图论——最短路

最新推荐文章于 2024-04-07 21:31:24 发布

Crayone_

最新推荐文章于 2024-04-07 21:31:24 发布

阅读量307

点赞数 1

CC 4.0 BY-SA版权

分类专栏：图论

本文链接：https://blog.youkuaiyun.com/qq_43344009/article/details/90210485

图论专栏收录该内容

1 篇文章

订阅专栏

本文介绍了两种求解图中两点间最短路径的算法：Floyd算法和Dijkstra算法。Floyd算法通过三层循环寻找所有点之间的最短路径，适用于小规模数据；Dijkstra算法则通过优先队列优化，每次选择与源点最近的点进行更新，适用于大规模数据。文章通过实例和代码解析了这两种算法的工作原理和优化思路。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

引入
最短路，从字面意义上理解就是两点之间权值最短的路径，那我们如何实现找到这个路径呢？

算法一，Floyd
我们知道，两点之间的最短距离的优化，通常都是通过另外一个点来实现的，如下图
在这里插入图片描述
点u到点w本来距离是9，但如果经过v点的中转优化，最小距离值就从9优化到了3+4=7了
那么通过这个例子，我们就可以得出这个算法的思想，也就是通过枚举起始点，中转点，目标点来不断优化两点之间的最小距离
这是最简易的方法，复杂度也是最大的

时间：O(n^3)
空间：O(n^2)

这种方法，只要n<=500，都不会TLE。一般适合用于需要求多个点之间的最小距离（但是这个还是要看具体题目，有些还是要用到别的算法），或是直接打印最小距离的地图

for(i=1;i<=n;i++)
		for(j=1;j<=n;j++)
			for(k=1;k<=n;k++)
				if(e[j][k]>e[j][i]+e[i][k]) e[j][k]=e[j][i]+e[i][k];

这边解释一下三层循环的意义
为什么第一层放中转点？因为每次的更新都是因为中转点而更新，如果第一层放起始点，那么就会出现这样情况
在这里插入图片描述
a到c的距离如果只经过b点的优化的话，那么值为7。但是实际上，最短路径却是a到b到d到c，权值和为6
算法二，Dijkstra
Floyd固然很方便，但是遇到大数据就TLE了，所以我们需要有种更快的算法。

我们不妨理解Floyd为盲目的优化更新，我们需要更有针对性的算法，也就是每次都只为源点服务的算法，也就是说，我们要尽量优化每一个点到源点的距离

我们先用邻接矩阵或邻接表存储每个点到源点的距离，后期在这里进行优化和修改

每次循环，我们找到与源点最接近的点。因为它是最近的点，所以为了更新到源点的距离，想到要得到最近也只能通过这个点来优化。

用个比喻来形象的理解，每次与源点最接近的点不妨看做班上的“好学生”，源点为老师心中的“理想学生”，为了更接近老师心中的“理想学生”，最好的优化就是向“好学生”学习。

这里的“学习”，我们称之为“松弛”

插入一个引例（图片部分来自《啊哈算法》）
在这里插入图片描述
（默认点1为源点）
那么点与点之间的距离表达如下（这里使用的是领接矩阵）

以及初始到源点的距离

首先我们可以看出，目前距离源点最近的点是点2，所以我们通过点2松弛其余各点
在这里插入图片额述
松弛之后，当前距离源点最近的点是点4，所以我们通过点4松弛
在这里插入图片描述
松弛之后，当前距离源点最近的点是点3，所以我们通过点3松弛（接下来直接上图）

松弛之后，当前距离源点最近的点是点5，所以我们通过点5松弛

松弛点6

代码如下（这里使用的是经过邻接表+优先队列的优化）

#include<iostream>
#include<cstdio>
#include<queue>
using namespace std;
const long long INF=0x7fffffff;
typedef pair<long long,long long> P;//first为最短路径 second为编号 
struct node
{	long long nx;
	long long v;
	long long w;
}p[200001];
long long ne,n,m,s,f[40001],d[40001],u,v,w,ans[40001];
//f为领接表辅助，d为一个点到原点的距离 
void contact(long long u,long long v,long long w){
	p[++ne].v=v;
	p[ne].w=w;
	p[ne].nx=f[u];
	f[u]=ne;
}
void Dijkstra(long long s)
{	priority_queue<P,vector<P>,greater<P> > que;//小根堆 
	for(long long i=1;i<=n;i++)d[i]=INF;
	d[s]=0;
	que.push(P(0,s));
	while(!que.empty())
	{	P g=que.top();
		que.pop();
		int v=g.second;
		if(d[v]<g.first)continue;
		for(int i=f[v];i!=0;i=p[i].nx)
			if(d[p[i].v]>d[v]+p[i].w)
			{	d[p[i].v]=d[v]+p[i].w;
				que.push(P(d[p[i].v],p[i].v));
			}
	}
}
int main(){

	long long maxx=0,b;
	scanf("%lld%lld%lld%lld",&n,&m,&b,&s);
	for(int i=1;i<=m;i++){
		cin>>u>>v>>w;
		contact(u,v,w);
	}
	Dijkstra(b);
	printf("%lld",d[s]);
	return 0;
}

算法三，SPFA

#include<iostream>
#include<queue>
using namespace std;
int n,m,s;
#define MM 500005
#define MN 10005
#define INF 99999999
#define IINF 2147483647
struct node{int u,v,w,next;};
node edge[MM];
int head[MN];
int spfa[MN];
queue<int>q;
bool inq[MN];
void SPFA()
{
    q.push(s);
    inq[s]=true;
    for(int i=1;i<=n;i++) spfa[i]=INF;
    spfa[s]=0;
    while(!q.empty())
    {
        int u=q.front();q.pop();
        inq[u]=false;
        for(int i=head[u];i>0;i=edge[i].next)
        {
            int v=edge[i].v;
            int w=edge[i].w;
            if(spfa[v]>spfa[u]+w)
            {
                spfa[v]=spfa[u]+w;
                if(!inq[v])
                {
                    inq[v]=true;
                    q.push(v);
                }
            }
        }
    }
}
int main()
{
    cin>>n>>m>>s;
    for(int i=1;i<=m;i++)
    {
        int u,v,w;
        cin>>u>>v>>w;
        edge[i]=(node){u,v,w,head[u]};
        head[u]=i;
    }
    SPFA();
    for(int i=1;i<=n;i++)
    {
        if(spfa[i]==INF) spfa[i]=IINF;
        cout<<spfa[i]<<" "; 
    }
    return 0;
}