【BZOJ 4765】普通计算姬（树状数组，分块）

t14

已于 2022-07-16 00:03:06 修改

阅读量177

点赞数

分类专栏：树状数组 # 分块数据结构文章标签：算法

于 2022-07-15 23:55:08 首次发布

本文链接：https://blog.csdn.net/t14zack/article/details/125814045

版权

数据结构同时被 3 个专栏收录

15 篇文章 0 订阅

订阅专栏

分块

3 篇文章 0 订阅

订阅专栏

树状数组

2 篇文章 0 订阅

订阅专栏

本文介绍了如何使用DFS遍历和分块技术高效地处理计算姬的问题，通过树状数组和动态维护子树和，解决了在带权树上进行单点修改和区间和查询的挑战。通过记录修改影响和分块处理，降低了操作2的时间复杂度至O(n√n)。

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

题目

题目传送门

Description

“奋战三星期，造台计算机”。小G响应号召，花了三小时造了台普通计算姬。普通计算姬比普通计算机要厉害一些
。普通计算机能计算数列区间和，而普通计算姬能计算树中子树和。更具体地，小G的计算姬可以解决这么个问题
：给定一棵n个节点的带权树，节点编号为1到n，以root为根，设sum[p]表示以点p为根的这棵子树中所有节点的权
值和。计算姬支持下列两种操作:
1 给定两个整数u,v，修改点u的权值为v。
2 给定两个整数l,r，计算sum[l]+sum[l+1]+…+sum[r-1]+sum[r]
尽管计算姬可以很快完成这个问题，可是小G并不知道它的答案是否正确，你能帮助他吗？

Input

第一行两个整数n,m，表示树的节点数与操作次数。
接下来一行n个整数，第i个整数di表示点i的初始权值。
接下来n行每行两个整数ai,bi，表示一条树上的边，若ai=0则说明bi是根。
接下来m行每行三个整数，第一个整数op表示操作类型。
若op=1则接下来两个整数u,v表示将点u的权值修改为v。
若op=2则接下来两个整数l,r表示询问。
N<=10^5 ,M<=10^5
0<=Di,V<2^31,1<=L<=R<=N,1<=U<=N

Output

对每个操作类型2输出一行一个整数表示答案。

Sample Input

6 4
0 0 3 4 0 1
0 1
1 2
2 3
2 4
3 5
5 6
2 1 2
1 1 1
2 3 6
2 3 5

Sample Output

16
10
9

思路

对于维护子树的题目，我们会想到 dfs序 +树状数组，因为对于一颗子树，其 dfs序是连续的一段区间。
题目有两种操作：1.单点修改，2.区间子树和查询。
对单词操作进行分析：
对于操作 1，很简单，树状数组单点修改，时间复杂度 $\;n)$ 。
对于操作 2，我们则需要枚举 $i\in[l,r]$ ，对于每一个 $i$ ，用树状数组查询子树和，时间复杂度 $\;log\;n)$ ，暴毙了。

于是，我们想到了优雅的暴力——分块。
将 $n$ 个点分块，每块长度 $\sqrt n$ ，分完块后，再次分析：
记 $sum_i$ 为第 $i$ 个块的总和。
对于操作 1，我们不仅要进行树状数组单点修改的操作，还需要统计一下修改当前点 $x$ 对每个块所产生的影响。记 $g_{i,j}$ 为点 $i$ 对块 $j$ 的贡献，也就是说，修改 $i$ 对第 $j$ 块来说影响了几个点。显然 $i$ 只会影响 $i$ 的祖先，所以求 $g$ 数组可以在 dfs 中处理，记录好祖先所在的块即可。回到操作，我们枚举每个块 $i$ ，对于每个 $sum_i$ 加上对应的值（ $△a[x]\times g_{x,i}$ ）。时间复杂度 $O(\sqrt n)$ 。
对于操作 2，典型的分块查询。两端的散点直接用树状数组查，中间的整块直接是 $s u m$ 数组的值，累加起来即可。时间复杂度 $O(\sqrt n)$ 。
总时间复杂度 $\sqrt n)$

注意空间，注意 $s u m$ 数组的预处理，注意数据范围会爆 long long，要用 unsigned long long。

思维链：dfs序+树状数组 $\to$ 暴毙 $\to$ 分块 $\to$ 如何维护整块？ $\to$ 每次修改对块的影响 $\to$ 记录 $g$ 数组 $\to$ 如何处理散点？ $\to$ 依旧树状数组

代码

#include <bits/stdc++.h>
#define rep(i, a, b) for (register int i(a); i <= b; ++i)
#define per(i, a, b) for (register int i(a); i >= b; --i)
#define FILE(s) freopen(s".in", "r", stdin), freopen(s".out", "w", stdout)
#define mem(a, x) memset(a, x, sizeof a)
#define pb push_back
#define umap unordered_map
#define pqueue priority_queue
#define mp make_pair
#define PI acos(-1)
// #define int long long

using namespace std;
typedef unsigned long long ll;
// typedef unsigned long long ull;
int n, m, siz, num, blo[100005], rt, tot;
int xianren[100005], g[100005][321], l[100005], r[100005];
ll a[100005], sum[321];
vector <int> e[100005];

template <typename _T>
void rd(_T &x) {
    int f = 1; x = 0;
    char s = getchar();
    while (s > '9' || s < '0') {if (s == '-') f = -1; s = getchar();}
    while (s >= '0' && s <= '9') x = (x<<3)+(x<<1)+(s^48), s = getchar();
    x *= f;
}

template <typename _T>
void write(_T x) {
    if (x < 0) putchar('-'), x = -x;
    if (x > 9) write(x/10);
    putchar(x%10+'0');
    return ;
}

struct BIT {
    ll tr[100005];

    inline int lowbit(int x) {
        return x & (-x);
    }

    void add(int x, ll c) {
        while (x <= n) {
            tr[x] += c;
            x += lowbit(x);
        }
        return ;
    }

    ll query(int x) {
        ll ret = 0ll;
        while (x != 0) {
            ret += tr[x];
            x -= lowbit(x);
        }
        return ret;
    }
} Tr;

void dfs(int x, int fa) {
    ++xianren[blo[x]];
    rep(i, 1, num) g[x][i] = xianren[i];
    l[x] = ++tot;
    for (auto y : e[x]) {
        if (y == fa) continue;
        dfs(y, x);
    }
    r[x] = tot;
    --xianren[blo[x]];
    return ;
}

int main() {
    rd(n), rd(m);
    siz = (int)(sqrt(n));
    num = n/siz;
    if (n%siz != 0) ++num;
    rep(i, 1, n) rd(a[i]), blo[i] = (i-1)/siz+1;
    rep(i, 1, n) {
        int x, y; rd(x), rd(y);
        if (x == 0) rt = y;
        else e[x].pb(y), e[y].pb(x);
    }
    dfs(rt, 0);
    rep(i, 1, n) Tr.add(l[i], a[i]);
    rep(i, 1, n) sum[blo[i]] += Tr.query(r[i])-Tr.query(l[i]-1);
    while (m--) {
        int opt; rd(opt);
        if (opt == 1) {
            ll x, y; rd(x), rd(y);
            Tr.add(l[x], y-a[x]);
            rep(i, 1, num) sum[i] += 1llu*g[x][i]*(y-a[x]);
            a[x] = y;
        } else {
            int x, y; rd(x), rd(y);
            ll ans = 0ll;
            if (blo[x] == blo[y]) {
                for (register int i = x; i <= y; ++i) ans += Tr.query(r[i])-Tr.query(l[i]-1);
            } else {
                for (register int i = x; blo[i] == blo[x]; ++i) ans += Tr.query(r[i])-Tr.query(l[i]-1);
                rep(i, blo[x]+1, blo[y]-1) ans += sum[i];
                for (register int i = y; blo[i] == blo[y]; --i) ans += Tr.query(r[i])-Tr.query(l[i]-1);
            }
            printf("%llu\n", ans);
        }
    }
    return 0;
}

t14

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【BZOJ 4765】普通计算姬（树状数组，分块）

目录题目DescriptionInputOutputSample InputSample Output思路代码题目题目传送门Description“奋战三星期，造台计算机”。小G响应号召，花了三小时造了台普通计算姬。普通计算姬比普通计算机要厉害一些。普通计算机能计算数列区间和，而普通计算姬能计算树中子树和。更具体地，小G的计算姬可以解决这么个问题：给定一棵n个节点的带权树，节点编号为1到n，以root为根，设sum[p]表示以点p为根的这棵子树中所有节点的权值和。计算姬支持下
复制链接

扫一扫

专栏目录