洛谷P2146【线段树】【树链剖分】

willem248

于 2022-08-01 09:37:57 发布

阅读量105

点赞数

分类专栏：洛谷文章标签： c++ 深度优先算法

转载请注明出处，谢谢。

本文链接：https://blog.csdn.net/lxylluvio/article/details/126094675

版权

洛谷专栏收录该内容

33 篇文章 0 订阅

订阅专栏

这篇博客详细介绍了如何使用树剖和线段树解决动态维护区间信息的问题。首先，通过树剖计算节点的深度、大小、祖先等信息，然后进行拓扑排序。接着，博主利用线段树实现区间修改和查询操作，并在每次操作后更新区间和。整个过程展示了树剖和线段树在动态编程中的高效应用。

摘要由CSDN通过智能技术生成

又是裸的树剖。

#include <bits/stdc++.h>

#define int long long

using std::cin;
using std::cout;
using std::endl;
using std::ends;
using std::swap;
using std::vector;
using std::cerr;
using std::array;
using std::sort;
using std::greater;
using std::less;
using std::equal_to;
using std::greater_equal;
using std::less_equal;
using std::not_equal_to;
using std::atomic;
using std::set;
using std::map;
using std::unordered_set;
using std::unordered_map;
using std::multiset;
using std::multimap;
using std::unordered_multiset;
using std::unordered_multimap;
using std::bitset;
using std::numeric_limits;
using std::mt19937;
using std::valarray;
using std::pair;
using std::tuple;
using std::string;

const int N = (int) 5e5 + 233;

int dep[N];
int size[N];
int father[N];
vector <int> z[N];
int dfs_order[N];
int rank[N];
int cnt;
int top[N];
int len[N];
int a[N];
int w[N];
int n;
int m;

void dfs1(int now, int fa = -1) {
    dep[now] = dep[father[now]] + 1;
    size[now] = 1;
    for (auto &u : z[now]) {
        if (u == fa)
            continue ;
        father[u] = now;
        dfs1(u, now);
        size[now] += size[u];
    }
}

void dfs2(int now, int head, int fa = -1) {
    cnt ++;
    w[cnt] = a[now];
    dfs_order[cnt] = now;
    rank[now] = cnt;
    top[now] = head;
    len[head] ++;
    int p = -1;
    for (auto &u : z[now]) {
        if (u == fa)
            continue ;
        if (p == -1)
            p = u;
        else if (size[u] > size[p])
            p = u;
    }
    if (p == -1)
        return ;
    dfs2(p, head, now);
    for (auto &u : z[now])
        if (p != u)
            if (u != fa)
                dfs2(u, u, now);
}

struct Node {
    int l;
    int r;
    int sum;
    int lazy;
    Node () {
        l = 0;
        r = 0;
        sum = 0;
        lazy = 114514;
    }
    void init(int p) {
        l = r = p;
        sum = 0;
        lazy = 114514;
    }
    void color(int p) {
        sum = (r - l + 1) * p;
        lazy = p;
    }
} y[N];

Node operator + (const Node &lhs, const Node &rhs) {
    Node res;
    res.l = lhs.l;
    res.r = rhs.r;
    res.sum = lhs.sum + rhs.sum;
    res.lazy = 114514;
    return res;
}

void build(int l, int r, int rt) {
    if (l == r)
        y[rt].init(l);
    else {
        int mid = l + r >> 1;
        build(l, mid, rt << 1);
        build(mid + 1, r, rt << 1 | 1);
        y[rt] = y[rt << 1] + y[rt << 1 | 1];
    }
}

void push_lazy(int p) {
    if (y[p].lazy != 114514) {
        y[p << 1].color(y[p].lazy);
        y[p << 1 | 1].color(y[p].lazy);
        y[p].lazy = 114514;
    }
}

void modify(int l, int r, int rt, int nowl, int nowr, int v) {
    if (nowl <= l && r <= nowr)
        y[rt].color(v);
    else {
        push_lazy(rt);
        int mid = l + r >> 1;
        if (nowl <= mid)
            modify(l, mid, rt << 1, nowl, nowr, v);
        if (mid < nowr)
            modify(mid + 1, r, rt << 1 | 1, nowl, nowr, v);
        y[rt] = y[rt << 1] + y[rt << 1 | 1];
    }
}

int query(int l, int r, int rt, int nowl, int nowr) {
    if (nowl <= l && r <= nowr)
        return y[rt].sum;
    push_lazy(rt);
    int mid = l + r >> 1;
    int ans = 0;
    if (nowl <= mid)
        ans += query(l, mid, rt << 1, nowl, nowr);
    if (mid < nowr)
        ans += query(mid + 1, r, rt << 1 | 1, nowl, nowr);
    return ans;
}

void modify_link(int p1, int p2, int v) {
    while (true) {
        if (top[p1] == top[p2]) {
            if (dep[p1] > dep[p2])
                swap (p1, p2);
            modify(1, n, 1, rank[p1], rank[p2], v);
            break;
        }
        else {
            if (dep[top[p1]] < dep[top[p2]])
                swap (p1, p2);
            int p3 = top[p1];
            modify(1, n, 1, rank[p3], rank[p1], v);
            p1 = father[p3];
        }
    }
}

signed main() {
    // freopen ("output.txt", "w", stdout);
    cin >> n;
    for (int i = 1; i <= n; i ++)
        a[i] = 0;
    for (int i = 2; i <= n; i ++) {
        int x;
        cin >> x;
        z[x + 1].emplace_back(i);
        z[i].emplace_back(x + 1);
    }
    cin >> m;
    dfs1(1);
    dfs2(1, 1);
    build(1, n, 1);
    while (m --) {
        string opt;
        cin >> opt;
        int bef = y[1].sum;
        if (opt == "install") {
            int x;
            cin >> x;
            x ++;
            modify_link(1, x, 1);
        }
        else {
            int x;
            cin >> x;
            x ++;
            modify(1, n, 1, rank[x], rank[x] + size[x] - 1, 0);
        }
        int aft = y[1].sum;
        cout << abs(bef - aft) << '\n';
    }
    return 0;
}

#if 0

csp 2022 rp ++
noip 2022 rp ++

#endif