杭电1874————单源最短路径（dijkstra)

畅通工程续

Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 28395    Accepted Submission(s): 10289

Problem Description

某省自从实行了很多年的畅通工程计划后，终于修建了很多路。不过路多了也不好，每次要从一个城镇到另一个城镇时，都有许多种道路方案可以选择，而某些方案要比另一些方案行走的距离要短很多。这让行人很困扰。

现在，已知起点和终点，请你计算出要从起点到终点，最短需要行走多少距离。

 

Input

本题目包含多组数据，请处理到文件结束。
每组数据第一行包含两个正整数N和M(0<N<200,0<M<1000)，分别代表现有城镇的数目和已修建的道路的数目。城镇分别以0～N-1编号。
接下来是M行道路信息。每一行有三个整数A,B,X(0<=A,B<N,A!=B,0<X<10000),表示城镇A和城镇B之间有一条长度为X的双向道路。
再接下一行有两个整数S,T(0<=S,T<N)，分别代表起点和终点。

 

Output

对于每组数据，请在一行里输出最短需要行走的距离。如果不存在从S到T的路线，就输出-1.

 

Sample Input

3 3
0 1 1
0 2 3
1 2 1
0 2
3 1
0 1 1
1 2

 

Sample Output

2
-1

这个问题其实很简单，就是求单源最短路径的最基础的题目。这里用的是dijkstra的算法求解。
dijkstra的算法和最小生成树的prim算法如出一辙，思想基本上都是一样的（dijkstra还有贪心的思想在里边）
描述一下算法：
1.将所有的结点分成两个集合。一个集合A代表我们的解答树，另一个集合B代表没有进入解答树的结点。
（如果在集合A中那么intree[i] = 1 否则为0）
2.设定一个数组mindist[i]表示起始结点到i结点的最小距离.
3.将初始结点（也就是开始结点）加入到集合A(intree[start] = 1)中去并且mindist[i] = G[start][i]
到此为止的流程都和MST的prim算法一模一样
4.每次从B集合中找到一个节点，将其加入到A集合中，之后更新start到各个结点的mindist。（因为当这个加点加入到A集合当中后，start结点可以直接或者间接到达的结点更多了，所以mindist都需要更新）。这里就是一个贪心的思想：mindist[j] = min(mindist[j],mindist[minpos] + G[minpos][j])。其中minpos是刚刚加入到A集合的结点。
如果还有什么不太明白的地方可以看这个链接里边的图示+code ：http://blog.csdn.net/u013548531/article/details/38467183

下面说一下本题目的小陷阱：
1.从i城市到j城市的道路会有多条，所以必须在读取的时候稍作处理，只存最小距离的道路（因为这里WA两次）
2.当start == end 的时候要特判一下
3.唔...这是个无向图

杭电亲测15MS
<span style="font-family:Microsoft YaHei;font-size:14px;">#include <stdio.h>
#include <string.h>
#define cost_max  100000
#define min(A,B) ( (A) < (B) ? A : B)
#define maxn 105
int sum,intree[maxn];
int G[maxn][maxn];

void initialize_tree(int N)
{
	for(int i = 0 ; i < N ; i++)
		for(int j = 0 ; j < N ; j++)
			G[i][j] = cost_max;
	memset(intree,0,sizeof(intree));
}
int dijkstra(int s,int e,int N)
{
	int mindist[N];/*mindist[i]表示从初始节点到i结点的最小距离*/ 
	int tempdist,node;
	
	for(int i = 0 ; i < N ; i++)
		mindist[i] = G[s][i];
	intree[s] = 1;
	/*把初始结点s加入A集合*/
	for(int i = 0 ; i < N - 1 ; i++)/*从剩下的结点中依次选取*/ 
	{
		tempdist = cost_max;
		for(int j = 0 ; j < N ; j++)
		{
			if(mindist[j] < tempdist && !intree[j])
			{
				tempdist = mindist[j];
				node = j;
			}
		}
		/*选择最小代价边*/
		intree[node] = 1;
		for(int j = 0 ; j < N ; j++)
			if(!intree[j])
				mindist[j] = min(mindist[j],mindist[node] + G[node][j]);
	} 
	return mindist[e];
}
int main()
{
	int N,M;
	int vertex1,vertex2,weight,s,e;/*start and end*/
	while(scanf("%d%d",&N,&M) != EOF)
	{
		initialize_tree(N);
		for(int i = 0 ; i < M ; i++)
		{
			scanf("%d%d%d",&vertex1,&vertex2,&weight);
			if(G[vertex1][vertex2] > weight && G[vertex2][vertex1] > weight)
				G[vertex1][vertex2] = G[vertex2][vertex1] = weight;
		}
		scanf("%d%d",&s,&e);
		if(s == e)
			printf("%d\n",0);
		else
		{
			int ans = dijkstra(s,e,N);
			if(ans == cost_max)
				printf("-1\n");
			else
				printf("%d\n",ans);
		}	
	}
	return 0;
}</span>