有关字典树的力扣题

472. 连接词

题目描述：

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

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

思路：

1、字典树的插入直接套用模版即可
2、然后定义一个搜索函数，给定一个树根，搜索在这棵树上能够与字符串后缀进行匹配的数量，如果搜索结果大于1，则满足题目要求，插入到结果数组中

class Solution {
    //构建字典树上的节点->构建字典树，以及字典树的插入 
    struct TrieNode { //构造字典树上的节点
        int isEnd;
        TrieNode *next[26];
        TrieNode() { //构造函数初始化 不是终点，并且后续节点指针全置空
            isEnd = false;
            memset(next, NULL, sizeof(next));
        }
    };

    struct TrieTree { //构造字典树，只需要一个根节点即可,树的子节点都可以通过根节点获取到
        TrieNode *root;
        
        TrieTree() {
            root = new TrieNode();
        }

        void insert(const string& s) {
            TrieNode *now = root; 
            //遍历整个字符串
            for (int i = 0; i < s.size(); ++i) {
                //当前节点的下一个节点不存在，需要new一个节点出来
                if (!now->next[s[i]-'a']) {
                    now->next[s[i]-'a'] = new TrieNode();
                }
                now = now->next[s[i] - 'a'];
            }
            //字符串遍历完毕，打上结尾标记
            now->isEnd = true;
        }

        //搜索字符串的函数:给定当前树上的某个节点，从start这个位置开始搜索，有跟字符串s匹配的数量
        int dfs (TrieNode *now, const string& s, int start) {
            if (now == NULL) return 0; //节点为空，没有匹配
            if (start == s.size()) return now->isEnd ? 1 : 0; //空串情况
            
            int ans = 0;
            int c = s[start] - 'a';
            ans += dfs(now->next[c], s, start + 1);
            if (ans > 1) return 2;
            if (now->isEnd) ans += dfs(root, s, start); //当前节点到终点了，从根节点开始另行匹配
            return ans > 1 ? 2 : ans;

        }
    };

public:
    vector<string> findAllConcatenatedWordsInADict(vector<string>& words) {
        TrieTree T;
        vector<string> ans;

        //创建words的字典树
        for (int i = 0; i < words.size(); ++i) {
            T.insert(words[i]);
        }
        //重点在搜索字符串的那个函数
        for (int i = 0; i < words.size(); ++ i) {
            if (T.dfs(T.root, words[i], 0) > 1) {
                ans.push_back(words[i]);
            }

        }

        return ans;
    }
};

面试题 17.15. 最长单词

题目描述：

给定一组单词words，编写一个程序，找出其中的最长单词，且该单词由这组单词中的其他单词组合而成。若有多个长度相同的结果，返回其中字典序最小的一项，若没有符合要求的单词则返回空字符串。

思路：

思路同上，只是这边的要求是返回最场且字典序最小的单词。修改一点点就可以了

class Solution {
    struct TrieNode {
        int isEnd;
        TrieNode *next[26];

        TrieNode () {
            isEnd = false;
            memset(next, NULL, sizeof(next));
        }
    };
    struct TrieTree {
        TrieNode *root;

        TrieTree () {
            root = new TrieNode();
        }

        void insert(const string& s) {
            TrieNode *now = root;
            for (int i = 0; i < s.size(); ++ i) {
                if (!now->next[s[i] - 'a']) {
                    now->next[s[i] - 'a'] = new TrieNode();
                }
                now = now->next[s[i] - 'a'];
            }
            now->isEnd = true;
        }

        int dfs(TrieNode *now, const string& s, int start) {
            if (now == NULL) return 0;
            if (start == s.size()) return now->isEnd ? 1 : 0;
            int ans = 0;
            int c = s[start] - 'a';
            ans += dfs(now->next[c], s, start + 1);

            if (ans > 1) return 2;
            if (now->isEnd) ans += dfs(root, s, start);
            
            return ans > 1 ? 2 : ans;
            
        }
    };
public:
    string longestWord(vector<string>& words) {
        TrieTree T;
        string ans = "";
        for (int i = 0; i < words.size(); ++ i) {
            T.insert(words[i]);
        }

        for (int i = 0; i < words.size(); ++ i) {
            if (T.dfs(T.root, words[i], 0) > 1 ) {
                if (words[i].size() > ans.size() || words[i].size() == ans.size() && words[i] < ans) {
                    ans = words[i];
                }
            }

        }
        return ans;

    }
};