并查集

并查集是一种可以动态地维护若干个不重叠的集合，并支持查询和合并的数据结构。

具体地说，并查集支持以下两种操作：

\(1.\) 查询某一个元素属于哪个集合

$2. $ 把两个集合合并为一个大集合

查询操作

我们可以用代表元法来查询集合。也就是说，对于每一个集合，我们指定一个元素为这个集合的代表元，这个集合的编号也就是这个元素的编号。

具体地说，我们用树形结构来存储集合，那么这一棵树的根节点就是这个集合的代表元。对于每一个点，我们记录下它的父亲节点，在查询集合时，只要不断向上找父亲节点，直到找到根节点，就是这个集合的编号，其时间复杂度为\(O(n)\)。

\(Code:\)

inline void find(int x)
{return f[x] == x ? x : find(f[x]);
}

合并操作

对于合并两个集合，在代表元法中也很容易实现。合并\((x,y)\)两个元素所在的集合，我们只需先分别找到两个元素的代表元，然后将一个代表元的父亲节点赋值为另一个代表元即可，其时间复杂度为\(O(n)\)。

\(Code:\)

inline void merge(int x,int y)
{int fx = find(x) , fy = find(y);if ( fx ^ fy ) f[fx] = fy;
}

路径压缩和启发式合并

并查集的两个基础操作很容易实现，但是其时间复杂的并不是很乐观，我们可以考虑如下两个优化：

\(1.\) 路径压缩：由于只涉及集合的合并操作，所以每一次查找父亲时考虑将路径上的每一个元素的父亲赋值为这个集合的代表元，这样对于重复的查询就可以避免浪费时间

\(2.\) 启发式合并：我们定义"秩"为一个集合的大小，那么在每一次合并操作时，我们将秩较小的集合合并到秩较大的集合中，这样对于新集合的查询操作就只增加了秩较小集合的查询复杂度

可以证明，这加入两种优化中的任意一种后，并查集的时间复杂度都是\(O(log_2n)\)(包括两种操作)，当两种操作同时运用时，其时间复杂度为\(O(\alpha(n))\)，近乎一个常数。

\(Code:\)

#include <bits/stdc++.h>
using namespace std;
const int N = 10020 , M = 200020;
int n,m,f[N],size[N];
inline void input(void)
{scanf("%d%d",&n,&m);
}
inline void init(void)
{for (int i=1;i<=n;i++)f[i] = i , size[i] = 1;
}
inline int find(int x)
{return f[x] == x ? x : f[x] = find(f[x]);
}
inline void merge(int x,int y)
{int fx = find(x) , fy = find(y);if ( fx ^ fy ){if ( size[fx] <= size[fy] ) f[fx] = fy , size[fy] += size[fx];if ( size[fx] > size[fy] ) f[fy] = fx , size[fx] += size[fy];}
}
inline void solve(void)
{int x,y,k;for (int i=1;i<=m;i++){scanf("%d%d%d",&k,&x,&y);if ( k == 1 ) merge(x,y);if ( k == 2 ) puts( find(x) == find(y) ? "Y" : "N" );}
}
int main(void)
{input();init();solve();return 0;
}

不过一般来说，我们使用路径压缩优化的并查集就完全够用了。

带边权的并查集

普通并查集中，我们将集合储存为一个树形结构，那么带边权的并查集就是在树形结构的每一条边上都记录了边权，在路径压缩后，就能用来反映一些元素和指定元素(代表元)之间的关系，其代码模板基本上是一样的，我们通过一道例题来了解一下。

银河英雄传说

Description

公元五八零一年，地球居民迁移至金牛座α第二行星，在那里发表银河联邦创立宣言，同年改元为宇宙历元年，并开始向银河系深处拓展。

宇宙历七九九年，银河系的两大军事集团在巴米利恩星域爆发战争。泰山压顶集团派宇宙舰队司令莱因哈特率领十万余艘战舰出征，气吞山河集团点名将杨威利组织麾下三万艘战舰迎敌。

杨威利擅长排兵布阵，巧妙运用各种战术屡次以少胜多，难免恣生骄气。在这次决战中，他将巴米利恩星域战场划分成30000列，每列依次编号为1, 2, …, 30000。之后，他把自己的战舰也依次编号为1, 2, …, 30000，让第i号战舰处于第i列(i = 1, 2, …, 30000)，形成“一字长蛇阵”，诱敌深入。这是初始阵形。当进犯之敌到达时，杨威利会多次发布合并指令，将大部分战舰集中在某几列上，实施密集攻击。合并指令为M i j，含义为让第i号战舰所在的整个战舰队列，作为一个整体（头在前尾在后）接至第j号战舰所在的战舰队列的尾部。显然战舰队列是由处于同一列的一个或多个战舰组成的。合并指令的执行结果会使队列增大。

然而，老谋深算的莱因哈特早已在战略上取得了主动。在交战中，他可以通过庞大的情报网络随时监听杨威利的舰队调动指令。

在杨威利发布指令调动舰队的同时，莱因哈特为了及时了解当前杨威利的战舰分布情况，也会发出一些询问指令：C i j。该指令意思是，询问电脑，杨威利的第i号战舰与第j号战舰当前是否在同一列中，如果在同一列中，那么它们之间布置有多少战舰。

作为一个资深的高级程序设计员，你被要求编写程序分析杨威利的指令，以及回答莱因哈特的询问。

最终的决战已经展开，银河的历史又翻过了一页……

Input Format

第一行有一个整数T（1 <= T <= 500,000），表示总共有T条指令。

以下有T行，每行有一条指令。指令有两种格式：

1. M i j ：i和j是两个整数（1 <= i , j <= 30000），表示指令涉及的战舰编号。该指令是莱因哈特窃听到的杨威利发布的舰队调动指令，并且保证第i号战舰与第j号战舰不在同一列。
2. C i j ：i和j是两个整数（1 <= i , j <= 30000），表示指令涉及的战舰编号。该指令是莱因哈特发布的询问指令。

Output Format

你的程序应当依次对输入的每一条指令进行分析和处理：

如果是杨威利发布的舰队调动指令，则表示舰队排列发生了变化，你的程序要注意到这一点，但是不要输出任何信息；

　如果是莱因哈特发布的询问指令，你的程序要输出一行，仅包含一个整数，表示在同一列上，第i号战舰与第j号战舰之间布置的战舰数目。如果第i号战舰与第j号战舰当前不在同一列上，则输出-1。

Sample Input

4
M 2 3
C 1 2
M 2 4
C 4 2

Sample Output

-1
1

解析

我们可以将每一列战舰看做一个集合，我们我们需要完成的操作就变成了并查集的操作。但是题目在\(C\)操作中还要求我们输出两个战舰之间的距离，这就需要用带边权的并查集来实现了。设\(d_x\)代表节点\(x\)到其所在集合代表元的距离，只需在路径压缩的把这个值记录下来，我们就能在查询后通过\(d\)数组相减得到答案。

当然，我们支持在合并操作后还能正确地维护\(d\)数组，我们还需记录下每一个集合的大小，在合并操作时利用\(size\)数组更新\(d\)数组即可。

\(Code:\)

#include <bits/stdc++.h>
using namespace std;
const int T=500020,N=30000;
int t,f[N+20],d[N+20],size[N+20];
inline int find(int x)
{if (f[x]==x)return x;int root = find(f[x]);d[x] += d[f[x]];return f[x] = root;
}
inline int merge(int x,int y)
{x = find(x) , y = find(y);f[x] = y , d[x] = size[y];size[y] += size[x];
}
inline void solve(void)
{scanf("%d",&t);for (int i=1;i<=N;i++)f[i] = i , size[i] = 1 ;for (int i=1;i<=t;i++){char op;int x,y;scanf("\n%c%d%d",&op,&x,&y);if (op=='M')merge(x,y);if (op=='C'){int fx = find(x) , fy = find(y);if (fx==fy)printf("%d\n",abs(d[x]-d[y])-1);else printf("%d\n",-1);}}
}
int main(void)
{solve();return 0;
}

拓展域的并查集

拓展域其实是一种并查集的运用思想，就是将并查集的一个节点拆为若干个节点，分别代表了不同的域。就是说，一个节点的多个信息，我们都用并查集来维护，那么就可以考虑运用并查集，其最重要的部分为思维转换，我们还是通过一道例题来了解。

关押罪犯

Description

S 城现有两座监狱，一共关押着N 名罪犯，编号分别为1~N。他们之间的关系自然也极不和谐。很多罪犯之间甚至积怨已久，如果客观条件具备则随时可能爆发冲突。我们用“怨气值”（一个正整数值）来表示某两名罪犯之间的仇恨程度，怨气值越大，则这两名罪犯之间的积怨越多。如果两名怨气值为c 的罪犯被关押在同一监狱，他们俩之间会发生摩擦，并造成影响力为c 的冲突事件。

每年年末，警察局会将本年内监狱中的所有冲突事件按影响力从大到小排成一个列表，然后上报到S 城Z 市长那里。公务繁忙的Z 市长只会去看列表中的第一个事件的影响力，如果影响很坏，他就会考虑撤换警察局长。

在详细考察了N 名罪犯间的矛盾关系后，警察局长觉得压力巨大。他准备将罪犯们在两座监狱内重新分配，以求产生的冲突事件影响力都较小，从而保住自己的乌纱帽。假设只要处于同一监狱内的某两个罪犯间有仇恨，那么他们一定会在每年的某个时候发生摩擦。那么，应如何分配罪犯，才能使Z 市长看到的那个冲突事件的影响力最小？这个最小值是多少？

Input Format

输入文件的每行中两个数之间用一个空格隔开。

第一行为两个正整数N 和M，分别表示罪犯的数目以及存在仇恨的罪犯对数。

接下来的M 行每行为三个正整数aj，bj，cj，表示aj 号和bj 号罪犯之间存在仇恨，其怨气值为cj。数据保证1<=aj<bj<N,0<cj<=1,000,000,000 且每对罪犯组合只出现一次。

Output Format

输出共1 行，为Z 市长看到的那个冲突事件的影响力。如果本年内监狱中未发生任何冲突事件，请输出0。

Sample Input

4 6
1 4 2534
2 3 3512
1 2 28351
1 3 6618
2 4 1805
3 4 12884

Sample Output

3512

解析

我们可以先考虑贪心的思想，将每一个冲突事件先按影响力从大到小排序，然后依次处理每一个冲突事件，尽量使得这个事件不发生。当处理到某个事件一定会发生时，这个事件的影响力就是最小的最大影响力。

那么如何处理这些事件呢？我们用拓展域的并查集来维护：节点\(x\)所在的集合代表包含了所有与\(x\)在同一监狱的元素，节点\(x'\)所代表的集合包含了所有与\(x\)不在同一监狱的元素。对于事件\((x,y)\)，我们合并\((x,y')\)，\((x',y)\)，就是尽量分开\(x\)和\(y\)。当\((x,y)\)已经已经在同一集合时，这个事件就不可避免的发生了。

\(Code:\)

#include <bits/stdc++.h>
using namespace std;
const int N = 20020 , M = 100020;
int n,m,f[N<<1];
struct criminal
{int x,y,val;
}a[M];
inline void input(void)
{scanf("%d%d",&n,&m);for (int i=1;i<=m;i++)scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].val);
}
inline int find(int x)
{return f[x] == x ? x : f[x] = find(f[x]);
}
inline void merge(int x,int y)
{int fx = find(x) , fy = find(y);if ( fx ^ fy ) f[fx] = fy;
}
inline bool compare(criminal p1, criminal p2)
{return p1.val > p2.val;
}
inline void solve(void)
{for (int i=1;i<=n*2;i++)f[i] = i;for (int i=1;i<=m;i++){if ( find(a[i].x) == find(a[i].y) ){printf("%d\n",a[i].val); exit(0);}merge( a[i].x , a[i].y + n );merge( a[i].y , a[i].x + n );}
}
int main(void)
{input();sort( a+1 , a+m+1 , compare );solve();puts("0");return 0;
}