/*
无向图 
双连通分量
1 边的双连通分量  e-dcc  极大的不包含桥的连通块
2 点的双连通分量  v-dcc  极大的不包含割点的连通块

删除后不连通 的 两个定义

桥  
 o-o 桥o-o
 | | ↓ | |
 o-o - o-o 
1 如何找桥？ x
            /
           y
x和y之间是桥 <=> dfn[x] < low[y] y无论如何往上走不到x 
                +y能到的最高的点low[y] = dfn[y]

2 如何找所有边的双连通分量？
2.1 将所有桥删掉
2.2 stack
dfn[x] == low[x] 
<=> x无论如何走不到x的上面
<=> 从x开始的子树可以用一个栈存

每个割点至少属于两个连通分量

树里的每条边都是桥
     o
    / \
   o   o
  /\   /\
 o  o o  o

1 边双连通分量 
tarjan回顾
dfn[x] dfs序时间戳 
low[x] x能达到的时间戳最小的点

无向图不存在横插边
     o
    / \
   o   o
  /   / \
 y ← x   o
   →
x能往左的话 由于无向边 所以y也能往右,
那么在之前dfs的时候就把x先于x的父节点加进来了
*/
/*
新建一条道路 使得每两个草场之间都有一个分离的路径
给定一个无向连通图，问最少加几条边，可以将其变为一个边双连通分量

结论：一个边的双连通分量 <=> 任何两个点之间至少存在两个不相交路径
充分性: 对于每两个点都有互相分离的路径的话，则必然为强连通分量
反证 假设有桥(非双连通) x,y必然经过中间的桥 则只x→y的路径必在桥上相交
 o-x 桥y-o
 | | ↓ | |
 o-o - o-o
必要性：图是一个边双连通分量 <=> 不包含桥
        则一定对任意两点x,y 
        x,y之间至少存在两条互相分离(不相交)的路径
反证:假设存在两条相交路径
     那么x→y中间必然有桥
//  o-o-o-o-o 蓝色路径 (从x出发到y经过边数最少的路径)
//   - - - -  绿色路径 
//  x       y

对双连通分量做完缩点后 只剩桥和点
         o
        / \
       o   o
      /\   /\
     o  o o  o
    / \  
   o   o

         o
        / \
       o   o
      /\   /\
     o  o-o  o
    / \   |  |
   o   o__|  |
   |_________|
   可以发现对左右两个叶子节点连通后，根节点连向左右叶子节点的边就可以删去了
   同理 再把第2个和第4个叶子节点连通后，根节点连向第2个和第4个叶子节点的边也可以删去
   第3个叶子节点随便连
  给叶子节点按对称性加上边后就没有桥 <=> 变成边的双连通分量
  这里cnt= 5 加了ans=(cnt+1)/2=3条
  ans >= 下界[cnt/2]取整 == [(cnt+1)/2]取整
        其中 cnt为缩完点后度数==1的点的个数


*/

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 5010, M = 20010;

int n, m;
int h[N], e[M], ne[M], idx;
int dfn[N], low[N], timestamp;
int stk[N], top;
int id[N], dcc_cnt;
bool is_bridge[M];//每条边是不是桥
int d[N];//度数

void add(int a, int b)
{
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx ++;
}

void tarjan(int u, int from)
{
    dfn[u] = low[u] = ++ timestamp;
    stk[ ++ top] = u;

    for (int i = h[u]; i!=-1; i = ne[i])
    {
        int j = e[i];
        if (!dfn[j])//j未遍历过
        {
            tarjan(j, i);//dfs(j)
            low[u] = min(low[u], low[j]);//用j更新u
            if (dfn[u] < low[j])//j到不了u
                // 则x-y的边为桥,
                //正向边is_bridge[i] 反向边is_bridge[i ^ 1]都是桥
                is_bridge[i] = is_bridge[i ^ 1] = true;
                // 这里i==idx 如果idx==奇数 则反向边=idx-1 = idx^1
                //            如果idx==偶数 则反向边=idx+1 = idx^1
        }
        // j遍历过 且i不是反向边(即i不是指向u的父节点的边)
        // 因为我们不能用u的父节点的时间戳更新u
        else if (i != (from ^ 1))
            low[u] = min(low[u], dfn[j]);
    }
    //双连通分量起点u  /
    //                u
    //               /
    //              ne1
    //             ne2 
    if (dfn[u] == low[u])
    {
        ++ dcc_cnt;
        int y;
        do {
            y = stk[top -- ];
            id[y] = dcc_cnt;
        } while (y != u);
    }
}

int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    while (m -- )
    {
        int a, b;
        cin >> a >> b;
        add(a, b), add(b, a);
    }

    tarjan(1, -1);//防止搜反向边 用一个from

    for (int i = 0; i < idx; i ++ )
        //如果边i是桥 在其所连的出边的点j所在强连通分量的度+1
        // 桥两边的双连通分量各+1
        if (is_bridge[i])
            d[id[e[i]]] ++ ;

    int cnt = 0;
    for (int i = 1; i <= dcc_cnt; i ++ )
        if (d[i] == 1)//多少个度数为1的节点(强连通分量)
            cnt ++ ;//需要加的边的数量

    cout << (cnt + 1) / 2 << endl;

    return 0;
}