LightOJ 1300 Odd Personality

Odd Personality

Time Limit: 2000ms

Memory Limit: 32768KB

This problem will be judged on LightOJ. Original ID: 1300
64-bit integer IO format: %lld      Java class name: Main

Being an odd person, Jim always liked odd numbers. One day he was visiting his home town which consists of n places and m bidirectional roads. A road always connects two different places and there is at most one road between two places. The places are numbered from 0 to n-1.

Jim wants to find a tour which starts from a place p and each time it goes to a new road and finally at last step it returns back to p. As Jim likes odd numbers, he wants the length of the tour to be odd. And the length of a tour is defined by the number of roads used in the tour.

 

For the city map given above, 0 - 1 - 2 - 0 is such a tour, so, 0 is one of the results, since from 0, a tour of odd length is found, similarly, 1 - 2 - 0 - 1 is also a valid tour. But 3 - 2 - 0 - 1 - 2 - 3 is not. Since the road 2 - 3 is used twice. Now given the city map, Jim wants to find the number of places where he can start his journey for such a tour. As you are the best programmer in town, he asks you for help. Jim can use a place more than once, but a road can be visited at most once in the tour.

 

Input

Input starts with an integer T (≤ 30), denoting the number of test cases.

Each case starts with a blank line. The next line contains two integers: n (3 ≤ n ≤ 10000) and m (0 ≤ m ≤ 20000). Each of the next m lines contains two integers u v (0 ≤ u, v < n, u ≠ v) meaning that there is a bidirectional road between place u and v. The input follows the above constraints. And no road is reported more than once.

 

Output

For each case, print the case number and the total number places where Jim can start his journey.

Sample Input

1

6 6

0 1

1 2

2 0

3 2

3 4

3 5

Sample Output

Case 1: 3

Source

Problem Setter: Jane Alam Jan

 

解题：大概意思就是说看有多少个起点，从这个起点出发，最后经过奇数条边后回到起点，但是不能经过相同的边，可以有相同的点。很明显在边双连通中找奇圈嘛。

 

#include <bits/stdc++.h>
using namespace std;
const int maxn = 50000;
struct arc {
    int to,next;
    arc(int x = 0,int y = -1) {
        to = x;
        next = y;
    }
} e[maxn<<2];
int head[maxn],dfn[maxn],low[maxn],color[maxn];
int tot,idx,cnt,n,m,flag,ans;
bool b[maxn];
void add(int u,int v) {
    e[tot] = arc(v,head[u]);
    head[u] = tot++;
}
void tarjan(int u,int fa) {
    dfn[u] = low[u] = ++idx;
    for(int i = head[u]; ~i; i = e[i].next) {
        if(!dfn[e[i].to]) {
            tarjan(e[i].to,u);
            low[u] = min(low[u],low[e[i].to]);
            if(low[e[i].to] > dfn[u]) b[i] = b[i^1] = true;
        } else if(e[i].to != fa) low[u] = min(low[u],dfn[e[i].to]);
    }
}
void dfs(int u,int s) {
    color[u] = s;
    cnt++;
    for(int i = head[u]; ~i; i = e[i].next) {
        if(b[i]) continue;
        if(color[e[i].to] && color[e[i].to] == color[u]) flag = 1;
        else if(color[e[i].to] == 0) dfs(e[i].to,3-s);
    }
}
int main() {
    int T,cs = 1,u,v;
    scanf("%d",&T);
    while(T--) {
        scanf("%d %d",&n,&m);
        memset(head,-1,sizeof(head));
        memset(low,0,sizeof(low));
        memset(dfn,0,sizeof(dfn));
        memset(color,0,sizeof(color));
        memset(b,false,sizeof(b));
        idx = 0;
        for(int i = tot = 0; i < m; ++i) {
            scanf("%d %d",&u,&v);
            add(u,v);
            add(v,u);
        }
        for(int i = ans = 0; i < n; ++i)
            if(!dfn[i]) tarjan(i,-1);
        for(int i = 0; i < n; ++i)
            if(color[i] == 0) {
                flag = cnt = 0;
                dfs(i,1);
                if(flag) ans += cnt;
            }
        printf("Case %d: %d
",cs++,ans);
    }
    return 0;
}