UVA 1364

尤其是不要谈了些什么，我想A这个问题！

FML啊.....！

题意来自 kuangbin：

亚瑟王要在圆桌上召开骑士会议。为了不引发骑士之间的冲突。 而且可以让会议的议题有令人惬意的结果，每次开会前都必须对出席会议的骑士有例如以下要求： 1、  相互憎恨的两个骑士不能坐在直接相邻的2个位置； 2、  出席会议的骑士数必须是奇数，这是为了让投票表决议题时都能有结果。  
注意：1、所给出的憎恨关系一定是双向的。不存在单向憎恨关系。 2、因为是圆桌会议。则每一个出席的骑士身边必然刚好有2个骑士。

即每一个骑士的座位两边都必然各有一个骑士。 3、一个骑士无法开会，就是说至少有3个骑士才可能开会。  
首先依据给出的互相憎恨的图中得到补图。 然后就相当于找出不能形成奇圈的点。 利用以下两个定理： （1）假设一个双连通分量内的某些顶点在一个奇圈中（即双连通分量含有奇圈）。 那么这个双连通分量的其它顶点也在某个奇圈中； （2）假设一个双连通分量含有奇圈，则他必然不是一个二分图。反过来也成立。这是一个充要条件。

 
所以本题的做法，就是对补图求点双连通分量。 然后对于求得的点双连通分量，使用染色法推断是不是二分图，不是二分图。这个双连通分量的点是能够 存在的 */

这样，思路例如以下：

1.找出全部的双连通分量；

2.推断找出的双联通分量似不似一个二分图，假设是二分图，说明它不含有奇圈，不符合题意，反之符合题意，所以在该连通分量中的点都是能够上桌开会的点...

详细思路就是这个样子了~然后照着刘汝佳大白书上的 找双联通分量 的算法，以及 染色法判二分图 的方法，就ok了

没有办法。太水了我仅仅能理解到这里才干做题了尼玛啊 ！

！

T_T.....

没有大神讲，变量的意思想了一上午卧槽好傻逼。

。。

接下来会有一篇给一些变量凝视的！

大白书上的代码。造福弱逼不用谢。

#include <cstdio>  
#include <cstring>  
#include <vector>  
#include <stack>  
using namespace std;  
  
const int N = 1005;  
  
struct Edge {  
    int u, v;  
    Edge() {}  
    Edge(int u, int v) {  
        this->u = u;  
        this->v = v;  
    }  
};  
            ///bccno[]是用来表示 编号为i的点在哪一个双连通分量中！

            ///bcc_cnt是用来表示 总共同拥有几个双连通分量
int pre[N], bccno[N], dfs_clock, bcc_cnt;  
bool iscut[N];  
  
vector<int> g[N], bcc[N];///用来存下来每个双连通分量
stack<Edge> S;  
  
int dfs_bcc(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 (!pre[v]) {  
            S.push(e);  
            child++;  
            int lowv = dfs_bcc(v, u);  
            lowu = min(lowu, lowv);  
            if (lowv >= pre[u]) {  
                iscut[u] = true;  
                bcc_cnt++; bcc[bcc_cnt].clear(); //start from 1  
                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 (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 < 0 && child == 1) iscut[u] = false;  
    return 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 (!pre[i]) dfs_bcc(i, -1);  
}  
  
int odd[N], color[N];  
  
bool bipartite(int u, int b) {  
    for (int i = 0; i < 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] = 3 - color[u];  
            if (!bipartite(v, b)) return false;  
        }  
    }  
    return true;  
}  
  
int n, m, A[N][N];  
  
int main() {  
    int cas = 0;  
    while (~scanf("%d%d", &n, &m) && n) {  
        for (int i = 0; i < n; i++) g[i].clear();  
        memset(A, 0, sizeof(A));  
        for (int i = 0; i < m; i++) {  
            int u, v;  
            scanf("%d%d", &u, &v); u--; v--;  
            A[u][v] = A[v][u] = 1;  
        }  
        for (int u = 0; u < n; u++) {  
            for (int v = u + 1; v < n; v++)  
                if (!A[u][v]) {  
                    g[u].push_back(v);  
                    g[v].push_back(u);  
                }  
        }  
        find_bcc(n);  
        memset(odd, 0, sizeof(odd));  
        for (int i = 1; i <= bcc_cnt; i++) {  
            memset(color, 0, sizeof(color));  
            for (int j = 0; j < bcc[i].size(); j++) bccno[bcc[i][j]] = i;  
            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++)  
            ans -= odd[i];  
        printf("%d
", ans);  
    }  
    return 0;  
}  

版权声明：请注明出处撒...http://blog.csdn.net/u013382399