Uvalive 3523 - Knights of the Round Table （双连通分量+二分图）

题目链接 https://vjudge.net/problem/UVALive-3523

【题意】
有n个骑士经常举行圆桌会议，每次圆桌会议应至少有3个人参加且人数必须是奇数，相互憎恨的骑士不能坐在圆桌上的相邻位置，在知道了哪些骑士互相憎恨后，要求出有多少个骑士不能参加任何一次会议

【思路】
大白书316页例题，以骑士为结点，两个骑士可以相邻（不憎恨）为边建立无向图，问题转换为求不在任何一个简单奇圈上的顶点个数，对应每个联通分量分别求解。简单圈上的点一定属于同一个双联通分量，而二分图没有奇圈，所以当这一双联通分量是二分图时所有点都符合要求，如果不是二分图，那么对于这个双连通分量上的某点，一定可以找到包含该点奇圈，具体证明看大白书317页。所以这道题最关键的还是求出双连通分量以及用黑白二着色去判断是否为二分图。

#include<bits/stdc++.h>
using namespace std;

const int maxn = 1050;
const int maxm = 100050;

int n, m;
int a[maxn][maxn];//输入
vector<int> g[maxn];//输入图的补图

int dfs_clock, bcc_cnt;
int pre[maxn], low[maxn], bccno[maxn], odd[maxn], color[maxn];
bool iscut[maxn];
vector<int> bcc[maxn];

struct edge {
    int u, v;
    edge(int uu, int vv) :u(uu), v(vv) {}
};
stack<edge> s;

bool bipartite(int u, int num) {//在第num个点-双联通分量中着色
    for (int i = 0; i < g[u].size(); ++i) {
        int v = g[u][i];
        if (bccno[v] != num) continue;
        if (color[v] == color[u]) return false;
        if (color[v] == 0) {
            color[v] = 3 - color[u];
            if (!bipartite(v, num)) return false;
        }
    }
    return true;
}

int dfs(int u, int fa) {
    int lowu = pre[u] = ++dfs_clock;
    int child = 0;
    for (int i = 0; i < g[u].size(); ++i) {
        int v = g[u][i];
        edge e = edge(u, v);
        if (0 == pre[v]) {
            ++child;
            s.push(e);
            int lowv = dfs(v, u);
            lowu = min(lowu, lowv);
            if (lowv >= pre[u]) {
                iscut[u] = true;
                ++bcc_cnt;
                bcc[bcc_cnt].clear();
                while (1) {
                    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 (u == x.u && v == x.v) break;
                }
            }
        }
        else if (pre[v] < pre[u] && v != fa) {
            s.push(e);
            lowu = min(lowu, pre[v]);
        }
    }
    if (fa < 0 && child == 1) { iscut[u] = false; }
    return low[u] = lowu;
}

void find_bcc(int n) {
    memset(pre, 0, sizeof(pre));
    memset(iscut, 0, sizeof(iscut));
    memset(bccno, 0, sizeof(bccno));
    dfs_clock = bcc_cnt = 0;
    for (int i = 0; i < n; ++i) {
        if (0 == pre[i]) dfs(i, -1);
    }
}

int main() {
    while (scanf("%d%d", &n, &m) == 2) {
        if (0 == n && 0 == m) break;
        memset(a, 0, sizeof(a));
        for (int i = 0; i <= n; ++i) g[i].clear();

        for (int i = 0; i < m; ++i) {
            int from, to;
            scanf("%d%d", &from, &to);
            --from;
            --to;
            a[from][to] = a[to][from] = 1;
        }

        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                if (0 == a[i][j]) {
                    g[i].push_back(j);
                    g[j].push_back(i);
                }
            }
        }
        find_bcc(n);

        memset(odd, 0, sizeof(odd));
        for (int i = 1; i <= bcc_cnt; ++i) {
            memset(color, 0, sizeof(color));
            int u = bcc[i][0];
            color[u] = 1;
            if (!bipartite(u, i)) {
                for (int j = 0; j < bcc[i].size(); ++j) odd[bcc[i][j]] = 1;
            }
        }

        int ans = n;
        for (int i = 0; i < n; ++i) {
            if (odd[i]) --ans;
        }
        printf("%d\n", ans);
    }
    return 0;
}