import sys
from math import log2
from collections import deque
def main():
sys.setrecursionlimit(1 << 25)
input = sys.stdin.read().split()
ptr = 0
N, S, Q, E = map(int, input[ptr:ptr+4])
ptr +=4
adj = [[] for _ in range(N+1)]
edges = []
edge_to_index = {}
for i in range(1, N):
A, B, W = map(int, input[ptr:ptr+3])
ptr +=3
adj[A].append((B, W, i))
adj[B].append((A, W, i))
edges.append((A, B, W))
edge_to_index[(A, B)] = i
edge_to_index[(B, A)] = i
shops = set()
for _ in range(S):
C = int(input[ptr])
ptr +=1
shops.add(C)
queries = []
for _ in range(Q):
I, R = map(int, input[ptr:ptr+2])
ptr +=2
queries.append((I, R))
LOG = int(log2(N)) + 1
parent = [[-1]*(N+1) for _ in range(LOG)]
depth = [0]*(N+1)
dist_from_root = [0]*(N+1)
q = deque([E])
parent[0][E] = -1
while q:
u = q.popleft()
for v, w, _ in adj[u]:
if parent[0][v] == -1 and v != parent[0][u]:
parent[0][v] = u
depth[v] = depth[u] + 1
dist_from_root[v] = dist_from_root[u] + w
q.append(v)
for k in range(1, LOG):
for v in range(1, N+1):
if parent[k-1][v] != -1:
parent[k][v] = parent[k-1][parent[k-1][v]]
def lca(u, v):
if depth[u] < depth[v]:
u, v = v, u
for k in range(LOG-1, -1, -1):
if depth[u] - (1<<k) >= depth[v]:
u = parent[k][u]
if u == v:
return u
for k in range(LOG-1, -1, -1):
if parent[k][u] != -1 and parent[k][u] != parent[k][v]:
u = parent[k][u]
v = parent[k][v]
return parent[0][u]
def distance(u, v):
ancestor = lca(u, v)
return dist_from_root[u] + dist_from_root[v] - 2 * dist_from_root[ancestor]
edge_child = {}
edge_parent = {}
for i in range(1, N):
A, B, W = edges[i-1]
if depth[A] > depth[B]:
edge_child[i] = A
edge_parent[i] = B
else:
edge_child[i] = B
edge_parent[i] = A
closest_shop = [None]*(N+1)
closest_dist = [float('inf')]*(N+1)
stack = [(E, False)]
while stack:
node, processed = stack.pop()
if not processed:
stack.append((node, True))
for neighbor, _, _ in reversed(adj[node]):
if neighbor != parent[0][node]:
stack.append((neighbor, False))
else:
if node in shops:
closest_shop[node] = node
closest_dist[node] = 0
for neighbor, _, _ in adj[node]:
if neighbor != parent[0][node]:
if closest_dist[neighbor] + (distance(node, neighbor)) < closest_dist[node]:
closest_dist[node] = closest_dist[neighbor] + distance(node, neighbor)
closest_shop[node] = closest_shop[neighbor]
# Now process queries
for I, R in queries:
A, B, W = edges[I-1]
u, v = A, B
if depth[u] > depth[v]:
child = u
else:
child = v
parent_edge = edge_parent[I]
child_edge = edge_child[I]
if lca(parent_edge, R) == parent_edge and lca(child_edge, R) == child_edge:
if closest_shop[child_edge] is not None:
print(closest_dist[child_edge] + distance(R, child_edge))
else:
print("oo")
else:
print("escaped")
if __name__ == "__main__":
main()
