最短路板子及其应用

已于 2024-06-01 18:41:10 修改
阅读量386 收藏 4
点赞数 5
文章标签： 算法 数据结构
于 2024-06-01 18:39:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Doctor_Anonymous/article/details/139377869
版权

最短路板子及其应用

1. 经典最短路算法分析

image-20240601180958679

2. 朴素dijkstra算法板子：
  1. 首先迭代n次，每次迭代更新一个点到起点的距离。即dist[]。
  2. 找到一个不在集合中的点且这个点到起点的距离最小。
  3. 将这个点加入集合当中。
  4. 用这个点更新其他点到起点的距离。
849. Dijkstra求最短路 I - AcWing题库
#include <bits/stdc++.h>
using namespace std;
const int N = 510;

int g[N][N];
int n, m;
bool st[N];
int dist[N];

int dijkstra(){
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	for(int i = 0; i < n; i++){
		int t = -1;
		for(int j = 1; j <= n; j++){
			if(!st[j] && (t == - 1 || dist[t] > dist[j])){
				t = j;
			}
		}
		st[t] = true;
		for(int i = 1; i <= n; i++){
			dist[i] = min(dist[i], dist[t] + g[t][i]);
		}
	}
	if(dist[n] == 0x3f3f3f3f) return -1;
	return dist[n];
}

int main()
{
	ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
	cin >> n >> m;
	memset(g, 0x3f, sizeof g);
	for(int i = 0; i < m; i++){
		int a, b, c;
		cin >> a >> b >> c;
		g[a][b] = min(g[a][b], c);
	}	
	int t = dijkstra();
	cout << t << endl;
	return 0;
}
3. 堆优化版dijkstra算法板子：

​ 我们注意到，每次找到不在集合中的点的时间复杂度最高。故我们采用小根堆，其可以有效解决这个问题。

850. Dijkstra求最短路 II - AcWing题库
#include <bits/stdc++.h>
using namespace std;

int n, m;
const int N = 150010;
int e[2 * N], ne[2 * N], idx = 0, h[N], w[2 * N];
bool st[N];
int dist[N];

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

priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> heap;
int dijkstra(){
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    heap.push({0, 1});
    while(heap.size()){
        auto temp = heap.top();
        int dis = temp.first, ver = temp.second;
        heap.pop();
        if(st[ver]) continue;
        st[ver] = true;
        for(int i = h[ver]; i != -1; i = ne[i]){
            int j = e[i];
            if(dist[j] > dist[ver] + w[i]){
                dist[j] = dist[ver] + w[i];
                heap.push({dist[j], j});
            }
        }
    }
    if(dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

int main()
{
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for(int i = 0; i < m; i++){
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }    
    cout << dijkstra() << endl;
    return 0;
}
4. Bellman-ford算法板子：
  1. 我们存图采用简单的结构体。
  2. 其原理非常简单：一个有n个点的图，给每个点n次机会查询邻居，是否有到起点更短的路径，如果有就更新。
  3. 板子中第一层循环表示最多经过k条边的最短路。故我们更新下一层时，要拿上一层的状态更新。所以我们使用backup（备份）数组来存上一层的状态。
  4. 之后枚举每条边，更新距离。
  5. 其次，Bellman-ford算法可以用来检查是否存在负权回路：如果在进行完k轮操作后，仍可以继续完成松弛操作，那么此图必然存在负权回路。
853. 有边数限制的最短路 - AcWing题库
#include <bits/stdc++.h>
using namespace std;

int n, m, k;
const int N = 510, M = 10010;
int dist[N], backup[N];

struct e{
    int a, b, w;
}e[M];

void bellman_ford(){
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    for(int i = 0; i < k; i++){
        memcpy(backup, dist, sizeof dist);
        for(int j = 0; j < m; j++){
            int a = e[j].a, b = e[j].b, w = e[j].w;
            dist[b] = min(dist[b], backup[a] + w);
        }
    }
    if(dist[n] > 0x3f3f3f3f / 2){
        cout << "impossible" << endl;
        return;
    }
    cout << dist[n] << endl;
    return;
}

int main() {
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    cin >> n >> m >> k;
    for(int i = 0; i < m; i++){
        int a, b, w;
        cin >> a >> b >> w;
        e[i] = {a, b, w};
    }
    bellman_ford();
    return 0;
}
5. SPFA算法板子：
  1. SPFA是Bellman-Ford算法的改进，也可以说，SPFA是用队列优化的Bellman-ford算法。
  2. st数组用来记录点是否在队列中。
#include <bits/stdc++.h>
using namespace std;

const int N = 100010;
int e[N], ne[N], idx, h[N], w[N];
int n, m;
int dist[N];
bool st[N];

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

void spfa(){
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    queue<int> q;
    q.push(1);
    st[1] = true;
    while(q.size()){
        int sz = q.size();
        for(int k = 0; k < sz; k ++){
            auto temp = q.front();
            q.pop();
            st[temp] = false;
            for(int i = h[temp]; i != -1; i = ne[i]){
                int j = e[i];
                if(dist[j] > dist[temp] + w[i]){
                    dist[j] = dist[temp] + w[i];
                    if(!st[j]){
                        q.push(j);
                        st[j] = true;
                    }
                }
            }
        }
    }
    if(dist[n] == 0x3f3f3f3f){
        cout << "impossible" << endl;
        return;
    }
    cout << dist[n] << endl;
    return;
}

int main() {
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for(int i = 0; i < m; i ++){
        int a, b, w;
        cin >> a >> b >> w;
        add(a, b, w);
    }
    spfa();
    return 0;
}
6. SPFA判断负环板子：
  1. cnt数组表示当前1~x的边的数量。若cnt >= n 则证明从1~x至少经过了n条边（n + 1个点）。有抽屉原理可知，至少有两个点的编号一样，即存在负权回路。
852. spfa判断负环 - AcWing题库
#include <bits/stdc++.h>
using namespace std;

int n, m;
const int N = 2010, M = 10010;
int e[M], ne[M], idx, h[N], w[M], cnt[N], dist[N];
bool st[N];

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

void spfa(){
    memset(dist, 0x3f, sizeof dist);
    queue<int> q;
    for(int i = 1; i <= n; i++){
        q.push(i);
        st[i] = true;
    }
    while(q.size()){
        int sz = q.size();
        for(int k = 0; k < sz; k++){
            auto temp = q.front();
            q.pop();
            st[temp] = false;
            for(int i = h[temp]; i != -1; i = ne[i]){
                int j = e[i];
                if(dist[j] > dist[temp] + w[i]){
                    dist[j] = dist[temp] + w[i];
                    cnt[j] = cnt[temp] + 1;
                    if(cnt[j] >= n){
                        cout << "Yes" << endl;
                        return;
                    }
                    if(!st[j]){
                        q.push(j);
                        st[j] = true;
                    }
                }
            }
        }
    }
    cout << "No" << endl;
    return;
}

int main() {
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    memset(h, -1, sizeof h);
    cin >> n >> m;
    for(int i = 0; i < m; i++){
        int a, b, w;
        cin >> a >> b >> w;
        add(a, b, w);
    }
    spfa();
    return 0;
}
7. Floyd算法板子：
  1. 三层循环更新邻接矩阵，更新完毕后得到最短路。
854. Floyd求最短路 - AcWing题库
#include <bits/stdc++.h>
using namespace std;

int n, m, k;
const int N = 210, M = 20010;
int g[N][N];
int INF = 0x3f3f3f3f;

void floyd(){
    for(int k = 1; k <= n; k++){
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= n; j++){
                g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
            }
        }
    }
}

void solve(){
    int a, b;
    cin >> a >> b;
    if(g[a][b] > INF / 2) cout << "impossible" << endl;
    else cout << g[a][b] << endl;
}

int main() {
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    cin >> n >> m >> k;
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= n; j++){
            if(i == j) g[i][j] = 0;
            else g[i][j] = INF;
        }
    }
    for(int i = 0; i < m; i++){
        int a, b, w;
        cin >> a >> b >> w;
        g[a][b] = min(g[a][b], w);
    }   
    floyd();
    for(int i = 0; i < k; i++){
        solve();
    }
    return 0;
}
zhangpz_
关注
【硬件调试】示波器探头一碰芯片引脚板子就短路或者闪小火花
云轩阁
07-12 456
在对晶振进行测试时，示波器探头选用X10档（因为这时可以让探头的等效输入电容最小，让输入阻抗最大，减小对晶振的影响，因为当探头接在晶振引脚上时，相当于改变了晶振的振荡电容大小。而晶振的匹配电容一般为8pF、10pF、12pF、18pF、30pF等，探头的输入电容会影响晶振的起振，但是当改为X10档，可以知道15pF~45pF，输入电容对晶振起振影响降低，但是多多少少可能会影响波形的质量。x1档相当于接了一个很大的负载，可能改变电路中的振荡条件，测量的结果可能不是电路中真实的波形。输入电容为128PF.
最短路板子
lppppppppps的博客
07-20 177
1 ACW849 初学图论，月底前学完图论课，这个专题是很重要、基础的最短路，这两天让HDU搞自闭了，后续更些基础题。 先是朴素dij，不妨先将点分为两部分：S集合（包含已确定最短路的点）和T集合（包含还未确定最短路的点）。主要思路是n个点，每个点只扩展1次求得所有点的最短路，以下方法可以保证每个点只扩展一次（因为每个点拓展一次后就确定了，将它加入S，再也用不到它扩展了）：每次从T集合中的所有点中选出一个距离当前源点距离dist最短的点，该点一定是所有点中的源点到其距离dist最短的点（在图中很好理解，边无
最短路算法（Floyd算法，Dijkstra算法，Bellman-Ford算法，SPFA算法）
baodream的博客
01-31 790
1.Floyd算法 //1.Floyd算法,多源无负权 //通过邻接矩阵跑出所有点之间的最短路,时间复杂度O(n^3),空间复杂度O(n^2) //d[i][j]表示i到j的最短路径长度,初始化：d[i][i]=0,点到点有路按正常权值初始化,其余INF int mp[n][n]; int d[n][n]; void Floyd() { for(int i=1;i<=n;i++)
最短路（基础板子）
weixin_50935546的博客
08-20 140
1.朴素版Dijkstra 题目:A - Til the Cows Come Home #define INF 0x3f3f3f3f using namespace std; int n,m; int mp[1010][1010],dist[1010],vis[1010]; void Dij() { for(int i=1;i<=n;i++)dist[i]=mp[n][i]; vis[n]=1; for(int i=1;i<=n;i++) { in
最短路板子第一弹·Dijkstra基础
Xylodesu
10-19 344
1. Dijkstra 无图警告 1.1 思路   Dijkstra的来历不必多讲，但是需要知道的，是Dijkstra是一种基于“贪心“的求“单源最短路”算法，和最小生成树中的Prim是类似的。（如果你不知道什么是单源最短路，建议百度一下再来）   粗略来讲，Dijkstra的做法就是： 以起始点为中心向外层层扩展，直到扩展到终点为止 ——百度百科   既然是这样，我...
PCB技术中的BGA线路板及其CAM制作
11-25
在电子制造领域，PCB（Printed Circuit Board）技术中的BGA（Ball Grid Array）线路板是一种广泛应用的封装技术，特别是在高密度集成的电路设计中。BGA的优势在于它的球栅阵列结构，这种设计使得封装面积减小，功能...
行业分类-设备装置-线路板及其制作方法与具有此线路板的光电装置.zip
08-20
标题中的“行业分类-设备装置-线路板及其制作方法与具有此线路板的光电装置.zip”揭示了这个压缩包文件的主要内容，它涉及到的是电子工程领域中的线路板设计与制造，以及这种线路板在光电装置中的应用。线路板，全称...
stm32f103zet6板子总工程文件及板子芯片资料、DRC、BOM表实物图原理图pdf原理图schdoc.rar
05-19
这款芯片在嵌入式系统领域广泛应用，特别是在小型电子设备、物联网(IoT)产品和自动化系统中。STM32F103ZET6具有丰富的功能集，包括高速的处理能力、多种通信接口以及大量的内置存储和I/O端口。 工程文件是开发基于...
最短路的Floyd-Dijkstra-Spfa板子
02-06
做ACM最短路问题普遍算法的Floyd-Dijkstra-Spfa板子..
最短路的一些板子
the CodeRoom of wjfwzzc
04-03 1547
起因是一场训练赛，这道题我和Thor拿出了正解（之一），但非常令人发指地送出了不计其数的TLE。 　　题干不说了，我们的做法是前向星建图，然后每个LPG（起点终点也算LPG）跑一遍SPFA，然后所有LPG重新前向星建图，再跑一遍SPFA。复杂度大概是O(k1*n+k2*m^2)，按理说不会超时啊…… 　　然后我们发现昂神的做法前面和我们一样，后面建邻接矩阵，跑一遍Floyd，理论复杂度是O(k
各种最短路的板子
博客迁移http://www.cnblogs.com/xzz_233/
11-14 547
发个最短路板子。。
最短路入门板子及各自题目
AsUs.的博客
09-14 506
目录单源最短路朴素Dijkstra求最短路（O(n^2)）堆优化版Dijkstra求最短路（O(mlogn)）有边数限制的最短路（Bellman_Ford）（O(nm)）spfa求最短路（一般O(m)，最坏（O(nm)））spfa判断负环多源汇最短路Floyd求最短路（O(n^3)）练习题（持续更新） 单源最短路 朴素Dijkstra求最短路（O(n^2)） 题目链接 给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值。 请你求出 1 号点到 n 号点的最短距离，如果无法从 1
堆优化的dijkstra板子
最新发布
JK01WYX的博客
01-21 558
③vectorarr代表通路，用set可以去重（有的题可能是多重图，即含平行边）。①tmpdis代表节点之间的距离，有的时候就是1，自己设置吧，dijkstr主函数中算距离用。2.cmp仿函数是用于堆排比较器的，（试过greater()是不行的。②dij代表此点到所有点的最短路，所以我放参数列表当输出型参数了，许多题可能要用到。然后这次周赛又考了，我没有板子QAQ，普通板子还超时了，所以补一篇。之前力扣周赛有一次，都没想到用这个，，后来自己写了。
Dijkstra 最短路径板子 青春版 仅供参考 慎入
做一做笔记，做一做总结
08-02 2522
Dijkstra算法是最短路径里常用的一种算法，在邻接矩阵中，n个点，时间复杂度为O(n^2)。 再次强调，此板子本人使用次数也较少，仅供参考，如果看不懂注释，不明就里，最好去参考参考更好的。 int n; const long long inf = __LONG_LONG_MAX__; struct NODE { int u, v, next; // u、v两个点，next链式前...
dijkstra Floyd 迪杰斯特拉 弗洛伊德 板子
Florentino107的博客
04-07 264
好久没写dijkstra了，找个板子，记录一下，方便用 朴素dijkstra #include<iostream> #include<cstring> #include<algorithm> #include<queue> using namespace std; const int N=3000; int g[N][N],dist[N]; int n,m,s,e; bool st[N]; int dijkstra(int s,int e) { mem
Dijkstra 板子（效率对比）
辣鸡葫芦娃
08-23 767
测试题目：luogu 1462：二分+Dijkstra 保证了尽可能除了Dijkstra的存图方式不同，其他部分完全相同。 比较结果：vector链表比模拟链表慢大约1/4 板子1号：手动模拟链表版 最慢测试点：420ms 总时间：1984ms #include using namespace std; const int MAX = 1e5; int first[MAX]; in
最短路算法详解与应用实践
"最短路算法及其应用 编程 C C++ ACM" 最短路问题是图论中的关键问题，它在很多复杂算法中起到基础性作用，同时也广泛应用于现实生活中的各种场景。本文由广东北江中学的余远铭撰写，详细探讨了最短路问题的相关...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值