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 ui andvi.
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.
Sample test(s)
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
题意：一棵树只有一个顶点，然后由这个顶点引申出多条链，对于输入 0 v x d，代表把距离V节点距离在d以内的所有节点增加x，对于输入 1 v,代表查询v节点的值
思路：这道题参考别人的代码的时候，发现用到了树状数组，但是以前并没有做过树状数组，虽说能用树状数组做的题都能用线段树做，但是树状数组还是挺巧妙的，于是临时去看了一下树状数组的原理，最后结合别人的思想把这道题A了
首先我们对于一条链而言，当这个节点在链中，往下更新d的距离很好办，但是往上更新到1节点的时候，我们假设还有d的距离没有更新，如果我们一条条的去更新很容易超时，于是我们可以对于整棵树直接更新，即所有距离1为d的节点更新的状态都是一样的
使用new动态分配内存放置超内存
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <algorithm>
using namespace std;
#define ls 2*i
#define rs 2*i+1
#define up(i,x,y) for(i=x;i<=y;i++)
#define down(i,x,y) for(i=x;i>=y;i--)
#define mem(a,x) memset(a,x,sizeof(a))
#define w(a) while(a)
#define LL long long
const double pi = acos(-1.0);
#define N 100005
#define mod 19999997
const int INF = 0x3f3f3f3f;
#define exp 1e-8
//v点所在链的编号，所在层数，v在链上标号，各条链长度。
int mark[N],level[N],pos[N],length[N],id,deep;
vector<int> vec[N];
struct node
{
int *sum,n;
void init(int len)
{
n = len;
sum = new int[n+1];
memset(sum,0,(n+1)*sizeof(int));
}
int query(int i)
{
int ans = 0;
for(; i<=n; i+=i&-i)
ans+=sum[i];
return ans;
}
void add(int i,int x)
{
for(; i>0; i-=i&-i)
sum[i]+=x;
}
void updata(int l,int r,int x)//更新l~r区间
{
add(r,x);
add(l-1,-x);//多余的更新减去
}
} tree,*chain;
int dfs(int step,int u,int pre)
{
int i,n = vec[u].size(),v;
level[u] = step+1;//层数要加上1所在的那层
mark[u] = id;
pos[u] = step;//在链上的标号不算1节点，所以不加1
up(i,0,n-1)
{
v = vec[u][i];
if(v == pre) continue;
return dfs(step+1,v,u);
}
return step;
}
void init()
{
int i,n=vec[1].size(),len,v;
chain = new node[n];
level[1]=1;
up(i,0,n-1)//对每条链进行初始化
{
id = i;
v = vec[1][i];
len = dfs(1,v,1);
length[i]=len;
deep = max(len,deep);//找出最长的链的深度
chain[i].init(len);//更新每条链的深度
}
tree.init(++deep);//整棵树的深度
}
int query(int v)
{
int ans = 0;
ans = tree.query(level[v]);
if(v!=1)
{
ans+=chain[mark[v]].query(pos[v]);
}
return ans;
}
void updata(int v,int x,int d)
{
int l,r;
if(v == 1)
{
if(deep>=1+d) r = 1+d;//比较树深度与d的深度来确定更新深度
else r = deep;
tree.updata(1,r,x);
return;
}
//对于每条链，r代表往下更新的深度，l代表往上更新的深度，先更新到1节点为止
if(length[mark[v]]>=pos[v]+d) r = pos[v]+d;
else r = length[mark[v]];
if(1<=pos[v]-d) l = pos[v]-d;
else l = 1;
chain[mark[v]].updata(l,r,x);
d-=level[v]-1;
if(d>=0)//到了1节点还有剩下
{
if(deep>=1+d) r = 1+d;//以1节点为原点，更新所有链，深度为r
else r = deep;
tree.updata(1,r,x);
if(r>=2)//对于要求的点，由于更新了两次，要减去这次的更新
{
if(length[mark[v]]>=r-1) r = r-1;
else r = length[mark[v]];
chain[mark[v]].updata(1,r,-x);
}
}
}
int main()
{
int i,n,q,x,y;
scanf("%d%d",&n,&q);
up(i,1,n-1)
{
scanf("%d%d",&x,&y);
vec[x].push_back(y);
vec[y].push_back(x);
}
init();
int cas,v,d;
w(q--)
{
scanf("%d%d",&cas,&v);
if(!cas)
{
scanf("%d%d",&x,&d);
updata(v,x,d);
}
else
printf("%d\n",query(v));
}
return 0;
}