【HDU】4010 Query on The Trees

#include<cstdio>
#include<cstring>
#include<queue>
#include<iostream>
#include<algorithm>
#define MAXN 300010
#define MAXM 600010
#define CLEAR(a,b) memset(a,b,sizeof(a))
using namespace std;
int first[MAXN], next[MAXM], v[MAXM], e;
bool vis[MAXN];
struct LCT {
    int bef[MAXN];
    bool flip[MAXN];
    int next[MAXN][2], pre[MAXN], key[MAXN], add[MAXN], maxi[MAXN];
    void Init() {
        CLEAR(next, 0);
        CLEAR(pre, 0);
        flip[0] = flip[1] = false;
        add[0] = add[1] = 0;
        bef[0] = bef[1] = 0;
        key[0] = maxi[0] = 0;
    }
    inline void PushUp(int x) {
        maxi[x] = max(key[x], max(maxi[next[x][0]], maxi[next[x][1]]));
    }
    inline void Inc(int x, int val) {
        if (x) {
            add[x] += val;
            key[x] += val;
            maxi[x] += val;
        }
    }
    inline void PushDown(int x) {
        if (add[x]) {
            Inc(next[x][0], add[x]);
            Inc(next[x][1], add[x]);
            add[x] = 0;
        }
        if (flip[x]) {
            flip[next[x][0]] ^= true;
            flip[next[x][1]] ^= true;
            swap(next[x][0], next[x][1]);
            flip[x] = false;
        }
    }
    void Rotate(int x, int kind) {
        int y, z;
        y = pre[x];
        z = pre[y];
        PushDown(x);
        next[y][!kind] = next[x][kind];
        pre[next[x][kind]] = y;
        next[z][next[z][1] == y] = x;
        pre[x] = z;
        next[x][kind] = y;
        pre[y] = x;
        PushUp(y);
    }
    void Splay(int x) {
        int rt;
        for (rt = x; pre[rt]; rt = pre[rt])
            ;
        if (rt != x) {
            bef[x] = bef[rt];
            bef[rt] = 0;
            while (pre[x]) {
                PushDown(pre[x]);
                if (next[pre[x]][0] == x)
                    Rotate(x, 1);
                else
                    Rotate(x, 0);
            }
            PushUp(x);
        } else
            PushDown(x);
    }
    void Access(int x) {
        int father;
        for (father = 0; x; x = bef[x]) {
            Splay(x);
            bef[next[x][1]] = x;
            pre[next[x][1]] = 0;
            next[x][1] = father;
            pre[father] = x;
            bef[father] = 0;
            father = x;
            PushUp(x);
        }
    }
    int GetRoot(int x) {
        Access(x);
        Splay(x);
        while (next[x][0])
            x = next[x][0];
        return x;
    }
    void MakeRoot(int x) {
        Access(x);
        Splay(x);
        flip[x] ^= true;
    }
    void Join(int x, int y) {
        MakeRoot(x);
        MakeRoot(y);
        bef[x] = y;
    }
    void Cut(int x) {
        Access(x);
        Splay(x);
        bef[next[x][0]] = bef[x];
        bef[x] = 0;
        pre[next[x][0]] = 0;
        next[x][0] = 0;
        PushUp(x);
    }
    void Update(int x, int y, int val) {
        Access(y);
        for (y = 0; x; x = bef[x]) {
            Splay(x);
            if (!bef[x]) {
                key[x] += val;
                Inc(y, val);
                Inc(next[x][1], val);
                return;
            }
            bef[next[x][1]] = x;
            pre[next[x][1]] = 0;
            next[x][1] = y;
            pre[y] = x;
            bef[y] = 0;
            y = x;
            PushUp(x);
        }
    }
    int Query(int x, int y) {
        Access(y);
        for (y = 0; x; x = bef[x]) {
            Splay(x);
            if (!bef[x])
                return max(key[x], max(maxi[next[x][1]], maxi[y]));
            bef[next[x][1]] = x;
            pre[next[x][1]] = 0;
            next[x][1] = y;
            pre[y] = x;
            bef[y] = 0;
            y = x;
            PushUp(x);
        }
        return -1;
    }
} lct;
int INT() {
    int res;
    char ch;
    while (ch = getchar(), !isdigit(ch))
        ;
    for (res = ch - '0'; ch = getchar(), isdigit(ch);)
        res = res * 10 + ch - '0';
    return res;
}
inline void AddEdge(int x, int y) {
    v[e] = y;
    next[e] = first[x];
    first[x] = e++;
}
void BFS(int x) {
    int i, y;
    queue<int> q;
    memset(vis, false, sizeof(vis));
    vis[x] = true;
    q.push(x);
    while (!q.empty()) {
        x = q.front();
        q.pop();
        for (i = first[x]; i != -1; i = next[i]) {
            y = v[i];
            if (!vis[y]) {
                lct.bef[y] = x;
                lct.add[y] = 0;
                lct.flip[y] = false;
                vis[y] = true;
                q.push(y);
            }
        }
    }
}
int main() {
    int n, i, q;
    int cmd, x, y, val;
    while (~scanf("%d", &n)) {
        lct.Init();
        memset(first, -1, sizeof(first));
        for (e = 0, i = 1; i < n; i++) {
            x = INT(), y = INT();
            AddEdge(x, y);
            AddEdge(y, x);
        }
        BFS(1);
        for (i = 1; i <= n; i++)
            lct.key[i] = INT();
        q = INT();
        while (q--) {
            cmd = INT();
            if (cmd == 1) {
                x = INT(), y = INT();
                if (lct.GetRoot(x) == lct.GetRoot(y))
                    puts("-1");
                else
                    lct.Join(x, y);
            } else if (cmd == 2) {
                x = INT(), y = INT();
                if (x == y || lct.GetRoot(x) != lct.GetRoot(y))
                    puts("-1");
                else {
                    lct.MakeRoot(x);
                    lct.Cut(y);
                }
            } else if (cmd == 3) {
                val = INT(), x = INT(), y = INT();
                if (lct.GetRoot(x) != lct.GetRoot(y))
                    puts("-1");
                else
                    lct.Update(x, y, val);
            } else {
                x = INT(), y = INT();
                if (lct.GetRoot(x) != lct.GetRoot(y))
                    puts("-1");
                else
                    printf("%d\n", lct.Query(x, y));
            }
        }
        putchar('\n');
    }
    return 0;
}