最短路模板:使用priority_queue实现的Dijkstra算法

测试数据:

8 15
4 5 0.35
5 4 0.35
4 7 0.37
5 7 0.28
7 5 0.28
5 1 0.32
0 4 0.38
0 2 0.26
7 3 0.39
1 3 0.29
2 7 0.34
6 2 0.40
3 6 0.52
6 0 0.58
6 4 0.93

测试结果:

1 1.05
2 0.26
3 0.99
4 0.38
5 0.73
6 1.51
7 0.60


PS:边的权重必须非负。

PS2:就算有平行边和自环也请方向使用。


代码:

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<utility>
#include<functional>
using namespace std;
const int mx = 10005;

typedef pair<double, int> P; ///first是最短距离,second是顶点编号
struct edge
{
	double cost;
	int to;
	void read()
	{
		scanf("%d%lf", &to, &cost);
	}
} e;

vector<edge> G[mx];
double disTo[mx];
priority_queue<P, vector<P>, greater<P> > pq;

/*
使用:dj(起点)
输出:disTo[目标点]
复杂度:平均情况:O(ElogV),最坏情况:O(ElogV)
*/
void dj(int s)
{
	P p;
	int v, i;
	memset(disTo, 100, sizeof(disTo));
	disTo[s] = 0.0;
	while (!pq.empty()) pq.pop();
	pq.push(P(0.0, s));
	while (!pq.empty())
	{
		p = pq.top(), pq.pop();
		v = p.second; ///v视作e.from
		if (p.first > disTo[v]) continue;
		for (i = 0; i < G[v].size(); ++i)
		{
			e = G[v][i];
			if (disTo[e.to] > disTo[v] + e.cost) ///v视作e.from
			{
				disTo[e.to] = disTo[v] + e.cost;
				pq.push(P(disTo[e.to], e.to));
			}
		}
	}
}

int main()
{
	int n, m, i, a;
	while (~scanf("%d%d", &n, &m))
	{
		for (i = 0; i < n; ++i) G[i].clear();
		while (m--)
		{
			scanf("%d", &a);
			e.read();
			G[a].push_back(e);
		}
		dj(0);
		for (i = 1; i < n; ++i)
			printf("%d %.2f\n", i, disTo[i]);
		putchar(10);
	}
	return 0;
}

PS:O(V^2)复杂度的算法见http://blog.csdn.net/synapse7/article/details/18253329

PS2:对于有向无环图,有更简单且更快的算法,见http://blog.csdn.net/synapse7/article/details/19284933


另:若有负权重边,须使用Bellman-Ford算法(基于队列),但这一算法的局限性又在于图中不能存在负权重环

复杂度:平均情况:O(E+V),最坏情况:O(EV)

  • 1
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是C++实现Dijkstra算法的示例代码: ```c++ #include <iostream> #include <vector> #include <queue> #include <climits> using namespace std; #define INF INT_MAX // 定义无穷大 // 定义边的结构体 struct Edge { int to; // 边的终点 int cost; // 边的权值 }; // 定义图的结构体 struct Graph { int V; // 图的顶点数 vector<vector<Edge>> adj; // 邻接表 }; // Dijkstra算法 vector<int> dijkstra(const Graph& g, int s) { vector<int> dist(g.V, INF); // 存储起点到各点的最短距离 dist[s] = 0; // 起点到自己的距离为0 priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> que; // 存储已经确定最短路的节点 vector<bool> used(g.V, false); que.push(make_pair(0, s)); while (!que.empty()) { pair<int, int> p = que.top(); que.pop(); int v = p.second; if (used[v]) { continue; } used[v] = true; for (auto& e : g.adj[v]) { if (dist[e.to] > dist[v] + e.cost) { dist[e.to] = dist[v] + e.cost; que.push(make_pair(dist[e.to], e.to)); } } } return dist; } int main() { // 用邻接表表示下面这个图 // 1 // 7 / \3 // / \ // 0-----2 // 5\ /2 // \ / // 3 Graph g = { 4, vector<vector<Edge>>(4) }; g.adj[0].push_back(Edge{ 1, 7 }); g.adj[0].push_back(Edge{ 3, 5 }); g.adj[1].push_back(Edge{ 0, 7 }); g.adj[1].push_back(Edge{ 2, 3 }); g.adj[2].push_back(Edge{ 0, 3 }); g.adj[2].push_back(Edge{ 1, 3 }); g.adj[2].push_back(Edge{ 3, 2 }); g.adj[3].push_back(Edge{ 0, 5 }); g.adj[3].push_back(Edge{ 2, 2 }); vector<int> dist = dijkstra(g, 0); for (int i = 0; i < dist.size(); i++) { cout << "0 -> " << i << ": " << dist[i] << endl; } return 0; } ``` 注释已经很详细了,这里简单解释一下。首先定义了边的结构体和图的结构体,存储边和邻接表。然后是Dijkstra算法实现使用了优先队列来存储已经确定最短路的节点,每次取出队列中距离起点最近的点进行扩展,如果扩展后可以更新到达其它点的距离,则更新距离。最后返回起点到各点的最短距离。最后在main函数中构造了一个图来测试Dijkstra算法的正确性。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值