POJ - 2942 Knights of the Round Table 二分图染色 点双连通分量 tarjan模板

题意：亚瑟王要在圆桌上召开骑士会议,为了不引发骑士之间的冲突, 
并且能够让会议的议题有令人满意的结果,每次开会前都必须对出席会议的骑士有如下要求: 
1、 相互憎恨的两个骑士不能坐在直接相邻的2个位置;
2、 出席会议的骑士数必须是奇数,这是为了让投票表决议题时都能有结果。
注意:1、所给出的憎恨关系一定是双向的,不存在单向憎恨关系。
        2、由于是圆桌会议,则每个出席的骑士身边必定刚好有2个骑士。即每个骑士的座位两边都必定各有一个骑士。
        3、一个骑士无法开会,就是说至少有3个骑士才可能开会。

首先根据给出的互相憎恨的图中得到补图。
然后就相当于找出不能形成奇圈的点。
利用下面两个定理: 
(1)如果一个双连通分量内的某些顶点在一个奇圈中(即双连通分量含有奇圈), 那么这个双连通分量的其他顶点也在某个奇圈中; 
(2)如果一个双连通分量含有奇圈,则他必定不是一个二分图。反过来也成立,这是一个充要条件。
所以本题的做法,就是对补图求点双连通分量。然后对于求得的点双连通分量,使用染色法判断是不是二分图,不是二分图,这个双连通分量的点是可以存在的

内存别开太大，会mle。

链接：poj - 2942

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#define INF 0x3f3f3f3f

using namespace std;

const int inf = 0x3f3f3f3f;
const int maxn = 1005;
const int maxm = 2000005;

struct Edge {
    int to, next;
} edge[maxm];

int head[maxn], tot;
int low[maxn], dfn[maxn], cnt;
int sstack[maxn], top;
int belong[maxn], scnt;      //  点双连通分量的个数
bool instack[maxn];

bool can[maxn];
bool ok[maxn];  //  标记
int tmp[maxn];  //  暂时存储双连通分量中的点
int cc;         //  tmp的计数
int color[maxn];//  染色

void addedge(int u, int v) {
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
    return;
}

void init() {
    tot = 0;
    memset(head, -1, sizeof(head));
    memset(dfn, 0, sizeof(dfn));
    memset(instack, false, sizeof(instack));
    cnt = scnt = top = 0;
    
    memset(can, false, sizeof(can));
}

bool dfs(int u, int col) {   //  染色判断二分图 
    color[u] = col;
    for (int i = head[u]; i != -1; i = edge[i].next) {
        int v = edge[i].to;
        if (!ok[v]) {
            continue;
        }
        if (color[v] != -1) {
            if (color[v] == col) {
                return false;
            }
            continue;
        }
        if (!dfs(v, !col)) {
            return false;
        }
    }
    return true;
}

void Tarjan(int u, int pre) {
    int v;
    low[u] = dfn[u] = ++cnt;
    sstack[top++] = u;
    instack[u] = true;
    for (int i = head[u]; i != -1; i = edge[i].next) {
        v = edge[i].to;
        if (v == pre) {
            continue;
        }
        if (!dfn[v]) {
            Tarjan(v, u);
            if (low[u] > low[v]) {
                low[u] = low[v];
            }
            if (low[v] >= dfn[u]) {
                scnt++;
                int vn;
                cc = 0;
                memset(ok, false, sizeof(ok));
                do {
                    vn = sstack[--top];
                    belong[vn] = scnt;
                    instack[vn] = false;
                    ok[vn] = true;
                    tmp[cc++] = vn;
                }
                while (vn != v);
                ok[u] = 1;
                
                memset(color, -1, sizeof(color));
                if (!dfs(u, 0)) {
                    can[u] = true;
                    while (cc--) {
                        can[tmp[cc]] = true;
                    }
                }
            }
        }
        else if (instack[v] && low[u] > dfn[v]) {
            low[u] = dfn[v];
        }
    }
}

int g[maxn][maxn];

int main()
{
    int n, m;
    int u, v;
    while (scanf("%d %d", &n, &m) == 2) {
        if (n == 0 && m == 0) {
            break;
        }
        init();
        memset(g, 0, sizeof(g));
        while (m--) {
            scanf("%d %d", &u, &v);
            g[u][v] = g[v][u] = 1;
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if(i != j && g[i][j] == 0) {
                    addedge(i, j);
                }
            }
        }
        for (int i = 1; i <= n; i++) {
            if (!dfn[i]) {
                Tarjan(i, -1);
            }
        }
        int ans = n;
        for (int i = 1; i <= n; i++) {
            if(can[i]) {
                ans--;
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}