#include <bits/stdc++.h>

int32_t main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n;
    std::cin >> n;
    std::string s;
    std::cin >> s;
    std::vector<std::vector<int>> gr(n);
    for (int i = 0; i < n - 1; i++) {
        int u, v;
        std::cin >> u >> v;
        u--;
        v--;
        gr[u].push_back(v);
        gr[v].push_back(u);
    }

    std::vector<bool> used(n);
    std::vector<int> roots;
    for (int i = 0; i < n; i++) {
        if (used[i]) {
            continue;
        }
        if (s[i] == '0') {
            gr[i].clear();
            continue;
        }
        auto dfs = [&](auto dfs, int v, int f) {
            if (s[v] == '0') {
                return;
            }
            used[v] = true;
            for (int t : gr[v]) {
                if (t != f) {
                    dfs(dfs, t, v);
                }
            }
        };
        roots.push_back(i);
        dfs(dfs, i, -1);
    }

    std::vector<int> sz(n);
    for (int u : roots) {
        auto dfs = [&](auto dfs, int v, int f) {
            if (s[v] == '0') {
                return;
            }
            sz[v] = 1;
            for (int& t : gr[v]) {
                if (t != f && s[t] == '1') {
                    dfs(dfs, t, v);
                    sz[v] += sz[t];
                } else {
                    t = -1;
                }
            }
            std::erase(gr[v], -1);
            std::sort(gr[v].begin(), gr[v].end(), [&](int a, int b) { return sz[a] > sz[b]; });
        };
        dfs(dfs, u, -1);
    }

    std::vector<int> diam(n, -1);
    for (int u : roots) {
        continue;
        if (s[u] == '0') {
            continue;
        }
        std::pair<int, int> max(0, u);
        int cnt = 0;
        for (int i = 0; i < 2; i++) {
            cnt = 0;
            auto dfs = [&](auto dfs, int v, int d, int f) {
                if (s[v] == '0') {
                    return;
                }
                if (std::find_if(gr[v].begin(), gr[v].end(), [&](int t) { return s[t] == '0'; }) != gr[v].end()) {
                    cnt++;
                    max = std::max(max, {d, v});
                }
                for (int t : gr[v]) {
                    if (t != f) {
                        dfs(dfs, t, d + 1, v);
                    }
                }
            };
            int u = max.second;
            max = {0, u};
            dfs(dfs, u, 0, -1);
        }
        if (cnt == 0) {
            continue;
        }
        diam[u] = max.first;
    }

    int q;
    std::cin >> q;
    for (int test = 0; test < q; test++) {
        int d;
        std::cin >> d;

        for (int u : roots) {
            if (diam[u] != -1 && 2 * d > diam[u]) {
                d = -1;
                break;
            }
        }
        if (d == -1) {
            std::cout << "-1\n";
            continue;
        }
        std::vector<std::vector<int>> dp(n), dp2(n);
        int ans_total = 0;
        auto fuck_min = [&](auto& vec) {
            for (int i = (int)vec.size() - 2; i >= 0; i--) {
                vec[i] = std::min(vec[i], vec[i + 1]);
            }
        };
        for (int root : roots) {
            auto dfs = [&](auto dfs, int v) -> void {
                if (gr[v].empty()) {
                    dp[v] = {0};
                    dp2[v] = {1};
                    return;
                }
                for (int t : gr[v]) {
                    dfs(dfs, t);
                }
                dp[v] = std::move(dp[gr[v][0]]);
                dp2[v] = std::move(dp2[gr[v][0]]);

                dp[v].push_back(dp2[v].rbegin()[std::min<int>(dp2[v].size() - 1, d)]);
                dp2[v].push_back(dp[v].rbegin()[std::min<int>(dp[v].size() - 1, d)] + 1);

                fuck_min(dp[v]);
                fuck_min(dp2[v]);

                for (int i = 1; i < gr[v].size(); i++) {
                    int t = gr[v][i];
                    dp[t].push_back(dp2[t].rbegin()[std::min<int>(dp2[t].size() - 1, d)]);
                    dp2[t].push_back(dp[t].rbegin()[std::min<int>(dp[t].size() - 1, d)] + 1);

                    if (dp[v].size() < dp[t].size()) {
                        dp[v].swap(dp[t]);
                        dp2[v].swap(dp2[t]);
                    }
                    for (int i = 0; i <= std::min<int>(d, dp[t].size() - 1); i++) {
                        dp[v].rbegin()[i] = std::min<int>({
                            dp[v].rbegin()[i] + dp[t].rbegin()[i],
                        });
                        dp2[v].rbegin()[i] = std::min<int>({
                            dp2[v].rbegin()[i] + dp2[t].rbegin()[i],
                            dp2[v].rbegin()[i] + dp[t].rbegin()[std::min<int>(dp[t].size() - 1, d - i)],
                            dp[v].rbegin()[std::min<int>(dp[v].size() - 1, d - i)] + dp2[t].rbegin()[i],
                        });
                    }

                    fuck_min(dp[v]);
                    fuck_min(dp2[v]);
                }
            };

            dfs(dfs, root);

            int ans = dp2[root].rbegin()[std::min<int>(dp2[root].size() - 1, d)];
            ans_total += ans;
        }
        std::cout << ans_total << "\n";
    }

    return 0;
}