LeetCode每日一题 745. 前缀和后缀搜索

745. 前缀和后缀搜索

设计一个包含一些单词的特殊词典，并能够通过前缀和后缀来检索单词。

实现 WordFilter 类：

• WordFilter(string[] words) 使用词典中的单词 words 初始化对象。
• f(string pref, string suff) 返回词典中具有前缀 prefix 和后缀 suff 的单词的下标。如果存在不止一个满足要求的下标，返回其中 最大的下标 。如果不存在这样的单词，返回 -1 。

示例：

输入
["WordFilter", "f"]
[[["apple"]], ["a", "e"]]
输出
[null, 0]
解释
WordFilter wordFilter = new WordFilter(["apple"]);
wordFilter.f("a", "e"); // 返回 0 ，因为下标为 0 的单词：前缀 prefix = "a" 且 后缀 suff = "e" 。

提示：

• 1 <= words.length <= 104
• 1 <= words[i].length <= 7
• 1 <= pref.length, suff.length <= 7
• words[i]、pref 和 suff 仅由小写英文字母组成
• 最多对函数 f 执行 10^4 次调用

方法一：字典树

字段树实现参考 这篇文章

构建两棵树，一颗正序，一颗倒序 即可。

参考代码

class WordFilter {

    private final Trie trie;

    public WordFilter(String[] words) {
        trie = new Trie();
        for (int i = 0; i < words.length; i++) {
            trie.insert(words[i], i);
        }
    }

    public int f(String pref, String suff) {
        return trie.find(pref, suff);
    }

    static class Trie {

        private final TrieNode root1 = new TrieNode();
        private final TrieNode root2 = new TrieNode();

        public void insert(String word, int idx) {
            TrieNode node1 = root1;
            TrieNode node2 = root2;

            char[] chars = word.toCharArray();
            int n = chars.length;
            for (int i = 0; i < n; i++) {
                char c1 = chars[i];
                if (node1.child[c1 - 'a'] == null) {
                    node1.child[c1 - 'a'] = new TrieNode();
                }
                node1.child[c1 - 'a'].index.add(idx);
                node1 = node1.child[c1 - 'a'];

                char c2 = chars[n - i - 1];
                if (node2.child[c2 - 'a'] == null) {
                    node2.child[c2 - 'a'] = new TrieNode();
                }
                node2.child[c2 - 'a'].index.add(idx);
                node2 = node2.child[c2 - 'a'];
            }
        }

        public int find(String pref, String suff) {
            TrieNode node1 = root1;
            for (char c : pref.toCharArray()) {
                node1 = node1.child[c - 'a'];
                if (node1 == null) {
                    return -1;
                }
            }

            TrieNode node2 = root2;
            char[] chars = suff.toCharArray();
            for (int i = chars.length - 1; i >= 0; i--) {
                node2 = node2.child[chars[i] - 'a'];
                if (node2 == null) {
                    return -1;
                }
            }

            int l1 = node1.index.size() - 1, l2 = node2.index.size() - 1;
            while (l1 >= 0 && l2 >= 0) {
                if (node1.index.get(l1) > (node2.index.get(l2))) {
                    l1--;
                }  else if (node1.index.get(l1) < (node2.index.get(l2))) {
                    l2--;
                } else {
                    return node1.index.get(l1);
                }
            }
            return -1;
        }

        static class TrieNode {
            
            private TrieNode[] child;

            private List<Integer> index;

            public TrieNode() {
                child = new TrieNode[26];
                index = new ArrayList<>();
            }
        }
    }
}

执行结果