[LOJ144] DFS Sequence 1 - DFS sequence segment tree

The room is familiar with the keyboard and the water

#include <bits/stdc++.h>
using namespace std;
#define int long long

const int N = 4000005;

int R;

namespace seg {
int a[N], src[N];

void pushup(int p) { a[p] = a[p * 2] + a[p * 2 + 1]; }

void build(int p, int l, int r) {
    if (l == r) {
        a[p] = src[l];
    } else {
        build(p * 2, l, (l + r) / 2);
        build(p * 2 + 1, (l + r) / 2 + 1, r);
        pushup(p);
    }
}

void modify(int p, int l, int r, int pos, int val) {
    if (l == r) {
        a[p] += val;
    } else {
        if (pos <= (l + r) / 2) {
            modify(p * 2, l, (l + r) / 2, pos, val);
        } else {
            modify(p * 2 + 1, (l + r) / 2 + 1, r, pos, val);
        }
        pushup(p);
    }
}

int query(int p, int l, int r, int ql, int qr) {
    if (l > qr || r < ql)
        return 0;
    if (l >= ql && r <= qr)
        return a[p];
    else {
        return query(p * 2, l, (l + r) / 2, ql, qr) + query(p * 2 + 1, (l + r) / 2 + 1, r, ql, qr);
    }
}
}  // namespace seg

namespace tree {
int dfn[N], fin[N], ind;
vector<int> g[N];

void dfs(int p) {
    dfn[p] = ++ind;
    for (int i = 0; i < g[p].size(); i++) {
        if (dfn[g[p][i]] == 0) {
            dfs(g[p][i]);
        }
    }
    fin[p] = ind;
}

void presolve() {
    ind = 0;
    dfs(R);
}
}  // namespace tree

int n, m, t1, t2, t3, t4, val[N];

signed main() {
    ios::sync_with_stdio(false);
    cin >> n >> m >> R;
    for (int i = 1; i <= n; i++) {
        cin >> val[i];
    }
    for (int i = 1; i < n; i++) {
        cin >> t1 >> t2;
        tree::g[t1].push_back(t2);
        tree::g[t2].push_back(t1);
    }

    tree::presolve();

    for (int i = 1; i <= n; i++) {
        seg::src[tree::dfn[i]] = val[i];
    }

    seg::build(1, 1, n);

    for (int i = 1; i <= m; i++) {
        cin >> t1 >> t2;
        if (t1 == 1) {
            cin >> t3;
            seg::modify(1, 1, n, tree::dfn[t2], t3);
        } else {
            cout << seg::query(1, 1, n, tree::dfn[t2], tree::fin[t2]) << endl;
        }
    }
}