cf 659E（强连通分量，判断无向图是否成环，拓扑排序思想）

E. New Reform

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Berland has n cities connected by m bidirectional roads. No road connects a city to itself, and each pair of cities is connected by no more than one road. It is not guaranteed that you can get from any city to any other one, using only the existing roads.

The President of Berland decided to make changes to the road system and instructed the Ministry of Transport to make this reform. Now, each road should be unidirectional (only lead from one city to another).

In order not to cause great resentment among residents, the reform needs to be conducted so that there can be as few separate cities as possible. A city is considered separate, if no road leads into it, while it is allowed to have roads leading from this city.

Help the Ministry of Transport to find the minimum possible number of separate cities after the reform.

Input

The first line of the input contains two positive integers, n and m — the number of the cities and the number of roads in Berland (2 ≤ n ≤ 100 000, 1 ≤ m ≤ 100 000).

Next m lines contain the descriptions of the roads: the i-th road is determined by two distinct integers xi, yi (1 ≤ xi, yi ≤ n, xi ≠ yi), wherexi and yi are the numbers of the cities connected by the i-th road.

It is guaranteed that there is no more than one road between each pair of cities, but it is not guaranteed that from any city you can get to any other one, using only roads.

Output

Print a single integer — the minimum number of separated cities after the reform.

Examples

input

4 3
2 1
1 3
4 3

output

1

input

5 5
2 1
1 3
2 3
2 5
4 3

output

0

input

6 5
1 2
2 3
4 5
4 6
5 6

output

1

Note

In the first sample the following road orientation is allowed: , , .

The second sample: , , , , .

The third sample: , , , , .

题意：原本该图是一个无向图，现在要把它变成有向图，问你怎样让入读为0的点最少。

思路：强连通分量缩完点之后对每一个缩点，只要这个缩点内部有环，入度为0的点最少肯定是0，若没环，入度为0的点最少是1，所以将问题转化为了求无向图是否有环的问题，由于是缩点内的一些点，我们没法直接去得到边数，所以我用了类似拓扑排序的方法进行标记来找是否存在环（拓扑排序是对有向图，但是如果加一个标记也可以来对无向图进行判环）。不过刚开始wa了俩遍，因为缩点如果是本身就只有2个以下的话，那就表示肯定是入度为0了，这个特殊的数据没考虑……

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include<string.h>
#include<algorithm>
#include<math.h>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
const int N=100010;
struct data
{
    int to,next;
} tu[N*2];
int head[N];
int ip;
int dfn[N], low[N];///dfn[]表示深搜的步数，low[u]表示u或u的子树能够追溯到的最早的栈中节点的次序号
int sccno[N];///缩点数组，表示某个点对应的缩点值
int step;
int scc_cnt;///强连通分量个数
void init()
{
    ip=0;
    memset(head,-1,sizeof(head));
}
void add(int u,int v)
{
    tu[ip].to=v,tu[ip].next=head[u],head[u]=ip++;
}
vector<int> scc[N];///得出来的缩点，scc[i]里面存i这个缩点具体缩了哪些点
stack<int> S;
void dfs(int u)
{
    dfn[u] = low[u] = ++step;
    S.push(u);
    for (int i = head[u]; i !=-1; i=tu[i].next)
    {
        int v = tu[i].to;
        if (!dfn[v])
        {
            dfs(v);
            low[u] = min(low[u], low[v]);
        }
        else if (!sccno[v])
            low[u] = min(low[u], dfn[v]);
    }
    if (low[u] == dfn[u])
    {
        scc_cnt += 1;
        scc[scc_cnt].clear();
        while(1)
        {
            int x = S.top();
            S.pop();
            if (sccno[x] != scc_cnt) scc[scc_cnt].push_back(x);
            sccno[x] = scc_cnt;
            if (x == u) break;
        }
    }
}
void tarjan(int n)
{
    memset(sccno, 0, sizeof(sccno));
    memset(dfn, 0, sizeof(dfn));
    step = scc_cnt = 0;
    for (int i = 1; i <=n; i++)
        if (!dfn[i]) dfs(i);
}
int rd[N];
bool vis[N]= {0};
int main()
{
    int m,n;
    init();
    memset(rd,0,sizeof(rd));
    scanf("%d%d",&n,&m);
    for(int i=0; i<m; i++)
    {
        int a,b,flag=0;
        scanf("%d%d",&a,&b);
        for(int j=head[a]; j!=-1; j=tu[j].next)
            if(tu[j].to==b)
            {
                flag=1;
                break;
            }
        if(flag)
            continue;
        add(a,b);
        add(b,a);
        rd[a]++,rd[b]++;
    }
    tarjan(n);
    ll ans=0;
    for(int i=1; i<=scc_cnt; i++)
    {
        queue<int>q;
        int l=scc[i].size();
        if(l<=2){ans++;continue;}
        for(int j=0; j<l; j++)
            if(rd[scc[i][j]]==1)
                q.push(scc[i][j]);
        while(!q.empty())
        {
            int x=q.front();
            rd[x]--;
            vis[x]=1;
            q.pop();
            for(int i=head[x]; i!=-1; i=tu[i].next)
            {
                int to=tu[i].to;
                rd[to]--;
                if(rd[to]==1)
                    q.push(to);
            }
        }
        int flag=1;
        for(int j=0; j<l; j++)
            if(!vis[scc[i][j]])
            {
                flag=0;
                break;
            }
        if(flag)
            ans++;
    }
    cout<<ans<<endl;
    return 0;
}