DFS序

DFS序：每个节点在DFS深度优先遍历中的进出栈的时间序列

树是一种非线性结构，所以对树进行区间操作会很不方便，所以要考虑将树转化成数组形式以便操作

对树进行一趟DFS，同时维护一个时间戳，记录每个结点被访问的时间，可以想象，对同一棵子树上的结点，访问的时间一定是相连的，映射到数组上就是一片连续的区间，如此，对一棵子树进行操作，可以等价于对一片连续的区间进行操作，区间操作常常可以使用树状数组或线段树维护

我们常常需要维护以下信息：

Time：时间戳

l[i]：dfs进入子树i的时间

r[i]：dfs离开子树i的时间

显然l[i]~r[i]记录的就是子树i每个结点被访问的时间

LOJ144. DFS 序 1（单点修改，区间查询）

#include <bits/stdc++.h>
#define int long long
using namespace std;
int v[1000005], l[1000005], r[1000005], t[1000005], Time, N, M, R;
vector<int> g[1000005];
void dfs(int now, int fa) {
    l[now] = ++Time;
    for (int i = 0; i < g[now].size(); i++) {
        if (g[now][i] != fa) {
            dfs(g[now][i], now);
        }
    }
    r[now] = Time;

}
void add(int x, int v) {
    for (; x <= N; x += x & -x) {
        t[x] += v;
    }
}
int ask(int x) {
    int res = 0;
    for (; x; x -= x & -x) {
        res += t[x];
    }
    return res;
}
signed main() {
    cin >> N >> M >> R;
    for (int i = 1; i <= N; i++) {
        cin >> v[i];
    }
    for (int i = 1; i < N; i++) {
        int v, u;
        cin >> v >> u;
        g[v].push_back(u);
        g[u].push_back(v);
    }
    dfs(R, 0);
    for (int i = 1; i <= N; i++) {
        add(l[i], v[i]);
    }
    while (M--) {
        int op, a, x;
        cin >> op;
        if (op == 1) {
            cin >> a >> x;
            add(l[a], x);
        } else {
            cin >> a;
            cout << ask(r[a]) - ask(l[a] - 1) << endl;
        }
    }
    return 0;
}

LOJ145. DFS 序 2（区间修改，区间查询）

区间修改用线段树就好了，这题有点卡常数，交第一次TLE了，第二次就过了，用树状数组也行，常数更小

#include <bits/stdc++.h>
#define int long long
using namespace std;
int v[1000005], l[1000005], r[1000005], d[4000005], lazy[4000005], Time, N, M, R;
vector<int> g[1000005];
void dfs(int now, int fa) {
    l[now] = ++Time;
    for (int i = 0; i < g[now].size(); i++) {
        if (g[now][i] != fa) {
            dfs(g[now][i], now);
        }
    }
    r[now] = Time;
 
}
void push_down(int p, int l, int r, int m) {
    d[p << 1] += lazy[p] * (m - l + 1);
    d[p << 1 | 1] += lazy[p] * (r - m);
    lazy[p << 1] += lazy[p];
    lazy[p << 1 | 1] += lazy[p];
    lazy[p] = 0;
}
void change(int p, int l, int r, int s, int t, int v) {
    if (r < s || l > t) {
        return;
    } else if (s <= l && r <= t) {
        d[p] += (r - l + 1) * v;
        lazy[p] += v;
        return;
    } else {
        int m = l + r >> 1;
        push_down(p, l, r, m);
        change(p << 1, l, m, s, t, v);
        change(p << 1 | 1, m + 1, r, s, t, v);
        d[p] = d[p << 1] + d[p << 1 | 1];
    }
}
int query(int p, int l, int r, int s, int t) {
    if (r < s || l > t) {
        return 0;
    } else if (s <= l && r <= t) {
        return d[p];
    } else {
        int m = l + r >> 1;
        push_down(p, l, r, m);
        return query(p << 1, l, m, s, t) + query(p << 1 | 1, m + 1, r, s, t);
    }
}
signed main() {
    ios::sync_with_stdio(0), cin.tie(0);
    cin >> N >> M >> R;
    for (int i = 1; i <= N; i++) {
        cin >> v[i];
    }
    for (int i = 1; i < N; i++) {
        int v, u;
        cin >> v >> u;
        g[v].push_back(u);
        g[u].push_back(v);
    }
    dfs(R, 0);
    for (int i = 1; i <= N; i++) {
        change(1, 1, N, l[i], l[i], v[i]);
    }
    while (M--) {
        int op, a, x;
        cin >> op;
        if (op == 1) {
            cin >> a >> x;
            change(1, 1, N, l[a], r[a], x);
        } else {
            cin >> a;
            cout << query(1, 1, N, l[a], r[a]) << endl;
        }
    }
    return 0;
}