Codeforces Gym 100338C Important Roads 最短路+Tarjan找桥

原题链接：http://codeforces.com/gym/100338/attachments/download/2136/20062007-winter-petrozavodsk-camp-andrew-stankevich-contest-22-asc-22-en.pdf

题意

给你一个无向图，要从1走到n，问你哪些边去掉之后就没法走原本的最短路了。

题解

跑两发最短路，顺着跑一发，倒着跑一发，对于边(u,v)，如果w(u,v)+d[u]+rd[v]或者w(u,v)+d[v]+rd[u]等于最短路，那么边(u,v)就是某条最短路上的边，将这些边标记好后，跑一发Tarjan找桥，这些桥就是答案。需要注意的是有重边。

代码

#include<iostream>
#include<queue>
#include<cstring>
#include<algorithm>
#include<vector>
#include<cstdio>
#include<set>
#define INF 21234567890
#define MAX_N 20004
#define MAX_M 112345
using namespace std;

typedef long long ll;

struct node {
public:
    int u;
    ll c;

    node(int uu, ll cc) : u(uu), c(cc) { }

    node() { }

    bool operator<(const node &a)const {
        return c > a.c;
    }
};

struct edge {
public:
    int to;
    ll cost;
    bool isShort;
    int id;
    edge(int t, ll c,int i) : to(t), cost(c), isShort(), id(i){ }

    edge() { }
};
priority_queue<node> que;
int n, m;

struct fuck {
public:
    int u, v, c, id;

    fuck(int uu, int vv, int cc, int i) : u(uu), v(vv), c(cc), id(i) { }

    fuck() { }
    bool operator<(const fuck &a)const{
        if(a.u==u){
            if(a.v==v)return a.c<c;
            else return a.v<v;
        }
        return a.u<u;
    }
};

set<fuck> se;

vector<edge> G[MAX_N];

void dijkstra(int s,ll d[]) {
    while (que.size())que.pop();
    fill(d, d + n + , INF);
    que.push(node(s, ));
    d[s] = ;
    while (que.size()) {
        node now = que.top();
        que.pop();
        int u = now.u;
        ll c = now.c;
        if (d[u] < c)continue;
        for (int i = ; i < G[u].size(); i++) {
            int v = G[u][i].to;
            if (d[v] > d[u] + G[u][i].cost) {
                d[v] = d[u] + G[u][i].cost;
                que.push(node(v, d[v]));
            }
        }
    }
}

ll d[MAX_N],rd[MAX_N];

int father[MAX_N];
int dfn[MAX_N],low[MAX_N],ind=;
bool vis[MAX_N];
int sum=;
bool isBridge[MAX_M];

bool hasSame[MAX_M];

void Tarjan(int u,int p) {
    father[u] = p;
    dfn[u] = low[u] = ++ind;
    vis[u] = ;
    for (int i = ; i < G[u].size(); i++) {
        int v = G[u][i].to;
        if (v == p||(!G[u][i].isShort))continue;
        if (!vis[v]) {
            Tarjan(v,u);
            low[u] = min(low[u], low[v]);
            if (low[v] > dfn[u]) {
                sum++;
                isBridge[G[u][i].id] = ;
            }
        }
        else
            low[u] = min(dfn[v], low[u]);
    }
}

bool ans[MAX_M];

int main() {
    freopen("important.in", "r", stdin);
    freopen("important.out", "w", stdout);
    scanf("%d%d", &n, &m);
    for (int i = ; i < m; i++) {
        int u, v;
        int c;
        scanf("%d%d%d", &u, &v, &c);
        fuck f(u,v,c,i);
        fuck f0(v,u,c,i);
        auto it=se.find(f);
        if(it!=se.end()){
            hasSame[it->id]=;
            continue;
        }
        it=se.find(f0);
        if(it!=se.end()){
            hasSame[it->id]=;
            continue;
        }
        se.insert(f);
        G[u].push_back(edge(v, c, i));
        G[v].push_back(edge(u, c, i));
    }

    dijkstra(, d);
    dijkstra(n, rd);
    ll sd = d[n];
    for (int i = ; i <= n; i++)
        for (int j = ; j < G[i].size(); j++) {
            int u = i, v = G[i][j].to;
            if (d[u] + rd[v] + G[i][j].cost == sd || d[v] + rd[u] + G[i][j].cost == sd)
                G[i][j].isShort = ;
        }
    Tarjan(,);
    int tot = ;
    for (int i = ; i <= n; i++)
        for (int j = ; j < G[i].size(); j++)
            if (isBridge[G[i][j].id])
                ans[G[i][j].id + ] = ;
    for (int i = ; i <= m; i++)if ((!hasSame[i-])&&ans[i])tot++;
    printf("%d\n", tot);
    for (int i = ; i <= m; i++)
        if (ans[i]&&(!hasSame[i-]))
            printf("%d ", i);
    printf("\n");
    return ;
}