Codeforces 396C on changing Tree

On changing treetime limit:2000msmemory limit:262144kbthis problem would be judged onCodeforces. Original id:396c
64-bit integer IO format: %i64d Java class name: (any) You are given a rooted tree consisting of n vertices numbered from 1 to n. The root of the tree is a vertex number 1.

Initially all vertices contain number 0. Then come q queries, each query has one of the types:

• the format of the Query: 1  v   x   K . In response to the query, you need to add to the number at Vertex  v  number  x , to the numbers at The descendants of Vertex  v  at distance 1, add x - k ; and so on, to the numbers written in the descendants of Vertex  v  at distance  i , you need to Add  x -( i • K ). The distance between and vertices are the number of edges in the shortest path between these vertices.
• The format of the query: 2 v. In reply to the query should print the number written in vertex v modulo 1000000007 (9 + 7) .

Process the queries given in the input.

Input

The first line contains an integer n (1≤ n ≤3 105)-the number of vertices in the tree. The second line contains n -1 integers p2, p3, ... P n (1≤ pi < i), where pI is the number of the vertex, that's the parent of vertex i in the tree.

The third line contains integerQ(1≤Q≤3 105)-the number of queries. Next q lines contain the queries, one per line. The first number in the line is type. It represents the type of the query. If Type = 1, then next follow space-separated integers v, x, k (1≤v ≤ n;  0≤ x <9 + 7; 0≤ k <9 + 7). If Type = 2, then next follows integer v (1≤ v ≤ n)-the vert Ex where you need to find the value of the number.

Output

For each query of the second type, print on a, the number written in the vertex from the query. Print the number modulo 1000000007 (9 + 7).

Sample InputInput

3
1 1
3
1 1 2 1
2 1
2 2

Output

2
1

Hint

You can read on a rooted tree here: http://en.wikipedia.org/wiki/Tree_ (graph_theory).

Source

Codeforces Round #232 (Div. 1) Solve a problem: A tree array or segment tree gives a tree with 1 roots, which is the parent node of each node starting from Node 2, and then the M operation, which is divided into two types, 1 V, X, K, which is added on the word "V" as its root. The added rule is to look at the node's distance to the V node as I, plus x-i*k;2 v to query the value of Node v. Discover the nature of the addition, maintaining two tree arrays to the C1 node represents the interval plus x + d[u]*k to the second tree array plus d[u]*k assume you are the parent node of V when calculating V can be used $ x + d[u]*k-d[v]*k $ exactly what we want $x + K\tim ES (D[u]-d[v]) $

 
 
 1 #include <bits/stdc++.h>
 2 using namespace std;
 3 typedef long long LL;
 4 const int maxn = 300010;
 5 const int mod = 1000000007;
 6 vector<int>g[maxn];
 7 LL c[2][maxn],val[2];
 8 int n,m,L[maxn],R[maxn],d[maxn],clk;
 9 void update(int i){
10     while(i < maxn){
11         c[0][i] += val[0];
12         c[1][i] += val[1];
13         c[0][i] %= mod;
14         c[1][i] %= mod;
15         i += i&-i;
16     }
17 }
18 LL query(int i){
19     LL sum[2] = {0},dep = d[i];
20     i = L[i];
21     while(i > 0){
22         sum[0] += c[0][i];
23         sum[1] += c[1][i];
24         sum[0] %= mod;
25         sum[1] %= mod;
26         i -= i&-i;
27     }
28     return ((sum[0] - dep*sum[1])%mod + mod)%mod;
29 }
30 void dfs(int u,int dep){
31     L[u] = ++clk;
32     d[u] = dep;
33     for(int i = g[u].size()-1; i >= 0; --i)
34         dfs(g[u][i],dep+1);
35     R[u] = clk;
36 }
37 int main(){
38     int u,op,x,y,z;
39     while(~scanf("%d",&n)){
40         for(int i = clk = 0; i <= n; ++i) g[i].clear();
41         for(int i = 2; i <= n; ++i){
42             scanf("%d",&u);
43             g[u].push_back(i);
44         }
45         dfs(1,0);
46         memset(c,0,sizeof c);
47         scanf("%d",&m);
48         while(m--){
49             scanf("%d%d",&op,&x);
50             if(op == 1){
51                 scanf("%d%d",&y,&z);
52                 val[0] = ((LL)y + (LL)d[x]*z)%mod;
53                 val[1] = z;
54                 update(L[x]);
55                 val[0] = -val[0];
56                 val[1] = -val[1];
57                 update(R[x]+1);
58             }else printf("%I64d\n",query(x));
59         }
60     }
61     return 0;
62 }

Codeforces 396C on changing Tree