POJ 3177 Redundant Paths （边双连通分量缩点）

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

题解：边双连通分量
题目的意思转化一下就是：至少要添加几条边，才能使其变为双连通图。

一个有桥的连通图，如何把它通过加边变成边双连通图？方法为首先求出所有的桥，然后删除这些桥边，剩下的每个连通块都是一个双连通子图。把每个双连通子图收缩为一个顶点，再把桥边加回来，最后的这个图一定是一棵树，边连通度为 1。

统计出树中度为 1 的节点的个数，即为叶节点的个数，记为 leaf。则至少在树上添加(leaf+1)/2 条边，就能使树达到边二连通，所以至少添加的边数就是 (leaf+1)/2。

具体方法为，首先把两个最近公共祖先最远的两个叶节点之间连接一条边，这样可以把这两个点到祖先的路径上所有点收缩到一起，因为一个形成的环一定是双连通的。然后再找两个最近公共祖先最远的两个叶节点，这样一对一对找完，恰好是 (leaf+1)/2 次，把所有点收缩到了一起。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#include<cmath>
#include<vector>
#include<fstream>
#include<set>
#include<map>
#include<sstream>
#include<iomanip>
#define ll long long
using namespace std;
//边双连通分量
const int MAXN = 5010;//点数
const int MAXM = 20010;//边数，因为是无向图，所以这个值要 *2
struct Edge {
    int to, next;
    bool cut;//是否是桥标记
}edge[MAXM];
int head[MAXN], tot;
int Low[MAXN], DFN[MAXN], Stack[MAXN], Belong[MAXN];//Belong 数组的值是1 ∼ block
int Index, top;
int block;//边双连通块数
bool Instack[MAXN];
int bridge;//桥的数目
void addedge(int u, int v) {
    edge[tot].to = v; edge[tot].next = head[u]; edge[tot].cut = false;
    head[u] = tot++;
}
void Tarjan(int u, int pre) {
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    int pre_cnt = 0;
    for (int i = head[u]; ~i; i = edge[i].next) {
        v = edge[i].to;
        if (v == pre && pre_cnt == 0) { pre_cnt++; continue; }
        if (!DFN[v]) {
            Tarjan(v, u);
            if (Low[u] > Low[v])Low[u] = Low[v];
            if (Low[v] > DFN[u]) {
                bridge++;
                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);
    }
}
void init() {
    tot = 0;
    memset(head, -1, sizeof(head));
}
void solve(int n) {
    memset(DFN, 0, sizeof(DFN));
    memset(Instack, false, sizeof(Instack));
    Index = top = block = 0;
    bridge = 0;
    Tarjan(1, 0);
}
int n, m, u, v, du[MAXN];
int main() {
    init();
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= m; i++) {
        scanf("%d%d", &u, &v);
        addedge(u, v);
        addedge(v, u);
    }
    solve(n);
    for (int i = 1; i <= n; i++) {
        for (int j = head[i]; ~j; j = edge[j].next) {
            if (edge[j].cut) {
                du[Belong[i]]++;  //无向图，计算i所属双连通分量的度即可
            }
        }
    }
    int ans = 0;
    for (int i = 1; i <= block; i++) {
        if (du[i] == 1) ans++;
    }
    printf("%d\n", (ans + 1) / 2);
	return 0;
}