#include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
#define pb push_back
#define sz(a) ((int)a.size())
using ll = long long;
using u32 = unsigned int;
using u64 = unsigned long long;
using i128 = __int128;
using u128 = unsigned __int128;
using f128 = __float128;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename T> using vc = vector<T>;
template <typename T> using vvc = vc<vc<T>>;
template <typename T> using vvvc = vc<vvc<T>>;
using vi = vc<int>;
using vll = vc<ll>;
using vvi = vc<vi>;
using vvll = vc<vll>;
#define vv(type, name, n, ...) \
vector<vector<type>> name(n, vector<type>(__VA_ARGS__))
#define vvv(type, name, n, m, ...) \
vector<vector<vector<type>>> name( \
n, vector<vector<type>>(m, vector<type>(__VA_ARGS__)))
template <typename T> using min_heap = priority_queue<T, vector<T>, greater<T>>;
template <typename T> using max_heap = priority_queue<T>;
// https://trap.jp/post/1224/
#define rep1(n) for (ll i = 0; i < (ll)(n); ++i)
#define rep2(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define rep3(i, a, b) for (ll i = (ll)(a); i < (ll)(b); ++i)
#define rep4(i, a, b, c) for (ll i = (ll)(a); i < (ll)(b); i += (c))
#define cut4(a, b, c, d, e, ...) e
#define rep(...) cut4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define per1(n) for (ll i = ((ll)n) - 1; i >= 0; --i)
#define per2(i, n) for (ll i = ((ll)n) - 1; i >= 0; --i)
#define per3(i, a, b) for (ll i = ((ll)a) - 1; i >= (ll)(b); --i)
#define per4(i, a, b, c) for (ll i = ((ll)a) - 1; i >= (ll)(b); i -= (c))
#define per(...) cut4(__VA_ARGS__, per4, per3, per2, per1)(__VA_ARGS__)
#define rep_subset(i, s) \
for (ll i = (s); i >= 0; i = (i == 0 ? -1 : (i - 1) & (s)))
template <typename T, typename S> constexpr T ifloor(const T a, const S b) {
return a / b - (a % b && (a ^ b) < 0);
}
template <typename T, typename S> constexpr T iceil(const T a, const S b) {
return ifloor(a + b - 1, b);
}
template <typename T> void sort_unique(vector<T> &vec) {
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
}
template <typename T, typename S> constexpr bool chmin(T &a, const S b) {
if (a > b)
return a = b, true;
return false;
}
template <typename T, typename S> constexpr bool chmax(T &a, const S b) {
if (a < b)
return a = b, true;
return false;
}
template <typename T, typename S>
istream &operator>>(istream &i, pair<T, S> &p) {
return i >> p.first >> p.second;
}
template <typename T, typename S>
ostream &operator<<(ostream &o, const pair<T, S> &p) {
return o << p.first << ' ' << p.second;
}
#ifdef i_am_noob
#define bug(...) \
cerr << "#" << __LINE__ << ' ' << #__VA_ARGS__ << "- ", _do(__VA_ARGS__)
template <typename T> void _do(vector<T> x) {
for (auto i : x)
cerr << i << ' ';
cerr << "\n";
}
template <typename T> void _do(set<T> x) {
for (auto i : x)
cerr << i << ' ';
cerr << "\n";
}
template <typename T> void _do(unordered_set<T> x) {
for (auto i : x)
cerr << i << ' ';
cerr << "\n";
}
template <typename T> void _do(T &&x) { cerr << x << endl; }
template <typename T, typename... S> void _do(T &&x, S &&...y) {
cerr << x << ", ";
_do(y...);
}
#else
#define bug(...) 777771449
#endif
template <typename T> void print(vector<T> x) {
for (auto i : x)
cout << i << ' ';
cout << "\n";
}
template <typename T> void print(set<T> x) {
for (auto i : x)
cout << i << ' ';
cout << "\n";
}
template <typename T> void print(unordered_set<T> x) {
for (auto i : x)
cout << i << ' ';
cout << "\n";
}
template <typename T> void print(T &&x) { cout << x << "\n"; }
template <typename T, typename... S> void print(T &&x, S &&...y) {
cout << x << ' ';
print(y...);
}
template <typename T> istream &operator>>(istream &i, vector<T> &vec) {
for (auto &x : vec)
i >> x;
return i;
}
vvi read_graph(int n, int m, int base = 1) {
vvi adj(n);
for (int i = 0, u, v; i < m; ++i) {
cin >> u >> v, u -= base, v -= base;
adj[u].pb(v), adj[v].pb(u);
}
return adj;
}
vvi read_tree(int n, int base = 1) { return read_graph(n, n - 1, base); }
template <typename T, typename S>
pair<T, S> operator+(const pair<T, S> &a, const pair<T, S> &b) {
return {a.first + b.first, a.second + b.second};
}
template <typename T> constexpr T inf = 0;
template <> constexpr int inf<int> = 0x3f3f3f3f;
template <> constexpr ll inf<ll> = 0x3f3f3f3f3f3f3f3f;
template <typename T> vector<T> operator+=(vector<T> &a, int val) {
for (auto &i : a)
i += val;
return a;
}
template <typename T> T isqrt(const T &x) {
T y = sqrt(x + 2);
while (y * y > x)
y--;
return y;
}
#define ykh mt19937 rng(chrono::steady_clock::now().time_since_epoch().count())
#include <algorithm>
#ifdef _MSC_VER
#include <intrin.h>
#endif
namespace atcoder {
namespace internal {
// @param n `0 <= n`
// @return minimum non-negative `x` s.t. `n <= 2**x`
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n))
x++;
return x;
}
// @param n `1 <= n`
// @return minimum non-negative `x` s.t. `(n & (1 << x)) != 0`
int bsf(unsigned int n) {
#ifdef _MSC_VER
unsigned long index;
_BitScanForward(&index, n);
return index;
#else
return __builtin_ctz(n);
#endif
}
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <vector>
namespace atcoder {
template <class S, S (*op)(S, S), S (*e)()> struct segtree {
public:
segtree() : segtree(0) {}
segtree(int n) : segtree(std::vector<S>(n, e())) {}
segtree(const std::vector<S> &v) : _n(int(v.size())) {
log = internal::ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
for (int i = 0; i < _n; i++)
d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
d[p] = x;
for (int i = 1; i <= log; i++)
update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
return d[p + size];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
S sml = e(), smr = e();
l += size;
r += size;
while (l < r) {
if (l & 1)
sml = op(sml, d[l++]);
if (r & 1)
smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
template <bool (*f)(S)> int max_right(int l) {
return max_right(l, [](S x) { return f(x); });
}
template <class F> int max_right(int l, F f) {
assert(0 <= l && l <= _n);
assert(f(e()));
if (l == _n)
return _n;
l += size;
S sm = e();
do {
while (l % 2 == 0)
l >>= 1;
if (!f(op(sm, d[l]))) {
while (l < size) {
l = (2 * l);
if (f(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*f)(S)> int min_left(int r) {
return min_left(r, [](S x) { return f(x); });
}
template <class F> int min_left(int r, F f) {
assert(0 <= r && r <= _n);
assert(f(e()));
if (r == 0)
return 0;
r += size;
S sm = e();
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!f(op(d[r], sm))) {
while (r < size) {
r = (2 * r + 1);
if (f(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};
} // namespace atcoder
using namespace atcoder;
// using mint=modint998244353;
// using mint=modint1000000007;
pii op(pii a, pii b) { return max(a, b); }
pii e() { return {-inf<int>, -1}; }
void mango() {
int n;
cin >> n;
vi a(n);
cin >> a;
vi c(n);
cin >> c;
vi p(n);
cin >> p;
rep(n) p[i]--;
vc<pii> nodes;
rep(n) nodes.pb({a[i], i});
segtree<pii, op, e> tree(nodes);
int cur_node = 0;
vi par(n, -1), pos(n, -1), cnt(n);
auto dfs = [&](auto &self, int l, int r, int p) {
if (l >= r)
return;
int cur = cur_node++;
par[cur] = p;
auto [mxval, id] = tree.prod(l, r);
pos[id] = cur;
tree.set(id, e());
vi vec = {id};
cnt[cur]++;
while (1) {
auto [val, id2] = tree.prod(l, r);
if (val < mxval)
break;
pos[id2] = cur;
tree.set(id2, e());
vec.pb(id2);
cnt[cur]++;
}
sort(all(vec));
self(self, l, vec[0], cur);
rep(sz(vec) - 1) self(self, vec[i] + 1, vec[i + 1], cur);
self(self, vec.back() + 1, r, cur);
return;
};
dfs(dfs, 0, n, -1);
vi mn_c(cur_node, inf<int>);
rep(n) chmin(mn_c[pos[i]], c[i]);
vi reset_t(cur_node, inf<int>);
rep(n) chmin(reset_t[pos[p[i]]], i);
vi c2 = mn_c, t2 = reset_t;
rep(i, 1, cur_node) {
chmin(c2[i], c2[par[i]]);
chmin(t2[i], t2[par[i]]);
}
vll res(n + 1);
rep(cur_node) {
res[t2[i]] += 1ll * c2[i] * cnt[i];
if (i == 0)
res[t2[i]] -= c2[i];
}
per(i, n, 0) res[i] += res[i + 1];
rep(n + 1) cout << res[i] << ' ';
cout << "\n";
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cout << fixed << setprecision(20);
int t = 1;
cin >> t;
while (t--)
mango();
}
