LeetCode刷题记201-Trie(字典树)

472. 连接词

class Solution {
    class TreeNode {
        boolean isWord;
        TreeNode[] next;

        public TreeNode() {
            isWord = false;
            next = new TreeNode[26];
        }
    }

    public boolean findInTree(String word, TreeNode root, int i) {  // 在字典树里面找某个单词是否出现过
        TreeNode cur = root;
        for (; i < word.length(); i ++) {
            int id = word.charAt(i) - 'a';
            if (cur.next[id] == null) {  // 没有出现
                return false;
            } else {  // 出现过
                if (cur.next[id].isWord) {  // 且是完整单词
                    if (i == word.length() - 1) return true;
                    boolean flag = findInTree(word, root, i + 1);  // 不要用substring的方法，比较慢
                    if (flag) return true;
                }
                cur = cur.next[id];
            }
        }
        return false;
    }
 
    public List<String> findAllConcatenatedWordsInADict(String[] words) {
        Arrays.sort(words, new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                return a.length() - b.length();
            }
        });

        List<String> ans = new ArrayList<String>();

        TreeNode root = new TreeNode();
        for (String s : words) {
            if (findInTree(s, root, 0)) ans.add(s);  // 组合而来的单词不要加入字典树，否则会超时
            else {  
                // 当前词语加入字典树
                TreeNode cur = root;
                for (int i = 0; i < s.length(); i ++) {
                    int id = s.charAt(i) - 'a';
                    if (cur.next[id] == null) cur.next[id] = new TreeNode();
                    cur = cur.next[id];
                }
                cur.isWord = true;
            }
        }
        return ans;
    }
}

1707. 与数组中元素的最大异或值

class Solution {
    class TrieNode {
        int val;
        TrieNode[] next;

        boolean choose;
        int other;

        public TrieNode() {
            next = new TrieNode[2];
            val = 0;
        }
    }
    
    int[] pow;

    public int[] maximizeXor(int[] nums, int[][] queries) {
        Arrays.sort(nums);

        pow = new int[31];
        pow[0] = 1;
        for (int i = 1; i < 31; i ++) pow[i] = pow[i - 1] * 2;

        TrieNode root = new TrieNode();
        int[] binary = new int[31];
        for (int num : nums) {
            Arrays.fill(binary, 0);
            int tmp = num;
            int j = 31;
            while (tmp > 0) {
                binary[-- j] = tmp & 1;
                tmp >>= 1;
            }
            TrieNode cur = root;
            for (int i = 0; i < 31; i ++) {
                if (cur.next[binary[i]] == null) {
                    cur.next[binary[i]] = new TrieNode();
                }
                cur.next[binary[i]].val = cur.val;
                if (binary[i] == 1) cur.next[binary[i]].val += pow[30 - i];
                cur = cur.next[binary[i]];
            }
        }

        int[] ans = new int[queries.length];
        for (int i = 0; i < queries.length; i ++) {
            int num = queries[i][0];
            int max = queries[i][1];
            if (nums[0] > max) {
                ans[i] = -1;
                continue;
            }
            if (num == 0) {
                if (max == 0) {
                    if (nums[0] == 0) ans[i] = 0;
                    else ans[i] = -1;
                } else {
                    int ind = Arrays.binarySearch(nums, max);
                    if (ind > 0) ans[i] = max;
                    else {
                        ind = - ind - 1;
                        if (ind == 0) ans[i] = -1;
                        else ans[i] = nums[ind - 1];
                    }
                }
                continue;
            }
            Arrays.fill(binary, 0);
            int t = num;
            int j = 31;
            while (t > 0) {
                binary[-- j] = t & 1;
                t >>= 1;
            }
            Stack<TrieNode> sta = new Stack<TrieNode>();
            j = 0;
            TrieNode cur = root;
            while (j < 31) {
                if (binary[j] == 0) {
                    if (cur.next[1] != null) {  // 这个位置有1
                        if (cur.next[1].val > max) {  // 这个位置选择1太大了，不行
                            if (cur.next[0] != null) {  // 有0选0
                                sta.push(cur);
                                cur = cur.next[0];
                                j ++;
                            } else {  // 没有0，说明之前有一个错误选择的路径
                                while (!sta.isEmpty()) {
                                    TrieNode tmp = sta.pop();
                                    j --;
                                    if (tmp.choose) {  // 回溯到一个可以选择的位子
                                        tmp.choose = false;
                                        sta.push(tmp);
                                        cur = tmp.next[tmp.other];
                                        j ++;
                                        break;
                                    }
                                }
                            }
                        } else {  // 这个位置可选1
                            if (cur.next[0] != null) {  // 0也可以选择，标记
                                cur.choose = true;
                                cur.other = 0;  
                            }
                            sta.push(cur);
                            cur = cur.next[1];  // 1是更优解，选择1
                            j ++;
                        }
                    } else {  // 这个位置没有1，一个地方下一个不可能两个都不存在
                        sta.push(cur);
                        cur = cur.next[0];
                        j ++;
                    }
                } else {  // 1
                    if (cur.next[0] != null) {  // 这个位置有0，选择0最佳，也不用考虑回溯问题
                        sta.push(cur);
                        cur = cur.next[0];
                        j ++;
                    } else {
                        if (cur.next[1] != null && cur.next[1].val <= max) {  // 1也可以选
                            sta.push(cur);
                            cur = cur.next[1];
                            j ++;
                        } else {  // 选1太大了
                            while (!sta.isEmpty()) {
                                TrieNode tmp = sta.pop();
                                j --;
                                if (tmp.choose) {  // 回溯到一个可以选择的位子
                                    tmp.choose = false;
                                    sta.push(tmp);
                                    cur = tmp.next[tmp.other];
                                    j ++;
                                    break;
                                }
                            }
                        }
                    }
                }
            }

            ans[i] = num ^ cur.val;
        }
        return ans;
    }
}

1032. 字符流

class StreamChecker {
    class Trie {
        Trie[] next;
        boolean isWord;
        public Trie() {
            next = new Trie[26];
        }
    }

    Trie root;
    Trie[] t;
    int num;

    public void insert(String word) {
        Trie cur = root;
        for (int i =0; i < word.length(); i ++) {
            int id = word.charAt(i) - 'a';
            if (cur.next[id] == null) {
                cur.next[id] = new Trie();
            }
            cur = cur.next[id];
        }
        cur.isWord = true;
    }

    public StreamChecker(String[] words) {
        root = new Trie();
        for (int i = 0; i < words.length; i ++) {
            insert(words[i]);
        }
        t = new Trie[40001];
        num = 0;
    }
    


    public boolean query(char letter) {
        int id = 0;
        boolean flag = false;
        int k = letter - 'a';
        for (int i = 0; i < num; i ++) {
            Trie tmp = t[i].next[k];
            if (tmp == null) continue;
            t[id] = tmp;
            if (tmp.isWord) flag = true;
            id ++;
        }
        t[id] = root.next[k];
        if (t[id] == null) num = id;
        else {
            if (t[id].isWord) flag = true;
            num = id + 1;
        }

        return flag;
    }
}

/**
 * Your StreamChecker object will be instantiated and called as such:
 * StreamChecker obj = new StreamChecker(words);
 * boolean param_1 = obj.query(letter);
 */