#include <iostream>
#include <vector>
#include <array>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <iomanip>
#include <algorithm>
#include <numeric>
#include <cmath>

using namespace std;
typedef long long ll;

#define all(x) (x).begin(), (x).end()

const int N = 2e6 + 3;

int n, k;
int c[N];
vector<int> adj[N];

int sz[N], d[N];

set<pair<int, int>> d_set[N], s_set[N];
int sum[N], cnt[N][3];

void _add(int u, int node){
    sum[u] -= c[node];
    cnt[u][c[node]]++;
}

void _remove(int u, int node){
    cnt[u][c[node]]--;
}

void merge(int u, int to){
    int u_size = d_set[u].size() + s_set[u].size();
    int to_size = d_set[to].size() + s_set[to].size();

    if(u_size < to_size){
        swap(d_set[u], d_set[to]);
        swap(s_set[u], s_set[to]);
        swap(sum[u], sum[to]);
        swap(cnt[u], cnt[to]);
    }

    for(auto p: d_set[to]){
        d_set[u].insert(p);
    }
    for(auto p: s_set[to]){
        s_set[u].insert(p);
    }

    cnt[u][1] += cnt[to][1];
    cnt[u][2] += cnt[to][2];
    sum[u] += sum[to];
}

int dfs(int u, int par = -1){
    int ans = 0;
    sz[u] = c[u];
    for(int to: adj[u]){
        if(to == par) continue;
        d[to] = d[u] + c[u];
        ans += dfs(to, u);
        sz[u] += sz[to];
        merge(u, to);
    }

    // d_set[u].insert({d[u], u});
    s_set[u].insert({sz[u], u});
    sum[u] += c[u]; 

    int all = sz[u];
    while(!s_set[u].empty()){
        auto [cand_size, cand] = *s_set[u].begin();
        if(all - cand_size >= k){
            s_set[u].erase({cand_size, cand});
            _add(u, cand);
            d_set[u].insert({d[cand], cand});
        }
        else break;
    }

    while(!d_set[u].empty()){
        auto [cand_d, cand] = *d_set[u].rbegin();
        if(cand_d - d[u] > k){
            d_set[u].erase({cand_d, cand});
            _remove(u, cand);
        }
        else break;
    }

    bool success = false;
    if(sz[u] >= k){
        if(sum[u] % 2 == k % 2){
            success = true;
        }
        else if(cnt[u][1]){
            success = true;
        }
    }

    if(success){
        sum[u] = 0;
        cnt[u][1] = cnt[u][2] = 0;
        sz[u] = 0;
        d_set[u].clear();
        s_set[u].clear();
        ++ans;
    }

    return ans;
}

void solve(){
    cin >> n >> k;
    for(int i = 1; i <= n; ++i)
        cin >> c[i];

    for(int i = 1; i <= n; ++i){
        adj[i].clear();
        d[i] = 0;
        sz[i] = 0;
        sum[i] = 0;
        d_set[i].clear();
        s_set[i].clear();
        for(int j = 0; j <= 2; ++j)
            cnt[i][j] = 0;
    }
    
    for(int i = 1; i <= n - 1; ++i){
        int x, y;
        cin >> x >> y;
        adj[x].push_back(y);
        adj[y].push_back(x);
    }

    cout << dfs(1) << "\n";
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);

    int t;
    cin >> t;

    while(t--)
        solve();
}