并查集题解

格子游戏

时间限制: 1000 ms         内存限制: 65536 KB
提交数: 3036     通过数: 1823 

【题目描述】

Alice和Bob玩了一个古老的游戏：首先画一个n × n的点阵（下图n = 3）

接着，他们两个轮流在相邻的点之间画上红边和蓝边：

直到围成一个封闭的圈（面积不必为1）为止，“封圈”的那个人就是赢家。因为棋盘实在是太大了(n ≤ 200)，他们的游戏实在是太长了！他们甚至在游戏中都不知道谁赢得了游戏。于是请你写一个程序，帮助他们计算他们是否结束了游戏？

【输入】

输入数据第一行为两个整数n和m。m表示一共画了m条线。以后m行，每行首先有两个数字(x, y)，代表了画线的起点坐标，接着用空格隔开一个字符，假如字符是"D "，则是向下连一条边，如果是"R "就是向右连一条边。输入数据不会有重复的边且保证正确。

【输出】

输出一行：在第几步的时候结束。假如m步之后也没有结束，则输出一行“draw”。

【输入样例】

3 5
1 1 D
1 1 R
1 2 D
2 1 R
2 2 D

【输出样例】

4

 这是一道很简单的并查集题目，就按照模板直接模拟就可以了，如果起点在集合里，终点也在集合里，那么符合条件，输出当时的步数就可以了；如果不符合上面的条件，把点入集合；如果到最后还没有符合条件的情况，输出draw就可以了

#include<bits/stdc++.h>
using namespace std;
struct node
{
    int x,y;
 
}f[350][350];
 
node findth(node k)
{
    if((f[k.x][k.y].x==k.x)&&(f[k.x][k.y].y==k.y)){
        return k;
    }
    return f[k.x][k.y]=findth(f[k.x][k.y]);
}
 
 
int main()
{
    int n,m;
    scanf("%d %d",&n,&m);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            f[i][j].x=i;
            f[i][j].y=j;
        }
    }
    node k1,k2;
    for(int i=1;i<=m;i++){
        int x;
        int y;
        char c;
        scanf("%d %d %c\n",&x,&y,&c);
        if(c=='D'){
            k1=findth(f[x][y]);
            k2=findth(f[x+1][y]);
        }
        if(c=='R'){
            k1=findth(f[x][y]);
            k2=findth(f[x][y+1]);
        }
        if((k1.x==k2.x)&&(k1.y==k2.y)){
            printf("%d\n",i);
            return 0;
        }
        else f[k2.x][k2.y]=k1;
    }
    printf("draw\n");
 
    return 0;
}

团伙(group)

时间限制: 1000 ms         内存限制: 65536 KB
提交数: 4722     通过数: 2190 

【题目描述】

在某城市里住着n个人，任何两个认识的人不是朋友就是敌人，而且满足：

1、我朋友的朋友是我的朋友；

2、我敌人的敌人是我的朋友；

所有是朋友的人组成一个团伙。告诉你关于这n个人的m条信息，即某两个人是朋友，或者某两个人是敌人，请你编写一个程序，计算出这个城市最多可能有多少个团伙？

【输入】

第1行为n和m，1<n<1000,1≤m≤100 000；

以下m行，每行为p x y，p的值为0或1，p为0时，表示x和y是朋友，p为1时，表示x和y是敌人。

【输出】

一个整数，表示这n个人最多可能有几个团伙。

【输入样例】

6 4
1 1 4
0 3 5
0 4 6
1 1 2

【输出样例】

3

同样这也是一道 思路比较简单的 并查集题目，先将是朋友的归类合并，然后判断敌人的敌人 是朋友归并到朋友类来，不是的话，就归并到敌人类去。最后统计下有几个团伙。 

#include<iostream>
#include<cstdio>
const int maxn = 2005;
using namespace std;
int f[maxn],vis	[maxn];
int findf(int k){
	while(k!=f[k]) k=f[k];
	return k;
}
void Union(int a,int b){
	int fa=findf(a);
	int fb=findf(b);
	if(fa!=fb)
	f[fb] = fa;
}
int main(){
	int n,m;
	scanf("%d %d",&n,&m);
	for(int i=1;i<=2*n;i++) f[i] =i;
	for(int i=i;i<=m;i++){
		int p,a,b;
		scanf("%d%d%d",&p,&a,&b);
		if(!p) Union(a,b);
		else{
			Union(b,a+n);
			Union(a,b+n);
		}
	}
	int cnt=0;
	for(int i=1;i<=n;i++){

         if(f[i] == i) cnt++;
        
	}
	
	cout<<cnt;
	return 0;
}

打击犯罪(black)

时间限制: 1000 ms         内存限制: 65536 KB
提交数: 2708     通过数: 1474 

【题目描述】

某个地区有n(n≤1000)个犯罪团伙，当地警方按照他们的危险程度由高到低给他们编号为1-n，他们有些团伙之间有直接联系，但是任意两个团伙都可以通过直接或间接的方式联系，这样这里就形成了一个庞大的犯罪集团，犯罪集团的危险程度由集团内的犯罪团伙数量唯一确定，而与单个犯罪团伙的危险程度无关（该犯罪集团的危险程度为n）。现在当地警方希望花尽量少的时间（即打击掉尽量少的团伙），使得庞大的犯罪集团分离成若干个较小的集团，并且他们中最大的一个的危险程度不超过n/2。为达到最好的效果，他们将按顺序打击掉编号1到k的犯罪团伙，请编程求出k的最小值。

【输入】

第一行一个正整数n。接下来的n行每行有若干个正整数，第一个整数表示该行除第一个外还有多少个整数，若第i行存在正整数k，表示i，k两个团伙可以直接联系。

【输出】

一个正整数，为k的最小值。

【输入样例】

7
2 2 5
3 1 3 4
2 2 4
2 2 3
3 1 6 7
2 5 7
2 5 6

【输出样例】

1

【提示】

【提示】

输出1（打击掉犯罪团伙）

如果正向建立并查集，正向删除，那么每一次都需要维护重置并查集。所以我们可以倒过来思考，从n到1枚举，每次把i点加入图中，也就是删除1~k-1条边，剩余k~n，若最大集合点数不超过n/2，说明这种方案可行，且k还能小，一旦不满足，意味这k不能加入图中，即k即为最小删除边。 

 

#include<bits/stdc++.h>
using namespace std;
#define N 1010
int fa[N],a[N][N],c[N];
//fa[i]表示i所在集合的根，c[i]表示i所在集合的总个数
int find(int x)
{
    return x==fa[x]?x:fa[x]=find(fa[x]);
}
int main()
{
    int n;
    scanf("%d",&n);
   for(int i=1;i<=n;i++)  //初始化
   {
       fa[i]=i;
       c[i]=1;
   }
   for(int i=1;i<=n;i++)
   {
       scanf("%d",&a[i][0]);
       for(int j=1;j<=a[i][0];j++)
       scanf("%d",&a[i][j]);
   }
   for(int i=n;i>=1;i--)  //倒着枚举
   {
       for(int j=1;j<=a[i][0];j++)
        if(a[i][j]>i)
        //因为是按顺序删除，这里假设i点在图中，所以接下来合并的点必须比i大,
       {
           int r1=find(i),r2=find(a[i][j]);
           if(r1!=r2)
           {
               fa[r2]=r1;//这里是把i加入到图中
               c[r1]+=c[r2];
               if(c[i]>(n>>1))
                //集合点数超过n/2，k不能进入图中，必须删k
               {
                   cout<<i<<endl;
                   return 0;
               }
           }
       }
   }
   return 0;
}

：搭配购买(buy)

时间限制: 1000 ms         内存限制: 65536 KB
提交数: 2536     通过数: 1251 

【题目描述】

Joe觉得云朵很美，决定去山上的商店买一些云朵。商店里有nn朵云，云朵被编号为1，2，…，n1，2，…，n，并且每朵云都有一个价值。但是商店老板跟他说，一些云朵要搭配来买才好，所以买一朵云则与这朵云有搭配的云都要买。

但是Joe的钱有限，所以他希望买的价值越多越好。

【输入】

第1行n，m，wn，m，w，表示nn朵云，mm个搭配，Joe有ww的钱。

第2~n+1行，每行cici，didi表示ii朵云的价钱和价值。

第n+2~n+1+m行，每行uiui，vivi，表示买uiui就必须买vivi，同理，如果买vivi就必须买uiui。

【输出】

一行，表示可以获得的最大价值。

【输入样例】

5 3 10
3 10
3 10
3 10
5 100
10 1
1 3
3 2
4 2

【输出样例】

1

【提示】

【数据范围】

30%的数据保证：n≤100n≤100；

50%的数据保证：n≤1,000；m≤100；w≤1,000n≤1,000；m≤100；w≤1,000；

100%的数据保证：n≤10,000；0≤m≤5000；w≤10,000n≤10,000；0≤m≤5000；w≤10,000。

这道并查集题目还是很有意思的，是 并查集和01背包的组合出来的题，还可以复习一下动态规划，首先要把搭配一起的用并查集组合起来，那么最后求出的物品数量肯定<=n，需要注意在用结构体把值赋值给w v时一定要先路径压缩一下，这样就是父节点就是一个值了

 

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 1e4 + 10;
int p[N];
int w[N];
int c[N];
int f[N];
int n, m, s;
struct node
{
	int c;
	int w;
	bool flag;
}num[N];
 
int findth(int x)
{
	if (x == p[x]) return x;
	return p[x] = findth(p[x]);
}
 
void unionn(int x, int y)
{
	int xx = findth(x);
	int yy = findth(y);
	if (xx != yy) p[yy] = xx;
}
int cnt;
int ci[N];
int di[N];
 
int main()
{
	scanf("%d %d %d", &n, &m, &s);
	for (int i = 1;i <= n;i++) p[i] = i;
	for (int i = 1;i <= n;i++) {
		scanf("%d %d", &ci[i], &di[i]);
	}
 
	for (int i = 1;i <= m;i++) {
		int x, y;
		scanf("%d %d", &x, &y);
		unionn(x, y);
	}
 
    for (int i = 1;i <= n;i++) {
		findth(i);
	}
 
	for (int i = 1;i <= n;i++) {
		num[p[i]].w += ci[i];
		num[p[i]].c += di[i];
		num[p[i]].flag = true;
	}
 
	
	
	for (int i=1;i<=n;i++){
		if (num[i].flag) {
			w[++cnt] = num[i].w;
			c[cnt] = num[i].c;
		}
	}
 
	for (int i = 1;i <= cnt;i++) {
		for (int j = s;j >= w[i];j--) {
			f[j] = max(f[j], f[j - w[i]] + c[i]);
		}
	}
 
	printf("%d\n", f[s]);
 
	return 0;
}