PATA1030_图的遍历（难度：⭐️⭐️）

这个题难度在于有多个路径，需要DFS回溯判断最少花费。

---

#include<bits/stdc++.h>
using namespace std;
const int maxn = 520;
const int INF = 999999999;
int n, m, start, dst, c1, c2, d, cost, minCost = INF;
int G[maxn][maxn], dis[maxn], W[maxn][maxn];
vector<vector<int>> path;
vector<int> temppath, ans;
bool vis[maxn];
void Dijkstra(int s) {
    fill (vis, vis + maxn, false);
    fill (dis, dis + maxn, INF);
    dis[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 && dis[j] < MIN) {
                u = j;
                MIN = dis[j];
            }
        }
        if (u == -1) return;
        vis[u] = true;
        for (int v = 0; v < n; v++) {
            if (vis[v] == false && G[u][v] != INF) {
                if (dis[u] + G[u][v] < dis[v]) {
                    path[v].clear();
                    path[v].push_back(u);
                    dis[v] = dis[u] + G[u][v];
                }
                else if (dis[u] + G[u][v] == dis[v]) {
                    path[v].push_back(u);
                }
            }
        }
    }
}
void DFS (int s, int cost) {
    temppath.push_back(s);
    if (s == start && cost < minCost) {
        ans = temppath;
        minCost = cost;
        return;
    }
    for (int i = 0; i < path[s].size(); i++) {
        int now = path[s][i];
        DFS (now, cost + W[s][now]);
        temppath.pop_back();
    }
}
int main() {
    fill (G[0], G[0] + maxn * maxn, INF);
    fill (W[0], W[0] + maxn * maxn, INF);
    scanf ("%d %d %d %d", &n, &m, &start, &dst);
    path.resize(n);
    for (int i = 0; i < m; i++) {
        scanf ("%d %d %d %d", &c1, &c2, &d, &cost);
        G[c1][c2] = G[c2][c1] = d;
        W[c1][c2] = W[c2][c1] = cost;
    }
    Dijkstra(start);
    DFS(dst, 0);
    for (int i = ans.size() - 1; i >= 0; i--)
        printf ("%d ", ans[i]);
    printf ("%d %d", dis[dst], minCost);
}