并查集的删除操作

UVA11987--Almost Union-Find

zz:https://blog.csdn.net/scut_pein/article/details/8660719?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task

I hope you know the beautiful Union-Find structure. In this problem, you're to implement something similar, but not identical.

The data structure you need to write is also a collection of disjoint sets, supporting 3 operations:


1 p q : Union the sets containing p and q. If p and q are already in the same set, ignore this command.


2 p q : Move p to the set containing q. If p and q are already in the same set, ignore this command


3 p : Return the number of elements and the sum of elements in the set containing p.


Initially, the collection contains n sets: {1}, {2}, {3}, ..., {n}.


Input Description
There are several test cases. Each test case begins with a line containing two integers n and m (1<=n,m<=100,000), the number of integers, and the number of commands. Each of the next m lines contains a command. For every operation, 1<=p,q<=n. The input is terminated by end-of-file (EOF). The size of input file does not exceed 5MB.
Output Description
For each type-3 command, output 2 integers: the number of elements and the sum of elements.
题目大意:有n个集合,提供三种操作
1 p q:将p所在的集合和q所在的集合并起来
2 p q:将p元素移到集合q所在的集合
3 p:求出p所在集合有多少个元素并输出这些元素的和


Sample Input

5 7
1 1 2  //集合1与2合并(集合操作)
2 3 4  //元素3放到元素4所在的集合中
1 3 5  //将[3,4]与[5]合并，得到[3,4,5]
3 4   //查询4所在的集合
2 4 1 //将元素4移动到1所在集合，得到[1,2,4]
3 4
3 3  //查询3所在的集合[3,5]

Sample Output

3 12
3 7
2 8

SOL：

如果进行删除一个点，将其加入到另一个集合时。

会发现如果这个点是开始那个集合中的非叶子点，就很麻烦了。因为“上有老下有小”，“牵一发而动全身”

但如果为叶子点，那就好办多了。

于是对于每个点i,给它“上面”再加一个点N+i出来

这样点i就不会是叶子点了

为了维护这个性质，当点i与点j合并时，我们同时也要保持点J的“叶子”的状态

于是设i的父亲点为N+j就好了。

//假设有5个点，则对1到5这些点，每个点上面还有一个N+i的点
//1上面是6，2上面是7，3上面是8,4上面是9,这样就可以保证我们在删除点的时候
//不会删除根结点了
//如果将1，2，3并在一个集合里面，则(1,2,3,6,7,8)就在一个集合中了
//如果要移动1到4那集合，则先消除它在原集合中的影响 
//然后将1的父亲设为9 
#include <cstdio>
#include <cstring>
const int N = 200005;
int n, m, parent[N], num[N], sum[N];
 
int find(int x) 
{
    return x == parent[x] ? x : parent[x] = find(parent[x]);
}
void init() {
    for (int i = 0; i <= n; i++) 
	{
	parent[i] = parent[i + n] = i + n;
	sum[i] = sum[i + n] = i;
	num[i] = num[i + n] = 1;
    }
}
int main() 
{
    while (~scanf("%d%d", &n, &m)) 
	{
	int q, a, b;
	init();
	while (m--) {
	    scanf("%d", &q);
	    if (q == 1) {
		scanf("%d%d", &a, &b);
		int pa = find(a);
		int pb = find(b);
		if (pa == pb) continue;
		parent[pa] = pb;
		num[pb] += num[pa];
		sum[pb] += sum[pa];
	    }
	    else if (q == 2) {
		scanf("%d%d", &a, &b);
		int pa = find(a);
		int pb = find(b);
		if (pa == pb) continue;
		parent[a] = pb;
		num[pa]--;
		num[pb]++;
		sum[pa] -= a;
		sum[pb] += a;
	    }
	    else {
		scanf("%d", &a);
		int pa = find(a);
		printf("%d %d
", num[pa], sum[pa]);
	    }
	}
    }
    return 0;
}

　　

 Sol:

开始时如最一般的并查集一样开点,对于涉及移动一个元素到另一个集合的操作即第二种操作时.由于不知道这个元素是根结点还是一般的叶子点(叶子点可以直接移过去,所以可以将这个点的在原集合中的影响力清零,然后另新开一个结点将其copy过去，再将新结点并到目标集合中去。

#include <iostream>
#include <cstdio>
using namespace std;
#define maxn 200018
int father[maxn],idx[maxn],num[maxn];
//num来多少个，idx才存
long long int sum[maxn];
int n,m,cnt;
int find(int x)
{
    if(x==father[x])return x;
    return find(father[x]);
}
void init()
{
    for(int i=1;i<=n;i++)
    {
        father[i]=idx[i]=sum[i]=i;
        num[i]=1;
    }
    cnt=n;
}
void Union(int p,int q)
{
    int pp=find(idx[p]),qq=find(idx[q]);
    //统一使用idx[i]代表i目前在哪个集合中 
    father[pp]=qq;
    num[qq]+=num[pp];
    sum[qq]+=sum[pp];
}
void Delete(int p)
{
    int pp=idx[p];
    //取出p所在集合的真实的编号,因为存在删除操作，p所在的集合编号是不断变化的 
    sum[find(pp)]-=p; //消除其影响力 
    num[find(pp)]--;
    idx[p]=++cnt; //新加一个集合出来 
    sum[idx[p]]=p; //以下如传统操作一样 
    num[idx[p]]=1;
    father[idx[p]]=idx[p];
}
int main()
{
    while(scanf("%d%d",&n,&m)==2)
    {
        init();
        int ope,p,q;
        for(int i=1;i<=m;i++)
        {
            scanf("%d",&ope);
            if(ope==1)
            {
                scanf("%d%d",&p,&q);
                if(find(idx[p])==find(idx[q]))
                continue;
                else 
                Union(p,q);
            }
            else if(ope==2)
            {
                scanf("%d%d",&p,&q);
                if(find(idx[p])!=find(idx[q]))
                {
                    Delete(p);
                    Union(p,q);
                }
            }
            else 
            {
                int u;
                scanf("%d",&u);
                int fuck=find(idx[u]);
                printf("%d %lld
",num[fuck],sum[fuck]);
                //这里我用I64d既然WA。。。
            }
        }
    }
    return 0;
}

 另一个题目:Hdu2473

5 6//5个数字(编号从0开始),6个操作
M 0 1//将0与1所在集合，进行合并
M 1 2//将2与1所在集合，进行合并
M 1 3//将3与1所在集合，进行合并
S 1//将1从所在集合中抽出来
M 1 2
S 3
3 1 //第二组数据了
M 1 2
0 0

Sample Output

Case #1: 3 //[0,1,2],[3],[4]这三个集合
Case #2: 2

Sol:感觉没什么好写的。就是开虚点吧
最开始时每个数字所在集合的编号就是其本身的值
但涉及“踢"操作的时候，就将那个点的集合编号换成另一个没有用过的编号。

#include<iostream>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#include<set>
using namespace std;
int par[100005];
int vis[100005];//记录节点 
int flag;
set<int> S;
void init(int x) 
{
	for (int i = 0; i<x; i++) 
	{
		vis[i] = i;
	}
}
int find(int x) 
{
	if (par[x] == x) 
	    return x;
	else 
		return par[x]=find(par[x]);
}
void unite(int x, int y) 
{
	int a = find(x);
	int b = find(y);
	if (a == b)
	{
			return ;
		}
	else 
	{
		par[a] = b;
	}
	return ;
}
int main()
{  
    int n,m;  
    int sase = 0;  
    while(scanf("%d%d",&n,&m))
	{  
        if(n == 0 && m == 0) break;  
        sase++;  
        int cnt = n;  
        for(int i = 0;i < 100005;i++) 
		   par[i] = i;  
        for(int i = 0;i < n;i++) 
		   vis[i] = i;  
        while(m--)
		{  
            char s[3];  
            int a,b;  
            scanf("%s",s);  
            if(s[0] == 'M')
			{  
                scanf("%d%d",&a,&b);  
                unite(vis[a],vis[b]);
            }  
            else{  
                scanf("%d",&a);  
                vis[a] = cnt++;  
            }  
        }  
        S.clear();  
        for(int i = 0;i < n;i++)
		{  
            S.insert(find(vis[i]));  
            //对比一般并查集的写法..if(a[i]==i)ans++,可知vis[]数组的作用
        }  
        printf("Case #%d: %d
",sase,S.size());  
    }  
    return 0;  
}  
————————————————
版权声明：本文为CSDN博主「Hugo5332」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/xxxslinyue/article/details/55259798

 Sol:

正确的方法是每一个点都设立一个虚拟父亲比如1,2,3的父亲分别是4,5,6，现在合并1,2,3都在一个集合，那他们的父亲都是4，现在删除1，那就给1重新申请一个节点7

现在2,3的父亲是4,1的父亲是7，删除成功。

#include <stdio.h>
#include <algorithm>
#include <math.h>
#include <string.h>
#include <vector>
#include <queue>
#include <map>
#include <stack>
#include <iostream>
#define pi acos(-1.0)
#define INF 0x3f3f3f3f
using namespace std;
#define ll long long
const int maxn=5000010;
int pre[maxn],id,vis[maxn];
int found(int x)
{
    if(x!=pre[x]) 
	    pre[x]=found(pre[x]);
    return pre[x];
}
void Merge(int a,int b)
{
    int fx=found(a),fy=found(b);
    if(fx!=fy)
        pre[fx]=fy;
}
void del(int x)
{
    pre[x]=id++;
}
int main()
{
   
    int n,m,Case=0;
    while(scanf("%d%d",&n,&m),n+m)
    {
        for(int i=0;i<=n;i++)
            pre[i]=i+n;
        for(int i=n;i<=n+n+m;i++) 
        //本只有N个点，每个点多开一个“上面的”点出来
		//另还有M次操作，预先再多开出M个点来 
            pre[i]=i;
        id=n+n;
        int a,b; char ch[5];
        for(int i=0;i<m;i++)
        {
            scanf("%s",ch);
            if(ch[0]=='M')
            {
                scanf("%d%d",&a,&b);
                Merge(a,b);
            }
            else
            {
                scanf("%d",&a);
                del(a);
            }
        }
        int ans=0;
        memset(vis,0,sizeof vis);
        for(int i=0;i<n;i++)
        {
            int x=found(i);
            if(!vis[x])
                ans++,vis[x]=1;
        }
        printf("Case #%d: %d
",++Case,ans);
    }
    return 0;
}