You are given two 0-indexed arrays of strings startWords
and targetWords
. Each string consists of lowercase English letters only.
For each string in targetWords
, check if it is possible to choose a string from startWords
and perform a conversion operation on it to be equal to that from targetWords
.
The conversion operation is described in the following two steps:
- Append any lowercase letter that is not present in the string to its end.
- For example, if the string is
"abc"
, the letters'd'
,'e'
, or'y'
can be added to it, but not'a'
. If'd'
is added, the resulting string will be"abcd"
.
- For example, if the string is
- Rearrange the letters of the new string in any arbitrary order.
- For example,
"abcd"
can be rearranged to"acbd"
,"bacd"
,"cbda"
, and so on. Note that it can also be rearranged to"abcd"
itself.
- For example,
Return the number of strings in targetWords
that can be obtained by performing the operations on any string of startWords
.
Note that you will only be verifying if the string in targetWords
can be obtained from a string in startWords
by performing the operations. The strings in startWords
do not actually change during this process.
Example 1:
Input: startWords = ["ant","act","tack"], targetWords = ["tack","act","acti"] Output: 2 Explanation: - In order to form targetWords[0] = "tack", we use startWords[1] = "act", append 'k' to it, and rearrange "actk" to "tack". - There is no string in startWords that can be used to obtain targetWords[1] = "act". Note that "act" does exist in startWords, but we must append one letter to the string before rearranging it. - In order to form targetWords[2] = "acti", we use startWords[1] = "act", append 'i' to it, and rearrange "acti" to "acti" itself.
Example 2:
Input: startWords = ["ab","a"], targetWords = ["abc","abcd"] Output: 1 Explanation: - In order to form targetWords[0] = "abc", we use startWords[0] = "ab", add 'c' to it, and rearrange it to "abc". - There is no string in startWords that can be used to obtain targetWords[1] = "abcd".
Constraints:
1 <= startWords.length, targetWords.length <= 5 * 104
1 <= startWords[i].length, targetWords[j].length <= 26
- Each string of
startWords
andtargetWords
consists of lowercase English letters only. - No letter occurs more than once in any string of
startWords
ortargetWords
.
思路:因为无序,所以分别各自sort array,这样targetword就是找比自己小一个char的string是不是在start set里面;O(word ^2)去判断每个targetword。O(1)去判断,这样快很多。
class Solution {
public int wordCount(String[] startWords, String[] targetWords) {
HashSet<String> startSet = new HashSet<>();
for(String startWord: startWords) {
char[] ss = startWord.toCharArray();
Arrays.sort(ss);
startSet.add(new String(ss));
}
for(int i = 0; i < targetWords.length; i++) {
char[] tt = targetWords[i].toCharArray();
Arrays.sort(tt);
targetWords[i] = new String(tt);
}
int count = 0;
for(String targetWord: targetWords) {
for(int i = 0; i < targetWord.length(); i++) {
StringBuilder sb = new StringBuilder();
for(int j = 0; j < targetWord.length(); j++) {
if(i != j) {
sb.append(targetWord.charAt(j));
}
}
if(startSet.contains(sb.toString())) {
count++;
break;
}
}
}
return count;
}
}