最短路径之Dijkstra算法

最短路径之Dijkstra算法（单源最短路径）

//求1号顶点到其余各个顶点的最短路径 
//但是注意，此方法不能解决带有“负权”的图 

算法思想： 每次找到离源点最近的一个顶点，然后以该顶点为中心进行扩展，最终得到源点到其余所有点的最短路径。基本步骤如下：

1 将所有顶点分为两部分：已知最短路程的顶点集合P和未知最短路径的顶点集合Q。最开始，已知最短路径的顶点集合P中只有源点一个顶点。这里用一个book数组来记录哪些点在集合P中。例如对于某个顶点i，若book[i]=1表示这个点在集合P中，book[i]=0表示这个点在在集合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数组中的值就是源点到所有顶点的最短路径。

#include<stdio.h>
int main() {
	int e[10][10],dis[10],book[10],k,i,j,n,m,t1,t2,t3,u,v,min;
	int inf=99999999; //正无穷定义为99999999 （int可以存储最大整数是2147483647） 
	scanf("%d %d",&n,&m);
	//初始化 
	for(i=1;i<=n;i++) 
		for(j=1;j<=n;j++)
			if(i==j)	e[i][j]=0;
			else e[i][j]=inf;
	//读入边		
	for(i=1;i<=m;i++) {
		scanf("%d %d %d",&t1,&t2,&t3);
		e[t1][t2]=t3; 
	} 
	
	//初始化dis数组，这里是1号顶点到其余各个顶点的初始路程 
	for(i=1;i<=n;i++)
		dis[i]=e[1][i]; 
	
	//book数组初始化
	for(i=1;i<=n;i++)
		book[i]=0;
	book[1]=1;
	
	//Dijikstra算法核心语句
	for(i=1;i<=n-1;i++) {
		//找到离1号顶点最近的顶点 
		min=inf;
		for(j=1;j<=n;j++) {
			if(book[j]==0 && dis[j]<min) {
				min=dis[j];
				u=j;
			} 
		} 
		book[u]=1;
		for(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(i=1;i<=n;i++) 
		printf("%10d",dis[i]);
	getchar(); 
	getchar(); 
	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、

算法时间复杂度是O(N*N)，其中每次找到离1号顶点最近的顶点的时间复杂度是O(N), 此处可以用堆来优化，使得这一部分的时间复杂度降低到O(logN).另外对于边数M少于N*N的稀疏图来说，可以用邻接表来代替邻接矩阵，使得整个时间复杂度优化到O(N+M)logN、 注意：最坏情况下M就是N*N，这样的话(M+N)logN要比N*N还要大。但是大多数情况下并不会有那么多边，因此（M+N）logN要比N*N小很多。

//用邻接表来存储这个图 
int n,m,i;
int u[6],v[6],w[6];//u、v、w的数组大小要根据实际情况来设置，要比m的最大值要大1 
int first[5],next[5];//first、next数组大小要根据实际情况来设置，要比n的最大值要大1 
scanf("%d %d",&n,&m);
for(i=1;i<=n;i++) //初始化first数组下标1~n的值为-·，表示1~n顶点暂时都没有边 
	first[i]=-1;

for(i=1;i<=m;i++) {
	scanf("%d %d %d",&u[i],&v[i],&w[i]);
	next[i]=first[u[i]];
	first[u[i]]=i;
}

此处用数组来实现邻接表，而没有真正使用指针链表，而是用了一种在实际应用中非常容易实现的方法。为每个顶点i（i从1~n）都设置一个链表，保存了从顶点i出发的所有边。用u、v、w三个数组来记录每条边的信息，即u[i]、v[i]、w[i]表示第i条边是从第u[i]顶点到第v[i]顶点，且权值为w[i]。 first数组的1~n号单元格分别用来存储1~n号顶点的第一条边的编号，初始的时候因为没有边加入所以都是-1。即first[u[i]]保存顶点u[i]的第一条边的编号，next[i]存储“编号为i的边”的“下一条边”的编号。

如何遍历每一条边呢？first数组存储的就是每个顶点i（i从1~n）的第一条边。
  在找到1号顶点的第一条边之后，剩下的边都可以在next数组中依次找到。

k=first[1];
while(k!=-1) {
	printf("%d %d %d\n",u[k],v[k],w[k]);
	k=next[k];
}

此时遍历某个顶点的边的时候的遍历顺序正好与读入时候的顺序相反。因为在为每个顶点插入边的时候都是直接插入“链表”的首部而不是尾部。不过这并不会产生任何问题，这正是这种方法的奇妙之处。遍历某个顶点的边，其代码如下：

for(i=1;i<=n;i++) {
	k=first[1];
	while(k!=-1) {
		printf("%d %d %d\n",u[k],v[k],w[k]);
		k=next[k];
	} 
}

使用邻接表存储图的时间复杂度是O(M),遍历每一条边的时间复杂度也是O(M).