POJ 2492 A Bug's Life （並查集應用的擴展）

A Bug's Life

Time Limit: 10000MS		Memory Limit: 65536K
Total Submissions: 21637		Accepted: 7056

Description

Background
Professor Hopper is researching the sexual behavior of a rare species of bugs. He assumes that they feature two different genders and that they only interact with bugs of the opposite gender. In his experiment, individual bugs and their interactions were easy to identify, because numbers were printed on their backs.
Problem
Given a list of bug interactions, decide whether the experiment supports his assumption of two genders with no homosexual bugs or if it contains some bug interactions that falsify it.

Input

The first line of the input contains the number of scenarios. Each scenario starts with one line giving the number of bugs (at least one, and up to 2000) and the number of interactions (up to 1000000) separated by a single space. In the following lines, each interaction is given in the form of two distinct bug numbers separated by a single space. Bugs are numbered consecutively starting from one.

Output

The output for every scenario is a line containing "Scenario #i:", where i is the number of the scenario starting at 1, followed by one line saying either "No suspicious bugs found!" if the experiment is consistent with his assumption about the bugs' sexual behavior, or "Suspicious bugs found!" if Professor Hopper's assumption is definitely wrong.

Sample Input

2
3 3
1 2
2 3
1 3
4 2
1 2
3 4

Sample Output

Scenario #1:
Suspicious bugs found!

Scenario #2:
No suspicious bugs found!

/* 功能Function Description:     POJ-2492 並查集應用的擴展
   開發環境Environment:          DEV C++ 4.9.9.1
   技術特點Technique:
   版本Version:
   作者Author:                   可笑痴狂
   日期Date:                      20120808
   備注Notes:
關於並查集，注意兩個概念：按秩合並、路徑壓縮。
1、按秩合並
由於並查集一般是用比較高效的樹形結構來表示的，按秩合並的目的就是防止產生退化的樹（也就是類似鏈表的樹），
用一個數組記錄各個元素的高度（也有的記錄各個元素的孩子的數目，具體看哪種能給解題帶來方便），
然后在合並的時候把高度小的嫁接到高度大的上面，從而防止產生退化的樹。
2、路徑壓縮
而另一個數組記錄各個元素的祖先，這樣就防止一步步地遞歸查找父親從而損失的時間。因為並查集只要搞清楚各個元素所在的集合，
而區分不同的集合我們用的是代表元素（也就是樹根），所以對於每個元素我們只需保存其祖先，從而區分不同的集合。
而我們這道題並沒有使用純正的並查集算法，而是對其進行了擴展，
我們並沒有使用“1、按秩合並”（當然你可以用，那樣就需要再開一個數組）
我們從“1、按秩合並”得到啟示，保存“秩”的數組保存的是    元素相對於父節點的關系  ，我們豈不可以利用這種關系
（即相對於父節點的不同秩值來區分不同的集合），從而可以把兩個集合合並成一個集合。
（注：此代碼 relation=0 代表 和父節點同一性別）
*/


#include<stdio.h>
int father[2005];
int relation[2005];

int find_father(int i)
{
    int t;
    if(father[i]==i)
        return i;

    //計算相對於新的父節點（即根）的秩，relation[t]是老的父節點相對於新的父節點（即根）的秩，relation[i]是i元素相對於老的父節點的秩，
    //類似於物理里的相對運動，得到的r[i]就是相對於新的父節點（即根）的秩。而且這個遞歸調用不會超過兩層
    t=father[i];    
    father[i]=find_father(father[i]);
    relation[i]=(relation[i]+relation[t]+1)%2;   //注意遞歸中把這棵樹relation中的的值都更新一遍，這句的順序 不能 和上一句 調換位置
    // relation[a]的改變是伴隨着father[a]的改變而更新的（有father改變就有relation改變），要是father改變了，而relation未改變，此時的relation就記錄了一個錯誤的值，
    //father未改變（即使實際的father已不是現在的值，但只要father未改變，relation的值就是“正確”的，認識到這點很重要。）
    return father[i];
}

void merge(int a,int b)
{
    int x,y;
    x=find_father(a);
    y=find_father(b);
    father[x]=y;
    relation[x]=(relation[b]-relation[a])%2;//relation[a]+relation[x]與relation[b]相對於新的父節點必須相差1個等級，因為他們不是gay
}                                            //x下邊的節點不用改，因為查找的時候會自動更新

int main()
{
    int T,m,n,i,j,a,b,flag;
    scanf("%d",&T);
    for(i=1;i<=T;++i)
    {
        flag=0;
        scanf("%d%d",&n,&m);
        for(j=1;j<=n;++j)       //初始化
        {
            father[j]=j;
            relation[j]=1;
        }
        for(j=1;j<=m;++j)
        {
            scanf("%d%d",&a,&b);
            if(find_father(a)==find_father(b))
            {
            //    if(relation[a]!=(relation[b]+1)%2)
                if(relation[a]==relation[b])            //說明是同性
                    flag=1;
            }
            else
                merge(a,b);
        }
        if(flag)
            printf("Scenario #%d:\nSuspicious bugs found!\n\n",i);
        else
            printf("Scenario #%d:\nNo suspicious bugs found!\n\n",i);
    }
    return 0;
}

 復習並查集，又重新做了一遍：

#include <cstdio>
#include <iostream>
#include <cstring>

using namespace std;

const int MAX = 2005;

bool flag;
int fa, fb, n;
int father[MAX], rela[MAX];

int find(int x)
{
    if(father[x] == -1)
        return x;
    else
    {
        int tmp = father[x];
        father[x] = find(father[x]);
        
        rela[x] = (rela[x]+rela[tmp])%2; 
        return father[x];
    }
}

int main()
{
    int T, m, a, b;
    scanf("%d", &T);
    for(int k = 1; k <= T; ++k)
    {
        flag = true;
        scanf("%d%d", &n, &m);
        {
            memset(father, -1, (n+1)*sizeof(int));
            memset(rela, 0, (n+1)*sizeof(int));
            while(m--)
            {
                scanf("%d%d", &a, &b);
                if(!flag)
                    continue;
                fa = find(a);
                fb = find(b);
                
                if(fa != fb)
                {
                    father[fa] = fb;
                    rela[fa] = (rela[a] + rela[b] + 1)%2;
                }
                else
                {
                    if(rela[a] == rela[b])
                        flag = false;
                }
                
            }
            
            printf("Scenario #%d:\n", k);
            if(flag)   
                printf("No suspicious bugs found!\n\n");
            else
                printf("Suspicious bugs found!\n\n");                  
        }
    }
    return 0; 
}