Trie（字典树）

---

前言

Trie字典树又叫前缀树，原因是当要存储的数据满足有公共前缀时那么这部分前缀将只被存储一遍，存储方式是将数据离散地拆分成树上的一系列结点，如字符串"abc"可以拆成三个char型结点a、b、c，而后这些不同的数据从它们公共前缀开始延展出多个不同的分支，最终形成了一个字典树。

同时为了区分出公共前缀的某个子集是否为一个完整数据，引入了一个标记表示以根结点到以某个结点为尾的路径是否已存储或存储了几次。(注意，根结点不包含任何数据)。

---

字符串统计（数组模拟）

维护一个字符串集合，支持两种操作：

1. I x 向集合中插入一个字符串 x；
2. Q x 询问一个字符串在集合中出现了多少次。

共有 N 个操作，输入的字符串总长度不超过 105，字符串仅包含小写英文字母。

输入格式
第一行包含整数 N，表示操作数。

接下来 N 行，每行包含一个操作指令，指令为 I x 或 Q x 中的一种。

输出格式
对于每个询问指令 Q x，都要输出一个整数作为结果，表示 x 在集合中出现的次数。

每个结果占一行。

数据范围
1≤N≤2∗104

输入样例：

5
I abc
Q abc
Q ab
I ab
Q ab

输出样例：

1
0
1

---

字符串存储的Trie树大概长这样：

一些具体细节可以参考这位博主写的图文分析，很到位！

👉AcWing 835. Trie字符串统计

son[][]数组存的是当前结点的下一个子结点的位置，这里的“位置”是根据idx来唯一标识的，它只是一个抽象位置，第一个[]存的是位置索引，第二个[]存的是字符索引（'a'对应0…），默认根结点的位置是0。

举个例子说明：
根据定义知son[1][1]表示处于位置1，然后它的存了字符b（'b' - 'a' = 1）的子结点位置，如果son[1][1]为0，说明这个结点不存在，那么son[1][1] = ++ idx就为建立起这个b结点的操作。若不为0，定义loc指针指向当前的位置索引，然后使得loc = son[1][1]后再访问son[loc][...]，就实现了向下访问的操作。

Java代码

import java.util.Scanner;

public class Main{
    private static int N, idx = 0;
    private static int[][] son = new int[100010][26];
    private static int[] cnt = new int[100010];

    public static void insert(String str){
        int loc = 0;
        for (char c : str.toCharArray()){
            int num = (c - 'a');
            if (son[loc][num] == 0)     son[loc][num] = ++ idx;     //添加结点
            loc = son[loc][num];        //往下找
        }
        
        //此时loc指向末尾字符对应结点的地址
        cnt[loc] ++;        //打上标记：数量 ＋ 1
    }

    public static int query(String str){
        int loc = 0;
        for (char c : str.toCharArray()){
            int num = (c - 'a');
            if (son[loc][num] == 0)     return 0;       //查找的分支中没有结点存字符c
            loc = son[loc][num];        //往下找
        }

        return cnt[loc];
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        N = Integer.parseInt(in.next());
        while(N -- != 0){
            String op = in.next();
            String str = in.next();

            if (op.equals("I"))     insert(str);
            else    System.out.println(query(str));
        }
    }
}

---

最大异或对

在给定的 N 个整数 A1，A2……AN 中选出两个进行 xor（异或）运算，得到的结果最大是多少？

输入格式
第一行输入一个整数 N。

第二行输入 N 个整数 A1～AN。

输出格式
输出一个整数表示答案。

数据范围
1≤N≤105,
0≤Ai<231

输入样例：

3
1 2 3

输出样例：

3

---

首先从暴力的角度来看就是Ai和Aj(1<= i < j <= N)异或后的结果与res进行max一遍，复杂度是 O(N^2)，毫无疑问肯定是会超时的，所以来优化这个做法。

对于枚举的每个Ai，为了找到与Aixor操作后结果最大数ret，肯定是先从Ai的第一位开始（二进制视角），依次往后遍历，每次从待选数集合中找与它在这一位能对立的数（0找1，1找0），然后ret加上2的这一位权重次方（因为对立数的xor贡献出一位“1”），这样就有点像贪心思路，如果在沿着贪心路径上找不到在当前位上对立的数，则只有默认该位找到的数相同，然后接着向下搜索。

如果把每个数的二进制形式映射到Trie树上（如下图，可以看到像Huffman树一样），那么这显然是一个树上搜索的问题，每次结点都尽量往能跟Ai在同一位上数值对立的结点上跳。注意到每个数都小于2^31，所以用31位表示一个数，对应地，一个数映射在Trie树上的0-1分支长度最多不会超过31，由于该题N的数据量为10e5，所以结点数量最多为31 * 10e5。

最终将每个枚举出的ret进行max一遍即得到最终结果，因为枚举Ai的复杂度为O(N)，而每次查找“最大异或数”操作为O(logn)（跟树的高度有关），所以总的来讲用Trie将时间复杂度优化到了O(N * logN)。

---

C++代码

#include <iostream>
#include <algorithm>
using namespace std;

const int N = 10e5 + 10;

int n, idx, res = -1;
int a[N], son[31 * N][2];

void insert(int x){     //插入30个结点的数x
    int loc = 0;
    for(int i = 30; ~i ;i --){      
        int u = x >> i & 1;     //获取x的（从右往左数）第i位数字
        if(!son[loc][u])        son[loc][u] = ++ idx;
        loc = son[loc][u];
    }
}

int search(int x){      //找使得与x异或后结果最大的数
    int loc = 0, ret = 0;
    for(int i = 30; ~i ;i --){
        int u = x >> i & 1;
        if(son[loc][!u]){           //!u表示取反(0->1，1->0)
            ret += 1 << i;       //二进制加法，1 << i表示权值为i：即2的i次方
            loc = son[loc][!u];
        }
        else        loc = son[loc][u];      //由于异或后的这一位为0，ret += 0可以略去
    }
    
    return ret;
}

int main(){
    ios :: sync_with_stdio(false);
    cin >> n;
    for(int i = 0;i < n;i ++){
        cin >> a[i];
        insert(a[i]);
    }
    
    for(int i = 0;i < n;i ++)       res = max(res, search(a[i]));
    
    cout << res << endl;
    return 0;
}

---

LeetCode 208. 实现Trie（类存储）

这是题目链接。

注意到提示中：

insert…等操作总共不超过3 * 10e4次，而每个可能存储的字符串长度不超过2000，也就是说，这棵Trie树的结点最多会达到接近2000 × 30000个，如果用数组模拟，预定义的son数组应该是int son[2000 * 30000][26]，显然空间复杂度无法承受。

所以此时将Trie进行类动态存储。

---

Java代码

class Trie {
    public Trie[] son;         //子结点
    public boolean isEnd;      //是否为某个字符串的末尾，(isEnd为true说明存储了从根到这个Trie结点路径的字符串)

    public Trie() {
        son = new Trie[26];
        isEnd = false;
    }
    
    public void insert(String word) {
        Trie loc = this;
        for(char c : word.toCharArray()){
            int u = (c - 'a');
            if(loc.son[u] == null)      loc.son[u] = new Trie();
            loc = loc.son[u];
        }

        loc.isEnd = true;
    }

    public boolean search(String word) {
        Trie loc = this;
        for(char c : word.toCharArray()){
            int u = c - 'a';
            if(loc.son[u] == null)      return false;
            loc = loc.son[u];
        }

        //此时loc结点值已是word的最后一个字符，只需看它的标记
        return loc.isEnd;
    }
    
    public boolean startsWith(String prefix) {
        Trie loc = this;
        for(char c : prefix.toCharArray()){
            int u = c - 'a';
            if(loc.son[u] == null)      return false;
            loc = loc.son[u];
        }

        //能找到一条“畅通无阻”的字符串路径，说明有prefix这个前缀。
        return true;
    }
}