POJ 3177 Redundant Paths

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>
using namespace std;

const int MAXN=5010;
const int MAXM=20010;

struct Edge{
    int to,next;
    bool cut;
}edge[MAXM];

int head[MAXM],tot;

void init(){
    memset(head,-1,sizeof(head));
    tot=0;
}

void addEdge(int u,int v){
    edge[tot].to=v;
    edge[tot].next=head[u];
    edge[tot].cut=false;
    head[u]=tot++;
}


int DFN[MAXN],LOW[MAXN],Belong[MAXN],Stack[MAXN];
bool Instack[MAXN];
int Index,top,brige,block;

int Tarjan(int u,int pre){
    LOW[u]=DFN[u]=++Index;
    Stack[top++]=u;
    Instack[u]=true;

    int v;
    for(int i=head[u];i!=-1;i=edge[i].next){
        v=edge[i].to;
        if(v==pre) continue;

        if(!DFN[v]){
            Tarjan(v,u);

            if(LOW[u]>LOW[v])
                LOW[u]=LOW[v];

            if(LOW[v]>DFN[u]){
                brige++;
                edge[i].cut=true;
                edge[i^1].cut=true;
            }

        }else if(Instack[v]&&LOW[u]>DFN[v]){
            LOW[u]=DFN[v];
        }
    }

    if(LOW[u]==DFN[u]){
        block++;
        do{
            v=Stack[--top];
            Instack[v]=false;
            Belong[v]=block;
        }while(v!=u);
    }
}

int deg[MAXN];

void solve(int n){
    memset(DFN,0,sizeof(DFN));
    memset(Instack,0,sizeof(Instack));
    Index=top=brige=block=0;

    Tarjan(1,0);
    memset(deg,0,sizeof(deg));
    for(int u=1;u<=n;u++)
    for(int i=head[u];i!=-1;i=edge[i].next){
        if(edge[i].cut){
            deg[Belong[u]]++;
        }
    }

    int ans=0;
    for(int i=1;i<=block;i++)
        if(deg[i]==1)
            ans++;

    printf("%d\n",(ans+1)/2);
}

int main(){
    int F,R;
    scanf("%d%d",&F,&R);
    init();

    while(R--){
        int u,v;
        scanf("%d%d",&u,&v);
        addEdge(u,v);
        addEdge(v,u);
    }
    solve(F);

    return 0;
}