A Bug's Life（种类并查集）（也是可以用dfs做）

http://acm.hdu.edu.cn/showproblem.php?pid=1829

 

A Bug's Life

Time Limit:5000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u

Submit Status Practice HDU 1829

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!

Hint

Huge input,scanf is recommended.
         

 题意： 有一堆虫，正常来说只能和异性有关系，现在给你一堆关系，问你这些中可能存在“同性恋”吗

思路1： （种类并查集） 除了正常的并查集之外，此题还要维护一个关系数组记录它与其父亲的性别关系，这个关系一般自己定义，

此题可以认为是同性为 1 ， 异性为0 ，那么要找到它与其父亲的父亲的关系就可以使（rank[x]+rank[x+1] ）%2 ，依次递归下去就可以得到它和他最上面的祖先的关系

并查集一般就考虑并，和查两部分，其中压缩路径的时候要注意将关系数组也要更新，

 #include <cstdio>
 //存储的是其父亲的下表
 int bugs[];
 int relation[];//1:相同性别 0：不同性别
 //初始化
 void init(int len)
 {
     for(int i = ;i <= len; i++)
     {
         bugs[i] = i;
         relation[i] = ;
     }
 }
 //找到根
 int find(int bug)
 {
     if(bugs[bug]==bug)return bug;
     int tem = bugs[bug];
     bugs[bug] = find(bugs[bug]);//递归更新域，返回最终的父亲节点，把所有的孩子都更新了
     //注意这里，求当前位置和父亲的关系，记录之前父亲的位置为tem,然后因为是递归，
     //此时的relation[tem]已经在递归中更新过了，也就是孩子和父亲的关系+父亲和爷爷的关系+1然后模2就得到
     //孩子和爷爷的关系，这里用0和1表示，0表示不同性别，1表示相同性别
     relation[bug] = (relation[bug]+relation[tem]+)%;
     return bugs[bug];
 }

 void union_set(int a,int b,int x,int y)
 {
     //合并，让前边的集合的根指向后边集合的根，成为一个集合
     bugs[x]=y;
     //更新前边集合根和新的集合根之间的关系，
     //注意这里，relation[a]+relation[x]与relation[b]
     //相对于新的父节点必须相差1个等级，因为他们不是gay
     relation[x] = (relation[b]-relation[a])%;   //这里的种类函数还是不理解，大概是根据一个关系的环状推出关系
 }

 int main()
 {
     int S;
     int n,inter;
     int bug1,bug2,parent1,parent2;
     bool flag;//false:无同性恋，true：有同性恋
     scanf("%d",&S);
     for(int i=; i<=S;i++)
     {
         scanf("%d%d",&n,&inter);
         flag = false;
         init(n);//初始化，使其父节点为自己
         for(int j = ; j <= inter; j++)
         {
             scanf("%d%d",&bug1,&bug2);
             if(flag)continue;// 因为当有同性的时候是依次读入的数据，要保证数据时读完的所以用continue
             parent1 = find(bug1);
             parent2 = find(bug2);
             if(parent1==parent2)
             {
                 if(relation[bug1]==relation[bug2])//同性
                 flag = true;
             }
             union_set(bug1,bug2,parent1,parent2);
         }
         if(flag)
         printf("Scenario #%d:\nSuspicious bugs found!\n",i);
         else
         printf("Scenario #%d:\nNo suspicious bugs found!\n",i);
         printf("\n");
     }
     return ;
 }

下面是dfs的思路，将所有的关系都用链接表的形式存起来，然以后肯定会有环的情况，当时奇环的时候（定点数是基数的时候）就存在同性恋，要是偶环就是不存在同性恋，扫描的时候统计节点数，当再次扫描到同一个点的时候看扫描过得点数是奇还是偶。

 #include <cstdio>
 #include <cstring>
 using namespace std;
 #define N 2005
 #define M 1000005

 int head[N];
 struct Edge{
     int v, next;
 }edge[*M];
 int Ecnt;

 void init()
 {
     Ecnt = ;
     memset(head, -, sizeof(head));
 }

 void add(int u, int v)
 {
     edge[Ecnt].v = v;
     edge[Ecnt].next = head[u];
     head[u] = Ecnt++;
     edge[Ecnt].v = u;
     edge[Ecnt].next = head[v];
     head[v] = Ecnt++;
 }//存双向边 

 bool visited[N];
 int f[N];//统计它是男生还是女生，定义 男生是1 女生是0 搜索的时候按0,1,0,1 的顺序标记点，如果再次访问到原先的点的时候应该按顺序标的值与其之前标的不一样的话就是奇环
 bool dfs(int u)
 {
     for(int i = head[u]; i != -; i = edge[i].next)//遍历每一条边
     {
         int v = edge[i].v;//下一个点
         if(!visited[v])//如果没有访问过这个点
         {
             visited[v] = ;
             f[v] = (-f[u]);  //按0,1 交替顺序的标记点
             bool res = dfs(v)；//如果在这之前就已经发现有奇环的话就直接返回FALSE
             if(res == false) return false;
         }
         else if(f[u] == f[v]) return false;//最后又访问到了这个点，就判断这两个点是否是同一个值
     }
     return true;
 }

 int main()
 {
     int T, n, m;
     scanf("%d", &T);
     int cas = ;
     while(T--)
     {
         printf("Scenario #%d:\n", cas++);
         scanf("%d %d", &n, &m);
         init();
         int s, t;
         for(int i = ; i < m; i++)
         {
             scanf("%d %d", &s, &t);
             add(s, t);
         }
         memset(visited, , sizeof(visited));
         memset(f, -, sizeof(f));
         bool ans = true;
         for(int i = ; i <= n; i++)
         {
             if(!visited[i])
             {
                 visited[i] = ;
                 f[i] = ;
                 bool res = dfs(i);
                 if(res == false)
                 {
                     ans = false;
                     break;
                 }
             }
         }
         if(ans) puts("No suspicious bugs found!\n");
         else puts("Suspicious bugs found!\n");
     }
     return ;
 }