算法刷题记录(Day 28)

最新推荐文章于 2026-01-08 22:28:34 发布
原创 最新推荐文章于 2026-01-08 22:28:34 发布 · 87 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #c++ #c语言

本文探讨了两种解决边双连通分量问题的算法：一种基于Tarjan算法和并查集，另一种利用LCA（最近公共祖先）和并查集。第一种方法在原图上进行操作，遇到割边时更新边的状态；第二种方法在缩点后的图上计算LCA，通过调整连接关系减少边的数量。这两种方法在不同的场景下各有优势，对于理解图论算法和实际问题的解决具有重要意义。

Network(poj 3694)

原题链接
题目类型:缩点+边双连通分量
思路一:
存在的问题:
1.可能存在重边，又无向图中要求子节点不能通过反边访问父亲节点，因此需要将边的序号作为条件传入参数中。
2.加入了一条新的边后如何求得割边的个数，dfs遍历到目的节点，然后列出路径上的割边的个数，并在dfs的过程中做出标记标记为不是割边。需要注意的是，需要设置dfs的返回值，以标志该条路径是否为到达目的块的路径。
3.那么应该遍历的是缩点后的图还是原先的图呢？由于本题时间限制较少，因此可以直接在原图上进行遍历。

具体的实现代码如下所示:

//WA代码
#include<iostream>
#include<vector>
#include<cstring>
#include<stack>
#define NMAX 100005

using namespace std;
int F, R;
struct edge {
	int from, to, next;
	int is;//是否为割边
};
vector<edge> E;
int h[NMAX];
int a, b;
void addline(int x, int y) {
	edge cur;
	cur.from = x, cur.to = y, cur.next = h[x], cur.is = 0;
	h[x] = E.size();
	E.push_back(cur);

	cur.from = y, cur.to = x, cur.next = h[y], cur.is = 0;
	h[y] = E.size();
	E.push_back(cur);
}

int dfn[NMAX], low[NMAX], belong[NMAX];
stack<int > S;
int tot = 0;
int connect = 0;
void tarjan(int x, int fa, int side) {
	dfn[x] = low[x] = ++tot;
	S.push(x);
	for (int i = h[x]; i != -1; i = E[i].next) {
		int to = E[i].to;
		if (!dfn[to]) {
			tarjan(to, x, i);
			low[x] = min(low[x], low[to]);
			//用来判断是否为割边
			if (low[to] == dfn[to]) {
				E[i].is = 1;
				E[i ^ 1].is = 1;//其反向边也应该添加
			}
		}
		else if (i!= (side^1) ) low[x] = min(low[x], dfn[to]); //修改条件，避免存在重边
	}
	if (dfn[x] == low[x]) {
		int cur = -1;
		while (cur!=x) {
			cur = S.top();
			S.pop();
			belong[cur] = connect;
		}
		connect++;
	}

}

int num = 0;
int vis[NMAX];
int dfs(int x, int dst,int & res) {
	int ret = 0;
	vis[x] = 1;
	if (belong[x] == dst) return 1;
	for (int i = h[x]; i != -1; i = E[i].next) {
		if (!vis[E[i].to]) {
			int j = dfs(E[i].to, dst, res);
			if (j) ret = j;
			if (j && E[i].is) {
				res--;
				E[i].is = 0;
				E[i ^ 1].is = 0;
			}
			
		}
	}
	return ret;

}
int main() {
	cin >> F >> R;
	while (!(F == 0 && R == 0)) {
		memset(h, -1, sizeof(h));
		E.clear();
		while (!S.empty()) S.pop();
		tot = 0;
		connect = 0;
		for (int i = 0; i < R; i++) {
			cin >> a >> b;
			addline(a, b);
		}
		//for (int i = 0; i < E.size(); i++) cout << E[i].from << " " << E[i].to << endl;
		//for(int i=h[4];i!=-1;i=E[i].next) cout << E[i].from << " " << E[i].to << endl;
		memset(dfn, 0, sizeof(dfn));
		for (int i = 1; i <= F; i++) {
			if (!dfn[i]) tarjan(i, 0, -1);
		}

		int Q;
		cin >> Q;
		int res = connect-1;
		num++;
		cout << "Case " << num << ":" << endl;
		for (int i = 0; i < Q; i++) {
			int a, b;
			cin >> a >> b;
			int A = belong[a];
			int B = belong[b];
			if (A != B) {
				//进行原图的dfs并进行相应的修改
				memset(vis, 0, sizeof(vis));
				dfs(a, B,res);//引用会一直传递下去吗？
			}
			cout << res << endl;
		}
		cout << endl;
		cin >> F >> R;
	}
}

仍然没有找到哪里存在错误!!!

思路二:
学习别人的思路:lca+并查集

LCA(最近公共祖先)是指在一棵树上，两个节点深度最大的公共祖先节点
用于解决两个节点仅有唯一的一条确定的路径的问题。
在本例中，使用的是暴力的算法，逐步向上求取lca。对于边的删除，利用的是并查集的方式来实现，即每次通过边移动一个点，然后便直接查找其父亲节点，以回避同一个集合中的边。

tarjan求最近公共祖先
数组的引用

//AC代码
#include<iostream>
#include<vector>
#include<cstring>
#include<stack>
#define NMAX 100005

using namespace std;
int F, R;
struct edge {
	int from, to, next;
	int is;//是否为割边
};
vector<edge> E;
vector<edge> Es;
int h[NMAX];
int hs[NMAX];
int a, b;
void addline(int x, int y,vector<edge> & E,int  (& h) [NMAX] ) {
	edge cur;
	cur.from = x, cur.to = y, cur.next = h[x], cur.is = 0;
	h[x] = E.size();
	E.push_back(cur);

	cur.from = y, cur.to = x, cur.next = h[y], cur.is = 0;
	h[y] = E.size();
	E.push_back(cur);
}

int dfn[NMAX], low[NMAX], belong[NMAX];
stack<int > S;
int tot = 0;
int connect = 0;
void tarjan(int x, int fa, int side) {
	dfn[x] = low[x] = ++tot;
	S.push(x);
	for (int i = h[x]; i != -1; i = E[i].next) {
		int to = E[i].to;
		if (!dfn[to]) {
			tarjan(to, x, i);
			low[x] = min(low[x], low[to]);
			//用来判断是否为割边
			if (low[to] == dfn[to]) {
				E[i].is = 1;
				E[i ^ 1].is = 1;//其反向边也应该添加
			}
		}
		else if (i!= (side^1) ) low[x] = min(low[x], dfn[to]); //修改条件，避免存在重边
	}
	if (dfn[x] == low[x]) {
		int cur = -1;
		while (cur!=x) {
			cur = S.top();
			S.pop();
			belong[cur] = connect;
		}
		connect++;
	}

}

int num = 0;
int vis[NMAX];
int deep[NMAX], fa[NMAX], bf[NMAX];
int dfs(int x, int dst, int& res) {
	int ret = 0;
	vis[x] = 1;
	if (belong[x] == dst) return 1;
	for (int i = h[x]; i != -1; i = E[i].next) {
		if (!vis[E[i].to]) {
			int j = dfs(E[i].to, dst, res);
			if (j) ret = j;
			if (j && E[i].is) {
				res--;
				E[i].is = 0;
				E[i ^ 1].is = 0;
			}
			
		}
	}
	return ret;

}
void dfs(int x) {
	for (int i = hs[x]; i != -1; i = Es[i].next) {
		if (!deep[Es[i].to]) {
			deep[Es[i].to] = deep[x] + 1;
			fa[Es[i].to] = x;
			dfs(Es[i].to);
		}
	}
}
int find(int x) {
	if (x != bf[x]) bf[x] = find(bf[x]);
	return bf[x];
}
int LCA(int u, int v) {
	while (u != v) {
		if (deep[u] > deep[v]) u = fa[u];
		else if (deep[u] < deep[v]) v = fa[v];
		else u = fa[u], v = fa[v];
		u = find(u), v = find(v);
	}
	return u;
}
int main() {
	cin >> F >> R;
	while (!(F == 0 && R == 0)) {
		memset(h, -1, sizeof(h));
		memset(hs, -1, sizeof(hs));
		E.clear();
		Es.clear();
		while (!S.empty()) S.pop();
		tot = 0;
		connect = 0;
		for (int i = 0; i < R; i++) {
			cin >> a >> b;
			addline(a, b, E, h);
		}
		//for (int i = 0; i < E.size(); i++) cout << E[i].from << " " << E[i].to << endl;
		//for(int i=h[4];i!=-1;i=E[i].next) cout << E[i].from << " " << E[i].to << endl;
		memset(dfn, 0, sizeof(dfn));
		for (int i = 1; i <= F; i++) {
			if (!dfn[i]) tarjan(i, 0, -1);
		}

		//在缩点后的图上来处理
		//首先建立缩点后的图
		for (int i = 0; i < E.size(); i++) {
			if (E[i].is) {
				addline(belong[E[i].from], belong[E[i].to], Es, hs );
			}
		}
		
		//lca一定需要deep和fa的关系吗？->lca是基于树的，因此需要fa的信息，而在暴力搜索lca的过程中，需要向上寻找父节点
		memset(deep, 0, sizeof(deep));
		for (int i = 0; i < connect; i++) {
			bf[i] = i;
			if (!deep[i]) deep[i] = 1, fa[i] = -1, dfs(i);
		}
		int Q;
		cin >> Q;
		int res = connect-1;
		num++;
		cout << "Case " << num << ":" << endl;
		for (int i = 0; i < Q; i++) {
			int a, b;
			cin >> a >> b;
			int A = find(belong[a]);
			int B = find(belong[b]);
			if (A != B) {
				//首先找公共祖先
				int lca = LCA(A, B);
				//计算路径上的边的个数
				while (A != lca) {
					res--;
					bf[A] = lca; //A一定是代表元

					A = fa[A];
					A = find(A);
				}
				while (B != lca) {
					res--;
					bf[B] = lca;

					B = fa[B];
					B = find(B);
				}
			}
			cout << res << endl;
		}
		cout << endl;
		cin >> F >> R;
	}
}

对于思路一进行验证，将思路一应用到缩点后的图中，是成立的。
满脸疑惑

#include<iostream>
#include<vector>
#include<cstring>
#include<stack>
#define NMAX 100005

using namespace std;
int F, R;
struct edge {
	int from, to, next;
	int is;//是否为割边
};
vector<edge> E;
vector<edge> Es;
int h[NMAX];
int hs[NMAX];
int a, b;
void addline(int x, int y,vector<edge> & E,int  (& h) [NMAX] ) {
	edge cur;
	cur.from = x, cur.to = y, cur.next = h[x], cur.is = 0;
	h[x] = E.size();
	E.push_back(cur);

	cur.from = y, cur.to = x, cur.next = h[y], cur.is = 0;
	h[y] = E.size();
	E.push_back(cur);
}

int dfn[NMAX], low[NMAX], belong[NMAX];
stack<int > S;
int tot = 0;
int connect = 0;
void tarjan(int x, int fa, int side) {
	dfn[x] = low[x] = ++tot;
	S.push(x);
	for (int i = h[x]; i != -1; i = E[i].next) {
		int to = E[i].to;
		if (!dfn[to]) {
			tarjan(to, x, i);
			low[x] = min(low[x], low[to]);
			//用来判断是否为割边
			if (low[to] == dfn[to]) {
				E[i].is = 1;
				E[i ^ 1].is = 1;//其反向边也应该添加
			}
		}
		else if (i!= (side^1) ) low[x] = min(low[x], dfn[to]); //修改条件，避免存在重边
	}
	if (dfn[x] == low[x]) {
		int cur = -1;
		while (cur!=x) {
			cur = S.top();
			S.pop();
			belong[cur] = connect;
		}
		connect++;
	}

}

int num = 0;
int vis[NMAX];
int deep[NMAX], fa[NMAX], bf[NMAX];
int hdfs(int x, int dst, int& res, vector<edge>& E) {
	int ret = 0;
	vis[x] = 1;
	if (x == dst) return 1;
	for (int i = hs[x]; i != -1; i = E[i].next) {
		if (!vis[E[i].to]) {
			int j = hdfs(E[i].to, dst, res, E);
			if (j) ret = j;
			if (j && !E[i].is) {
				res--;
				//标记该边已经被删除
				E[i].is = 1;
				E[i ^ 1].is = 1;
			}
		}
	}
	return ret;

}
void dfs(int x) {
	for (int i = hs[x]; i != -1; i = Es[i].next) {
		if (!deep[Es[i].to]) {
			deep[Es[i].to] = deep[x] + 1;
			fa[Es[i].to] = x;
			dfs(Es[i].to);
		}
	}
}
int find(int x) {
	if (x != bf[x]) bf[x] = find(bf[x]);
	return bf[x];
}
int LCA(int u, int v) {
	while (u != v) {
		if (deep[u] > deep[v]) u = fa[u];
		else if (deep[u] < deep[v]) v = fa[v];
		else u = fa[u], v = fa[v];
		u = find(u), v = find(v);
	}
	return u;
}
int main() {
	cin >> F >> R;
	while (!(F == 0 && R == 0)) {
		memset(h, -1, sizeof(h));
		memset(hs, -1, sizeof(hs));
		E.clear();
		Es.clear();
		while (!S.empty()) S.pop();
		tot = 0;
		connect = 0;
		for (int i = 0; i < R; i++) {
			cin >> a >> b;
			addline(a, b, E, h);
		}
		//for (int i = 0; i < E.size(); i++) cout << E[i].from << " " << E[i].to << endl;
		//for(int i=h[4];i!=-1;i=E[i].next) cout << E[i].from << " " << E[i].to << endl;
		memset(dfn, 0, sizeof(dfn));
		for (int i = 1; i <= F; i++) {
			if (!dfn[i]) tarjan(i, 0, -1);
		}

		//在缩点后的图上来处理
		//首先建立缩点后的图
		for (int i = 0; i < E.size(); i++) {
			if (E[i].is) {
				addline(belong[E[i].from], belong[E[i].to], Es, hs );
				i++;//反向边就不要再建立了
			}
		}
		//cout << "bian" << endl;
		//for (int i = 0; i < Es.size(); i++) {
			//cout << Es[i].from << " " << Es[i].to << " "<< Es[i].next<< endl;
		//}
		//lca一定需要deep和fa的关系吗？->lca是基于树的，因此需要fa的信息，而在暴力搜索lca的过程中，需要向上寻找父节点
		memset(deep, 0, sizeof(deep));
		for (int i = 0; i < connect; i++) {
			bf[i] = i;
			if (!deep[i]) deep[i] = 1, fa[i] = -1, dfs(i);
		}
		int Q;
		cin >> Q;
		int res = connect-1;
		num++;
		cout << "Case " << num << ":" << endl;
		for (int i = 0; i < Q; i++) {
			int a, b;
			cin >> a >> b;
			int A = belong[a];
			int B = belong[b];
			if (A != B) {
				//dfs来搜索到达那里的路径
				memset(vis, 0, sizeof(vis));
				hdfs(A, B, res,Es);
			}
			cout << res << endl;
		}
		cout << endl;
		cin >> F >> R;
	}
}
算法刷题记录 Day28
qq_45542288的博客
04-01 227
lc 122. 买卖股票的最佳时机II。lc 45. 跳跃游戏II。lc 55. 跳跃游戏。
算法刷题记录 Day40
qq_45542288的博客
04-08 708
kamma 56. 多重背包。lc 139. 单词拆分。
算法刷题记录 Day50
qq_45542288的博客
04-22 685
lc 496. 下一个更大元素I。lc 739. 每日温度。
算法刷题记录 Day51
qq_45542288的博客
04-22 642
lc 503. 下一个更大元素II。lc 42. 接雨水。
算法刷题记录 Day4
qq_45542288的博客
02-24 385
leetcode 24. 两两交换链表中的结点. 时间On,空间O1；leetcode 面试题02.07. 链表相交 时间On, 空间O1。leetcode 19. 删除链表的倒数第N个结点。leetcode 142. 环形链表ii.
算法刷题记录 Day44
qq_45542288的博客
04-13 353
lc 714. 买卖股票，含手续费。lc 309. 买卖股票，含冷冻期。
算法刷题记录 Day33
qq_45542288的博客
04-01 603
lc 746. 使用最小花费爬楼梯。lc 509. 斐波那契数列。lc 70. 爬楼梯。
算法刷题记录 Day35
qq_45542288的博客
04-01 424
lc 96. 不同的二叉搜索树。lc 343. 整数拆分。
算法刷题记录 Day32
qq_45542288的博客
04-01 480
lc 738. 单调递增的数字。
算法刷题记录 Day9
qq_45542288的博客
03-01 337
lc 225. 用队列实现栈. 单队列和双队列实现方式一致。leetcode 232. 用栈实现队列。
算法刷题记录(Day 56)
m0_67393342的博客
05-16 244
复旦大学计算机学院2021夏令营机试 第一题 题目描述:给定一颗二叉树，树的每个节点的值为一个正整数。如果从根节点到节点 N 的路径上不存在比节点 N 的值大的节点，那么节点 N 被认为是树上的关键节点。求树上所有的关键节点的个数。请写出程序，并解释解题思路。 输入: 3, 1, 4, 3, null, 1, 5 解题思路: dfs遍历一遍树上的所有节点，注意维护一个当前路径上最大值的变量max，当遍历到节点i，时，便和这个值进行比较，若大于该值，则节点数加上1，并更新变量max。否则，直接向下传递即可
30天LeetCode挑战：我的算法刷题记录
该存储库记录了从第1天到至少第6天的每日刷题进度，体现了持续学习和编程实践的理念。LeetCode作为全球知名的在线编程练习平台，广泛被用于准备技术面试、提升编码技巧以及深入理解计算机科学中的核心算法思想。此...
leetcode刷题记录day008：125和242
CodeYello的博客
09-22 312
125、难度简单： “回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。 本题中：只考虑字母和数字字符，可以忽略字母的大小写；将空字符串定义为有效的回文串；字符串 s 由 ASCII 字符组成 方法一：筛选 + 判断：时间复杂度：O(∣s∣) 空间复杂度：O(∣s∣) 其中 |s∣ 是字符串 s 的长度。 最简单的方法是对字符串 ss 进行一次遍历，并将其中的字母和数字字符进行保留，放在另一个字符串 sgood 中。这样我们只需要判断 sgood 是否是一个普通的回
c++/go算法模板, 刷题记录
MARSHCW的博客
09-01 2226
◉ 一、数组 1184. 公交站间的距离 难度：简单 环形公交路线上有 n 个站，按次序从 0 到 n - 1 进行编号。我们已知每一对相邻公交站之间的距离，distance[i] 表示编号为 i 的车站和编号为 (i + 1) % n 的车站之间的距离。 环线上的公交车都可以按顺时针和逆时针的方向行驶。 返回乘客从出发点 start 到目的地 destination 之间的最短距离。 示例 1： 输入：distance = [1,2,3,4], start = 0, destination = 1 输出
LeetCode刷题 | Day 5 分裂二叉树的最大乘积 (Maximum Product of Splitted Binary Tree) 递归深度优先算法
weixin_44459972的博客
06-07 1070
LeetCode位置：1339. 分裂二叉树的最大乘积日常刷题，维持手感，同步学习英语，刷题顺序参考B站UP@justyyuk的系列视频，感兴趣的点波关注。学海无涯，大路千万，感恩此程，彼此真诚陪伴！Ps：第一次刷到的道友留步，这里拉齐一下信息。文章主要记录视频中的主要内容，算法思路会按照个人理解，用伪代码+举例每步输出的方式呈现（建议自己过一遍）。代码部分会以Python和C++语法进行呈现。文章最后会总结一些英语词汇。OK，就啰嗦这么多，开始进步[干杯🐱‍👓]输入：二叉树列表root。
算法详解（一）--算法系列开篇：什么是算法？
最新发布
whc的博客
01-08 1213
算法定义与特性 算法是解决特定问题的明确有限步骤，具有五大核心特性：必须在有限步骤内结束（有穷性）、每步操作明确无歧义（确定性）、能用基本操作实现（可行性）、可接受输入数据、并产生输出结果。算法是抽象思想，不同于具体代码实现。 效率评估体系 通过时间复杂度和空间复杂度衡量算法效率。时间复杂度关注运行时间随数据规模的增长趋势，使用大O表示法描述；空间复杂度分析算法所需的额外内存空间。实际设计常需在时间与空间效率间权衡取舍。
【人工智能领域】-YOLO目标检测算法全解析（含大白话解释）
Java && AI Agent工程师
01-07 1309
本文全面解析YOLO目标检测算法的发展历程与技术特点。文章首先对比CNN与YOLO的本质区别，指出CNN是基础组件而YOLO是完整解决方案。随后详细梳理YOLO从v1到最新版本的演进之路，包括各版本核心创新与性能提升。重点分析了目标检测算法的两大类别（Two-stage与One-stage）的技术差异，并通过YOLOv1的实例详解其将检测转化为回归问题的核心思想。文章还介绍了非极大值抑制(NMS)等关键技术，以及YOLOv3的多尺度预测改进。最后总结了YOLO在自动驾驶、工业检测等领域的广泛应用，并展望其未
leetcode算法（144.二叉树的前序遍历）
m0_61706299的博客
01-05 488
leetcode算法（144.二叉树的前序遍历）
【剑斩OFFER】算法的暴力美学——力扣 844 题：比较含退格的字符串
就业知识博客
01-08 198
力扣 844 题：比较含退格的字符串
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值