#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


int N;
char S[100'010];
vector<int> P;

vector<vector<int>> graph;
vector<int> ans;

struct Data {
  int zero, sumL;
  vector<int> ls, rs;
  Data() : zero(0), sumL(0) {}
  friend ostream &operator<<(ostream &os, const Data &f) {
    return os << "(" << f.zero << ", " << f.sumL << ", " << f.ls << ", " << f.rs << ")";
  }
  int size() const {
    return (int)ls.size() + (int)rs.size();
  }
  void swap(Data &f) {
    ::swap(zero, f.zero);
    ::swap(sumL, f.sumL);
    ls.swap(f.ls);
    rs.swap(f.rs);
  }
  int at(int i) const {
    if (i < 0) {
      assert(false);
    } else if (i < (int)ls.size()) {
      return ls[i];
    } else if (i < size()) {
      return rs[size() - 1 - i];
    } else {
      assert(false);
    }
  }
  void add(const Data &f) {
    zero += f.zero;
    for (int i = 0; i < (int)ls.size(); ++i) {
      const int res = f.at(i);
      sumL += res;
      ls[i] += res;
    }
    for (int i = (int)ls.size(); i < size(); ++i) {
      rs[size() - 1 - i] += f.at(i);
    }
  }
  void reduce(int thr) {
    for (; ls.size() && ls.back() >= thr; ls.pop_back()) {
      sumL -= ls.back();
      rs.push_back(ls.back());
    }
    for (; rs.size() && rs.back() < thr; rs.pop_back()) {
      sumL += rs.back();
      ls.push_back(rs.back());
    }
  }
};
Data solve(int u) {
  Data ret;
  for (int j = 0; j < (int)graph[u].size(); ++j) {
    const int v = graph[u][j];
    if (j) {
      Data res = solve(v);
      if (ret.size() > res.size()) {
        ret.swap(res);
      }
      ret.add(res);
    } else {
      ret = solve(v);
    }
  }
  if (S[u] == '1') {
    /*
      *= [1, 0]
      l <= -1 <= 0 <= r
    */
    ret.reduce(0);
    ret.zero += 1;
    ret.sumL += -1;
    ret.ls.push_back(-1);
  } else {
    /*
      *= [0, 1]
      l <= 0 <= +1 <= r
    */
    ret.reduce(+1);
    ret.rs.push_back(+1);
  }
  ans[u] = ret.zero + ret.sumL;
// cerr<<u<<": "<<ret<<endl;
  return ret;
}

int main() {
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    scanf("%d", &N);
    scanf("%s", S);
    P.resize(N);
    for (int u = 1; u < N; ++u) {
      scanf("%d", &P[u]);
      --P[u];
    }
    P[0] = -1;
    
    graph.assign(N, {});
    for (int u = 1; u < N; ++u) {
      graph[P[u]].push_back(u);
    }
    ans.resize(N);
    solve(0);
    
    for (int u = 0; u < N; ++u) {
      if (u) printf(" ");
      printf("%d", ans[u]);
    }
    puts("");
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}