[SinGuLaRiTy-1001] Calculation Of The Shortest Path 最短路算法集锦

最新推荐文章于 2023-10-05 00:30:00 发布
原创 最新推荐文章于 2023-10-05 00:30:00 发布 · 466 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#SinGuLaRiTy #算法 #path

本文详细介绍了四种经典的最短路径算法：Dijkstra算法、SPFA算法、Floyd算法及Bellman-Ford算法，并提供了每种算法的具体实现代码，帮助读者深入理解算法原理及其应用场景。

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

 By Wen Jian
A Calculation Of The Shortest Path Codes Library.

Sources from CQBZ Judge & CODE[VS] [ Codevs Website][ CQBZ Judge]
最短路算法代码库。

Includes Dijkstra , SPAF , Floyd , BellmanFord.
包含 Dijkstra , SPAF , Floyd , BellmanFord 。

[ Dijkstra ]

Subject: First line: two numbers that describe the number of points and edges; Then the following lines of data describe the start , end , value of every edge; Last line: two numbers : Start , End;

Original Subject: [CQBZOJ 1172]

题目描述

有向图的单源点最短路问题（Dijkstra算法）

输入

第1行：2个空格分开的整数n(2<=n<=500)和m(10<=m<=20000)，分别表示图的顶点数和边数。

第2..m+1行：每行3个空格分开的整数i，j， w。i表示一条边的起点，j表示终点， w表示权值。

第m＋2行：2个整数s，t(1<=s，t<=n),表示指定的顶点。

输出

第1行：最小距离

第2行：最短路径（从起点到终点的序列，用1个空格分开）

样例输入

5 7
1 2 10
1 4 30
1 5 100
2 3 50
3 5 10
4 3 20
4 5 60
1 5

样例输出

60
1 4 3 5 

#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<cmath>
using namespace std;
int n,m;
int G[501][501],dis[501],L[501];
bool used[501];
void Dijkstra(int s)
{
    for(int i=1;i<=n;i++)
    {
        used[s]=1;
        for(int j=1;j<=n;j++)
        {
            if(G[s][j]==0||s==j)
                continue;
            if(dis[j]>dis[s]+G[s][j])
                dis[j]=dis[s]+G[s][j],L[j]=s;
        }
        int themin=0x3f3f3f3f;
        for(int i=1;i<=n;i++)                
            if(used[i]==0&&dis[i]<themin)
                s=i,themin=dis[i];
    }
}
int main()
{
    int a,b,c,S,E,cnt=1;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&a,&b,&c);
        G[a][b]=c;
    }
    scanf("%d%d",&S,&E);
    int e=E;
    dis[S]=0;
    for(int i=1;i<=n;i++)
        if(i!=S) dis[i]=0x3f3f3f3f;  
              
    Dijkstra(S);
      
    printf("%d\n",dis[E]);
    while(L[E]!=0)
    {
        dis[cnt++]=L[E];
        E=L[E];
    }
    for(int i=cnt-1;i>=1;i--)
        printf("%d ",dis[i]);
    printf("%d",e);
    return 0;
}

[ SPAF ]

Subject: First line: two numbers that describe the number of points and edges; Then the following lines of data describe the start , end , value of every edge. Output the shortest path between point[1] and point[n].

Original Subject: [CQBZOJ 1178]

题目描述

有向图的单源点最短路径问题。源点编号为1，终点编号为n。

输入

第1行：2个空格分开的整数n(2<=n<=5000)和m(10<=m<=500000)，分别表示图的顶点数和边数。

第2..m+1行：每行3个空格分开的整数i，j， w。i表示一条边的起点，j表示终点， w表示权值。

输出

第1行：1个整数，表示最小距离

样例输入

样例1:
4 7
1 2 68
1 3 19
1 4 66
2 3 23
3 4 65
3 2 57
4 1 68

样例2:
3 3
1 2 -7
2 3 4
3 1 2

样例输出

样例1:
66
样例2:
No Solution 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
struct node{
    int v,w,next;
}edge[500050];
int cnt,head[5050],n,m,dis[5050],tot[5050];
bool inq[5050];
void addedge(int u,int v,int w)
{
    edge[cnt].v=v;
    edge[cnt].w=w;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}
bool SPFA()
{
    memset(dis,0x3f,sizeof dis);
    dis[1]=0;
    inq[1]=1;
    deque<int>q;
    q.push_front(1);
    while(!q.empty())
    {
        int u=q.front();
        q.pop_front();
        inq[u]=0;
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].v,w=edge[i].w;
            if(dis[v]>dis[u]+w)
            {
                dis[v]=dis[u]+w;
                if(!inq[v])
                {
                    if(dis[v]<dis[u])q.push_front(v);
                    else q.push_back(v);
                    inq[v]=1;
                    if(++tot[v]>n)return 0;
                }
            }
        }
    }
    return 1;
}
int main()
{
    int u,v,w;
    scanf("%d%d",&n,&m);
    memset(head,-1,sizeof head);
    for(int i=1;i<=m;++i)
    {
        scanf("%d%d%d",&u,&v,&w);
        addedge(u,v,w);
    }
    SPFA()?printf("%d\n",dis[n]):
    puts("No Solution");
}

[Floyd]

Subject:(None)

Original Subject:(None) 

#include <stdio.h>  
#include <string.h>  
#define maxn 100  
#define INF -1  
int map[maxn][maxn];  
int n, m, path[maxn][maxn];  
  
void Floyd(int n)  
{  
    int i, j, k;  
    for(k = 0; k < n; ++k)  
        for(i = 0; i < n; ++i)  
            for(j = 0; j < n; ++j)  
                if(map[i][k] != INF && map[k][j] != INF && (map[i][k] + map[k][j] < map[i][j] || map[i][j] == INF)){  
                    map[i][j] = map[i][k] + map[k][j];  
                    path[i][j] = k;  
                }             
}  
  
void getPath(int v, int u)  
{  
    int k = path[v][u];  
    if(k == INF){  
        printf("%d===>", v);  
                return;  
    }  
    getPath(v, k);  
    getPath(k, u);  
}  
  
int main()  
{   
    scanf("%d%d", &n, &m);  
    memset(map, INF, sizeof(map));  
    memset(path, INF, sizeof(path));  
    int i, j, a, b, c;  
    for(i = 0; i < n; ++i) map[i][i] = 0;  
    for(i = 0; i < m; ++i){  
        scanf("%d%d%d", &a, &b, &c);  
        map[a][b] = c;  
    }  
    Floyd(n);  
    for(i = 0; i < n; ++i)  
        for(j = 0; j < n; ++j)  
            if(map[i][j] != INF){  
                printf("%d->%d:%d\n the path is:", i, j, map[i][j]);  
                getPath(i, j);  
                printf("%d\n", j);  
            }  
    return 0;  
}

[BellmanFord]

Subject: First line: two numbers that describe the number of points and edges; Then the following lines of data describe the start , end , value of every edge; Last line: two numbers : Start , End;

Original Subject: [CQBZOJ 2890]

题目描述

有向图负权的单源点最短路问题（BellmanFord 算法）

输入

第1行：2个空格分开的整数n(2<=n<=500)和m(10<=m<=20000)，分别表示图的顶点数和边数。

第2..m+1行：每行3个空格分开的整数i，j， w。i表示一条边的起点，j表示终点， w表示权值。

第m＋2行：2个整数s，t(1<=s，t<=n),表示指定的顶点。

输出

第1行：最小距离

第2行：最短路径（从起点到终点的序列，用1个空格分开）

如果出现负权回路,输出:No Solution

样例输入

样例1:
6 7
1 2 2
1 3 -1
2 4 -3
3 4 3
3 6 7
4 6 -2
3 5 6
1 6

样例2:
3 3
1 2 -7
2 3 4
3 1 2
1 3

样例输出

样例1:
-3
1 2 4 6

样例2:
No Solution

提示

如果最短路径有多条,输出路径经过边数较小的解; 如果最短路径边数相同,输出编号较小的序列.



 
#include<cstdio> 
#include<cstring> 
#include<algorithm> 
using namespace std; 
int f[20005][3],dis[505],s[505]; 
void print(int x)
{
    if(s[x]==0) return;
    print(s[x]);
    printf(" %d",x);
}
int main() 
{
    int n,m,i,j,q,z; 
    scanf("%d%d",&n,&m); 
    for(i=1;i<=m;i++)
        scanf("%d%d%d",&f[i][0],&f[i][1],&f[i][2]); 
    scanf("%d%d",&q,&z);
    memset(dis,1,sizeof(dis)); 
    dis[q]=0;
    for(i=1;i<=n;i++){
        for(j=1;j<=m;j++){
            if(dis[f[j][0]]+f[j][2]<dis[f[j][1]]&&i<n){
                dis[f[j][1]]=dis[f[j][0]]+f[j][2];
                s[f[j][1]]=f[j][0];
            }
            if(i==n&&dis[f[j][0]]+f[j][2]<dis[f[j][1]]){
                printf("No Solution");
                return 0;
            }
        }
    }
    printf("%d\n",dis[z]); 
    printf("%d",q); 
    print(z);
}

Coding by SinGuLaRiTy

Time : 2017-02-03



singularity 和 singularity-ce 版本之间的区别
qq_40256654的博客
08-01 316
和都提供了强大的容器解决方案，但它们的开发背景、维护模式和目标用户群有所不同。选择哪一个版本取决于您的具体需求和对支持的期望。如果您需要企业级支持和服务，可能会选择 Singularity；如果您倾向于开源社区驱动的开发模式和参与，Singularity-CE 是一个很好的选择。
singularity-ce-4.1.0 + go 完整安装步骤，及报错解决
最新发布
qq_40256654的博客
02-20 981
singularity-ce-4.1.0 + go 完整安装步骤，及报错解决
26991: 带负权的单源最短路
jing1223639316的博客
07-10 1163
题目描述  输入一个有向网络图，边的权值可正可负，求顶点到其他各点的最短路。输入 第一行输入n，表示n个结点（默认顶点为0号） 接下来输入n*n矩阵。表示各边的权值。输出 输出一行，如果有负权回路输出“not possible”，否则输出顶点0到其他点的最短路，输出答案之间仅有一个空格，结尾没有空格。样例输入4 0 0 -3 0 2 0 0 0 0 -1 0 -4 0 0 0 0样
带负权的最短路
qq_62389037的博客
03-06 318
1.Bellman-Ford O(nm) #include <bits/stdc++.h> using namespace std; const int N = 510, M = 10010; int n, m, k; int dist[N], temp[N]; struct { int a, b, w; } g[M]; void f() { memset(dist, 0x3f, sizeof dist); dist[1] = 0; for (int i
带负权的单源最短路（Bellman-Ford&&SPFA）
serendipity的博客
09-01 908
带负权的单源最短路（Bellman-Ford&&SPFA） 这次终于遇到带负权的单源最短路了，以前遇到的都是权值为正的情况，直接跑个Dijkstra算法即可 这次也终于能好好学学Bellman-Ford算法和SPFA算法了（Bellman-Ford算法的优化（用队列）） 下面的博客，感觉很好，代码简单，而且用结构体和vector都有模板 https://blog.youkuaiyun.com/...
SPFA 求带负权的单源最短路
weixin_34259159的博客
05-03 201
int spfa_bfs(int s) { ///s表示起点。 queue &lt;int&gt; q; memset(d,0x3f,sizeof(d)); ///d数组中存下的就是最短路径（存在的话） d[s] = 0; memset(c,0,sizeof(c));///c数组表示的是某一个节点的入队次数 memset(vis,0,size...
bellman_ford算法_有负权边的单源最短路问题
一只懒猫的博客
08-10 474
当图中存在负权边时，dijkstra算法就不再适用，这是需要用到bellman_ford算法。算法思想是从每次连接所有的边，但是只更新到前一个结点的距离。如果不存在负权环，则在循环n次（结点数量）后一定可以得到答案。 伪码描述： for i in n: for j in m: dis[边尾] = min(dis[边尾],back[边头]+边权) 题目： 代码： #include<iostream> #include<cstring> using namespace std
singularity-cri:Kubernetes 容器运行时接口的 Singularity 实现
05-31
Singularity-cri 和 wlm-operator 项目由 Sylabs 创建，用于探索 Kubernetes 和 HPC 世界之间的交互。 2020 年，我们没有将我们的精力分散在大量项目上，而是专注于 Singularity 本身和我们的支持服务。 我们还期待...
singularity-rstudio:单一容器中的RStudio服务器
05-22
singularity pull --name singularity-rstudio.simg shub://nickjer/singularity-rstudio 跑步 RStudio服务器 使用默认的运行命令启动rserver命令： singularity run singularity-rstudio.simg 或作为显式应用程序...
Singularity-avoidingswing-up control for underactuated three-link gymnast robot using virtualcoupling between control torques
02-10
标题中提到的“Singularity-avoiding swing-up control for underactuated three-link gymnast robot using virtual coupling between control torques”涉及的关键技术点主要有： 1. 机器人技术：这里特指三连杆...
C++算法：存在负权边的单源最短路径的原理和实现
闻缺陷则喜何志丹
10-05 1165
如果有正权环和0权环，则拿掉这个环。如果负权环，则最小距离是无穷小。循环“点数-1”后，再循环一次，如果有点的最短距离变小，则一定有负权环；如果有负权环，则再循环一次，一定有点（任意负权环的负权边的终点）距离变短。假定此点是e，拿掉负权环上所有的边后，源点到e的最短路径为Path。不拿掉负权环，则e的最短路径为:Path+此负权环。循环k次，循环第i次时，m_vDis表示各点最多经过i-1条边的最短距离；vDis表示各点最多经过i条边的最短距离。但floyd无法处理负权环，最短距离是无穷小。
存在负权边的单源汇最短路（Ballman-Ford、SPFA）
Jefferson__的博客
08-31 1904
（一）Ballman-Ford Bellman-Ford算法是求负权图的单源最短路径的一种算法，效率较低，代码难度小。其原理为连续进行松弛，在每次松弛时吧每条边都更新一下，若在n-1次松弛后还能更新，则说明图中有负环，因此无法得出结果，否则就完成。 优点：可以计算有边数限制的最短路问题；但是处理负权图时往往使用SPFA。 具体步骤：for(int i = 0; i < n; i ++ ) for(所有边 a, b, w) <-松弛操作 dist[b] = min(dist[b
带有负权边的单源最短路 bellman_ford算法
FLYxcym的博客
07-10 528
对于带有负权边的单源最短路问题，dijkstra因为其仅能更新一次的特性而无法使用，因此就需要使用到bellman_ford算法,bellman_ford算法。尤其是带有边数限制的单源最短路，更应该使用bellmam_ford 算法，我们用结构体等方式存储每条边，循环k次,k为至多用到的边数，每一次对两点间进行松弛操作。简而言之，求至多k条边的最短路问题，只需要对图进行k次松弛操作即可。这里为了避免更新是造成串联，即用此次松弛的点去更新更多的点，用backup数组对dist进行备份。
存在负权边的单源最短路问题—Bellman-Ford算法及其优化SPFA算法
LFT24的博客
05-05 3779
1、Bellman-Ford算法是用来处理图中存在负权边的最短路情况，当图中有负权边时，Dijkstra()就不能用了，计算出的最短路会有问题。这里要注意若图中存在负权回路，最短路很可能不存在（在负权回路不影响我们想要走过的路径时，不影响结果），Bellman-Ford算法的思路是非常简单的，其应用场景也比较有限。 首先在进行松弛操作的时候，需要注意，要用上一次更新过的距离来更新其他节点，即需要...
带负权边的单源最短路径算法
lwdn旭
04-23 345
const int N=510,M=1e5+10,INF=0x3f3f3f3f; int n,m,k; int dist[N],last[N]; struct Edge{ int a,b,w; }edges[M]; void bellmen_ford(){ memset(dist,0x3f,sizeof dist); dist[1]=0; for(int i=0;i<k;i++){ memcpy(last,dist,sizeof dist);
hdu1317 负权最短路（Floyd+bellman）
Hard。
07-24 1082
首先要读懂题，做这个题时读题看样例琢磨了半天才明白= =； 题目的意思是，一个人从一号房间走到最后一个房间，每个房间有相应的能量值（可正可负），当走到这个房间的时候可以获取这个房间的能量值，如果走到最后一个房间时，人的能量值为正，则“winnable"”，否则的话就"hopeless"，另外，这个人一开始自身有100点能量值，房间可以重复的走，且第一个房间和最后一个房间的能量值为零。 首先输入
POJ3259 回到过去（带负权的单源最短路径）
Shuyu Fang
12-06 860
有N个农场，它们之间有M条普通的双向路径，同时有W条单向“虫洞”，通过普通路径需要花费时间，但通过虫洞却可以回到过去。问能否从任意一个点出发，通过某些普通路径或者“虫洞”再回到起始位置，使到达的时间早于出发的时间。 这是带负权的单源最短路径的入门题，按题目给定的边建好图，从任意一点起点开始，使用Bellman-Ford算法运行一遍，判断有没有回路就可以了。 #include #include
带负权图的单源最短路径算法：Bellman-Ford算法
weixin_30451709的博客
05-31 429
算法简介 前面介绍过图的单源最短路径算法Dijkstra算法，然而Dijkstra算法无法判断含负权边的图的最短路。如果遇到负权，在没有负权回路存在时（负权回路的含义是，回路的权值和为负。）即便有负权的边，也可以采用Bellman-Ford算法正确求出最短路径。 Bellman-Ford算法能在更普遍的情况下（存在负权边）解决单源点最短路径问题。对于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值