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

试实现迪杰斯特拉最短路径算法。

函数接口定义：

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

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]=true;
    D[v0]=0;//初始化S，D数组
    for(i=0;i<n-1;i++)
    {
        min=MaxInt;
        for(j=0;j<n;++j)
        {
            if(D[j]<min&&!S[j])
            {
                v=j;
                min=D[j];//在未被访问的点中寻找权值最小的
            }
        }
        S[v]=true;
        for(j=0;j<n;++j)
        {
            if(!S[j]&&(D[j]>D[v]+G.arcs[v][j]))
            {
                D[j]=D[v]+G.arcs[v][j];//更新数组D
                Path[j]=v;
            }
        }
    }
}