Dijkstra算法基础详解，附有练习题

已于 2024-02-17 18:59:42 修改
阅读量277 收藏
点赞数 2
文章标签： 算法 c++ 图论
于 2023-10-28 14:34:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/clmm_/article/details/133961313
版权

介绍

Dijkstra算法是一种用于求解单源最短路径问题的经典算法。它可以在给定有向加权图（无向是特殊的有向）中，从一个起点到其他所有节点的最短路径。

作用：

在给定的加权图中，求一个点到其余点的最短路径

基本思想：

  • 初始化一个距离数组dist[]，表示起点到各个节点的当前最短距离，初始时起点的最短距离为0，其余节点的最短距离为无穷大。
  • 创建一个集合S，用于存放已经确定最短路径的节点，初始时集合S为空。
  • 重复以下步骤，直到集合S包含了所有节点：
    • 在未确定最短路径的节点中，选择一个节点v，选择的是dist[v]值最小，将该节点加入集合S。
    • 更新节点v的所有邻接节点u的最短距离，如果通过节点v到达节点u的距离比当前最短路径更短，则更新最短距离dist[u]为新的最短距离。
    • 表示为： dist[u] = min(dist[u],dist[v]+edge[v][u])

Dijkstra算法的关键是如何选择节点v，这里使用了贪心策略，每次选择距离起点最近的未确定最短路径的节点，确保每次加入的节点都是当前最短距离确定的。

朴素模板如下：

int dijkstra(int b)//求b到各个点的距离
{
	memset(dist, 0x3f, sizeof dist);
	dist[b] = 0;

	for (int i = 0; i < n - 1; i++)
	{
		int t = -1;     // 在还未确定最短路的点中，寻找距离最小的点
		for (int j = 1; j <= n; j++)
			if (!st[j] && (t == -1 || dist[t] > dist[j]))
				t = j;

		//从t这个点更新到其他点的距离。
		//虽然是遍历了每个点，但并不代表t可以到任意点，
		//因为会把到不了的边的距离设为inf，就避免了考虑t点可以到哪些点的问题
		for (int j = 1; j <= n; j++)
			dist[j] = min(dist[j], dist[t] + v[t][j]);

		st[t] = true;
	}

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

堆优化版

可以看到，朴素版有一个遍历找dist最小的操作，如果用小根堆维护dist的话，就可以一下子找到最小了，无需遍历

插入优先队列的知识点

可以使用标准库中的priority_queue来实现小根堆和大根堆。priority_queue默认实现的是大根堆，如果需要实现小根堆，可以通过自定义比较器来改变默认行为。

priority_queue<int, vector<int>, greater<int>> minHeap;

int dijkstra(int b)//求b到各个点的距离
{
	memset(dist, 0x3f, sizeof dist);
	dist[b] = 0;

	
    priority_queue<node, vector<node>, cmp> q;
	q.push({ b,0 });
	
	while (q.size()) {
		node t = q.top();
		q.pop();
		int ver = t.v, distance = t.w;
		//此时dist[ver] == distance，是最小的
		if (st[ver]) continue;

		st[ver] = true;
		for (int i = 0; i < edge[ver].size();i++) {
			//更新ver可以到达的点
			if (dist[i] > edge[ver][i] + distance) {
				dist[i] = edge[ver][i] + distance;
				q.push({ i,dist[i] });
			}
		}

	}




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

邻接表写法

Dijkstra求最短路 II

const int N = 150010;
typedef pair<int,int> PII;

int h[N],w[N],ne[N],e[N],idx;
void add(int u,int v,int we){
    w[idx] = we,ne[idx] = h[u],e[idx] = v;
    h[u] = idx++;
}
int dist[N];bool st[N];
int n,m;
int dijkstra(int b){
    memset(dist,0x3f,sizeof dist);
    dist[b] = 0;
    
    //PII的第一个元素是点x到b点的距离，第二个元素是点x
    priority_queue<PII,vector<PII>,greater<PII>> heap;
    heap.push({0,b});
    while(heap.size()){
        auto t = heap.top();
        heap.pop();
        
        int ver = t.second,distance = t.first;
        if(st[ver]) continue;
        st[ver] = true;
        //访问ver能到达的点，更新ver到这些点的距离
        for(int i = h[ver];i!=-1;i = ne[i]){
            //切记了，i只是编号！
            int j = e[i];//j才是ver能到达的点
            if(dist[j] > distance + w[i]){
                dist[j] = distance + w[i];
                heap.push({dist[j],j});
            }
            
        }
        
    }
    if(dist[n] == 0x3f3f3f3f) return -1;
    else return dist[n];
    
}
void solve() {
	cin>>n>>m;
	memset(h,-1,sizeof h);
	//memset(st,false,sizeof st);
	//idx = 1;
	while(m--){
	    int a,b,c;cin>>a>>b>>c;
	    add(a,b,c);
	}
	int t = dijkstra(1);
	cout<<t<<endl;
	
}

Dijkstra序列

输入样例：
5 7
1 2 2
1 5 1
2 3 1
2 4 1
2 5 2
3 5 1
3 4 1
4
5 1 3 4 2
5 3 1 2 4
2 3 4 5 1
3 2 1 5 4
输出样例：
Yes
Yes
Yes
No

分析：还是要先弄目标dijkstra序列的含义是什么，这个困扰我了很久。

我们知道，在构建dist数组时，每次是选 还没有选过 且 当前dist最小 的点，在这个点的基础上进行更新。然后要选n次，我们这n次选的点的序列就称作dijkstra序列（第一个点就是起点）。

例如：5，1，3，4，2。代表点5是起点，然后选点1，点3，点4，点2。

设每次选的点为dist[i]，那么dist[i]一定小于当前所有还没选过的点。以这个为判断条件，如果不满足，则不是一个dijkstra序列。

#include<assert.h>
#include<cstdio>
#include<set>
#include<list>
#include<queue>
#include<math.h>
#include<stdlib.h>
#include<string>
#include<string.h>
#include <stdio.h>
#include<algorithm>
#include<iomanip>
#include<cmath>
#include<sstream>
#include<stack>
#include <utility>
#include<map>
#include <vector>

#define inf 0x3f3f3f3f
#define int long long
const int N =1010;
//#include <bits/stdc++.h>
typedef long long ll;
#include<iostream>
using namespace std;

//long long MAX(long long a, long long b) { return a < b ? b : a; }

int n, m;


int v[N][N];//存每条边,v[i][j]代表i到j的距离。如果i到j没有直接的路径，那么设为inf
int dist[N];//存i号点到各个点的最短距离
int st[N];//存到达该点该点是否已经确定最短路径
int q[N];

int dijkstra() {//从b开始，到各个点的距离
	memset(dist, inf, sizeof(dist));
	memset(st, 0, sizeof(st));
	dist[q[0]] = 0;//到达自己的距离是0

	
	for (int i = 0; i < n; i++) {

		int cur = q[i];
		for (int j = 1; j <= n; j++) {
			if (!st[j] && dist[j]<dist[cur]) {
				return false;
			}
		}

		//从cur这个点更新到其他点的距离。
		//虽然是遍历了每个点，但并不代表cur可以到任意点，
		//因为会把到不了的边的距离设为inf，就避免了考虑cur点可以到哪些点的问题
		for (int j = 1; j <= n; j++) {
			dist[j] = min(dist[j], dist[cur] + v[cur][j]);
		}

		st[cur] = 1;
	}

	return 1;
}
signed main() {
	cin >> n >> m;
	memset(v, inf, sizeof(v));

	for (int i = 0; i < m; i++) {
		int a, b, d; cin >> a >> b >> d;

		//因为是无向图
		v[a][b] = d;
		v[b][a] = d;
	}
	int k; cin >> k;
	while (k--) {
		vector<int> t;
		t.push_back(0);
		for (int i = 0; i < n; i++) {
			cin >> q[i];
		}
		if (dijkstra()) cout << "Yes" << endl;
		else cout << "No" << endl;

	}

	return 0;
}

奶牛回家

输入样例：
5
A d 6
B d 3
C e 9
d Z 8
e Z 3
输出样例：
B 11

分析：简单题。命名为大写字母的牧场才有牛，可以逆向思考，从牛棚Z开始往这些牧场走，那条路最短。

易错点，两个牧场间可能有多条路，这些路长度可能不一样，注意判断。

#include<cstdio>
#include<set>
#include<list>
#include<queue>
#include<math.h>
#include<stdlib.h>
#include<string>
#include<string.h>
#include <stdio.h>
#include<algorithm>
#include<iomanip>
#include<cmath>
#include<sstream>
#include<stack>
#include <utility>
#include<map>
#include <vector>

#define inf 0x3f3f3f3f
#define int long long
const int N =1010;
//#include <bits/stdc++.h>
typedef long long ll;
#include<iostream>
using namespace std;

//long long MAX(long long a, long long b) { return a < b ? b : a; }

int n;

int v[N][N];  // 存储每条边
int dist[N];  // 存储1号点到每个点的最短距离
bool st[N];   // 存储每个点的最短路是否已经确定

int get(char x) {
	if (x >= 'A' && x <= 'Z') return x - 'A' + 1;
	return x - 'a' + 26 + 1;

}
void dijkstra() {
	memset(dist, inf, sizeof(dist));
	memset(st, 0, sizeof(st));
	dist[26] = 0;//Z到Z距离是0
	for (int i = 1; i <= 52; i++) {
		int cur = -1;
		for (int j = 1; j <= 52; j++) {
			if (!st[j] && (cur == -1 || dist[cur] > dist[j])) {
				cur = j;
			}
		}

		for (int j = 1; j <= 52; j++) {
			dist[j] = min(dist[j], dist[cur] + v[cur][j]);
		}
		st[cur] = 1;
	}

}
signed main() {
	cin >> n;
	memset(v, inf, sizeof(v));
	while (n--) {
		char a, b; int c;
		cin >> a >> b >> c;
		int d = get(a);
		int e = get(b);
		v[d][e] = v[e][d] = min(v[d][e], c);

	}
	dijkstra();
	int index = 0, len = inf;
	for (int i = 1; i <= 25; i++) {
		if (len > dist[i] && dist[i] <= 10000 * 1000) {
                           //如果大于这个距离就是没有到i的路，距离为inf
			len = dist[i];
			index = i;
		}
	}
	printf("%c %lld", index + 'A' - 1, len);

	return 0;
}

clmm_
关注
【作业存档】Dijkstra算法的练习
巨大化
12-04 1065
Dijkstra算法，广度优先的寻找加权最短路径的算法，
Dijkstra算法练习
bigthinker的博客
06-29 548
/**  * Dijkstra算法思想：  * 按各顶点与源点start间路径长度的递增次序，生成到各顶点的最短路径的算法。  * 即求出长度最短的一条最短路径，再参照它求出长度次短的一条路径，以此类推，直到  * 从源点start到其他各顶点的最短路径全部求出为止。  * 1.选出一个距离初始顶点start最近的未访问顶点  * 2.以这个顶点为中间点更新从start到未访问各店的距
Dijkstra算法的一个例子
03-26
http://blog.csdn.net/m0_37885286/article/details/66476680可以看博主的文章，里面有详细介绍
遍历所有点的最短路径matlab_号称最贪心的算法Dijkstra算法
weixin_39897505的博客
12-11 6784
Dijkstra算法算是贪心思想实现的，首先把起点到所有点的距离存下来找个最短的，然后松弛一次再找出最短的，所谓的松弛操作就是，遍历一遍看通过刚刚找到的距离最短的点作为中转站会不会更近，如果更近了就更新距离，这样把所有的点找遍之后就存下了起点到其他所有点的最短距离。问题引入：指定一个点(源点)到其余各个顶点的最短路径，也叫做“单源最短路径”。例如求下图中的1号顶点到2、3、4、5、6号顶...
【图论习题集】（dijkstra, 匈牙利算法，更新至8873字）
gfyy_bkj的博客
11-05 695
前言：匈牙利算法的本质是DFS，就用那个男女朋友的例子为例，每个女生暗恋一个男生，我们先是假定第一个女生和他暗恋的第一个男生配对，接下来，我们考察第二个女生，如果这个女生也喜欢这个男生，那么我们先考虑第一位女生让步，让她取希望暗恋的第二个男生，如果成功，那么配对的数目自然就加一了，或者没有其他男生的话，只能让第二个女生去喜欢暗恋的第二个男生，一次类推。由于增广路径的正确性，我们得到的每一个都是当前女生数的最大匹配数，这里运用的动态规划的思想。注意：是有向的，我们把起点集合里的第一个点作为起点。
Dijkstra算法详解（完美图解、趣学算法）
热门推荐
qq_45776662的博客
07-07 12万+
Dijkstra算法详解Dijkstra算法设计Dijkstra算法简介Dijkstra算法的基本思想Dijkstra贪心策略完美图解伪代码详解完整代码算法解析及优化拓展使用优先队列的完整代码相关题的题解写在最后的话 Dijkstra算法设计 Dijkstra算法简介 Dijkstra算法是解决**单源最短路径**问题的**贪心算法** 它先求出长度最短的一条路径，再参照该最短路径求出长度次短的一条路径 直到求出从源点到其他各个顶点的最短路径。 Dijkstra算法的基本思想 首先假定源点为u，顶点集合
Dijkstra算法详解.pdf
最新发布
06-05
### Dijkstra算法详解 #### 一、引言 在计算机科学领域中，寻找最短路径问题是一个非常重要的研究方向。Dijkstra算法作为一种经典的最短路径算法，被广泛应用于各种场景中，比如网络路由、地图导航等。该算法由...
Dijkstra算法的流程图
02-08
Dijkstra算法，由荷兰计算机科学家艾兹格·迪科斯彻于1956年提出，是一种用于寻找图中两点间最短路径的算法。它主要用于解决单源最短路径问题，即从图中的一个顶点（源点）出发，找到到达其他所有顶点的最短路径。...
Python使用Dijkstra算法实现求解图中最短路径距离问题详解
12-24
这里继续前面一篇《Python基于Floyd算法求解最短路径距离问题》的内容，这里要做的是Dijkstra算法，与Floyd算法类似，二者的用途均为求解最短路径距离，在图中有着广泛的应用，二者的原理都是老生常谈了，毕竟本科...
Dijkstra算法Matlab实例代码实现
05-07
Dijkstra算法算是贪⼼思想实现的，⾸先把起点到所有点的距离存下来找个最短的，然后松弛⼀次再找出最短的，所谓的松弛操作就是，遍历⼀遍看通过刚刚找到的距离最短的点作为中转站会不会更近，如果更近了就更新距离，...
数据结构习题－Dijkstra
11-23
数据结构习题Dijkstra 1.3、将二叉树看作图，并对它作图的深度优先遍历，则与原二叉树的 结果是相同的。 A、前序遍历 B、中序遍历C、后序遍历D、层次序遍历 1.4、在关于树的以下4种叙述中，正确的是 。 A、用指针方式存储有n个结点的二叉树，至少要有n+1个指针。 B、m阶B-树中，具有k个子结点的结点，必有k-1个键值。 C、m阶B-树中，每个非叶子结点的子结点个数≥[m/2]。 D、平衡树一定是丰满树。 1.5、在最好和最坏情况下的时间复杂度均为O(nlog2n)且稳定的排序方法是 A、希尔排序 B、快速排序 C、堆排序 D、归并排序 二、解答题 2.1、对目标串 abaabcc和模式串aabc，描述根据KMP算法进行匹配的过程，包括失效函数计算。答：失效函数：-1， 0， -1， -1 目标串 abaabcc和模式串aabc的KMP算法进行匹配的过程 abaabcc aabc 首先，从目标位置0和模式位置0开始比较，至ab和aa，不等时目标位置为1， 模式位置为1。因0位置失效函数的值（ f [posP-1] ） 为-1，从目标位 置1和模式位置0开始新一轮比较。因第一个字符( posP == 0 )就不等，目标 位置增1，目标位置2和模式位置0开始新一轮比较，直到模式位置比较至4， 匹配成功。 int fastFind ( char *s, char * pat ){ //带失效函数的KMP匹配算法 int posP = 0, posT = 0; int lengthP = strlen(pat), lengthT = strlen(s); while ( posP < lengthP && posT < lengthT ) if ( pat[posP] == s[posT] ) { posP++; posT++; //相等继续比较 } else if ( posP == 0 ) posT++; //不相等 else posP = f [posP-1]+1; if ( posP < lengthP ) return -1; else return posT - lengthP; }
Dijkstra的三个实例
07-06
用VC6.0开发的Dijkstra算法的三个应用实例，方法1中包含了图的生成和邻接表存储，方法2和三需要用户手动输入，用邻接矩阵存储 Dijkstra's algorithm with VC6.0 developed three application examples, the method includes a graph adjacency table generation and storage, two and three methods require the user to manually enter, with adjacency matrix storage
Dijkstra算法（朴素，堆优化）+例题
阳光的博客
11-27 1732
Dijkstra算法基于贪心，分为朴素版和堆优化版，稠密图用朴素版，稀疏图用堆优化版。 算法思想 首先给定起始点和终点，求起始点到终点的最短路径。 Dijkstra算法的做法是： 在所有顶点里找到距离起点最近的点，将它放入集合S。 用这个顶点来更新其它顶点到起点的距离。 重复1,2步，直到所有顶点都在集合S里，此时，终点存的距离就是终点到起点的最短距离。 朴素版Dijkstra例题 ACWING849. Dijkstra求最短路 I 给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权
最短路算法——Dijkstra（题目练习解析）
指北针_N的博客
04-22 2809
Dijkstra（题目练习解析） 点击 -> Dijkstra算法详细讲解 王国 题目描述 小明是王国的王子，今天是他登基之日。在即将成为国王之前，老国王给他出了道题，他想要考验小明是否有能力管理国家。 题目的内容如下： 蓝桥王国一共有N个建筑和M条单向道路，每条道路都连接着两个建筑，每个建筑都有自己编号，分别为 1∼N。（其中皇宫的编号为1） 国王想让小明回答从皇宫到每个建筑的最短路径是多少，但紧张的小明此时已经无法思考，请你编写程序帮助小明回答国王的考核。 输入描述 ...
dijkstra模板及例题（最短路算法）
weixin_61017400的博客
04-22 1万+
dijkstra算法、模板及例题
Dijkstra算法（最短路；例题HDU2112）
weixin_30823227的博客
09-03 337
Dijkstra算法：求单源最短路的算法。 主要步骤： 1.定义一个dis数组记录起始点到每个点的距离，初始化时不能到达的记为inf(一般用0x3f3f3f3f)。 2.找到离起始点最近的节点从这个点松弛，并标记 3.松弛，如果出现s->m >s->k->m，则将dis[m]松弛为dis[k]+G[k][j] 核心代码： ...
【期末复习】例题讲解Dijkstra算法
榕城候佳人的博客
02-20 1303
Dijkstra算法将图中所有顶点分成两部分，第一部分是已知到源点最短距离的顶点Known(K)，第二部分是不知道到源点最短距离的顶点Unknown(U)。发现U中2到源点的距离最小，把2加入K中得到下表。发现U中4到源点的距离最短，把4加入K中得到下表。K中5到源点的距离最小把5加入K中得到下表。1-1. 找到顶点1的邻接点2和3，然后更新它们到源点1的距离得到下表。6-2. 更新K,U中的顶点，将顶点7加入K中完成计算得到下表。4-1. 找到4的邻接点5和6，更新它们到源点的距离得到下表。
图结构练习——最短路径 （Dijkstra算法版）
weixin_54699118的博客
02-20 3568
Dijkstra算法 定义：迪克斯特拉算法，是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。 这里解决最短路径问题需要先了解Dijkstra算法，所以这里先把个人对于这个算法的理解附上，再解决最短路问题。 以这个图为例，从1号走到7号的最短路径明显是从1到4再到7，这条路径的权值最小。从代码角度就要利用Dijkstra算法来解释。 因为是从1号开始走，所以
C++实现Dijkstra算法详解
"这篇文档提供了一个使用C++实现Dijkstra算法的完整代码示例，用于找到图中的最短路径。" 在计算机科学中，Dijkstra算法是一种解决单源最短路径问题的有效算法，由荷兰计算机科学家艾兹格·迪科斯彻在1956年提出。...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值