Tire树 并查集 堆

已于 2023-03-02 14:22:39 修改
阅读量98 收藏
点赞数 2
分类专栏： 数据结构与算法 文章标签： 算法 c++ 数据结构
于 2023-02-23 18:01:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_71434369/article/details/129178846
版权
文章介绍了Tire树，一种用于高效存储和查找字符串集合的数据结构，以及并查集的基本概念和不同优化版本，包括朴素并查集、维护size的并查集和维护到祖宗结点距离的并查集。此外，还讨论了小根堆的基本操作，如插入、删除、修改和查找最小值。这些数据结构和算法常用于解决集合操作和优先级队列等问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Tire树及并查集


​

一 Tire树

Tire树：用于高效地存储和查找字符串集合的数据结构。
算法思想：用一个二维数组son[][]来存储每个结点的孩子，cnt[]来存放以某个结点为结尾的单词的个数，idx表示当前用到了哪个结点
基本操作：
1 .插入字符串

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;//如果当前结点p不存在u这个孩子，则创造一个
        p = son[p][u];//p指向下一个结点
    }
    cnt[p]++;//将以点p为结尾的单词的个数加1
}

2. 查询字符串的个数

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不存在u这个孩子的话，则不存在这个单词，返回0
        p = son[p][u];//p指向下一个结点
    }
    return cnt[p];//输出以点p为结尾的单词的个数
}

代码实例：

输入：

5

I abc

Q abc

Q ab

I ab

Q ab

输出：

1 0 1

#include<iostream>
#include<algorithm>
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<string>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<ctype.h>
#include<iomanip>
#include<fstream>
#include<ctime>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
using namespace std;
#define endl '\n'
#define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef long long ll;
const int N = 1e3 + 10, null = 0x3f3f3f3f,M=2*N;
const double eps=1e-6;
int son[N][26];//由于每个结点最多有26个孩子，A-Z
int cnt[N];//记录以某个结点为结尾的单词的个数，即字符串的个数
int idx;//表示当前用到了哪个点
int t;
char str[N];//用来存储字符串
void insert(char a[])
{
	int p=0;//从头结点开始
	for(int i=0;a[i];i++)//遍历该字符串所有字符
	{
		int u=a[i]-'a';//求出每个字符对应的编号
		if(!son[p][u]) son[p][u]=++idx;//如果结点p不存在u这个儿子的话，则创建一个
		p=son[p][u];//p指向下一个结点
	}
	cnt[p]++;//以结点p结尾的单词的个数加一
}
int query(char a[])
{
	int p=0;//从头结点开始
	for(int i=0;a[i];i++)//遍历该字符串的所有字符
	{
		int u=a[i]-'a';//求出每个字符对应的编号
		if(!son[p][u]) return 0;//如果结点p不存在u这个儿子的话，说明不存在这个字符串，这个字符串的个数为0，函数返回0
		p=son[p][u];//p指向下一个结点
	}
	return cnt[p];//返回以结点p为结尾的单词的个数
}
int main()
{
	cin>>t;
	while(t--)
	{
		char op[2];//将单个字符作为字符串进行读入，可以避免读入一些奇奇怪怪的东西
		scanf("%s%s",op,str);
		if(op[0]=='I') insert(str);	
		else 
		{
			int ans=query(str);//输出该字符串的个数
			printf("%d\n",ans);
		}		
	}
	return 0;
}

二 并查集

主要用处：

  1. 将两个集合合并

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

基本原理：

每个集合用一棵树来表示，树根的编号就是整个集合的编号，每个结点存储它的父结点。p[x]表示结点x的父结点。
基本操作：
1 .判断树根

if (p[x] == x)//结点x的父结点等于x，说明x是树根`

2. 求集合x的编号

while (p[x] != x) x = p[x];//只要x的父结点不等于x，x就一直向上走

1.朴素并查集

int p[N]; //存储每个点的父节点

// 返回x的祖宗节点，核心操作
int find(int x)
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}
// 初始化，假定节点编号是1~n
for (int i = 1; i <= n; i ++ ) p[i] = i;//初始时每个节点的父结点就是本身自己

// 合并a和b所在的两个集合：
p[find(a)] = find(b);

2. 维护size的并查集

int p[N], size[N];
//p[]存储每个结点的父节点, size[]只有祖宗节点的有意义，表示祖宗节点所在集合中的元素的个数

// 返回x的祖宗节点
int find(int x)
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

// 初始化，假定节点编号是1~n
for (int i = 1; i <= n; i ++ )
{
    p[i] = i;
    size[i] = 1;//初始时，每个点所在的集合中只有本身一个点，因此数目为1
}

// 合并a和b所在的两个集合：
p[find(a)] = find(b);
size[find(b)] += size[find(a)];

3.维护到祖宗结点距离的并查集

int p[N], d[N];
//p[]存储每个点的父节点, d[x]存储x到根节点的距离

// 返回x的祖宗节点
int find(int x)
{
    if (p[x] != x)
    {
        int u = find(p[x]);
        d[x] += d[p[x]];
        p[x] = u;
    }
    return p[x];
}

// 初始化，假定节点编号是1~n
for (int i = 1; i <= n; i ++ )
{
    p[i] = i;
    d[i] = 0;
}

// 合并a和b所在的两个集合：
p[find(a)] = find(b);
d[find(a)] = distance; // 根据具体问题，初始化find(a)的偏移量

**小技巧**：
如果读入一个字母的话，可以将其当做字符串用scanf进行读入，可以过滤掉空格和回车，比较方便。

代码示例：

输入：

4 5

M 1 2

M 3 4

Q 1 2

Q 1 3

Q 3 4

输出：yes no yes

#include<iostream>
#include<algorithm>
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<string>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<ctype.h>
#include<iomanip>
#include<fstream>
#include<ctime>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
using namespace std;
#define endl '\n'
#define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef long long ll;
const int N = 1e3 + 10, null = 0x3f3f3f3f,M=2*N;
const double eps=1e-6;
int n,t;
int p[N];
int find(int x)
{
	if(p[x]!=x) p[x]=find(p[x]);
	return p[x];
}
int main()
{
	scanf("%d%d",&n,&t);
	for(int i=1;i<=n;i++) p[i]=i;
	while(t--)
	{
		char op[2];
		int a,b;
		scanf("%s%d%d",op,&a,&b);
		if(op[0]=='M') p[find(a)]=find(b);
		else 
		{
			if(find(a)==find(b)) puts("YES");
			else puts("NO");
		}
	}
	return 0;
}

代码实例2：
数组sz[]表示每个结点的祖宗结点所在集合中元素的个数。

输入：5 5

C 1 2

Q1 1 2

Q2 1

C 2 5

Q2 5

输出：YES 2 3

#include<iostream>
#include<algorithm>
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<string>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<ctype.h>
#include<iomanip>
#include<fstream>
#include<ctime>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
using namespace std;
#define endl '\n'
#define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef long long ll;
const int N = 1e3 + 10, null = 0x3f3f3f3f,M=2*N;
const double eps=1e-6;
int n, m;
int p[N];//存储每个结点的父结点
int sz[N];//存储每个结点所在结合中元素的个数
int find(int x)//返回结点x的祖宗结点，即结点x所在集合的根节点
{
	if (p[x] != x) p[x] = find(p[x]);
	return p[x];
}//核心操作
int main()
{
	scanf("%d%d",&n,&m);
	for (int i = 1; i <= n; i++)
	{
		p[i] = i;//每个集合中只有一个结点，该结点就是父结点，
		sz[i] = 1;//由于每个集合当中只有一个点，因此这个结点的祖宗结点就是自己本身，因此这个点的祖宗结点所在集合中元素的个数为1
	}//初始化
	while (m--)
	{
		char op[5];
		scanf("%s",op);//作为字符串进行读入，可以过滤掉回车和空格
		int a, b;
		if (op[0] == 'C')
		{
			scanf("%d%d",&a,&b);
			if (find(a) == find(b)) continue;//如果结点a和结点b在一个集合当中
			sz[find(b)] += sz[find(a)];//结点b的祖宗结点所在集合的元素个数加上结点a的祖宗结点所在集合的元素个数
			p[find(a)] = find(b);//结点a所在集合当中的根节点的父结点等于结点b所在集合当中的根节点，即将集合a连接在结合b之后
		}
		else if (op[1] == '1')
		{
			scanf("%d%d",&a,&b);
			if (find(a) == find(b)) puts("YES");//如果a和b在一个集合当中，输出yes，否则输出no
			else puts("NO");
		}
		else
		{
			scanf("%d",&a);
			printf("%d\n",sz[find(a)]);//输出结点a的祖宗结点所在集合当中的元素个数
		}
	}
	return 0;
}

三. 堆

小根堆

基本操作：
1.插入：
heap[++size] = x; up(size);
2.求最小值
求集合当中的最小值：heap[1];
3.删除
删除最小值：
heap[1] = heap[size]; size–; down(1);
删除任意一个元素：
heap[k] = heap[size]; size–; down[k]; up[k];
4.修改
修改任意一个元素：
heap[k] = x; down[k]; up[k];
// h[N]存储堆中的值, h[1]是堆顶，x的左儿子是2x, 右儿子是2x + 1
// ph[k]存储第k个插入的点在堆中的下标
// hp[k]堆中下标为k的点是第几个插入的
int h[N], ph[N], hp[N], size;
5.交换
// 交换两个点，及其映射关系
void heap_swap(int a, int b)
{
swap(ph[hp[a]],ph[hp[b]]);
swap(hp[a], hp[b]);
swap(h[a], h[b]);
}
**6.建堆：**时间复杂度为o（n）
for (int i = n / 2; i; i–) down(i);
核心：
1.down()操作：

**void down(int u)
{
	int t = u;//用t存储三个点里最小的那个点的下标
	if (u * 2 <= ans && h[u * 2] < h[t]) t = u * 2;//如果左儿子存在的话并且左儿子的值小，则更新t
	if (u * 2 + 1 <= ans && h[u * 2 + 1] < h[t]) t = u * 2 + 1;//如果右儿子存在的话并且右儿子的值小的话，则更新t
	if (t != u)//如果t不等于u的话，说明根节点不是最小值，则将二者的值进行交换
	{
		heap_swap(u,t);
		down(t);//递归处理
	}
}**

2.up操作：

**void up(int u)
{
	while (u / 2 && h[u / 2] > h[u])//只要父结点存在并且父结点的值比当前结点的值大的话，就进行交换
	{
		heap_swap(u,u/2);
		u /= 2;
	}
}**

输入：
10
I -10
PM
I -10
D
C 2 8
I 6
PM
DM

输出：

-10 6
代码实例：

#include<iostream>
#include<vector>
#include<set>
#include<stack>
#include<queue>
#include<algorithm>
#include<string>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<ctype.h>
using namespace std;
#define endl '\n'
#define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
typedef pair<int, int> PII;
typedef long long ll;
const int N = 1e6 + 10;
int h[N];
int ph[N];
int hp[N];
int ans;
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;//用t存储三个点里最小的那个点的下标
	if (u * 2 <= ans && h[u * 2] < h[t]) t = u * 2;//如果左儿子存在的话并且左儿子的值小，则更新t
	if (u * 2 + 1 <= ans && h[u * 2 + 1] < h[t]) t = u * 2 + 1;//如果右儿子存在的话并且右儿子的值小的话，则更新t
	if (t != u)//如果t不等于u的话，说明根节点不是最小值，则将二者的值进行交换
	{
		heap_swap(t, u);
		down(t);//递归处理
	}
}
void up(int u)
{
	while (u / 2 && h[u / 2] > h[u])//只要父结点存在并且父结点的值比当前结点的值大的话，就进行交换
	{
		heap_swap(u, u/2);
		u /= 2;
	}
}
int main()
{
	int n;
    scanf("%d",&n);
	int res = 0;
	while (n--)
	{
		char op[5];
		scanf("%s", op);//作为字符串用scanf进行读入，可以忽略空格和回车
		int k, x;
		if (!strcmp(op,"I"))//插入
		{
			scanf("%d",&x);
			res++;
			h[++ans] = x;
			ph[res] = ans;
			hp[ans] = res;
			up(ans);
		}
		else if (!strcmp(op, "PM"))//求最小值
		{
			printf("%d\n",h[1]);
		}
		else if (!strcmp(op, "D"))//删除最小值
		{
			heap_swap(1, ans);
			ans--;
			down(1);
		}
		else if (!strcmp(op, "C"))//修改第k个插入的点
		{
			scanf("%d%d",&k,&x);
			k = ph[k];
			h[k] = x;
			down(k);
			up(k);
		}
		else//删除第k个插入的点
		{
			scanf("%d",&k);
			k = ph[k];
			heap_swap(k, ans);
			ans--;
			down(k);
			up(k);
		}
	}
	return 0;
}

​

KMP字符串匹配+Tire树+并查集+堆+哈希表+字符串哈希
lihua777的博客
02-11 952
acwing(4)
算法基础复盘笔记Day04【数据结构】—— KMP、字典树（Tire）、并查集、堆、哈希表
Java技术一点通
03-18 1942
并查集是一种树形的数据结构。并查集支持的两个操作：合并：将两个子集合并成一个集合。查找：确定某个元素在哪个集合。带路径压缩的查找：根节点是集合的代表，查找就是找到元素所在集合的根。1. 如果父节点等于自己，则找到了根并返回；2. 如果还没有找到根，则继续递归查找；3. 在返回的路上，顺带修改各节点的父节点为根。
算法笔记5.Tire树，并查集，堆
fadaoge的博客
03-21 342
并查集就是一个用来快速实现合并和查找根节点的数据结构，一般是一个树形结构是一个集合。合并是将两个集合合并为一个大集合，查找是看一个元素是不是这个集合的。堆是一个完全二叉树（左右都很满的那个），其中有一个特点，每个点的值都小于等于左右两个子节点的值基本操作是插入新元素，查找最小节点，删除最小节点，删除任意一个元素，修改任意一个元素。
tire树的存储和并查集
秋名山码民的技术小屋
01-05 1659
tire树+并查集
trie树、并查集、堆
m0_64372178的博客
07-30 92
AcWing学习笔记
数据结构---Tire、并查集、堆
一名混沌的大学生
01-02 189
Tire、并查集、堆
Trie 树、并查集、堆
weixin_60569662的博客
05-22 359
Trie 树 用来高效地存储和查找字符串集合的数据结构 假设要在 Tire 树中存储以下字符串：都是大写字母、都是小写字母、都是数字，字母的类型不会很多 从根节点开始，从前往后依次遍历每一个字符 ......
字典树/并查集/堆
Ameriy的博客
07-30 70
字典树/并查集/堆的结构以及操作的代码实现
算法基础课（五）＜Tire树，并查集，堆＞
qq_43399648的博客
07-21 260
1.Tire树 高效地存储和查找字符串集合的数据结构 eg: #include <iostream> using namespace std; const int N = 100010; int son[N][26],cnt[N],idx;//下标是0的点，既是根节点，又是空节点 char str[N]; void insert(char str[]) { int p = 0; for(int i = 0;str[i];i++) { int u = str[i] - 'a';
Tire 字典树 + 并查集 + 字符串哈希
向未来❀去探索 的博客
10-27 818
Tire 字典树 + 并查集 + 字符串哈希
tire树分析
03-17
**Trie树分析** 在计算机科学中，Trie树（又称前缀树或字典树）是一种用于存储关联数组的数据结构，特别适用于字符串查询。它通过将字符串的公共前缀组织在一起，使得查找效率得以显著提升。Trie树的主要特点是能够...
TIRE 字典树 论文
11-14
标题中的"TIRE字典树"实际上是指“Trie树”，也被称为前缀树或字典树，它是一种用于...通过阅读“Tire树”这篇论文，我们可以深入理解Trie树的工作原理，学习如何根据实际问题选择合适的数据结构，并从中获取优化策略。
【漫话机器学习系列】275.GrabCut 算法——用于去除图片背景（Grabcut For Removing Image Backgrounds）
IT古董
05-24 689
GrabCut 是由微软剑桥实验室于 2004 年提出的一种交互式图像前景分割算法。相比传统的图像分割方法，它的亮点是：支持用户轻松交互，只需简单画个矩形；基于高斯混合模型（GMM）与图割（Graph Cut）优化；分割效果细腻，适用于复杂背景下的图像处理。GrabCut 是一项结合图割与 GMM 的强大图像分割算法；通过手动圈定目标区域，就能自动判断前景与背景；适合中等难度的抠图任务，是 OpenCV 实战中的常用技能之一。
回调函数与qsort函数详解
jingfeng514的博客
05-23 353
如果你把函数的指针(地址)作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，被调用的函数就是回调函数。因为红色框中的代码，只有调用函数的逻辑是有差异的，我们可以把调用的函数的地址以参数的形式传递过去，使用函数指针接收，函数指针指向什么函数就调用什么函数，这里其实使用的就是回调函数的功能。第13讲中我们写的计算机的实现的代码中，红色框中的代码是重复出现的，其中虽然执行计算的逻辑是区别的，但是输入输出操作是冗余的，有没有办法，简化一些呢？1 指向要排序的第一个元素的指针（地址）
[C语言实战]深度解析C语言函数指针与回调机制(七)
曼岛_的博客
05-26 472
[C语言实战]深度解析C语言函数指针与回调机制(七)
JVM——垃圾回收
2301_81283571的博客
05-23 1285
本文详细介绍了Java垃圾回收机制的核心概念和实现方法。首先，文章解释了如何判断对象可以回收，包括引用计数法和可达性分析算法，并介绍了四种引用类型：强引用、软引用、弱引用和虚引用。接着，文章探讨了三种垃圾回收算法：标记清除、标记整理和标记复制，并分析了它们的优缺点。随后，文章介绍了分代垃圾回收机制，将堆内存划分为新生代和老年代，并详细描述了MinorGC的流程。此外，文章还介绍了六种常见的垃圾回收器，包括串行、并行和并发的垃圾回收器，并重点分析了CMS和G1垃圾回收器的工作原理和优缺点。最后，文章提供了垃圾
016搜索之广度优先BFS——算法备赛
最新发布
2401_82484471的博客
05-27 537
广度优先搜索是一种逐层遍历的方式，是图论，树论的基本搜索方式，在决策类问题上也有应用。 算法的关键是准备一个`节点队列`，每遍历一个节点将其所有未访问的子节点(或所有的邻接节点)入队，遍历完一个节点后及时从队列中出队。当队列为空遍历结束。 BFS作为基础搜索算法，其逐层扩散的特点在很多高级算法有着广泛的应用，如`Djstra`算法就是用优先队列实现的`BFS`。
DeepSeek 赋能智能安防：从算法革新到场景落地的全解析
邓邓子的博客
05-27 541
随着人工智能技术的快速发展，智能安防系统迎来了新的变革机遇。本文聚焦 DeepSeek 在智能安防系统中的应用，深入剖析其基于 Transformer 架构与混合专家架构的核心技术原理。详细阐述 DeepSeek 在智能监控预警、门禁身份识别、智能分析决策及系统运维优化等场景中的实践应用，结合智慧社区、智慧监狱等实际案例，展现其高精度识别、高效决策优势。同时，客观分析DeepSeek应用过程中面临的数据安全、算法优化等挑战，并对其与物联网、大数据融合的未来发展方向进行展望，为智能安防领域技术创新提供参考。
题目 3341: 蓝桥杯2025年第十六届省赛真题-抽奖
m0_75262437的博客
05-27 620
题目 3341: 蓝桥杯2025年第十六届省赛真题-抽奖时间限制: 2s 内存限制: 192MB 提交: 415 解决: 105题目描述LQ 商场为了回馈广大用户，为在此消费的用户提供了抽奖机会：抽奖机有三个转轮，每个转轮上都分布有 n 个数字图案，标号为 1 ∼ n ，按照从 1 到 n 顺序转动，当转到第 n 个图案时会从第一个继续开始。奖项如下：1）三个相同的图案，积分 +200；2）两个相同的图案，积分 +100；
全面解析全文检索引擎DEMO：技术实现与学习建议
向量模型的排名算法则是信息检索中的一个基础概念，其中最为人所知的是TF-IDF（词频-逆文档频率）权重算法，它用于评价一个词语对于一个文件集或一个语料库中的其中一份文件的重要程度，进而根据这个权重对结果进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值