最短路算法总结（Dijkstra）

如何求任意两点之间的最短路径呢？在之前的学习里，知道可以通过深搜或者广搜求出两点之间的最短路径。但学习了Dijkstra这个新的算法以后，会更方便。

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

基本步骤：
1. 将所有顶点分为两部分：已知最短路程的顶点集合P和未知最短路径的顶点集合Q。最开始，已知最短路径的顶点集合P中只有源点一个顶点。我们这里用一个book数组来记录哪些顶点再集合P中。例如对于某个顶点i，如果book[i]为1则表示这个顶点再集合P中，如果book[i]为0则表示这个顶点再集合Q中。
2. 设置源点x到自己的最短路径为0即 dis[x]=0。若存在有源点能直接到达的顶点i，则把dis[i]设为g[x][i]。同时把所有其他（源点不能直接到达的）顶点的最短路径设为∞。
3. 在集合Q的所有顶点中选择一个离源点x最近的顶点u（即dis[u]最小）加入到集合P。并考察所有以点u为起点的边，对每一条边进行松弛操作。例如存在一条从u到v的边，那么可以通过将u->v添加到尾部来拓展一条从s到v的路径，这条路径的长度时dis[u]+g[u][v]。如果这个值比目前已知的dis[v]的值要小，我们可以用新值来替代当前dis[v]中的值。
4. 重复第3步，如果集合Q为空，算法结束。最终dis数组中的值就是源点到所有顶点的最短路径。

其实它的过程是很简单的，下面是代码的实现：

Floyd-Warshall：

#include
int main()
{
	int i,j,k,m,n,t1,t2,t3,e[10][10];
	int inf = 99999999;
	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;//双向e[t1][t2] = e[t2][t1] = t3;
	}
	//Floyd-Warshall核心语句 
	for(k = 1; k <= n; k ++)
		for(i = 1; i <= n; i ++)
			for(j = 1; j <= n; j ++)
				if(e[i][j] > e[i][k] + e[k][j])
					e[i][j] = e[i][k] + e[k][j];
	for(i = 1; i <= n; i ++)
	{
		for(j = 1; j <= n; j ++)
			printf("%d",e[i][j]);
		printf("\n");
	}
	return 0;
}

Dijkstra：

#include
int m,n,e[10][10],dis[10],book[10];
int inf = 99999999;
void Dijkstra(int x)
{
	int i,j,u,min;
	for(i = 1; i <= n; i ++)
	{
		dis[i] = e[x][i];
		book[i] = 0;
	}
	dis[x] = 0;
	book[x] = 1;
	for(i = 1; i < n; i ++)
	{
		min = inf;
		for(j = 1; j <= n; j ++)
			if(book[j] == 0 && dis[j] < min)
			{
				min = dis[j];
				u = j;
			}	
		book[u] = 1;
		for(j = 1; j <= n; j ++)
			if(book[j] == 0 && dis[j] > dis[u] + e[u][j])
				dis[j] = dis[u] + e[u][j];
	}
}
int main()
{
	int i,j,t1,t2,t3;
	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;//双向e[t1][t2] = e[t2][t1] = t3
	}
	Dijkstra(1);
	return 0; 
}

另外，还有一个负权边的情况,就是在给出的距离上会出现负的，此时就不能再用上面的代码来实现了，因为扩展到负权边的时候会产生更短的路程，有可能就破坏了已经更新的点路程不会改变的性质。

此时，用Bellman-Ford算法就能很好的解决了。

代码实现：

#include
int main()
{
	int i,j,k,m,n,count,flag;
	int dis[10],u[10],v[10],w[10];
	int inf = 99999999;
	scanf("%d%d",&n,&m);
	for(i = 1; i <= m; i ++)
		scanf("%d%d%d",&u[i],&v[i],&w[i]);
	for(i = 1; i <= n; i ++)
		dis[i] = inf;
	dis[1] = 0;
	//Bellman-Ford核心语句 
	for(k = 1; k < n; k ++)
	{
		count = 0;
		for(i = 1; i <= m; i ++)
			if(dis[v[i]] > dis[u[i]] + w[i])
			{
				dis[v[i]] = dis[u[i]] + w[i];
				count = 1;
			}
		if(count == 1)
			break;
	}
	flag = 0;
	for(i  =1; i <= m; i ++)
		if(dis[v[i]] > dis[u[i]] + w[i])
			flag = 1;
	if(flag == 1)
		printf("此图含有负权回路");
	return 0; 
}