#include <bits/stdc++.h>

void solve() {
	int n;
	std::cin >> n;
	std::vector<int> s(n), fa(n), c(n);
	std::vector<std::vector<int>> G(n, std::vector<int>());
	for (int i = 1; i < n; ++i) {
		std::cin >> s[i];
	}
	for (int i = 1; i < n; ++i) {
		std::cin >> fa[i];
		--fa[i];
		G[fa[i]].push_back(i);
	}
	for (int i = 1; i < n; ++i) {
		std::cin >> c[i];
	}
	auto get = [&](auto &f, int i) -> int64_t {
		if (i < f.size())
			return f[i].second;
		return 0;
	};
	auto output = [&](auto x) {
		for (auto [a, b] : x)
			printf("[%d, %d] ", a, b);
		putchar('\n');
	};
	auto merge = [&](auto &f, auto g, int64_t limit) {
		std::vector<std::pair<int64_t, int64_t>> _g;
		_g.emplace_back(1, 0);
		for (auto &p : g) {
			++p.first;
			_g.push_back(p);
		}
		g = _g;
		int pf = 0, pg = 0;
		std::vector<std::pair<int64_t, int64_t>> h;
		while (pf < f.size() || pg < g.size()) {
			int64_t cost_f = get(f, pf);
			int64_t cost_g = get(g, pg);
			if (pf != f.size() && (pg == g.size() || f[pf].first < g[pg].first)) {
				assert(pf < f.size());
				h.emplace_back(f[pf].first, cost_f + cost_g);
				++pf;
			}
			else {
				assert(pg < g.size());
				h.emplace_back(g[pg].first, cost_f + cost_g);
				++pg;
			}
		}
		int64_t remain = 0, cur = 0;
		std::vector<std::pair<int64_t, int64_t>> nf;
		for (int i = 0; i < h.size(); ++i) {
			if (h[i].second > limit) {
				remain += (h[i].first - cur) * (h[i].second - limit);
				nf.emplace_back(h[i].first, limit);
			}
			else {
				int64_t free = (h[i].first - cur) * (limit - h[i].second);
				if (remain >= free) {
					remain -= free;
					h[i].second = limit;
					nf.emplace_back(h[i].first, limit);
				}
				else {
					// k
					// k * limit + r
					int64_t k = remain / (limit - h[i].second);
					int64_t r = remain - k * (limit - h[i].second);
					assert(cur + k < h[i].first);
					assert(h[i].second + r < limit);
					nf.emplace_back(cur + k, limit);
					nf.emplace_back(cur + k + 1, h[i].second + r);
					nf.emplace_back(h[i].first, h[i].second);
					remain = 0;
				}
			}
			cur = h[i].first;
		}
		if (remain > 0) {
			int64_t k = remain / limit;
			int64_t r = remain - k * limit;
			nf.emplace_back(cur + k, limit);
			nf.emplace_back(cur + k + 1, r);
		}
		std::vector<std::pair<int64_t, int64_t>> ret;
		for (auto p : nf) {
			while (!ret.empty() && ret.back().second == p.second)
				ret.pop_back();
			if (!ret.empty() && ret.back().first == p.first)
				continue;
			ret.push_back(p);
			//if (ret.empty() || (ret.back().second != p.second && ret.back().first != p.first))
			//	ret.push_back(p);
		}
		while (!ret.empty() && ret.back().second == 0)
			ret.pop_back();
		return ret;
	};
	auto init = [&](int x, auto &vec) {
		int64_t k = s[x] / c[x];
		int64_t r = s[x] - k * c[x];
		vec.emplace_back(k, c[x]);
		vec.emplace_back(k + 1, r);
		while (!vec.empty() && vec.back().second == 0)
			vec.pop_back();
	};
	int64_t ans = 0;
	auto dfs = [&](auto &self, int x, int par) -> std::vector<std::pair<int64_t, int64_t>> {
		std::vector<std::pair<int64_t, int64_t>> vec;
		if (x) init(x, vec);
		for (int y : G[x])
			if (y != par) {
				auto fy = self(self, y, x);
				if (x) vec = merge(vec, fy, c[x]);
				else ans = std::max(ans, fy.back().first);
				
			}
		return vec;
	};
	dfs(dfs, 0, -1);
	std::cout << ans << '\n';
}

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);
	std::cout.tie(nullptr);
	int T;
	std::cin >> T;
	while (T--) {
		solve();
	}
}