2942

/*
题目大意是：一些骑士，他们都有自己的仇人，所以安排座位的时候，必须邻座没有仇人。
但是某些人可能无法安排座位，问无法安排座位的人有多少个

解法：把所有的仇人关系建立图，求补图，在补图中，所有连接边的两个顶点可以做邻居
这个图可能存在割点，所以我们要找出连通分量，如果连通分量存在奇圈，那么可以满足，如果不存在
去除所有该连通分量的人

最后输出去除的人数

这道题让我知道了我写的点连通分量是有问题的，在碰到割点的时候，从栈中输出分量，碰到割点连接的儿子的时候停止
可是我写的是当下一个点是割点的时候停止，就这一点小小的不同，就一直WA.现在我还不知道为什么会错，因为割点和它的儿子在栈中
是不连续的吗？
*/



// include file
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cctype>
#include <ctime>

#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <bitset>

#include <algorithm>
#include <string>
#include <vector>
#include <queue>
#include <set>
#include <list>
#include <functional>

using namespace std;

// typedef
typedef long long LL;
typedef unsigned long long ULL;
typedef __int64 Bint;

// 
#define read freopen("in.txt","r",stdin)
#define write freopen("out.txt","w",stdout)
#define FORi(a,b,c) for(int i=(a);i<(b);i+=c)
#define FORj(a,b,c) for(int j=(a);j<(b);j+=c)
#define FORk(a,b,c) for(int k=(a);k<(b);k+=c)
#define FORp(a,b,c) for(int p=(a);p<(b);p+=c)
#define FORii(a,b,c) for(int ii=(a);ii<(b);ii+=c)
#define FORjj(a,b,c) for(int jj=(a);jj<(b);jj+=c)
#define FORkk(a,b,c) for(int kk=(a);kk<(b);kk+=c)

#define FF(i,a)    for(int i=0;i<(a);i++)
#define FFD(i,a)   for(int i=(a)-1;i>=0;i--)

#define Z(a) (a<<1)
#define Y(a) (a>>1)

const double eps = 1e-6;
const double INFf = 1e10;
const int INFi = 1000000000;
const double Pi = acos(-1.0);

template<class T> inline T sqr(T a){return a*a;}
template<class T> inline T TMAX(T x,T y)
{
    if(x>y) return x;
    return y;
}
template<class T> inline T TMIN(T x,T y)
{
    if(x<y) return x;
    return y;
}
template<class T> inline void SWAP(T &x,T &y)
{
    T t = x;
    x = y;
    y = t;
}
template<class T> inline T MMAX(T x,T y,T z)
{
    return TMAX(TMAX(x,y),z);
}


// code begin
#define MAXN 1010
#define MAXM 1000010
bool mp[MAXN][MAXN];
struct node1
{
    int e;
    int next;
};
struct node2
{
    int next;
};
node1 mem[MAXM];
node2 G[MAXN];
int N,M;

int dfn[MAXN];       ///
int low[MAXN];        //
bool used[MAXN];     //
int cnt;

int stk[MAXN],top; // 辅助栈
int block[MAXN]; // 存贮快
int bsize; //每个块的大小

bool expll[MAXN]; //判断某个点是否被剔除
bool bused[MAXN]; //辅助判断二分图用
bool bvist[MAXN];
int color[MAXN]; //染色用
bool ok;

void Add_edge(int dx,int a,int b)
{
    mem[dx].e = b;
    mem[dx].next = G[a].next;
    G[a].next = dx;
}

void Isbipartial( int st,int co)
{
    if(!ok) return;
    color[st] = co;
    bvist[st] = true;
    int dx = G[st].next;
    while(dx!=-1)
    {
        int v = mem[dx].e;
        if( bused[v] )
        {
            if(!bvist[v])
            {
                Isbipartial(v,5-co);
                if(!ok) return;
            }
            else
            {
                if(color[v]==color[st])
                {
                    ok = false;
                    return;
                }
            }
        }
        dx = mem[dx].next;
    }
}

void BCC_tarjan(int i,int fa)
{
    dfn[i] = cnt;
    low[i] = cnt;
    used[i] = true;
    cnt ++;
    stk[top++] = i;
    int dx = G[i].next;
    while(dx!=-1)
    {
        int v = mem[dx].e;
        if(!used[v])
        {
            BCC_tarjan(v,i);
            low[i] = TMIN(low[i],low[v]);
            
            if(low[v]>=dfn[i])
            {// 割点

                memset(bused,0,sizeof(bused));
                memset(color,0,sizeof(color));
                memset(bvist,0,sizeof(bvist));
                int tp;
                bsize = 0;
                
                do
                {
                    tp = stk[--top];
                    block[bsize++] = tp;
                    bused[tp] = true;
                }while(tp != v); //退出到v就可以了，u还可以在别的其他的块中
                

                /*
                while(stk[top-1]!=i)
                {
                    tp = stk[--top];
                    block[bsize++] = tp;
                    bused[tp] = true;
                }
                */

                block[bsize++] = i;
                bused[i] = true;

                ok = true;
                Isbipartial(i,2);
                if( !ok ) //如果是二分图，那么所有的点都要被剔除了，因为它们形成不了奇圈
                {
                    FORj(0,bsize,1)
                        expll[block[j]] = true;
                }            


            }
        }
        else if(v!=fa)
        {
            low[i] = TMIN(low[i],dfn[v]);
        }

        dx = mem[dx].next;
    }

}

int main()
{
    read;
    write;
    int dx,a,b;
    while(scanf("%d %d",&N,&M)!=-1)
    {
        if(N+M==0)
        {
            break;
        }
        dx = 0;
        memset(mp,0,sizeof(mp));
        FORi(0,M,1)
        {
            scanf("%d %d",&a,&b);
            mp[a][b] = 1;
            mp[b][a] = 1;
        }

        FORi(1,N+1,1)
        {
            G[i].next = -1;
        }
        // 建立补图
        FORi(1,N+1,1)
        {
            FORj(1,N+1,1)
            {
                if(!mp[i][j]&&i!=j)
                {
                    Add_edge(dx++,i,j);
                }
            }
        }
        
        //CheckG();

        // 求点连通分量
        memset(dfn,0,sizeof(dfn));
        memset(low,0,sizeof(low));
        memset(used,0,sizeof(used));
        cnt = 1;
        top = 0;
        memset(expll,0,sizeof(expll));
        FORi(1,N+1,1)
        {
            if(!used[i])
            {
                BCC_tarjan(i,-1);
            }
        }
        
        // 
        int ans = 0;
        FORi(1,N+1,1)
        {
            if(expll[i])
                ans++;
        }
        printf("%d\n",N-ans);
    }
    return 0;
}