472. 连接词(每日一难phase2--day24)

472. 连接词

给你一个 不含重复 单词的字符串数组 words ，请你找出并返回 words 中的所有 连接词 。

连接词 定义为：一个完全由给定数组中的至少两个较短单词组成的字符串。

示例 1：

输入：words = [“cat”,“cats”,“catsdogcats”,“dog”,“dogcatsdog”,“hippopotamuses”,“rat”,“ratcatdogcat”]

输出：[“catsdogcats”,“dogcatsdog”,“ratcatdogcat”]

解释：
“catsdogcats” 由 “cats”, “dog” 和 “cats” 组成;
“dogcatsdog” 由 “dog”, “cats” 和 “dog” 组成;
“ratcatdogcat” 由 “rat”, “cat”, “dog” 和 “cat” 组成。

示例 2：

输入：words = [“cat”,“dog”,“catdog”]
输出：[“catdog”]

提示：

1 <= words.length <= 1e4
0 <= words[i].length <= 30
words[i] 仅由小写字母组成
0 <= sum(words[i].length) <= 1e5

解析：

• 暴力做法，可以dfs产生所有可能的组合串，显然是不可能的
• 可以换个思路，枚举每个字符串，看下当前字符串是否可以由其他字符串组成
• 可以发现，如果一个字符串可以由其他字符串组成，那么其他字符串长度一定小于该字符串，因此我们先根据长度从小到大排序，先判断较短字符串，是否可以由其他组成，如果能组成添加到答案，不能组成就插入字典树。
• 如何判断一个字符串是否由其他字符串组成呢？
• 例如：“cats”,“catsdogcats”,“dog”，首先将cat插入字典树，dog插入字典树，判断"catsdogcats"时，判断每个前缀是否为前边插入的字符串，cats存在，递归判断dogcats，dog存在，递归判断cats，cats存在；说明该字符串可以被组成，假如答案。
• 例如：”cat“,“cats”,cat插入，在字典树中搜索cats，遇到cat，递归判断s，s不是字符串返回false。接着判断cats，cats不存在，返回false。将cats插入。
• 判断字符串是否存在时可以使用记忆化，假如判断了dogcats存在，则可以将dogcats加入记忆化。

class Solution {
    struct Node{
        Node* son[26];
        bool isEnd=false;
    };

public:
    // 按照长度从小到大插入，如果遇到前缀将后缀插入（插到最后都是后缀，那就是可组合）
    unordered_map<string,bool> vis;
    void insert(Node* root,string s){
        int m = s.size();
        Node* cur=root;
        for(int i=0;i<m;i++){
            int c=s[i]-'a';
            if(!cur->son[c]){
                cur->son[c]=new Node();
            }    
            cur=cur->son[c];
        }
        cur->isEnd = true;
    }

    bool dfs(Node* root,string s){
        Node* cur=root;
        int m=s.size();
        if(m==0)
            return true;
        if(vis.find(s)!=vis.end())
            return vis[s];
        for(int i=0;i<m;i++){
            int c=s[i]-'a';
            cur=cur->son[c];
            // 不存在该词，例如：存在cate，当前串为cats;对比到cat，cur指向s不存在s因此指向空，返回false
            if(cur==nullptr)
                return false;
            // 遇到前缀词，dfs判断后续是不是可以由其他单词组成（此时可以记忆化）
            if(cur->isEnd){
                if(dfs(root,s.substr(i+1,m-i-1))){
                    vis[s.substr(i+1,m-i-1)]=true;
                    return true;
                }  
            }
        }
        vis[s]=false;
        return vis[s];
    }

    vector<string> findAllConcatenatedWordsInADict(vector<string>& words) {
        int n=words.size();
        sort(words.begin(),words.end(),[&](string s1,string s2){
            return s1.size()<s2.size();
        });

        Node* root=new Node();
        vector<string> res;
        // 字典树插入
        for(auto a :words){
            if(dfs(root,a))
                vis[a]=true,res.push_back(a);
            else 
                vis[a]=false,insert(root,a);
        }
        return res;
    }
};