input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import sys
from collections import defaultdict
import heapq
import sys
def dijkstra(startvertex,V,graph):
distances=[sys.maxsize]*V
distances[startvertex]=0
heap=[(0,startvertex)]
while heap:
current_distance,current_vertex=heapq.heappop(heap)
if current_distance>distances[current_vertex]:
continue
for neighbor in range(len(graph[current_vertex])):
if graph[current_vertex][neighbor]>0:
distance=current_distance+graph[current_vertex][neighbor]
if distance<distances[neighbor]:
distances[neighbor]=distance
heapq.heappush(heap,(distance,neighbor))
return distances
n=int(eval(input()))
sys.setrecursionlimit(10**9)
graph=[[0 for i in range(n)]for j in range(n)]
for i in range(n-1):
a=[int(x) for x in input().split()]
# print(a)
graph[a[0]-1][a[1]-1]=a[2]
graph[a[1]-1][a[0]-1]=a[2]
# print(graph)
w=[int(x) for x in input().split()]
m=dijkstra(w[1]-1,n,graph)
# print(m)
c=0
for i in range(w[0]):
s=[int(x) for x in input().split()]
# print(s)
c=abs(m[s[0]-1])+abs(m[s[1]-1])
print(c) | N=int(eval(input()))
import sys
sys.setrecursionlimit(10**6)
T=[[] for _ in range(N)]
for i in range(N-1):
a,b,c=list(map(int, input().split()))
T[a-1].append((b-1,c))
T[b-1].append((a-1,c))
Q,K=list(map(int, input().split()))
D=[-1]*N
D[K-1]=0
def dfs(start, nowd):
to=T[start]
for t in to:
next_node,c=t
if D[next_node]!=-1:
continue
nextd=nowd+c
D[next_node]=nextd
dfs(next_node, nextd)
dfs(K-1,0)
# print(D)
for i in range(Q):
x,y=list(map(int, input().split()))
print((D[x-1]+D[y-1]))
| p03634 |
import sys
from collections import deque
def dfs(start, dest, pre, d):
if d[start][dest] > 0:
return d[start][dest]
for i in range(len(d)):
if d[start][i] > 0 and i != pre:
c = dfs(i, dest, start, d)
if c > 0:
return d[start][i] + dfs(i, dest, start, d)
return 0
def main():
input = sys.stdin.readline
N = int(eval(input()))
d = [[] for _ in range(N)]
for _ in range(N-1):
a, b, c = list(map(int, input().split()))
a, b = a - 1, b - 1
d[a].append((b, c))
d[b].append((a, c))
Q, K = list(map(int, input().split()))
K -= 1
k_dist = [0 for _ in range(N)]
start = deque()
start.append(K)
while len(start) > 0:
s = start.popleft()
for dest, cost in d[s]:
if k_dist[dest] > 0:
continue
k_dist[dest] = k_dist[s] + cost
start.append(dest)
for _ in range(Q):
x, y = list(map(int, input().split()))
x, y = x - 1, y - 1
print((int(k_dist[x] + k_dist[y])))
if __name__ == '__main__':
main()
| import sys
from collections import deque
def main():
input = sys.stdin.readline
N = int(eval(input()))
d = [[] for _ in range(N)]
for _ in range(N-1):
a, b, c = list(map(int, input().split()))
a, b = a - 1, b - 1
d[a].append((b, c))
d[b].append((a, c))
Q, K = list(map(int, input().split()))
K -= 1
k_dist = [0 for _ in range(N)]
start = deque()
start.append(K)
while len(start) > 0:
s = start.popleft()
for dest, cost in d[s]:
if k_dist[dest] > 0:
continue
k_dist[dest] = k_dist[s] + cost
start.append(dest)
for _ in range(Q):
x, y = list(map(int, input().split()))
print((k_dist[x-1] + k_dist[y-1]))
if __name__ == '__main__':
main()
| p03634 |
# -*- coding: utf-8 -*-
#幅優先探索
import sys
N=eval(input())
a=[[] for i in range(N+1)]
#隣接リスト
for i in range(N-1):
x,y,z=list(map(int,input().split()))
a[x].append((y,z))
a[y].append((x,z))
#print a
Q,K=list(map(int,input().split()))
b=[]
for i in range(Q):
b.append(list(map(int, input().split())))
#print b
#訪問判別フラグ
F=(N+1)*[0]
#Queue
queue=[]
#距離
dist=[0 for i in range(N+1)]
#先頭から幅優先探索
queue.append(K)
while len(queue) != 0:
#print queue
v= queue.pop(0)
#print "v::"+str(v)
if F[v]==0:
F[v]=1
for u,length in a[v]:
if F[u]==0:
queue.append(u)
dist[u]=dist[v]+length
#print dist
#print dist
for x in range(len(b)):
print(dist[ b[x][0] ]+ dist[ b[x][1] ])
| # -*- coding: utf-8 -*-
#深さ優先探索 再帰
#
import sys
sys.setrecursionlimit(200000)
N=eval(input())
a=[[] for i in range(N+1)]
#隣接リスト
for i in range(N-1):
x,y,z=list(map(int,input().split()))
a[x].append((y,z))
a[y].append((x,z))
#print a
Q,K=list(map(int,input().split()))
b=[]
for i in range(Q):
b.append(list(map(int, input().split())))
#print b
#訪問判別フラグ
F=(N+1)*[0]
#距離
dist=[0 for i in range(N+1)]
#深さ優先探索 再帰
#現在の頂点 v, v の親 p, スタート地点Kから現在の頂点vまでの距離 d
def dfs(v,p,d):
F[v]=1
dist[v]=d
for i,j in a[v]:
#頂点 v に隣接しているかつ未訪問
if F[i]==0:
#DFS(次の頂点i, 次に親となる頂点v, d+ 頂点vと頂点iの間の辺のコスト)
dfs(i,v,d+j)
dfs(K,-1,0)
for x in range(len(b)):
print(dist[ b[x][0] ]+ dist[ b[x][1] ])
| p03634 |
import sys,bisect,string,math,time,functools,random
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
def Golf():*a,=map(int,open(0))
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def GI(V,E,ls=None,Directed=False,index=0):
org_inp=[];g=[[] for i in range(V)]
FromStdin=True if ls==None else False
for i in range(E):
if FromStdin:
inp=LI()
org_inp.append(inp)
else:
inp=ls[i]
if index==0:inp[0]-=1;inp[1]-=1
if len(inp)==2:
a,b=inp;g[a].append(b)
if not Directed:g[b].append(a)
elif len(inp)==3:
a,b,c=inp;aa=(inp[0],inp[2]);bb=(inp[1],inp[2]);g[a].append(bb)
if not Directed:g[b].append(aa)
return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'#':1,'.':0}):
#h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0}) # sample usage
mp=[1]*(w+2);found={}
for i in range(h):
s=input()
for char in search:
if char in s:
found[char]=((i+1)*(w+2)+s.index(char)+1)
mp_def[char]=mp_def[replacement_of_found]
mp+=[1]+[mp_def[j] for j in s]+[1]
mp+=[1]*(w+2)
return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def bit_combination(k,n=2):
rt=[]
for tb in range(n**k):
s=[tb//(n**bt)%n for bt in range(k)];rt+=[s]
return rt
def show(*inp,end='\n'):
if show_flg:print(*inp,end=end)
YN=['YES','NO'];Yn=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
#sys.setrecursionlimit(10**7)
input=lambda: sys.stdin.readline().rstrip()
class Comb:
def __init__(self,n,mo=10**9+7):
self.fac=[0]*(n+1)
self.inv=[1]*(n+1)
self.fac[0]=1
self.fact(n)
for i in range(1,n+1):
self.fac[i]=i*self.fac[i-1]%mo
self.inv[n]*=i
self.inv[n]%=mo
self.inv[n]=pow(self.inv[n],mo-2,mo)
for i in range(1,n):
self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo
return
def fact(self,n):
return self.fac[n]
def invf(self,n):
return self.inv[n]
def comb(self,x,y):
if y<0 or y>x:
return 0
return self.fac[x]*self.inv[x-y]*self.inv[y]%mo
show_flg=False
show_flg=True
## Segment Tree ##
## Initializer Template ##
# Range Sum: sg=SegTree(n)
# Range Minimum: sg=SegTree(n,inf,min,inf)
class SegTree:
def __init__(self,n,init_val=0,function=lambda a,b:a+b,ide=0):
self.n=n
self.ide_ele=ide_ele=ide
self.num=num=2**(n-1).bit_length()
self.seg=seg=[self.ide_ele]*2*self.num
self.lazy=lazy=[self.ide_ele]*2*self.num
self.segfun=segfun=function
#set_val
for i in range(n):
self.seg[i+self.num-1]=init_val
#built
for i in range(self.num-2,-1,-1):
self.seg[i]=self.segfun(self.seg[2*i+1],self.seg[2*i+2])
def update(self,k,x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfun(self.seg[k*2+1],self.seg[k*2+2])
def evaluate(k,l,r): #遅延評価処理
if lazy[k]!=0:
node[k]+=lazy[k]
if(r-l>1):
lazy[2*k+1]+=lazy[k]//2
lazy[2*k+2]+=lazy[k]//2
lazy[k]=0
def query(self,p,q):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfun(res,self.seg[p])
if q&1 == 1:
res = self.segfun(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfun(res,self.seg[p])
else:
res = self.segfun(self.segfun(res,self.seg[p]),self.seg[q])
return res
def find_min_index(self,p,q,m):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfun(res,self.seg[p])
if q&1 == 1:
res = self.segfun(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfun(res,self.seg[p])
else:
res = self.segfun(self.segfun(res,self.seg[p]),self.seg[q])
return res
def __str__(self):
# 生配列を表示
rt=self.seg[self.num-1:self.num-1+self.n]
return str(rt)
ans=0
class Tree:
def __init__(self,inp_size=None,init=True):
if init:
self.stdin(inp_size)
return
def stdin(self,inp_size=None):
if inp_size==None:
self.size=int(input())
else:
self.size=inp_size
self.edges,_=GI(self.size,self.size-1)
return
def listin(self,ls):
self.size=len(ls)+1
self.edges,_=GI(self.size,self.size-1,ls)
return
def __str__(self):
return str(self.edges)
def dfs(self,x,func=lambda prv,nx,dist:prv+dist,root_v=0):
q=deque()
q.append(x)
v=[-1]*self.size
v[x]=root_v
while q:
c=q.pop()
for nb in self.edges[c]:
d=1
if type(nb) is not int:
nb,d=nb
if v[nb]==-1:
q.append(nb)
v[nb]=func(v[c],nb,d)
return v
def EulerTour(self,x,func=lambda x:x+1,root_v=0):
q=deque()
q.append((-1,x))
v=[None]*self.size
v[x]=root_v
et=[]
while q:
cb,ce=q.pop()
et.append(ce)
for nb in self.edges[ce]:
if v[nb]==None:
q.append((nb,ce))
q.append((ce,nb))
v[nb]=func(v[ce])
vid=[[-1,-1]for i in range(self.size)]
for i,j in enumerate(et):
if vid[j][0]==-1:
vid[j][0]=i
else:
vid[j][1]=i
return v,et,vid
def LCA_init(self,depth,et):
self.st=SegTree(self.size*2-1,func=min,ide=inf)
for i,j in enumerate(et):
self.st.update(i,j)
self.LCA_init_stat==True
return
def LCA(self,root,x,y):
if self.LCA_init_stat==False:
depth,et,vid=self.EulerTour(root)
self.LCA_init(depth,et)
return self.st.query(x,y+1)
#tr=Tree(init=False)
tr=Tree()
q,k=LI()
v=tr.dfs(k-1)#,func=lambda x,y,d:x+d)
for i in range(q):
x,y=LI_()
print(v[x]+v[y])
| import sys,bisect,string,math,time,functools,random
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
def Golf():*a,=map(int,open(0))
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def GI(V,E,ls=None,Directed=False,index=1):
org_inp=[];g=[[] for i in range(V)]
FromStdin=True if ls==None else False
for i in range(E):
if FromStdin:
inp=LI()
a,b,c=(inp+[1])[:3]
org_inp.append(inp)
else:
index=0
a,b,c=(ls[i]+[1])[:3]
if index==1:a-=1;b-=1
aa=(a,c);bb=(b,c);g[a].append(bb)
if not Directed:g[b].append(aa)
return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'#':1,'.':0}):
#h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0}) # sample usage
mp=[1]*(w+2);found={}
for i in range(h):
s=input()
for char in search:
if char in s:
found[char]=((i+1)*(w+2)+s.index(char)+1)
mp_def[char]=mp_def[replacement_of_found]
mp+=[1]+[mp_def[j] for j in s]+[1]
mp+=[1]*(w+2)
return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def bit_combination(k,n=2):
rt=[]
for tb in range(n**k):
s=[tb//(n**bt)%n for bt in range(k)];rt+=[s]
return rt
def show(*inp,end='\n'):
if show_flg:print(*inp,end=end)
YN=['YES','NO'];Yn=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
#sys.setrecursionlimit(10**7)
input=lambda: sys.stdin.readline().rstrip()
class Comb:
def __init__(self,n,mo=10**9+7):
self.fac=[0]*(n+1)
self.inv=[1]*(n+1)
self.fac[0]=1
self.fact(n)
for i in range(1,n+1):
self.fac[i]=i*self.fac[i-1]%mo
self.inv[n]*=i
self.inv[n]%=mo
self.inv[n]=pow(self.inv[n],mo-2,mo)
for i in range(1,n):
self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo
return
def fact(self,n):
return self.fac[n]
def invf(self,n):
return self.inv[n]
def comb(self,x,y):
if y<0 or y>x:
return 0
return self.fac[x]*self.inv[x-y]*self.inv[y]%mo
show_flg=False
show_flg=True
## Segment Tree ##
## Initializer Template ##
# Range Sum: sg=SegTree(n)
# Range Minimum: sg=SegTree(n,inf,min,inf)
class SegTree:
def __init__(self,n,init_val=0,function=lambda a,b:a+b,ide=0):
self.n=n
self.ide_ele=ide_ele=ide
self.num=num=2**(n-1).bit_length()
self.seg=seg=[self.ide_ele]*2*self.num
self.lazy=lazy=[self.ide_ele]*2*self.num
self.segfun=segfun=function
#set_val
for i in range(n):
self.seg[i+self.num-1]=init_val
#built
for i in range(self.num-2,-1,-1):
self.seg[i]=self.segfun(self.seg[2*i+1],self.seg[2*i+2])
def update(self,k,x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfun(self.seg[k*2+1],self.seg[k*2+2])
def evaluate(k,l,r): #遅延評価処理
if lazy[k]!=0:
node[k]+=lazy[k]
if(r-l>1):
lazy[2*k+1]+=lazy[k]//2
lazy[2*k+2]+=lazy[k]//2
lazy[k]=0
def query(self,p,q):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfun(res,self.seg[p])
if q&1 == 1:
res = self.segfun(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfun(res,self.seg[p])
else:
res = self.segfun(self.segfun(res,self.seg[p]),self.seg[q])
return res
def find_min_index(self,p,q,m):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfun(res,self.seg[p])
if q&1 == 1:
res = self.segfun(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfun(res,self.seg[p])
else:
res = self.segfun(self.segfun(res,self.seg[p]),self.seg[q])
return res
def __str__(self):
# 生配列を表示
rt=self.seg[self.num-1:self.num-1+self.n]
return str(rt)
class Tree:
def __init__(self,inp_size=None,init=True):
if init:
self.stdin(inp_size)
return
def stdin(self,inp_size=None):
if inp_size==None:
self.size=int(input())
else:
self.size=inp_size
self.edges,_=GI(self.size,self.size-1)
return
def listin(self,ls):
self.size=len(ls)+1
self.edges,_=GI(self.size,self.size-1,ls)
return
def __str__(self):
return str(self.edges)
def dfs(self,x,func=lambda prv,nx,dist:prv+dist,root_v=0):
q=deque()
q.append(x)
v=[-1]*self.size
v[x]=root_v
while q:
c=q.pop()
for nb,d in self.edges[c]:
if v[nb]==-1:
q.append(nb)
v[nb]=func(v[c],nb,d)
return v
def EulerTour(self,x,func=lambda prv,nx,dist:prv+dist,root_v=0):
q=deque()
q.append((-1,x))
v=[None]*self.size
v[x]=root_v
et=[]
while q:
cb,ce=q.pop()
et.append(ce)
for nb,d in self.edges[ce]:
if v[nb]==None:
q.append((nb,ce))
q.append((ce,nb))
v[nb]=func(v[ce],nb,d)
vid=[[-1,-1]for i in range(self.size)]
for i,j in enumerate(et):
if vid[j][0]==-1:
vid[j][0]=i
else:
vid[j][1]=i
return v,et,vid
def LCA_init(self,depth,et):
self.st=SegTree(self.size*2-1,func=min,ide=inf)
for i,j in enumerate(et):
self.st.update(i,j)
self.LCA_init_stat==True
return
def LCA(self,root,x,y):
if self.LCA_init_stat==False:
depth,et,vid=self.EulerTour(root)
self.LCA_init(depth,et)
return self.st.query(x,y+1)
n=I()
tr=Tree(n)
q,k=LI()
v=tr.dfs(k-1)
for i in range(q):
x,y=LI_()
print(v[x]+v[y])
| p03634 |
import sys
stdin = sys.stdin
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from heapq import heappush, heappop
def dijkstra(graph:list, node:int, start:int) -> list:
# 未探索のノードは距離INF
INF = float("inf")
dist = [INF]*node
# 始点ノードの距離を0とし、dfsのためのpriority queを作成
dist[start] = 0
heap = [(0,start)]
# 未探索のノードをpriority queueに入れる
while heap:
cost, cur_node = heappop(heap)
for nex_cost, nex_node in graph[cur_node]:
dist_cand = dist[cur_node] + nex_cost
if dist_cand < dist[nex_node]:
dist[nex_node] = dist_cand
heappush(heap, (dist[nex_node], nex_node))
return dist
n = ni()
abc = []
for _ in range(n-1):
a,b,c = li()
a -= 1
b -= 1
abc.append((a,b,c))
q,k = li()
k -= 1
query = [li_() for _ in range(q)]
# 隣接リストつくる
graph = [[] for _ in range(n)]
for frm,to,cost in abc:
graph[frm].append((cost,to))
graph[to].append((cost,frm))
# 頂点Kをスタートとするダイクストラ
dist = dijkstra(graph, n, k)
# クエリ処理
for frm,to in query:
print((dist[frm] + dist[to])) | import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from heapq import heappush, heappop
def dijkstra(graph:list, node:int, start:int) -> list:
# 未探索のノードは距離INF
INF = float("inf")
dist = [INF]*node
# 始点ノードの距離を0とし、dfsのためのpriority queを作成
dist[start] = 0
heap = [(0,start)]
# 未探索のノードをpriority queueに入れる
while heap:
cost, cur_node = heappop(heap)
for nex_cost, nex_node in graph[cur_node]:
dist_cand = dist[cur_node] + nex_cost
if dist_cand < dist[nex_node]:
dist[nex_node] = dist_cand
heappush(heap, (dist[nex_node], nex_node))
return dist
n = ni()
graph = [[] for _ in range(n)]
for _ in range(n-1):
a,b,c = li()
a -= 1
b -= 1
graph[a].append((c,b))
graph[b].append((c,a))
q,k = li()
dist = dijkstra(graph,n,k-1)
xy = [tuple(li_()) for _ in range(q)]
for x,y in xy:
print((dist[x]+dist[y])) | p03634 |
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from heapq import heappush, heappop
def dijkstra(graph:list, node:int, start:int) -> list:
# 未探索のノードは距離INF
INF = float("inf")
dist = [INF]*node
# 始点ノードの距離を0とし、dfsのためのpriority queを作成
dist[start] = 0
heap = [(0,start)]
# 未探索のノードをpriority queueに入れる
while heap:
cost, cur_node = heappop(heap)
for nex_cost, nex_node in graph[cur_node]:
dist_cand = dist[cur_node] + nex_cost
if dist_cand < dist[nex_node]:
dist[nex_node] = dist_cand
heappush(heap, (dist[nex_node], nex_node))
return dist
n = ni()
graph = [[] for _ in range(n)]
for _ in range(n-1):
a,b,c = li()
a -= 1
b -= 1
graph[a].append((c,b))
graph[b].append((c,a))
q,k = li()
dist = dijkstra(graph,n,k-1)
xy = [tuple(li_()) for _ in range(q)]
for x,y in xy:
print((dist[x]+dist[y])) | import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from heapq import heappush, heappop
def dijkstra(graph:list, node:int, start:int) -> list:
# 未探索のノードは距離INF
INF = float("inf")
dist = [INF]*node
# 始点ノードの距離を0とし、dfsのためのpriority queを作成
dist[start] = 0
heap = [(0,start)]
# 未探索のノードをpriority queueに入れる
while heap:
cost, cur_node = heappop(heap)
for nex_cost, nex_node in graph[cur_node]:
dist_cand = dist[cur_node] + nex_cost
if dist_cand < dist[nex_node]:
dist[nex_node] = dist_cand
heappush(heap, (dist[nex_node], nex_node))
return dist
n = ni()
graph = [[] for _ in range(n)]
for _ in range(n-1):
a,b,c = li()
a -= 1
b -= 1
graph[a].append((c, b))
graph[b].append((c, a))
q,k = li()
k -= 1
query = []
for _ in range(q):
x, y = li_()
query.append((x, y))
dist = dijkstra(graph, n, k)
for qx, qy in query:
print((dist[qx] + dist[qy])) | p03634 |
from heapq import heappush, heappop
class Dijkstra:
def __init__(self, route_map, start_point, goal_point=None):
self.route_map = route_map
self.start_point = start_point
self.goal_point = goal_point
def execute(self):
num_of_vertex = len(self.route_map)
dist = [float('inf') for _ in range(num_of_vertex)]
prev = [float('inf') for _ in range(num_of_vertex)]
dist[self.start_point] = 0
heap_q = []
heappush(heap_q, (0, self.start_point))
while len(heap_q) != 0:
prev_cost, src = heappop(heap_q)
if dist[src] < prev_cost:
continue
for dest in range(num_of_vertex):
cost = route_map[src][dest]
if cost != float('inf') and dist[dest] > dist[src] + cost:
dist[dest] = dist[src] + cost
heappush(heap_q, (dist[dest], dest))
prev[dest] = src
if self.goal_point is not None:
return self.get_path(prev)
else:
return dist
def get_path(prev):
path = [self.goal_point]
dest = self.goal_point
while prev[dest] != float('inf'):
dest = prev[dest]
return list(reversed(path))
N = int(eval(input()))
route_map = [[float('inf') for _ in range(N)] for _ in range(N)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
route_map[a - 1][b - 1] = c
route_map[b - 1][a - 1] = c
Q, K = list(map(int, input().split()))
K -= 1
dijakstra_result = Dijkstra(route_map, K).execute()
for _ in range(Q):
x, y = list(map(int, input().split()))
print((dijakstra_result[x - 1] + dijakstra_result[y - 1])) | import sys
sys.setrecursionlimit(10 ** 8)
class Solve():
def __init__(self):
self.N = int(eval(input()))
self.route = [dict() for _ in range(self.N)]
for _ in range(self.N - 1):
a, b, c = list(map(int, input().split()))
self.route[a - 1][b - 1] = c
self.route[b - 1][a - 1] = c
self.Q, self.K = list(map(int, input().split()))
self.K -= 1
self.query = []
for _ in range(self.Q):
x, y = list(map(int, input().split()))
self.query.append([x - 1, y - 1])
self.depth = [0 for _ in range(self.N)]
def DFS(self, v, p, d):
self.depth[v] = d
for dest, cost in list(self.route[v].items()):
if dest == p:
continue
self.DFS(dest, v, d + cost)
def execute(self):
self.DFS(self.K, -1, 0)
for x, y in self.query:
print((self.depth[x] + self.depth[y]))
if __name__ == '__main__':
Solve().execute() | p03634 |
def BFS(K, edges, N):
roots = [[] for i in range(N)]
for a, b, c in edges:
roots[a - 1] += [(b - 1, c)]
roots[b - 1] += [(a - 1, 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
N = int(eval(input()))
edges = []
for i in range(N - 1):
edges += [list(map(int, input().split()))]
Q, K = list(map(int, input().split()))
xy = [list(map(int, input().split())) for i in range(Q)]
distance = BFS(K-1, edges, N)
for i in range(Q):
print((distance[xy[i][0] - 1] + distance[xy[i][1] - 1])) | def getDis(k, abc, n):
r = [[] for i in range(n)]
for a, b, c in abc:
r[a-1] += [(b-1, c)]
r[b-1] += [(a-1, c)]
dis = [-1] * n
stack = [k]
dis[k] = 0
while stack:
label = stack.pop(-1)
for i, c in r[label]:
if dis[i] == -1:
dis[i] = dis[label] + c
stack.append(i)
return dis
N = int(eval(input()))
abc = [[int(i) for i in input().split()] for i in range(N-1)]
Q, K = list(map(int, input().split()))
xy = [[int(i) for i in input().split()] for i in range(Q)]
d = getDis(K-1, abc, N)
for i in range(Q):
print((d[xy[i][0] - 1] + d[xy[i][1] - 1]))
| p03634 |
N = int(eval(input()))
treedic = {}
for i in range(1, N+1):
treedic[i] = {}
for i in range(N-1):
a, b, c = list(map(int, input().split()))
treedic[a][b] = c
treedic[b][a] = c
Q, K = list(map(int, input().split()))
checked = set([K])
length = [0]*(N+1)
check = set([K])
while len(checked) < N:
nextcheck = set()
for i in check:
for j in list(treedic[i].keys()):
if j not in checked:
length[j] = length[i] + treedic[i][j]
checked.add(j)
nextcheck.add(j)
check = nextcheck
for i in range(Q):
x, y = list(map(int, input().split()))
print((length[x] + length[y]))
| def main():
N = int(eval(input()))
treedic = {}
for i in range(1, N+1):
treedic[i] = {}
for i in range(N-1):
a, b, c = list(map(int, input().split()))
treedic[a][b] = c
treedic[b][a] = c
Q, K = list(map(int, input().split()))
checked = set([K])
length = [0]*(N+1)
check = set([K])
while len(checked) < N:
nextcheck = set()
for i in check:
for j in list(treedic[i].keys()):
if j not in checked:
length[j] = length[i] + treedic[i][j]
checked.add(j)
nextcheck.add(j)
check = nextcheck
for i in range(Q):
x, y = list(map(int, input().split()))
print((length[x] + length[y]))
if __name__ == "__main__":
main()
| p03634 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
mod2 = 998244353
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))
n = inp()
g = [[] for i in range(n)]
cc = dict()
for i in range(n-1):
a,b,c = inpl()
a -= 1
b -= 1
g[a].append(b)
g[b].append(a)
cc[(a,b)] = c
cc[(b,a)] = c
q,k = inpl()
k -= 1
cost = [INF] * n
cost[k] = 0
def dfs(node,c):
for next in g[node]:
if cost[next] == INF:
cost[next] = c + cc[(node,next)]
dfs(next,cost[next])
dfs(k,0)
res = [0] * q
for i in range(q):
x,y = inpl()
x -= 1
y -= 1
res[i] = cost[x] + cost[y]
for z in res:
print(z)
| from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions
from decimal import Decimal
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n = inp()
co = dict()
g = [[] for _ in range(n)]
cost = [-1] * n
for i in range(n-1):
a,b,c = inpl()
a -= 1; b -= 1
g[a] += [b]; g[b] += [a]
co[(a,b)] = c; co[(b,a)] = c
Q,k = inpl()
k -= 1; cost[k] = 0
q = deque()
q.append(k)
while q:
nv = q.popleft()
for v in g[nv]:
if cost[v] > 0:
continue
cost[v] = cost[nv] + co[(v,nv)]
q.append(v)
for _ in range(Q):
a,b = inpl()
a -= 1; b -= 1
print((cost[a] + cost[b])) | p03634 |
import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
X = [list(map(int,input().split())) for _ in range(N-1)]
Q,K = list(map(int,input().split()))
Y = [list(map(int,input().split())) for _ in range(Q)]
tree = [[] for _ in range(N)]
dif = [10**15 for _ in range(N)]
dif[K-1] = 0
for i in range(N-1):
tree[X[i][0]-1].append(X[i][1])
tree[X[i][1]-1].append(X[i][0])
queue = [K]
while queue:
a = queue.pop()
for i in range(N-1):
if X[i][0] == a:
dif[X[i][1]-1] = min(dif[X[i][1]-1],dif[a-1]+X[i][2])
tree[X[i][1]-1].remove(a)
queue[0:0] = tree[a-1]
if X[i][1] == a:
dif[X[i][0]-1] = min(dif[X[i][0]-1],dif[a-1]+X[i][2])
tree[X[i][0]-1].remove(a)
queue[0:0] = tree[a-1]
queue = list(set(queue))
for i in range(Q):
print((dif[Y[i][0]-1]+dif[Y[i][1]-1]))
if __name__ == "__main__":
main() | import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
X = [list(map(int,input().split())) for _ in range(N-1)]
Q,K = list(map(int,input().split()))
Y = [list(map(int,input().split())) for _ in range(Q)]
tree = [[] for _ in range(N)]
dif = [10**15 for _ in range(N)]
dif[K-1] = 0
for i in range(N-1):
tree[X[i][0]-1].append((X[i][1]-1,X[i][2]))
tree[X[i][1]-1].append((X[i][0]-1,X[i][2]))
queue = [K-1]
while queue:
a = queue.pop()
for i in tree[a]:
s,t = i[0],i[1]
if dif[s] == 10**15:
dif[s] = dif[a]+t
queue.append(s)
for i in range(Q):
print((dif[Y[i][0]-1]+dif[Y[i][1]-1]))
if __name__ == "__main__":
main() | p03634 |
def BFS(K,path,N):
"""リストのリスト道順path,頂点の個数Nが与えられたとき, 頂点Kから各頂点までの距離をlistで返す"""
from collections import deque
dist=[-1]*N
dist[K]=0
que=deque()
que.append(K)
while que:
label=que.popleft()
for i,c in path[label]:
if dist[i]==-1:
dist[i]=dist[label]+c
que+=[i]
return dist
N=int(eval(input()))
path=[ [] for i in range(N)]
for i in range(N-1):
a,b,c=list(map(int,input().split()))
path[a-1]+=[[b-1,c]]
path[b-1]+=[[a-1,c]]
Q,K=list(map(int,input().split()))
distance=BFS(K-1,path,N)
for i in range(Q):
x,y=list(map(int,input().split()))
print((distance[x-1]+distance[y-1])) | from sys import stdin
input = stdin.readline
def BFS(K,path,N):
"""リストのリスト道順path,頂点の個数Nが与えられたとき, 頂点Kから各頂点までの距離をlistで返す"""
from collections import deque
dist=[-1]*N
dist[K]=0
que=deque()
que.append(K)
while que:
label=que.popleft()
for i,c in path[label]:
if dist[i]==-1:
dist[i]=dist[label]+c
que+=[i]
return dist
N=int(eval(input()))
path=[ [] for i in range(N)]
for i in range(N-1):
a,b,c=list(map(int,input().split()))
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)]
distance=BFS(K-1,path,N)
for i in range(Q):
print((distance[xy[i][0]-1]+distance[xy[i][1]-1])) | p03634 |
from sys import stdin
input = stdin.readline
def BFS(K,path,N):
"""リストのリスト道順path,頂点の個数Nが与えられたとき, 頂点Kから各頂点までの距離をlistで返す"""
from collections import deque
dist=[-1]*N
dist[K]=0
que=deque()
que.append(K)
while que:
label=que.popleft()
for i,c in path[label]:
if dist[i]==-1:
dist[i]=dist[label]+c
que+=[i]
return dist
N=int(eval(input()))
path=[ [] for i in range(N)]
for i in range(N-1):
a,b,c=list(map(int,input().split()))
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)]
distance=BFS(K-1,path,N)
for i in range(Q):
print((distance[xy[i][0]-1]+distance[xy[i][1]-1])) | from sys import stdin
input = stdin.readline
def BFS(K,path,N):
"""リストのリスト道順path,頂点の個数Nが与えられたとき, 頂点Kから各頂点までの距離をlistで返す"""
from collections import deque
dist=[-1]*N
dist[K]=0
que=deque()
que.append(K)
while que:
label=que.popleft()
for i,c in path[label]:
if dist[i]==-1:
dist[i]=dist[label]+c
que+=[i]
return dist
N=int(eval(input()))
path=[ [] for i in range(N)]
for i in range(N-1):
a,b,c=list(map(int,input().split()))
path[a-1].append((b-1,c))
path[b-1].append((a-1,c))
Q,K=list(map(int,input().split()))
xy=[list(map(int,input().split())) for i in range(Q)]
distance=BFS(K-1,path,N)
for i in range(Q):
print((distance[xy[i][0]-1]+distance[xy[i][1]-1])) | p03634 |
from sys import stdin
input = stdin.readline
def BFS(K,path,N):
"""リストのリスト道順path,頂点の個数Nが与えられたとき, 頂点Kから各頂点までの距離をlistで返す"""
import queue
dist=[-1]*N
dist[K]=0
que=queue.Queue()
que.put(K)
while que.qsize():
label=que.get()
for i,c in path[label]:
if dist[i]==-1:
dist[i]=dist[label]+c
que.put(i)
return dist
N=int(eval(input()))
path=[ [] for i in range(N)]
for i in range(N-1):
a,b,c=list(map(int,input().split()))
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)]
distance=BFS(K-1,path,N)
for i in range(Q):
print((distance[xy[i][0]-1]+distance[xy[i][1]-1])) | from sys import stdin
input = stdin.readline
def BFS(K,path,N):
"""リストのリスト道順path,頂点の個数Nが与えられたとき, 頂点Kから各頂点までの距離をlistで返す"""
from collections import deque
dist=[-1]*N
dist[K]=0
que=[]
que.append(K)
while que:
label=que.pop(-1)
for i,c in path[label]:
if dist[i]==-1:
dist[i]=dist[label]+c
que+=[i]
return dist
N=int(eval(input()))
path=[ [] for i in range(N)]
for i in range(N-1):
a,b,c=list(map(int,input().split()))
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)]
distance=BFS(K-1,path,N)
for i in range(Q):
print((distance[xy[i][0]-1]+distance[xy[i][1]-1])) | p03634 |
from collections import deque
n=int(eval(input()))
con=[[] for _ in range(n)]
dist=[[None]*n for _ in range(n)]
dist_f_k=[0]*n
for _ in range(n-1):
a,b,c=list(map(int,input().split()))
con[a-1].append(b-1)
con[b-1].append(a-1)
dist[a-1][b-1]=dist[b-1][a-1]=c
q,k=list(map(int,input().split()))
dist_f_k[k-1]=None
que=deque([(k-1,0)])
while que:
cur,d=que.popleft()
for nxt in con[cur]:
if dist_f_k[nxt]==0:
tmp=d+dist[cur][nxt]
que.append((nxt,tmp))
dist_f_k[nxt]=tmp
for _ in range(q):
x,y=list(map(int,input().split()))
print((dist_f_k[x-1]+dist_f_k[y-1])) | from collections import deque
n=int(eval(input()))
con=[[] for _ in range(n)]
dist_f_k=[0]*n
for _ in range(n-1):
a,b,c=list(map(int,input().split()))
con[a-1].append((b-1,c))
con[b-1].append((a-1,c))
q,k=list(map(int,input().split()))
que=deque([k-1])
while que:
cur=que.popleft()
for nxt,dd in con[cur]:
if dist_f_k[nxt]==0 and nxt!=k-1:
que.append(nxt)
dist_f_k[nxt]=dist_f_k[cur]+dd
for _ in range(q):
x,y=list(map(int,input().split()))
print((dist_f_k[x-1]+dist_f_k[y-1])) | p03634 |
from collections import deque
n=int(eval(input()))
con=[[] for _ in range(n)]
dist_f_k=[0]*n
for _ in range(n-1):
a,b,c=list(map(int,input().split()))
con[a-1].append((b-1,c))
con[b-1].append((a-1,c))
q,k=list(map(int,input().split()))
que=deque([k-1])
while que:
cur=que.popleft()
for nxt,dd in con[cur]:
if dist_f_k[nxt]==0 and nxt!=k-1:
que.append(nxt)
dist_f_k[nxt]=dist_f_k[cur]+dd
for _ in range(q):
x,y=list(map(int,input().split()))
print((dist_f_k[x-1]+dist_f_k[y-1])) | from collections import deque
n,*t=list(map(int,open(0).read().split()))
con=[[] for _ in range(n)]
dist_f_k=[0]*n
for a,b,c in zip(t[:3*n-3:3],t[1::3],t[2::3]):
con[a-1].append((b-1,c))
con[b-1].append((a-1,c))
k=t[3*n-2]
que=deque([k-1])
while que:
cur=que.popleft()
for nxt,dd in con[cur]:
if dist_f_k[nxt]==0 and nxt!=k-1:
que.append(nxt)
dist_f_k[nxt]=dist_f_k[cur]+dd
for x,y in zip(t[3*n-1::2],t[3*n::2]):
print((dist_f_k[x-1]+dist_f_k[y-1])) | p03634 |
from collections import deque
def main():
n=int(eval(input()))
dis=[[10**20 for i in range(n)] for i in range(n)]
g=[[] for i in range(n)]
for _ in range(n-1):
a,b,c = list(map(int,input().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
dis[a-1][b-1] = c
dis[b-1][a-1] = c
q,k = list(map(int,input().split()))
k-=1
d=deque([k])
f=[False for i in range(n)]
dis[k][k]=0
while d:
s= d.popleft()
f[s]= True
for sg in g[s]:
if not f[sg]:
dis[k][sg]= dis[k][s]+dis[s][sg]
d.append(sg)
lq=[]
for _ in range(q):
lq.append(list(map(int,input().split())))
for sq in lq:
print((dis[k][sq[0]-1]+dis[k][sq[1]-1]))
main() | from collections import deque
import sys
sys.setrecursionlimit(10**7)
n=int(eval(input()))
d=[10**20 for i in range(n)]
g=[[] for i 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()))
k-=1
f=[False for i in range(n)]
d[k]=0
def dfs(s,c):
f[s]=True
d[s]=c
for sg in g[s]:
if not f[sg[0]]:
dfs(sg[0],c+sg[1])
dfs(k,0)
lq=[]
for _ in range(q):
lq.append(list(map(int,input().split())))
for sq in lq:
print((d[sq[0]-1]+d[sq[1]-1]))
| p03634 |
import sys
def input():
return sys.stdin.readline()[:-1]
n=int(input())
def warshall_floyd(d):
for x in range(n):
for y in range(n):
for z in range(n):
d[y][z] = min(d[y][z],d[y][x]+d[x][z])
return d
graph = [[float("inf")]*n for _ in range(n)]
for i in range(n-1):
a,b,c = map(int,input().split())
graph[a-1][b-1] = c
graph[b-1][a-1] = c
for i in range(n):
graph[i][i] = 0
G = warshall_floyd(graph)
ans = []
q,k = map(int,input().split())
for i in range(q):
x,y = map(int,input().split())
ans.append(G[k-1][x-1] + G[k-1][y-1])
print(*ans , sep="\n")
| n=int(input())
def warshall_floyd(d,k):
for x in range(n):
for y in range(n):
for z in range(n):
d[y][z] = min(d[y][z],d[y][x]+d[x][z])
return d[k-1]
graph = [[float("inf") for x in range(n)] for _ in range(n)]
for i in range(n-1):
a,b,c = map(int,input().split())
graph[a-1][b-1] = c
graph[b-1][a-1] = c
for i in range(n):
graph[i][i] = 0
q,k = map(int,input().split())
G = warshall_floyd(graph,k)
ans = []
for i in range(q):
x,y = map(int,input().split())
ans.append(G[x-1] + G[y-1])
print(*ans , sep="\n")
| p03634 |
from collections import deque
def f(k,edge,n):
root = [[] for _ in range(n)]
for i in range(n-1):
a,b,c = edge[i][0],edge[i][1],edge[i][2]
root[a-1].append([b-1,c])
root[b-1].append([a-1,c])
que = deque()
for l in root[k]:
que.append(l)
dist = [float("inf")]*n
dist[k] = 0
visited = [False]*n
que = deque([k])
while que:
pos = que.popleft()
if not visited[pos]:
visited[pos] = True
for x,y in root[pos]:
if not visited[x]:
dist[x] = dist[pos] + y
visited[x] = True
que.append(x)
return dist
n = int(input())
edge = [list(map(int,input().split())) for _ in range(n-1)]
q,k = map(int,input().split())
ans = []
d = f(k-1,edge,n)
for i in range(q):
x,y = map(int,input().split())
ans.append(d[x-1] + d[y-1])
print(*ans , sep = "\n")
| from collections import deque
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()))
dis = [float('inf')]*(n+1)
dis[k] = 0
que = deque(g[k])
while que:
x,y = que.popleft()
if dis[x] == float('inf'):
dis[x] = y
for x_, y_ in g[x]:
que.append((x_, dis[x]+y_))
else:
dis[x] = min(dis[x], y)
ans = []
for _ in range(q):
x,y = list(map(int,input().split()))
ans.append(dis[x] + dis[y])
for a in ans:
print(a) | p03634 |
from collections import defaultdict
inf = float('inf')
def solve(graph, n, start_node):
costs = [inf for _ in range(n)]
costs[start_node] = 0
flgs = [False for _ in range(n)]
while not all(flgs):
prv_node = _get_min_idx(flgs,costs)
flgs[prv_node] = True
for node, dis in graph[prv_node]:
if costs[node] > costs[prv_node] + dis:
costs[node] = costs[prv_node] + dis
return costs
def _get_min_idx(flgs, costs):
min_cost = inf
min_idx = None
cnt = 0
for cost, flg in zip(costs, flgs):
if min_cost > cost and flg is False:
min_cost = cost
min_idx = cnt
cnt += 1
return min_idx
n =int(eval(input()))
graph = defaultdict(list)
costs_dict = {}
for _ in range(n-1):
a,b,c = list(map(int, input().split()))
graph[a-1].append([b-1,c])
graph[b-1].append([a-1,c])
q, k = list(map(int, input().split()))
k -= 1
costs = solve(graph, n, k)
for _ in range(q):
x, y = list(map(int, input().split()))
print(( costs[x-1] + costs[y-1]))
| from collections import deque
def dfs():
dis_from_k = [float('inf') for _ in range(N+1)]
q = deque()
used = set()
q.append([K, 0])
used.add(K)
while len(q) > 0:
prv_node, prv_cost = q.pop()
for node, cost in g[prv_node]:
if node in used:
continue
dis_from_k[node] = min(dis_from_k[node], prv_cost + cost)
q.append([node, prv_cost + cost])
used.add(node)
return dis_from_k
N = int(eval(input()))
g = {i: [] for i in range(1, 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()))
dis_from_k = dfs()
for _ in range(Q):
x, y = list(map(int, input().split()))
print((dis_from_k[x] + dis_from_k[y])) | p03634 |
import heapq
n = int(eval(input()))
cost = [[float('inf') for _ in range(n+1)] for _ in range(n+1)]
for _ in range(n-1):
From, To, d = list(map(int, input().split()))
cost[From][To] = d
cost[To][From] = d
q, k = list(map(int, input().split()))
dist = [float('inf') for _ in range(n+1)]
dist[k] = 0
next_v = [[0, k]]
while len(next_v):
v = next_v[0][1]
for i in range(n+1):
if dist[i] > dist[v] + cost[v][i]:
dist[i] = dist[v] + cost[v][i]
heapq.heappush(next_v, [dist[i], i])
heapq.heappop(next_v)
for _ in range(q):
x, y = list(map(int, input().split()))
print((dist[x]+dist[y])) | import heapq
def dijkstra(n, edges, s):
min_dist = [float('inf')] * n
min_dist[s] = 0
next_v = []
heapq.heappush(next_v, (0, s))
path = [-1] * n
while True:
if len(next_v) == 0: break
d, v = heapq.heappop(next_v)
for u, d in edges[v]:
if min_dist[u] > min_dist[v] + d:
min_dist[u] = min_dist[v] + d
heapq.heappush(next_v, (min_dist[u], u))
path[u] = v
return min_dist, path
n = int(eval(input()))
edges = [[] for _ in range(n)]
for _ 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()))
dist, _ = dijkstra(n, edges, k-1)
for _ in range(q):
x, y = list(map(int, input().split()))
print((dist[x-1] + dist[y-1])) | p03634 |
import heapq
N = int(eval(input()))
tree = {i+1:[] for i in range(N)}
route = [10**20 for i in range(N+1)]
visited = [False for i in range(N+1)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
tree[a].append((c, b))
tree[b].append((c, a))
Q, K = list(map(int, input().split()))
route[K], visited[K] = 0, True
queue = tree[K]
while len(queue):
c, r = heapq.heappop(queue)
if not visited[r]:
visited[r], route[r] = True, c
for cost, next_r in tree[r]:
if not visited[next_r]:
heapq.heappush(queue, (route[r]+cost, next_r))
for i in range(Q):
x, y = list(map(int, input().split()))
print((route[x]+route[y]))
| import heapq
N = int(eval(input()))
graph = [[] for i in range(N+1)]
visited = [False] * (N+1)
cost = [10**20 for i in range(N+1)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
graph[a].append((c, b))
graph[b].append((c, a))
Q, K = list(map(int, input().split()))
q = []
for cr in graph[K]:
heapq.heappush(q, cr)
visited[K] = True
cost[K] = 0
while q:
c, r = heapq.heappop(q)
if not visited[r]:
visited[r] = True
cost[r] = c
for c_n, r_n in graph[r]:
if not visited[r_n]:
heapq.heappush(q, (c+c_n, r_n))
for i in range(Q):
x, y = list(map(int, input().split()))
print((cost[x] + cost[y])) | 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)]
graph = [[] for _ in range(N)]
for i, (ai, bi, ci) in enumerate(abc):
graph[ai - 1].append((bi - 1, ci))
graph[bi - 1].append((ai - 1, ci))
import heapq
MY_INF = None
q = [(0, K - 1)]
d = [MY_INF] * N
d[K - 1] = 0
while len(q) > 0:
dist, src = heapq.heappop(q)
for dst, c_dst in graph[src]:
dist_tmp = dist + c_dst
if d[dst] == None or d[dst] > dist_tmp:
d[dst] = dist_tmp
heapq.heappush(q, (dist_tmp, dst))
for i, (xi, yi) in enumerate(xy):
print((d[xi - 1] + d[yi - 1])) | 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 = [[] for _ in range(N)]
for ai, bi, ci in abc:
graph[ai - 1].append((bi - 1, ci))
graph[bi - 1].append((ai - 1, ci))
MY_INF = 10 ** 18
import heapq
q = [(0, K - 1)]
d = [MY_INF] * N
d[K - 1] = 0
while len(q) > 0:
dist, src = heapq.heappop(q)
for dst, c_tmp in graph[src]:
dist_tmp = dist + c_tmp
if d[dst] > dist_tmp:
d[dst] = dist_tmp
heapq.heappush(q, (dist_tmp, dst))
for xi, yi in xy:
print((d[xi - 1] + d[yi - 1]))
| p03634 |
n = int(eval(input()))
a = [[int(i) for i in input().split()] for i in range(n-1)]
q,k = (int(i) for i in input().split())
question = [[int(i) for i in input().split()] for i in range(q)]
x = []
for i in range(n):
subx = []
for j in range(n):
subx.append(float("inf"))
x.append(subx)
for i in range(n): x[i][i] = 0
for i in a: x[i[0]-1][i[1]-1],x[i[1]-1][i[0]-1] = i[2],i[2]
for p in range(n):
for i in range(n):
for j in range(n):
x[i][j] = min(x[i][p]+x[p][j],x[i][j])
for i in question:
print((x[i[0]-1][k-1]+x[k-1][i[1]-1])) | n = int(eval(input()))
a = [[int(i) for i in input().split()] for i in range(n-1)]
q,k = (int(i) for i in input().split())
question = [[int(i) for i in input().split()] for i in range(q)]
x,ans = [[] for i in range(n)],[False for i in range(n)]
for i in a:
x[i[0]-1].append([i[1],i[2]])
x[i[1]-1].append([i[0],i[2]])
visit = [False for i in range(n)]
visit[k-1],now = True,[k]
while now:
p = now.pop()
for i in x[p-1]:
if not visit[i[0]-1]:
visit[i[0]-1],ans[i[0]-1] = True,ans[p-1]+i[1]
now.append(i[0])
for i in question:
print((ans[i[0]-1]+ans[i[1]-1])) | p03634 |
from collections import deque
def main():
def p(a,b):
if a < b:
return (a,b)
else:
return (b,a)
#input = open(0).readline
N = int(eval(input()))
E = [[] for i in range(N)]
C = {}
D = [0] * N
parent = [0]*N
for i in range(N-1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
E[a].append(b)
E[b].append(a)
C[p(a,b)] = c
M, K = list(map(int, input().split()))
K -= 1
parent[K] = K
Q = deque()
Q.append(K)
while Q:
u = Q.popleft()
d = D[u]
for v in E[u]:
if parent[u] == v:
continue
parent[v] = u
D[v] = d + C[p(u,v)]
Q.append(v)
for i in range(M):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
print((D[x]+D[y]))
main()
| from collections import deque
def main():
def p(a,b):
if a < b:
return (a,b)
else:
return (b,a)
input = open(0).readline
N = int(eval(input()))
E = [[] for i in range(N)]
C = {}
D = [0] * N
parent = [0]*N
for i in range(N-1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
E[a].append(b)
E[b].append(a)
C[(a,b)] = c
C[(b,a)] = c
M, K = list(map(int, input().split()))
K -= 1
parent[K] = K
Q = deque()
Q.append(K)
while Q:
u = Q.popleft()
d = D[u]
for v in E[u]:
if parent[u] == v:
continue
parent[v] = u
D[v] = d + C[(u,v)]
Q.append(v)
for i in range(M):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
print((D[x]+D[y]))
main()
| p03634 |
from collections import deque
def main():
def p(a,b):
if a < b:
return (a,b)
else:
return (b,a)
input = open(0).readline
N = int(eval(input()))
E = [[] for i in range(N)]
C = {}
D = [0] * N
parent = [0]*N
for i in range(N-1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
E[a].append(b)
E[b].append(a)
C[(a,b)] = c
C[(b,a)] = c
M, K = list(map(int, input().split()))
K -= 1
parent[K] = K
Q = deque()
Q.append(K)
while Q:
u = Q.popleft()
d = D[u]
for v in E[u]:
if parent[u] == v:
continue
parent[v] = u
D[v] = d + C[(u,v)]
Q.append(v)
for i in range(M):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
print((D[x]+D[y]))
main()
| from collections import deque
import sys
def main():
def p(a,b):
if a < b:
return (a,b)
else:
return (b,a)
input = sys.stdin.readline
N = int(eval(input()))
E = [[] for i in range(N)]
C = {}
D = [0] * N
parent = [0]*N
for i in range(N-1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
E[a].append(b)
E[b].append(a)
C[p(a,b)] = c
M, K = list(map(int, input().split()))
K -= 1
parent[K] = K
Q = deque()
Q.append(K)
while Q:
u = Q.popleft()
d = D[u]
for v in E[u]:
if parent[u] == v:
continue
parent[v] = u
D[v] = d + C[p(u,v)]
Q.append(v)
for i in range(M):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
print((D[x]+D[y]))
main()
| p03634 |
import sys
input = sys.stdin.readline
n = int(eval(input()))
v = [[0]+[]*(n+1) for i in range(n+1)]
for i in range(n-1):
a,b,c = list(map(int,input().split()))
v[a].append([b,c])
v[b].append([a,c])
q,k = list(map(int,input().split()))
l = [k]
while l:
now = l.pop()
for i in v[now][1:]:
if v[i[0]][0] == 0:
v[i[0]][0] = i[1]+v[now][0]
l.append(i[0])
for i in range(q):
x,y = list(map(int,input().split()))
print((v[x][0]+v[y][0])) | import sys
def main():
input = sys.stdin.readline
n = int(eval(input()))
v = [[0]+[]*(n+1) for i in range(n+1)]
for i in range(n-1):
a,b,c = list(map(int,input().split()))
v[a].append([b,c])
v[b].append([a,c])
q,k = list(map(int,input().split()))
l = [k]
while l:
now = l.pop()
for i in v[now][1:]:
if v[i[0]][0] == 0:
v[i[0]][0] = i[1]+v[now][0]
l.append(i[0])
for i in range(q):
x,y = list(map(int,input().split()))
print((v[x][0]+v[y][0]))
if __name__ == '__main__':
main() | p03634 |
def dijkstra(s: int, n: int, w: int, cost: list) -> list:
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()))
t = [[float("inf")]*(n) for _ in range(n)]
for _ in range(n-1):
a, b, c = list(map(int, input().split()))
t[a-1][b-1] = c
t[b-1][a-1] = c
q, k = list(map(int, input().split()))
k -= 1
d = dijkstra(k, n, n-1, t)
for _ in range(q):
x, y = list(map(int, input().split()))
print((d[x-1]+d[y-1]))
| import sys
sys.setrecursionlimit(10**6)
def dfs(v: int, p: int = -1, s: int = 0):
dist[v] = s
for i, j in t[v]:
if i == p:
continue
dfs(i, v, s + j)
n = int(eval(input()))
t = [[] for _ in range(n)]
for _ in range(n-1):
a, b, c = list(map(int, input().split()))
a -= 1; b -= 1;
t[a].append((b, c))
t[b].append((a, c))
q, k = list(map(int, input().split()))
k -= 1
dist = [0]*n
dfs(k)
for _ in range(q):
x, y = list(map(int, input().split()))
print((dist[x-1]+dist[y-1]))
| p03634 |
from collections import deque
n = int(eval(input()))
nodes = [set() for i in range(n+1)]
dis = [dict() for i in range(n+1)]
ans = [-1 for i in range(n+1)]
for _ in range(n-1):
a,b,c = list(map(int,input().split()))
nodes[a].add(b)
nodes[b].add(a)
dis[a][b] = c
dis[b][a] = c
#print(nodes)
#print(dis)
Q,K = list(map(int,input().split()))
q = [K]
d = 0
ans[K] = 0
c = 0
while True:
now = q[-1]
nex = -1
for x in nodes[now]:
if ans[x] == -1:
nex = x
break
if nex == -1:
if c >= n-1:
break
else:
q.pop()
d -= dis[now][q[-1]]
else:
nodes[now].remove(nex)
nodes[nex].remove(now)
d += dis[now][nex]
q.append(nex)
ans[nex] = d
c += 1
#print(ans)
for _ in range(Q):
x,y = list(map(int,input().split()))
print((ans[x] + ans[y]))
| import sys
sys.setrecursionlimit(10**8)
N = int(eval(input()))
vertex = [{} for _ in range(N)]
for i in range(N-1):
a,b,c = list(map(int,input().split()))
vertex[a-1][b-1] = c
vertex[b-1][a-1] = c
Q,K = list(map(int,input().split()))
d = [0 for i in range(N)]
def dfs(v1,v2):
d[v2] = d[v1] + vertex[v1][v2]
for v in vertex[v2]:
if v == v1:
continue
dfs(v2,v)
for v in list(vertex[K-1].keys()):
dfs(K-1,v)
for q in range(Q):
x,y = list(map(int,input().split()))
print((d[x-1] + d[y-1]))
| p03634 |
import sys
from collections import deque
readline = sys.stdin.readline
n = int(readline())
D = [[-1]*n for _ in range(n)]
for i in range(n): D[i][i]=0
G = [[] for _ in range(n)]
for i in range(n-1):
a,b,c = [int(x)-1 for x in list(map(int, readline().split()))]
G[a].append(b)
G[b].append(a)
D[a][b] = c+1
D[b][a] = c+1
q, k = list(map(int, readline().split()))
k -= 1
que = deque([k])
_D = [-1]*n
_D[k] = 0
while que:
nw = que.popleft()
d = _D[nw]
for nx in G[nw]:
if nw!=k and _D[nx]!=-1: continue
_D[nx] = d+D[nw][nx]
que.append(nx)
for i in range(q):
x, y = [int(x)-1 for x in readline().split()]
print((_D[x]+_D[y])) | import sys
sys.setrecursionlimit(pow(10,6))
readline = sys.stdin.readline
def dfs(nw, d):
V[nw] = d
for nx in G[nw]:
if V[nx[0]]==-1:
dfs(nx[0], d+nx[1])
n = int(readline())
G = [[] for _ in range(n)]
for i in range(n-1):
a,b,c = list(map(int, readline().split()))
G[a-1].append((b-1,c))
G[b-1].append((a-1,c))
q, k = list(map(int, readline().split()))
V = [-1]*n
dfs(k-1, 0)
for i in range(q):
x,y = [int(x)-1 for x in readline().split()]
print((V[x]+V[y])) | p03634 |
import sys
import collections
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n = int(input().rstrip('\n'))
ts = collections.defaultdict(list)
tc = collections.defaultdict(int)
for i in range(n-1):
ta, te, ttc = list(map(int, input().rstrip('\n').split()))
ts[ta - 1] += [te - 1]
ts[te - 1] += [ta - 1]
tc[ta - 1, te - 1] = ttc
tc[te - 1, ta - 1] = ttc
q, k = list(map(int, input().rstrip('\n').split()))
ql = [[0, k-1]]
ql = collections.deque(ql)
fq = collections.defaultdict(int)
while True:
if len(ql) != 0:
cost, p = ql.popleft()
for v in ts[p]:
if v not in fq:
n_cost = tc[p, v]
ql.append([cost + n_cost, v])
fq[v] = cost + n_cost
else:
n_cost = tc[p, v]
if n_cost + cost < fq[v]:
ql.append([cost + n_cost, v])
fq[v] = cost + n_cost
else:
break
for i in range(q):
x, y = list(map(int, input().rstrip('\n').split()))
print((fq[x-1] + fq[y-1]))
if __name__ == '__main__':
solve()
| import sys
import collections
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n = int(input().rstrip('\n'))
tmd = collections.defaultdict(list)
tmdc = collections.defaultdict(int)
for i in range(n-1):
tma, tmb, tmc = list(map(int, input().rstrip('\n').split()))
tmd[tma-1] += [tmb-1]
tmd[tmb-1] += [tma-1]
tmdc[tma-1, tmb-1] = tmc
tmdc[tmb-1, tma-1] = tmc
q, k = list(map(int, input().rstrip('\n').split()))
ql = [[0, k-1]]
ql = collections.deque(ql)
fq = collections.defaultdict(int)
fq[k-1]
while True:
if len(ql) != 0:
cost, tmp = ql.popleft()
for tmv in tmd[tmp]:
if tmv not in fq or cost + tmdc[tmp, tmv] < fq[tmv]:
ql.append([cost + tmdc[tmp, tmv], tmv])
fq[tmv] = cost + tmdc[tmp, tmv]
else:
break
for i in range(q):
x, y = list(map(int, input().rstrip('\n').split()))
print((fq[x-1] + fq[y-1]))
if __name__ == '__main__':
solve()
| p03634 |
import sys
sys.setrecursionlimit(10**7)
n = int(eval(input()))
l = [[] for _ in range(n)]
for _ in range(n-1):
a, b, c = list(map(int, input().split()))
l[a-1].append([b-1, c])
l[b-1].append([a-1, c])
q, k = list(map(int, input().split()))
dist = [-1]*n
dist[k-1] = 0
def dfs(v):
for nv, c in l[v]:
if dist[nv] == -1:
dist[nv] = dist[v]+c
dfs(nv)
dfs(k-1)
for _ in range(q):
x, y = list(map(int, input().split()))
print((dist[x-1] + dist[y-1])) | import sys
sys.setrecursionlimit(10**7)
n = int(eval(input()))
l = [[] for _ in range(n)]
for _ in range(n-1):
a, b, c = list(map(int, input().split()))
l[a-1].append((b-1, c))
l[b-1].append((a-1, c))
q, k = list(map(int, input().split()))
dist = [-1]*n
dist[k-1] = 0
def dfs(v):
for nv, c in l[v]:
if dist[nv] == -1:
dist[nv] = dist[v]+c
dfs(nv)
dfs(k-1)
for _ in range(q):
x, y = list(map(int, input().split()))
print((dist[x-1] + dist[y-1]))
| p03634 |
import sys
sys.setrecursionlimit(10**9)
n = int(eval(input()))
adjacency = [[] for i in range(n+1)] #adjacency[i]は頂点iと隣接する頂点のリスト
distance = {} # distance[(i,j)](i,jは隣接した頂点)は頂点i,jを結ぶ辺の長さ
for i in range(n-1):
line = list(map(int, input().split()))
adjacency[line[0]].append(line[1])
adjacency[line[1]].append(line[0])
distance[(line[0], line[1])] = line[2]
distance[(line[1], line[0])] = line[2]
q, k = list(map(int, input().split()))
x = []
y = []
for i in range(q):
line = list(map(int, input().split()))
x.append(line[0])
y.append(line[1])
k_distance = [-1 for i in range(n+1)] # k_distance[i]は頂点i,kの距離
k_distance[k] = 0
reached = {k}
def dfs(v, d): # 現在いる頂点vと頂点v,k間の距離dを入力すると頂点vと隣接する未到達の頂点のk_distanceを計算してappendする
for neighbor in adjacency[v]:
if not neighbor in reached:
reached.add(neighbor)
k_distance[neighbor] = d + distance[(v, neighbor)]
dfs(neighbor, k_distance[neighbor])
return
dfs(k, 0)
for i in range(q):
print((k_distance[x[i]] + k_distance[y[i]]))
| import sys
sys.setrecursionlimit(10**6)
from sys import stdin
input = stdin.readline
n = int(eval(input()))
adjacency = [[] for i in range(n+1)] #adjacency[i]は頂点iと隣接する頂点のリスト
distance = {} # distance[(i,j)](i,jは隣接した頂点)は頂点i,jを結ぶ辺の長さ
for i in range(n-1):
line = list(map(int, input().split()))
adjacency[line[0]].append(line[1])
adjacency[line[1]].append(line[0])
distance[(line[0], line[1])] = line[2]
distance[(line[1], line[0])] = line[2]
q, k = list(map(int, input().split()))
x = []
y = []
for i in range(q):
line = list(map(int, input().split()))
x.append(line[0])
y.append(line[1])
k_distance = [-1 for i in range(n+1)] # k_distance[i]は頂点i,kの距離
k_distance[k] = 0
reached = {k}
def dfs(v, d): # 現在いる頂点vと頂点v,k間の距離dを入力すると頂点vと隣接する未到達の頂点のk_distanceを計算してappendする
for neighbor in adjacency[v]:
if not neighbor in reached:
reached.add(neighbor)
k_distance[neighbor] = d + distance[(v, neighbor)]
dfs(neighbor, k_distance[neighbor])
return
dfs(k, 0)
for i in range(q):
print((k_distance[x[i]] + k_distance[y[i]]))
| p03634 |
import heapq
N = int(eval(input()))
es = [[] 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
es[a].append((b,c))
es[b].append((a,c))
Q,K = list(map(int, input().split()))
K -= 1
INF = float('inf')
ds = [INF for i in range(N)]
ds[K] = 0
visited = [0 for i in range(N)]
q = [K]
heapq.heapify(q)
while q:
now = heapq.heappop(q)
visited[now] = 1
for to,cost in es[now]:
ds[to] = min(ds[to], ds[now]+cost)
if visited[to]: continue
heapq.heappush(q,to)
for i in range(Q):
x,y = list(map(int, input().split()))
x,y = x-1, y-1
print((ds[x] + ds[y]))
| import heapq
N = int(eval(input()))
src = [tuple(map(int,input().split())) for i in range(N-1)]
Q,K = list(map(int,input().split()))
K -= 1
qs = [tuple(map(int,input().split())) for i in range(Q)]
es = [[] for i in range(N)]
for a,b,c in src:
a,b = a-1,b-1
es[a].append((c,b))
es[b].append((c,a))
INF = float('inf')
dists = [INF] * N
dists[K] = 0
hq = [(0,K)]
heapq.heapify(hq)
while hq:
dist,v = heapq.heappop(hq)
dists[v] = dist
for dd,to in es[v]:
if dists[to] != INF: continue
heapq.heappush(hq, (dist+dd, to))
for a,b in qs:
a,b = a-1,b-1
print((dists[a] + dists[b])) | p03634 |
import sys
from functools import lru_cache
sys.setrecursionlimit(10**6)
@lru_cache(maxsize=1000)
def dfs(v,p,d):
for i, j in tree[v]:
if i != p:
depth[i] = d + j
dfs(i,v,d+j)
N = int(eval(input()))
tree = [[] for _ in range(N)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
tree[a].append((b,c))
tree[b].append((a,c))
Q, K = list(map(int, input().split()))
depth = [0 for i in range(N)]
depth[K-1] = 0
dfs(K-1,-1,0)
for _ in range(Q):
x, y = list(map(int, input().split()))
print((depth[x-1] + depth[y-1])) | import sys
sys.setrecursionlimit(10**6)
def dfs(v,p,d):
for i, j in tree[v]:
if i != p:
depth[i] = d + j
dfs(i,v,d+j)
N = int(eval(input()))
tree = [[] for _ in range(N)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
tree[a].append((b,c))
tree[b].append((a,c))
Q, K = list(map(int, input().split()))
depth = [0 for i in range(N)]
depth[K-1] = 0
dfs(K-1,-1,0)
for _ in range(Q):
x, y = list(map(int, input().split()))
print((depth[x-1] + depth[y-1])) | p03634 |
import heapq
def dijkstra(graph, node, start):
dist = [float("inf") for _ in range(node)]
dist[start] = 0
q = []
heapq.heappush(q, (0, start))
while q:
cost, cur_node = heapq.heappop(q)
if dist[cur_node] < cost:
continue
for nex_cost, nex_node in graph[cur_node]:
dist_cand = dist[cur_node] + nex_cost
if dist_cand < dist[nex_node]:
dist[nex_node] = dist_cand
heapq.heappush(q, (dist[nex_node], nex_node))
return dist
n = int(eval(input()))
adj = [[] for _ in range(n)]
for i in range(n - 1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
adj[a].append((c, b))
adj[b].append((c, a))
q, k = list(map(int, input().split()))
k -= 1
shortest = []
for i in range(n):
shortest.append(dijkstra(adj, n, i))
for i in range(q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
print((shortest[x][k] + shortest[y][k])) | import heapq
def dijkstra(graph, node, start):
dist = [float("inf") for _ in range(node)]
dist[start] = 0
q = []
heapq.heappush(q, (0, start))
while q:
cost, cur_node = heapq.heappop(q)
if dist[cur_node] < cost:
continue
for nex_cost, nex_node in graph[cur_node]:
dist_cand = dist[cur_node] + nex_cost
if dist_cand < dist[nex_node]:
dist[nex_node] = dist_cand
heapq.heappush(q, (dist[nex_node], nex_node))
return dist
n = int(eval(input()))
adj = [[] for _ in range(n)]
for i in range(n - 1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
adj[a].append((c, b))
adj[b].append((c, a))
q, k = list(map(int, input().split()))
shortest = dijkstra(adj, n, k - 1)
for i in range(q):
x, y = list(map(int, input().split()))
print((shortest[x - 1] + shortest[y - 1])) | p03634 |
# -*- coding: utf-8 -*-
"""
http://abc070.contest.atcoder.jp/tasks/abc070_d
"""
from enum import Enum
class Sssp(object):
""" single source shortest path """
INFINITY = 999999999999
class Status(Enum):
""" ノードの訪問状態 """
white = 1 # 未訪問
gray = 2 # 訪問中
black = 3 #訪問済
def __init__(self, N, data):
num_of_nodes = N+1
self.color = [Sssp.Status.white] * num_of_nodes # 各ノードの訪問状態
self.M = [[Sssp.INFINITY] * num_of_nodes for _ in range(num_of_nodes)]
self._make_matrix(data) # dataから作成した隣接行列(未接続部分はコスト無限大に変換済)
self.d = [Sssp.INFINITY] * num_of_nodes # 始点からの重み
self.p = [-1] * num_of_nodes # 各頂点の親の番号を記録するための配列
def _make_matrix(self, data):
""" 重み付き有効グラフの隣接行列を作成する
入力データは先頭2つが自ノード番号と出次数、以降は出次数の分だけ(接続先ID, 重み)のペアが続く
"""
for my_id, to_id, cost in data:
self.M[my_id][to_id] = cost
self.M[to_id][my_id] = cost
def dijkstra(self, start):
self.d[start] = 0
self.p[start] = -1
while True:
mincost = Sssp.INFINITY
# 以降の処理で親ノードとして働くノードuを選択する
for i in range(len(self.d)):
if self.color[i] != Sssp.Status.black and self.d[i] < mincost: # Sに属しておらず、Sと接続があるノードのうち重みが最小のものを選択
mincost = self.d[i]
u = i # uが親ノードのID
if mincost == Sssp.INFINITY:
break
self.color[u] = Sssp.Status.black # ノードuはSに属している側に
for v in range(len(self.d)):
if self.color[v] != Sssp.Status.black and self.M[u][v] != Sssp.INFINITY:
# vへの重みを考えた時、新たにSに加わったuからの経路の方が重みが低ければ、その情報で更新する
if self.d[u] + self.M[u][v] < self.d[v]:
self.d[v] = self.d[u] + self.M[u][v]
self.p[v] = u
self.color[v] = Sssp.Status.gray
def main():
# データの入力
N = int(eval(input()))
data = []
for i in range(N-1):
data.append(list(map(int, input().split(' '))))
queries = []
Q, K = [int(x) for x in input().split(' ')]
for i in range(Q):
queries.append([int(x) for x in input().split(' ')])
# 経路の探索
s = Sssp(N, data)
s.dijkstra(K)
# 結果の表示
for q in queries:
print((s.d[q[0]] + s.d[q[1]]))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
"""
http://abc070.contest.atcoder.jp/tasks/abc070_d
"""
# TLEするので、ダイクストラのアルゴリズムからの高速化が必要。
# 隣接行列をやめて隣接リストにしたところ、だいぶ速度が改善された。しかし、今度はWAが出るようになった。
from enum import Enum
from heapq import heappush, heappop
class Sssp(object):
""" single source shortest path """
class Status(Enum):
""" ノードの訪問状態 """
white = 1 # 未訪問
gray = 2 # 訪問中
black = 3 #訪問済
def __init__(self, N, data):
num_of_nodes = N+1
self.color = [Sssp.Status.white] * num_of_nodes # 各ノードの訪問状態
self.d = [float('inf')] * num_of_nodes # 始点からの重み
self.adj = [[] for _ in range(num_of_nodes)]
self.make_adj(data)
def make_adj(self, data):
# 隣接リストの作成 (接続先 コスト)のタプル
for f, t, c in data:
self.adj[f].insert(0, (t, c))
self.adj[t].insert(0, (f, c))
def dijkstra(self, start):
self.d[start] = 0
pq = [(0, start)]
#heappush(pq, (0, start))
while pq:
cost, u = heappop(pq)
self.color[u] = Sssp.Status.black
if self.d[u] < cost:
continue
for v, c in self.adj[u]:
if self.color[v] == Sssp.Status.black:
continue
if self.d[v] > self.d[u] + c:
self.d[v] = self.d[u] + c
heappush(pq, (self.d[v], v))
self.color[v] = Sssp.Status.gray
def main():
# データの入力
N = int(eval(input()))
data = []
for i in range(N-1):
data.append(list(map(int, input().split(' '))))
queries = []
Q, K = [int(x) for x in input().split(' ')]
for i in range(Q):
queries.append([int(x) for x in input().split(' ')])
# 経路の探索
s = Sssp(N, data)
s.dijkstra(K)
# 結果の表示
for q in queries:
print((s.d[q[0]] + s.d[q[1]]))
if __name__ == '__main__':
main()
| p03634 |
n=int(eval(input()))
l=[[] for i in range(n)]
for i in range(n-1):
a,b,c=list(map(int,input().split()))
l[a-1].append([b-1,c])
l[b-1].append([a-1,c])
ans=[-1]*n
q,k=list(map(int,input().split()))
ans[k-1]=0
from collections import deque
d=deque([k-1])
while d:
now=d.pop()
for x in l[now]:
a,b=x
if ans[a]<0:
ans[a]=ans[now]+b
d.appendleft(a)
for i in range(q):
a,b=list(map(int,input().split()))
print((ans[a-1]+ans[b-1])) | import sys
from collections import deque
input = sys.stdin.readline
n=int(eval(input()))
l=[[] for i in range(n)]
for i in range(n-1):
a,b,c=list(map(int,input().split()))
l[a-1].append([b-1,c])
l[b-1].append([a-1,c])
ans=[-1]*n
q,k=list(map(int,input().split()))
ans[k-1]=0
d=deque([k-1])
while d:
now=d.pop()
for x in l[now]:
a,b=x
if ans[a]<0:
ans[a]=ans[now]+b
d.appendleft(a)
for i in range(q):
a,b=list(map(int,input().split()))
print((ans[a-1]+ans[b-1])) | p03634 |
# -*- coding: utf-8 -*-
from collections import deque
def inpl(): return list(map(int, input().split()))
N = int(eval(input()))
G = [[] for _ in range(N+1)]
for _ in range(N-1):
a, b, c = inpl()
G[a].append((b, c))
G[b].append((a, c))
D = [0] * (N+1)
Q, K = inpl()
DQ = deque([K])
visited = [False]*(N+1)
while DQ:
p = DQ.popleft()
visited[p] = True
for q, c in G[p]:
if not visited[q]:
D[q] = D[p] + c
DQ.append(q)
for _ in range(Q):
x, y = inpl()
print((D[x] + D[y])) | # -*- coding: utf-8 -*-
from collections import deque
def inpl(): return list(map(int, input().split()))
N = int(eval(input()))
G = [[] for _ in range(N+1)]
for _ in range(N-1):
a, b, c = inpl()
G[a].append((b, c))
G[b].append((a, c))
Q, K = inpl()
def BFS(G, K):
DQ = deque([K])
D = [0] * (N+1)
visited = [False]*(N+1)
while DQ:
p = DQ.popleft()
visited[p] = True
for q, c in G[p]:
if not visited[q]:
D[q] = D[p] + c
DQ.append(q)
return D
D = BFS(G, K)
for _ in range(Q):
x, y = inpl()
print((D[x] + D[y])) | p03634 |
import sys
sys.setrecursionlimit(1000000)
n=int(eval(input()))
visitedlist=[-1 for i in range(n)]
kilist=[[] for i in range(n)]
anslist=[0 for i in range(n)]
searchedlist=[-1 for i in range(n)]
for i in range(n-1):
a,b,c=list(map(int,input().split()))
kilist[a-1].append((b,c))
kilist[b-1].append((a,c))
def search(i):
searchedlist[i-1]=1
visitedlist[i-1]=1
flag=0
for j in kilist[i-1]:
if visitedlist[j[0]-1]<0:
visitedlist[j[0]-1]=1
flag+=1
anslist[j[0]-1]=anslist[i-1]+j[1]
else:
pass
if flag>0:
for k in kilist[i-1]:
if searchedlist[k[0]-1]==-1:
search(k[0])
q,k=list(map(int,input().split()))
List=[0 for i in range(q)]
search(k)
for i in range(q):
x,y=list(map(int,input().split()))
List[i]=anslist[x-1]+anslist[y-1]
for j in List:
print(j)
| import sys
input=sys.stdin.readline
sys.setrecursionlimit(1000000)
n=int(eval(input()))
visitedlist=[-1 for i in range(n)]
kilist=[[] for i in range(n)]
anslist=[0 for i in range(n)]
searchedlist=[-1 for i in range(n)]
for i in range(n-1):
a,b,c=list(map(int,input().split()))
kilist[a-1].append((b,c))
kilist[b-1].append((a,c))
def search(i):
searchedlist[i-1]=1
visitedlist[i-1]=1
flag=0
for j in kilist[i-1]:
if visitedlist[j[0]-1]<0:
visitedlist[j[0]-1]=1
flag+=1
anslist[j[0]-1]=anslist[i-1]+j[1]
else:
pass
if flag>0:
for k in kilist[i-1]:
if searchedlist[k[0]-1]==-1:
search(k[0])
q,k=list(map(int,input().split()))
List=[0 for i in range(q)]
search(k)
for i in range(q):
x,y=list(map(int,input().split()))
List[i]=anslist[x-1]+anslist[y-1]
for j in List:
print(j)
| p03634 |
N = int(eval(input()))
M = N-1
inf = float("inf")
dp = [[inf]*N for _ in [0]*N]
for i in range(N):dp[i][i] = 0
q = [list(map(int, input().split())) for i in range(M)]
Q , K = list(map(int, input().split()))
p = [list(map(int, input().split())) for i in range(Q)]
ans = 0
for a,b,c in q:
dp[a-1][b-1] = c
dp[b-1][a-1] = c
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])
for a,b in p:
print((dp[a-1][K-1]+dp[K-1][b-1]))
| N = int(eval(input()))
tree = [[] for _ in range(N)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
tree[a].append((b, c))
tree[b].append((a, c))
Q, K = list(map(int, input().split()))
K -= 1
depth = [0 for _ in range(N)]
def dfs(v, p = -1, d = 0):
St = []
St.append([v, p, d])
# 空のシーケンスは偽になる
while St:
cur = St.pop()
depth[cur[0]] = cur[2]
for i, j in tree[cur[0]]:
if i == cur[1]:
continue
St.append([i, cur[0], cur[2] + j])
dfs(K)
for i in range(Q):
x, y = list(map(int, input().split()))
x -= 1; y -= 1
print((depth[x] + depth[y]))
| p03634 |
import queue
N = int(eval(input()))
tree = [[] for _ in range(N)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
tree[a].append((b, c))
tree[b].append((a, c))
Q, K = list(map(int, input().split()))
K -= 1
depth = [0 for _ in range(N)]
def bfs(v, p = -1, d = 0):
q = queue.Queue()
q.put([v, p, d])
while not q.empty():
cur = q.get()
depth[cur[0]] = cur[2]
for i, j in tree[cur[0]]:
if i == cur[1]:
continue
q.put([i, cur[0], cur[2] + j])
bfs(K)
for i in range(Q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
print((depth[x] + depth[y])) |
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()))
a -= 1
b -= 1
tree[a].append((b, c))
tree[b].append((a, c))
Q, K = list(map(int, input().split()))
K -= 1
depth = [0 for _ in range(N)]
def bfs(v, p = -1, d = 0):
q = deque()
q.append([v, p, d])
while len(q)>0:
cur = q.popleft()
depth[cur[0]] = cur[2]
for i, j in tree[cur[0]]:
if i == cur[1]:
continue
q.append([i, cur[0], cur[2] + j])
bfs(K)
for i in range(Q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
print((depth[x] + depth[y])) | p03634 |
from collections import deque
#
# N = 5
# ARR = [
# [1, 2, 1],
# [1, 3, 1],
# [2, 4, 1],
# [3, 5, 1]
# ]
#
# Q, K = 3, 1
#
# BRR = [
# [2, 4],
# [2, 3],
# [4, 5],
# ]
#
#
# N = 7
# ARR = [
# [1, 2, 1],
# [1, 3, 3],
# [1, 4, 5],
# [1, 5, 7],
# [1, 6, 9],
# [1, 7, 11],
# ]
#
# Q, K = 3, 2
#
# BRR = [
# [1, 3],
# [4, 5],
# [6, 7],
# ]
#
#
# N = 10
# ARR = [
# [1, 2, 1000000000],
# [2, 3, 1000000000],
# [3, 4, 1000000000],
# [4, 5, 1000000000],
# [5, 6, 1000000000],
# [6, 7, 1000000000],
# [7, 8, 1000000000],
# [8, 9, 1000000000],
# [9, 10, 1000000000]
# ]
#
# Q, K = 1, 1
#
# BRR = [
# [9, 10]
# ]
N = int(eval(input()))
ARR = [list(map(int,input().split())) for i in range(N-1)]
Q, K = list(map(int,input().split()))
BRR = [list(map(int,input().split())) for i in range(Q)]
def prepare(n, arr):
links = {}
nodeStatus = {}
distances = {}
finalDistance = {}
for i in range(1, N + 1):
nodeStatus.__setitem__(i, False)
finalDistance.__setitem__(i, 0)
for i in range(len(arr)):
tmp = arr[i]
startNode = tmp[0]
endNode = tmp[1]
distance = tmp[2]
distances.__setitem__((startNode, endNode), distance)
distances.__setitem__((endNode, startNode), distance)
if links.get(startNode) == None:
links.__setitem__(startNode, [endNode])
else:
tmpChild = links.get(startNode)
tmpChild.append(endNode)
links.__setitem__(startNode, tmpChild)
if links.get(endNode) == None:
links.__setitem__(endNode, [startNode])
else:
tmpChild = links.get(endNode)
tmpChild.append(startNode)
links.setdefault(endNode, tmpChild)
return links, nodeStatus, distances, finalDistance
def bfs(startNode):
q = deque()
q.append((startNode, 0))
while len(q):
currentNode, dist = q.popleft()
finalDistance.__setitem__(currentNode, dist)
nodeStatus.__setitem__(currentNode, True)
childNodes = links.get(currentNode)
for childNode in childNodes:
if nodeStatus.get(childNode) == False:
q.append((childNode, dist + distances.get((currentNode, childNode))))
links, nodeStatus, distances, finalDistance = prepare(N, ARR)
# print(links)
# print(nodeStatus)
# print(distances)
# print(finalDistance)
bfs(K)
for i in range(Q):
dist1 = finalDistance[BRR[i][0]]
dist2 = finalDistance[BRR[i][1]]
print((dist1 + dist2)) | import sys
sys.setrecursionlimit(20000000)
# N = 5
# ARR = [
# [1, 2, 1],
# [1, 3, 1],
# [2, 4, 1],
# [3, 5, 1]
# ]
#
# Q, K = 3, 1
#
# BRR = [
# [2, 4],
# [2, 3],
# [4, 5],
# ]
#
#
N = int(eval(input()))
ARR = [list(map(int,input().split())) for i in range(N-1)]
Q, K = list(map(int,input().split()))
BRR = [list(map(int,input().split())) for i in range(Q)]
def prepare(arr, n):
links = [[] for i in range(n)]
depth = [0 for i in range(n)]
for i in range(n - 1):
startNode = arr[i][0] - 1
endNode = arr[i][1] - 1
dist = arr[i][2]
links[startNode].append((endNode, dist))
links[endNode].append((startNode, dist))
return links, depth
def dfs(currentNode, parrentNode=-1, dist=0):
childNodes = links[currentNode]
depths[currentNode] = dist
for (childNode, childDistance) in childNodes:
if childNode == parrentNode:
continue
dfs(childNode, currentNode, dist + childDistance)
links, depths = prepare(ARR, N)
dfs(K - 1)
for i in range(Q):
p1 = BRR[i][0] - 1
p2 = BRR[i][1] - 1
d1 = depths[p1]
d2 = depths[p2]
print((d1 + d2)) | p03634 |
import heapq
N = int(eval(input()))
G = [[] for _ in range(N)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
G[a - 1].append([c, b - 1])
G[b - 1].append([c, a - 1])
Q, K = list(map(int, input().split()))
def dijkstra(s, N, G, x, y):
d = [20 ** 9] * N
d[s] = 0
hq = [[0, s]]
heapq.heapify(hq)
while len(hq) > 0:
v, i = heapq.heappop(hq)
if d[i] < v:
continue
for c, j in G[i]:
if d[j] > d[i] + c:
d[j] = d[i] + c
heapq.heappush(hq, [d[j], j])
return d[x] + d[y]
dist = [0] * Q
for i in range(Q):
x, y = list(map(int, input().split()))
dist[i] = dijkstra(K - 1, N, G, x - 1, y - 1)
for d in dist:
print(d) | import heapq
N = int(eval(input()))
G = [[] for _ in range(N)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
G[a - 1].append([c, b - 1])
G[b - 1].append([c, a - 1])
Q, K = list(map(int, input().split()))
def dijkstra(s, N, G):
d = [float('inf')] * N
d[s] = 0
hq = [[0, s]]
heapq.heapify(hq)
while len(hq) > 0:
v, i = heapq.heappop(hq)
if d[i] < v:
continue
for c, j in G[i]:
if d[j] > d[i] + c:
d[j] = d[i] + c
heapq.heappush(hq, [d[j], j])
return d
D = dijkstra(K - 1, N, G)
dist = [0] * Q
for i in range(Q):
x, y = list(map(int, input().split()))
dist[i] = D[x - 1] + D[y - 1]
for d in dist:
print(d) | p03634 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
INF = 10**5
n = int(eval(input()))
graph = [[] for _ in range(n+1)]
d = [[INF]*(n+1) for _ in range(n+1)]
for _ in range(n-1):
a, b, c = list(map(int, input().split()))
d[a][b] = d[b][a] = c
graph[a].append(b)
graph[b].append(a)
q, k = list(map(int, input().split()))
dist = [INF]*(n+1)
def dfs(v1, parent, add):
dist[v1] = add
for v2 in graph[v1]:
if v2 == parent:
continue
dfs(v2, v1, add + d[v1][v2])
dfs(k, -1, 0)
for _ in range(q):
x, y = list(map(int, input().split()))
print((dist[x]+dist[y]))
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
INF = 10**9+1
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, c))
graph[b].append((a, c))
q, k = list(map(int, input().split()))
dist = [INF]*(n+1)
def dfs(v1, parent, add):
dist[v1] = add
for v2, d in graph[v1]:
if v2 == parent:
continue
dfs(v2, v1, add + d)
dfs(k, -1, 0)
for _ in range(q):
x, y = list(map(int, input().split()))
print((dist[x]+dist[y]))
| p03634 |
import sys
import heapq
input = sys.stdin.readline
n = int(eval(input()))
edges = [[]for _ in range(n)]
for _ in range(n-1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
edges[a].append((c, b))
edges[b].append((c, a))
INF = float('inf')
def dijkstra(init_v):
dist = [INF]*n
dist[init_v] = 0
tasks = [(0, init_v)]
while tasks:
d, v = heapq.heappop(tasks)
if dist[v] < d:
continue
for d2, v2 in edges[v]:
if dist[v2] <= dist[v]+d2:
continue
dist[v2] = dist[v]+d2
heapq.heappush(tasks, ((dist[v2], v2)))
return dist
q, k = list(map(int, input().split()))
dist = dijkstra(k-1)
for _ in range(q):
x, y = [int(x)-1 for x in input().split()]
print((dist[x]+dist[y])) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
n = int(eval(input()))
edges = [[]for _ in range(n)]
for _ in range(n-1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
edges[a].append((c, b))
edges[b].append((c, a))
INF = float('inf')
def dfs(v, parent, distance):
dist[v] = distance
for d, v2 in edges[v]:
if parent == v2:
continue
dfs(v2, v, distance+d)
q, k = list(map(int, input().split()))
dist = [INF]*n
dfs(k-1, -1, 0)
for _ in range(q):
x, y = [int(x)-1 for x in input().split()]
print((dist[x]+dist[y])) | p03634 |
import heapq
n = int(eval(input()))
g = [[] for _ 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))
ans = []
q, k = list(map(int, input().split()))
for i in range(q):
x, y = list(map(int, input().split()))
res = 0
# x -> k
dis = [float("inf")] * n
dis[x-1] = 0
pq = [(0, x-1)]
while pq:
d, node = heapq.heappop(pq)
if d > dis[node]: continue
for nxt, cost in g[node]:
if d + cost < dis[nxt]:
dis[nxt] = d + cost
heapq.heappush(pq, (dis[nxt], nxt))
res += dis[k-1]
# k -> y
dis = [float("inf")] * n
dis[k-1] = 0
pq = [(0, k-1)]
while pq:
d, node = heapq.heappop(pq)
if d > dis[node]: continue
for nxt, cost in g[node]:
if d + cost < dis[nxt]:
dis[nxt] = d + cost
heapq.heappush(pq, (dis[nxt], nxt))
res += dis[y-1]
ans.append(res)
print(("\n".join(map(str, ans)))) | import heapq
n = int(eval(input()))
g = [[] for _ 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()))
dis = [float("inf")] * n
dis[k-1] = 0
pq = [(0, k-1)]
while pq:
d, node = heapq.heappop(pq)
if d > dis[node]: continue
for nxt, cost in g[node]:
if d + cost < dis[nxt]:
dis[nxt] = d + cost
heapq.heappush(pq, (dis[nxt], nxt))
ans = []
for i in range(q):
x, y = list(map(int, input().split()))
ans.append(dis[x-1]+dis[y-1])
print(("\n".join(map(str, ans))))
| p03634 |
import queue
from sys import stdin
input = stdin.readline
N = int(input())
tree = [[] for _ in range(N)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
a -= 1; b -= 1;
tree[a].append((b, c))
tree[b].append((a, c))
Q, K = list(map(int, input().split()))
K -= 1
d = [float("inf") for _ in range(N)]
def dijkstra(s):
que = queue.PriorityQueue()
d[s] = 0
que.put([0, s])
while not que.empty():
p = que.get()
v = p[1]
if d[v] < p[0]:
continue
for i, j in tree[v]:
if d[i] > d[v] + j:
d[i] = d[v] + j
que.put([d[i], i])
dijkstra(K)
for i in range(Q):
x, y = list(map(int, input().split()))
x -= 1; y -= 1
print(d[x] + d[y])
| #!/usr/bin/env python2
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(200000)
N = int(input())
tree = [[] for _ in range(N)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
a -= 1; b -= 1;
tree[a].append((b, c))
tree[b].append((a, c))
Q, K = list(map(int, input().split()))
K -= 1
depth = [0 for _ in range(N)]
def dfs(v, p = -1, d = 0):
depth[v] = d
for i, j in tree[v]:
if i == p:
continue
dfs(i, v, d + j)
dfs(K)
for i in range(Q):
x, y = list(map(int, input().split()))
x -= 1; y -= 1
print(depth[x] + depth[y]) | p03634 |
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
import queue
N = int(input())
tree = [[] for _ in range(N)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
a -= 1; b -= 1;
tree[a].append((b, c))
tree[b].append((a, c))
Q, K = list(map(int, input().split()))
K -= 1
d = [float("inf") for _ in range(N)]
def dijkstra(s):
que = queue.PriorityQueue()
d[s] = 0
que.put([0, s])
while not que.empty():
p = que.get()
v = p[1]
if d[v] < p[0]:
continue
for i, j in tree[v]:
if d[i] > d[v] + j:
d[i] = d[v] + j
que.put([d[i], i])
dijkstra(K)
for i in range(Q):
x, y = list(map(int, input().split()))
x -= 1; y -= 1
print(d[x] + d[y]) | #!/usr/bin/env python2
# -*- coding: utf-8 -*-
N = int(input())
tree = [[] for _ in range(N)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
a -= 1; b -= 1;
tree[a].append((b, c))
tree[b].append((a, c))
Q, K = list(map(int, input().split()))
K -= 1
depth = [0 for _ in range(N)]
def dfs(v, p = -1, d = 0):
St = []
St.append([v, p, d])
# 空のシーケンスは偽になる
while St:
cur = St.pop()
depth[cur[0]] = cur[2]
for i, j in tree[cur[0]]:
if i == cur[1]:
continue
St.append([i, cur[0], cur[2] + j])
dfs(K)
for i in range(Q):
x, y = list(map(int, input().split()))
x -= 1; y -= 1
print(depth[x] + depth[y])
| p03634 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
from collections import deque
def getN():
return int(eval(input()))
def getList():
return list(map(int, input().split()))
import math
n = getN()
vtxs = [[] for i in range(n)]
dist = [0 for i in range(n)]
visit = [0 for i in range(n)]
for i in range(n-1):
a,b,c = getList()
vtxs[a-1].append((b-1 ,c))
vtxs[b-1].append((a-1 ,c))
ques, k = getList()
from collections import deque
q = deque([k-1])
visit[k-1] = 1
while(q):
cur = q.popleft()
cdist = dist[cur]
for nx in vtxs[cur]:
nxa, nxc = nx
if visit[nxa] == 0:
dist[nxa] = cdist + nxc
visit[nxa] = 1
q.append(nxa)
for i in range(ques):
x, y = getList()
print((dist[x-1] + dist[y-1])) | import sys
# from collections import defaultdict, deque
import math
# import copy
# from bisect import bisect_left, bisect_right
import heapq
# sys.setrecursionlimit(1000000)
# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(eval(input()))
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]
INF = 10 ** 20
MOD = 1000000007
def dijkstra(graph, start, n):
h = []
heapq.heappush(h, (0, start))
costs = [INF for _ in range(n)]
while h:
cost, cur = heapq.heappop(h)
if costs[cur] != INF:
continue
costs[cur] = cost
for edge in graph[cur]:
ecost, tgt = edge
if costs[tgt] == INF:
heapq.heappush(h, (cost + ecost, tgt))
return costs
def solve():
n = getN()
graph = [[] for _ in range(n)]
for i in range(n-1):
a,b,c = getList()
a,b = a-1, b-1
graph[a].append([c, b])
graph[b].append([c, a])
q, k = getList()
costs = dijkstra(graph, k-1, n)
# print(costs)
for i in range(q):
s, e = getZList()
print((costs[s] + costs[e]))
return
def main():
n = getN()
for _ in range(n):
solve()
if __name__ == "__main__":
# main()
solve()
| p03634 |
import heapq
V = int(eval(input()))
E = V - 1
G = {}
for i in range(V):
G[i] = {}
for _ in range(E):
s, t, c = [int(_) for _ in input().split()]
s -= 1 # 0-indexed
t -= 1 # 0-indexed
G[s][t] = c
G[t][s] = c
Q, K = [int(_) for _ in input().split()]
K -= 1 # 0-indexed
XY = [[int(_) for _ in input().split()] for _ in range(Q)]
INF = float('inf')
que = []
i = K
d = 0
D = [INF] * V
D[i] = 0
used = [False] * V
used[i] = True
while True:
for j in list(G[i].keys()):
heapq.heappush(que, (d + G[i][j], j))
v = -1
while que:
d, j = heapq.heappop(que)
if not used[j]:
v = j
break
if v == -1:
break
else:
used[v] = True
D[v] = d
i = v
for x, y in XY:
x -= 1 # 0-indexed
y -= 1 # 0-indexed
print((D[x] + D[y])) | V = int(eval(input()))
E = V - 1
G = {}
for i in range(V):
G[i] = {}
for _ in range(E):
s, t, c = [int(_) for _ in input().split()]
s -= 1 # 0-indexed
t -= 1 # 0-indexed
G[s][t] = c
G[t][s] = c
Q, K = [int(_) for _ in input().split()]
K -= 1 # 0-indexed
XY = [[int(_) for _ in input().split()] for _ in range(Q)]
INF = float('inf')
D = [INF] * V
D[K] = 0
cand = []
for j in list(G[K].keys()):
cand += [(K, j)]
while True:
if cand:
x, y = cand.pop()
if D[y] == INF:
D[y] = D[x] + G[x][y]
for z in list(G[y].keys()):
cand += [(y, z)]
else:
break
for x, y in XY:
x -= 1
y -= 1
print((D[x] + D[y]))
| p03634 |
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby
#from itertools import product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil
#from operator import itemgetter
#inf = 10**17
#mod = 10**9 + 7
N = int(eval(input()))
def dfs(v):
visited[v] = 1
for cost, nv in edge[v]:
if visited[nv] == 1:
continue
d[nv] = d[v] + cost
dfs(nv)
#N:頂点数 W:辺数
edge = [[] for i in range(N)]
#edge[i] : iから出る道の[重み,行先]の配列
for _ in range(N-1):
x,y,z = list(map(int,input().split()))
edge[x-1].append((z,y-1))
edge[y-1].append((z,x-1))
q,k = list(map(int, input().split()))
d = [-1]*N
d[k-1] = 0
visited = [0]*N
dfs(k-1)
for _ in range(q):
x,y = list(map(int, input().split()))
print((d[x-1]+d[y-1]))
if __name__ == '__main__':
main() | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby
#from itertools import product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil
#from operator import itemgetter
#inf = 10**17
#mod = 10**9 + 7
N = int(eval(input()))
inf = 10**17
def dijkstra_heap(start,edge):
#始点から各頂点への最短距離(頂点番号:0~N-1)
d = [inf]*N
used = [False]*N
d[start] = 0
used[start] = True
edgelist = []
#a:重み(//), b:次の頂点(%)
for a,b in edge[start]:
heappush(edgelist,a*(10**6)+b)
while len(edgelist):
#まだ最短距離が決まっていない頂点の中から最小の距離のものを探す
minedge = heappop(edgelist)
if used[minedge%(10**6)]:
continue
node = minedge%(10**6)
d[node] = minedge//(10**6)
used[node] = True
for e in edge[node]:
if not used[e[1]]:
heappush(edgelist,(e[0]+d[node])*(10**6)+e[1])
return d
#N:頂点数 W:辺数
edge = [[] for i in range(N)]
#edge[i] : iから出る道の[重み,行先]の配列
for _ in range(N-1):
x,y,z = list(map(int,input().split()))
edge[x-1].append((z,y-1))
edge[y-1].append((z,x-1))
q,k = list(map(int, input().split()))
d = dijkstra_heap(k-1, edge)
for _ in range(q):
x,y = list(map(int, input().split()))
print((d[x-1]+d[y-1]))
if __name__ == '__main__':
main()
| p03634 |
import sys
sys.setrecursionlimit(500000)
N = int(eval(input()))
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()))
from functools import lru_cache
@lru_cache(maxsize=None)
def dfs(start, end, dist, f=None):
if start == end:
return 0
for n, d in tree[start]:
if n == f:
continue
if n == end:
return dist + d
else:
result = dfs(n, end, dist+d, start)
if result is not None:
return result
xy = [list(map(int, input().split())) for i in range(Q)]
for i in range(Q):
x, y = xy[i]
print((dfs(x, K, 0) + dfs(K, y, 0)))
| import sys
sys.setrecursionlimit(500000)
N = int(eval(input()))
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()))
def dfs(start, dist, dists, f=None):
for n, d in tree[start]:
if n == f:
continue
dists[n] = dist + d
dfs(n, dist+d, dists, start)
xy = [list(map(int, input().split())) for i in range(Q)]
dists = [0] * (N+1)
dfs(K, 0, dists)
for i in range(Q):
x, y = xy[i]
print((dists[x] + dists[y]))
| p03634 |
import sys
sys.setrecursionlimit(500000)
N = int(eval(input()))
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()))
def dfs(start, dist, dists, f=None):
for n, d in tree[start]:
if n == f:
continue
dists[n] = dist + d
dfs(n, dist+d, dists, start)
xy = [list(map(int, input().split())) for i in range(Q)]
dists = [0] * (N+1)
dfs(K, 0, dists)
for i in range(Q):
x, y = xy[i]
print((dists[x] + dists[y]))
| import sys
sys.setrecursionlimit(500000)
import sys
def input():
return sys.stdin.readline()[:-1]
N = int(eval(input()))
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()))
def dfs(start, dist, dists, f=None):
for n, d in tree[start]:
if n == f:
continue
dists[n] = dist + d
dfs(n, dist+d, dists, start)
xy = [list(map(int, input().split())) for i in range(Q)]
dists = [0] * (N+1)
dfs(K, 0, dists)
for i in range(Q):
x, y = xy[i]
print((dists[x] + dists[y]))
| p03634 |
from collections import deque
n = int(eval(input()))
gr = { i:[] for i in range(1, n + 1)}
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
gr[a].append((b, c))
gr[b].append((a, c))
q, k = list(map(int, input().split()))
dmax = 10**14 + 1
dist = [dmax for _ in range(n + 1)]
dist[k] = 0
ls = deque([k])
while 0 < len(ls):
u = ls[0]
for v, c in gr[u]:
if dist[v] == dmax:
dist[v] = dist[u] + c
ls.append(v)
ls.popleft()
for _ in range(q):
x, y = list(map(int, input().split()))
print((dist[x] + dist[y])) | from collections import deque
n = int(eval(input()))
gr = { i:[] for i in range(1, n + 1)}
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
gr[a].append((b, c))
gr[b].append((a, c))
q, k = list(map(int, input().split()))
dmax = 10**14 + 1
dist = [dmax for _ in range(n + 1)]
dist[k] = 0
ls = deque([k])
while 0 < len(ls):
u = ls.popleft()
for v, c in gr[u]:
if dist[v] == dmax:
dist[v] = dist[u] + c
ls.append(v)
for _ in range(q):
x, y = list(map(int, input().split()))
print((dist[x] + dist[y])) | 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()))
G[a-1].append((b-1,c))
G[b-1].append((a-1,c))
q,k=list(map(int,input().split()))
k=k-1
stack=[k]
dis=[-1]*n
dis[k]=0
from collections import deque
stack=deque(stack)
while len(stack)>0:
now=stack.pop()
d=dis[now]
for i in G[now]:
if dis[i[0]]==-1:
dis[i[0]]=d+i[1]
stack.append(i[0])
for i in range(q):
x,y=list(map(int,input().split()))
x=x-1
y=y-1
print((dis[x]+dis[y]))
| 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()))
k=k-1
stack=[k]
dis=[-1]*n
dis[k]=0
while stack!=[]:
now=stack.pop()
d=dis[now]
for i in G[now]:
if dis[i[0]]==-1:
dis[i[0]]=d+i[1]
stack.append(i[0])
for i in range(q):
x,y=list(map(int,input().split()))
x=x-1
y=y-1
print((dis[x]+dis[y]))
| p03634 |
from collections import deque
N = int(input())
T = [[] for i in range(N)]
for i in range(N-1) :
u,v,c = map(int,input().split())
u -= 1
v -= 1
T[u].append([v,c])
T[v].append([u,c])
Q,K = map(int,input().split())
K -= 1
L = []
for i in range(Q) :
u,v = map(int,input().split())
u -= 1
v -= 1
L.append([u,v])
dist = [0]*N
q = deque([[K,0]])
explored = [0]*N
C = []
while q :
now,c = q.pop()
if not explored[now] :
C.append(c)
dist[now] = sum(C)
explored[now] = 1
flg = 1
while T[now] :
to, c = T[now].pop(0)
if explored[to] :
continue
q.append([now, 0])
q.append([to, c])
flg = 0
break
if flg :
if len(T[now]) == 0 :
C.pop(-1)
#print("now:", now, "C:", C)
ans = []
for i in range(Q) :
u,v = L[i]
calc = dist[u] + dist[v]
ans.append(calc)
print(*ans, sep="\n")
| import sys
sys.setrecursionlimit(10**9)
N = int(input())
T = [[] for i in range(N+1)]
for i in range(N-1) :
a,b,c = map(int,input().split())
T[a].append([b,c])
T[b].append([a,c])
Q,K = map(int,input().split())
dist = [None]*(N+1)
def dfs(now,d) :
dist[now] = d
for to,c in T[now] :
if dist[to] is not None :
continue
dfs(to,d+c)
dfs(K,0)
ans = []
for i in range(Q) :
u,v = map(int,input().split())
ans.append(dist[u]+dist[v])
print(*ans,sep="\n")
| p03634 |
### bfs ###
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N = int(eval(input()))
G = [[] for _ in range(N)]
dis = [-1]*N
que = []
for _ 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
dis[K] = 0
que.append(K) #dfs
while que:
p = que.pop(0)
for i in range(len(G[p])):
n_p, d = G[p][i]
if dis[n_p] != -1:
continue
que.append(n_p)
dis[n_p] = dis[p] + d
for i in range(Q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
ans = dis[x]+dis[y]
print(ans)
| ### dfs ###
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N = int(eval(input()))
G = [[] for _ in range(N)]
dis = [-1]*N
for _ 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
dis[K] = 0
def dfs(pos):
for n_pos, n_cost in G[pos]:
if dis[n_pos] != -1:
continue
dis[n_pos] = dis[pos]+n_cost
dfs(n_pos)
dfs(K)
for i in range(Q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
ans = dis[x]+dis[y]
print(ans)
| p03634 |
import sys
from collections import defaultdict
from heapq import heappush, heappop
def input():
return sys.stdin.readline().strip()
def dijkstra(adj_list, start):
n = len(adj_list)
dist = [float("inf")] * n
dist[start] = 0
pq = []
heappush(pq, (0, start))
visited = set()
while pq:
w, v = heappop(pq)
if dist[v] < w:
continue
visited.add(v)
for nv, nw in adj_list[v]:
if nv in visited:
continue
if dist[nv] > dist[v] + nw:
dist[nv] = dist[v] + nw
heappush(pq, (dist[nv], nv))
return dist
N = int(eval(input()))
g = defaultdict(list)
for _ 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
d = dijkstra(g, K)
ans = []
for _ in range(Q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
print((d[x] + d[y]))
| import sys
from collections import deque
def input():
return sys.stdin.readline().strip()
def bfs(start):
q = deque([start])
dist = [-1] * (N + 1)
dist[start] = 0
while q:
v = q.popleft()
for nv, nw in g[v]:
if dist[nv] > 0:
continue
dist[nv] = dist[v] + nw
q.append(nv)
return dist
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 = bfs(K)
ans = []
for _ in range(Q):
x, y = list(map(int, input().split()))
print((d[x] + d[y]))
| p03634 |
from collections import defaultdict
from collections import deque
n = int(eval(input()))
tree = 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])
def distance(x, y):
seen = set()
d = 0
stack = deque([[tree[x], d]])
flag = True
while flag:
connect, d = stack.popleft()
for i in connect:
if i[0] not in seen:
seen.add(i[0])
d += i[1]
if i[0] == y:
flag = False
break
stack.append([tree[i[0]], d])
d -= i[1]
return d
q, k = list(map(int, input().split()))
dis_l = {}
for i in range(n):
dis_l[i+1] = distance(i + 1, k)
for i in range(q):
x, y = list(map(int, input().split()))
print((dis_l[x] + dis_l[y])) | from collections import defaultdict
from collections import deque
n = int(eval(input()))
tree = 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])
def distance(k):
seen = set()
dis_l = {}
d = 0
stack = deque([[tree[k], d]])
flag = True
while stack:
connect, d = stack.popleft()
for i in connect:
if i[0] not in seen:
seen.add(i[0])
d += i[1]
dis_l[i[0]] = d
stack.append([tree[i[0]], d])
d -= i[1]
return dis_l
q, k = list(map(int, input().split()))
dis_l = distance(k)
for i in range(q):
x, y = list(map(int, input().split()))
print((dis_l[x] + dis_l[y])) | p03634 |
n = int(eval(input()))
cs = [[0] * (n + 1) for _ in range(n + 1)]
es = [[] for _ in range(n + 1)]
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
cs[a][b] = cs[b][a] = c
es[a].append(b)
es[b].append(a)
ds = [0] * (n + 1)
qs = []
def bfs():
cur, prev = qs.pop()
ds[cur] = ds[prev] + cs[prev][cur]
for e in es[cur]:
if e != prev:
qs.append((e, cur))
q, k = list(map(int, input().split()))
qs.append((k, k))
while qs:
bfs()
for _ in range(q):
x, y = list(map(int, input().split()))
print((ds[x] + ds[y])) | n = int(eval(input()))
cs = [[0] * (n + 1) for _ in range(n + 1)]
es = [[] for _ in range(n + 1)]
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
cs[a][b] = cs[b][a] = c
es[a].append(b)
es[b].append(a)
ds = [0] * (n + 1)
def dfs(cur, prev):
ds[cur] = ds[prev] + cs[prev][cur]
for e in es[cur]:
if e != prev:
dfs(e, cur)
q, k = list(map(int, input().split()))
dfs(k, k)
for _ in range(q):
x, y = list(map(int, input().split()))
print((ds[x] + ds[y])) | p03634 |
n=int(eval(input()))
edges=[[] for i in range(n)]
for i in range(n-1):
a,s,d=list(map(int,input().split()))
edges[a-1].append((s-1,d));edges[s-1].append((a-1,d))
q,k=list(map(int,input().split()))
cost=[0]*n
from collections import deque
dq=deque([])
#pop/append/(append,pop)_left/in/len/count/[]/index/rotate()(右へnずらす)
for to,cos in edges[k-1]:
dq.append((k-1,to))
cost[to]=cos
while dq:
par,now=dq.popleft()
for to,c in edges[now]:
if to!=par:
cost[to]=cost[now]+c
dq.append((now,to))
for i in range(q):
x,y=list(map(int,input().split()))
print((cost[x-1]+cost[y-1])) | import sys
input=sys.stdin.buffer.readline
sys.setrecursionlimit(10**9)
n=int(eval(input()))
edges=[[] for i in range(n)]
for i in range(n-1):
a,s,d=list(map(int,input().split()))
edges[a-1].append((s-1,d));edges[s-1].append((a-1,d))
q,k=list(map(int,input().split()))
cost=[0]*n
from collections import deque
dq=deque([])
#pop/append/(append,pop)_left/in/len/count/[]/index/rotate()(右へnずらす)
for to,cos in edges[k-1]:
dq.append((k-1,to))
cost[to]=cos
while dq:
par,now=dq.popleft()
for to,c in edges[now]:
if to!=par:
cost[to]=cost[now]+c
dq.append((now,to))
for i in range(q):
x,y=list(map(int,input().split()))
print((cost[x-1]+cost[y-1])) | p03634 |
import sys
import os
from collections import defaultdict
adj = defaultdict(list)
vis =[0 for i in range(1000000)]
dis =[0 for i in range(1000000)]
def dfs(u, p):
for v, w in adj[u]:
if v==p:
continue
dis[v]=dis[u]+w
dfs(v, u)
def main():
n = int(eval(input()))
for i in range(n-1):
a, b, w = list(map(int , input().split()))
adj[a].append((b, w))
adj[b].append((a, w))
q, k = list(map(int , input().split()))
sys.setrecursionlimit(1000000)
dfs(k , 0)
for i in range(q):
x, y =list(map(int , input().split()))
print((dis[x]+dis[y]))
# rec_limit= sys.getrecursionlimit()
# print(rec_limit)
if __name__ == "__main__":
main() | import sys
import os
from collections import defaultdict
adj = defaultdict(list)
vis =[0 for i in range(1000000)]
dis =[0 for i in range(1000000)]
# since it's a tree shortest path will be only one and unique between two node
# find distance from k to each and every node
def dfs(u, p):
for v, w in adj[u]:
if v==p:
continue
dis[v]=dis[u]+w
dfs(v, u)
def main():
n = int(eval(input()))
for i in range(n-1):
a, b, w = list(map(int , input().split()))
adj[a].append((b, w))
adj[b].append((a, w))
q, k = list(map(int , input().split()))
sys.setrecursionlimit(1000000)
dfs(k , 0)
for i in range(q):
x, y =list(map(int , input().split()))
# print the sum of the two distance from k
print((dis[x]+dis[y]))
# rec_limit= sys.getrecursionlimit()
# print(rec_limit)
if __name__ == "__main__":
main() | p03634 |
from heapq import heappop, heappush
n = int(eval(input()))
INF = 10**13
g = [[INF for __ in range(n)] for _ 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
def dijkstra(s, n, edges):
# edges[i][j] : the cost of i→j
# import 'heap'
d = [INF] * n
d[s] = 0
q = [(0, s)]
while q:
dist_u, u = heappop(q)
if d[u] < dist_u:
continue
for v, c in enumerate(edges[u]):
if d[v] > dist_u + c:
d[v] = dist_u + c
heappush(q, (d[v], v))
return d
q, k = list(map(int, input().split()))
d = dijkstra(k-1, n, g)
for _ in range(q):
x, y = list(map(int, input().split()))
print((d[x-1]+d[y-1]))
| from heapq import heappop, heappush
n = int(eval(input()))
g = [[] 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))
def dijkstra(s, n, edges):
# edges[i][j] : the cost of i→j
# import 'heap'
d = [10**18] * n
d[s] = 0
q = [(0, s)]
while q:
dist_u, u = heappop(q)
if d[u] < dist_u:
continue
for v, c in edges[u]:
if d[v] > dist_u + c:
d[v] = dist_u + c
heappush(q, (d[v], v))
return d
q, k = list(map(int, input().split()))
d = dijkstra(k-1, n, g)
for _ in range(q):
x, y = list(map(int, input().split()))
print((d[x-1]+d[y-1]))
| p03634 |
# 2019/07/11
import sys
from heapq import heappop,heappush
input=sys.stdin.readline
n=int(eval(input()))
edge=[[] for _ in range(n)]
for _ in range(n-1):
u,v,c=list(map(int,input().split()))
u-=1
v-=1
edge[u].append((c,v))
edge[v].append((c,u))
def dijkstra(s):
d=[float('inf')]*n
visited=[False]*n
d[s]=0
visited[s]=True
que=[]
for e in edge[s]:
heappush(que,e)
while que:
c,v=heappop(que)
if visited[v]:continue
d[v]=c
visited[v]=True
for cost,vtx in edge[v]:
if visited[vtx]:continue
hq=(cost+d[v],vtx)
heappush(que,hq)
return d
q,k=list(map(int,input().split()))
k-=1
res=dijkstra(k)
for _ in range(q):
x,y=list(map(int,input().split()))
x-=1
y-=1
print((res[x]+res[y]))
| # 2019/07/12
# DFS ver
import sys
sys.setrecursionlimit(10**9)
input=sys.stdin.readline
n=int(eval(input()))
edge=[[] for _ in range(n)]
for _ in range(n-1):
u,v,c=list(map(int,input().split()))
u-=1 ; v-=1
edge[u].append((c,v))
edge[v].append((c,u))
q,k=list(map(int,input().split()))
k-=1
d=[0]*n
visited=[False]*n
def dfs(s,p):
visited[s]=True
for c,v in edge[s]:
if visited[v] or p==v:continue
d[v]=c+d[s]
visited[v]=True
dfs(v,s)
return
dfs(k,-1)
for _ in range(q):
x,y=list(map(int,input().split()))
x-=1 ; y-=1
print((d[x]+d[y]))
| p03634 |
from collections import deque
n=int(input())
e=[[] for _ in range(n+1)]
l=[[0]*(n+1) for _ in range(n+1)]
dist=[-1]*(n+1)
for i in range(n-1):
a,b,c=map(int,input().split())
e[a].append(b)
e[b].append(a)
l[a][b]=c
l[b][a]=c
q,k=map(int,input().split())
a=deque()
a.append((k,0))
while a:
x,d=a.popleft()
dist[x]=d
for j in e[x]:
if dist[j]!=-1:
continue
else:
a.append((j,d+l[x][j]))
ans=[]
for i in range(q):
x,y=map(int,input().split())
ans.append(dist[x]+dist[y])
print(*ans,sep="\n")
| from collections import deque
n=int(input())
e=[[] for _ in range(n+1)]
dist=[-1]*(n+1)
for i in range(n-1):
a,b,c=map(int,input().split())
e[a].append((b,c))
e[b].append((a,c))
q,k=map(int,input().split())
a=deque()
a.append((k,0))
while a:
x,d=a.popleft()
dist[x]=d
for j,nc in e[x]:
if dist[j]!=-1:
continue
else:
a.append((j,d+nc))
ans=[]
for i in range(q):
x,y=map(int,input().split())
ans.append(dist[x]+dist[y])
print(*ans,sep="\n")
| p03634 |
#%%
n = int(eval(input()))
a, b, c = [0] * n, [0] * n, [0] * n
for i in range(n-1):
a[i], b[i], c[i] = list(map(int, input().split()))
q, k = list(map(int, input().split()))
l = [[] for _ in range(n+1)]
for i in range(n-1):
l[a[i]].append([b[i],c[i]])
l[b[i]].append([a[i],c[i]])
d = [0] * (n+1)
check = [0] * (n+1)
check[k] = 1
que = [k]
while len(que) > 0:
tmp = que.pop(0)
for i in l[tmp]:
if check[i[0]] == 0:
que.append(i[0])
check[i[0]] = 1
d[i[0]] = d[tmp] + i[1]
else:
pass
x, y = [0] * q, [0] * q
for i in range(q):
x[i], y[i] = list(map(int, input().split()))
print((d[x[i]] + d[y[i]])) | #%%
n = int(eval(input()))
a, b, c = [0] * n, [0] * n, [0] * n
for i in range(n-1):
a[i], b[i], c[i] = list(map(int, input().split()))
q, k = list(map(int, input().split()))
l = [[] for _ in range(n+1)]
for i in range(n-1):
l[a[i]].append([b[i],c[i]])
l[b[i]].append([a[i],c[i]])
d = [0] * (n+1)
check = [0] * (n+1)
check[k] = 1
que = [k]
count = 1
while len(que) > 0:
tmp = que.pop(0)
for i in l[tmp]:
if check[i[0]] == 0:
que.append(i[0])
check[i[0]] = 1
d[i[0]] = d[tmp] + i[1]
count += 1
else:
pass
if count >= n:
break
x, y = [0] * q, [0] * q
for i in range(q):
x[i], y[i] = list(map(int, input().split()))
print((d[x[i]] + d[y[i]])) | p03634 |
import sys
sys.setrecursionlimit(10**8)
n = int(eval(input()))
data = [[] for i in range(n)]
for i in range(n-1):
a,b,c = list(map(int,input().split()))
a -= 1
b -= 1
data[a].append([b,c])
data[b].append([a,c])
dist = [-1 for i in range(n)]
q,k = list(map(int,input().split()))
k -= 1
dist[k] = 0
def dfs(now,pre,d):
dist[now] = d
for p,q in data[now]:
if p == pre:
continue
dfs(p,now,d+q)
dfs(k,-1,0)
for i in range(q):
x,y = list(map(int,input().split()))
x -= 1
y -= 1
print((dist[x]+dist[y])) | import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
n = int(eval(input()))
data = [[] for i in range(n)]
for i in range(n-1):
a,b,c = list(map(int,input().split()))
a -= 1
b -= 1
data[a].append([b,c])
data[b].append([a,c])
dist = [-1 for i in range(n)]
q,k = list(map(int,input().split()))
k -= 1
dist[k] = 0
def dfs(now,pre,d):
dist[now] = d
for p,q in data[now]:
if p == pre:
continue
dfs(p,now,d+q)
dfs(k,-1,0)
for i in range(q):
x,y = list(map(int,input().split()))
x -= 1
y -= 1
print((dist[x]+dist[y])) | p03634 |
import heapq
INF = float('inf')
N = int(eval(input()))
to = [[] for _ in range(N)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
a, b, = a - 1, b - 1
to[a].append((c, b))
to[b].append((c, a))
Q, K = list(map(int, input().split()))
query = [list([int(x) - 1 for x in input().split()]) for _ in range(Q)]
def dijkstra(s, e):
hq = [(0, s)]
heapq.heapify(hq) # リストを優先度付きキューに変換
cost = [INF] * N # 行ったことのないところはinf
cost[s] = 0 # 開始地点は0
while hq:
c, v = heapq.heappop(hq)
if c > cost[v]: # コストが現在のコストよりも高ければスルー
continue
for d, u in to[v]:
tmp = d + cost[v]
if tmp < cost[u]:
cost[u] = tmp
heapq.heappush(hq, (tmp, u))
return cost[e]
def main():
min_path = [dijkstra(i, K - 1) for i in range(N)]
for x, y in query:
print((min_path[x] + min_path[y]))
if __name__ == "__main__":
main() | import sys
sys.setrecursionlimit(10**9)
N = int(eval(input()))
to = [[] for _ in range(N)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
a, b, = a - 1, b - 1
to[a].append((c, b))
to[b].append((c, a))
Q, K = list(map(int, input().split()))
K -= 1
query = [list([int(x) - 1 for x in input().split()]) for _ in range(Q)]
depth = [0] * N
def dfs(v, d, p=-1):
depth[v] = d
for cost, nv in to[v]:
if nv == p:
continue
dfs(nv, d + cost, v)
def main():
dfs(K, 0)
for x, y in query:
print((depth[x] + depth[y]))
if __name__ == "__main__":
main() | p03634 |
from heapq import heappush,heappop,heapify
INF=10**30
def dijkstra(G,s,n):
que=[(0,s)]
dist=[INF]*n
dist[s]=0
while que:
mincost,u=heappop(que)
if(mincost>dist[u]):
continue
for v,c in G[u]:
if(dist[u]+c<dist[v]):
dist[v]=dist[u]+c
heappush(que,(dist[v],v))
return dist
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=dijkstra(G,K-1,N)
for i in range(Q):
x,y=[int(x)-1 for x in input().split()]
print((dist[x]+dist[y])) | import sys
sys.setrecursionlimit(10**6)
def dfs(v,p,d):
dist[v]=d
for nv,nd in G[v]:
if nv==p:
continue
dfs(nv,v,d+nd)
N=int(eval(input()))
G=[[] for i in range(N)]
dist=[-1]*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()))
dfs(K-1,-1,0)
for i in range(Q):
x,y=[int(x)-1 for x in input().split()]
print((dist[x]+dist[y])) | p03634 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
def dfs(G, v, p, dist):
"""G: graph, v: vertex, p: parent"""
# Loop for each child
for c, d in G[v]:
# Avoid multiple access to parent
if c == p:
continue
dist[c] = dist[v] + d
dfs(G, c, v, dist)
def main():
N = int(eval(input()))
G = [[] for _ in range(N)]
for _ 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()))
x = [0] * Q
y = [0] * Q
for i in range(Q):
x[i], y[i] = list(map(int, input().split()))
for i in range(Q):
dist_a = [0] * N
dist_b = [0] * N
dfs(G, x[i]-1, -1, dist_a)
dfs(G, K-1, -1, dist_b)
ans = dist_a[K-1] + dist_b[y[i]-1]
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
def dfs(G, v, p, dist):
"""G: graph, v: vertex, p: parent"""
# Loop for each child
for c, d in G[v]:
# Avoid multiple access to parent
if c == p:
continue
dist[c] = dist[v] + d
dfs(G, c, v, dist)
def main():
N = int(eval(input()))
G = [[] for _ in range(N)]
for _ 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()))
x = [0] * Q
y = [0] * Q
for i in range(Q):
x[i], y[i] = list(map(int, input().split()))
dist = [0] * N
dfs(G, K-1, -1, dist)
for i in range(Q):
ans = dist[x[i]-1] + dist[y[i]-1]
print(ans)
if __name__ == "__main__":
main()
| p03634 |
# Kから各頂点への距離をメモする
# xからKの距離とyからKの距離を足したものが答え
import sys
readline = sys.stdin.readline
N = int(readline())
G = [[] for i in range(N)]
for i in range(N - 1):
a,b,c = list(map(int,readline().split()))
G[a-1].append((b-1,c))
G[b-1].append((a-1,c))
dist = [-1 for i in range(N)] # Kからの距離
Q,K = list(map(int,readline().split()))
dist[K - 1] = 0
from collections import deque
# 頂点、Kからの距離, 親
q = deque([[K - 1, 0, -1]])
while q:
v, d, parent = q.popleft()
dist[v] = d
for child in G[v]:
if child[0] == parent:
continue
q.append([child[0],d + child[1], v])
for i in range(Q):
x,y = list(map(int,readline().split()))
print((dist[x - 1] + dist[y - 1]))
| import sys
readline = sys.stdin.readline
N = int(readline())
G = [[] for i in range(N)]
for i in range(N - 1):
a,b,c = list(map(int,readline().split()))
G[a - 1].append((b - 1, c))
G[b - 1].append((a - 1, c))
Q,K = list(map(int,readline().split()))
dist = [0] * N
stack = [(K - 1, -1, 0)]
while stack:
v,parent,cost = stack.pop()
dist[v] = cost
for child, c in G[v]:
if child == parent:
continue
stack.append((child, v, cost + c))
for i in range(Q):
x,y = list(map(int,readline().split()))
print((dist[x - 1] + dist[y - 1]))
| p03634 |
from collections import Counter,defaultdict,deque
import sys
import copy
from itertools import permutations, combinations
from heapq import heappop, heappush
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def main():
n=int(eval(input()))
graph = [[] for _ in range(n)]
for _ in range(n-1):
a,b,w=list(map(int,input().split()))
a-=1
b-=1
graph[a].append((b,w))
graph[b].append((a,w))
graph = tuple(graph)
q,k = list(map(int,input().split()))
pre = []
que = deque()
for e in range(n):
dis = [-1 for _ in range(n)]
dis[e]=0
if e == k-1:
pre.append(0)
else:
que.append(e)
while que:
i = que.pop()
for j in range(len(graph[i])):
go = graph[i][j][0]
d = graph[i][j][1]
if dis[go]!=-1:
continue
dis[go] = dis[i] + d
if k-1 == go:
pre.append(dis[go])
que=deque()
break
que.append(go)
pre = tuple(pre)
for _ in range(q):
x,y = list(map(int,input().split()))
print(( pre[x-1] + pre[y-1] ))
if __name__ == "__main__":
main() | from collections import Counter,defaultdict,deque
import sys
import copy
from itertools import permutations, combinations
from heapq import heappop, heappush
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def main():
n=int(eval(input()))
graph = [[] for _ in range(n)]
for _ in range(n-1):
a,b,w=list(map(int,input().split()))
a-=1
b-=1
graph[a].append((b,w))
graph[b].append((a,w))
graph = tuple(graph)
q,k = list(map(int,input().split()))
que = deque([k-1])
dis = [-1 for _ in range(n)]
dis[k-1]=0
while que:
i = que.pop()
for j in range(len(graph[i])):
go = graph[i][j][0]
d = graph[i][j][1]
if dis[go]==-1:
dis[go] = dis[i] + d
que.append(go)
for _ in range(q):
x,y = list(map(int,input().split()))
print(( dis[x-1] + dis[y-1] ))
if __name__ == "__main__":
main() | p03634 |
import queue
N=int(eval(input()))
d=[-1 for _ in range(N+1)]
e=[[] for _ in range(N+1)]
for _ in range(N-1):
a,b,c=list(map(int,input().split()))
e[a].append([b, c])
e[b].append([a, c])
Q,K=list(map(int,input().split()))
d[K]=0
q=queue.Queue()
q.put(K)
while not q.empty():
now=q.get()
for nx,c in e[now]:
if d[nx] == -1:
d[nx] = c+d[now]
q.put(nx)
for _ in range(Q):
x,y=list(map(int,input().split()))
print((d[x]+d[y]))
| import sys
sys.setrecursionlimit(1145141919)
N=int(eval(input()))
d=[-1 for _ in range(N+1)]
e=[[] for _ in range(N+1)]
for _ in range(N-1):
a,b,c=list(map(int,input().split()))
e[a].append((b, c))
e[b].append((a, c))
Q,K=list(map(int,input().split()))
def dfs(now, dis):
d[now] = dis
for nxt,cos in e[now]:
if d[nxt] == -1:
dfs(nxt, dis+cos)
dfs(K, 0)
for _ in range(Q):
x,y=list(map(int,input().split()))
print((d[x]+d[y]))
| p03634 |
from collections import deque
def main():
n = int(eval(input()))
G = [[] for _ in range(n)]
D = [[] for _ in range(n)]
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
G[a].append(b)
D[a].append(c)
G[b].append(a)
D[b].append(c)
q, k = list(map(int, input().split()))
k -= 1
stack = deque([k, ])
ans = [-1] * n
ans[k] = 0
while stack:
x = stack.popleft()
for dx, l in zip(G[x], D[x]):
if ans[dx] == -1:
ans[dx] = ans[x] + l
stack.appendleft(dx)
for _ in range(q):
x, y = list([int(x) - 1 for x in input().split()])
print((ans[x] + ans[y]))
if __name__ == '__main__':
main()
| from collections import deque
import sys
def input():
return sys.stdin.readline().rstrip()
def main():
n = int(eval(input()))
G = [[] for _ in range(n)]
for _ 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
stack = deque([k, ])
ans = [-1] * n
ans[k] = 0
while stack:
x = stack.popleft()
for (dx, l) in G[x]:
if ans[dx] == -1:
ans[dx] = ans[x] + l
stack.appendleft(dx)
for _ in range(q):
x, y = list([int(x) - 1 for x in input().split()])
print((ans[x] + ans[y]))
if __name__ == '__main__':
main()
| p03634 |
N=int(eval(input()))
G=[[] for _ 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()))
SD=[0]*N
for x,d in G[K-1]:
SD[x]=d
for i in range(N):
if i==K-1:continue
ans=[]
seen=[0]*N
stack=[[i,0]]
seen[i]=1
while stack:
x,d=stack.pop()
if x==K-1:
ans.append(d)
elif SD[x]!=0:
ans.append(d+SD[x])
else:
for y,co in G[x]:
if seen[y]==0:
stack.append([y,d+co])
seen[y]=1
SD[i]=min(ans)
for i in range(Q):
x,y=list(map(int,input().split()))
ans=SD[x-1]+SD[y-1]
print(ans)
| N=int(eval(input()))
G=[[] for _ 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()))
SD=[0]*N
seen=[0]*N
stack=[]
stack.append([K-1,0])
seen[K-1]=1
while stack:
x,d=stack.pop()
for y,d0 in G[x]:
if seen[y]==0:
SD[y]=d+d0
stack.append([y,d+d0])
seen[y]=1
for i in range(Q):
x,y=list(map(int,input().split()))
ans=SD[x-1]+SD[y-1]
print(ans)
| p03634 |
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
n = int(input())
from collections import defaultdict
abc = [tuple(map(int,input().split())) for i in range(n-1)]
cost = [[-1]*n for i in range(n)]
for a,b,c in abc:
a,b = a-1,b-1
cost[a][b]=c
cost[b][a]=c
q, k = map(int, input().split())
xy = [tuple(map(int,input().split())) for i in range(q)]
dist = [-1]*n
def dfs(v=0,parent=-1):
if dist[v]==-1:
dist[v] = dist[parent] + cost[v][parent]
for i,d in enumerate(cost[v]):
if d!=-1 and dist[i]==-1:
dfs(i,v)
dist[k-1] =0
dfs(k-1)
ans=[]
for x,y in xy:
x,y=x-1,y-1
ans.append(dist[x]+dist[y])
print(*ans,sep='\n')
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
n = int(input())
from collections import defaultdict
abc = [tuple(map(int,input().split())) for i in range(n-1)]
es = [[] for i in range(n)]
for a,b,c in abc:
a,b = a-1,b-1
es[a].append((b,c))
es[b].append((a,c))
q, k = map(int, input().split())
xy = [tuple(map(int,input().split())) for i in range(q)]
dist = [-1]*n
def dfs(v=0,parent=-1,d=0):
for next_v,dd in es[v]:
if dist[next_v] == -1:
dist[next_v] = d + dd
dfs(next_v,v,dist[next_v])
dist[k-1] =0
dfs(k-1,-1,0)
ans=[]
for x,y in xy:
x,y=x-1,y-1
ans.append(dist[x]+dist[y])
print(*ans,sep='\n')
| p03634 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)
INF = 10**18
N = int(readline())
ABC = [list(map(int, readline().split())) for _ in range(N - 1)]
Q, K = list(map(int, readline().split()))
XY = [list(map(int, readline().split())) for _ in range(Q)]
def warshall_floyd(dist):
for k, _ in enumerate(dist):
for i, _ in enumerate(dist):
for j, _ in enumerate(dist):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
return dist
dist = [[INF] * (N + 1) for _ in range(N + 1)]
for abc in ABC:
dist[abc[0] - 1][abc[1] - 1] = abc[2]
dist[abc[1] - 1][abc[0] - 1] = abc[2]
dist = warshall_floyd(dist)
for x, y in XY:
print((dist[x - 1][K - 1] + dist[K - 1][y - 1]))
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)
N = int(readline())
edges = [[] for _ in range(N + 1)]
for _ in range(N - 1):
a, b, c = list(map(int, readline().split()))
edges[a].append((b, c))
edges[b].append((a, c))
Q, K = list(map(int, readline().split()))
dist = [0] * (N + 1)
def dfs(v, p, d):
dist[v] = d
for n, dd in edges[v]:
if n == p:
continue
dfs(n, v, d + dd)
dfs(K, -1, 0)
for _ in range(Q):
x, y = list(map(int, readline().split()))
print((dist[x] + dist[y]))
| p03634 |
import sys
readline = sys.stdin.readline
from collections import deque
def main():
N = int(readline())
path = [[] for _ in range(N)]
for _ in range(N-1):
a, b, c = list(map(int, readline().rstrip().split()))
path[a-1].append((b-1, c))
path[b-1].append((a-1, c))
Q, K = list(map(int, readline().rstrip().split()))
K -= 1
dist = [-1] * N
dist[K] = 0
for n, c in path[K]:
dist[n] = c
que = deque([(K, n) for n, c in path[K]])
while que:
pre, now = que.popleft()
for next, d in path[now]:
if next != pre:
dist[next] = dist[now] + d
que.append((now, next))
for _ in range(Q):
x, y = list(map(int, readline().rstrip().split()))
print((dist[x-1] + dist[y-1]))
if __name__ == '__main__':
main() | import sys
readline = sys.stdin.readline
from collections import deque
def main():
N = int(readline())
path = [[] for _ in range(N)]
for _ in range(N-1):
a, b, c = list(map(int, readline().rstrip().split()))
path[a-1].append((b-1, c))
path[b-1].append((a-1, c))
Q, K = list(map(int, readline().rstrip().split()))
K -= 1
dist = [-1] * N
dist[K] = 0
que = deque([K])
while que:
pre = que.popleft()
for next, d in path[pre]:
if dist[next] == -1:
dist[next] = dist[pre] + d
que.append(next)
for _ in range(Q):
x, y = list(map(int, readline().rstrip().split()))
print((dist[x-1] + dist[y-1]))
if __name__ == '__main__':
main() | p03634 |
import sys
readline = sys.stdin.readline
from collections import deque
def main():
N = int(readline())
path = [[] for _ in range(N)]
for _ in range(N-1):
a, b, c = list(map(int, readline().rstrip().split()))
path[a-1].append((b-1, c))
path[b-1].append((a-1, c))
Q, K = list(map(int, readline().rstrip().split()))
K -= 1
dist = [-1] * N
dist[K] = 0
que = deque([K])
while que:
pre = que.popleft()
for next, d in path[pre]:
if dist[next] == -1:
dist[next] = dist[pre] + d
que.append(next)
for _ in range(Q):
x, y = list(map(int, readline().rstrip().split()))
print((dist[x-1] + dist[y-1]))
if __name__ == '__main__':
main() | import sys
readline = sys.stdin.readline
from heapq import heapify, heappush, heappop
def dijkstra(path, N, start):
"""
Args:
path (list): [[(cost, node), (cost, node), ...], [], [], ...]
"""
visited = [False] * N
que = [(0, start)]
heapify(que) # 始点aから各頂点への(距離, 頂点ID)
dist = [-1] * N # 始点aから各頂点への距離
dist[start] = 0 # 始点aからaへの距離は0
while que:
d, v = heappop(que) # 始点から最短距離の頂点を(確定ノード)を取り出す
visited[v] = True # 確定フラグを立てる
# 接続先ノードの情報を更新する
for d, to in path[v]:
cost = dist[v] + d
if dist[to] < 0 or cost < dist[to]:
dist[to] = cost
if not visited[to]:
heappush(que, (cost, to))
return dist
def main():
N = int(readline())
path = [[] for _ in range(N)]
for _ in range(N-1):
a, b, c = list(map(int, readline().rstrip().split()))
path[a-1].append((c, b-1))
path[b-1].append((c, a-1))
Q, K = list(map(int, readline().rstrip().split()))
dist = dijkstra(path, N, K-1)
for _ in range(Q):
x, y = list(map(int, readline().rstrip().split()))
print((dist[x-1] + dist[y-1]))
if __name__ == '__main__':
main() | p03634 |
# ABC070 D - Transit Tree Path
import heapq
def dijkstra_heap(s):
"""
始点sから各頂点への最短距離を返す
Parameters
----------
s : int
視点とする頂点
Returns
-------
d ：list
始点sから各頂点への最短距離
"""
d = [float("inf")] * n
used = [True] * n #True:未確定
d[s] = 0
used[s] = False
edgelist = []
for e in edge[s]:
heapq.heappush(edgelist,e)
while len(edgelist):
minedge = heapq.heappop(edgelist)
#未使用の頂点の中から最小の距離のものを探す
if not used[minedge[0]]:
continue
v = minedge[0]
d[v] = minedge[1]
used[v] = False
for e in edge[v]:
if used[e[0]]:
heapq.heappush(edgelist,[e[0],e[1]+d[v]])
return d
n=int(eval(input()))
edge=[[] for i in range(n)]
for i in range(n-1):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
edge[a].append([b,c])
edge[b].append([a,c])
q,k=list(map(int,input().split()))
k-=1
dist=dijkstra_heap(k)
for i in range(q):
x,y=list(map(int,input().split()))
x-=1
y-=1
print((dist[x]+dist[y])) | import sys
sys.setrecursionlimit(100000000)
def dfs(cur,par,d):
dist[cur]=d
for nx,nx_dist in G[cur]:
if nx==par:continue
dfs(nx,cur,d+nx_dist)
n=int(eval(input()))
G=[[] for i in range(n)]
dist=[0]*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()))
k-=1
dfs(k,-1,0)
for i in range(q):
x,y=list(map(int,input().split()))
x-=1
y-=1
print((dist[x]+dist[y])) | p03634 |
n=int(eval(input()))
G=[[] for i in range(n)]
for i in range(n-1):
u,v,w=list(map(int,input().split()))
G[u-1].append([v-1,w])
G[v-1].append([u-1,w])
dist=[-1]*n
from collections import deque
Q,k=list(map(int,input().split()))
q=deque()
q.append(k-1)
dist[k-1]=0
while q:
cur=q.popleft()
for nx,nd in G[cur]:
if dist[nx]!=-1:continue
dist[nx]=dist[cur]+nd
q.append(nx)
for i in range(Q):
x,y=list(map(int,input().split()))
x-=1
y-=1
print((dist[x]+dist[y]))
| from heapq import heappop,heappush
def dijkstra(s,n,edge):
"""
始点sから各頂点への最短距離を返す
Parameters
----------
s : int
視点とする頂点（0-indexed）
n : int
グラフの要素数
eage:list
グラグ
Returns
-------
dist ：list
始点sから各頂点への最短距離
"""
dist=[float("inf")]*n
dist[s]=0
used=[-1]*n
hq=[[dist[s],s]]
while hq:
d,cur=heappop(hq)
if dist[cur]<d:continue # 距離が最小でない場合は飛ばす
for nx,nxd in edge[cur]:
if dist[cur]+nxd<dist[nx]:
dist[nx]=dist[cur]+nxd
used[nx]=cur
heappush(hq,[dist[cur]+nxd,nx])
return dist
n=int(eval(input()))
edge=[[] for _ in range(n)]
for _ in range(n-1):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
edge[a].append((b,c))
edge[b].append((a,c))
q,k=list(map(int,input().split()))
xy=[list(map(int,input().split()))for _ in range(q)]
d=dijkstra(k-1,n,edge)
for x,y in xy:
print((d[x-1]+d[y-1]))
| p03634 |
import sys
from collections import defaultdict
sys.setrecursionlimit(10 ** 7)
def dfs(v, parent, d):
depth[v] = d
for to, cost in tree[v]:
if to == parent:
continue
dfs(to, v, d + cost)
depth = defaultdict(int)
tree = defaultdict(list)
n = int(eval(input()))
for i in range(n - 1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
tree[a].append((b, c))
tree[b].append((a, c))
q, k = list(map(int, input().split()))
k -= 1
dfs(k, -1, 0)
for i in range(q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
print((depth[x] + depth[y]))
| import sys
from collections import defaultdict
sys.setrecursionlimit(10 ** 7)
def input():
return sys.stdin.readline()[:-1]
def dfs(v, parent, d):
depth[v] = d
for to, cost in tree[v]:
if to == parent:
continue
dfs(to, v, d + cost)
depth = defaultdict(int)
tree = defaultdict(list)
n = int(eval(input()))
for i in range(n - 1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
tree[a].append((b, c))
tree[b].append((a, c))
q, k = list(map(int, input().split()))
k -= 1
dfs(k, -1, 0)
for i in range(q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
print((depth[x] + depth[y]))
| p03634 |
N = int(eval(input()))
d = [0] * N
INF = float('inf')
cost = [[INF] * N for i in range(N)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
cost[a - 1][b- 1] = c
cost[b- 1][a - 1] = c
def dijkstra(s):
used = [False] * N
for i in range(N):
d[i] = INF
d[s] = 0
while True:
v = -1
for u in range(N):
if used[u] == False and (v == -1 or d[u] < d[v]):
v = u
if v == -1:
break
used[v] = True
for u in range(N):
d[u] = min(d[u], d[v] + cost[v][u])
Q, K = list(map(int, input().split()))
for _ in range(Q):
ans = 0
x, y = list(map(int, input().split()))
dijkstra(x - 1)
ans += d[K - 1]
#print(d)
dijkstra(K - 1)
ans += d[y - 1]
#print(d)
print(ans) | import heapq
N = int(eval(input()))
d = [0] * N
INF = float('inf')
class Info:
def __init__(self, to, cost):
self.to = to
self.cost = cost
G = [[] for i in range(N)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
G[a - 1].append(Info(b - 1, c))
G[b - 1].append(Info(a - 1, c))
def dijkstra(s):
for i in range(N):
d[i] = INF
d[s] = 0
h = []
heapq.heappush(h, [0, s])
while h != []:
p = heapq.heappop(h)
v = p[1]
if d[v] < p[0]:
continue
for i in range(len(G[v])):
e = G[v][i]
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost
heapq.heappush(h, [d[e.to], e.to])
Q, K = list(map(int, input().split()))
for _ in range(Q):
ans = 0
x, y = list(map(int, input().split()))
dijkstra(x - 1)
ans += d[K - 1]
#print(d)
dijkstra(K - 1)
ans += d[y - 1]
#print(d)
print(ans) | p03634 |
from collections import defaultdict
import heapq
N = int(eval(input()))
INF = float('inf')
edges = [list(map(int, input().split())) for _ in range(N-1)]
nodes = defaultdict(list)
for e in edges:
nodes[e[0] - 1].append((e[2], e[1] - 1))
nodes[e[1] - 1].append((e[2], e[0] - 1))
Q, K = list(map(int, input().split()))
queries = [list(map(int, input().split())) for _ in range(Q)]
def dijkstra(x, y):
que = []
heapq.heapify(que)
dist = [INF for _ in range(N)]
dist[x] = 0
heapq.heappush(que, (0, x))
while que:
p = heapq.heappop(que)
v = p[1]
if dist[v] < p[0]:
continue
for e in nodes[v]:
if dist[e[1]] > dist[v] + e[0]:
dist[e[1]] = dist[v] + e[0]
heapq.heappush(que, (dist[e[1]], e[1]))
return dist[y]
for q in queries:
x, y = q[0] - 1, q[1] - 1
print((dijkstra(x, K - 1) + dijkstra(K - 1, y)))
| from collections import defaultdict
import heapq
N = int(eval(input()))
INF = float('inf')
edges = [list(map(int, input().split())) for _ in range(N-1)]
nodes = defaultdict(list)
for e in edges:
nodes[e[0] - 1].append((e[2], e[1] - 1))
nodes[e[1] - 1].append((e[2], e[0] - 1))
Q, K = list(map(int, input().split()))
queries = [list(map(int, input().split())) for _ in range(Q)]
def dijkstra(x):
que = []
heapq.heapify(que)
dist = [INF for _ in range(N)]
dist[x] = 0
heapq.heappush(que, (0, x))
while que:
p = heapq.heappop(que)
v = p[1]
if dist[v] < p[0]:
continue
for e in nodes[v]:
if dist[e[1]] > dist[v] + e[0]:
dist[e[1]] = dist[v] + e[0]
heapq.heappush(que, (dist[e[1]], e[1]))
return dist
distk = dijkstra(K - 1)
for q in queries:
x, y = q[0] - 1, q[1] - 1
print((distk[x] + distk[y]))
| p03634 |
from heapq import heappush, heappop
inf = float('inf')
# import: from heapq import heappush,heappop
# distの初期化: dist = [inf]*n; dist[start] = 0
def dijkstra(ad,dist,n,start):
pq = [(0,start)]
while pq:
w,v = heappop(pq)
for nw,nv in ad[v]:
if dist[nv] > dist[v] + nw:
dist[nv] = dist[v] + nw
heappush(pq,(dist[nv],nv))
N = int(eval(input()))
ad = [[] for _ in range(N)]
for _ in range(N-1):
a,b,c = list(map(int,input().split()))
a -= 1; b -= 1
ad[a].append((c,b))
ad[b].append((c,a))
Q,K = list(map(int,input().split()))
K -= 1
query = [[int(e)-1 for e in input().split()] for _ in range(Q)]
dist = [inf]*N
dist[K] = 0
dijkstra(ad,dist,N,K)
for x,y in query:
ans = dist[x] + dist[y]
print(ans) | from heapq import heappush, heappop
inf = float('inf')
# (始点,隣接リスト)
def dijkstra(start,ad):
global dist
dist = [inf]*len(ad)
dist[start] = 0
pq = [(start,0)]
while pq:
v = heappop(pq)[0]
for nv,nw in ad[v]:
if dist[nv] > dist[v] + nw:
dist[nv] = dist[v] + nw
heappush(pq,(nv,dist[nv]))
N = int(eval(input()))
ad = [[] for _ in range(N)]
for _ in range(N-1):
a,b,c = list(map(int,input().split()))
a -= 1; b -= 1
ad[a].append((b,c))
ad[b].append((a,c))
Q,K = list(map(int,input().split()))
K -= 1
query = [[int(e)-1 for e in input().split()] for _ in range(Q)]
dijkstra(K,ad)
for x, y in query:
ans = dist[x] + dist[y]
print(ans) | p03634 |
from heapq import heappop, heappush
n = int(eval(input()))
grid = [list(map(int, input().split())), list(map(int, input().split()))]
def biggest(grid, start, cost=0):
dist = [[0 for _ in range(n)] for _ in range(2)]
dx = [1, 0]
dy = [0, 1]
st = [(cost, start)]
dist[start[0]][start[1]] = grid[start[0]][start[1]] + cost
while(st):
c, [sx, sy] = heappop(st)
for a, b in zip(dx, dy):
x = sx + a
y = sy + b
if x >= 2 or y >= n:
continue
dxy = dist[sx][sy] + grid[x][y]
if dist[x][y] >= dxy:
continue
dist[x][y] = dxy
heappush(st, (dist[x][y], [x, y]))
return dist[-1][-1]
dist = biggest(grid, [0, 0], cost=0)
print(dist) | n = int(eval(input()))
grid = [list(map(int, input().split())), list(map(int, input().split()))]
dist = [[0 for _ in range(n)] for _ in range(2)]
dist[0][0] = grid[0][0]
for i in range(2):
for j in range(n):
if j < n - 1:
dist[i][j + 1] = max(dist[i][j + 1], dist[i][j] + grid[i][j + 1])
if i == 0:
dist[1][j] = max(dist[1][j], dist[0][j] + grid[1][j])
print((dist[-1][-1])) | p03451 |
def third(n,q):
n = int(n)
q = float(q)
if n == 1: return q/2
else : return third(n-1,q)- (third(n-1,q)**3-q)/(3*third(n-1,q)**2)
kai = []
while(True):
try:
q = eval(input())
if q == -1:
break
else :
n = 1
q = float(q)
while (abs(q-third(n, q)**3) >= 0.00001*q):
n += 1
print('{:.6f}'.format(third(n, q)))
except EOFError:
break | while(True):
try:
q = eval(input())
if q == -1:
break
else :
q = float(q)
x = q/2
while (abs(q-x**3) >= 0.00001*q):
x = x- (x**3-q)/(3*x**2)
print('{:.6f}'.format(x))
except EOFError:
break | p00080 |
N, M = list(map(int, input().split(" ")))
A = list(map(int, input().split(" ")))
R = [0] * (N+1)
ans = 0
temp = 0
for i in range(N):
R[i+1] = temp + A[i]
temp = R[i+1]
for j in range(1,N+1):
for d in range(1,N+1):
if j - d >= 0:
if (R[j] - R[j-d]) % M == 0:
ans += 1
print(ans) | # coding: utf-8
# Your code here!
N, M = list(map(int, input().split(" ")))
A = list(map(int, input().split(" ")))
R = [0] * (N+1)
S = [0] * (N+1)
S_dict = {}
ans = 0
temp = 0
for i in range(N):
R[i+1] = temp + A[i]
S[i+1] = R[i+1] % M
temp = R[i+1]
for s in S:
if s in S_dict:
S_dict[s] += 1
else:
S_dict[s] = 1
for v in list(S_dict.values()):
ans += int(v*(v-1)/2)
print(ans) | p03287 |
from collections import Counter
N, M = [int(elem) for elem in input().split(' ')]
A_list = [int(elem) % M for elem in input().split(' ')]
assert len(A_list) == N
cuml_A_list = [0] * N
current_sum = 0
for i, A in enumerate(A_list):
current_sum += A
current_sum %= M
cuml_A_list[i] = current_sum
counter = Counter(cuml_A_list)
total_count = 0
for key, value in list(counter.items()):
if key == 0:
total_count += value * (value - 1) // 2 + value
else:
total_count += value * (value - 1) // 2
print(total_count)
| import sys
from collections import Counter
finput = sys.stdin.readline
N, M = [int(elem) for elem in finput().split(' ')]
A_list = [int(elem) % M for elem in finput().split(' ')]
assert len(A_list) == N
cuml_A_list = [0] * N
current_sum = 0
for i, A in enumerate(A_list):
current_sum += A
current_sum %= M
cuml_A_list[i] = current_sum
counter = Counter(cuml_A_list)
total_count = 0
for key, value in list(counter.items()):
if key == 0:
total_count += value * (value - 1) // 2 + value
else:
total_count += value * (value - 1) // 2
print(total_count)
| p03287 |
from collections import Counter
n,m = list(map(int,input().split()))
A = list(map(int,input().split()))
S = [0]
s = 0
for i in range(n):
s += A[i]
S += [s]
R = []
for i in range(n+1):
R += [S[i]%m]
R = Counter(R)
ans = 0
for r in list(R.values()):
ans += r*(r-1)//2
print(ans) | from collections import Counter
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
S = [0]
for i in range(N):
S.append((S[-1]+A[i])%M)
C = Counter(S)
ans = 0
for v in list(C.values()):
ans += v*(v-1)//2
print(ans) | p03287 |
def comb1(n, r):
if n == 0 or r == 0: return 1
return comb1(n, r-1) * (n-r+1) / r
N, M = list(map(int, input().split()))
A = [int(i) for i in input().split()]
# N, M = 10, 400000000
# A = [int(i) for i in '1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000'.split()]
surplus = {0:0}
res = 0
B = []
for i in range(1, N + 1):
tmp = sum(A[:i])%M
B.append(tmp)
surplus[tmp] = 0
for i in B:
surplus[i] += 1
for tmp_key in list(surplus.keys()):
res += comb1(surplus[tmp_key], 2)
corner = surplus[0]
if corner == 0:
res -= 1
else:
res += corner
print((int(res))) | def comb1(n, r):
if n == 0 or r == 0: return 1
return comb1(n, r-1) * (n-r+1) / r
N, M = list(map(int, input().split()))
A = [int(i) for i in input().split()]
# N, M = 10, 400000000
# A = [int(i) for i in '1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000'.split()]
surplus = {0:0}
res = 0
tmp = 0
B = []
for i in range(0, N):
tmp += A[i]
tmp %= M
B.append(tmp)
surplus[tmp] = 0
for i in B:
surplus[i] += 1
for tmp_key in list(surplus.keys()):
res += comb1(surplus[tmp_key], 2)
corner = surplus[0]
if corner == 0:
res -= 1
else:
res += corner
print((int(res))) | p03287 |
from collections import Counter as C
from itertools import accumulate as a
def inp():return list(map(int,input().split()))
n,m = inp()
print((sum([v*(v-1)//2+(0 if k else v)for k,v in list(C([x%m for x in a(inp())]).items())]))) | from collections import Counter as C
from itertools import accumulate as a
def inp():return list(map(int,input().split()))
n,m = inp()
print((sum([v*(v-1)//2 for v in list(C([x%m for x in a([0]+inp())]).values())]))) | p03287 |
from collections import Counter as C
from itertools import accumulate as a
def inp():return list(map(int,input().split()))
n,m = inp()
print((sum([v*(v-1)//2 for v in list(C([x%m for x in a([0]+inp())]).values())]))) | from collections import Counter as C
from itertools import accumulate as a
def i():return list(map(int,input().split()))
n,m=i()
print((sum([v*(v-1)//2 for v in list(C([x%m for x in a([0]+i())]).values())]))) | p03287 |
import sys
input=sys.stdin.readline
if __name__ == '__main__':
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
dp=[[0 for i in range(N)] for j in range(N)]
count = 0
for i in range(N):
dp[i][i]=A[i]
dp[i][i]%=M
if dp[i][i]==0:
count+=1
for l in range(N):
for r in range(l,N-1):
dp[l][r+1]=dp[l][r]+A[r+1]
dp[l][r+1]%=M
if dp[l][r+1]==0:
count+=1
print(count)
| import sys
input=sys.stdin.readline
if __name__ == '__main__':
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
B=[0]*(N+1)
count=0
for i in range(N):
B[i+1]=B[i]+A[i]
B[i+1]%=M
for b in B:
c=B.count(b)
count+=c-1
print((count//2))
| p03287 |
from collections import defaultdict
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
A[0] %= M
for i in range(N-1):
A[i+1] += A[i]
A[i+1] %= M
d = defaultdict(lambda:0)
d[0] = 1
ans = 0
for i in range(N):
ans += d[A[i]]
d[A[i]] += 1
print(ans) | N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
from collections import defaultdict
r = defaultdict(lambda:0)
s = 0
for i in range(N):
s += A[i]
s %= M
r[s] += 1
ans = r[0]
for s in r:
ans += (r[s]*(r[s]-1))//2
print(ans) | p03287 |
import math
from itertools import accumulate
n,m = list(map(int,input().split()))
A = list(map(int,input().split()))
accum_A = [0] + A
accum_A = list(accumulate(accum_A))
ans = 0
for i in range(n):
for j in range(i+1,n+1):
# print('l:{}, r:{}, sum:{}'.format(i,j,(accum_A[j]-accum_A[i])))
if (accum_A[j]-accum_A[i]) % m == 0:
ans += 1
print(ans)
|
import math
from itertools import accumulate
def combinations_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
n,m = list(map(int,input().split()))
A = list(map(int,input().split()))
accum_A = [0] + A
accum_A = list(accumulate(accum_A))
mod_dic = {}
for i in accum_A:
mod = i%m
if mod in list(mod_dic.keys()):
mod_dic[mod] += 1
else:
mod_dic[mod] = 1
ans = 0
for i in list(mod_dic.values()):
if i >= 2:
ans += combinations_count(i,2)
print(ans)
| p03287 |
n, m = list(map(int, input().split()))
l = list(map(int, input().split()))
l = [0] + l
from itertools import accumulate
cum =list(accumulate(l))
cum = [c%m for c in cum]
d = {}
ans = 0
for i in range(n+1):
if cum[i] not in d:
d[cum[i]] = 1
else:
ans += d[cum[i]]
d[cum[i]] += 1
print(ans) | n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
from itertools import accumulate
B = [0]+A
B = list(accumulate(B))
d = {}
ans = 0
for i in range(n+1):
s = B[i]%m
if s in d:
ans += d[s]
d[s] += 1
else:
d[s] = 1
print(ans)
| p03287 |
# -*- coding: utf-8 -*-
# import numpy as np
N, M = list(map(int, input().split()))
An = list(map(int, input().split()))
pare_list = []
val_list = []
for i in range(N):
tmp = 0
for j in range(i,N):
tmp += An[j]
pare_list.append((i,j))
# for m in range(i,j+1):
# tmp += An[m]
val_list.append(tmp)
count = 0
for val in val_list:
if val % M == 0:
count += 1
print(count)
# print(pare_list)
# print(val_list)
| # -*- coding: utf-8 -*-
# import numpy as np
N, M = list(map(int, input().split()))
An = list(map(int, input().split()))
pare_list = []
val_list = []
for i in range(N):
tmp = 0
for j in range(i,N):
tmp += An[j]
# pare_list.append((i,j))
# for m in range(i,j+1):
# tmp += An[m]
if tmp % M == 0:
val_list.append(tmp)
print((len(val_list)))
#
# count = 0
# for val in val_list:
# if val % M == 0:
# count += 1
# print(count)
# print(pare_list)
# print(val_list)
| p03287 |
N, M = list(map( int, input().split()))
A = list( map( int, input().split()))
A = [ x%M for x in A]
SUM = [0]
for i in range(N):
SUM.append(SUM[-1]+A[i])
ans = 0
cnt = 1
for l in range(N):
if A[l] == 0:
ans += cnt
cnt += 1
else:
PART = 0
for r in range(l+1,N+1):
if (SUM[r] - SUM[l])%M == 0:
PART += 1
ans += cnt * PART
cnt = 1
print((int(ans))) | N, M = list(map( int, input().split()))
A = list( map( int, input().split()))
D = {0:1}
a = 0
ans = 0
for i in range(N):
a = (a+A[i])%M
ans += D.get(a,0)
D[a] = 1 + D.get(a,0)
print(ans) | p03287 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.