目录

一、Trie树

二、并查集

1.并查集习题1（简单）

2.并查集习题2——食物链（中等）

三、堆和堆排序

1.堆排序

2.模拟堆

一、Trie树

Trie树是一种高效存储和查找字符串的结构。

当存储abcd时，先看根节点有没有为a的子节点，若没有则创建，若有则看a节点有没有为b的子节点，若没有则创建。以此类推。需要注意的是，每个字符串结束后面需要结束标记。

具体实现分析：使用idx表示代表树中的每一个字符。使用二维数组，行代表根节点，列代表其子节点。

具体实现过程：

//这里填你的代码^^
#include
using namespace std;
const  int N =100010;

char str[N];

//idx表示根结点，表示存储到了哪个位置，表示某个字符存在的位置（行数）。cnt是这个idx结尾的次数，表示一个字符串出现的次数。
int son[N][26], idx=0,cnt[N];

//son 数组 行 为根节点 列代表子节点


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;//注意要先++，表示son这个位置存进一个idx，表示创建子节点，
        p=son[p][u];//p走向下一个根节点，实际上是上一次的子节点。
    }
    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];
}


int main()
{
    int n; cin>>n;
    while(n--)
    {
        char op[2]; cin>>op>>str;
        if(op[0]=='I')  insert(str);
        else    cout< 
二、并查集 
 
 一般情况下，如果要合并两个元素想x，y，就让x的父节点为y。但是若合并的元素过多，数的高度就会很大，判断树根就比较费时，所以采用路径压缩或者按秩合并的方法。路径压缩是指查询过某一个数后，将他以及他之上的所有父节点直接指向根节点。
 
路径压缩代码：
 
int find (int x)//找根节点 + 路径压缩！！！！！！
{
    if(p[x]!=x)   p[x] =find(p[x]);
    return p[x];
}
 
 总体实现：
 
//这里填你的代码^^
#include
using namespace std;

const int N  =100010;

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=0;i>op>>a>>b;
        if(op[0]=='M')  p[find(a)] =find(b);
        else 
        {
            if(find(a)==find(b))  cout<<"Yes"< 
1.并查集习题1（简单） 
 
 分析：就是最简单的并查集，不过需要一个cnt数组存储一下每一个集合中点的数量。在合并集合的时候要合并数量。//注意a和b是一个集合的时候，则不能相加数量。
 
//这里填你的代码^^
#include 

using namespace std;

const int N = 100010;

int n, m;
int p[N], cnt[N];

int find(int x)
{
    if(p[x]!=x)  p[x]=find(p[x]);
    return p[x];
}


int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++) p[i]=i,cnt[i]=1;
    while(m--)
    {
        string op;
        int a,b;
        cin>>op;
        if(op=="C")
        {
            cin>>a>>b;
            if(find(a)!=find(b))//注意是不属于一个集合才要进行操作，而不是a和b不相等
            {
                cnt[find(b)] += cnt[find(a)];
                p[find(a)]=find(b); 
            }
        }
        else if (op=="Q1")
        {
            cin>>a>>b;
            if(find(a)==find(b))  cout<<"Yes"<>a;
            cout< 
2.并查集习题2——食物链（中等） 
 
 分析：由于只有三种动物，所以当给出x，y，z三个编号动物，x吃y，y吃z时，要求代码能推理出z吃x。
 
因此我们要实现一个并查集，并且维护每个节点到根节点的距离。当距离d%3==1时，表示子节点吃个根节点；当距离d%3==2时，表示子节点吃距离d%3==1的结点，同时表示子节点会被根节点吃；当距离d%3==0时，表示子节点与根节点同类。一个集合里面代表已经知道互相关系的动物编号。
 
 
 
 
难点:维护到根节点的距离同时路径压缩,结点到根节点的距离等于它到父节点的距离加上父节点到根节点的距离。
 
注意点：对每次询问前要做一次路径压缩，更新各节点到根节点的距离。
 
再分析：1.当给出x与y是同类时，如果x与y存在捕食关系，则为假话。如果x，y关系未知，就要合并到一个集合并且让他们是同类。将x所属集合“粘”到y所属的集合上，同时要求x的根节点到新根节点的距离d1=d[x]-d[y]。
 
值得注意的是在做完这个操作后，px应该等于py，但是d[x]貌似还等于它到原来的px的距离。事实上，要更新d[x]，就需要对x节点做一次路径压缩，而这个操作会在下一次遇到这个x，y时，在最开始开始赋值px=find(x),py=find(y)时完成。因为我们并不马上用到d[x];
 
 
 2.当给出x吃y时,若在一个集合内,则可以直接判断出关系。若不在一个集合内，则是真话，要合并x，y到一个集合。要求px到新的根节点的距离d1=d[y]-d[x]+1;
 
 
实现:
 
//这里填你的代码^^
#include
using namespace std;

const int N =50010;
int p[N],d[N];
int n,m;
//到根节点距离模3为0，同类；为1 吃根节点；为2 被根节点吃

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 res=0;
    while(m--)
    {
        int op,x,y;
        cin>>op>>x>>y;
        if(x>n||y>n)  res++;//越界
        else
        {
            int px=find(x),py=find(y);//对每次询问前做一次路径压缩，同时更新上一次改变的d[x];
            if(op==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++;//若x吃y，则d[x]%3-d[y]%3==1
                else if(px!=py)
                {
                    p[px]=py;
                    d[px]=d[y]-d[x]+1;
                }
            }
        }
    }
    cout< 
三、堆和堆排序 
  堆，是一个完全二叉树，一般有大根堆和小根堆。大根堆指每一个根节点的元素，都是它所属的子树的最大值。小根堆则是最小值。
 
 
down是向下调整，up是向上调整。
 
1.要插入一个值就把它放到最后面，然后向上调整。
 
2.删除最小值，即删除根节点，就把根节点用最后一个值覆盖，然后向下调整；
 
3.删除或者修改任意元素类似。
 
4.把一个数组构建成堆，需要找到最后一个非叶节点，即n/2（在下标为1开始时是n/2，为0开始是n/2 -1），从后往前对每一个元素down一遍。
 
1.堆排序 
  堆排序思想是，运用一个小根堆。 每一次输出最小值，然后删除最小值。直到堆为空
 
//这里填你的代码^^
#include
using namespace std;
const int N =100010;
int n,m;
int h[N],cnt;
void down(int u)//下标为u处向下调整 直至找到初始h[u]所在的位置
{
    int t=u;
    if(u*2<=cnt&&h[t]>h[u*2]) t=u*2;
    if(u*2+1<=cnt&&h[t]>h[u*2+1])  t=u*2+1;
    //h[t]为三个数中最小值 
    if(u!=t)
    {
        swap(h[u],h[t]);
        down(t);
    }
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)//堆从1开始构建
    cin>>h[i]; cnt=n;//记得赋值cnt
    for(int i=n/2;i>=1;i--) down(i);//构建堆

    while(m--)
    {
        cout< 
2.模拟堆 
 
 题目中第4,5个操作值得注意。为了知道第k个插入的数在堆中的下标，我们需要ph数组，以及在调整过程中动态改变ph数组，我们需要hp数组指示堆中以j为下标的数是第几个插入的数。
 
 
 因此，交换堆中两个元素的函数会变的不一样。
 
//这里填你的代码^^
#include
#include
#include
using namespace std;
const int N =100010;
int h[N],ph[N],hp[N],cnt;
//ph是第k个插入的点在 堆中的下标 hp是堆中下标为k的点是第j个插入的点
void heap_swap(int a,int b)
{
    swap(ph[hp[a]],ph[hp[b]]);//首先第a，b个插入的数在堆中的下标需要交换；而找到a，b是第几个插入的数需要用到hp
    swap(hp[a],hp[b]);//通过hp交换ph之后，a，b的hp需要交换，因为各自ph的交换
    swap(h[a],h[b]);//最后交换堆中下标为a，b的值（但是一切的起因）
}

void down(int u)
{
    int t=u;
    if(u*2<=cnt&&h[u*2]>=1;//ΔΔΔ
    }
}
int main()
{
    int n,m=0;//m是用到了第m个数
    cin>>n;
    int k,x;
    while(n--)
    {
        string op;
        cin>>op;
        if(op=="I") 
        {
            cin>>x;
            m++;
            h[++cnt]=x;
            ph[m]=cnt;hp[cnt]=m;
            up(cnt);
        }
        else if(op=="D")
        {
            cin>>k;
            k=ph[k];
            heap_swap(k,cnt);
            cnt--;
            up(k),down(k);
        }
        else if(op=="DM")
        {
            heap_swap(1,cnt);
            cnt--;
            down(1);
        }
        else if(op=="PM") cout<>k>>x;
            k=ph[k];
            h[k]=x;
            up(k),down(k);
        }
    }
}

作者：yankai
链接：https://www.acwing.com/activity/content/code/content/3446562/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。