问题 A: 算法7-15：迪杰斯特拉最短路径算法

题目描述
在带权有向图G中，给定一个源点v，求从v到G中的其余各顶点的最短路径问题，叫做单源点的最短路径问题。
在常用的单源点最短路径算法中，迪杰斯特拉算法是最为常用的一种，是一种按照路径长度递增的次序产生最短路径的算法。
可将迪杰斯特拉算法描述如下：

在本题中，读入一个有向图的带权邻接矩阵（即数组表示），建立有向图并按照以上描述中的算法求出源点至每一个其它顶点的最短路径长度。

输入
输入的第一行包含2个正整数n和s，表示图中共有n个顶点，且源点为s。其中n不超过50，s小于n。
以后的n行中每行有n个用空格隔开的整数。对于第i行的第j个整数，如果大于0，则表示第i个顶点有指向第j个顶点的有向边，且权值为对应的整数值；如果这个整数为0，则表示没有i指向j的有向边。当i和j相等的时候，保证对应的整数为0。

输出
只有一行，共有n-1个整数，表示源点至其它每一个顶点的最短路径长度。如果不存在从源点至相应顶点的路径，输出-1。
请注意行尾输出换行。

样例输入

4 1
0 3 0 1
0 0 4 0
2 0 0 0
0 0 1 0

样例输出

6 4 7 

提示
在本题中，需要按照题目描述中的算法完成迪杰斯特拉算法，并在计算最短路径的过程中将每个顶点是否可达记录下来，直到求出每个可达顶点的最短路径之后，算法才能够结束。
迪杰斯特拉算法的特点是按照路径长度递增的顺序，依次添加下一条长度最短的边，从而不断构造出相应顶点的最短路径。
另外需要注意的是，在本题中为了更方便的表示顶点间的不可达状态，可以使用一个十分大的值作为标记。

思路一：Dijkstra算法。

#include <cstdio>
#include <algorithm>
using namespace std;

const int MAXV = 110;
const int INF = 0x3fffffff;

int n, st, G[MAXV][MAXV];
int d[MAXV];
bool vis[MAXV] = {false};

void Dijkstra(int s) {
    fill(d, d + MAXV, INF);
    d[s] = 0;
    for (int i = 0; i < n; i++) {
        int u = -1, min = INF;
        for (int j = 0; j < n; j++) {
            if (vis[j] == false && d[j] < min) { //找到未访问结点中d[]最小的
                u = j;
                min = d[j];
            }
        }
        if (u == -1) return;
        vis[u] = true; //标记u为已访问
        for (int v = 0; v < n; v++) {
            //如果v未访问且u能到达v
            if (vis[v] == false && G[u][v] != 0) {
                if (d[u] + G[u][v] < d[v]) {
                    d[v] = d[u] + G[u][v];
                }
            }
        }
    }
}


int main() {
    fill(G[0], G[0] + MAXV * MAXV, 0);
    scanf("%d%d", &n, &st);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &G[i][j]);
        }
    }
    Dijkstra(st);
    for (int i = 0; i < n; i++) {
        if (i != st) {
            if (d[i] != INF) {
                printf("%d ", d[i]);
            } else {
                printf("-1 ");
            }
        }
    }
    printf("\n");
    return 0;
}

思路二：Bellman-Ford算法。

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXV = 110;
const int INF = 0x3fffffff;

struct Node {
    int v, dis;
    Node(int _v, int _dis) :
        //构造函数
        v(_v), dis(_dis){};
};
vector<Node> Adj[MAXV];
int n, st;
int d[MAXV];

bool Bellman(int s) {
    fill(d, d + MAXV, INF);
    d[s] = 0;
    for (int i = 0; i < n - 1; i++) {
        for (int u = 0; u < n; u++) {
            for (int j = 0; j < Adj[u].size(); j++) {
                int v = Adj[u][j].v;
                int dis = Adj[u][j].dis;
                if (d[u] + dis < d[v]) {
                    d[v] = d[u] + dis;
                }
            }
        }
    }
    for (int u = 0; u < n; u++) {
        for (int j = 0; j < Adj[u].size(); j++) {
            int v = Adj[u][j].v;
            int dis = Adj[u][j].dis;
            if (d[u] + dis < d[v]) {
                return false;
            }
        }
    }
    return true;
}

int main() {
    scanf("%d%d", &n, &st);
    int t;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &t);
            if (t != 0) {
                Adj[i].push_back(Node(j, t));
            }
        }
    }
    Bellman(st);
    for (int i = 0; i < n; i++) {
        if (i != st) {
            if (d[i] != INF) {
                printf("%d ", d[i]);
            } else {
                printf("-1 ");
            }
        }
    }
    printf("\n");
    return 0;
}