HDU2473 Junk-Mail Filter【并查集删点】

Junk-Mail Filter

Time Limit: 15000/8000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 7750    Accepted Submission(s): 2446

Problem Description

Recognizing junk mails is a tough task. The method used here consists of two steps:
1) Extract the common characteristics from the incoming email.
2) Use a filter matching the set of common characteristics extracted to determine whether the email is a spam.

We want to extract the set of common characteristics from the N sample junk emails available at the moment, and thus having a handy data-analyzing tool would be helpful. The tool should support the following kinds of operations:

a) “M X Y”, meaning that we think that the characteristics of spam X and Y are the same. Note that the relationship defined here is transitive, so
relationships (other than the one between X and Y) need to be created if they are not present at the moment.

b) “S X”, meaning that we think spam X had been misidentified. Your tool should remove all relationships that spam X has when this command is received; after that, spam X will become an isolated node in the relationship graph.

Initially no relationships exist between any pair of the junk emails, so the number of distinct characteristics at that time is N.
Please help us keep track of any necessary information to solve our problem.

 

Input

There are multiple test cases in the input file.
Each test case starts with two integers, N and M (1 ≤ N ≤ 10 ⁵ , 1 ≤ M ≤ 10 ⁶), the number of email samples and the number of operations. M lines follow, each line is one of the two formats described above.
Two successive test cases are separated by a blank line. A case with N = 0 and M = 0 indicates the end of the input file, and should not be processed by your program.

 

Output

For each test case, please print a single integer, the number of distinct common characteristics, to the console. Follow the format as indicated in the sample below.

 

Sample Input

  
  

   
   5 6
M 0 1
M 1 2
M 1 3
S 1
M 1 2
S 3

3 1
M 1 2

0 0
  
  

 

Sample Output

  
  

   
   Case #1: 3
Case #2: 2
  
  

 

题目大意就是说，n 个点，m个操作，开始时每个元素分别自己在一个集合中，M a b 表示将 a b 并在一个集合中，然后 S a 表示将 a 从它所在集合中拿出来，问最后有多少个集合。

这种方法是不将节点的根初始化为它本身，然后设置虚父节点为删除节点的根

#include <iostream>
#include<cstdio>
#include<cstring>
#define maxn 1200000
using namespace std;
int pre[maxn];
int vis[maxn];
int n,m,cnt;
void init()
{
    for(int i=1;i<=n;++i)
        pre[i]=i+n;//使得节点的根不在是自身
    for(int i=n+1;i<=n*2+m;++i)//m个操作
        pre[i]=i;//虚父节点的根是本身，find函数
}
int find(int x)
{
    return x==pre[x]?x:pre[x]=find(pre[x]);
}
void join(int a,int b)
{
    int fa=find(a);
    int fb=find(b);
    if(fa!=fb)
        pre[fa]=fb;
}
int main()
{
    int a,b;
    char s[3];
    int num=1;
    while(scanf("%d%d",&n,&m)&&(n||m))
    {
        init();
        cnt=2*n;//删除的节点的新的虚父节点
        while(m--)
        {
            scanf("%s",s);
            if(s[0]=='M')
            {
                scanf("%d%d",&a,&b);
                join(a+1,b+1);//题目中输入是从0开始的，这里从1开始的
            }
            else
            {
                scanf("%d",&a);
                pre[a+1]=++cnt;
            }
        }
        memset(vis,0,sizeof(vis));
        int ans=0;
        for(int i=1;i<=n;++i)//查找有多少个根
        {
            if(!vis[find(i)])
            {
                vis[find(i)]=1;
                ans++;
            }
        }
        printf("Case #%d: %d\n",num++,ans);
    }
    return 0;
}

这种方法是在增加一个标记数组来记录删除的点，但需要将删除的点的根节点设置为一个正常情况下不会出现的值

#include<cstdio>
#include<cstring>
#define maxn 1200000
int pre[maxn];
int mark[maxn];
int vis[maxn];
int n,m,k,cnt;
void init()
{
    k=n+1;
    for(int i=1;i<=n+m;++i)//m个操作
    {
        pre[i]=i;
        mark[i]=i;
    }
}
int find(int x)
{
    return x==pre[x]?x:pre[x]=find(pre[x]);
}
void join(int a,int b)
{
    int fa=find(mark[a]);
    int fb=find(mark[b]);
    if(fa!=fb)
        pre[fa]=fb;
}
void dele(int x)//删除节点时，将其标记改掉，查找时根据标记的值进行查找
{//若直接只在pre上修改，则下次有find 函数时将有可能并没删除该节点
    mark[x]=k;
    k++;
}
int main()
{
    int a,b,num=1;
    char s[3];
    while(scanf("%d%d",&n,&m)&&(n||m))
    {
        init();
        while(m--)
        {
            scanf("%s",s);
            if(s[0]=='M')
            {
                scanf("%d%d",&a,&b);
                join(a+1,b+1);
            }
            else
            {
                scanf("%d",&a);
                dele(a+1);
            }
        }
        memset(vis,0,sizeof(vis));
        int cnt=0;
        for(int i=1;i<=n;++i)
        {
            int tem=find(mark[i]);//通过查找标记查找真实的根节点
            if(!vis[tem])
            {
                vis[tem]=1;
                cnt++;
            }
        }
        printf("Case #%d: %d\n",num++,cnt);
    }
    return 0;
}