Trie、并查集、堆

目录

Trie

并查集 

操作 

基本原理

关键

 堆

---

Trie

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

#include <iostream>
using namespace std;
const int N = 1e5+ 10;
//son[N][26]每个节点的子节点最多有26个，cnt[]表示以当前这个点为结尾的字符串个数
int son[N][26], cnt[N], idx; //idx是当前用到的下标，下标是0的点，既是根节点，又是空节点
char str[N];

void insert(char str[]) {
	int p = 0; //从根节点开始遍历，不存在就创建
	for (int i = 0; str[i]; i++) {
		int u = str[i] - 'a'; //将a~z映射成0~25
		if (!son[p][u])
			son[p][u] = ++idx; //如果节点p不存在u的子节点，就创建出来
		p = son[p][u]; //节点p转换成当前节点，循环结束后p为最后一个节点
	}
	cnt[p]++;//以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;//不存在u的节点，返回0
		p = son[p][u];
	}
	return cnt[p];
}

int main() {
	int n;
	cin >> n;
	while (n--) {
		char op;
		cin >> op>>str;
		if (op == 'I')  insert(str);
        else cout << query(str) << endl;
	}
	return 0;
}

并查集 

操作 

1.将两个集合合并

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

基本原理

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

关键

1.如何判断树根？if(p[x]==x)除了根节点，其他节点都不等于它本身

2.如何求x的集合编号？while(p[x]!=x) x=p[x];往上走，找到根节点 可以优化——路径压缩（当x找到根节点，就将查找路径上所有的节点直接指向根节点）

3.如何合并两个集合？假设p[x]是x的集合编号（根节点），p[y]是y的集合编号，p[p[x]]=p[y];

#include<iostream>
using namespace std;
const int N=1e5+10;
int p[N];
int n,m;
int find(int x)//返回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;
    while(m--)
    {
        char op;
        int a,b;
        cin>>op>>a>>b;
        if(op=='M') p[find(a)]=find(b);
        else
        {
            if(find(a)==find(b)) cout<<"Yes"<<endl;
            else cout<<"No"<<endl;
        }
    }
    return 0;
}

 堆

堆要支持哪些操作？

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

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

3.删除最小值 heap[1]=heap[size];size--;down(1);（将heap[size]删除，删除数组最后一个元素比第一个元素容易）

4.删除任意一个数 heap[k]=heap[size];size--;down(k);up(k);（虽然down(k)与up(k)都写了，但实际上只会执行一个）

5.修改任意一个数 

（4和5STL没有办法直接实现）

 以上操作是在小根堆（每个节点都小于它的子节点）的基础上，一维数组的下标从1开始比较好

#include<iostream>
using namespace std;
const int N=1e5+10;
int h[N],s;
void down(int u)
{
    int t=u;
    if(u*2<=s&&h[t]>h[u*2]) t=u*2;//与左儿子比较
    if(u*2+1<=s&&h[t]>h[u*2+1]) t=u*2+1;
    if(u!=t)
    {
        swap(h[u],h[t]);
        down(t);
    }
}
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>h[i];
    s=n;
    for(int i=n/2;i;i--) down(i);//可以降低时间复杂度
    while(m--)
    {
        cout<<h[1]<<" ";
        h[1]=h[s];
        s--;
        down(1);
    }
    return 0;
}

//up操作
void up(int u)
{
    while(u/2&&h[u/2]>h[u])
    {
        swap(h[u/2],h[u]);
        u/=2;
    }
}

#include<iostream>
using namespace std;
const int N=1e5+10;
int h[N],ph[N],hp[N],s;//ph[k]表示第k个节点的下标
//p——下标，h——堆，ph表示下标映射到堆，hp表示堆映射到下标
void heap_swap(int a,int b)
{
    swap(ph[hp[a]],ph[hp[b]]);
    swap(hp[a],hp[b]);
    swap(h[a],h[b]);
}
void down(int u)
{
    int t=u;
    if(u*2<=s&&h[u*2]<h[t]) t=2*u;
    if(u*2+1<=s&&h[u*2+1]<h[t]) t=2*u+1;
    if(u!=t)
    {
        heap_swap(u,t);
        down(t);
    }
}
void up(int u)
{
    while(u/2&&h[u/2]>h[u])
    {
        heap_swap(u/2,u);
        u/=2;
    }
}
int main()
{
    int n,m=0;
    cin>>n;
    while(n--)
    {
        string op;
        int k,x;
        cin>>op;
        if(op=="I")
        {
            cin>>x;
            s++;
            m++;
            ph[m]=s,hp[s]=m;
            h[s]=x;
            up(s);
        }
        else if(op=="PM") cout<<h[1]<<endl;
        else if(op=="DM")
        {
            heap_swap(1,s);
            s--;
            down(1);
        }
        else if(op=="D")
        {
            cin>>k;
            k=ph[k];//找到第k个插入的数的下标
            heap_swap(k,s);
            s--;
            down(k),up(k);
        }
        else
        {
            cin>>k>>x;
            k=ph[k];
            h[k]=x;
            down(k),up(k);        
        }
    }
    return 0;
}