BZOJ3999 [TJOI2015]旅游

题面：给定一个有$n$个节点的树，每个点又点权$v_i$，每次选取一条树链$[a, b]$，求出$max(v_i - v_j)$，其中$i, j \in [a, b]$且$i$出现在$j$前面，最后树链$[a, b]$上的点点权都加上$v'$

裸的树链剖分，用线段树维护树链。。。查询的时候要用线段树合并。。。然后就没有然后了。。。

代码能力捉鸡QAQQQ，而且貌似是C++程序里面跑的最慢的QAQQQ

 /**************************************************************
     Problem: 3999
     User: rausen
     Language: C++
     Result: Accepted
     Time:4268 ms
     Memory:17988 kb
 ****************************************************************/

 #include <cstdio>
 #include <algorithm>

 using namespace std;
 typedef long long ll;
 const int N = 5e4 + ;
 const int inf = 1e9;

 inline int read();

 int n;
 int a[N], seq[N], cnt_seq;

 struct edge {
     int next, to;
     edge() {}
     edge(int _n, int _t) : next(_n), to(_t) {}
 } e[N << ];

 int first[N], tot;

 struct tree_node {
     int sz, dep, fa, son, v;
     int top, pos;
 } tr[N];

 struct seg {
     seg *ls, *rs, *res;
     ll mx, mn, mxl, mxr, tag;

     #define Len (1 << 16)
     inline void* operator new(size_t) {
         static seg *mempool, *c;
         if (mempool == c)
             mempool = (c = new seg[Len]) + Len;
         return c++;
     }
     #undef Len
     inline seg& operator += (int x) {
         mx += x, mn += x, tag += x;
     }

     inline seg* rev() {
         swap(mxl, mxr);
         return this;
     }
     inline void update(seg *ls, seg *rs) {
         mxl = max(max(ls -> mxl, rs -> mxl), ls -> mx - rs -> mn);
         mxr = max(max(ls -> mxr, rs -> mxr), rs -> mx - ls -> mn);
         mx = max(ls -> mx, rs -> mx), mn = min(ls -> mn, rs -> mn);
     }
     inline void push() {
         if (tag) {
             *ls += tag, *rs += tag;
             tag = ;
         }
     }

     #define mid (l + r >> 1)
     inline void build(int l, int r, int* a) {
         res = new()seg;
         if (l == r) {
             mx = mn = a[l];
             return;
         }
         ls = new()seg(), rs = new()seg;
         ls -> build(l, mid, a), rs -> build(mid + , r, a);
         update(ls, rs);
     }

     inline void add(int l, int r, int L, int R, int d) {
         if (L <= l && r <= R) {
             *this += d;
             return;
         }
         push();
         if (L <= mid) ls -> add(l, mid, L, R, d);
         if (mid < R) rs -> add(mid + , r, L, R, d);
         update(ls, rs);
     }

     inline seg* query(int l, int r, int L, int R) {
         if (L <= l && r <= R) {
             *res = *this;
             return res;
         }
         *res = seg(), push();
         if (mid >= R) res = ls -> query(l, mid, L, R);
         else if (mid < L) res = rs -> query(mid + , r, L, R);
         else res -> update(ls -> query(l, mid, L, R), rs -> query(mid + , r, L, R));
         update(ls, rs);
         return res;
     }
     #undef mid
 } *T;

 inline void get(seg *t, int f, int a, int b, int v) {
     if (!f) t -> update(T -> query(, n, a, b), t);
     else t -> update(t, T -> query(, n, a, b) -> rev());
     T -> add(, n, a, b, v);
 }

 inline void pre(seg *t) {
     *t = seg();
     t -> mx = t -> mxl = t -> mxr = -inf, t -> mn = inf;
 }

 inline void work(int x, int y, int v) {
     static seg *left = new()seg, *right = new()seg, *ans = new()seg;
     pre(left), pre(right);
     while (tr[x].top != tr[y].top) {
         if (tr[tr[x].top].dep > tr[tr[y].top].dep)
             get(right, , tr[tr[x].top].pos, tr[x].pos, v), x = tr[tr[x].top].fa;
         else
             get(left, , tr[tr[y].top].pos, tr[y].pos, v), y = tr[tr[y].top].fa;
     }
     if (tr[x].dep > tr[y].dep) get(right, , tr[y].pos, tr[x].pos, v);
     else get(left, , tr[x].pos, tr[y].pos, v);
     ans -> update(left, right);
     printf("%lld\n", max(ans -> mxl, 0ll));
 }

 inline void Add_Edges(int x, int y) {
     e[++tot] = edge(first[x], y), first[x] = tot;
     e[++tot] = edge(first[y], x), first[y] = tot;
 }

 #define y e[x].to
 void dfs(int p) {
     int x;
     tr[p].sz = ;
     for (x = first[p]; x; x = e[x].next)
         if (y != tr[p].fa) {
             tr[y].fa = p, tr[y].dep = tr[p].dep + ;
             dfs(y);
             tr[p].sz += tr[y].sz;
             if (!tr[p].son || tr[tr[p].son].sz < tr[y].sz) tr[p].son = y;
         }
 }

 void DFS(int p) {
     int x;
     seq[tr[p].pos = ++cnt_seq] = tr[p].v;
     if (!tr[p].son) return;
     tr[tr[p].son].top = tr[p].top;
     DFS(tr[p].son);
     for (x = first[p]; x; x = e[x].next)
         if (y != tr[p].fa && y != tr[p].son)
             tr[y].top = y, DFS(y);
 }
 #undef y

 int main() {
     int i, x, y, z, Q;
     n = read();
     for (i = ; i <= n; ++i) tr[i].v = read();
     for (i = ; i < n; ++i)
         Add_Edges(read(), read());
     dfs();
     tr[].top = , DFS();
     T = new()seg;
     T -> build(, n, seq);
     for (Q = read(); Q; --Q) {
         x = read(), y = read(), z = read();
         work(x, y, z);
     }
     return ;
 }

 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;
 }