LCA模板

include<bits/stdc++.h>

using namespace std;
const int MAXN = 80010;
int vs[MAXN];   //第i次DFS的节点
int id[MAXN];   //节点第一次出现的下标
int depth[MAXN];//第i次DFS的深度
int dis[MAXN];
struct Edge
{
    int from,to,next;
    int w;
}edge[MAXN];
int head[MAXN];
int dp[MAXN][20];
int tol,n,m,dfs_clock;

void init()
{
    tol = 0;
    dfs_clock = 0;
    memset(head,-1,sizeof(head));
    memset(vs,-1,sizeof(vs));
    memset(id,-1,sizeof(id));
    memset(depth,-1,sizeof(depth));
    memset(dis,0,sizeof(dis));
}

void addedge(int u,int v,int w)
{
    edge[tol].from = u;
    edge[tol].to = v;
    edge[tol].next = head[u];
    edge[tol].w = w;
    head[u] = tol++;
}

void dfs(int u,int f,int d)
{
    id[u] = dfs_clock;
    vs[dfs_clock] = u;
    depth[dfs_clock++] = d;
    for(int i = head[u]; ~i; i = edge[i].next){
        int v = edge[i].to;
        if( v == f ) continue;
        dis[v] = dis[u] + edge[i].w;
        dfs(v,u,d+1);
        vs[dfs_clock] = u;
        depth[dfs_clock++] = d;
    }
}

void rmq(int nn)
{
    for(int i = 1; i <= nn; i++) dp[i][0] = i;
    for(int j = 1; (1<<j) <= nn; j++){
        for(int i = 1; i + (1<<j) - 1 <= nn; i++){
            int a = dp[i][j-1];
            int b = dp[i + (1<<(j-1))][j-1];
            if(depth[a] <= depth[b])
                dp[i][j] = a;
            else
                dp[i][j] = b;
        }
    }
}

int lca(int x,int y)
{
    int l = min(id[x],id[y]);
    int r = max(id[x],id[y]);
    int k = 0;
    while(l + (1<<(1 + k)) - 1 <= r) k++;
    int a = dp[l][k];
    int b = dp[r - (1<<k) + 1][k];
    if(depth[a] <= depth[b])
        return vs[a];
    else
        return vs[b];
}

int main()
{
    int t,u,v,w,p1,p2;
    scanf("%d",&t);
    while(t--){
        init();
        scanf("%d%d",&n,&m);
        for(int i = 1; i <= n-1; i++){
            scanf("%d%d%d",&u,&v,&w);
            addedge(u,v,w);
            addedge(v,u,w);
        }
        dfs(1,-1,0);
        rmq(dfs_clock-1);
        for(int i = 1; i <= m; i++){
            scanf("%d%d",&p1,&p2);
            int f = lca(p1,p2);
            cout<<dis[p1] + dis[p2] - dis[f]*2<<endl;
        }
    }
    return 0;
}