g2501_2600.s2573_find_the_string_with_lcp.Solution Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation
Java-based LeetCode algorithm problem solutions, regularly updated
There is a newer version: 1.38
package g2501_2600.s2573_find_the_string_with_lcp;

// #Hard #String #Dynamic_Programming #Greedy #Union_Find
// #2023_08_21_Time_5_ms_(100.00%)_Space_142.3_MB_(10.34%)

/**
 * 2573 - Find the String with LCP\.
 *
 * Hard
 *
 * We define the `lcp` matrix of any **0-indexed** string `word` of `n` lowercase English letters as an `n x n` grid such that:
 *
 * *   `lcp[i][j]` is equal to the length of the **longest common prefix** between the substrings `word[i,n-1]` and `word[j,n-1]`.
 *
 * Given an `n x n` matrix `lcp`, return the alphabetically smallest string `word` that corresponds to `lcp`. If there is no such string, return an empty string.
 *
 * A string `a` is lexicographically smaller than a string `b` (of the same length) if in the first position where `a` and `b` differ, string `a` has a letter that appears earlier in the alphabet than the corresponding letter in `b`. For example, `"aabd"` is lexicographically smaller than `"aaca"` because the first position they differ is at the third letter, and `'b'` comes before `'c'`.
 *
 * **Example 1:**
 *
 * **Input:** lcp = \[\[4,0,2,0],[0,3,0,1],[2,0,2,0],[0,1,0,1]]
 *
 * **Output:** "abab"
 *
 * **Explanation:** lcp corresponds to any 4 letter string with two alternating letters. The lexicographically smallest of them is "abab".
 *
 * **Example 2:**
 *
 * **Input:** lcp = \[\[4,3,2,1],[3,3,2,1],[2,2,2,1],[1,1,1,1]]
 *
 * **Output:** "aaaa"
 *
 * **Explanation:** lcp corresponds to any 4 letter string with a single distinct letter. The lexicographically smallest of them is "aaaa".
 *
 * **Example 3:**
 *
 * **Input:** lcp = \[\[4,3,2,1],[3,3,2,1],[2,2,2,1],[1,1,1,3]]
 *
 * **Output:** ""
 *
 * **Explanation:** lcp[3][3] cannot be equal to 3 since word[3,...,3] consists of only a single letter; Thus, no answer exists.
 *
 * **Constraints:**
 *
 * *   `1 <= n == ``lcp.length ==` `lcp[i].length` `<= 1000`
 * *   `0 <= lcp[i][j] <= n`
**/
public class Solution {
    public String findTheString(int[][] lcp) {
        int n = lcp.length;
        char[] arr = new char[n];
        arr[0] = 'a';
        char test;
        boolean found;
        for (int i = 1; i < n; ++i) {
            test = 'a';
            found = false;
            for (int j = 0; j < i; ++j) {
                test = (char) Math.max(test, arr[j]);
                if (lcp[i][j] != 0) {
                    found = true;
                    arr[i] = arr[j];
                    break;
                }
            }
            if (found) {
                continue;
            }
            ++test;
            arr[i] = test;
            if (test > 'z') {
                return "";
            }
        }
        int[][] dp = new int[n + 1][n + 1];
        int val;
        for (int i = n - 1; i >= 0; --i) {
            for (int j = n - 1; j >= 0; --j) {
                if (arr[i] != arr[j]) {
                    val = 0;
                } else {
                    val = 1 + dp[i + 1][j + 1];
                }
                dp[i][j] = val;
            }
        }
        for (int i = n - 1; i >= 0; --i) {
            for (int j = n - 1; j >= 0; --j) {
                if (dp[i][j] != lcp[i][j]) {
                    return "";
                }
            }
        }
        return String.valueOf(arr);
    }
}