最短路问题简单汇总

最新推荐文章于 2024-06-13 23:07:13 发布

小郑菜菜

最新推荐文章于 2024-06-13 23:07:13 发布

阅读量82

点赞数

文章标签：算法

本文链接：https://blog.csdn.net/m0_65395195/article/details/132816677

版权

文章目录

最短路

最短路

1.dijkstra算法

dijkstra算法是单源最短路，也就是说以某个点为起点，我们求解这个点到其他点的最短路。

dijkstra的核心思路如下(以下我们假设起点为1)：

$d i s t$ 数组记录了从1点到其他点的最短距离比如说 dist[j]代表从1点到j点的最短距离
首先我们先让dist初始化为正无穷表示一开始我们所有点都和1点无连接只让dist[1]为0 因为自己跟自己的距离肯定是0
之后每次更新dist，首先，我们要找到dist当中的最小值（假如是dist[i]），这个最小值一定是最短路，我们就不用改变他了以后（这个具体为啥，是基于贪心的思想进行证明的）。然后我们看看从当前点（dist最小值的点）直接走到和他相连的点(比如dist[j])和之前已经更新过的dist[j]那个更小取最小值也就是以下公式 ,w表示从i到j需要的权重

$d i s t [j] = min (d i s t [j], d i s t [i] + w)$

我们画个图可能更好理解这个公式描绘的过程就是如下图所示的过程是走红色小还是走黄色小。

在这里插入图片描述

dijkstra可以处理自环和重边对于自环我们有一个st数组记录是否进入被判定为最短路对于重边因为朴素的dijkstra是针对稠密图的，所以用邻接矩阵存，直接取重边的最小值即可
但是 dijkstra无法处理负权边和负环因为越走越小就出不来了

coding

#include<iostream>
#include<cstring>
using namespace std;
const int N=520;
int g[N][N];
int dist[N];
bool st[N];
int n,m;
int dijkstra(int x)
{
// 以x为起点求单源最短路
    memset(dist,0x3f,sizeof(dist));
    dist[1]=0;
    for(int i=1;i<=n;i++)
    {
        int k=-1;
        for(int j=1;j<=n;j++)
        {
            if(st[j]==0&&(k==-1||dist[j]<dist[k]))
            k=j;
        }
        // cout<<k<<endl;
        st[k]=1;
        for(int j=1;j<=n;j++){
            dist[j]=min(dist[j],dist[k]+g[k][j]);
        }

    }   
    // cout<<dist[3];
    if(dist[n]==0x3f3f3f3f)
    return -1;
    return dist[n];

}
int main()
{
  
    cin>>n>>m;
    memset(g,0x3f,sizeof(g));
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        cin>>x>>y>>z;
        g[x][y]=min(g[x][y],z);


    }
    // cout<<g[1][2]<<endl;
    cout<<dijkstra(1)<<endl;

    return 0;
}

这段代码当中需要注意的是去除重边取最小再有就是算法中第一层循环n次和n-1次都可以因为每一次循环都是取出一个dist作为最小做了n-1次之后剩下的哪一个dist肯定是最小的了（因为只有他一个了）
这个算法的时间复杂度是 $O(n^2)$ 的对于稠密图很好用

2.堆优化迪杰斯特拉

对于稀疏图也就是点很多，但是边很少的图我们可以用堆优化的dijkstra

也就是对于每一次找最小dist的过程我们借助于优先队列这个数据结构去找而不是去遍历

coding

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
const int INF=0x3f3f3f3f;
int n,m;
const int N=1e6+100;
int dist[N];
bool st[N];
typedef pair<int,int> PII;
priority_queue<PII,vector<PII>,greater<PII>> heap;
// 优先队列默认为小根堆 
int h[N],e[N],ne[N],w[N];
int idx;
int dijkstra(int x)
{
    memset(dist,0x3f,sizeof(dist));
    dist[x]=0;
    heap.push({0,x});
    while(heap.size())
    {
        auto temp=heap.top();
        heap.pop();
        int distance=temp.first;
        int k=temp.second;
        // cout<<k<<" "<<distance<<endl;
        if(st[k]==1) continue;
        st[k]=1;
        for(int i=h[k];i!=-1;i=ne[i])
        {
             int temp_1=e[i];
            if(st[temp_1]==0)
            {
                if(dist[temp_1]>dist[k]+w[i])
                {
                    dist[temp_1]=dist[k]+w[i];
                    heap.push({dist[temp_1],temp_1});

            }


        }





    }

}
    if(dist[n]==0x3f3f3f3f)
    return -1;
    return dist[n];

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

    cin>>n>>m;
    memset(h,-1,sizeof(h));3.
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        cin>>x>>y>>z;
        add(x,y,z);
    }
    cout<<dijkstra(1)<<endl;
    return 0;
}

注意这个算法的时间复杂度是 $nlog_m$ 的也就是针对稀疏图非常的有效
if(st[k]==1) continue; 不加这个语句这个代码可能会退化成 $O(n^2)$ 的朴素迪杰斯特拉
注意迪杰斯特拉算法无法解决负权边如下图就得不到答案

3.bellman_ford

bellman_ford算法的思路非常简单进行n次循环每次循环内部对我们的dist数组做一下松弛操作

dist[a]+w)那么什么是松弛操作？松弛操作就是假如图当中有一条边 (a,b,w) 表示a指向b 距离为w，那么松弛操作就是注意这里的dist[a]+w是上一次迭代当中的dist 至于为什么要这么做看下面那个问题

$d i s t [b] = min (d i s t [b], d i s t [a] + w)$

为什么要这样做那

我们首先要明确每迭代一次代表什么，我们先看下面这张图，经过我们第一次更新结果应该是 :

dist[2]=1,dist[3]=2,dist[4]=INF INF表示无穷

经过第二次更新

dist[2]=1,dist[3]=2,dist[4]=5

我们可以管中窥豹的看出一些问题，首先，为什么要是以前的状态因为我们的贝尔曼–福德算法相当于是每一次迭代，如果有更新的话假设现在是第k次迭代那么就表示我们的最短路从1走到现在这个点需要迭代的点需要k步，如果是现在的状态的话，那么就有可能出现串联现象也就是说会在第一次就让我们的dist[4]等于5 这看起来是正确的但是是不符合贝尔曼–福德算法的设计思想的这样就无法保证是第2步走到我们的4的了也就是说如果从1-4有两条边的话我们要保证在遍历第二次之前 1和4依旧是不连通的

再有就是为什么循环n次一定能获得答案（如果有的话），因为如果第n次还有更新的话（一般不会更新）那么就代表 1-n之间有n条边，这不可能，所以说如果n次都找不到答案，那么就代表了从1-n有负环存在有的环路越走越小了，不断的在被更新。

在这里插入图片描述

什么情况没有最短路

和迪杰斯特拉不一样 bellman_ford算法允许有负权边但是不允许有负环，因为负环可能存在没有最短路的情况但是可能有因为负环可能每在1-n要走的路上。所以在所经过的路上有负环的最短路是无法求解的因为负环的话一定是越走越小的只要一直在负环里面转圈。

所以说 bellman_ford算法的应用就只有最多走k步得到最短路这一种情况因为他的时间复杂度是 $O (n * m)$ 处理不带负权边的情况不如堆优化的迪杰斯特拉处理带负权变的情况不如SPFA 所以就比较局限

accoding

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int n,m,k;
const int N=520;
const int M=1e4+100;
typedef struct
{
int a;
int b;
int w;

}edge;
edge g[M];
int dist[N],backup[N];
int bellman_ford()
{
    memset(dist,0x3f,sizeof(dist ));
    dist[1]=0;
    for(int _=1;_<=k;_++)
    {
        memcpy(backup,dist,sizeof(dist));
        for(int i=1;i<=m;i++)
        {
            int a=g[i].a,b=g[i].b,c=g[i].w;
            dist[b]=min(dist[b],backup[a]+c);


        }



    }
    
    if(dist[n]>0x3f3f3f3f/2)
    return -1e9;
    return dist[n];


}
int main()
{
    cin>>n>>m>>k;
    for(int i=1;i<=m;i++){
        int a,b,w;
        cin>>a>>b>>w;
        g[i]={a,b,w};

    }
    int t=bellman_ford();
        if(t==-1e9)
            cout<<"impossible";
        else 
        cout<<t<<endl;

    return 0;
}

4.SPFA

我们可以看到贝尔曼福德算法有一个问题就是他很笨我们更新了很多不需要更新的点

我们可以观察到 dist[b]=min(dist[b],dist[a]+w)这样的松弛操作 只有在dist[a]改变的时候 其他才会变换 于是SPFA的思想就是 每次只更新dist 变换之后的变 因为 这个带有拓补排序的特征 所以如果1-n之间没有边的话 是不会更新到n的 。

SPFA算法的时间复杂度一般是 $O (m)$ 但是遇到菊花图会退化退化成贝尔曼福德算法所以如果是正权图的话我们也可以用，只要出题人不卡就可以了。但是 spfa依然不能处理负环问题

accoding:

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
const int INF=0x3f3f3f3f;
int n,m;
const int N=1e6+100;
int dist[N];
bool st[N];
// 优先队列默认为小根堆 
int h[N],e[N],ne[N],w[N];
int idx;
int spfa(int x)
{
    queue<int > q;
    memset(dist,0x3f,sizeof(dist));
    dist[1]=0;
    q.push(1);
    st[1]=true;
    while(q.size())
    {
        auto temp=q.front();
        q.pop();
        st[temp]=false;
        for(int i=h[temp];i!=-1;i=ne[i]){
            int g=e[i];
            if(dist[g]>dist[temp]+w[i])
            {
                dist[g]=dist[temp]+w[i];
                if(st[g]==false)
                {   
                    st[g]=true;
                    q.push(g);
                }


            }


        }



    }


    if(dist[n]==0x3f3f3f3f)
    cout<<"impossible"<<endl;
    else 
    cout<<dist[n]<<endl;
    return dist[n];
}
void add(int a,int b,int c)
{
    e[idx]=b;
    ne[idx]=h[a];
     w[idx]=c;
    h[a]=idx++;
   
}
int main()
{

    cin>>n>>m;
    memset(h,-1,sizeof(h));
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        cin>>x>>y>>z;
        add(x,y,z);
    }
   int t=spfa(1);
    return 0;
}

5floyd

直接背板子动态规划模板注意i,k,j的遍历顺序即可而且是多元最短路比较easy

#include<iostream>
#include<string.h>
#include<algorithm>
using namespace std;
const int N=200+10; 
const int INF=1e9;
int d[N][N];
int n,m,k;
void flod()
{
    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]);
}
int main()
{
    cin>>n>>m>>k;
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)//初始化数组 
    {
        if(i==j)
        d[i][j]=0;
        else 
        {
            d[i][j]=INF;
        }

    }
    while(m--)
    {
        int x,y,right;
        cin>>x>>y>>right;
        d[x][y]=min(d[x][y],right);//防止重边 
    }
    flod();
    while(k--)
    {
        int x,y;
        cin>>x>>y;
        if(d[x][y]>=INF/2)//存在负权边 
        {
            cout<<"impossible"<<endl;

        }
        else 
        {
            cout<<d[x][y]<<endl;
        }

    }
    return 0;   
 }

小郑菜菜

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
最短路问题简单汇总

所以在所经过的路上有负环的最短路是无法求解的因为负环的话一定是越走越小的只要一直在负环里面转圈。再有就是为什么循环n次一定能获得答案（如果有的话），因为如果第n次还有更新的话（一般不会更新）那么就代表 1-n之间有n条边，这不可能，所以说如果n次都找不到答案，那么就代表了从1-n有负环存在有的环路越走越小了，不断的在被更新。 dijkstra算法是单源最短路，也就是说以某个点为起点，我们求解这个点到其他点的最短路。 SPFA算法的时间复杂度一般是。
复制链接

扫一扫