基于Dijsktra算法的最短路径求解

 

描述

 

一张地图包括n个城市，假设城市间有m条路径（有向图），每条路径的长度已知。给定地图的一个起点城市和终点城市，利用Dijsktra算法求出起点到终点之间的最短路径。

 

输入

多组数据，每组数据有m+3行。第一行为两个整数n和m，分别代表城市个数n和路径条数m。第二行有n个字符，代表每个城市的名字。第三行到第m+2行每行有两个字符a和b和一个整数d，代表从城市a到城市b有一条距离为d的路。最后一行为两个字符，代表待求最短路径的城市起点和终点。当n和m都等于0时，输入结束。

输出

每组数据输出两行。第一行为一个整数，为从起点到终点之间最短路的长度。第二行为一串字符串，代表该路径。每两个字符之间用空格隔开。

输入样例 1 

3 3
A B C
A B 1
B C 1
A C 3
A C
6 8
A B C D E F
A F 100
A E 30
A C 10
B C 5
C D 50
E D 20
E F 60
D F 10
A F
0 0

输出样例 1

2
A B C
60
A E D F

#include <iostream>
#include <cstring>
#define MVNum 100
#define MaxInt 999
using namespace std;

typedef struct
{
	char vexs[MVNum];//点集 
	int arcs[MVNum][MVNum];//边的邻接矩阵 
	int vexnum,arcnum;//点数&边数 
}AMGraph;

int LocateVex(AMGraph G,char u)
 {//存在则返回u在顶点表中的下标;否则返回-1
   int i;
   for(i=0;i<G.vexnum;++i)
     if(u==G.vexs[i])
       return i;
   return -1;
 }

void InitAM(AMGraph &G)
{//初始化图 
 	memset(G.vexs,0,sizeof(G.vexs));//初始化顶点集 
	for(int i=0;i<MVNum;i++)
		for(int j=0;j<MVNum;j++)
			G.arcs[i][j]=MaxInt;
	return;
}

int CreateUDN(AMGraph &G)
{
	int i,j,k;  
	//G.vexnum++;
	for(i=0;i<G.vexnum;i++)
		cin>>G.vexs[i];
	for(k=0;k<G.arcnum;k++)//将边录入邻接矩阵，顺便将顶点录入 
	{
		char v1,v2;int w;
		cin>>v1>>v2>>w;//边的端点
		i=LocateVex(G,v1);
		j=LocateVex(G,v2);
		G.arcs[i][j]=w;
		G.arcs[j][i]=G.arcs[i][j];
		G.arcs[i][j]=w;
		G.arcs[k][k]=0;
	}
	return 1;
}

void ShortestPath_DIJ(AMGraph G){ 
    //用Dijkstra算法求有向网G的v0顶点到其余顶点的最短路径 
    char v0,v1;
    int S[MVNum];
    int D[MVNum];
    int Path[MVNum];
    cin>>v0>>v1;
    int v00=LocateVex(G,v0);
    int n=G.vexnum; int v;                  		//n为G中顶点的个数 
    for( v = 0; v<n; ++v){             	//n个顶点依次初始化 
       S[v] = false;                  	//S初始为空集 
       D[v] = G.arcs[v00][v];           	//将v0到各个终点的最短路径长度初始化 
       if(D[v]< MaxInt)  Path [v]=v00; //v0和v之间有弧，将v的前驱置为v0 
       else Path [v]=-1;               	//如果v0和v之间无弧，则将v的前驱置为-1 
      }//for 
      S[v00]=true;                    	//将v0加入S 
      D[v00]=0;     
	  int w;  int i;               		//源点到源点的距离为0 	
/*―开始主循环，每次求得v0到某个顶点v的最短路径，将v加到S集―*/ 
      for(i=1;i<n; ++i){               	//对其余n?1个顶点，依次进行计算 
        int min= MaxInt;  
        for(w=0;w<n; ++w) 
          if(!S[w]&&D[w]<min)  
              {v=w; min=D[w];}         	//选择一条当前的最短路径，终点为v 
        S[v]=true;                   		//将v加入S 
        for(w=0;w<n; ++w) 	//更新从v0出发到集合V?S上所有顶点的最短路径长度 
        if(!S[w]&&(D[v]+G.arcs[v][w]<D[w])){ 
             D[w]=D[v]+G.arcs[v][w];   	//更新D[w] 
             Path [w]=v;              		//更改w的前驱为v 
        }//if 
    }//for   
	w=LocateVex(G,v1);
	cout<<D[w]<<endl; 
	char road[G.vexnum];
	road[0]=G.vexs[w];
	int t=w;i=0;
	while(1)
	{  
		i++;
		if(t==-1||t==v00)break;
		//cout<<G.vexs[Path[t]];//<<"#"<<Path[t]<<"#"<<Path[Path[t]]
		road[i]=G.vexs[Path[t]];
		//if(t!=-1||t!=v00)cout<<" ";
		t=Path[t];	
	}
	while(i)
	{
		if(road[i])cout<<road[i]<<" ";
		i--;
	} 
	cout<<road[0];
	cout<<endl;
}//ShortestPath_DIJ 

void CA(AMGraph &G)
{//输出矩阵 
	int i;int j;
	//输出表头 
	cout<<0<<" ";
	for(int i=0,j;i<G.vexnum;i++)
	{
			cout<<G.vexs[i];
			if(i!=G.vexnum-1)cout<<" ";
	}
	cout<<endl;
	for(i=0;i<G.vexnum;i++)
	{
		//输出表头 
		cout<<G.vexs[i];
		if(i!=G.vexnum)cout<<" ";
		//输出内容 
		for(j=0;j<G.vexnum;j++)
		{
			cout<<G.arcs[i][j];
			if(j!=G.vexnum-1)cout<<" "; 
		}
		cout<<endl;
	}
 } 

int main()
{	
	while(1)
	{
		AMGraph G;
		InitAM(G);
		cin>>G.vexnum>>G.arcnum;
		if(G.vexnum==0&&G.arcnum==0)break;
		CreateUDN(G);
		//CA(G);
		ShortestPath_DIJ(G);
		//cout<<"--------------"<<endl;
	}
}