【强连通】

/*
题目简述：n头奶牛，给出若干个欢迎关系a b，表示a欢迎b，欢迎关系是单向的，但是是可以传递的。另外每个奶牛都是欢迎他自己的。求出被所有的奶牛欢迎的奶牛的数目
算法证明：
1：假设a和b都是最受欢迎的cow，那么，a欢迎b，而且b欢迎a，于是，a和b是属于同一个连通分量内的点，所有，问题的解集构成一个强连通分量。
2：如果某个强连通分量内的点a到强连通分量外的点b有通路，因为b和a不是同一个强连通分量内的点，所以b到a一定没有通路，那么a不被b欢迎，于是a所在的连通分量一定不是解集的那个连通分量。
3：如果存在两个独立的强连通分量a和b，那么a内的点和b内的点一定不能互相到达，那么，无论是a还是b都不是解集的那个连通分量，问题保证无解。
4：如果图非连通，那么，至少存在两个独立的连通分量，问题一定无解。
POJ   2186

*/

#include<cstdio>
#include<cstring>
#include<stack>
using namespace std;
#define maxn 10010
struct Node{
    int v;
    int next;
}edge[50010];
int head[maxn];
int dfn[maxn];
int low[maxn];
bool vis[maxn];
int id[maxn];
int t;
stack<int>s;
int scc;
//模板
void tarjan(int v){
    dfn[v]=low[v]=++t;
    s.push(v);
    vis[v]=true;
    for(int k=head[v];k!=-1;k=edge[k].next){
        int u=edge[k].v;
        if(!dfn[u]){
            tarjan(u);
            low[v]=min(low[v],low[u]);
        }
        else if(vis[u]){
            low[v]=min(low[v],dfn[u]);
        }
    }
    if(low[v]==dfn[v]){
        ++scc;
        int u;
        do{
            u=s.top();
            s.pop();
            id[u]=scc;
        }while(u!=v);
    }
    return ;
}
void solve(int n){
    scc=0;
    for(int i=1;i<=n;i++)
        if(!dfn[i])
            tarjan(i);
    memset(vis,false,sizeof(vis));
    for(int i=1;i<=n;i++)
        for(int k=head[i];k!=-1;k=edge[k].next)
            if(id[i]!=id[edge[k].v])
                vis[id[i]]=true;//寻找出度为0的个数
    int p;
    int cnt=0;
    for(int i=1;i<=scc;i++){
        if(!vis[i]){
            ++cnt;
            p=i;
        }
    }
    if(cnt>1)
        printf("0\n");
    else{
        cnt=0;
        for(int i=1;i<=n;i++){
            if(id[i]==p)
                ++cnt;
        }
         printf("%d\n",cnt);
    }
}
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    int a,b;
    for(int i=1;i<=n;i++){
        head[i]=-1;
        dfn[i]=0;
        vis[i]=false;
    }
    for(int i=0;i<m;i++){
        scanf("%d%d",&a,&b);
        edge[i].v=b;
        edge[i].next=head[a];
        head[a]=i;
    }
    solve(n);
}

/*
题意：无向图增加几条边能保证删除任何一条边后，图还是连通的。
思路：无向图边的双向连通图。求强连通缩点后，构成一颗树，
树中度为一的点的个数ans.(ans+1)/2即为所要加边的最少条数
（据说这是一个定理）。相当于连接两条度为一的点之后再缩点，在连接，
在缩点，故而最少需要（n+1)/2条边。

POJ  3352


*/

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=5000+5;
const int M=10000+5;
struct Edge{
    int v,next;
}edge[M*2];
int head[N],low[N],dfn[N],belong[N],degree[N],sta[N],instack[N];
int g,cnt,top,scc;
void AddEdge(int u,int v){//加边
    edge[g].v=v;
    edge[g].next=head[u];
    head[u]=g++;
}
void Tarjan(int u,int fa){
    int v;
    low[u]=dfn[u]=++cnt;
    sta[++top]=u;
    instack[u]=1;
    for(int i=head[u];i!=-1;i=edge[i].next){
        v=edge[i].v;
        if(v==fa)
            continue;
        if(!dfn[v]){
            Tarjan(v,u);
            low[u]=min(low[u],low[v]);
        }
        else if(instack[v]){
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(dfn[u]==low[u]){
        scc++;
        while(1){
            v=sta[top--];
            instack[v]=0;
            belong[v]=scc;
            if(v==u)
                break;
        }
    }
}
int main(){
    int n,m,u,v;
    scanf("%d%d",&n,&m);
    g=cnt=top=scc=0;
    memset(head,-1,sizeof(head));
    memset(low,0,sizeof(low));
    memset(dfn,0,sizeof(dfn));
    memset(instack,0,sizeof(instack));
    memset(degree,0,sizeof(degree));
    for(int i=0;i<m;i++){
        scanf("%d%d",&u,&v);
        AddEdge(u,v);
        AddEdge(v,u);
    }
    for(int i=1;i<=n;i++)
        if(!dfn[i])
            Tarjan(i,-1);
    for(int i=1;i<=n;i++){
        for(int j=head[i];j!=-1;j=edge[j].next){
            v=edge[j].v;
            if(belong[i]!=belong[v])
                degree[belong[i]]++;//统计入度
        }
    }
    int sum=0;
    for(int i=1;i<=n;i++)
        if(degree[i]==1)//入度为1的节点个数 至少增加的边数 =（ 这棵树总度数为1的结点数 + 1 ）/ 2
            sum++;
    int ans=(sum+1)/2;
    printf("%d\n",ans);
}