#include<bits/stdc++.h>
using namespace std;

typedef long long LL;

const int MAXN = 100005;

vector<int>G[MAXN], depG[MAXN];
int dep[MAXN];
int a[MAXN];
int kpre[MAXN];
int siz[MAXN], top[MAXN], pre[MAXN], son[MAXN], pos[MAXN], dfn_clock;
int n, k;
int s[MAXN];
int sumv[MAXN << 2], addv[MAXN << 2];

void dfs(int u) {
    if(a[u]) depG[dep[u]].push_back(u);
    s[dep[u]] = u;
    if(dep[u] >= k) kpre[u] = s[dep[u] - k];
    else kpre[u] = 1;
    siz[u] = 1;
    son[u] = 0;
    for(int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        dep[v] = dep[u]+1;
        pre[v] = u;
        dfs(v);
        siz[u] += siz[v];
        if(siz[son[u]] < siz[v]) son[u] = v;
    }
}

void build(int u, int top_e) {
    top[u] = top_e;
    pos[u] = ++dfn_clock;
    if(son[u]) build(son[u], top_e);
    for(int i = 0 ; i < G[u].size(); i++) {
        int v = G[u][i];
        if(v != son[u]) build(v, v);
    }
}

void pushdown(int o) {
    if(addv[o]) {
        sumv[o<<1] += addv[o];
        addv[o<<1] += addv[o];
        sumv[o<<1|1] += addv[o];
        addv[o<<1|1] += addv[o];
        addv[o] = 0;
    }
}

void pushup(int o) {
    sumv[o] = sumv[o<<1] + sumv[o<<1|1];
}

void add(int o, int l, int r, int L, int R, int v) {
    if(L <= l && r <= R) {
        sumv[o] += v;
        addv[o] += v;
        return;
    }
    pushdown(o);
    int mid=l+r>>1;
    if(L <= mid) add(o<<1, l, mid, L, R, v);
    if(mid < R) add(o<<1|1, mid+1, r, L, R, v);
    pushup(o);
}

int sum(int o, int l, int r, int L, int R) {
    if(L <= l && r <= R) {
        return sumv[o];
    }
    pushdown(o);
    int mid=l+r>>1;
    int ans = 0;
    if(L <= mid) ans += sum(o<<1, l, mid, L, R);
    if(mid < R) ans += sum(o<<1|1, mid+1, r, L, R);
    return ans;
}

void update(int x, int y) {
    while(top[x] != top[y]) {
        if(dep[top[x]] < dep[top[y]]) swap(x, y);
        add(1, 1, n, pos[top[x]], pos[x], 1);
        x = pre[top[x]];
    }
    if(dep[x] > dep[y]) swap(x, y);
    add(1, 1, n, pos[x], pos[y], 1);
}

int query(int x, int y) {
    int ans = 0;
    while(top[x] != top[y]) {
        if(dep[top[x]] < dep[top[y]]) swap(x, y);
        ans += sum(1, 1, n, pos[top[x]], pos[x]);
        x = pre[top[x]];
    }
    if(dep[x] > dep[y]) swap(x, y);
    ans += sum(1, 1, n, pos[x], pos[y]);
    return ans;
}

void buildT(int o, int l, int r) {
    sumv[o] = addv[o] = 0;
    if(l == r) {
        return;
    }
    int mid = l+r>>1;
    buildT(o<<1, l, mid);
    buildT(o<<1|1, mid+1, r);
}


void solve() {
    scanf("%d%d", &n, &k);
    dfn_clock = 0;
    for(int i = 0; i <= n; i++) {
        G[i].clear();
        depG[i].clear();
    }
    for(int i = 2; i <= n; i++) {
        int x;
        scanf("%d", &x);
        G[x].push_back(i);
    }
    for(int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
    }
    dfs(1);
    build(1,1);
    buildT(1, 1, n);
    int ans = 0;
    for(int i = n; i >= 0; i--) {
        for(int j = 0; j < depG[i].size(); j++) {
            int u = depG[i][j], v = kpre[u];
            //printf("u=%d, dep=%d %d\n", u, dep[u], query(u, v));
            if(query(u, v) > 0) continue;
            update(u, v);
            //printf("%d %d\n", u, v);
            ans++;
        }
    }
    printf("%d\n", ans);
}

int main() {
    int T;
    scanf("%d", &T);
    for(int i = 1; i <= T; i++) solve();
    return 0;
}