#include <bits/stdc++.h>
using namespace std;
const int MAX = (int) 1e5+10;

vector<int> graph[MAX],que[MAX];
int a[MAX],tam[MAX],res[MAX];

struct DSU{
    // o que cada grupo carrega de informacao
    struct gp{
        // se precisa adicionar coisa a mais
        int tam;
        set<int> good, bad;

        // inicializar o smol
        void init(int x){
            // se precisa inicializar coisa a mais, passa por parametro
            tam=1;
            if(a[x] == 1) good.insert(1);
            else bad.insert(a[x]);
        }
        void clear(){
            good.clear();
            bad.clear();
        }
        ~gp(){good.clear();bad.clear();}
    };
    
    vector<int> repre;
    vector<gp> smol;
    int n;

    // inicializar passando a qtd de vertices, grupos iniciais
    DSU (int n) : n(n){
        repre.resize(n+10);
        smol.resize(n+10);
        // for(int i=1; i<=n; i++){
        //     repre[i]=i;
        //     smol[i].init(i);
        // }
    }
    ~DSU(){
        repre.clear();
        smol.clear();
    }
    void init(int n){
        this->n = n;
        for(int i=1; i<=n; i++){
            repre[i] = i;
            smol[i].init(i);
        }
    }
    void clear(){
        for(int i=1; i<=n; i++) smol[i].clear();
    }

    // achar o representante do u
    int rep(int u){
        if(u == repre[u]) return u;
        return repre[u]=rep(repre[u]);
    }

    // unir u e v
    void unite(int u,int v,int t){
        u=rep(u);
        v=rep(v);
        if(u == v) return;

        auto &x=smol[u];
        auto &y=smol[v];
        if(y.tam > x.tam){
            unite(v,u,t);
            return;
        }
        
        // da merge nos smols
        merge(x,y,t);
        repre[v]=u;
    }

    // fazer o merge de 2 grupos
    void merge(gp &x, gp &y,int t){
        // faz o merge se precisar
        for(auto w : y.good) x.good.insert(w);
        for(auto w : y.bad) x.bad.insert(w);
        auto it = x.bad.begin();
        while(it != x.bad.end() && *it <= t) {
            x.good.insert(*it);
            it = x.bad.erase(it);
        }
        y.good.clear();
        y.bad.clear();
        x.tam+=y.tam;
    }
};

DSU dsu(MAX);

void set_tam(int u,int ant){
    tam[u] = 1;
    for(auto v: graph[u]){
        if(v == ant) continue;
        set_tam(v,u);
        tam[u] += tam[v];
    }
}

void solve(int u,int ant){
    for(auto v: graph[u]){
        if(v == ant) continue;
        solve(v,u);
        dsu.unite(u,v,tam[u]);
    }
    auto & x = dsu.smol[dsu.rep(u)];
    for(auto v: que[u]) {
        res[v] = tam[u] - int(x.good.size()); 
    }
}

void test(){
    int n;
    cin >> n;
    for(int i=1; i<=n; i++) cin >> a[i];
    dsu.init(n);
    for(int i=1; i<n; i++){
        int x,y;
        cin >> x >> y;
        graph[x].push_back(y);
        graph[y].push_back(x);
    }
    int q;
    cin >> q;
    for(int i=0; i<q; i++){
        int x;
        cin >> x;
        que[x].push_back(i);
    }
    set_tam(1,1);
    solve(1,1);
    for(int i=0; i<q; i++) cout << res[i] << '\n';
    dsu.clear();
    for(int i=1; i<=n; i++) graph[i].clear();
    for(int i=1; i<=n; i++) que[i].clear();
}

int32_t main(){
    ios::sync_with_stdio(false); cin.tie(nullptr);
    int t = 1;
    cin >> t;
    while(t--) test();
    return 0;
}