[迪杰斯特拉模板详解]模板(紫书模板+优先队列模板) 后续会更新一些简单模板题

对于初学图论算法的ACMer，第一个接触的算法应该就是迪杰斯特拉了，所以我先简单讲讲迪杰斯特拉算法，后文简写为dij。

dij适合于边权值为正的情况，可用于计算正权图上单源最短路，即求出一个点到其它所有结点的最短路。

先举一个简单列子：如图所示，现在要求求1到5的最短路径。

先说明两个变量：w[u][v]  表示从u到v的距离，  d[i] 表示从1到 i 这个点的距离。

我们先从1开始出发，从1走有三条路，分别是1—>2（10），1—>4（30），1—>5（100）。实际上现在已经存在一条从1到5的路径了，但他是不是最短的那条路，我们并不知道。所以我们先将这些边分别放入优先队列（每次优先选择最短的边出队），选择一条最短的边出队，也就是1—>2（10）这条边，出队操作相当于我们从1走到了2这个点。从2再走也只有一条路，2—>3（50）。这个时候我们就要开始dij的核心操作了。

边的松弛操作：从1到3本来是没有边直接相连，也就是1到3的距离w[1][3]我们默认为无穷远，但是我们发现有一条路径能从1走到2，再走到3，并且比它们原先的距离要小。然后我们就更新d[3],d[3] = d[2] + w[2][3] = 60;代码表示就是 

if(d[y] > d[x] + w[x][y])
 d[y] = d[x] + w[x][y];

现在再从1—>3（60），1—>4（30），1—>5（100）选一条最短边1—>4（30），从4走可以走到3和5，4—>3（20）的距离为20，进行一次判断    if(d[3] > d[4] + w[4][3])  发现成立 再进行一次松弛操作  d[3] = d[4] + w[4][3] = 50。4—>5（60）的距离为60，再继续之前的操作，将d[5]更新为90。这个时候剩下两条边1—>3（50），1—>5（90），从3继续走，3—>5（10），继续之前的操作最终更新到d[5]=60。

最终求得1到5的最短距离60，然后也更新了从1到各个点的最短距离。

从上面的步骤能看出，dij的算法核心就是不断的进行边的松弛操作。

优先队列模板：

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5;
int n, m, dis[N], vis[N], head[N], cnt_edge;
struct Edge {
    int to, val, next;
} edge[N * 2];
struct node {
	int val, pos;
	friend bool operator <(node a, node b) {//优先队列，边权值小的先出队 
		return a.val > b.val;
	}
};
/*或许大家会问为什么这里没有上面的松弛操作代码，其实一个队列可能会出现多条起点和终点都一样的边，
但是由于优先队列优先选择最短的边出队，这就相当于进行了松弛操作了 */ 
priority_queue<node> q;
void add_edge(int from, int to, int val) {
	edge[cnt_edge].to = to;
    edge[cnt_edge].val = val;
    edge[cnt_edge].next = head[from];
    head[from] = cnt_edge++;
}
void dij(int s) {
	q.push({0, s});
	while(!q.empty()) {
		struct node top = q.top();
		q.pop();
		if(vis[top.pos]) continue;
		vis[top.pos] = 1;
		for(int i = head[top.pos]; i != -1; i = edge[i].next) {
			int to_val = top.val + edge[i].val;
			int to_pos = edge[i].to;
			if(dis[to_pos] > to_val) {
				dis[to_pos] = to_val;
				q.push({to_val, to_pos});
			}
		}
	}
}
void init(int s) {//s为源点
	for(int i = 0; i <= n; ++i)  {
		if(i != s) dis[i] = INT_MAX;
	}
	while(!q.empty()) q.pop();
	memset(head, -1, sizeof head);
	memset(vis, 0, sizeof vis);
	cnt_edge = 0;
}
int main() {
	while(cin>>n>>m) {
		init(0);
		for(int i = 1; i <= m; ++i) {
			int from, to, val;
			cin>>from>>to>>val;
			add_edge(from, to, val);
		}
		dij(0);
		for(int i = 0; i < n; ++i) {
			cout << dis[i] << " ";
		}
		puts("");
	} 
} 

紫书模板

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
const int maxn = 1e5;
const int INF = INT_MAX/10;
using namespace std;
struct Edge{
	int from,to,dist;
};

struct HeapNode{
	int d,u;
	bool operator<(const HeapNode & rhs)const{
		return d > rhs.d;
	}
};

struct Dijkstra{
	int n,m;            //点数和边数 
	vector<Edge>edges;  //边列表 
	vector<int>G[maxn]; //每个结点出发的边编号（从0开始编号） 
	bool done[maxn];    //是否已永久编号 
	int d[maxn];        //s到各个点的距离 
	int p[maxn];        //最短路中上一条边 
	
	void init(int n){
		this->n=n;
		for(int i=0;i<n;i++)
		G[i].clear();   //清空邻接表 
		edges.clear();  //清空边表 
	}
	
	void AddEdge(int from,int to,int dist)  //如果是无向边 ，每条边需要调用两次AddEdge 
	{
		edges.push_back((Edge){from,to,dist});
		m = edges.size();
		G[from].push_back(m-1);
	}
	
	void dijkstra(int s){ //求s到所有点的距离 
		priority_queue<HeapNode>Q;
		for(int i=0;i<n;i++) d[i]=INF;
		d[s] = 0;
		memset(done,0,sizeof(done));
		Q.push((HeapNode){0,s});
		while(!Q.empty())
		{
			HeapNode x = Q.top();Q.pop();
			int u = x.u;
			if(done[u]) continue;
			done[u] = true;
			for(int i=0;i<G[u].size();i++)
			{
				Edge& e= edges[G[u][i]];
				if(d[e.to]>d[u]+e.dist){
				d[e.to] = d[u] + e.dist;
				p[e.to] = G[u][i];
				Q.push((HeapNode){d[e.to],e.to});
				}
			}
		}
	}
}solver;                      

int main()
{
	int n,m;
	while(scanf("%d%d",&n,&m)&&n&&m)
	{
		solver.init(n+1);
		for(int i=0;i<m;i++)
		{
			int u,v,x;
			scanf("%d%d%d",&u,&v,&x);
			solver.AddEdge(u,v,x);//如果是无向图要调用两次AddEdge 
			solver.AddEdge(v,u,x);
		}
		solver.dijkstra(1);
		printf("%d\n",solver.d[n]);
	}
}