pku2942 Knights of the Round Table

#include <iostream>
#include <stack>
#include <algorithm>
using namespace std;

#define MAXN 1001
#define min(a,b) (a<b?a:b)

typedef pair<int,int> PAIR;

int p[MAXN],ecnt,n,m,dfn[MAXN],lowlink[MAXN],sign,st,color[MAXN];
bool hate[MAXN][MAXN],mark[MAXN],ans[MAXN];
stack<PAIR> sta;

struct Edge{
    int v,next;
}edg[MAXN*MAXN];


void init(){
    ecnt=0;
    memset(p,-1,sizeof(p));
    memset(dfn,-1,sizeof(dfn));
    memset(hate,false,sizeof(hate));
    sign=0;
    while(!sta.empty())
        sta.pop();
    memset(ans,false,sizeof(ans));
}

bool check_odd(int u,int col){//检查该子块是否为二分图
    int i,v;
    color[u]=col;
    for(i=p[u];i!=-1;i=edg[i].next){
        v=edg[i].v;
        if(mark[v]){
            if(color[v]==0){
                if(check_odd(v,-col))
                    return true;
            }
            else if(col==color[v])
                return true;
        }
    }
    return false;
}


void dfs(int pre,int u){
    int i,j,v,x,y;
    PAIR P;
    dfn[u]=lowlink[u]=++sign;
    for(i=p[u];i!=-1;i=edg[i].next){
        v=edg[i].v;
        if(v!=pre && dfn[u]>dfn[v]){//边u-v未访问过
            sta.push(make_pair(u,v));
        }
        if(dfn[v]==-1){//顶点v未访问过
            dfs(u,v);
            lowlink[u]=min(lowlink[u],lowlink[v]);
            if(dfn[u]<=lowlink[v]){//u是割点，找到一个重连通分量
                memset(mark,false,sizeof(mark));
                st=u;
                    
                do{
                    P=sta.top();
                    x=P.first;
                    y=P.second;
                    sta.pop();
                    mark[x]=mark[y]=true;
                }while(!( (x==u && y==v) || (x==v && y==u) ));

                memset(color,0,sizeof(color));
                if(check_odd(st,1)){
                    for(j=1;j<=n;j++)
                        ans[j]|=mark[j];
                }
            }
        }
        else if(v!=pre){
            lowlink[u]=min(lowlink[u],dfn[v]);
        }
    }
}

int solve(){
    int i,anscnt=0;
    for(i=1;i<=n;i++){
        if(dfn[i]==-1){
            dfs(-1,i);
        }
    }
    for(i=1;i<=n;i++)
        if(ans[i])
            anscnt++;
    return n-anscnt;
}


int main(){
    int i,u,v;
    while(scanf("%d%d",&n,&m) && n && m){
        init();
        for(i=0;i<m;i++){
            scanf("%d%d",&u,&v);
            hate[u][v]=hate[v][u]=true;
        }
        for(u=1;u<=n;u++){
            for(v=u+1;v<=n;v++){
                if(!hate[u][v]){
                     edg[ecnt].v=v;
                     edg[ecnt].next=p[u];
                     p[u]=ecnt++;
                     edg[ecnt].v=u;
                     edg[ecnt].next=p[v];
                    p[v]=ecnt++;
                }
            }
        }


        printf("%d\n",solve());
    }
    return 0;
}