ACM-ICPC 2018 沈阳赛区网络预赛 J. Ka Chang（树状数组+分块）

题目链接：https://nanti.jisuanke.com/t/31451

题目大意：现在给出一棵包含n个结点的有根树，根节点为1，且根节点的深度为0。接下来进行q次操作，每次操作有以下两种操作：

1 L x ：将深度为L的结点的值加上x；

2 x ：查询x的子树所有结点的权值和。

题目思路：考虑到要查询子树，我们很容易就能想到用dfs序 + 树状数组来解决。对于修改操作，如果暴力去更新的话，时间复杂度肯定是不合理的。在dfs的过程中，我们可以将所有结点的深度记录下来，并用一个vector来记录各个深度有哪些结点。

接下来对于操作1我们考虑两种情况，一种情况是深度为L的结点个数小于等于sqrt(n)，这些结点我们可以采用暴力更新，另一种情况我们可以将这些深度存起来，并将这些深度的更新情况用一个数组记录下来。

这样在查询的时候，对于x的子树中深度结点个数小于sqrt(n)的部分可以直接用树状数组进行查询，而另一部分就可以用存起来的深度进行算贡献。这样优化之后均摊的复杂度是可以被接受的。

具体实现看代码：

#include <bits/stdc++.h>
#define fi first
#define se second
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define pb push_back
#define MP make_pair
#define lowbit(x) x&-x
#define clr(a) memset(a,0,sizeof(a))
#define _INF(a) memset(a,0x3f,sizeof(a))
#define FIN freopen("in.txt","r",stdin)
#define IOS ios::sync_with_stdio(false)
#define fuck(x) cout<<"["<<#x<<" "<<(x)<<"]"<<endl
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll>pll;
typedef pair<int, int>pii;
typedef vector<int> VI;
const int inf = 0x3f3f3f3f;
const int MX = 1e5 + 7;
const int mod = 1e9 + 7;

int n, q;
int in[MX], out[MX], dep[MX], dfn;
bool vis[MX];
ll tag[MX];
VI deep[MX], E[MX], ver;
void pre_init(int _n) {
	dfn = 0; ver.clear();
	for (int i = 0; i <= _n; i++) {
		deep[i].clear();
		E[i].clear();
		tag[i] = vis[i] = 0;
	}
}
struct BIT {
	ll a[MX];
	void init(int _n) {
		for (int i = 0; i <= _n; i++) a[i] = 0;
	}
	void add(int x, ll d) {
		for (int i = x; i <= n; i += lowbit(i))
			a[i] += d;
	}
	ll sum(int x) {
		ll res = 0;
		for (int i = x; i; i -= lowbit(i))
			res += a[i];
		return res;
	}
	ll query(int l, int r) {
		return sum(r) - sum(l - 1);
	}
} T;
void dfs(int u, int fa, int d) {
	dep[u] = d; in[u] = ++dfn;
	deep[d].pb(dfn);
	for (auto v : E[u]) {
		if (v == fa) continue;
		dfs(v, u, d + 1);
	}
	out[u] = dfn;
}

int main() {
	while (~scanf("%d%d", &n, &q)) {
		pre_init(n);
		for (int i = 1; i < n; i++) {
			int u, v;
			scanf("%d%d", &u, &v);
			E[u].pb(v); E[v].pb(u);
		}
		dfs(1, 0, 0);
		for (int i = 0; i <= n; i++) sort(deep[i].begin(), deep[i].end());
		int limt = (int)sqrt(n + 0.5);
		T.init(n);
		int op, L, x;
		while (q--) {
			scanf("%d", &op);
			if (op == 1) {
				scanf("%d%d", &L, &x);
				if (L > n) continue;
				int sz = deep[L].size();
				if (sz <= limt) {
					for (auto it : deep[L]) T.add(it, x);
				} else {
					if (!vis[L]) {
						ver.pb(L);
						vis[L] = 1;
					}
					tag[L] += x;
				}
			} else {
				scanf("%d", &x);
				ll ans = T.query(in[x], out[x]);
				for (auto nw : ver) {
					if (nw < dep[x]) continue;
					int lb = lower_bound(deep[nw].begin(), deep[nw].end(), in[x]) - deep[nw].begin();
					int rb = upper_bound(deep[nw].begin(), deep[nw].end(), out[x]) - deep[nw].begin();
					ans += tag[nw] * (rb - lb);
				}
				printf("%lld\n", ans);
			}
		}
	}
	return 0;
}