HDU 5215 BestCoder"杯中国大学生程序设计冠军赛” 边双连通分量取出子图+二分染色判图内奇偶环

Cycle

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 865    Accepted Submission(s): 241

Problem Description

Ery is interested in graph theory, today he ask BrotherK a problem about it: Given you a undirected graph with N vertexes and M edges, you can select a vertex as your starting point, then you need to walk in the graph along edges. However, you can't pass a edge more than once, even opposite direction is forbidden. At the end, you should come back to the starting point. Assume you has passed X edges, there are two questions:

Question 1: Can X be a odd number ?

Question 2: Can X be a even number ?

(note: you must walk, so X can't be 0)

Input

The first line contains a single integer T, indicating the number of test cases.

Each test case begins with two integer N, M, indicating the number of vertexes and the number of edges. Following M lines, each line contains two integers Ui, Vi, indicating there are a edge between vertex Ui and vertex Vi.

T is about 30

1 ≤ N ≤ 100000

0 ≤ M ≤ 300000

1 ≤ Ui,Vi ≤ N

Ui will not equal to Vi

There is at most one edge between any pair of vertex.

Output

For each test, print two lines.

The first line contains "YES" or "NO" for question 1.

The second line contains "YES" or "NO" for question 2.

Sample Input

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

Sample Output

NO
NO
YES
NO
NO
YES

Hint

If you need a larger stack size,
please use #pragma comment(linker, "/STACK:102400000,102400000") and submit your solution using C++.

Source

赛码"BestCoder"杯中国大学生程序设计冠军赛

题目大意：给你一个有n个顶点的无向图和m条边，从任意一点出发（经过的边不能再经过），问能否通过走偶数步或者奇数步再回到原点。

思路：首先我们用边双连通分量把所有的符合条件的极大子图都给取出来，然后我们分别对极大子图进行求解。边双连通分量有个特性，不存在和其他的子图有公共点或者公共边。所以我们每次都只要考虑当前子图内部即可。接下来进行分类讨论：

①如果只有一个偶环，或者全都是偶环，那么就是偶数步。 ②如果只有一个奇环，那么就只能走奇数步。③如果子图内有多个奇环或子图内奇偶环都有，那么偶数and奇数都可以。

因此，奇偶环的判定我们就用二分图染色，即可以得到偶环和奇环，并且我们得到奇环以后让cnt++即可，并且不进行return即可。

 //看看会不会爆int! 或者绝对值问题。
 #include <bits/stdc++.h>
 using namespace std;
 #pragma comment(linker,"/STACK:102400000,102400000")
 #define LL long long
 #define pb push_back
 #define mk make_pair
 #define fi first
 #define se second
 #define all(a) a.begin(), a.end()
 const int maxn =  + ;
 vector<int> G[maxn], bcc[maxn];
 int bccno[maxn], pre[maxn], low[maxn];
 int n, m, dfstime, bcc_cnt;
 stack<int> s;

 void dfs(int u, int fa){
     low[u] = pre[u] = ++dfstime;
     int len = G[u].size();
     s.push(u);
     for (int i = ; i < len; i++){
         int v = G[u][i];
         if (pre[v] == -){
             dfs(v, u);
             low[u] = min(low[u], low[v]);
         }
         else if(bccno[v] == ){
             low[u] = min(low[u], pre[v]);
         }
     }
     if (low[u] == pre[u]){
         bcc_cnt++;
         while (true){
             int x = s.top(); s.pop();
             bccno[x] = bcc_cnt;
             bcc[bcc_cnt].pb(x);
             if (x == u) break;
         }
     }
     return ;
 }
 int color[maxn], vis[maxn], myodd, myeven;
 bool flag;
 void draw(int u, int fa){
     int len = G[u].size();
     for (int i = ; i < len; i++){
         int v = G[u][i];
         if (bccno[v] != bccno[u]) continue;
         if (color[v] != -){
             if (v == fa) continue;
             if (color[u] == color[v]) {
                 myodd++;
             }
             else myeven = ;
         }
         else {
             color[v] =  - color[u];
             draw(v, u);
         }
     }
     return ;
 }

 int main(){
     int t; cin >> t;
     while (t--){
         scanf("%d%d", &n, &m);
         for (int i = ; i <= n; i++) G[i].clear(), bcc[i].clear();
         for (int i = ; i <= m; i++){
             int u, v; scanf("%d%d", &u, &v);
             G[u].pb(v), G[v].pb(u);
         }
         memset(bccno, , sizeof(bccno));
         memset(pre, -, sizeof(pre));
         memset(low, -, sizeof(low));
         dfstime = bcc_cnt = ;
         for (int i = ; i <= n; i++){
             if (pre[i] == -){
                 dfs(i, -);
             }
         }
         memset(color, -, sizeof(color));
         ///如果能染色，表示是偶环，反之存在奇环
         int odd = , even = ;
         for (int i = ; i <= bcc_cnt; i++){
             if (bcc[i].size() > ){
                 myodd = myeven = ;
                 color[bcc[i][]] = ;
                 draw(bcc[i][], -);
                 myodd /= ;
                 if (myeven == ) even = ;
                 if (myodd == ) odd = ;
                 if (myodd > ) even = odd = ;
             }
             if (odd ==  && even == ) break;
         }
         printf("%s\n", odd ? "YES" : "NO");
         printf("%s\n", even ? "YES" : "NO");
     }
     return ;
 }

 /*
 100
 7 8
 1 2
 2 3
 1 3
 2 4
 4 5
 5 6
 6 7
 7 4

 ans:
 yes yes
 yes yes
 */

学习点：对边连通分量的实际意义的使用