g1001_1100.s1048_longest_string_chain.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 g1001_1100.s1048_longest_string_chain;

// #Medium #Array #String #Hash_Table #Dynamic_Programming #Two_Pointers
// #2022_02_28_Time_23_ms_(97.92%)_Space_46.6_MB_(66.36%)

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 1048 - Longest String Chain\.
 *
 * Medium
 *
 * You are given an array of `words` where each word consists of lowercase English letters.
 *
 * word_A is a **predecessor** of word_B if and only if we can insert **exactly one** letter anywhere in word_A **without changing the order of the other characters** to make it equal to word_B.
 *
 * *   For example, `"abc"` is a **predecessor** of `"abac"`, while `"cba"` is not a **predecessor** of `"bcad"`.
 *
 * A **word chain** is a sequence of words [word₁, word₂, ..., word_k] with `k >= 1`, where word₁ is a **predecessor** of word₂, word₂ is a **predecessor** of word₃, and so on. A single word is trivially a **word chain** with `k == 1`.
 *
 * Return _the **length** of the **longest possible word chain** with words chosen from the given list of_ `words`.
 *
 * **Example 1:**
 *
 * **Input:** words = ["a","b","ba","bca","bda","bdca"]
 *
 * **Output:** 4
 *
 * **Explanation:** One of the longest word chains is ["a","ba","bda","bdca"].
 *
 * **Example 2:**
 *
 * **Input:** words = ["xbc","pcxbcf","xb","cxbc","pcxbc"]
 *
 * **Output:** 5
 *
 * **Explanation:** All the words can be put in a word chain ["xb", "xbc", "cxbc", "pcxbc", "pcxbcf"].
 *
 * **Example 3:**
 *
 * **Input:** words = ["abcd","dbqca"]
 *
 * **Output:** 1
 *
 * **Explanation:** The trivial word chain ["abcd"] is one of the longest word chains. ["abcd","dbqca"] is not a valid word chain because the ordering of the letters is changed.
 *
 * **Constraints:**
 *
 * *   `1 <= words.length <= 1000`
 * *   `1 <= words[i].length <= 16`
 * *   `words[i]` only consists of lowercase English letters.
**/
@SuppressWarnings("unchecked")
public class Solution {
    public int longestStrChain(String[] words) {
        List[] lenStr = new List[20];
        for (String word : words) {
            int len = word.length();
            if (lenStr[len] == null) {
                lenStr[len] = new ArrayList();
            }
            lenStr[len].add(word);
        }
        Map longest = new HashMap<>();
        int max = 0;
        for (String s : words) {
            max = Math.max(findLongest(s, lenStr, longest), max);
        }
        return max;
    }

    public int findLongest(String word, List[] lenStr, Map longest) {
        if (longest.containsKey(word)) {
            return longest.get(word);
        }
        int len = word.length();
        List words = lenStr[len + 1];
        if (words == null) {
            longest.put(word, 1);
            return 1;
        }
        int max = 0;
        int i;
        int j;
        for (String w : words) {
            i = 0;
            j = 0;
            while (i < len && j - i <= 1) {
                if (word.charAt(i) == w.charAt(j++)) {
                    ++i;
                }
            }
            if (j - i <= 1) {
                max = Math.max(findLongest(w, lenStr, longest), max);
            }
        }
        ++max;
        longest.put(word, max);
        return max;
    }
}