[BZOJ4538]網絡

題目鏈接：BZOJ4538

題目大意
給出一顆樹，要求支持三種操作：
1. 聲明一個經過樹上兩點之間路徑的帶權任務；
2. 取消t 時刻的任務；
3. 詢問不經過x 點的未取消任務中權值最大值。

分析
1. 乍一看樹剖，其實就是樹剖+線段樹+堆。
2. 首先我們把操作1取反，即在路徑的補集上加任務，那麼操作3就變成了所有經過x 的未取消任務的最大值。
3. 線段樹每個節點套一個堆，代表覆蓋這整個區間的任務的集合；若任務不足以覆蓋整個區間，處理方式和經典線段樹一樣；詢問時詢問從線段樹第一層一直到最後一層x 點的max ；
4. 求補集的話，先把原集合在線段樹上的各個左右端點mark[i] 求出，然後加上端點0 和端點n+1 排一遍序，區間[mark[i]+1,mark[i+1]−1] 就是補集了，複雜度O(logNlog(logN)) 。

上代碼

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

const int N = 1e5 + 10;
const int M = 2e5 + 10;

int n, m;
inline int read() {
    char ch;
    int ans = 0, neg = 1;
    while (ch = getchar(), ch < '0' || ch > '9')
        if (ch == '-') neg  = -1;
    while (ch >= '0' && ch <= '9')
        ans = ans * 10 + ch - '0', ch = getchar();
    return ans * neg;
}

bool book[M];
vector <int> edge[N];

namespace HLD {
    struct Poi { // poi？ poi！
        int id, val;
        Poi() {}
        Poi(int a, int b) : id(a), val(b) {}
        inline bool operator < (const Poi &a) const {
            return val < a.val;
        }
    }; typedef priority_queue <Poi> HP;
    int cntSeg;
    #define lc(a) (a << 1)
    #define rc(a) (lc(a) | 1)
    struct SegTree {
        HP H;
        int l, r;
    } T[N * 3];

    int fa[N], son[N], size[N], dep[N];
    int top[N], plc[N], replc[N];
    void dfs1(int a, int par) {
        fa[a] = par, size[a] = 1, dep[a] = dep[par] + 1;
        for (int i = 0; i < edge[a].size(); i++) {
            int tmp = edge[a][i];
            if (tmp == par) continue;
            dfs1(tmp, a), size[a] += size[tmp];
            if (size[tmp] > size[son[a]]) son[a] = tmp;
        }
    }
    void dfs2(int a, int up) {
        top[a] = up, replc[plc[a] = ++cntSeg] = a;
        if (son[a]) dfs2(son[a], up);
        for (int i = 0; i < edge[a].size(); i++) {
            int tmp = edge[a][i];
            if (tmp == fa[a] || tmp == son[a]) continue;
            dfs2(tmp, tmp);
        }
    }
    void build(int a, int l, int r) {
        T[a].l = l, T[a].r = r;
        if (l == r) return;
        int mid = (l + r) >> 1;
        build(lc(a), l, mid), build(rc(a), mid + 1, r);
    }
    Poi mdf;
    void modify(int a, int l, int r) {
        if (l > r) return;
        if (T[a].l == l && T[a].r == r) {
            T[a].H.push(mdf); return;
        }
        int mid = (T[a].l + T[a].r) >> 1;
        if (r <= mid) modify(lc(a), l, r);
        else if (l > mid) modify(rc(a), l, r);
        else modify(lc(a), l, mid), modify(rc(a), mid + 1, r);
    }
    int getMax(int a, int p) {
        while (!T[a].H.empty() && book[T[a].H.top().id]) T[a].H.pop();
        int tmp =  T[a].H.empty() ? -1 : T[a].H.top().val;
        if (T[a].l == p && T[a].r == p) return tmp;
        int mid = (T[a].l + T[a].r) >> 1;
        if (p > mid) return max(tmp, getMax(rc(a), p));
        else return max(tmp, getMax(lc(a), p));
    }
    int mark[N];
    void decom(int a, int b, int c, int d) {
        int cnt = 0; mdf = Poi(d, c);
        while (top[a] != top[b]) {
            if (dep[top[a]] < dep[top[b]]) swap(a, b);
            mark[++cnt] = plc[top[a]], mark[++cnt] = plc[a];
            a = fa[top[a]];
        }
        if (dep[a] < dep[b]) swap(a, b);
        mark[++cnt] = plc[b], mark[++cnt] = plc[a];
        mark[++cnt] = 0, mark[++cnt] = n + 1;
        sort(mark + 1, mark + cnt + 1);
        for (int i = 2; i <= cnt; i += 2)
            modify(1, mark[i - 1] + 1, mark[i] - 1);
    }
}

void init() {
    n = read(), m = read();
    for (int i = 1; i < n; i++) {
        int a = read(), b = read();
        edge[a].push_back(b), edge[b].push_back(a);
    }
    HLD::dfs1(1, 0), HLD::dfs2(1, 1), HLD::build(1, 1, n);
}
void figure() {
    int a, b, c;
    for (int i = 1; i <= m; i++) {
        switch (read()) {
            case 0:
                a = read(), b = read(), c = read();
                HLD::decom(a, b, c, i); break;
            case 1:
                book[read()] = true; break;
            default:
                a = HLD::plc[read()];
                printf("%d\n", HLD::getMax(1, a)); break;
        }
    }
}

int main() {
    init();
    figure();
    return 0;
}

以上