圆桌骑士 图的连通性

题目描述

圆桌骑士是一个非常吸引人的职业。因此，在最近几年里，亚瑟王史无前例的扩招圆桌骑士，并不令人惊讶。现在这里有许多圆桌骑士，每个圆桌骑士都收到一份珍贵的邀请函，被邀请去英灵殿圆桌。这些骑士将要环绕着坐在一个圆桌旁，但通常只有一小部分骑士会来，因为剩下的骑士正忙着在全国各地为人民服务。

不幸的是，这些圆桌骑士的酒量不行，很容易喝高。当他们喝高时，一些不幸的便当事件将会发生。因此，亚瑟王请来了长门大神，来确保在未来不会有类似的事情发生。在仔细分析了这个问题后，长门大神意识到要想避免骑士之间相互斗殴，当且仅当他们在圆桌旁所坐的位置，符合以下条件：

1. 某些骑士之间有仇，避免相互之间有仇的骑士挨在一块。

2. 当场上有偶数个骑士时，若通过投票解决问题的话，正方与反方的票数可能相同，这会令骑士们非常不爽。因此，只能有奇数个骑士坐在圆桌旁。

长门大神会尽量的满足以上两个条件，否则她会代替亚瑟王宣布散会（若只有一个骑士在场的话，也会宣布散会，因为一个骑士不管怎么坐，都不可能环绕一个圆桌）。这将意味着无论如何安排，一些骑士都无法到场，无法坐在圆桌旁边（其中一种情况即为当这个骑士对所有骑士都有仇时，当然还可能是其他情况）。若一个圆桌骑士永远无法到场，则这个骑士就失去了“圆桌”的意义，他将会被开除。这些骑士将会被降级，降到诸如“爱的战士”“蘑菇骑士”“人鱼骑士”之类的职阶。

为了帮助长门大神，你必须写一个程序来计算会有多少圆桌骑士会被开除。

输入

输入有多组，每组第一行两个整数，N和M，N为骑士的数量。

接下来M行每行两个整数i,j，表示i与j之间有仇恨。

输入数据保证不会有重边和自环。

0 0 代表输入结束

输出

一个整数，为所求的答案。

样例输入

5 51 21 32 32 43 50 0

样例输出

2

提示

1 ≤ n ≤ 1000 and 1 ≤ m ≤ 1000000

步骤：

1.先将没有仇恨的骑士两两建边。

2.求一遍双联通分量。

3.在同一联通分量里面找奇环，若该联通分量存在奇环，则该联通分量的任意两点都可以形成奇环。（下面有证明）

步骤三的证明：

1.首先明确：若存在奇环，则奇环上任意点必存在两条路径可以到达，而且长度必为一奇一偶。

2.所以如果再添加一个点或几个的话，他们必与此环有联通，且存在两条路径。

3.若单看这新添加的这几个点或这一个点，他们之间一定存在一条路径把他们联通，若该路径为奇数，则可以和环上的偶数路径搭配，构成奇环。反之，若为偶数，则可以和环上的奇数路径搭配，构成奇环。所以无论如何都可以搭配成奇环。

下面是代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<vector>
using namespace std;
 
int gi()
{
    int str=0;
    char ch=getchar();
    while(ch>'9'||ch<'0')ch=getchar();
    while(ch>='0' && ch<='9')str=str*10+ch-'0',ch=getchar();
    return str;
}
const int N=1001;
int n,m;
bool d[N][N];
int num=0;
struct Lin
{
    int next,to;
} a[N*N*2];
int head[N];
int ans=0;
int color[N];
bool c[N];
 
void init(int x,int y)
{
    a[++num].next=head[x];
    a[num].to=y;
    head[x]=num;
}
vector<int>q[N];
int dfn[N],low[N],st[N],top=0,NUM=0,flg[N],bel[N],sum=0;
 
 
void Clear()
{
    memset(d,0,sizeof(d));
    for(int i=1; i<=N-1; i++)
    {
        dfn[i]=low[i]=flg[i]=bel[i]=color[i]=head[i]=st[i]=c[i]=0;
        q[i].clear();
    }
    num=NUM=top=ans=sum=0;
}
 
void dfs(int x,int last)
{
    int u,v;
    dfn[x]=low[x]=++NUM;
    flg[x]=1;
    st[++top]=x;
    for(int i=head[x]; i; i=a[i].next)
    {
        u=a[i].to;
        if(u==last)continue;
        if(!dfn[u])
        {
            dfs(u,x);
            low[x]=min(low[x],low[u]);
            if(low[u]>=dfn[x])
            {
                sum++;
                while(top)
                {
                    v=st[top--];
                    flg[v]=false;
                    bel[v]=sum;
                    q[sum].push_back(v);
                    if(v==u)break;
                }
                q[sum].push_back(x);
            }
        }
        else if(flg[u])low[x]=min(dfn[u],low[x]);
    }
}
 
bool Make(int x)
{
    int u;
    for(int i=head[x]; i; i=a[i].next)
    {
        u=a[i].to;
        if(bel[u]!=bel[x])continue;
        if(color[u]==color[x])return false;
        if(!color[u])
        {
            color[u]=3-color[x];
            if(!Make(u))return false;
        }
    }
    return true;
}
 
void work()
{
    int x,y;
    for(int i=1; i<=m; i++)
    {
        x=gi();
        y=gi();
        d[x][y]=d[y][x]=1;
    }
    for(int i=1; i<=n; i++)
        for(int j=i+1; j<=n; j++)
            if(!d[i][j])init(i,j),init(j,i);
    for(int i=1; i<=n; i++)if(!dfn[i])dfs(i,i);

    bool ff=1;
    int size;
    ans=0;
    for(int i=1; i<=sum; i++)
    {
        if(q[i].size()<=2)continue;
        memset(color,0,sizeof(color));
        color[q[i][0]]=1;
        size=q[i].size();
        for(int j=0;j<size;j++)bel[q[i][j]]=i;
        ff=Make(q[i][0]);
        if(!ff)for(int j=0;j<size;j++)c[q[i][j]]=1;
    }
    for(int i=1;i<=n;i++)if(!c[i])ans++;
    printf("%d\n",ans);
}
 
int main()
{
    while(1)
    {
        n=gi();
        m=gi();
        if(!n && !m)break;
        work();
        Clear();
    }
    return 0;
}