Dijkstra算法-单源最短路+堆优化

用于求某一个点到所有点的最短路径

算法思想：

每次找到离源点最近的一个顶点，然后以该顶点为中心向下扩展，最终得到源点到其余所有点的最短路径。

说明：dis[]数组储存离源点的所有点的最短路径，比如源点是1，dis[2]=3,表示顶点2离源点的最短路径为2

执行步骤：
1.将所有点的顶点分为两部分：已知最短路径集合p和未知最短路径的集合Q。最开始，已知最短路径的顶点集合P只有源点一个顶点。我们这里用一个book数组来记录哪些点在集合P中。例如当对于某个顶点i，如果book[i]为true则表示这个顶点在集合P中，如果book[i]为false则表示在集合Q中。

2.设置源点S到自己的最短路径为0即dis[s]=0;若存在源点能直接到达顶点i,则把dis[i]设为e[s][i].同时把其他其他所有（源点不能直接到达的）顶点的最短路径设为无穷大

3.在集合Q的所有顶点中选择一个离源点s最近的顶点u(即dis[u]最小)加入到集合p.并考察所有以点U为起点的边，对每一条边进行松弛操作。例如存在一条从u到v的边，那么可以通过将边u→v添加到尾部来拓展一条从s到v的路径，这条路径的长度是dis[u]+e[u][v].如果这个值比目前已知的dis[v]的值最小，我们可以用新值来替代当前dis[v]中的值

4.重复第三步，如果集合Q为空，算法结束。最终dis数组中的值就是源点到所有顶点的最短路径

接下来我们结合代码说明：

输入我们采用邻接矩阵：
用e[][]数组来储存图

	scanf("%d %d",&n,&m,&cnt);//n个顶点，m条边，cnt表示源点
	for(int i=1;i<=n;i++){//初始化邻接矩阵 
		for(int j=1;j<=n;j++){
			if(i==j){
				e[i][j]=0;
			}else{
				e[i][j]=inf;
			}
		}
	}
    int t1,t2,t3;                  
	for(int i=1;i<=m;i++){//读入边 
		scanf("%d %d %d",&t1,&t2,&t3);
		e[t1][t2]=t3;
	} 

初始化dis[]数组（也就是步骤2）：

for(int i=1;i<=n;i++){//初始化dis 
		dis[i]=e[cnt][i];
	} 

初始化book[]数组：
这里我开到了全局变量，所以所有值默认为false（还未求出最短路径）
我们只需要将源点的book[]赋值为true即可，表示源点已求出最短路径

	book[cnt]=true;//初始化book[]数组

核心算法：

//Dijkstra算法核心
    //实现找出离源点最近的点
	for(int i=1;i<=n-1;i++){//最后一个顶点不需要求
		min=inf;//min表示离源点最近的点的距离
		for(int j=1;j<=n;j++){//遍历每一个点找出离源点最近的点
			if(!book[j]&&dis[j]<min){//没有访问过，且路径更短我们就记录下下标，并且将min的值更新
				u=j;
				min=dis[j];
			}
		}
		book[u]=true;//已经找出来离远点最近的点，将此点设为访问过
		//以下实现松弛操作
		for(int v=1;v<=n;v++){//遍历离源点最近的点附近的点
			if(e[u][v]<inf){
				if(dis[v]>dis[u]+e[u][v]){//进行松弛
					dis[v]=dis[u]+e[u][v];
				}
			}
		}
	}

完整代码：

/*
测试数据 ：第一行n,m,cnt,接下来是m条边 
6 9 1
1 2 1
1 3 12
2 3 9
2 4 3
3 5 5
4 3 4
4 5 13
4 6 15
5 6 4
*/
#include<cstdio>
int e[10][10];//邻接矩阵存放图
int dis[10];//用来记录所有点离原点的最短路径
bool book[10];//记录点有没有被访问过 
int n,m,min,inf=99999999,cnt;
int main(){
	scanf("%d %d %d",&n,&m,&cnt);
	for(int i=1;i<=n;i++){//初始化邻接矩阵 
		for(int j=1;j<=n;j++){
			if(i==j){
				e[i][j]=0;
			}else{
				e[i][j]=inf;
			}
		}
	}
    int t1,t2,t3;                  
	for(int i=1;i<=m;i++){//读入边 
		scanf("%d %d %d",&t1,&t2,&t3);
		e[t1][t2]=t3;
	} 
	for(int i=1;i<=n;i++){//初始化dis 
		dis[i]=e[cnt][i];
	} 
	/*for( i=1;i<=n;i++){
		for( j=1;j<=n;j++){
			printf("%10d",e[i][j]);
		}printf("\n");
	}*/

	book[cnt]=true;//初始化book[]数组
	int min,u;
	//Dijkstra算法核心
	for(int i=1;i<=n-1;i++){
		min=inf;
		for(int j=1;j<=n;j++){
			if(!book[j]&&dis[j]<min){
				u=j;
				min=dis[j];
			}
		}
		book[u]=true;
		for(int v=1;v<=n;v++){
			if(e[u][v]<inf){
				if(dis[v]>dis[u]+e[u][v]){
					dis[v]=dis[u]+e[u][v];
				}
			}
		}
	}
	for(int i=1;i<=n;i++){
	  printf("%d ",dis[i]);
	}

	return 0;
} 

该算法大量的时间花在前期寻找最近的点这一步，其实可以直接使用小顶堆进行优化

/*
测试数据 
6 9 1
1 2 1
1 3 12
2 3 9
2 4 3
3 5 5
4 3 4
4 5 13
4 6 15
5 6 4
0 1 8 4 13 17
*/ 
#include<cstdio>
#include<iostream>
#include<queue>
#include<vector>
using namespace std;
const int INF = 2147483647;
int n,m,start,dis[10005],vis[10005];
struct node{
	int v,w;
	node(int vv,int ww){
		v=vv;
		w=ww;
	}
};
vector<node> ve[10005];//邻接表存图 
priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int> > > que;//小顶堆 
int main(){
	//输入 
	cin>>n>>m>>start;
	for(int i=0;i<m;i++){
		int x,y,z;
		cin>>x>>y>>z;
		ve[x].push_back(node(y,z));//建立邻接表 
	}
	//初始化dis
	for(int i=1;i<=n;i++){
		dis[i]=INF;
	} 
	dis[start]=0;
	//初始化队列
	que.push(make_pair(0,start));
	//dijkstra算法 
	while(!que.empty()){
		int u = que.top().second;
		que.pop();
		if(vis[u])continue;//这个点松弛过 
		vis[u]=true;
		for(int i=0;i<ve[u].size();i++){//寻找和u相邻的点 
			int v = ve[u][i].v;
			int w = ve[u][i].w;//距离 
			if(dis[v]>dis[u]+w){//判断是否可以松弛 
				dis[v]=dis[u]+w;//松弛 
				que.push(make_pair(dis[v],v));//入队 
			}
		}
		
	} 
	for(int i=1;i<=n;i++){
		printf("%d ",dis[i]);
	}
	return 0;
}