本文链接：https://blog.csdn.net/Mashiro_ylb/article/details/78287724

Dijkstra迪杰斯特拉+堆优化

众所周知，朴素的迪杰斯特拉的时间复杂度为O(n^2)，这在某些题目当中是会超时的。但如果在迪杰斯特拉中枚举每个最短边时加入堆优化，则迪杰斯特拉的效率则会大大提高。

朴素版迪杰斯特拉

void dijkstra(int x)  //x为起点，使用迪杰斯特拉查找起点到其他任意点的最短路径
{for(int i = 1; i <= n; i++) dis[i] = w[x][i];  //dis[i]数组存储从x到i的最短路（迪杰斯特拉跑完之前不一定是最终解）//w[i][j]数组存储从i到j的路径长度（这里用的邻接矩阵存储，也可以换成前向星等）b[x] = 1; //b[i]数组存储此点是否被访问过dis[x] = 0;for(int i = 1; i <= n - 1; i++){minl = maxx;k = 0;for(int j = 1; j <= n; j++)  //查找可以更新的点if((!b[j]) && (dis[j] < minl)){minl = dis[j];k = j;}if(k == 0) break;  //这一句也可以换成if(k == y) break;表示已经更新完从x到y的最短路b[k] = true;  //更新k点，把k标记为已确定最短路径for(int j = 1; j <= n; j++)  //更新与k相连的每个未确定最短路径的顶点jif(dis[k] + w[k][j] < dis[j])dis[j] = dis[k] + w[k][j]; //可以加上pre[j] = k用来记录前驱节点}
}

加入堆优化

笔者在oj上找到了几个较好的不同类型的模板，大家可以灵活选择记忆理解。

题目

题目描述

如题，给出一个有向图，请输出从某一点出发到所有点的最短路径长度。

输入输出格式

输入格式：
第一行包含三个整数N、M、S，分别表示点的个数、有向边的个数、出发点的编号。

接下来M行每行包含三个整数Fi、Gi、Wi，分别表示第i条有向边的出发点、目标点和长度。

输出格式：
一行，包含N个用空格分隔的整数，其中第i个整数表示从点S出发到点i的最短路径长度（若S=i则最短路径长度为0，若从点S无法到达点i，则最短路径长度为2147483647）
输入输出样例
输入样例#1：

4 6 1
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4

输出样例#1：

0 2 4 3

版本一（邻接矩阵存图）

#include<vector>
#include<map>
#include<queue>
#include<algorithm>
#include<set>
#include<iostream>
#include<cstdio>
#include<list>
#include<string>
#include<cmath>
#include<cstring>
#include<stack>
using namespace std;
struct ha//小根堆
{int x; int d;//节点编号 bool operator < (const ha &a) const {return x > a.x;}
};
struct haha//小根堆
{int x; int d;//节点编号
};
ha e;
haha ee;
int d[1000010];
priority_queue <ha> q;
int n, m, s, xx, yy, zz, i;
vector<haha> a[1000000];
int main()
{scanf("%d%d%d",&n ,&m ,&s);for(i = 1; i <= m; i++){scanf("%d%d%d",&xx ,&yy ,&zz);ee.d = yy;ee.x = zz;a[xx].push_back(ee);}for(i = 1; i <= n; i++) d[i] = 2000003647;e.d = s;e.x = 0; d[s] = 0;q.push(e);//入队 while (!q.empty())//队列非空 {e = q.top(); q.pop();//出队int v = e.d;//取出节点编号int d1 = e.x;if (d[v] < d1) continue;//说明在这个点再此之后又入队了//此次出队的并不是s到这个点的最短路，//所以在这次更新前点v所连的点已经更过一次了 //所以后面也不会进行松弛操作 int len = a[v].size(); for(i = 0; i < len; i++){haha g = a[v][i];if ((d[v] + g.x < d[g.d]) || (d[g.d] == -233))//松弛操作 {d[g.d] = d[v] + g.x;e.d = g.d;e.x = d[g.d];q.push(e);}}}for (i=1; i <= n; i++) //输出 if (d[i] == 2000003647) cout << 2147483647 << " "; else cout << d[i] << " ";return 0;
}

版本二（前向星存图）

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
const int INF = 2147483647;
const int maxn = 10000 + 10;
const int maxm = 500000 + 10;
int n, m, s;
int fir[maxn], nxt[maxm], to[maxm], val[maxm], cnt;
void add_edge(int u, int v, int w) //前向星加边
{nxt[++cnt] = fir[u];fir[u] = cnt;to[cnt] = v;val[cnt] = w;
}
struct Node
{int d, id;Node(){}Node(int d, int id) : d(d), id(id){}bool operator < (const Node& rhs) const{return d > rhs.d;//重载 < 方便堆}
};
int dis[maxn], vis[maxn];
void Dijkstra(int s)
{for(int i = 1; i <= n; i++) dis[i] = INF;dis[s]=0;priority_queue<Node> Q;Q.push(Node(0,s));while(!Q.empty()) {Node u = Q.top(); Q.pop();if(vis[u.id]) continue;  //若某个点已经被更新到最优,就不用再次更新其他点vis[u.id] = 1;for(int e = fir[u.id]; e; e = nxt[e]) {int v = to[e], w = val[e];if(u.d + w < dis[v]) {dis[v] = u.d + w;Q.push(Node(dis[v],v));}}}
}
int main()
{scanf("%d%d%d",&n ,&m ,&s);for(int u, v, w, i=0; i < m; i++){scanf("%d%d%d",&u ,&v ,&w);add_edge(u, v, w);}Dijkstra(s);for(int i = 1; i <= n; i++) printf("%d ", dis[i]);return 0;
}

版本三（运用pair存储）

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<utility>
#include<vector>
#include<queue>
#define MAXN 20000
#define INF 2147483647
using namespace std;
typedef pair<int,int> pii;
priority_queue<pii, vector<pii>, greater<pii> > pq;
struct edge
{int to;int cost;
};
vector<edge> G[MAXN];//g[i]--i to g[i].to cost cost
int n, m, s;
int dis[MAXN];
void dijk(int s)
{for(int i = 1; i <= n; i++)dis[i] = INF;dis[s] = 0;pq.push(make_pair(0,s));// cout<<dis[s]<<endl;while(!pq.empty()){pii u = pq.top();pq.pop();int x = u.second; // bian hao//cout<<x<<endl;for(int i = 0; i < G[x].size(); i++){edge e = G[x][i];if(dis[e.to] > dis[x] + e.cost){dis[e.to] = dis[x] + e.cost;pq.push(make_pair(dis[e.to], e.to));// cout<<dis[e.to]<<endl;}}}
}
int main()
{cin >> n >> m >> s;int from, to, cost;edge in;for(int i = 0; i < m; i++){scanf("%d%d%d",&from ,&to ,&cost);in.to = to; in.cost = cost;G[from].push_back(in);}// cout<<endl;dijk(s);for(int i = 1; i <= n; i++)printf("%d ", dis[i]);return 0;
}

* Dijkstra 堆优化相关推荐

dijkstra堆优化(multiset实现-大大减小代码量)
例题: Time Limit: 1 second Memory Limit: 128 MB [问题描述] 在电视时代,没有多少人观看戏剧表演.Malidinesia古董喜剧演员意识到这一事实,他们想宣 ...
A - Age of Moyu HDU - 6386（Dijkstra+堆优化）
要解决这道题,可以用dfs+bfs,但是我不会,所以我只会dijkstra算法: 要解决这道题必须明白迪杰斯特拉算法的核心思想,我是这样理解的: 我可以任意举例一个图: 比如这个图,那么求1-6的最短 ...
poj1511 InvitationCards 最短路 Dijkstra堆优化
第一反应想到和 poj3268做法一样,先是从起点dj,然后将图反向,再次dj一次,求和即可.但是,数据O(n*n)过不去,所以需要使用dijkstra的堆优化! 淦,没用scanf结果超时了= = ...
寒假集训最短路（I - Heavy Transportation）dijkstra+堆优化
今天的集训学习了最短路dijkstra的堆优化,把时间复杂度从朴素版的O()降至了O(n*logn+m). 首先,先上一段朴素版的代码. void dijkstra() {dist[1] = 0;fo ...
dijkstra+堆优化
分析: 可知Dijkstra算法的复杂度是O(n*n) Dijkstra算法在寻找集合T中距离最小的顶点W(即寻找dist数组中最小值)复杂度是O(n),在更新距离操作时复杂度为O(n). 上述操作需 ...
HDU-6290 奢侈的旅行 2018女赛 Dijkstra堆优化
又因为cost=log2∗((level+ai)/level)cost=log2*((level+a_i)/level)cost=log2∗((level+ai)/level),cost会带着log ...
* poj 3159 Candies 最短路 dijkstra堆优化
题意: n个人,m个信息,每行的信息是3个数字,A,B,C,表示B比A多出来的糖果不超过C个,问你,n号人最多比1号人多几个糖果 Input: 输入包含单个测试用例.测试用例以两个整数n和m开头,分别 ...
HDU ACM 3986 Harry Potter and the Final Battle(邻接表实现最短路dijkstra堆优化记录路径 + 枚举最短路上每条边)...
http://acm.hdu.edu.cn/showproblem.php?pid=3986 题意: 从起点1 到终点n,删除图中任意一条边求最短路的最坏情况. n --表示有n个点 m --边数 ...
dijkstra算法及其堆优化
dijkstra算法及其堆优化 (个人笔记写给自己看的) 数据结构:链式前向星,优先队列 dijkstra算法: vis数组初始化为0,dis数组初始化为inf(很大的值如:0x7fffffff),设 ...

* Dijkstra 堆优化