LeetCode 1048. Longest String Chain Solution in Java, C++, Python & More | Explanation + Code

Description

You are given an array of words where each word consists of lowercase English letters.

wordA is a predecessor of wordB if and only if we can insert exactly one letter anywhere in wordA without changing the order of the other characters to make it equal to wordB.

• For example, "abc" is a predecessor of "abac", while "cba" is not a predecessor of "bcad".

A word chain is a sequence of words [word1, word2, ..., wordk] with k >= 1, where word1 is a predecessor of word2, word2 is a predecessor of word3, 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.

Solutions

Solution 1

PythonJavaC++GoTypeScriptRust

class Solution: def longestStrChain(self, words: List[str]) -> int: def check(w1, w2): if len(w2) - len(w1) != 1: return False i = j = cnt = 0 while i < len(w1) and j < len(w2): if w1[i] != w2[j]: cnt += 1 else: i += 1 j += 1 return cnt < 2 and i == len(w1) n = len(words) dp = [1] * (n + 1) words.sort(key=lambda x: len(x)) res = 1 for i in range(1, n): for j in range(i): if check(words[j], words[i]): dp[i] = max(dp[i], dp[j] + 1) res = max(res, dp[i]) return res(code-box)

class Solution { public int longestStrChain(String[] words) { Arrays.sort(words, Comparator.comparingInt(String::length)); int res = 0; Map<String, Integer> map = new HashMap<>(); for (String word : words) { int x = 1; for (int i = 0; i < word.length(); ++i) { String pre = word.substring(0, i) + word.substring(i + 1); x = Math.max(x, map.getOrDefault(pre, 0) + 1); } map.put(word, x); res = Math.max(res, x); } return res; } }(code-box)

class Solution { public: int longestStrChain(vector<string>& words) { sort(words.begin(), words.end(), [&](string a, string b) { return a.size() < b.size(); }); int res = 0; unordered_map<string, int> map; for (auto word : words) { int x = 1; for (int i = 0; i < word.size(); ++i) { string pre = word.substr(0, i) + word.substr(i + 1); x = max(x, map[pre] + 1); } map[word] = x; res = max(res, x); } return res; } };(code-box)

func longestStrChain(words []string) int { sort.Slice(words, func(i, j int) bool { return len(words[i]) < len(words[j]) }) res := 0 mp := make(map[string]int) for _, word := range words { x := 1 for i := 0; i < len(word); i++ { pre := word[0:i] + word[i+1:len(word)] x = max(x, mp[pre]+1) } mp[word] = x res = max(res, x) } return res }(code-box)

function longestStrChain(words: string[]): number { words.sort((a, b) => a.length - b.length); let ans = 0; let hashTable = new Map(); for (let word of words) { let c = 1; for (let i = 0; i < word.length; i++) { let pre = word.substring(0, i) + word.substring(i + 1); c = Math.max(c, (hashTable.get(pre) || 0) + 1); } hashTable.set(word, c); ans = Math.max(ans, c); } return ans; }(code-box)

use std::collections::HashMap; impl Solution { #[allow(dead_code)] pub fn longest_str_chain(words: Vec<String>) -> i32 { let mut words = words; let mut ret = 0; let mut map: HashMap<String, i32> = HashMap::new(); // Sort the words vector first words.sort_by(|lhs, rhs| lhs.len().cmp(&rhs.len())); // Begin the "dp" process for w in words.iter() { let n = w.len(); let mut x = 1; for i in 0..n { let s = w[..i].to_string() + &w[i + 1..]; let v = map.entry(s.clone()).or_default(); x = std::cmp::max(x, *v + 1); } map.insert(w.clone(), x); ret = std::cmp::max(ret, x); } ret } }(code-box)

Solution 2

Python

class Solution: def longestStrChain(self, words: List[str]) -> int: words.sort(key=lambda x: len(x)) res = 0 mp = {} for word in words: x = 1 for i in range(len(word)): pre = word[:i] + word[i + 1 :] x = max(x, mp.get(pre, 0) + 1) mp[word] = x res = max(res, x) return res(code-box)