算法基础课—数据结构（五） Trie树

用来高效存储和查找字符串集合的数据结构

基本操作

通过创建或遍历树可以满足存储和查找字符串的过程

创建

如果没有当前字符则创造一个分支，如果有则继续，结束单词有个标记

查找

一直往下遍历，看是否存在

Trie字符串统计

题目

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

I x 向集合中插入一个字符串 x；
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

算法思想

树本身还是链表的结构，一定有当前值本身e[N],和指向下标ne[N],idx用来表示结点，串起e[N]和ne[N].
而在trie树这里，由于字符串中字符仅可能有26种（不考虑大小写），则不需要另外开放一个e[N]专门存储值，同时trie树为多叉树，一个节点有可能指向26个子节点。
于是开创son[N][26]表示，son[i][0]表示第i个节点，指向值为a的节点的下标。
cnt的创建含义// 以“abc”字符串为例，最后一个字符—‘c’对应的idx作为cnt数组的下标。数组的值是该idx对应的个数。
此时的c是独一无二的一定是以ab为前缀的
Trie树的创造过程
如果有值为a的节点则继续往下走，没有则创造一个节点，idx++，然后顺着新创造的节点往下走
Trie树的查找过程
沿着值往下查找节点，如果还没有找完就碰到0，则没有这个，一直遍历到最后一个节点j，cnt[j]即为其个数

代码数据结构

son[N][26]表示，son[i][0]表示第i个节点，指向值为a的节点的下标。根节点为0，为空也指向0
cnt的创建含义// 以“abc”字符串为例，最后一个字符—‘c’对应的idx作为cnt数组的下标。数组的值是该idx对应的个数。cnt其实也是用来表示字符串的结束
idx 当前节点
inset()操作和query()操作

代码

#include <iostream>
using namespace std;
const int N = 1e6 + 1;
int son[N][26] = {0}, cnt[N] = {0}, idx = 0;
void insert(char str[]){
    int p = 0;//表示从根节点开始。根节点下标为0，空节点下标也为0
    int u, i;
    for(i = 0; str[i]; i ++ ){
        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 u, i;
    for(i = 0; str[i]; i ++ ){
        u = str[i] - 'a';
        if(!son[p][u])//如果对应值下指向空，则不存在这个字符串
            return 0;
        p = son[p][u];//往下遍历
    }
    return cnt[p];//有可能cnt[p]为0 ，即存在abbb字符串，但不存在abb字符串，此时对应最后一位b的cnt为0
}
int main(){
    int n, i;
    char op[2];
    char s[N];
    cin>>n;
    for(i=0;i<n;i++){
        cin>>op>>s;
        if(op[0] == 'I')
            insert(s);
        else if(op[0] == 'Q'){
            cout<<query(s)<<endl;
        }
    }
}

最大异或对

题目

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

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

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

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

数据范围
1≤N≤105,
0≤Ai<231
输入样例：
3
1 2 3
输出样例：
3

算法思想

暴力思想是每个值都互相进行比较，我们的优化时如果取一个数，怎么尽量少的比较

考虑值相反的越多是异或值越大，于是可以采用树的结构来遍历
依次遍历，每次取其相反的路去走，如果相反的路走不通则，就走与自身值相同的路
走不通说明树中没有这个数，由于是与存在的数进行比较，所以只能退而求其次，但是因为之前的都是相反的，高位都是1，所以仍然是最佳方案。

对于字符串数据的存储，要存储31位，前面没有的要补零，这样方便比较
如果N取的较大的时候，对于son的数组空间要设的较大，否则会报错。

代码

#include <iostream>
#include <math.h>
using namespace std;
const int N = 5e6;//如果N太小，则在输入100000个数的时候会出错
int M = 31;
int son[N][2] = {0}, cnt[N], idx = 0;
int str1[N],str2[N][31] = {0};
void ten2two(int num, int index){
    int i = 0, j, len;
    while(num){
        str1[i ++ ] = num % 2;
        num = num / 2;
    }
    len = i;
    for(j = M - len, i = len - 1; i >= 0; i --,j ++){
        str2[index][j] = str1[i];
    }
}
void insert(int str[]){
    int p = 0, i, u;
    for(i = 0; i < M; i ++){
        u = str[i];
        if(!son[p][u]) son[p][u] = ++idx;
        p = son[p][u];
    }
    cnt[p] ++;
}
int query(int str[]){
    int p = 0, u, i, t = pow(2,M-1);
    int result = 0;
    for(i = 0; i < M; i ++){
        u = (str[i] + 1)% 2;//这里不能直接用取反，因为如果是0，可能是0000，取反后是1111
        if(son[p][u]){
            p = son[p][u];
            result = result + t;
        }
        else if(son[p][str[i]]){
            p = son[p][str[i]];
        }
        t = t / 2;
    }
    return result;
}
int main(){
    int n, i, len, num;
    int result, result_max = 0;
    cin>>n;
    for(i=0;i<n;i++){
        cin>>num;
        ten2two(num,i);
        insert(str2[i]);
    }
    for(i = 0; i < n; i ++){
        result = query(str2[i]);
        result_max = max(result, result_max);
        //cout<<result_max<<endl;
    }
    cout<<result_max<<endl;
}

总结

对于算法的考虑，一开始是先考虑暴力做法怎么做，然后去想怎么优化，用什么数据结构。
Trie树，是用树的形式来存储各个字符串，拥有左右节点和父子节点，拥有树的相关特性，所以对于求前缀、子字符串、相反值有很好的作用。