Problem:
Score : 400 points

Problem Statement

You are given a tree with N vertices.

Here, a tree is a kind of graph, and more specifically, a connected undirected graph with N-1 edges, where N is the number of its vertices.

The i-th edge (1≤i≤N-1) connects Vertices a_i and b_i, and has a length of c_i.

You are also given Q queries and an integer K. In the j-th query (1≤j≤Q):

find the length of the shortest path from Vertex x_j and Vertex y_j via Vertex K.

Constraints

3≤N≤10^5

1≤a_i,b_i≤N (1≤i≤N-1)

1≤c_i≤10^9 (1≤i≤N-1)

The given graph is a tree.

1≤Q≤10^5

1≤K≤N

1≤x_j,y_j≤N (1≤j≤Q)

x_j≠y_j (1≤j≤Q)

x_j≠K,y_j≠K (1≤j≤Q)

Input

Input is given from Standard Input in the following format:

N
a_1 b_1 c_1
:
a_{N-1} b_{N-1} c_{N-1}
Q K
x_1 y_1
:
x_{Q} y_{Q}

Output

Print the responses to the queries in Q lines.

In the j-th line j(1≤j≤Q), print the response to the j-th query.

Sample Input 1

5
1 2 1
1 3 1
2 4 1
3 5 1
3 1
2 4
2 3
4 5

Sample Output 1

3
2
4

The shortest paths for the three queries are as follows:

Query 1: Vertex 2 → Vertex 1 → Vertex 2 → Vertex 4 : Length 1+1+1=3

Query 2: Vertex 2 → Vertex 1 → Vertex 3 : Length 1+1=2

Query 3: Vertex 4 → Vertex 2 → Vertex 1 → Vertex 3 → Vertex 5 : Length 1+1+1+1=4

Sample Input 2

7
1 2 1
1 3 3
1 4 5
1 5 7
1 6 9
1 7 11
3 2
1 3
4 5
6 7

Sample Output 2

5
14
22

The path for each query must pass Vertex K=2.

Sample Input 3

10
1 2 1000000000
2 3 1000000000
3 4 1000000000
4 5 1000000000
5 6 1000000000
6 7 1000000000
7 8 1000000000
8 9 1000000000
9 10 1000000000
1 1
9 10

Sample Output 3

17000000000

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <iostream> 
#include <cstring> 
#include <algorithm> 
using namespace std; 
#define N 100000+10 
#define M 100000+10 

typedef long long ll;

typedef struct node 
{ 
    int v;
	ll w;
    struct node *next; 
} node, *pnode; 
node e[M<<1], *adjlist[N];
int stack[N];
int top, E[N<<1], L[N<<1], H[N], n, m, tot;
ll d[N];

bool vis[N];

void insert(int u, int v, ll w) 
{ 
    pnode p = e + (++tot); 
    p->v = v, p->w = w; 
    p->next = adjlist[u], adjlist[u] = p; 
} 

void DFS(int root) 
{ 
    memset(vis, false, sizeof(vis)); 
    top = -1; 
    int level = 1, order = 1;
    ll dist = 0,  pre_w = 0; 
    stack[++top] = root, vis[root] = true, H[root] = order , d[root] = dist; 
    while(top >= 0) 
    { 
        int now = stack[top]; 
        bool back = true; 
        E[order] = now, L[order++] = level; 
        for(pnode p = adjlist[now]; p; p = p->next) 
        { 
            if(!vis[p->v]) 
            { 
                stack[++top] = p->v; 
                d[p->v] = (dist += (pre_w = p->w)), H[p->v] = order , level++; 
                vis[p->v] = true, back = false; 
                break; 
            } 
        } 
        if(back)dist -= pre_w, level--, top--; 
    } 
} 

int Min[N<<1][22], idx[N<<1]; 
void RMQ(int len) 
{ 
    idx[0] = -1; 
    for(int i = 1; i <= len ; i ++) 
        idx[i] = (i & (i - 1)) ? idx[i-1] : idx[i-1] + 1, Min[i][0] = i; 
    for(int j = 1; j <= idx[len] ; j ++) 
        for(int i = 1, limit = len + 1 - (1 << j); i <= limit ; i ++) 
            Min[i][j] = Min[i+(L[Min[i][j-1]] > L[Min[i+(1<<j>>1)][j-1]] ? (1 << j>>1) : 0)][j-1]; 
} 

int LCA(int u, int v) 
{ 
    int a = H[u], b = H[v]; 
    if(a > b)swap(a, b); 
    int t = idx[b-a+1]; 
    b -= (1 << t) - 1; 
    return E[Min[L[Min[a][t]] > L[Min[b][t]] ? b : a][t]]; 
} 
int main() 
{ 
    int n, K, Q; 
    cin>>n;
    tot = -1; 
    memset(adjlist, 0, sizeof(adjlist)); 
    m = n - 1; 
    for(int i = 0; i < m; i++){ 
            int u, v;
			ll w; 
            cin>>u>>v>>w;
            insert(u, v, w), insert(v, u, w); 
        } 
        DFS(1); 
        RMQ(n + n - 1); 
        cin>>Q>>K;
        while(Q--) 
        { 
            int u, v; 
            cin>>u>>v;
            ll dist1 = d[u] + d[K] - 2 * d[LCA(u, K)];
            ll dist2 =  d[v] + d[K] - 2 * d[LCA(v, K)];
            cout<<dist1+ dist2<<endl; 
        } 
    return 0; 
}