POJ - 3352 Road Construction、 POJ - 3177 Redundant Paths 边双连通分量 tarjan模板

割点、桥定义

设G是一个图，v是G的一个顶点，如果G-v的连通分支数大于G的连通分支数，则称v是G的一个割点。
设G是一个图，x是G的一条边，如果G-x的连通分支数大于G的连通分支数，则称x是G的一个桥，或割边。

 双联通分量

双连通分量又分点双连通分量和边双连通分量两种。若一个无向图中的去掉任意一个节点（一条边）都不会改变此图的连通性，即不存在割点（桥），则称作点（边）双连通图。一个无向图中的每一个极大点（边）双连通子图称作此无向图的点（边）双连通分量。

本题题意：为了保护放牧环境，避免牲畜过度啃咬同一个地方的草皮，牧场主决定利用不断迁移牲畜进行喂养的方法去保护牧草。然而牲畜在迁移过程中也会啃食路上的牧草，所以如果每次迁移都用同一条道路，那么该条道路同样会被啃咬过度而遭受破坏。 现在牧场主拥有F个农场，已知这些农场至少有一条路径连接起来（不一定是直接相连），但从某些农场去另外一些农场，至少有一条路可通行。为了保护道路上的牧草，农场主希望再建造若干条道路，使得每次迁移牲畜时，至少有2种迁移途径，避免重复走上次迁移的道路。已知当前有的R条道路，问农场主至少要新建造几条道路，才能满足要求？

分析之后即是：给定一个连通的无向图G，至少要添加几条边，才能使其变为边双连通图。

去掉桥，其余的连通分支就是边双连通分支了。一个有桥的连通图要变成边双连通图的话，
把双连通子图收缩为一个点，形成一颗树。需要加的边为（leaf+1）/ 2（leaf为叶子结点的个数）

输入可能会有重边，所以在tarjan中会有一个参数pre来判断是否是走过来的那条边，如果用这条边在edge中的下标来传递参数，那么在tarjan中就可以判断一下到底这条边是走过来的那条边，还是重复的边了，如果是重复的边，还是让它去往下去更新，这样就能得到正确的结果

链接：poj - 3177  有重边

          poj - 3352  无重边

代码一样如下：

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#define INF 0x3f3f3f3f


using namespace std;

const int inf = 0x3f3f3f3f;
const int maxn = 5005;
const int maxm = 20005;

struct Edge {
    int to, next;
    bool cut;           //  是否是桥标记
}edge[maxm];

int head[maxn], tot;
int low[maxn], dfn[maxn], cnt;
int sstack[maxn], top;
int belong[maxn], scnt;    //belong数组的值是1~scnt 边双连通块数
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++;
    return ;
}

void init() {
    tot = 0;
    memset(head, -1, sizeof(head));
    memset(dfn, 0, sizeof(dfn));
    memset(instack, false, sizeof(instack));
    cnt = top = scnt = 0;
    return;
}

void Tarjan(int u, int pre) {
    int v;
    low[u] = dfn[u] = ++cnt;
    sstack[top++] = u;
    instack[u] = true;
    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]) {
                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]) {
        scnt++;
        do {
            v = sstack[--top];
            instack[v] = false;
            belong[v] = scnt;
        }
        while (v != u);
    }
    return;
}

int du[maxn];   //  缩点后形成树,每个点的度数

int main()
{
    int n, m;
    int u, v;
    while (scanf("%d %d", &n, &m) == 2) {
        init();
        while (m--) {
            scanf("%d %d", &u, &v);
            addedge(u, v);
            addedge(v, u);
        }
        Tarjan(1, 0);
        int ans = 0;
        memset(du, 0, sizeof(du));
        for (int i = 1; i <= n; i++) {
            for (int j = head[i]; j != -1; j = edge[j].next) {
                if (edge[j].cut) {
                    du[belong[i]]++;
                }
            }
        }
        for (int i = 1; i <= scnt; i++) {
            if(du[i] == 1) {
                ans++;
            }
        }
        // 找叶子结点的个数ans,构造边双连通图需要加边(ans+1)/2
        printf("%d\n", (ans + 1) / 2);
    }
    return 0;
}