C++图网结构算法

已于 2024-07-25 21:54:22 修改
阅读量225 收藏 2
点赞数 2
文章标签： 算法
于 2024-07-25 21:53:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Archie28/article/details/140696407
版权

目录

一.迪杰斯特拉算法（dijkstra）

1.实现原理：

2.代码实现：

3.例题：

二.spfa算法：

1.实现原理：

2.代码实现：

3.例题：

三.贝尔曼福特（bellman_ford）

1.实现原理：

2.代码实现：

3.例题：

四.弗洛伊德（floyd）

1.实现原理：

2.代码实现：

3.例题：

4.floyd性质探索：

（1）.性质一

（2）.性质二

（3）.性质三

5.floyd传递闭包问题

一.迪杰斯特拉算法（dijkstra）

1.实现原理：

dijkstra算法能实现的原因是它保证了在第一次出队之后，答案一定为最短。也就是出队之后

，一定不会再有更短的路径出队，而dijkstra算法的实现就是基于边权不为负的情况下。

实现步骤：
1.初始化所有点到起点1的距离为正无穷，且dis[1]=0。
2.将起点信息(0,1)入队进行bfs拓展。
3.将起点相连点入队，即(1,2)，（2,3）入队。更新点2,3的距离信息。
4.继续拓展节点2，3，将(9,4)，(5,4)以及(9,5)入队。此时队首为(5,4)，将该节点出队，得到dis[4]=5。
5.继续拓展，直到终点出队...

2.代码实现：

用dis数组记录到每个点的具体距离，每一次循环后，加上相应的边权

priority_queue<node> q;
void dijkstra(int x) {
	memset(dis,0x3f,sizeof dis);
	dis[x]=0;
	q.push({0,x});
	while(!q.empty()) {
		node t=q.top();
		q.pop();
		int y=t.p;
		vis[y]=true;
		for(int i=he[y]; i; i=nxt[i]) {
			int z=per[i],w=ed[i];
			if(vis[z]==false && dis[z]>dis[y]+w) {
				dis[z]=dis[y]+w;
				q.push({dis[z],z});
			}
		}
	}
}

3.例题：

求单源最短路

给定一个n个点m条边的有向图，图中可能存在重边和自环，所有边权均为正值(边权小于10000)。
请你求出1号点到n号点的最短距离。如果无法从1号点走到n号点，则输出-1。第一行包含整数n和m(n<=1e5,m<=2e5)。
接下来m行每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。

输出一个整数，表示1号点到n号点的最短距离
如果路径不存在，则输出-1。

用例输入 1 

正确代码：

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int n,m,tot,ed[N*2],nxt[N*2],he[N],per[N*2],dis[N*2];
bool vis[N*2];
void add(int x,int y,int z) {//邻接表
	++tot;
	per[tot]=y,ed[tot]=z,nxt[tot]=he[x],he[x]=tot;
}
struct node {
	int d,p;
};
bool operator < (node x,node y) {//重载运算符，明确在优先队列中的排序依据
	return x.d>y.d;
}
priority_queue<node> q;
void dijkstra(int x) {
	memset(dis,0x3f,sizeof dis);
	dis[x]=0;
	q.push({0,x});
	while(!q.empty()) {
		node t=q.top();
		q.pop();
		int y=t.p;
		vis[y]=true;
		for(int i=he[y]; i; i=nxt[i]) {
			int z=per[i],w=ed[i];
			if(vis[z]==false && dis[z]>dis[y]+w) {//比较最小
				dis[z]=dis[y]+w;
				q.push({dis[z],z});//入队
			}
		}
	}
}
int main() {
	cin>>n>>m;
	for(int i=1; i<=m; i++) {
		int x,y,z;
		cin>>x>>y>>z;
		add(x,y,z);//有向图
	}
	dijkstra(1);
	if(dis[n]==0x3f3f3f3f) cout<<-1;//是否遍历到过，没有就没法从医到这个点
	else cout<<dis[n];
	return 0;
}

二.spfa算法：

对于全是正边权的图，我们可以使用dijkstra处理最短路问题。但是如果带有负边边，dijkstra算法无法保证节点出队时一定得到最短路，spfa算法则可以解决这个问题。

1.实现原理：

在求解各点到起点的最小距离dis值时，若某点i产生一个更小的dis[i]，那么节点i后续指向的节点都会重新更新，因此我们可以将该点i再次入队，重新更新。

在枚举到3->5的时候由于它小于之前入队的数，所以要进行出对，并进行更新后再次入队。

2.代码实现：

在dijlstra算法的基础上，加入重新出对与再入队的代码

void spfa() {
	queue<int>q;
	q.push(1);
	memset(dis,0x3f,sizeof dis);
	dis[1]=0;
	vis[1]=true;
	while(!q.empty()) {
		int x=q.front();q.pop();
		vis[x]=false;//出队之后将原来的标记清除
		for(int i=he[x]; i; i=nxt[i]) {
			int y=per[i],w=ed[i];
			if(dis[x]+w<dis[y]){
				dis[y]=dis[x]+w;
				if(vis[y]==false){
					q.push(y);
					vis[y]=true;
				}
			}
		}
	}
}

3.例题：

带负权的最短路计算

给定一个n个点m条边(n<=1e5,m<=2e5)的有向图，图中可能存在重边和自环，边权绝对值小于104。数据保证图中不存在负权回路。

请你求出1号点到n号点的最短距离。如果无法从1号点走到n号点，则输出-1。

第一行包含整数n和m(n<=1e5,m<=2e5)。

接下来m行每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。

输出一个整数，表示1号点到n号点的最短距离
如果路径不存在，则输出-1。

正确代码：

#include<bits/stdc++.h>
using namespace std;
const int N=2e5+5;
int n,m,he[N],per[N],nxt[N],tot,dis[N],ed[N];
bool vis[N];
void add(int x,int y,int z) {
	++tot;
	per[tot]=y,ed[tot]=z,nxt[tot]=he[x],he[x]=tot;
}
long long read(){
	int x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9'){
		if(c=='-') f=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9'){
		x=x*10+c-'0';
		c=getchar();
	}
	return x*f;
}
void spfa() {
	queue<int>q;
	q.push(1);
	memset(dis,0x3f,sizeof dis);
	dis[1]=0;
	vis[1]=true;
	while(!q.empty()) {
		int x=q.front();q.pop();
		vis[x]=false;
		for(int i=he[x]; i; i=nxt[i]) {
			int y=per[i],w=ed[i];
			if(dis[x]+w<dis[y]){
				dis[y]=dis[x]+w;
				if(vis[y]==false){
					q.push(y);
					vis[y]=true;
				}
			}
		}
	}
}
int main() {
	n=read(),m=read();
	for(int i=1; i<=m; i++) {
		int x,y,z;
		x=read(),y=read(),z=read();
		add(x,y,z);
	}
	spfa();
	if(dis[n]==0x3f3f3f3f) cout<<-1;
	else cout<<dis[n];
	return 0;
}

三.贝尔曼福特（bellman_ford）

上面讲到的两种最短路算法(dijkstra与spfa)，他们都是由枚举已知顶点更新未知点。如果我们要在最短路上增加边数限定，即不超过k条边所能构成的最短路，我们就需要将边编号，通过枚举边来实现。

1.实现原理：

枚举边，若左端点值已知，则更新右端点的值。初始化所有点的dis值为正无穷，且dis[1]=0。第1次枚举边：得到dis[2]=1，dis[3]=8第2次枚举边：得到dis[4]=1第3次枚举边：得到dis[5]=2
已知：任意一条路径都是由若干条边组成的链。第一次枚举所有边，可以求出与起点直连的点的最短路。第二次枚举所有边，可以求出不超过2条边所构成的最短路。第k次枚举所有边，可以求出不超过k条边所构成的最短路。

2.代码实现：

使用bellman_ford枚举边，所有用结构体存边并且进行编号。

void bellman_ford(){
	memset(dis,0x3f,sizeof dis);
	dis[1]=0;
	for(int i=0;i<k;i++){
		memcpy(dis_old,dis,sizeof dis_old);
		for(int i=1;i<=m;i++) dis[a[i].y]=min(dis[a[i].y],dis_old[a[i].x]+a[i].w);
	}
}

3.例题：

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离，如果无法从 1 号点走到 n 号点，输出 impossible。

第一行包含三个整数 n,m,k。

接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x
到点 y 的有向边，边长为 z。

点的编号为 1∼n。

输出一个整数，表示从 1 号点到 n 号点的最多经过 k 条边的最短距离。

如果不存在满足条件的路径，则输出 impossible。

正确代码：

#include<bits/stdc++.h>
using namespace std;
const int N=2e5+5;
bool vis[N];
vector<int> v[N];
int n,m,k,dis[N],dis_old[N];//用dis_old记录上一个·点，以此来实现标记边
long long read(){
	int x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9'){
		if(c=='-') f=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9'){
		x=x*10+c-'0';
		c=getchar();
	}
	return x*f;
}
struct node{
	int x,y,w;
}a[N];
void bellman_ford(){
	memset(dis,0x3f,sizeof dis);
	dis[1]=0;
	for(int i=0;i<k;i++){
		memcpy(dis_old,dis,sizeof dis_old);
		for(int i=1;i<=m;i++) dis[a[i].y]=min(dis[a[i].y],dis_old[a[i].x]+a[i].w);
	}
}
int main() {
	n=read(),m=read(),k=read();
	for(int i=1;i<=m;i++) a[i].x=read(),a[i].y=read(),a[i].w=read();
	bellman_ford();
	if(dis[n]>0x3f3f3f3f) cout<<"impossible";
	else cout<<dis[n];
	return 0;
}

四.弗洛伊德（floyd）

floyd算法专门针对多源最短路问题。floyd可以用一个二维矩阵表示两点之间的最短路径，即我们只需要维护图中最小距离的邻接矩阵。floyd本质上就是通过不断为两点的路径上增加中间点(所以又称为插点法)，进而对邻接矩阵进行更新迭代，每加入一个点，矩阵信息就可能变化一次，从而维护该最小距离矩阵。

1.实现原理：

每次枚举是加入一个中间点k，矩阵中有些点对的距离就有可能减小。同时也说明两点的最短路径链上就可能会增加该中间点k。当所有点都作为中间点加入且完成矩阵的更新后，最终矩阵一定存储任意两点之间的距离最小值。

在这幅图中，如果不进行插点，它的初始矩阵是这样的：

1234
100x3f3f3f3f0x3f3f3f3f3
2100x3f3f3f3f8
32503
40x3f3f3f3f0x3f3f3f3f0x3f3f3f3f

0

而在插入1为中间点后，它的矩阵就变成了这样：

1234
100x3f3f3f3f0x3f3f3f3f3
2100x3f3f3f3f4
32503
40x3f3f3f3f0x3f3f3f3f0x3f3f3f3f

0

在插入2为中间点后，它的矩阵又变成这样：

1234
100x3f3f3f3f0x3f3f3f3f3
2100x3f3f3f3f4
32503
40x3f3f3f3f0x3f3f3f3f0x3f3f3f3f

0

最后插入三为中间点后，它的矩阵是这样的：

1234
100x3f3f3f3f0x3f3f3f3f3
2100x3f3f3f3f4
32503
40x3f3f3f3f0x3f3f3f3f0x3f3f3f3f

0

（这只是一个特殊样例，并不是所有可能都只会在插入第一个中间点后才会改变，但经过n-1次插点后路径一定最短）

2.代码实现：

图中存在负边权，且无负权环。n较小，m较大特别稠密，可以使用邻接矩阵存边。最后涉及到多次询问，使用floyd可以维护邻接矩阵，快速求解。

void floyd(){
	for(int k=1;k<=n;k++){
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				if(k==i||k==j||i==j) continue;//可有可无
				if(g[i][j]>g[i][k]+g[k][j]) g[i][j]=g[i][k]+g[k][j],pat[i][j]=k;//修改最短路径
			}
		}
	}
}

3.例题：

给定由n个点m条边的构成无向图，边权可能为负，图中可能存在重边，不存自环以及负权环。

现在给定q组询问，请输出每组询问中节点i到j的最短距离及其路径。

第一行 n,m,q，其中n≤500,m≤106,q≤104。
接下来m行表示这两个点之间有边相连，边权绝对值小于10000。
随后q行，代表接下来有q个询问，每个询问由ai​,bi​构成。

一共输出q行，如果两点不存在路径则输出-1，否则每行第一个数字表示两点之间的最短距离，随后输出其路径(如果存在多条最短路径，则输出字典序最小的一个)

正确代码：

#include<bits/stdc++.h>
using namespace std;
int n,m,q,g[505][505],pat[505][505];
long long read() {
	int x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9') {
		if(c=='-') f=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9') {
		x=x*10+c-'0';
		c=getchar();
	}
	return x*f;
}
void floyd(){
	for(int k=1;k<=n;k++){
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				if(k==i||k==j||i==j) continue;
				if(g[i][j]>g[i][k]+g[k][j]) g[i][j]=g[i][k]+g[k][j],pat[i][j]=k;
			}
		}
	}
}
void print(int x,int y){
	if(pat[x][y]==0){
		cout<<" "<<y;
		return;
	}
	print(x,pat[x][y]),print(pat[x][y],y);
}
int main(){
	n=read(),m=read(),q=read();
	memset(g,0x3f,sizeof g);
	for(int i=1;i<=m;i++){
		int x,y,w;
		x=read(),y=read(),w=read();
		g[x][y]=g[y][x]=min(g[x][y],w);
	}
	floyd();
	for(int i=1;i<=q;i++){
		int x,y;
		x=read(),y=read();
		if(g[x][y]==-1) cout<<-1<<endl;
		else{
			cout<<g[x][y]<<" "<<x;
			print(x,y);
			cout<<endl;
		}
	}
	return 0;
}

4.floyd性质探索：

（1）.性质一

插入中间点的顺序对结果没有影响。

插入一个中间点k后，此时矩阵中任意两点的距离就可能因为该中间点变小，即点k加入了其中两点的路径中。因此，我们只需要保证点1-n都作为中间点插入一次，从而更新矩阵，对插入顺序不作要求。

（2）.性质二

floyd算法在第执行k次插点后，最短路径上的边数一定不会超过k+1。

第1次插点后：
两端点由(i->j)直连变成可能加入一个中间点k相连，变成(i->k->j)，即最短路径上存在不超过两条边。

第2次插点后：
两端点最短路径有可能还是只有一条边构成(i->j)，当然也有可能在第1次插点的基础上增加为两条边构成(i->k->j)，此时插点有可能再增加一个点p，变成3条边。即(i->p->k->j) 或 (i->k->p->j)。

第n次插点后：
两端点最短路径上最多由n+2个点构成，即存在不超过n+1条边

（3）.性质三

在执行第k次插点操作前，所求任意两端点的最短路径上，一定不包含k以及k后的若干点。

与性质1类似插入某一个点，则说明把该点放到两端点的路径上，从而尝试更新两端点的最小距离。同理，未插入的点是没有更新任意两端点的距离。必不在现有的路径上。

5.floyd传递闭包问题

传递闭包是离散数学中的一个概念，简单来说就是维护关系的传递性。如a<b,b<c则有a<c。
我们以前学习过使用并查集解决部分具有关系传递性的问题。在这里，我们可以通过floyd算法去建立与维护关系矩阵。从而快速判断任意两点是否具备当前关系。可以通过g数组来记录每一个点之间的关系，若g[a][b]=1就代表a>b，若g[a][b]=0，则a<b。如果a、b的关系需要通过k来传递，我们可以通过g[a][b] |= (g[a][k] & g[k][b])来转移他们的关系。

Archie28
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ 图像压缩算法
03-17
本篇文章将详细探讨基于C++实现的图像压缩算法，特别是如何利用霍夫曼（Huffman）编码进行图像压缩。 首先，我们需要理解图像的基本构成。图像通常由像素矩阵表示，每个像素包含红、绿、蓝（RGB）三个颜色通道的...
C++数据结构与算法 （第4版）
01-06
C++数据结构与算法 （第4版）
【C++】图的构造算法-邻接表表示法
Var-al 的博客
02-19 1195
结构分析： 算法思想： 输入总顶点数和总边数 建立顶点表，依次输入信息存于顶点表中，将每个顶点头节点的指针域初始化为NULL 创建邻接表，依次输入边所依附的两个顶点，确定两个顶点的下标 i 和 j ，建立边结点，使用头插法分别差入 vi 和 vj 对应的边链表的头部 存储表示： #define MaxInt 32767 // 极大值 #define MVNum 100 // 最大定点数 typedef int ArcType; // 边的权值类型 typedef char
C++之常用通用算法
qq_41920323的博客
05-18 1339
C++通用算法
C++算法之贪心算法
一个程序猿~
05-23 4922
贪心算法是一种求解最优解问题的算法，它的核心思想是每一步都采取当前状态下最优的选择，从而最终得到全局最优解。它是C++重要的一种算法。本文会介绍贪心算法。
C++数据结构与算法实践
m0_55540913的博客
10-27 1687
3、设计一个时间复杂度为O(n)的算法，实现将数组b[n]中所有元素调整为左右两部分，左边为奇数，右边为偶数。cout
C++数据结构与算法分析——Floyd算法
l_red_forest的博客
10-15 2899
介绍 Floyd算法是一种求多源汇最短路的算法，它可以求出任意两点间的最短距离(如果这两点连通的话)，并且Floyd算法非常容易实现： 算法模板O(n3)O(n^3)O(n3) for(int k = 1; k <= n; k ++) for(int i = 1; i <= n; i ++) for(int j = 1; j <= n; j ++) d[i][j] = min(d[i][j],d[i][k] + d[k][j]); 它总共有3层循环，每层n次，所以时间复杂度为
C++ 数据结构算法集合.zip
12-28
C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据...
c++数据结构和算法合集.zip
12-28
c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 ...
C++算法：图算法 （第3版）.rar
06-25
《C++算法：图算法（第3版）》是一本深入探讨图算法的书籍，针对C++编程语言，旨在帮助读者理解和实现各种重要的图论概念和技术。这本书详细讲解了图的搜索策略、图的结构类型、最小生成树算法、最短路径算法以及...
算法-KMP字符串匹配
xx_xb的博客
07-23 177
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 660
AtCoder Beginner Contest 363 ABCDE
【LeetCode】141.环形链表、142. 环形链表 II（算法 + 图解）
最新发布
明志の博客
07-25 853
环形链表
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 756
二叉搜索树向左或向右指明方向，不用遍历整个树。
数据结构与算法--【数组2】力扣练习 || 双指针 / 移除元素 / 数组排序
qq_44578108的博客
07-25 513
简单删除元素 / 指定某元素位置，其余元素位置相对不变双指针指向数组头。快指针扫描数组并判断，慢指针收集变化后的数组元素。不创建新数组，只覆盖原数组。对数组元素排序一个指针指开头，一个指针指结尾。判断两指针指向值大小，循环结束条件first <= last；for循环，while循环均可，本人更习惯while循环。使用malloc为新数组分配空间，注意，创建了新数组。
河南萌新联赛2024第（二）场：南阳理工学院
a13997460860的博客
07-25 657
这场比赛里面出到了很多的题，都是需要很多的时间去写，主要考察到了代码的实现能力，与codeforces里面的题有些差距。codeforces打多了还是有点不习惯的。题挺好的，尤其是H题感觉很考代码实现能力与STL的使用熟练度。多写写这样的题还是对我们很有好处的。只不过前三题都太水了，没有一点难度。
python基础知识点（蓝桥杯python科目个人复习计划73）
m0_73523976的博客
07-25 126
（1）100万元正好被分成若干份，不能有剩余。1 <= |s| <= 5 * 10^5,保证s只包含大写字母、小写字母和数字。地产大佬先生临终的遗愿是拿出100万元给x社区的居民抽奖。1 <= |s| <= 10^6，保证s只包含大小写字母。给定一个长度为n的字符串s，请你判断字符串s是否回文。（3）在满足上述条件的情况下，分成的份数越多越好。给定一个字符串s，请你求出s的最长回文字符串。若字符串s为回文串，则输出Y，否则输出N。输出共1行，包含一个整数，表示答案。输入仅一行包含一个字符串s。
算法力扣刷题记录 五十六【501.二叉搜索树中的众数】
danaaaa的博客
07-21 915
求众数方法
代码随想录算法训练营day8 | 344.反转字符串、541.反转字符串 II、卡码网：54.替换数字
m0_55763458的博客
07-25 440
代码随想录算法训练营day8 | 344.反转字符串、541.反转字符串 II、卡码网：54.替换数字
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值