p515.cpp
======================
#include <bits/stdc++.h>

using namespace std;

template<typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& x) {
    return out << x.first << ' ' << x.second;
}

template<typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& x) {
    return in >> x.first >> x.second;
}

template<typename T>
istream& operator>>(istream& in, vector<T>& a) {
    for(auto& x: a) {
        in >> x;
    }
    return in;
};

template<typename T>
ostream& operator<<(ostream& out, const vector<T>& a) {
    for(auto x: a) {
        out << x << ' ';
    }
    return out;
};

int n, m, k;
vector<tuple<int, int, int>> edges;
vector<vector<pair<int, int>>> adj;
vector<int> important;

void read() {
    cin >> n >> m;
    edges.resize(m);
    adj.assign(n, {});
    for(int i = 0; i < m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        u--, v--;
        adj[u].push_back({v, i});
        adj[v].push_back({u, i});
        edges[i] = {u, v, w};
    }

    cin >> k;
    important.resize(k);
    cin >> important;
    for(int &v: important) {
        v--;
    }
}

vector<int> dijkstra(int src) {
    vector<int> dist(n, 1e9);
    dist[src] = 0;
    priority_queue<
        pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>
        pq;
    pq.push({0, src});
    while(!pq.empty()) {
        auto [d, u] = pq.top();
        pq.pop();
        if(dist[u] < d) {
            continue;
        }
        for(auto [v, i]: adj[u]) {
            auto [_, __, w] = edges[i];
            if(dist[v] > dist[u] + w) {
                dist[v] = dist[u] + w;
                pq.push({dist[v], v});
            }
        }
    }
    return dist;
}

vector<vector<pair<int, int>>> build_shortest_path_dag(const vector<int>& dist
) {
    vector<vector<pair<int, int>>> dag(n);
    for(int u = 0; u < n; u++) {
        for(auto [v, i]: adj[u]) {
            auto [_, __, w] = edges[i];
            if(dist[v] == dist[u] + w) {
                dag[u].push_back({v, i});
            }
        }
    }
    return dag;
}

int get_furthest(const vector<int>& dist) {
    int endpoint = important[0];
    for(int v: important) {
        if(dist[v] > dist[endpoint]) {
            endpoint = v;
        }
    }
    return endpoint;
}

void solve() {
    vector<int> dist = dijkstra(important[0]);
    int endpoint = get_furthest(dist);

    dist = dijkstra(endpoint);
    vector<int> dp(n, -1);
    vector<bool> visited(n, false);
    for(int v: important) {
        visited[v] = true;
    }

    vector<vector<pair<int, int>>> dag = build_shortest_path_dag(dist);
    function<int(int)> dfs = [&](int u) {
        if(dp[u] != -1) {
            return dp[u];
        }
        dp[u] = visited[u];
        for(auto [v, i]: dag[u]) {
            dp[u] = max(dp[u], dfs(v) + visited[u]);
        }
        return dp[u];
    };

    int other_endpoint = get_furthest(dist);
    int start = endpoint;
    
    vector<int> ans;
    while(start != other_endpoint) {
        for(auto [v, i]: dag[start]) {
            if(dfs(start) == dfs(v) + visited[start]) {
                ans.push_back(i + 1);
                start = v;
                break;
            }
        }
    }

    cout << ans.size() << '\n';
    cout << ans << '\n';
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int T = 1;
    // cin >> T;
    for(int test = 1; test <= T; test++) {
        read();
        // cout << "Case #" << test << ": ";
        solve();
    }

    return 0;
}

=================
statement.txt
======================
515. Recover path
Time limit per test: 0.75 second(s)
Memory limit: 262144 kilobytes
input: standard
output: standard

Traveller Gregory is famous for his ability to always choose the shortest path for his journey. Ostap is a journalist who seeks for information about the recent Gregory's trip. He managed to get the evidence that during this trip Gregory visited a number of cities. However, there is no information about the order in which they were visited, and no information about the starting city and the ending city of Gregory's trip (the entire trip is (one of) the shortest path between these cities). Help Ostap to find any shortest path that contains all specified cities.

Country in which Gregory traveled consists of n cities and m undirected roads between them. For each road Ostap knows the time it takes to travel it, and the "shortest" word above is with respect to those times.

It is guaranteed that there exists some shortest path going through all specified cities.

Input
First line contains two integers n, m (1 ≤ n, m ≤ 105). Each of the m following lines contains a description of a single road ai, bi, ti (ai ≠ bi, 1 ≤ ai, bi ≤ n, 1 ≤ ti ≤ 104) means Gregory can go between ai and bi by road and that will take ti seconds. The next line contains k — the number of cities that Ostap knows Gregory has visited. The last line contains a list of these cities. All cities in that list are distinct.

Output
On the first line output the number of roads in the sought shortest path. On the second line output the list of road numbers (numbered in the order of appearing in the input) in the order of that shortest path. If there are many solutions, output any.

Example(s)
sample input
sample output
6 6
1 2 2
2 6 2
1 3 1
3 4 1
4 5 1
5 6 1
3
5 1 3
3
3 4 5

sample input
sample output
6 6
1 2 2
2 6 2
1 3 1
3 4 1
4 5 1
5 6 1
2
1 6
2
1 2

=================
