#include <bits/stdc++.h>


using namespace std;


#define ll long long
#define flt double
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()


mt19937 rnd(234);
const ll inf = 1e18;


int n;
vector<int> s;
vector<vector<int>> g;
vector<ll> rs;
vector<int> usd;
vector<ll> dp_clrd, dp_not_clrd;
int dfs_usdc;
vector<int> dfs_usd;
vector<int> prnt;


void dfs0(int v, int p, ll k){
    prnt[v] = p;
    dfs_usd[v] = dfs_usdc;
    dp_clrd[v] = -1 - k;
    dp_not_clrd[v] = 0;
    for(auto to: g[v]){
        if(dfs_usd[to] != dfs_usdc && to != p && usd[to] == 0){
            dfs0(to, v, k);
            dp_not_clrd[v] += max(dp_clrd[to], dp_not_clrd[to]);
            if(dp_clrd[to] + k > dp_not_clrd[to]){
                dp_clrd[v] += dp_clrd[to] + k;
            } else{
                dp_clrd[v] += dp_not_clrd[to];
            }
        }
        if(usd[to] == 2){
            dp_clrd[v] += k;
        }
    }
}


void dfs1(int v, int p, ll k, bool clrd, ll &dsm, ll &dcmps){
    if(clrd){
        usd[v] = 1;
        dsm += -1 - k;
        dcmps -= 1;
        for(auto to: g[v]){
            if(to != p && usd[to] == 0){
                if(dp_clrd[to] + k > dp_not_clrd[to]){
                    dcmps += 1;
                    dsm += k;
                    dfs1(to, v, k, true, dsm, dcmps);
                } else{
                    dfs1(to, v, k, false, dsm, dcmps);
                }
            }
            if(usd[to] == 2){
                dsm += k;
                dcmps += 1;
            }
        }
    } else{
        for(auto to: g[v]){
            if(to != p && usd[to] == 0){
                if(dp_clrd[to] > dp_not_clrd[to]){
                    dfs1(to, v, k, true, dsm, dcmps);
                } else{
                    dfs1(to, v, k, false, dsm, dcmps);
                }
            }
        }
    }
}



void solve_slow(){
    rs.resize(n + 1);
    usd.resize(n);
    for(int i = 0; i < n; i += 1){
        if(s[i] == 0){
            usd[i] = 0;
        } else{
            usd[i] = 2;
        }
    }
    dfs_usdc = 10;
    dfs_usd.assign(n, 0);
    prnt.resize(n);
    dp_clrd.resize(n);
    dp_not_clrd.resize(n);
    ll sm = 0;
    ll components = 0;
    for(int i = 0; i < n; i += 1){
        if(s[i] == 1){
            sm += 1;
            components += 1;
        }
    }
    for(int v = 0; v < n; v += 1){
        for(auto to: g[v]){
            if(v < to && usd[v] == 2 && usd[to] == 2){
                components -= 1;
            }
        }
    }
    for(int k = 1; k <= n; k += 1){
        dfs_usdc += 1;
        sm += components;
        vector<int> not_usd;
        not_usd.reserve(n);
        for(int i = 0; i < n; i += 1){
            if(usd[i] == 0){
                not_usd.push_back(i);
            }
        }
        for(auto v: not_usd){
            if(dfs_usd[v] != dfs_usdc){
                dfs0(v, -1, k);
                ll dsm = 0;
                ll dcmps = 0;
                if(dp_clrd[v] > dp_not_clrd[v]){
                    dfs1(v, -1, k, true, dsm, dcmps);
                } else{
                    dfs1(v, -1, k, false, dsm, dcmps);
                }
                sm -= dsm;
                components -= dcmps;
            }
        }
        for(auto v: not_usd){
            if(usd[v] == 1){
                usd[v] = 2;
            }
        }
        rs[k] = sm;
    }
}


void solve(ll tl, ll tr, ll sm, ll cmps, vector<int> &vrtcs){
    if(tl > tr){
        return;
    }
    ll k = (tl + tr) / 2;
    vector<int> lft_vrtcs, rght_vrtcs;
    ll my_sm = sm + cmps * (k - tl + 1);
    ll my_cmps = cmps;
    dfs_usdc += 1;
    for(auto v: vrtcs){
        if(dfs_usd[v] != dfs_usdc){
            dfs0(v, -1, k);
            ll dsm = 0;
            ll dcmps = 0;
            if(dp_clrd[v] > dp_not_clrd[v]){
                dfs1(v, -1, k, true, dsm, dcmps);
            } else{
                dfs1(v, -1, k, false, dsm, dcmps);
            }
            my_sm -= dsm;
            my_cmps -= dcmps;
        }
    }
    rs[k] = my_sm;
    for(auto v: vrtcs){
        if(usd[v] == 1){
            lft_vrtcs.push_back(v);
        } else{
            rght_vrtcs.push_back(v);
        }
    }
    solve(k + 1, tr, my_sm, my_cmps, rght_vrtcs);
    for(auto v: rght_vrtcs){
        usd[v] = 1;
    }
    for(auto v: lft_vrtcs){
        usd[v] = 0;
    }
    solve(tl, k - 1, sm, cmps, lft_vrtcs);
}


void solve(){
    rs.resize(n + 1);
    usd.resize(n);
    for(int i = 0; i < n; i += 1){
        if(s[i] == 0){
            usd[i] = 0;
        } else{
            usd[i] = 2;
        }
    }
    dfs_usdc = 10;
    dfs_usd.assign(n, 0);
    prnt.resize(n);
    dp_clrd.resize(n);
    dp_not_clrd.resize(n);
    ll sm = 0;
    ll components = 0;
    for(int i = 0; i < n; i += 1){
        if(s[i] == 1){
            sm += 1;
            components += 1;
        }
    }
    for(int v = 0; v < n; v += 1){
        for(auto to: g[v]){
            if(v < to && usd[v] == 2 && usd[to] == 2){
                components -= 1;
            }
        }
    }
    vector<int> vrtcs;
    for(int i = 0; i < n; i += 1){
        if(usd[i] == 0){
            vrtcs.push_back(i);
        }
    }
    solve(1, n, sm, components, vrtcs);
}


int32_t main(){
    if(1){
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
    }
    cin >> n;
    // assert(n <= 1e4);
    s.resize(n);
    for(int i = 0; i < n; i += 1){
        char c;
        cin >> c;
        s[i] = c - '0';
    }
    g.assign(n, vector<int>());
    for(int i = 0; i < n - 1; i += 1){
        int u, v;
        cin >> u >> v;
        --u;
        --v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    solve();
    for(int k = 1; k <= n; k += 1){
        cout << rs[k] << "\n";
    }
    return 0;
}