#include <bits/stdc++.h>
#define int long long

using namespace std;

constexpr int maxn = 1e5 + 5, inf = 1e9 + 7;

vector<int> g[maxn];

int mn_dist[maxn];

// int dp1[maxn][maxn], dp2[maxn][maxn];

deque<int> dp1[maxn], dp2[maxn];

int used[maxn];

int dp_ans[maxn];

int t = 0;

int get(deque<int> &dq, int pos) {
    if (pos < dq.size()) {
        return dq[pos];
    }
    return 0;
}

void dfs(int v, int nights, int prv = -1LL) {
    used[v] = t;
    vector<int> kids;
    for (auto u : g[v]) {
        if (used[u] < t) {
            dfs(u, nights, v);
            kids.push_back(u);
        }
    }
    sort(kids.begin(), kids.end(), [&](int a, int b) {
        return dp1[a].size() > dp1[b].size();
    });
    if (kids.empty()) {
        dp1[v].push_back(inf);
        if (mn_dist[v] > nights) {
            dp1[v][0] = 1;
        }
        dp2[v].push_back(0);
        dp_ans[v] = dp1[v][0];
        return;
    }
    swap(dp1[v], dp1[kids[0]]);
    dp1[v].push_front(inf);
    if (dp1[v].size() > nights + 1) {
        dp1[v].pop_back();
    }
    if (mn_dist[v] > nights) {
        dp1[v][0] = 1;
        for (auto u : kids) {
            if (nights == 0) {
                dp1[v][0] += dp_ans[u];
            } else {
                dp1[v][0] += get(dp2[u], nights - 1);
            }
        }
    }
    for (int d = 1; d < (int)dp1[v].size(); ++d) {
        int sum = 0;
        for (auto u : kids) {
            if (u == kids[0]) {
                continue;
            }
            if (d == nights) {
                sum += dp_ans[u];
            } else {
                if (dp2[u].size() <= nights - d - 1) {
                    break;
                }
                sum += get(dp2[u], nights - d - 1);
            }
        }
        dp1[v][d] += sum;
        // cout << "!" << sum << ' ';
        if (d == nights) {
            sum += dp_ans[kids[0]];
        } else {
            sum += get(dp2[kids[0]], nights - d - 1);
        }
        // cout << sum << endl;
        for (auto u : kids) {
            if (u == kids[0]) {
                continue;
            }
            if (d == nights) {
                sum -= dp_ans[u];
            } else {
                // cout << u << ' ' << nights - d - 1 << ' ' << dp2[u].size() << ' ' << get(dp2[u], nights - d - 1) << endl;
                sum -= get(dp2[u], nights - d - 1);
            }
            if (dp1[u].size() <= d - 1) {
                break;
            }
            // if (sum == -1) {
            //     cout << "!" << v << ' ' << u << endl;
            // }
            dp1[v][d] = min(dp1[v][d], get(dp1[u], d - 1) + sum);
            if (d == nights) {
                sum += dp_ans[u];
            } else {
                sum += get(dp2[u], nights - d - 1);
            }
        }
    }
    swap(dp2[v], dp2[kids[0]]);
    dp2[v].push_front(0);
    if (dp2[v].size() > nights + 1) {
        dp2[v].pop_back();
    }
    for (auto u : kids) {
        dp2[v][0] += dp_ans[u];
    }
    for (int d = 1; d < (int)dp2[v].size(); ++d) {
        for (int i = 1; i < (int)kids.size(); ++i) {
            dp2[v][d] += get(dp2[kids[i]], d - 1);
            if (dp2[kids[i]].size() < d - 1) {
                break;
            }
        }
    }

    for (int d = 1; d < (int)dp1[v].size(); ++d) {
        dp1[v][d] = min(dp1[v][d], dp1[v][d - 1]);
    }
    dp_ans[v] = dp1[v].back();
    dp2[v][0] = min(dp2[v][0], dp1[v].back());
    for (int i = 1; i < (int)dp2[v].size(); ++i) {
        dp2[v][i] = min(dp2[v][i], dp2[v][i - 1]);
    }
}

void solve() {
    int n;
    cin >> n;
    string s;
    cin >> s;
    for (int i = 0; i < n; ++i) {
        mn_dist[i] = inf;
    }
    for (int i = 0; i < n - 1; ++i) {
        int a, b;
        cin >> a >> b;
        a--, b--;
        if (s[a] == '1' && s[b] == '1') {
            g[a].push_back(b);
            g[b].push_back(a);
        } else {
            mn_dist[a] = 1;
            mn_dist[b] = 1;
        }
    }
    queue<int> q;
    for (int i = 0; i < n; ++i) {
        if (s[i] == '1' && mn_dist[i] == 1) {
            q.push(i);
        }
    }
    while (!q.empty()) {
        int v = q.front();
        q.pop();
        for (auto u : g[v]) {
            if (mn_dist[u] > mn_dist[v] + 1) {
                mn_dist[u] = mn_dist[v] + 1;
                q.push(u);
            }
        }
    }
    int qs;
    cin >> qs;
    while (qs--) {
        int nights;
        cin >> nights;
        for (int i = 0; i < n; ++i) {
            if (s[i] == '1') {
                dp1[i].clear();
                dp2[i].clear();
            }
        }
        t++;
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            if (s[i] == '1' && used[i] < t) {
                dfs(i, nights);
                if (dp_ans[i] >= inf) {
                    ans = -1;
                    break;
                }
                ans += dp_ans[i];
            }
        }
        cout << ans << '\n';
    }
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    int t = 1;
    // cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}