Trie 详解和应用

Trie树图文详解

题目（Trie字符串统计）

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

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

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

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

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

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

每个结果占一行。

数据范围
1 ≤ N ≤ 2∗10⁴
输入样例：
5
I abc
Q abc
Q ab
I ab
Q ab
输出样例：
1
0
1

Trie 树是一种多叉树的结构，每个节点保存一个字符，一条路径表示一个字符串。

下图表示了字符串： him 、 her 、 cat 、 no 、 nova 构成的 Trie 树。

从图中可以看出 Trie 树包含以下性质：

• 根节点不包含字符，其他节点包含一个字符。
• 从根节点到某一节点经过的字符连接起来构成一个字符串。如图中的 him 、 her 、 cat 、 no 、 nova。
• 一个字符串与 Trie 树中的一条路径对应。
• 在实现过程中，会在叶节点中设置一个标志，用来表示该节点是否是一个字符串的结尾，本例中用青色填充进行标记。

Trie 树中每个节点存储一个字符，从根节点到叶节点的一条路径存储一个字符串。另外，有公共前缀的字符串，他们的公共前缀会共用节点。如 her、 him 共用 h 节点。

如何生成 Trie 树？

Trie 树的生成过程，就是不断将字符串插入树中。

以插入字符串 him 、 her 、 cat 、 no 、 nova 为例，过程如下：

• 插入 him :
  
• 根节点不存在子节点 h，因此创建子节点 h。
• 在节点 h 的基础上插入第二个字符 i。
• 节点 h 不存在子节点 i，创建子节点 i。
• 在节点 i 的基础上插入第三个字符 m。
• 节点 i 不存在子节点 m，创建子节点 m。并将该节点标记为字符串结束标志，完成 him 字符串插入。
• 插入 her :
  
• 根节点存在子节点 h。不用重新创建子节点 h。
• 在节点 h 的基础上插入第二个字符 e。
• 节点 h 不存在子节点 e，创建子节点 e。
• 在节点 e 的基础上插入第三个字符 r。
• 节点 e 不存在子节点 r，创建子节点 r。并将该节点标记为字符串结束标志，完成 her 字符串插入。
• 插入 cat：
  
• 根节点不存在子节点 c，因此创建子节点 c。
• 在节点 c 的基础上插入第二个字符 a。
• 节点 c 不存在子节点 a，创建子节点 a。
• 在节点 a 的基础上插入第三个字符 t。
• 节点 a 不存在子节点 t，创建子节点 t。并将该节点标记为字符串结束标志，完成 cat 字符串插入。
• 插入 no:
  
• 根节点不存在子节点 n，因此创建子节点 n。
• 在节点 n 的基础上插入第二个字符 o。
• 节点 n 不存在子节点 o，创建子节点 o。并将该节点标记为字符串结束标志，完成 no 字符串插入。
• 插入 nova:
  
• 根节点存在子节点 n，不用重新创建子节点 n。
• 在节点 n 的基础上插入第二个字符 o。
• 节点 n 存在子节点 o，不用重新创建子节点 o。
• 在节点 o 的基础上插入第三个字符 v。
• 节点 o 不存在子节点 v，创建子节点 v。
• 在节点 v 的基础上插入第四个字符 a。
• 节点 v 不存在子节点 a，创建子节点 a。并将该节点标记为字符串结束标志，完成 nova 字符串插入。

如何删除一个字符串？

删除一个字符串需要考虑的地方较多。

情况一：待删除的字符串末尾为叶节点，且与其它字符串无公共前缀。将节点逐一删除即可，例如删除 cat。

情况二：待删除字符串末尾不是叶节点。将字符串标志位置为 false 即可，例如删除 no 。

情况三：待删除字符串末尾为叶节点，并且中间有其它单词。逐一删除节点，直到待删除节点是另一个字符串的结尾为止，例如删除 nova。

情况四：待删除字符串某一节点还有其它子节点。逐一删除节点，如果待删除节点还有其它子节点，则停止删除，例如删除 him。

Trie 树有什么用？

Trie 树又叫字典树。字典是用来查字的，Trie 树最基本的作用是在树上查找字符串。

例如有 5 个字符串： him 、 her 、 cat 、 no 、 nova 。现在要查找 catch 是否存在。

如果使用暴力的方法，需要用 catch 与这 5 个字符串分别进行匹配，效率较低。

如果将这 5 个字符串存储成 Trie 的结构，只需要顺着路径依次比较，比较完 cat 之后，没有节点与 c 匹配，所以字符串集合中不存在 catch。

Trie 树还有其他用途吗？

可以用来词频统计

词频统计

在构造树的过程中，已经将所有字符串遍历了一遍。可以在 Trie 树节点的数据结构中，增加一个 count 来计数。对于每个字符串的插入操作，若已存在，计数加 1，若不存在，插入后 count 置为 1。

要统计某个字符串出现的次数，只需要找到字符串结尾对应的节点，输出对应节点的 count 值即可。

说说 Trie 树的优缺点。

Trie树的核心思想是空间换时间，利用字符串的公共前缀来减少无谓的字符串比较以达到提高查询效率的目的。

优点

1. 插入和查询的效率很高，都为O(m)。其中 m 是待插入/查询的字符串的长度。。

缺点

1. 空间消耗比较大。

代码：

//这个代码的注释好难写，以自己理解为主
#include<iostream>
using namespace std;
const int N = 100010;
int idx; // 各个节点的编号，根节点编号为0
int son[N][26];//Trie 树本身
//cnt[x] 表示：以 编号为 x 为结尾的字符串的个数
int cnt[N];

int n;

void insert(string s){
    int p = 0;//指向根节点
    for(int i = 0; i < s.size(); i++){
        //将当前字符转换成数字（a->0, b->1,...）
        int u = s[i] - 'a';
        //如果数中不能走到当前字符
        //为当前字符创建新的节点，保存该字符
        if(!son[p][u])
            // 新节点编号为 idx + 1
            son[p][u] = ++idx;
        p = son[p][u];
    }
    //这个时候，p 等于字符串 s 的尾字符所对应的 idx
    //cnt[p] 保存的是字符串 s 出现的次数
    //故 cnt[p] ++
    cnt[p] ++;
}

int query(string s){
    int p = 0;//指向根节点
    for(int i = 0; i < s.size(); i++){
        //将当前字符转换成数字（a->0, b->1,...）
        int u = s[i] - 'a';
        //如果走不通了，即树中没有保存当前字符
        //则说明树中不存在该字符串
        if(!son[p][u]) 
            return 0;
        //指向下一个节点
        p = son[p][u];
    }
    //循环结束的时候，p 等于字符串 s 的尾字符所对应的 idx
    // cnt[p] 就是字符串 s 出现的次数
    return cnt[p];
}

int main(){
    cin >> n;
    string s;
    char q;
    while(n--){
        cin >> q >> s;
        if(q == 'I'){
            //插入操作
            insert(s);
        }
        else{
            //查询操作
            cout << query(s) << endl;
        }
    }
}

应用

题目（最大异或对）

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

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

第二行输入 N 个整数 A₁ ～A_N 。

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

数据范围
1 ≤ N ≤ 10⁵ ,
0 ≤ A_i < 2³¹
输入样例：
3
1 2 3
输出样例：
3

思路：

用Trie（字典树）

• 建树时，根据输入数字的对应的二进制串构造一个 Trie 树。
• Trie 树的每个结点两个分支，分支指向的两个son结点分别表示当前位的数值为0或1
• 记录每次输入的数字转化成的二进制串，当前位为1，就走到数值为1的结点，否则走到0结点
• 这样每个数字对应的Trie中的路径就是唯一的。

因为要求异或对的值最大，可以用贪心的思想。

• 在第一个数字固定的情况下，尽可能地让第二个数的每一位都与第一个数的对应位相反，这样最终确定的第二个数与第一个数的异或值就最大，所以在查询时，遍历第一个串o（n），根据固定的第一个二进制串，每次尽可能走到与当前位的值相反的结点，这样的路径对应的就是与第一个二进制串异或值最大的二进制串，便利了这个数的位数次o（logn），所以总的时间复杂度o（n*logn）；

代码

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 100010;
//保存 Trie 树
int son[N * 31][2];  
int n, idx;

void insert(int x)
{
    int p = 0;//初始化指向根节点
    //从最高位开始，依次取出每一位
    for (int i = 31; i >= 0; i--)
    {   // 取出当前位
        int u = x >> i & 1;
         //如果树中不能走到当前数字
        //为当前数字创建新的节点，保存该数字
        if (!son[p][u])
            // 新节点编号为 idx + 1
            son[p][u] = ++idx; 
        p = son[p][u];
    }
}

int query(int x)
{
    //指向根节点
    int p = 0;
    // 保存与 x 异或结果最大的那个数
    int ret = 0;
     //从最高位开始，依次取出 x 的每一位
    for (int i = 31; i >= 0; i--)
    {
        // 取出 x 的当前位
        int u = x >> i & 1;
        //如果树中能走到 !u，就走到!u
        if (son[p][!u]){
            //走到!u
            p = son[p][!u];
            //更新 x 异或的对象
            ret = ret * 2 + !u;
        }  
        //没有!u，就只能走到u了
        else{
            p = son[p][u];
            //更新 x 异或的对象
            ret = ret * 2 + u; 
        }
    }
    //计算异或结果
    ret = ret ^ x;
    return ret;
}

int main()
{
    cin >> n;
    int maxXorNum = 0; 
    int x;
    for (int i = 0; i < n; i++)
    {
        cin >> x;
        insert(x);
        maxXorNum = max(maxXorNum, query(x));
    }

    cout << maxXorNum << endl;

    return 0;
}