UVALive

Problem  UVALive - 3523 - Knights of the Round Table

Time Limit: 4500 mSec

Problem Description

Input

The input contains several blocks of test cases. Each case begins with a line containing two integers 1 ≤ n ≤ 1000 and 1 ≤ m ≤ 1000000. The number n is the number of knights. The next m lines describe which knight hates which knight. Each of these m lines contains two integers k1 and k2, which means that knight number k1 and knight number k2 hate each other (the numbers k1 and k2 are between 1 and n). The input is terminated by a block with n = m = 0.

Output

For each test case you have to output a single integer on a separate line: the number of knights that have to be expelled.

 

Sample Input

5 5 1 4 1 5 2 5 3 4 4 5 0 0

Sample Output

2

题解：双连通分量+二分图性质及判断，首先抽象出本题的模型，可以相邻而坐的骑士之间连一条边，对于简单奇环中的每一个骑士都可以参加会议，而不被任意一个简单奇环包含的骑士不能参加会议，因此此题就是统计不在任意一个简单奇环中的节点个数，做出这个题首先需要知道两个知识点

　　一、二分图中必定没有奇环

　　二、点双连通分量是满足如下性质：任意两条边都在同一个简单环中

通常来说如果要求任意两条边在同一个简单环中,那么就是求点-双连通，因此此题就相当于求完点双连通之后判断一下每个双连通分量是否是二分图，其实还需要证明一个东西就是如果该双连通分量不是二分图，那么其中每一个节点都会存在于某个奇环内，证明很简单不赘述。有了这些理论基础之后其实就是两个模板放在一起即可。

#include <bits/stdc++.h>

using namespace std;

#define REP(i, n) for (int i = 1; i <= (n); i++)
#define sqr(x) ((x) * (x))

const int maxn = 1000 + 10;
const int maxm = 30 + 10;
const int maxs = 10000 + 10;

typedef long long LL;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;

const LL unit = 1LL;
const int INF = 0x3f3f3f3f;
const LL mod = 1000000007;
const double eps = 1e-14;
const double inf = 1e15;
const double pi = acos(-1.0);

struct Edge
{
    int u, v;
};

int gra[maxn][maxn];
int n, m;
int dfs_clock, bcc_cnt, bccno[maxn], pre[maxn], is_cut[maxn];
int color[maxn], odd[maxn];
vector<int> G[maxn], bcc[maxn];

stack<Edge> S;

int dfs(int u, int fa)
{
    int lowu = pre[u] = ++dfs_clock;
    int child = 0;
    for (auto v : G[u])
    {
        Edge e = (Edge){u, v};
        if (!pre[v])
        {
            S.push(e);
            child++;
            int lowv = dfs(v, u);
            lowu = min(lowu, lowv);
            if (lowv >= pre[u])
            {
                is_cut[u] = 1;
                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)
        is_cut[u] = 0;
    return lowu;
}

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

bool bipartite(int u, int cnt)
{
    for (auto v : G[u])
    {
        if (bccno[v] != cnt)
            continue;
        if (color[v] == color[u])
        {
            return false;
        }
        if (!color[v])
        {
            color[v] = 3 - color[u];
            if (!bipartite(v, cnt))
            {
                return false;
            }
        }
    }
    return true;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    while (cin >> n >> m && (n || m))
    {
        for (int i = 0; i < n; i++)
        {
            bcc[i].clear();
            G[i].clear();
        }
        memset(gra, 0, sizeof(gra));
        int u, v;
        for (int i = 0; i < m; i++)
        {
            cin >> u >> v;
            u--, v--;
            gra[u][v] = gra[v][u] = 1;
        }
        for (int i = 0; i < n; i++)
        {
            for (int j = i + 1; j < n; j++)
            {
                if (!gra[i][j])
                {
                    G[i].push_back(j);
                    G[j].push_back(i);
                }
            }
        }
        find_bcc();
        memset(odd, 0, sizeof(odd));
        for (int i = 1; i <= bcc_cnt; i++)
        {
            for (auto v : bcc[i])
            {
                bccno[v] = i;
            }
            memset(color, 0, sizeof(color));
            int u = bcc[i][0];
            color[u] = 1;
            if (!bipartite(u, i))
            {
                for (auto v : bcc[i])
                {
                    odd[v] = 1;
                }
            }
        }
        int ans = n;
        for (int i = 0; i < n; i++)
        {
            if (odd[i])
                ans--;
        }
        cout << ans << endl;
    }
    return 0;
}