#include<bits/stdc++.h>
using namespace std;

#define ll           long long
#define pii          pair<ll,ll>
#define bug(a)       cerr << #a << " : " << a << endl;
#define FastRead     ios_base::sync_with_stdio(false);cin.tie(NULL);

const ll MAX = 1e5+10;

vector<ll>adj[MAX] , ans[MAX] , cnt[MAX] , subb[MAX];
ll n , dep[MAX] , T[MAX] , P[MAX][30] , cum[MAX][30] , root;
map<pii,ll>cost;

void DFS(ll src,ll par,ll lev)
{
    dep[src] = lev;
    T[src] = par;

    for(ll i=0;i<adj[src].size();i++)
    {
        ll x = adj[src][i];

        if(x == par)
            continue;
        cum[x][0] = cost[{src,x}];
        DFS(x,src,lev+1);
    }
}
void initLCA()
{
    memset(P,-1,sizeof P);

    for(ll i=1;i<=n;i++)
        P[i][0] = T[i];
    for(ll j=1; 1<<j <n;j++)
    {
        for(ll i=1;i<=n;i++)
        {
            if(P[i][j-1] != -1)
            {
                P[i][j] = P[P[i][j-1]][j-1];
                cum[i][j] = cum[i][j-1] + cum[P[i][j-1]][j-1];
            }
        }
    }
}
ll lca_query(ll u,ll v)
{
    if(dep[u] < dep[v])
        swap(u,v);

    ll log = log2(dep[u]);
    ll sum = 0;
    for(ll i=log;i>=0;i--)
    {
        if(dep[u]-(1<<i) >= dep[v])
        {
            sum += cum[u][i];
            u = P[u][i];
        }
    }
    if(u == v)
        return sum;
    for(ll i=log;i>=0;i--)
    {
        if(P[u][i] != -1 && P[u][i] != P[v][i])
        {
            sum += cum[u][i]+cum[v][i];
            u = P[u][i];
            v = P[v][i];
        }
    }
    return sum + cum[u][0] + cum[v][0];
}
ll dist(ll u,ll v)
{
    return lca_query(u,v);
}
struct CentroidDecomposition
{
    ll path[MAX] , sub[MAX];
    bool vis[MAX];

    CentroidDecomposition()
    {
        memset(vis,0,sizeof vis);
        memset(path,0,sizeof path);
    }

    void subDFS(ll src,ll par)
    {
        sub[src] = 1;

        for(auto i : adj[src])
        {
            if(i == par || vis[i])
                continue;

            subDFS(i,src);
            sub[src] += sub[i];
        }
    }
    ll centroid(ll src,ll par,ll sz)
    {
        for(auto i : adj[src])
        {
            if(i == par || vis[i])
                continue;
            else if(sub[i] > sz)
                return centroid(i,src,sz);
        }
        return src;
    }
    ll decompose(ll src,ll par)
    {
        subDFS(src,-1);
        ll c = centroid(src,-1,sub[src]/2);
        vis[c] = 1;
        path[c] = par;

        for(auto i : adj[c])
        {
            if(!vis[i])
            {
                ll child = decompose(i,c);
                for(auto j : subb[child])
                    subb[c].push_back(j);
            }
        }
        subb[c].push_back(c);
        for(auto i : subb[c])
        {
            ans[c].push_back(dist(c,i));
            if(par != -1)
                cnt[c].push_back(dist(par,i));
        }
        return c;
    }
} tree;

struct QueryHandler
{
    ll query(ll u,ll l)
    {
        ll cur = u;
        ll ret = upper_bound(ans[u].begin(),ans[u].end(),l)-ans[u].begin();

        while(1)
        {
            if(tree.path[cur] == -1)
                break;

            ll dd = l-dist(u,tree.path[cur]);
            ll add = upper_bound(ans[tree.path[cur]].begin(),ans[tree.path[cur]].end(),dd)-ans[tree.path[cur]].begin();
            ll sub = upper_bound(cnt[u].begin(),cnt[u].end(),dd)-cnt[u].begin();

            //cout << ">>> " << add << " - " << sub << endl;

            ret += add-sub;
            cur = tree.path[cur];
        }
        return ret;
    }
} ds;

int main()
{
#ifdef Aaman007
    freopen("input.txt","r",stdin);
    // freopen("output.txt","w",stdout);
#endif // Aaman007

    FastRead

    ll u,v,q;
    ll l,w;

    cin >> n >> q;

    for(ll i=0;i<n-1;i++)
    {
        cin >> u >> v >> w;
        adj[u].push_back(v);
        adj[v].push_back(u);
        cost[{u,v}] = cost[{v,u}] = w;
    }
    DFS(1,1,0);
    initLCA();

    tree.decompose(1,-1);

    for(ll i=1;i<=n;i++)
    {
        sort(ans[i].begin(),ans[i].end());
        sort(cnt[i].begin(),cnt[i].end());
    }

    while(q--)
    {
        cin >> u >> l;

        cout << ds.query(u,l) << endl;
    }
}