各版本最短路算法简单温习

温习Algs4 (六):有向带权图,最短路径 有向带权图, 最短路径有向带权图WeightedDirectedEdge.javaEdgeWeightedDigraph.java最短路径SP.javaDijstra算法Dijstra.javaBellman-Ford最短路径算法BellmanFord.java算法比较 有向带权图 有向带权图的API和有向图的几乎一样, 不再赘述 WeightedDirectedEdge.java /******... 阅读详情
http://acm.hdu.edu.cn/showproblem.php?pid=1874

Floyd:
//#pragma comment(linker, "/STACK:61400000,61400000")
#include <set>
#include <map>
#include <list>
#include <stack>
#include <queue>
#include <cmath>
#include <cstdio>
#include <vector>
#include <string>
#include <iomanip>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;

#define pi 3.1415926535897932385
#define LL64 __int64
#define LL long long
#define oo 2147483647
#define N 100000100
#define M 210
#define INF 1e9

int tu[M][M];

int main()
{
    int n, m;
    
    //freopen("data.in", "r", stdin);
    //freopen("data.out", "w", stdout);
    //int _case = 1;
    //scanf("%d", &t);
    //while (t--)
    //for (int _case = 1; _case <= t; _case++)
    while (~scanf("%d%d", &n, &m))
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (i == j) tu[i][j] = 0;
                else tu[i][j] = N;
            }
        }
        for (int i = 0; i < m; i++)
        {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            if (tu[a][b] == N) tu[a][b] = tu[b][a] = c;
            else tu[a][b] = tu[b][a] = min(tu[a][b], c);
        }
        int s, t;
        scanf("%d%d", &s, &t);
        for (int k = 0; k < n; k++)
        {
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    tu[i][j] = min(tu[i][j], tu[i][k] + tu[k][j]);
                }
            }
        }
        printf("%d\n", tu[s][t] == N ? -1 : tu[s][t]);
    }
    
    return 0;
}
SPFA:
//#pragma comment(linker, "/STACK:61400000,61400000")
#include <set>
#include <map>
#include <list>
#include <stack>
#include <queue>
#include <cmath>
#include <cstdio>
#include <vector>
#include <string>
#include <iomanip>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;

#define pi 3.1415926535897932385
#define LL64 __int64
#define LL long long
#define oo 2147483647
#define N 100000100
#define M 210
#define INF 1e9

int tu[M][M];
int dis[M];
queue<int> q;

int main()
{
    int n, m;
    
    //freopen("data.in", "r", stdin);
    //freopen("data.out", "w", stdout);
    //int _case = 1;
    //scanf("%d", &t);
    //while (t--)
    //for (int _case = 1; _case <= t; _case++)
    while (~scanf("%d%d", &n, &m))
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                tu[i][j] = N;
            }
        }
        for (int i = 0; i < m; i++)
        {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            if (tu[a][b] == N) tu[a][b] = tu[b][a] = c;
            else tu[a][b] = tu[b][a] = min(tu[a][b], c);
        }
        int s, t;
        scanf("%d%d", &s, &t);
        for (int i = 0; i < n; i++)
        {
            if (i == s) dis[i] = 0;
            else dis[i] = N;
        }
        while (!q.empty())
        {
            q.pop();
        }
        q.push(s);
        while (!q.empty())
        {
            int so = q.front();
            q.pop();
            for (int i = 0; i < n; i++)
            {
                if (i == so) continue;
                if (dis[i] > dis[so] + tu[so][i])
                {
                    dis[i] = dis[so] + tu[so][i];
                    q.push(i);
                }
            }
        }
        printf("%d\n", dis[t] == N ? -1 : dis[t]);
    }
    
    return 0;
}
传统Dijkstra:
//#pragma comment(linker, "/STACK:61400000,61400000")
#include <set>
#include <map>
#include <list>
#include <stack>
#include <queue>
#include <cmath>
#include <cstdio>
#include <vector>
#include <string>
#include <iomanip>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;

#define pi 3.1415926535897932385
#define LL64 __int64
#define LL long long
#define oo 2147483647
#define N 100000100
#define M 210
#define INF 1e9

int tu[M][M];
int dis[M];
bool tp[M];

int main()
{
    int n, m;
    
    //freopen("data.in", "r", stdin);
    //freopen("data.out", "w", stdout);
    //int _case = 1;
    //scanf("%d", &t);
    //while (t--)
    //for (int _case = 1; _case <= t; _case++)
    while (~scanf("%d%d", &n, &m))
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                tu[i][j] = oo;
            }
        }
        for (int i = 0; i < m; i++)
        {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            if (tu[a][b] == oo) tu[a][b] = tu[b][a] = c;
            else tu[a][b] = tu[b][a] = min(tu[a][b], c);
        }
        int s, t;
        scanf("%d%d", &s, &t);
        for (int i = 0; i < n; i++)
        {
            if (i == s) dis[i] = 0;
            else dis[i] = oo;
        }
        memset(tp, 0, sizeof(tp));
        for (int i = 0; i < n; i++)
        {
            int p = -1;
            int d = oo;
            for (int j = 0; j < n; j++)
            {
                if (tp[j] == 0)
                {
                    if (d > dis[j])
                    {
                        d = dis[j];
                        p = j;
                    }
                }
            }
            if (p == -1) break;
            for (int j = 0; j < n; j++)
            {
                if (tu[p][j] != oo)
                {
                    dis[j] = min(dis[j], dis[p] + tu[p][j]);
                }
            }
            tp[p] = 1;
        }
        printf("%d\n", dis[t] == oo ? -1 : dis[t]);
    }
    
    return 0;
}
HeapDijkstra:
//#pragma comment(linker, "/STACK:61400000,61400000")
#include <set>
#include <map>
#include <list>
#include <stack>
#include <queue>
#include <cmath>
#include <cstdio>
#include <vector>
#include <string>
#include <iomanip>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;

#define pi 3.1415926535897932385
#define LL64 __int64
#define LL long long
#define oo 2147483647
#define N 100000100
#define M 210
#define INF 1e9

int tu[M][M];
int dis[M];

struct cmp
{
    bool operator () (int x, int y)
    {
        return dis[x] > dis[y];
    }
};

priority_queue<int, vector<int>, cmp> q;

int main()
{
    int n, m;
    
    //freopen("data.in", "r", stdin);
    //freopen("data.out", "w", stdout);
    //int _case = 1;
    //scanf("%d", &t);
    //while (t--)
    //for (int _case = 1; _case <= t; _case++)
    while (~scanf("%d%d", &n, &m))
    {
        memset(tu, -1, sizeof(tu));
        for (int i = 0; i < m; i++)
        {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            if (tu[a][b] == -1) tu[a][b] = tu[b][a] = c;
            else tu[a][b] = tu[b][a] = min(tu[a][b], c);
        }
        int s, t;
        scanf("%d%d", &s, &t);
        for (int i = 0; i < n; i++)
        {
            if (i == s) dis[i] = 0;
            else dis[i] = oo;
        }
        while (!q.empty())
        {
            q.pop();
        }
        q.push(s);
        while (!q.empty())
        {
            int p = q.top();
            q.pop();
            for (int j = 0; j < n; j++)
            {
                if (tu[p][j] != -1)
                {
                    if (dis[j] > dis[p] + tu[p][j])
                    {
                        dis[j] = dis[p] + tu[p][j];
                        q.push(j);
                    }
                }
            }
        }
        printf("%d\n", dis[t] == oo ? -1 : dis[t]);
    }
    
    return 0;
}
ZYNQ-7035+HMCAD1511高速数据采集系统设计 高速数据采集是电子测量、雷达信号处理与通信基带验证的核心技术基础,其性能瓶颈常集中于采样率、通道同步性与实时处理能力。基于ADC采样原理与SoC异构架构,高带宽、低抖动时钟链路与FPGA+ARM协同处理成为突破关键。ZYNQ-7035凭借275K逻辑单元与千级DSP资源,显著提升LVDS数据流吞吐与片上滤波/触发等实时算法部署能力;HMCAD1511则以1GSPS四通道同步采样和8位分辨率,满足示波器级动态范围需求。该组合广泛应用于嵌入式信号采集平台开发、教学实验系统构建及国产化仪器原型验证。 阅读详情

相关推荐

科研指南:IEEE期刊LaTeX/Word模板下载与使用全解析

本文详细解析了IEEE期刊LaTeX/Word模板的下载与使用技巧,帮助科研人员高效完成论文排版。从官方模板获取入口到LaTeX文档结构配置,再到Word样式管理与常见问题解决方案,全面覆盖投稿准备的关键步骤。特别针对数学公式、参考文献和图片处理等难点提供实用建议,助力学术写作规范化。

weixin_28396629的博客 570

图论:最短路问题 Floyd Dijkstra SPFA算法

昨天的模拟赛中有一道用到最短路算法的题,自己竟然写T了,所以今天来温习一下三个最短路算法,把模板写一写。  首先说明,这三个算法都是无向图有向图皆适用的。 Floyd算法: 三个里面最好写的算法,算法原理是通过枚举中间点k,不断对两点之间的最短路长度进行松弛。d[i][j]表示i到j之间的最短路长度,d[i][j] = min{d[i][k] + d[k][j] | k ∈

Sky 1712

手把手教你解决Keil5安装时xerces-c_3_0.dll缺失和0xc000007b报错(附文件下载与路径设置)

本文详细解析了Keil5安装过程中常见的xerces-c_3_0.dll缺失和0xc000007b报错问题,提供了从文件获取、路径设置到系统配置的完整解决方案。同时,文章还涵盖了STM32开发环境的搭建技巧和最佳实践,帮助开发者快速构建稳定的嵌入式开发环境。

weixin_29164497的博客 616

常见最短路算法模板

所有内容均来自课堂归纳整理的笔记,附带本人踩过的坑与思考,我认为这是最有价值的一点,适合大致了解这些算法但还是有一些似懂非懂的小伙伴

2301_79178851的博客 263

JSON 与 JSON-RPC 的区别

JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,基于文本,采用人类可读的语法来表示结构化数据。它起源于JavaScript,但如今已被几乎所有主流编程语言支持。标准文档:RFC 4627数据类型:支持 String、Number、Boolean、Null、Object、Array 六种基本类型格式示例"name": "张三","age": 30,JSON-RPC(JSON Remote Procedure Call)是一种远程过程调用(RPC)协议。

h a 6 6 6 c k 为 你解决复杂难题! 149

AUTOSAR进阶图解==>AUTOSAR_SWS_COM

AUTOSAR COM模块是AUTOSAR通信堆栈的核心组件,提供信号导向的通信服务。该模块位于通信服务层,连接RTE与PDU Router,主要功能包括信号封装/提取、传输模式管理、信号路由、超时监控和字节序转换等。COM模块架构分为应用层、通信服务层和通信抽象层,包含信号管理、I-PDU处理、传输模式管理等组件。其配置结构包括顶层容器、I-PDU组、I-PDU和信号等多层次配置对象,支持丰富的参数设置。模块采用严格的状态管理机制,包括模块状态和I-PDU组状态转换,确保通信可靠性。

一名留德华的,康德的信徒的,专注于汽车电子领域的博客 1245

温习最短路1

A - 温习最短路1 Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Submit Status Description 某省自从实行了很多年的畅通工程计划后,终于修建了很多路。不过路多了也不好,每次要从一个城镇到另一个城镇时,都有许多种道路方案可以选择,而某些方案

代码君 465

基于机器学习的网络入侵检测系统设计与实现

本文设计并实现了一个基于机器学习的网络入侵检测系统,采用随机森林模型结合KMM算法优化,使用CICIDS2017数据集进行训练。系统包含完整的数据预处理流程、特征工程、模型调优和远程部署方案。实验结果表明,该系统能有效识别多种网络攻击类型,在检测准确率和误报率方面表现优异。研究为网络安全防护提供了新的技术思路和实用工具,具有重要的应用价值。

huanghm88的专栏 319

dijkstra算法及一些最短路的注意事项

学习dijkstra已经一周了,学完之后没有

Pekary 1207

4、风险管理、信息安全与信息管理的核心原则

本文深入探讨了风险管理、信息安全与信息管理的核心原则,涵盖Risk IT框架、ISO 31000标准以及信息安全与信息管理的关键原则。通过案例分析与实际应用挑战的解析,帮助组织更好地应对数字化时代的风险与安全问题,实现可持续发展。

bread的博客 120

bacnet 官方协议栈 bacnet-stack-0.8.2关于router例程BACnet MS/TP BACnet IP调试说明

bacnet 官方协议栈 bacnet-stack-0.8.2关于router例程mstp,bacnet ip调试说明

shufawangzhang的博客 2224

(阶段三 dijkstra算法温习1.1)HDU 2544 最短路(利用dijkstra算法计算两个节点间的最短路径)

/* * HDU_2544_2.CPP * * Created on: 2013年11月10日 * Author: Administrator */ #include #include using namespace std; const int maxn = 110; const int inf = 10000000; int map[maxn][maxn];

黄俊东的专栏 2017

Ultralytics 框架中predict 与 track 的区别

在 Ultralytics 框架中,predict 和 track 是两种不同的推理方法,分别用于目标检测(或分割、姿态估计)和目标跟踪任务。

浩瀚之水的专栏 1127

最短路相关(Dijkstra,Bellman-Ford,Floyd)

最短路相关算法思想,Bellman,Floyd,地杰斯特拉

C_eeking的博客 1149

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

温习 数据结构之求最短路径 Dijstra

#include <stdio.h> #define INFINITY INT_MAX //最大值 #define MAX_VERTEX_NUM 20 //最大顶点个数 #define MAX_NAME 5 //定点字符串的最大长度+1 #define MAX_INFO 20 //相关信息字符串的最大长度+1 #define FALSE 0 #def...

weixin_30820077的博客 126

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

Floyd算法求解最短路径问题(C++实现)(源码见链接))

Floyd算法求解最短路径问题(C++实现)(源码见链接) Floyd(弗洛伊德)算法也可称其为插点算法,是一种基于动态规划思想的最短路径算法。动态规划算法将求解的分体分成若干个阶段,按顺序求解子阶段并且动态规划算法所处理的问题无后效性,即在当前情况下,一个阶段的结果常常影响到下一阶段的决策,但下一阶段的结果不会影响前一状态的决策,因此适用于求解最短路径规划问题。Floyd算法编码较为简单,容易理...

muyutianzhilan的博客 2756

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

最短路

A - 温习最短路1 Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Submit Status Description 某省自从实行了很多年的畅通工程计划后,终于修建了很多路。不过路多了也不好,每次要从一个城镇到另一个城镇时,都有许多种道路方案可以选择,而某些

袁汉春 606

【CJOJ P1365】最短路

http://oj.changjun.com.cn/problem/detail/pid/1365Description给出N个点,M条无向边的简单图,问所有点对之间的最短路。Input第1行两个正整数N,M(N<=100,M<=5000) 下面M行,每行3个正整数x, y, w,为一条连接顶点x与y的边权值为w。(x<=n,y<=n,w<=1000)Output包括N行,每行N个数,第i行第j

小蒟蒻yyb的博客 720

HDU 2680 有点坑的稠密图最短路(dij各版本)

Choose the best route Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 14431    Accepted Submission(s): 4711 Problem Description One

Lawliet 468

数据结构与算法 - Bellman-Ford算法:处理负权边的最短路径问题

本文介绍了Bellman-Ford算法,这是一种用于解决单源最短路径问题的动态规划算法,特别适用于包含负权重边的图。文章首先通过类比说明算法原理,随后回顾了图论基本概念,详细阐述了算法的核心思想——通过V-1次松弛操作逐步逼近最优解。通过具体示例分步演示了算法执行过程,分析了算法复杂度为O(V×E),并提供了Python代码实现。与Dijkstra算法相比,Bellman-Ford虽然效率较低,但能处理负权边情况,是图论中重要的基础算法之一。

千淘万漉虽辛苦,吹尽狂沙始到金 2万+

校园导航系统,生成图,图之间最短路径问题(温习迪杰斯特拉算法,普利姆算法)

关于图,大家都觉特非常头疼,当你仔细看这个算法,细细品味,只觉得它是小菜一碟,希望给你带来帮助 #include "stdio.h" #define  Infinity 1000 #define  MaxVertexNum 7 #define  MAX 20 #include "stdlib.h" #include "string.h" typedef struct arcell//

Zhangaihua 5242

(阶段三 dijkstra算法温习1.5)HDU 2680 Choose the best route(使用dijkstra算法求解多源起点的最短路径问题)

/* * HDU_2066.cpp * * Created on: 2013年11月10日 * Author: Administrator */ #include #include using namespace std; const int maxn = 1100; const int inf = 10000000; int map[maxn][maxn]; in

黄俊东的专栏 1634

[图的最短路径算法]Dijkstra, Bellman-Ford, Floyd-Warshall

随着算法教学进度的推进,虽然关于图论的专题只开了头,讲了$DFS$和$BFS$... 可是,万恶的计算机网络作业居然都是这样的题目,此处省略脏话1000+字,本真离散数学曾经学过的良心,默默温习一下~但是,与此同时也算是对算法的一点点预习吧~~~(你心态真好!!喂,刚刚搞完JAVA的大作业,然后就得知马上要交网络的作业啊喂!!! 正题开始 一. Dijkstra算法 中文维基百科...

asqxbps6254的博客 253
上一篇: STL 中优先队列的使用方法(priority_queue)
下一篇: 二分法、线段树
ColorWaterer
博客等级 码龄12年 16粉丝 128原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值