/*
 Every vectex will be counted in the union of several retangle.
 The sum of the rectangles is O(nlogn) and can be obtained through
 SGT merging.
 compute the union of each [dep] then done in O(nlog^2n + mlogn).
 */
#include <bits/stdc++.h>

typedef unsigned long long ull;

const int N = 100010, L = 18, M = 500010;

struct Node {
	int min, max, ls, rs;
} P[N * L];

int n;
int ans[M];
ull dep[N];
std::vector<std::pair<int, int>> g[N], qry[N], points[N];
std::unordered_map<ull, std::vector<std::pair<int, int>>> mp;

int nnode() { static int top; P[++top].min = n + 1; return top; }

int merge(int p, int q, int l, int r, std::vector<std::pair<int, int>>& rects) {
	if (!p || !q) return p ^ q;
	int mid = (l + r) >> 1;
	auto lv = std::max(std::make_pair(P[P[p].ls].max, 0), std::make_pair(P[P[q].ls].max, 1)),
	     rv = std::min(std::make_pair(P[P[p].rs].min, 0), std::make_pair(P[P[q].rs].min, 1));
	if (lv.second != rv.second && lv.first >= 1 && rv.first <= n) rects.emplace_back(lv.first, rv.first);
	P[p].min = std::min(P[p].min, P[q].min);
	P[p].max = std::max(P[p].max, P[q].max);
	P[p].ls = merge(P[p].ls, P[q].ls, l, mid, rects);
	P[p].rs = merge(P[p].rs, P[q].rs, mid + 1, r, rects);
	return p;
}

int ins(int o, int l, int r, int x) {
	if (!o) o = nnode();
	P[o].min = std::min(P[o].min, x); P[o].max = std::max(P[o].max, x);
	if (l == r) return o;
	int mid = (l + r) >> 1;
	if (x <= mid) P[o].ls = ins(P[o].ls, l, mid, x);
	else P[o].rs = ins(P[o].rs, mid + 1, r, x);
	return o;
}

int dfs(int u, int p) {
	int ret = 0;
	mp[dep[u]].emplace_back(u, u);
	for (const auto& pr : g[u]) {
		int v, d; std::tie(v, d) = pr; if (v == p) continue;
		dep[v] = dep[u] + d; int cur = dfs(v, u);
		ret = merge(ret, cur, 1, n, mp[dep[u]]);
	}
	ret = ins(ret, 1, n, u);
	return ret;
}

int fw[N];
void change(int k, int x) { for (; k <= n; k += k & -k) fw[k] += x; }
int query(int k) { int ret = 0; for (; k; k &= k - 1) ret += fw[k]; return ret; }

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr); std::cout.tie(nullptr);

	int m; std::cin >> n >> m;
	for (int rep = 1; rep != n; ++rep) {
		int u, v, d; std::cin >> u >> v >> d;
		g[u].emplace_back(v, d);
		g[v].emplace_back(u, d);
	}
	for (int i = 1; i <= m; ++i) {
		int l, r; std::cin >> l >> r;
		qry[l].emplace_back(r, i);
	}

	P[0].min = n + 1;
	dfs(1, 0);
	for (auto& pr : mp) {
		auto& rects = pr.second;
		if (rects.empty()) continue;
		std::sort(rects.begin(), rects.end());
		std::vector<std::pair<int, int>> critical; critical.push_back(rects.back());
		for (int i = (int)rects.size() - 2; i >= 0; --i) if (rects[i].second < critical.back().second) critical.push_back(rects[i]);
		std::reverse(critical.begin(), critical.end());
		rects.clear();
		for (int i = 0; i != critical.size(); ++i) {
			points[critical[i].first].emplace_back(critical[i].second, 1);
			if (i) points[critical[i - 1].first].emplace_back(critical[i].second, -1);
		}
	}
	mp.clear();

	for (int i = n; i; --i) {
		for (const auto& pr : points[i]) change(pr.first, pr.second);
		for (const auto& pr : qry[i]) ans[pr.second] = query(pr.first);
	}
	for (int i = 1; i <= m; ++i) std::cout << ans[i] << '\n';

	return 0;
}