#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 = 4e16;

ll readll(){
    ll x = 0;
    int c = getchar_unlocked();
    while(c < '0') c = getchar_unlocked();
    while(c >= '0'){
        x = x * 10 + (c - '0');
        c = getchar_unlocked();
    }
    return x;
}

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



vector<pair<pll, pll>> 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}, {-1, -2}};
    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].ff.ss){
            pref[c][i].ff.ff = max(pref[c][i].ff.ff, d);
        }else{
            if(d > pref[c][i].ff.ff){
                pref[c][i].ss.ff = pref[c][i].ff.ff;
                pref[c][i].ss.ss = pref[c][i].ff.ss;
                pref[c][i].ff.ff = d;
                pref[c][i].ff.ss = k;
            } else if(d > pref[c][i].ss.ff){
                pref[c][i].ss.ff = d;
                pref[c][i].ss.ss = k;
            }
        }
    }

    suf[c][m - 1] = {{odl[c][m - 1].ff, odl[c][m - 1].ss}, {INF, -2}};
    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].ff.ss){
            suf[c][i].ff.ff = min(suf[c][i].ff.ff, d);
        }else{
            if(d < suf[c][i].ff.ff){
                suf[c][i].ss.ff = suf[c][i].ff.ff;
                suf[c][i].ss.ss = suf[c][i].ff.ss;
                suf[c][i].ff.ff = d;
                suf[c][i].ff.ss = k;
            } else if(d < suf[c][i].ss.ff){
                suf[c][i].ss.ff = d;
                suf[c][i].ss.ss = 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].size() < 2) 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 dod = -1;

            if(k != pref[c][j].ff.ss){
                dod = pref[c][j].ff.ff;
            }else if(pref[c][j].ss.ff != -1){
                dod = pref[c][j].ss.ff;
            }

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

ll wiecej(ll x, int n){
    ll best = INF;
    for(int c = 1; c <= n; c++){
        if(odl[c].size() < 2) 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 dod = INF;

                if(k != suf[c][j].ff.ss){
                    dod = suf[c][j].ff.ff;
                }else if(suf[c][j].ss.ff != INF){
                    dod = suf[c][j].ss.ff;
                }

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

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

    int n = readll(), q = readll();

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

    decompose(1);

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

    ll le = (pocz + 1) / 2;
    ll akt = pocz;

    while(true){
        ll best = mniej(2 * akt, n);
        if(best > akt){
            akt = best;
        }else{
            przedzialy.pb({le, akt});
            ll next = wiecej(2 * akt + 1, n);
            if(next == INF) break;
            le = (next + 1) / 2;
            akt = next;
        }
    }

    while(q--){
        ll k = readll();

        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;
            }
        }

        if(ok) putchar_unlocked('1');
        else putchar_unlocked('0');
    }


    return 0;
}