DS图—图的最短路径（待验证）

题解

1. Dijkstra算法按照路径长度递增的次序来产生到各个顶点的最短路径。
2. 这里需要记录哪些顶点是已经求的最短路径的，可以用一个数组S来实现。
3. 还需要一个dist数组来记录在已有S中顶点的状态下到各个顶点的最短路径，因此dist数组在每次顶点加入S后要更新，并且当所有顶点都加入S后dist中的值就是最终到各个顶点的最短路径了。
4. 顶点加入S的原则是每次都选V-S中dist值最小的顶点加入S，这样就实现了由最短求最短（路径长度递增）。
5. 此外还需要记录具体的路径，由于是由最短求最短的算法，所以可以不用记录到每个顶点完整的路径，只需要记录一个顶点的前驱顶点是谁就行了，其可以用一个path数组实现。

题目

问题 A: DS图—图的最短路径（不含代码框架）
时间限制: 1 Sec  内存限制: 128 MB
提交: 588  解决: 361
[提交][状态][讨论版]
题目描述
给出一个图的邻接矩阵，输入顶点v，用迪杰斯特拉算法求顶点v到其它顶点的最短路径。

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

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

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

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

隔开。第四行输入v0，表示求v0到其他顶点的最短路径距离

以此类推输入下一个示例

输出
对每组测试数据，输出：

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

每行格式：v0编号-其他顶点编号-最短路径值----[最短路径]。没有路径输出：v0编号-其他顶点编号--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
样例输出
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 <stack>
using namespace std;

class Graph
{
    int vexnum;
    string *vertex;
    int **matrix;
    int *S;
    int *dist;
    int *path;
    int IsOver();
    int Index(string vex);
    void DisplayPath(int i);//根据path数组输出从起始点到各个顶点的路径
public:
    Graph();
    ~Graph();
    void Dijkstra(string vex);
};

Graph::Graph()
{
    int i, j;
    cin>>vexnum;
    vertex = new string[vexnum];
    matrix = new int*[vexnum];
    S = new int[vexnum];
    dist = new int[vexnum];
    path = new int[vexnum];
    for(i=0; i<vexnum; i++)
    {
        matrix[i] = new int[vexnum];
        cin>>vertex[i];
        S[i] = 0;//初始S中没有顶点，全置为0
        dist[i] = 99999;//dist初始都为无穷
        path[i] = -1;//path初值都为-1，避免和下标0冲突
    }
    for(i=0; i<vexnum; i++)
        for(j=0; j<vexnum; j++)
            cin>>matrix[i][j];
}

Graph::~Graph()
{
    for(int i=0; i<vexnum; i++)
        delete []matrix[i];
    delete []vertex;
    delete []matrix;
    delete []S;
    delete []dist;
    delete []path;
}

int Graph::Index(string vex)
{
    for(int i=0; i<vexnum; i++)
        if(vertex[i]==vex)
            return i;
    return -1;
}

int Graph::IsOver()
{
    for(int i=0; i<vexnum; i++)
        if(S[i]==0 && dist[i]!=99999)//注意可能有孤立点的存在，而dist为无穷就代表当前阶段的孤立点，当dist数组中没加入S数组中的点都是孤立点时就也要结束循环！！！
            return 0;
    return 1;
}

void Graph::DisplayPath(int i)
{
    stack<int> s;
    s.push(i);
    while(path[i]!=-1)
    {
        i = path[i];
        s.push(i);
    }
    while(!s.empty())
    {
        i = s.top();
        s.pop();
        cout<<vertex[i]<<' ';
    }
}

void Graph::Dijkstra(string vex)
{
    int i, minweight, pos;
    int v = Index(vex);
    S[v] = 1;
    dist[v] = 0;
    for(i=0; i<vexnum; i++)
    {
        if(matrix[v][i])//正确代码
            dist[i] = matrix[v][i];
        //错误代码：dist[i] = matrix[v][i];  只有当邻接矩阵中用0代表主对角线且∞代表没有边时才可以直接用矩阵的v行给dist数组赋值。
        if(matrix[v][i])
            path[i] = v;
    }
    while(!IsOver())
    {
        minweight = 99999;
        for(i=0; i<vexnum; i++)
        {
            if(!S[i] && dist[i]<minweight)
            {
                minweight = dist[i];
                pos = i;
            }
        }
        S[pos] = 1;
        for(i=0; i<vexnum; i++)
        {
            if(matrix[pos][i] && !S[i] && (dist[pos]+matrix[pos][i])<dist[i])
            {
                dist[i] = dist[pos]+matrix[pos][i];
                path[i] = pos;
            }
        }
    }
    for(i=1; i<vexnum; i++)
    {
        if(dist[i]==99999)
            cout<<vex<<'-'<<vertex[i]<<"--1"<<endl;
        else
        {
            cout<<vex<<'-'<<vertex[i]<<'-'<<dist[i]<<"----[";
            DisplayPath(i);
            cout<<']'<<endl;
        }
    }
}

int main(void)
{
    int t;
    cin>>t;
    while(t--)
    {
        Graph myGraph;
        string vex;
        cin>>vex;
        myGraph.Dijkstra(vex);
    }
    return 0;
}