luoguP3250 [HNOI2016]网络 树链剖分 + 堆

机房某大佬告诉我，一条链在全局线段树中的区间最多有$log$段

因此同样的，代表不在这条链上的区间同样只有$log$段

对这$log$段区间进行维护即可

为了能够删除，在线段树的每个节点暴力维护一个堆

每次加入一条链时，在这$log$段区间上暴力加入元素

每次删除一条链时，暴力删除元素

询问时，对所有经过的区间进行查询

注意堆标记不要下传，直接标记永久化就行

插入 / 删除复杂度单次$O(\log^3 n)$

查询复杂度单次$O(log n)$

空间复杂度$O(n \log^2 n)$

注：$bzoj$会$MLE$....不要轻易尝试

注2：打了30多min，好累啊.....

注3：大家还是去学习$O(n \log n)$的优秀做法吧...

#include <map>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

extern inline char gc() {
    static char RR[], *S = RR + , *T = RR + ;
    if(S == T) fread(RR, , , stdin), S = RR;
    return *S ++;
}
inline int read() {
    int p = , w = ; char c = gc();
    while(c > '' || c < '') { if(c == '-') w = -; c = gc(); }
    while(c >= '' && c <= '') p = p *  + c - '', c = gc();
    return p * w;
}

#define ri register int
#define sid 200050

int n, m, cnp, id;
int nxt[sid], node[sid], cap[sid];

inline void addedge(int u, int v) {
    nxt[++ cnp] = cap[u]; cap[u] = cnp; node[cnp] = v;
    nxt[++ cnp] = cap[v]; cap[v] = cnp; node[cnp] = u;
}

int U[sid], V[sid], W[sid];
int dfn[sid], sz[sid], dep[sid];
int son[sid], anc[sid], fa[sid];

#define cur node[i]
void dfs(int o) {
    sz[o] = ;
    for(int  i = cap[o]; i; i = nxt[i])
    if(cur != fa[o]) {
        dep[cur] = dep[o] + ; fa[cur] = o; dfs(cur); sz[o] += sz[cur];
        if(sz[cur] > sz[son[o]]) son[o] = cur;
    }
}

void dfs(int o, int ac) {
    dfn[o] = ++ id; anc[o] = ac;
    if(!son[o]) return; dfs(son[o], ac);
    for(int i = cap[o]; i; i = nxt[i])
    if(cur != fa[o] && cur != son[o]) dfs(cur, cur);
}

struct Heap {
    priority_queue <int> q1, q2;
    inline void ins(int x) { q1.push(x); }
    inline void era(int x) { q2.push(x); }
    inline int top() {
        while() {
            if(q2.empty()) return q1.top();
            if(q1.top() == q2.top()) q1.pop(), q2.pop();
            else return q1.top();
        }
    }
} t[sid << ];

#define ls (o << 1)
#define rs (o << 1 | 1)

void build(int o, int l, int r) {
    t[o].ins(-); if(l == r) return;
    int mid = (l + r) >> ;
    build(ls, l, mid); build(rs, mid + , r);
}

void upd(int o, int l, int r, int ml, int mr, int v, int opt) {
    if(ml > mr) return;
    if(ml > r || mr < l) return;
    if(ml <= l && mr >= r) { if(opt) t[o].ins(v); else t[o].era(v); return; }
    int mid = (l + r) >> ;
    upd(ls, l, mid, ml, mr, v, opt);
    upd(rs, mid + , r, ml, mr, v, opt);
}

int qry(int o, int l, int r, int ml, int mr) {
    if(ml > r || mr < l) return -;
    if(ml <= l && mr >= r) return t[o].top();
    int mid = (l + r) >> ;
    return max(t[o].top(), max(qry(ls, l, mid, ml, mr), qry(rs, mid + , r, ml, mr)));
}

struct Seg {
    int l, r;
    friend bool operator < (Seg a, Seg b)
    { return a.l < b.l; }
}; vector <Seg> re;

void Upd(int u, int v, int w, int opt) {
    re.clear();
    int pu = anc[u], pv = anc[v];
    while(pu != pv) {
        if(dep[pu] < dep[pv]) swap(u, v), swap(pu, pv);
        re.push_back( { dfn[pu], dfn[u] } );
        u = fa[pu]; pu = anc[u];
    }
    if(dep[u] < dep[v]) swap(u, v);
    re.push_back( { dfn[v], dfn[u] } );
    re.push_back( { ,  } );
    re.push_back( { n + , n +  } );
    sort(re.begin(), re.end());
    for(ri i = ; i < re.size(); i ++)
    upd(, , n, re[i - ].r + , re[i].l - , w, opt);
}

int main() {
    n = read(); m = read();
    for(ri i = ; i < n; i ++) {
        int u = read(), v = read();
        addedge(u, v);
    }
    dfs(); dfs(, ); build(, , n);
    for(ri i = ; i <= m; i ++) {
        int opt = read(), u, v, w;
        if(opt == ) {
            u = read(); v = read(); w = read();
            U[i] = u; V[i] = v; W[i] = w; Upd(u, v, w, );
        }
        if(opt == ) u = read(), Upd(U[u], V[u], W[u], );
        if(opt == ) u = read(), printf("%d\n", qry(, , n, dfn[u], dfn[u]));
    }
    return ;
}