Gym - 100338C Important Roads 最短路+tarjan

题意：给你一幅图，问有多少条路径使得去掉该条路后最短路发生变化。

思路：先起始两点求两遍单源最短路，利用s[u] + t[v] + G[u][v] = dis 找出所有最短路径，构造新图。在新图中找到所有的桥输出就可以了。

 #include <iostream>
 #include <cstdio>
 #include <fstream>
 #include <algorithm>
 #include <cmath>
 #include <deque>
 #include <vector>
 #include <queue>
 #include <string>
 #include <cstring>
 #include <map>
 #include <stack>
 #include <set>
 #define LL long long
 #define eps 1e-8
 #define INF 0x3f3f3f3f
 #define MAXN 20005
 #define MAXM 100005
 using namespace std;

 struct Edge
 {
     int from, to, dist, pos;
     Edge(int from, int to, int dist, int pos) :from(from), to(to), dist(dist), pos(pos){};
 };
 struct HeapNode
 {
     int d, u;
     HeapNode(int d, int u) :d(d), u(u){};
     bool operator <(const HeapNode& rhs) const{
         return d > rhs.d;
     }
 };
 struct Dijstra
 {
     int n, m;
     vector<Edge> edges;
     vector<int> G[MAXN];
     bool done[MAXN];
     int d[MAXN];
     int p[MAXN];

     void init(int n){
         this->n = n;
         for (int i = ; i <= n; i++){
             G[i].clear();
         }
         edges.clear();
     }

     void AddEdge(int from, int to, int dist, int pos = ){
         edges.push_back(Edge(from, to, dist, pos));
         m = edges.size();
         G[from].push_back(m - );
     }

     void dijstra(int s){
         priority_queue<HeapNode> Q;
         for (int i = ; i <= n; i++){
             d[i] = INF;
         }
         d[s] = ;
         memset(done, , sizeof(done));
         Q.push(HeapNode(, s));
         while (!Q.empty()){
             HeapNode x = Q.top();
             Q.pop();
             int u = x.u;
             if (done[u]) continue;
             done[u] = true;
             for (int i = ; i < G[u].size(); i++){
                 Edge& e = edges[G[u][i]];
                 if (d[e.to] > d[u] + e.dist){
                     d[e.to] = d[u] + e.dist;
                     p[e.to] = G[u][i];
                     Q.push(HeapNode(d[e.to], e.to));
                 }
                 else if (d[e.to] == d[u] + e.dist){

                 }
             }
         }
     }
 };
 int pre[MAXN], isbridge[MAXM], low[MAXN];
 vector<Edge> G[MAXN];
 int dfs_clock;
 int dfs(int u, int father){
     int lowu = pre[u] = ++dfs_clock;
     //int child = 0;
     for (int i = ; i < G[u].size(); i++){
         int v = G[u][i].to;
         if (!pre[v]){
             //child++;
             int lowv = dfs(v, G[u][i].pos);
             lowu = min(lowu, lowv);
             if (lowv > pre[u]){
                 isbridge[G[u][i].pos] = true;
             }
         }
         else if (pre[v] < pre[u] && G[u][i].pos != father){
             lowu = min(lowu, pre[v]);
         }
     }
     low[u] = lowu;
     return lowu;
 }
 Dijstra s, t;
 vector<Edge> edges;

 int res[MAXM];
 int main()
 {
 #ifdef ONLINE_JUDGE
     freopen("important.in", "r", stdin);
     freopen("important.out", "w", stdout);
 #endif // OPEN_FILE
     int n, m;
     while (~scanf("%d%d", &n, &m)){
         s.init(n);
         t.init(n);
         edges.clear();
         int x, y, z;
         for (int i = ; i <= m; i++){
             scanf("%d%d%d", &x, &y, &z);
             edges.push_back(Edge(x, y, z, i));
             edges.push_back(Edge(y, x, z, i));
             s.AddEdge(x, y, z);
             s.AddEdge(y, x, z);
             t.AddEdge(x, y, z);
             t.AddEdge(y, x, z);
         }
         s.dijstra();
         t.dijstra(n);
         LL dis = s.d[n];
         //把所有最短路径找出来，在里面找出所有的桥就是答案
         for (int i = ; i < edges.size(); i++){
             Edge e = edges[i];
             if (s.d[e.from] + e.dist + t.d[e.to] == dis){
                 G[e.from].push_back(Edge(e.from, e.to, e.dist, e.pos));
                 G[e.to].push_back(Edge(e.to, e.from, e.dist, e.pos));

             }
         }
         dfs_clock = ;
         memset(isbridge, , sizeof(isbridge));
         memset(pre, , sizeof(pre));
         dfs(, -);
         int ans = ;
         for (int i = ; i <= m; i++){
             if (isbridge[i]){
                 ans++;
                 res[ans] = i;
             }
         }
         printf("%d\n", ans);
         for (int i = ; i <= ans; i++){
             printf("%d ", res[i]);
         }
         printf("\n");
     }
 }