题目
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,很简单,树状数组单点修改,时间复杂度
O
(
l
o
g
n
)
O(log \;n)
O(logn)。
对于操作 2,我们则需要枚举
i
∈
[
l
,
r
]
i\in[l,r]
i∈[l,r],对于每一个
i
i
i ,用树状数组查询子树和,时间复杂度
O
(
n
l
o
g
n
)
O(n \;log\;n)
O(nlogn),暴毙了。
于是,我们想到了优雅的暴力——分块。
将
n
n
n 个点分块,每块长度
n
\sqrt n
n,分完块后,再次分析:
记
s
u
m
i
sum_i
sumi 为第
i
i
i 个块的总和。
对于操作 1,我们不仅要进行树状数组单点修改的操作,还需要统计一下修改当前点
x
x
x 对每个块所产生的影响。记
g
i
,
j
g_{i,j}
gi,j 为点
i
i
i 对块
j
j
j 的贡献,也就是说,修改
i
i
i 对第
j
j
j 块来说影响了几个点。显然
i
i
i 只会影响
i
i
i 的祖先,所以求
g
g
g 数组可以在 dfs 中处理,记录好祖先所在的块即可。回到操作,我们枚举每个块
i
i
i,对于每个
s
u
m
i
sum_i
sumi 加上对应的值(
△
a
[
x
]
×
g
x
,
i
△a[x]\times g_{x,i}
△a[x]×gx,i)。时间复杂度
O
(
n
)
O(\sqrt n)
O(n)。
对于操作 2,典型的分块查询。两端的散点直接用树状数组查,中间的整块直接是
s
u
m
sum
sum 数组的值,累加起来即可。时间复杂度
O
(
n
)
O(\sqrt n)
O(n)。
总时间复杂度
O
(
m
n
)
O(m \sqrt n)
O(mn)
注意空间,注意 s u m sum sum 数组的预处理,注意数据范围会爆 long long,要用 unsigned long long。
思维链:dfs序+树状数组 → → → 暴毙 → → → 分块 → → → 如何维护整块? → → → 每次修改对块的影响 → → → 记录 g g g 数组 → → → 如何处理散点? → → → 依旧树状数组
代码
#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;
}