【Codeforces Round 169 (Div 2) E】【数据结构区间维护】Little Girl and Problem on Trees 大菊花树的距离性修改查询

E. Little Girl and Problem on Trees

time limit per test
2 seconds

memory limit per test
256 megabytes

input
standard input

output
standard output

A little girl loves problems on trees very much. Here's one of them.

A tree is an undirected connected graph, not containing cycles. The degree of node x in the tree is the number of nodes y of
the tree, such that each of them is connected with node x by some edge of the tree.

Let's consider a tree that consists of n nodes. We'll consider the tree's nodes indexed from 1 to n.
The cosidered tree has the following property: each node except for node number 1 has the degree of at most 2.

Initially, each node of the tree contains number 0. Your task is to quickly process the requests of two types:

Request of form: 0 v x d.
In reply to the request you should add x to all numbers that are written in the nodes that are located at the distance of at most d from
node v. The distance between two nodes is the number of edges on the shortest path between them.

Request of form: 1 v.
In reply to the request you should print the current number that is written in node v.

Input

The first line contains integers n (2 ≤ n ≤ 105)
and q (1 ≤ q ≤ 105)
— the number of tree nodes and the number of requests, correspondingly.

Each of the next n  -  1 lines contains two integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi),
that show that there is an edge between nodes uiand vi.
Each edge's description occurs in the input exactly once. It is guaranteed that the given graph is a tree that has the property that is described in the statement.

Next q lines describe the requests.

The request to add has the following format: 0 v x d (1 ≤ v ≤ n, 1 ≤ x ≤ 104, 1 ≤ d < n).

The request to print the node value has the following format: 1 v (1 ≤ v ≤ n).

The numbers in the lines are separated by single spaces.

Output

For each request to print the node value print an integer — the reply to the request.

Examples

input

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

output

9
9
6

input

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

output

11
17
11
16
17
11

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<string>
#include<ctype.h>
#include<math.h>
#include<set>
#include<map>
#include<vector>
#include<queue>
#include<bitset>
#include<algorithm>
#include<time.h>
using namespace std;
void fre() { freopen("c://test//input.in", "r", stdin); freopen("c://test//output.out", "w", stdout); }
#define MS(x, y) memset(x, y, sizeof(x))
#define ls o<<1
#define rs o<<1|1
#define mid (l+r>>1)
#define lson o<<1,l,mid
#define rson o<<1|1,mid+1,r
#define rt 1,1,n
typedef long long LL;
typedef unsigned long long UL;
typedef unsigned int UI;
template <class T1, class T2>inline void gmax(T1 &a, T2 b) { if (b > a)a = b; }
template <class T1, class T2>inline void gmin(T1 &a, T2 b) { if (b < a)a = b; }
const int N = 1e5 + 10, M = 0, Z = 1e9 + 7, inf = 0x3f3f3f3f;
template <class T1, class T2>inline void gadd(T1 &a, T2 b) { a = (a + b) % Z; }
int casenum, casei;
int n, Q;
vector<int>a
;
int dep
, mxdep
;
int pos
, tim;
void dfs(int x, int fa)
{
pos[x] = ++tim;
dep[x] = dep[fa] + 1;
mxdep[x] = dep[x];
for (auto y : a[x])if (y != fa)
{
dfs(y, x);
gmax(mxdep[x], mxdep[y]);
}
}
LL bit
;
void add(int x, int val)
{
for (; x; x -= x&-x)bit[x] += val;
}
LL check(int x)
{
LL ret = 0;
for (; x <= n; x += x&-x)ret += bit[x];
return ret;
}
int L, R, P, V;
struct SGT
{
LL val[1 << 18], flag[1 << 18];
void build(int o, int l, int r)
{
val[o] = flag[o] = 0;
if (l == r)return;
build(lson);
build(rson);
}
void pushdown(int o)
{
if (flag[o])
{
flag[ls] += flag[o];
flag[rs] += flag[o];
val[ls] += flag[o];
val[rs] += flag[o];
flag[o] = 0;
}
}
LL check(int o, int l, int r)
{
if (l == r)return val[o];
pushdown(o);
if (P <= mid)return check(lson);
else return check(rson);
}
void add(int o, int l, int r)
{
if (L <= l && r <= R)
{
flag[o] += V;
val[o] += V;
return;
}
pushdown(o);
if (L <= mid)add(lson);
if (R > mid)add(rson);
}
}sgt;
int main()
{
while (~scanf("%d%d", &n, &Q))
{
for (int i = 1; i <= n; ++i)
{
a[i].clear();
bit[i] = 0;
}
for (int i = 1; i < n; ++i)
{
int x, y; scanf("%d%d", &x, &y);
a[x].push_back(y);
a[y].push_back(x);
}
tim = 0; dep[0] = 0; dfs(1, 0);
sgt.build(rt);
for (int i = 1; i <= Q; ++i)
{
int op, x, dis;
scanf("%d%d", &op, &x);
if (op == 0)
{
scanf("%d%d", &V, &dis);
if (dis >= dep[x] - dep[1])//能覆盖到根
{
int outdep = dep[1] + (dis - dep[x] + 1); gmin(outdep, n);
add(outdep, V);
int mxgodep = min(mxdep[x], dep[x] + dis);
if (outdep < mxgodep)
{
L = pos[x] + outdep + 1 - dep[x];
R = pos[x] + mxgodep - dep[x];
sgt.add(rt);
}
}
else //无法覆盖到根
{
int mngodep = dep[x] - dis;
int mxgodep = min(mxdep[x], dep[x] + dis);
L = pos[x] - (dep[x] - mngodep);
R = pos[x] + (mxgodep - dep[x]);
sgt.add(rt);
}
}
else
{
P = pos[x];
LL ans1 = check(dep[x]);
LL ans2 = sgt.check(rt);
printf("%lld\n", ans1 + ans2);
}
}
}
return 0;
}
/*
【题意】
怎么静下心来读懂题是非常重要的~
这道题给出一棵节点数为n（1e5）的树，树上每个点，除了根节点，最多度数为2。
这说明这棵树，是若干条链连在了1号节点上。
一开始，所有节点的权值都为0
我们有两种操作——
0 x val dis ：我们对于所有距离x不超过dis的节点，加权val
1 x ：查询节点x的权值是多少

【分析】
首先，我们知道了树的结构是这样子的，若干条链连在了1号节点上。

于是，对于操作0，其操作可以被拆分为——
<1> 生成了由根节点1发散出的等距离波的变动
<2> 生成了一段链上的变动

我们拆分之后，分别用数据结构做区间维护即可。

*/