Knights of the Round Table【点双连通分量与二分图】

题目链接 POJ - 2942

---

  题意：亚瑟王要给骑士们开会啦，有N个骑士，其中有M对骑士相互之间会吵架，亚瑟王不允许相互吵架的骑士坐在一起，但是他们可以一同坐在餐桌上，只要隔开就可以了。还有就是，出席会议的骑士数必须是奇数，这是为了让投票表决议题时都能有结果。如果出现有某些骑士无法出席所有会议（例如这个骑士憎恨所有的其他骑士），则亚瑟王为了世界和平会强制把他剔除出骑士团。 问亚瑟王至少要剔除多少个骑士才能顺利召开会议？

好了，看到我标红色，加下划线的，并且还有斜体的“所有”，这句话很有深意，只有无法参与所有会议才会被踢掉。我一开始没有考虑到这个，然后就在不断的环内瞎搞，显然是没有整明白题目。所以也错了很久呀。

于是，理清楚了题意之后，我们开始讲一下思维的过程，首先，作为有左右两个位置，又是圆桌会议，所以很容易想到的是环，环就是一个圆桌。环又可以说是把一个二分图给展开了，也就是把原本DNA链一样扭曲的二分图拉成了一个环。

  这里的环还比较的特殊，它一定得是点双连通分量，如果是边双的话，很明显的，这样就不行：

其中，1号点和4号点如果考虑成边双的话，就不行。

  所以，这里的环，指的是点双连通分量。

  点双连通分量和二分图之间有什么性质呢？

• 如果一个点双连通分量内的某些点在一个奇环中（即点双连通分量中含有奇环），那么这个点双连通分量的其他所有点也在某个奇环中；
• 如果某个点双连通分量含有奇环，则它必定不是一个二分图，反过来，如果它是一个二分图，那么它的点双连通分量中必定不含有奇环，这是一个充要条件。

  根据这两个信息，我们其实已经可以构造出思路了。

  我们用BFS染色判断二分图的方法，然后如果它是一个二分图的话，那么就一定不存在一个奇环，好了，那么这些点都是不行的，如果染色出来不是一个二分图的话，那么就是一个奇环了，那么其内所有点都是可以存在入坐的可能性的，于是都是true点，这道题的基础在于能true就true。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
//#include <unordered_map>
//#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f3f3f3f3f
#define eps 1e-8
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
#define MAX_3(a, b, c) max(a, max(b, c))
#define Rabc(x) x > 0 ? x : -x
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 1e3 + 7, maxM = 1e6 + 7;
int N, M, head[maxN], cnt;
bool hate[maxN][maxN];
struct Eddge
{
    int nex, to;
    Eddge(int a=-1, int b=0):nex(a), to(b) {}
}edge[maxM];
inline void addEddge(int u, int v)
{
    edge[cnt] = Eddge(head[u], v);
    head[u] = cnt++;
}
inline void _add(int u, int v) { addEddge(u, v); addEddge(v, u); }
int dfn[maxN], tot, low[maxN], Stap[maxN], Stop, Bcnt, Bsiz[maxN], ans;
vector<int> Belong[maxN], B_have[maxN];
void Tarjan(int u, int fa)
{
    dfn[u] = low[u] = ++tot;
    Stap[++Stop] = u;
    for(int i=head[u], v, p; ~i; i=edge[i].nex)
    {
        v = edge[i].to;
        if(v == fa) continue;
        if(!dfn[v])
        {
            Tarjan(v, u);
            if(low[v] >= dfn[u])
            {
                Bcnt++; Bsiz[Bcnt] = 0; B_have[Bcnt].clear();
                do
                {
                    p = Stap[Stop--];
                    Bsiz[Bcnt] ++;
                    Belong[p].push_back(Bcnt);
                    B_have[Bcnt].push_back(p);
                } while(p ^ v);
                Belong[u].push_back(Bcnt);
                B_have[Bcnt].push_back(u);
                Bsiz[Bcnt]++;
            }
            low[u] = min(low[u], low[v]);
        }
        else low[u] = min(low[u], dfn[v]);
    }
}
queue<int> Q;
int col[maxN];
bool can_use[maxN];
inline bool bfs(int Bid)
{
    while(!Q.empty()) Q.pop();
    Q.push(B_have[Bid][0]); col[B_have[Bid][0]] = 0;
    int u, v; bool ok;
    while(!Q.empty())
    {
        u = Q.front(); Q.pop();
        for(int i=head[u], len; ~i; i=edge[i].nex)
        {
            v = edge[i].to;
            len = (int)Belong[v].size();
            ok = false;
            for(int j=0; j<len; j++)
            {
                if(Belong[v][j] == Bid) ok = true;
            }
            if(!ok) continue;
            if(col[v] == col[u]) return false;
            if(!~col[v])
            {
                col[v] = col[u] ^ 1;
                Q.push(v);
            }
        }
    }
    return true;
}
inline void init()
{
    cnt = tot = Stop = Bcnt = 0; ans = 0;
    for(int i=1; i<=N; i++)
    {
        head[i] = -1;
        dfn[i] = 0;
        can_use[i] = false;
        Belong[i].clear();
        for(int j=1; j<=N; j++) hate[i][j] = false;
    }
}
int main()
{
    while(scanf("%d%d", &N, &M) && (N | M))
    {
        init();
        for(int i=1, u, v; i<=M; i++)
        {
            scanf("%d%d", &u, &v);
            hate[u][v] = hate[v][u] = true;
        }
        for(int i=1; i<=N; i++)
        {
            for(int j=i + 1; j<=N; j++)
            {
                if(!hate[i][j]) _add(i, j);
            }
        }
        for(int i=1; i<=N; i++) if(!dfn[i]) Tarjan(i, 0);
        for(int i=1, len; i<=Bcnt; i++)
        {
            len = Bsiz[i];
            for(int j=0; j<len; j++)
            {
                col[B_have[i][j]] = -1;
            }
            if(!bfs(i))
            {
                for(int j=0; j<len; j++)
                {
                    can_use[B_have[i][j]] = true;
                }
            }
        }
        for(int i=1; i<=N; i++) if(!can_use[i]) ans++;
        printf("%d\n", ans);
    }
    return 0;
}