西北工业大学数据结构noj4-2

question

完整代码

// 用迪杰斯塔拉算法求赋权图中的最短路径
#include <iostream>
#include <vector>
#include <stack>
#define INF 10000 // 无穷大，表示两结点之间无边

struct Graph
{
    std::vector<int> vertex;
    std::vector<std::vector<int>> arcs;
    int vexnum = 0, arcnum = 0;
};

void CreateGraph(Graph &G);

std::vector<int> DijkstraPath(Graph G, int start);

int main()
{
    Graph G;

    CreateGraph(G);

    std::vector<int> result;
    int start, end;
    std::cin >> start >> end;
    result = DijkstraPath(G, start);

    std::stack<int> S;
    int path = end;
    while (path != start) // 需要输出起始结点到目标结点的最短路径，所以需要逆序输出
    {
        S.push(result[path]);
        path = result[path];
    }

    // std::cout << start << std::endl;
    while (!S.empty())
    {
        std::cout << S.top() << std::endl;
        S.pop();
    }

    std::cout << end << std::endl;
    // for (auto i = 0; i < G.vexnum; ++i)
    // {
    //     std::cout << result[i] << std::endl;
    // }

    system("pause");
    return 0;
}

void CreateGraph(Graph &G)
{
    int n;
    std::cin >> n;
    G.vexnum = n;
    G.arcs.resize(n, std::vector<int>(n, 0));

    for (auto i = 0; i < G.vexnum; ++i)
    {
        for (auto j = 0; j < G.vexnum; ++j)
        {
            std::cin >> n;
            G.arcs[i][j] = n;
        }
    }
}

std::vector<int> DijkstraPath(Graph G, int start)
{
    int n = G.vexnum;
    std::vector<int> dist(n, 0);      // 存取当前最短路径长度
    std::vector<bool> flag(n, false); // 表示结点是否被访问
    std::vector<int> path(n, start);  // 存储起始结点到对应下标结点最短路径的上一个结点
    flag[start] = true;

    for (auto i = 0; i < n; ++i)
        dist[i] = G.arcs[start][i];

    for (auto i = 0; i < n; ++i)
    {
        int min_dist = INF;
        int middle = 0;
        for (auto j = 0; j < n; ++j)
        {
            if (!flag[j] && min_dist > dist[j])
            {
                middle = j, min_dist = dist[j];
            }
        }

        for (auto j = 0; j < n; ++j)
        {
            if (!flag[j] && dist[j] > dist[middle] + G.arcs[middle][j])
                dist[j] = dist[middle] + G.arcs[middle][j], path[j] = middle;
        }
        flag[middle] = true;
    }
    return path;
}

// 6
// 0 1 4 10000 10000 10000
// 1 0 2 4 5 10000
// 4 2 0 10000 1 10000
// 10000 4 10000 0 5 2
// 10000 5 1 5 0 8
// 10000 10000 10000 2 8 0
// 1 4
// 1
// 2
// 4