POJ3177 Redundant Paths

一.  原题链接：http://poj.org/problem?id=3177

二.  题目大意：给一个无向图，要求添加一些边使得任意两点之间最少有2条不同的路径，不同的路径指的是没有公共边的路径。

三.  思路：

1.     我们知道任意一个边双连通分量，满足之中的两两点之间有2条不同的路径，其实利用Tarjan算法求边双连通分量也体现这种结果。假设父亲为u，子女为v，如果low[v]<=dfn[u]，说明v可以回到u以及u以上的点，而u到v已经有一条路径了，于是u,v在同一个边双连通分量里面。

2.     于是问题转化成求出多少个边双连通分量，单独一个节点算一个，然后把每个双连通分量看成一个点，也就是缩点，这时候变成了一棵树（无回路），树的叶子节点到叶子节点直接肯定只有一条路径，因为它是叶子节点，要走到另一个叶子节点一定要先返回根，于是我们要做的只需要把叶子节点全部连成一个边双连通图，而n个叶子节点，需要(n+1)/2条边，其实叶子节点就是度为1的边。

3.     于是我们可以用Tarjan求出原图的各个边双连通分量，用并查集把同一连通分量的节点（low[u] <= dfn[v]）集合起来，同时求出所有的桥(low[u]>dfn[v])，就是缩点后的树的边。用一个数组blong把所有的边双连通分量标号，然后扫一遍，数出各个双连通分量的度，度为1的个数就是树的叶子节点。然后结果就出来了。

四．代码

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
#include <cmath>
#include <cstdlib>

using namespace std;

const int MAX_N = 5008,
INF = 0x3f3f3f3f;

class AdjList
{
public:
struct Edge
{
int v, next;
}edges[MAX_N*MAX_N];
int head[MAX_N], cnt;
void init()
{
cnt = 0;
memset(head, -1, sizeof(head));
}
void addEdge(int u, int v)
{
edges[cnt].v = v,
edges[cnt].next = head[u];
head[u] = cnt++;
}
};

class FUset
{
public:
int pre[MAX_N];
void init()
{
memset(pre, -1, sizeof(pre));
}
int Find(int x)
{
int root = x, save;
for(; pre[root] >= 0; root = pre[root]);
for(save = pre[x]; x != root; pre[x] = root, x = save, save = pre[x]);

return root;
}
void Union(int x, int y)
{
int Rootx = Find(x), Rooty = Find(y);
int temp = pre[Rootx] + pre[Rooty];
if(pre[Rootx] > pre[Rooty]){
pre[Rootx] = Rooty;
pre[Rooty] = temp;
}
else{
pre[Rooty] = Rootx;
pre[Rootx] = temp;
}
}
};

class Tarjan
{
public:
AdjList graph;
FUset FU;
int bridge[MAX_N][2], low[MAX_N], dfn[MAX_N],
nBridge, nodeNum, belong[MAX_N];//every node belong to which double connection.
bool visited[MAX_N];
void init(int n)
{
nodeNum = n;
nBridge = 0;
graph.init();
FU.init();
memset(visited, 0, sizeof(visited));
memset(belong, -1, sizeof(belong));
}
void dfs(int pre, int u, int depth)
{
visited[u] = true;
low[u] = dfn[u] = depth;
bool toPre = false;
int i, v;
for(i = graph.head[u]; i != -1; i = graph.edges[i].next){
v = graph.edges[i].v;
if(!visited[v]){
dfs(u, v, depth + 1);
low[u] = min(low[u], low[v]);
if(low[v] <= dfn[u])//able to return, belong to the same double connection.
FU.Union(u, v);
if(low[v] > dfn[u])//unable to return, (u, v) is a bridge.
bridge[nBridge][0] = u, bridge[nBridge++][1] = v;
}
else if(v != pre || toPre)
low[u] = min
4000
(low[u], dfn[v]);
else if(v == pre)
toPre = true;
}
}
int doubleConnection()
{
int i, root, res = 0;
dfs(-1, 1, 1);
for(i = 1; i <= nodeNum; i++){
root = FU.Find(i);
if(belong[root] == -1)
belong[root] = res++;
belong[i] = belong[root];
}
return res;
}
int getRes()
{
int cnt[MAX_N] = {0}, i, num, u, v, res = 0;
num = doubleConnection();
for(i = 0; i < nBridge; i++){
u = bridge[i][0];
v = bridge[i][1];
cnt[belong[u]]++, cnt[belong[v]]++;
}
for(i = 0; i < num; i++)
if(1 == cnt[i])
res++;
return res;
}
}G;

int main()
{
//freopen("in.txt", "r", stdin);

int i, u, v, F, R;

while(~scanf("%d%d", &F, &R)){
G.init(F);

for(i = 0; i < R; i++){
scanf("%d%d", &u, &v);
G.graph.addEdge(u, v);
G.graph.addEdge(v, u);
}

printf("%d\n", (G.getRes()+1)/2);
}

return 0;
}