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相连的每个未确定最短路径的顶点j
if(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;
}
