算法专栏 ---- trie树，并查集

 trie树 

#include <iostream>
using namespace std;
const int N = 1000010;
int son[N][26],cnt[N],idx;
//明确前面两个数组以及idx的含义
//我们把son这个二维数组看成一个字典树
//本题要求26个字母，所以我们每个节点里面最多有26个儿子节点
//而我们本题要求字符串长度是100000个，所以son数组的N代表有100000层，对应的就是字符串长度
//为什么这样就可以呢，因为我们查找的字符串（只有26个字母）在查找的时候想象成树
//每次面临26种选择（26个字母）(也有点组合的意思)，选择一种和当前匹配的，没有就说明没有匹配的
//idx是什么呢，我们怎么用数组来模拟的呢，我们怎么算是创建过这个节点了，我们son数组的元素为1
//就代表我们创建了这个节点，如果遇到这个节点之后我们就可以直接往下走，如果没有遇到，我们就
//不往下走,先创建在走，创建的过程就是idx++,就是走到当前元素为1时说明创建过了
//cnt数组表示以当前节点的值为终点的字符串个数

char str[N];
void insert(char str[])
{
    int p = 0;//p代表我们当前走到哪个位置了（把数组抽象成一棵树）
    for(int i = 0; str[i] != '\0';i++)//枚举插入的字符串，枚举的字符串抽象成路径
    {
        int u = str[i] - 'a';//映射到数组里，son数组一维数组的下标0代表的是a，1是b
        if(son[p][u] == 0) son[p][u] = ++idx;//每次进入判断是否创建过当前值的节点
        p = son[p][u];//走到下一层
    }
    cnt[p]++;//当前下标为终点的字符串个数++
}
int  inquire(char str[])
{
   int p = 0;
   for(int i = 0; str[i] != '\0';i++)
   {
       int u = str[i] - 'a';
       if(!son[p][u]) return 0;
       p = son[p][u];
   }
   return cnt[p];
}
int main()
{
    int n;
    cin>>n;
    for(int i = 0;i < n;i++)
    {
        char chose[2];
        cin>>chose>>str;
        if(chose[0] == 'I')
        {
            insert(str);
        }
        else
        {
            printf("%d\n",inquire(str));
        }
    }
    return 0;
}

并查集

#include <iostream>
#include <algorithm>
#include <vector>
#include <cstring>
using namespace std;
//本题是模板题，所以我们先理解这道题的模板是什么
//本题的模板是并查集，那什么是并查集呢，其实你可以想象成一个树
//我们的字符串都是通过递归去搜索的，跟字典树类似
//但是并查集强在归并和询问的操作近乎O(1)的时间复杂度,可以快速将两个集合
//合并和快速查两个集合是否在同一个集合


//并查集的基本原理是什么呢，基本原理就是每个集合我们看成一颗小树，一颗大树里可能包含小树
//比方说一个字符串是一个集合，那么这棵大树可能就有好多字符串集合，
//那我们并查集是怎么快速实现合并和查询的呢，这就要说到并查集的编号了
//我们怎么去查找到这个集合呢，我们肯定得让他的根节点跟孩子节点编号不一样，我们才能找到
//我们的集合，在此我们设置P[x]为节点的编号，而p[x] == x 是根节点的编号
//我们的p[x]代表的是当前节点的父节点
//1.如何判断根节点 if(p[x] == x)
//2.如何从孩子节点求根节点的编号while(p[x]!=x) x = p[x];
//3.如何合并两个集合，假设编号是p[X],P[Y],前面提到过的我们抽象成一颗树，这棵树
//合并只需要把一个根节点作为另一个根节点的父节点即可
//在此，我们还需要优化一下，路径压缩法,等于说第一次查询过这个集合之后下次查询就是O（1)的
//时间复杂度,为什么呢，想象一下一棵树的高度只有2，根节点只有1个，这时我们查询集合的所以元素的话
//我们就只需要遍历这个集合就元素就行，不需要再去递归好几层了

//并查集模板最关键的点是在于写出find操作
const int N = 1000010;
int p[N];
int  find(int x)//返回要查找的元素的集合,递归查找
{
    if(p[x] != x)  p[x] = find(p[x]);//如果父节点不是根节点，那么就把接力棒给父节点
    //让父亲节点去找
    return p[x];//找到了就返回
}
int main()
{
    int n, m;
    cin >> n >> m;
    for (int i = 1;i <= n;i++) p[i] = i;
    while (m--)
    {
        char op[2];
        int a, b;
        scanf("%s%d%d",op,&a,&b);
        if (op[0] == 'Q')
        {
            if (find(a) == find(b)) printf("Yes\n");
            else printf("No\n");
        }
        else if(op[0] == 'M')
        {
            p[find(a)] = find(b);//找到a集合的根节点，把a集合的根节点查到b集合的根节点
        }
    }
   return 0;
}

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 510000;
int p[N],d[N];
int n,m;
int find(int x)//路径压缩
{
    if(p[x] != x)//不是根节点的话
    {
        int t = find(p[x]);
        d[x] += d[p[x]]; 
        p[x] = t;
    }
    return p[x];
}

int main()
{
    cin>>n>>m;
    for(int i = 1;i <= N;i++)
    {
        p[i] = i;
    }
    int cnt = 0;
    for(int i = 1;i <= m;i++)
    {
        int op,a,b;
        cin>>op>>a>>b;
        if(a > n || b > n)
        {
            cnt++;
            continue;
        }
        int pa = find(a);
        int pb = find(b);
        if(op == 1)
        {
  if(pa == pb && (d[a] - d[b]) % 3){
                    //是在同一个集合的话，判断是否是同类
                //不是同类res++，是同类不用管
                    cnt++;
                }
                else if(pa != pb){
                    //不在同一个集合，判断是否同类
                //先建立两个集合的集合关系，为什么建立两个呢
                //因为能find找到说明必有根节点
                //本题根节点肯定存在，就算只有两个节点
                //我们也看成两个集合
                
                    p[p[a]] = pb;//让x集合的根节点作为y集合的根节点的孩子
                    //节点
                    
                    //建立之后还得更新一下距离关系，第一次进入的话其实
                    //并没有建立集合，也就是刚好是说了第一句话的时候
                    //第一句不同的x和y或者两个相同的x或者y我们默认为真话，
                    //默认为x和y同类并且建立关系（同类关系）
                    //所以x和y分别到当前建立好集合关系
                    //的根节点的距离一定要相等，所以距离
                    //就是d[x] + ？= d[y]，这个问好是根节点到px的距离
                    d[pa] = d[b] - d[a];
                }
        }
        else
        {

               if(pa == pb && (d[a] - d[b] -1) %3){
                    //在同一个集合
                //并且不是x 吃 y的关系
                //c++中-n % n等于0
                    cnt++;
                }
                else if(pa != pb){
                //不是同一个集合的话，那么我们默认为
                //真话，x能吃掉y
                    p[p[a]] = pb;
                    //维护距离使得x能吃掉y
                    d[pa] = d[b] - d[a] + 1;
                }
        }
    }
    cout<<cnt<<endl;
    return 0;
}