#include "bits/stdc++.h"

#pragma warning(disable:4996)
using namespace std;

class Tree {
public:
	Tree(int V, int root) : V(V), root(root), cnum(V), place(V), id(V) {
		T.resize(V);
		for (int i = 0; i < MAXLOGV; i++) {
			parent[i].resize(V);
		}
		depth.resize(V);
	}
	// uとvをつなぐ
	// lcaを求めることが主目的なので無向グラフとしている
	void unite(int u, int v) {
		T[u].push_back(v);
		T[v].push_back(u);
	}
	void unite(vector<vector<int>>&e) {
		T = e;
	}
	// initする
	// コンストラクタだけじゃなくてこれも呼ばないとlcaが求められないぞ
	void init() {
		dfs(root, 0, 0);
		int id = 0;
		getid(root, 0, id);
	}
	// uとvのlcaを求める
	int lca(int u, int v) const {
		if (depth[u] > depth[v]) swap(u, v);
		for (int k = 0; k < MAXLOGV; k++) {
			if ((depth[v] - depth[u]) >> k & 1) {
				v = parent[k][v];
			}
		}
		if (u == v) return u;
		for (int k = MAXLOGV - 1; k >= 0; k--) {
			if (parent[k][u] != parent[k][v]) {
				u = parent[k][u];
				v = parent[k][v];
			}
		}
		return parent[0][u];
	}
	// uとvの距離を求める
	// edgeを定義しないといけない時はこれじゃダメ
	int dist(int u, int v) const {
		int p = lca(u, v);
		return (depth[u] - depth[p]) + (depth[v] - depth[p]);
	}
	int dfs(int v, int p, int d) {
		parent[0][v] = p;
		depth[v] = d;
		cnum[v] = 0;
		for (int i = 1; i < MAXLOGV; i++) {
			parent[i][v] = parent[i - 1][parent[i - 1][v]];
		}
		for (int next : T[v]) {
			if (next != p) cnum[v] += dfs(next, v, d + 1);
		}
		return cnum[v] + 1;
	}

	void dfs2(int v, int p, vector<vector<int>>&doubles, const vector<int>&nums) {
		for (int next : T[v]) {
			if (next != p) dfs2(next, v, doubles, nums);
		}
		doubles[0][v] = nums[v];
		for (int j = 1; j < MAXLOGV; ++j) {
			doubles[j][v] = min(doubles[j][v], doubles[j - 1][v]);
		}
		for (int j = 0; j < MAXLOGV - 1; ++j) {
			doubles[j + 1][parent[j][v]] = min(doubles[j + 1][parent[j][v]], doubles[j][v]);
		}
	}
	//ここでは親から距離2^iの部分木の最小値を求めている
	vector<vector<int>>get_doubles(const vector<int>&nums) {
		vector<vector<int>>doubles(MAXLOGV, vector<int>(V, 1e9));
		dfs2(root, -1, doubles, nums);
		return doubles;
	}

	void getid(const int v, const int p, int &nplace) {
		place[v] = nplace;
		id[nplace] = v;
		nplace++;
		for (int next : T[v]) {
			if (next != p) getid(next, v, nplace);
		}
	}
	static const int MAXLOGV = 25;
	// グラフの隣接リスト表現
	vector<vector<int> > T;
	// 頂点の数
	int V;
	// 根ノードの番号
	int root;

	// 親ノード
	vector<int> parent[MAXLOGV];
	// 根からの深さ
	vector<int> depth;

	//子の数
	vector<int>cnum;

	//変換
	vector<int>place;
	vector<int>id;

};
void dd(const int now, const int from, const long long int now_len,
	const vector<vector<pair<int, long long int>>>&edges,
	vector<long long int>&lens) {
	lens[now]=now_len;
	for (auto e : edges[now]) {
		if (e.first != from) {
			dd(e.first,now,now_len+e.second,edges,lens);
		}
	}
}

pair<int,int>solve(const vector<long long int>&lens,Tree&t, int x, int y) {
	int r=t.lca(x,y);
	long long int rx_len=lens[x]-lens[r];
	long long int ry_len=lens[y]-lens[r];

	if (rx_len < ry_len) {
		swap(x,y);
		swap(rx_len,ry_len);
	}
	assert(rx_len>=ry_len);
	long long int half=(rx_len+ry_len)/2;
	int now=x;
	long long int sum=0;
	for (int i = 24; i >=0;--i) {
		int next=t.parent[i][now];
		long long int plus=lens[now]-lens[next];
		if ((sum+plus) * 2 <= rx_len + ry_len) {
			now=next;
			sum+=plus;
		}
	}
	return make_pair(now,t.parent[0][now]);
}
int main() {
	int N,Q;cin>>N>>Q;
	Tree t(N,0);
	vector<long long int>lens(N);
	vector<vector<pair<int,long long int>>>edges(N);
	for (int i = 0; i < N - 1; ++i) {
		int u,v,w;cin>>u>>v>>w;
		u--;v--;
		t.unite(u,v);
		edges[u].push_back(make_pair(v,w));
		edges[v].push_back(make_pair(u,w));
	}
	t.init();
	dd(0,-1,0,edges,lens);

	for (int q = 0; q < Q; ++q) {
		vector<int>cities(3);
		for (int i = 0; i < 3; ++i) {
			cin>>cities[i];
			cities[i]--;
		}


		vector<int>candidates;
		for (int i = 0; i < 3; ++i) {
			int a=i;
			int b=(i+1)%3;
			a=cities[a];
			b=cities[b];
			auto p=solve(lens,t,a,b);
			candidates.push_back(p.first);
			candidates.push_back(p.second);
		}
		long long int answer=1e18;
		for (auto cand : candidates) {
			long long int nanswer=0;
			for (int i = 0; i < 3; ++i) {
				int alca=t.lca(cities[i],cand);
				long long int need=lens[cand]+lens[cities[i]]-2*
					lens[alca];
				nanswer = max(nanswer, need);

			}
			answer=min(answer,nanswer);
		}
		cout<<answer<<endl;
	}
	return 0;
}


Measured memory_bytes: 35368