Trie树、并查集、堆

Trie树

#include <iostream>
using namespace std;
const int N = 100010;
int son[N][26];//存储每个节点的儿子(在哪一行)
int idx;cnt[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;//分配唯一的一个idx指向下一个字符存储的位置(行数)
        p = son[p][u];//走到下一个字符位置处
    }
    cnt[p]++;//每个idx对应唯一的一条字符串，计算字符串出现的次数
}
int query(char str[])
{
    int p = 0;
    for(int i = 0;str[i];i++)
    {
        int u = str[i] - 'a';
        if(!son[p][u]) return false;
        p = son[p][u];
    }
    return cnt[p];//通过p索引次数
}

 例题1

#include <bits/stdc++.h>
using namespace std;
const int M = 4E6;
const int N = 100010;
int son[M][2];int q[N];int idx;
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];
    }
}
int query(int x)
{
    int res = 0;int p = 0;
    for(int i = 30;i >= 0;i--)
    {
        int u = x >> i & 1;//x的该位
        if(son[p][!u])//存在相反的元素
        {
            res += 1 << i;//将遍历到的数值进行累加
            p = son[p][!u];
        }
        else p = son[p][u];
    }
    return res;
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i = 0;i < n;i++)
    {
        scanf("%d",&q[i]);
        insert(q[i]);
        //printf("%d ",q[i]);
    }
    int res = 0;
    for(int i = 0;i < n;i++) res = max(res,query(q[i]));
    printf("%d\n",res);
    return 0;
}

 并查集

使用场景：1、将两个集合合并 

                  2、询问两个元素是否在一个集合中

近乎O(1)的时间复杂度

belong[x] = a;

if(belong[x] == belong[y])O(1),在O(1)时间复杂度内判断数据是否属于同一个集合

如果要将两个集合合并，则需要将其中一个集合的数据全部改为另一个集合，时间复杂度为其中一个集合数据的数量

基本原理：每个集合用一棵树来表示。树根的编号就是整个集合的编号。每个节点存储它的父节点，p[x]表示x的父节点

问题1：如何判断树根：if(p[x] == x)

问题2：如何求x的集合编号：while(p[x] != x) x = p[x];

问题3：如何合并两个集合：px是x的集合编号，py是y的集合编号。p[x] = y

 例题1

#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int q[N];
int n,m;
int findroot(int x)//寻找根的位置并进行路径压缩
{
    if(q[x] != x) 
    q[x] = findroot(q[x]);
    return q[x];
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i = 1;i <= n;i++) q[i] = i;//最开始每个数都是一个集合
    while(m--)
    {
        char op[2];//用scanf读一个字符,采用字符串形式
        int a,b;
        scanf("%s%d%d",&op,&a,&b);//使用%s读一个字符
        if(op[0] == 'M') q[findroot(a)] = findroot(b);//b作为一个新的父节点
        else 
        {
            if(findroot(a) == findroot(b)) puts("Yes");
            else puts("No");
        }
    }
    return 0;
}

 例题2

#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int q[N];
int num[N];//保存每个祖宗节点下有多少个元素，只有祖宗节点的元素为有效值
int find(int x)
{
    if(q[x] != x) q[x] = find(q[x]);
    return q[x];
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i = 1;i <= n;i++) 
    {
        q[i] = i;
        num[i] = 1;//初始时每个元素自己都是一个根
    }
    while(m--)
    {
        char op[3];
        scanf("%s",op);
        if(op[0] == 'C')
        {
            int a,b;
            scanf("%d%d",&a,&b);
            if(find(a) != find(b))//首先判断不在一个集合中
            {
                num[find(b)] += num[find(a)];//注意一定是先将每个集合中的元素累加
                //再把其中一个的集合总数中再进行相应的祖先节点重置
                q[find(a)] = find(b);
                
            }
        }
        else if(op[1] == '1')
        {
            int a,b;
            scanf("%d%d",&a,&b);
            if(find(a) == find(b)) puts("Yes");
            else puts("No");
        }
        else //op[1] == '2'
        {
            int a;
            scanf("%d",&a);
            printf("%d\n",num[find(a)]);
        }
    }
    return 0;
}

 例题3

#include <bits/stdc++.h>
using namespace std;
const int N = 50010;
int p[N];//保存节点的父节点
int d[N];//保存每个节点距父节点的距离，初始化距离为0
int find(int x)//找根节点+路径压缩，因为路径压缩所以要重新计算每个节点距根节点距离
{
    if(x != p[x])
    {
        int t = find(p[x]);//拿到节点根节点
        d[x] += d[p[x]];//节点到根节点的距离等于距父节点的距离+父节点到父节点的距离(到根)
        p[x] = t;//对父节点进行更改
    }
    return p[x];
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i = 1;i <= n;i++) p[i] = i;//初始化每个节点就是根节点
    int res = 0;
    while(m--)
    {
        int t,x,y;
        scanf("%d%d%d",&t,&x,&y);
        
        if(x > n || y > n) res++;
        else
        {
            int px = find(x),py = find(y);//找到x,y的祖宗节点，判断是否加到集合中
                                              //，加到集合中可判断真假，没有加到集合中就加到集合中
            if(t == 1)//判断同类
            {
                if(px == py && (d[x] - d[y]) % 3)//在集合中但不是同一层
                res++;
                else if(px != py)//不在集合中
                {
                    p[px] = py;//加到集合中
                    d[px] = d[y] - d[x];//重新计算到根的距离
                }
            }
            else//判断吃的关系
            {
                if(px == py && (d[x] - d[y] - 1) % 3) res++;//在集合中但两者关系不是取余后相差一层
                else if(px != py)
                {
                    p[px] = py;
                    d[px] = d[y] + 1 - d[x];
                }
            }
        }
    }
    printf("%d\n",res);
    return 0;
}

堆

1、插入一个数           heap[++size] = x;up(size);

2、求集合中的最小值heap[1];

3、删除最小值           heap[1] = heap[size];size--;down(1);//从下标1开始

4、删除任意一个元素heap[k] = heap[size];size--;down(k);up(k);//down和up只会执行一个

5、修改任意一个元素heap[k] = x;down(k);up(k);

向下调整算法
void down(int u)
{
    int t = u;//t保存三个元素最小值的编号
    if(u * 2 <= size && h[u * 2] < h[t]) t = u * 2;
    if(u * 2 + 1 <= size && h[u * 2 + 1] < h[t]) t = u * 2 + 1;
    //t指向较小的元素
    if(u != t)//两者相等说明指向没有改变，也就是说找不到孩子比父亲小
    {
        swap(h[t],h[u]);
        down(t);
    }
}


//建堆需要使用向下调整算法
for(int i = n / 2;i;i--)
down(i);
//从非叶子节点开始向下进行调整,调整到根节点


//向上调整算法
void up(int u)
{
    while(u / 2 && h[u / 2] > h[u])//父节点存在且父节点大于子节点
    {
        swap(h[u / 2],h[u]);
        u /= 2;//交换后u指向父节点
    }
}

 例题：含有映射关系的模拟堆

 将堆内元素的插入顺序(第几个插入的数以及堆内元素下标进行相互映射)

那么进行交换操作时就需要对映射关系进行维护(见具体代码)

#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int h[N];//存储元素
int hp[N];//存储插入第几个元素到元素下标的映射
int ph[N];//存储元素下标到插入第几个元素的映射
int Size;//元素个数
//维护映射关系的堆元素交换
void heap_swap(int a,int b)//a,b为下标
{
    swap(ph[hp[a]],ph[hp[b]]);//交换ph数组中第k个插入的数的下标
    swap(hp[a],hp[b]);
    swap(h[a],h[b]);
}
//向上调整算法
void up(int u)
{
    while(u / 2 && h[u / 2] > h[u])
    {
        heap_swap(u / 2,u);
        u /= 2;
    }
}
//向下调整算法
void down(int u)
{
    int t = u;
    if(2 * u <= Size && h[2 * u] < h[t]) t = 2 * u;
    if(2 * u + 1 <= Size && h[2 * u + 1] < h[t]) t = 2 * u + 1;
    if(t != u)
    {
        heap_swap(t,u);
        down(t);
    }
}


int main()
{
    int m,n = 0;
    scanf("%d",&m);
    while(m--)
    {
        char op[5];
        scanf("%s",op);
        int n = 0;//用于规定插入顺序
        if(!strcmp(op,"I"))
        {
            int x;
            scanf("%d",&x);
            Size++;
            n++;
            h[Size] = x;
            up(Size);
            hp[Size] = n;
            ph[n] = Size;
        }
        else if(!strcmp(op,"PM"))
        {
            printf("%d\n",h[1]);
        }
        else if(!strcmp(op,"D"))
        {
            int k;
            scanf("%d",&k);
            k = ph[k];//找到第k个插入的数的下标
            heap_swap(k,Size);
            Size--;
            up(k);
            down(k);
        }
        else if(!strcmp(op,"DM"))
        {
            heap_swap(Size,1);
            Size--;
            down(1);
        }
        else if(!strcmp(op,"C"))
        {
            int k,x;
            scanf("%d%d",&k,&x);
            int idx = ph[k];
            h[idx] = x;
            down(idx);
            up(idx);
        }
    }
    return 0;
}

题目：堆排序

#include <bits/stdc++.h>
using namespace std;
const int  N = 100010;
int q[N],cur_size;
void down(int u)
{
    int t = u;
    if(2 * u <= cur_size && q[2 * u] < q[t]) t = 2 * u;
    if(2 * u + 1 <= cur_size && q[2 * u + 1] < q[t]) t = 2 * u + 1;
    if(t != u)
    {
        swap(q[u],q[t]);
        down(t);
    }
}
void up(int u)
{
    while(u / 2 && q[u / 2] > q[u])
    {
        swap(q[u / 2],q[u]);
        u /= 2;
    }
}

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    cur_size = n;
    for(int i = 1;i <= n;i++) scanf("%d",&q[i]);
    for(int i = n / 2;i > 0;i--) down(i);//建堆
    while(m--)
    {
        printf("%d ",q[1]);
        swap(q[1],q[cur_size]);
        cur_size--;
        down(1);
    }
    return 0;
}