A

//#include<bits/stdc++.h>
//#pragma comment(linker, "/STACK:1024000000,1024000000") 
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<string.h>
#include<iostream>
#include<math.h>
#include<set>
#include<map>
#include<vector>
#include<iomanip>
using namespace std;
#define ll long long
#define pb push_back

const int maxn=4e4+9;
const int maxq=210;
int n,m,root;

struct EDGE{int v;int d;};
vector<EDGE>G[maxn];

int vs[maxn*2-1];
int dep[maxn*2-1];
int depth[maxn];
int id[maxn];

void addedge(int u,int v,int d){
	G[u].pb((EDGE){v,d});
	G[v].pb((EDGE){u,d});
}

void dfs(int u,int fa,int d,int &k){
	id[u]=k;
	vs[k]=u;dep[k++]=d;
	for(int i=0;i<G[u].size();i++){
		EDGE &e=G[u][i];
		if(e.v==fa)continue;
		dfs(e.v,u,d+e.d,k);	
		vs[k]=u;dep[k++]=d;
	}
}
void init_dfs(int n){
	int k=0;
	dfs(root,-1,0,k);
}

int dp[maxn<<1][20];
int mm[maxn<<1];
void init_rmq(int n,int dep[]){
	for(int i=0;i<n;i++){
		dp[i][0]=i;	
	}
	for(int j=1;(1<<j)<=n;j++)
		for(int i=0;i+(1<<j)-1<n;i++){
			int a=dp[i][j-1],b=dp[i+(1<<(j-1))][j-1];
			if(dep[a]<=dep[b]){
				dp[i][j]=a;
			}else dp[i][j]=b;
		}
		
}
int rmq(int l,int r){
	int k=0;
	while((1<<(k+1))<=r-l+1)k++;
	int a=dp[l][k],b=dp[r-(1<<k)+1][k];
	if(dep[a]<=dep[b])return a;
	else return b;	
}

int lca(int u,int v){
	return vs[rmq(min(id[u],id[v]),max(id[u],id[v])+1)];
}

int main(){
	int T;
	scanf("%d",&T);
	while(T--){
		scanf("%d%d",&n,&m);
		for(int i=1;i<=n;i++)G[i].clear();
		for(int i=1;i<n;i++){
			int u,v,d;
			scanf("%d%d%d",&u,&v,&d);
			addedge(u,v,d);
		}
		root=1;
		init_dfs(n);

		init_rmq(n*2-1,dep);

		for(int i=1;i<=m;i++){
			int u,v;
			scanf("%d%d",&u,&v);
			printf("%d
",dep[id[u]]+dep[id[v]]-2*dep[id[lca(u,v)]]);
		}
		if(T)puts("");
	}
}

与传统RMQ不同的是DP数组的意义，

反正可以用dep数组查找到对应深度，RMQ就没必要保存最值了，直接保存dfs序列号