图论最短路问题（总结篇）

已于 2024-05-11 09:33:49 修改
阅读量765 收藏 10
点赞数 18
文章标签： 图论 算法
于 2024-05-06 23:00:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjqnnn_/article/details/138511383
版权

关于最短路，这里展示几个相关的算法及对应题目和代码

1.Dijkstra算法

        定住一个点求到其他点的最短路，缺点是无法求有边权为负值的图

       模板例题 练习1

#include<bits/stdc++.h> //最短路模板
using namespace std;
struct ty1{
    int to;
    int l;
};
vector<ty1>q[1009];
long long  dis[1009];
int vis[1009];
struct ty2{
    int x;
    long long len;
    bool operator <(const ty2 &a)const{
        return len>a.len;    //将点用len从大到小排序
    }
}tmp;
void dijk(int s,int t)
{
    memset(dis,0x3f3f3f3f,sizeof(dis));
    dis[s]=0;
    priority_queue<ty2>k; //应用在优先队列后，会将排序变为从小到大排序
    k.push({s,0});
    int i;
    while(k.size())
    {
        tmp=k.top();
        k.pop();
        int st=tmp.x;
        if (vis[st])
            continue;
        vis[st]=1;
        for(i=0;i<q[st].size();i++)
        {
            int y=q[st][i].to;
            if (vis[y])
                continue;
            if (dis[st]+q[st][i].l<dis[y])
            {
                dis[y]=dis[st]+q[st][i].l;
                k.push({y,dis[y]});
            }
        }
    }
    if (dis[t]>=0x3f3f3f3f)
        cout<<"-1"<<endl;
    else cout<<dis[t]<<endl;
    
}

int main ()
{
    int n,m,s,t;
    int i,a,b,v;
    cin>>n>>m>>s>>t;
    for(i=1;i<=m;i++)
    {
        cin>>a>>b>>v;
        q[a].push_back({b,v}); //无向边
        q[b].push_back({a,v});
    }
    dijk(s,t);
    return 0;
}

2.spfa 算法

        补上了上一个算法无法在有负边权的情况，但效率相对上一个较慢

        例题 同上

#include<bits/stdc++.h> //最短路模板
using namespace std;
struct ty1{
    int to;
    int l;
};


void spfa(int s,int t)
{
    queue<int>q2;
    q2.push(s);
    memset(dis,0x3f3f3f3f,sizeof(dis));
    dis[s]=0;
    vis[s]=1;
    while(q2.size())
    {
        int x=q2.front(),i;
        q2.pop();
        vis[x]=0;
        for(i=0;i<q[x].size();i++)
        {
            int y=q[x][i].to;
            if (dis[y]>dis[x]+q[x][i].l)
            {
                dis[y]=dis[x]+q[x][i].l;
                if (!vis[y])
                {   q2.push(y);
                     vis[y]=1;}  //在spfa中vis 表示当前点是否在队列里
            }
        }
    }
    if (dis[t]>=0x3f3f3f3f)
        cout<<"-1"<<endl;
    else cout<<dis[t]<<endl;
}
int main ()
{
    int n,m,s,t;
    int i,a,b,v;
    cin>>n>>m>>s>>t;
    for(i=1;i<=m;i++)
    {
        cin>>a>>b>>v;
        q[a].push_back({b,v});
        q[b].push_back({a,v});
    }
    spfa(s,t);
    return 0;
}

3.floyd算法

        方便用于多次输出一点到另一点的最短路径

        例题 练习2

#include<bits/stdc++.h>
using namespace std;
int n,m;
long long f[150][140];
void floyd()
{
	int i,j,k;
	for(k=1;k<=n;k++)
	{
		for(i=1;i<=n;i++)
		{
			for(j=1;j<=n;j++)
			{
				if (i!=j&&i!=k&&k!=j)
				{
					if (f[i][k]+f[k][j]<f[i][j])
						f[i][j]=f[i][k]+f[k][j];
				}
			}
		}
	}
}
int main ()
{
	cin>>n>>m;
	int i,u,v,w,j;
	memset(f,0x3f3f3f,sizeof(f));
	for(i=1;i<=n;i++)
		f[i][i]=0;
	for(i=1;i<=m;i++)
	{
		cin>>u>>v>>w;
		f[u][v]=min(f[u][v],w);
		f[v][u]=min(f[v][u],w);
	}
	floyd();
	for(i=1;i<=n;i++)
	{
		for(j=1;j<=n;j++)
			cout<<f[i][j]<<" ";
		cout<<endl;
	}
	return 0;
}

图片来源于：牛客竞赛

    关于做题我这里分成四类

1.单源最短路径：一般套用模板即可，不是特别难

2.负环与差分约束

负环 ：例题 链接 主要是通过spfa来判断一个点入队次数是否超过n-1次来判断是否形成负环

#include<bits/stdc++.h>
using namespace std;
int n,m;
struct ty1{
	int to;
	int l;
	int next;
}edge[70000];
int cnt=0;
int head[3000];
void add(int x,int y ,int z)
{
	edge[++cnt].to=y;
	edge[cnt].l=z;
	edge[cnt].next=head[x];
	head[x]=cnt;
}
long long dis[3000];

bool  spfa()
{
	int vis[3000]={0},i;
	int cnt[3000]={0};
	dis[1]=0;
	queue<int>q;
	q.push(1);
	vis[1]=1;
	cnt[1]++;
	while(q.size())
	{
		int x=q.front();
		q.pop();
		vis[x]=0;
		for(i=head[x];i!=-1;i=edge[i].next)
		{
			int y=edge[i].to;
			if (dis[y]>dis[x]+edge[i].l)
			{
				dis[y]=dis[x]+edge[i].l;
				if (vis[y]==0)
				{
					q.push(y);
					cnt[y]++;
					if (cnt[y]>=n)
						return true;
					vis[y]=1;
				}
			}
		
		}		
	}
	return false;
}
int main ()
{
	int t,i;
	int u,v,w;
	cin>>t;
	while(t--)
	{
		cin>>n>>m;
		memset(dis,0x3f3f3f3f,sizeof(dis));
		memset(head,-1,sizeof(head));
		for(i=1;i<=m;i++)
		{
			cin>>u>>v>>w;
			if (w>=0)
			{
				add(u,v,w);
				add(v,u,w);
			}
			else add(u,v,w);
		}
		if (spfa())
		{
			cout<<"YES"<<endl;
		
		}
		else cout<<"NO"<<endl;
		
	}
}

差分约束 例题 链接

      解题思路（引用洛谷第一篇题解）

  根据题目要求选择不同的连边方法和对应的解法，最长路只是在最短路改了一些，不难

ac代码，本道题两种方法都可，我用的是最短路的求解

#include<bits/stdc++.h>
using namespace std;
int n,m;
struct ty1{
	int to;
	int l;
	int next;
}edge[500000];
int k=0;
int head[50000];
void add(int x,int y ,int z)
{
	edge[++k].to=y;
	edge[k].l=z;
	edge[k].next=head[x];
	head[x]=k;
}
long long dis[50000];
int vis[50000];
	int cnt[50000];
bool  spfa()
{
	int i;
	dis[0]=0;
	queue<int>q;
	q.push(0);
	vis[0]=1;
	while(q.size())
	{
		int x=q.front();
		q.pop();
		vis[x]=0;
		for(i=head[x];i!=-1;i=edge[i].next)
		{
			int y=edge[i].to;
			if (dis[y]>dis[x]+edge[i].l)
			{
				dis[y]=dis[x]+edge[i].l;
				if (vis[y]==0)
				{
					q.push(y);
					cnt[y]++;
					if (cnt[y]>=n+1)
						return true;
					vis[y]=1;
				}
			}
		
		}		
	}
	return false;
}
int main ()
{
	cin>>n>>m;
	int i,c1,c2,y;
	memset(head,-1,sizeof(head));
	memset(dis,0x3f3f3f3f,sizeof(dis));
	for(i=1;i<=n;i++)
		add(0,i,0);
	for(i=1;i<=m;i++)
	{
		cin>>c1>>c2>>y;
		add(c2,c1,y);
	}
	if (spfa())
	{
		cout<<"NO"<<endl;
	}
	else {
		for(i=1;i<=n;i++)
			cout<<dis[i]<<" ";
	}
	return 0;
}

3.次最短路 找到长度第二小的路径，其实就是在最短路的基础上修改一条边，先从起点开始求各点到起点的最短路，后再求一次终点出发到各点的最短路。最后枚举每一条边，如果起点到该边的起点+该边边权+终点到该边的终点的最短路>大于起点到终点的最短路，加入考虑，求最小值，此时就是求得次最短路

题目 链接

#include<bits/stdc++.h>
using namespace std;
int n;
struct ty1{
	int to;
	int l;
	int next;
}edge[500009];
int cnt=0;
int head[200019];
long long dis1[200010],dis2[200010];
struct ty2{
	int x;
	long long len;
	bool operator <(const ty2 &a)const{
		return len>a.len;
	}
	
}tmp;
void dijk1()
{
	int vis[100010]={0};
	priority_queue<ty2>q;
	q.push({1,0});
	dis1[1]=0;
	int i;
	while(q.size())
	{
		tmp=q.top();
		q.pop();
		if (vis[tmp.x])
			continue;
		vis[tmp.x]=1;
		for(i=head[tmp.x];i!=-1;i=edge[i].next)
		{
			int y=edge[i].to;
			if (vis[y])
				continue;
			if (dis1[y]>dis1[tmp.x]+edge[i].l)
			{
				dis1[y]=dis1[tmp.x]+edge[i].l;
				q.push({y,dis1[y]});
			}
		}
	}

}
void dijk2()
{
	int vis[100010]={0};
	priority_queue<ty2>q;
	q.push({n,0});
	dis2[n]=0;
	int i;
	while(q.size())
	{
		tmp=q.top();
		q.pop();
		if (vis[tmp.x])
			continue;
		vis[tmp.x]=1;
		for(i=head[tmp.x];i!=-1;i=edge[i].next)
		{
			int y=edge[i].to;
			if (vis[y])
				continue;
			if (dis2[y]>dis2[tmp.x]+edge[i].l)
			{
				dis2[y]=dis2[tmp.x]+edge[i].l;
				q.push({y,dis2[y]});
			}
		}
	}
}
void add(int x,int y,int z)
{
	edge[++cnt].to=y;
	edge[cnt].l=z;
	edge[cnt].next=head[x];
	head[x]=cnt;
}
int main ()
{
ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	int r;
	cin>>n>>r;
	int i,j,a,b,d;
	memset(head,-1,sizeof(head));
	memset(dis1,0x3f3f3f3f,sizeof(dis1));
	memset(dis2,0x3f3f3f3f,sizeof(dis2));
	for(i=1;i<=r;i++)
	{
		cin>>a>>b>>d;
		add(a,b,d);
		add(b,a,d);
	}
	dijk1();
	dijk2();
	long long dum;
	long long ans=2e8;
//	for(i=1;i<=n;i++)
//		cout<<dis1[i]<<" ";
//	cout<<endl;
//	for(i=1;i<=n;i++)
//		cout<<dis2[i]<<" ";
//	cout<<endl;
	for(i=1;i<=n;i++)
	{
		for(j=head[i];j!=-1;j=edge[j].next)
		{
			int y=edge[j].to;
			dum=dis1[i]+dis2[y]+edge[j].l;
			if (dum>dis1[n]&&dum<ans)
			{
				ans=dum;
			}
		}
	}
	cout<<ans<<endl;
	return 0;
}

4.传递闭包

题目 链接

floyd的一道常见延申题，总的来说就是传递性，一个点能通过一个中转点到达原本不能直接到达的点。

#include<bits/stdc++.h>
using namespace std;
int n;
bitset<110>f[110];
void floy()
{
	int i,k;
	for(k=1;k<=n;k++)
	{
		for(i=1;i<=n;i++)
		{
			if (f[i][k])
				f[i] |= f[k];
		}
	}
}
int main ()
{

	cin>>n;
	int i,j;
	int x;
	for(i=1;i<=n;i++)
	{
		for(j=1;j<=n;j++)
		{
			cin>>x;
			if (x)
				f[i][j]=1;
		}
	}
	floy();
	for(i=1;i<=n;i++)
	{
		for(j=1;j<=n;j++)
			cout<<f[i][j]<<" ";
		cout<<endl;
	}
	return 0;
}

wjqnnn_
关注
  • 18
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
NOIP图论最短路.pptx
07-29
最短路径问题是图论研究中的一个经典算法问题， 旨在寻找图（由结点和路径组成的）中两结点之间的最短路径。
图论最短路方法详细介绍
07-25
在图论中，最短路问题是一个核心议题，主要涉及寻找两个或多个节点之间路径的最小代价。本文将详细介绍几种常见的最短路算法，包括Dijkstra算法、Dijkstra的堆优化、Floyd算法以及Bellman-Ford算法。 首先，...
图论 ——五种最短路算法
qq_46056407的博客
03-29 9046
文章目录 前言 一、最短路是什么？ 二、朴素Dijkstra算法 三、堆优化版Dijkstra算法 四、Bellman-Ford算法 五、Spfa算法 六、Floyd算法 总结 前言 本篇文章讲的是图论里的最短路问题，如果你还没有图论的基础知识，可以看看我之前的文章： DFS（深度优先算法）BFS(广度优先算法）邻接表和邻接矩阵、树的遍历 （DFS和BFS） 这些都是关于图论的基本知识。 一、最短路是什么？ 最短路径： 从某个点A（位置）到另一个点B(位置)的最..
OI学习笔记之图论最短路算法
Hoyoak的博客
08-10 315
最短路 没有用的话qaq : Ummmm…图论的大部分知识本来早就有学过，只是一直没有写成博文来梳理，但既然上了qbxt DP图论就写一篇来总结下，主要是来听DP的，但…由于太菜的原因，DP听得天花乱坠QWQ 图中的最短路算法分为单源最短路算法（dijkstra,Bellman-food,spfa）和多源最短路算法(floyd),单源最短路算法是求图上一点到其他任意一点的最短路径，多源最短路算...
图论——最短路
faith_xy的博客
07-25 791
和Bellman-Ford一样，因为在SPFA中每一个点松弛过后说明这个点距离更近了，所以有可能通过这个点会再次优化其他点，所以将这个点入队再判断一次，而Dijkstra中是贪心的策略，每个点选择之后就不再更新，如果碰到了负边的存在就会破坏这个贪心的策略就无法处理了。算法只能应用于正权图，因为当把一个节点选入集合S时，即意味着已经找到了从源点到这个点的最短路径，但若存在负权边，就与这个前提矛盾，可能会出现得出的距离加上负权后比已经得到S中的最短路径还短。最后，dp[i][j]就为i~j的最短路。......
图与网络02—最短路问题
weixin_51128278的博客
07-02 1906
图与网络02—最短路问题 上一篇blog主要是基础内容，接下来就是来解决实际问题了，“亿点点慢慢来”，争取敲一篇就搞懂一篇！ 图与网络分析图与网络02—最短路问题前言一、固定起点的最短路1.Dijkstra(迪杰斯特拉)标号算法二、所有顶点对之间最短路的Floyd算法1.引入库2.读入数据三、最短路应用范例四、最短路问题的0-1整数规划模型 前言 咕咕~~ 一、固定起点的最短路 [定义2.1] 设图GGG是赋权图，ΓΓΓ为GGG中的一条路。则称ΓΓΓ的各边权之和为路ΓΓΓ的长度。 对于连通的赋权图GGG
最短路问题
涛涛的个人博客
01-24 428
算法竞赛最短路问题算法基础入门，包含相关思路和核心代码实现。
最短路问题的五种算法
GD_ONE的博客
02-08 9865
本文主要介绍关于图的最短路的五种常用算法和其应用。朴素Dijkstra堆优化DijkstraSPFAFloyd。这几种算法有各自的优势和劣势，适用于不同的场景。另：本篇文章篇幅较长，但难度不大， 建议学习算法的同时，自己手动画图，并模拟算法流程，将会一目了然，所见即所得！一定要画图。一定要刷题。写题的时候一定要注意是不是无向图， 无向图的话建边时要建一来一去两条,如果用邻接表存，数组一定要开足够大，至少是边数的两倍。对于邻接矩阵，要判断重边。邻接表则不需要判断重边。
最短路问题-基础篇
weixin_50518617的博客
04-09 129
先写篇博客回复一下心情吧 图论太难了，我不配 总结一下这几天学的吧。 朴素版dijkstra算法 时间复杂是 O(n2+m), n 表示点数，m 表示边数 主要用于解决边权为正，存在重边和自环； 参考链接 #include<iostream> #include<cstring> #include<cstdio> #include<algorithm> #include<cmath> #include<algorithm> #includ
图论（五）单源最短路算法
qq_45785407的博客
11-25 1277
目录一 单源最短路问题二 有向无环图的单源最短路算法三 Dijkstra算法3.1 原理3.2 伪代码与代码实现3.3 时间复杂度分析3.4 正确性证明3.5 与BFS和Prim算法的比较四 Bellman-Ford算法4.1 无负圈的最短路算法4.2 正确性分析4.3 检测负圈4.4 完整的Bellman-Ford算法 一 单源最短路问题 给出单源最短路的定义：给定一个有向图G=(V,E)，每条边都有一个权重wiw_iwi​，在现实问题中，权重可以代表长度、时间、成本、罚款损失…，我们可以简单的理解为长
一周小结——图的最短路算法总结篇
qq_57150526的博客
10-12 296
树与图最短路算法详解
图论最短路dijkstra算法.doc
05-06
图论最短路 Dijkstra 算法 图论最短路 Dijkstra 算法是计算图论中从一个节点到另一个节点的最短路径的经典算法。该算法于 1959 年由荷兰数学家 Edsger W. Dijkstra 首次提出，是一种常用的图论算法。 算法描述 ...
最短路问题及其应用.pdf
03-30
最短路问题是一个在图论中非常重要的概念，主要涉及如何在给定的网络中找到两个节点之间具有最小代价的路径。这个问题最早在20世纪60年代就已经得到了广泛研究，其中Dijkstra算法和Floyd算法是两种常用的方法。 ...
图论最短路
10-27
不用多说最短路估计学算法的一定不会陌生了吧，但是网上资源比较杂很难找到好的，这是我学习看的希望对你们有所帮助。
再来点boss题解
mikeshizi1234的博客
07-22 339
我们可以发现同一个边双内的点之间没有必须经过的边。所以在这一道题目中，我们只需要把给我们的图给缩点缩成一棵树，然后跑两边 dfs 求树的直径即可，也就是 2 个板子套一下就可以了。找到两个点 s,t ，使得 s 到 t 必须经过的边最多（一条边无论走哪条路线这一条边都经过，这条边就是必须经过的边）。if(dfn[s]<=low[v])//直接就是一座桥。void tarjan(int s,int last)//缩点板子，不必多说。void dfs_0(int s)//跑2遍dfs，求树的直径。
力扣刷题-图论-岛屿类问题-集合实现（c++实现）
最新发布
07-23 313
【代码】力扣刷题-图论-岛屿类问题-集合实现（c++实现）
【18】输出字符菱形
2301_78786609的博客
07-19 390
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 338
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值