POJ-3177-RedundantPaths(边联通分量，缩点)

链接：https://vjudge.net/problem/POJ-3177#author=Dillydally

题意：

有n个牧场，Bessie 要从一个牧场到另一个牧场，要求至少要有2条独立的路可以走。现已有m条路，求至少要新建多少条路，使得任何两个牧场之间至少有两条独立的路。两条独立的路是指：没有公共边的路，但可以经过同一个中间顶点。

思路：

依然是缩点求边，不过输入好坑。。。

代码：

#include <iostream>
#include <memory.h>
#include <string>
#include <istream>
#include <sstream>
#include <vector>
#include <stack>
#include <algorithm>
#include <map>
#include <queue>
#include <math.h>
#include <cstdio>
#include <set>
#include <iterator>
#include <cstring>
using namespace std;

typedef long long LL;
const int MAXN = 5e3+10;

vector<int> G[MAXN];
stack<int> St;
int Dfn[MAXN], Low[MAXN];
int Dis[MAXN], Fa[MAXN];
int times, res, cnt;
int n, m;

void Init()
{
    for (int i = 1;i <= n;i++)
        G[i].clear();
    memset(Dfn, 0, sizeof(Dfn));
    memset(Low, 0, sizeof(Low));
    memset(Dis, 0, sizeof(Dis));
    memset(Fa, 0, sizeof(Fa));
    times = res = cnt = 0;
}

void Tarjan(int u, int v)
{
    Dfn[v] = Low[v] = ++times;
    St.push(v);
    int flag = 0;
    for (int i = 0;i < G[v].size();i++)
    {
        int node = G[v][i];
        if (node == u && !flag)
        {
            flag = 1;
            continue;
        }
        if (Dfn[node] == 0)
            Tarjan(v, node);
        Low[v] = min(Low[v], Low[node]);
    }
    if (Dfn[v] == Low[v])
    {
        cnt++;
        int node;
        do
        {
            node = St.top();
            Fa[node] = cnt;
            St.pop();
        }
        while (node != v);
    }
}

int main()
{
    string s;
    int t;
    while (cin >> n >> m)
    {
        int l, r;
//        cin >> n >> m;
        Init();
        for (int i = 1;i <= m;i++)
        {
            cin >> l >> r;
            G[l].push_back(r);
            G[r].push_back(l);
        }
        Tarjan(0, 1);
//        copy(Fa+1, Fa+1+n, ostream_iterator<int> (cout, " "));
//        copy(Dis+1, Dis+1+n, ostream_iterator<int> (cout, " "));
//        cout << endl;
        for (int i = 1;i <= n;i++)
        {
            for (int j = 0;j < G[i].size();j++)
            {
                int node = G[i][j];
                if (node == i)
                    continue;
                if (Fa[i] != Fa[node])
                    Dis[Fa[node]]++;
            }
        }
        int leaf = 0;
        for (int i = 1;i <= cnt;i++)
        {
            if (Dis[i] == 1)
                leaf++;
        }
//        cout << "Output for Sample Input " << t << endl;
        cout << (leaf+1)/2 << endl;
    }

    return 0;
}