时间限制:
4000ms 单点时限:
2000ms 内存限制:
256MB

描述

有一个N个节点的树，其中点1是根。初始点权值都是0。

一个节点的深度定义为其父节点的深度+1,。特别的，根节点的深度定义为1。

现在需要支持一系列以下操作：给节点u的子树中，深度在l和r之间的节点的权值（这里的深度依然从整个树的根节点开始计算），都加上一个数delta。

问完成所有操作后，各节点的权值是多少。

为了减少巨大输出带来的开销，假设完成所有操作后，各节点的权值是answer[1..N]，请你按照如下方式计算出一个Hash值（请选择合适的数据类型，注意避免溢出的情况）。最终只需要输出这个Hash值即可。

MOD =1000000007; // 10^9 + 7

MAGIC= 12347;

Hash =0;

For i= 1 to N do

   Hash = (Hash * MAGIC + answer[i]) mod MOD;

EndFor

输入

第一行一个整数T (1 ≤ T ≤ 5)，表示数据组数。

接下来是T组输入数据，测试数据之间没有空行。

每组数据格式如下：

第一行一个整数N (1 ≤ N ≤ 105)，表示树的节点总数。

接下来N – 1行，每行1个数，a (1 ≤ a ≤ N)，依次表示2..N节点的父亲节点的编号。

接下来一个整数Q(1 ≤ Q ≤ 105)，表示操作总数。

接下来Q行，每行4个整数，u, l, r, delta (1 ≤ u ≤ N, 1 ≤ l ≤ r ≤ N, -109 ≤ delta ≤ 109)，代表一次操作。

输出

对每组数据，先输出一行“Case x: ”，x表示是第几组数据，然后接这组数据答案的Hash值。

数据范围

小数据：1 ≤ N, Q ≤ 1000

大数据：1 ≤ N, Q ≤ 105

样例解释

点1的子树中有1,2,3三个节点。其中深度在2-3之间的是点2和点3。

点2的子树中有2,3两个节点。其中没有深度为1的节点。

所以，执行完所有操作之后，只有2,3两点的权值增加了1。即答案是0 1 1。再计算对应的Hash值即可。

样例输入

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

样例输出

Case 1: 12348

思路：这里采用顺序表存储所有的树节点，然后依据每个节点的父节点从高往低进行排序，接着根据题中根节点的深度为1，构造所有节点的深度信息，同时构造父节点的查找索引，最后通过构造递归检索父节点来调整权重。

注意：遇到树相关的数据结构，肯定要想到递归，这里在开始思考的时候，就只考虑了调整节点为u的权重，而忽略了它的子树很可能也符合条件。以后一定要注意，是自己的思考更加严密。

#include <iostream>
#include <vector>
#include <algorithm>
#include <fstream>

struct ele
{
	int i;    // 编号
	int h;    // 深度
	int w;    // 权值
	int p;    // 父节点编号
};

bool less(const struct ele &l, struct ele &r)
{
	return l.p<r.p;
}

int hash(std::vector<struct ele> &v)
{
	int hv = 0;
	int mod = 1000000007;
	int magic = 12347;

	for (size_t i=0; i<v.size(); ++i)
	{
		hv = ((hv%mod*magic%mod)%mod+v[i].w%mod)%mod;
	}

	return hv;
}

void adjustWeight(int u, int l, int r, int delta,
				  std::vector<struct ele> &v,
				  std::vector<int> &d)
{
	int N = d.back();
	int k = 0;
	int j = 0;
	while (k<N && u != v[k].p)
	{
		k = d[j++];
	}

	for (; k<d[j]; ++k)
	{
		if (v[k].h >=l && v[k].h<=r)
		{
			v[k].w += delta;
		}
		if (v[k].h < r)
		{
		    // 当前节点的深度小于上限值r，那么就需要调整其子树的权重;否则就不需要
			adjustWeight(v[k].i, l, r, delta, v, d);
		}
	}
}

std::ifstream in("c.txt");

int main(void)
{
	int T;
	int N;
	int Q;
	std::vector<struct ele> v;
	std::vector<int> h;
	std::vector<int> d;
	int u, l, r, delta;

	std::cin >> T;
	for (int idx=0; idx<T; ++idx)
	{
		std::cin >> N;
		for (int i=0; i<N-1; ++i)
		{
			struct ele e;
			e.i = i+2;
			std::cin >> e.p;
			e.w = 0;
			e.h = 0;

			v.push_back(e);
		}

		std::sort(v.begin(), v.end(), less);

		h.assign(N, 0);
		h[0] = 1;
		int prev = v[0].p;
		for (int i=0; i<v.size(); ++i)
		{
			if (prev != v[i].p)
			{
				prev = v[i].p;
				d.push_back(i);
			}

			v[i].h = h[prev-1]+1;
			h[v[i].i-1] = v[i].h;
		}
		d.push_back(N-1);

		std::cin >> Q;
		for (int i=0; i<Q; ++i)
		{
			std::cin >> u >> l >> r >> delta;

			adjustWeight(u, l, r, delta, v, d);
		}

		std::cout << "Case " << idx+1 << ": " << hash(v) << '\n';
	}

	system("pause");
	return 0;
}