input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import heapq
N = int(eval(input()))
edges = {i: [] for i in range(N)}
for i in range(N - 1):
a, b, c = list(map(int, input().split(" ")))
edges[a - 1].append((b - 1, c))
edges[b - 1].append((a - 1, c))
Q, K = list(map(int, input().split(" ")))
# Kからの最短距離を計算
dist = [-1 for i in range(N)]
que = []
heapq.heappush(que, (0, K - 1, -1)) # (distance, index, parent)
while len(que) > 0:
d, ind, par = heapq.heappop(que)
if dist[ind] != -1:
continue
dist[ind] = d
for edge in edges[ind]:
if edge[0] == par:
continue
heapq.heappush(que, (d + edge[1], edge[0], ind))
for _ in range(Q):
x, y = list(map(int, input().split(" ")))
print((dist[x - 1] + dist[y - 1])) | import heapq
import sys
input = sys.stdin.readline
N = int(eval(input()))
edges = {i: [] for i in range(N)}
for i in range(N - 1):
a, b, c = list(map(int, input().split(" ")))
edges[a - 1].append((b - 1, c))
edges[b - 1].append((a - 1, c))
Q, K = list(map(int, input().split(" ")))
# Kからの最短距離を計算
dist = [-1 for i in range(N)]
que = []
heapq.heappush(que, (0, K - 1, -1)) # (distance, index, parent)
while len(que) > 0:
d, ind, par = heapq.heappop(que)
if dist[ind] != -1:
continue
dist[ind] = d
for edge in edges[ind]:
if edge[0] == par:
continue
heapq.heappush(que, (d + edge[1], edge[0], ind))
for _ in range(Q):
x, y = list(map(int, input().split(" ")))
print((dist[x - 1] + dist[y - 1])) | p03634 |
# -*- coding: utf-8 -*-
from collections import defaultdict,deque
N = int(eval(input()))
abc = [list(map(int, input().split())) for _ in range(N-1)]
Q, K = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(Q)]
graph = defaultdict(lambda: defaultdict(int))
for a,b,c in abc:
graph[a-1][b-1] = c
graph[b-1][a-1] = c
def xfs(v,g):
que = deque()
que.append([v,0])
while len(que) > 0:
# i,dist = que.pop() # 深さ優先探索
i,dist = que.popleft() #幅優先探索
if i == g:
return dist
for n, val in list(graph[i].items()):
que.append([n,dist+val])
return -1
for x,y in xy:
print((xfs(x-1,K-1) + xfs(K-1,y-1)))
| # -*- coding: utf-8 -*-
from collections import defaultdict,deque
N = int(eval(input()))
abc = [list(map(int, input().split())) for _ in range(N-1)]
Q, K = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(Q)]
# graph = defaultdict(lambda: defaultdict(int))
graph = [defaultdict(int) for _ in range(N)]
for a,b,c in abc:
graph[a-1][b-1] = c
graph[b-1][a-1] = c
def xfs(v):
dist = [-1 for _ in range(N)]
dist[v] = 0
que = deque()
que.append(v)
while len(que) > 0:
i = que.pop() # 深さ優先探索
# i = que.popleft() #幅優先探索
for n, val in list(graph[i].items()):
if dist[n] == -1:
dist[n] = dist[i] + val
que.append(n)
return dist
dist = xfs(K-1)
for x,y in xy:
print((dist[x-1] + dist[y-1]))
| p03634 |
#dojkstra (prioroty queue ver.)
import queue
G=[]
inf=3*10**15
#V, E=map(int,input().strip().split(' '))
V=int(input().strip())
E=V-1
for i in range(V):
G.append([])
for i in range(E):
at,bt,ct=list(map(int,input().strip().split(' ')))
G[at-1].append([ct,bt-1])
G[bt-1].append([ct,at-1]) #無向グラフのときはon
'''
#入力が0-indexedのとき
G[at].append([ct,bt])
G[bt].append([ct,at]) #無向グラフのときはon
'''
#入力が1-indexedのとき
def dijkstra(s):
d=[inf]*V
d[s]=0
q=queue.PriorityQueue()
q.put([0,s])
while q.empty()==False:
dq,v=q.get()
if d[v]<dq:
continue
for i in range(len(G[v])):
ec, et=G[v][i]
#print(ec,et)
if d[et]>d[v]+ec:
d[et]=d[v]+ec
q.put([d[et],et])
return d
d=[]
for i in range(V):
d.append(dijkstra(i))
Q, K=list(map(int,input().strip().split(' ')))
K-=1 #0-indexedに直す
x=[]
y=[]
for i in range(Q):
xt, yt=list(map(int,input().strip().split(' ')))
x.append(xt-1)#0-indexedに直して入れる
y.append(yt-1)#0-indexedに直して入れる
for i in range(Q):
print((d[x[i]][K]+d[K][y[i]])) | #dojkstra (prioroty queue ver.)
import queue
G=[]
#infの値に注意
inf=3*10**15
#V, E=map(int,input().strip().split(' '))
V=int(input().strip())
E=V-1
for i in range(V):
G.append([])
for i in range(E):
at,bt,ct=list(map(int,input().strip().split(' ')))
G[at-1].append([ct,bt-1])
G[bt-1].append([ct,at-1]) #無向グラフのときはon
'''
#入力が0-indexedのとき
G[at].append([ct,bt])
G[bt].append([ct,at]) #無向グラフのときはon
'''
#入力が1-indexedのとき
def dijkstra(s):
d=[inf]*V
d[s]=0
q=queue.PriorityQueue()
q.put([0,s])
while q.empty()==False:
dq,v=q.get()
if d[v]<dq:
continue
for i in range(len(G[v])):
ec, et=G[v][i]
#print(ec,et)
if d[et]>d[v]+ec:
d[et]=d[v]+ec
q.put([d[et],et])
return d
Q, K=list(map(int,input().strip().split(' ')))
K-=1 #0-indexedに直す
x=[]
y=[]
d=dijkstra(K)
for i in range(Q):
xt, yt=list(map(int,input().strip().split(' ')))
x.append(xt-1)#0-indexedに直して入れる
y.append(yt-1)#0-indexedに直して入れる
for i in range(Q):
print((d[x[i]]+d[y[i]])) | p03634 |
#dojkstra (prioroty queue ver.)
import queue
G=[]
#infの値に注意
inf=3*10**15
#V, E=map(int,input().strip().split(' '))
V=int(input().strip())
E=V-1
for i in range(V):
G.append([])
for i in range(E):
at,bt,ct=list(map(int,input().strip().split(' ')))
G[at-1].append([ct,bt-1])
G[bt-1].append([ct,at-1]) #無向グラフのときはon
'''
#入力が0-indexedのとき
G[at].append([ct,bt])
G[bt].append([ct,at]) #無向グラフのときはon
'''
#入力が1-indexedのとき
def dijkstra(s):
d=[inf]*V
d[s]=0
q=queue.PriorityQueue()
q.put([0,s])
while q.empty()==False:
dq,v=q.get()
if d[v]<dq:
continue
for i in range(len(G[v])):
ec, et=G[v][i]
#print(ec,et)
if d[et]>d[v]+ec:
d[et]=d[v]+ec
q.put([d[et],et])
return d
Q, K=list(map(int,input().strip().split(' ')))
K-=1 #0-indexedに直す
x=[]
y=[]
d=dijkstra(K)
for i in range(Q):
xt, yt=list(map(int,input().strip().split(' ')))
x.append(xt-1)#0-indexedに直して入れる
y.append(yt-1)#0-indexedに直して入れる
for i in range(Q):
print((d[x[i]]+d[y[i]])) | import sys
#limit=sys.getrecursionlimit()
sys.setrecursionlimit(10000000)
#sys.setrecursionlimit(1000000000)
V=int(input().strip())
E=V-1
inf=3*10**15
G=[]
dist=[inf]*V
for i in range(V):
G.append([])
for i in range(E):
at,bt,ct=list(map(int,input().strip().split(' ')))
G[at-1].append([ct,bt-1])
G[bt-1].append([ct,at-1])
visited=[False]*V
def dfs(v,p,d):
#global d
dist[v]=d
for q in G[v]:
if q[1]==p:
continue
dfs(q[1],v,d+q[0])
Q, K=list(map(int,input().strip().split(' ')))
K-=1 #0-indexedに直す
dfs(K,-1,0)
x=[]
y=[]
for i in range(Q):
xt, yt=list(map(int,input().strip().split(' ')))
x.append(xt-1)#0-indexedに直して入れる
y.append(yt-1)#0-indexedに直して入れる
for i in range(Q):
print((dist[x[i]]+dist[y[i]]))
| p03634 |
#!/usr/bin/env python3
import sys
def warshall_floyd(conn):
n = len(conn)
dp = [[v for v in A] for A in conn]
for k in range(n):
for i in range(n):
for j in range(n):
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j])
return dp
def solve(N: int, A: "List[int]", B: "List[int]", C: "List[int]", Q: int, K: int, x: "List[int]", y: "List[int]"):
conn = [[float('inf') for _ in range(N)] for _ in range(N)]
for i in range(N):
conn[i][i] = 0
for j in range(N - 1):
a = A[j] - 1
b = B[j] - 1
conn[a][b] = min(conn[a][b], C[j])
conn[b][a] = min(conn[b][a], C[j])
d = warshall_floyd(conn)
for q in range(Q):
s = x[q] - 1
t = y[q] - 1
k = K - 1
ret = d[s][k] + d[k][t]
print(ret)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int()] * (N-1) # type: "List[int]"
b = [int()] * (N-1) # type: "List[int]"
c = [int()] * (N-1) # type: "List[int]"
for i in range(N-1):
a[i] = int(next(tokens))
b[i] = int(next(tokens))
c[i] = int(next(tokens))
Q = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
x = [int()] * (Q) # type: "List[int]"
y = [int()] * (Q) # type: "List[int]"
for i in range(Q):
x[i] = int(next(tokens))
y[i] = int(next(tokens))
solve(N, a, b, c, Q, K, x, y)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
sys.setrecursionlimit(300000)
def dfs(idx, visited, conn, d, cur):
visited[idx] = True
for nex in conn[idx]:
if not visited[nex[0]]:
d[nex[0]] = cur + nex[1]
d = dfs(nex[0], visited, conn, d, cur + nex[1])
return d
def solve(N: int, A: "List[int]", B: "List[int]", C: "List[int]", Q: int, K: int, x: "List[int]", y: "List[int]"):
conn = [[] for _ in range(N)]
for j in range(N - 1):
a = A[j] - 1
b = B[j] - 1
conn[a].append([b, C[j]])
conn[b].append([a, C[j]])
visited = [False] * N
d = [0] * N
d = dfs(K - 1, visited, conn, d, 0)
for q in range(Q):
s = x[q] - 1
t = y[q] - 1
ret = d[s] + d[t]
print(ret)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int()] * (N-1) # type: "List[int]"
b = [int()] * (N-1) # type: "List[int]"
c = [int()] * (N-1) # type: "List[int]"
for i in range(N-1):
a[i] = int(next(tokens))
b[i] = int(next(tokens))
c[i] = int(next(tokens))
Q = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
x = [int()] * (Q) # type: "List[int]"
y = [int()] * (Q) # type: "List[int]"
for i in range(Q):
x[i] = int(next(tokens))
y[i] = int(next(tokens))
solve(N, a, b, c, Q, K, x, y)
if __name__ == '__main__':
main()
| p03634 |
#!/usr/bin/python3
# -*- coding:utf-8 -*-
from collections import defaultdict
import sys
sys.setrecursionlimit(10**9)
def main():
n = int(eval(input()))
tree = defaultdict(lambda : {'parent':-1, 'score':0, 'children':[]})
weights = dict()
for _ in range(n-1):
a, b, c = list(map(int, input().split()))
tree[a]['children'].append(b)
tree[b]['children'].append(a)
weights[(a, b)] = weights[(b, a)] = c
q, k = list(map(int, input().split()))
visited = [False] * (n+1)
iroot = k
def dfs(inode, score=0):
visited[inode] = True
for ichild in tree[inode]['children']:
if visited[ichild]:
continue
tree[ichild]['score'] = weights[(inode, ichild)] + score
tree[ichild]['parent'] = inode
dfs(ichild, tree[ichild]['score'])
dfs(iroot)
for _ in range(q):
x, y = list(map(int, input().split()))
print((tree[x]['score'] + tree[y]['score']))
if __name__=='__main__':
main()
| #!/usr/bin/python3
# -*- coding:utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
def main():
n = int(eval(input()))
inode2scores = [0] * (n+1)
tree = [[] for _ in range(n+1)]
weights = dict()
for _ in range(n-1):
a, b, c = list(map(int, input().split()))
tree[a].append(b)
tree[b].append(a)
weights[(a, b)] = weights[(b, a)] = c
q, k = list(map(int, input().split()))
visited = [False] * (n+1)
iroot = k
def dfs(inode, score=0):
visited[inode] = True
for ichild in tree[inode]:
if visited[ichild]:
continue
inode2scores[ichild] = weights[(inode, ichild)] + score
dfs(ichild, inode2scores[ichild])
dfs(iroot)
for _ in range(q):
x, y = list(map(int, input().split()))
print((inode2scores[x] + inode2scores[y]))
if __name__=='__main__':
main()
| p03634 |
from heapq import heappush, heappop
from collections import deque
N = int(eval(input()))
G = [[] for i in range(N)]
for i in range(N - 1):
a, b, c = list(map(int, input().split()))
a, b = a - 1, b - 1
G[a].append((b, c))
G[b].append((a, c))
Q, K = list(map(int, input().split()))
K -= 1
INF = float("inf")
d = [INF] * N
d[K] = 0
que = [(0, K)]
while que:
cost, v = heappop(que)
if d[v] < cost:
continue
for w, c in G[v]:
if d[v] + c < d[w]:
d[w] = d[v] + c
heappush(que, (d[w], w))
for i in range(Q):
x, y = list(map(int, input().split()))
print((d[x - 1] + d[y - 1]))
| import sys
sys.setrecursionlimit(10 ** 6)
N = int(eval(input()))
G = [[] for i in range(N)]
for i in range(N - 1):
a, b, c = list(map(int, input().split()))
G[a - 1].append((b - 1, c))
G[b - 1].append((a - 1, c))
Q, K = list(map(int, input().split()))
dist = [-1] * N
def dfs(u, par, d):
dist[u] = d
for w, cost in G[u]:
if w == par:
continue
dfs(w, u, d + cost)
dfs(K - 1, -1, 0)
for i in range(Q):
x, y = list(map(int, input().split()))
x, y = x - 1, y - 1
print((dist[x] + dist[y])) | p03634 |
import sys
sys.setrecursionlimit(10 ** 6)
N = int(eval(input()))
G = [[] for i in range(N)]
for i in range(N - 1):
a, b, c = list(map(int, input().split()))
G[a - 1].append((b - 1, c))
G[b - 1].append((a - 1, c))
Q, K = list(map(int, input().split()))
dist = [-1] * N
def dfs(u, par, d):
dist[u] = d
for w, cost in G[u]:
if w == par:
continue
dfs(w, u, d + cost)
dfs(K - 1, -1, 0)
for i in range(Q):
x, y = list(map(int, input().split()))
x, y = x - 1, y - 1
print((dist[x] + dist[y])) | import sys
sys.setrecursionlimit(10 ** 6)
N = int(eval(input()))
G = [[] for i in range(N)]
for i in range(N - 1):
a, b, c = list(map(int, input().split()))
a, b = a - 1, b - 1
G[a].append((b, c))
G[b].append((a, c))
d = [0] * N
def dfs(u, p, k):
d[u] = k
for w, c in G[u]:
if w == p:
continue
dfs(w, u, k + c)
Q, K = list(map(int, input().split()))
dfs(K - 1, -1, 0)
for i in range(Q):
x, y = list(map(int, input().split()))
x, y = x - 1, y - 1
print((d[x] + d[y]))
| p03634 |
from collections import deque
def bfs(start):
queue = deque([start])
visited = []
while queue:
label = queue.pop()
if label not in visited:
visited.append(label)
for v in d[label]:
if dist[v[0]] == float("inf"):
dist[v[0]] = dist[label] + v[1]
queue.appendleft(v[0])
return
n = int(eval(input()))
d = [[] for _ in range(n)]
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
d[a - 1].append([b - 1, c])
d[b - 1].append([a - 1, c])
q, k = list(map(int, input().split()))
dist = [float("inf") for _ in range(n)] # nは頂点数
dist[k - 1] = 0
bfs(k - 1)
for _ in range(q):
x, y = list(map(int, input().split()))
print((dist[x - 1] + dist[y - 1]))
| from collections import deque
def bfs(start):
queue = deque([start])
visited = []
while queue:
label = queue.pop()
#if label not in visited:
visited.append(label)
for v in d[label]:
if dist[v[0]] == float("inf"):
dist[v[0]] = dist[label] + v[1]
queue.appendleft(v[0])
return
n = int(eval(input()))
d = [[] for _ in range(n)]
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
d[a - 1].append([b - 1, c])
d[b - 1].append([a - 1, c])
q, k = list(map(int, input().split()))
dist = [float("inf") for _ in range(n)] # nは頂点数
dist[k - 1] = 0
bfs(k - 1)
for _ in range(q):
x, y = list(map(int, input().split()))
print((dist[x - 1] + dist[y - 1]))
| p03634 |
from collections import deque
def nearlist(N, LIST): # 隣接リスト
NEAR = [set() for _ in range(N)]
COST = {}
for a, b, c in LIST:
NEAR[a - 1].add(b - 1)
NEAR[b - 1].add(a - 1)
COST[(a - 1, b - 1)] = c
COST[(b - 1, a - 1)] = c
return NEAR, COST
def bfs(NEAR, S, N): # 幅優先探索 # キュー
DIST = [-1 for _ in range(N)] # 前処理
DIST[S] = 0
que, frag = deque([S]), set([S])
while len(que) > 0:
q = que.popleft()
for i in NEAR[q]: # 移動先の候補
if i in frag: # 処理済みか否か
continue
DIST[i] = DIST[q] + cost[(q, i)]
que.append(i), frag.add(i)
return DIST
n = int(eval(input()))
abc = [list(map(int, input().split())) for _ in range(n - 1)]
q, k = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(q)]
near, cost = nearlist(n, abc)
dist = bfs(near, k - 1, n)
for x, y in xy:
print((dist[x - 1] + dist[y - 1]))
| from collections import deque
def nearlist(N, LIST): # 隣接リスト
NEAR = [{} for _ in range(N)]
for a, b, c in LIST:
NEAR[a - 1][b - 1] = c
NEAR[b - 1][a - 1] = c
return NEAR
def bfs(NEAR, S, N): # 幅優先探索 # キュー
DIST = [-1 for _ in range(N)] # 前処理
DIST[S] = 0
que, frag = deque([S]), set([S])
while len(que) > 0:
q = que.popleft()
for i, c in list(NEAR[q].items()): # 移動先の候補
if i in frag: # 処理済みか否か
continue
DIST[i] = DIST[q] + c
que.append(i), frag.add(i)
return DIST
n = int(eval(input()))
abc = [list(map(int, input().split())) for _ in range(n - 1)]
q, k = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(q)]
near = nearlist(n, abc)
dist = bfs(near, k - 1, n)
for x, y in xy:
print((dist[x - 1] + dist[y - 1]))
| p03634 |
from collections import deque
def nearlist(N, LIST): # 隣接リスト
NEAR = [{} for _ in range(N)]
for a, b, c in LIST:
NEAR[a - 1][b - 1] = c
NEAR[b - 1][a - 1] = c
return NEAR
def dfs(NEAR, S, N): # 深優先探索 # スタック
DIST = [-1 for _ in range(N)] # 前処理
DIST[S] = 0
stack, frag = [S], set([S])
while len(stack) > 0:
q = stack.pop()
for i, c in list(NEAR[q].items()): # 移動先の候補
if i in frag: # 処理済みか否か
continue
DIST[i] = DIST[q] + c
stack.append(i), frag.add(i)
return DIST
n = int(eval(input()))
abc = [list(map(int, input().split())) for _ in range(n - 1)]
q, k = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(q)]
near = nearlist(n, abc)
dist = dfs(near, k - 1, n)
for x, y in xy:
print((dist[x - 1] + dist[y - 1]))
| def nearlist(N, LIST): # 隣接リスト
NEAR = [{} for _ in range(N)]
for a, b, c in LIST:
NEAR[a - 1][b - 1] = c
NEAR[b - 1][a - 1] = c
return NEAR
def dfs(NEAR, S, N): # 深優先探索 # スタック
DIST = [-1 for _ in range(N)] # 前処理
DIST[S] = 0
stack, frag = [S], set([S])
while len(stack) > 0:
q = stack.pop()
for i, c in list(NEAR[q].items()): # 移動先の候補
if i in frag: # 処理済みか否か
continue
DIST[i] = DIST[q] + c
stack.append(i), frag.add(i)
return DIST
n = int(eval(input()))
abc = [list(map(int, input().split())) for _ in range(n - 1)]
q, k = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(q)]
near = nearlist(n, abc)
dist = dfs(near, k - 1, n)
for x, y in xy:
print((dist[x - 1] + dist[y - 1]))
| p03634 |
from collections import deque
N = int(eval(input()))
G = [[-1 for j in range(N)] for i in range(N)]
for _ in range(N-1):
a, b, c = list(map(int, input().split()))
G[a-1][b-1] = c
G[b-1][a-1] = c
Q, K = list(map(int, input().split()))
visited = [False] * N
visited[K-1] = True
distance = [-1]*N
que = deque([(K-1, 0)])
while que:
cur, d = que.popleft()
distance[cur] = d
for nx, nd in enumerate(G[cur]):
if nd != -1 and visited[nx] is False:
visited[nx] = True
que.append((nx, d+nd))
for i in range(Q):
x, y = list(map(int, input().split()))
print((distance[x-1]+distance[y-1]))
| from collections import deque
N = int(eval(input()))
G = set()
for _ in range(N-1):
a, b, c = list(map(int, input().split()))
G.add((a, b, c))
Q, K = list(map(int, input().split()))
visited = [False] * N
visited[K-1] = True
distance = [-1]*N
que = deque([(K, 0)])
while que:
cur, d = que.popleft()
distance[cur-1] = d
for a, b, c in G:
if a == cur and visited[b-1] is False:
visited[b-1] = True
que.append((b, d+c))
elif b == cur and visited[a-1] is False:
visited[a-1] = True
que.append((a, d+c))
for i in range(Q):
x, y = list(map(int, input().split()))
print((distance[x-1]+distance[y-1]))
| p03634 |
from collections import deque
N = int(eval(input()))
G = [set() for i in range(N)]
for _ in range(N-1):
a, b, c = list(map(int, input().split()))
G[a-1].add((b, c))
G[b-1].add((a, c))
Q, K = list(map(int, input().split()))
visited = [False] * N
visited[K-1] = True
distance = [-1]*N
que = deque([(K, 0)])
while que:
cur, d = que.popleft()
distance[cur-1] = d
for nx, nd in G[cur-1]:
if visited[nx-1] is False:
visited[nx-1] = True
que.append((nx, d+nd))
for i in range(Q):
x, y = list(map(int, input().split()))
print((distance[x-1]+distance[y-1]))
| import sys
sys.setrecursionlimit(1000000)
N = int(eval(input()))
G = [set() for i in range(N)]
for _ in range(N-1):
a, b, c = list(map(int, input().split()))
G[a-1].add((b, c))
G[b-1].add((a, c))
Q, K = list(map(int, input().split()))
visited = [False] * N
visited[K-1] = True
distance = [-1]*N
def dfs(v, p, d): # 現在の頂点v, vの親p, 現在の距離d
distance[v-1] = d
for i, c in G[v-1]:
if visited[i-1] is False:
if i == p:
continue
dfs(i, v, d+c)
return
dfs(K, -1, 0)
for i in range(Q):
x, y = list(map(int, input().split()))
print((distance[x-1]+distance[y-1]))
| p03634 |
# -*- coding: utf-8 -*-
def main():
from collections import defaultdict
from collections import deque
n = int(eval(input()))
graph = [defaultdict(int) for _ in range(n)]
visited = [False for _ in range(n)]
dist = [0 for _ in range(n)]
for i in range(n - 1):
ai, bi, ci = list(map(int, input().split()))
ai -= 1
bi -= 1
graph[ai][bi] = ci
graph[bi][ai] = ci
q, k = list(map(int, input().split()))
k -= 1
dist[k] = 0
d = deque()
d.append(k)
while d:
di = d.popleft()
visited[di] = True
for bi, ci in list(graph[di].items()):
if visited[bi]:
continue
dist[bi] = dist[di] + ci
d.append(bi)
for j in range(q):
xi, yi = list(map(int, input().split()))
xi -= 1
yi -= 1
print((dist[xi] + dist[yi]))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
def main():
from collections import defaultdict
from collections import deque
n = int(eval(input()))
graph = [defaultdict(int) for _ in range(n)]
visited = [False for _ in range(n)]
dist = [float('inf') for _ in range(n)]
for i in range(n - 1):
ai, bi, ci = list(map(int, input().split()))
ai -= 1
bi -= 1
graph[ai][bi] = ci
graph[bi][ai] = ci
q, k = list(map(int, input().split()))
k -= 1
dist[k] = 0
d = deque()
d.append(k)
while d:
di = d.popleft()
visited[di] = True
for bi, ci in list(graph[di].items()):
if visited[bi]:
continue
dist[bi] = dist[di] + ci
d.append(bi)
ans = [0 for _ in range(q)]
for j in range(q):
xi, yi = list(map(int, input().split()))
xi -= 1
yi -= 1
ans[j] = dist[xi] + dist[yi]
print(('\n'.join(map(str, ans))))
if __name__ == '__main__':
main()
| p03634 |
import sys
sys.setrecursionlimit(10**6)
n=int(input())
G=[[]for i in[0]*-~n]
for I in[lambda:map(int,input().split())]*~-n:a,b,c=I();G[a]+=(b,c),;G[b]+=(a,c),
q,k=I()
d=[0]*-~n
def f(v,p,u):
d[v]=u
for t,c in G[v]:p==t or f(t,v,u+c)
f(k,0,0)
for p in[print]*q:
x,y=I()
p(d[x]+d[y])
| import sys;sys.setrecursionlimit(6**8);I=lambda:list(map(int,input().split()));n,=I();G=[[]for i in[0]*-~n]
for i in[0]*~-n:a,b,c=I();G[a]+=(b,c),;G[b]+=(a,c),
q,k=I()
def f(v,p,u):
for t,c in G[v]:p==t or f(t,v,u+c)
G[v]=u
f(k,0,0)
for p in[0]*q:x,y=I();print((G[x]+G[y])) | p03634 |
import queue
import sys
sys.setrecursionlimit(10**7)
n = int(eval(input()))
abc = [[] for i in range(n+1)]
for i in range(n-1):
a,b,c = list(map(int,input().split()))
abc[a].append([b,c])
abc[b].append([a,c])
Q,k = list(map(int,input().split()))
xy = [[int(i) for i in input().split()] for j in range(Q)]
q = queue.Queue()
q.put(k)
path = [-1]*(n+1)
path[k] = 0
def dfs(p):
for i in range(len(abc[p])):
num = abc[p][i][0]
if path[num] != -1:
continue
else:
path[num] = path[p] + abc[p][i][1]
dfs(num)
dfs(k)
for i in range(Q):
print((path[xy[i][0]]+path[xy[i][1]])) | import queue
n = int(eval(input()))
abc = [[] for i in range(n+1)]
for i in range(n-1):
a,b,c = list(map(int,input().split()))
abc[a].append([b,c])
abc[b].append([a,c])
Q,k = list(map(int,input().split()))
xy = [[int(i) for i in input().split()] for j in range(Q)]
q = queue.Queue()
q.put(k)
path = [-1]*(n+1)
path[k] = 0
while not q.empty():
tmp = q.get()
for i in range(len(abc[tmp])):
#print(abc[tmp])
#exit()
num = abc[tmp][i][0]
if path[num] != -1:
continue
else:
path[num] = path[tmp] + abc[tmp][i][1]
q.put(num)
for i in range(Q):
print((path[xy[i][0]]+path[xy[i][1]])) | p03634 |
import sys
import math
import collections
import itertools
import array
import inspect
# Set max recursion limit
sys.setrecursionlimit(1000000)
# Debug output
def chkprint(*args):
names = {
id(v): k
for k, v in list(inspect.currentframe().f_back.f_locals.items())
}
print((', '.join(
names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args)))
# Binary converter
def to_bin(x):
return bin(x)[2:]
def li_input():
return [int(_) for _ in input().split()]
# --------------------------------------------
dp = None
D = None
D_dfs_d = None
def dfs_d(v, pre, dist):
global D_dfs_d
D_dfs_d[v] = dist
for i, d in enumerate(D[v]):
if d != -1 and i != pre:
dfs_d(i, v, dist + d)
return
def main():
global D
global D_dfs_d
N = int(eval(input()))
D = [[-1] * (N + 1) for _ in range(N + 1)]
D_dfs_d = [-1] * (N + 1)
for i in range(N - 1):
a, b, c = li_input()
D[a][b] = c
D[b][a] = c
Q, K = li_input()
# Kから各頂点までの長さをWFSで求める
dfs_d(K, -1, 0)
for i in range(Q):
x, y = li_input()
print((D_dfs_d[x] + D_dfs_d[y]))
main()
| import sys
import math
import collections
import itertools
import array
import inspect
# Set max recursion limit
sys.setrecursionlimit(1000000)
# Debug output
def chkprint(*args):
names = {
id(v): k
for k, v in list(inspect.currentframe().f_back.f_locals.items())
}
print((', '.join(
names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args)))
# Binary converter
def to_bin(x):
return bin(x)[2:]
def li_input():
return [int(_) for _ in input().split()]
# --------------------------------------------
dp = None
D = None
D_dfs_d = None
def dfs_d(v, pre, dist):
global D_dfs_d
D_dfs_d[v] = dist
for next_v, d in D[v]:
if next_v != pre:
dfs_d(next_v, v, dist + d)
return
def main():
global D
global D_dfs_d
N = int(eval(input()))
D_dfs_d = [-1] * (N + 1)
D = [[] for _ in range(N + 1)]
for i in range(N - 1):
a, b, c = li_input()
D[a].append((b, c))
D[b].append((a, c))
Q, K = li_input()
# Kから各頂点までの長さをWFSで求める
dfs_d(K, -1, 0)
for i in range(Q):
x, y = li_input()
print((D_dfs_d[x] + D_dfs_d[y]))
main()
| p03634 |
n=int(eval(input()))
es=[[] for _ in range(n)]
for _ in range(n-1):
a,b,c=list(map(int,input().split()))
es[a-1].append((b-1,c))
es[b-1].append((a-1,c))
from heapq import heappush, heappop
def dijkstra(edges, size, source):
distance = [float('inf')] * size
distance[source] = 0
visited = [False] * size
pq = []
heappush(pq, (0, source))
while pq:
dist_v, v = heappop(pq)
visited[v] = True
for u, weight in edges[v]:
if not visited[u]:
new_dist = dist_v + weight
if distance[u] > new_dist:
distance[u] = new_dist
heappush(pq, (new_dist, u))
return distance
q,k=list(map(int,input().split()))
k-=1
dist=dijkstra(es,n,k)
for _ in range(q):
x,y=list(map(int,input().split()))
x-=1
y-=1
print((dist[x]+dist[y])) | n=int(eval(input()))
es=[[] for _ in range(n)]
for _ in range(n-1):
a,b,c=list(map(int,input().split()))
es[a-1].append((b-1,c))
es[b-1].append((a-1,c))
q,k=list(map(int,input().split()))
k-=1
dist=[float('inf')]*n
dist[k]=0
stack=[k]
while stack:
now=stack.pop()
for e,w in es[now]:
if dist[e]==float('inf'):
dist[e]=dist[now]+w
stack.append(e)
for _ in range(q):
x,y=list(map(int,input().split()))
x-=1
y-=1
print((dist[x]+dist[y])) | p03634 |
import sys
input = sys.stdin.readline
from collections import deque
N = int(eval(input()))
graph = [[] for _ in range(N + 1)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
graph[a].append([b, a, c])
graph[b].append([a, b, c])
distance = [-1] * (N + 1)
Q, K = list(map(int, input().split()))
distance = [-1] * (N + 1)
distance[K] = 0
que = deque()
q_append = que.append
for i in graph[K]:
q_append(i)
q_left = que.popleft
while len(que) != 0:
for _ in range(len(que)):
abc = q_left()
if distance[abc[0]] == -1: #動き先の値がまだ決まっていないとき
distance[abc[0]] = distance[abc[1]] + abc[2]
for j in graph[abc[0]]:
q_append(j)
# print (distance)
for _ in range(Q):
x, y = list(map(int, input().split()))
print((distance[x] + distance[y])) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
MOD = 10 ** 9 + 7
N = int(eval(input()))
G = [[] for _ in range(N + 1)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
G[a].append((b, c))
G[b].append((a, c))
Q, K = list(map(int, input().split()))
d = [-1] * (N + 1)
d[K] = 0
stack = [K]
while stack:
now = stack.pop()
for tmp in G[now]:
next_ = tmp[0]
if d[next_] == -1:
d[next_] = d[now] + tmp[1]
stack.append(next_)
for _ in range(Q):
x, y = list(map(int, input().split()))
print((d[x] + d[y])) | p03634 |
import sys
from collections import deque
inf=100000000000000000000
fastinput=sys.stdin.readline
N=int(fastinput())
path=[[0]*N for hoge in range(N)]
for fuga in range(N-1):
a,b,c=[int(hoge) for hoge in fastinput().split()]
path[a-1][b-1]=c
path[b-1][a-1]=c
Q,K=[int(hoge) for hoge in fastinput().split()]
stack=deque()
stack.append(K-1)
Kcost=[0]*N#あとあと初期化
went=[False]*N
went[K-1]=True
while stack:
cur=stack.pop()
curcost=Kcost[cur]
for next,c in enumerate(path[cur]):
if c and not went[next]:
went[next]=True
Kcost[next]=curcost+c
stack.append(next)
for q in range(Q):
x,y=[int(hoge) for hoge in fastinput().split()]
print((Kcost[x-1]+Kcost[y-1]))
| import sys
from collections import deque
inf=100000000000000000000
fastinput=sys.stdin.readline
N=int(fastinput())
path=[[] for hoge in range(N)]
for fuga in range(N-1):
a,b,c=[int(hoge) for hoge in fastinput().split()]
path[a-1].append([b-1,c])
path[b-1].append([a-1,c])
Q,K=[int(hoge) for hoge in fastinput().split()]
stack=deque()
stack.append(K-1)
Kcost=[0]*N#あとあと初期化
went=[False]*N
went[K-1]=True
while stack:
cur=stack.pop()
curcost=Kcost[cur]
for next,c in path[cur]:
if c and not went[next]:
went[next]=True
Kcost[next]=curcost+c
stack.append(next)
for q in range(Q):
x,y=[int(hoge) for hoge in fastinput().split()]
print((Kcost[x-1]+Kcost[y-1]))
| p03634 |
import copy
n = int(eval(input()))
d = []
for i in range(n - 1):#h:高さ
d.append([int(m) for m in input().split()])
q, k = list(map(int, input().split()))
z = []
for i in range(q):#h:高さ
z.append([int(m) for m in input().split()])
e = []
for i in range(n):
e.append([])
for i in d:
e[i[0] - 1].append(i)
e[i[1] - 1].append(i)
f = {}
for i in range(1, n + 1):
if i != k:
f[i] = 0
ar = []
pre = {}
for i in e[k - 1]:
if k == i[0]:
ar.append(i[1])
f[i[1]] = i[2]
pre[i[1]] = k
else:
ar.append(i[0])
f[i[0]] = i[2]
pre[i[0]] = k
while min(f.values()) == 0:
ar2 = copy.deepcopy(ar)
ar = []
for j in ar2:
for m in e[j - 1]:
if j == m[0]:
if m[1] != pre[j]:
ar.append(m[1])
f[m[1]] = m[2] + f[j]
pre[m[1]] = j
else:
if m[0] != pre[j]:
ar.append(m[0])
f[m[0]] = m[2] + f[j]
pre[m[0]] = j
for i in range(q):#h:高さ
print((f[z[i][0]] + f[z[i][1]]))
"""
adj = []
for i in range(n):
adj.append([])
for i in range(n):
for j in range(n):
adj[i].append(0)
#鱗屑行列
for i in range(q):
adj[d[i][0] - 1][d[i][1] - 1] = d[i][2]
adj[d[i][1] - 1][d[i][0] - 1] = d[i][2]""" | n = int(eval(input()))
d = []
for i in range(n - 1):#h:高さ
d.append([int(m) for m in input().split()])
q, k = list(map(int, input().split()))
z = []
for i in range(q):#h:高さ
z.append([int(m) for m in input().split()])
for i in range(n - 1):
d[i][0] -= 1
d[i][1] -= 1
for i in range(q):
z[i][0] -= 1
z[i][1] -= 1
def BFS(k, edges, N):
roots=[ [] for i in range(N)]
for a,b,c in edges:
roots[a]+=[(b,c)]
roots[b]+=[(a,c)]
dist=[-1]*N
stack=[]
stack.append(k)
dist[k]=0
while stack:
label=stack.pop(-1)
for i,c in roots[label]:
if dist[i]==-1:
dist[i]=dist[label]+c
stack+=[i]
return dist
root = BFS(k - 1, d, n)
for i in range(q):
print((root[z[i][0]] + root[z[i][1]])) | p03634 |
import collections
def bfs(tree, s, distance):
queue = [s]
distance[s] = 0
while queue:
v = queue.pop(0)
v_c = distance[v]
for node, cost in tree[v]:
if distance[node] == -1:
distance[node] = v_c + cost
queue.append(node)
N = int(eval(input()))
Tree = collections.defaultdict(list)
for i in range(N - 1):
a, b, c = list(map(int, input().split()))
Tree[a].append((b, c))
Tree[b].append((a, c))
q, k = list(map(int, input().split()))
distance = collections.defaultdict(lambda : -1)
bfs(Tree, k, distance)
for i in range(q):
x, y = list(map(int, input().split()))
print((distance[x] + distance[y]))
| import collections
def bfs(tree, s, distance):
queue = collections.deque([s])
distance[s] = 0
while queue:
v = queue.popleft()
v_c = distance[v]
for node, cost in tree[v]:
if distance[node] == -1:
distance[node] = v_c + cost
queue.append(node)
N = int(eval(input()))
Tree = collections.defaultdict(list)
for i in range(N - 1):
a, b, c = list(map(int, input().split()))
Tree[a].append((b, c))
Tree[b].append((a, c))
q, k = list(map(int, input().split()))
distance = collections.defaultdict(lambda : -1)
bfs(Tree, k, distance)
for i in range(q):
x, y = list(map(int, input().split()))
print((distance[x] + distance[y]))
| p03634 |
import sys
sys.setrecursionlimit(1000000)
N = int(eval(input()))
X = [[] for _ in range(N)]
for i in range(N-1):
a,b,c = list(map(int,input().split()))
X[a-1].append((b-1,c))
X[b-1].append((a-1,c))
cost = [-1]*N
def calc(i,c):
# 指定の頂点までのコストを代入
cost[i] = c
# 頂点から移動できる頂点があれば
for ni,nc in X[i]:
# 初期状態のままなら計算
if cost[ni] == -1:
calc(ni,c+nc)
Q,K = list(map(int,input().split()))
# 事前計算
calc(K-1,0)
for i in range(Q):
x,y = list(map(int,input().split()))
print((cost[x-1]+cost[y-1]))
| import sys
sys.setrecursionlimit(1000000)
def dfs(n,p,d):
visited[n] = True
dist[n] = d
for (i,c) in A[n]:
if i != p and not visited[i]:
dfs(i,n,d+c)
N = int(eval(input()))
A = [[] for _ in range(N)]
for _ in range(N-1):
a,b,c = list(map(int,input().split()))
A[a-1].append((b-1,c))
A[b-1].append((a-1,c))
Q,K = list(map(int,input().split()))
B = []
for _ in range(Q):
x,y = list(map(int,input().split()))
B.append((x,y))
dist = [-1]*N
visited = [False]*N
dfs(K-1,N,0)
for (x,y) in B:
print((dist[x-1]+dist[y-1]))
| p03634 |
from heapq import heappush, heappop
INF = 10**15
def dijkstra(s, edges):
n = len(edges)
que = []
d = [INF] * n
prev = [-1] * n
d[s] = 0
heappush(que, (0, s))
while len(que) > 0:
(c, v) = heappop(que)
if d[v] < c:
continue
for (cc, w) in edges[v]:
if d[w] > d[v] + cc:
d[w] = d[v] + cc
prev[w] = v
heappush(que, (d[w], w))
return d, prev
n = int(eval(input()))
edge = [[] for i in range(n)]
for i in range(n-1):
ai, bi, ci = list(map(int, input().split()))
ai, bi = ai-1, bi-1
edge[ai].append((ci, bi))
edge[bi].append((ci, ai))
q, k = list(map(int, input().split()))
x, y = [], []
for i in range(q):
xi, yi = list(map(int, input().split()))
xi, yi = xi-1, yi-1
x.append(xi)
y.append(yi)
dist, prev = dijkstra(k-1, edge)
for i in range(q):
print((dist[x[i]]+dist[y[i]])) | from heapq import heappush, heappop
INF = 10**15
def dijkstra(s, edges):
n = len(edges)
que = []
d = [INF] * n
prev = [-1] * n
d[s] = 0
heappush(que, (0, s))
while len(que) > 0:
(c, v) = heappop(que)
if d[v] < c:
continue
for (cc, w) in edges[v]:
if d[w] > d[v] + cc:
d[w] = d[v] + cc
prev[w] = v
heappush(que, (d[w], w))
return d, prev
n = int(eval(input()))
edges = [[] for i in range(n)]
for i in range(n-1):
ai, bi, ci = list(map(int, input().split()))
ai, bi = ai-1, bi-1
edges[ai].append((ci, bi))
edges[bi].append((ci, ai))
q, k = list(map(int, input().split()))
k -= 1
d, prev = dijkstra(k, edges)
ans = []
for i in range(q):
xi, yi = list(map(int, input().split()))
xi, yi = xi-1, yi-1
ans.append(d[xi]+d[yi])
for i in ans:
print(i) | p03634 |
n = int(eval(input()))
l = [list(map(int,input().split())) for _ in range(n-1)]
dp = [[0 for _ in range(n)] for _ in range(n)]
INF = 10**18
for i in range(n):
for j in range(n):
if i!=j:
dp[i][j] = INF
for a,b,c in l:
dp[a-1][b-1] = c
dp[b-1][a-1] = c
#print(dp)
#最短リスト
for c in range(n):
for f in range(n):
for la in range(n):
dp[f][la] = min(dp[f][la] , dp[f][c] + dp[c][la])
q,k = list(map(int,input().split()))
for _ in range(q):
x,y = list(map(int,input().split()))
k1 = dp[x-1][k-1] + dp[k-1][y-1]
k2 = dp[y-1][k-1] + dp[k-1][x-1]
print((min(k1,k2)))
| import sys
sys.setrecursionlimit(200000)
n = int(eval(input()))
l = [list(map(int,input().split())) for _ in range(n-1)]
q,k = list(map(int,input().split()))
k -= 1
#kからの距離
tree = [[] for _ in range(n)]
for a,b,c in l:
a -= 1
b -= 1
tree[a].append([b,c])
tree[b].append([a,c])
bit = [0 for _ in range(n)]
depth = [0 for _ in range(n)]
def dfs(v,d=0):
bit[v] = 1
depth[v] = d
for j,k in tree[v]:
if bit[j]==0:
dfs(j,d+k)
dfs(k)
for _ in range(q):
x,y = list(map(int,input().split()))
x-= 1
y-= 1
print((depth[x] + depth[y]))
| p03634 |
N = int(eval(input()))
edge = set(tuple(map(int, input().split())) for i in range(N-1))
Q, K = list(map(int, input().split()))
query = [tuple(map(int, input().split())) for i in range(Q)]
# dist[-i]:頂点Kから頂点iまでの距離
dist = [None for i in range(N)]
dist[-K] = 0
while edge:
rm = set()
for a, b, c in edge:
if dist[-a] is not None:
dist[-b] = dist[-a] + c
rm.add((a, b, c))
elif dist[-b] is not None:
dist[-a] = dist[-b] + c
rm.add((a, b, c))
edge -= rm
for x, y in query:
print((dist[-x] + dist[-y]))
| import sys
sys.setrecursionlimit(1000000)
N = int(eval(input()))
adj = [[] for i in range(N)]
for i in range(N - 1):
a, b, c = list(map(int, input().split()))
adj[-a].append((b, c))
adj[-b].append((a, c))
Q, K = list(map(int, input().split()))
query = [tuple(map(int, input().split())) for i in range(Q)]
# dist[-i]:頂点Kから頂点iまでの距離
dist = [0 for i in range(N)]
def dfs(v, prv, ds):
dist[-v] = ds
for nxt, c in adj[-v]:
if nxt != prv:
dfs(nxt, v, ds + c)
dfs(K, None, 0)
for x, y in query:
print((dist[-x] + dist[-y]))
| p03634 |
# -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
class Scanner():
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [eval(input()) for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [int(eval(input())) for i in range(n)]
class Math():
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def roundUp(a, b):
return -(-a // b)
@staticmethod
def toUpperMultiple(a, x):
return Math.roundUp(a, x) * x
@staticmethod
def toLowerMultiple(a, x):
return (a // x) * x
@staticmethod
def nearPow2(n):
if n <= 0:
return 0
if n & (n - 1) == 0:
return n
ret = 1
while(n > 0):
ret <<= 1
n >>= 1
return ret
@staticmethod
def sign(n):
if n == 0:
return 0
if n < 0:
return -1
return 1
@staticmethod
def isPrime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n ** 0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
class PriorityQueue:
def __init__(self, l=[]):
self.__q = l
heapq.heapify(self.__q)
return
def push(self, n):
heapq.heappush(self.__q, n)
return
def pop(self):
return heapq.heappop(self.__q)
sys.setrecursionlimit(1000000)
MOD = int(1e09) + 7
INF = int(1e15)
def bfs(s, g, N, G):
if s == g:
return 0
q = []
q.append(s)
memo = [0 for _ in range(N)]
while q != []:
i = q.pop()
if i == g:
return memo[i]
for n in G[i]:
if memo[n[0]] != 0:
continue
memo[n[0]] = memo[i] + n[1]
q.append(n[0])
return 0
def main():
# sys.stdin = open("Sample.txt")
N = Scanner.int()
G = [[] for _ in range(N)]
for i in range(N - 1):
a, b, c = Scanner.map_int()
a -= 1
b -= 1
G[a].append((b, c))
G[b].append((a, c))
Q, K = Scanner.map_int()
K -= 1
length = [0] * N
for i in range(N):
length[i] = bfs(i, K, N, G)
query = Scanner.int_list_list(Q)
for q in query:
print((length[q[0] - 1] + length[q[1] - 1]))
return
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
class Scanner():
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [eval(input()) for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [int(eval(input())) for i in range(n)]
class Math():
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def roundUp(a, b):
return -(-a // b)
@staticmethod
def toUpperMultiple(a, x):
return Math.roundUp(a, x) * x
@staticmethod
def toLowerMultiple(a, x):
return (a // x) * x
@staticmethod
def nearPow2(n):
if n <= 0:
return 0
if n & (n - 1) == 0:
return n
ret = 1
while(n > 0):
ret <<= 1
n >>= 1
return ret
@staticmethod
def sign(n):
if n == 0:
return 0
if n < 0:
return -1
return 1
@staticmethod
def isPrime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n ** 0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
class PriorityQueue:
def __init__(self, l=[]):
self.__q = l
heapq.heapify(self.__q)
return
def push(self, n):
heapq.heappush(self.__q, n)
return
def pop(self):
return heapq.heappop(self.__q)
sys.setrecursionlimit(1000000)
MOD = int(1e09) + 7
INF = int(1e15)
def bfs(s, g, N, G):
return 0
def main():
# sys.stdin = open("Sample.txt")
N = Scanner.int()
G = [[] for _ in range(N)]
for i in range(N - 1):
a, b, c = Scanner.map_int()
a -= 1
b -= 1
G[a].append((b, c))
G[b].append((a, c))
Q, K = Scanner.map_int()
K -= 1
length = [0] * N
q = []
q.append(K)
while q != []:
i = q.pop()
for n in G[i]:
if length[n[0]] != 0:
continue
length[n[0]] = length[i] + n[1]
q.append(n[0])
query = Scanner.int_list_list(Q)
for q in query:
print((length[q[0] - 1] + length[q[1] - 1]))
return
if __name__ == "__main__":
main()
| p03634 |
import collections
N = int(eval(input()))
List = [[] for _ in range(N)]
ans = [-1]*N
for i in range(N-1):
a, b, c = list(map(int, input().split()))
List[a-1].append((b-1, c))
List[b-1].append((a-1, c))
Q, K = list(map(int, input().split()))
queue = collections.deque([K-1])
ans[K-1] = 0
while queue:
edge = queue.pop()
for node in List[edge]:
index, cost = node
if ans[index]>0:
continue
ans[index] = ans[edge]+cost
queue.append(index)
for i in range(Q):
x, y = list(map(int, input().split()))
print((ans[x-1]+ans[y-1])) | import sys
input = sys.stdin.readline
N = int(eval(input()))
List = [[] for _ in range(N)]
ans = [-1]*N
for i in range(N-1):
a, b, c = list(map(int, input().split()))
List[a-1].append((b-1, c))
List[b-1].append((a-1, c))
Q, K = list(map(int, input().split()))
queue = [K-1]
ans[K-1] = 0
while queue:
edge = queue.pop()
for node in List[edge]:
index, cost = node
if ans[index]>0:
continue
ans[index] = ans[edge]+cost
queue.append(index)
for i in range(Q):
x, y = list(map(int, input().split()))
print((ans[x-1]+ans[y-1])) | p03634 |
import sys
sys.setrecursionlimit(10**6)
def dfs(v, d=0):
seen[v] = True
dist[v] = d
for i in graph[v]:
next_v = i[0]
l = i[1]
if seen[next_v] == True:
continue
dfs(next_v, d+l)
return
N = int(eval(input()))
graph = [[] for i in range(N + 1)]
for i in range(N - 1):
a, b, c = list(map(int, input().split()))
graph[a].append([b, c])
graph[b].append([a, c])
Q, K = list(map(int, input().split()))
for i in range(Q):
ans = 0
x, y = list(map(int, input().split()))
seen = [False for i in range(N + 1)]
dist = [0 for i in range(N + 1)]
dfs(x)
ans += dist[K]
seen = [False for i in range(N + 1)]
dist = [0 for i in range(N + 1)]
dfs(K)
ans += dist[y]
print(ans) | import sys
sys.setrecursionlimit(10**6)
def dfs(v, d=0):
seen[v] = True
dist[v] = d
for i in graph[v]:
next_v = i[0]
l = i[1]
if seen[next_v] == True:
continue
dfs(next_v, d+l)
return
N = int(eval(input()))
graph = [[] for i in range(N + 1)]
for i in range(N - 1):
a, b, c = list(map(int, input().split()))
graph[a].append([b, c])
graph[b].append([a, c])
Q, K = list(map(int, input().split()))
seen = [False for i in range(N + 1)]
dist = [0 for i in range(N + 1)]
dfs(K)
for i in range(Q):
x, y = list(map(int, input().split()))
print((dist[x] + dist[y]))
| p03634 |
from collections import deque
N = int(eval(input()))
edge = [[] for _ in range(N+1)]
for _ in range(N-1):
a, b, c = list(map(int, input().split()))
edge[a].append([b, c])
edge[b].append([a, c])
def BFS(x, y):
visited = [False for _ in range(N+1)]
next_N = [False for _ in range(N+1)]
INF = float('inf')
dest = [INF for _ in range(N+1)]
d = deque()
visited[x] = True
dest[x] = 0
for B, C in edge[x]:
d.append([B, C])
next_N[B] = True
dest[B] = dest[x] + C
while d:
now = d.popleft()
visited[now[0]] = True
for B, C in edge[now[0]]:
if visited[B] == False and next_N[B] == False:
d.append([B, C])
next_N[B] = True
dest[B] = dest[now[0]] + C
return dest[y]
Q, K = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(Q)]
for X, Y in xy:
print((BFS(X, K) + BFS(K, Y)))
| from collections import deque
N = int(eval(input()))
edge = [[] for _ in range(N+1)]
for _ in range(N-1):
a, b, c = list(map(int, input().split()))
edge[a].append([b, c])
edge[b].append([a, c])
def BFS(x):
visited = [False for _ in range(N+1)]
next_N = [False for _ in range(N+1)]
INF = float('inf')
dest = [INF for _ in range(N+1)]
d = deque()
visited[x] = True
dest[x] = 0
for B, C in edge[x]:
d.append([B, C])
next_N[B] = True
dest[B] = dest[x] + C
while d:
now = d.popleft()
visited[now[0]] = True
for B, C in edge[now[0]]:
if visited[B] == False and next_N[B] == False:
d.append([B, C])
next_N[B] = True
dest[B] = dest[now[0]] + C
return dest
Q, K = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(Q)]
DEST = BFS(K)
for X, Y in xy:
print((DEST[X] + DEST[Y]))
| p03634 |
import queue
def main():
n = int(eval(input()))
a = []
b = []
c = []
lst = [[] for _ in range(n)]
for i in range(n - 1):
aa, bb, cc = list(map(int,input().split()))
lst[aa - 1].append((bb - 1, cc))
lst[bb - 1].append((aa - 1, cc))
q, k = list(map(int,input().split()))
x = []
y = []
for i in range(q):
xx, yy = list(map(int,input().split()))
x.append(xx - 1)
y.append(yy - 1)
qq = queue.Queue()
qq.put(k - 1)
dist = [0] * n
while not qq.empty():
now = qq.get()
for to, w in lst[now]:
if dist[to] != 0:
continue
dist[to] = dist[now] + w
qq.put(to)
for i in range(q):
print((dist[x[i]] + dist[y[i]]))
if __name__ == '__main__':
main()
| from collections import deque
def main():
n = int(eval(input()))
a = []
b = []
c = []
lst = [[] for _ in range(n)]
for i in range(n - 1):
aa, bb, cc = list(map(int,input().split()))
lst[aa - 1].append((bb - 1, cc))
lst[bb - 1].append((aa - 1, cc))
q, k = list(map(int,input().split()))
x = []
y = []
for i in range(q):
xx, yy = list(map(int,input().split()))
x.append(xx - 1)
y.append(yy - 1)
qq = deque()
qq.append(k - 1)
dist = [0] * n
while len(qq) != 0:
now = qq.popleft()
for to, w in lst[now]:
if dist[to] != 0:
continue
dist[to] = dist[now] + w
qq.append(to)
for i in range(q):
print((dist[x[i]] + dist[y[i]]))
if __name__ == '__main__':
main()
| p03634 |
from collections import defaultdict
N = int(eval(input()))
E = defaultdict(list)
W = dict()
for i in range(N-1):
a,b,c = list(map(int,input().split()))
E[a].append(b)
E[b].append(a)
W[(a,b)] = c
W[(b,a)] = c
Q,K = list(map(int,input().split()))
costs = [float('inf')]*(N+1)
costs[K] = 0
stack = [K]
while stack:
s = stack.pop()
for t in E[s]:
if costs[t] > costs[s] + W[(s,t)]:
costs[t] = costs[s] + W[(s,t)]
stack.append(t)
for i in range(Q):
x,y = list(map(int,input().split()))
print((costs[x]+costs[y])) |
N = int(eval(input()))
E = [[] for _ in range(N)]
for i in range(N-1):
a,b,c = list(map(int,input().split()))
a -= 1
b -= 1
E[a].append((b,c))
E[b].append((a,c))
Q,K = list(map(int,input().split()))
K -= 1
costs = [None]*N
costs[K] = 0
stack = [K]
while stack:
s = stack.pop()
c = costs[s]
for t,d in E[s]:
if costs[t] is None:
costs[t] = c + d
stack.append(t)
for i in range(Q):
x,y = list(map(int,input().split()))
print((costs[x-1]+costs[y-1])) | p03634 |
from collections import deque
def main():
n = int(eval(input()))
tree = AdjacentListGraph([Vertex() for _ in range(n)])
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
tree.add_edge(a - 1, b - 1, c)
tree.add_edge(b - 1, a - 1, c)
q, k = list(map(int, input().split()))
distances = distances_from(tree, k - 1)
# print(distances)
answers = []
for _ in range(q):
x, y = list(map(int, input().split()))
answers.append(distances[x - 1] + distances[y - 1])
print(("\n".join(map(str, answers))))
def distances_from(
graph: "Graph", from_: int, break_if=lambda node: False
) -> "List[int]":
distances = [None for _ in range(graph.size)]
distances[from_] = 0
queue = deque([from_])
while queue:
node = queue.popleft()
if break_if(node):
break
curDist = distances[node]
for edge in graph.edges_from(node):
if distances[edge.to] is not None:
continue
delta = edge.weight if edge.weight else 0
distances[edge.to] = curDist + delta
queue.append(edge.to)
return distances
class Vertex:
__slots__ = ("data", "edges")
def __init__(self, data=None):
self.data = data
self.edges = []
def add_edge(self, to, weight=None) -> bool:
for edge in self.edges:
if edge.to == to:
return False
self.edges.append(Edge(to, weight))
return True
def remove_edge(self, to: int) -> bool:
for i, edge in enumerate(self.edges):
if edge.to == to:
del self.edges[i]
return True
return False
class Edge:
__slots__ = ("to", "weight")
def __init__(self, to, weight=None):
self.to = to
self.weight = weight
class AdjacentListGraph:
def __init__(self, vertices):
self.vertices = vertices
self.size = len(vertices)
def get_weight(self, from_: int, to: int):
for edge in self.vertices[from_].edges:
if edge.to == to:
return edge.weight
return None
def edges_from(self, from_: int):
return self.vertices[from_].edges
def add_edge(self, from_: int, to: int, weight=None) -> bool:
return self.vertices[from_].add_edge(to, weight)
def remove_edge(self, from_: int, to: int) -> bool:
return self.vertices[from_].remove_edge(to)
def is_adjacent(self, from_: int, to: int) -> bool:
return to in {edge.to for edge in self.edges_from(from_)}
if __name__ == "__main__":
main()
| from collections import deque
def main():
n = int(eval(input()))
tree = AdjacentListGraph([Vertex() for _ in range(n)])
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
tree.add_edge(a - 1, b - 1, c)
tree.add_edge(b - 1, a - 1, c)
q, k = list(map(int, input().split()))
distances = distances_from(tree, k - 1)
# print(distances)
answers = []
for _ in range(q):
x, y = list(map(int, input().split()))
answers.append(distances[x - 1] + distances[y - 1])
print(("\n".join(map(str, answers))))
def distances_from(
graph: "Graph", from_: int, break_if=lambda node: False
) -> "List[int]":
distances = [None for _ in range(graph.size)]
distances[from_] = 0
queue = deque([from_])
while queue:
node = queue.popleft()
if break_if(node):
break
curDist = distances[node]
for edge in graph.edges_from(node):
if distances[edge.to] is not None:
continue
delta = edge.weight if edge.weight else 0
distances[edge.to] = curDist + delta
queue.append(edge.to)
return distances
class Vertex:
__slots__ = ("data", "edges")
def __init__(self, data=None):
self.data = data
self.edges = []
def add_edge(self, to, weight=None):
self.edges.append(Edge(to, weight))
def remove_edge(self, to: int) -> bool:
for i, edge in enumerate(self.edges):
if edge.to == to:
del self.edges[i]
return True
return False
class Edge:
__slots__ = ("to", "weight")
def __init__(self, to, weight=None):
self.to = to
self.weight = weight
class AdjacentListGraph:
def __init__(self, vertices):
self.vertices = vertices
self.size = len(vertices)
def get_weight(self, from_: int, to: int):
for edge in self.vertices[from_].edges:
if edge.to == to:
return edge.weight
return None
def edges_from(self, from_: int):
return self.vertices[from_].edges
def add_edge(self, from_: int, to: int, weight=None) -> bool:
return self.vertices[from_].add_edge(to, weight)
def remove_edge(self, from_: int, to: int) -> bool:
return self.vertices[from_].remove_edge(to)
def is_adjacent(self, from_: int, to: int) -> bool:
return to in {edge.to for edge in self.edges_from(from_)}
if __name__ == "__main__":
main()
| p03634 |
from collections import defaultdict
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
AtoZ = [chr(i) for i in range(65,65+26)]
atoz = [chr(i) for i in range(97,97+26)]
def inpl(): return list(map(int, input().split()))
def inpl_s(): return list(input().split())
N = int(eval(input()))
lines = defaultdict(set)
for i in range(N-1):
a,b,c = inpl() #a -> b コスト:c の経路
lines[a].add((b,c))
lines[b].add((a,c))
Q,s = inpl()
weight = [-1]*(N+1)
weight[s] = 0
q = [[0,s]]
heapq.heapify(q)
while q:
w0,s = heapq.heappop(q)
for line in list(lines[s]):
t = line[0]
w = w0 + line[1]
if weight[t] == -1 or weight[t] > w: #未探索orより小さい
heapq.heappush(q, [w,t])
weight[t] = w
for i in range(Q):
x,y = inpl()
print((weight[x]+weight[y]))
| from collections import defaultdict
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
AtoZ = [chr(i) for i in range(65,65+26)]
atoz = [chr(i) for i in range(97,97+26)]
def inpl(): return list(map(int, input().split()))
def inpl_s(): return list(input().split())
N = int(eval(input()))
lines = defaultdict(set)
for i in range(N-1):
a,b,c = inpl()
a -= 1
b -= 1
lines[a].add((b,c))
lines[b].add((a,c))
Q,s = inpl()
s -= 1
ss = [-1]*N
ss[s] = 0
def check(a,w):
global ss
for b,c in lines[a]:
if ss[b] == -1:
ss[b] = w + c
check(b,w+c)
check(s,0)
for i in range(Q):
x,y = inpl()
print((ss[x-1]+ss[y-1]))
| p03634 |
from collections import deque
N=int(eval(input()))
cost=[[float("inf")]*N for _ in range(N)]
graph=[[] for _ in range(N)]
for i in range(N-1):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
graph[a].append(b)
graph[b].append(a)
cost[a][b]=c
cost[b][a]=c
def dfs(start):
visited=[False]*N
queue=deque([start])
visited[start]=0
while queue:
x=queue.pop()
for y in graph[x]:
if visited[y]!=False:
continue
visited[y]=visited[x]+cost[x][y]
queue.append(y)
return visited
Q,K=list(map(int,input().split()))
K-=1
d=dfs(K)
for _ in range(Q):
x,y=list(map(int,input().split()))
x-=1
y-=1
print((d[x]+d[y])) | import sys
sys.setrecursionlimit(10**9)
N=int(eval(input()))
graph=[[] for _ in range(N)]
for i in range(N-1):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
graph[a].append([b,c])
graph[b].append([a,c])
def dfs(start):
for x,cost in graph[start]:
if d[x]==-1:
d[x]=d[start]+cost
dfs(x)
Q,K=list(map(int,input().split()))
K-=1
d=[-1]*N
d[K]=0
dfs(K)
for i in range(Q):
x,y=list(map(int,input().split()))
x-=1
y-=1
print((d[x]+d[y])) | p03634 |
from queue import deque
n = int(eval(input()))
edges = [set() for _ in range(n + 1)]
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
edges[a].add((c, b))
edges[b].add((c, a))
q, k = list(map(int, input().split()))
stack = deque([(0, k)])
costs = [0] * (n + 1)
visited = set()
while stack:
c, p = stack.popleft()
costs[p] = c
visited.add(p)
stack.extend((c + c2, p2) for c2, p2 in edges[p] if p2 not in visited)
ans = []
for _ in range(q):
x, y = list(map(int, input().split()))
ans.append(costs[x] + costs[y])
print(('\n'.join(map(str, ans))))
| n = int(eval(input()))
edges = [set() for _ in range(n + 1)]
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
edges[a].add((c, b))
edges[b].add((c, a))
q, k = list(map(int, input().split()))
stack = [(0, k, None)]
costs = [0] * (n + 1)
visited = set()
while stack:
c, p, a = stack.pop()
costs[p] = c
visited.add(p)
stack.extend((c + c2, p2, p) for c2, p2 in edges[p] if p2 != a)
print(('\n'.join(map(str, (costs[x] + costs[y] for x, y
in (list(map(int, input().split())) for _ in range(q)))))))
| p03634 |
n = int(eval(input()))
edges = [set() for _ in range(n + 1)]
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
edges[a].add((c, b))
edges[b].add((c, a))
q, k = list(map(int, input().split()))
stack = [(0, k, None)]
costs = [0] * (n + 1)
while stack:
c, p, a = stack.pop()
costs[p] = c
stack.extend((c + c2, p2, p) for c2, p2 in edges[p] if p2 != a)
print(('\n'.join(map(str, (costs[x] + costs[y] for x, y
in (list(map(int, input().split())) for _ in range(q)))))))
| n = int(eval(input()))
edges = [[] for _ in range(n + 1)]
for a, b, c in (list(map(int, input().split())) for _ in range(n - 1)):
edges[a].append((c, b))
edges[b].append((c, a))
q, k = list(map(int, input().split()))
stack = [(0, k, None)]
costs = [0] * (n + 1)
while stack:
c, p, a = stack.pop()
costs[p] = c
stack.extend((c + c2, p2, p) for c2, p2 in edges[p] if p2 != a)
print(('\n'.join(map(str, (costs[x] + costs[y] for x, y in (list(map(int, input().split())) for _ in range(q)))))))
| p03634 |
import heapq
N = int(eval(input()))
nb = [[] for _ in range(N)]
for i in range(N - 1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
nb[a].append((c, b))
nb[b].append((c, a))
for x in nb:
x.sort()
Q, K = list(map(int, input().split()))
K -= 1
dist = [2 ** 62] * N
visited = set()
h = [(0, K, -1)]
while h:
d0, node, parent = heapq.heappop(h)
if node in visited:
continue
visited.add(node)
dist[node] = d0
for d1, child in nb[node]:
if child != parent and d0 + d1 < dist[child]:
heapq.heappush(h, (d0 + d1, child, node))
for i in range(Q):
x, y = list(map(int, input().split()))
# print(f"{x}->K = {dist[x]}, K->{y} = {dist[y]}")
print((dist[x - 1] + dist[y - 1]))
| import sys
import heapq
input = sys.stdin.readline
def main():
N = int(eval(input()))
nb = [[] for _ in range(N)]
for i in range(N - 1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
nb[a].append((c, b))
nb[b].append((c, a))
for x in nb:
x.sort()
Q, K = list(map(int, input().split()))
K -= 1
dist = [2 ** 62] * N
h = [(0, K, -1)]
while h:
d0, node, parent = heapq.heappop(h)
if d0 >= dist[node]:
continue
dist[node] = d0
for d1, child in nb[node]:
if child != parent and d0 + d1 < dist[child]:
heapq.heappush(h, (d0 + d1, child, node))
for i in range(Q):
x, y = list(map(int, input().split()))
# print(f"{x}->K = {dist[x]}, K->{y} = {dist[y]}")
print((dist[x - 1] + dist[y - 1]))
if __name__ == "__main__":
main()
| p03634 |
from heapq import heappop, heappush
N = int(eval(input()))
links = [[] for _ in range(N + 1)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
links[a].append((b, c))
links[b].append((a, c))
Q, K = list(map(int, input().split()))
d = [float('inf')] * (N + 1)
d[K] = 0
#prev = [None] * (N + 1)
q = [(0, K)]
while q:
_, u = heappop(q)
for v, c in links[u]:
alt = d[u] + c
if d[v] > alt:
d[v] = alt
#prev[v] = u
heappush(q, (alt, v))
result = []
for _ in range(Q):
x, y = list(map(int, input().split()))
result.append(d[x] + d[y])
print(('\n'.join(str(v) for v in result)))
| N = int(eval(input()))
links = [[] for _ in range(N + 1)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
links[a].append((b, c))
links[b].append((a, c))
Q, K = list(map(int, input().split()))
d = [float('inf')] * (N + 1)
d[K] = 0
q = [K]
while q:
i = q.pop()
for j, c in links[i]:
if d[i] + c < d[j]:
d[j] = d[i] + c
q.append(j)
result = []
for _ in range(Q):
x, y = list(map(int, input().split()))
result.append(d[x] + d[y])
print(('\n'.join(str(v) for v in result)))
| p03634 |
from collections import defaultdict
def warshall_floyd(V, E):
INF = 10 ** 10
d = [defaultdict(lambda: INF) for i in range(V)]
for i, j, c in E:
d[i - 1][j - 1] = c
d[j - 1][i - 1] = c
for k in range(V):
for i in range(V - 1):
for j in range(i, V):
dk = d[i][k] + d[k][j]
if d[i][j] > dk:
d[i][j] = dk
d[j][i] = dk
return d
N = int(eval(input()))
E = [list(map(int, input().split())) for _ in range(N - 1)]
d = warshall_floyd(N, E)
Q, K = list(map(int, input().split()))
for i in range(Q):
x, y = list(map(int, input().split()))
print((d[x - 1][K - 1] + d[K - 1][y - 1]))
| def dfs(i, V, E):
S = [i]
while(len(S) > 0):
vi = S.pop()
d = V[vi]
for j, value in list(E[vi].items()):
if V[j] > value + d:
V[j] = value + d
S.append(j)
return V
INF = 10 ** 14
n = int(eval(input()))
V = [INF for _ in range(n + 1)]
E = [{} for _ in range(n + 1)]
for i in range(n - 1):
ai, bi, ci = list(map(int, input().split()))
E[ai][bi] = ci
E[bi][ai] = ci
q, k = list(map(int, input().split()))
z = [list(map(int, input().split())) for _ in range(q)]
V[k] = 0
V = dfs(k, V, E)
for i in range(q):
x, y = z[i]
print((V[x] + V[y]))
| p03634 |
from collections import *
d=defaultdict(list)
n=int(eval(input()))
for s in range(n-1):
a,b,c=list(map(int,input().split()))
d[a].append([b,c])
d[b].append([a,c])
#defaultdict(<class 'list'>, {1: [[2, 1], [3, 1]], 2: [[1, 1], [3, 3]], 3: [[1, 1], [2, 3]]})
def DIJKSTRA(point,d):
cost = {node:float("inf") for node in list(d.keys())}
preference= {node:None for node in list(d.keys())}#最適路のこと
Q = set(d.keys()) #頂点のリスト
cost[point]=0 #開始地点のコストをゼロとする（当たり前
while True:
prefnd=min(Q, key=lambda c:cost[c]) #最適な点探し
Q.remove(prefnd) #最適だった点を削除
if len(Q)==0:
break #全部の点消したら終了
for p,c in d[prefnd]: #次の点とそこまでのコスト
temp=cost[prefnd]+c #スタートからそこまでのコストを計算
if temp<cost[p]: #計算してみたコストがそこに行くまでの最小値ならば
cost[p]=temp #最小値更新
preference[p]=prefnd
return preference,cost #点のつながりとコスト例 1から１に０ １から２に１ １から３に２
q,k=list(map(int,input().split()))
x,y=DIJKSTRA(k,d)
for i in range(q):
a,b=list(map(int,input().split()))
print((y[a]+y[b]))
| from collections import *
from heapq import*
import sys
input=lambda:sys.stdin.readline()
d=defaultdict(list)
n=int(eval(input()))
for s in range(n-1):
a,b,c=list(map(int,input().split()))
d[a].append([b,c])
d[b].append([a,c])
#defaultdict(<class 'list'>, {1: [[2, 1], [3, 1]], 2: [[1, 1], [3, 3]], 3: [[1, 1], [2, 3]]})
def DIJKSTRA(point,d):
cost = {node:float("inf") for node in list(d.keys())}
Q = [] #頂点のリスト
cost[point]=0 #開始地点のコストをゼロとする（当たり前
heappush(Q,(point,cost[point]))
while Q:
prefnd,tmpC=heappop(Q)
if cost[prefnd]<tmpC:
continue
for node,c in d[prefnd]:
altC=c+tmpC
if cost[node]>altC:
cost[node]=altC
heappush(Q,(node,altC))
return cost
q,k=list(map(int,input().split()))
y=DIJKSTRA(k,d)
for i in range(q):
a,b=list(map(int,input().split()))
print((y[a]+y[b])) | p03634 |
from collections import *
from heapq import*
import sys
input=sys.stdin.readline
d=defaultdict(list)
n=int(eval(input()))
for s in range(n-1):
a,b,c=list(map(int,input().split()))
d[a].append([b,c])
d[b].append([a,c])
#defaultdict(<class 'list'>, {1: [[2, 1], [3, 1]], 2: [[1, 1], [3, 3]], 3: [[1, 1], [2, 3]]})
def DIJKSTRA(point,d):
cost = {node:float("inf") for node in list(d.keys())}
Q = [] #頂点のリスト
cost[point]=0 #開始地点のコストをゼロとする（当たり前
heappush(Q,(point,cost[point]))
while Q:
prefnd,tmpC=heappop(Q)
if cost[prefnd]<tmpC:
continue
for node,c in d[prefnd]:
altC=c+tmpC
if cost[node]>altC:
cost[node]=altC
heappush(Q,(node,altC))
return cost
q,k=list(map(int,input().split()))
y=DIJKSTRA(k,d)
for i in range(q):
a,b=list(map(int,input().split()))
print((y[a]+y[b])) | from collections import *
from heapq import*
import sys
input=sys.stdin.readline
d=defaultdict(list)
n=int(eval(input()))
for s in range(n-1):
a,b,c=list(map(int,input().split()))
d[a].append([b,c])
d[b].append([a,c])
#defaultdict(<class 'list'>, {1: [[2, 1], [3, 1]], 2: [[1, 1], [3, 3]], 3: [[1, 1], [2, 3]]})
def DIJKSTRA(point,d):
cost = {node:1e18 for node in list(d.keys())}
Q = [] #頂点のリスト
cost[point]=0 #開始地点のコストをゼロとする（当たり前
heappush(Q,(point,cost[point]))
while Q:
prefnd,tmpC=heappop(Q)
if cost[prefnd]<tmpC:
continue
for node,c in d[prefnd]:
altC=c+tmpC
if cost[node]>altC:
cost[node]=altC
heappush(Q,(node,altC))
return cost
q,k=list(map(int,input().split()))
y=DIJKSTRA(k,d)
for i in range(q):
a,b=list(map(int,input().split()))
print((y[a]+y[b]))
| p03634 |
from collections import defaultdict
def inpl(): return [int(i) for i in input().split()]
path = defaultdict(lambda: [])
N = int(eval(input()))
for _ in range(N-1):
a, b, c = inpl()
path[a].append((b,c))
path[b].append((a,c))
Q, K = inpl()
now = {K}
dist = [0 for _ in range(N+1)]
visited = [False for _ in range(N+1)]
visited[K] = visited[0] = True
while True:
for na in now.copy():
na = now.pop()
for nb, nc in path[na]:
dist[nb] = dist[na] + nc
visited[nb] = True
path[nb].remove((na,nc))
now.add(nb)
if all(visited):
break
for i in range(Q):
x, y = inpl()
print((dist[x]+dist[y])) | from collections import defaultdict
def inpl(): return [int(i) for i in input().split()]
path = defaultdict(lambda: [])
N = int(eval(input()))
for _ in range(N-1):
a, b, c = inpl()
path[a].append((b,c))
path[b].append((a,c))
ctr = 1
Q, K = inpl()
now = [K]
dist = [0 for _ in range(N+1)]
while True:
for na in now.copy():
na = now.pop()
for nb, nc in path[na]:
dist[nb] = dist[na] + nc
path[nb].remove((na,nc))
now.append(nb)
ctr += 1
if ctr >= N:
break
for i in range(Q):
x, y = inpl()
print((dist[x]+dist[y])) | p03634 |
from collections import deque
N = int(eval(input()))
graph = [[] * N for _ in range(N)]
graph_dist = [[0] * N for _ in range(N)]
C = [0] * (N - 1)
for i in range(N-1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
graph[a].append(b)
graph[b].append(a)
graph_dist[a][b] = c
graph_dist[b][a] = c
Q, K = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(Q)]
# BFSのためのデータ構造
dist = [-1 for _ in range(N)] # 全頂点を未訪問に
que = deque()
# 初期条件(頂点 K-1 を初期ノードとする)
dist[K-1] = 0
que.append(K-1)
# BFS 開始(キューが空になるまで探索を行う)
while que:
v = que[0]
que.popleft()
for new_v in graph[v]:
if dist[new_v] != -1: # すでに探索済みの頂点は探索しない
continue
# 新たな頂点 new_vについて距離情報を更新してキューに追加する
dist[new_v] = dist[v] + graph_dist[v][new_v]
que.append(new_v)
for i in range(Q):
print((dist[xy[i][0] - 1] + dist[xy[i][1] - 1]))
| from collections import deque
N = int(eval(input()))
graph = [[] * N for _ in range(N)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
graph[a].append([b, c])
graph[b].append([a, c])
Q, K = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(Q)]
# BFSのためのデータ構造
dist = [-1 for _ in range(N)] # 全頂点を未訪問に
que = deque()
# 初期条件(頂点 K-1 を初期ノードとする)
dist[K-1] = 0
que.append(K-1)
# BFS 開始(キューが空になるまで探索を行う)
while que:
v = que[0]
que.popleft()
for new_v_list in graph[v]:
new_v = new_v_list[0]
if dist[new_v] != -1: # すでに探索済みの頂点は探索しない
continue
# 新たな頂点 new_vについて距離情報を更新してキューに追加する
dist[new_v] = dist[v] + new_v_list[1]
que.append(new_v)
for i in range(Q):
print((dist[xy[i][0] - 1] + dist[xy[i][1] - 1]))
| p03634 |
from heapq import heappush, heappop
from math import isinf
class Edge(object):
def __init__(self, src, dst, cost):
self.src = src
self.dst = dst
self.cost = cost
class Dijkstra(object):
def __init__(self, v_len, edges, start, directed=False):
"""
ダイクストラ法で最短経路を求める。
:param v_len: グラフのノード数 通常は|V|、1-indexedなグラフなら |V| + 1
:param edges: グラフの構造
:param start: 始点 単一視点最短経路問題として解くので必要
:param directed: 有向グラフの場合True 隣接行列を対称行列にするかが変わる
"""
# 隣接行列 (adjacency matrix)
# adj[i][j] でi番目の頂点からj番目の頂点へのコストを示す パスがなければINF
self._adj = [[float('inf') for _ in range(v_len)] for _ in range(v_len)]
for e in edges:
self._adj[e.src][e.dst] = e.cost
if not directed:
self._adj[e.dst][e.src] = e.cost
self._dist = [float('inf') for i in range(v_len)] # 始点から各頂点までの最短距離
self._prev = [float('inf') for i in range(v_len)] # 最短経路における，その頂点の前の頂点のIDを格納する
self._solve(start)
def _solve(self, start):
# 「最短距離が確定した頂点」に隣接する点からBFSするにあたり、それをどう探すかが問題になる
# 安直に実装すればここで O(|V|) かかってしまうが、優先度キューを使えば O(log|V|) になる
self._dist[start] = 0
q = list()
heappush(q, (0, start)) # キューの要素は (始点から頂点v_iへの仮の距離, v_iのID)
while len(q) != 0:
c, src = heappop(q)
if self._dist[src] < c:
continue
# 隣接行列から隣接するノードを全て調べる = BFS
for dst in range(len(self._adj)):
cost = self._adj[src][dst]
if isinf(cost):
continue
if self._dist[src] + cost < self._dist[dst]:
self._dist[dst] = self._dist[src] + cost
heappush(q, (self._dist[dst], dst))
self._prev[dst] = src
def distance(self, goal):
return self._dist[goal]
def path(self, goal):
path = list()
path.append(goal)
cursor = goal
while not isinf(self._prev[cursor]):
path.append(self._prev[cursor])
cursor = self._prev[cursor]
return list(reversed(path))
N = int(eval(input()))
edges = list()
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
edges.append(Edge(a, b, c))
Q, K = list(map(int, input().split()))
dijkstra = Dijkstra(N + 1, edges, K)
for x, y in [tuple(map(int, input().split())) for _ in range(Q)]:
print((dijkstra.distance(x) + dijkstra.distance(y)))
| N = int(eval(input()))
nl = [list() for _ in range(N + 1)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
nl[a].append((b, c))
nl[b].append((a, c))
Q, K = list(map(int, input().split()))
ans = [-1 for _ in range(N + 1)]
stack = [(K, -1, 0)] # v, p, c
while len(stack) > 0:
v, p, c = stack.pop()
ans[v] = c
for next_v, next_c in nl[v]:
if next_v == p:
continue
stack.append((next_v, v, c + next_c))
for x, y in [tuple(map(int, input().split())) for _ in range(Q)]:
print((ans[x] + ans[y]))
| p03634 |
#!/usr/bin/env python3
import sys
import heapq
def main():
input = sys.stdin.readline
n = int(eval(input()))
adjs = [[] for i in range(n)]
for i in range(n - 1):
a, b, c = list(map(int, input().split()))
adjs[a - 1].append((b - 1, c))
adjs[b - 1].append((a - 1, c))
q, k = list(map(int, input().split()))
# Dijkstra
dist = [None] * n
dist[k - 1] = 0
hq = [(0, k - 1)]
queued = [False] * n
queued[k - 1] = True
while hq:
d, j = heapq.heappop(hq)
dist[j] = d
for j2, d2 in adjs[j]:
if queued[j2]:
continue
heapq.heappush(hq, (d + d2, j2))
queued[j2] = True
# For each query
for i in range(q):
x, y = list(map(int, input().split()))
print((dist[x - 1] + dist[y - 1]))
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
import sys
def main():
input = sys.stdin.readline
n = int(eval(input()))
adjs = [[] for i in range(n)]
for i in range(n - 1):
a, b, c = list(map(int, input().split()))
adjs[a - 1].append((b - 1, c))
adjs[b - 1].append((a - 1, c))
q, k = list(map(int, input().split()))
# DFS
dist = [None] * n
dist[k - 1] = 0
hq = [(0, k - 1)]
queued = [False] * n
queued[k - 1] = True
while hq:
d, j = hq.pop()
dist[j] = d
for j2, d2 in adjs[j]:
if queued[j2]:
continue
hq.append((d + d2, j2))
queued[j2] = True
# For each query
for i in range(q):
x, y = list(map(int, input().split()))
print((dist[x - 1] + dist[y - 1]))
if __name__ == "__main__":
main()
| p03634 |
import heapq
import sys
sys.setrecursionlimit(10000)
INF = float('inf')
N = int(sys.stdin.readline())
ABC = [list(map(int, sys.stdin.readline().split())) for _ in range(N - 1)]
Q, K = list(map(int, sys.stdin.readline().split()))
X, Y = list(zip(*[list(map(int, sys.stdin.readline().split())) for _ in range(Q)]))
def dijkstra(graph, start):
"""
TODO: start していしなかったときに全部の距離を知りたい
マイナスの辺があっちゃダメ
scipy.sparse.csgraph.dijkstra は内部で使われてるフィボナッチヒープが一部のケースでめっちゃ遅いのであんまり使わないほうがよさげ
https://atcoder.jp/contests/soundhound2018-summer-qual/submissions/5311823
:param list of (list of (int, int)) graph:
graph[from_index]: (to_index, weight)
:param int start:
:return:
"""
dist = [float('inf') for _ in range(len(graph))]
dist[start] = 0
heap = []
heapq.heappush(heap, (0, start))
while len(heap) > 0:
w, v = heapq.heappop(heap)
if w > dist[v]:
continue
for u, dw in graph[v]:
if w + dw < dist[u]:
dist[u] = w + dw
heapq.heappush(heap, (w + dw, u))
return dist
#: :type: list of (list of (int, int))
graph = [[] for _ in range(N + 1)]
for a, b, c in ABC:
graph[a].append((b, c))
graph[b].append((a, c))
dists = dijkstra(graph, K)
for x, y in zip(X, Y):
print((int(dists[x] + dists[y])))
| import sys
sys.setrecursionlimit(100000)
INF = float('inf')
N = int(sys.stdin.readline())
ABC = [list(map(int, sys.stdin.readline().split())) for _ in range(N - 1)]
Q, K = list(map(int, sys.stdin.readline().split()))
X, Y = list(zip(*[list(map(int, sys.stdin.readline().split())) for _ in range(Q)]))
#: :type: list of (list of (int, int))
graph = [[] for _ in range(N + 1)]
for a, b, c in ABC:
graph[a].append((b, c))
graph[b].append((a, c))
stack = [(K, 0)]
dists = {K: 0}
while stack:
v, vw = stack.pop()
for u, w in graph[v]:
if u not in dists:
dists[u] = vw + w
stack.append((u, vw + w))
for x, y in zip(X, Y):
print((int(dists[x] + dists[y])))
| p03634 |
import heapq
N = int(eval(input()))
abc = [list(map(int,input().split())) for _ in range(N-1)]
Q,K = list(map(int,input().split()))
xy = [list(map(int,input().split())) for _ in range(Q)]
connect = [[] for _ in range(N)]
INFTY = 10**15
for a,b,c in abc:
connect[a-1].append([b-1,c])
connect[b-1].append([a-1,c])
cost = [[INFTY,False] for _ in range(N)]
cost[K-1][0] = 0
q = [(0,K-1)]
while q:
_,i = heapq.heappop(q)
if cost[i][1]:
continue
cost[i][1] = True
ci0 = cost[i][0]
for j,c in connect[i]:
if cost[j][1]:
continue
tmp_cost = ci0+c
if tmp_cost < cost[j][0]:
cost[j][0] = tmp_cost
heapq.heappush(q,(tmp_cost,j))
for x,y in xy:
print((cost[x-1][0] + cost[y-1][0])) | N = int(eval(input()))
ABC = [list(map(int,input().split())) for _ in [0]*(N-1)]
Q,K = list(map(int,input().split()))
XY = [list(map(int,input().split())) for _ in [0]*Q]
E = [{} for _ in [0]*N]
for a,b,c in ABC:
E[a-1][b-1] = c
E[b-1][a-1] = c
def dist_dfs_tree(N,E,start):
d = [-1]*N
d[start] = 0
q = [start]
while q:
i = q.pop()
ci = d[i]
for j,cj in list(E[i].items()):
if d[j] !=-1:continue
d[j] = ci+cj
q.append(j)
return d
d = dist_dfs_tree(N,E,K-1)
for x,y in XY:
print((d[x-1]+d[y-1])) | p03634 |
import sys
import heapq
from operator import itemgetter
from collections import deque, defaultdict
from bisect import bisect_left, bisect_right
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
class Heapq:
def __init__(self, que=[], asc=True):
if not asc:
que = [-a for a in que]
self.__que = que
heapq.heapify(self.__que)
self.__sign = 1 if asc else -1
def pop(self):
return heapq.heappop(self.__que) * self.__sign
def push(self, value):
heapq.heappush(self.__que, value * self.__sign)
def pushpop(self, value):
return heapq.heappushpop(self.__que, value * self.__sign) * self.__sign
def top(self):
return self.__que[0] * self.__sign
def size(self):
return len(self.__que)
def sol():
N = int(eval(input()))
edges = [[] for _ in range(N)]
for _ in range(N - 1):
fr, to, cost = list(map(int, input().split()))
fr -= 1
to -= 1
edges[fr].append((to, cost))
edges[to].append((fr, cost))
Q, K = list(map(int, input().split()))
K -= 1
minDist = [float('inf')] * N
que = Heapq([])
que.push((0, K))
while que.size():
dist, now = que.pop()
if minDist[now] < dist:
continue
minDist[now] = dist
for to, cost in edges[now]:
if minDist[to] > dist + cost:
que.push((dist + cost, to))
for _ in range(Q):
fr, to = list(map(int, input().split()))
print((minDist[fr - 1] + minDist[to - 1]))
sol() | from collections import deque
import sys
input = sys.stdin.buffer.readline
N = int(input())
edges = [[] for _ in range(N)]
for _ in range(N - 1):
fr, to, cost = map(int, input().split())
fr -= 1
to -= 1
edges[fr].append((to, cost))
edges[to].append((fr, cost))
Q, K = map(int, input().split())
K -= 1
XY = [tuple(map(int, input().split())) for _ in range(Q)]
que = deque([(K, -1, 0)])
dist = [10**18] * N
while que:
now, pr, d = que.popleft()
dist[now] = d
for to, c in edges[now]:
if to == pr:
continue
que.append((to, now, d + c))
ans = [dist[x - 1] + dist[y - 1] for x, y in XY]
print(*ans, sep='\n')
| p03634 |
N = int(input())
edges = [[] for _ in range(N)]
for _ in range(N - 1):
fr, to, cost = map(int, input().split())
fr -= 1
to -= 1
edges[fr].append((to, cost))
edges[to].append((fr, cost))
Q, K = map(int, input().split())
K -= 1
minDist = [10**18] * N
minDist[K] = 0
st = [(K, 0)]
while st:
now, dist = st.pop()
for to, c in edges[now]:
d = dist + c
if minDist[to] > d:
minDist[to] = d
st.append((to, d))
ans = []
for _ in range(Q):
X, Y = map(lambda a: int(a) - 1, input().split())
ans.append(minDist[X] + minDist[Y])
print(*ans, sep='\n')
| N = int(input())
edges = [[] for _ in range(N)]
for _ in range(N - 1):
fr, to, cost = map(int, input().split())
fr -= 1
to -= 1
edges[fr].append((to, cost))
edges[to].append((fr, cost))
Q, K = map(int, input().split())
K -= 1
XY = [tuple(map(lambda a: int(a) - 1, input().split())) for _ in range(Q)]
minDist = [10**18] * N
minDist[K] = 0
st = [K]
while st:
now = st.pop()
dist = minDist[now]
for to, c in edges[now]:
d = dist + c
if minDist[to] > d:
minDist[to] = d
st.append(to)
ans = [minDist[x] + minDist[y] for x, y in XY]
print(*ans, sep='\n')
| p03634 |
import sys
sys.setrecursionlimit(100001)
def input():
return sys.stdin.readline()[:-1]
from heapq import *
INF = 10 ** 20
def dijkstra(s, edges):
dist = [INF for _ in range(len(edges))]
dist[s], h = 0, []
heappush(h, (0, s))
while (len(h)):
dv, v = heappop(h)
if dv > dist[v]:
continue
for u, cost in edges[v]:
if dv + cost < dist[u]:
dist[u] = dv + cost
heappush(h, (dist[u], u))
return dist
N = int(eval(input()))
es = [[] for i in range(N+1)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
es[a].append((b, c))
es[b].append((a, c))
Q, K = list(map(int, input().split()))
xy = [list(map(int, input().split())) for i in range(Q)]
dist = dijkstra(K, es)
for i in range(Q):
print((dist[xy[i][0]] + dist[xy[i][1]]))
| import sys
sys.setrecursionlimit(1000000)
def input():
return sys.stdin.readline()[:-1]
from heapq import *
def dfs(s, es):
dist = [None] * len(es)
dist[s] = 0
def ret(v, d):
for u, c in es[v]:
if dist[u] == None:
dist[u] = dist[v] + c
ret(u, dist[u])
ret(s, 0)
return dist
N = int(eval(input()))
es = [[] for i in range(N+1)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
es[a].append((b, c))
es[b].append((a, c))
Q, K = list(map(int, input().split()))
xy = [list(map(int, input().split())) for i in range(Q)]
dist = dfs(K, es)
for i in range(Q):
print((dist[xy[i][0]] + dist[xy[i][1]]))
| p03634 |
import sys
# sys.setrecursionlimit(100000)
from collections import defaultdict
def warshall_floyd(graph: dict, N: int):
""" graph:
{node:{node:cost,node:cost,...},
node:{node:cost,node:cost,...},...}
"""
INF = float("inf")
dp = [[INF] * N for _ in range(N)]
for i in range(N):
dp[i][i] = 0
# Step 1: fill dp
for v1, edges in list(graph.items()):
for v2, cost in list(edges.items()):
dp[v1][v2] = cost
# search
for k in range(N): # 中継点
for i in range(N): # 始点
for j in range(N): # 終点
dp[i][j] = min(dp[i][k] + dp[k][j], dp[i][j])
return dp
def input():
return sys.stdin.readline().strip()
def input_int():
return int(eval(input()))
def input_int_list():
return [int(i) for i in input().split()]
def main():
n = input_int()
graph = defaultdict(dict)
for _ in range(n - 1):
a, b, c = input_int_list()
graph[a][b] = c
graph[b][a] = c
dp = warshall_floyd(graph, n + 1)
q, k = input_int_list()
ans = []
for _ in range(q):
x, y = input_int_list()
ans.append(dp[x][k] + dp[k][y])
for i in ans:
print(i)
return
if __name__ == "__main__":
main()
| import sys
# sys.setrecursionlimit(100000)
from collections import defaultdict
from heapq import heappop, heappush
class Dijkstra:
"""Graph input:
{
node:{node:cost,node:cost...},
node:{node:cost,node:cost...},
...
}
"""
def __init__(self, graph: dict, N: int):
self.graph = graph
self.costs = [float("inf")] * N
def calculate(self, start):
queue = list()
# step1: push the start point into the priority queue
self.costs[start] = 0
heappush(queue, (0, start)) # (cost,node)
while queue:
# step2: get the minimum cost node from unfixed node and fix the cost
cost_from_start, min_node = heappop(queue)
# step3: update the direct connected nodes
for link, cost in list(self.graph[min_node].items()):
if cost_from_start + cost < self.costs[link]:
self.costs[link] = cost_from_start + cost
heappush(queue, (self.costs[link], link))
return self.costs
def input():
return sys.stdin.readline().strip()
def input_int():
return int(eval(input()))
def input_int_list():
return [int(i) for i in input().split()]
def main():
n = input_int()
graph = defaultdict(dict)
for _ in range(n - 1):
a, b, c = input_int_list()
graph[a][b] = c
graph[b][a] = c
# dp = warshall_floyd(graph, n + 1) O(n**3) => TLD
q, k = input_int_list()
solver = Dijkstra(graph, n + 1)
costs = solver.calculate(k)
ans = []
for _ in range(q):
x, y = input_int_list()
ans.append(costs[x] + costs[y])
for i in ans:
print(i)
return
if __name__ == "__main__":
main()
| p03634 |
n = int(eval(input()))
connect_list = [[] for i in range(n)]
for i in range(n-1):
a, b, c = [ int(v)-1 for v in input().split() ]
c += 1
connect_list[a].append((b,c))
connect_list[b].append((a,c))
q, k = [ int(v) for v in input().split() ]
k -= 1
shortest_list = [-1 for i in range(n)]
shortest_list[k] = 0
searching_list = [k]
while searching_list != []:
new_search_list = []
for i in searching_list:
for j in connect_list[i]:
x, y = j
if shortest_list[x] == -1:
shortest_list[x] = y + shortest_list[i]
new_search_list.append(x)
searching_list = new_search_list
for i in range(q):
a, b = [ int(v)-1 for v in input().split() ]
print((shortest_list[a] + shortest_list[b]))
| import sys
input = sys.stdin.readline
n = int(eval(input()))
connect_list = [[] for i in range(n)]
for i in range(n-1):
a, b, c = [ int(v)-1 for v in input().split() ]
c += 1
connect_list[a].append((b,c))
connect_list[b].append((a,c))
q, k = [ int(v) for v in input().split() ]
k -= 1
shortest_list = [-1 for i in range(n)]
shortest_list[k] = 0
searching_list = [k]
while searching_list != []:
new_search_list = []
for i in searching_list:
for j in connect_list[i]:
x, y = j
if shortest_list[x] == -1:
shortest_list[x] = y + shortest_list[i]
new_search_list.append(x)
searching_list = new_search_list
for i in range(q):
a, b = [ int(v)-1 for v in input().split() ]
print((shortest_list[a] + shortest_list[b]))
| p03634 |
n = int(eval(input()))
g = [[] for i in range(n)]
for i in range(n-1):
a,b,c = list(map(int,input().split()))
a-=1;b-=1
g[a].append([b,c])
g[b].append([a,c])
q,k = list(map(int,input().split()))
k -= 1
con = [-1] * n
con[k] = 0
stack = [k]
while stack:
cur = stack.pop()
for i,j in g[cur]:
if con[i] == -1:
con[i] = con[cur] + j
stack.append(i)
for i in range(q):
x,y = list(map(int,input().split()))
x-=1;y-=1
print((con[x]+con[y]))
| import sys
input = sys.stdin.readline
n = int(eval(input()))
g = [[] for i in range(n)]
for i in range(n-1):
a,b,c = list(map(int,input().split()))
a-=1;b-=1
g[a].append([b,c])
g[b].append([a,c])
q,k = list(map(int,input().split()))
k -= 1
con = [-1] * n
con[k] = 0
stack = [k]
while stack:
cur = stack.pop()
for i,j in g[cur]:
if con[i] == -1:
con[i] = con[cur] + j
stack.append(i)
for i in range(q):
x,y = list(map(int,input().split()))
x-=1;y-=1
print((con[x]+con[y])) | p03634 |
n = int(eval(input()))
tree = [[] for _ in range(n+1)]
for i in range(n-1):
a, b, c = list(map(int, input().split()))
tree[a].append([b, c])
tree[b].append([a, c])
q, k = list(map(int, input().split()))
from collections import deque
que = deque([k])
visit = [-1 for _ in range(n+1)]
visit[k] = 0
while que:
pos = que.popleft()
for i, j in tree[pos]:
if visit[i] < 0:
visit[i] = visit[pos]+j
que.append(i)
for i in range(q):
x, y = list(map(int, input().split()))
print((visit[x]+visit[y])) | def main():
n = int(eval(input()))
tree = [[] for _ in range(n+1)]
for i in range(n-1):
a, b, c = list(map(int, input().split()))
tree[a].append([b, c])
tree[b].append([a, c])
q, k = list(map(int, input().split()))
from collections import deque
que = deque([k])
visit = [-1 for _ in range(n+1)]
visit[k] = 0
while que:
pos = que.popleft()
for i, j in tree[pos]:
if visit[i] < 0:
visit[i] = visit[pos]+j
que.append(i)
for i in range(q):
x, y = list(map(int, input().split()))
print((visit[x]+visit[y]))
if __name__=="__main__":
main() | p03634 |
n = int(eval(input()))
graph = [dict() for _ in range(n)]
for i in range(n - 1):
a, b, c = list(map(int, input().split()))
graph[a - 1][b - 1] = c
graph[b - 1][a - 1] = c
q, k = list(map(int, input().split()))
xy = []
for i in range(q):
x, y = list(map(int, input().split()))
xy.append([x-1, y-1])
depth = [0 for _ in range(n)]
prev = [False for _ in range(n)]
depth[k-1] = 0
import sys
sys.setrecursionlimit(10 ** 6)
def dfs(now, graph, depth, prev):
if len(graph[now]) == 0 or prev[now]:
return
prev[now] = True
for k, v in list(graph[now].items()):
if not prev[k]:
depth[k] += depth[now] + v
dfs(k, graph, depth, prev)
return depth
depth = dfs(k-1, graph, depth, prev)
for x, y in xy:
print((depth[x] + depth[y]))
| n = int(eval(input()))
graph = [dict() for _ in range(n)]
for i in range(n - 1):
a, b, c = list(map(int, input().split()))
graph[a - 1][b - 1] = c
graph[b - 1][a - 1] = c
q, k = list(map(int, input().split()))
xy = []
for i in range(q):
x, y = list(map(int, input().split()))
xy.append([x - 1, y - 1])
depth = [0 for _ in range(n)]
prev = [False for _ in range(n)]
depth[k - 1] = 0
import sys
sys.setrecursionlimit(10 ** 6)
def dfs(now, prev, cost, graph, depth):
depth[now] = cost
for k, v in list(graph[now].items()):
if k == prev:
continue
dfs(k, now, cost + v, graph, depth)
return depth
depth = dfs(k - 1, -1, 0, graph, depth)
for x, y in xy:
print((depth[x] + depth[y]))
| p03634 |
# disjoint setかと思いきやDFS
# どこが悪いのかさっっっっっっぱりわからん...
# あ 再帰にしてるからその上限か
import sys
sys.setrecursionlimit(10000000)
n = int(eval(input()))
graph = [[] for _ in range(n)]
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
a, b = a - 1, b - 1
graph[a].append([b, c])
graph[b].append([a, c])
q, k = list(map(int, input().split()))
k = k - 1
# kからスタートしてぜんぶたどる
ans_list = [0 for _ in range(n)]
def dfs(node, used, weight):
for data in graph[node]:
if data[0] not in used:
next_used = used[:]
next_used.append(data[0])
dfs(data[0], next_used, weight + data[1])
ans_list[node] = weight
dfs(k, [k], 0)
for _ in range(q):
a, b = [int(x) - 1 for x in input().split()]
print((ans_list[a] + ans_list[b]))
| # disjoint setかと思いきやDFS
# したらTLEになったので根本的にやり方が間違ってるということ
# よくよく考えたらdfsなのでそこにたどり着いたときが最短距離だわ ムダに探索してた
import sys
sys.setrecursionlimit(10000000)
n = int(eval(input()))
graph = [[] for _ in range(n)]
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
a, b = a - 1, b - 1
graph[a].append([b, c])
graph[b].append([a, c])
q, k = list(map(int, input().split()))
k = k - 1
# kからスタートしてぜんぶたどる
ans_list = [0 for _ in range(n)]
def dfs(node, weight):
for data in graph[node]:
if data[0] not in used:
used.append(data[0])
dfs(data[0], weight + data[1])
ans_list[node] = weight
used = [k]
dfs(k, 0)
for _ in range(q):
a, b = [int(x) - 1 for x in input().split()]
print((ans_list[a] + ans_list[b]))
| p03634 |
from collections import deque
N = int(input())
E = [[] for _ in range(N)]
for _ in range(N-1):
a, b, c = map(int, input().split())
E[a-1].append((b-1, c))
E[b-1].append((a-1, c))
Q, K = map(int, input().split())
distance = [0] * N
stack = deque([K-1])
checked = [False] * N
while stack:
v = stack.pop()
for u, c in E[v]:
if checked[u]:
continue
distance[u] = distance[v] + c
stack.append(u)
checked[v] = True
ans = [0] * Q
for i in range(Q):
x, y = map(int, input().split())
ans[i] = distance[x-1] + distance[y-1]
[print(a) for a in ans]
| from collections import deque
N = int(input())
E = [[] for _ in range(N)]
for _ in range(N-1):
a, b, c = map(int, input().split())
E[a-1].append((b-1, c))
E[b-1].append((a-1, c))
Q, K = map(int, input().split())
distance = [0] * N
stack = deque([K-1])
# checked = [False] * N
while stack:
v = stack.pop()
for u, c in E[v]:
if distance[u] != 0:
continue
distance[u] = distance[v] + c
stack.append(u)
# checked[v] = True
ans = [0] * Q
for i in range(Q):
x, y = map(int, input().split())
ans[i] = distance[x-1] + distance[y-1]
[print(a) for a in ans]
| p03634 |
from collections import deque
N = int(eval(input()))
G = [[] * N for _ in range(N)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
G[a - 1].append((b - 1, c))
G[b - 1].append((a - 1, c))
Q, K = list(map(int, input().split()))
D = [-1] * N
D[K - 1] = 0
q = deque([K - 1])
while q:
n = q.popleft()
for i, c in G[n]:
if D[i] < 0:
q.append(i)
D[i] = D[n] + c
for _ in range(Q):
x, y = list(map(int, input().split()))
print((D[x - 1] + D[y - 1])) | import sys
sys.setrecursionlimit(10**6)
N = int(eval(input()))
ABC = [list(map(int, input().split())) for _ in range(N - 1)]
Q, K = list(map(int, input().split()))
XY = [list(map(int, input().split())) for _ in range(Q)]
G = [[] * N for _ in range(N)]
for a, b, c in ABC:
G[a - 1].append((b - 1, c))
G[b - 1].append((a - 1, c))
D = [-1] * N
def dfs(v, d):
D[v] = d
for i, c in G[v]:
if D[i] < 0:
dfs(i, d + c)
dfs(K - 1, 0)
for x, y in XY:
print((D[x - 1] + D[y - 1])) | p03634 |
N = int(eval(input()))
ABC = [list(map(int, input().split())) for _ in range(N - 1)]
Q, K = list(map(int, input().split()))
XY = [list(map(int, input().split())) for _ in range(Q)]
G = [[] * N for _ in range(N)]
for a, b, c in ABC:
G[a - 1].append((b - 1, c))
G[b - 1].append((a - 1, c))
D = [-1] * N
s = [(K - 1, 0)]
while s:
v, c = s.pop()
D[v] = c
for vv, cc in G[v]:
if D[vv] < 0:
s.append((vv, cc + c))
for x, y in XY:
print((D[x - 1] + D[y - 1])) | import sys
input = sys.stdin.readline
N = int(eval(input()))
ABC = [list(map(int, input().split())) for _ in range(N - 1)]
Q, K = list(map(int, input().split()))
XY = [list(map(int, input().split())) for _ in range(Q)]
G = [[] * N for _ in range(N)]
for a, b, c in ABC:
G[a - 1].append((b - 1, c))
G[b - 1].append((a - 1, c))
D = [-1] * N
s = [(K - 1, 0)]
while s:
v, c = s.pop()
D[v] = c
for vv, cc in G[v]:
if D[vv] < 0:
s.append((vv, cc + c))
for x, y in XY:
print((D[x - 1] + D[y - 1])) | p03634 |
import sys
input = sys.stdin.readline
N = int(eval(input()))
ABC = [list(map(int, input().split())) for _ in range(N - 1)]
Q, K = list(map(int, input().split()))
XY = [list(map(int, input().split())) for _ in range(Q)]
G = [[] * N for _ in range(N)]
for a, b, c in ABC:
G[a - 1].append((b - 1, c))
G[b - 1].append((a - 1, c))
D = [-1] * N
s = [(K - 1, 0)]
while s:
v, c = s.pop()
D[v] = c
for vv, cc in G[v]:
if D[vv] < 0:
s.append((vv, cc + c))
for x, y in XY:
print((D[x - 1] + D[y - 1])) | import sys
input = sys.stdin.readline
N = int(eval(input()))
G = [[] * N for _ in range(N)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
G[a - 1].append((b - 1, c))
G[b - 1].append((a - 1, c))
Q, K = list(map(int, input().split()))
D = [-1] * N
s = [(K - 1, 0)]
while s:
v, c = s.pop()
D[v] = c
for vv, cc in G[v]:
if D[vv] < 0:
s.append((vv, cc + c))
for _ in range(Q):
x, y = list(map(int, input().split()))
print((D[x - 1] + D[y - 1])) | p03634 |
def dfs(k, path, n):
"""連結情報path,頂点の個数Nが与えられたとき
頂点Kから各頂点までの距離をlistで返す"""
from collections import deque # deque(),popleft()
dist = [-1] * n
dist[k] = 0
que = deque([])
que.append(k)
while que:
label = que.popleft()
for i,c in path[label]: # 頂点labelと連結している頂点iと距離c
if dist[i] == -1:
dist[i] = dist[label] + c
que += [i] # 次に調べる頂点に
return dist
n = int(eval(input()))
path = [[] for i in range(n)]
# path = [{1,2}] * 3
# print(path)
for i in range(n-1):
a, b, c = list(map(int, input().split()))
# print(a,b,c)
path[a-1] += [(b-1, c)]
path[b-1] += [(a-1, c)]
q, k = list(map(int, input().split()))
xy = [list(map(int, input().split())) for i in range(q)]
dis = dfs(k-1, path, n)
for i in range(q):
print((dis[xy[i][0] - 1] + dis[xy[i][1] - 1]))
| from sys import stdin
input = stdin.readline
def dfs(k, path, n):
"""連結情報path,頂点の個数Nが与えられたとき
頂点Kから各頂点までの距離をlistで返す"""
from collections import deque # deque(),popleft()
dist = [-1] * n
dist[k] = 0
que = deque([])
que.append(k)
while que:
label = que.popleft()
for i,c in path[label]: # 頂点labelと連結している頂点iと距離c
if dist[i] == -1:
dist[i] = dist[label] + c
que += [i] # 次に調べる頂点に
return dist
n = int(eval(input()))
path = [[] for i in range(n)]
# path = [{1,2}] * 3
# print(path)
for i in range(n-1):
a, b, c = list(map(int, input().split()))
# print(a,b,c)
path[a-1] += [(b-1, c)]
path[b-1] += [(a-1, c)]
q, k = list(map(int, input().split()))
xy = [list(map(int, input().split())) for i in range(q)]
dis = dfs(k-1, path, n)
for i in range(q):
print((dis[xy[i][0] - 1] + dis[xy[i][1] - 1]))
| p03634 |
import queue
def ans():
def dfs(v, p, d):
visited = []
q = queue.Queue()
for i in tree[v]:
q.put((i[0], i[1], p))
visited.append(v)
while not q.empty():
e, cost, parent = q.get()
if (e in visited): continue
if e == parent : continue
visited.append(e)
depth[e] = cost
for i in tree[e]:
if (i[0] in visited): continue
q.put((i[0], i[1] + cost, e))
n = int(eval(input()))
tree = [[] for _ in range(n+1)]
depth = [0] * (n * 2)
for _ in range(1,n):
a, b, c = list(map(int, input().split()))
tree[a].append((b,c))
tree[b].append((a,c))
q, k = list(map(int, input().split()))
dfs(k, -1, 0)
for _ in range(q):
x, y = list(map(int, input().split()))
print((depth[x] + depth[y]))
ans() | import sys
sys.setrecursionlimit(1000000)
def ans():
def dfs(v, p, d):
depth[v] = d
for e, cost in tree[v]:
if e == p:
continue
dfs(e, v, d + cost)
n = int(eval(input()))
tree = [[] for _ in range(n + 1)]
depth = [0] * (n * 2)
for _ in range(1, n):
a, b, c = list(map(int, input().split()))
tree[a].append((b, c))
tree[b].append((a, c))
q, k = list(map(int, input().split()))
dfs(k, -1, 0)
for _ in range(q):
x, y = list(map(int, input().split()))
print((depth[x] + depth[y]))
ans() | p03634 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LS()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
dire4 = [(1,0), (0,1), (-1,0), (0,-1)]
dire8 = [(1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1), (0, -1), (1, -1)]
N = I()
abc = LIR(N-1)
Q, K = LI()
xy = LIR(Q)
abc = list([[x[0]-1, x[1]-1, x[2]] for x in abc])
xy = list([[x[0]-1, x[1]-1] for x in xy])
K = K-1
utov = [[] for i in range(N)]
edge = [[0]*N for i in range(N)]
for a, b, c in abc:
edge[a][b] = c
edge[b][a] = c
utov[a].append(b)
utov[b].append(a)
bfs_map = [-1]*N
q = deque()
q.append(K)
bfs_map[K] = 0
while q:
u = q.popleft()
for v in utov[u]:
if (bfs_map[v] == -1) or (bfs_map[v] > bfs_map[u]+edge[u][v]):
bfs_map[v] = bfs_map[u]+edge[u][v]
q.append(v)
for x, y in xy:
print((bfs_map[x]+bfs_map[y]))
| #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LS()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
dire4 = [(1,0), (0,1), (-1,0), (0,-1)]
dire8 = [(1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1), (0, -1), (1, -1)]
N = I()
abc = LIR(N-1)
Q, K = LI()
xy = LIR(Q)
K = K
utov = [[] for i in range(N+1)]
for a, b, c in abc:
utov[a].append((b,c))
utov[b].append((a,c))
bfs_map = [-1]*(N+1)
q = deque()
q.append(K)
bfs_map[K] = 0
while q:
u = q.popleft()
for v, cost in utov[u]:
if (bfs_map[v] == -1) or (bfs_map[v] > bfs_map[u]+cost):
bfs_map[v] = bfs_map[u] + cost
q.append(v)
for x, y in xy:
print((bfs_map[x]+bfs_map[y]))
| p03634 |
from collections import deque
import sys
sys.setrecursionlimit(10 ** 9)
N = int(eval(input()))
G = [[] for _ in range(N + 1)]
for i in range(N - 1):
a, b, c = [int(_) for _ in input().split()]
G[a].append((b, c))
G[b].append((a, c))
Q, K = [int(_) for _ in input().split()]
# make tree
G2 = [-1] * (N + 1)
def f(v, c, p):
if G2[v] != -1: return
G2[v] = c
for nv, nc in G[v]:
if nv == p: continue
f(nv, nc + c, v)
f(K, 0, 0)
for i in range(Q):
x,y = [int(_) for _ in input().split()]
print((G2[x]+G2[y]))
| from collections import deque
import sys
sys.setrecursionlimit(10 ** 9)
N = int(eval(input()))
G = [[] for _ in range(N + 1)]
for i in range(N - 1):
a, b, c = [int(_) for _ in input().split()]
G[a].append((b, c))
G[b].append((a, c))
Q, K = [int(_) for _ in input().split()]
# make tree
G2 = [10 ** 12] * (N + 1)
G2[K] = 0
def f():
que = deque()
que.append((K, 0))
while que:
v, p = que.pop()
for nv, nc in G[v]:
if nv == p: continue
G2[nv] = G2[v] + nc
que.append((nv, v))
f()
for i in range(Q):
x, y = [int(_) for _ in input().split()]
print((G2[x] + G2[y]))
| p03634 |
import heapq
def dijkstra_heap(s,edge):
#始点sから各頂点への最短距離
d = [10**10]*n
used = [True] * n #True:未確定
d[s] = 0
used[s] = False
edgelist = []
for a,b in edge[s]:
heapq.heappush(edgelist,a*(10**6)+b)
while len(edgelist):
minedge = heapq.heappop(edgelist)
#まだ使われてない頂点の中から最小の距離のものを探す
if not used[minedge%(10**6)]:
continue
v = minedge%(10**6)
d[v] = minedge//(10**6)
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
return d
################################
N = int(eval(input()))
n = N
w = N
edge = tuple([] for i in range(n))
#edge[i] : iから出る道の[重み,行先]の配列
for i in range(w-1):
a,b,c = list(map(int,input().split()))
edge[a-1].append([c,b-1])
edge[b-1].append([c,a-1])
dist = []
for i in range(N):
dist.append(dijkstra_heap(i,edge))
Q,K = list(map(int,input().split()))
for i in range(Q):
x,y = list(map(int,input().split()))
print((int(dist[x-1][K-1]+dist[K-1][y-1]))) | import heapq
"""
https://juppy.hatenablog.com/entry/2019/02/18/%E8%9F%BB%E6%9C%AC_python_%E3%83%97%E3%83%A9%E3%82%A4%E3%82%AA%E3%83%AA%E3%83%86%E3%82%A3%E3%82%AD%E3%83%A5%E3%83%BC%28heapq%29%E3%82%92%E7%94%A8%E3%81%84%E3%81%9F%E3%83%97%E3%83%AA%E3%83%A0%E6%B3%95
"""
def dijkstra_heap(s,edge):
#始点sから各頂点への最短距離
d = [10**10]*n
used = [True] * n #True:未確定
d[s] = 0
used[s] = False
edgelist = []
for a,b in edge[s]:
heapq.heappush(edgelist,a*(10**6)+b)
while len(edgelist):
minedge = heapq.heappop(edgelist)
#まだ使われてない頂点の中から最小の距離のものを探す
if not used[minedge%(10**6)]:
continue
v = minedge%(10**6)
d[v] = minedge//(10**6)
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
return d
################################
N = int(eval(input()))
n = N
w = N
edge = tuple([] for i in range(n))
#edge[i] : iから出る道の[重み,行先]の配列
for i in range(w-1):
a,b,c = list(map(int,input().split()))
edge[a-1].append([c,b-1])
edge[b-1].append([c,a-1])
Q,K = list(map(int,input().split()))
dist = dijkstra_heap(K-1,edge)
for i in range(Q):
x,y = list(map(int,input().split()))
print((int(dist[x-1]+dist[y-1]))) | p03634 |
from heapq import heappush, heappop
INF = 10**20
def dijkstra(N, G, s):
dist = [INF] * N
que = [(0, s)]
dist[s] = 0
while que:
c, v = heappop(que)
if dist[v] < c:
continue
for t, cost in G[v]:
if dist[v] + cost < dist[t]:
dist[t] = dist[v] + cost
heappush(que, (dist[t], t))
return dist
N = int(eval(input()))
edge = [[] for _ in range(N)]
for _ in range(N-1):
a,b,c = list(map(int,input().split()))
edge[a-1].append((b-1,c))
edge[b-1].append((a-1,c))
Q,K = list(map(int,input().split()))
dist = dijkstra(N,edge,K-1)
for _ in range(Q):
x,y = list(map(int,input().split()))
print((dist[x-1]+dist[y-1])) |
from heapq import heappush, heappop
INF = float("inf")
def dijkstra(N, G, s):
dist = [INF] * N
que = [(0, s)]
dist[s] = 0
while que:
c, v = heappop(que)
if dist[v] < c:
continue
for t, cost in G[v]:
if dist[v] + cost < dist[t]:
dist[t] = dist[v] + cost
heappush(que, (dist[t], t))
return dist
N = int(eval(input()))
edge = [[] for _ in range(N)]
for _ in range(N-1):
a,b,c = list(map(int,input().split()))
edge[a-1].append((b-1,c))
edge[b-1].append((a-1,c))
Q,K = list(map(int,input().split()))
dist = dijkstra(N,edge,K-1)
for _ in range(Q):
x,y = list(map(int,input().split()))
print((dist[x-1]+dist[y-1])) | p03634 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n = I()
G = [[] for _ in range(n)]
for a, b, c in LIR(n - 1):
G[a - 1] += [(b - 1, c)]
G[b - 1] += [(a - 1, c)]
q, k = LI()
dq = deque([k - 1])
dist = [-1] * n
dist[k - 1] = 0
while dq:
u = dq.pop()
for v, c in G[u]:
if dist[v] == -1:
dist[v] = dist[u] + c
dq += [v]
for _ in range(q):
x, y = LI()
print((dist[x - 1] + dist[y - 1]))
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n = I()
G = [[] for _ in range(n)]
for a, b, c in LIR(n - 1):
G[a - 1] += [(b - 1, c)]
G[b - 1] += [(a - 1, c)]
q, k = LI()
dq = deque([k - 1])
dist = [-1] * n
dist[k - 1] = 0
while dq:
u = dq.popleft()
for v, c in G[u]:
if dist[v] == -1:
dist[v] = dist[u] + c
dq += [v]
for _ in range(q):
x, y = LI()
print((dist[x - 1] + dist[y - 1]))
| p03634 |
from collections import defaultdict
n = int(eval(input()))
tree = dict()
graph = defaultdict(list)
for i in range(n-1):
a,b,c = (int(x) for x in input().split())
tree[a,b] = c
tree[b,a] = c
graph[a].append(b)
graph[b].append(a)
q, k = (int(x) for x in input().split())
dist = dict()
stack = [k,]
visited = [False for _ in range(n+1)]
dist[k] = 0
visited[k] = True
while stack:
new_stack = []
for node in stack:
for next_node in graph[node]:
if not visited[next_node]:
visited[next_node] = True
dist[next_node] = dist[node] + tree[node, next_node]
new_stack.extend(graph[node])
stack = new_stack
for _ in range(q):
x, y = (int(x) for x in input().split())
print((dist[x] + dist[y]))
| from collections import defaultdict
n = int(eval(input()))
tree = dict()
graph = defaultdict(list)
for i in range(n-1):
a,b,c = (int(x) for x in input().split())
tree[a,b] = c
tree[b,a] = c
graph[a].append(b)
graph[b].append(a)
q, k = (int(x) for x in input().split())
dist = dict()
stack = [k,]
visited = [False for _ in range(n+1)]
dist[k] = 0
visited[k] = True
while stack:
new_stack = []
for node in stack:
for next_node in graph[node]:
if not visited[next_node]:
visited[next_node] = True
dist[next_node] = dist[node] + tree[node, next_node]
new_stack.append(next_node)
stack = new_stack
for _ in range(q):
x, y = (int(x) for x in input().split())
print((dist[x] + dist[y]))
| p03634 |
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(eval(input()))
def LI(): return list(map(int, input().split()))
def LIR(row,col):
if row <= 0:
return [[] for _ in range(col)]
elif col == 1:
return [I() for _ in range(row)]
else:
read_all = [LI() for _ in range(row)]
return list(map(list, list(zip(*read_all))))
#################
from heapq import heappop, heappush
def dijkstra(E,s,n):
d = [float('inf')]*n
d[s] = 0
q = []
heappush(q,(0,s))
while q:
du,u = heappop(q)
if d[u] < du:
continue
for v,weight in list(E[u].items()):
dnew = du + weight
if d[v] > dnew:
d[v] = dnew
heappush(q,(dnew,v))
return d
N = I()
a,b,c = LIR(N-1,3)
Q,K = LI()
x,y = LIR(Q,2)
E = [dict() for _ in range(N)]
for i in range(N-1):
E[a[i]-1][b[i]-1] = c[i]
E[b[i]-1][a[i]-1] = c[i]
d = dijkstra(E,K-1,N)
for i in range(Q):
print((d[x[i]-1]+d[y[i]-1])) | import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(eval(input()))
def LI(): return list(map(int, input().split()))
def LIR(row,col):
if row <= 0:
return [[] for _ in range(col)]
elif col == 1:
return [I() for _ in range(row)]
else:
read_all = [LI() for _ in range(row)]
return list(map(list, list(zip(*read_all))))
#################
from heapq import heappop, heappush
def dijkstra(E,s,n,inf=float('inf')):
d = [inf]*n
d[s] = 0
q = []
heappush(q,(0,s))
while q:
du,u = heappop(q)
if d[u] < du:
continue
for v,dist in E[u]:
dnew = du + dist
if d[v] > dnew:
d[v] = dnew
heappush(q,(dnew,v))
return d
N = I()
a,b,c = LIR(N-1,3)
Q,K = LI()
x,y = LIR(Q,2)
E = [[] for _ in range(N)]
for i in range(N-1):
E[a[i]-1].append((b[i]-1,c[i]))
E[b[i]-1].append((a[i]-1,c[i]))
d = dijkstra(E,K-1,N,inf=10**9*(N-1)+1)
for i in range(Q):
print((d[x[i]-1]+d[y[i]-1])) | p03634 |
N=int(eval(input()))
edge=[list(map(int,input().split())) for i in range(N-1)]
INF=10**15
c=[[INF]*N for i in range(N)]
for i,j,w in edge:
c[i-1][j-1]=w
c[j-1][i-1]=w
Q,K=list(map(int, input().split()))
xy=[list(map(int,input().split())) for i in range(Q)]
from heapq import heappop,heappush
def dij(c,N,start):
d=[INF]*N
d[start]=0
prev=[-1]*N
q=[]
heappush(q,(0,start))
while len(q)>0:
u=heappop(q)[1]
for v in range(N):
if c[u][v]<INF:
temp=d[u]+c[u][v]
if d[v]>temp:
d[v]=temp
prev[v]=u
heappush(q,(d[v],v))
return d
d=dij(c,N,K-1)
for x,y in xy:
print((d[x-1]+d[y-1])) | N=int(eval(input()))
edge=[list(map(int,input().split())) for i in range(N-1)]
inf=10**15
c=[[] for i in range(N)]
for i,j,w in edge:
c[i-1].append((j-1,w))
c[j-1].append((i-1,w))
Q,K=list(map(int, input().split()))
d=[inf]*N
d[K-1]=0
v=[0]*N
import sys
sys.setrecursionlimit(10**5+9)
def dfs(p,v,d):
for n,w in c[p]:
if v[n]==0:
d[n]=min(d[n],d[p]+w)
v[n]=1
dfs(n,v,d)
dfs(K-1,v,d)
xy=[list(map(int,input().split())) for i in range(Q)]
for x,y in xy:
print((d[x-1]+d[y-1])) | p03634 |
from collections import defaultdict
n = int(eval(input()))
V = defaultdict(list)
for _ in range(n-1):
a, b,c = list(map(int, input().split()))
V[a].append([b,c])
V[b].append([a,c])
def dfs(source):
dist = [-1]*(n+1)
dist[source] = 0
q = [source]
while q:
a = q.pop()
for b in V[a]:
if dist[b[0]]!=-1:
continue
dist[b[0]] = dist[a] + b[1]
q.append(b[0])
return dist
q,k = list(map(int, input().split()))
for i in range(q):
x,y = list(map(int,input().split()))
print((dfs(x)[k]+dfs(y)[k])) | from collections import defaultdict
n = int(eval(input()))
V = defaultdict(list)
for _ in range(n-1):
a, b,c = list(map(int, input().split()))
V[a].append([b,c])
V[b].append([a,c])
def dfs(source):
dist = [-1]*(n+1)
dist[source] = 0
q = [source]
while q:
a = q.pop()
for b in V[a]:
if dist[b[0]]!=-1:
continue
dist[b[0]] = dist[a] + b[1]
q.append(b[0])
return dist
q,k = list(map(int, input().split()))
dk = dfs(k)
for i in range(q):
x,y = list(map(int,input().split()))
print((dk[x]+dk[y])) | p03634 |
## abc070d: Transit Tree Path
n = int(eval(input()))
T = [None]*(n+1)
for _ in range(n-1):
v1,v2,d = list(map(int, input().split()))
T[v1] = T[v1] + [[v1,v2,d]] if(T[v1]) else [[v1,v2,d]]
T[v2] = T[v2] + [[v2,v1,d]] if(T[v2]) else [[v2,v1,d]]
q,k = list(map(int, input().split()))
depth = [0]*(n+1)
visit = [False]*(n+1)
depth[k] = 0
visit[k] = True
stack = T[k]
while stack:
p,c,d = stack.pop()
if visit[c]: continue
visit[c] = True
depth[c] = depth[p] + d
for pp,cc,dd in T[c]:
if not visit[cc]: stack.append([pp,cc,dd])
for _ in range(q):
v1,v2 = list(map(int, input().split()))
print((depth[v1]+depth[v2])) | ## abc070d: Transit Tree Path
n = int(eval(input()))
T = [None]*(n+1)
for _ in range(n-1):
v1,v2,d = list(map(int, input().split()))
if(T[v1] is None): T[v1] = [[v1,v2,d]]
else: T[v1].append([v1,v2,d])
if(T[v2] is None): T[v2] = [[v2,v1,d]]
else: T[v2].append([v2,v1,d])
q,k = list(map(int, input().split()))
depth = [0]*(n+1)
visit = [False]*(n+1)
depth[k] = 0
visit[k] = True
stack = T[k]
while stack:
p,c,d = stack.pop()
if visit[c]: continue
visit[c] = True
depth[c] = depth[p] + d
for pp,cc,dd in T[c]:
if not visit[cc]: stack.append([pp,cc,dd])
for _ in range(q):
v1,v2 = list(map(int, input().split()))
print((depth[v1]+depth[v2])) | p03634 |
## abc070d: Transit Tree Path
from collections import deque
n = int(eval(input()))
T = [{} for _ in range(n)]
for _ in range(n-1):
v1,v2,d = list(map(int, input().split()))
T[v1-1][v2-1] = d
T[v2-1][v1-1] = d
q,k = list(map(int, input().split()))
visit = [False]*n
depth = [0]*n
que = deque([[-1,k-1,0]])
while que:
p,c,d = que.popleft()
if visit[c]: continue
visit[c] = True
depth[c] = d
if p>=0: depth[c] += depth[p]
for cc in list(T[c].keys()):
if not visit[cc]: que.append([c,cc,T[c][cc]])
for _ in range(q):
v1,v2 = list(map(int, input().split()))
print((depth[v1-1]+depth[v2-1])) | ## abc070d: Transit Tree Path
from collections import deque
n = int(eval(input()))
T = [{} for _ in range(n)]
for _ in range(n-1):
v1,v2,d = list(map(int, input().split()))
T[v1-1][v2-1] = d
T[v2-1][v1-1] = d
q,k = list(map(int, input().split()))
visit = [False]*n
depth = [0]*n
que = deque()
que.append(k-1)
while que:
p = que.popleft()
visit[p] = True
for c in list(T[p].keys()):
if visit[c]: continue
depth[c] = depth[p] + T[p][c]
que.append(c)
for _ in range(q):
v1,v2 = list(map(int, input().split()))
print((depth[v1-1]+depth[v2-1])) | p03634 |
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n = int(eval(input()))
from collections import defaultdict
ns = defaultdict(set)
for i in range(n-1):
u,v,c = list(map(int, input().split()))
u -= 1
v -= 1
ns[u].add((c,v))
ns[v].add((c,u))
# print(ns)
k = len(bin(n-1))-2
# 深さ
def cdepth(root=0):
# rootを根としたときの深さ
ps = [None] * n
ps[0] = -1
q = [0]
while q:
u = q.pop()
for c,v in ns[u]:
if ps[v] is None:
ps[v] = u
q.append(v)
# psを元から持っている場合、引数のnsをpsにしてこの下だけで良い
depth = [None] * n
depth[root] = 0
q = [root]
while q:
u = q.pop()
for c,v in ns[u]:
if depth[v] is None:
depth[v] = depth[u] + 1
q.append(v)
return depth, ps
def dijkstra(start):
import heapq
vals = [None] * n
h = [(0, start)] # (距離, ノード番号)
vals[start] = 0
while h:
val, u = heapq.heappop(h)
for d, v in ns[u]:
if vals[v] is None or vals[v]>val+d:
vals[v] = val+d
heapq.heappush(h, (vals[v], v))
return vals
# ダブリング
def double(ps):
# global: n=psのサイズ
k = 0
while pow(2,k)<n:
k += 1
prev = [[None]*n for _ in range(k)] # ノードjから2^i個上の上司
for j in range(n):
prev[0][j] = ps[j]
for i in range(1,k):
for j in range(n):
p = prev[i-1][j]
if p>=0:
prev[i][j] = prev[i-1][p]
else:
prev[i][j] = p
return prev
# k: 必要桁数を定める必要アリ
def cprev(u,i):
"""uからi個上の頂点を返す
"""
for j in range(k):
if i>>j&1:
u = prev[j][u]
return u
# k: 必要桁数を定める必要アリ
def lca(u,v):
if depth[u]<depth[v]:
v = cprev(v, depth[v]-depth[u])
else:
u = cprev(u, depth[u]-depth[v])
if u==v:
return u
for i in range(k-1, -1, -1):
if prev[i][u]!=prev[i][v]:
u = prev[i][u]
v = prev[i][v]
return prev[0][u]
dist = dijkstra(0)
depth, ps = cdepth(0)
prev = double(ps)
q,K = list(map(int, input().split()))
K -= 1
ans = [None]*q
for i in range(q):
x,y = list(map(int, input().split()))
x -= 1
y -= 1
l1 = lca(x,K)
l2 = lca(y,K)
# print(x,y,l1,l2)
ans[i] = (dist[x]+dist[K]-2*dist[l1]) + (dist[y]+dist[K]-2*dist[l2])
write("\n".join(map(str, ans))) | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n = int(eval(input()))
from collections import defaultdict
ns = defaultdict(set)
for i in range(n-1):
u,v,c = list(map(int, input().split()))
u -= 1
v -= 1
ns[u].add((c,v))
ns[v].add((c,u))
# print(ns)
k = len(bin(n-1))-2
# 深さ
def cdepth(root=0):
# rootを根としたときの深さ
ps = [None] * n
ps[0] = -1
q = [0]
while q:
u = q.pop()
for c,v in ns[u]:
if ps[v] is None:
ps[v] = u
q.append(v)
# psを元から持っている場合、引数のnsをpsにしてこの下だけで良い
depth = [None] * n
depth[root] = 0
q = [root]
while q:
u = q.pop()
for c,v in ns[u]:
if depth[v] is None:
depth[v] = depth[u] + 1
q.append(v)
return depth, ps
def dijkstra(start):
import heapq
vals = [None] * n
h = [(0, start)] # (距離, ノード番号)
vals[start] = 0
while h:
val, u = heapq.heappop(h)
for d, v in ns[u]:
if vals[v] is None or vals[v]>val+d:
vals[v] = val+d
heapq.heappush(h, (vals[v], v))
return vals
# ダブリング
def double(ps):
# global: n=psのサイズ
k = 0
while pow(2,k)<n:
k += 1
prev = [[None]*n for _ in range(k)] # ノードjから2^i個上の上司
for j in range(n):
prev[0][j] = ps[j]
for i in range(1,k):
for j in range(n):
p = prev[i-1][j]
if p>=0:
prev[i][j] = prev[i-1][p]
else:
prev[i][j] = p
return prev
# k: 必要桁数を定める必要アリ
def cprev(u,i):
"""uからi個上の頂点を返す
"""
for j in range(k):
if i>>j&1:
u = prev[j][u]
return u
# k: 必要桁数を定める必要アリ
def lca(u,v):
if depth[u]<depth[v]:
v = cprev(v, depth[v]-depth[u])
else:
u = cprev(u, depth[u]-depth[v])
if u==v:
return u
for i in range(k-1, -1, -1):
if prev[i][u]!=prev[i][v]:
u = prev[i][u]
v = prev[i][v]
return prev[0][u]
q,K = list(map(int, input().split()))
K -= 1
dist = dijkstra(K)
ans = [None]*q
for i in range(q):
x,y = list(map(int, input().split()))
x -= 1
y -= 1
ans[i] = dist[x] + dist[y]
write("\n".join(map(str, ans))) | p03634 |
import heapq
INF = 10**15
n = int(eval(input()))
dist_mat = [[INF]*n for _ in range(n)]
edges = [[] for _ in range(n)]
for i in range(n-1):
a, b, c = list(map(int,input().split()))
a -= 1
b -= 1
dist_mat[a][b] = c
dist_mat[b][a] = c
edges[a].append(b)
edges[b].append(a)
dist_mat[i][i] = 0
q, k = list(map(int, input().split()))
k -= 1
que = [(0, k)]
heapq.heapify(que)
costs = [INF]*n
costs[k] = 0
while len(que) > 0:
dist, current = heapq.heappop(que)
for edge in edges[current]:
if costs[edge] > costs[current] + dist_mat[current][edge]:
costs[edge] = costs[current] + dist_mat[current][edge]
heapq.heappush(que, (costs[edge], edge))
res = []
for _ in range(q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
res.append(costs[x]+costs[y])
for ans in res:
print(ans)
| import sys
sys.setrecursionlimit(10**9)
n = int(eval(input()))
edges = [[] for _ in range(n)]
costs = [-1]*n
def dfs(current):
for nex, cost in edges[current]:
if costs[nex] != -1:
continue
costs[nex] = costs[current] + cost
dfs(nex)
for i in range(n-1):
a, b, c = list(map(int,input().split()))
a -= 1
b -= 1
edges[a].append((b, c))
edges[b].append((a, c))
q, k = list(map(int, input().split()))
k -= 1
costs[k] = 0
dfs(k)
res = []
for _ in range(q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
res.append(costs[x]+costs[y])
for ans in res:
print(ans)
| p03634 |
from collections import deque
n=int(eval(input()))
tree=[[] for _ in range(n)]
for i in range(n-1):
a,b,c=list(map(int,input().split()))
tree[a-1].append([b-1,c])
tree[b-1].append([a-1,c])
q,k=list(map(int,input().split()))
dis=[-1 for i in range(n)]
dis[k-1]=0
que=deque()
que.append(k-1)
while que:
x=que.popleft()
for i,c in tree[x]:
if dis[i]==-1:
que.append(i)
dis[i]=dis[x]+c
for i in range(q):
x,y=list(map(int,input().split()))
print((dis[x-1]+dis[y-1])) | n=int(eval(input()))
g=[[] for i in range(n)]
for _ in range(n-1):
u,v,c=list(map(int,input().split()))
g[u-1].append((v-1,c))
g[v-1].append((u-1,c))
Q,k=list(map(int,input().split()))
d=[-1]*n
d[k-1]=0
q=[k-1]
while q:
t=q.pop()
for x,cost in g[t]:
if d[x]==-1:
d[x]=d[t]+cost
q.append(x)
for _ in range(Q):
x,y=list(map(int,input().split()))
print((d[x-1]+d[y-1])) | p03634 |
import queue
n = int(eval(input()))
my_dict = dict()
mtx = [[0] * n for _ in range(n)]
for i in range(n-1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
if a in my_dict:
my_dict[a].append(b)
else:
my_dict[a] = [b]
if b in my_dict:
my_dict[b].append(a)
else:
my_dict[b] = [a]
mtx[a][b] = c
mtx[b][a] = c
qu, k = list(map(int, input().split()))
ret_dict = dict()
visited = set()
q = queue.Queue()
q.put((k-1, 0))
visited.add(k-1)
while not q.empty():
ptr, length = q.get()
if ptr in my_dict:
for item in my_dict[ptr]:
if item not in visited:
q.put((item, length + mtx[ptr][item]))
ret_dict[item] = length + mtx[ptr][item]
visited.add(item)
for i in range(qu):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
print((ret_dict[x] + ret_dict[y]))
| import queue
n = int(eval(input()))
my_dict = dict()
mtx = dict()
for i in range(n-1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
if a in my_dict:
my_dict[a].append(b)
else:
my_dict[a] = [b]
if b in my_dict:
my_dict[b].append(a)
else:
my_dict[b] = [a]
mtx[(a, b)] = c
mtx[(b, a)] = c
qu, k = list(map(int, input().split()))
ret_dict = dict()
visited = set()
q = queue.Queue()
q.put((k-1, 0))
visited.add(k-1)
while not q.empty():
ptr, length = q.get()
if ptr in my_dict:
for item in my_dict[ptr]:
if item not in visited:
q.put((item, length + mtx[(ptr, item)]))
ret_dict[item] = length + mtx[(ptr, item)]
visited.add(item)
for i in range(qu):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
print((ret_dict[x] + ret_dict[y]))
| p03634 |
n = int(eval(input()))
edge = []
for _ in range(n-1):
a,b,c = list(map(int,input().split()))
edge.append([a-1,b-1,c])
q, k = list(map(int,input().split()))
querry = []
for _ in range(q):
x,y = list(map(int,input().split()))
querry.append([x-1,y-1])
class Graph():
def __init__(self,n,edge):
self.n = n
self.graph = [[0]*n for _ in range(n)]
self.edge = edge
self.ed_list = [[] for _ in range(n)]
for a,b,c in edge:
self.ed_list[a].append([b,c])
self.ed_list[b].append([a,c])
def dijkstra(self,start):
INF = float('inf')
cost = [INF]*self.n
cost[start] = 0
from heapq import heappop,heappush
stack = [[0, start]]
while stack:
c, x = heappop(stack)
for to,j in self.ed_list[x]:
if cost[to] > j + c:
cost[to] = j + c
heappush(stack,[j + c, to])
return cost
gp = Graph(n,edge)
cost = gp.dijkstra(k-1)
for i,j in querry:
print((cost[i] + cost[j]))
| n = int(eval(input()))
edge = []
for _ in range(n-1):
a,b,c = list(map(int,input().split()))
edge.append([a-1,b-1,c])
q, k = list(map(int,input().split()))
querry = []
for _ in range(q):
x,y = list(map(int,input().split()))
querry.append([x-1,y-1])
class Graph():
def __init__(self,n,edge):
self.n = n
self.edge = edge
self.ed_list = [[] for _ in range(n)]
for a,b,c in edge:
self.ed_list[a].append([b,c])
self.ed_list[b].append([a,c])
def dijkstra(self,start):
INF = float('inf')
cost = [INF]*self.n
cost[start] = 0
from heapq import heappop,heappush
stack = [[0, start]]
while stack:
c, x = heappop(stack)
for to,j in self.ed_list[x]:
if cost[to] > j + c:
cost[to] = j + c
heappush(stack,[j + c, to])
return cost
gp = Graph(n,edge)
cost = gp.dijkstra(k-1)
for i,j in querry:
print((cost[i] + cost[j]))
| p03634 |
N = int(eval(input()))
edge = [[] for i in range(N)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
edge[a-1].append([c, b-1])
edge[b-1].append([c, a-1])
Q, K = list(map(int, input().split()))
query = [list(map(int, input().split())) for _ in range(Q)]
import heapq
def dijkstra_heap(s):
d = [float('inf')] * N
used = [False] * N
d[s] = 0
used[s] = True
edgelist = []
for e in edge[s]:
heapq.heappush(edgelist, e)
while len(edgelist):
min_edge = heapq.heappop(edgelist)
if used[min_edge[1]]:
continue
v = min_edge[1]
d[v] = min_edge[0]
used[v] = True
for e in edge[v]:
heapq.heappush(edgelist, [e[0] + d[v], e[1]])
return d
for q in query:
x, y = q[0], q[1]
x -= 1
y -= 1
dist = dijkstra_heap(K-1)
print((dist[x] + dist[y])) | N = int(eval(input()))
edge = [[] for i in range(N)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
edge[a-1].append([c, b-1])
edge[b-1].append([c, a-1])
Q, K = list(map(int, input().split()))
query = [list(map(int, input().split())) for _ in range(Q)]
import heapq
def dijkstra_heap(s):
d = [float('inf')] * N
used = [False] * N
d[s] = 0
used[s] = True
edgelist = []
for e in edge[s]:
heapq.heappush(edgelist, e)
while len(edgelist):
min_edge = heapq.heappop(edgelist)
if used[min_edge[1]]:
continue
v = min_edge[1]
d[v] = min_edge[0]
used[v] = True
for e in edge[v]:
heapq.heappush(edgelist, [e[0] + d[v], e[1]])
return d
dist = dijkstra_heap(K-1)
for q in query:
x, y = q[0], q[1]
x -= 1
y -= 1
print((dist[x] + dist[y])) | p03634 |
from collections import deque
def dfs(neigh,K):
q = deque()
q.append(K)
visited = [False]*N
d = [0]*N
visited[K] = True
while len(q)>0:
p = q.pop()
for i in range(len(neigh[p])):
if neigh[p][i]==0 or visited[i]:
continue
d[i] = d[p]+neigh[p][i]
visited[i] = True
q.append(i)
return d
N = int(eval(input()))
neigh = [[0 for i in range(N)] for i in range(N)]
for i in range(N-1):
a,b,c = list(map(int,input().split()))
neigh[a-1][b-1] = c
neigh[b-1][a-1] = c
Q,K = list(map(int,input().split()))
d = dfs(neigh,K-1)
for i in range(Q):
x,y = list(map(int,input().split()))
print((d[x-1]+d[y-1]))
| from collections import deque
def dfs(neigh,K):
q = deque([K])
d = [0]*N
visited = [0]*N
visited[K] = True
while q:
p = q.pop()
for di,cost in neigh[p]:
if visited[di]:
continue
d[di] = d[p]+cost
visited[di] = True
q.append(di)
return d
N = int(eval(input()))
neigh = [[] for i in range(N)]
for i in range(N-1):
a,b,c = list(map(int,input().split()))
neigh[a-1].append((b-1,c))
neigh[b-1].append((a-1,c))
Q,K = list(map(int,input().split()))
d = dfs(neigh,K-1)
for i in range(Q):
x,y = list(map(int,input().split()))
print((d[x-1]+d[y-1]))
| p03634 |
import heapq
def dijkstra(V, edges, s):
inf=float('inf')
dist=[inf]*V
dist[s]=0
que=[[0,s]]
heapq.heapify(que) #最小値を管理 [dist[i],i]となる要素
while que:
p=heapq.heappop(que) #距離が最小のものを取り出す
dis=p[0]
v=p[1]
if dist[v] <dis:
continue
for edge in edges[v]:
to_v=edge[0]
cost=edge[1]
if dist[to_v] > dist[v] + cost:
dist[to_v]=dist[v]+cost
heapq.heappush(que,[dist[to_v], to_v])
return dist
def main():
n=int(eval(input()))
edges=[[] for _ in range(n)]
for i in range(n-1):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
edges[a].append([b,c])
edges[b].append([a,c])
q,k=list(map(int,input().split()))
k-=1
dist=dijkstra(n,edges,k)
for i in range(q):
x,y=list(map(int,input().split()))
x-=1
y-=1
print((dist[x]+dist[y]))
if __name__=='__main__':
main() | import heapq
def dijkstra(V, edges, s):
inf=float('inf')
dist=[inf]*V
dist[s]=0
que=[[0,s]]
heapq.heapify(que) #最小値を管理 [dist[i],i]となる要素
while que:
p=heapq.heappop(que) #距離が最小のものを取り出す
dis=p[0]
v=p[1]
if dist[v] <dis:
continue
for edge in edges[v]:
to_v=edge[0]
cost=edge[1]
if dist[to_v] > dist[v] + cost:
dist[to_v]=dist[v]+cost
heapq.heappush(que,[dist[to_v], to_v])
return dist
def main():
import sys
input=sys.stdin.readline
n=int(eval(input()))
edges=[[] for _ in range(n)]
for i in range(n-1):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
edges[a].append([b,c])
edges[b].append([a,c])
q,k=list(map(int,input().split()))
k-=1
dist=dijkstra(n,edges,k)
for i in range(q):
x,y=list(map(int,input().split()))
x-=1
y-=1
print((dist[x]+dist[y]))
if __name__=='__main__':
main() | p03634 |
import heapq
def dijkstra(V, edges, s):
inf=float('inf')
dist=[inf]*V
dist[s]=0
que=[[0,s]]
heapq.heapify(que) #最小値を管理 [dist[i],i]となる要素
while que:
p=heapq.heappop(que) #距離が最小のものを取り出す
dis=p[0]
v=p[1]
if dist[v] <dis:
continue
for edge in edges[v]:
to_v=edge[0]
cost=edge[1]
if dist[to_v] > dist[v] + cost:
dist[to_v]=dist[v]+cost
heapq.heappush(que,[dist[to_v], to_v])
return dist
def main():
import sys
input=sys.stdin.readline
n=int(eval(input()))
edges=[[] for _ in range(n)]
for i in range(n-1):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
edges[a].append([b,c])
edges[b].append([a,c])
q,k=list(map(int,input().split()))
k-=1
dist=dijkstra(n,edges,k)
for i in range(q):
x,y=list(map(int,input().split()))
x-=1
y-=1
print((dist[x]+dist[y]))
if __name__=='__main__':
main() | def main():
import sys
input=sys.stdin.readline
sys.setrecursionlimit(1000000)
n=int(eval(input()))
edges=[[] for _ in range(n)]
for i in range(n-1):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
edges[a].append([b,c])
edges[b].append([a,c])
q,k=list(map(int,input().split()))
k-=1
dist=[10**9+1]*n
dist[k]=0
def dfs(s,before=-1):
for edge in edges[s]:
to=edge[0]
c=edge[1]
if to!=before:
dist[to]=dist[s]+c
dfs(to,s)
dfs(k)
for i in range(q):
x,y=list(map(int,input().split()))
x-=1
y-=1
print((dist[x]+dist[y]))
if __name__=='__main__':
main() | p03634 |
import queue
N=int(eval(input()))
G=[dict() for i in range(N)]
for i in range(N-1):
a,b,c=list(map(int,input().split()))
G[a-1][b-1]=c
G[b-1][a-1]=c
Q,K=list(map(int,input().split()));K-=1
x=[0 for i in range(Q)]
y=[0 for i in range(Q)]
for i in range(Q):
x[i],y[i]=list(map(int,input().split()))
x[i]-=1
y[i]-=1
q=queue.Queue()
q.put(K)
dist=[-1 for i in range(N)]
dist[K]=0
while(not(q.empty())):
r=q.get()
for p in G[r]:
if dist[p]!=-1:
continue
dist[p]=dist[r]+G[p][r]
q.put(p)
for i in range(Q):
print((dist[x[i]]+dist[y[i]]))
| import queue
N=int(eval(input()))
G=[dict() for i in range(N)]
for i in range(N-1):
a,b,c=list(map(int,input().split()))
G[a-1][b-1]=c
G[b-1][a-1]=c
Q,K=list(map(int,input().split()));K-=1
x=[0 for i in range(Q)]
y=[0 for i in range(Q)]
for i in range(Q):
x[i],y[i]=list(map(int,input().split()))
x[i]-=1
y[i]-=1
q=[]
q.append(K)
dist=[-1 for i in range(N)]
dist[K]=0
while(len(q)>0):
r=q[-1]
q.pop()
for p in G[r]:
if dist[p]!=-1:
continue
dist[p]=dist[r]+G[p][r]
q.append(p)
for i in range(Q):
print((dist[x[i]]+dist[y[i]]))
| p03634 |
# bellman_fordは重いのでTLE
from collections import namedtuple
import sys
input = sys.stdin.readline
def solve():
inf = 10 ** 14 + 10
Edge = namedtuple('Edge', 'cost from_ to')
def bellman_ford(s):
# 始点sから各頂点への最短距離
# O(VE) <- dijkstraならO(E log V)だが負辺は無理
dist = [inf] * n
dist[s] = 0
while True:
update = False
for e_ in e:
if dist[e_.from_] != inf and dist[e_.to] > dist[e_.from_] + e_.cost:
dist[e_.to] = dist[e_.from_] + e_.cost
update = True
if not update:
break
return dist
n = int(eval(input()))
e = set()
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
e.add(Edge(cost=c, from_=a, to=b))
e.add(Edge(cost=c, from_=b, to=a))
q, v = list(map(int, input().split()))
v -= 1
d = bellman_ford(v)
for _ in range(q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
print((d[x] + d[y]))
if __name__ == '__main__':
solve()
| # bellman_ford : O(V E)
# dijkstra : O(E log V), 負辺は無理
# warshall_floyd : O(V**3)
from collections import namedtuple
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
def solve():
inf = 10 ** 14 + 10
Edge = namedtuple('Edge', 'cost to')
def dfs(v: 'vertex_index, 0-indexed') -> None:
for e_ in e[v]:
if d[e_.to] != inf:
continue
d[e_.to] = d[v] + e_.cost
dfs(e_.to)
n = int(eval(input()))
e = tuple(set() for _ in range(n))
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
e[a].add(Edge(cost=c, to=b))
e[b].add(Edge(cost=c, to=a))
q, v = list(map(int, input().split()))
v -= 1
d = [inf] * n
d[v] = 0
dfs(v)
for _ in range(q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
print((d[x] + d[y]))
if __name__ == '__main__':
solve()
| p03634 |
# bellman_ford : O(V E)
# dijkstra : O(E log V), 負辺は無理
# warshall_floyd : O(V**3)
from collections import namedtuple
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
def solve():
inf = 10 ** 14 + 10
Edge = namedtuple('Edge', 'cost to')
def dfs(v: 'vertex_index, 0-indexed') -> None:
for e_ in e[v]:
if d[e_.to] != inf:
continue
d[e_.to] = d[v] + e_.cost
dfs(e_.to)
n = int(eval(input()))
e = tuple(set() for _ in range(n))
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
e[a].add(Edge(cost=c, to=b))
e[b].add(Edge(cost=c, to=a))
q, v = list(map(int, input().split()))
v -= 1
d = [inf] * n
d[v] = 0
dfs(v)
for _ in range(q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
print((d[x] + d[y]))
if __name__ == '__main__':
solve()
| # bellman_ford : O(V E)
# dijkstra : O(E log V), 負辺は無理
# warshall_floyd : O(V**3)
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
def solve():
inf = 10 ** 14 + 10
def dfs(v: 'vertex_index, 0-indexed') -> None:
for c, t in e[v]:
if d[t] != inf:
continue
d[t] = d[v] + c
dfs(t)
n = int(eval(input()))
e = tuple(set() for _ in range(n))
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
e[a].add((c, b))
e[b].add((c, a))
q, v = list(map(int, input().split()))
v -= 1
d = [inf] * n
d[v] = 0
dfs(v)
for _ in range(q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
print((d[x] + d[y]))
if __name__ == '__main__':
solve()
| p03634 |
def dijkstra(s,n,w,cost):
#始点sから各頂点への最短距離
#n:頂点数, w:辺の数, cost[u][v] : 辺uvのコスト(存在しないときはinf)
d = [float("inf")] * n
used = [False] * n
d[s] = 0
while True:
v = -1
#まだ使われてない頂点の中から最小の距離のものを探す
for i in range(n):
if (not used[i]) and (v == -1):
v = i
elif (not used[i]) and d[i] < d[v]:
v = i
if v == -1:
break
used[v] = True
for j in range(n):
d[j] = min(d[j],d[v]+cost[v][j])
return d
N = int(eval(input()))
cost = [[float("inf") for i in range(N)] for i in range(N)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
cost[a-1][b-1] = c
cost[b-1][a-1] = c
Q, K = list(map(int, input().split()))
ans = dijkstra(K-1, N, N-1, cost)
for i in range(Q):
x, y = list(map(int, input().split()))
print((ans[x-1] + ans[y-1])) | import sys
sys.setrecursionlimit(10**7)
N = int(eval(input()))
tree = [[] for _ in range(N)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
tree[a-1].append([b-1, c])
tree[b-1].append([a-1, c])
Q, K = list(map(int, input().split()))
dist = [-1] * N
def dfs(v, total_cost):
# v：頂点, total_cost：今までかかったコストの合計
dist[v] = total_cost
for v_next, cost in tree[v]:
if dist[v_next] >= 0:
continue
# v_nextが訪問済みならスキップ
dfs(v_next, total_cost+cost)
dfs(K-1, 0)
for i in range(Q):
x, y = list(map(int, input().split()))
print((dist[x-1] + dist[y-1]))
| p03634 |
N = int(eval(input()))
edges = {}
for _ in range(N-1):
a, b, c = list(map(int, input().split()))
edges[(a, b)] = c
edges[(b, a)] = c
Q, K = list(map(int, input().split()))
xy = []
for _ in range(Q):
xy.append(tuple(map(int, input().split())))
d = [10**14] * (N+1)
d[K] = 0
for n in range(N):
for e in edges:
if d[e[0]] > d[e[1]] + edges[e]:
d[e[0]] = d[e[1]] + edges[e]
for x, y in xy:
print((d[x] + d[y]))
| import sys
sys.setrecursionlimit(100005)
N = int(eval(input()))
edges = {n: [] for n in range(N+1)}
for _ in range(N-1):
a, b, c = list(map(int, input().split()))
edges[a].append((b, c))
edges[b].append((a, c))
Q, K = list(map(int, input().split()))
xy = []
for _ in range(Q):
xy.append(tuple(map(int, input().split())))
d = [-1] * (N+1)
d[K] = 0
def dfs(n: int):
for m, c in edges[n]:
if d[m] == -1:
d[m] = d[n] + c
dfs(m)
dfs(K)
for x, y in xy:
print((d[x] + d[y])) | p03634 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
"""
def gcd(a,b):
if a == 0:
return b
return gcd(b%a,a)
n = I()
a = IR(n)
l = a[0]
for i in range(1,n):
g = gcd(l,a[i])
l *= a[i]//g
print(l)
"""
#B
def dijkstra(k):
d[k] = 0
q = [[0,k]]
while q:
dx,x = heappop(q)
for y,c in v[x]:
if d[y] > dx+c:
d[y] = dx+c
heappush(q,[d[y],y])
n = I()
v = [[] for i in range(n)]
for i in range(n-1):
a,b,c = LI()
a -= 1
b -= 1
v[a].append([b,c])
v[b].append([a,c])
q,k = LI()
d = [float("inf") for i in range(n)]
dijkstra(k-1)
for i in range(q):
x,y = LI()
x -= 1
y -= 1
print((d[x]+d[y]))
#C
#D
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
| #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
"""
def gcd(a,b):
if a == 0:
return b
return gcd(b%a,a)
n = I()
a = IR(n)
l = a[0]
for i in range(1,n):
g = gcd(l,a[i])
l *= a[i]//g
print(l)
"""
#B
n = I()
v = [[] for i in range(n)]
for i in range(n-1):
a,b,c = LI()
a -= 1
b -= 1
v[a].append([b,c])
v[b].append([a,c])
Q,k = LI()
d = [-1 for i in range(n)]
d[k-1] = 0
q = deque()
q.append(k-1)
while q:
x = q.pop()
for y,c in v[x]:
if d[y] == -1:
d[y] = d[x]+c
q.append(y)
for i in range(Q):
x,y = LI()
x -= 1
y -= 1
print((d[x]+d[y]))
#C
#D
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
| p03634 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
"""
def gcd(a,b):
if a == 0:
return b
return gcd(b%a,a)
n = I()
a = IR(n)
l = a[0]
for i in range(1,n):
g = gcd(l,a[i])
l *= a[i]//g
print(l)
"""
#B
n = I()
v = [[] for i in range(n)]
for i in range(n-1):
a,b,c = LI()
a -= 1
b -= 1
v[a].append([b,c])
v[b].append([a,c])
Q,k = LI()
d = [-1 for i in range(n)]
d[k-1] = 0
q = deque()
q.append(k-1)
while q:
x = q.pop()
for y,c in v[x]:
if d[y] == -1:
d[y] = d[x]+c
q.append(y)
for i in range(Q):
x,y = LI()
x -= 1
y -= 1
print((d[x]+d[y]))
#C
#D
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
| #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
"""
def gcd(a,b):
if a == 0:
return b
return gcd(b%a,a)
n = I()
a = IR(n)
l = a[0]
for i in range(1,n):
g = gcd(l,a[i])
l *= a[i]//g
print(l)
"""
#B
n = I()
v = [[] for i in range(n)]
for i in range(n-1):
a,b,c = LI()
a -= 1
b -= 1
v[a].append([b,c])
v[b].append([a,c])
Q,k = LI()
d = [-1 for i in range(n)]
d[k-1] = 0
q = deque()
q.append(k-1)
while q:
x = q.popleft()
for y,c in v[x]:
if d[y] == -1:
d[y] = d[x]+c
q.append(y)
for i in range(Q):
x,y = LI()
x -= 1
y -= 1
print((d[x]+d[y]))
#C
#D
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
| p03634 |
# -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/abc070/editorial.pdf
・公式解が再帰だったのでやってみる
"""
import sys
# 再帰呼び出しの回数制限(デフォルト1000)
sys.setrecursionlimit(10 ** 9)
from heapq import heappop, heappush
N = int(eval(input()))
nodes = [[] for _ in range(N+1)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
# nodes[出発ノード](到着ノード, コスト))
nodes[a].append((b, c))
# 無向グラフなのでこっちも入れる
nodes[b].append((a, c))
memo = [0] * (N+1)
def dfs(cur, prev, dist):
memo[cur] = dist
for nxt, cost in nodes[cur]:
if nxt == prev:
continue
dfs(nxt, cur, dist+cost)
Q, K = list(map(int, input().split()))
dfs(K, -1, 0)
for i in range(Q):
x, y = list(map(int, input().split()))
# 今回は全てKを経由するので、Kからの距離さえ分かれば全部出る
print((memo[x] + memo[y]))
| # -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/abc070/editorial.pdf
・公式解が再帰だったのでやってみる
"""
import sys
# 再帰呼び出しの回数制限(デフォルト1000)
sys.setrecursionlimit(10 ** 9)
N = int(eval(input()))
nodes = [[] for _ in range(N+1)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
# nodes[出発ノード](到着ノード, コスト))
nodes[a].append((b, c))
# 無向グラフなのでこっちも入れる
nodes[b].append((a, c))
memo = [0] * (N+1)
def dfs(cur, prev, dist):
memo[cur] = dist
for nxt, cost in nodes[cur]:
if nxt == prev:
continue
dfs(nxt, cur, dist+cost)
Q, K = list(map(int, input().split()))
dfs(K, -1, 0)
for i in range(Q):
x, y = list(map(int, input().split()))
# 今回は全てKを経由するので、Kからの距離さえ分かれば全部出る
print((memo[x] + memo[y]))
| p03634 |
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
from heapq import heappop, heappush
# 今回はダイクストラするので、データの持ち方は隣接リスト
N = int(eval(input()))
nodes = [[] for _ in range(N+1)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
# nodes[出発ノード](到着ノード, コスト))
nodes[a].append((b, c))
# 無向グラフなのでこっちも入れる
nodes[b].append((a, c))
def dijkstra(nodes, start):
# 最短距離メモ
memo = [float('inf')] * (len(nodes))
# スタート位置
que = [(0, start)]
memo[start] = 0
# キューが空になるまで
while len(que) != 0:
# startからの距離, 現在のノード
dist, cur = heappop(que)
# 出発ノードcurの到着ノードでループ
for nxt, cost in nodes[cur]:
# 今回の経路のが短い時
if memo[cur] + cost < memo[nxt]:
memo[nxt] = memo[cur] + cost
# 現在の移動距離をキューの優先度として、早い方から先に処理するようにする
heappush(que, (memo[nxt], nxt))
# ノードstartからの最短距離リストを返却
return memo
Q, K = list(map(int, input().split()))
# 引数：(ノードの隣接リスト, 出発ノード)
memo = dijkstra(nodes, K)
for i in range(Q):
x, y = list(map(int, input().split()))
# 今回は全てKを経由するので、Kからの距離さえ分かれば全部出る
print((memo[x] + memo[y]))
| # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
# 再帰呼び出しの回数制限(デフォルト1000)
sys.setrecursionlimit(10 ** 9)
N = int(eval(input()))
nodes = [[] for _ in range(N+1)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
# nodes[出発ノード](到着ノード, コスト))
nodes[a].append((b, c))
# 無向グラフなのでこっちも入れる
nodes[b].append((a, c))
memo = [0] * (N+1)
def dfs(cur, prev, dist):
memo[cur] = dist
for nxt, cost in nodes[cur]:
if nxt == prev:
continue
dfs(nxt, cur, dist+cost)
Q, K = list(map(int, input().split()))
dfs(K, -1, 0)
for i in range(Q):
x, y = list(map(int, input().split()))
# 今回は全てKを経由するので、Kからの距離さえ分かれば全部出る
print((memo[x] + memo[y]))
| p03634 |
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def dijkstra(N: int, nodes: list, src: int) -> list:
""" ダイクストラ高速化版(頂点数, 隣接リスト(0-indexed), 始点) """
from heapq import heappush, heappop
# 頂点[ある始点からの最短距離]
res = [INF] * N
# スタート位置
que = [src]
res[src] = 0
# キューが空になるまで
while len(que) != 0:
# 距離*N + 現在のノード
cur = heappop(que)
# 距離とノードに分ける
dist = cur // N
cur %= N
# 出発ノードcurの到着ノードでループ
for nxt, cost in nodes[cur]:
# 今回の経路のが短い時
if dist + cost < res[nxt]:
res[nxt] = dist + cost
# 距離*N+ノード番号 の形でキューに詰める
heappush(que, (dist+cost)*N+nxt)
# ノードsrcからの最短距離リストを返却
return res
N = INT()
nodes = [[] for i in range(N)]
for i in range(N-1):
a, b, c = MAP()
a -= 1; b -= 1
nodes[a].append((b, c))
nodes[b].append((a, c))
Q, K = MAP()
K -= 1
res = dijkstra(N, nodes, K)
for i in range(Q):
x, y = MAP()
x -= 1; y -= 1
ans = res[x] + res[y]
print(ans)
| # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def dfs(N, nodes, src):
""" DFS(木、スタック、重みあり) """
stack = [(src, -1, 0)]
dist = [INF] * N
while stack:
u, prev, c1 = stack.pop()
dist[u] = c1
for v, c2 in nodes[u]:
if v != prev:
stack.append((v, u, c1+c2))
return dist
N = INT()
nodes = [[] for i in range(N)]
for i in range(N-1):
a, b, c = MAP()
a -= 1; b -= 1
nodes[a].append((b, c))
nodes[b].append((a, c))
Q, K = MAP()
K -= 1
res = dfs(N, nodes, K)
for i in range(Q):
x, y = MAP()
x -= 1; y -= 1
ans = res[x] + res[y]
print(ans)
| p03634 |
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def dfs(N, nodes, src):
""" DFS(木、スタック、重みあり) """
stack = [(src, -1, 0)]
dist = [INF] * N
while stack:
u, prev, c1 = stack.pop()
dist[u] = c1
for v, c2 in nodes[u]:
if v != prev:
stack.append((v, u, c1+c2))
return dist
N = INT()
nodes = [[] for i in range(N)]
for i in range(N-1):
a, b, c = MAP()
a -= 1; b -= 1
nodes[a].append((b, c))
nodes[b].append((a, c))
Q, K = MAP()
K -= 1
res = dfs(N, nodes, K)
for i in range(Q):
x, y = MAP()
x -= 1; y -= 1
ans = res[x] + res[y]
print(ans)
| # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def dfs(N, nodes, src):
""" DFS(木、スタック、重みあり) """
stack = [(src, -1, 0)]
dist = [INF] * N
while stack:
u, prev, c1 = stack.pop()
dist[u] = c1
for v, c2 in nodes[u]:
if v != prev:
stack.append((v, u, c1+c2))
return dist
N = INT()
nodes = [[] for i in range(N)]
for i in range(N-1):
a, b, c = MAP()
a -= 1; b -= 1
nodes[a].append((b, c))
nodes[b].append((a, c))
Q, K = MAP()
K -= 1
res = dfs(N, nodes, K)
ans = []
for i in range(Q):
x, y = MAP()
x -= 1; y -= 1
ans.append(str(res[x] + res[y]))
print(('\n'.join(ans)))
| p03634 |
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def dfs(N, nodes, src):
""" DFS(木、スタック、重みあり) """
stack = [(src, -1, 0)]
dist = [INF] * N
while stack:
u, prev, c1 = stack.pop()
dist[u] = c1
for v, c2 in nodes[u]:
if v != prev:
stack.append((v, u, c1+c2))
return dist
N = INT()
nodes = [[] for i in range(N)]
for i in range(N-1):
a, b, c = MAP()
a -= 1; b -= 1
nodes[a].append((b, c))
nodes[b].append((a, c))
Q, K = MAP()
K -= 1
res = dfs(N, nodes, K)
ans = []
for i in range(Q):
x, y = MAP()
x -= 1; y -= 1
ans.append(str(res[x] + res[y]))
print(('\n'.join(ans)))
| # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def dfs(N, nodes, src):
""" DFS(木、スタック、重みあり) """
stack = [(src, -1, 0)]
dist = [INF] * N
while stack:
u, prev, c1 = stack.pop()
dist[u] = c1
for v, c2 in nodes[u]:
if v != prev:
stack.append((v, u, c1+c2))
return dist
N = INT()
nodes = [[] for i in range(N)]
for i in range(N-1):
a, b, c = MAP()
a -= 1; b -= 1
nodes[a].append((b, c))
nodes[b].append((a, c))
Q, K = MAP()
K -= 1
res = dfs(N, nodes, K)
for i in range(Q):
x, y = MAP()
x -= 1; y -= 1
ans = res[x] + res[y]
print(ans)
| p03634 |
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def dfs(N, nodes, src):
""" DFS(木、スタック、重みあり) """
stack = [(src, -1, 0)]
dist = [INF] * N
while stack:
u, prev, c1 = stack.pop()
dist[u] = c1
for v, c2 in nodes[u]:
if v != prev:
stack.append((v, u, c1+c2))
return dist
N = INT()
nodes = [[] for i in range(N)]
for i in range(N-1):
a, b, c = MAP()
a -= 1; b -= 1
nodes[a].append((b, c))
nodes[b].append((a, c))
Q, K = MAP()
K -= 1
res = dfs(N, nodes, K)
for i in range(Q):
x, y = MAP()
x -= 1; y -= 1
ans = res[x] + res[y]
print(ans)
| # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def dfs(N, nodes, src):
""" DFS(木、スタック、重みあり) """
stack = [(src, -1, 0)]
dist = [INF] * N
while stack:
u, prev, c1 = stack.pop()
dist[u] = c1
for v, c2 in nodes[u]:
if v != prev:
stack.append((v, u, c1+c2))
return dist
N = INT()
nodes = [[] for i in range(N)]
for i in range(N-1):
a, b, c = MAP()
a -= 1; b -= 1
nodes[a].append((b, c))
nodes[b].append((a, c))
Q, K = MAP()
K -= 1
res = dfs(N, nodes, K)
ans = []
for i in range(Q):
x, y = MAP()
x -= 1; y -= 1
ans.append(str(res[x] + res[y]))
print(('\n'.join(ans)))
| p03634 |
import sys
sys.setrecursionlimit(2147483647)
n=int(eval(input()))
c={}
tree=[[] for _ in range(n)]
for _ in range(n-1):
i,j,k=list(map(int,input().split()))
i-=1
j-=1
tree[i].append(j)
tree[j].append(i)
c[(i,j)]=k
c[(j,i)]=k
result=[]
q,k=list(map(int,input().split()))
#初期値が0の辞書
from collections import defaultdict
memo = defaultdict(lambda: -1)
def DEF(z,cnt):
global memo,tree,c
memo[z]=cnt
for item in tree[z]:
if memo[item]==-1:
DEF(item,cnt+c[(item,z)])
DEF(k-1,0)
result=[]
for item in range(q):
a,b=list(map(int,input().split()))
result.append(memo[a-1]+memo[b-1])
for item in result:
print(item)
| import sys
sys.setrecursionlimit(2147483647)
n=int(eval(input()))
c={}
tree=[[] for _ in range(n)]
for _ in range(n-1):
i,j,k=list(map(int,input().split()))
i-=1
j-=1
tree[i].append(j)
tree[j].append(i)
c[(i,j)]=k
c[(j,i)]=k
result=[]
q,k=list(map(int,input().split()))
memo=[-1]*n
def DEF(z,cnt):
global memo,tree,c
memo[z]=cnt
for item in tree[z]:
if memo[item]==-1:
DEF(item,cnt+c[(item,z)])
DEF(k-1,0)
result=[]
for item in range(q):
a,b=list(map(int,input().split()))
result.append(memo[a-1]+memo[b-1])
for item in result:
print(item)
| p03634 |
import sys
sys.setrecursionlimit(2147483647)
n=int(eval(input()))
c={}
tree=[[] for _ in range(n)]
for _ in range(n-1):
i,j,k=list(map(int,input().split()))
i-=1
j-=1
tree[i].append(j)
tree[j].append(i)
c[(i,j)]=k
c[(j,i)]=k
result=[]
q,k=list(map(int,input().split()))
memo=[-1]*n
def DEF(z,cnt):
global memo,tree,c
memo[z]=cnt
for item in tree[z]:
if memo[item]==-1:
DEF(item,cnt+c[(item,z)])
DEF(k-1,0)
result=[]
for item in range(q):
a,b=list(map(int,input().split()))
result.append(memo[a-1]+memo[b-1])
for item in result:
print(item)
| import sys
sys.setrecursionlimit(2147483647)
n=int(eval(input()))
c={}
tree=[set([]) for _ in range(n)]
for _ in range(n-1):
i,j,k=list(map(int,input().split()))
i-=1
j-=1
tree[i].add(j)
tree[j].add(i)
c[(min(i,j),max(i,j))]=k
result=[]
q,k=list(map(int,input().split()))
memo=[-1]*n
def DEF(z,cnt):
global memo,tree,c
memo[z]=cnt
for item in tree[z]:
if memo[item]==-1:
DEF(item,cnt+c[(min(item,z),max(item,z))])
DEF(k-1,0)
result=[]
for item in range(q):
a,b=list(map(int,input().split()))
result.append(memo[a-1]+memo[b-1])
for item in result:
print(item)
| p03634 |
def dijkstra(s, n, cost):
d = [float("inf")] * (n+1)
used = [False] * (n+1)
d[s] = 0
while True:
v = -1
for i in range(1, n+1):
if (not used[i]) and (v == -1):
v = i
elif (not used[i]) and d[i] < d[v]:
v = i
if v == -1:
break
used[v] = True
for j in range(1, n+1):
d[j] = min(d[j], d[v] + cost[v][j])
return d
n = int(eval(input()))
inf = float("inf")
cost = [[inf]*(n+1) for _ in range(n+1)]
for _ in range(n-1):
a, b, c = list(map(int, input().split()))
cost[a][b] = c
cost[b][a] = c
q, k = list(map(int, input().split()))
ans = dijkstra(k, n, cost)
for _ in range(q):
x, y = list(map(int, input().split()))
print((ans[x] + ans[y])) | n = int(eval(input()))
inf = float("inf")
tree = [[] for _ in range(n+1)]
for _ in range(n-1):
a, b, c = list(map(int, input().split()))
tree[a].append([b, c])
tree[b].append([a, c])
q, k = list(map(int, input().split()))
depth = [inf] * (n+1)
visited = [False] * (n+1)
depth[k] = 0
stack = [k]
while stack:
now = stack.pop()
visited[now] = True
for i, v in tree[now]:
if visited[i]:
pass
else:
stack.append(i)
depth[i] = min(depth[i], depth[now] + v)
for _ in range(q):
x, y = list(map(int, input().split()))
ans = depth[x] + depth[y]
print(ans) | p03634 |
from functools import reduce
import math
def main():
# 文字列の2進数を数値にする
# '101' → '5'
# 文字列の頭に'0b'をつけてint()にわたす
# binary = int('0b'+'101',0)
# 2進数で立っているbitを数える
# 101(0x5) → 2
# cnt_bit = bin(5).count('1')
# N! を求める
# f = math.factorial(N)
# N の逆元
# N_inv = pow(N,MOD-2,MOD)
# nCr
# Nの階乗 * rの階乗の逆元 * n-rの階乗の逆元
# 切り捨て
# 4 // 3
# 切り上げ
#-(-4 // 3)
# 初期値用:十分大きい数(100億)
INF = float("inf")
# 大きな素数
MOD = 10**9+7
# 1文字のみを読み込み
# 入力:2
# a = input().rstrip()
# 変数:a='2'
# スペース区切りで標準入力を配列として読み込み
# 入力:2 4 5 7
# a, b, c, d = (int(_) for _ in input().split())
# 変数:a=2 b=4 c=5 d =7
# 1文字ずつ標準入力を配列として読み込み
# 入力:2 4 5 7
# a = list(int(_) for _ in input().split())
# 変数:a = [2, 4, 5, 7]
# 1文字ずつ標準入力を配列として読み込み
# 入力:2457
# a = list(int(_) for _ in input())
# 変数:a = [2, 4, 5, 7]
N = int(eval(input()))
a = []
b = []
c = []
for i in range(N-1):
s1,s2,s3 = list(int(_) for _ in input().split())
a.append(s1-1)
b.append(s2-1)
c.append(s3)
Q,K = list(int(_) for _ in input().split())
x = []
y = []
for i in range(Q):
s1,s2 = list(int(_) for _ in input().split())
x.append(s1-1)
y.append(s2-1)
d = []
for i in range(N):
d_i = list(INF for j in range(N))
d.append(d_i)
for i in range(N):
for j in range(N):
if(i == j):
d[i][j] = 0
for i in range(N-1):
d[a[i]][b[i]] = c[i]
d[b[i]][a[i]] = c[i]
for k in range(N):
for i in range(N):
for j in range(N):
d[i][j] = min(d[i][j],d[i][k]+d[k][j])
for i in range(Q):
print((d[x[i]][K-1]+d[K-1][y[i]]))
if __name__ == '__main__':
main()
| from functools import reduce
from collections import deque
import math
def bfs(i,E,N):
q = deque()
q.append(i)
d = [-1]*N
d[i] = 0
while q:
next_node = q.popleft()
for e in E[next_node]:
if d[e[0]] == -1:
d[e[0]] = d[next_node] + e[1]
q.append(e[0])
return d
def main():
# 文字列の2進数を数値にする
# '101' → '5'
# 文字列の頭に'0b'をつけてint()にわたす
# binary = int('0b'+'101',0)
# 2進数で立っているbitを数える
# 101(0x5) → 2
# cnt_bit = bin(5).count('1')
# N! を求める
# f = math.factorial(N)
# N の逆元
# N_inv = pow(N,MOD-2,MOD)
# nCr
# Nの階乗 * rの階乗の逆元 * n-rの階乗の逆元
# 切り捨て
# 4 // 3
# 切り上げ
#-(-4 // 3)
# 初期値用:十分大きい数(100億)
INF = float("inf")
# 大きな素数
MOD = 10**9+7
# 1文字のみを読み込み
# 入力:2
# a = input().rstrip()
# 変数:a='2'
# スペース区切りで標準入力を配列として読み込み
# 入力:2 4 5 7
# a, b, c, d = (int(_) for _ in input().split())
# 変数:a=2 b=4 c=5 d =7
# 1文字ずつ標準入力を配列として読み込み
# 入力:2 4 5 7
# a = list(int(_) for _ in input().split())
# 変数:a = [2, 4, 5, 7]
# 1文字ずつ標準入力を配列として読み込み
# 入力:2457
# a = list(int(_) for _ in input())
# 変数:a = [2, 4, 5, 7]
N = int(eval(input()))
a = []
b = []
c = []
for i in range(N-1):
s1,s2,s3 = list(int(_) for _ in input().split())
a.append(s1-1)
b.append(s2-1)
c.append(s3)
Q,K = list(int(_) for _ in input().split())
x = []
y = []
for i in range(Q):
s1,s2 = list(int(_) for _ in input().split())
x.append(s1-1)
y.append(s2-1)
e = [[] for i in range(N)]
for i in range(N-1):
e[a[i]].append((b[i],c[i]))
e[b[i]].append((a[i],c[i]))
d = bfs(K-1,e,N)
for i in range(Q):
print((d[x[i]]+d[y[i]]))
if __name__ == '__main__':
main()
| p03634 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.