#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
#define ordered_multiset tree<int, null_type, less_equal<int>, rb_tree_tag, tree_order_statistics_node_update>
#define pb push_back
#define ff first
#define ss second

const int N = 2e5 + 1;
const ll INF = 4000000000000000000LL;

vector<pll> graf[N], odl[N];
vi zb;
ll dyst[N];
int podd[N], odw[N];

struct oba{
    ll v1, k1, v2, k2;
};

vector<oba> pref[N], suf[N];

void poddrzewa(int v, int ojc){
    podd[v] = 1;
    for(pll x : graf[v]){
        int u = x.ff;
        if(odw[u] || u == ojc) continue;
        poddrzewa(u, v);
        podd[v] += podd[u];
    }
}

int znajdz(int v, int ojc, int r){
    for(pll x : graf[v]){
        int u = x.ff;
        if(odw[u] || u == ojc) continue;
        if(podd[u] > r / 2) return znajdz(u, v, r);
    }
    return v;
}

void dfs_policz(int v, int ojc){
    zb.pb(v);
    for(pll x : graf[v]){
        int u = x.ff;
        if(u == ojc || odw[u]) continue;
        dyst[u] = dyst[v] + x.ss;
        dfs_policz(u, v);
    }
}

void decompose(int v){
    poddrzewa(v, 0);
    int c = znajdz(v, 0, podd[v]);
    odw[c] = 1; dyst[c] = 0;
    odl[c].pb({0, c});
    
    for(pll x : graf[c]){
        int u = x.ff; ll w = x.ss;
        if(odw[u]) continue;
        dyst[u] = w;
        zb.clear();
        dfs_policz(u, 0);

        for(int y : zb){
            odl[c].pb({dyst[y], u});
        }
    }

    sort(odl[c].begin(), odl[c].end());
    int m = odl[c].size();
    pref[c].resize(m);
    suf[c].resize(m);
    
    pref[c][0] = {odl[c][0].ff, odl[c][0].ss, -1LL, -2LL};
    for(int i = 1; i < m; i++){
        ll d = odl[c][i].ff, k = odl[c][i].ss;
        pref[c][i] = pref[c][i - 1]; 
        
        if(k == pref[c][i].k1){
            pref[c][i].v1 = max(pref[c][i].v1, d);
        } else {
            if(d > pref[c][i].v1){
                pref[c][i].v2 = pref[c][i].v1;
                pref[c][i].k2 = pref[c][i].k1;
                pref[c][i].v1 = d;
                pref[c][i].k1 = k;
            } else if(d > pref[c][i].v2){
                pref[c][i].v2 = d;
                pref[c][i].k2 = k;
            }
        }
    }

    suf[c][m - 1] = {odl[c][m - 1].ff, odl[c][m - 1].ss, INF, -2LL};
    for(int i = m - 2; i >= 0; i--){
        ll d = odl[c][i].ff, k = odl[c][i].ss;
        suf[c][i] = suf[c][i + 1];
        
        if(k == suf[c][i].k1){
            suf[c][i].v1 = min(suf[c][i].v1, d);
        } else {
            if(d < suf[c][i].v1){
                suf[c][i].v2 = suf[c][i].v1;
                suf[c][i].k2 = suf[c][i].k1;
                suf[c][i].v1 = d;
                suf[c][i].k1 = k;
            } else if(d < suf[c][i].v2){
                suf[c][i].v2 = d;
                suf[c][i].k2 = k;
            }
        }
    }

    for(pii x : graf[c]){
        if(odw[x.ff]) continue;
        decompose(x.ff);
    }
}

ll mniej(ll x, int n){
    ll best = -1;
    for(int c = 1; c <= n; c++){
        if(odl[c].empty()) continue;
        int m = odl[c].size();
        int j = m - 1;
        for(int i = 0; i < m; i++){
            while(j >= 0 && odl[c][i].ff + odl[c][j].ff > x) j--;
            if(j < 0) break;

            ll kand = odl[c][i].ff, k = odl[c][i].ss;
            ll partner_d = -1;
            
            if(k != pref[c][j].k1){
                partner_d = pref[c][j].v1;
            } else if(pref[c][j].v2 != -1){
                partner_d = pref[c][j].v2;
            }

            if(partner_d != -1){
                best = max(kand + partner_d, best);
            }
        }
    }
    return best;
}

ll wiecej(ll x, int n){
    ll best = INF;
    for(int c = 1; c <= n; c++){
        if(odl[c].empty()) continue;
        int m = odl[c].size();
        int j = m - 1;
        for(int i = 0; i < m; i++){
            while(j > 0 && odl[c][i].ff + odl[c][j - 1].ff >= x) j--;
            if(odl[c][i].ff + odl[c][j].ff >= x){
                ll kand = odl[c][i].ff, k = odl[c][i].ss;
                ll partner_d = INF;
                
                if(k != suf[c][j].k1){
                    partner_d = suf[c][j].v1;
                } else if(suf[c][j].v2 != INF){
                    partner_d = suf[c][j].v2;
                }

                if(partner_d != INF){
                    best = min(kand + partner_d, best);
                }
            }
        }
    }
    return best;
}

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int n, q;
    if (!(cin >> n >> q)) return 0;

    for(int i = 1; i < n; i++){
        int a, b; ll c;
        cin >> a >> b >> c;
        graf[a].pb({b, c}); 
        graf[b].pb({a, c});
    }

    decompose(1);

    vector<pll> przedzialy;
    ll p0 = wiecej(1, n);

    if(p0 != INF){
        ll L = (p0 + 1) / 2;
        ll curr = p0;

        while(true){
            ll p_prime = mniej(2 * curr, n);
            if(p_prime > curr){
                curr = p_prime;
            } else {
                przedzialy.pb({L, curr});
                ll p_next = wiecej(2 * curr + 1, n);
                if(p_next == INF) break;
                L = (p_next + 1) / 2;
                curr = p_next;
            }
        }
    }

    string odp = "";
    while(q--){
        ll K;
        cin >> K;
        
        bool ok = false;
        auto it = upper_bound(przedzialy.begin(), przedzialy.end(), make_pair(K, INF));
        if(it != przedzialy.begin()){
            --it;
            if(K >= it->ff && K <= it->ss){
                ok = true;
            }
        }
        
        odp += (ok ? "1" : "0");
    }
    
    cout << odp << "\n";

    return 0;
}