472. Concatenated Words

Given a list of words (without duplicates), please write a program that returns all concatenated words in the given list of words.
A concatenated word is defined as a string that is comprised entirely of at least two shorter words in the given array.

Example:

登录后复制

      
      

       
       Input: ["cat","cats","catsdogcats","dog","dogcatsdog","hippopotamuses","rat","ratcatdogcat"]
       
       

       
       
Output: ["catsdogcats","dogcatsdog","ratcatdogcat"]
       
       

       
       
Explanation: "catsdogcats" can be concatenated by "cats", "dog" and "cats"; 
       
       
 "dogcatsdog" can be concatenated by "dog", "cats" and "dog"; 
       
       
"ratcatdogcat" can be concatenated by "rat", "cat", "dog" and "cat".
      
      
      
      

       
       
1.
       
       
2.
       
       
3.
       
       
4.
       
       
5.
       
       
6.
       
       
7.
      
      

Note:
The number of elements of the given array will not exceed 10,000
The length sum of elements in the given array will not exceed 600,000.
All the input string will only include lower case letters.
The returned elements order does not matter.

思路：
从list中找出所有字符串，该字符串至少由list中的两个单词构成。
我们首先按字符串长度由小到大排列words. 然后构造一个set, 依次加入set中。对于具体的字符串word，如果word可以由至少set中的两个word构成，则该word加入结果集中。这种字符串的prefix问题，很明显要用dynamic programming来解。

登录后复制

      
      

       
       class Solution {
       
       
    public List<String> findAllConcatenatedWordsInADict(String[] words) {
       
       
        List<String> res = new ArrayList<>();
       
       
        if (words==null || words.length==0) return res;
       
       
        HashSet<String> dict = new HashSet<>();
       
       
        Arrays.sort(words, new Comparator<String>() {
       
       
            public int compare(String str1, String str2) {
       
       
                return str1.length() - str2.length();
       
       
            }
       
       
        });
       
       

       
       
        for (String word : words) {
       
       
            if (canForm(word, dict))
       
       
                res.add(word);
       
       
            dict.add(word);
       
       
        }
       
       
        return res;
       
       
    }
       
       

       
       
    public boolean canForm(String word, HashSet<String> dict) {
       
       
        if (dict.isEmpty()) return false;
       
       
        boolean[] dp = new boolean[word.length()+1];
       
       
        dp[0] = true;
       
       
        for (int i=1; i<=word.length(); i++) {
       
       
            for (int j=0; j<i; j++) {
       
       
                if (!dp[j]) continue;
       
       
                String str = word.substring(j, i);
       
       
                if (dp[j] && dict.contains(str)) {
       
       
                    dp[i] = true;
       
       
                    break;
       
       
                }
       
       
            }
       
       
        }
       
       
        return dp[word.length()];
       
       
    }
       
       
}
      
      
      
      

       
       
1.
       
       
2.
       
       
3.
       
       
4.
       
       
5.
       
       
6.
       
       
7.
       
       
8.
       
       
9.
       
       
10.
       
       
11.
       
       
12.
       
       
13.
       
       
14.
       
       
15.
       
       
16.
       
       
17.
       
       
18.
       
       
19.
       
       
20.
       
       
21.
       
       
22.
       
       
23.
       
       
24.
       
       
25.
       
       
26.
       
       
27.
       
       
28.
       
       
29.
       
       
30.
       
       
31.
       
       
32.
       
       
33.
       
       
34.
       
       
35.
       
       
36.