单源最短路径----Dijkstra

dijkstra算法个人感觉挺怪异的，不过复杂度O(n2)，速度快，但是不能理解WSM很多人都推荐用FLOYD，可能是实现简单吧，但是FLOYD必须用邻接矩阵来实现。两者的功能上稍有不同，dijkstra算法对于输入的节点，能够找出该点到所有其他点的最短路径。
基本的算法思路是，把图中的点集分为2部分，一部分为访问过的点（即已经找到了输入点到该点的最短路径），另一部分为还没访问到的点。dijkstra算法的进行过程就是把第二类点归并到第一类点的过程。
如何归并，首先在第二类点中找到距输入点(v)距离最近的点(i)，把这个点归入第一类，然后开始更新其余第二类点到输入点的距离（即如果dist[i]+cost[i][j]<dist[j]，dist[j]=dist[i]+cost[i][j],cost为邻接矩阵中的权值，点j是更新的节点）。
可以看出，没归并更新一次，第一类点就曾加一个，第二类点就少一个，那么我们初始化时将第一类点集设为空，所有的点全在第二类点集中。只需经过NUMV次归并更新操作，即可找到从输入点到所有点的最短路径。

#include<iostream>
#include<string.h>
using namespace std;
const int numv=6;
const int maxm=100000;
int dist[numv];
int path[numv];
int s[numv];
int cost[numv][numv];
int init()
{
	for(int i=0;i<numv;i++)
	{
		path[i]=-1;
		s[i]=0;
	}
	for(int i=0;i<numv;i++)
	for(int j=0;j<numv;j++)
	cost[i][j]=maxm;
	//cost[0][0]=0;
	cost[0][2]=10;
	cost[0][4]=30;
	cost[0][5]=100;
	//cost[1][1]=0;
	cost[1][2]=10;
	//cost[2][2]=0;
	cost[2][3]=50;
	//cost[3][3]=0;
	cost[3][5]=10;
	//cost[4][4]=0;
	cost[4][3]=20;
	cost[4][5]=60;
	//cost[5][5]=0;
}
void getShotpath(int v)
{
	for(int i=0;i<numv;i++)
	{
		dist[i]=cost[v][i];
		s[i]=0;
		if(cost[v][i]<maxm)
		path[i]=v;
		else
		path[i]=-1;	
	}
	s[v]=1;
	dist[v]=0;
	for(int i=0;i<numv;i++)
	{
		int min=100000;
		int flag;
		for(int j=0;j<numv;j++)
		{
			if(!s[j]&&dist[j]<min)
			{
				min=dist[j];
				flag=j;
			}	
		}
		s[flag]=1;
		//cout<<min<<endl;
		for(int j=0;j<numv;j++)
		{
			if(!s[j]&&dist[flag]+cost[flag][j]<dist[j])
			{
				dist[j]=dist[flag]+cost[flag][j];
				path[j]=flag;
			}	
		}		
	}	
}
int main()
{
	int a,b;
	while(cin>>a>>b)
	{
		if(a==b)
		cout<<"input again"<<endl;
		if(a>5||b>5)
		cout<<"input again"<<endl;
		init();
		getShotpath(a);
		cout<<"shotpath="<<dist[b]<<endl;
		int k=b;
		int pout[maxm];
		int count=0;
		while(path[k]!=-1)
		{
			pout[count]=path[k];
			k=path[k];
			++count;
		}
		for(int i=count-1;i>=0;i--)
		cout<<pout[i]<<" ";
		cout<<b<<" ";

		cout<<endl;

	}	
}