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 + ;
 const int M = 2e5 + ;
 const int inf = 1e9;

 struct edge {
     int next, to, v, vis;
     edge(int _n = , int _t = , int _v = , int __v = ) : next(_n), to(_t), v(_v), vis(__v) {}
 } e[M << ];

 struct heap_node {
     int v, e, to;
     heap_node(int _v = , int _e = , int _t = ) : 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 << ], *cnt_seg = mempool;

 int n, m, cnt_q;
 int first[N], tot = ;
 int dis[N];
 priority_queue <heap_node> h;

 inline int read() {
     static int x;
     static char ch;
     x = , ch = getchar();
     while (ch < '' || '' < ch)
         ch = getchar();
     while ('' <= ch && ch <= '') {
         x = x *  + ch - '';
         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 = ; p <= n; ++p) dis[p] = inf;
     while (!h.empty()) h.pop();
     dis[S] = , 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 = ;
         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 = ;
     for (x = first[p]; x; x = e[x].next)
         if (tr[y].e == x) {
             tr[y].dep = tr[p].dep + ;
             dfs(y);
             tr[p].sz += tr[y].sz;
             if (Son ==  || 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 + , 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 +  <= R) seg_modify(Rs, mid + , 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 + , 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, , n, tr[tr[x].top].w, tr[x].w, v);
         x = tr[tr[x].top].fa;
     }
     seg_modify(seg_root, , n, tr[fa].w + , tr[x].w, v);
 }

 int main() {
     int i, x, y, z, fa, tmp;
     n = read(), m = read();
     for (i = ; i <= m; ++i) {
         x = read(), y = read(), z = read();
         Add_Edges(x, y, z);
     }
     Dijkstra();
     for (i = ; i <= n; ++i)
         tr[i].fa = e[tr[i].e ^ ].to;
     dfs();
     tr[].top = , DFS();
     seg_make_null(seg_null);
     seg_build(seg_root, , n);
 #define y e[x].to
     for (i = ; 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 = ; i <= n; ++i) {
         tmp = seg_query(seg_root, , n, tr[i].w);
         printf("%d\n", tmp == inf ? - : tmp - dis[i]);
     }
     return ;
 }