#include <bits/stdc++.h>

const int MAXN = 1e5 + 5;

std :: vector<int> son[MAXN];
std :: vector<int> dp[MAXN];

char typ[MAXN];

int q1[MAXN], h1, t1;
int q2[MAXN], h2, t2;

int lag[MAXN][2], ans[MAXN];

int n;

void init() {
    for( int i = 1 ; i <= n ; i ++ ) {
        son[i].clear(), dp[i].clear();
        lag[i][0] = lag[i][1] = 0;
    }
}

void normalise( std :: vector<int> &f, const int &lim, const int &r, const int &b ) {
    std :: vector<int> res( lim + 1 );

    h1 = h2 = 1, t1 = t2 = 0;
    for( int i = 0 ; i <= lim ; i ++ ) {
        // maintain suffix
        int cur = i;
        if( cur < ( int ) f.size() ) {
            while( h2 <= t2 && f[q2[t2]] + q2[t2] >= f[cur] + cur ) t2 --;
            q2[++ t2] = cur;
        }
        while( h2 <= t2 && q2[h2] < i - b ) h2 ++;
        // maintain prefix
        cur = i - b - 1;
        if( cur >= 0 ) {
            while( h1 <= t1 && f[q1[t1]] - q1[t1] >= f[cur] - cur ) t1 --;
            q1[++ t1] = cur;
        }
        while( h1 <= t1 && q1[h1] < i - b - r ) h1 ++;

        res[i] = 1e9;
        if( h1 <= t1 ) res[i] = std :: min( res[i], f[q1[h1]] + i - b - q1[h1] );
        if( h2 <= t2 ) res[i] = std :: min( res[i], f[q2[h2]] + b + q2[h2] - i );
    }

    f.swap( res );
}

void dfs( const int &u ) {
    if( son[u].empty() ) {
        ans[u] = 0;
        dp[u].resize( 1 ), dp[u][0] = 0;
    } else if( ( int ) son[u].size() == 1 ) {
        int v = son[u][0];
        dfs( v );
        lag[u][0] = lag[v][0];
        lag[u][1] = lag[v][1];
        dp[u].swap( dp[v] ), ans[u] = ans[v];
    } else {
        for( const int &v : son[u] ) dfs( v );
        std :: sort( son[u].begin(), son[u].end(),
            [] ( const int &a, const int &b ) -> bool {
                return dp[a].size() + lag[a][0] + lag[a][1] <
                       dp[b].size() + lag[b][0] + lag[b][1];
            } );
        int s = son[u].size(), v = son[u][0];
        int lim = dp[v].size() + lag[v][0] + lag[v][1] - 1;
        for( int i = 0 ; i < s ; i ++ ) {
            int w = son[u][i];
            normalise( dp[w], lim, lag[w][0], lag[w][1] );
        }
        dp[u].resize( lim + 1 ), ans[u] = 1e9;
        for( int i = 0 ; i <= lim ; i ++ ) {
            dp[u][i] = 0;
            for( int j = 0 ; j < s ; j ++ )
                dp[u][i] += dp[son[u][j]][i];
            ans[u] = std :: min( ans[u], dp[u][i] );
        }
    }
    lag[u][typ[u] - '0'] ++;
    for( const int &v : son[u] )
        std :: vector<int> ().swap( dp[v] );
}

void solve() {
    scanf( "%d", &n ), init();
    scanf( "%s", typ + 1 );
    for( int i = 2 ; i <= n ; i ++ ) {
        int fa; scanf( "%d", &fa );
        son[fa].push_back( i );
    }
    dfs( 1 );
    for( int i = 1 ; i <= n ; i ++ )
        printf( "%d%c", ans[i], " \n"[i == n] );
}

int main() {
    int t;
    scanf( "%d", &t );
    while( t -- ) solve();
    return 0;
}