題目鏈接
給你一棵樹，每個結點有權值，距離是兩點間邊的條數，帶修改操作的，多次詢問距離u點距離小於等於d的點的點權之和。
很容易想到是我們可以利用動態點分治來維護這個信息，然後就是在點分樹上不斷的向上跳，接下去就是要查詢一個前綴和的問題了，也就是距離小於等於d的點的點權前綴和，於是，可以用樹狀數組來維護這個信息，時間複雜度是
有些小細節。
我們在查詢的時候，不能遇到此時的距離已經是
然後更新答案的時候，千萬不要更新錯了，是用將要變成的值減去原始值，相當於是“覆蓋”這樣的操作。
一個點分樹上的點，到其子結點點分樹的點的距離，是一定小於等於子結點點分樹的點的個數的。
然後我們要開兩個樹狀數組，分別維護的是子樹所有點到子樹根結點的距離權值前綴和、子樹所有點到子樹的點分樹的父節點的距離的權值前綴和。
然後，就是一個冗斥的思想，多的部分就不斷的減去，即可。
#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 1e5 + 7;
int N, Q, head[maxN], cnt, LOG_2[maxN << 1], a[maxN];
struct Eddge
{
int nex, to;
Eddge(int a=-1, int b=0):nex(a), to(b) {}
} edge[maxN << 1];
void addEddge(int u, int v)
{
edge[cnt] = Eddge(head[u], v);
head[u] = cnt++;
}
void _add(int u, int v) { addEddge(u, v); addEddge(v, u); }
struct Grand_Father
{
int deep[maxN], euler[maxN << 1], Esiz, rid[maxN];
void dfs(int u, int fa)
{
deep[u] = deep[fa] + 1; rid[u] = Esiz + 1;
for(int i=head[u], v; ~i; i=edge[i].nex)
{
v = edge[i].to;
if(v == fa) continue;
euler[++Esiz] = u;
dfs(v, u);
}
euler[++Esiz] = u;
}
int mn[maxN << 1][20];
void RMQ_Init()
{
for(int i=1; i<=Esiz; i++) mn[i][0] = euler[i];
for(int j=1; (1 << j) <= Esiz; j++)
{
for(int i=1; i + (1 << j) - 1 <= Esiz; i++)
{
if(deep[mn[i][j - 1]] < deep[mn[i + (1 << (j - 1))][j - 1]]) mn[i][j] = mn[i][j - 1];
else mn[i][j] = mn[i + (1 << (j - 1))][j - 1];
}
}
}
int Rmq(int l, int r)
{
int det = r - l + 1, kk = LOG_2[det];
if(deep[mn[l][kk]] <= deep[mn[r - (1 << kk) + 1][kk]]) return mn[l][kk];
else return mn[r - (1 << kk) + 1][kk];
}
int _LCA(int u, int v)
{
int l = rid[u], r = rid[v];
if(l > r) swap(l, r);
return Rmq(l, r);
}
int _Dis(int u, int v)
{
int lca = _LCA(u, v);
return deep[u] + deep[v] - 2 * deep[lca];
}
void clear() { Esiz = 0; }
} A_lca;
int siz[maxN], son[maxN], father[maxN];
int root, all, maxx;
bool vis[maxN];
void findroot(int u, int fa)
{
siz[u] = 1; son[u] = 0;
for(int i=head[u], v; ~i; i=edge[i].nex)
{
v = edge[i].to;
if(vis[v] || v == fa) continue;
findroot(v, u);
siz[u] += siz[v];
son[u] = max(son[u], siz[v]);
}
son[u] = max(son[u], all - siz[u]);
if(maxx > son[u]) { root = u; maxx = son[u]; }
}
struct BIT_Tree
{
vector<int> tree;
int _UP;
void init(int n)
{
_UP = n; tree.clear();
for(int i=0; i<=n; i++) tree.push_back(0);
}
void update(int x, int val)
{
if(!x) return;
while(x <= _UP)
{
tree[x] += val;
x += lowbit(x);
}
}
int query(int x)
{
int sum = 0; x = min(x, _UP);
while(x)
{
sum += tree[x];
x -= lowbit(x);
}
return sum;
}
} b[maxN], bf[maxN];
void Get_Dis(int u, int fa)
{
int dis_Fa, dis_rt;
dis_rt = A_lca._Dis(root, u);
b[root].update(dis_rt, a[u]);
if(father[root])
{
dis_Fa = A_lca._Dis(father[root], u);
bf[root].update(dis_Fa, a[u]);
}
for(int i=head[u], v; ~i; i=edge[i].nex)
{
v = edge[i].to;
if(vis[v] || v == fa) continue;
Get_Dis(v, u);
}
}
void Divide(int u)
{
vis[u] = true;
b[u].init(all + 1); bf[u].init(all + 1);
Get_Dis(u, 0);
int totsiz = all;
for(int i=head[u], v; ~i; i=edge[i].nex)
{
v = edge[i].to;
if(vis[v]) continue;
all = siz[v] > siz[u] ? totsiz - siz[u] : siz[v];
maxx = INF; root = 0;
findroot(v, 0);
father[root] = u;
Divide(root);
}
}
void change(int u, int x)
{
int p, dis, cop_u = u;
a[u] = x;
while(u)
{
p = father[u];
if(p)
{
dis = A_lca._Dis(p, cop_u);
bf[u].update(dis, x);
}
dis = A_lca._Dis(u, cop_u);
b[u].update(dis, x);
u = p;
}
}
int ask(int u, int d)
{
int ans = 0, p, cop_u = u, dis;
while(u)
{
p = father[u];
if(p)
{
dis = A_lca._Dis(p, cop_u);
if(d - dis > 0) ans -= bf[u].query(d - dis);
}
dis = A_lca._Dis(u, cop_u);
if(d - dis >= 0) ans += b[u].query(d - dis) + a[u];
u = p;
}
return ans;
}
void init()
{
cnt = 0; A_lca.clear();
for(int i=1; i<=N; i++) { head[i] = -1; vis[i] = false; }
}
int main()
{
for(int i = 1, j = 2, k = 0; i <= 200000; i++)
{
if(i == j) { j <<= 1; k ++; }
LOG_2[i] = k;
}
while(scanf("%d%d", &N, &Q) != EOF)
{
init();
for(int i=1; i<=N; i++) scanf("%d", &a[i]);
for(int i=1, u, v; i<N; i++)
{
scanf("%d%d", &u, &v);
_add(u, v);
}
A_lca.dfs(1, 0);
A_lca.RMQ_Init();
all = N; maxx = INF;
findroot(1, 0); father[root] = 0;
Divide(root);
char op[3];
for(int i=1, u, x; i<=Q; i++)
{
scanf("%s%d%d", op, &u, &x);
if(op[0] == '?')
{
printf("%d\n", ask(u, x));
}
else
{
change(u, x - a[u]);
a[u] = x;
}
}
}
return 0;
}