#include <cmath>

 #include <cstdio>

 #include <cstring>

 #include <algorithm>

 #define N1 100005

 #define M1 505

 #define ll long long

 #define uint unsigned int

 #define ush unsigned short

 using namespace std;

 const int inf=0x3f3f3f3f;

 template <typename _T> void read(_T &ret)

 {

     ret=; _T fh=; char c=getchar();

     while(c<''||c>''){ if(c=='-') fh=-; c=getchar(); }

     while(c>=''&&c<=''){ ret=ret*+c-''; c=getchar(); }

     ret=ret*fh;

 }

 struct Edge{

 int to[N1*],nxt[N1*],val[N1*],head[N1],cte;

 void ae(int u,int v,int w)

 { cte++; to[cte]=v; nxt[cte]=head[u]; val[cte]=w; head[u]=cte; }

 }e;

 int lg[N1*],de;

 namespace Tree{

 int dis[N1],dep[N1],fa[N1],st[N1],ff[N1*][],cur; //ord[N1*2],

 void dfs1(int x)

 {

     int j,v; st[x]=++cur; ff[cur][]=x;

     for(j=e.head[x];j;j=e.nxt[j])

     {

         v=e.to[j]; if(v==fa[x]) continue;

         fa[v]=x; dis[v]=dis[x]+e.val[j]; dep[v]=dep[x]+;

         dfs1(v); ff[++cur][]=x;

     }

 }

 void init()

 {

     dep[]=; dfs1();

     int i,j;

     for(i=,lg[]=;i<=cur;i++) lg[i]=lg[i>>]+;

     for(j=;j<=lg[cur];j++)

     for(i=;i+(<<j)-<=cur;i++)

         ff[i][j]=dep[ff[i][j-]] < dep[ff[i+(<<(j-))][j-]] ? ff[i][j-] : ff[i+(<<(j-))][j-];

 }

 inline int Dis(int x,int y)

 {

     int i=st[x],j=st[y],F; if(i>j) swap(i,j);

     F=dep[ff[i][lg[j-i+]]] < dep[ff[j-(<<lg[j-i+])+][lg[j-i+]]] ? ff[i][lg[j-i+]] : ff[j-(<<lg[j-i+])+][lg[j-i+]];

     return dis[x]+dis[y]-*dis[F];

 }

 };

 struct SEG{

 struct node{ int ls,rs,mi; };

 node a[N1*]; int root[N1],tot;

 inline void pushup(int rt)

 {

     a[rt].mi=inf;

     if(a[rt].ls) a[rt].mi=min(a[rt].mi,a[a[rt].ls].mi);

     if(a[rt].rs) a[rt].mi=min(a[rt].mi,a[a[rt].rs].mi);

 }

 void upd(int x,int l,int r,int &rt,int w)

 {

     if(!rt) rt=++tot;

     if(l==r){ a[rt].mi=w; return; }

     int mid=(l+r)>>;

     if(x<=mid) upd(x,l,mid,a[rt].ls,w);

     else upd(x,mid+,r,a[rt].rs,w);

     pushup(rt);

 }

 int qmi(int L,int R,int l,int r,int rt)

 {

     if(!rt) return inf;

     if(L<=l&&r<=R) return a[rt].mi;

     int mid=(l+r)>>; int ans=inf;

     if(L<=mid) ans=min(ans,qmi(L,R,l,mid,a[rt].ls));

     if(R>mid) ans=min(ans,qmi(L,R,mid+,r,a[rt].rs));

     return ans;

 }

 }s;

 using Tree::Dis;

 int n;

 int sz[N1],ms[N1],use[N1],pfa[N1],SZ,G;

 void gra(int x,int dad,int now)

 {

     int j,v; sz[x]=; ms[x]=;

     if(now) s.upd(x,,n,s.root[now],Dis(x,now));

     for(j=e.head[x];j;j=e.nxt[j])

     {

         v=e.to[j]; if(v==dad || use[v]) continue;

         gra(v,x,now);

         sz[x]+=sz[v]; ms[x]=max(ms[x],sz[v]);

     }

     ms[x]=max(ms[x],SZ-sz[x]);

     if(ms[x]<ms[G]) G=x;

 }

 void main_dfs(int x)

 {

     int j,v; use[x]=;

     s.upd(x,,n,s.root[x],);

     for(j=e.head[x];j;j=e.nxt[j])

     {

         v=e.to[j]; if(use[v]) continue;

         SZ=sz[v]; G=; gra(v,x,x); pfa[G]=x;

         main_dfs(G);

     }

 }

 int main()

 {

     scanf("%d",&n);

     int i,j,x,y,w,Q,q,l,r,D,ans;

     for(i=;i<n;i++)

     {

         read(x), read(y), read(w);

         e.ae(x,y,w); e.ae(y,x,w);

     }

     Tree::init();

     ms[]=n; SZ=n; gra(,,); main_dfs(G);

     scanf("%d",&Q);

     for(q=;q<=Q;q++)

     {

         read(l), read(r), read(x); ans=inf;

         for(y=x;y;y=pfa[y])

         {

             D=Dis(x,y);

             ans=min(ans,D+s.qmi(l,r,,n,s.root[y]));

         }

         printf("%d\r\n",ans);

     }

     return ;

 }