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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
s097961722 | p03836 | u026155812 | 1553964528 | Python | Python (3.4.3) | py | Runtime Error | 17 | 2940 | 7 | 0 0 1 2 |
s354226650 | p03836 | u065446124 | 1545168540 | Python | Python (3.4.3) | py | Runtime Error | 17 | 2940 | 169 | sx, sy, tx, ty=map(int, input().split())
print("D"+"R"*(tx-sx+1)+"U"*(ty-sy+1)+"L"*(tx-sx+1)+"D"*(tx-sx)+
"L"+"U"*(ty-sy+1)+"R"*(tx-sx+1)+"D"*(tx-sx+1)"L"*(tx-sx)) |
s119023982 | p03836 | u283846680 | 1544220991 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3060 | 261 | sx, sy, tx, ty = map(int, input().split())
dx = tx - sx
dy = ty - sy
a = iter[dx, dy, dx, dy+1, dx+1, dy+1, dx+1, dy+1,]
w = "R"*next(a) + "U"*next(a) + "L"*next(a) + "D"*next(a) + "R"*next(a) + "U"*next(a) + "L" + "U" + "L"*next(a) + "D"*next(a) + "R"
print(w) |
s461516083 | p03836 | u513081876 | 1535937631 | Python | Python (3.4.3) | py | Runtime Error | 19 | 3064 | 433 | N = int(input())
A = list(map(int, input().split()))
ans = 1
if N % 2 == 0:
for i in list(range(1, N, 2)):
if A.count(i) != 2:
ans = 0
break
else:
if A.count(0) == 1:
for i in list(range(2, N, 2)):
if A.count(i) != 2:
ans = 0
break
else:
ans = 0
if ans == 0:
print(0)
else:
print((2**(N//2))%(10**9+7)) |
s191868580 | p03836 | u140251125 | 1533483005 | Python | Python (3.4.3) | py | Runtime Error | 24 | 3700 | 444 | # input
sx, sy, tx, ty = map(int, input().split())
for i in range(tx - sx):
print('R')
for i in range(ty - sy):
print('U')
for i in range(tx - sx):
print('L')
for i in range(ty - sy):
print('D')
print('L')
for i in range(ty - sy + 1):
print('U')
for i in range(tx - sx + 1):
print('R')
print('D')
print('R')
for i in range(ty - sy + 1):
print('D')
for i in range('tx - sx + 1'):
print('L')
print('U') |
s454331580 | p03836 | u653005308 | 1521781513 | Python | Python (3.4.3) | py | Runtime Error | 17 | 2940 | 264 | import sys
2.
3.stdin = sys.stdin
4.na = lambda: list(map(int, stdin.readline().split()))
5.
6.k,s = na()
7.ans = 0
8.for x in range(k+1):
9. for y in range(k+1):
10. z = s - (x+y)
11. if z >= 0 and z <= k:
12. ans += 1
13.print(ans)
|
s657448791 | p03836 | u005388620 | 1520308559 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 457 | lis = list(map(int, input().split()))
a=lis[0], b=lis[1], c=lis[2], d=lis[3]
x=c-a, y=d-b
for i in range(x):
print('R', end='')
for i in range(y):
print('U', end='')
for i in range(x):
print('L', end='')
for i in range(y+1):
print('D', end='')
for i in range(x+1):
print('R', end='')
for i in range(y+2):
print('U', end='')
for i in range(x+2):
print('L', end='')
for i in range(y+1):
print('D', end='')
print('R',end='')
|
s397269162 | p03836 | u089230684 | 1507011725 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 571 | sx, sy, tx, ty = [int(x) for x in input().strip()]
# A = (sx,sy) B = (tx,ty)
S = ''
def move(a,b):
global x,y,S
if a-x>0:
for i in range(a-x):
x+=1
S += 'R'
else:
for i in range(x-a):
x-=1
S += 'L'
if b-y>0:
for j in range(b-y):
y+=1
S += 'U'
else:
for j in range(y-b):
y-=1
S += 'D'
x,y=sx,sy
move(tx,y)
move(x,ty)
y+=1
S += 'U'
move(sx-1,y)
move(x,sy)
x += 1
S += 'R'
y -= 1
S += 'D'
move(tx+1,y)
move(x,ty+1)
print(S) |
s054984798 | p03836 | u481165257 | 1491544483 | Python | Python (3.4.3) | py | Runtime Error | 17 | 2940 | 616 | ef route(sx, sy, tx, ty):
dx = tx - sx
dy = ty - sy
dx2 = dx if dx >= 0 else -dx
dy2 = dy if dy >= 0 else -dy
buf = ""
for i in range(dx2):
if dx >= 0:
buf += "L"
else:
buf += "R"
for i in range(dy2):
if dy >= 0:
buf += "U"
else:
buf += "D"
return buf
if __name__ == "__main__":
sx, sy, tx, ty = [int(i) for i in input().split()]
r1 = route(sx, sy, tx, ty) + route(tx, ty, sx, sy)
r2 = "L" + route(sx-1, sy, tx, ty+1)\
+ "DR" + route(tx+1, ty, sx, sy-1) + "U"
print(r1 + r2) |
s762320037 | p03836 | u912359563 | 1489755916 | Python | Python (3.4.3) | py | Runtime Error | 19 | 3188 | 435 | sx, sy, gx, gy = list(map(int, input().split()))
l = []
dx = gx - sx
dy = gy - sy
for i in range(dx):
l.append('R')
for i in range(dy):
l.append('U')
for i in range(dx):
l.append('L')
for i in range(dy):
l.append('D')
l.append('D')
for i in range(dx+1):
l.append('R')
for i in range(dy+1):
l.append('U')
l.append('L')
l.append('U')
for i in range(dx+1):
l.append('L')
for i in range(dy+1):
l.append('D')
l.append('R')
print(S)
|
s182380244 | p03836 | u290326033 | 1483846747 | Python | Python (3.4.3) | py | Runtime Error | 23 | 3064 | 496 | def col(a, x):
if x > a:
while x > a:
print("R")
a += 1
else:
while x < a:
print("L")
a -= 1
def row(b, y):
if y > b:
while y > b:
print("U")
a += 1
else:
while y < b:
print("D")
a -= 1
data = int(input().split())
a, b, x, y = data[0], data[1], data[2], data[3]
col(a, x)
row(b, y)
row(y, b)
col(x, a)
print("L")
row(b, y + 1)
col(a - 1, x)
print("D")
print("R")
row(y, b)
col(x + 1, a) |
s137265164 | p03836 | u757184416 | 1483844299 | Python | Python (3.4.3) | py | Runtime Error | 23 | 3064 | 439 | ret=''
for i in range(tx-sx):
ret=ret+'U'
for i in range(ty-sy):
ret=ret+'R'
for i in range(tx-sx):
ret=ret+'D'
import sys
inp=sys.stdin.readline()
sx,sy,tx,ty=map(lambda x: int(x), inp.split(' '))
for i in range(ty-sy+1):
ret=ret+'L'
for i in range(tx-sx+1):
ret=ret+'U'
for i in range(ty-sy+1):
ret=ret+'R'
ret=ret+'DR'
for i in range(tx-sx+1):
ret=ret+'D'
for i in range(ty-sy+1):
ret=ret+'L'
ret=ret+'U' |
s419611643 | p03836 | u237316771 | 1483842138 | Python | Python (2.7.6) | py | Runtime Error | 16 | 2568 | 55 | "U" * h + "R" * (w + 1) + "D" * (h + 1) + "L" * (w + 1) |
s963096571 | p03837 | u070201429 | 1597932083 | Python | PyPy3 (7.3.0) | py | Runtime Error | 90 | 68876 | 1146 | def main():
from sys import stdin
def input():
return stdin.readline().strip()
n, m = map(int, input().split())
tree = [[] for _ in range(n)]
for _ in range(m):
i, j, k = map(int, input().split())
i -= 1
j -= 1
tree[i].append((k, j))
tree[j].append((k, i))
# dijkstra
import heapq
from numpy import zeros
ans = 0
for i in range(n):
for j in tree[i]:
seen = zeros(n)
goal = j[1]
base = j[0]
seen[i] = 1
todo = []
heapq.heapify(todo)
for k in tree[i]:
if k[0] < base and k != j:
heapq.heappush(todo, k)
while len(todo) > 0:
k = heapq.heappop(todo)
if k[1] == goal:
if k[0] < base:
ans += 1
break
seen[k[1]] = 1
for l in tree[k[1]]:
if seen[l[1]] == 0 and k[0] + l[0] < base:
heapq.heappush(todo, (k[0] + l[0], l[1]))
print(ans // 2)
main() |
s977828810 | p03837 | u477320129 | 1597431919 | Python | Python (3.8.2) | py | Runtime Error | 390 | 41456 | 1092 | #!/usr/bin/env python3
import sys
def solve(N: int, M: int, a: "List[int]", b: "List[int]", c: "List[int]"):
import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import floyd_warshall
omat = csr_matrix((c, (a, b)), shape=(N+1, N+1), dtype=np.int32, directed=False)
smat = floyd_warshall(omat)
return ((omat-smat) > 0).sum() // 2
# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
a = [int()] * (M) # type: "List[int]"
b = [int()] * (M) # type: "List[int]"
c = [int()] * (M) # type: "List[int]"
for i in range(M):
a[i] = int(next(tokens))
b[i] = int(next(tokens))
c[i] = int(next(tokens))
print(solve(N, M, a, b, c))
def test():
import doctest
doctest.testmod()
if __name__ == '__main__':
#test()
main()
|
s954766818 | p03837 | u685983477 | 1595190415 | Python | PyPy3 (7.3.0) | py | Runtime Error | 85 | 68512 | 811 | import numpy as np
def warshall_floyd(d,n):
#d[i][j]: iからjへの最短距離
for k in range(n):
for i in range(n):
for j in range(n):
if(i!=j):
d[i][j] = min(d[i][j],d[i][k] + d[k][j])
return d
def main():
n,m=map(int, input().split())
edge = [[] for _ in range(n)]
d = [[float("inf")]*n for i in range(n)]
d_1 = [[float("inf")]*n for i in range(n)]
e_lis = [0]*m
for i in range(m):
a,b,c=map(int, input().split())
d[a-1][b-1]=d[b-1][a-1]=d_1[a-1][b-1]=d_1[b-1][a-1]=c
res = warshall_floyd(d,n)
cnt=0
for i in range(n):
for j in range(n):
if(res[i][j]!=d_1[i][j] and d_1[i][j]<10000):
cnt+=1
print(cnt//2)
if __name__ == '__main__':
main()
|
s479399022 | p03837 | u858742833 | 1592966079 | Python | Python (3.8.2) | py | Runtime Error | 106 | 9500 | 864 | import heapq
def main():
N, M = map(int, input().split())
G = [[] for _ in range(N)]
for _ in range(M):
a, b, c = map(int, input().split())
G[a - 1].append((b - 1, c))
G[b - 1].append((a - 1, c))
used = set()
for i in range(N):
H = []
for b, c in G[i]:
heapq.heappush(H, (c, i, b))
todo = set(range(N))
todo.remove(i)
D = [10**10] * N
D[i] = 0
while H:
c, a, b = heapq.heappop(H)
if D[b] < c:
continue
D[b] = c
if a < b:
used.add((a, b))
else:
used.add((b, a))
todo.remove(b)
for d, cc in G[b]:
if d in todo:
heapq.heappush(H, (c + cc, b, d))
return M - len(used)
print(main())
|
s604703279 | p03837 | u127499732 | 1592855687 | Python | Python (3.8.2) | py | Runtime Error | 31 | 9400 | 1006 | import heapq
def dijkstra(n, s, g):
h = [(0, s)]
heapq.heapify(h)
cost = [float("Inf")] * (n + 1) # cost: i -> j
cost[s] = 0
while h:
c, v = heapq.heappop(h)
if c > cost[v]:
continue
for d, u in g[v]:
d_s_u = d + cost[v]
if d_s_u < cost[u]:
cost[u] = d_s_u
heapq.heappush(h, (d_s_u, u))
return cost
def main():
n, m, *abc = map(int, open(0).read().split())
g = [[] for _ in range(n + 1)]
for a, b, c in zip(*[iter(abc)] * 3):
g[a].append([c, b])
g[b].append([c, a])
ans = 0
checkd = [[False] * (n + 1) for _ in range(n + 1)]
for i in range(1, n + 1):
cost = dijkstra(n, i, g)
for j, k in g[i]:
if checkd[i][j]:
continue
if j > cost[k]:
ans += 1
checkd[i][j] = True
checkd[j][i] = True
print(ans)
if __name__ == '__main__':
main()
|
s863134321 | p03837 | u677121387 | 1592589539 | Python | Python (3.8.2) | py | Runtime Error | 28 | 9352 | 484 | n,m = map(int,input().split())
INF = 10**18
d = [[INF]*n for _ in range(n)]
for i in range(n): d[i][i] = 0
a = [0]*m
b = [0]*m
c = [0]*m
for i in range(m):
a,b,c = map(int,input().split())
a -= 1
b -= 1
a[i] = a
b[i] = b
c[i] = c
d[a][b] = c
d[b][a] = c
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j], d[i][k]+d[k][j])
ans = 0
for i in range(m):
if d[a[i]][b[i]] < c[i]: ans += 1
print(ans) |
s534380098 | p03837 | u169350228 | 1591587789 | Python | Python (3.4.3) | py | Runtime Error | 249 | 17408 | 875 | import math
#import numpy as np
import queue
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
from scipy.sparse.csgraph import dijkstra
from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
def main():
n,m = map(int,ipt().split())
cos = []
row = []
col = []
for _ in range(m):
a,b,c = map(int,ipt().split())
row.append(a-1)
col.append(b-1)
cos.append(c)
cos.append(c)
csr = csr_matrix((cos,(row,col)),shape=(n,n))
d = dijkstra(csr,directed=False)
ans = 0
for i in range(m):
csr = csr_matrix((cos[:i:]+cos[i+1::],(row[:i:]+row[i+1::],col[:i:]+col[i+1::])),shape=(n,n))
di = dijkstra(csr)
if (di == d).all():
ans += 1
print(ans)
return
if __name__ == '__main__':
main()
|
s877397987 | p03837 | u762540523 | 1591296634 | Python | Python (3.4.3) | py | Runtime Error | 361 | 25572 | 1174 | def resolve():
from scipy.sparse.csgraph import shortest_path
import scipy
import numpy as numpy
n, m = map(int, input().split())
row = [None] * m
col = row[:]
data = row[:]
for i in range(m):
row[i], col[i], data[i] = map(int, input().split())
row[i] -= 1
col[i] -= 1
a = scipy.sparse.csr_matrix((data, (row, col)), shape=(n, n))
s, p = shortest_path(a, return_predecessors=True, directed=False)
l = [[True] * n for _ in range(n)]
for start in range(n - 1):
for goal in range(start + 1, n):
path = get_path(start, goal, p)
for i in range(len(path) - 1):
l[path[i]][path[i + 1]] = False
l[path[i + 1]][path[i]] = False
ans = 0
for i, j in zip(row, col):
if l[i][j]:
ans += 1
print(ans)
def get_path(start, goal, pred):
return get_path_row(start, goal, pred[start])
def get_path_row(start, goal, pred_row):
path = []
i = goal
while i != start and i >= 0:
path.append(i)
i = pred_row[i]
if i < 0:
return []
path.append(i)
return path[::-1]
resolve()
|
s767656457 | p03837 | u591808161 | 1590869951 | Python | PyPy3 (2.4.0) | py | Runtime Error | 207 | 39280 | 968 | import sys
sys.setrecursionlimit(1000001)
def main():
n, m = map(int, input().rstrip().split())
dist = [[500000 for i in range(n)]for j in range(n)]
for i in range(n):
for j in range(n):
if (i==j):
dist[i][j]=0
a = [None] * (m-1)
b = [None] * (m-1)
c = [None] * (m-1)
for i in range(m):
x, y, z = map(int, input().rstrip().split())
dist[x-1][y-1] = min(dist[x-1][y-1], z)
dist[y-1][x-1] = min(dist[x-1][y-1], z)
a[i] = x - 1
b[i] = y - 1
c[i] = z
for k in range(n):
for i in range(n):
for j in range(n):
dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j])
#print(dist)
result = m
for i in range(m):
for j in range(n):
if dist[j][a[i]] + c[i] == dist[j][b[i]]:
result -= 1
break
print(result)
if __name__ == '__main__':
main() |
s333370424 | p03837 | u591808161 | 1590868051 | Python | Python (3.4.3) | py | Runtime Error | 579 | 3428 | 766 | import sys
sys.setrecursionlimit(1000001)
n, m = map(int, input().rstrip().split())
dist = [[500000 for i in range(n)]for j in range(n)]
for i in range(n):
for j in range(n):
if (i==j):
dist[i][j]=0
a = []
b = []
c = []
for i in range(m):
x, y, z = map(int, input().rstrip().split())
dist[x-1][y-1] = min(dist[x-1][y-1], z)
dist[y-1][x-1] = min(dist[x-1][y-1], z)
a.append(x-1)
b.append(y-1)
c.append(z)
for k in range(n):
for i in range(n):
for j in range(n):
dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j])
#print(dist)
result = m
for i in range(m):
for j in range(m):
if dist[j][a[i]] + c[i] == dist[j][b[i]]:
result -= 1
break
print(result) |
s943443315 | p03837 | u591808161 | 1590868012 | Python | Python (3.4.3) | py | Runtime Error | 589 | 4176 | 819 | import sys
sys.setrecursionlimit(1000001)
n, m = map(int, input().rstrip().split())
dist = [[500000 for i in range(n)]for j in range(n)]
for i in range(n):
for j in range(n):
if (i==j):
dist[i][j]=0
a = []
b = []
c = []
for i in range(m):
x, y, z = map(int, input().rstrip().split())
dist[x-1][y-1] = min(dist[x-1][y-1], z)
dist[y-1][x-1] = min(dist[x-1][y-1], z)
a.append(x-1)
b.append(y-1)
c.append(z)
for k in range(n):
for i in range(n):
for j in range(n):
dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j])
#print(dist)
result = m
for i in range(m):
for j in range(m):
if dist[j][a[i]] + c[i] == dist[j][b[i]]:
print(j, a[i],b[i], c[i], i, dist[j][a[i]] ,dist[j][b[i]])
result -= 1
print(result) |
s738974439 | p03837 | u591808161 | 1590867839 | Python | Python (3.4.3) | py | Runtime Error | 604 | 3476 | 723 | import sys
n, m = map(int, input().rstrip().split())
dist = [[500000 for i in range(n)]for j in range(n)]
for i in range(n):
for j in range(n):
if (i==j):
dist[i][j]=0
a = []
b = []
c = []
for i in range(m):
x, y, z = map(int, input().rstrip().split())
dist[x-1][y-1] = min(dist[x-1][y-1], z)
dist[y-1][x-1] = min(dist[x-1][y-1], z)
a.append(x-1)
b.append(y-1)
c.append(z)
for k in range(n):
for i in range(n):
for j in range(n):
dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j])
result = m
for i in range(m):
for j in range(m):
if dist[j][a[i]] + c[i] == dist[j][b[i]]:
result -= 1
break
print(result) |
s940834752 | p03837 | u591808161 | 1590867771 | Python | PyPy3 (2.4.0) | py | Runtime Error | 253 | 42348 | 723 | import sys
n, m = map(int, input().rstrip().split())
dist = [[500000 for i in range(n)]for j in range(n)]
for i in range(n):
for j in range(n):
if (i==j):
dist[i][j]=0
a = []
b = []
c = []
for i in range(m):
x, y, z = map(int, input().rstrip().split())
dist[x-1][y-1] = min(dist[x-1][y-1], z)
dist[y-1][x-1] = min(dist[x-1][y-1], z)
a.append(x-1)
b.append(y-1)
c.append(z)
for k in range(n):
for i in range(n):
for j in range(n):
dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j])
result = m
for i in range(m):
for j in range(m):
if dist[j][a[i]] + c[i] == dist[j][b[i]]:
result -= 1
break
print(result) |
s235793004 | p03837 | u591808161 | 1590867682 | Python | PyPy3 (2.4.0) | py | Runtime Error | 249 | 42716 | 734 | import sys
n, m = map(int, input().rstrip().split())
dist = [[500000 for i in range(n)]for j in range(n)]
for i in range(n):
for j in range(n):
if (i==j):
dist[i][j]=0
a = []
b = []
c = []
for i in range(m):
x, y, z = map(int, input().rstrip().split())
dist[x-1][y-1] = min(dist[x-1][y-1], z)
dist[y-1][x-1] = min(dist[x-1][y-1], z)
a.append(x-1)
b.append(y-1)
c.append(z)
for k in range(n):
for i in range(n):
for j in range(n):
dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j])
print(dist)
result = m
for i in range(m):
for j in range(m):
if dist[j][a[i]] + c[i] == dist[j][b[i]]:
result -= 1
break
print(result) |
s102749735 | p03837 | u591808161 | 1590820764 | Python | PyPy3 (2.4.0) | py | Runtime Error | 254 | 42348 | 724 | import sys
n, m = map(int, input().rstrip().split())
dist = [[500000 for i in range(n)]for j in range(n)]
for i in range(1, n):
for j in range(1, n):
if (i==j):
dist[i][j]=0
a = []
b = []
c = []
for i in range(m):
x, y, z = map(int, input().rstrip().split())
dist[x-1][y-1] = min(dist[x-1][y-1], z)
dist[y-1][x-1] = min(dist[x-1][y-1], z)
a.append(x-1)
b.append(y-1)
c.append(z)
for k in range(n):
for i in range(n):
for j in range(n):
dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j])
#print(dist)
result = m
for i in range(m):
for j in range(m):
if dist[j][a[i]] + c[i] == dist[j][b[i]]:
result -= 1
print(result) |
s864394271 | p03837 | u591808161 | 1590819506 | Python | PyPy3 (2.4.0) | py | Runtime Error | 232 | 41836 | 723 | import sys
n, m = map(int, input().rstrip().split())
dist = [[500000 for i in range(n)]for j in range(n)]
for i in range(1, n):
for j in range(1, n):
if (i==j):
dist[i][j]=0
a = []
b = []
c = []
for i in range(m):
x, y, z = map(int, input().rstrip().split())
dist[x-1][y-1] = min(dist[x-1][y-1], z)
dist[y-1][x-1] = min(dist[x-1][y-1], z)
a.append(x-1)
b.append(y-1)
c.append(z)
for i in range(n):
for j in range(n):
for k in range(n):
dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j])
#print(dist)
result = m
for i in range(m):
for j in range(m):
if dist[j][a[i]] + c[i] == dist[j][b[i]]:
result -= 1
print(result) |
s526490998 | p03837 | u591808161 | 1590819380 | Python | Python (3.4.3) | py | Runtime Error | 596 | 3648 | 729 | import sys
n, m = map(int, input().rstrip().split())
dist = [[float('inf') for i in range(n)]for j in range(n)]
for i in range(1, n):
for j in range(1, n):
if (i==j):
dist[i][j]=0
a = []
b = []
c = []
for i in range(m):
x, y, z = map(int, input().rstrip().split())
dist[x-1][y-1] = min(dist[x-1][y-1], z)
dist[y-1][x-1] = min(dist[x-1][y-1], z)
a.append(x-1)
b.append(y-1)
c.append(z)
for i in range(n):
for j in range(n):
for k in range(n):
dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j])
#print(dist)
result = m
for i in range(m):
for j in range(m):
if dist[j][a[i]] + c[i] == dist[j][b[i]]:
result -= 1
print(result) |
s283978455 | p03837 | u591808161 | 1590728768 | Python | PyPy3 (2.4.0) | py | Runtime Error | 272 | 44268 | 752 | import sys
import re
import heapq
n, m = map(int, input().rstrip().split())
dist = [[float('inf') for i in range(n)]for j in range(n)]
for i in range(1, n):
for j in range(1, n):
if (i==j):
dist[i][j]=0
a = []
b = []
c = []
for i in range(m):
x, y, z = map(int, input().rstrip().split())
dist[x-1][y-1] = min(dist[x-1][y-1], z)
dist[y-1][x-1] = min(dist[x-1][y-1], z)
a.append(x-1)
b.append(y-1)
c.append(z)
for i in range(n):
for j in range(n):
for k in range(n):
dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j])
#print(dist)
result = m
for i in range(m):
for j in range(m):
if dist[j][a[i]] + c[i] == dist[j][b[i]]:
result -= 1
print(result) |
s925330395 | p03837 | u318127926 | 1590718625 | Python | Python (3.4.3) | py | Runtime Error | 1076 | 93148 | 874 | import sys
sys.setrecursionlimit(10**5)
n, m = map(int, input().split())
INF = 10**10
d = [[INF]*n for _ in range(n)]
for _ in range(m):
a, b, c = map(int, input().split())
d[a-1][b-1] = c
d[b-1][a-1] = c
nxt = [[[i] for i in range(n)] for _ in range(n)]
for k in range(n):
for i in range(n):
for j in range(n):
if i==j:
continue
if d[i][k]+d[k][j] < d[i][j]:
d[i][j] = d[i][k]+d[k][j]
nxt[i][j] = nxt[i][k]
elif d[i][k]+d[k][j] == d[i][j]:
nxt[i][j].extend(nxt[i][k])
s = set()
for start in range(n):
for goal in range(n):
if start==goal:
continue
def DFS(i):
for j in nxt[i][goal]:
s.add((i, j))
if j!=goal:
DFS(j)
DFS(start)
print(m-len(s)//2) |
s262294743 | p03837 | u318127926 | 1590718549 | Python | Python (3.4.3) | py | Runtime Error | 843 | 5436 | 834 | n, m = map(int, input().split())
INF = 10**10
d = [[INF]*n for _ in range(n)]
for _ in range(m):
a, b, c = map(int, input().split())
d[a-1][b-1] = c
d[b-1][a-1] = c
nxt = [[[i] for i in range(n)] for _ in range(n)]
for k in range(n):
for i in range(n):
for j in range(n):
if i==j:
continue
if d[i][k]+d[k][j] < d[i][j]:
d[i][j] = d[i][k]+d[k][j]
nxt[i][j] = nxt[i][k]
elif d[i][k]+d[k][j] == d[i][j]:
nxt[i][j].extend(nxt[i][k])
s = set()
for start in range(n):
for goal in range(n):
if start==goal:
continue
def DFS(i):
for j in nxt[i][goal]:
s.add((i, j))
if j!=goal:
DFS(j)
DFS(start)
print(m-len(s)//2) |
s535182593 | p03837 | u197457087 | 1590717587 | Python | PyPy3 (2.4.0) | py | Runtime Error | 282 | 44780 | 698 | N,M = map(int,input().split())
INF = float("inf")
load = [[[INF, 0] for _ in range(N)] for _ in range(N)]
#print(load)
#dis = [[] for _ in range(N)]
#ID = [0 for _ in range(M)] #、0は未使用、1は使用
for i in range(M):
a,b,c = map(int,input().split())
a-=1;b-=1
load[a][b] = [c,0]
load[b][a] = [c,0]
#dis[a].append([b,i])
#dis[b].append([a,i])
#for i in range(N):
for i in range(N):
load[i][i] = [0,0]
#print(load)
for k in range(N):
for i in range(N):
for j in range(N):
if load[i][j][0] > load[i][k][0]+load[j][k][0]:
load[i][j][1] = 1
#print(load)
ans = 0
for i in range(N):
for j in range(i+1,M):
if load[i][j][1] == 1:
ans += 1
print(ans) |
s775981771 | p03837 | u591808161 | 1590557109 | Python | PyPy3 (2.4.0) | py | Runtime Error | 172 | 38384 | 714 | import sys
import re
import heapq
n, m = map(int, input().rstrip().split())
for i in range(n):
for j in range(n):
if (i==j):
dist[i][j]=0
else:
dist[i][j]=float('inf')
a = []
b = []
c = []
for i in range(m):
x, y, z = map(int, input().rstrip().split())
dist[x][y] = min(dist[x][y], z)
dist[y][x] = min(dist[x][y], z)
a.append(x)
b.append(y)
c.append(z)
for i in range(n):
for j in range(n):
for k in range(n):
dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j])
result = m
for i in range(m):
for j in range(m):
if dist[j][a[i]] + c[i] == dist[j][b[i]]:
result -= 1
print(result) |
s818648667 | p03837 | u836004075 | 1590541195 | Python | Python (3.4.3) | py | Runtime Error | 109 | 11252 | 1281 | import heapq
n, m = map( int, input().split() )
adj_list = [ [] for i in range( n+1 ) ]
for _ in range( m ):
a, b, c = map( int, input().split() )
adj_list[ a ].append( ( b, c ) )
adj_list[ b ].append( ( a, c ) )
# dijkstra
def dijkstra( start ):
prev_node = [ -1 ] * ( n + 1 )
INF = 10 ** 10
VISITED = 1
NOT_VISITED = 0
cost = [ INF ] * ( n + 1 )
cost[ start ] = 0
visit = [ NOT_VISITED ] * ( n + 1 )
queue = [ ( cost[ start ], start ) ]
while len( queue ) > 0:
c, v = heapq.heappop( queue )
visit[ v ] = VISITED
for u, cost_vu in adj_list[v]:
if visit[ u ] == VISITED:
continue
if cost[u] > cost[v] + cost_vu:
cost[u] = cost[v] + cost_vu
heapq.heappush( queue, ( cost[u], u ) )
prev_node[ u ] = v
return prev_node
used_edge = [ [ False ] * ( m+1 ) for i in range( m+1 ) ]
used_count = 0
for s in range( 1, n+1 ):
prev_node = dijkstra( s )
for i in range( 1, n+1 ):
j = prev_node[ i ]
if j == -1:
continue
if used_edge[ i ][ j ] == False:
used_count += 1
used_edge[ i ][ j ] = True
used_edge[ j ][ i ] = True
print( m - used_count ) |
s794074746 | p03837 | u836004075 | 1590541100 | Python | Python (3.4.3) | py | Runtime Error | 45 | 11124 | 1281 | import heapq
n, m = map( int, input().split() )
adj_list = [ [] for i in range( n+1 ) ]
for _ in range( m ):
a, b, c = map( int, input().split() )
adj_list[ a ].append( ( b, c ) )
adj_list[ b ].append( ( a, c ) )
# dijkstra
def dijkstra( start ):
prev_node = [ -1 ] * ( n + 1 )
INF = 10 ** 10
VISITED = 1
NOT_VISITED = 0
cost = [ INF ] * ( n + 1 )
cost[ start ] = 0
visit = [ NOT_VISITED ] * ( n + 1 )
queue = [ ( cost[ start ], start ) ]
while len( queue ) > 0:
c, v = heapq.heappop( queue )
visit[ v ] = VISITED
for u, cost_vu in adj_list[v]:
if visit[ u ] == VISITED:
continue
if cost[u] > cost[v] + cost_vu:
cost[u] = cost[v] + cost_vu
heapq.heappush( queue, ( cost[u], u ) )
prev_node[ u ] = v
return prev_node
used_edge = [ [ False ] * ( m+1 ) for i in range( m+1 ) ]
used_count = 0
for s in range( 1, n+1 ):
prev_node = dijkstra( s )
for i in range( 1, m+1 ):
j = prev_node[ i ]
if j == -1:
continue
if used_edge[ i ][ j ] == False:
used_count += 1
used_edge[ i ][ j ] = True
used_edge[ j ][ i ] = True
print( m - used_count ) |
s783598936 | p03837 | u836004075 | 1590540967 | Python | Python (3.4.3) | py | Runtime Error | 32 | 3316 | 1284 | import heapq
n, m = map( int, input().split() )
adj_list = [ [] for i in range( 0, n+1 ) ]
for _ in range( m ):
a, b, c = map( int, input().split() )
adj_list[ a ].append( ( b, c ) )
adj_list[ b ].append( ( a, c ) )
# dijkstra
def dijkstra( start ):
prev_node = [ -1 ] * ( n + 1 )
INF = 10 ** 10
VISITED = 1
NOT_VISITED = 0
cost = [ INF ] * ( n + 1 )
cost[ start ] = 0
visit = [ NOT_VISITED ] * ( n + 1 )
queue = [ ( cost[ start ], start ) ]
while len( queue ) > 0:
c, v = heapq.heappop( queue )
visit[ v ] = VISITED
for u, cost_vu in adj_list[v]:
if visit[ u ] == VISITED:
continue
if cost[u] > cost[v] + cost_vu:
cost[u] = cost[v] + cost_vu
heapq.heappush( queue, ( cost[u], u ) )
prev_node[ u ] = v
return prev_node
used_edge = [ [ False ] * ( n+1 ) for i in range( n+1 ) ]
used_count = 0
for s in range( 1, n+1 ):
prev_node = dijkstra( s )
for i in range( 1, m+1 ):
j = prev_node[ i ]
if j == -1:
continue
if used_edge[ i ][ j ] == False:
used_count += 1
used_edge[ i ][ j ] = True
used_edge[ j ][ i ] = True
print( m - used_count ) |
s887722392 | p03837 | u446774692 | 1590539827 | Python | Python (3.4.3) | py | Runtime Error | 25 | 3564 | 741 | N,M = map(int,input().split())
from collections import deque
v = [deque([]) for _ in range(N)]
for i in range(M):
a,b,c = map(int,input().split())
a,b = a-1,b-1
v[a].append([b,c])
v[b].append([a,c])
import math
s = deque([])
for i in range(N):
ls = [[-1,math.inf]]*N
ls[i] = [-1,0]
q = [deque(j for j in i) for i in v]
l = deque([i])
while l:
u = l.popleft()
while q[u]:
e = q[u].popleft()
if ls[u][1] + e[1] < ls[e[0]][1]:
ls[e[0]] = [u, ls[u][1] + e[1]]
l.append(e[0])
for j,e in enumerate(ls):
if e[0] != -1:
s.append([min(j,e[0]),max(j,e[0])])
s = list(map(list, set(map(tuple, s))))
print(M-len(s))
|
s091573843 | p03837 | u679520304 | 1590070173 | Python | Python (3.4.3) | py | Runtime Error | 20 | 3064 | 499 | N,M = map(int,input().split())
start = []
goal = []
data = []
for _ in range(M):
a,b,c = map(int,input().split())
start.append(a)
goal.append(b)
data.append(c)
csr = csr_matrix((data,(start,goal)),shape=(N+1,N+1))
p,q = floyd_warshall(csr,directed=False,return_predecessors=True)
d=[[True]*N for _ in range(N)]
for i in range(1,N+1):
for k,v in enumerate(q[i]):
if v != -9999:
d[i-1][v-1]=False
d[v-1][i-1]=False
print(sum([sum(i) for i in d])//2) |
s699886861 | p03837 | u132687480 | 1589888052 | Python | Python (3.4.3) | py | Runtime Error | 521 | 3700 | 1395 | N, M = map(int, input().split())
A = [0]*M
B = [0]*M
C = [0]*M
for i in range(M):
A[i], B[i], C[i] = map(int, input().split())
import heapq
def dijkstra(graph, start, goal):
path = [start]
score = 0
searching_heap = []
checked = {start: score}
heapq.heappush(searching_heap, (score, path))
while(len(searching_heap) > 0):
score, path = heapq.heappop(searching_heap)
latest_pos = path[-1]
if(latest_pos == goal):
return path, score
for next_pos, weight in graph[latest_pos].items():
new_path = path + [next_pos]
new_score = score + weight
if(next_pos in checked and checked[next_pos] <= new_score):
continue
else:
checked[next_pos] = new_score
heapq.heappush(searching_heap, (new_score, new_path))
import copy
def Main(N, M, A, B, C):
g = {}
for i in range(M):
if A[i] not in g:
g[A[i]] = {}
if B[i] not in g:
g[B[i]] = {}
g[A[i]].update({B[i]:C[i]})
g[B[i]].update({A[i]:C[i]})
ans = 0
for i in range(1, N):
for j in range(i+1, N+1):
path, score = dijkstra(g, i, j)
if len(path) > 2 and score < g[i][j]:
ans += 1
return ans
print(Main(N, M, A, B, C)) |
s434949834 | p03837 | u977193988 | 1588886513 | Python | PyPy3 (2.4.0) | py | Runtime Error | 213 | 40560 | 1130 | import sys
def input():
return sys.stdin.readline().strip()
sys.setrecursionlimit(20000000)
def main():
N, M = map(int, input().split())
S = []
d = [[float("inf")] * N for _ in range(N)]
L = []
for i in range(M):
a, b, c = map(int, input().split())
d[a - 1][b - 1] = c
d[b - 1][a - 1] = c
if a < b:
L.append((a - 1, b - 1))
else:
L.append(b - 1, a - 1)
for i in range(N):
d[i][i] = 0
L = set(L)
def warshall_floyd(d):
# d[i][j]: iからjへの最短距離
for k in range(N):
for i in range(N):
for j in range(N):
if d[i][j] > d[i][k] + d[k][j]:
d[i][j] = d[i][k] + d[k][j]
if i < j:
if (i, j) in L:
S.append((i, j))
else:
if (j, i) in L:
S.append((j, i))
return d
warshall_floyd(d)
print(len(set(S)))
if __name__ == "__main__":
main()
|
s286808398 | p03837 | u572343785 | 1588045483 | Python | Python (3.4.3) | py | Runtime Error | 580 | 3188 | 489 | N,M = map(int,input().split())
a = [0]*M
b = [0]*M
c = [0]*M
for i in range(M):
a[i],b[i],c[i] = map(int,input().split())
d = [[0]*N for i in range(N)]
for i in range(M):
d[a[i]-1][b[i]-1] = c[i]
d[b[i]-1][a[i]-1] = c[i]
for i in range(N):
for j in range(N):
for s in range(N):
d[i][j] = min(d[i][j], d[i][s]+d[s][j])
count = 0
for i in range(M):
d[i][i] = float("inf")
if d[a[i]-1][b[i]-1] != c[i]:
count += 1
print(count) |
s692959447 | p03837 | u572343785 | 1588045290 | Python | Python (3.4.3) | py | Runtime Error | 559 | 3188 | 488 | N,M = map(int,input().split())
a = [0]*M
b = [0]*M
c = [0]*M
for i in range(M):
a[i],b[i],c[i] = map(int,input().split())
d = [[0]*N for i in range(N)]
for i in range(M):
d[a[i]-1][b[i]-1] = c[i]
d[b[i]-1][a[i]-1] = c[i]
for s in range(N):
for i in range(N):
for j in range(N):
d[i][j] = min(d[i][j], d[i][s]+d[s][j])
count = 0
for i in range(N):
d[i][i] = float("inf")
if d[a[i]-1][b[i]-1] != c[i]:
count += 1
print(count) |
s235072922 | p03837 | u572343785 | 1588045064 | Python | Python (3.4.3) | py | Runtime Error | 559 | 3188 | 510 | N,M = map(int,input().split())
a = [0]*M
b = [0]*M
c = [0]*M
for i in range(M):
a[i],b[i],c[i] = map(int,input().split())
d = [[0]*N for i in range(N)]
for i in range(M):
d[a[i]-1][b[i]-1] = c[i]
d[b[i]-1][a[i]-1] = c[i]
for s in range(N):
for i in range(N):
for j in range(N):
d[i][j] = min(d[i][j], d[i][s]+d[s][j])
count = 0
for i in range(N):
d[i][i] = float("inf")
for j in range(N):
if c[i] > d[i][j]:
count += 1
print(count//2) |
s328902467 | p03837 | u572343785 | 1588044855 | Python | Python (3.4.3) | py | Runtime Error | 582 | 3188 | 490 | N,M = map(int,input().split())
a = [0]*M
b = [0]*M
c = [0]*M
for i in range(M):
a[i],b[i],c[i] = map(int,input().split())
d = [[0]*N for i in range(N)]
for i in range(M):
d[a[i]-1][b[i]-1] = c[i]
d[b[i]-1][a[i]-1] = c[i]
for s in range(N):
for i in range(N):
for j in range(N):
d[i][j] = min(d[i][j], d[i][s]+d[s][j])
count = 0
for i in range(M):
d[i][i] = float("inf")
if c[i] > d[a[i]-1][b[i]-1]:
count += 1
print(count) |
s530318420 | p03837 | u572343785 | 1588044632 | Python | Python (3.4.3) | py | Runtime Error | 554 | 3188 | 490 | N,M = map(int,input().split())
a = [0]*M
b = [0]*M
c = [0]*M
for i in range(M):
a[i],b[i],c[i] = map(int,input().split())
d = [[0]*N for i in range(N)]
for i in range(M):
d[a[i]-1][b[i]-1] = c[i]
d[b[i]-1][a[i]-1] = c[i]
for s in range(M):
for i in range(N):
for j in range(N):
d[i][j] = min(d[i][j], d[i][s]+d[s][j])
count = 0
for i in range(M):
d[i][i] = float("inf")
if c[i] > d[a[i]-1][b[i]-1]:
count += 1
print(count) |
s654139403 | p03837 | u843135954 | 1587010738 | Python | PyPy3 (2.4.0) | py | Runtime Error | 182 | 38740 | 1504 | import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()
class WarshallFloyd():
def __init__(self, N):
self.N = N
self.d = [[float("inf") for i in range(N)]
for i in range(N)] # d[u][v] : 辺uvのコスト(存在しないときは'inf')
def add(self, u, v, c, directed=False):
"""
0-indexedであることに注意
u = from, v = to, c = cost
directed = Trueなら、有向グラフである
"""
if directed is False:
self.d[u][v] = c
self.d[v][u] = c
else:
self.d[u][v] = c
def WarshallFloyd_search(self):
# これを d[i][j]: iからjへの最短距離 にする
# 本来無向グラフでのみ全域木を考えるが、二重辺なら有向でも行ける
for k in range(self.N):
for i in range(self.N):
for j in range(self.N):
self.d[i][j] = min(
self.d[i][j], self.d[i][k] + self.d[k][j])
for i in range(self.N):
self.d[i][i] = 0
return self.d
n,m = na()
g = WarshallFloyd(n)
abc = []
for i in range(m):
a,b,c = na()
g.add(a,b,c)
abc.append([a,b,c])
dp = g.WarshallFloyd_search()
ans = 0
for a,b,c in abc:
if dp[a][b] < c:
ans += 1
print(ans) |
s791976457 | p03837 | u107601154 | 1586728512 | Python | Python (3.4.3) | py | Runtime Error | 517 | 3608 | 765 | N,M = (int(x) for x in input().split())
a= [0]*1000
b = [0]*1000
c = [0]*1000
dist= [[0]*100 for i in range(100)]
for i in range(M):
a[i],b[i],c[i] = (int(x) for x in input().split())
for i in range(N):
for j in range(N):
if(i==j):
dist[i][j] = 0
else:dist[i][j] = float('inf')
for i in range(M):
dist[a[i]][b[i]] = min(dist[a[i]][b[i]],c[i])
dist[b[i]][a[i]] = min(dist[b[i]][a[i]],c[i])
for k in range(N):
for i in range(N):
for j in range(N):
dist[i][j] = min(dist[i][j],dist[i][k] + dist[k][j]);
ans = M
for i in range(M):
flag = 0
for j in range(N):
if(dist[j][a[i]]+c[i] == dist[j][b[i]]):
flag = 1
if(flag == 1):
ans -= 1
print(ans) |
s072272859 | p03837 | u139112865 | 1586311290 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3192 | 703 | #051_D
from heapq import heappop, heappush
inf = 10 ** 10
d = [[inf for _ in range(n)] for _ in range(n)]
for i in range(n):
d[i][i] = 0
n, m = map(int, input().split())
edges = []
for _ in range(m):
a, b, c = map(int, input().split())
d[a-1][b-1] = c
d[b-1][a-1] = c
edges.append((a-1, b-1))
def warshall_floyd(d):
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
warshall_floyd(d)
ans = 0
for u, v in edges:
for i in range(n):
if i == u or i == v:
continue
if d[u][i] + d[i][v] == d[u][v]:
ans += 1
break
print(ans) |
s844193191 | p03837 | u780962115 | 1584826724 | Python | Python (3.4.3) | py | Runtime Error | 434 | 3700 | 954 | # cadidates of no shortest paths
n, m = map(int, input().split())
d = [[float("inf") for i in range(n + 1)] for i in range(n + 1)]
edge_data=[]
connect={i:[] for i in range(1,n+1)}
for i in range(m):
x, y, z = map(int, input().split())
# 有向グラフか無向グラフかによってここで場合わけが生じる
d[x][y] = z
d[y][x] = z
connect[x].append(y)
connect[y].append(x)
edge_data.append((x,y,z))
for i in range(n + 1):
d[i][i] = 0 # 自身のところに行くコストは０
def warshall_floyd(d):
# d[i][j]=i番目の頂点からj番目の頂点までの最短距離
for k in range(1, n + 1):
for i in range(1, n + 1):
for j in range(1, n + 1):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
return d
warshall_floyd(d)
#最短距離を求めた
cnt=0
for some in edge_data:
x,y,zsome[0],some[1],some[2]
if d[x][y]<z:
cnt+=1
print(cnt)
|
s362857552 | p03837 | u059940903 | 1584084889 | Python | PyPy3 (2.4.0) | py | Runtime Error | 250 | 43372 | 514 | from copy import deepcopy
N, M = map(int, input().split())
graph = [[10000 for _ in range(N)] for l in range(N)]
for i in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
graph[b][a] = c
graph[a][b] = c
newGraph = deepcopy(graph)
for k in range(N):
for i in range(N):
for j in range(N):
graph[i][j] = min(graph[i][j], graph[i][k] + graph[k][j])
res = 0
for (i, row) in enumerate(newGraph):
for (j, weight) in row:
if (graph[i][j] != weight):
res += 1
print(res/2) |
s922623666 | p03837 | u964299793 | 1583809414 | Python | Python (3.4.3) | py | Runtime Error | 644 | 3380 | 633 | import sys
input=sys.stdin.readline
n,m=map(int,input().split())
a=[0]*n
b=[0]*n
c=[0]*n
for i in range(m):
a[i],b[i],c[i]=map(int,input().split())
a[i]-=1
b[i]-=1
INF=float('inf')
dist=[ [INF]*n for _ in range(n)]
for i in range(n):
dist[i][i]=0
for i in range(m):
dist[a[i]][b[i]]=c[i]
dist[b[i]][a[i]]=c[i]
#floyd warshall
for k in range(n):
for i in range(n):
for j in range(n):
dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j])
ans=m
for i in range(m):
shortest=False
for j in range(n):
if dist[j][a[i]]+c[i]==dist[j][b[i]]:
shortest=True
break
if shortest:
ans-=1
print(ans)
|
s275444833 | p03837 | u964299793 | 1583809088 | Python | Python (3.4.3) | py | Runtime Error | 560 | 3380 | 597 | n,m=map(int,input().split())
a=[0]*n
b=[0]*n
c=[0]*n
for i in range(m):
a[i],b[i],c[i]=map(int,input().split())
a[i]-=1
b[i]-=1
INF=float('inf')
dist=[ [INF]*n for _ in range(n)]
for i in range(n):
dist[i][i]=0
for i in range(m):
dist[a[i]][b[i]]=c[i]
dist[b[i]][a[i]]=c[i]
#floyd warshall
for k in range(n):
for i in range(n):
for j in range(n):
dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j])
ans=m
for i in range(m):
shortest=False
for j in range(n):
if dist[j][a[i]]+c[i]==dist[j][b[i]]:
shortest=True
break
if shortest:
ans-=1
print(ans)
|
s004702084 | p03837 | u223904637 | 1583193693 | Python | PyPy3 (2.4.0) | py | Runtime Error | 200 | 39280 | 604 | import heapq
n,m=map(int,input().split())
g=[[] for i in range(n)]
p=[]
for i in range(m):
a,b,c=map(int,input().split())
a-=1
b-=1
p.append([a,b,c])
g[a].append([c,b])
g[b].append([c,a])
ans=0
for i in range(m):
s=p[i][0]
goal=p[i][1]
c=p[i][2]
q=[]
heapq.heappush(q,[0,s])
v=[-1]*n
v[s]=0
while q:
p=heapq.heappop(q)
if p[1]==goal:
break
for i in g[p[1]]:
if v[i[1]]==-1:
v[i[1]]=i[0]+v[p[1]]
heapq.heappush(q,[v[i[1]],i[1]])
if p[0]<c:
ans+=1
print(ans) |
s057785619 | p03837 | u368796742 | 1582406591 | Python | Python (3.4.3) | py | Runtime Error | 2104 | 3828 | 1227 | import sys
input = sys.stdin.readline
from collections import deque
import copy
n,m = map(int,input().split())
r = [[] for i in range(n)]
for i in range(m):
a,b,c = map(int,input().split())
r[a-1].append((b-1,c,i+1))
r[b-1].append((a-1,c,i+1))
def bfs(x,y):
q = deque([])
l = [-1]*n
l[x] = 0
check =[[] for i in range(n)]
q.append((x,0,[]))
while q:
bef,pas,rec = q.popleft()
if bef == y:
break
for nex,c,num in r[bef]:
rec2 = copy.deepcopy(rec)
rec2.append(num)
if l[nex] == -1:
l[nex] = pas+c
check[nex] = rec2
q.append((nex,pas+c,rec2))
else:
if pas+c < l[nex]:
l[nex] = pas+c
check[nex] = rec2
elif pas+c == l[nex]:
check[nex].append(rec2)
else:
continue
return check[y]
ans = set()
for i in range(n):
for j in range(n):
for k in bfs(i,j):
ans.add(k)
if len(ans) == m:
print(0)
exit()
print(m-len(ans))
|
s204905302 | p03837 | u326552320 | 1582268742 | Python | Python (3.4.3) | py | Runtime Error | 152 | 12420 | 1520 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# FileName: D_fix
# CreatedDate: 2020-02-21 01:20:19 +0900
# LastModified: 2020-02-21 02:04:42 +0900
#
import os
import sys
import numpy as np
import pandas as pd
def make_matrix(matrix,a,b,c):
matrix[a-1][b-1] = c
matrix[b-1][a-1] = c
def initial_signal(i,matrix):
d = [100]*(matrix.shape[0])
d[i] = 0
Q = []
for j in range(matrix.shape[0]):
Q.append([j,100])
Q[i][1]=0
Q.sort()
return d,Q
def relax(matrix,u,v,d,Q):
if d[v] > d[u[0]]+matrix[u[0]][v]:
d[v] = d[u[0]]+matrix[u[0]][v]
for i,tmp in enumerate(Q):
if Q[i][0]==v:
Q[i][1] = d[u[0]]+matrix[u[0]][v]
def dijkstra(i,matrix):
d,Q = initial_signal(i,matrix)
S = []
while Q:
Q.sort(key=lambda x: x[1])
u = Q.pop(0)
S.append(u)
for v in range(matrix.shape[0]):
if matrix[u[0]][v]!=0:
relax(matrix,u,v,d,Q)
return d
def main():
N,M = map(int, input().split())
matrix = np.zeros((N,N),dtype=np.int32)
for _ in range(M):
a,b,c = map(int,input().split())
make_matrix(matrix,a,b,c)
shortest = []
for i in range(matrix.shape[0]):
short = dijkstra(i,matrix)
shortest.append(short)
ans=0
for i in range(N):
for j in range(N):
cost = matrix[i][j]
if cost>shortest[i][j]:
ans+=1
print(ans//2)
if __name__ == "__main__":
main()
|
s240412850 | p03837 | u808806124 | 1581756176 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 448 | n, m = map(int, input().split())
d = np.ones((n, n)) * 1001
es = []
for i in range(m):
es.append(list(map(int, input().split())))
for (i, j, w) in es:
d[i - 1][j - 1] = w
d[j - 1][i - 1] = w
for k in range(n):
for i in range(n):
for j in range(n):
l = d[i][k] + d[k][j]
if d[i][j] > l:
d[i][j] = l
c = 0
for (i, j, w) in es:
if d[i - 1][j - 1] < w:
c += 1
print(c)
|
s792520521 | p03837 | u476604182 | 1581741161 | Python | PyPy3 (2.4.0) | py | Runtime Error | 320 | 45148 | 659 | from collections import defaultdict
from heapq import heappush, heappop
N, M = map(int, input().split())
dic = defaultdict(list)
Els = []
for i in range(M):
a, b, c = map(int, input().split())
dic[a-1] += [(b-1,c)]
dic[b-1] += [(a-1, c)]
Els += [(a,b,c)]
def dijkstra(s,e):
dist = [float('inf')]*N
dist[s] = 0
q = [(0,s)]
z = -1
while q:
c, v = heappop(q)
if dist[v]<c:
continue
dist[v] = c
for u, m in dic[v]:
if dist[u]>dist[v]+m:
dist[u] = dist[v]+m
heappush(q,(dist[v],v))
if u==e:
z = v
return z
ans = 0
for a, b, c in Els:
if dijkstra(a,b)==a:
ans += 1
print(ans) |
s140792643 | p03837 | u311379832 | 1581292459 | Python | Python (3.4.3) | py | Runtime Error | 376 | 24788 | 549 | from scipy.sparse.csgraph import dijkstra
INF = 10 ** 18
N, M = map(int, input().split())
d = [[INF for _ in range(N)] for _ in range(N)]
abc = []
for i in range(M):
a, b, c = map(int, input().split())
abc.append([a - 1, b - 1, c])
d[a - 1][b - 1] = c
d[b - 1][a - 1] = c
dtra = dijkstra(d)
minlst = [INF] * N
for i in range(N):
for j in range(N):
if dtra[i][j] != 0:
minlst[i] = min(minlst[i], dtra[i][j])
cnt = 0
for i in range(M):
if int(minlst[abc[i][1]]) < abc[i][2]:
cnt += 1
print(cnt) |
s764392572 | p03837 | u311379832 | 1581292446 | Python | PyPy3 (2.4.0) | py | Runtime Error | 172 | 38516 | 549 | from scipy.sparse.csgraph import dijkstra
INF = 10 ** 18
N, M = map(int, input().split())
d = [[INF for _ in range(N)] for _ in range(N)]
abc = []
for i in range(M):
a, b, c = map(int, input().split())
abc.append([a - 1, b - 1, c])
d[a - 1][b - 1] = c
d[b - 1][a - 1] = c
dtra = dijkstra(d)
minlst = [INF] * N
for i in range(N):
for j in range(N):
if dtra[i][j] != 0:
minlst[i] = min(minlst[i], dtra[i][j])
cnt = 0
for i in range(M):
if int(minlst[abc[i][1]]) < abc[i][2]:
cnt += 1
print(cnt) |
s361851437 | p03837 | u342869120 | 1581100906 | Python | PyPy3 (2.4.0) | py | Runtime Error | 170 | 38384 | 739 | import copy
N, M = map(int, input().split())
dp = [[float('inf')]*N for _ in range(N)]
for i in range(N):
dp[i][i] = 0
for i in range(M):
a, b, c = map(int, input().split())
dp[a-1][b-1] = c
dp[b-1][a-1] = c
g = copy.deepcopy(dp)
# ワーシャルフロイド
for k in range(N):
for i in range(N):
for j in range(N):
dp[i][j] = min([dp[i][j], dp[i][k]+dp[k][j]])
# 経路復元
p = {}
for i in range(N):
for j in range(i+1, N):
c = i
while c != j:
for k in range(N):
if k != c and (g[c][k]+dp[k][j]) == dp[c][j]:
p[(c, k) if c < k else (k, c)] = 1
c = k
break
print(max([0, M-len(p)))
|
s002849271 | p03837 | u342869120 | 1581100882 | Python | PyPy3 (2.4.0) | py | Runtime Error | 167 | 38384 | 734 | import copy
N, M = map(int, input().split())
dp = [[float('inf')]*N for _ in range(N)]
for i in range(N):
dp[i][i] = 0
for i in range(M):
a, b, c = map(int, input().split())
dp[a-1][b-1] = c
dp[b-1][a-1] = c
g = copy.deepcopy(dp)
# ワーシャルフロイド
for k in range(N):
for i in range(N):
for j in range(N):
dp[i][j] = min([dp[i][j], dp[i][k]+dp[k][j]])
# 経路復元
p = {}
for i in range(N):
for j in range(N):
c = i
while c != j:
for k in range(N):
if k != c and (g[c][k]+dp[k][j]) == dp[c][j]:
p[(c, k) if c < k else (k, c)] = 1
c = k
break
print(max([0, M-len(p)))
|
s303840888 | p03837 | u905582793 | 1580711895 | Python | PyPy3 (2.4.0) | py | Runtime Error | 170 | 38384 | 684 | from itertools import combinations
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import floyd_warshall
import sys
input = sys.stdin.readline
n,m = map(int,input().split())
abc = [list(map(int,input().split())) for i in range(m)]
abc = [[abc[i][0]-1,abc[i][1]-1,abc[i][2]] for i in range(m)]
graph = [[] for i in range(n+1)]
for a,b,c in abc:
graph[a].append((b,c))
graph[b].append((a,c))
v1,v2,edge = zip(*abc)
csr = csr_matrix((edge,(v1,v2)),shape = (n,n))
dist = floyd_warshall(csr, directed = False)
ans = 0
for i,j in combinations(range(n),2):
fs1,fs2 = zip(*graph[i])
if j in fs1:
x = fs1.index(j)
if fs2[x] > dist[i][j]:
ans += 1
print(ans) |
s955247638 | p03837 | u373958718 | 1579020981 | Python | Python (3.4.3) | py | Runtime Error | 546 | 3316 | 561 | n,m=map(int,input().split())
l=[list(map(int,input().split()))for i in range(m)]
dist=[[1<<29]*n for i in range(n)]
for i in range(m): dist[i][i]=0
for a in l:
dist[a[0]-1][a[1]-1] = min(dist[a[0]-1][a[1]-1],a[2])
dist[a[1]-1][a[0]-1] = min(dist[a[1]-1][a[0]-1],a[2])
# print(dist)
for k in range(n):
for i in range(n):
for j in range(n):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
# 経路復元
ans=m
for a in l:
flag=False
for j in range(n):
if dist[j][a[0]-1]+a[2]==dist[j][a[1]-1]: flag=True
if flag: ans-=1
print(ans) |
s035128439 | p03837 | u373958718 | 1579020821 | Python | Python (3.4.3) | py | Runtime Error | 570 | 3316 | 547 | n,m=map(int,input().split())
l=[list(map(int,input().split()))for i in range(m)]
dist=[[1<<29]*n for i in range(n)]
for i in range(m): dist[i][i]=0
for a in l:
dist[a[0]-1][a[1]-1] = min(dist[a[0]-1][a[1]-1],a[2])
dist[a[1]-1][a[0]-1] = min(dist[a[1]-1][a[0]-1],a[2])
for k in range(n):
for i in range(n):
for j in range(n):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
# 経路復元
ans=m
for a in l:
flag=False
for j in range(n):
if dist[j][a[0]-1]+a[2]==dist[j][a[1]-1]: flag=True
if flag: ans-=1
print(ans) |
s215460291 | p03837 | u594244257 | 1578508568 | Python | Python (3.4.3) | py | Runtime Error | 234 | 3572 | 974 | MAX_D = 10**9
def solve():
N,M = map(int, input().split())
d = [[MAX_D]*N for _ in range(N)]
edges = [[False]*N for _ in range(N)]
base_edge = {}
for _ in range(M):
a,b,c = map(int, input().split())
edges[a-1][b-1] = True
edges[b-1][a-1] = True
d[a-1][b-1] = c
d[b-1][a-1] = c
base_edge[(a-1,b-1)] = c
base_edge[(b-1,a-1)] = c
# ワーシャルフロイド法
for k in range(N):
for i in range(N):
for j in range(N):
if i != j and d[i][j] > d[i][k]+d[k][j]:
# print(i+1,k+1,j+1, d[i][j], d[i][k], d[k][j])
edges[i][j] = False
if base_edge[(i,k)] == d[i][k]: edges[i][k] = True
if base_edge[(k,j)] == d[k][j]: edges[k][j] = True
d[i][j] = d[i][k]+d[k][j]
# print(edges)
print(M - sum(map(sum, edges))//2)
solve() |
s586855957 | p03837 | u940139461 | 1577391260 | Python | Python (3.4.3) | py | Runtime Error | 20 | 3316 | 874 | N, M = map(int, input().split())
graph = [[float('infinity') for _ in range(N + 1)] for _ in range(N + 1)]
for _ in range(M):
a, b, c = map(int, input().split())
graph[a][b] = c
graph[b][c] = c
ans = 0
# 頂点g -> 頂点vへのコストを計算する。直接のpathが最小なら、カウントしない。
# そうでなければ、他の経路があるので、カウントする。
for g in range(1, len(graph)):
for v in range(1, N + 1):
if g == v:
continue
paths = graph[g]
direct = paths[v]
if direct == float('infinity'):
continue
min_path = float('infinity')
for i in range(len(paths)):
p = paths[i]
cost = p + graph[i][v]
if min_path > cost:
min_path = cost
if direct > min_path:
ans += 1
print(ans)
|
s161860862 | p03837 | u945181840 | 1576346116 | Python | Python (3.4.3) | py | Runtime Error | 1695 | 29068 | 599 | import sys
from scipy.sparse.csgraph import shortest_path
from scipy.sparse import csr_matrix
from itertools import combinations
read = sys.stdin.read
N, M, *abc = map(int, read().split())
a, b, c = zip(*zip(*[iter(abc)] * 3))
graph = csr_matrix((c, (a, b)), shape=(N + 1, N + 1))
distance = shortest_path(graph, directed=False)
answer = 0
for i, j in zip(a, b):
for s in range(1, N + 1):
if distance[i][j] + distance[j][s] == distance[i][s]:
continue
if distance[j][i] + distance[i][s] == distance[j][s]:
continue
answer += 1
print(answer) |
s264448894 | p03837 | u698919163 | 1575173308 | Python | Python (3.4.3) | py | Runtime Error | 640 | 3316 | 598 | N,M = list(map(int,input().split()))
abc = []
abc = [list(map(int,input().split())) for i in range(M)]
A=[]
B=[]
C=[]
dist=[[1000]*N for i in range(N)]
for i in range(M):
A.append(abc[i][0])
B.append(abc[i][1])
C.append(abc[i][2])
for i in range(N):
dist[A[i]-1][B[i]-1] = C[i]
dist[B[i]-1][A[i]-1] = C[i]
for i in range(N):
for j in range(N):
for k in range(N):
dist[i][j] = min(dist[i][j],dist[i][k]+dist[k][j])
count = 0
for i in range(N):
if dist[abc[i][0]-1][abc[i][1]-1] != abc[i][2]:
count+=1
print(count) |
s568730123 | p03837 | u879870653 | 1574178261 | Python | Python (3.4.3) | py | Runtime Error | 176 | 13952 | 528 | import sys
input = sys.stdin.readline
from scipy.sparse.csgraph import csgraph_from_dense, dijkstra
n,m = map(int,input().split())
A = [0]*n
B = [0]*n
C = [0]*n
for i in range(m) :
a, b, c = map(int,input().split())
A[i] = a-1
B[i] = b-1
C[i] = c
graph = [[0]*n for i in range(n)]
for i in range(m) :
graph[A[i]][B[i]] = C[i]
graph[B[i]][A[i]] = C[i]
graph = csgraph_from_dense(graph)
dist = dijkstra(graph)
ans = 0
for i in range(m) :
if dist[A[i]][B[i]] != C[i] :
ans += 1
print(ans)
|
s721488595 | p03837 | u879870653 | 1574178232 | Python | Python (3.4.3) | py | Runtime Error | 257 | 17048 | 490 | from scipy.sparse.csgraph import csgraph_from_dense, dijkstra
n,m = map(int,input().split())
A = [0]*n
B = [0]*n
C = [0]*n
for i in range(m) :
a, b, c = map(int,input().split())
A[i] = a-1
B[i] = b-1
C[i] = c
graph = [[0]*n for i in range(n)]
for i in range(m) :
graph[A[i]][B[i]] = C[i]
graph[B[i]][A[i]] = C[i]
graph = csgraph_from_dense(graph)
dist = dijkstra(graph)
ans = 0
for i in range(m) :
if dist[A[i]][B[i]] != C[i] :
ans += 1
print(ans)
|
s121206863 | p03837 | u879870653 | 1574131658 | Python | Python (3.4.3) | py | Runtime Error | 243 | 17188 | 595 | from scipy.sparse.csgraph import dijkstra
n,m = map(int,input().split())
edges = [[int(x) for x in input().split()] for i in range(m)]
graph = [[None]*n for i in range(n)]
for a, b, c in edges :
graph[a-1][b-1] = c
#graph = csgraph_from_dense(graph)
dist = dijkstra(graph, directed=True).astype(int)
used = [0]*m
for s in range(n-1) :
for t in range(s+1, n) :
for i in range(len(edges)) :
a, b, c = edges[i]
a -= 1
b -= 1
if dist[s][a] + c + dist[b][t] == dist[s][t] :
used[i] = 1
ans = m - sum(used)
print(ans)
|
s522827234 | p03837 | u879870653 | 1574130446 | Python | Python (3.4.3) | py | Runtime Error | 303 | 17952 | 585 | from scipy.sparse.csgraph import *
n,m = map(int,input().split())
edges = [[int(x) for x in input().split()] for i in range(m)]
graph = [[0]*n for i in range(n)]
for a, b, c in edges :
graph[a-1][b-1] = c
graph = csgraph_from_dense(graph)
dist = dijkstra(graph, directed=False).astype(int)
used = [0]*m
for s in range(n-1) :
for t in range(s+1, n) :
for i in range(len(edges)) :
a, b, c = edges[i]
a -= 1
b -= 1
if dist[s][a] + c + dist[b][t] == dist[s][t] :
used[i] = 1
ans = m - sum(used)
print(ans)
|
s997243731 | p03837 | u638795007 | 1573428427 | Python | Python (3.4.3) | py | Runtime Error | 35 | 3956 | 941 | def examD():
N, M = LI()
D = [[float("inf") for i in range(N)] for i in range(N)]
# d[u][v] : 辺uvのコスト(存在しないときはinf)
XY = [[0,0]]*M
for i in range(M):
x, y, z = map(int, input().split())
XY[i] = [x-1,y-1]
D[x - 1][y - 1] = z
D[y - 1][x - 1] = z
for i in range(N):
D[i][i] = 0 # 自身のところに行くコストは０
d = copy.deepcopy(D)
# print(warshall_floyd(N, d))
W = warshall_floyd(N, d)
cur = int(0)
for i in range(M):
if D[XY[i][0]][XY[i][1]]>W[XY[i][0]][XY[i][1]]:
cur += 1
print(cur)
import sys
import copy
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')
examD()
|
s051420292 | p03837 | u562935282 | 1572584182 | Python | PyPy3 (2.4.0) | py | Runtime Error | 164 | 38256 | 819 | from heapq import heappop, heappush
from math import inf
def dijkstra_need_edge(s):
used = [False] * n
used[s] = True
dist = [inf] * n
dist[s] = 0
hq = []
for e in g[s]:
heappush(hq, e)
need_edge = set()
while hq:
w, t, ind = heappop(hq)
if used[t]: continue
need_edge.add(ind)
used[t] = True
dist[t] = w
add_es = map(lambda x: (dist[t] + x[0], x[1], x[2]), g[t])
for e in add_es:
heappush(hq, e)
return need_edge
n, m = map(int, input().split())
g = tuple(set() for _ in range(n))
for ind in range(m):
a, b, c = map(int, input().split())
a -= 1
b -= 1
g[a].add((c, b, ind))
g[b].add((c, a, ind))
st = set()
for v in range(n):
st |= dijkstra_need_edge(v)
print(m - len(st))
|
s194249502 | p03837 | u564837886 | 1571806794 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3060 | 176 | sx, sy, tx, ty = map(int, input().split())
X, Y = tx-sx, ty-sy
ans = 'R'*X + 'U'*Y + 'L'*X + 'D'*Y + 'D' + 'R'*(X+1) + 'U'*(Y+1) + 'LU' + 'L'*(X+1) + 'D'*(Y+1) + 'R'
print(ans) |
s349011426 | p03837 | u118642796 | 1571447564 | Python | PyPy3 (2.4.0) | py | Runtime Error | 181 | 38256 | 407 | N,M=map(int,input().split())
INF = 10**5
D=[[INF]*N for _ in range(N)]
for i in range(N):
D[i][i]=0
path=[]
for i in range(M):
a,b,c = map(int,input().split())
D[a][b]=c
D[b][a]=c
path.append([a,b,c])
for k in range(N):
for i in range(N-1):
for j in range(i+1,N):
D[i][j]=min(D[i][j],D[i][k]+D[j][k])
D[j][i]=D[i][j]
ans=0
for a,b,c in path:
if D[a][b]>c:
ans+=1
print(ans) |
s675486617 | p03837 | u437727817 | 1570310027 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3064 | 452 | n,m = map(int,input().split())
dist = []
a = []
b = []
c = []
for i in range(m):
a[i], b[i], c[i] = map(int,input().split())
dist[a[i]-1][b[i]-1] = c[i]
dist[b[i]-1][a[i]-1] = c[i]
#nは頂点、mは辺、a、bは頂点、cはaとbの距離
for i in range(n):
for j in range(n):
for k in range(n):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
res = 0
for i in range(m):
if c[i] > dist[a[i]-1][b[i]-1]:
res += 1
print (res)
|
s393703925 | p03837 | u924374652 | 1570067745 | Python | Python (3.4.3) | py | Runtime Error | 19 | 3188 | 1108 | import heapq
def dijkstra(graph, node, start):
INF = float("inf")
dist = [INF] * node
dist[start] = 0
que = [(0, start)]
while que:
cost, one_node = heapq.heappop(heap)
for next_c, next_n in graph[one_node]:
dist_candi = dist[one_node] + next_c
if dist_candi < dist[next_n]:
dist[next_node] = dist_candi
heapq.heappush(heap, (dist[next_n], next_n))
return dist
class SetGraph:
def __init__(self, node_num):
self.graph = [[] for _ in range(node_num)]
def add_one_edge(self, start, end, cost):
self.graph[start].append((cost, end))
self.graph[end].append((cost, start))
def get_graph(self):
return self.graph
n, m = map(int, input().split(" "))
graph = SetGraph(n)
add_process = SetGraph.add_one_edge
for i in range(m):
a, b, c = map(int, input().split(" "))
add_process(a - 1, b - 1, c)
graph = Graph.get_graph()
cost = []
for i in range(n):
temp_cost = dijkstra(graph, n, i)
cost.append(temp_cost)
result = 0
for i in range(n):
for c, node in graph[i]:
if cost[i][node] != c:
result += 1
print(result // 2) |
s958460238 | p03837 | u714378447 | 1568667937 | Python | PyPy3 (2.4.0) | py | Runtime Error | 173 | 38384 | 781 | from queue import Queue
N,M=map(int,input().split())
G=[[] for i in range(N)]
for i in range(M):
a,b,c=map(int,input().split())
G[a-1].append([b-1,c])
G[b-1].append([a-1,c])
T=[[1000]*N for i in range(N)]
U=[[[]for i in range(N)] for i in range(N)]
for i in range(N):
q=Queue()
seen=[False]*N
q.put([i,0,[i]])
seen[i]=True
while not(q.empty()):
t,d,u=q.get()
seen[t]=True
if T[i][t]>d:
T[i][t]=d
U[i][t]=u
T[t][i]=d
U[t][i]=u
for x,c in G[t]:
if seen[x]==False:
q.put([x,d+c,[*u,x]])
A=[[False]*N for i in range(N)]
for i in range(N-1):
for j in range(i+1,N):
u=U[i][j]
for k in range(len(u)-1):
a,b=min(u[k],u[k+1]),max(u[k],u[k+1])
A[a][b]=True
ans=M
for i in range(N-1):
for j in range(i+1,N):
ans-=int(A[i][j])
print(ans) |
s017815943 | p03837 | u499381410 | 1568572024 | Python | PyPy3 (2.4.0) | py | Runtime Error | 203 | 38896 | 1444 | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from functools import reduce
from scipy.sparse.csgraph import floyd_warshall, csgraph_from_dense
INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n, m = LI()
graph = [[INF] * n for _ in range(n)]
for i in range(n):
graph[i][i] = 0
for a, b, c in LIR(m):
graph[a - 1][b - 1] = c
graph[b - 1][a - 1] = c
dist = [[graph[i][j] for j in range(n)] for i in range(n)]
for i in range(n):
for j in range(n):
for k in range(n):
dist[j][k]=min(dist[j][i]+dist[i][k], dist[j][k])
cnt = 0
for i in range(n):
for j in range(i, n):
if graph[i][j] != INF and graph[i][j] > dist[i][j]:
cnt += 1
print(cnt) |
s180417784 | p03837 | u673361376 | 1567040924 | Python | Python (3.4.3) | py | Runtime Error | 26 | 3692 | 1265 | from collections import defaultdict, deque
def solve(graph, edges, n, start_idx):
flg = [False for _ in range(n)] #未検索のノードはFlase
flg[start_idx] = True
cost = [float('inf') for _ in range(n)]
cost[start_idx] = 0
prv_edges = [None for _ in range(n)]
prv_node = start_idx
while not all(flg):
for node, dis in graph[prv_node]:
if cost[node] > dis:
cost[node] = dis
tmp_edge = sorted([prv_node, node])
if tmp_edge in edges:
edges.remove(tmp_edge)
if prv_edges[node] is not None and prv_edges[node] not in edges:
edges.append(prv_edges[node])
prv_edges[node] = tmp_edge
min_cost = float('inf')
tmp_idx = -1
for i in range(n):
if flg[i] is False and min_cost > cost[i]:
min_cost = cost[i]
tmp_idx = i
prv_node = tmp_idx
flg[prv_node] = True
#print(start_idx, prv_node, cost, edges, prv_edges)
return edges
n, m = map(int, input().split())
graph = defaultdict(list)
edges = []
for i in range(m):
a,b,c = map(int, input().split())
graph[a-1].append([b-1,c])
graph[b-1].append([c-1,c])
edges.append(sorted([a-1,b-1]))
for i in range(n):
edges = solve(graph, edges, n, i)
print(len(edges)) |
s269822174 | p03837 | u820047642 | 1567023356 | Python | PyPy3 (2.4.0) | py | Runtime Error | 185 | 38480 | 1176 | import heapq,math,sys
input=sys.stdin.readline
INF=math.inf
heappush=heapq.heappush
heappop=heapq.heappop
n,m=map(int,input().split())
graph=[[] for _ in range(n)]
minway=[]
bridges=[]
ans=0
for _ in range(m):
a,b,c=map(int,input().split())
graph[a-1].append((b-1,c))
graph[b-1].append((a-1,c))
bridges.append((a-1,b-1))
def dijkstra(graph,n,start):
Q=[]
distance=[]
dappend=distance.append
for i in range(n):
dappend([INF,i])
distance[start][0]=0
for j in distance:
heappush(Q,j)
while Q!=[]:
q=heappop(Q)
for v,vl in graph[q[1]]:
alt=vl+q[0]
if alt<distance[v][0]:
distance[v][0]=alt
heappush(Q,[alt,v])
return distance
for k in range(n):
minway.append(dijkstra(graph,n,k))
for l in bridges:
flag=0
x,y=l[0],l[1]
for p in graph[x]:
if p!=y:
if minway[x][p[0]][0]+minway[x][y][0]==minway[p[0]][y][0]:
flag=1
for q in graph[y]:
if q!=x:
if minway[x][y][0]+minway[y][q[0]][0]==minway[x][q[0]][0]:
flag=1
if flag==0:
ans+=1
print(ans) |
s552136193 | p03837 | u484229314 | 1565648137 | Python | PyPy3 (2.4.0) | py | Runtime Error | 254 | 42604 | 747 | N, M = [int(_) for _ in input().split()]
INF = 10 ** 10
costs = [[INF] * 101 for _ in range(101)]
for i in range(N + 1):
costs[i][i] = 0
paths = []
for i in range(M):
a, b, c = [int(_) for _ in input().split()]
costs[a][b] = c
costs[b][a] = c
paths.append((a, b, c))
for k in range(N + 1):
for i in range(N + 1):
for j in range(N + 1):
costs[i][j] = min(costs[i][j], costs[i][k] + costs[j][k])
costs[j][i] = costs[i][j]
for i in range(N):
paths2 = paths.copy()
for p in paths:
# 点i から 経路p をつかってp[1]への経路をもつかチェック
if costs[i][p[0]] + p[2] == costs[i][p[1]]:
paths2.remove(p)
paths = paths2
print(len(paths)) |
s381793332 | p03837 | u813102292 | 1563587641 | Python | Python (3.4.3) | py | Runtime Error | 21 | 3316 | 721 | N, M = map(int, input().split())
INF = 10**9
edges = []
for i in range(M):
edges.append(list(map(int, input().split())))
dist = [[INF for j in range(N)] for i in range(N)]
for i in range(N):
dist[i][i] = 0
for i in range(M):
a, b, c = edges[i]
a, b = a - 1, b - 1
dist[a][b] = c[i]
dist[b][a] = c[i]
for k in range(N):
for i in range(N):
for j in range(N):
dist[i][j] = min(dist[i][k] + dist[k][j], dist[i][j])
res = M
for i in range(M):
a, b, c = edges[i]
a, b = a - 1, b - 1
shortest = False
for j in range(N):
if dist[j][a] + c == dist[j][b]:
shortest = True
break
if shortest:
res -= 1
print(res)
|
s390080903 | p03837 | u813102292 | 1563587535 | Python | Python (3.4.3) | py | Runtime Error | 21 | 3316 | 700 | N, M = map(int, input().split())
INF = 10**9
edges = []
for i in range(M):
edges.append(list(map(int, input().split())))
dist = [[INF for j in range(N)] for i in range(N)]
for i in range(N):
dist[i][i] = 0
for i in range(M):
a, b, c = edges[i]
a, b = a - 1, b - 1
dist[a][b] = c[i]
dist[b][a] = c[i]
for k in range(N):
for i in range(N):
for j in range(N):
dist[i][j] = min(dist[i][k] + dist[k][j], dist[i][j])
res = M
for i in range(M):
a, b, c = edges[i]
a, b = a - 1, b - 1
shortest = False
for j in range(N):
if dist[j][a] + c == dist[j][b]:
shortest = True
break
res -= 1
print(res)
|
s410440370 | p03837 | u144980750 | 1562685634 | Python | PyPy3 (2.4.0) | py | Runtime Error | 184 | 39792 | 230 | s=input()
k=int(input())
ans=[]
for i in range(len(s)):
for j in range(i+1,len(s)+1):
ans.append(s[i:j])
ans.sort()
a=[ans[0]]
for i in range(1,len(ans)):
if ans[i-1]!=ans[i]:
a.append(ans[i])
print(a[k-1]) |
s179824173 | p03837 | u731028462 | 1562185296 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3064 | 658 | g = Graph()
N,M = list(map(int, input().split()))
INF = 10**9+7
A = [[INF if i!=j else 0 for i in range(N)] for j in range(N)]
S=[]
E=[]
W=[]
for i in range(M):
s,e,w=list(map(int,input().split()))
g.add_edge(s-1, e-1, w)
g.add_edge(e-1, s-1, w)
S.append(s-1)
E.append(e-1)
W.append(w)
for i in range(N):
d = Dijkstra(g, i)
for j in range(i+1,N):
dist = d.shortest_distance(j)
A[i][j] = dist
A[j][i] = dist
ans=M
for i in range(M):
shortest = False
for j in range(N):
if A[j][S[i]] + W[i] == A[j][E[i]]:
shortest = True
if shortest:
ans-=1
print(ans) |
s878106621 | p03837 | u900045983 | 1562126246 | Python | Python (3.4.3) | py | Runtime Error | 154 | 12500 | 1365 | import numpy as np
import copy
from collections import defaultdict
from heapq import heappush, heappop
def djkstra(adj_mat, src):
dist = defaultdict(lambda: np.inf)
dist[src] = 0
prev = defaultdict(lambda: None)
queue = []
heappush(queue, (dist[src], src))
while len(queue) > 0:
dist_u, u = heappop(queue)
vs = np.argwhere(adj_mat[u] > 0).flatten()
for v in vs:
weight = adj_mat[u, v]
alt = dist_u + weight
if alt < dist[v]:
dist[v] = alt
prev[v] = u
heappush(queue, (alt, v))
visited_edges = np.zeros_like(adj_mat, dtype=np.int32)
for v in range(adj_mat.shape[0]):
u = prev[v]
if u is not None:
visited_edges[u, v] = 1
visited_edges[v, u] = 1
return visited_edges
def main():
N, M = map(int, input().split())
adj_mat = np.zeros((N, N), dtype=np.int32)
for _ in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
adj_mat[a, b] = c
adj_mat[b, a] = c
visited_edge_count = np.sum(
np.stack([djkstra(adj_mat, src)[np.newaxis, :, :] for src in range(N)], axis=0), axis=0)
out = np.sum(np.logical_and(adj_mat > 0, visited_edge_count == 0)) // 2
print(out)
if __name__ == '__main__':
main()
|
s179398374 | p03837 | u655834330 | 1561948206 | Python | PyPy3 (2.4.0) | py | Runtime Error | 286 | 45020 | 1327 |
def warshall_floyd(d, n):
# d[i][j]: iからjへの最短距離
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
return d
def read_input():
n, m = map(int, input().split())
edges = []
for i in range(m):
a, b, c = map(int, input().split())
edges.append((a - 1, b - 1, c))
return n, m, edges
def submit():
n, m, edges = read_input()
# 全ノード間の最短経路を求める
d = [[float('inf') for _ in range(n)] for _ in range(n)]
for edge in edges:
d[edge[0]][edge[1]] = edge[2]
d[edge[1]][edge[0]] = edge[2]
for i in range(n):
d[i][i] = 0
d = warshall_floyd(d, n)
# 各edgeについていずれかの2点間の最短経路に含まれうるか確認する
edge_inuse = [0 for _ in range(n)]
for e, edge in enumerate(edges):
for i in range(n):
for j in range(n):
dist1 = d[i][j]
dist2 = d[i][edge[0]] + edge[2] + d[edge[1]][j]
if dist1 == dist2:
edge_inuse[e] = 1
break
if edge_inuse[e] == 1:
break
print(m - sum(edge_inuse))
return
if __name__ == '__main__':
submit()
|
s827938268 | p03837 | u838644735 | 1561696644 | Python | PyPy3 (2.4.0) | py | Runtime Error | 2112 | 134536 | 3002 | N, M = map(int, input().split())
ABC = []
for i in range(M):
abc = tuple(map(int, input().split()))
ABC.append(abc)
# print(N, M, ABC)
max_len = 0
for abc in ABC:
max_len += abc[2]
def sub(a, b, d, d_min, ABC, path):
# print('sub', a, b, d, d_min, ABC, path)
for abc in ABC:
# print('sub', abc)
if abc[0] == a:
n_a = abc[1]
tmp_d = d + abc[2]
if tmp_d > d_min:
# print('exceed', d, d_min)
continue
if n_a == b:
path.append(n_a)
# print('found', tmp_d, path)
return tmp_d
tmp = [x for x in path]
tmp.append(n_a)
tmp_d = sub(n_a, b, tmp_d, d_min, ABC, tmp)
if tmp_d > d_min:
# print('exceed2', tmp_d, d_min)
continue
if abc[1] == a:
n_a = abc[0]
tmp_d = d + abc[2]
if tmp_d > d_min:
# print('exceed', tmp_d, d_min)
continue
if n_a == b:
path.append(n_a)
# print('found', tmp_d, path)
return tmp_d
tmp = [x for x in path]
tmp.append(n_a)
tmp_d = sub(n_a, b, tmp_d, d_min, ABC, tmp)
if tmp_d > d_min:
# print('exceed2', tmp_d, d_min)
continue
# print('not found')
path = []
return max_len
def shortest(a, b, ABC):
d_min = max_len
ans = []
for abc in ABC:
# print('shortest', a, b, abc)
if abc[0] == a:
n_a = abc[1]
d = abc[2]
path = [a, n_a]
if n_a == b and d <= d_min:
d_min = d
ans = [path]
continue
d = sub(n_a, b, d, d_min, ABC, path)
if d <= d_min:
# print('shortest, found', d, path)
d_min = d
ans = [path]
if d == d_min:
ans.append(path)
if abc[1] == a:
n_a = abc[0]
d = abc[2]
path = [a, n_a]
if n_a == b and d <= d_min:
d_min = d
ans = [path]
continue
d = sub(n_a, b, d, d_min, ABC, path)
if d < d_min:
# print('shortest, found', d, path)
d_min = d
ans = [path]
if d == d_min:
ans.append(path)
return ans
# print(shortest(1, 2, ABC))
# print(shortest(1, 3, ABC))
# print(shortest(2, 3, ABC))
s_paths = set()
for i in range(N):
for j in range(i + 1, N):
paths = shortest(i + 1, j + 1, ABC)
# print(i, j, paths)
for path in paths:
# print(path)
for k in range(len(path) - 1):
l = min(path[k], path[k + 1])
r = max(path[k], path[k + 1])
s_paths.add((l, r))
print(len(ABC) - len(s_paths))
|
s478976455 | p03837 | u365364616 | 1558471385 | Python | Python (3.4.3) | py | Runtime Error | 235 | 6740 | 1134 | import copy
def warshall_floyd(V, E):
INF = 10 ** 9
d = [[[INF, []] for j in range(V + 1)] for i in range(V + 1)]
for i, j, c in E:
d[i][j] = [c, []]
d[j][i] = [c, []]
for k in range(1, V + 1):
for i in range(1, V):
for j in range(i, V + 1):
dk = d[i][k][0] + d[k][j][0]
if d[i][j][0] > dk:
root = copy.copy(d[i][k][1]) + [k] + copy.copy(d[k][j][1])
d[i][j] = [dk, root]
d[j][i] = [dk, root]
return d
n, m = map(int, input().split())
E = [[None for j in range(n + 1)] for i in range(n + 1)]
E_list = []
for i in range(m):
a, b, c = map(int, input().split())
E_list.append([a, b, c])
E[a][b] = 0
E[b][a] = 0
d = warshall_floyd(n, E_list)
ans = m
for i in range(1, n + 1):
for j in range(i + 1, n + 1):
k = i
for r in d[i][j][1]:
if E[r][k] == 0:
ans -= 1
E[r][k] += 1
E[k][r] += 1
k = r
if E[j][k] == 0:
ans -= 1
E[j][k] += 1
E[k][j] += 1
print(ans) |
s543285252 | p03837 | u167751176 | 1556750468 | Python | Python (3.4.3) | py | Runtime Error | 1079 | 3828 | 928 | def main():
N, M = map(int, input().split())
points = [[] for _ in range(N+1)]
for i in range(1, M+1):
a, b, c = map(int, input().split())
points[a].append([b, c, i])
points[b].append([a, c, i])
use = set()
def dijksta(start):
is_visited = [False]*(N+1)
is_visited[0] = True
is_visited[start] = True
stack = list(points[start])
while stack:
stack.sort(key=lambda x: x[1])
use_edge = stack.pop()
cur = use_edge[0]
dist = use_edge[1]
use.add(use_edge[2])
is_visited[cur] = True
if all(is_visited):
break
add_stack = list(points[cur])
removes = []
for i, pair in enumerate(add_stack):
if is_visited[pair[0]]:
removes.append(i)
continue
add_stack[i][1] += dist
removes.reverse()
for i in removes:
add_stack.pop(i)
stack.extend(add_stack)
for i in range(1, M+1):
dijksta(i)
ans = M - len(use)
print(ans)
if __name__ == '__main__':
main() |
s241414194 | p03837 | u167751176 | 1556750381 | Python | Python (3.4.3) | py | Runtime Error | 1099 | 3828 | 958 | def main():
N, M = map(int, input().split())
points = [[] for _ in range(N+1)]
for i in range(1, M+1):
a, b, c = map(int, input().split())
points[a].append([b, c, i])
points[b].append([a, c, i])
use = set()
def dijksta(start):
is_visited = [False]*(N+1)
is_visited[0] = True
is_visited[start] = True
stack = list(points[start])
edge = 0
while stack:
edge += 1
stack.sort(key=lambda x: x[1])
use_edge = stack.pop()
cur = use_edge[0]
dist = use_edge[1]
use.add(use_edge[2])
is_visited[cur] = True
if all(is_visited):
return edge
add_stack = list(points[cur])
removes = []
for i, pair in enumerate(add_stack):
if is_visited[pair[0]]:
removes.append(i)
continue
add_stack[i][1] += dist
removes.reverse()
for i in removes:
add_stack.pop(i)
stack.extend(add_stack)
for i in range(1, M+1):
dijksta(i)
ans = M - len(use)
print(ans)
if __name__ == '__main__':
main() |
s587249863 | p03837 | u167751176 | 1556750213 | Python | Python (3.4.3) | py | Runtime Error | 31 | 3316 | 956 | def main():
N, M = map(int, input().split())
points = [[] for _ in range(N+1)]
for i in range(1, M+1):
a, b, c = map(int, input().split())
points[a].append([b, c, i])
points[b].append([a, c, i])
is_visited = [False]*(N+1)
is_visited[0] = True
use = set()
def dijksta(start):
is_visited[start] = True
stack = list(points[start])
edge = 0
while stack:
edge += 1
stack.sort(key=lambda x: x[1])
use_edge = stack.pop()
cur = use_edge[0]
dist = use_edge[1]
use.add(use_edge[2])
is_visited[cur] = True
if all(is_visited):
return edge
add_stack = list(points[cur])
removes = []
for i, pair in enumerate(add_stack):
if is_visited[pair[0]]:
removes.append(i)
continue
add_stack[i][1] += dist
removes.reverse()
for i in removes:
add_stack.pop(i)
stack.extend(add_stack)
for i in range(1, M+1):
dijksta(i)
ans = M - len(use)
print(ans)
if __name__ == '__main__':
main() |
s761234637 | p03837 | u789339072 | 1556313719 | Python | Python (3.4.3) | py | Runtime Error | 1377 | 14408 | 587 | import sys
import numpy as np
input = sys.stdin.readline
N, M = map(int, input().split())
a = [0]*N
b = [0]*N
c = [0]*N
for i in range(M):
a[i], b[i], c[i] = map(int, input().split())
a[i] -=1
b[i] -=1
MAX = 10**10
dist = np.zeros((N,N))
dist += MAX
for i in range(N):
dist[i,i] = 0
for i in range(M):
dist[a[i], b[i]] = c[i]
dist[b[i], a[i]] = c[i]
for k in range(N):
for i in range(N):
for j in range(N):
dist[i, j] = min(dist[i,j], dist[i,k] + dist[k,j])
ans = 0
for i in range(M):
if dist[a[i], b[i]] < c[i]:
ans += 1 |
s056354177 | p03837 | u789339072 | 1556312960 | Python | PyPy3 (2.4.0) | py | Runtime Error | 201 | 41580 | 601 | import sys
input = sys.stdin.readline
N, M = map(int, input().split())
a = [0]*N
b = [0]*N
c = [0]*N
for i in range(M):
a[i], b[i], c[i] = map(int, input().split())
a[i] -=1
b[i] -=1
MAX = 10**10
dist = [[MAX for j in range(N)] for i in range(N)]
for i in range(N):
dist[i][i] = 0
for i in range(M):
dist[a[i]][b[i]] = c[i]
dist[b[i]][a[i]] = c[i]
for k in range(N):
for i in range(N):
for j in range(N):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
ans = 0
for i in range(M):
if dist[a[i]][b[i]] < c[i]:
ans += 1
print(ans)
|
s243809870 | p03837 | u794250528 | 1556159218 | Python | Python (3.4.3) | py | Runtime Error | 1506 | 3444 | 722 | import itertools
n, m = map(int, input().split())
a = [None] * n
b = [None] * n
c = [None] * n
for i in range(m):
a[i], b[i], c[i] = map(int, input().split())
a[i] -= 1
b[i] -= 1
wf = [[float('inf')] * n for _ in range(n)]
for i in range(n):
wf[i][i] = 0
for i in range(m):
wf[a[i]][b[i]] = wf[b[i]][a[i]] = c[i]
for k, i, j in itertools.product(range(n), repeat=3):
wf[i][j] = min(wf[i][j], wf[i][k] + wf[k][j])
ans = 0
for x in range(m):
used = False
for i, j in itertools.product(range(n), repeat=2):
if wf[i][a[x]] + c[x] + wf[b[x]][j] == wf[i][j] or wf[i][b[x]] + c[x] + wf[a[x]][j] == wf[i][j]:
used = True
if not used:
ans += 1
print(ans)
|
s393145895 | p03837 | u151625340 | 1555885846 | Python | PyPy3 (2.4.0) | py | Runtime Error | 181 | 38384 | 3976 | class Dijkstra: # 最短経路問題
def __init__(self, route_map, start_point, goal_point=None):
self.route_map = route_map #
self.start_point = start_point # スタート位置
self.goal_point = goal_point
def execute(self):
import heapq
num_of_city = len(self.route_map) # ノード数
dist = [float("inf") for _ in range(num_of_city)] # startからの距離を格納する
prev = [float("inf") for _ in range(num_of_city)] # prev[i]:ノードiに向かう前のノード番号。これを持っておけば、goalからstartまで辿れる
dist[self.start_point] = 0 # スタート位置までのコストは0
heap_q = [] # 優先度つきキュー
heapq.heappush(heap_q, (0, self.start_point)) # タプル(0,スタート位置)をheap_qに追加
while len(heap_q) != 0:
prev_cost, src = heapq.heappop(heap_q) # 直前にheap_qに入れたタプルから取り出す(src＝ソース)
if dist[src] < prev_cost: # もし、スタート位置からsrcまでの距離がprev_costより小さいなら問題ないのでok
continue
for dest, cost in self.route_map[src].items(): # destはsrcから行ける頂点(目的地)
if cost != float("inf") and dist[dest] > dist[src] + cost: # もし、destに有限のコストで行けて、srcからdestに行くのがスタートからの現状の最短距離になるなら、
dist[dest] = dist[src] + cost # 更新する
heapq.heappush(heap_q, (dist[dest], dest)) # 更新したのでheap_qに入れておく。次のノードに移動した時に取り出して無駄な変更がないか確認する
prev[dest] = src
if self.goal_point is not None: # ゴールまでの最短経路を返す
return self.get_path(self.goal_point, prev)
else: # スタートから各頂点までの最短距離を格納したリストを返す
return dist
def get_path(self, goal, prev): # prev[i]:ノードiに向かう前のノード番号。これを持っておけば、goalからstartまで辿れる
global edge_num
global used_edge
path = [goal]
dest = goal
while prev[dest] != float("inf"): # prev[start]はfloat("inf")になり、停止する
used_edge[edge_num[prev[dest]][dest]] += 1
path.append(prev[dest]) # 後ろから戻っていく
dest = prev[dest]
return list(reversed(path)) # 逆から辿ったので順を元に戻す
import sys
input = sys.stdin.readline
N,M = map(int,input().split())
route_map = [dict() for _ in range(N)]
edge_num = [dict() for _ in range(N)]
for i in range(M): # M == エッジの数
u, v, cost = map(int, input().split()) # cost は 辺 u -> v の重み(距離,コスト)
u, v = u - 1, v - 1
route_map[u][v] = cost # route_mapの第u番目のdictに{v:cost}が入る
route_map[v][u] = cost # route_mapの第v番目のdictに{u:cost}が入る
edge_num[u][v] = i # redge_numの第u番目のdictに{v:i}が入る
edge_num[v][u] = i # redge_numの第v番目のdictに{u:i}が入る
used_edge = [0 for _ in range(M)]
checked_node = [[0 or _ in range(N)] for __ in range(N)]
for i in range(N-1):
for j in range(i+1,N):
if checked_node[i][j] != 0:
continue
dijkstra_result1 = Dijkstra(route_map, i, j).execute()
dijkstra_result2 = Dijkstra(route_map, N-1-i, N-1-j).execute()
for k in range(len(dijkstra_result1)-1):
for l in range(k+1,len(dijkstra_result1)):
checked_node[dijkstra_result1[k]][dijkstra_result1[l]] += 1
for k in range(len(dijkstra_result2)-1):
for l in range(k+1,len(dijkstra_result2)):
checked_node[dijkstra_result2[k]][dijkstra_result2[l]] += 1
ans = used_edge.count(0)
print(ans)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.