Dijkstra算法（附【模板】单源最短路径（标准版）代码）c++

1.简介

Dijkstra算法是一种用于在图中找到单源最短路径的算法。该算法由荷兰计算机科学家Edsger W. Dijkstra在1956年提出，适用于带有非负权重的有向图或无向图。Dijkstra算法能够找到图中一个节点（称为源点）到其他所有节点的最短路径。

2.工作原理

算法的基本思想

Dijkstra算法通过维护一个距离数组（dist[]），该数组中的每个元素dist[i]表示从源点到图中顶点i的最短路径长度。算法从源点开始，逐步向外扩展，更新到其他顶点的最短路径长度，直到所有顶点的最短路径都被找到。

算法步骤

1. 初始化：将距离数组dist[]中的所有元素初始化为无穷大（除了dist[源点] = 0）。

2. 维护一个集合：通常使用优先队列（或称为最小堆）来存储待处理的顶点，初始时将源点加入该集合。集合中的顶点按照它们的dist[]值进行排序，以便每次都能从集合中取出当前已知最短路径长度最小的顶点。

3. 循环处理：

   • 从集合中取出当前dist[]值最小的顶点u（即当前已知最短路径长度最小的顶点）。
   • 遍历顶点u的所有邻接顶点v：
     • 如果通过顶点u到达顶点v的路径比已知的最短路径更短（即dist[u] + weight(u, v) < dist[v]），则更新dist[v]为dist[u] + weight(u, v)，并将v加入优先队列（如果v还未在集合中）。
   • 重复上述步骤，直到优先队列为空，即所有顶点都被处理过。

4. 结果：dist[]数组最终将包含从源点到图中所有其他顶点的最短路径长度。

算法的复杂度

• 使用简单线性查找的Dijkstra算法的时间复杂度为O(V^2)，其中V是图中顶点的数量。
• 使用优先队列（如二叉堆）的Dijkstra算法的时间复杂度可以降低到O((V + E)logV)，其中E是图中边的数量。这使得算法在处理稀疏图时更加高效。

注意事项

• Dijkstra算法不适用于包含负权边的图，因为负权边可能破坏算法的贪心选择策略。
• 对于带有负权边的图，可以使用Bellman-Ford算法或Floyd-Warshall算法来找到最短路径。

Dijkstra算法因其高效性和易实现性，在图论和计算机科学领域中得到了广泛应用。

3.代码

题目：P4779 【模板】单源最短路径（标准版）    AC记录

代码绝对为本人所写！！！

#include <bits/stdc++.h>
using namespace std;
long long n, m, s, dis[2000005], vis[2000005];
struct node
{
	int x, y;
};
vector<node>g[2000005];
void dijkstra(int z)
{
	priority_queue<pair<int, int>>q;
	memset(dis, 0x3f, sizeof(dis));
	memset(vis, 0, sizeof(vis));
	dis[z] = 0;
	q.push({0, z});
	while(!q.empty())
	{
		int x = q.top().second;
		q.pop();
		if(vis[x]) continue;
		vis[x] = 1;
		for(auto to : g[x])
		{
			int k = to.x;
			int l = to.y;
			if(dis[k] > dis[x] + l)
			{
				dis[k] = dis[x] + l;
				if(vis[k] == 0)
				{
					q.push({-dis[k], k});
				}
			}
		}
	}
}
int main()
{
	cin >> n >> m >> s;
	for(int i = 1; i <= m; i ++)
	{
		int u, v, w;
		cin >> u >> v >> w;
		g[u].push_back({v, w});
	}
	dijkstra(s);
	for(int i = 1; i <= n; i ++)
	{
		cout << dis[i] << " ";
	}
	return 0;
}

注释版：

#include <bits/stdc++.h>
using namespace std;
long long n, m, s, dis[2000005], vis[2000005];
// 定义节点结构体，包含两个整数x和y
struct node
{
	int x, y;
};
// 定义一个vector数组g，用于存储每个节点的邻接节点
vector<node>g[2000005];
// 定义一个dijkstra函数，用于计算从节点z到其他节点的最短路径
void dijkstra(int z)
{
	// 定义一个优先队列q，用于存储节点和对应的距离
	priority_queue<pair<int, int>>q;
	// 将dis数组初始化为无穷大
	memset(dis, 0x3f, sizeof(dis));
	// 将vis数组初始化为0
	memset(vis, 0, sizeof(vis));
	// 将起点z的距离设置为0
	dis[z] = 0;
	// 将起点z和距离0放入优先队列q中
	q.push({0, z});
	// 当优先队列q不为空时，执行循环
	while(!q.empty())
	{
		// 取出优先队列q中的节点x和距离
		int x = q.top().second;
		q.pop();
		// 如果节点x已经访问过，则跳过
		if(vis[x]) continue;
		// 将节点x标记为已访问
		vis[x] = 1;
		// 遍历节点x的邻接节点
		for(auto to : g[x])
		{
			// 取出邻接节点k和距离l
			int k = to.x;
			int l = to.y;
			// 如果从节点z到节点k的距离大于从节点z到节点x的距离加上距离l，则更新距离
			if(dis[k] > dis[x] + l)
			{
				dis[k] = dis[x] + l;
				// 如果节点k未被访问过，则将节点k和距离放入优先队列q中
				if(vis[k] == 0)
				{
					q.push({-dis[k], k});
				}
			}
		}
	}
}
int main()
{
	// 输入节点数n、边数m和起点s
	cin >> n >> m >> s;
	// 遍历每条边，输入边的两个端点和距离，并将距离存入邻接节点数组g中
	for(int i = 1; i <= m; i ++)
	{
		int u, v, w;
		cin >> u >> v >> w;
		g[u].push_back({v, w});
	}
	// 调用dijkstra函数，计算从起点s到其他节点的最短路径
	dijkstra(s);
	// 输出从起点s到其他节点的最短路径
	for(int i = 1; i <= n; i ++)
	{
		cout << dis[i] << " ";
	}
	return 0;
}