s_id stringlengths 10 10 | p_id stringlengths 6 6 | u_id stringlengths 10 10 | date stringlengths 10 10 | language stringclasses 1
value | original_language stringclasses 11
values | filename_ext stringclasses 1
value | status stringclasses 1
value | cpu_time stringlengths 1 5 | memory stringlengths 1 7 | code_size stringlengths 1 6 | code stringlengths 1 539k |
|---|---|---|---|---|---|---|---|---|---|---|---|
s449698194 | p03864 | u485137520 | 1549058391 | Python | Python (3.4.3) | py | Runtime Error | 105 | 14132 | 297 |
n, x = map(int, input().split())
l = list(map(int, input().split()))
total = 0
for i in range(n - 1):
sub = l[i] + l[i+1]
if sub > x:
total += sub - x
l[i+1] -= sub - x
if l[i+1] > x:
l[i] -= l[i+1] - x
total += l[i+1 - x]
print(total) |
s105464647 | p03864 | u236127431 | 1544466834 | Python | Python (3.4.3) | py | Runtime Error | 19 | 3188 | 794 | from heapq import heapify,heappop,heappush
xs,ys,xt,yt=map(int,input().split())
P=[]
inf=float("inf")
P.append((xs,ys,0))
N=int(input())
for i in range(N):
x,y,r=map(int,input().split())
P.append((x,y,r))
P.append((xt,yt,0))
G=[set() for i in range(N+2)]
for i in range(N+2):
for j in range(N+2):
if i!=j:
x1,y1,r1,x2,y2,r2=P[i][0],P[i][1],P[i][2],P[j][0],P[j][1],P[j][2]
d=((x1-x2)**2+(y1-y2)**2)**(1/2)
if d<=r1+r2:
G[i].add((0,j))
else:
G[i].add((d-r1-r2,j))
def dijkstra(s,n,links):
cost=[inf]*n
cost[s]=0
heap=[(0,s)]
heapify(heap)
while heap:
hc,hp=heappop(heap)
for c,p in links[hp]:
if c+hc<cost[p]:
cost[p]=c+hc
heappush(heap,(cost[p],p))
return cost
c=dijkstra(0,N+2,G)
print(c[-1]) |
s220807976 | p03864 | u397531548 | 1543618357 | Python | Python (3.4.3) | py | Runtime Error | 79 | 14052 | 137 | N,x=map(int,input().split())
a=list(map(int,input().split()))
b=0
for i in range(N//2):
b+=max(a[2*i],a[2*(i+1)])+a[2*i+1]-x
print(b) |
s885938368 | p03864 | u438786370 | 1541172919 | Python | Python (3.4.3) | py | Runtime Error | 110 | 14060 | 356 | N,x =map(int, input().split())
candy = list(map(int, input().split()))
eat = 0
for i in range(N - 1):
if(candy[i] + candy[i + 1] > x):
ex = candy[i] + candy[i + 1] - x
eat += ex
if(candy[i + 1] >= ex):
candy[i + 1] -= ex
else:
candy[i] -= ex - cndy[i + 1]
candy[i + 1] = 0
print(eat) |
s693358039 | p03864 | u177398299 | 1537989080 | Python | PyPy3 (2.4.0) | py | Runtime Error | 194 | 40304 | 933 | from heapq import heappop, heappush
INF = 10 ** 20
xs, ys, xt, yt = map(int, input().split())
N = int(input())
circle = [list(map(int, input().split())) for _ in range(N)]
circle = [[xs, ys, 0]] + circle + [[xt, yt, 0]]
edges_lst = [[] for _ in range(N + 2)]
for i, (x1, y1, r1) in enumerate(circle):
for j, (x2, y2, r2) in enumerate(circle[i + 1:]):
j += i + 1
d = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** .5
dist = max(0, d - r1 - r2)
edges_lst[i].append((j, dist))
edges_lst[j].append((i, dist))
def dijkstra():
que = []
heappush(que, (0, 0))
dist_lst = [INF] * (N + 2)
dist_lst[0] = 0
while que:
dist, node = heappop(que)
for to, cost in edges_lst[node]:
if dist_lst[to] > cost + dist:
dist_lst[to] = cost + dist
heappush(que, (cost + dist, to))
return dist_lst[-1]
print('{:.10f}'.format(dijkstra())) |
s885741832 | p03864 | u200239931 | 1531392590 | Python | Python (3.4.3) | py | Runtime Error | 164 | 14588 | 849 | def getinputdata():
# 配列初期化
array_result = []
data = input()
array_result.append(data.split(" "))
flg = 1
try:
while flg:
data = input()
if(data != ""):
array_result.append(data.split(" "))
flg = 1
else:
flg = 0
finally:
return array_result
arr_data = getinputdata()
n = int(arr_data[0][0])
x = int(arr_data[0][1])
arr=[int(arr_data[1][x]) for x in range(0,n)]
cnt=0
for i in range(n-1):
if arr[i]+arr[i+1]>x:
if arr[i]-x>=0:
cnt+=arr[i-x]
arr[i]=0
if arr[i]+arr[i+1]-x>=0:
cnt+=arr[i+1]-x
arr[i+1]=arr[i+1]-x
print(cnt)
|
s146329704 | p03864 | u033407970 | 1494710064 | Python | Python (3.4.3) | py | Runtime Error | 150 | 12448 | 772 | import numpy as np
xs, ys, xt, yt = [int(x) for x in input().split(' ')]
n = int(input())
cirl = []
for i in range(n):
cirl.append([int(x) for x in input().split(' ')])
cirl = [[xs, ys, 0]] + cirl + [[xt, yt, 0]]
use = [x for x in range(n+2)]
weigth = [0] + [10**10 for x in range(n+1)]
while min(weigth) != weigth[n+1]:
chos = weigth.index(min(weigth))
use.remove(chos)
x1, y1, r1 = cirl[chos][0], cirl[chos][1], cirl[chos][2]
for i in use:
x2, y2, r2 = cirl[i][0], cirl[i][1], cirl[i][2]
dist = np.sqrt((y2-y1)**2 + (x2-x1)**2) - (r1+r2)
print(dist)
if dist < 0:
dist = 0
if dist + weigth[chos] < weigth[i]:
weigth[i] = dist + weigth[chos]
weigth[chos] = 10**10
print(weigth[n+1])
|
s123606732 | p03864 | u159380019 | 1494705118 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3064 | 1018 | from math import sqrt
class Edge:
def __init__(self, to, cost):
self.to = to
self.cost = cost
def dijkstra(G, s):
from heapq import heappush, heappop
l = len(G)
dist = [float('inf')] * l
done = [False] * l
dist[s] = 0
pq = []
heappush(pq, (0, s))
while pq:
c, v = heappop(pq)
done[v] = True
for e in G[v]:
cost = dist[v] + e.cost
if cost < dist[e.to] and not done[e.to]:
dist[e.to] = cost
heappush(pq, (cost, e.to))
return dist
xs, ys, xt, yt = map(int, input().split())
N = int(input())
xyr = [[int(i) for i in input().split()] for _ in range(N)]
xyr += [[xs, ys, 0], [xt, yt, 0]]
G = [[] for _ in range(N + 2)]
for i, (x, y, r) in enumerate(xyr):
for j, (x2, y2, r2) in enumerate(xyr[i + 1:]):
w = max(0, sqrt((x - x2)**2 + (y - y2)**2) - r - r2)
G[i].append(Edge(i + j + 1, w))
G[i + j + 1].append(Edge(i, w))
print(dijkstra(G, len(G) - 2)[-1])
|
s599843640 | p03864 | u107077660 | 1494301926 | Python | PyPy3 (2.4.0) | py | Runtime Error | 170 | 38640 | 868 | from math import hypot
def dijkstra(matrix):
from heapq import heappush, heappop
n = len(matrix)
inf = 10**10
hq = []
ans = [inf]*n
ans[0] = 0
heappush(hq, (0, 0))
while hq:
d, p = heappop(hq)
for i in range(n):
if ans[p] == d and p != i and d + matrix[p][i] < ans[i]:
ans[i] = d + matrix[p][i]
heappush(hq, (ans[i], i))
return ans[n-1]
x_s, y_s, x_t, y_t = map(int, input().split())
N = int(input())
xyr = [(x_s,y_s,0)]
for i in range(N):
xyr.append(tuple(int(i) for i in input().split()))
xyr.append((x_t,y_t,0))
graph = [[0]*(N+2) for j in range(N+2)]
for i in range(N+2):
for j in range(i,N+2):
graph[i][j] = max(hypot((xyr[i][1]-xyr[j][1]), (xyr[i][0]-xyr[j][0])) - xyr[i][2] - xyr[j][2], 0)
graph[j][i] = graph[i][j]
print(dijkstra(graph)) |
s460039863 | p03864 | u509661905 | 1482104657 | Python | PyPy3 (2.4.0) | py | Runtime Error | 211 | 38640 | 1564 | #!/usr/bin/env pypy3
import math
import itertools
INVALID = -1
INF = 10 ** 12
def dijkstra_dense(num_vs, adj_matrix, source, dest):
dist = [INF for _ in range(num_vs)]
visited = [False for _ in range(num_vs)]
dist[source] = 0
while True:
try:
u = min((j for j in range(num_vs) if not visited[j]),
key=lambda i: dist[i])
except ValueError:
break
if dist[u] == INF:
break
visited[u] = True
for v in range(num_vs):
w = adj_matrix[u][v]
if u != v and w < INF:
new_len = dist[u] + w
if new_len < dist[v]:
dist[v] = new_len
return dist[dest]
def main():
# 始点を頂点0、終点を頂点N + 1とする
x0, y0, xf, yf = (int(x) for x in input().split())
n = int(input())
xs = [None for _ in range(n + 2)]
ys = [None for _ in range(n + 2)]
rs = [None for _ in range(n + 2)]
xs[0], ys[0], rs[0] = x0, y0, 0
xs[n + 1], ys[n + 1], rs[n + 1] = xf, yf, 0
for i in range(1, n + 1):
xs[i], ys[i], rs[i] = (int(z) for z in input().split())
adj_matrix = [[INF for _ in range(n + 2)] for _ in range(n + 2)]
for i, j in itertools.product(range(n + 2), repeat=2):
adj_matrix[i][j] = max(0, math.hypot(xs[i] - xs[j],
ys[i] - ys[j]) - (rs[i] + rs[j]))
res = dijkstra_dense(n + 2, adj_matrix, 0, n + 1)
print("{:.12f}".format(res))
if __name__ == '__main__':
main()
|
s949146595 | p03864 | u509661905 | 1482104304 | Python | Python (3.4.3) | py | Runtime Error | 24 | 3192 | 1533 | #!/usr/bin/env python3
import math
import itertools
INVALID = -1
INF = 10 ** 12
def dijkstra_dense(num_vs, adj_matrix, source, dest):
dist = [INF for _ in range(num_vs)]
visited = [False for _ in range(num_vs)]
dist[source] = 0
while True:
u = min((j for j in range(num_vs) if not visited[j]),
key=lambda i: dist[i], default=INVALID)
if u == INVALID or dist[u] == INF:
break
visited[u] = True
for v in range(num_vs):
w = adj_matrix[u][v]
if u != v and w < INF:
new_len = dist[u] + w
if new_len < dist[v]:
dist[v] = new_len
return dist[dest]
def main():
# 始点を頂点0、終点を頂点N + 1とする
x0, y0, xf, yf = (int(x) for x in input().split())
n = int(input())
xs = [None for _ in range(n + 2)]
ys = [None for _ in range(n + 2)]
rs = [None for _ in range(n + 2)]
xs[0], ys[0], rs[0] = x0, y0, 0
xs[n + 1], ys[n + 1], rs[n + 1] = xf, yf, 0
for i in range(1, n + 1):
xs[i], ys[i], rs[i] = (int(z) for z in input().split())
adj_matrix = [[INF for _ in range(n + 2)] for _ in range(n + 2)]
for i, j in itertools.product(range(n + 2), repeat=2):
adj_matrix[i][j] = max(0, math.hypot(xs[i] - xs[j],
ys[i] - ys[j]) - (rs[i] + rs[j]))
res = dijkstra_dense(n + 2, adj_matrix, 0, n + 1)
print("{:.12f}".format(res))
if __name__ == '__main__':
main()
|
s005156561 | p03864 | u272028993 | 1480915960 | Python | PyPy2 (5.6.0) | py | Runtime Error | 49 | 9328 | 1041 | import math
import heapq
def dijkstra(s,m,n):
visited=[0]*n
d=[float("inf")]*n
d[s]=0
while True:
mincost=float("inf")
for i in xrange(n):
if visited[i]!=2 and d[i]<mincost:
mincost=d[i]
u=i
if mincost==float("inf"):
break
visited[u]=2
for v in xrange(n):
if visited[v]!=2:
if d[u]+m[u][v]<d[v]:
d[v]=d[u]+m[u][v]
visited[v]=1
return d
def main():
xs,ys,xt,yt=map(int,raw_input().split())
n=int(raw_input())
c=[[xs,ys,0]]+[map(int,raw_input().split()) for _ in xrange(n)]+[[xt,yt,0]]
dist=[[float("inf")]*(n+2) for _ in xrange(n+2)]
for i in xrange(n+2):
for j in xrange(n+2):
if i==j:continue
dist[i][j]=min(dist[i][j],dist[j][i],max(math.sqrt(abs(c[i][0]-c[j][0])**2+abs(c[i][1]-c[j][1])**2)-c[i][2]-c[j][2],0))
dist[j][i]=dist[i][j]
ans=dijkstra(0,dist,n+2)
print(ans[n+1])
main()
|
s258797385 | p03864 | u091855288 | 1480912206 | Python | Python (3.4.3) | py | Runtime Error | 132 | 14224 | 802 | def get_input(f, n):
l = [f(x) for x in input().split()]
if n==1:
return l[0]
else:
return l
N, x = get_input(int, 2)
As = get_input(int, N)
Bs = [As[i]+As[i+1] for i in range(N-1)]
result = 0
for idx in range(N-2):
if Bs[idx] > x:
if Bs[idx+1] > x:
la = max(Bs[idx], Bs[idx+1])
ex = la - x
if ex > As[idx+1]:
su = ex - As[idx+1]
Bs[idx+1] -= su
As[idx+2] -= su
result += su
if (Bs[idx] - x - su > 0):
results += (Bs[idx]-x-su)
else:
Bs[idx+1] -= ex
result += ex
else:
result += Bs[idx] - x
idx = N-2
if Bs[idx] > x:
result += Bs[idx] - x
print(result) |
s894489062 | p03864 | u107077660 | 1480910980 | Python | Python (3.4.3) | py | Runtime Error | 23 | 3188 | 621 | from math import sqrt
inf = 10**10
x_s, y_s, x_t, y_t = map(int, input().split())
N = int(input())
xyr = []
for i in range(N):
x_i, y_i, r_i = map(int, input().split())
xyr.append((x_i, y_i, r_i))
p = (x_s, y_s)
goal = (x_t, y_t)
ans = 0
while p != goal and xyr:
D = inf
for i in range(N):
x, y, r = xyr[i]
d = sqrt((x-p[0])**2+(y-p[1])**2) - 2*r
if d < D:
j = i
D = d
d = sqrt((goal[0]-p[0])**2+(goal[1]-p[1])**2)
if d < D:
ans += d
p = goal
else:
x, y, r = xyr.pop(j)
p = (x, y)
N -= 1
ans += D
if p != goal:
d = sqrt((goal[0]-p[0])**2+(goal[1]-p[1])**2)
ans += d
print(max(0, ans))
|
s034398687 | p03864 | u272028993 | 1480908222 | Python | PyPy2 (5.6.0) | py | Runtime Error | 39 | 9072 | 1037 | import math
def dis(x1,y1,r1,x2,y2,r2):
if math.sqrt(abs(x1-x2)**2+abs(y1-y2)**2)>r1+r2:
return math.sqrt(abs(x1-x2)**2+abs(y1-y2)**2)-r1-r2
else:
return 0
import heapq
def dijkstra(s,g,c,n):
d=[float('inf')]*n
d[s]=0
pq=[]
heapq.heappush(pq,[0,s])
while len(pq)!=0:
t,u=heapq.heappop(pq)
if d[u]<t:
continue
for v in g[u]:
if d[u]+c[u][v]<d[v]:
d[v]=d[u]+c[u][v]
heapq.heappush(pq,[d[v],v])
return d
def main():
xs,ys,xt,yt=map(int,raw_input().split())
n=int(raw_input())
c=[[xs,ys,0]]+[map(int,raw_input().split()) for _ in xrange(n)]+[[xt,yt,0]]
g=[[] for _ in xrange(n+2)]
dist=[[float("inf")]*(n+2) for _ in xrange(n+2)]
for i in xrange(n+2):
for j in xrange(n+2):
if i==j:continue
g[i].append(j)
dist[i][j]=min(dist[i][j],dis(c[i][0],c[i][1],c[i][2],c[j][0],c[j][1],c[j][2]))
ans=dijkstra(0,g,dist,n+2)
print(ans[n+1])
main() |
s228202447 | p03864 | u039623862 | 1480907457 | Python | Python (3.4.3) | py | Runtime Error | 23 | 3316 | 1140 | xs,ys,xt,yt = map(int, input().split())
n = int(input())
c = [(xs,ys, 0),(xt,yt,0)]
for i in range(n):
x,y,r = map(int, input().split())
c.append((x,y,r))
def circle_circle(ax,ay,ar,bx,by,br):
d =((ax-bx)**2 + (ay-by)**2)**0.5
return max(0, d-(ar+br))
def dijkstra(V, edges, root):
import heapq
visited = [False] * V
nodes = [[] for i in range(V)]
cost = [[] for i in range(V)]
for e in edges:
s, t, d = e
nodes[s].append(t)
cost[s].append(d)
dist = [float('inf')] * V
dist[root] = 0
h = [(0, root)]
while h:
c, v = heapq.heappop(h)
if visited[v]:
continue
visited[v] = True
for i in range(n+1):
t = nodes[v][i]
nc = c + cost[v][i]
if dist[t] > nc:
dist[t] = nc
heapq.heappush(h, (nc, t))
return dist
edges = []
for i in range(n+1):
for j in range(i+1, n+2):
d = circle_circle(c[i][0],c[i][1],c[i][2],c[j][0],c[j][1],c[j][2])
edges.append((i,j,d))
edges.append((j,i,d))
dij = dijkstra(n+2, edges, 0)
print(dij[1])
|
s999864342 | p03864 | u039623862 | 1480907289 | Python | PyPy3 (2.4.0) | py | Runtime Error | 197 | 38640 | 1150 | xs,ys,xt,yt = map(int, input().split())
n = int(input())
c = [(xs,ys, 0),(xt,yt,0)]
for i in range(n):
x,y,r = map(int, input().split())
c.append((x,y,r))
def circle_circle(ax,ay,ar,bx,by,br):
d =((ax-bx)**2 + (ay-by)**2)**0.5
return max(0, d-(ar+br))
def dijkstra(V, edges, root):
import heapq
visited = [False] * V
nodes = [[] for i in range(V)]
cost = [[] for i in range(V)]
for e in edges:
s, t, d = e
nodes[s].append(t)
cost[s].append(d)
dist = [float('inf')] * V
dist[root] = 0
h = [(0, root)]
while h:
c, v = heapq.heappop(h)
if visited[v]:
continue
visited[v] = True
for i in range(len(nodes[v])):
t = nodes[v][i]
nc = c + cost[v][i]
if dist[t] > nc:
dist[t] = nc
heapq.heappush(h, (nc, t))
return dist
edges = []
for i in range(n+1):
for j in range(i+1, n+2):
d = circle_circle(c[i][0],c[i][1],c[i][2],c[j][0],c[j][1],c[j][2])
edges.append((i,j,d))
edges.append((j,i,d))
dij = dijkstra(n+2, edges, 0)
print(dij[1])
|
s483982470 | p03865 | u827202523 | 1583360231 | Python | PyPy3 (2.4.0) | py | Runtime Error | 190 | 39220 | 100 | s = input().strip()
l = len(s)
if (l + s[0] == s[-1]) % 2:
print("First")
else:
print("Second") |
s528270335 | p03865 | u835482198 | 1481278509 | Python | Python (3.4.3) | py | Runtime Error | 24 | 3316 | 139 | #!/usr/bin/env python
# -*- coding:utf-8 -*-
s = input()
if len(s) % 2 == 0 ^ s[0] == s[-1]:
print("Second")
else:
print("First")
|
s007216014 | p03865 | u113430839 | 1481238092 | Python | Python (3.4.3) | py | Runtime Error | 24 | 3316 | 246 | s=input();l = len;p = print
if (s[0]==s[-1] * l(s)%2==0) + (s[0]!=s[-1] * l(s)%2==1):
p("First")
else:
p("Second")
s=input();l = len;p = print
if (s[0]==s[-1] * l(s)%2==0) + (s[0]!=s[-1] * l(s)%2==1):
p("First")
else:
p("Second")
|
s108835057 | p03866 | u399721252 | 1597192021 | Python | PyPy3 (7.3.0) | py | Runtime Error | 2208 | 95168 | 1170 | def djkstra(in_connect_list,v):
out_shortest_list = [10**14 for i in range(v)]
out_shortest_list[0] = 0
searching_list = [0]
while searching_list != []:
new_search_list = []
for i in searching_list:
for j in range(len(in_connect_list[i])):
if i != j and out_shortest_list[j] > in_connect_list[i][j] + out_shortest_list[i]:
out_shortest_list[j] = in_connect_list[i][j] + out_shortest_list[i]
new_search_list.append(j)
searching_list = new_search_list
return out_shortest_list, out_parent_list
a, b, c, d = [ int(v) for v in input().split() ]
n = int(input())
point_list = []
point_list.append((a, b, 0))
for i in range(n):
point_list.append(tuple([ int(v) for v in input().split() ]))
point_list.append((c, d, 0))
def dist(p1,p2):
d = ((p1[0]-p2[0])**2+ (p1[1]-p2[1])**2)**0.5 - (p1[2]+p2[2])
return max(0,d)
connect_list = [ [ dist(point_list[i],point_list[j]) for j in range(n+2) ] for i in range(n+2) ]
for i in range(n+2):
connect_list[i][i] = -1
shortest_list, parent_list = djkstra(connect_list,n+2)
print(shortest_list[-1]) |
s591065548 | p03866 | u509368316 | 1590460038 | Python | Python (3.4.3) | py | Runtime Error | 217 | 39340 | 453 | xs,ys,xt,yt=map(int,input().split())
N=int(input())
import numpy as np
XYR=np.empty((N+2,3),dtype=np.float64)
XYR[1:-1,:]=np.array([input().split() for i in range(N)])
XYR[0,:]=[xs,ys,0]
XYR[-1,:]=[xt,yt,0]
X,Y,R=XYR.T
c=np.maximum(0,np.sqrt(np.square(X[None,:]-X[:,None])+np.square(Y[None,:]-Y[:,None]))-R[None,:]-R[:,None])
from scipy.sparse import*
g=csgraph.csgraph_from_dense(c,null_value=np.inf)
print(csgraph.dijkstra(g,directed=0,indices=0)[-1]) |
s380195391 | p03866 | u674574659 | 1590118420 | Python | Python (3.4.3) | py | Runtime Error | 2107 | 61040 | 894 | import heapq
xs,yx,xt,yt = map(int,input().split())
N = int(input())
l = [[],[xs,yx,0],[xt,yt,0]]
for i in range(N):
l.append(list(map(int,input().split())))
##距離リスト
d = [[0]*(N+3) for _ in range(N+3)]
for i in range(1,N+3):
d[i][i] = 0
#O(10**6)
for i in range(1,N+3):
for j in range(i+1,N+3):
sa = (l[i][0]-l[j][0])**2 + (l[i][1]-l[j][1])**2
kyori = max(0,sa**(1/2)-l[i][2]-l[j][2])
d[i][j] = kyori
d[j][i] = kyori
md = [float("inf")]*(N+3)
heap = [[d[1][i],i] for i in range(2,N+3)]
heapq.heapify(heap)
for i in range(1,N+3):
md[i]=d[1][i]
cnt = 0
seen = [False]*(N+3)
seen[1] = True
while cnt != N+1:
v = heapq.heappop(heap)
if seen[v[1]] == False:
for i in range(1,N+3):
if md[i] > md[v[1]]+d[i][v[1]]:
md[i] = md[v[1]]+d[i][v[1]]
seen[v[1]] = True
cnt += 1
heapq.heappush(heap,[md[i],i])
print(md[2]) |
s950431093 | p03866 | u227082700 | 1590110344 | Python | PyPy3 (2.4.0) | py | Runtime Error | 164 | 38292 | 867 | def main()
import sys
input=sys.stdin.readline
sx,sy,tx,ty=map(int,input().split())
n=int(input())
p=[(sx,sy,0)]
for _ in range(n):
x,y,r=map(int,input().split())
p.append((x,y,r))
p.append((tx,ty,0))
n+=2
edge=[[]for _ in range(n)]
for i in range(n-1):
for j in range(i+1,n):
sx,sy,sr=p[i]
tx,ty,tr=p[j]
t=(abs(sx-tx)**2+abs(sy-ty)**2)**0.5
c=max(0,t-(sr+tr))
edge[i].append((j,c))
edge[j].append((i,c))
from heapq import heappop,heappush
def dijkstra(s,n,edge):
inf=10**20
ans=[inf]*n
ans[s]=0
root=[-1]*n
h=[[0,s]]
while h:
c,v=heappop(h)
if ans[v]<c:continue
for u,t in edge[v]:
if c+t<ans[u]:
ans[u]=c+t
root[u]=v
heappush(h,[c+t,u])
print(ans[n-1])
dijkstra(0,n,edge)
if __name__ == "__main__":
main() |
s369328321 | p03866 | u893063840 | 1589730312 | Python | Python (3.4.3) | py | Runtime Error | 274 | 40560 | 578 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
import numpy as np
from scipy.spatial.distance import cdist
from scipy.sparse.csgraph import dijkstra, csgraph_from_dense
xs, ys, xt, yt = map(int, readline().split())
n = int(readline())
xyr = np.array(read().split(), np.int64)
xyr = np.append(xyr, [xs, ys, 0, xt, yt, 0])
xyr = xyr.reshape((-1, 3))
xy = xyr[:, :2]
dist = cdist(xy, xy)
r = xyr[:, 2]
dist = np.maximum(dist - r - r.reshape((-1, 1)), 0)
g = csgraph_from_dense(dist, null_value=np.inf)
ans = dijkstra(g, indices=n)[n+1]
print(ans)
|
s740598019 | p03866 | u919730120 | 1589678292 | Python | PyPy3 (2.4.0) | py | Runtime Error | 783 | 129364 | 1316 | import heapq
def dijkstra_heap(s,g,edge):
#始点sから各頂点への最短距離
d = [10**20] * (n+2)
used = [True] * (n+2) #True:未確定
d[s] = 0
used[s] = False
edgelist = []
sx,sy,sr=edge[s][0],edge[s][1],edge[s][2]
for i in range(n+2):
x,y,r=edge[i][0],edge[i][1],edge[i][2]
dist=((x-sx)**2+(y-sy)**2)**(1/2)
heapq.heappush(edgelist,int(max(dist-r-sr,0)*(10**9))*10000+i)
while len(edgelist):
minedge = heapq.heappop(edgelist)
#まだ使われてない頂点の中から最小の距離のものを探す
dis=(minedge//(10**4))/10**9
v = int(minedge-dis*10**13)
if not used[v]:
continue
d[v] = dis
used[v] = False
bx,by,br=edge[v][0],edge[v][1],edge[v][2]
for i in range(n+2):
x,y,r=edge[i][0],edge[i][1],edge[i][2]
dist=((x-bx)**2+(y-by)**2)**(1/2)
if used[i]:
heapq.heappush(edgelist,int((max(dist-r-br,0)+d[v])*(10**9))*10000+i)
if not used[g]:
break
return d[g]
sx,sy,gx,gy = map(int,input().split()) #n:頂点数 w:辺の数
n=int(input())
edge=[[sx,sy,0],[gx,gy,0]]
for i in range(2,n+2):
x,y,r=map(int,input().split())
edge.append([x,y,r])
print(dijkstra_heap(0,1,edge)) |
s202570144 | p03866 | u623819879 | 1587948753 | Python | PyPy3 (2.4.0) | py | Runtime Error | 189 | 38384 | 7804 | import sys
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
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=(list(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_ls=None,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
if init_ls==None:
for i in range(n):
self.seg[i+self.num-1]=init_val
else:
for i in range(n):
self.seg[i+self.num-1]=init_ls[i]
#build
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 >>= 1
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)
def dijkstra(edge,st):
# edge=[[(v_to,dist_to_v),...],[],...]
# initialize: def: d=dist(st,i), prev=[previous vertex in minimum path], q[]
n=len(edge)
d=[(0 if st==i else inf) for i in range(n)]
q=[(0,st)]
# calc
while q:
dist,cur=heappop(q)
for dst,dist in edge[cur]:
alt=d[cur]+dist
if alt<d[dst]:
d[dst]=alt
heappush(q,(alt,dst))
return d
sx,sy,gx,gy=LI()
n=I()
c=[(sx,sy,0),(gx,gy,0)]
for i in range(n):
c+=[LI()]
n+=2
g=[[]for i in range(n)]
for i in range(n):
for j in range(i+1,n):
x,y,r1=c[i]
s,t,r2=c[j]
d=((x-s)**2+(y-t)**2)**0.5 -r1 -r2
if d<0:d=0
g[i].append((j,d))
g[j].append((i,d))
d=dijkstra(g,0)
print(d[1])
|
s997254251 | p03866 | u623819879 | 1587948474 | Python | PyPy3 (2.4.0) | py | Runtime Error | 170 | 38256 | 7904 | 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=(list(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_ls=None,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
if init_ls==None:
for i in range(n):
self.seg[i+self.num-1]=init_val
else:
for i in range(n):
self.seg[i+self.num-1]=init_ls[i]
#build
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 >>= 1
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)
def dijkstra(edge,st):
# edge=[[(v_to,dist_to_v),...],[],...]
# initialize: def: d=dist(st,i), prev=[previous vertex in minimum path], q[]
n=len(edge)
d=[(0 if st==i else inf) for i in range(n)]
q=[(0,st)]
# calc
while q:
dist,cur=heappop(q)
for dst,dist in edge[cur]:
alt=d[cur]+dist
if alt<d[dst]:
d[dst]=alt
heappush(q,(alt,dst))
return d,0
sx,sy,gx,gy=LI()
n=I()
c=[(sx,sy,0),(gx,gy,0)]
for i in range(n):
c+=[LI()]
n+=2
g=[[]for i in range(n)]
for i in range(n):
for j in range(i+1,n):
x,y,r1=c[i]
s,t,r2=c[j]
d=(x-s)**2+(y-t)**2)**0.5 -r1 -r2
if d<0:d=0
g[i].append((j,d))
g[j].append((i,d))
d,_=dijkstra(g,0)
print(d[1])
|
s709261000 | p03866 | u497046426 | 1587056116 | Python | PyPy3 (2.4.0) | py | Runtime Error | 2110 | 125548 | 1141 | from itertools import combinations
from heapq import heappush, heappop
def dist(p1, p2): return ((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2) ** 0.5
xs, ys, xt, yt = map(int, input().split())
N = int(input())
P = [[(xs, ys), 0, 0], [(xt, yt), 0, 1]]
for i in range(2, N+2):
x, y, r = map(int, input().split())
P.append([(x, y), r, i])
E = [[float('inf')] * (N+2) for _ in range(N+2)]
for v in range(N): E[v][v] = 0
for [p1, r1, i], [p2, r2, j] in combinations(P, 2):
d = max(0, dist(p1, p2) - (r1 + r2))
E[i][j] = E[j][i] = d
dist = [float('inf')] * N # the distance of each vertex from s
prev = [-1] * N # the previous vertex of each vertex on a shortest path from s
visited = [False] * N
n_visited = 0 # #(visited vertices)
heap = []
heappush(heap, (0, -1, 0))
while heap:
d, p, v = heappop(heap)
if visited[v]: continue # (s,v)-shortest path is already calculated
dist[v] = d; prev[v] = p; visited[v] = True
n_visited += 1
if n_visited == N: break
for u in range(N):
if visited[u]: continue
temp = d + E[v][u]
if dist[u] > temp: heappush(heap, (temp, v, u))
print(dist[1]) |
s589332870 | p03866 | u497046426 | 1587056040 | Python | PyPy3 (2.4.0) | py | Runtime Error | 253 | 62320 | 1137 | from itertools import combinations
from heapq import heappush, heappop
def dist(p1, p2): return ((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2) ** 0.5
xs, ys, xt, yt = map(int, input().split())
N = int(input())
P = [[(xs, ys), 0, 0], [(xt, yt), 0, 1]]
for i in range(2, N+2):
x, y, r = map(int, input().split())
P.append([(x, y), r, i])
E = [[float('inf')] * N for _ in range(N+2)]
for v in range(N): E[v][v] = 0
for [p1, r1, i], [p2, r2, j] in combinations(P, 2):
d = max(0, dist(p1, p2) - (r1 + r2))
E[i][j] = E[j][i] = d
dist = [float('inf')] * N # the distance of each vertex from s
prev = [-1] * N # the previous vertex of each vertex on a shortest path from s
visited = [False] * N
n_visited = 0 # #(visited vertices)
heap = []
heappush(heap, (0, -1, 0))
while heap:
d, p, v = heappop(heap)
if visited[v]: continue # (s,v)-shortest path is already calculated
dist[v] = d; prev[v] = p; visited[v] = True
n_visited += 1
if n_visited == N: break
for u in range(N):
if visited[u]: continue
temp = d + E[v][u]
if dist[u] > temp: heappush(heap, (temp, v, u))
print(dist[1]) |
s169594859 | p03866 | u497046426 | 1587055997 | Python | PyPy3 (2.4.0) | py | Runtime Error | 239 | 61424 | 1135 | from itertools import combinations
from heapq import heappush, heappop
def dist(p1, p2): return ((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2) ** 0.5
xs, ys, xt, yt = map(int, input().split())
N = int(input())
P = [[(xs, ys), 0, 0], [(xt, yt), 0, 1]]
for i in range(2, N+2):
x, y, r = map(int, input().split())
P.append([(x, y), r, i])
E = [[float('inf')] * N for _ in range(N)]
for v in range(N): E[v][v] = 0
for [p1, r1, i], [p2, r2, j] in combinations(P, 2):
d = max(0, dist(p1, p2) - (r1 + r2))
E[i][j] = E[j][i] = d
dist = [float('inf')] * N # the distance of each vertex from s
prev = [-1] * N # the previous vertex of each vertex on a shortest path from s
visited = [False] * N
n_visited = 0 # #(visited vertices)
heap = []
heappush(heap, (0, -1, 0))
while heap:
d, p, v = heappop(heap)
if visited[v]: continue # (s,v)-shortest path is already calculated
dist[v] = d; prev[v] = p; visited[v] = True
n_visited += 1
if n_visited == N: break
for u in range(N):
if visited[u]: continue
temp = d + E[v][u]
if dist[u] > temp: heappush(heap, (temp, v, u))
print(dist[1]) |
s541277128 | p03866 | u779455925 | 1582590208 | Python | PyPy3 (2.4.0) | py | Runtime Error | 764 | 122972 | 1555 | from collections import *
from itertools import *
from bisect import *
from heapq import *
import copy
#N=int(input())
#S=[list(map(int,input().split())) for i in range(N)]
idle=10**13
xs,ys,xt,yt=map(int,input().split())
N=int(input())
XYR=[list(map(int,input().split())) for i in range(N)]
XYR.append([xt,yt,0])#終点
XYR.append([xs,ys,0])#開始
"""for i in range(len(XYR)):
XYR[i][0]*=idle
XYR[i][1]*=idle
XYR[i][2]*=idle"""
kyori=[[0 for i in range(len(XYR))] for n in range(len(XYR))]
for i in range(len(XYR)):
for m in range(i,len(XYR)):
if i==m:
t=0
else:
x1,y1,r1=XYR[i]
x2,y2,r2=XYR[m]
t=max(((x2-x1)**2+(y2-y1)**2)**.5-r1-r2,0)
kyori[i][m]=round(t*idle)
kyori[m][i]=round(t*idle)
stack=sorted(kyori[-2])
heapify(stack)
Pdic={}
dic={}
kyoriset=set()
for i in range(len(XYR)):
a=kyori[-1][i]
Pdic.update({i:a})
if not a in kyoriset:
kyoriset.add(a)
dic.update({a:[i]})
else:
dic[a].append(i)
visited=set([len(XYR)-1])
while stack:
m=heappop(stack)
a=dic[m].pop()
if a==len(XYR)-2:
print(m/idle)
exit()
if not a in visited:
visited.add(a)
for i in range(len(XYR)):
nm=kyori[a][i]+m
if Pdic[i]>nm:
Pdic[i]=nm
heappush(stack,nm)
if not nm in kyoriset:
kyoriset.add(nm)
dic.update({nm:[i]})
else:
dic[nm].append(i)
|
s968758340 | p03866 | u779455925 | 1582590134 | Python | PyPy3 (2.4.0) | py | Runtime Error | 2111 | 122460 | 1539 | from collections import *
from itertools import *
from bisect import *
from heapq import *
import copy
#N=int(input())
#S=[list(map(int,input().split())) for i in range(N)]
idle=10**13
xs,ys,xt,yt=map(int,input().split())
N=int(input())
XYR=[list(map(int,input().split())) for i in range(N)]
XYR.append([xt,yt,0])#終点
XYR.append([xs,ys,0])#開始
for i in range(len(XYR)):
XYR[i][0]*=idle
XYR[i][1]*=idle
XYR[i][2]*=idle
kyori=[[0 for i in range(len(XYR))] for n in range(len(XYR))]
for i in range(len(XYR)):
for m in range(i,len(XYR)):
if i==m:
t=0
else:
x1,y1,r1=XYR[i]
x2,y2,r2=XYR[m]
t=max(((x2-x1)**2+(y2-y1)**2)**.5-r1-r2,0)
kyori[i][m]=round(t)
kyori[m][i]=round(t)
stack=sorted(kyori[-2])
heapify(stack)
Pdic={}
dic={}
kyoriset=set()
for i in range(len(XYR)):
a=kyori[-1][i]
Pdic.update({i:a})
if not a in kyoriset:
kyoriset.add(a)
dic.update({a:[i]})
else:
dic[a].append(i)
visited=set([len(XYR)-1])
while stack:
m=heappop(stack)
a=dic[m].pop()
if a==len(XYR)-2:
print(m/idle)
exit()
if not a in visited:
visited.add(a)
for i in range(len(XYR)):
nm=kyori[a][i]+m
if Pdic[i]>nm:
Pdic[i]=nm
heappush(stack,nm)
if not nm in kyoriset:
kyoriset.add(nm)
dic.update({nm:[i]})
else:
dic[nm].append(i)
|
s442377458 | p03866 | u779455925 | 1582589812 | Python | PyPy3 (2.4.0) | py | Runtime Error | 2109 | 103004 | 1524 | from collections import *
from itertools import *
from bisect import *
from heapq import *
import copy
#N=int(input())
#S=[list(map(int,input().split())) for i in range(N)]
#print(max(((0)**2+(0)**2)**.5-0-0,0))
xs,ys,xt,yt=map(int,input().split())
N=int(input())
XYR=[list(map(int,input().split())) for i in range(N)]
XYR.append([xt,yt,0])#終点
XYR.append([xs,ys,0])#開始
kyori=[[0 for i in range(len(XYR))] for n in range(len(XYR))]
for i in range(len(XYR)):
for m in range(i,len(XYR)):
if i==m:
t=0
else:
x1,y1,r1=XYR[i]
x2,y2,r2=XYR[m]
t=max(((x2-x1)**2+(y2-y1)**2)**.5-r1-r2,0)
kyori[i][m]=t
kyori[m][i]=t
stack=sorted(kyori[-2])
heapify(stack)
Pdic={}
dic={}
kyoriset=set()
for i in range(len(XYR)):
a=str(kyori[-1][i])
Pdic.update({i:a})
if not a in kyoriset:
kyoriset.add(a)
dic.update({a:[i]})
else:
dic[a].append(i)
visited=set([len(XYR)-1])
while stack:
m=str(heappop(stack))
a=dic[m].pop()
if a==len(XYR)-2:
print(m)
exit()
if not a in visited:
visited.add(a)
for i in range(len(XYR)):
nm=kyori[a][i]+float(m)
nm=str(nm)
if float(Pdic[i])>float(nm):
Pdic[i]=nm
heappush(stack,float(nm))
if not nm in kyoriset:
kyoriset.add(nm)
dic.update({nm:[i]})
else:
dic[nm].append(i)
|
s386624412 | p03866 | u779455925 | 1582589068 | Python | PyPy3 (2.4.0) | py | Runtime Error | 813 | 129032 | 1448 | from collections import *
from itertools import *
from bisect import *
from heapq import *
import copy
#N=int(input())
#S=[list(map(int,input().split())) for i in range(N)]
xs,ys,xt,yt=map(int,input().split())
N=int(input())
XYR=[list(map(int,input().split())) for i in range(N)]
XYR.append([xt,yt,0])#終点
XYR.append([xs,ys,0])#開始
kyori=[[0 for i in range(len(XYR))] for n in range(len(XYR))]
for i in range(len(XYR)):
for m in range(i,len(XYR)):
if i==m:
t=0
else:
x1,y1,r1=XYR[i]
x2,y2,r2=XYR[m]
t=max(((x2-x1)**2+(y2-y1)**2)**.5-r1-r2,0)
kyori[i][m]=t
kyori[m][i]=t
print(exit)
stack=sorted(kyori[-2])
heapify(stack)
Pdic={}
dic={}
kyoriset=set()
for i in range(len(XYR)):
a=kyori[-1][i]
Pdic.update({i:a})
if not a in kyoriset:
kyoriset.add(a)
dic.update({a:[i]})
else:
dic[a].append(i)
visited=set([len(XYR)-1])
#print(Pdic)
#print(dic)
#print(stack)
while stack:
m=heappop(stack)
a=dic[m].pop()
if a==len(XYR)-2:
print(m)
exit()
if not a in visited:
visited.add(a)
for i in range(len(XYR)):
nm=kyori[a][i]+m
#if Pdic[i]>nm:
# Pdic[i]=nm
heappush(stack,nm)
if not nm in dic:
#kyoriset.add(nm)
dic.update({nm:[i]})
else:
dic[nm].append(i)
|
s136069938 | p03866 | u779455925 | 1582589015 | Python | PyPy3 (2.4.0) | py | Runtime Error | 882 | 128776 | 1436 | from collections import *
from itertools import *
from bisect import *
from heapq import *
import copy
#N=int(input())
#S=[list(map(int,input().split())) for i in range(N)]
xs,ys,xt,yt=map(int,input().split())
N=int(input())
XYR=[list(map(int,input().split())) for i in range(N)]
XYR.append([xt,yt,0])#終点
XYR.append([xs,ys,0])#開始
kyori=[[0 for i in range(len(XYR))] for n in range(len(XYR))]
for i in range(len(XYR)):
for m in range(i,len(XYR)):
if i==m:
t=0
else:
x1,y1,r1=XYR[i]
x2,y2,r2=XYR[m]
t=max(((x2-x1)**2+(y2-y1)**2)**.5-r1-r2,0)
kyori[i][m]=t
kyori[m][i]=t
stack=sorted(kyori[-2])
heapify(stack)
Pdic={}
dic={}
kyoriset=set()
for i in range(len(XYR)):
a=kyori[-1][i]
Pdic.update({i:a})
if not a in kyoriset:
kyoriset.add(a)
dic.update({a:[i]})
else:
dic[a].append(i)
visited=set([len(XYR)-1])
#print(Pdic)
#print(dic)
#print(stack)
while stack:
m=heappop(stack)
a=dic[m].pop()
if a==len(XYR)-2:
print(m)
exit()
if not a in visited:
visited.add(a)
for i in range(len(XYR)):
nm=kyori[a][i]+m
#if Pdic[i]>nm:
# Pdic[i]=nm
heappush(stack,nm)
if not nm in dic:
#kyoriset.add(nm)
dic.update({nm:[i]})
else:
dic[nm].append(i)
|
s213372034 | p03866 | u779455925 | 1582588708 | Python | PyPy3 (2.4.0) | py | Runtime Error | 942 | 137088 | 1476 | from collections import *
from itertools import *
from bisect import *
from heapq import *
import copy
#N=int(input())
#S=[list(map(int,input().split())) for i in range(N)]
xs,ys,xt,yt=map(int,input().split())
N=int(input())
XYR=[list(map(int,input().split())) for i in range(N)]
XYR.append([xt,yt,0])#終点
XYR.append([xs,ys,0])#開始
kyori=[[0 for i in range(len(XYR))] for n in range(len(XYR))]
for i in range(len(XYR)):
for m in range(i,len(XYR)):
if i==m:
t=0
else:
x1,y1,r1=XYR[i]
x2,y2,r2=XYR[m]
t=max(((x2-x1)**2+(y2-y1)**2)**.5-r1-r2,0)
kyori[i][m]=t
kyori[m][i]=t
stack=sorted(kyori[-2])
heapify(stack)
Pdic={}
dic={}
kyoriset=set()
for i in range(len(XYR)):
Pdic.update({i:kyori[-1][i]})
if not kyori[-1][i] in kyoriset:
kyoriset.add(kyori[-1][i])
dic.update({kyori[-1][i]:[i]})
else:
dic[kyori[-1][i]].append(i)
visited=set([len(XYR)-1])
#print(Pdic)
#print(dic)
#print(stack)
while stack:
m=heappop(stack)
a=dic[m].pop()
if a==len(XYR)-2:
print(m)
exit()
if not a in visited:
visited.add(a)
for i in range(len(XYR)):
nm=kyori[a][i]+m
#if Pdic[i]>nm:
# Pdic[i]=nm
heappush(stack,nm)
if not nm in kyoriset:
kyoriset.add(nm)
dic.update({nm:[i]})
else:
dic[nm].append(i)
|
s800074374 | p03866 | u779455925 | 1582588431 | Python | PyPy3 (2.4.0) | py | Runtime Error | 577 | 101980 | 1471 | from collections import *
from itertools import *
from bisect import *
from heapq import *
import copy
#N=int(input())
#S=[list(map(int,input().split())) for i in range(N)]
xs,ys,xt,yt=map(int,input().split())
N=int(input())
XYR=[list(map(int,input().split())) for i in range(N)]
XYR.append([xt,yt,0])#終点
XYR.append([xs,ys,0])#開始
kyori=[[0 for i in range(len(XYR))] for n in range(len(XYR))]
for i in range(len(XYR)):
for m in range(i,len(XYR)):
if i==m:
t=0
else:
x1,y1,r1=XYR[i]
x2,y2,r2=XYR[m]
t=max(((x2-x1)**2+(y2-y1)**2)**.5-r1-r2,0)
kyori[i][m]=t
kyori[m][i]=t
stack=sorted(kyori[-2])
heapify(stack)
Pdic={}
dic={}
kyoriset=set()
for i in range(len(XYR)):
Pdic.update({i:kyori[-1][i]})
if not kyori[-1][i] in kyoriset:
kyoriset.add(kyori[-1][i])
dic.update({kyori[-1][i]:[i]})
else:
dic[kyori[-1][i]].append(i)
visited=set([len(XYR)-1])
#print(dic)
while stack:
m=heappop(stack)
a=dic[m].pop()
if a==len(XYR)-2:
print(m)
exit()
if not a in visited:
visited.add(a)
for i in range(len(XYR)):
nm=kyori[a][i]+m
if Pdic[i]>nm:
Pdic[i]=nm
heappush(stack,nm)
if not nm in kyoriset:
kyoriset.add(nm)
dic.update({nm:[i]})
else:
dic[nm].append(i)
|
s531781634 | p03866 | u532966492 | 1575652113 | Python | PyPy3 (2.4.0) | py | Runtime Error | 181 | 38392 | 914 | from heapq import *
def main():
import numpy as np
xs,ys,xt,yt=map(int,input().split())
n=int(input())
xyr=[[xs,ys,0],[xt,yt,0]]+[list(map(int,input().split())) for _ in [0]*n]
inf=float('inf')
g=[[] for _ in [0]*(n+2)]
for i in range(n+1):
x1,y1,r1=xyr[i]
xy1=np.array([x1,y1])
for j in range(i+1,n+2):
x2,y2,r2=xyr[j]
xy2=np.array([x2,y2])
d_temp=max(0,np.linalg.norm(xy1-xy2)-r1-r2)
g[i].append([j,d_temp])
g[j].append([i,d_temp])
d=[10**10]*(n+2)
visit=[False]*(n+2)
visit[0]=True
h=[]
for i,j in g[0]:
h.append([j,i])
heapify(h)
while h:
i,j=heappop(h)
if visit[j]==True:
continue
visit[j]=True
d[j]=i
for k,l in g[j]:
if visit[k]==False:
heappush(h,[l+i,k])
print(d[1])
main() |
s790221365 | p03866 | u716530146 | 1570661229 | Python | Python (3.4.3) | py | Runtime Error | 2115 | 73784 | 757 | #!/usr/bin/env python3
from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall, dijkstra
# G = csgraph_from_dense(edge, null_value=10**9)
# f = floyd_warshall(G)
# d = dijkstra(G, indices=1)
import sys
input = lambda: sys.stdin.readline()[:-1]
sys.setrecursionlimit(10**8)
xs,ys,xt,yt=map(int,input().split())
n=int(input())
xyr=[(xs,ys,0),(xt,yt,0)]
data=[[0]*(n+2) for i in range(n+2)]
for i in range(n):
xyr.append(tuple(map(int,input().split())))
for i in range(n+2):
for j in range(n+2):
x0=xyr[i][0];y0=xyr[i][1];r0=xyr[i][2]
x1 = xyr[j][0];y1=xyr[j][1];r1=xyr[j][2]
data[i][j]=max(((x0-x1)**2+(y0-y1)**2)**.5-r0-r1,0)
G = csgraph_from_dense(data, null_value=10**9)
d = dijkstra(G, indices=0)
print(d[1])
|
s448999869 | p03866 | u392319141 | 1568766454 | Python | Python (3.4.3) | py | Runtime Error | 2113 | 51472 | 714 | import numpy as np
from scipy.sparse.csgraph import dijkstra, csgraph_from_dense
sX, sY, eX, eY = map(int, input().split())
N = int(input())
circles = [(sX, sY, 0)]
for _ in range(N):
cx, cy, r = map(int, input().split())
circles.append((cx, cy, r))
circles.append((eX, eY, 0))
minDist = [[float('inf')] * (N + 2) for _ in range(N + 2)]
for i, (cx1, cy1, r1) in enumerate(circles):
for j, (cx2, cy2, r2) in enumerate(circles):
cDist = ((cx1 - cx2)**2 + (cy1 - cy2)**2)**0.5
dist = max(0, cDist - r1 - r2)
minDist[i][j] = dist
minDist[j][i] = dist
l = csgraph_from_dense(minDist, null_value=float('inf'))
ans = dijkstra(l, indices=0, directed=False)
print(ans[-1]) |
s191089209 | p03866 | u844789719 | 1568172174 | Python | Python (3.4.3) | py | Runtime Error | 2109 | 27232 | 626 | import numpy as np
from scipy.sparse import csgraph
xs, ys, xt, yt = [int(_) for _ in input().split()]
N = int(input())
XYR = np.array([[xs, ys, 0]] + [[int(_) for _ in input().split()]
for _ in range(N)] + [[xt, yt, 0]])
edge = [[0] * (N + 2) for _ in range(N + 2)]
for i in range(N + 1):
for j in range(i + 1, N + 2):
edge[i][j] = edge[j][i] = max(
((XYR[i][0] - XYR[j][0])**2 +
(XYR[i][1] - XYR[j][1])**2)**0.5 - XYR[i][2] - XYR[j][2], 0)
G = csgraph.csgraph_from_dense(edge, null_value=np.inf)
print(csgraph.dijkstra(G, directed=False, indices=0)[-1])
|
s950438275 | p03866 | u844789719 | 1568171070 | Python | Python (3.4.3) | py | Runtime Error | 224 | 16532 | 611 | import numpy as np
from scipy.sparse.csgraph import *
xs, ys, xt, yt = [int(_) for _ in input().split()]
N = int(input())
XYR = np.array([[xs, ys, 0]] + [[int(_) for _ in input().split()]
for _ in range(N)] + [[xt, yt, 0]])
edge = [[0] * (N + 2) for _ in range(N + 2)]
for i in range(N + 1):
for j in range(i + 1, N + 2):
edge[i][j] = edge[j][i] = max(
((XYR[i][0] - XYR[j][0])**2 +
(XYR[i][1] - XYR[j][1])**2)**0.5 - XYR[i][2] - XYR[j][2], 0)
G = csgraph_from_dense(edge, null_value=10**10)
print(dijkstra(G, directed=False, indices=0)[-1])
|
s020913897 | p03866 | u102461423 | 1562701932 | Python | Python (3.4.3) | py | Runtime Error | 170 | 13676 | 619 | import sys
input = sys.stdin.readline
import numpy as np
from scipy.sparse.csgraph import *
xs,ys,xt,yt = map(int,input().split())
N = int(input())
XYR = np.empty((3,N+2),dtype=np.int64)
XYR[:,:2] = [[xs,xt],[ys,yt],[0,0]]
XYR[:,2:] = np.array([input().split() for _ in range(N)], dtype=np.int64).T
X,Y,R = XYR
dist = np.sqrt(np.square(X[:,None] - X[None,:]) + np.square(Y[:,None] - Y[None,:])) # euclid
dist -= R[:,None] + R[None,:]
np.maximum(dist, 0, out = dist)
dist[range(N+2), range(N+2)] = np.inf
graph = csgraph_from_dense(dist, null_value = np.inf)
answer = dijkstra(graph, indices = 0)[1]
print(answer) |
s599534876 | p03866 | u399721252 | 1561836278 | Python | PyPy3 (2.4.0) | py | Runtime Error | 182 | 38384 | 1349 | def djkstra(in_connect_list,v):
out_parent_list = [-1 for i in range(v)]
out_shortest_list = [10**9 for i in range(v)]
out_shortest_list[0] = 0
searching_list = [0]
while searching_list != []:
new_search_list = []
for i in searching_list:
for j in range(len(in_connect_list[i])):
if i != j and out_shortest_list[j] >= in_connect_list[i][j] + out_shortest_list[i]:
out_shortest_list[j] = in_connect_list[i][j] + out_shortest_list[i]
out_parent_list[j] = i
new_search_list.append(j)
searching_list = new_search_list
return out_shortest_list, out_parent_list
a, b, c, d = [ int(v) for v in input().split() ]
n = int(input())
point_list = [[a, b, 0]] + [ [ int(v) for v in input().split() ] for i in range(n) ] + [[c, d, 0]]
def dist(p1,p2):
d = ((p1[0]-p2[0])**2+ (p1[1]-p2[1])**2)**0.5 - (p1[2]+p2[2])
return max(0,d)
connect_list = [ [ dist(point_list[i],point_list[j]) for j in range(n+2) ] for i in range(n+2) ]
for i in range(n+2):
connect_list[i][i] = -1
shortest_list, parent_list = djkstra(connect_list,n+2)
print(shortest_list[-1]) |
s441310703 | p03866 | u310678820 | 1559669432 | Python | Python (3.4.3) | py | Runtime Error | 172 | 13660 | 593 | from scipy.sparse.csgraph import csgraph_from_dense,dijkstra
from numpy.linalg import norm
from numpy import array
xs, ys, xt, yt = map(int, input().split())
N = int(input())
p=[(xs, ys, 0), (xt, yt, 0)]
edge = [[-1]*(n+2) for _ in range(n+2)]
edge[0][1] = edge[1][0] = norm(array([xs-xt, ys-yt]))
for i in range(N):
x, y, r = map(int, input().split())
for j in range(len(p)):
x1, y1, r1 = p[j]
edge[i+2][j] = edge[j][i+2] = max(norm(array([x-x1, y-y1]))-r-r1, 0.0)
p.append((x, y, r))
G = csgraph_from_dense(edge,null_value=-1)
print(dijkstra(G,indices=0)[1]) |
s751941307 | p03866 | u284854859 | 1559663909 | Python | PyPy3 (2.4.0) | py | Runtime Error | 172 | 38640 | 512 | from scipy.sparse.csgraph import csgraph_from_dense,dijkstra
xs, ys, xt, yt = map(int, input().split())
n = int(input())
p = [(xs,ys,0),(xt,yt,0)]
for i in range(2,n+2):
p.append(tuple(map(int,input().split())))
edge = [[-1]*(n+2)for i in range(n+2)]
for i in range(n+2):
for j in range(i+1,n+2):
edge[i][j] = edge[j][i] = max(((p[i][0]-p[j][0])**2+(p[i][1]-p[j][1])**2)**0.5 - p[i][2] - p[j][2],0.0)
G = csgraph_from_dense(edge,null_value=-1)
print(dijkstra(G,indices=0)[1])
#print(d[1])
|
s846387625 | p03866 | u284854859 | 1559663248 | Python | Python (3.4.3) | py | Runtime Error | 1415 | 51516 | 527 | from scipy.sparse.csgraph import csgraph_from_dense,dijkstra
xs, ys, xt, yt = map(int, input().split())
n = int(input())
p = [(xs,ys,0),(xt,yt,0)]
for i in range(2,n+2):
p.append(tuple(map(int,input().split())))
edge = [[0]*(n+2)for i in range(n+2)]
for i in range(n+2):
for j in range(i+1,n+2):
edge[i][j] = edge[j][i] = max(((p[i][0]-p[j][0])**2+(p[i][1]-p[j][1])**2)**0.5 - p[i][2] - p[j][2],0.0)
edge = csgraph_from_dense(edge,null_value=None)
d = dijkstra(edge,directed=False,indices=0)
print(d[1])
|
s248066137 | p03866 | u627417051 | 1552959980 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3064 | 1462 | from collections import defaultdict
from heapq import heappop, heappush
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def add_edge(self, a, b, w):
self.graph[a].append((b, w))
class Dijkstra(object):
def __init__(self, graph, s):
self.g = graph.graph
self.dist = defaultdict(lambda: float('inf'))
self.dist[s] = 0
self.Q = []
heappush(self.Q, (self.dist[s], s))
while self.Q:
dist_u, u = heappop(self.Q)
if self.dist[u] < dist_u:
continue
for v, w in self.g[u]:
alt = dist_u + w
if self.dist[v] > alt:
self.dist[v] = alt
heappush(self.Q, (alt, v))
def s_d(self, goal):
return self.dist[goal]
xs, ys, xg, yg = list(map(int, input().split()))
xyr = []
xyr.append([xs, ys, 0])
N = int(input())
for i in range(N):
xyr.append(list(map(int, input().split())))
xyr.append([xg, yg, 0])
g_a = Graph()
for i in range(N + 1):
for j in range(i + 1, N + 2):
a, b = i, j
R = ((xyr[i][0] - xyr[j][0]) * (xyr[i][0] - xyr[j][0]) + (xyr[i][1] - xyr[j][1]) * (xyr[i][1] - xyr[j][1]) ** 0.5
if R > xyr[i][2] + xyr[j][2]:
r = R - xyr[i][2] - xyr[j][2]
else:
r = 0
g_a.add_edge(a, b, r)
g_a.add_edge(b, a, r)
d_a = Dijkstra(g_a, 0)
print(d_a.s_d(N + 1)) |
s335521828 | p03866 | u803848678 | 1552351035 | Python | Python (3.4.3) | py | Runtime Error | 1284 | 51612 | 609 | from math import sqrt
from scipy.sparse.csgraph import dijkstra, csgraph_from_dense
def calc_dist(p1,p2):
return max(0, sqrt((p1[0]-p2[0])**2 + (p1[1]-p2[1])**2) - (p1[2]+p2[2]))
xs, ys, xg, yg = map(int, input().split())
n = int(input())
p = [list(map(int, input().split())) for i in range(n)]
p = [[xs,ys,0], [xg,yg,0]] + p
n += 2
edges = [[float("inf")]*n for i in range(n)]
for i in range(n):
for j in range(i,n):
edges[i][j] = edges[j][i] = calc_dist(p[i], p[j])
edges = csgraph_from_dense(edges, null_value=float("inf"))
dist = dijkstra(edges, directed=False, indices=0)
print(dist[1]) |
s940326337 | p03866 | u284854859 | 1550650862 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 1056 | def dijkstra(s):
#始点sから各頂点への最短距離
#n:頂点数, w:辺の数, cost[u][v] : 辺uvのコスト(存在しないときはinf)
d = [float("inf")] * n
used = [False] * n
d[s] = 0
while True:
v = -1
#まだ使われてない頂点の中から最小の距離のものを探す
for i in range(n):
if (not used[i]) and (v == -1):
v = i
elif (not used[i]) and d[i] < d[v]:
v = i
if v == -1:
break
used[v] = True
for j in range(n):
d[j] = min(d[j],d[v]+cost[v][j])
return d
Xs,Ys,Xt,Yt = map(int,input().split())
n = int(input())
p = [([Xs,Ys,0],[Xt,Yt,0]]
for i in range(2,n+2):
p.append(list(map(int,input().split())))
cost = [[0]*(n+2)for i in range(n+2)]
for i in range(n+2):
for j in range(i,n+2):
cost[i][j] = cost[j][i] = max(((p[i][0]-p[j][0])**2+(p[i][1]-p[j][1])**2)**0.5 - p[i][2] - p[j][2],0)
n += 2
res = dijkstra(0)
print(1)
|
s611365865 | p03866 | u284854859 | 1550650596 | Python | Python (3.4.3) | py | Runtime Error | 43 | 11508 | 1070 | def dijkstra(s):
#始点sから各頂点への最短距離
#n:頂点数, w:辺の数, cost[u][v] : 辺uvのコスト(存在しないときはinf)
d = [float("inf")] * n
used = [False] * n
d[s] = 0
while True:
v = -1
#まだ使われてない頂点の中から最小の距離のものを探す
for i in range(n):
if (not used[i]) and (v == -1):
v = i
elif (not used[i]) and d[i] < d[v]:
v = i
if v == -1:
break
used[v] = True
for j in range(n):
d[j] = min(d[j],d[v]+cost[v][j])
return d
Xs,Ys,Xt,Yt = map(int,input().split())
n = int(input())
p = [[Xs,Ys,0],[Xt,Yt,0]]
for i in range(2,n+2):
p.append(map(int,input().split()))
cost = [[0]*(n+2)for i in range(n+2)]
for i in range(n+2):
for j in range(i,n+2):
cost[i][j] = cost[j][i] = max(((p[i][0]-p[j][0])**2+(p[i][1]-p[j][1])**2)**0.5 - p[i][2] - p[j][2],0)
#cost = tuple(cost)
n += 2
res = dijkstra(0)
print(1) |
s881077434 | p03866 | u926678805 | 1550135428 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3064 | 909 | sx,sy,gx,gy=map(int,input().split())
n=int(input())
g = [[] for i in range(n+2)]
data=[(sx,sy,0)]
for i in range(n):
data.append(tuple(map(int,input().split())))
data.append((gx,gy,0))
for i in range(n+2):
for j in range(i+1,n+2):
tmp=(data[i][0]-data[j][0])**2+(data[i][1]-data[j][1])**2)**0.5-data[i][2]-data[j][2]
if tmp<0:
tmp=0
g[i].append((tmp,j))
g[j].append((tmp,i))
def dijkstra(g,st,ed):
from heapq import heappush, heappop, heapify
dist=[2828427127 for i in range(len(g))]
dist[st]=0
que=[]
heappush(que,(0,st))
while que:
c,v=heappop(que)
if dist[v]<c:
continue
for i in range(len(g[v])):
tmp=g[v][i][0]+c
if tmp<dist[g[v][i][1]]:
dist[g[v][i][1]]=tmp
heappush(que,(tmp,g[v][i][1]))
return dist[ed]
print(dijkstra(g,0,n+1)) |
s990352747 | p03866 | u226155577 | 1548400210 | Python | Python (3.4.3) | py | Runtime Error | 2106 | 27508 | 1094 | from heapq import heappush, heappop, heapify
from math import sqrt
readline = open(0).readline
xs, ys, xt, yt = map(int, readline().split())
N = int(readline())
C = [list(map(int, readline().split())) for i in range(N)]
C.append((xt, yt, 0))
que = []
dist = [10**18]*(N+1)
rest = set(range(N+1))
for i in range(N+1):
x, y, r = C[i]
r0 = max(sqrt((xs - x)**2 + (ys - y)**2) - r, 0)
dist[i] = r0
que.append((r0, i))
heapify(que)
remove = rest.remove
T = []
pop = T.pop; push = T.append
while que:
c, i = heappop(que)
if i not in rest:
continue
if i == N:
break
push(i)
while T:
i = pop()
xi, yi, ri = C[i]
remove(i)
d = dist[i]
e = dist[N]-d
for j in rest:
x, y, r = C[j]
r0 = sqrt((xi - x)**2 + (yi - y)**2) - ri - r
if e > r0 < dist[j]-d:
if r0 > 0:
dist[j] = v = d + r0
heappush(que, (v, j))
else:
dist[j] = d
push(j)
print("%.016f" % dist[N]) |
s051705368 | p03866 | u690536347 | 1548391759 | Python | PyPy3 (2.4.0) | py | Runtime Error | 181 | 38768 | 592 | from heapq import heappush,heappop
from math import sqrt
inf=float("inf")
xs,ys,xt,yt=map(int,input().split())
n=int(input())
q=[]
l=[(xs,ys,0),(xt,yt,0)]+[tuple(map(int,input().split())) for _ in range(n)]
sizeV=len(l)
rests={*range(sizeV)}
cost=[inf]*sizeV
cost[0]=0
heappush(q,(0,0))
while q:
c1,i=heappop(q)
if c1>cost[i]:continue
rests.remove(i)
if not rests:break
costnow=c1
xi,yi,ri=l[i]
for j in rests:
xj,yj,rj=l[j]
d=max(0.0,sqrt((xj-xi)**2+(yj-yi)**2)-ri-rj)
c2=costnow+d
if c2<cost[j]:
cost[j]=c2
heappush(q,(c2,j))
print(cost[1]) |
s233223618 | p03866 | u690536347 | 1548391722 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3060 | 592 | from heapq import heappush,heappop
from math import sqrt
inf=float("inf")
xs,ys,xt,yt=map(int,input().split())
n=int(input())
q=[]
l=[(xs,ys,0),(xt,yt,0)]+[tuple(map(int,input().split())) for _ in range(n)]
sizeV=len(l)
rests={*range(sizeV)}
cost=[inf]*sizeV
cost[0]=0
heappush(q,(0,0))
while q:
c1,i=heappop(q)
if c1>cost[i]:continue
rests.remove(i)
if not rests:break
costnow=c1
xi,yi,ri=l[i]
for j in rests:
xj,yj,rj=l[j]
d=max(0.0,sqrt((xj-xi)**2+(yj-yi)**2)-ri-rj)
c2=costnow+d
if c2<cost[j]:
cost[j]=c2
heappush(q,(c2,j))
print(cost[1]) |
s892997076 | p03866 | u690536347 | 1548391230 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3060 | 572 | from heapq import heappush,heappop
from math import sqrt
inf=float("inf")
xs,ys,xt,yt=map(int,input().split())
n=int(input())
q=[]
l=[(xs,ys,0),(xt,yt,0)]+[tuple(map(int,input().split())) for _ in range(n)]
sizeV=len(l)
rests={*range(sizeV)}
cost=[inf]*sizeV
cost[0]=0
heappush(q,(0,0))
while q:
c1,i=heappop(q)
if c1>cost[i]:continue
rests.remove(i)
if not rests:break
xi,yi,ri=l[i]
for j in rests:
xj,yj,rj=l[j]
d=max(0,sqrt((xj-xi)**2+(yj-yi)**2)-ri-rj)
c2=c1+d
if c2<cost[j]:
cost[j]=c2
heappush(q,(c2,j))
print(cost[1]) |
s516289527 | p03866 | u690536347 | 1548391088 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3060 | 550 | from heapq import heappush,heappop
from math import sqrt
inf=float("inf")
xs,ys,xt,yt=map(int,input().split())
n=int(input())
q=[]
l=[(xs,ys,0),(xt,yt,0)]+[tuple(map(int,input().split())) for _ in range(n)]
sizeV=len(l)
rests={*range(sizeV)}
cost=[inf]*sizeV
cost[0]=0
heappush(q,(0,0))
while q:
c1,i=heappop(q)
if c1>cost[i]:continue
rests.remove(i)
xi,yi,ri=l[i]
for j in rests:
xj,yj,rj=l[j]
d=max(0,sqrt((xj-xi)**2+(yj-yi)**2)-ri-rj)
c2=c1+d
if c2<cost[j]:
cost[j]=c2
heappush(q,(c2,j))
print(cost[1]) |
s393741633 | p03866 | u690536347 | 1548390934 | Python | Python (3.4.3) | py | Runtime Error | 20 | 3060 | 550 | from heapq import heappush,heappop
from math import sqrt
inf=float("inf")
xs,ys,xt,yt=map(int,input().split())
n=int(input())
q=[]
l=[(xs,ys,0),(xt,yt,0)]+[tuple(map(int,input().split())) for _ in range(n)]
sizeV=len(l)
rests={*range(sizeV)}
cost=[inf]*sizeV
cost[0]=0
heappush(q,(0,0))
while q:
c1,i=heappop(q)
if c1>cost[i]:continue
rests.remove(i)
xi,yi,ri=l[i]
for j in rests:
xj,yj,rj=l[j]
d=max(0,sqrt((xj-xi)**2+(yj-yi)**2)-ri-rj)
c2=c1+d
if c2<cost[j]:
cost[j]=c2
heappush(q,(c2,j))
print(cost[1]) |
s372836309 | p03866 | u368780724 | 1542650967 | Python | Python (3.4.3) | py | Runtime Error | 746 | 60584 | 947 | def flpl(): return [float(i) for i in input().split()]
def inpl(): return [int(i) for i in input().split()]
import numpy as np
import heapq
xs, ys, xt, yt = flpl()
N = int(input())
xyr = [(xs, ys, 0),(xt, yt, 0)] + [inpl() for _ in range(N)]
X, Y, R = np.array(xyr).T
X, Y, R = np.tile(X, (N+2, 1)), np.tile(Y, (N+2, 1)), np.tile(R, (N+2, 1))
edge = np.maximum(np.zeros((N+2, N+2)), np.sqrt(np.square(X-X.T) +\
np.square(Y-Y.T))-(R+R.T)) +\
np.diag(np.ones(N+2)*np.inf)
dist = np.array([np.inf for _ in range(N+2)])
dist[0] = 0
remain = set(range(N+2))
Q = []
heapq.heappush(Q,(0,0))
while Q:
c, vn = heapq.heappop(Q)
if vn not in remain or c > dist[c]:
continue
remain.remove(vn)
for j in remain:
if dist[vn] + edge[vn][j] < dist[j]:
dist[j] = dist[vn] + edge[vn][j]
heapq.heappush(Q,(dist[j],j))
if 1 not in remain:
break
print(dist[1]) |
s600026922 | p03866 | u777923818 | 1523119743 | Python | Python (3.4.3) | py | Runtime Error | 359 | 41348 | 648 | # -*- coding: utf-8 -*-
import numpy as np
from scipy.sparse.csgraph import csgraph_from_dense, dijkstra
def inpl(): return map(int, input().split())
sx, sy, tx, ty = inpl()
N = int(input())
X = np.zeros((1, N+2), dtype=np.float64)
Y = np.zeros((1, N+2), dtype=np.float64)
R = np.zeros((1, N+2), dtype=np.float64)
X[0][0] = sx
Y[0][0] = sy
X[0][N+1] = tx
Y[0][N+1] = ty
for i in range(N):
X[0][i+1], Y[0][i+1], R[0][i+1] = inpl()
G = np.maximum(np.sqrt(np.square(X-X.T) + np.square(Y-Y.T)) - (R+R.T),
np.zeros((N+2, N+2), dtype=np.float64))
Gsp = csgraph_from_dense(G, null_value=np.inf)
print(dijkstra(Gsp, indices=0)[-1])
|
s867766005 | p03866 | u820351940 | 1496116814 | Python | Python (3.4.3) | py | Runtime Error | 2105 | 24500 | 1190 | def dist(x1, y1, x2, y2):
return pow((x1 - x2)**2 + (y1 - y2)**2, 0.5)
def dist_high(i, now):
if i == -1 and now == -1:
return dist(stx, sty, enx, eny)
if now == -1:
result = dist(stx, sty, xyr[i][0], xyr[i][1])
result -= xyr[i][2]
elif i == -1:
result = dist(xyr[now][0], xyr[now][1], enx, eny)
result -= xyr[now][2]
else:
result = dist(xyr[now][0], xyr[now][1], xyr[i][0], xyr[i][1])
result -= xyr[i][2] + xyr[now][2]
return result if result > 0 else 0
debugs = []
def debug(**args):
debugs.append(args)
return args["ret"]
def d():
for i in debugs:
print(i)
stx, sty, enx, eny = map(int, input().split())
n = int(input())
xyr = [list(map(int, input().split())) for x in range(n)]
xyr = list(sorted(xyr, key=lambda x: dist(stx, sty, x[0], x[1])))
dp = [[False for y in range(1001)] for x in range(1001)]
def calc(i, now):
if dp[i][now] != False:
return dp[i][now]
if i >= n:
return dist_high(-1, now)
dp[i][now] = min(
calc(i + 1, i) + dist_high(i, now),
calc(i + 1, now)
)
return dp[i][now]
print(calc(0, -1))
|
s387448089 | p03866 | u509661905 | 1482104161 | Python | PyPy3 (2.4.0) | py | Runtime Error | 404 | 74844 | 1531 | #!/usr/bin/env pypy3
import math
import itertools
INVALID = -1
INF = 10 ** 12
def dijkstra_dense(num_vs, adj_matrix, source, dest):
dist = [INF for _ in range(num_vs)]
visited = [False for _ in range(num_vs)]
dist[source] = 0
while True:
u = min((j for j in range(num_vs) if not visited[j]),
key=lambda i: dist[i], default=INVALID)
if u == INVALID or dist[u] == INF:
break
visited[u] = True
for v in range(num_vs):
w = adj_matrix[u][v]
if u != v and w < INF:
new_len = dist[u] + w
if new_len < dist[v]:
dist[v] = new_len
return dist[dest]
def main():
# 始点を頂点0、終点を頂点N + 1とする
x0, y0, xf, yf = (int(x) for x in input().split())
n = int(input())
xs = [None for _ in range(n + 2)]
ys = [None for _ in range(n + 2)]
rs = [None for _ in range(n + 2)]
xs[0], ys[0], rs[0] = x0, y0, 0
xs[n + 1], ys[n + 1], rs[n + 1] = xf, yf, 0
for i in range(1, n + 1):
xs[i], ys[i], rs[i] = (int(z) for z in input().split())
adj_matrix = [[INF for _ in range(n + 2)] for _ in range(n + 2)]
for i, j in itertools.product(range(n + 2), repeat=2):
adj_matrix[i][j] = max(0, math.hypot(xs[i] - xs[j],
ys[i] - ys[j]) - (rs[i] + rs[j]))
res = dijkstra_dense(n + 2, adj_matrix, 0, n + 1)
print("{:.12f}".format(res))
if __name__ == '__main__':
main()
|
s821405834 | p03866 | u854685751 | 1481059215 | Python | PyPy2 (5.6.0) | py | Runtime Error | 49 | 9328 | 1773 | xs,ys,xt,yt=list(map(int,input().split()))
N=int(input())
a=[]
for i in range(N):
a.append(list(map(int,input().split())))
# xs,ys,xt,yt=[-1000000000, -1000000000, 1000000000, 1000000000]
# N=1
# a=[[-1000000000, 1000000000, 1]]
class Dijkstra(object):
"""
ダイクストラ法,(N^2)
ステータス:distance(list),prev(list),size(int)
distancemap[i][j]->Distance of edge i to j
"""
def __init__(self, distancemap, start):
self.start=start
self.size=len(distancemap)
self.distance=[float("inf") for x in range(self.size)]
self.distance[start]=0
self.prev=[0 for x in range(self.size)]
self.prev[start]=-1
yet=list(range(self.size))
yet.remove(start)
now=start
while(yet!=[]):
nearest_num=0
nearest_dis=float("inf")
for i in yet:
total_dis=distancemap[now][i]+self.distance[now]
self.distance[i]=min(total_dis, self.distance[i])
if self.distance[i]<=nearest_dis:
nearest_dis=self.distance[i]
nearest_num=i
yet.remove(nearest_num)
self.prev[nearest_num]=now
now=nearest_num
def route(self,goal):
route=[]
while(True):
route.append(self.prev[goal])
goal=self.prev[goal]
if goal==self.start:
break
route.reverse()
return(route)
import math
def solve(xs,ys,xt,yt,N,a):
a.insert(0,[xs,ys,0])
a.append([xt,yt,0])
def distance(i,j):
x1=a[i][0]
y1=a[i][1]
r1=a[i][2]
x2=a[j][0]
y2=a[j][1]
r2=a[j][2]
d=math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2))-r1-r2
if d<0:
d=0
return(d)
distancemap=[[0 for x in range(N+2)] for x in range(N+2)]
for i in range(N+2):
for j in range(N+2):
if i>j:
distancemap[i][j]=distancemap[j][i]
else:
distancemap[i][j]=distance(i,j)
d=Dijkstra(distancemap, 0)
return(d.distance.pop())
print(solve(xs, ys, xt, yt, N, a))
|
s568048775 | p03866 | u854685751 | 1480917517 | Python | PyPy3 (2.4.0) | py | Runtime Error | 230 | 39920 | 1488 | xs,ys,xt,yt=list(map(int,input().split()))
N=int(input())
a=[]
for i in N:
a.append(list(map(int,input().split())))
# xs,ys,xt,yt=[4,-2,-2,4]
# N=3
# a=[[0,0,2],[4,0,1],[0,4,1]]
class Dijkstra(object):
"""
ダイクストラ法,(N^2)
ステータス:distance(list),route(list),prev(list),size(int)
"""
def __init__(self, distancemap, start):
self.size=len(distancemap)
self.distance=[0 for x in range(self.size)]
self.route=[start]
self.prev=[0 for x in range(self.size)]
self.prev[start]=-1
yet=list(range(self.size))
yet.remove(start)
now=start
while(yet!=[]):
nearest_num=0
nearest_dis=float("inf")
for i in yet:
total_dis=distancemap[now][i]+self.distance[now]
if total_dis<nearest_dis:
nearest_dis=total_dis
nearest_num=i
yet.remove(nearest_num)
self.distance[nearest_num]=nearest_dis
self.route.append(nearest_num)
self.prev[nearest_num]=now
now=nearest_num
import math
def solve(xs,ys,xt,yt,N,a):
a.insert(0,[xs,ys,0])
a.append([xt,yt,0])
def distance(i,j):
x1=a[i][0]
y1=a[i][1]
r1=a[i][2]
x2=a[j][0]
y2=a[j][1]
r2=a[j][2]
d=math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2))-r1-r2
if d<0:
d=0
return(d)
distancemap=[[0 for x in range(N+2)] for x in range(N+2)]
for i in range(N+2):
for j in range(N+2):
if i>j:
distancemap[i][j]=distancemap[j][i]
else:
distancemap[i][j]=distance(i,j)
d=Dijkstra(distancemap,0)
return(d.distance.pop())
print(solve(xs, ys, xt, yt, N, a))
|
s921024453 | p03866 | u226155577 | 1480908205 | Python | PyPy2 (5.6.0) | py | Runtime Error | 1090 | 106908 | 1512 | from heapq import heappush, heappop
from math import sqrt
EPS = 1e-10
xs, ys, xt, yt = map(int, raw_input().split())
n = input()
ps = [map(int, raw_input().split()) for i in xrange(n)]
def calc(x0, y0, r0, x1, y1, r1):
v = (x0 - x1)**2 + (y0 - y1)**2
if v <= (r0+r1)**2 + EPS:
return 0.
return sqrt(v) - r0 - r1
parent = range(n)
def root(x):
if parent[x] != x:
x = parent[x] = root(parent[x])
return x
def unite(x, y):
px = root(x)
py = root(y)
if px < py:
parent[py] = px
else:
parent[px] = py
for i in xrange(n):
x0, y0, r0 = ps[i]
for j in xrange(i+1, n):
if i == j: continue
x1, y1, r1 = ps[j]
if calc(x0, y0, r0, x1, y1, r1) < EPS:
unite(i, j)
que = []
dist = [10**18+7]*n
for i in xrange(n):
x, y, r = ps[i]
d = dist[i] = calc(xs, ys, 0, x, y, r)
heappush(que, (d, i))
while que:
d, v = heappop(que)
if dist[v] < d:
continue
x0, y0, r0 = ps[v]
for t in xrange(n):
if v == t: continue
if root(v) == root(t) and d < dist[t]:
dist[t] = d
heappush(que, (d, t))
else:
x1, y1, r1 = ps[t]
nd = calc(x0, y0, r0, x1, y1, r1)
if d+nd < dist[t]:
dist[t] = d+nd
heappush(que, (d+nd, t))
ans = 10**18+7
for i in xrange(n):
if cant[i]: continue
x, y, r = ps[i]
d = calc(xt, yt, 0, x, y, r) + dist[i]
ans = min(ans, d)
print "%.010f" % ans
|
s309951077 | p03867 | u680707192 | 1596945476 | Python | PyPy3 (7.3.0) | py | Runtime Error | 120 | 74028 | 2453 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p_ll;
template<class T>
void debug(T itr1, T itr2) { auto now = itr1; while(now<itr2) { cout << *now << " "; now++; } cout << endl; }
#define repr(i,from,to) for (ll i=(ll)from; i<(ll)to; i++)
#define all(vec) vec.begin(), vec.end()
#define rep(i,N) repr(i,0,N)
#define per(i,N) for (int i=(int)N-1; i>=0; i--)
const ll MOD = pow(10,9)+7;
const ll LLINF = pow(2,61)-1;
const int INF = pow(2,30)-1;
vector<ll> fac;
void c_fac(int x=pow(10,6)+10) { fac.resize(x,true); rep(i,x) fac[i] = i ? (fac[i-1]*i)%MOD : 1; }
ll inv(ll a, ll m=MOD) { ll b = m, x = 1, y = 0; while (b!=0) { int d = a/b; a -= b*d; swap(a,b); x -= y*d; swap(x,y); } return (x+m)%m; }
ll nck(ll n, ll k) { return fac[n]*inv(fac[k]*fac[n-k]%MOD)%MOD; }
ll gcd(ll a, ll b) { if (a<b) swap(a,b); return b==0 ? a : gcd(b, a%b); }
ll lcm(ll a, ll b) { return a/gcd(a,b)*b; }
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
vector<bool> isp;
void sieve(int x=pow(10,6)+10) {
isp.resize(x,true);
isp[0] = false;
isp[1] = false;
for (int i=2; pow(i,2)<=x; i++) {
if (isp[i]) for(int j=2; i*j<=x; j++) isp[i*j] = false;
}
}
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
ll pnk(ll n, ll k) {
ll pn = n, now = 0, result = 1;
while (k>=1ll<<now) {
if (k&1ll<<now) result = result * pn % MOD;
pn = pn * pn % MOD;
now++;
}
return result;
}
int main() {
ll N, K; cin >> N >> K;
// map<string, ll> m;
// rep(i,1<<N/2) {
// string S; rep(j,N/2) S += i&1<<j ? '1' : '0';
// rep(j,N/2) S += S[N/2-1-j];
// rep(j,N) {
// m[S]++;
// S = S.substr(1) + S[0];
// }
// }
// cout << m.size() << endl;
sieve();
vector<ll> yaku;
for (ll i=1; i*i<=N; i++) {
if (N%i==0) {
yaku.push_back(i);
if (i*i!=N) yaku.push_back(N/i);
}
}
sort(all(yaku));
// debug(all(yaku));
ll l = yaku.size();
vector<ll> count(l,0);
rep(i,l) {
count[i] = pnk(K,(yaku[i]+1)/2);
rep(j,i) if (yaku[i]%yaku[j]==0) count[i] = (count[i]-count[j]+MOD) % MOD;
}
// debug(all(count));
ll result = 0; rep(i,l) result = (result+(yaku[i]%2 ? yaku[i] : yaku[i]/2)*count[i]) % MOD;
cout << result << endl;
return 0;
} |
s008102275 | p03867 | u875291233 | 1593212139 | Python | PyPy3 (7.3.0) | py | Runtime Error | 116 | 74452 | 1036 | # coding: utf-8
# Your code here!
import sys
read = sys.stdin.read
readline = sys.stdin.readline
n,k = map(int,readline().split())
MOD = 10**9+7
if n&1:
ans = k + (pow(k,(n+1)//2,MOD)-k)*n
print(ans%MOD)
else:
assert 0
def divisor_list(N): #約数のリスト
if N == 1: return [1]
res = []
for i in range(1,N):
if i*i >= N: break
if N%i == 0:
res.append(i)
res.append(N//i)
if i*i == N: res.append(i)
return sorted(res)
p = [1] + [i for i in divisor_list(n) if i%2==0 and i!=2]
r = {pi:pow(k,(pi+1)//2,MOD) for pi in p}
for pi in p:
for pj in p:
if pj >= pi: break
if pi%pj==0:
r[pi] -= r[pj]
#print(r)
ans = 0
for pi,v in r.items():
if pi==1:
ans += v
else:
ans += v*(pi//2)
ans %= MOD
print(ans)
|
s540651161 | p03867 | u353919145 | 1553541372 | Python | Python (2.7.6) | py | Runtime Error | 10 | 2568 | 621 | @parallel
@roles('allgame')
def _last_redis_save():
with cd(get_deploy_path()):
redisSet = set()
ret = run('supervisorctl status')
for line in ret.split('\n'):
line = line.strip()
if line.find('RUNNING') >= 0 and line.find('redis') >= 0:
name = line.split()[0].strip()
redisSet.add(name)
ret = []
with cd('db'):
for redis in sorted(list(redisSet)):
port = redis[5:]
ret.append(run('ls -l -h game%s.rdb' % port))
return '\n'.join(ret)
def last_redis_save():
result = execute(_last_redis_save)
for k in sorted(result.keys()):
print '-'*20
print k, ':'
v = result[k]
print v |
s528081524 | p03867 | u280667879 | 1480992295 | Python | PyPy2 (5.6.0) | py | Runtime Error | 42 | 8944 | 294 | M=10**9+7;D=[];i=1;r=0;N,K=map(int,input().split())
while i*i<=N:
if N%i==0:D.append(i);i*i<N and D.append(N//i)
i+=1
D.sort();N=[]
for i in range(len(D)):
N.append(pow(K,-~D[i]//2,M))
for j in range(i):
if D[i]%D[j]==0:N[i]=(N[i]-N[j])%M
r=(r+(N[i]*D[i]*pow(2,M-2+D[i]%2,M)))%M
print(r) |
s882361741 | p03869 | u584174687 | 1568496288 | Python | Python (3.4.3) | py | Runtime Error | 320 | 105924 | 1081 | from collections import Counter, defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 10)
# input = sys.stdin.readline
from math import factorial
import heapq, bisect
import math
import itertools
import queue
from collections import deque
def check(max_length, left, right, r, index):
if index == 100:
print(left)
half = (left + right) / 2
if 2 * half <= max_length * (r - half) / r:
check(max_length, half, right, r, index + 1)
else:
check(max_length, left, half, r, index + 1)
def main():
data = [list(map(int, input().split())) for i in range(3)]
a = ((data[0][0] - data[1][0]) ** 2 + (data[0][1] - data[1][1]) ** 2) ** 0.5
b = ((data[1][0] - data[2][0]) ** 2 + (data[1][1] - data[2][1]) ** 2) ** 0.5
c = ((data[0][0] - data[2][0]) ** 2 + (data[0][1] - data[2][1]) ** 2) ** 0.5
s = (a + b + c) / 2
S = (s * (s - a) * (s - b) * (s - c)) ** 0.5
r = 2 * S / (a + b + c)
left, right = 0, max(a, b, c)
check(max(a, b, c), left, right, r, 0)
if __name__ == '__main__':
main()
# test()
|
s135101637 | p03869 | u584174687 | 1568496174 | Python | Python (3.4.3) | py | Runtime Error | 304 | 105924 | 1082 | from collections import Counter, defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 10)
# input = sys.stdin.readline
from math import factorial
import heapq, bisect
import math
import itertools
import queue
from collections import deque
def check(max_length, left, right, r, index):
if index == 1000:
print(left)
half = (left + right) / 2
if 2 * half <= max_length * (r - half) / r:
check(max_length, half, right, r, index + 1)
else:
check(max_length, left, half, r, index + 1)
def main():
data = [list(map(int, input().split())) for i in range(3)]
a = ((data[0][0] - data[1][0]) ** 2 + (data[0][1] - data[1][1]) ** 2) ** 0.5
b = ((data[1][0] - data[2][0]) ** 2 + (data[1][1] - data[2][1]) ** 2) ** 0.5
c = ((data[0][0] - data[2][0]) ** 2 + (data[0][1] - data[2][1]) ** 2) ** 0.5
s = (a + b + c) / 2
S = (s * (s - a) * (s - b) * (s - c)) ** 0.5
r = 2 * S / (a + b + c)
left, right = 0, max(a, b, c)
check(max(a, b, c), left, right, r, 0)
if __name__ == '__main__':
main()
# test()
|
s444273681 | p03877 | u687214625 | 1582165500 | Python | Python (3.4.3) | py | Runtime Error | 19 | 2940 | 4381 | #include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
template<typename T,T MOD = 1000000007>
struct Mint{
T v;
Mint():v(0){}
Mint(signed v):v(v){}
Mint(long long t){v=t%MOD;if(v<0) v+=MOD;}
Mint pow(long long k){
Mint res(1),tmp(v);
while(k){
if(k&1) res*=tmp;
tmp*=tmp;
k>>=1;
}
return res;
}
static Mint add_identity(){return Mint(0);}
static Mint mul_identity(){return Mint(1);}
Mint inv(){return pow(MOD-2);}
Mint& operator+=(Mint a){v+=a.v;if(v>=MOD)v-=MOD;return *this;}
Mint& operator-=(Mint a){v+=MOD-a.v;if(v>=MOD)v-=MOD;return *this;}
Mint& operator*=(Mint a){v=1LL*v*a.v%MOD;return *this;}
Mint& operator/=(Mint a){return (*this)*=a.inv();}
Mint operator+(Mint a) const{return Mint(v)+=a;};
Mint operator-(Mint a) const{return Mint(v)-=a;};
Mint operator*(Mint a) const{return Mint(v)*=a;};
Mint operator/(Mint a) const{return Mint(v)/=a;};
Mint operator-() const{return v?Mint(MOD-v):Mint(v);}
bool operator==(const Mint a)const{return v==a.v;}
bool operator!=(const Mint a)const{return v!=a.v;}
bool operator <(const Mint a)const{return v <a.v;}
static Mint comb(long long n,int k){
Mint num(1),dom(1);
for(int i=0;i<k;i++){
num*=Mint(n-i);
dom*=Mint(i+1);
}
return num/dom;
}
};
template<typename M>
struct Enumeration{
static vector<M> fact,finv,invs;
static void init(int n){
int m=fact.size();
if(n<m) return;
fact.resize(n+1,1);
finv.resize(n+1,1);
invs.resize(n+1,1);
if(m==0) m=1;
for(int i=m;i<=n;i++) fact[i]=fact[i-1]*M(i);
finv[n]=M(1)/fact[n];
for(int i=n;i>=m;i--) finv[i-1]=finv[i]*M(i);
for(int i=m;i<=n;i++) invs[i]=finv[i]*fact[i-1];
}
static M C(int n,int k){
if(n<k||k<0) return M(0);
init(n);
return fact[n]*finv[n-k]*finv[k];
}
static M P(int n,int k){
if(n<k||k<0) return M(0);
init(n);
return fact[n]*finv[n-k];
}
static M H(int n,int k){
if(n<0||k<0) return M(0);
if(!n&&!k) return M(1);
init(n+k-1);
return C(n+k-1,k);
}
static M S(int n,int k){
M res;
init(k);
for(int i=1;i<=k;i++){
M tmp=C(k,i)*M(i).pow(n);
if((k-i)&1) res-=tmp;
else res+=tmp;
}
return res*=finv[k];
}
static vector<vector<M> > D(int n,int m){
vector<vector<M> > dp(n+1,vector<M>(m+1,0));
dp[0][0]=M(1);
for(int i=0;i<=n;i++){
for(int j=1;j<=m;j++){
if(i-j>=0) dp[i][j]=dp[i][j-1]+dp[i-j][j];
else dp[i][j]=dp[i][j-1];
}
}
return dp;
}
static M B(int n,int k){
if(n==0) return M(1);
k=min(k,n);
init(k);
vector<M> dp(k+1);
dp[0]=M(1);
for(int i=1;i<=k;i++)
dp[i]=dp[i-1]+((i&1)?-finv[i]:finv[i]);
M res;
for(int i=1;i<=k;i++)
res+=M(i).pow(n)*finv[i]*dp[k-i];
return res;
}
static M montmort(int n){
M res;
init(n);
for(int k=2;k<=n;k++){
if(k&1) res-=finv[k];
else res+=finv[k];
}
return res*=fact[n];
}
static M LagrangePolynomial(vector<M> &y,M t){
int n=y.size()-1;
if(t.v<=n) return y[t.v];
init(n+1);
M num(1);
for(int i=0;i<=n;i++) num*=t-M(i);
M res;
for(int i=0;i<=n;i++){
M tmp=y[i]*num/(t-M(i))*finv[i]*finv[n-i];
if((n-i)&1) res-=tmp;
else res+=tmp;
}
return res;
}
};
template<typename M>
vector<M> Enumeration<M>::fact = vector<M>();
template<typename M>
vector<M> Enumeration<M>::finv = vector<M>();
template<typename M>
vector<M> Enumeration<M>::invs = vector<M>();
//INSERT ABOVE HERE
signed main(){
int n,a,b,c;
cin>>n>>a>>b>>c;
using M = Mint<int>;
using E = Enumeration<M>;
E::init(1e5);
M ans{0};
for(int x=0;x<=c;x++){
for(int y=0;y*3<=c;y++){
int w=a-x;
int z=b/2;
int k=c-(x+y*3);
if(w<0||z<0||k<0) continue;
if(w+x==a&&z*2==b&&x+y*3+k==c){
M res=E::H(z,k);
int sum=w+x+y+z;
res*=E::fact[sum];
res*=E::finv[w];
res*=E::finv[x];
res*=E::finv[y];
res*=E::finv[z];
ans+=res;
}
}
}
cout<<ans.v<<endl;
return 0;
}
|
s453603044 | p03878 | u163320134 | 1566859220 | Python | Python (3.4.3) | py | Runtime Error | 522 | 28632 | 318 | n=int(input())
arr=[(int(input()),i//n) for i in range(2*n)]
arr=sorted(arr,key=lambda x:x[0])
mod=10**9+7
ans=1
cnta=0
cntb=0
for pos,flag in arr:
if flag==0:
if cntb==0:
cnta+=1
else:
cntb-=1
else:
if cnta>=1:
ans*=cnt
ans%=mod
cnta-=1
else:
cntb+=1
print(ans) |
s165008329 | p03878 | u163320134 | 1566859180 | Python | Python (3.4.3) | py | Runtime Error | 524 | 28628 | 317 | n=int(input())
arr=[(int(input()),i//n) for i in range(2*n)]
arr=sorted(arr,key=lambda x:x[0])
mod=10**9+7
ans=1
cnta=0
cntb=0
for pos,flag in arr:
if flag==0:
if cntb==0:
cnta+=1
else:
cntb-=1
else:
if cnta>=1:
ans*=cnt
ans%=mod
cnt-=1
else:
cntb+=1
print(ans) |
s565417243 | p03878 | u163320134 | 1566859137 | Python | Python (3.4.3) | py | Runtime Error | 360 | 12600 | 317 | n=int(input())
arr=[(int(input())+i//n) for i in range(2*n)]
arr=sorted(arr,key=lambda x:x[0])
mod=10**9+7
ans=1
cnta=0
cntb=0
for pos,flag in arr:
if flag==0:
if cntb==0:
cnta+=1
else:
cntb-=1
else:
if cnta>=1:
ans*=cnt
ans%=mod
cnt-=1
else:
cntb+=1
print(ans) |
s802290610 | p03878 | u548768105 | 1566719866 | Python | Python (3.4.3) | py | Runtime Error | 17 | 2940 | 1564 | #include "bits/stdc++.h"
typedef long long ll;
#define int ll
#define fi first
#define se second
#define SORT(a) sort(a.begin(),a.end())
#define rep(i,n) for(int i = 0;i < (n) ; i++)
#define REP(i,n) for(int i = 0;i < (n) ; i++)
#define MP(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define INF LLONG_MAX/2
#define all(x) (x).begin(),(x).end()
#define debug(x) cerr<<#x<<": "<<x<<endl
#define debug_vec(v) cerr<<#v<<":";rep(i,v.size())cerr<<" "<<v[i];cerr<<endl
using namespace std;
// int MOD = 998244353;
int MOD = 1000000007;
signed main(){
ll n;
cin >> n;
vector<pair<ll,char>> p;
rep(i,n){
int a;
cin >> a;
p.pb(MP(a,'a'));
}
rep(i,n){
int a;
cin >> a;
p.pb(MP(a,'b'));
}
SORT(p);
// rep(i,2*n)cerr << p[i].fi << " " << p[i].se << endl;
int a=0,b=0;
ll ans = 1;
rep(i,2*n){
if(p[i].se == 'a'){
if(b == 0)a++;
else{
ans *= b;
ans %= MOD;
b--;
}
}else{
if(a == 0)b++;
else{
ans *= a;
ans %= MOD;
a--;
}
}
}
cout << ans << endl;
return 0;
}
// g++ -std=c++14 code1.cpp
// rm -r -f test;oj dl https://cf16-exhibition-final-open.contest.atcoder.jp/tasks/cf16_exhibition_final_a
// rm -r -f test;oj dl https://cf17-final-open.contest.atcoder.jp/tasks/cf17_final_a
// rm -r -f test;oj dl http://abc125.contest.atcoder.jp/tasks/abc125_a
|
s546671229 | p03878 | u619819312 | 1566172292 | Python | PyPy3 (2.4.0) | py | Runtime Error | 189 | 38384 | 201 | p=1
s=[0]*2
n=int(input())
q=sorted([[int(input()),i//n]for i in range(2*n)])
for i in q:
if s[1-i[1]]==0:
s[i[1]]+=1
else:
p*=s[1-i[1]]
s[1-[i[1]]-=1
print(p%(10**9+7)) |
s817887864 | p03878 | u054106284 | 1548997079 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3064 | 322 | N = int(input())
L = []
for i in range(N):
L.append((int(input),'a'))
for i in range(N):
L.append((int(input),'b'))
L.sort()
res = 1
cc = 0
nowcol = None
mo = 1000000007
for i in range(2*N):
if cc == 0:
nowcol=L[i][1]
if nowcol == L[i][1]:
cc += 1
else:
res *= cc
res %= mo
cc -= 1
print(res) |
s806854824 | p03878 | u064408584 | 1548124292 | Python | Python (3.4.3) | py | Runtime Error | 741 | 31344 | 274 | import math
n=int(input())
a=[[int(input()),1] for i in range(n)]+[[int(input()),-1] for i in range(n)]
a.sort()
c=0
b=a[0][1]
d=[]
for i,j in a:
if j!=b and c*j<0:d.append(abs(c))
c+=j
b=j
print(d,c,r)
ans=1
for i in d:
ans*=math.factorial(i)
print(ans) |
s846073807 | p03878 | u619631862 | 1547394764 | Python | PyPy3 (2.4.0) | py | Runtime Error | 1534 | 86360 | 479 | def i1():
return int(input())
def i2():
return [int(i) for i in input().split()]
n=i1()
x=[]
for i in range(n):
x.append([i1(),0])
for i in range(n):
x.append([i1(),1])
x.sort()
d=x[0][1]
c=0
dd=[]
cc=0
for i in range(2*n):
if x[i][1]==d:
c+=1
cc=0
else:
if cc==0:
dd.append(c)
cc=1
c-=1
f=[i for i in range(max(dd)+1)]
f[0]=1
for i in range(max(dd)):
f[i+1]*=f[i]
f[i+1]%=10**9+7
ddd=1
for i in dd:
ddd*=f[i]
ddd%=10**9+7
print(ddd) |
s356217336 | p03878 | u760968784 | 1487223692 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3060 | 425 | from sys import stdin, stdout, stderr, setrecursionlimit
from io import StringIO
def read():
return stdin.readline().rstrip()
def reada(sep=None, maxsplit=-1):
return read().split(sep, maxsplit)
def readint():
return int(read())
def readia(sep=None, maxsplit=-1):
return [int(a) for a in reada(sep, maxsplit)]
r = readia()
b = readia()
diff = sum(abs(r[i]-b[i]) for i in range(6))
print(diff/400 + 0.5)
|
s639373510 | p03879 | u467736898 | 1539404012 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 776 | def norm(x1, y1, x2, y2):
return ((x1-x2)**2 + (y1-y2)**2)**0.5
def d(a, b, c, x, y):
return abs(a*x + b*y + c) / (a**2 + b**2)**0.5
def points2line(x1, y1, x2, y2):
la = y1 - y2
lb = x2 - x1
lc = x1 * (y2 - y1) + y1 * (x1 - x2)
return la, lb, lc
#from numpy import argmax
def argmax(L):
return max(enumerate(L), key=lambda x: x[1])[0]
x1, y1 = map(int, input().split())
x2, y2 = map(int, input().split())
x3, y3 = map(int, input().split())
a = norm(x3, y3, x2, y2)
b = norm(x1, y1, x3, y3)
c = norm(x1, y1, x2, y2)
xc = (a*x1 + b*x2 + c*x3)/(a+b+c)
yc = (a*y1 + b*y2 + c*y3)/(a+b+c)
iw = argmax([a, b, c])
w = [a, b, c][int(iw)]
L = [[x1, y1], [x2, y2], [x3, y3]]
del L[int(iw)]
h = d(*points2line(*L[0], *L[1]), xc, yc)
print(w*h/(2*h + w))
|
s932687292 | p03879 | u467736898 | 1539403729 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 708 | def norm(x1, y1, x2, y2):
return ((x1-x2)**2 + (y1-y2)**2)**0.5
def d(a, b, c, x, y):
return abs(a*x + b*y + c) / (a**2 + b**2)**0.5
def points2line(x1, y1, x2, y2):
la = y1 - y2
lb = x2 - x1
lc = x1 * (y2 - y1) + y1 * (x1 - x2)
return la, lb, lc
from numpy import argmax
x1, y1 = map(int, input().split())
x2, y2 = map(int, input().split())
x3, y3 = map(int, input().split())
a = norm(x3, y3, x2, y2)
b = norm(x1, y1, x3, y3)
c = norm(x1, y1, x2, y2)
xc = (a*x1 + b*x2 + c*x3)/(a+b+c)
yc = (a*y1 + b*y2 + c*y3)/(a+b+c)
iw = argmax([a, b, c])
w = [a, b, c][int(iw)]
L = [[x1, y1], [x2, y2], [x3, y3]]
del L[int(iw)]
h = d(*points2line(*L[0], *L[1]), xc, yc)
print(w*h/(2*h + w))
|
s163407397 | p03879 | u467736898 | 1539403648 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 698 | def norm(x1, y1, x2, y2):
return ((x1-x2)**2 + (y1-y2)**2)**0.5
def d(a, b, c, x, y):
return abs(a*x + b*y + c) / (a**2 + b**2)**0.5
def points2line(x1, y1, x2, y2):
la = y1 - y2
lb = x2 - x1
lc = x1 * (y2 - y1) + y1 * (x1 - x2)
return la, lb, lc
from numpy import argmax
x1, y1 = map(int, input().split())
x2, y2 = map(int, input().split())
x3, y3 = map(int, input().split())
a = norm(x3, y3, x2, y2)
b = norm(x1, y1, x3, y3)
c = norm(x1, y1, x2, y2)
xc = (a*x1 + b*x2 + c*x3)/(a+b+c)
yc = (a*y1 + b*y2 + c*y3)/(a+b+c)
iw = argmax([a, b, c])
w = [a, b, c][iw]
L = [[x1, y1], [x2, y2], [x3, y3]]
del L[iw]
h = d(*points2line(*L[0], *L[1]), xc, yc)
print(w*h/(2*h + w))
|
s576518461 | p03879 | u536113865 | 1539003178 | Python | Python (3.4.3) | py | Runtime Error | 149 | 12504 | 396 | import numpy as np
import math
def calc(A,B,C):
a = np.linalg.norm(B - C)
b = np.linalg.norm(C - A)
c = np.linalg.norm(A - B)
cosC = np.inner(A-C, B-C)/(b*a)
if cosC <= 0:
return 0
tanC = math.sqrt(1/(cosC**2)-1)
return (1 - 1/cosC + tanC) * (a+b-c)/4
a = np.array(ai())
b = np.array(ai())
c = np.array(ai())
print(max(calc(a,b,c),calc(b,c,a),calc(c,a,b))) |
s221326649 | p03879 | u020381098 | 1531003502 | Python | Python (2.7.6) | py | Runtime Error | 10 | 2568 | 183 | from sys import stdin
n = int(stdin.readline())
a = map(int,stdin.readline().split(' '))
xs = 0
oc = 0
for x in a:
xs ^= x >> 1
oc ^= x & 1
if xs:
print -1
else:
print oc |
s735481396 | p03880 | u754022296 | 1583189301 | Python | Python (3.4.3) | py | Runtime Error | 217 | 24688 | 514 | import sys
input = sys.stdin.readline
read = sys.stdin.read
import numpy as np
n = int(input())
A = np.array(read().split(), dtype=np.int64)
m = 30
C = np.zeros(m, dtype=bool)
used = np.zeros(m, dtype=bool)
x = 0
for a in A:
x ^= a
for i in range(m):
idx = np.where(A>>i & 1)
if np.any(~used[idx]):
C[i] = True
used[idx] = True
total = 0
ans = 0
for i in range(m-1, -1, -1):
if (x>>i & 1) ^ total:
if C[i]:
ans += 1
total ^= 1
else:
print(-1)
break
else:
print(ans) |
s646194231 | p03880 | u532966492 | 1576893528 | Python | Python (3.4.3) | py | Runtime Error | 194 | 7840 | 664 | def main():
n = int(input())
a = [int(input()) for _ in [0]*n]
m = max(a)
xor = 0
for i in a:
xor ^= i
i = 1
cnt = 0
while True:
if xor >= i:
i *= 2
cnt += 1
else:
break
ans = 0
for i in range(cnt-1, -1, -1):
j = (xor & 2**i) // (2**i)
if j == 1:
for k in a:
if k % (2**i) == 0:
xor ^= k
xor ^= k-1
ans += 1
a.remove(k)
break
else:
print(-1/0)
return 0
print(ans)
main() |
s972134573 | p03880 | u879309973 | 1570090412 | Python | Python (3.4.3) | py | Runtime Error | 209 | 11064 | 927 | def solve(n, a):
"""
References
----------
[1]. 足跡-sokuseki-, CODE FESTIVAL 2016 Grand Final C - Cheating Nim, http://wk1080id.hatenablog.com/entry/2018/08/17/234023
[2]. iroiro, CODE FESTIVAL 2016 Grand Final C - Cheating Nim, http://xxxasdfghjk999.hatenablog.jp/entry/2018/11/01/235259
[3]. Yang33, 競プロにおけるNim、Grundy数とNimK, http://yang33-kassa.hatenablog.com/entry/2017/12/21/202812
"""
x = 0
for i in range(n):
x ^= a[i]
b = [a[i] ^ (a[i] - 1) for i in range(n)]
mapping = {2**k-1: 0 for k in range(30)}
for y in b:
mapping[y] += 1
ans = 0
for k in range(30, 0, -1):
y = 2**k - 1
z = 2**(k-1)
if (x & z) > 0 and (mapping[y] > 0):
ans += 1
mapping[y] -= 1
x ^= y
return ans if x == 0 else -1
n = int(input())
a = [int(input()) for i in range(n)]
print(solve(n, a)) |
s872599828 | p03880 | u296518383 | 1569878488 | Python | Python (3.4.3) | py | Runtime Error | 225 | 15032 | 339 | import math
N=int(input())
A=[int(input()) for _ in range(N)]
#print(A)
B=0
for a in A:
B^=a
C=[]
D=[0]*30
for a in A:
C.append(bin(a^(a-1))[2:])
#print(C)
for c in C:
D[len(c)]=1
#print(D)
ans=0
while B:
#print(B,bin(B))
if D[len(bin(B)[2:])]:
B^=2**len(bin(B)[2:])-1
ans+=1
else:
ans=-1
break
print(ans) |
s145041413 | p03880 | u052499405 | 1566944264 | Python | Python (3.4.3) | py | Runtime Error | 240 | 3064 | 370 | n = int(input())
xor = 0
rank = [0] * 12
for i in range(n):
a = int(input())
LSB = (a & -a).bit_length()
rank[LSB] += 1
xor ^= a
prev = False
ans = 0
for i in range(10, -1, -1):
bit = xor & (1 << i)
if bit ^ prev:
if rank[i+1] == 0:
print(-1)
exit()
else:
ans += 1
prev = bit
print(ans) |
s693254047 | p03880 | u467736898 | 1539405857 | Python | Python (3.4.3) | py | Runtime Error | 340 | 7072 | 397 | N = int(input())
A = [int(input()) for i in range(N)]
s = 0
L = [False]*22
for a in A:
s ^= a
c = 0
while a&1==0:
c += 1
a >>= 1
L[c] = True
if s==0:
print(0)
exit()
ss = "0" + bin(s)[2:]
ans = 0
for i in range(len(ss)-1):
if ss[-1-i] != ss[-2-i]:
if L[i]:
ans += 1
else:
print(-1)
exit()
print(ans)
|
s703532035 | p03880 | u272028993 | 1482376586 | Python | PyPy2 (5.6.0) | py | Runtime Error | 233 | 21532 | 793 | n=int(raw_input())
a=[int(raw_input()) for _ in xrange(n)]
mxlba=0
for i in xrange(n):
mxlba=max(mxlba,len(bin(a[i])[2:]))
cnt=[0]*(mxlba+5)
for i in xrange(n):
bit=bin(a[i])[2:]
lb=len(bit)
for j in xrange(lb-1,-1,-1):
if bit[j]=="1":
cnt[lb-1-j]+=1
break
axor=0
for i in xrange(n):
axor^=a[i]
if axor==0:
print(0)
exit()
axor=bin(axor)[2:]
la=len(axor)
ans=0
i=-1
while i<la:
i+=1
if axor[i]=="1":
if cnt[i]==0:
print(-1)
exit()
else:
ans+=1
cnt[i]-=1
if la-i-1==0:
break
tmp=int("1"*(la-i-1),2)
axor=int(axor,2)^tmp
if axor==0:
break
axor=bin(axor)[2:]
print(ans)
|
s848956893 | p03880 | u272028993 | 1482376390 | Python | PyPy2 (5.6.0) | py | Runtime Error | 229 | 21532 | 747 | n=int(raw_input())
a=[int(raw_input()) for _ in xrange(n)]
mxlba=0
for i in xrange(n):
mxlba=max(mxlba,len(bin(a[i])[2:]))
cnt=[0]*(mxlba+5)
for i in xrange(n):
bit=bin(a[i])[2:]
lb=len(bit)
for j in xrange(lb-1,-1,-1):
if bit[j]=="1":
cnt[lb-1-j]+=1
break
axor=0
for i in xrange(n):
axor^=a[i]
if axor==0:
print(0)
exit()
axor=bin(axor)[2:]
la=len(axor)
ans=0
i=-1
while i<la:
i+=1
if axor[i]=="1":
if cnt[i]==0:
print(-1)
exit()
else:
ans+=1
cnt[i]-=1
if la-i-1==0:
break
tmp=int("1"*(la-i-1),2)
axor=int(axor,2)^tmp
axor=bin(axor)[2:]
print(ans)
|
s946973165 | p03880 | u272028993 | 1482376080 | Python | PyPy2 (5.6.0) | py | Runtime Error | 229 | 21532 | 712 | n=int(raw_input())
a=[int(raw_input()) for _ in xrange(n)]
mxlba=0
for i in xrange(n):
mxlba=max(mxlba,len(bin(a[i])[2:]))
cnt=[0]*(mxlba+5)
for i in xrange(n):
bit=bin(a[i])[2:]
lb=len(bit)
for j in xrange(lb-1,-1,-1):
if bit[j]=="1":
cnt[lb-1-j]+=1
break
axor=0
for i in xrange(n):
axor^=a[i]
axor=bin(axor)[2:]
la=len(axor)
ans=0
i=-1
while i<la:
i+=1
if axor[i]=="1":
if cnt[i]==0:
print(-1)
exit()
else:
ans+=1
cnt[i]-=1
if la-i-1==0:
break
tmp=int("1"*(la-i-1),2)
axor=int(axor,2)^tmp
axor=bin(axor)[2:]
print(ans)
|
s424739725 | p03880 | u272028993 | 1482375940 | Python | PyPy2 (5.6.0) | py | Runtime Error | 335 | 28828 | 708 | n=int(raw_input())
a=[int(raw_input()) for _ in xrange(n)]
mxlba=0
for i in xrange(n):
mxlba=max(mxlba,len(bin(a[i])[2:]))
cnt=[0]*mxlba
for i in xrange(n):
bit=bin(a[i])[2:]
lb=len(bit)
for j in xrange(lb-1,-1,-1):
if bit[j]=="1":
cnt[lb-1-j]+=1
break
axor=0
for i in xrange(n):
axor^=a[i]
axor=bin(axor)[2:]
la=len(axor)
ans=0
i=-1
while i<la:
i+=1
if axor[i]=="1":
if cnt[i]==0:
print(-1)
exit()
else:
ans+=1
cnt[i]-=1
if la-i-1==0:
break
tmp=int("1"*(la-i-1),2)
axor=int(axor,2)^tmp
axor=bin(axor)[2:]
print(ans)
|
s700850283 | p03880 | u272028993 | 1482375436 | Python | PyPy2 (5.6.0) | py | Runtime Error | 275 | 24348 | 703 | n=int(raw_input())
a=[int(raw_input()) for _ in xrange(n)]
mxlba=0
for i in xrange(n):
mxlba=max(mxlba,len(bin(a[i])[2:]))
cnt=[0]*mxlba
for i in xrange(n):
bit=bin(a[i])[2:]
lb=len(bit)
for j in xrange(lb-1,-1,-1):
if bit[j]=="1":
cnt[lb-1-j]+=1
break
axor=0
for i in xrange(n):
axor^=a[i]
axor=bin(axor)[2:]
ans=0
i=-1
while i<mxlba:
i+=1
if axor[i]=="1":
if cnt[i]==0:
print(-1)
exit()
else:
ans+=1
cnt[i]-=1
if mxlba-i-1==0:
break
tmp=int("1"*(mxlba-i-1),2)
axor=int(axor,2)^tmp
axor=bin(axor)[2:]
print(ans)
|
s052143373 | p03880 | u272028993 | 1482375191 | Python | PyPy2 (5.6.0) | py | Runtime Error | 300 | 30364 | 669 | n=int(raw_input())
a=[int(raw_input()) for _ in xrange(n)]
cnt=[0]*len(bin(max(a))[2:])
for i in xrange(n):
bit=bin(a[i])[2:]
lb=len(bit)
for j in xrange(lb-1,-1,-1):
if bit[j]=="1":
cnt[lb-1-j]+=1
break
axor=0
for i in xrange(n):
axor^=a[i]
axor=bin(axor)[2:]
mx=len(bin(max(a))[2:])
ans=0
i=-1
while i<mx:
i+=1
if axor[i]=="1":
if cnt[i]==0:
print(-1)
exit()
else:
ans+=1
cnt[i]-=1
if mx-i-1==0:
break
tmp=int("1"*(mx-i-1),2)
axor=int(axor,2)^tmp
axor=bin(axor)[2:]
print(ans)
|
s163357720 | p03880 | u382423941 | 1480369686 | Python | Python (3.4.3) | py | Runtime Error | 690 | 9604 | 515 | import math as m
import functools
def int_reverse(num):
num_len = len(bin(num))-2
f = 2**num_len-1
return num ^ f
n = int(input())
A = [int(input()) for i in range(n)]
lsbs = [[i for i in range(int(m.log2(a))+1) if (a>>i)&1][0] for a in A]
nim = functools.reduce(lambda x,y:x^y, A)
cnt = 0
if nim == 0:
ans = 0
else:
for lsb in reversed(sorted(lsbs)):
if int(m.log2(nim)) == lsb:
nim = int_reverse(nim)
cnt += 1
ans = cnt if(nim == 0) else -1
print(ans)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.