BZOJ1576 [Usaco2009 Jan]安全路经Travel

首先用Dijkstra做出最短路生成树，设dis[p]为1到p点的最短路长度

对于一条不在生成树上的边u -> v，不妨设fa为u、v的lca

则一fa到v的路径上的任意点x都可以由u达到，走的方式是1 -> fa -> u -> v -> x，dis'[x] = dis[u] + dis(u, v) ＋ dis[v] - dis[x]

于是可以用dis[u] + dis(u, v) + dis[v]更新fa到v的路径上的所有点

链剖一下，线段树lazytag就好了，连pushdown都不需要

/**************************************************************
    Problem: 1576
    User: rausen
    Language: C++
    Result: Accepted
    Time:2276 ms
    Memory:16636 kb
****************************************************************/
 
#include <cstdio>
#include <algorithm>
#include <queue>
 
using namespace std;
const int N = 1e5 + 5;
const int M = 2e5 + 5;
const int inf = 1e9;
 
struct edge {
    int next, to, v, vis;
    edge(int _n = 0, int _t = 0, int _v = 0, int __v = 0) : next(_n), to(_t), v(_v), vis(__v) {}
} e[M << 1];
 
struct heap_node {
    int v, e, to;
    heap_node(int _v = 0, int _e = 0, int _t = 0) : v(_v), e(_e), to(_t) {}
     
    inline bool operator < (const heap_node &p) const {
        return v > p.v;
    }
};
 
struct tree_node {
    int fa, sz, dep;
    int top, son, e;
    int w;
} tr[N];
 
struct seg_node {
    seg_node *ls, *rs;
    int mn;
} *seg_root, *seg_null, mempool[N << 2], *cnt_seg = mempool;
 
int n, m, cnt_q;
int first[N], tot = 1;
int dis[N];
priority_queue <heap_node> h;
 
inline int read() {
    static int x;
    static char ch;
    x = 0, ch = getchar();
    while (ch < '0' || '9' < ch)
        ch = getchar();
    while ('0' <= ch && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x;
}
 
inline void Add_Edges(int x, int y, int v) {
    e[++tot] = edge(first[x], y, v), first[x] = tot;
    e[++tot] = edge(first[y], x, v), first[y] = tot;
}
 
inline void add_to_heap(int p) {
    static int x;
    for (x = first[p]; x; x = e[x].next)
        if (dis[e[x].to] == inf)
            h.push(heap_node(e[x].v + dis[p], x, e[x].to));
}
 
void Dijkstra(int S) {
    int p;
    for (p = 1; p <= n; ++p) dis[p] = inf;
    while (!h.empty()) h.pop();
    dis[S] = 0, add_to_heap(S);
    while (!h.empty()) {
        if (dis[h.top().to] != inf) {
            h.pop();
            continue;
        }
        p = h.top().to;
        dis[p] = h.top().v, e[tr[p].e = h.top().e].vis = 1;
        h.pop(), add_to_heap(p);
    }
}
 
#define y e[x].to
#define Son tr[p].son
void dfs(int p) {
    int x;
    tr[p].sz = 1;
    for (x = first[p]; x; x = e[x].next)
        if (tr[y].e == x) {
            tr[y].dep = tr[p].dep + 1;
            dfs(y);
            tr[p].sz += tr[y].sz;
            if (Son == 0 || tr[y].sz > tr[Son].sz) Son = y;
        }
}
 
void DFS(int p) {
    int x;
    tr[p].w = ++cnt_q;
    if (Son)
        tr[Son].top = tr[p].top, DFS(Son);
        for (x = first[p]; x; x = e[x].next)
            if (y != Son && tr[y].e == x)
                tr[y].top = y, DFS(y);
}
#undef y
#undef Son
 
#define mid (l + r >> 1)
#define Ls p -> ls
#define Rs p -> rs
#define Mn p -> mn
inline void seg_make_null(seg_node *&p) {
    p = cnt_seg, Ls = Rs = p, Mn = inf;
}
 
inline void seg_new(seg_node *&p) {
    p = ++cnt_seg, *p = *seg_null;
}
 
void seg_build(seg_node *&p, int l, int r) {
    seg_new(p);
    if (l == r) return;
    seg_build(Ls, l, mid), seg_build(Rs, mid + 1, r);
}
 
void seg_modify(seg_node *p, int l, int r, int L, int R, int v) {
    if (L <= l && r <= R) {
        Mn = min(Mn, v);
        return;
    }
    if (L <= mid) seg_modify(Ls, l, mid, L, R, v);
    if (mid + 1 <= R) seg_modify(Rs, mid + 1, r, L, R, v);
}
 
int seg_query(seg_node *p, int l, int r, int pos) {
    if (l == r) return Mn;
    return min(Mn, pos <= mid ? seg_query(Ls, l, mid, pos) : seg_query(Rs, mid + 1, r, pos));
}
#undef mid
#undef Ls
#undef Rs
#undef Mn
 
int get_lca(int x, int y) {
    while (tr[x].top != tr[y].top) {
        if (tr[tr[x].top].dep < tr[tr[y].top].dep) swap(x, y);
        x = tr[tr[x].top].fa;
    }
    if (tr[x].dep < tr[y].dep) swap(x, y);
    return y;
}
 
void work_modify(int x, int fa, int v) {
    while (tr[x].top != tr[fa].top) {
        seg_modify(seg_root, 1, n, tr[tr[x].top].w, tr[x].w, v);
        x = tr[tr[x].top].fa;
    }
    seg_modify(seg_root, 1, n, tr[fa].w + 1, tr[x].w, v);
}
 
int main() {
    int i, x, y, z, fa, tmp;
    n = read(), m = read();
    for (i = 1; i <= m; ++i) {
        x = read(), y = read(), z = read();
        Add_Edges(x, y, z);
    }
    Dijkstra(1);
    for (i = 2; i <= n; ++i)
        tr[i].fa = e[tr[i].e ^ 1].to;
    dfs(1);
    tr[1].top = 1, DFS(1);
    seg_make_null(seg_null);
    seg_build(seg_root, 1, n);
#define y e[x].to
    for (i = 1; i <= n; ++i)
        for (x = first[i]; x; x = e[x].next) 
            if (!e[x].vis) work_modify(y, get_lca(i, y), dis[i] + dis[y] + e[x].v);
#undef y
    for (i = 2; i <= n; ++i) {
        tmp = seg_query(seg_root, 1, n, tr[i].w);
        printf("%d
", tmp == inf ? -1 : tmp - dis[i]);
    }
    return 0;
}