| comments | difficulty | edit_url | rating | source | tags | ||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
true |
中等 |
1599 |
第 137 场周赛 Q3 |
|
给出一个单词数组 words ，其中每个单词都由小写英文字母组成。
如果我们可以 不改变其他字符的顺序 ，在 wordA 的任何地方添加 恰好一个 字母使其变成 wordB ，那么我们认为 wordA 是 wordB 的 前身 。
- 例如，
"abc"是"abac"的 前身 ，而"cba"不是"bcad"的 前身
词链是单词 [word_1, word_2, ..., word_k] 组成的序列，k >= 1，其中 word1 是 word2 的前身，word2 是 word3 的前身，依此类推。一个单词通常是 k == 1 的 单词链 。
从给定单词列表 words 中选择单词组成词链，返回 词链的 最长可能长度 。
示例 1：
输入：words = ["a","b","ba","bca","bda","bdca"] 输出：4 解释：最长单词链之一为 ["a","ba","bda","bdca"]
示例 2:
输入：words = ["xbc","pcxbcf","xb","cxbc","pcxbc"] 输出：5 解释：所有的单词都可以放入单词链 ["xb", "xbc", "cxbc", "pcxbc", "pcxbcf"].
示例 3:
输入：words = ["abcd","dbqca"] 输出：1 解释：字链["abcd"]是最长的字链之一。 ["abcd"，"dbqca"]不是一个有效的单词链，因为字母的顺序被改变了。
提示：
1 <= words.length <= 10001 <= words[i].length <= 16words[i]仅由小写英文字母组成。
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 resclass 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;
}
}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;
}
};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
}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;
}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
}
}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