Untitled

#include <iostream>
#include<vector>
#include<algorithm>
#define int long long
const int maxn = 2e5 + 5;
using namespace std;

vector<pair<int, int>> g[maxn];
vector<vector<int>> edg;
int par[maxn][20], dep[maxn], depw[maxn];

void dfs(int node, int parent, int w) {
	par[node][0] = parent;
	depw[node] = depw[parent] + w;
	dep[node] = dep[parent] + 1;
	for (int i = 1; i < 20; ++i)
		par[node][i] = par[par[node][i - 1]][i - 1];
	for (auto x : g[node])
		if (x.first != parent)
			dfs(x.first, node, x.second);
}

int findpar(int node, int k) {
	for (int i = 0; i < 20; ++i)
		if ((k >> i) & 1)
			node = par[node][i];
	return node;
}

int lca(int u, int v) {
	if (dep[u] > dep[v]) swap(u, v);
	v = findpar(v, dep[v] - dep[u]);
	if (u == v) return u;

	for (int i = 20 - 1; i >= 0; --i)
		if (par[u][i] != par[v][i])
			u = par[u][i], v = par[v][i];
	return (u == v ? u : par[u][0]);
}

int fdist(int u, int v) {
	return (depw[u] - depw[lca(u, v)]) + (depw[v] - depw[lca(u, v)]);
}

class DSU {
public:
	vector<int> p, rank;
	vector<vector<int>> d;
	int mxd = 0;
	int fset(int x) { return p[x] = ((p[x] == x) ? x : fset(p[x])); }
	bool iset(int x, int y) { return fset(x) == fset(y); }

	void uset(int x, int y) {
		x = fset(x), y = fset(y);
		if (x == y) return;
		if (rank[x] > rank[y]) swap(x, y);
		p[x] = y, rank[y] += rank[x];

		vector<int> best, arr;
		for(auto v: d[x]) arr.push_back(v);
		for(auto v: d[y]) arr.push_back(v);
		int dist = 0;
		for (auto i : arr)
			for (auto j : arr) {
				int cur = fdist(i, j);
				if (dist < cur)
					dist = cur, best = { i, j };
			}
		d[y] = best;
		mxd = max(mxd, fdist(best[0], best[1]));
	}

	DSU(int n) {
		rank.assign(n + 1, 1);
		d.resize(n + 1);
		for (int i = 0; i <= n; ++i)
			p.push_back(i), d[i] = { i, i };
	}
};

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

	int t; cin >> t;
	while (t--) {
		int n, q; cin >> n >> q;
		for (int i = 1; i < n; ++i) {
			int u, v, w; cin >> u >> v >> w;
			g[u].push_back({ v, w });
			g[v].push_back({ u, w });
			edg.push_back({ w, u, v });
		}
		sort(edg.begin(), edg.end());

		vector<pair<int, int>> arr;
		vector<int> res(q);
		for (int i = 0; i < q; ++i) {
			int k; cin >> k;
			arr.push_back({ k, i });
		}
		sort(arr.begin(), arr.end());

		dfs(1, 0, 0);
		int j = 0;
		DSU u(n);
		for (auto x : arr) {
			while ((j < edg.size())) {
				if (x.first >= edg[j][0])
					u.uset(edg[j][1], edg[j][2]), j++;
				else if ((2 * x.first) >= edg[j][0])
					u.uset(edg[j][1], edg[j][2]), j++;
				else
					break;
			}
			res[x.second] = (u.mxd >= x.first);
		}

		for (auto x : res)
			cout << x;
		cout << endl;

		for (int i = 0; i <= n; ++i) {
			g[i].clear(), dep[i] = depw[i] = 0;
			for (int j = 0; j < 20; ++j) par[i][j] = 0;
		}
		edg.clear();
	}
}