最最全的短路算法

于 2024-09-13 00:15:00 发布
阅读量468 收藏 5
点赞数 14
分类专栏： 算法 文章标签： 图论 算法 数据结构 c++ 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79974919/article/details/142067355
版权

  1. dijkstra

适用范围：一源对多点，堆优化，多源对一点，建反图，适用于非负权图

  • 朴素算法

每次寻找离起点最近的点，以其为中介点最松弛操作，未经任何数据结构和算法的优化，时间复杂度为O(n^2)

#include<bits/stdc++.h>
#define maxn 20000
#define INF 2147483647
#define ll long long
using namespace std;
struct Edge{int to;
    int w;
    int next;
}edge[500005];
ll head[maxn],dis[maxn],vis[maxn]={0};
int n,m,s,tot=0;
void addedge(int u,int v,ll w){
    edge[++tot].w=w;
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot;
}
int main(){
    scanf("%d%d%d",&n,&m,&s);
    for(int i=0;i<=n;i++)
    head[i]=-1;
    for(int i=1;i<=m;i++)
    {
        int u,v,w;
        scanf("%d%d%lld",&u,&v,&w);
        addedge(u,v,w);
    }
    for(int i=1;i<=n;i++)
    dis[i]=INF;
    dis[s]=0;
    int cur=s,nex,minm=INF;
    for(int i=1;i<=n-1;i++)
    {
        vis[cur]=1;
        for(int j=head[cur];~j;j=edge[j].next)
        if(!vis[edge[j].to]&&dis[edge[j].to]>dis[cur]+edge[j].w)
        dis[edge[j].to]=dis[cur]+edge[j].w;
        for(int j=1;j<=n;j++)
        if(!vis[j]&&dis[j]<minm)
        {
            minm=dis[j];
            nex=j;
        }
        if(minm==INF)
        break;
        cur=nex;
        minm=INF;
    }
    for(int i=1;i<=n;i++)
    printf("%lld ",dis[i]);
}

  • 堆优化

利用小顶堆维护dis数组的大小顺序，虽然会遍历m条边，但每次存储和取出最小边仅需logm的复杂度，总时间复杂度O(mlogm)

#include<bits/stdc++.h>
#include<queue>
#define maxn 10000
#define INF 1e10
#define ll long long
using namespace std;
struct Edge{
    int to;
    ll w;
    int next;
}edge[maxn];
struct node{
    int id;
    ll dis;
    bool operator <(const node &a)const{return a.dis<dis;}
};
ll head[maxn],dis[maxn],vis[maxn]={0};
int n,m,s,tot=0;
void dij(void)
{
    priority_queue<node>q;//加了一个小顶堆用于维护dis数组的某些信息
    node cur,nex;
    cur.id=s;
    cur.dis=0;
    q.push(cur);
    for(int i=1;i<=n;i++)
        dis[i]=INF;
    dis[s]=0;
    while(!q.empty())
    {
        cur=q.top();//每次从堆中拿出1.未遍历过的2.dis最小的点，不需要一个一个地查
        q.pop();
        if(vis[cur.id])continue;//个人理解为清除剩下的因为距离过长而导致后遍历的边
        vis[cur.id]=1;//能进入以下循环的应该只有n个点
        for(int i=head[cur.id];~i;i=edge[i].next)
        if(dis[edge[i].to]>dis[cur.id]+edge[i].w)//遍历连接该点的下一个点，做松弛操作，同时push入
        {
            dis[edge[i].to]=dis[cur.id]+edge[i].w;
            nex.dis=dis[cur.id]+edge[i].w;
            nex.id=edge[i].to;
            q.push(nex);
        }
    }//O(mlogm)复杂度
}
void addedge(int u,int v,ll w)
{
    edge[++tot].w=w;
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot;
}
int main()
{
    scanf("%d%d%d",&n,&m,&s);
    for(int i=0;i<=n;i++)
    head[i]=-1;
    for(int i=1;i<=m;i++)
    {
        ll u,v,w;
        scanf("%lld %lld %lld",&u,&v,&w);
        addedge(u,v,w);
    }
    dij();
    for(int i=1;i<=n;i++)
    printf("%lld ",dis[i]);
    system("pause");
}

  1. Floyd

适用范围：可以解决负权问题，同时记录了多源到多源的最短路径，适合多对多，时间复杂度较高。

采用dp的朴素思想，以dp[k][i][j]表示有i到j经过前k个点的最短距离，根据状态转移方程

dp[k][i][j]=min{dp[k-1][i][k]+dp[k-1][k][j],dp[k-1][i][j]}(经过第k个点和不经过第k个点)的二维优化得来。故k的顺序不能调换，不然不遵循dp的最优子结构。

#include<bits/stdc++.h>//floyd例题（洛谷--邮递员送信）
#define maxn 10000
#define INF 0x3f3f3f3f
#define ll long long
using namespace std;
ll n,m,ans=0;
ll dis[maxn][maxn];
int main()
{
    scanf("%lld%lld",&n,&m);
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
    dis[i][j]=INF;
    for(int i=1;i<=m;i++)
    {
        ll u,v,w;
        scanf("%lld%lld%lld",&u,&v,&w);
        dis[u][v]=min(dis[u][v],w);//用普通邻接矩阵存边时要考虑两点间多边的存在情况，链式前向星和邻接表不需要考虑
    }
    for(int i=1;i<=n;i++)
    dis[i][i]=0;
//-----------------------------------------------核心代码
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                dis[i][j]=min(dis[i][k]+dis[k][j],dis[i][j]);
//---------------------------------------------------------
    for(int i=1;i<=n;i++)
    ans+=dis[1][i]+dis[i][1];
    printf("%lld",ans);
    system("pause");//floyd算法,操作简便快捷
}

  1. Bellman-ford

适用范围：能够进行负权图的最短路求解，并对负环图存在性做出判断；一源对多源，或建反图实现多源到一源

算法思路：

对每条边进行最多n-1次松弛操作，时间复杂度O(n^2)

#include<bits/stdc++.h>//bellman-ford（洛谷--邮递员送信）
#define ll long long
#define maxn 10000
#define INF 0x3f3f3f3f
using namespace std;
ll n,m,u[maxn],v[maxn],w[maxn],dis[maxn],ans=0;
int main()
{
    scanf("%lld%lld",&n,&m);
    for(int i=1;i<=m;i++)
    scanf("%lld%lld%lld",&u[i],&v[i],&w[i]);
    memset(dis,127,sizeof(dis));
    dis[1]=0;//勿忘初始化
    for(int k=1;k<=n-1;k++)
    for(int i=1;i<=m;i++)
    dis[v[i]]=min(dis[v[i]],dis[u[i]]+w[i]);
    for(int i=1;i<=n;i++)
    ans+=dis[i];

    memset(dis,127,sizeof(dis));
    dis[1]=0;
    for(int k=1;k<=n-1;k++)
    for(int i=1;i<=m;i++)
    dis[u[i]]=min(dis[u[i]],dis[v[i]]+w[i]);
    for(int i=1;i<=n;i++)
    ans+=dis[i];
    printf("%lld",ans);
    system("pause");
}

  • bellman判断负环存在性

思路：bellman可以判断图上所有的负环存在性，但是针对从某一源点出发可以到达的负环，则可以设置vis以及或运算传递可到达的信息，如以下代码。

#include<bits/stdc++.h>
#define maxn 100000
#define INF 0x3f3f3f3f
#define ll long long
using namespace std;
int T,n,m;
int u[maxn],v[maxn],w[maxn],tot=0,dis[maxn];
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        int vis[maxn]={0};
        tot=0;
        scanf("%d%d",&n,&m);
        for(int i=1;i<=m;i++)
        {
            int s,t,l;
            scanf("%d%d%d",&s,&t,&l);
            if(l>=0)
            {
                u[++tot]=s;
                v[tot]=t;
                w[tot]=l;
                u[++tot]=t;
                v[tot]=s;
                w[tot]=l;
            }
            else
            {
                u[++tot]=s;
                v[tot]=t;
                w[tot]=l;
            }
        }
        int flag=0;
        memset(dis,127,sizeof(dis));
        dis[1]=0;
        vis[1]=1;
        for(int k=1;k<=n-1;k++)
        for(int i=1;i<=tot;i++)
        if(dis[v[i]]>dis[u[i]]+w[i])
        {
            vis[v[i]]|=vis[u[i]];
            dis[v[i]]=dis[u[i]]+w[i];
        }
        for(int i=1;i<=tot;i++)
        if(dis[v[i]]>dis[u[i]]+w[i]&&vis[v[i]])
        flag=1;
        if(flag)
        puts("YES");
        else
        puts("NO");
    }
    system("pause");
}

  1. SPFA

适用范围：bell-man在时间上的优化，引入了队列加快了速度，但同时最坏情况时间复杂度仍与bellman相同，可能会被卡时间。

优化思路：

只有连接到某个点的边参与松弛后，该点才能参与后续的松弛操作，比如可能连接着终点或缩短了起点到其他点的距离，因此每个能够被松弛的点都能入列，否则不能。同时使用vis数组记录哪些点已经入列，后续如果又松弛操作导致入列，那么已经入列的点可以不再入列，一同由已入列的点进行后续的更新。

#include<bits/stdc++.h>
#include<queue>
#define ll long long
#define maxn 10000
#define INF 0x3f3f3f3f
using namespace std;
int n,m;
ll ans=0;
struct Edge{
    int to;
    int next;
    ll w;
}edge1[maxn],edge2[maxn];
int head1[maxn],head2[maxn],dis[maxn],vis[maxn]={0};
int tot1=0,tot2=0;
void addedge(int u,int v,ll w)
{
    edge1[++tot1].to=v;
    edge1[tot1].w=w;
    edge1[tot1].next=head1[u];
    head1[u]=tot1;

    edge2[++tot2].to=u;
    edge2[tot2].w=w;
    edge2[tot2].next=head2[v];
    head2[v]=tot2;
}
void spfa(void)
{
    queue<int>q;
    int s;
    q.push(1);
    vis[1]=1;
    dis[1]=0;
    while(!q.empty())
    {
        s=q.front();
        q.pop();
        vis[s]=0;//代表该点已经出队列
        for(int i=head1[s];~i;i=edge1[i].next)
        if(dis[edge1[i].to]>dis[s]+edge1[i].w)
        {
            dis[edge1[i].to]=dis[s]+edge1[i].w;
            if(!vis[edge1[i].to]) vis[edge1[i].to]=1,q.push(edge1[i].to);
            //vis数组是为了提高效率设计的
            //如果想要更新的元素已经在队列中，只需要把dis对应的距离更新了就可以了，
            //等到队列中已有的该点开始更新，到时候更新就可以一起更新
            //同时只有能做松弛操作的边指向的终点才有可能进行后续的松弛操作，否则不入队
        }
    }
}
void spfa1(void)
{
    queue<int>q;
    int s;
    q.push(1);
    vis[1]=1;
    dis[1]=0;
    while(!q.empty())
    {
        s=q.front();
        q.pop();
        vis[s]=0;
        for(int i=head2[s];~i;i=edge2[i].next)
        if(dis[edge2[i].to]>dis[s]+edge2[i].w)
        {
            dis[edge2[i].to]=dis[s]+edge2[i].w;
            if(!vis[edge2[i].to]) vis[edge2[i].to]=1,q.push(edge2[i].to);
        }
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=0;i<=n;i++)
    head1[i]=head2[i]=-1;
    for(int i=1;i<=m;i++)
    {
        int u,v;
        ll w;
        scanf("%d%d%lld",&u,&v,&w);
        addedge(u,v,w);
    }
    memset(vis,0,sizeof(vis));
    memset(dis,127,sizeof(dis));
    spfa();
    for(int i=1;i<=n;i++)
    ans+=dis[i];
    memset(vis,0,sizeof(vis));
    memset(dis,127,sizeof(dis));
    spfa1();
    for(int i=1;i<=n;i++)
    ans+=dis[i];
    printf("%lld",ans);
    system("pause");
}

lawhelo
关注
专栏目录
蚁群算法求解最短路，详细，可用于路径规划
02-20
在最短路问题中，目标是找到在给定网络中两个节点之间的最短路径。这种问题广泛存在于物流、交通、网络设计等领域。蚁群算法通过迭代过程，每只“虚拟蚂蚁”在图上随机行走，并根据信息素浓度和距离因子选择下一步的...
算法:最短路算法
长舒的博客
03-16 689
计算最短路的三大算法 常见计算最短路的题型模板:输入n代表结点数，输入m代表边数，接下来m行，每行三个数，分别输入n1,n2,k代表结点n1到结点n2的单向路径长度为k Floyd算法模板 基于动态规划思想，核心在于，为了计算两个结点i,j之间的最短路，需要引入中转结点k进行进一步比较，来对领接矩阵进行进一步更新,状态转移方程为map[i][j]=min(map[i][k]+map[k][j...
c语言短路算法
HUANGRUI的博客
11-16 5370
总的规则 ①当 && 碰到值为0时发生短路 ②当 || 碰到值为1时发生短路 口说无凭，举例为证！ 例1. 若 int a=6,b=4,c=2;表达式!(a-b)+c-1&&b+c/2 的值是 分析：①本题先计算 !(a-b),（a-b为非0的数，故为1，则!(a-b) 为0 ②再计算!(a-b)+c-1,显然为0+2-1=1，不为0。&&碰到的不是为0的数， 故后面不短路，继续计算b+c/2，也不为0。即&&两边都为1，整体为1。 不短路是这
浅谈五种最短路算法（c++）
最新发布
2301_79587247的博客
03-17 1140
最短路问题，说人话就是给定一个图，求两个点之间所有走法中，边权和最短的路的值。总的来说，最短路算法分为5个不同的种类。 floyd 概述 floyed算法是多元最短路的算法（说人话：随便两个点我都能求），主要思想就是只要算的多就一定能做出来。 思路 每次找到一个点k,在遍历所有点，找到一对i，j，d[i][j]=min(d[i][j],d[i][k]+d[k][j]); 例题 题目描述 样例输入 时间复杂度分析 由循环易知，时间复杂度是O(n^3)。（200以上的数据就不要用了）
最短路算法比较
simao
07-27 166
——图片来自《啊哈！算法》 n是顶点数,m是边数 floyd:O(n^3) 朴素dijkstra:O(n^2+m) dijkstra最小堆优化：O((m+n)logn) spfa:O(km)->O(nm) 理论上k<=2; 稠密图中适合使用朴素dijkstra 而稀疏图中采用最小堆dijkstra或者spfa，spfa在正权图中尽量不要使用，会被卡数据。。。但是有负权边的话使用s...
两种最短路算法总结
不知所云的博客
03-16 387
最短路算法 这里只总结两种最短路算法，第一是：Dijkstra，第二是：SPFA； 这两种算法都用了队列优化，Dijkstra是优先队列，SPFA是普通队列； Dijkstra 先介绍第一种，也是用的最多的一种最短路算法：Dijkstra； 这种算法的思想就是先根据给定的起点 s ，找到这个点 s 所能连的点，更新一下所能连到的点的路径，然后放入优先队列里面；优先队列维护两个东西，一个是起点 s...
算法合集之《最短路算法及其应用》
02-26
最短路算法是图论中的一个核心问题，广泛应用于计算机科学、运筹学、网络优化等领域。本资源《最短路算法及其应用》主要探讨了如何寻找网络中两点间最短路径的方法，以及这些方法在实际问题中的应用，如交通路线规划...
动态最短路_动态最短路算法程序_
10-03
动态最短路算法是图论中的一个重要概念，用于在带权重的有向或无向图中寻找从一个起点到其他所有节点的最短路径。在实际应用中，它广泛应用于网络设计、物流优化、交通路线规划等领域。在这个场景中，我们讨论的是...
【老生谈算法】floyd最短路算法Dijkstra最短路算法Matlab程序.doc
07-02
【老生谈算法】floyd最短路算法Dijkstra最短路算法Matlab程序.doc
代码 基于最短路dijkstra算法离散优化问题代码
06-04
代码 基于最短路dijkstra算法离散优化问题代码代码 基于最短路dijkstra算法离散优化问题代码代码 基于最短路dijkstra算法离散优化问题代码代码 基于最短路dijkstra算法离散优化问题代码代码 基于最短路dijkstra算法...
程序中的短路算法现象
qq_48374573的博客
05-24 1177
程序中的短路算法现象一、逻辑与(&&)中的短路。二、逻辑或(||)中的短路。总结 一、逻辑与(&&)中的短路。   逻辑与的运算符为&&, 其运算规则为，对于expr1 && expr2,只有当expr1和expr2同时为真(1)时，结果才为真(1);   可以得到，如果expr1为假，那么无论expr2值是什么，结果都是假。   这种情况下，expr2的值就不重要了，于是当expr1为0（假）时，后续的expr2不会加入计算，而是被忽略，这就
C语言之短路
df2714358228的博客
12-05 478
短路就是当你左边运算完以后发现这个式子在后面的逻辑运算中不需要再往下算已经知道结果了（后面的运算变得没有意义）。此时算到3>4就短路了，因为逻辑运算符是&&（两边有一个为假就是假）所以右边的5<6都不判断。首先我们需要知道，运算是从左到右开始的，（有括号先算括号）如果逻辑运算符两边有表达式并且短路的话，叫短路求值。此时发生短路求值，a为1。
最短路算法总结（超详细~）
热门推荐
wmy0217_的博客
04-11 3万+
文章目录最短路算法框架朴素Dijkstra算法堆优化版Dijkstra算法 最短路算法框架 最短路有五种算法，分别适用不同的情况。 单源最短路： 求一个点到其他点的最短路 多源最短路： 求任意两个点的最短路 稠密图用邻接矩阵存，稀疏图用邻接表存储。 稠密图： m 和 n2 一个级别 稀疏图： m 和 n 一个级别 朴素Dijkstra算法 Dijkstra算法是通过 n 次循环来确定 n 个点...
最短路算法详解
qq_59539549的博客
06-25 2704
图的最短路算法
图论 ——五种最短路算法
qq_46056407的博客
03-29 9757
文章目录 前言 一、最短路是什么？ 二、朴素Dijkstra算法 三、堆优化版Dijkstra算法 四、Bellman-Ford算法 五、Spfa算法 六、Floyd算法 总结 前言 本篇文章讲的是图论里的最短路问题，如果你还没有图论的基础知识，可以看看我之前的文章： DFS（深度优先算法）BFS(广度优先算法）邻接表和邻接矩阵、树的遍历 （DFS和BFS） 这些都是关于图论的基本知识。 一、最短路是什么？ 最短路径： 从某个点A（位置）到另一个点B(位置)的最..
最短路问题的几种算法
三日小先森的博客
08-15 1468
一、单源最短路 （1）Dijkstra算法（时间复杂度为o（n^2）） 双重循环 #include&lt;cstdio&gt; #include&lt;queue&gt; #include&lt;cstring&gt; using namespace std;//DJK求最短路径，o(n^2)//不常用 //单源最短路（下面可以求出st到每个点的最...
基本最短路算法的分析和比较
myzts的专栏
05-07 1191
1.Floyd-Warshall(求连通图任意两点最短路径) 核心代码: for (int k=1; k<=n; k++) { for (int i=1; i<=n; i++) { for (int j=1; j<=n; j++) { if (dis[i][j]>dis[i][k]+dis[k][j]) {
最短路的四种算法总结
zezzezzez的博客
04-19 1万+
标题 ##最短路的四种算法1、floyd 核心代码只有五行 for(int k=1; k<=n; k++) for(int i=1; i<=n; i++) for(int j=1; j<=n; j++) { if(map1[i][j]>map1[i][k]+map1[k][j])
最短路算法详解与应用
"最短路算法的PPT讲义，主要涵盖了如何详细描述和总结最短路算法。" 最短路算法是图论中的一个重要概念，用于寻找图中两个节点之间的最短路径。常见的最短路算法有Dijkstra算法、Floyd-Warshall算法和Bellman-Ford...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值