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 Java8 (OpenJDK 1.8.0) (judge verdict: Time Limit Exceeded)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.util.Iterator;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
import java.util.Vector;

public class Main {
	static Node[] nodes;
	static int src;
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		int n = in.nextInt();
		int e = n - 1;
		nodes = new Node[n];
		for (int i = 0; i < n; i++) nodes[i] = new Node(i);
		for (int i = 0; i < e; i++) {
			int from = in.nextInt() - 1;
			int to = in.nextInt() - 1;
			double len = in.nextInt();
			nodes[from].edges.add(new Edge(nodes[from], nodes[to], len));
			nodes[to].edges.add(new Edge(nodes[to], nodes[from], len));
		}
		int q = in.nextInt();
		src = in.nextInt() - 1;
		PFSearch dj = new PFSearch(nodes);
		dj.solve(nodes[src]);
		for (int i = 0; i < q; i++) {
			int x = in.nextInt() - 1;
			int y = in.nextInt() - 1;
			out.println((long)(dj.nodes[x].value + dj.nodes[y].value));
		}
		out.flush();
	}
	public static class Node implements Comparable {
		int id;
		double value;
		Node via;
		Vector<Edge> edges;
		public Node(int id) {
			this.id = id;
			this.value = Double.MAX_VALUE;
			this.via = null;
			this.edges = new Vector<Edge>();
		}
		public int compareTo(Object o) {
			if (!(o instanceof Node)) throw new IllegalArgumentException("Node needed");
			Node x = (Node)o;
			return (this.value > x.value)? 1 :
				((this.value < x.value)? (-1) : 0);
		}
	}
	public static class Edge {
		Node src;
		Node dst;
		double value;
		public Edge(Node src,Node dst,double value) {
			this.src = src;
			this.dst = dst;
			this.value = value;
		}
	}
	public static class PFSearch {
		Node[] nodes;
		public PFSearch(Node[] nodes) {
			this.nodes = nodes;
		}
		public void solve(Node src) {
			PriorityQueue<Node> q = new PriorityQueue<Node>();
			for (int i = 0; i < nodes.length; i++) {
				nodes[i].value = Double.MAX_VALUE;
				q.add(nodes[i]);
			}
			q.remove(src);
			src.value = 0;
			q.offer(src);
			while (q.size() > 0) {
				Node x = q.poll();
				if (x.value == Double.MAX_VALUE) return;
				for (Iterator<Edge> it = x.edges.iterator(); it.hasNext(); ) {
					Edge e = it.next();
					Node y = e.dst;
					double newValue = x.value + e.value;
					if (newValue < y.value) {
						if (q.remove(y)) {
							y.value = newValue;
							y.via = x;
							q.offer(y);
						}
					}
				}
			}
		}
		public Node[] getPath(int id) {
			Vector<Node> v = new Vector<Node>();
			for (Node node = nodes[id]; node != null; node=node.via) v.add(node);
			for (int i = 0; i < v.size() / 2; i++) {
				int j = v.size() - 1 - i;
				Node tmp = v.get(i);
				v.set(i, v.get(j));
				v.set(j, tmp);
			}
			return v.toArray(new Node[0]);
		}
	}
	public static class InputReader {
		BufferedReader in;
		StringTokenizer tok;
		public String nextString() {
			while (!tok.hasMoreTokens()) {
				try {
					tok = new StringTokenizer(in.readLine(), " ");
				} catch (IOException e) {
					throw new InputMismatchException();
				}
			}
			return tok.nextToken();
		}
		public int nextInt() {
			return Integer.parseInt(nextString());
		}
		public long nextLong() {
			return Long.parseLong(nextString());
		}
		public int[] nextIntArray(int n) {
			int[] res = new int[n];
			for (int i = 0; i < n; i++) {
				res[i] = nextInt();
			}
			return res;
		}
		public long[] nextLongArray(int n) {
			long[] res = new long[n];
			for (int i = 0; i < n; i++) {
				res[i] = nextLong();
			}
			return res;
		}
		public InputReader(InputStream inputStream) {
			in = new BufferedReader(new InputStreamReader(inputStream));
			tok = new StringTokenizer("");
		}
	}
}