FOJ2277(dfs序 + 树状数组区间更新)

Problem 2277 Change
Accept: 91 Submit: 450
Time Limit: 2000 mSec Memory Limit : 262144 KB

Problem Description

There is a rooted tree with n nodes, number from 1-n. Root’s number is 1.Each node has a value ai.

Initially all the node’s value is 0.

We have q operations. There are two kinds of operations.

1 v x k : a[v]+=x , a[v’]+=x-k (v’ is child of v) , a[v’’]+=x-2*k (v’’ is child of v’) and so on.

2 v : Output a[v] mod 1000000007(10^9 + 7).

Input

First line contains an integer T (1 ≤ T ≤ 3), represents there are T test cases.

In each test case:

The first line contains a number n.

The second line contains n-1 number, p2,p3,…,pn . pi is the father of i.

The third line contains a number q.

Next q lines, each line contains an operation. (“1 v x k” or “2 v”)

1 ≤ n ≤ 3*10^5

1 ≤ pi < i

1 ≤ q ≤ 3*10^5

1 ≤ v ≤ n; 0 ≤ x < 10^9 + 7; 0 ≤ k < 10^9 + 7

Output

For each operation 2, outputs the answer.

Sample Input

1
3
1 1
3
1 1 2 1
2 1
2 2
Sample Output

2
1
Source

第八届福建省大学生程序设计竞赛-重现赛（感谢承办方厦门理工学院）

解题思路：这种东西肯定是要把对树的操作弄到一个数据结构上去维护，刚开始想用树链剖分，但是因为更新一个点，以这个节点为根的子树都要改变，这样话，每次更新可能改变的链有很多条，于是树链剖分肯定是不行的，我们考虑一下dfs序，因为dfs序把一棵子树上的点都在一段连续的区间，那么到底要维护什么东西呢？

我们考虑一般情况，假设我们当前更新v节点，其中x = x1, k = k1,v节点子树上的一个节点s，于是v节点更新的值就是x1 + (depth[v] - depth[s]) * k1，其中depth[i]表示节点i的深度，我们化简上面式子可以得到为：x1 + depth[v] * k1 - depth[s]k1,观察式子可以得到，对于一次更新，每个受影响的节点(以v为根的子树上所有的节点）都加上了一个相同的数x1 + depth[v] k1,然后还要减去一个数k1 * depth[s],前者我们可以用树状数组区间维护更新维护就行，后者也同样可以这样维护，因为每个节点的depth[s]是不变的，每次更新改变的只是k的值，而且k的值是满足可加减性的，所以我们也要用树状数组维护一下k的值。下面简单的证明一下上面的做法：
假设更新节点v,x = x1, k = k1,更新节点u， x = x2, k = k2.节点s既是v，又是u的子树上的节点，我们单独考虑节点u, v更新对节点s的影响，先考虑v：a[v] = x1 + depth[v] * k1 - depth[s] * k1,a[u] = x2 + depth[u] * k2 - depth[s] * k2;那么我们把两者相加可以得到a[v] + a[u] = x1 + x2 + depth[v]k1 + depth[u] k2 - (k1 + k2) * depth[s],黑体的部分就表明了k的可加性了。除了树状数组，线段树也应该能够做。

#include <iostream>#include <stdio.h>#include <cmath>#include <algorithm>#include <vector>#include <cstring>using namespace std;typedef long long ll;const ll mod = 1e9 + 7;const int maxn = 3e5 + 10;int n, q;int depth[maxn];int Rank[maxn];vector<int> g[maxn];ll TreeK[maxn];ll TreeX[maxn];int L[maxn];int R[maxn];int res;int root;void init(){    res = 0;    root = 1;    memset(TreeK, 0, sizeof(TreeK));    memset(TreeX, 0, sizeof(TreeX));    for(int i = 1; i <= n; i++)    {        g[i].clear();    }}int lowbit(int x){    return x&(-x);}void update(int loc, ll value, int type){    value = (value + mod) % mod;//这里要注意，我在这里wa了很多次    if(type == 0)    {        for(int i = loc; i <= res; i += lowbit(i))        {            TreeK[i] = (TreeK[i] + value) % mod;        }    }    else    {        for(int i = loc; i <= res; i += lowbit(i))        {            TreeX[i] = (TreeX[i] + value) % mod;        }    }}ll sum(int loc, int type){    ll ans = 0;    if(type == 0)    {        for(int i = loc; i >= 1; i -= lowbit(i))        {            ans = (ans + TreeK[i]) % mod;        }    }    else    {        for(int i = loc; i >= 1; i -= lowbit(i))        {            ans = (ans + TreeX[i]) % mod;;        }    }    return ans;}void dfs(int u, int f, int d){    depth[u] = d;    L[u] = ++res;    Rank[res] = u;    for(int i = 0; i < g[u].size(); i++)    {        int v = g[u][i];        if(v == f) continue;        dfs(v, u, d + 1);    }    R[u] = res;}int main(){    int T;    scanf("%d", &T);    while(T--)    {        scanf("%d", &n);        init();        int pi;        for(int i = 2; i <= n; i++)        {            scanf("%d", &pi);            g[pi].push_back(i);        }        dfs(root, 1, 0);        scanf("%d", &q);        int op, v;        ll x, k;        for(int i = 1; i <= q; i++)        {           scanf("%d", &op);           if(op == 1)           {               scanf("%d%I64d%I64d", &v, &x, &k);               x = (x + depth[Rank[L[v]]] * k) % mod;               update(L[v], k, 0);               update(R[v] + 1, -k, 0);               update(L[v], x, 1);               update(R[v] + 1, -x, 1);           }           else           {               scanf("%d", &v);               ll ans1 = sum(L[v], 1);               ll ans2 = sum(L[v], 0);               ans1 %= mod;               ans2 %= mod;               ans1 = (ans1 - (depth[Rank[L[v]]] * ans2) % mod + mod) % mod;               printf("%I64d\n", ans1);           }        }    }    return 0;}