Dijkstra算法堆/优先队列优化

前文：Dijkstra算法&&邻接表数组

前言

​ 1、本文中所采用的存储结构依然是邻接表数组，只是较上一篇文章中的结构稍微发生了一些变化，但本质是一样的，若不懂可参考前文；

​ 2、本文将涉及到堆/优先队列、STL库、运算符重载等额外知识，若不了解可百度或google，文中只会提及其使用而不会深入介绍；

​ 3、代码仍将采用C++实现，较前文含有更多的C++特有内容，需先了解这些操作才能看懂本文的代码；

​ 4、若对本文存在疑问、意见或建议，欢迎评论及与我本人联系。

额外知识简介

堆与优先队列

​ 首先，队列是一种数据结构，堆也是一种数据结构。普通的队列我们可以通过顺序表，链表的方式来实现。同样，优先队列我们通常使用堆这种数据结构来实现。因为优先队列中的元素具有优先级，每次出队的是优先级最高的元素，而堆恰好拥有这种特性——所有父节点的优先级均高于子节点。因此我们可以通过堆这种手段来实现优先队列。在这个层面上来说，Dijkstra算法的优先队列优化就是堆优化，即在Dijkstra算法运行的过程中维护一个优先队列。

STL库

​ STL库是C++的独有内容，这个库中存放了大量的数据结构模板，如vector、queue、stack、map等等，通过对STL库的调用，不仅可以提高代码的可读性和简洁性，也大大减小了出错的可能性(前提是要正确使用)，实乃一大捷径。/滑稽

重载

​ 重载也是C++的独有内容，重载可以使一些符号和函数拥有多种功能，前提是参数类型和数量不能完全相同，与他们的返回值和函数内容无关。举个栗子，假如我们在一个程序中定义了一个函数plus，那么plus(int a,int b)与 plus(int a,int b, int c)和plus(int a,long long b)这三个函数是可以同时存在的，但plus(int a,int b)与 plus(int c,int d)是不能同时存在的，因为编译器无法区分这两个函数，你调用函数的时候系统就晕了，不知道该调用哪个，因此这样是不合法的重载，无法通过编译。

Dijkstra分析及优化

分析优化

​ 通过前文，我们已经详细了解了Dijkstra算法的运行过程，相信聪明的小伙伴们已经在其中发现了问题。这里我就直接切入正题。已知Dijkstra算法每次在集合B中寻找能够加入集合A的顶点的时候，都要将符合条件的边进行遍历，即前文中的如下循环

min=inf;//记录当前情况下长度最小的路径
for (j=1;j<=n;j++)
{
	if (!book[j]&&dis[j]<min)
	{
		min=dis[j];
		p=j;//记录最短路径的终点/弧头
	}
}
book[p]=true;//将最短路径的终点/弧头加入集合

​ 当边较多的时候，该循环会带来较大的时间复杂度。那么有没有什么办法对它进行优化呢？当然是有啦！可不可以直接得到那条最短的边呢？当然是可以啦！在这里我们可以维护一个优先队列，队列中存放的是点(额外定义的一种数据类型)，该点离顶点距离越小优先级越高。这样每次取队首元素，就可以得到当前状态下距离起点距离最短的点，并让其出队。若该点已在集合A中，则继续出队，否则将其加入集合A，并以该点为中介点进行松弛操作。(若此点i不在集合A中，则dis[i]表示起点到点i的距离或起点到点i经过松弛之后的距离，若点i不在集合A中且其位于队首位置，那么它到集合A中某点的距离一定是最小的，这样便可保证我们取队首元素就能取到算法中描述的“最短边”)如此一来便可以大大减小算法的时间复杂度。

代码实现

存储结构

边

struct Edge//定义边的结构体
{
	int to;//弧头
	int value;//权值
	int next;//“链域”
	Edge(int a=0,int b=inf,int c=0):to(a),value(b),next(c) {}//重载构造函数
    //即当定义一个Edge类型的变量时，立即初始化为a,b,c的默认值0,inf,0(此处inf值为0x3f3f3f3f)
}e[M2];

点

typedef struct Point//定义顶点的结构体类型
{
	int num;//顶点编号
	int dist;//起点到该顶点的距离
	Point(int a=0,int b=0):num(a),dist(b) {}//重载构造函数，含义同上
	inline bool operator < (const Point& b) const//重载<
	{
		return dist>b.dist;
	}//若顶点a的dist值大于顶点b的dist值，则a的优先级低于b
}Point;

优先队列

priority_queue <Point> q;

函数

初始化

void init()
{
	cnt=0;
	memset(head,-1,sizeof(head));
	return;
}

添加边

inline void add(int a,int b,int c)
{
	e[cnt].to=b;
	e[cnt].value=c;
	e[cnt].next=head[a];
	head[a]=cnt++;
	return;
}

Dijkstra

void dijkstra(int st)//st为起点
{
	int i;
	Point p;
	for (i=1;i<=n;++i)
		dis[i]=inf;//初始化起点到各点距离
	dis[st]=0;
	p.num=st;//起点编号
	p.dist=0;//起点与自己距离为0
	q.push(p);//将起点加入优先队列
	while (!q.empty())
	{
		int cur=q.top().num;//本次循环中距离最短的边的终点编号
		q.pop();//出队
		if (vis[cur])
			continue;//若此点已确定最短距离则跳过此点并进行下一次循环
		vis[cur]=1;//本次循环将确定该点的最短距离
		for (i=head[cur];i!=-1;i=e[i].next)
		{
			int to=e[i].to;//本次循环中的目标点
			if (dis[to]>e[i].value+dis[cur]&&!vis[to])
			{
				dis[to]=dis[cur]+e[i].value;//松弛
				p.num=to;
				p.dist=dis[to];
				q.push(p);//将到起点距离变短的点加入队列
			}
		}
	}
	for (i=1;i<=n;i++)
		cout<<dis[i]<<" "<<endl;//输出起点到各顶点的最短距离
	return;
}

主函数

int main()
{
	ios::sync_with_stdio(false);
	int i,x,y,z;

	cin>>n>>m;//n个点m条边
	init();

	for (i=0;i<m;i++)
	{
		cin>>x>>y>>z;
		add(x,y,z);
		add(y,x,z);
	}
	dijkstra(1);//以1为起点

	return 0;
}

可采取如下数据验证

6 9
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 

后记

此种方式优化后，虽然大大节省了时间开销，但是使用了优先队列，导致内存开销增大，当边数很多的时候，可能会爆内存。在此基础上依然可以进行优化，利用配对堆等方式缩小内存开销。