问题 D: 最短路径

题目描述
有n个城市m条道路（n<1000, m<10000)，每条道路有个长度，请找到从起点s到终点t的最短距离和经过的城市名。

输入
输入包含多组测试数据。

每组第一行输入四个数，分别为n，m，s，t。

接下来m行，每行三个数，分别为两个城市名和距离。

输出
每组输出占两行。

第一行输出起点到终点的最短距离。

第二行输出最短路径上经过的城市名，如果有多条最短路径，输出字典序最小的那条。若不存在从起点到终点的路径，则输出“can’t arrive”。

样例输入

3 3 1 3
1 3 3
1 2 1
2 3 1

样例输出

2
1 2 3

思路：Dijkstra+DFS。先用Djikstra记录所有最短路径，再遍历所有路径找到字典序最小的路径。使用邻接矩阵会出现问题，见1987 Problem D 最短路径，两点之间可能有多条边。

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

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

struct Node {
    int v, dis;
    Node(int _v, int _dis) :
        //构造函数
        v(_v), dis(_dis){};
};
int n, m, s, t, d[MAXV];
bool vis[MAXV] = {false};
vector<int> pre[MAXV], tempPath, path;
vector<Node> Adj[MAXV];

void Dijkstra(int s) {
    fill(d, d + MAXV, INF);
    memset(vis, false, sizeof(vis));
    d[s] = 0;
    for (int i = 1; i <= n; i++) {
        int u = -1, min = INF;
        for (int j = 1; 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 j = 0; j < Adj[u].size(); j++) {
            int v = Adj[u][j].v;
            if (vis[v] == false) {
                if (d[u] + Adj[u][j].dis < d[v]) {
                    d[v] = d[u] + Adj[u][j].dis;
                    pre[v].clear(); //清空pre[v]
                    pre[v].push_back(u); // u为v的前驱
                } else if (d[u] + Adj[u][j].dis == d[v]) { //找到一条相同长度的路径
                    pre[v].push_back(u); // u为v的前驱之一
                }
            }
        }
    }
}

//由于存储路径是逆序储存的，所以要倒着比较
bool compare(vector<int> a, vector<int> b) {
    int i = a.size() - 1, j = b.size() - 1;
    while (i >= 0 && j >= 0) {
        if (a[i] != b[j]) {
            return a[i] < b[j];
        }
        i--, j--;
    }
    return a.size() < b.size();
}

void DFS(int v) {
    if (v == s) { //如果到达了叶子结点st（即路径的起点）
        tempPath.push_back(v);
        if (path.size() == 0) {
            path = tempPath;
        } else if (compare(tempPath, path)) {
            path = tempPath;
        }
        tempPath.pop_back();
        return;
    }
    tempPath.push_back(v);
    for (int i = 0; i < pre[v].size(); i++) {
        DFS(pre[v][i]); //结点v的前驱结点pre[v][i]，递归
    }
    tempPath.pop_back();
}

int main() {
    int u, v, dis;
    while (scanf("%d%d%d%d", &n, &m, &s, &t) != EOF) {
        for (int i = 1; i <= n; i++) {
            Adj[i].clear();
        }
        for (int i = 0; i < m; i++) {
            scanf("%d%d%d", &u, &v, &dis);
            Adj[u].push_back(Node(v, dis));
            Adj[v].push_back(Node(u, dis));
        }
        Dijkstra(s);
        if (d[t] == INF) {
            printf("can't arrive\n");
        } else {
            printf("%d\n", d[t]);
            tempPath.clear();
            path.clear();
            DFS(t);
            for (int i = path.size() - 1; i >= 0; i--) {
                printf("%d ", path[i]);
            }
            printf("\n");
        }
    }
    return 0;
}