poj 2942 Knights of the Round Table

题意：在一张无向图中，问有多少个点不属于任意一个奇圈,孤立点不属于奇圈

首先明确两个定理：

定理1：对于一个点双连通分量，如果找个一个奇圈那么这个分量的其他点也必然在某个奇圈内。

证明很简单，设ab是一个奇圈上的点，c不属于这个奇圈，设c到a和边数为m到b的边数为n，若m+n为奇数，则c位于由这个奇环除ab外的其他边（偶数条）构成一个奇环，如果m+n为偶数，那么c到ab的路径与ab边构成一个奇环。次定理仅适用于点双连通分量，不适用于边连通分量。

1 4
| \ / \
| \ / \
| 2 5 此图在很多时候被用到，尤其是不太确定应该使用边连通还是点连通时。
| / \ /
| / \ /
3 6
依次此题变为判断一个点连通分量里是否存在一个奇圈，有事又用到了定理2
定理2：一个图是二部图当且仅当它不包含奇圈。这是判定二部图的一个方法，并一个方法时染色，因此我们可以染色的方法盘奇圈，如果一个连通分量中某边的两点染色相同则不是二部图，即存在奇圈，则此连通分量中所有点都不会被去除。
另外一种判断二分图的方法是使用并查集，两点有边说明两点不属于一类，每次加边时用差统计量判断是否矛盾即可，效率应该和染色差不多，但是更好写，sgu172 eXam二分图判定
PS：此题很经典也很综合，目前的瓶颈在于想不到那俩定理。。。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.Arrays;

public class Main{
int maxn = 1010,maxm=2000010;
class node{
int be,ne;
node(int b,int e){
be=b;
ne=e;
}
}
class block{
node buf[]=new node[maxn];
int E[]=new int[maxn],len;
int cut;
void  init(int c)
{
cut=c;
Arrays.fill(E,-1);
len=0;
}
void add(int a,int b)
{
buf[len]=new node(b,E[a]);
E[a]=len++;
}
int color[]=new int[maxn];
void work(){
Arrays.fill(color,-1);
if(tocolor(cut,0))
return;
flag[cut]=1;
for(int i=0;i<len;i++)
flag[buf[i].be]=1;
}
boolean tocolor(int a,int c){
boolean res=true;
color[a] = c;
for (int i=E[a];i!=-1;i=buf[i].ne) {
int b = buf[i].be;
if (color[b] == -1)
res&=tocolor(b, c ^ 1);
if (color[b] == c)
return false;
}
return res;
}
}

node buf[]=new node[maxm];
int E[]=new int[maxn],len;
void add(int a,int b){
buf[len]=new node(b,E[a]);
E[a]=len++;
buf[len]=new node(a,E[b]);
E[b]=len++;
}
void init(){
Arrays.fill(E,-1);
len=0;
}
int map[][] = new int[maxn][maxn], n;
int dfn[] = new int[maxn], low[] = new int[maxn], cnt;
int stack[] = new int[maxn], top;
int flag[] = new int[maxn];
block bk=new block();
void dfs(int a) {
dfn[a] = low[a] = ++cnt;
for (int i=E[a];i!=-1;i=buf[i].ne) {
int b=buf[i].be;
if (dfn[b] == 0) {
stack[++top] = i;
dfs(b);
if (low[b] < low[a])
low[a] = low[b];
if (low[b] >= dfn[a]) {
int x;
bk.init(a);
do {
x = stack[top--];
bk.add(buf[x^1].be, buf[x].be);
} while (buf[x^1].be!=a||buf[x].be!= b);// a组成多个块，不能弹出
bk.work();
}
} else if (dfn[b] < low[a]){
low[a] = dfn[b];
stack[++top] = i;
}
}
}

int solve() {
for (int i = 1; i <= n; i++)
dfn[i] = low[i] = flag[i] = 0;
top = cnt = 0;
for(int i=1;i<=n;i++)
if(dfn[i]==0)
dfs(i);
int ans = 0;
for (int i = 1; i <= n; i++)
if (flag[i] == 0)
ans++;
return ans;
}

StreamTokenizer in = new StreamTokenizer(new BufferedReader(
new InputStreamReader(System.in)));

int nextInt() throws IOException {
in.nextToken();
return (int) in.nval;
}

void run() throws IOException {
while(true){
n = nextInt();
int m = nextInt();
if(n==0)
break;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
map[i][j] = map[j][i] = 1;
int a, b;
while (m-- > 0) {
a = nextInt();
b = nextInt();
map[a][b] = map[b][a] = 0;
}
init();
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if(map[i][j]==1)
add(i,j);
System.out.println(solve());
}
}

public static void main(String[] args) throws IOException {
new Main().run();
}
}