Knights of the Round Table(Tarjan+奇圈)

http://poj.org/problem?id=2942

题意：n个武士，某些武士之间相互仇视，如果在一起容易发生争斗事件。所以他们只有满足一定的条件才能参加圆桌会议：(1)相互仇视的两个武士不能相邻 (2)同一个圆桌边上的武士数量必须是奇数。输出需要剔除的武士人数。
 　 / \    思路：根据图中的关系建立该图的补图，（Tarjan算法）求出图中的双连通分量，判断每个双连通分量中是否存在奇圈，若存在奇圈则该连通分量中的武士都符合条件，否则都不符合  　     |.|　　判断奇圈的方法：由于二分图中不含奇圈，可判断连通分量是否为二分图，若是，则不含奇圈，否则存在奇圈。。
 　 |.|
 　 |:|　　　__    
  ,_|:|_,　 /　)
 　 (Oo　　/ _I_
 　　+\ \　||^ ^|
 　　　 \ \||_0→  
 　　　　 \ /.:.\-\
 　　　　　|.:. /-----\
 　　　　　|___|::oOo::|
 　　　　　/　 |:<_T_>:|（无意中发现的武士字符画。。哈哈）
    ""....""

 #include <stdio.h>
 #include <string.h>
 #include <algorithm>
 #include <vector>
 #include <stack>
 using namespace std;
 const int N=;
 struct Edge
 {
     int u,v;
     Edge(int u,int v):u(u),v(v) {}
 };
 int low[N],dfn[N],iscut[N],bridge[N][N];
 int color[N],odd[N],bccno[N],map[N][N];
 int dfs_clock,bcc_cnt,n,m;
 vector<int>G[N],bcc[N];
 stack<Edge>S;

 void init()
 {
     bcc_cnt = ;
     dfs_clock = ;
     while(!S.empty()) S.pop();
     memset(low,,sizeof(low));
     memset(dfn,,sizeof(dfn));
     memset(iscut,,sizeof(iscut));
     memset(bridge,,sizeof(bridge));
     memset(bccno,,sizeof(bccno));
     memset(odd,,sizeof(odd));
     memset(map,,sizeof(map));
     for (int i = ; i < N; i++)
     {
         G[i].clear();
         bcc[i].clear();
     }
 }
 void dfs(int u,int father)//Tarjan
 {
     low[u]=dfn[u]=++dfs_clock;
     int child = ;
     for (int i = ; i < G[u].size(); i++)
     {
         int v = G[u][i];
         Edge e(u,v);
         if (!dfn[v])
         {
             S.push(e);
             child++;
             dfs(v,u);
             low[u] = min(low[u],low[v]);
             if(dfn[u] <= low[v])
             {
                 iscut[u] = ;//u为割点
                 ++bcc_cnt;
                 while()
                 {
                     Edge x = S.top();
                     S.pop();
                     if(bccno[x.u]!=bcc_cnt)
                     {
                         bccno[x.u] = bcc_cnt;//点u属于第bcc_cnt个连通分量
                         bcc[bcc_cnt].push_back(x.u);
                     }
                     if (bccno[x.v]!=bcc_cnt)
                     {
                         bccno[x.v] = bcc_cnt;
                         bcc[bcc_cnt].push_back(x.v);
                     }
                     if (x.u==u&&x.v==v)
                         break;
                 }
             }
             if (low[v] > dfn[u]) bridge[u][v] = ;//u-v之间为桥
         }
         else if (dfn[v]<dfn[u]&&v!=father)
         {
             S.push(e);
             low[u] = min(low[u],dfn[v]);
         }
     }
     if (father<&&child==)
         iscut[u]=;
 }
 bool bipartite(int u,int b)//判断二分图（交叉染色法）
 {
     for (int i = ; i < G[u].size(); i++)
     {
         int v = G[u][i];
         if (bccno[v]!=b) continue;
         if (color[u]==color[v]) return false;
         if (!color[v])
         {
             color[v] = -color[u];
             if (!bipartite(v,b))
                 return false;
         }
     }
     return true;
 }
 int main()
 {
     while(~scanf("%d%d",&n,&m))
     {
         if (n==&&m==)
             break;
         int u,v;
         init();
         for (int i = ; i < m; i++)
         {
             scanf("%d%d",&u,&v);
             --u;
             --v;
             map[u][v]=map[v][u]=;
         }
         for (int i = ; i < n; i++)
         {
             for (int j = i+; j <n; j++)
             {
                 if (!map[i][j])
                 {
                     G[i].push_back(j);//建立无向的补图
                     G[j].push_back(i);
                 }
             }
         }
         for (int i = ; i <n; i++)
         {
             if (!dfn[i])
                 dfs(i,-);
         }
         for (int i = ; i <= bcc_cnt; i++)
         {
             memset(color,,sizeof(color));
             for (int j = ; j < bcc[i].size(); j++)
             {
                 bccno[bcc[i][j]] = i;
             }
             int u = bcc[i][];
             color[u] = ;
             if(!bipartite(u,i))
             {
                 for (int j = ; j < bcc[i].size(); j++)
                 {
                     odd[bcc[i][j]] =;//标记奇圈中的点
                 }
             }
         }
         int ret = ;
         for (int i = ; i < n; i++)
         {
             if (!odd[i])
                 ret++;
         }
         printf("%d\n",ret);
     }
     return ;
 }