基础数据结构 - Trie

$Tire$ （字典树）是一种用于实现字符串快速检索的多叉树结构。 $Tire$ 的每个节点都拥有若干个字符指针，若在插入或检索字符串时扫描到了字符串 $c$ ，就沿着当前节点的 $c$ 字符指针，走向该指针指向的节点。

初始化

• 一颗空 $Tire$ 仅包含一个根节点，该点的字符指针均指向空。

插入

• 当需要插入一个字符串 $S$ 时，我们令指针 $P$ 起初指向根节点。然后，依次遍历 $S$ 中每一个字符 $c$ ：
  1. 若 $P$ 的 $c$ 字符指针为空，则新建一个节点 $Q$ ，令该指针指向它，然后 $P=Q$ 。
  2. 若已存在，则直接 $P=Q$ 。
• 当遍历结束后，在当前 $P$ 上标记它是一个字符串的结尾。

查询

• 当需要查询一个字符串 $S$ 是否在 $Tire$ 中存在过时，我们令一个指针 $P$ 起初 指向根节点，然后依次遍历 $S$ 中的字符：
  1. 若中途路径上有字符指针为空，则直接范围不存在。
  2. 若直到最后一个字符，且此时有标记，则说明存在字符串 $S$ 。
  3. 反之，不存在。

$AcWing$ 上代码如下：

int son[N][26], cnt[N], idx;
// 0号点既是根节点，又是空节点
// son[][]存储树中每个节点的子节点
// cnt[]存储以每个节点结尾的单词数量

// 插入一个字符串
void insert(char *str)
{
    int p = 0;
    for (int i = 0; str[i]; i ++ )
    {
        int u = str[i] - 'a';
        if (!son[p][u]) son[p][u] = ++ idx;
        p = son[p][u];
    }
    cnt[p] ++ ;
}

// 查询字符串出现的次数
int query(char *str)
{
    int p = 0;
    for (int i = 0; str[i]; i ++ )
    {
        int u = str[i] - 'a';
        if (!son[p][u]) return 0;
        p = son[p][u];
    }
    return cnt[p];
}

【例题】前缀统计

给定 $N$ 个字符串 $S_1,S_2\dots S_N$，接下来进行 $M$ 次询问，每次询问给定一个字符串 $T$，求 $S_1\sim S_N$ 中有多少个字符串是 $T$ 的前缀。

输入字符串的总长度不超过 $10^6$，仅包含小写字母。

数据范围
$1\le N,M\le 10^5$

分析：

前缀信息，所以我们需要维护的 $cnt$ 数组就可以表示该位置上字符出现过几次，那么我们先把所有字符串插入到 $Tire$ 后，在查询之前插入的每个字符串是否结尾出现几次。

代码如下：

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 3;
int son[N][26], idx;
int cnt[N];
char s[N];

void insert(char *str)  // 插入字符串
{
    int p = 0;
    for (int i = 0; str[i]; i ++ )
    {
        int u = str[i] - 'a';
        if (!son[p][u]) son[p][u] = ++ idx;
        p = son[p][u];

    }
    cnt[p] ++ ;
}

int query(char *str)  // 查询字符串出现次数
{
    int p = 0;
    int res = 0;
    for (int i = 0; str[i]; i ++ )
    {
        int u = str[i] - 'a';
        if(son[p][u] == 0) {
            return res;
        }
        p = son[p][u];
        res += cnt[p];
    }
    return res;
}

int main()
{
    int n, m;
    cin >> n >> m;

    for(int i = 0; i < n; ++i) {
        scanf("%s", s);
        insert(s);
    }

    while (m -- ) {
        scanf("%s", s);
        cout << query(s) << endl;
    }

    return 0;
}

【例题】最大异或对

在给定的 $N$ 个整数 $A_1，A_2\dots A_N$ 中选出两个进行 $xor$（异或）运算，得到的结果最大是多少？

数据范围
$1\le N\le 10^5,0\le A_i<2^{31}$

分析：

既然 $Tire$ 是用于字符串的快速检索，那么对于一个二进制串，也可以做到快速检索，而题目是异或运算，也就是已知数字 $A_i$ ，要找出另一个数字 $A_j$ 使它们异或最大，那么肯定是尽可能找出二进制 $A_i$ 与 $A_j$ 从高到低位尽可能不同的数。

这也相当于检索。所以我们先把每个数按先高后底的插入带字典树中，然后查询时，如果相反位的数字存在就选相反数，否则就相同，然后找出的数就是异或最大的。

代码如下：

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int son[N * 33][2], cnt[N * 33], idx;
int a[N];

void insert(int num)  
{
    int p = 0;
    for (int i = 30; i >= 0; i -- )
    {
        int u = num >> i & 1;
        if (!son[p][u]) son[p][u] = ++ idx;
        p = son[p][u];
    }
    cnt[p] = 1;
}

int query(int num)
{
    int p = 0, res = 0;
    for (int i = 30; i >= 0; i -- )
    {
        int u = !(num >> i & 1);
        if (son[p][u]) {
            p = son[p][u];
            res |= u << i;
        } else {
            u = !u;
            p = son[p][u];
            res |= u << i;
        } 
    }
    return res ^ num ;
}

int main()
{
    int n;
    scanf("%d", &n);
    for(int i = 0; i < n; ++i) {
        scanf("%d", &a[i]);
        insert(a[i]);
    }

    int res = 0;

    for(int i = 0; i < n; ++i) {
        res = max(res, query(a[i]));
    }

    cout << res << endl;

    return 0;
}

【例题】最大异或值路径

给定一个树，树上的边都具有权值。

树中一条路径的异或长度被定义为路径上所有边的权值的异或和：

⊕ 为异或符号。

给定上述的具有 n 个节点的树，你能找到异或长度最大的路径吗？

数据范围
$$\begin{gathered} 1\le n\le 100000, \\ 0\le u,v<n, \\ 0\le w<2^{31} \end{gathered}$$

分析：

直接做显然不现实，所以我们需要抽象一下问题：在一颗树上，设 $dist(x,y)$ 表示为节点 $x$ 到节点 $y$ 上所有权值的异或和，那么节点 $x$ 与 节点 $y$ 的路径上的异或值可以表示为：
$$\begin{gathered} dist(x,y)= \\ dist(x,LCA(x,y))\oplus dist(LCA(x,y),1)\oplus dist(y,LCA(x,y))\oplus dist(LCA(x,y),1) \\ =dist(x,1)\oplus dist(y,1) \end{gathered}$$

那么我预处理出所有节点到根节点的路径异或和，那么问题就变为从这些数中找出两个数异或和最大的问题了。

代码如下：

#include <bits/stdc++.h>
using namespace std;
const int N = 100010, M = 2 * N;

int D[N];
int h[N], e[M], w[M], ne[M], idx;
int n;

void add(int a, int b, int c)  // 添加一条边a->b，边权为c
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

void dfs(int u, int fa) {

    for(int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];

        if(j != fa) {
            D[j] = D[u] ^ w[i];
            dfs(j, u);
        }

    }
}


int son[N * 33][2], cnt[N * 33];

void insert(int x)  // 插入字符串
{
    int p = 0;
    for (int i = 30; i >= 0; i -- )
    {
        int u = x >> i & 1;
        if (!son[p][u]) son[p][u] = ++ idx;
        p = son[p][u];
    }
    cnt[p] = 1;
}

int query(int x) {
    int p = 0;
    int res = 0;
    for (int i = 30; i >= 0; i -- )
    {
        int u = !(x >> i & 1);

        if (!son[p][u]) {
            u = !u;
        }

        p = son[p][u];

        res |= u << i;
    }

    return res ^ x;
}


int main()
{
    memset(h, -1, sizeof h);


    scanf("%d", &n);

    for(int i = 0, u, v, x; i < n - 1; ++i) {
        scanf("%d%d%d", &u, &v, &x);
        add(u, v, x);
        add(v, u, x);
    }

    dfs(0, -1);

    idx = 0;

    for(int i = 0; i < n; ++i)
        insert(D[i]);

    int res = 0;

    for(int i = 0; i < n; ++i) {
        res = max(res, query(D[i]));
    }

    cout << res ;

    return 0;
}