395. 冗余路径（Trajan算法，边的双连通分量）

本文链接：https://blog.csdn.net/Landing_on_Mars/article/details/134422948

395. 冗余路径 - AcWing题库

为了从 F 个草场中的一个走到另一个，奶牛们有时不得不路过一些她们讨厌的可怕的树。

奶牛们已经厌倦了被迫走某一条路，所以她们想建一些新路，使每一对草场之间都会至少有两条相互分离的路径，这样她们就有多一些选择。

每对草场之间已经有至少一条路径。

给出所有 R 条双向路的描述，每条路连接了两个不同的草场，请计算最少的新建道路的数量，路径由若干道路首尾相连而成。

两条路径相互分离，是指两条路径没有一条重合的道路。

但是，两条分离的路径上可以有一些相同的草场。

对于同一对草场之间，可能已经有两条不同的道路，你也可以在它们之间再建一条道路，作为另一条不同的道路。

输入格式

第 1 行输入 F 和 R。

接下来 R 行，每行输入两个整数，表示两个草场，它们之间有一条道路。

输出格式

输出一个整数，表示最少的需要新建的道路数。

数据范围

1≤F≤5000
F−1≤R≤10000

输入样例：

输出样例：

解析：

1）边的双连通分量：
dfn[x]

low[x]

(1).如何找到桥（x，y）

桥<=>dfn[x]<low[y]

(2).如何找到所有边的双连通分量

方法一：将所有桥删掉

方法二：当dfn[x]==low[x]时，x的子树中的所有在栈中的节点组成边的双连通分量

题目意思：最少要添加多少条边使得任意两点之间存在至少两条相互分离的路径（边双连通分量）

性质：要使一棵树成为一个边双连通分量，只需添加 (cnt+1)/2 条边，cnt=树的叶子节点的个数

因此，我们可以使用 tarjan 算法将这个无向连通图缩点成为一棵树，然后使用上述性质得出答案。

注意，这里是无向图的 tarjan 算法

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
using namespace std;
typedef long long LL;
const int N = 5e3 + 5, M = 1e4 + 5;
int n, m;
int h[N], e[M], ne[M], idx;
int dfn[N], low[N], timestamp;
int stk[N], top;
bool bridge[M];
int id[N], dcc_cnt;
int du[N];

void add(int a, int b) {
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

void tarjan(int u, int fa) {
	dfn[u] = low[u] = ++timestamp;
	stk[++top] = u;
	for (int i = h[u]; i != -1; i = ne[i]) {
		int j = e[i];
		if (!dfn[j]) {// j 点没被访问过
			tarjan(j, i);//注意这里是 i，不是 u
			low[u] = min(low[u], low[j]);
			if (dfn[u] < low[j]) {//说明存在割边（桥）
				bridge[i] = bridge[i ^ 1] = 1;//标记当前的边属于桥
			}
		}
		else if (i != (fa ^ 1)) {// 边 i 不是边 fa 的反向
          //这里不需要instk标记，是应为这是一个无向图，我们可以直接找到它的祖先
			low[u] = min(low[u], dfn[j]);
		}
	}
	if (dfn[u] == low[u]) {
		dcc_cnt++;
		int y;
		do {
			y = stk[top--];
			id[y] = dcc_cnt;
		} while (y != u);
	}
}

int main() {
	scanf("%d%d", &n, &m);
	memset(h, -1, sizeof h);
	for (int i = 1, a, b; i <= m; i++) {
		scanf("%d%d", &a, &b);
		add(a, b), add(b, a);
	}
	for (int i = 1; i <= n; i++) {
		if (!dfn[i])
			tarjan(i, -1);
	}
	for (int i = 0; i < idx; i++) {
		int j = e[i];
		if (bridge[i]) {
			du[id[j]]++;
		}
	}
	int cnt = 0;
	for (int i = 1; i <= dcc_cnt; i++) {
		if (du[i] == 1)
			cnt++;
	}
	printf("%d\n", (cnt + 1) / 2);
	return 0;
}

--------------------------------------------------------------------------------------------------------------------2024.2.4

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
#include<sstream>
#include<deque>
#include<unordered_map>
#include<unordered_set>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int N = 5e3 + 5, M = 2e4 + 5, INF = 0x3f3f3f3f;
int n, m;
int h[N], e[M], ne[M], idx;
int dfn[N], low[N], timestamp;
int stk[N], top;
int id[N], dcc_cnt;
bool is_bridge[N];
int din[N];

void add(int a, int b) {
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

void tarjan(int u, int from) {
	dfn[u] = low[u] = ++timestamp;
	stk[++top] = u;
	for (int i = h[u]; i != -1; i = ne[i]) {
		int j = e[i];
		if (!dfn[j]) {
			tarjan(j, i);
			low[u] = min(low[u], low[j]);
			if (dfn[u] < low[j]) {
				is_bridge[i] = is_bridge[i ^ 1] = 1;
			}
		}
		else if (i != (from ^ 1))low[u] = min(low[u], dfn[j]);
	}
	if (dfn[u] == low[u]) {
		int y;
		++dcc_cnt;
		do {
			y = stk[top--];
			id[y] = dcc_cnt;
		} while (y != u);
	}
}

int main() {
	cin >> n >> m;
	memset(h, -1, sizeof h);
	for (int i = 1,a,b; i <= m; i++) {
		scanf("%d%d", &a, &b);
		add(a, b), add(b, a);
	}
	tarjan(1, -1);
	for (int i = 0; i < idx; i++) {
		if (is_bridge[i]) {
			int j = e[i];
			din[id[j]]++;
		}
	}
	int sum = 0;
	for (int i = 1; i <= dcc_cnt; i++) {
		if (din[i] == 1)sum++;
	}
	printf("%d\n", (sum + 1) / 2);
	return 0;
}