hdu 3478 Catch（染色 dfs 或 bfs ）

Problem Description

A thief is running away!
We can consider the city where he locates as an undirected graph in which nodes stand for crosses and edges stand for streets. The crosses are labeled from  to N–.
The tricky thief starts his escaping from cross S. Each moment he moves to an adjacent cross. More exactly, assume he is at cross u at the moment t. He may appear at cross v at moment t +  if and only if there is a street between cross u and cross v. Notice that he may not stay at the same cross in two consecutive moment.
The cops want to know if there’s some moment at which it’s possible for the thief to appear at any cross in the city.

 

Input

The input contains multiple test cases:
In the first line of the input there’s an integer T which is the number of test cases. Then the description of T test cases will be given.
For any test case, the first line contains three integers N (≤  ), M (≤  ), and S. N is the number of crosses. M is the number of streets and S is the index of the cross where the thief starts his escaping.
For the next M lines, there will be  integers u and v in each line ( ≤ u, v < N). It means there’s an undirected street between cross u and cross v.

Output

For each test case, output one line to tell if there’s a moment that it’s possible for the thief to appear at any cross. Look at the sample output for output format.

 

Sample Input

 

Sample Output

Case : YES
Case : NO

Hint

For the first case, just look at the table below. (YES means the thief may appear at the cross at that moment)

For the second input, at any moment, there’s at least one cross that the thief can’t reach.

Source

2010 ACM-ICPC Multi-University Training Contest（5）——Host by BJTU

转自别人的解释：

如果出现遍历图中的某个点都是在奇数时刻或者偶数时刻，那么小偷的藏点就是根据时间判定在某些的奇数点和偶数点了。

如果图出现奇数的环，即：有一个环由奇数个点组成，那么环中的某个点在奇数和偶数时刻都能到达(可以画图试试)。其实奇数环导致小偷藏点无规律的最大原因是：

在遍历最后奇数环的两个(必定是两个)未遍历点的时候他们是同奇(偶)的，然而还有一条边直接相连。导致在下一时刻，那两个点又可以同时变成偶(奇)。如果在回溯遍历的话，就会出现整张图在奇数时刻或者偶数时刻都能到达。 

无向图G为二部图的充分必要条件是：
G至少有两个顶点，且其所有回路的长度均为偶数。

如果我们把图中奇数时刻能够到达的点归到X集合，偶数能到点归到Y集合，那么如果图中出现相同集合的点有 
边相连，那么就不满足二分图的性质，即可输出YES，如果原图可二分图话，答案就是NO了。

然后就是经典的二分图判定。

///

题意：一个小偷从初始点逃到他相邻的点，从某个点到另外若干个相邻的点的时间是相同的，

也就是同个时间点，问你在同个时间点小偷能否遍历全部点，能的话输出YES，否则输出NO。

 

解法：DFS判断连通性+DFS染色判断是否为二分图。

如果是个二分图那么它的奇数步和偶数步是属于各自独立的集合，

如果奇数步能够遍历到偶数步，这个意思就是此小偷可以在某个时间点遍历整个图的点。

画个奇数点的环，从某个点出发一点存在一条边，同时改变改点的奇偶性。

///

总之，只要判断连通性和二分图即可

bfs实现染色：

 #pragma comment(linker, "/STACK:1024000000,1024000000")
 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cmath>
 #include<math.h>
 #include<algorithm>
 #include<queue>
 #include<set>
 #include<bitset>
 #include<map>
 #include<vector>
 #include<stdlib.h>
 #include <stack>
 using namespace std;
 #define PI acos(-1.0)
 #define max(a,b) (a) > (b) ? (a) : (b)
 #define min(a,b) (a) < (b) ? (a) : (b)
 #define ll long long
 #define eps 1e-10
 #define MOD 1000000007
 #define N 100006
 #define inf 1e12
 
 ////////////////////////////////////////////////////
 int fa[N];
 void init(){
     for(int i=;i<N;i++){
         fa[i]=i;
     }
 }
 int find(int x){
     return fa[x]==x?x:fa[x]=find(fa[x]);
 }
 bool merge(int x,int y){
     int root1=find(x);
     int root2=find(y);
     if(root1==root2) return false;
     fa[root1]=root2;
     return true;
 }
 ///////////////////////////////////////////////////
 int n,m,s;
 vector<int> v[N];
 int color[N];
 bool bfs(){
     queue<int>q;
     q.push(s);
     color[s]=;
     while(!q.empty()){
         int t1=q.front();
         q.pop();
 
         for(int i=;i<v[t1].size();i++){
             int t2=v[t1][i];
             if(color[t2]==-){
                 if(color[t1]==){
                     color[t2]=;
                 }
                 else{
                     color[t2]=;
                 }
                 q.push(t2);
             }
             else{
                 if(color[t1]==color[t2]){
                     return true;
                 }
             }
 
         }
     }
     return false;
 }
 int main()
 {
     int t;
     int ac=;
     scanf("%d",&t);
     while(t--){
         scanf("%d%d%d",&n,&m,&s);
         for(int i=;i<=n;i++){
             v[i].clear();
         }
         init();
         int num=n-;
         for(int i=;i<m;i++){
             int x,y;
             scanf("%d%d",&x,&y);
             if(merge(x,y)){
                 num--;
             }
             v[x].push_back(y);
             v[y].push_back(x);
         }
         memset(color,-,sizeof(color));
         printf("Case %d: ",++ac);
         if(num!=){
             printf("NO\n");
             continue;
         }
 
         if(bfs()){
             printf("YES\n");
         }
         else{
             printf("NO\n");
         }
 
     }
     return ;
 }

dfs实现染色：

 #pragma comment(linker, "/STACK:1024000000,1024000000")
 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cmath>
 #include<math.h>
 #include<algorithm>
 #include<queue>
 #include<set>
 #include<bitset>
 #include<map>
 #include<vector>
 #include<stdlib.h>
 #include <stack>
 using namespace std;
 #define PI acos(-1.0)
 #define max(a,b) (a) > (b) ? (a) : (b)
 #define min(a,b) (a) < (b) ? (a) : (b)
 #define ll long long
 #define eps 1e-10
 #define MOD 1000000007
 #define N 100006
 #define inf 1e12
 
 ////////////////////////////////////////////////////
 int fa[N];
 void init(){
     for(int i=;i<N;i++){
         fa[i]=i;
     }
 }
 int find(int x){
     return fa[x]==x?x:fa[x]=find(fa[x]);
 }
 bool merge(int x,int y){
     int root1=find(x);
     int root2=find(y);
     if(root1==root2) return false;
     fa[root1]=root2;
     return true;
 }
 ///////////////////////////////////////////////////
 
 int n,m,s;
 vector<int> v[N];
 int color[N];
 bool dfs(int x,int c){
     color[x]=c;
     for(int i=;i<v[x].size();i++){
         int y=v[x][i];
         if(color[y]==-){
             color[y]=!c;
             dfs(y,!c);
         }
         else{
             if(color[y]==color[x]){
                 return true;
             }
         }
     }
     return false;
 }
 int main()
 {
     int ac=;
     int t;
     scanf("%d",&t);
     while(t--){
         for(int i=;i<N;i++){
             v[i].clear();
         }
         init();
         scanf("%d%d%d",&n,&m,&s);
         int num=n-;
         for(int i=;i<m;i++){
             int x,y;
             scanf("%d%d",&x,&y);
             if(merge(x,y)){
                 num--;
             }
             v[x].push_back(y);
             v[y].push_back(x);
         }
 
         printf("Case %d: ",++ac);
         if(num!=){
             printf("NO\n");
             continue;
         }
 
         memset(color,-,sizeof(color));
         if(dfs(s,)){
             printf("YES\n");
         }
         else{
             printf("NO\n");
         }
 
     }
     return ;
 }