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 + 5;
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 << 1];
 
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 = 0;
        }
    }
     
    #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 + 1, 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 + 1, 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 + 1, r, L, R);
        else res -> update(ls -> query(l, mid, L, R), rs -> query(mid + 1, 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(1, n, a, b), t);
    else t -> update(t, T -> query(1, n, a, b) -> rev());
    T -> add(1, 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, 0, tr[tr[x].top].pos, tr[x].pos, v), x = tr[tr[x].top].fa;
        else
            get(left, 1, tr[tr[y].top].pos, tr[y].pos, v), y = tr[tr[y].top].fa;
    }
    if (tr[x].dep > tr[y].dep) get(right, 0, tr[y].pos, tr[x].pos, v);
    else get(left, 1, tr[x].pos, tr[y].pos, v);
    ans -> update(left, right);
    printf("%lld
", 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 = 1;
    for (x = first[p]; x; x = e[x].next)
        if (y != tr[p].fa) {
            tr[y].fa = p, tr[y].dep = tr[p].dep + 1;
            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 = 1; i <= n; ++i) tr[i].v = read();
    for (i = 1; i < n; ++i)
        Add_Edges(read(), read());
    dfs(1);
    tr[1].top = 1, DFS(1);
    T = new()seg;
    T -> build(1, n, seq);
    for (Q = read(); Q; --Q) {
        x = read(), y = read(), z = read();
        work(x, y, z);
    }
    return 0;
}
 
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;
}