DS图—图的最短路径（无框架）

题目描述

给出一个图的邻接矩阵，输入顶点v，用迪杰斯特拉算法求顶点v到其它顶点的最短路径。

输入

第一行输入t，表示有t个测试实例

第二行输入顶点数n和n个顶点信息

第三行起，每行输入邻接矩阵的一行，以此类推输入n行

第i个结点与其它结点如果相连则为距离，无连接则为0，数据之间用空格隔开。

第四行输入一个顶点v，表示求该顶点v到其他顶点的最短路径距离

以此类推输入下一个示例

输出

对每组测试数据，输出：

每行输出顶点v到某个顶点的最短距离和最短路径

每行格式：顶点v编号-其他顶点编号-最短路径值----[最短路径]。没有路径输出：顶点v编号-其他顶点编号--1。具体请参考示范数据

输入样例1

2
5 0 1 2 3 4
0 5 0 7 15
0 0 5 0 0
0 0 0 0 1
0 0 2 0 0
0 0 0 0 0
0
6 V0 V1 V2 V3 V4 V5
0 0 10 0 30 100
0 0 5 0 0 0
0 0 0 50 0 0
0 0 0 0 0 10
0 0 0 20 0 60
0 0 0 0 0 0
V0

输出样例1

0-1-5----[0 1 ]
0-2-9----[0 3 2 ]
0-3-7----[0 3 ]
0-4-10----[0 3 2 4 ]
V0-V1--1
V0-V2-10----[V0 V2 ]
V0-V3-50----[V0 V4 V3 ]
V0-V4-30----[V0 V4 ]
V0-V5-60----[V0 V4 V3 V5 ]

#include <iostream>
#include <string>
#include <sstream>
//#include <limits.h>
#include <algorithm>
using namespace std;
#define INT_MAX 99999//定义无限 

//顶点 
class node{
public:
	string data;
	int vexnum;//顶点个数
	int *mindis;//到其他顶点的最短距离;
	int *dis;//到其他顶点的直接距离
	bool *isvisited;//记录是否被访问过 
	string *path;//到其他顶点需要经过的顶点 
	
	node(){
		vexnum=0;
	}
	
	void setlink(int n){
		vexnum=n;
        //初始化邻接矩阵dis 
		dis = new int [vexnum];
        for (int i = 0; i < vexnum; i++){
			cin>>dis[i];
		}
		//初始化离顶点的距离，不连接为无限，连接为相应的dis 
		mindis=	new int [vexnum];
        for (int i = 0; i < vexnum; i++){
			if(dis[i]==0)
				mindis[i]=INT_MAX;
			else
				mindis[i]=dis[i];
		}
		
		//初始均为未访问 
		isvisited =new bool[vexnum];
        for (int i = 0; i < vexnum; i++){
			isvisited[i]=false;
		}
		
		//定义路径数组 
		path=new string[vexnum];

								
	}
	
	//返回最短路径的顶点编号 
	int find_closest_vex(){			
		int minindex=0;
		int minvalue=INT_MAX;
		for(int i = 0;i<vexnum;i++){
			if(!isvisited[i]){
				if(mindis[i]<minvalue){
					minvalue=mindis[i];
					minindex=i;
				}				
			}
		}
		return minindex;
	}
	
	void printpath(int n){
		//添加起始点 
		path[n]=data+" "+path[n];
		cout<<"["<<path[n]<<"]"<<endl; 
	} 
};


//图 
class Map{
public:
	int size; //图结点个数
	node * p;//顶点数组 
	
	Map(int n){
		size=n;
		p=new node[size];

		for(int i = 0;i<size;i++){
			cin>>p[i].data;
		}
		for(int i = 0;i<size;i++){
			p[i].setlink(size);
		}
		setpath();		
	}
	
	void setpath(){
		for(int i = 0;i<size;i++){
			for(int j = 0;j<size;j++){
				if(p[i].dis[j]>0){//如果顶点间有联系，更新该顶点路径 
					p[i].path[j]+=p[j].data+" ";
				}
			}
		}

	}
	
	void Dijkstra(string start){
		//begin是起始点编号，逐个对比data找出该编号 
		int begin=-1;
		for(int i = 0;i<size;i++){
			if(p[i].data==start){
				begin=i;
				break;
			}
		}
		p[begin].isvisited[begin]=true;
		int count=size;
		int index;//每轮距离最短且未被访问的点	
		for(int i = 0;i<size;i++){	
			index=p[begin].find_closest_vex();//找出距离起始点距离最近的点
			p[begin].isvisited[index]=true;//将该点设为已访问 
			for(int j = 0;j<size;j++){//遍历index点的mindis数组
				if(p[index].dis[j]>0){
					int temp_mindis=p[begin].mindis[j];//此时begin点到j点的最短距离 
					int temp_path=p[begin].mindis[index]+p[index].dis[j];//此时begin点到index点的距离+index点到j点的距离

					if(temp_path<temp_mindis){//如果该路径间的距离比mindis内存储的距离短 
						p[begin].mindis[j]=temp_path;//更新距离 
						p[begin].path[j]=p[begin].path[index]+p[index].path[j];//更新路径 
					}					
				} 
			}
		}
		print(begin);
	
	}
	
	void print(int begin){
		for(int i = 0;i<size;i++){
			if(i!=begin){
				if(p[begin].mindis[i]==INT_MAX){
					cout<<p[begin].data<<"-"<<p[i].data<<"-"<<"-1"<<endl;				
				}
				else{
					cout<<p[begin].data<<"-"<<p[i].data<<"-"<<p[begin].mindis[i]<<"----";
					p[begin].printpath(i);						
				}

			}
		}		
	}
};

int main(){
	int t;
	cin>>t;
	while(t--){
		int n;
		cin>>n;
		
		Map map(n);
		string start;
		cin>>start;
		map.Dijkstra(start);
	}


}