JZOJ3941 GDOI2015模拟11.23 重要道路

题面

给定一个无向图 G，对于其中的一条边(u,v)，将它删除之后会使得从 1 到 n 的最短路长度增加，那么这条边被称为“重要道路”。
求 G 中所有的重要道路。

输入

第一行两个整数 n,m，分别代表点数和边数。
接下来 m 行，每行三个整数 u,v,c，代表权值为 c 的无向边(u,v)。可能有重 边，但没有自环。保证 1 号点和 n 号点是连通的。
20%的数据，n,m<=10。
另外 20%的数据，m=n-1。
100%的数据，1<=n<=20000，1<=m,c<=100000。

输出

第一行一个整数 k，代表重要道路的数量。
下一行升序输出 k 个数代表重要道路的编号（按输入顺序从 1 到 m）

样例输入：

6 7
1 2 1
2 3 1
2 5 3
1 3 2
3 5 1
2 4 1
5 6 2

样例输出：

2
5 7

题解：

既然是最短路的题目，那么首先肯定要求出所有的最短路，我们要看的是1-n的最短路径上的点，其他点肯定对答案不影响，所以把最短路径全部从终点反向搜出来建个新图，然后看什么时候最短路会增加。。考虑新图，当新图不联通的时候，原图就不存在一条最短路是原来最短路的长度了，则最短路长度增加，所以只要在最短路图上求桥就OK了，复杂度$O(N log N + N)$ (注意，恶心的出题人卡SPFA，要Dij+heap)

代码：

# include<cstdio>
# include<algorithm>
# include<cstring>
# include<queue>
using namespace std;
const int N = 1e5 + 10;
const int M = 2e5 + 10;
struct edge
{
    int to,nex,val,pos;
}e[M << 1],e1[M << 1];
struct node
{
    int num,dis;
    bool operator < (node b) const
    {
        return dis > b.dis;
    }
};
int dfn[N],low[N],col[N],dis[N],st[N],st1[N];
bool vis[N];
int tot,cnt,n,m;
int read()
{
    int x = 0,f = 1; char ch = getchar();
    while (ch < '0' || ch > '9') { if (ch == '-') f = -f; ch = getchar(); }
    while (ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
    return x * f;
}
void add1(int u,int v,int w,int g)
{
    e[++tot].to = v,e[tot].nex = st[u],e[tot].val = w,e[tot].pos = g,st[u] = tot;
    e[++tot].to = u,e[tot].nex = st[v],e[tot].val = w,e[tot].pos = g,st[v] = tot;
}
void add2(int u,int v,int w)
{
    e1[++tot].to = v,e1[tot].nex = st1[u],e1[tot].pos = w,st1[u] = tot;
    e1[++tot].to = u,e1[tot].nex = st1[v],e1[tot].pos = w,st1[v] = tot;
}
inline void dij()
{
    priority_queue <node> q;
    memset(dis,0x3f,sizeof(dis));
    dis[1] = 0,q.push((node){1,0});
    while (!q.empty())
    {
        node x = q.top(); q.pop();
        if (vis[x.num]) continue;
        vis[x.num] = 1;
        for (int i = st[x.num]; i ;i = e[i].nex)
        {
            int v = e[i].to;
            if (dis[v] > dis[x.num] + e[i].val)
            {
                dis[v] = dis[x.num] + e[i].val;
                q.push((node){v,dis[v]});
            }
        }
    }
    memset(vis,0,sizeof(vis));
}
void dfs(int x)
{
    vis[x] = 1;
    for (int i = st[x]; i ; i = e[i].nex)
    {
        int v = e[i].to;
        if (dis[x] != dis[v] + e[i].val) continue;
        add2(v,x,e[i].pos);
        if (!vis[v]) dfs(v);
    }
}
void getcut(int x,int fa)
{
    low[x] = dfn[x] = ++cnt;
    for (int i = st1[x]; i ;i = e1[i].nex)
    {
        int v = e1[i].to;
        if (!dfn[v])
        {
            if (e1[i].pos == fa) continue;
            getcut(v,e1[i].pos);
            low[x] = min(low[x],low[v]);
            if (low[v] > dfn[x])
                col[e1[i].pos] = 1,++tot;
        }else
        if (dfn[v] < dfn[x] && e1[i].pos != fa)
            low[x] = min(low[x],dfn[v]);
    }
}
int main()
{
    int u,v,w;
    n = read(); m = read();
    for (int i = 1;i <= m; ++i)
    {
        u = read(); v = read(); w = read();
        add1(u,v,w,i);
    }
    dij();
    tot = 0;
    dfs(n);
    tot = 0;
    getcut(1,-1);
    printf("%d\n",tot);
    for (int i = 1;i <= m; ++i)
        if (col[i]) printf("%d ",i);
    return 0;
}