using namespace std;

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <vector>
#include <iostream>
#include <cmath>
#include <cassert>
#include <deque>
#include <ctime>
#define NDEBUG

#define FIN "felinare.in"
#define FOUT "felinare.out"

#define maxn 6000


#ifndef NDEBUG
int stp;
#endif


//vector<vector<short int> > x;
//vector<vector<short int> > poz;

//vector<bool>  a[2*maxn];
//char aa[2*maxn][(maxn/4)];

struct nod { short x, poz; bool cap; nod(){};  nod(short a, short b, bool c){x=a; poz=b; cap=c;};};

vector<vector<nod> > x;

int n, m, E;
short int source, sink;
//int t[maxn<<1];
short int d[maxn<<1];
bool Viz[maxn<<1];
int bfs();
void solve();

void read()
{

	int i,p, q;
		scanf("%d %d\n", &n, &m);
	

		source=0;
		sink=n+n+1;
		x.resize(n+n+2);
		//poz.resize(n+n+2);
		for(i=0;i<m;++i)
		{
			scanf("%d %d\n", &p, &q);  
			//if(!(aa[p][(q+n)>>3]&(1<<((q+n)&7))))
			  {
			    //  aa[p][(q+n)>>3]|=(1<<((q+n)&7));
			    
			    x[p].push_back(nod(q+n, x[q+n].size(), 1));
			    x[q+n].push_back(nod(p, x[p].size()-1, 0));
			  }
		//x[p].push_back(q+n);
			//		poz[p].push_back(x[q+n].size());
			//poz[q+n].push_back(x[p].size());
			//x[p].push_back(q+n);
			//x[q+n].push_back(p);
			
			
		}
		for(i=1;i<=n;++i)
		  {
		    //	    aa[source][i>>3]|=(1<<(i&7));
		    
		    x[source].push_back(nod(i, x[i].size(), 1));
		    x[i].push_back(nod(source, x[source].size()-1, 0));


		    
		    //		    poz[source].push_back(x[i].size());
		    //poz[i].push_back(x[source].size());
		    //x[source].push_back(i);
		    //x[i].push_back(source);
		  }		    
		for(i=n+1;i<sink;++i) 
		  {
		    //aa[i][sink>>3]|=1<<(sink&7);
		    // a[i][sink]=1;
		    x[i].push_back(nod(sink, x[sink].size(), 1));
		    x[sink].push_back(nod(i, x[i].size()-1, 0));

		    //    poz[i].push_back(x[sink].size());
		    //poz[sink].push_back(x[i].size());
		    //x[i].push_back(sink);
		    // x[sink].push_back(i);
		  }
		
		

		
}


int bfs()
{
	short Q[maxn<<1], p=1, q=1;
	bool viz[maxn<<1];
		
	memset(viz, 0,sizeof(viz));
	//memset(t, -1, sizeof(t));
	memset(d, 0, sizeof(d));
	viz[source]=1;
	Q[1]=source;
	d[1]=0;
	int u;
	int i, j;
	vector<nod>::iterator it,jt, xu;
	
	while(p<=q)
	{
		u=Q[p++];
		xu=x[u].end();
		for(it=x[u].begin() ;it!=xu;++it)
		{
		  
		  if(!viz[it->x]&& (it->cap)) //(aa[u][(i)>>3]&(1<<((i)&7))))
			{
				viz[it->x]=1;
				d[it->x]=d[u]+1;
				Q[++q]=it->x;
			       
			}
		}
	}
	
	return d[sink];
}



int flow, ok=1, dsink,nr;
int counter;

void DFS(short nd)
{
  //printf("%d %d\n", nd, nr);
  if(nr>dsink) return;
  if(nd==sink) { ++flow; ok=0; return ;}
  Viz[nd]=1;
  vector<nod>::iterator it, xend;
  xend=x[nd].end();
  int i;
  for(it=x[nd].begin();it!=xend;++it)
    if(d[nd]==d[it->x]-1)
     {
      
       if(ok && !Viz[it->x] &&  (it->cap))   //(aa[nd][i>>3]&(1<<(i&7))))//a[nd][i])
	{
	  ++nr;
	  DFS(it->x);
	  --nr;
	  if(!ok)
	    {
	      //(*it).cap=0;
		it->cap=0;
		x[it->x][it->poz].cap=1;
	      //aa[nd][i>>3]&=~(1<<(i&7)); //a[nd][i]=0;
	      // aa[i][nd>>3]|=(1<<(nd&7)); //a[i][nd]=1;
	      
	      if(nd==source) ok=1;
	      else break;
	    }
	}
     }
}


void solve()
{
	int i, j;
	int p;
	
	flow=0;
	vector<nod>::iterator it;
	int num=0;
	int sq=(int)sqrt(n+n)+3;
	int ntimes=0;


	while(dsink=bfs())
	{	
	 
	  memset(Viz, 0, sizeof(Viz));
	  ok=1;
	  nr=0;
	 
	  DFS(source);
	 
		
      	}
	printf("%d\n", 2*n-flow);
	
}






int main()
{
  //freopen("fel.in", "r", stdin);
  freopen(FIN, "r", stdin);
	
    	freopen(FOUT, "w", stdout);
  // double s=clock();
	read();
	
int i, j;

	solve();
	//printf("%f\n", (clock()-s)/(double)CLOCKS_PER_SEC);
	
	
	return 0;
}