NC23051 华华和月月种树

题目链接

题目

题目描述

华华看书了解到，一起玩养成类的游戏有助于两人培养感情。所以他决定和月月一起种一棵树。因为华华现在也是信息学高手了，所以他们种的树是信息学意义下的。
华华和月月一起维护了一棵动态有根树，每个点有一个权值。刚开存档的时候，树上只有 0 号节点，权值为 0 。接下来有两种操作：
操作 1：输入格式 \(1\ i\) ，表示月月氪金使节点 i 长出了一个新的儿子节点，权值为0，编号为当前最大编号 +1（也可以理解为，当前是第几个操作 1，新节点的编号就是多少）。
操作 2：输入格式 \(2 \ i \ a\) ，表示华华上线做任务使节点 i 的子树中所有节点（即它和它的所有子孙节点）权值加 a 。
但是月月有时会检查华华有没有认真维护这棵树，会作出询问：
询问 3：输入格式 \(3\ i\) ，华华需要给出 i 节点此时的权值。
华华当然有认真种树了，不过还是希望能写个程序以备不时之需。

输入描述

第一行一个正整数M，接下来M行，每行先输入一个正整数O表示操作类型，再输入一个非负整数i表示操作或询问的节点编号，如果O=2，再输入一个正整数a。

输出描述

对于每个询问3，输出一个非负整数表示询问的答案。

示例1

输入

9
1 0
2 0 1
3 0
3 1
1 0
1 1
2 0 2
3 1
3 3

输出

1
1
3
2

备注

\(1\le M\le 4\times 10^5\)，保证操作1的数量不超过 \(10^5\) ，保证操作2中的参数a满足 \(1\le a\le 999\)

题解

知识点：DFS序，线段树，离线。

加点的操作不好处理，但是我们可以离线解决。

我们可以先读取全部的操作，并把完整的树建好求dfn序，然后直接在完整的dfn序上用线段树操作。

因为只需要查询一个点的权值，所以完整的树中还未实际加入的点，是不影响其他点权值的。在操作时，只需要将加点操作替换成把这个点权值清零即可，其他正常操作。

时间复杂度 \(O(m \log m)\)

空间复杂度 \(O(m)\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

struct Graph {
    struct edge {
        int v, nxt;
    };
    int idx;
    vector<int> h;
    vector<edge> e;

    Graph(int n = 0, int m = 0) { init(n, m); }

    void init(int n, int m) {
        idx = 0;
        h.assign(n + 1, 0);
        e.assign(m + 1, {});
    }

    void add(int u, int v) {
        e[++idx] = { v,h[u] };
        h[u] = idx;
    }
};

struct T {
    int sum;
    static T e() { return { 0 }; }
    friend T operator+(const T &a, const T &b) { return { a.sum + b.sum }; }
};

struct F {
    int add;
    static F e() { return { 0 }; }
    T operator()(const T &x) { return { x.sum + add }; }
    F operator()(const F &g) { return { g.add + add }; }
};

template<class T, class F>
class SegmentTreeLazy {
    int n;
    vector<T> node;
    vector<F> lazy;

    void push_down(int rt) {
        node[rt << 1] = lazy[rt](node[rt << 1]);
        lazy[rt << 1] = lazy[rt](lazy[rt << 1]);
        node[rt << 1 | 1] = lazy[rt](node[rt << 1 | 1]);
        lazy[rt << 1 | 1] = lazy[rt](lazy[rt << 1 | 1]);
        lazy[rt] = F::e();
    }

    void update(int rt, int l, int r, int x, int y, F f) {
        if (r < x || y < l) return;
        if (x <= l && r <= y) return node[rt] = f(node[rt]), lazy[rt] = f(lazy[rt]), void();
        push_down(rt);
        int mid = l + r >> 1;
        update(rt << 1, l, mid, x, y, f);
        update(rt << 1 | 1, mid + 1, r, x, y, f);
        node[rt] = node[rt << 1] + node[rt << 1 | 1];
    }

    T query(int rt, int l, int r, int x, int y) {
        if (r < x || y < l) return T::e();
        if (x <= l && r <= y) return node[rt];
        push_down(rt);
        int mid = l + r >> 1;
        return query(rt << 1, l, mid, x, y) + query(rt << 1 | 1, mid + 1, r, x, y);
    }

public:
    SegmentTreeLazy(int _n = 0) { init(_n); }
    SegmentTreeLazy(const vector<T> &src) { init(src); }

    void init(int _n) {
        n = _n;
        node.assign(n << 2, T::e());
        lazy.assign(n << 2, F::e());
    }
    void init(const vector<T> &src) {
        assert(src.size() >= 2);
        init(src.size() - 1);
        function<void(int, int, int)> build = [&](int rt, int l, int r) {
            if (l == r) return node[rt] = src[l], void();
            int mid = l + r >> 1;
            build(rt << 1, l, mid);
            build(rt << 1, mid + 1, r);
            node[rt] = node[rt << 1] + node[rt << 1 | 1];
        };
        build(1, 1, n);
    }

    void update(int x, int y, F f) { update(1, 1, n, x, y, f); }

    T query(int x, int y) { return query(1, 1, n, x, y); }
};

const int N = 100007;
Graph g;

struct Query {
    int op, x, val;
}Q[400007];

int dfncnt;
int L[N], R[N];
void dfs(int u, int fa) {
    L[u] = ++dfncnt;
    for (int i = g.h[u];i;i = g.e[i].nxt) {
        int v = g.e[i].v;
        if (v == fa) continue;
        dfs(v, u);
    }
    R[u] = dfncnt;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    g.init(N, N << 1);
    int m;
    cin >> m;
    int n = 1;
    for (int i = 1;i <= m;i++) {
        int op, x;
        cin >> op >> x;
        x++;
        if (op == 1) {
            n++;
            g.add(x, n);
            g.add(n, x);
            Q[i] = { op,n,0 };
        }
        else if (op == 2) {
            int val;
            cin >> val;
            Q[i] = { op,x,val };
        }
        else Q[i] = { op,x,0 };
    }
    dfs(1, 0);
    SegmentTreeLazy<T, F> sgt(n);
    for (int i = 1;i <= m;i++) {
        auto [op, x, val] = Q[i];
        if (op == 1) sgt.update(L[x], L[x], { -sgt.query(L[x],L[x]).sum });
        else if (op == 2) sgt.update(L[x], R[x], { val });
        else cout << sgt.query(L[x], L[x]).sum << '\n';
    }
    return 0;
}