POJ 2942Knights of the Round Table(二分图判定+双连通分量)

题目链接

题意：一些骑士，他们有些人之间有矛盾，现在要求选出一些骑士围成一圈，圈要满足如下条件：1.人数大于1。2.总人数为奇数。3.有仇恨的骑士不能挨着坐。问有几个骑士不能和任何人形成任何的圆圈。

分析：以骑士为借点建立无向图G，如果两个骑士可以相邻（即不相互憎恶）建立一条有向边，题目转化成求不在任意一个简单奇圈上（包含奇数个节点的回路）的节点个数，

对于每个双连通分量，看是否存在奇环，若存在那么这个双连通分量中的任意两骑士都可以同时出现在一个奇环里：训练指南P317解释， 双联通分量B中有一个奇环C，奇环C中含有u1和u2两个点，v属于连通分量B,那么v一定存在到达u1和u2的路径，在奇环C中，u1和u2的两条路是一奇一偶的，由于v到u1和u2的两条路径此时必然能够造成一个经过v的奇环

一个奇环就是一场会议

二分图是没有奇环的

主算法：对于每个连通分量的每个双连通分量B，若它不是二分图，给B中所有节点标记为在 在奇环上，

 #include <iostream>
 #include <cstring>
 #include <cstdio>
 #include <algorithm>
 #include <stack>
 #include <vector>
 using namespace std;
 const int Max = ;
 vector<int> G[Max], bcc[Max];
 int odd[Max], color[Max];
 int A[Max][Max];
 int pre[Max], iscut[Max], bccno[Max];
 int dfs_clock, bcc_cnt;

 struct Edge
 {
     int u, v;
 };
 stack<Edge> S;
 int dfs(int u, int fa)
 {
     int lowu = pre[u] = ++dfs_clock;
     int child = ;
     int Size = (int) G[u].size();
     for (int i = ; i < Size; i++)
     {
         int v = G[u][i];
         Edge e;
         e.u = u;
         e.v = v;
         if (!pre[v])
         {
             S.push(e);
             child++;
             int lowv = dfs(v, u);
             lowu = min(lowu, lowv);
             if (lowv >= pre[u])
             {
                 iscut[u] = true;
                 ++bcc_cnt;
                 bcc[bcc_cnt].clear();
                 for(;;)
                 {
                     Edge x = S.top();
                     S.pop();
                     if (bccno[x.u] != bcc_cnt)
                     {
                         bcc[bcc_cnt].push_back(x.u);
                         bccno[x.u] = bcc_cnt;
                     }
                     if (bccno[x.v] != bcc_cnt)
                     {
                         bcc[bcc_cnt].push_back(x.v);
                         bccno[x.v] = bcc_cnt;
                     }
                     if (x.u == u && x.v == v)
                         break;
                 }
             }
         }
         else if (pre[v] < pre[u] && v != fa)
         {
             S.push(e);
             lowu = min(lowu, pre[v]);
         }
     }
     if (fa <  && child == )  //这里之前不理解，因为在之前判断是割点的时候已经将这种情况当成了割点，但是对于连通分量来说没问题
         iscut[u] = false;
     return lowu;
 }
 void find_bcc(int n)
 {
     memset(pre, , sizeof(pre));
     memset(iscut, , sizeof(iscut));
     memset(bccno, , sizeof(bccno));
     dfs_clock = bcc_cnt = ;
     for (int i = ; i < n; i++)
     {
         if (!pre[i])   //没访问就访问
             dfs(i, -);
     }
 }
 bool bipartite(int u, int b)  //判断二分图
 {
     for (int i = ; i < (int) G[u].size(); i++)
     {
         int v = G[u][i];
         if (bccno[v] != b)
             continue;
         if (color[v] == color[u])
             return false;
         if (!color[v])
         {
             color[v] =  - color[u]; // 0表示没图，1表示1种颜色，2表示另一种
             if (!bipartite(v, b))
                 return false;
         }
     }
     return true;
 }
 int main()
 {
     int n, m;
     while (scanf("%d%d", &n, &m) != EOF)
     {
         if (n ==  && m == )
             break;
         for (int i = ; i <= n; i++)
             G[i].clear();
         memset(A, , sizeof(A));
         for (int i = ; i < m; i++)
         {
             int u, v;
             scanf("%d%d", &u, &v);
             u--;
             v--;  // 从0开始
             A[u][v] = A[v][u] = ;
         }
         for (int i = ; i < n; i++)
         {
             for (int j = i + ; j < n; j++)
             {
                 if (!A[i][j])
                 {
                     G[i].push_back(j);
                     G[j].push_back(i);
                 }
             }
         }

         find_bcc(n); // 找连通分量

        // cout << bcc[3][0] << endl;
         memset(odd, , sizeof(odd));
         for (int i = ; i <= bcc_cnt; i++)
         {
             memset(color, , sizeof(color));
             for (int j = ; j < (int) bcc[i].size(); j++)
                 bccno[ bcc[i][j] ] = i;  //主要处理割顶，一个割点可能属于多个连通分量
             int u = bcc[i][];
             color[u] = ;

             if (!bipartite(u, i))  //如果不是二分图就标记
             {
                 for (int j = ; j < (int) bcc[i].size(); j++)
                     odd[ bcc[i][j] ] = ;
             }
         }
         int ans = n;
         for (int i = ; i < n; i++)
             if (odd[i])  //没标记的可定一场会议都参加不成
             ans--;
         printf("%d\n", ans);
     }
     return ;
 }