算法分析 - 单源最短路径（贪心算法）

【问题描述】Dijkstra算法解决的是带权重的有向图上单源最短路径问题。所有边的权重都为非负值。设置顶点集合S并不断地作贪心选择来扩充这个集合。使用最小堆数据结构构造优先队列。第1个顶点为源。
【输入形式】在屏幕上输入顶点个数和连接顶点间的边的权矩阵。
【输出形式】从源到各个顶点的最短距离及路径。
【样例输入】
5
0 10 0 30 100
0 0 50 0 0
0 0 0 0 10
0 0 20 0 60
0 0 0 0 0
【样例输出】
10: 1->2
50: 1->4->3
30: 1->4
60: 1->4->3->5
【样例说明】
输入：顶点个数为5。连接顶点间边的权矩阵大小为5行5列，位置[i,j]上元素值表示第i个顶点到第j个顶点的距离，0表示两个顶点间没有边连接。
输出：每行表示源1到其余各顶点的最短距离及路径，冒号后有一空格。如果源1到该顶点没有路，则输出：“inf: 1->u”，其中u为该顶点编号。
【评分标准】根据输入得到准确的输出。

#include <iostream>
#include <cstdio>
#include <queue>
#include <stack>

using namespace std;

struct Edge{
    int u = 0,v = 0,w = 0;
    friend bool operator < (Edge a, Edge b) {
        return a.w > b.w;
    }
};

const int maxn = 1005;
const int INF = 0x3f3f3f3f;

int n = 0, cnt = 0;
int mp[maxn][maxn] = {0};
int dis[maxn] = {0};
int bac[maxn] = {0};
bool vis[maxn] = {0};

void BackTrace() {
    stack<int> sta;
    for(int i = 2; i <= n; ++i) {
        while(!sta.empty()) sta.pop();
        int t = i;
        while(bac[t] != t) {
            sta.push(t);
            t = bac[t];
        }
        cout << dis[i] << ": 1";
        while(!sta.empty()) {cout << "->" << sta.top(); sta.pop();}
        cout << endl; 
    }
}

int main() {
    cin >> n;
    for(int i = 1; i <= n; ++i) {
        for(int j = 1; j <= n; ++j) {
            cin >> mp[i][j];
            if(mp[i][j] == 0) mp[i][j] = INF; 
        }
    }
    priority_queue<Edge> q;
    vis[1] = 1; bac[1] = 1;
    for(int i = 2; i <= n; ++i) {
        dis[i] = mp[1][i];
        q.push({1,i,mp[1][i]});
    }
    while(!q.empty()) {
        Edge et = q.top(); q.pop();
        if(vis[et.v]) continue;
        vis[et.v] = 1; cnt++;
        if(cnt == n-1) break;
        int u_ = et.v;
        for(int v_ = 2; v_ <= n; ++v_)
            if(!vis[v_] && mp[u_][v_] + dis[u_] < dis[v_]) {
                dis[v_] = mp[u_][v_] + dis[u_];
                bac[v_] = u_;
                q.push({u_, v_, mp[u_][v_] + dis[u_]});
            }
    }
    BackTrace();
    return 0;
}