luogu 2934

同 bzoj3694

需要先求出最短路树

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <queue>

const int N = 4e5 + , M = 4e5 + ;

using namespace std;

struct Node {
    int u, v, w, nxt;
} G[M << ], E[M << ];
int n, m;
int head[N], now, js, dis[N];

#define gc getchar()

inline int read() {
    int x = ; char c = gc;
    while(c < '' || c > '') c = gc;
    while(c >= '' && c <= '') x = x *  + c - '', c = gc;
    return x;
}

inline void write_int(int x) {
    printf("%d\n", x);
}

inline void Add(int u, int v, int w) {
    G[++ now].v = v, G[now].w = w, G[now].nxt = head[u], head[u] = now;
}

int fa[N], deep[N], topp[N], size[N], son[N], tree[N], Tree;

void Dfs_1(int u, int f_, int dep) {
    fa[u] = f_, deep[u] = dep, size[u] = ;
    for(int i = head[u]; ~ i; i = G[i].nxt) {
        int v = G[i].v;
        if(v == f_) continue;
        dis[v] = dis[u] + G[i].w;
        Dfs_1(v, u, dep + );
        size[u] += size[v];
        if(size[v] > size[son[u]]) son[u] = v;
    }
}

void Dfs_2(int u, int tp) {
    topp[u] = tp, tree[u] = ++ Tree;
    if(!son[u]) return ;
    Dfs_2(son[u], tp);
    for(int i = head[u]; ~ i; i = G[i].nxt)
        if(G[i].v != fa[u] && G[i].v != son[u]) Dfs_2(G[i].v, G[i].v);
}

const int oo = ;
int Minn[N << ];

#define lson jd << 1
#define rson jd << 1 | 1

void Build_tree(int l, int r, int jd) {
    Minn[jd] = oo;
    if(l == r) return ;
    int mid = (l + r) >> ;
    Build_tree(l, mid, lson), Build_tree(mid + , r, rson);
}

void Sec_G(int l, int r, int jd, int x, int y, int w) {
    if(x <= l && r <= y) {
        Minn[jd] = std:: min(Minn[jd], w);
        return ;
    }
    int mid = (l + r) >> ;
    if(x <= mid) Sec_G(l, mid, lson, x, y, w);
    if(y > mid)  Sec_G(mid + , r, rson, x, y, w);
}

void Sec_G_imp(int x, int y, int w) {
    int tpx = topp[x], tpy = topp[y];
    while(tpx != tpy) {
        if(deep[tpx] < deep[tpy]) std:: swap(tpx, tpy), std:: swap(x, y);
        Sec_G(, n, , tree[tpx], tree[x], w);
        x = fa[tpx], tpx = topp[x];
    }
    if(x == y) return ;
    if(deep[x] < deep[y]) std:: swap(x, y);
    Sec_G(, n, , tree[y] + , tree[x], w);
}

int Ans[N];

void Dfs_tree(int l, int r, int jd) {
    if(l == r) {
        Ans[l] = Minn[jd];
        return ;
    }
    int mid = (l + r) >> ;
    Minn[lson] = std:: min(Minn[lson], Minn[jd]);
    Minn[rson] = std:: min(Minn[rson], Minn[jd]);
    Dfs_tree(l, mid, lson), Dfs_tree(mid + , r, rson);
}

int shead[N];
struct Node_2 {
    int u, v, w, id, nxt;
} sG[M << ], sE[M << ];
int stot = ;
bool sOk[N];
queue <int> sQ;
int sdis[N];
bool svis[N];
int sto[N];

struct Short {

    void Link(int u, int v, int w, int id) {
        sG[++ stot].v = v, sG[stot].id = id, sG[stot].w = w, sG[stot].nxt = shead[u], shead[u] = stot;
    }

    void Spfa(int S) {
        for(int i = ; i <= n; i ++) sdis[i] = oo;
        sdis[S] = ;
        sQ.push(S);
        while(!sQ.empty()) {
            int stop = sQ.front();
            sQ.pop();
            svis[stop] = ;
            for(int i = shead[stop]; ~ i; i = sG[i].nxt) {
                int v = sG[i].v;
                if(sdis[v] > sdis[stop] + sG[i].w) {
                    sdis[v] = sdis[stop] + sG[i].w;
                    sOk[sto[v]] = ;
                    sto[v] = sG[i].id;
                    sOk[sto[v]] = ;
                    if(svis[v] == ) {
                        sQ.push(v);
                    }
                }
            }
        }
    }

    void Work() {
        for(int i = ; i <= n; i ++) shead[i] = -;
        for(int i = ; i <= m; i ++) {
            int u = sE[i].u, v = sE[i].v, w = sE[i].w, id = sE[i].id;
            Link(u, v, w, id), Link(v, u, w, id);
        }
        Spfa();
    }
}AB;

int main() {
    n = read(), m = read();
    for(int i = ; i <= n; i ++) head[i] = -;
    for(int i = ; i <= m; i ++) {
        int u = read(), v = read(), w = read();
        sE[i].u = u, sE[i].v = v; sE[i].w = w; sE[i].id = i;
    }
    if(Judge()) {

        return ;
    }
    AB.Work();
    int tot = ;
    for(int i = ; i <= m; i ++) {
        int u = sE[i].u, v = sE[i].v, w = sE[i].w; // id = sE[i].id;
        if(sOk[i] == ) {
            Add(u, v, w), Add(v, u, w);
        } else {
            E[++ tot].u = u, E[tot].v = v; E[tot].w = w;
        }
    }
    Dfs_1(, , );
    Dfs_2(, );
    Build_tree(, n, );
    for(int i = ; i <= tot; i ++) {
        int x = E[i].u, y = E[i].v;
        Sec_G_imp(x, y, dis[x] + dis[y] + E[i].w);
    }
    Dfs_tree(, n, );
    for(int i = ; i <= n; i ++) {
        if(Ans[tree[i]] == oo) write_int(-);
        else write_int(Ans[tree[i]] - dis[i]);
    }
    return ;
}