E - Redundant Paths - poj 3177（缩点求叶子节点）

题意：给一个图，想让每两条路都有两条边相，不过特殊的是相同的边多次相连也被认为是一条边，现在求最少还需要添加几条边才能做到

分析：手欠没看清楚是相同的边不能相连，需要去重边，缩点后求出来叶子节点的数目即可。

***********************************************************************

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

const int MAXN = 1e5+5;

struct Edge{int v, next;}e[MAXN];
int Head[MAXN], cnt;
void AddEdge(int u, int v)
{
    e[cnt].v = v;
    e[cnt].next = Head[u];
    Head[u] = cnt++;
}

int low[MAXN], dfn[MAXN], Index;
int Stack[MAXN], top;
int belong[MAXN], bnt;
int ru[MAXN];
bool use[5005][5005];

void InIt(int N)
{
    cnt = Index = top = bnt = 0;
    memset(use, 0, sizeof(use));
    for(int i=1; i<=N; i++)
    {
        Head[i] = -1;
        dfn[i] = 0;
        ru[i] = 0;
    }
}
void Tarjan(int u, int father)
{
    int v;

low[u] = dfn[u] = ++Index;
    Stack[++top] = u;

for(int j=Head[u]; j != -1; j=e[j].next)
    {
        v = e[j].v;
        if( !dfn[v] )
        {
            Tarjan(v, u);
            low[u] = min(low[u], low[v]);
        }
        else if(v != father)
            low[u] = min(low[u], dfn[v]);
    }

if(low[u] == dfn[u])
    {
        ++bnt;
        do
        {
            v = Stack[top--];
            belong[v] = bnt;
        }
        while( u != v );
    }
}

int main()
{
    int N, M;

while(scanf("%d%d", &N, &M) != EOF)
    {
        int i, j, u, v;

InIt(N);

while(M--)
        {
            scanf("%d%d", &u, &v);

if(use[u][v] == false)
            {
                AddEdge(u, v);
                AddEdge(v, u);
                use[u][v] = use[v][u] = true;
            }
        }

Tarjan(1, 1);

for(i=1; i<=N; i++)
        for(j=Head[i]; j!=-1; j=e[j].next)
        {
            if(belong[i] != belong[e[j].v])
            {
                ru[ belong[i] ]++;
            }
        }

int ans = 0;

for(i=1; i<=bnt; i++)
        {
            if(ru[i] == 1)
                ans++;
        }

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

return 0;

}