Knights of the Round Table

题目链接

题意：

n个人开会，会议人数至少为三且为奇数。有些人相互憎恨，这些人不能邻座。统计有几个人不能参加任意一个会议

输入：n，m。m行包括两个整数k1、k2表示两个人相互憎恨。输入结束标志为n=m=0

输出：无法参加任何会议的人数
分析：

对于存在割点的图，割点两侧的人肯定不能在一个会议中（不能构成环）。而对于不存在割点的一个极大子图，显然任意两个点都可以在一个会议中。然后的问题就是保证奇环。这里就要用到一个十分重要的性质：二分图中没有奇环。那么就可以判断一个图是否是二分图，如果不是，那么必然有一个奇环。然后利用这个奇环，对于这个图中的任意一点v可以构造出包括v的一个奇环（证明参见大白书P317）
关键：

分析出能参加会议的人必然在一个点双连通分量中

利用二分图判断图中存在奇环

图中存在奇环，那么对于任意一个点v，必然有包含v的奇环

判断双连通分量是否是二分图时对割点的处理

const int MAXV = 1100;
const int MAXE = 1000100;

//无向图的双连通分量
int pre[MAXV], iscut[MAXV], bccno[MAXV], dfs_clock, bcc_cnt; // 割顶的bccno无意义
struct Edge
{
int u, v;
};
vector<int> G[MAXV], bcc[MAXV];
stack<Edge> S;

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(!pre[v])   // 没有访问过v
{
S.push(e);
child++;
int lowv = dfs(v, u);
lowu = min(lowu, lowv); // 用后代的low函数更新自己
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 < 0 && child == 1) iscut[u] = 0;
return lowu;
}

void find_bcc(int n)
{
// 调用结束后S保证为空，所以不用清空
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(i, -1);
};

int color[MAXV];
bool bipartite(int u, int b)
{
REP(i, G[u].size())
{
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;
}

bool can[MAXV][MAXV];
bool odd[MAXV];

int main()
{
//    freopen("in.txt", "r", stdin);
int n, kase;
while (~RII(n, kase) && n)
{
CLR(can, true);
CLR(odd, false);
REP(i, n) G[i].clear();

REP(i, kase)
{
int a, b;
RII(a, b); a--; b--;
can[a][b] = can[b][a] = false;
}
REP(i, n) FF(j, i + 1, n)
if (can[i][j])
{
G[i].push_back(j);
G[j].push_back(i);
}
find_bcc(n);
int ans = 0;
FE(i, 1, bcc_cnt)
{
//主要是处理割点
REP(j, bcc[i].size()) bccno[bcc[i][j]] = i;
color[bcc[i][0]] = 1;
if (!bipartite(bcc[i][0], i))
{
REP(j, bcc[i].size())
{
odd[bcc[i][j]] = true;
color[bcc[i][j]] = 0;
}
}
REP(j, bcc[i].size()) color[bcc[i][j]] = 0;
}
REP(i, n)
if (!odd[i])
ans++;
WI(ans);
}
return 0;
}