6-2 最短路径（迪杰斯特拉算法）

6-2 最短路径（迪杰斯特拉算法） (15 分)
试实现迪杰斯特拉最短路径算法。

函数接口定义：

void ShortestPath_DIJ(AMGraph G, int v0);

其中 G 是基于邻接矩阵存储表示的有向图， v0表示源点

裁判测试程序样例：

#include <iostream>
using namespace std;

#define MaxInt 32767
#define MVNum 100 
typedef char VerTexType;
typedef int ArcType;

int *D=new int[MVNum];
bool *S=new bool[MVNum];
int *Path=new int[MVNum];

typedef struct{ 
    VerTexType vexs[MVNum]; 
    ArcType arcs[MVNum][MVNum]; 
    int vexnum,arcnum;
}AMGraph;

void CreateUDN(AMGraph &G){ 
    int i , j , k;
    cin >> G.vexnum >> G.arcnum;

    for(i = 0; i < G.vexnum; ++i){   
        cin >> G.vexs[i];       
    }

    for(i = 0; i < G.vexnum; ++i)            
        for(j = 0; j < G.vexnum; ++j)   
            G.arcs[i][j] = MaxInt;  

    for(k = 0; k < G.arcnum;++k){                            
        VerTexType v1 , v2;
        ArcType 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];                         
    }
}

void ShortestPath_DIJ(AMGraph G, int v0);

void DisplayPath(AMGraph G , int begin ,int temp ){
    if(Path[temp] != -1){
        DisplayPath(G , begin ,Path[temp]);
        cout << G.vexs[Path[temp]] << "->";
    }
}

int main()
{
    AMGraph G; 
    int i , j ,num_start , num_destination;
    VerTexType start , destination;
    CreateUDN(G);
    cin >> start >> destination;
    num_start = LocateVex(G , start);
    num_destination = LocateVex(G , destination);
    ShortestPath_DIJ(G , num_start);
    DisplayPath(G , num_start , num_destination);
    cout << G.vexs[num_destination]<<endl;
    return 0;
}
/* 请在这里填写答案 */

输入样例：
第1行输入结点数vexnum和边数arcnum。第2行输入vexnum个字符表示结点的值，接下来依次输入arcnum行，每行输入3个值，前两个字符表示结点，后一个数表示两个结点之间边的权值。最后一行输入源点及终点。

6 8
012345
0 5 100
0 2 10
0 4 30
1 2 5
2 3 50
3 5 10
4 3 20
4 5 60
0 5
结尾无空行
输出样例：
输出源点到终点的最短路径。

0->4->3->5
结尾无空行

C++（g++）

void ShortestPath_DIJ(AMGraph G, int v0)
{
	int v, i, j, min;
	int n = G.vexnum;
	for (v = 0; v < n; v++)
	{
		S[v] = false;
		D[v] = G.arcs[v0][v];
		if (D[v] < MaxInt)Path[v] = v0;
		else Path[v] = -1;
	}

	S[v0] = 1;
	D[v0] = 0;
	for (i = 1; i < n; i++)
	{
		min = MaxInt;
		for (j = 0; j < n; ++j)
		{
			if ( D[j] < min && !S[j])
			{
				v = j;
				min = D[j];
			}
		}

		S[v] = 1;
		for (j = 0; j < n; ++j)
		{
			if (!S[j] && (D[v] + G.arcs[v][j] < D[j]))
			{
				D[j] = D[v] + G.arcs[v][j]; //更新D[j] 
				Path[j] = v;
			}
		}
	}
}