题目:
给你两个下标从 0 开始的字符串数组 startWords
和 targetWords
。每个字符串都仅由 小写英文字母 组成。
对于 targetWords
中的每个字符串,检查是否能够从 startWords
中选出一个字符串,执行一次 转换操作 ,得到的结果与当前 targetWords
字符串相等。
转换操作 如下面两步所述:
- 追加 任何 不存在 于当前字符串的任一小写字母到当前字符串的末尾。
<ul>
<li>例如,如果字符串为 <code>"abc"</code> ,那么字母 <code>'d'</code>、<code>'e'</code> 或 <code>'y'</code> 都可以加到该字符串末尾,但 <code>'a'</code> 就不行。如果追加的是 <code>'d'</code> ,那么结果字符串为 <code>"abcd"</code> 。</li>
</ul>
</li>
<li><strong>重排</strong> 新字符串中的字母,可以按 <strong>任意</strong> 顺序重新排布字母。
<ul>
<li>例如,<code>"abcd"</code> 可以重排为 <code>"acbd"</code>、<code>"bacd"</code>、<code>"cbda"</code>,以此类推。注意,它也可以重排为 <code>"abcd"</code> 自身。</li>
</ul>
</li>
找出 targetWords
中有多少字符串能够由 startWords
中的 任一 字符串执行上述转换操作获得。返回 targetWords
中这类 字符串的数目 。
注意:你仅能验证 targetWords
中的字符串是否可以由 startWords
中的某个字符串经执行操作获得。startWords
中的字符串在这一过程中 不 发生实际变更。
示例 1:
输入:startWords = ["ant","act","tack"], targetWords = ["tack","act","acti"] 输出:2 解释: - 为了形成 targetWords[0] = "tack" ,可以选用 startWords[1] = "act" ,追加字母 'k' ,并重排 "actk" 为 "tack" 。 - startWords 中不存在可以用于获得 targetWords[1] = "act" 的字符串。 注意 "act" 确实存在于 startWords ,但是 必须 在重排前给这个字符串追加一个字母。 - 为了形成 targetWords[2] = "acti" ,可以选用 startWords[1] = "act" ,追加字母 'i' ,并重排 "acti" 为 "acti" 自身。
示例 2:
输入:startWords = ["ab","a"], targetWords = ["abc","abcd"] 输出:1 解释: - 为了形成 targetWords[0] = "abc" ,可以选用 startWords[0] = "ab" ,追加字母 'c' ,并重排为 "abc" 。 - startWords 中不存在可以用于获得 targetWords[1] = "abcd" 的字符串。
提示:
1 <= startWords.length, targetWords.length <= 5 * 104
1 <= startWords[i].length, targetWords[j].length <= 26
startWords
和targetWords
中的每个字符串都仅由小写英文字母组成- 在
startWords
或targetWords
的任一字符串中,每个字母至多出现一次
Related Topics
- 位运算
- 数组
- 哈希表
- 字符串
- 排序
思路:
掩膜计数+HashMap 我们要求的是targetWords中能够由startWords转化过来的数目,那么就要以targetWords为主体进行求解我们都知道startWords只能追加一个字母变成targetWords,那么我们以数目分组进行计算假设targetWords[i]的长度为len,那么只有可能从长度为len-1的startWords[j]转换过来我们可以枚举长度targetWords[i],再枚举targetWords[i]中可以删除的字母,每当删除一个字母后假若在长度为len-1的startWords中找到相同掩膜说明这个可以完成转换,直接下一个,否则就不能转换预处理:求出按照长度分组的startWords的占位掩膜时间复杂度:O(C*N) 空间复杂度:O(N)
代码:
class Solution {
public int wordCount(String[] startWords, String[] targetWords) {
/*
掩膜计数+HashMap
我们要求的是targetWords中能够由startWords转化过来的数目,那么就要以targetWords为主体进行求解
我们都知道startWords只能追加一个字母变成targetWords,那么我们以数目分组进行计算
假设targetWords[i]的长度为len,那么只有可能从长度为len-1的startWords[j]转换过来
我们可以枚举长度targetWords[i],再枚举targetWords[i]中可以删除的字母,每当删除一个字母后假若在长度为len-1的startWords
中找到相同掩膜说明这个可以完成转换,直接下一个,否则就不能转换
预处理:求出按照长度分组的startWords的占位掩膜
时间复杂度:O(C*N) 空间复杂度:O(N)
*/
// 预处理出按长度分组的startWords的占位掩膜
HashMap<Integer, HashSet<Integer>> map = new HashMap<>();
for (String s : startWords) {
int len = s.length();
if (!map.containsKey(len)) {
map.put(len, new HashSet<>());
}
// 求出掩膜
int mask = 0;
for (char c : s.toCharArray()) {
mask |= (1 << (c - 'a'));
}
map.get(len).add(mask);
}
int res = 0;
// 枚举目标字符串
for (String s : targetWords) {
int len = s.length();
if (len == 1) continue; // 长度为1不可能可以生成
// 求出掩膜
int mask = 0;
for (char c : s.toCharArray()) {
mask |= (1 << (c - 'a'));
}
// 枚举可以删除的单个字母
for (char c : s.toCharArray()) {
int newMask = mask - (1 << (c - 'a')); // 删除单个字母后的掩膜
if (map.containsKey(len - 1) && map.get(len - 1).contains(newMask)) { // 该字符串可以被转化过来
res++; // 结果+1
break; // 退出
}
}
}
return res;
}
}
这种涉及位运算的还是有点打脑壳,完全做不来。