并查集 - 标签 - 菠菜眾長https://lruihao.cn/tags/%E5%B9%B6%E6%9F%A5%E9%9B%86/并查集 - 标签 - 菠菜眾長Hugo -- gohugo.iozh-CN1024@lruihao.cn (Lruihao)1024@lruihao.cn (Lruihao)Thu, 02 Aug 2018 11:10:37 +0000食物链-poj1182（带权并查集经典模板）https://lruihao.cn/posts/poj1182/Thu, 02 Aug 2018 11:10:37 +0000Lruihaohttps://lruihao.cn/posts/poj1182/题目链接
思路参考 1,思路参考 2（没看懂）

先占坑，有时间再理理思路。

同一棵树中

d=1, 即 x 和 y 是同类，则需满足 r[x]==r[y]
d=2,x 应该吃了 y, 也就是 (r[x]+1)%3 == r[y]

不同树合并且更新关系 (x 树做主根)
’ 如果 x 和 y 为关系 r1, y 和 z 为关系 r2， 那么 x 和 z 的关系就是（r1+r2）%3

如果 d==1 则 x 和 y 是同类 ，那么 y 对 x 的关系是 0, 如果 d==2 , 则 x 吃了 y, 那么 y 对 x 的关系是 1, x 对 y 的关系是 2。综上所述 , 无论 d 为 1 或者是为 2, y 对 x 的关系都是 d-1。
fy 对 y 的关系为 3-r[y] （有点互补的感觉，注意这里是不同类喔）
y 对 x 的关系为 d-1,
x 对 fx 的关系为 r[x]
所以 fy 对 fx 的关系是（3-r[y] + d-1 + r[x]）%3。可以借助向量图理解 fy->y->x->fx 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#include<cstdio>

const int maxn = 50000+10;

int p[maxn]; //存父节点
int r[maxn];//存与父节点的关系 0 同一类，1 被父节点吃，2 吃父节点

void set(int n) //初始化
{
    for(int x = 1; x <= n; x++)
    {
        p[x] = x; //开始自己是自己的父亲节点
        r[x] = 0;//开始自己就是自己的父亲，每一个点均独立
    }
}

int find(int x) //找父亲节点
{
    if(x == p[x]) return x;

    int t = p[x];
    p[x] = find(p[x]);
    r[x] = (r[x]+r[t])%3; //回溯由子节点与父节点的关系和父节点与根节点的关系找子节点与根节点的关系
    return p[x];
}

void Union(int x, int y, int d)
{
    int fx = find(x);
    int fy = find(y);

    p[fy] = fx; //合并树 注意：被 x 吃，所以以 x 的根为父
    r[fy] = (r[x]-r[y]+3+(d-1))%3; //对应更新与父节点的关系
}

int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    set(n);

    int ans = 0;
    int d, x, y;
    while(m--)
    {
        scanf("%d%d%d", &d, &x, &y);

        if(x > n || y > n || (d == 2 && x == y)) ans++; //如果节点编号大于最大编号，或者自己吃自己，说谎

        else if(find(x) == find(y)) //如果原来有关系，也就是在同一棵树中，那么直接判断是否说谎
        {
            if(d == 1 && r[x] != r[y]) ans++; //如果 x 和 y 不属于同一类
            if(d == 2 && (r[x]+1)%3 != r[y]) ans++; // 如果 x 没有吃 y （注意要对应 Uinon(x, y) 的情况，否则一路 WA 到死啊！！！)
        }
        else Union(x, y, d); //如果开始没有关系，则建立关系
    }
    printf("%d\n", ans);
    return 0;
}
]]>小希的迷宫-HDU-1272（并查集 or 树性质）https://lruihao.cn/posts/hdu1272/Wed, 01 Aug 2018 21:45:50 +0000Lruihaohttps://lruihao.cn/posts/hdu1272/题目链接：小希的迷宫

并查集：

  • 无回路
  • 单连通

并查集做，首先想到的是判断两个点是否连通，不连通就合并，已连通的话说明会形成回路，则可以判定 No，交了一发错了。
想了一下没有考虑到多个连通域的情况，该题必须只有一个连通域

树的性质：

既然单连通无回路，则这肯定是一棵树；那么 edge=v-1;

最后注意空树的情况，至于自环我这里 No 也过了，没有去验证自环 Yes 的情况了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

//并查集
#include<bits/stdc++.h>
using namespace std;

int pre[100001];

int find(int root){
    int son,t;
    son=root;
    while(root!=pre[root])
        root=pre[root];
    while(son!=root){
        t=pre[son];
        pre[son]=root;
        son=t;
    }
    return root;
}

void join(int a,int b){
    int x=find(a),y=find(b);
    if(x!=y)
        pre[y]=x;
}

int main(){
    int a,b,flag,i,sum;
	while(1)
	{
		flag = 0;
		while(~scanf("%d%d",&a,&b) && a!=0 && b!=0){
			if(a==-1 && b==-1) return 0;
            if(pre[a]==0)pre[a]=a;
			if(pre[b]==0)pre[b]=b;
			if(find(a)==find(b))flag = 1;
			else if(flag!=1)
			join(a,b);
		}
        for(sum = 0,i=1;i<100001;i++){
            if(pre[i]==i)sum++;
            pre[i] = 0;
        }
        if(sum>1 || flag == 1)
			printf("No\n");
        else
			printf("Yes\n");
	}
}
//1 2 3 4 0 0 No 没有连通
//0 0 Yes
//1 1 0 0 No（该代码）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

//树性质
#include <stdio.h>
bool s[100001];
int main()
{	int a,b,i,len,num,v;
	for(i=0;i<100001;++i)	s[i]=false;
	len=0,num=0,v=0;
	while(1)
	{	scanf("%d%d",&a,&b);
		if(a==-1&&b==-1)	break;
		if(a==0&&b==0)
		{	if(v==0)
			{	printf("Yes\n");
				continue;
			}
			if(num==len-1)	//划重点！！
				printf("Yes\n");
			else printf("No\n");

			num=len=v=0;
			for(i=0;i<100001;++i)
				s[i]=false;
			continue;
		}
		v=1;
		if(s[a]==false)		len++;//点数
		if(s[b]==false)		len++;
		s[a]=s[b]=true;
		num++;//边数
	}
	return 0;
]]>How Many Answers Are Wrong-hdu3038（带权并查集）https://lruihao.cn/posts/hdu3038/Wed, 01 Aug 2018 11:45:53 +0000Lruihaohttps://lruihao.cn/posts/hdu3038/题目链接：How Many Answers Are Wrong
思路参考：本题直接参考,图文解释

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include<bits/stdc++.h>
using namespace std;

typedef long long LL;
int pre[200010],ranks[200010];

int find(int root){
    if(pre[root] != root)
    {
        int f = pre[root];
        pre[root] = find(pre[root]);//递归路径压缩
        ranks[root] += ranks[f];
        /*精髓假如一开始没关系，那么用 rank 数组来表示 a，b 各自到各自祖先的距离。
        那么在把 a 的祖先给 b 的祖先当父亲之后，那么 b 到祖先的距离也就是 rank[b] 就要再加上 b 原本的祖先到 a 的祖先的距离，更新一下，
        其中 find 函数（找根节点的函数）里 rank[x]+=rank[pre[x]]（这里 pre 数组存的是对应数的父节点）*/
    }
    return pre[root];
}

int main(){
    int n,m;
    while(~scanf("%d%d",&n,&m)){
        int ans=0;
        for(int i=1; i<=n; i++)
            pre[i]=i;
        memset(ranks,0,sizeof(ranks));
        while(m--){
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            a--;//[a,b]~~(a--,b]
            int fa=find(a);
            int fb=find(b);
            if(fa!=fb){
                pre[fb]=fa;//注意合并顺序，反过来下面的也要改
                ranks[fb]=ranks[a]-ranks[b]+c;//更新距离
            }
            else {
                if(ranks[b]-ranks[a]!=c)
                    ans++;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}
]]>how many tables-HDU-1213（并查集求连通域数目）https://lruihao.cn/posts/how-tables/Tue, 31 Jul 2018 11:12:10 +0000Lruihaohttps://lruihao.cn/posts/how-tables/并查集求连通域数目，初始化 sum=n； 题目链接： how many tables

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#include<bits/stdc++.h>
using namespace std;

int pre[1005];

int find(int root){
    int son,t;
    son=root;
    while(root!=pre[root])
        root=pre[root];
    while(son!=root){
        t=pre[son];
        pre[son]=root;
        son=t;
    }
    return root;
}

int main(){
    int n,m,t,sum,root1,root2;
    cin>>t;
    while(t--){
        cin>>n>>m;
        sum=n;
        for(int i=1;i<=n;i++)
            pre[i]=i;
        for(int i=0;i<m;i++){
            cin>>root1>>root2;
            int xx=find(root1);
            int yy=find(root2);
            if(xx!=yy){
                pre[xx]=yy;
                sum--;
            }
        }
        cout<<sum<<endl;
    }
	return 0;
}
]]>The-suspects-POJ-1611（并查集）https://lruihao.cn/posts/poj-1611/Tue, 31 Jul 2018 11:11:31 +0000Lruihaohttps://lruihao.cn/posts/poj-1611/题目链接：The-suspects

翻译：

警察抓贩毒集团。有不同类型的犯罪集团，人员可能重复，集团内的人会相互接触。现在警察在其中一人（0 号）身上搜出毒品，认为与这个人直接接触或通过其他人有间接接触的人都是嫌疑犯。问包括 0 号犯人共有多少嫌疑犯？

Input

多样例输入。
每个测试用例以两个整数 n 和 m 开头，其中 n 为人数，m 为犯罪集团数。你可以假定 0 < n <= 30000 和 0 <= m <= 500。在所有的情况下，每个人都有自己独特的整数编号 0 到 n−1, 且 0 号是公认的嫌疑犯。
接下来 m 行输入，每个犯罪集团一行。每一行从一个整数 k 开始，它本身表示集团内成员的数量。按照成员的数量，在这个组中有 k 个整数表示人员。一行中的所有整数都被至少一个空格隔开。
n = 0 且 m = 0 时输入结束。

Output

对于每个样例，输出嫌疑犯人数。

Sample Input

100 4
2 1 2
5 10 13 11 12 14
2 0 1
2 99 2
200 2
1 5
5 1 2 3 4 5
1 0
0 0

Sample Output

4
1

这题也很好理解，AC 代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


#include<cstdio>

int pre[30010],x[30010];

int find(int root){
    int son,t;
    son=root;
    while(root!=pre[root])
        root=pre[root];
    while(son!=root){
        t=pre[son];
        pre[son]=root;
        son=t;
    }
    return root;
}

void join(int x,int y){
    int fx=find(x),fy=find(y);
    if(fx!=fy)
        pre[fy]=fx;
}

int main(){
    int n,m,i,k,sum;
    while(scanf("%d%d",&n,&m),n||m){
        sum=0;
        for(i=0;i<n;i++)
            pre[i]=i;
        while(m--){
            scanf("%d",&k);
            for(i=0;i<k;i++)
                scanf("%d",&x[i]);
            for(i=1;i<k;i++)
                join(x[i-1],x[i]);
        }

        for(i=0;i<n;i++)
            if(find(0)==find(i)) sum++;//再次查找并压缩路径，注不用 pre[i]
        printf("%d\n",sum);

    }
	return 0;
}
]]>wireless network-POJ-2236（并查集）https://lruihao.cn/posts/poj-2236/Tue, 31 Jul 2018 11:10:54 +0000Lruihaohttps://lruihao.cn/posts/poj-2236/题目链接：wireless network

翻译：

南亚发生了一次地震。ACM (Asia Cooperated Medical 亚洲联合医疗队） 已经为膝上型电脑搭建了一个无线网络，但受到了一次不可预知的余震攻击，因此网络中的所有电脑都被破坏了。电脑被逐台修复，网络逐步恢复了工作。由于受到硬件的约束，每台电脑只能与距离它不超过 d 米的其它电脑直接通信。但每台电脑可被看作其它两台电脑的通信中转点，也就是说，如果电脑 A 和电脑 B 可以直接通信，或存在一台电脑 C 既可与 A 也可与 B 通信，那么电脑 A 和电脑 B 之间就能够通信。

在处理网络修复的过程中，工作人员们在任何一个时刻，可以执行两种操作：维修一台电脑，或测试两台电脑是否能够通信。请您找出全部的测试操作。

输入

第一行包含了两个整数 N 和 d (1 <= N <= 1001, 0 <= d <= 20000)。此处 N 是电脑的数目，编号从 1 到 N；同时，D 是两台电脑之间能够直接通信的最大距离。接下来的 N 行，每行包含两个整数 xi, yi (0 <= xi, yi <= 10000)，表示 N 台电脑的坐标。从第 (N+1) 行到输入结束，是逐一执行的操作，每行包含一个操作，格式是以下两者之一：

  1. “O p” (1 <= p <= N)，表示维护电脑 p 。
  2. “S p q” (1 <= p, q <= N)，表示测试电脑 p 和 q 是否能够通信。

输入不超过 300000 行。

输出

对于每个测试操作，如果两台电脑能够通信，则打印 “SUCCESS”；否则，打印 “FAIL”。

示例输入

4 1
0 1
0 2
0 3
0 4
O 1
O 2
O 4
S 1 4
O 3
S 1 4

示例输出

FAIL
SUCCESS

AC 代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

#include "iostream"
#include "cstring"
using namespace std;
int pre[1005];
int x[1005],y[1005],use[1005];

int findd(int root){
    int son,t;
    son=root;
    while(root!=pre[root])
        root=pre[root];
    while(son!=root){
        t=pre[son];
        pre[son]=root;
        son=t;
    }
    return root;
}

void join(int x,int y){
    int fx=findd(x),fy=findd(y);
    if(fx!=fy)
        pre[fx]=fy;
}

int dis(int i,int num,int d){
    d=d*d;
    int xx=x[i]-x[num];
    int yy=y[i]-y[num];
    if((xx*xx+yy*yy)<=d)
        return 1;
    return 0;
}

int main(){
    int n,d;
    char s;
    memset(use,0,sizeof(use));
    cin>>n>>d;
    for(int i=0;i<=n;i++)
        pre[i]=i;
    for(int i=1;i<=n;i++)
        cin>>x[i]>>y[i];
    while(cin>>s){
        if(s=='O'){
            int num;
            cin>>num;
            use[num]=1;
            findd(num);//路径压缩
            for(int i=1;i<=n;i++)
                if(i!=num&&use[i]==1&&dis(i,num,d))//修好了，且可以被合并（自己除外）
                    join(i,num);
        }
        else if(s=='S'){
            int q,p;
            cin>>q>>p;
            if(findd(q)==findd(p))
                cout<<"SUCCESS"<<endl;
            else cout<<"FAIL"<<endl;
        }
    }
    return 0;
}
]]>畅通工程-HDU-1232（并查集经典模板）https://lruihao.cn/posts/%E7%95%85%E9%80%9A%E5%B7%A5%E7%A8%8B/Tue, 31 Jul 2018 11:08:43 +0000Lruihaohttps://lruihao.cn/posts/%E7%95%85%E9%80%9A%E5%B7%A5%E7%A8%8B/并查集入门推荐：超有爱的并查集~

题目链接：畅通工程

题意分析：

首先在地图上给你若干个城镇，这些城镇都可以看作点，然后告诉你哪些对城镇之间是有道路直接相连的。最后要解决的是整幅图的连通性问题。比如随意给你两个点，让你判断它们是否连通，或者问你整幅图一共有几个连通分支，也就是被分成了几个互相独立的块。像畅通工程这题，问还需要修几条路，实质就是求有几个连通分支。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include<iostream>
#include<cstdio>
using namespace std;
int pre[1010];

int findd(int root){
    int son,t;
    son=root;
    while(root!=pre[root])
        root=pre[root];
    while(son!=root){
        t=pre[son];
        pre[son]=root;
        son=t;
    }
    return root;
}

int main(){
    int n,m,i,sum,r1,r2,star,end1;
    while(scanf("%d",&n)&&n){
        sum=n-1;
        for(i=1;i<=n;i++)
            pre[i]=i;
        scanf("%d",&m);
        while(m--){
            scanf("%d%d",&star,&end1);
            r1=findd(star);
            r2=findd(end1);
            if(r1!=r2){
                pre[r1]=r2;
                sum--;
            }
        }
        printf("%d\n",sum);
    }
	return 0;
}

基础回顾：

find() 函数找根结点的两种写法如下：

第一种递归：

1
2
3
4

int find(int x)
{
    return x == pre[x] ? x : find(pre[x]);
}

第二种：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

int find(int x)
{
    int root, temp;
    root = x;
    while(root != pre[root])
        root = pre[root];
    while(x != root)
    {
        temp = pre[x];
        pre[temp] = root;
        x = temp;
    }
    return root;
}
合并函数
1
2
3
4
5
6

void join(int x,int y){
    int fx=find(x);
    int fy=find(y);
    if(fx!=fy)
        pre[fx]=fy;
}
]]>