input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
N, K = list(map(int, input().split()))
tmp1 = abs(N - K)
while True:
if K == 1:
print((0))
break
tmp2 = abs(tmp1 - K)
if tmp1 < tmp2:
print(tmp1)
break
else:
tmp1 = tmp2
| N, K = list(map(int, input().split()))
print((min(N % K, K - (N % K))))
| p02719 |
n,k = input().split(" ")
n = int(n)
k = int(k)
min = 1000000000000000001
abs0 = 0
if n == 0:
print((0))
elif k == 1:
print((0))
elif n == 1:
print((1))
else:
for i in range(1000000000):
abs0 = abs(k - n)
n = abs0
if abs0 < min:
min = abs0
elif min == abs0:
print(abs0)
break | n,k = input().split(" ")
n = int(n)
k = int(k)
min = 1000000000000000001
abs0 = 0
if n == 0:
print((0))
elif k == 1:
print((0))
elif n == 1:
print((1))
else:
if n > k:
n = n % k
print((abs(k-n)))
else:
for i in range(1000000000):
abs0 = abs(k - n)
n = abs0
if abs0 < min:
min = abs0
elif min == abs0:
print(abs0)
break | p02719 |
import sys
n,k=list(map(int,input().split()))
if n==0 or n%k==0:
print((0))
sys.exit()
tmp=abs(n-k)
while tmp<n:
n=tmp
tmp=abs(n-k)
print(n) | import sys
n,k=list(map(int,input().split()))
if n==0 or n%k==0:
print((0))
sys.exit()
n=n%k
tmp=abs(n-k)
while tmp<n:
n=tmp
tmp=abs(n-k)
print(n) | p02719 |
N, K = list(map(int, input().split()))
if K == 1:
print((0))
elif N == K:
print((0))
elif N == 0:
print((0))
elif N % 2 == 0 and K % 2 == 0 and N > K and K % N == 0:
print((0))
elif N % 2 == 0 and K % 2 == 0 and N > K and K % N != 0:
if abs(N - K) > N:
print(N)
else:
for i in range(10 ** 18):
if N > abs(N - K):
N = abs(N - K)
else:
print(N)
break
elif N % 2 == 0 and K % 2 == 0 and N < K and K % N == 0:
print(N)
elif N % 2 == 0 and K % 2 == 0 and N < K and K % N != 0:
if abs(N - K) > N:
print(N)
else:
print((abs(N - K)))
elif N % 2 == 1 and K % 2 == 1 and N > K and K % N == 0:
print((0))
elif N % 2 == 1 and K % 2 == 1 and N > K and K % N != 0:
if abs(N - K) > N:
print(N)
else:
for i in range(10**18):
if N > abs(N - K):
N = abs(N - K)
else:
print(N)
break
elif N % 2 == 0 and K % 2 == 0 and N < K and K % N == 0:
print(N)
elif N % 2 == 0 and K % 2 == 0 and N < K and K % N != 0:
if abs(N - K) > N:
print(N)
else:
for i in range(10 ** 18):
if N > abs(N - K):
N = abs(N - K)
else:
print(N)
break
elif N % 2 == 0 and K % 2 == 1 and N > K and N % K != 0:
if abs(N - K) > N:
print(N)
else:
for i in range(10 ** 18):
if N > abs(N - K):
N = abs(N - K)
else:
print(N)
break
elif N % 2 == 0 and K % 2 == 1 and N > K and N % K == 0:
print((0))
elif N % 2 == 0 and K % 2 == 1 and N < K and N % K != 0:
if abs(N - K) > N:
print(N)
else:
for i in range(10 ** 18):
if N > abs(N - K):
N = abs(N - K)
else:
print(N)
break
elif N % 2 == 0 and K % 2 == 1 and N < K and N % K == 0:
print((0))
elif N % 2 == 1 and K % 2 == 0 and N > K and N % K != 0:
if abs(N - K) > N:
print(N)
else:
for i in range(10 ** 18):
if N > abs(N - K):
N = abs(N - K)
else:
print(N)
break
elif N % 2 == 1 and K % 2 == 0 and N > K and N % K == 0:
print((0))
elif N % 2 == 1 and K % 2 == 0 and N < K and N % K != 0:
if abs(N - K) > N:
print(N)
else:
for i in range(10 ** 18):
if N > abs(N - K):
N = abs(N - K)
else:
print(N)
break
elif N % 2 == 1 and K % 2 == 0 and N < K and N % K == 0:
print(N)
else:
print("NG")
| N, K = list(map(int, input().split()))
print((min(N % K, abs(K - N % K)))) | p02719 |
import fractions
import sys
N,K = list(map(int,input().split()))
L = []
L.append(N)
i = 0
if N == K:
print((0))
sys.exit(0)
if N == 0:
print((0))
sys.exit(0)
if K == 1:
print((0))
sys.exit(0)
Q = 0
N-=((N//K)*K)
while True:
L.append(abs(N-K))
N = abs(N-K)
i += 1
if i > 10**5:
Q = min(L)
break
if N%K == 0 and N>=K:
print((0))
else:
if N < K:
print((min(N,Q)))
else:
print((min(N%K,Q,fractions.gcd(N,K)))) | N,K = list(map(int,input().split()))
#N-K -> -K -> -K... gives N%K
#-> (N%K - K) -> (N%K)
answ = N%K
print((min(abs(answ),abs(answ-K))))
| p02719 |
N,K=input().split()
N=int(N)
K=int(K)
list=[]
if N%K==0:
print((0))
else:
while N not in list:
list.append(N)
N=abs(N-K)
print((min(list)))
| N,K=input().split()
N=int(N)
K=int(K)
print((min(N%K,K-N%K)))
| p02719 |
n,k = list(map(int,input().split()))
answer = 0
if k == 1:
answer = 0
elif k >= n:
gap = k-n
if gap > n:
answer = n
else:
answer = gap
else:
while n > k:
n = n - k
if k >= n:
gap = k-n
if gap > n:
answer = n
else:
answer = gap
print(answer) | n,k = list(map(int,input().split()))
answer = 0
if k >= n:
gap = k-n
if gap > n:
answer = n
else:
answer = gap
else:
sho = n // k
if n % k == 0:
dec = sho - 1
else:
dec = sho
n = n - k*dec
if k >= n:
gap = k-n
if gap > n:
answer = n
else:
answer = gap
print(answer) | p02719 |
n,k = list(map(int,input().split()))
if n>=k:
t = n%k
else:
t = n
print((t if t <= k-t else k-t))
| #x>Kの時、x => x-k =>x-2k => x-3k ... : xをkで割った余りになる
#x<Kの時、x => k-x => x : max(x,k-x)
n,k = list(map(int,input().split()))
if n >= k:
n = n%k
print((n if n%k <= k-n else k-n)) | p02719 |
N, K = list(map(int, input().split()))
Nj = N
while True:
Ni = Nj
Nj = abs(Ni - K)
if Ni > N:
print(N)
break
elif Nj > Ni:
print(Ni)
break
elif K == 1 or Nj == K:
print((0))
break
else:
continue
| n, k = list(map(int, input().split()))
if n % k == 0:
print((0))
else:
l = [n]
p = n // k
c = n - (p * k)
half = k // 2
while c > half:
c = abs(c - k)
l.append(c)
print((min(l)))
| p02719 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
from bisect import bisect_left
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n,k = inpl()
print((min(n%k, k-(n%k)))) | from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n,k = inpl()
print((min(n%k, k-n%k))) | p02719 |
n,k=list(map(int,input().split()))
n%=k
N=abs(n-k)
while N<n:
n=N
N=abs(n-k)
print(n)
| n,k=list(map(int,input().split()))
n%=k
N=abs(n-k)
if N<n:
n=N
print(n)
| p02719 |
import sys
sys.setrecursionlimit(1000000000)
n, k = list(map(int, input().split()))
if k == 1:
print((0))
elif n < k / 2:
print(n)
else:
while n >= k / 2:
n = abs(k - n)
print(n)
| n, k = list(map(int, input().split()))
if k > n:
tmp = n
else:
tmp = n % k
if tmp > k / 2:
tmp = k - tmp
print(tmp)
| p02719 |
n, k = list(map(int, input().split()))
L = []
if n > k:
n = n - k*(n//k)
for i in range(k+1):
L.append(abs(n-k))
n = abs(n-k)
print((min(L))) | n, k = list(map(int, input().split()))
L = []
if n > k:
n = n - k*(n//k)
if n*2 <= k:
print(n)
else:
print((k-n)) | p02719 |
n,k=list(map(int,input().split()))
if n%k==0:
print((0))
exit()
while abs(n-k)<n:
n=abs(n-k)
print(n) | n,k=list(map(int,input().split()))
print((min(n%k,abs(n%k-k)))) | p02719 |
if __name__ == '__main__':
n, k = [int(i) for i in input().split(" ")]
while abs(n - k) <= n:
if n%(k*10)==0:
n = int(n/(k*10))
else:
n = abs(n - k)
print(n) | if __name__ == '__main__':
n, k = [int(i) for i in input().split(" ")]
while abs(n - k) < n and n != 0:
n = n%k
if n != 0:
n = abs(n - k)
print(n)
| p02719 |
n = list(map(int, input().split()))
re = True
num = n[0]
if n[1] == 1:
print((0))
elif n[1] == 2:
if n[0]%2 == 0:
print((0))
else:
print((1))
else:
while re:
k = num - n[1]
if num > abs(k):
num = abs(k)
else:
re = False
print(num) | n = list(map(int, input().split()))
k = n[0] % n[1]
if abs(k - n[1]) > k:
print(k)
else:
print((abs(k - n[1]))) | p02719 |
n, k = list(map(int, input().split()))
ans = abs(n - k)
i = False
if n % k == 0:
ans = 0
i = True
while not i:
if ans > abs(ans - k):
ans = abs(ans - k)
else:
i = True
print(ans) | n, k = list(map(int, input().split()))
ans = n % k
i = False
if ans == 0:
i = True
while not i:
if ans > abs(ans - k):
ans = abs(ans - k)
else:
i = True
print(ans) | p02719 |
def replaceInt(N, M):
N = abs(N-M)
return N
N, M = [int(i) for i in input().split()]
if N == M :
output = 0
elif N < M :
if N <= M / 2:
output = N
else:
output = abs(M-N)
else :
if M == 1:
output = 0
else :
output_candidates = [N]
while True:
N = replaceInt(N,M)
if N in output_candidates:
break
output_candidates.append(N)
output = min(output_candidates)
print(output)
| def replaceInt(N, M):
N = abs(N-M)
return N
N, M = [int(i) for i in input().split()]
if N == M :
output = 0
elif N < M :
if N <= M / 2:
output = N
else:
output = abs(M-N)
else :
if M == 1:
output = 0
else :
N = N % M
output_candidates = []
while True:
N = replaceInt(N,M)
if N in output_candidates:
break
output_candidates.append(N)
output = min(output_candidates)
print(output)
| p02719 |
NK = input().split();
N,K = int(NK[0]),int(NK[1]);
min = N;
#桁が大きい時の処理
if(K == 1):
while(int(len(str(N))) > 2):
N = int(N - K * (N / 2));
# else:
# while(int(len(str(N))) > 2):
# N = int(N / K);
flag = True;
while flag == True:
N = abs(N - K);
if(N <= min):
min = N;
else:
flag = False;
print(min); | import math
NK = input().split();
N,K = int(NK[0]),int(NK[1]);
min = N;
#桁が大きい時の処理
if(K == 1):
while(int(len(str(N))) > 2):
N = int(N - K * (N / 2));
else:
border = math.floor(N / K);
N = N - K * border;
flag = True;
while flag == True:
N = abs(N - K);
if(N <= min):
min = N;
else:
flag = False;
print(min); | p02719 |
n,k = list(map(int, input().split()))
t = n // k
n -= t*k
print((min(abs(n-k), n))) | n, k = list(map(int, input().split()))
l = n // k
print((min(n - l * k, abs((n - l * k) - k)))) | p02719 |
def solve(n, k):
occurence = set()
diff = n % k
if diff == 0:
print(diff)
return
else:
while n not in occurence:
if k == 1:
print((0))
return
occurence.add(n)
n = abs(n - k)
if n == 0:
print(n)
return
min_value = min(occurence)
print(min_value)
if __name__ == '__main__':
nk = input().split()
n = int(nk[0])
k = int(nk[1])
solve(n, k)
| def solve(n, k):
occurence = set()
diff = n % k
n = diff
if diff == 0 or diff == 1:
print(diff)
return
else:
while n not in occurence:
if k == 1:
print((0))
return
occurence.add(n)
n = abs(n - k)
if n == 0:
print(n)
return
min_value = min(occurence)
print(min_value)
if __name__ == '__main__':
nk = input().split()
n = int(nk[0])
k = int(nk[1])
solve(n, k)
| p02719 |
N, K = list(map(int, input().split()))
if K == 1:
res = 0
elif K == 2:
res = K % 2
else:
diff = abs(N-K)
while diff < N:
N = diff
diff = abs(N-K)
res = N
print(res)
| N, K = list(map(int, input().split()))
rem = N %K
print((min(rem, abs(rem - K))))
| p02719 |
n,k=list(map(int,input().split()))
if n>k:
n=n%k
print((min(n,k-n))) | n,k=list(map(int,input().split()))
n=n%k
print((min(n,k-n))) | p02719 |
N, K = list(map(int,input().split()))
if K == 1 or N == 0 or N == K:
print((0))
exit()
elif K == 0:
print(N)
exit()
elif N == 1 or N == K-1 or K == N-1:
print((1))
exit()
else:
res = []
ans = N
for i in range(max(N,K)):
ans = abs(ans - K)
res.append(ans)
if i >= 2:
if res[i] == res[i-2]:
print((min(res)))
exit()
print((min(res))) | N, K = list(map(int,input().split()))
if K == 1 or N == 0 or N == K or N%K==0:
print((0))
elif K == 0:
print(N)
elif N == 1 or N == K-1 or K == N-1 or N%K==1:
print((1))
elif N > K:
res = abs(N - (K*(N//K)))
if abs(res - K) < res:
print((abs(res-K)))
else:
print(res)
elif K > N:
if abs(K-N) < N:
print((abs(K-N)))
else:
print(N) | p02719 |
n, k = list(map(int, input().split()))
loop = True
while loop:
if n > abs(n - k):
if n > k:
n = min(n, n % k)
elif k > n:
n = min(n, k % n)
else:
loop = False
print(n)
| n, k = list(map(int, input().split()))
if n == k:
n = 0
else:
while n > abs(n - k):
if n > k:
n = min(n, n % k)
elif k > n:
n = min(n, k % n)
print(n)
| p02719 |
li = list(map(int, input().split()))
new_li = []
n = 0
while True:
if li[1] == 1:
print((0))
break
li[0] = abs(li[0]-li[1])
new_li.append(li[0])
if n>=2:
if new_li[n] == new_li[n-2]:
print((min(new_li)))
break
n += 1 | N, K = list(map(int, input().split()))
if N%K == 0:
print("0")
elif abs(N%K - K) < N:
print((abs(N%K - K)))
else:
print(N) | p02719 |
N,K = list(map(int,input().split()))
if K == 1 or N%K == 0:
print((0))
exit()
S = set()
S.add(N)
for x in range(N):
c = abs(N-K)
if N == c:
break
N = abs(N-K)
S.add(N)
print((min(S))) | N,K = list(map(int,input().split()))
T = N%K
L = [T,abs(T-K)]
print((min(L))) | p02719 |
import sys
N, K = list(map(int, input().split()))
first = N
list_a = []
if N % K == 0:
print((0))
sys.exit()
else:
while N > 0:
N = N - K
second = N + K
N = abs(N)
list_a.append(N)
list_a.append(second)
list_a.append(first)
list_a = sorted(list_a)
print((list_a[0]))
| import sys
N, K = list(map(int, input().split()))
first = N
list_a = []
if N % K == 0:
print((0))
sys.exit()
else:
X = N // K
N = N - (K * (X+1))
second = N + K
N = abs(N)
list_a.append(N)
list_a.append(second)
list_a.append(first)
list_a = sorted(list_a)
print((list_a[0]))
| p02719 |
N,K=list(map(int,input().split()))
if N % K ==0:
print((0))
exit()
ans = N
for i in range((N//K)+1):
N = abs(N-K)
ans =min(ans,N)
print(ans) | N,K=list(map(int,input().split()))
if N % K ==0:
print((0))
exit()
if N < K:
print((min(N,K-N)))
exit()
if N > K:
print((min(N%K,K-(N%K)))) | p02719 |
n, k = list(map(int,input().split()))
if k == 1:
print((0))
exit()
while n >= abs(n-k):
n = abs(n-k)
print(n) | n, k = list(map(int,input().split()))
print((min(n%k, k - n%k))) | p02719 |
N, K = [int(n) for n in input().split()]
def cmp(a, b):
if a > b:
return a%b
return abs(a-b)
while True:
ans = cmp(N, K)
if 0 <= ans <=2:
break
N = ans
print(ans)
| N, K = [int(n) for n in input().split()]
print((min(N%K, K-(N%K)))) | p02719 |
n, k = list(map(int, input().split()))
t = n // k
re = n - t * k
i = True
while i == True:
if abs(re - k) < re:
re = abs(re - k)
i = True
else:
i = False
print(re)
| n, k = list(map(int, input().split()))
t = n // k
re = n - t * k
if abs(re - k) < re:
re = abs(re - k)
i = True
print(re)
| p02719 |
N,K = list(map(int, input().split()))
if N % K == 0:
print((0))
elif N > K:
while N > 0:
hako1 = N
N -= K
hako2 = abs(N)
if hako1 > hako2:
print(hako2)
else:
print(hako1)
else:
if N >= abs(N-K):
print((abs(N-K)))
else:
print(N) | N,K = list(map(int, input().split()))
if N % K == 0:
print((0))
elif N > K:
hako1 = N%K
hako2 = abs(hako1-K)
if hako1 > hako2:
print(hako2)
else:
print(hako1)
else:
if N >= abs(N-K):
print((abs(N-K)))
else:
print(N) | p02719 |
N, K = [int(x) for x in input().split(" ")]
if N ==0 or K==1:
print((0))
else:
while N>abs(N-K):
N = abs(N%K-K)
print(N)
| N, K = [int(x) for x in input().split(" ")]
if N ==0 or K==1 or N == K:
print((0))
else:
while N>abs(N-K):
N = abs(N%K-K)
print(N)
| p02719 |
a,b = list(map(int, input().split()))
if b == 1:
print((0))
exit()
while True:
x = abs(a-b)
if x < a:
a = x
else:
print(a)
break | a,b = list(map(int, input().split()))
if a > b:
if a % b == 0:
print((0))
exit()
else:
print((min(a%b, b-(a%b))))
exit()
while True:
x = abs(a-b)
if x < a:
a = x
else:
print(a)
break | p02719 |
n,k = list(map(int,input().split()))
N = n
if n % k == 0:
print((0))
else:
while n > 0:
n -= k
if abs(n) > N:
print(N)
else:
print((abs(n)))
| n,k = list(map(int,input().split()))
a = n % k
print((min(abs(a-k),a))) | p02719 |
n, k = list(map(int, input().split()))
if n==k or k==1:
print((0))
else:
ans=n
res=[ans]
while(1):
ans=abs(ans-k)
if ans in res or ans == k:
break
res.append(ans)
print((min(res))) | n, k = list(map(int, input().split()))
print((min(n%k, k - n%k))) | p02719 |
N , K = input().split()
N = int(N)
K = int(K)
print((min(N % K , K - N % K))) | n, k = list(map(int,input().split()))
m = n %k
print((min(m, abs(m-k)))) | p02719 |
#
N, K = list(map(int,input().split()))
N %= K
min = N
for i in range(10**6):
N = abs(N-K)
if min > N:
min = N
if N == 0:
min = 0
break
print(min) | #input
N, K = list(map(int,input().split()))
#main
t = N % K
ans = min(t, K - t)
#output
print(ans) | p02719 |
n,k = list(map(int,input().split()))
if n%k==0:
print((0))
else:
while(n > abs(n-k)):
if k == 1:
n=0
break
n=abs(n-k)
print(n) | n,k = list(map(int,input().split()))
ans = min(n%k,k-(n%k))
print(ans) | p02719 |
import sys
N, K = list(map(int, input().split()))
if K == 1:
print((0))
sys.exit()
current = N
while True:
prev = current
current = abs(current - K)
next = abs(current - K)
if prev == next:
print((min(current, next)))
break
| import sys
N, K = list(map(int, input().split()))
if K == 1:
print((0))
sys.exit()
a = abs(N - K * (N // K + 1))
print((min(a, abs(a - K))))
| p02719 |
N, K = list(map(int, input().split()))
Nj = N
while True:
Ni = Nj
Nj = abs(Ni - K)
if Ni > N:
print(N)
break
elif Nj > Ni:
print(Ni)
break
elif K == 1 or Nj == K:
print((0))
break
else:
continue | N, K = list(map(int, input().split()))
a = N % K
print((min(abs(a - K), a))) | p02719 |
N,K=list(map(int,input().split()))
for i in range(18):
if N > 10 ** i * K:
for j in range(999):
if N > j*10 ** i * K:
N=N-j*10 ** i * K
while abs(N-K)<N:
N=abs(N-K)
print(N) | N,K=list(map(int,input().split()))
for i in reversed(list(range(18))):
while N > 10 ** i * K:
N=N-10 ** i * K
while abs(N-K)<N:
N=abs(N-K)
print(N) | p02719 |
n, k = list(map(int, input().split()))
if k == 1:
n = 0
else:
while True:
if abs(k - n) < n:
n = abs(k - n)
else:
FLG = True
break
print(n) | n, k = list(map(int, input().split()))
if n >= k:
n -= k * (n // k)
if k-n > n:
print(n)
else:
print((k-n)) | p02719 |
N, K = list(map(int, input().split()))
if N % K == 0:
print((0))
else:
li = []
li.append(N)
aoki = N
while aoki <= min(li):
aoki = abs(min(li) - K)
li.append(aoki)
print((min(li)))
| n, k = list(map(int, input().split()))
if n==0 or k==1:
print((0))
exit()
elif n<k:
print((min(n, abs(n-k))))
exit()
elif n % k == 0:
print((0))
exit()
else:
mx = n%k
print((min(abs(mx-k), mx))) | p02719 |
N,K = list(map(int,input().split()))
if(K==1 and N>1):
print((int(0)))
elif(N==0 and K>=1):
print((int(0)))
else:
i = 0
l = 100000000000000000
r = []
while(i==0):
r.append(N)
s = abs(N-K)
if(l>s):
l = s
N = s
if(N in r):
i+=1
print(l) | N,K = list(map(int,input().split()))
if(N==0):
print((int(0)))
else:
r = N%K
print((min(r,K-r)))
| p02719 |
n,k = list(map(int, input().split()))
mi = n
loop = True
if n%k==0:
mi = 0
loop = False
while loop:
loop = False
if mi > abs(n-k):
loop = True
n = abs(n-k)
mi = n
print(mi) | n,k = list(map(int, input().split()))
mi = n%k
if mi > abs(mi-k):
print((abs(mi-k)))
else:
print(mi) | p02719 |
X = list(map(int, input().split()))
N = X[0]
K = X[1]
if N % K == 0:
print((0))
else:
while True:
A = abs(N - K)
if N > A:
N = A
else:
break
print(N) | X = list(map(int, input().split()))
N = X[0]
K = X[1]
t = N % K
s = K - t
if t <= s:
print(t)
else:
print(s) | p02719 |
import sys
def input():
return sys.stdin.readline().strip()
def main():
n, k = list(map(int, input().split()))
if k == 1:
n = 0
print(n)
return
while n > k//2:
n = abs(n-k)
print(n)
main() | import sys
def input():
return sys.stdin.readline().strip()
def main():
n, k = list(map(int, input().split()))
a = n % k
print((min(a, k-a)))
main()
| p02719 |
n,k=list(map(int,input().split()))
if n==0 or k==0:
print((0))
exit()
if n%k==0:
print((0))
exit()
while n > abs(n-k):
n=abs(n-k)
print(n) | n,k=list(map(int,input().split()))
amari=n%k
if n==0:
print((0))
exit()
elif n%k==0:
print((0))
exit()
else:
print((min(amari,k-amari)))
'''
while n > abs(n-k):
n=abs(n-k)
print(n)
''' | p02719 |
def main():
N, K = list(map(int, input().split()))
# K: fixed
ans = 0
if N%K==0:
ans = 0
else:
if N>=K:
temp = K
while temp<N:
temp += K
upper = temp-N
lower = abs(upper-K)
ans = min(upper, lower)
else:
ans = min(N, K-N)
print(("{}".format(ans)))
if __name__=="__main__":
main() | def main():
N, K = list(map(int, input().split()))
# K: fixed
ans = 0
r = N%K
if N%K==0:
ans = 0
else:
ans = min(r, abs(r-K))
print(("{}".format(ans)))
if __name__=="__main__":
main() | p02719 |
n, k = list(map(int, input().split()))
if n % k == 0:
print((0))
else:
while True:
prev = n
n = abs(n - k)
if n >= prev:
break
print(prev)
| n, k = list(map(int, input().split()))
p = n // k
print((min(abs(n - p * k), abs(n - (p + 1) * k)))) | p02719 |
import sys
n,k=list(map(int,input().split()))
if n%k==0:
print((0))
sys.exit()
while abs(n-k)<n:
n=abs(n-k)
if n==0:
print(n)
sys.exit()
else:
print(n) | import sys
n,k=list(map(int,input().split()))
if n%k==0:
print((0))
sys.exit()
if n%k<abs(k-n%k):
print((n%k))
else:
print((abs(k-n%k))) | p02719 |
#coding: utf-8
A = list(map(int, input().split()))
N = A[0]
K = A[1]
n = 0
sw = 0
while True:
if N%K == 0:
N = 0
break
sw = abs(N-K)
n += 1
if N > sw:
N = sw
else:
break
print(N) | #coding: utf-8
A = list(map(int, input().split()))
N = A[0]
K = A[1]
n = 0
sw = 0
while True:
if N%K == 0:
N = 0
break
if (N/K) //1:
C = N//K
N = N-C*K
sw = abs(N-K)
n += 1
if N > sw:
N = sw
else:
break
print(N) | p02719 |
n,k = list(map(int,input().split()))
if k == 1:
print((0))
else:
for i in range(1000000000000000000):
if n > abs(n-k):
n = abs(n-k)
elif n <= abs(n-k):
break
print(n) | n,k = list(map(int,input().split()))
# if k == 1:
# print(0)
# else:
# for i in range(1000000000000000000):
# if n > abs(n-k):
# n = abs(n-k)
# elif n <= abs(n-k):
# break
# print(n)
amari = n % k
if abs(amari-k) < amari:
print((abs(amari-k)))
else:
print(amari) | p02719 |
n,k = list(map(int,input().split()))
if(k==1):
print((0))
else:
t = n//k
for i in range(t):
n = abs(n-k)
if(n < abs(k-n)):
print(n)
else:
print((abs(k-n))) | N, K = list(map(int,input().split()))
t = N%K
if (K - t) >= t:
print(t)
else:
print((K - t)) | p02719 |
n, k = list(map(int, input().split()))
if n % k == 0:
print((0))
else:
ans = n
while ans > abs(n-k):
n = abs(n - k)
ans = min(n, ans)
print(ans) | n, k = list(map(int, input().split()))
if n % k == 0:
print((0))
else:
ans = n % k
#print(ans)
while ans > k//2:
n = abs(ans - k)
ans = min(n, ans)
print(ans) | p02719 |
import sys
import math
import heapq
mod=10**9+7
inf=float("inf")
from math import sqrt, ceil
from collections import deque, Counter, defaultdict, OrderedDict
#すべてのkeyが用意されてる defaultdict(int)で初期化
#順序を保ったdict
input=lambda: sys.stdin.readline().strip()
sys.setrecursionlimit(11451419)
from decimal import ROUND_HALF_UP,Decimal #変換後の末尾桁を0や0.01で指定
#Decimal((str(0.5)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
from functools import lru_cache
#メモ化再帰defの冒頭に毎回 @lru_cache(maxsize=10**10)
#引数にlistはだめ
#######ここまでテンプレ#######
#ソート、"a"+"b"、再帰ならPython3の方がいい
#######ここから天ぷら########
n=int(eval(input()))
A=[]
# ans=0
for i in range(n):
a=list(map(int,input().split()))
A.append(a)
# ans+=sum(a)
#ans//=2
miti=A[:]
for k in range(n):
for i in range(k):
for j in range(i):
q=miti[i][j]
w=miti[j][k]
e=miti[k][i]
q,w,e=sorted([[q,i,j],[w,j,k],[e,k,i]])
if e[0]==inf:
continue
if sum([q[0],w[0],e[0]])==e[0]*2:
miti[e[1]][e[2]]=inf
miti[e[2]][e[1]]=inf
elif q[0]+w[0]<e[0]:
print((-1));exit()
ans=0
for i in range(n):
for j in range(n):
if miti[i][j]!=inf:
ans+=miti[i][j]
print((ans//2))
| import sys
import math
import heapq
mod=10**9+7
inf=float("inf")
from math import sqrt, ceil
from collections import deque, Counter, defaultdict, OrderedDict
#すべてのkeyが用意されてる defaultdict(int)で初期化
#順序を保ったdict
input=lambda: sys.stdin.readline().strip()
sys.setrecursionlimit(11451419)
from decimal import ROUND_HALF_UP,Decimal #変換後の末尾桁を0や0.01で指定
#Decimal((str(0.5)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
from functools import lru_cache
#メモ化再帰defの冒頭に毎回 @lru_cache(maxsize=10**10)
#引数にlistはだめ
#######ここまでテンプレ#######
#ソート、"a"+"b"、再帰ならPython3の方がいい
#######ここから天ぷら########
n=int(eval(input()))
A=[]
# ans=0
for i in range(n):
a=list(map(int,input().split()))
A.append(a)
# ans+=sum(a)
#ans//=2
miti=[[] for i in range(n)]
for i in range(n):
miti[i]=A[i][:]
for k in range(n):
for j in range(k):
for i in range(j):
q=A[i][j]
w=A[j][k]
e=A[k][i]
#print(i,j,k,"\t",q,w,e)
# q,w,e=sorted([[q,i,j],[w,j,k],[e,k,i]])
# if max(q,w,e)==inf: continue
if q+w==e and q!=inf and w!=inf: miti[k][i]=inf;miti[i][k]=inf;continue
if q+w<A[k][i] and q!=inf and w!=inf: print((-1));exit()
if w+e==q and e!=inf and w!=inf: miti[i][j]=inf;miti[j][i]=inf;continue
if w+e<A[i][j] and e!=inf and w!=inf : print((-1));exit()
if e+q==A[j][k] and q!=inf and e!=inf: miti[j][k]=inf;miti[k][j]=inf;continue
if e+q<A[j][k] and q!=inf and e!=inf: print((-1));exit()
ans=0
for i in range(n):
for j in range(n):
if miti[i][j]!=inf:
ans+=miti[i][j]
print((ans//2))
| p03600 |
import copy
ans=0
n=int(eval(input()))
l=[list(map(int,input().split())) for _ in [0]*n]
o=copy.deepcopy(l)
for k in range(n):
for i in range(n):
for j in range(n):
if l[i][j]>l[i][k]+l[k][j]:
print((-1))
exit()
for k in range(n):
for i in range(n):
for j in range(n):
if i==j or j==k or k==i :
continue
if o[i][j]==o[i][k]+o[k][j]:
o[i][j]=float("inf")
for i in range(n):
for j in range(n):
if o[i][j] != float("inf") :
ans+=o[i][j]
print((ans//2))
| INF = 10 ** 12
N = int(eval(input()))
a = [list(map(int, input().split())) for _ in range(N)]
for i in range(N):
for j in range(N):
for k in range(N):
if a[i][j] > a[i][k] + a[k][j]:
print((-1))
exit()
res = 0
for i in range(N):
for j in range(i + 1, N):
for k in range(N):
if i != k and j != k and a[i][j] == a[i][k] + a[k][j]:
break
else:
res += a[i][j]
print(res)
| p03600 |
from itertools import product
N = int(eval(input()))
r = list(range(N))
A = [list(map(int, input().split())) for _ in r]
for i in r: A[i][i] = float('inf')
possible = True
ans = 0
for i,j in product(r, r) :
if j <= i: continue
for k in r:
if A[i][j] < A[i][k] + A[k][j]:
continue
elif A[i][j] == A[i][k] + A[k][j]:
break
else:
possible = False
break
else:
ans += A[i][j]
print((ans if possible else -1)) | from itertools import product
N = int(eval(input()))
r = list(range(N))
A = [list(map(int, input().split())) for _ in r]
for i in r: A[i][i] = float('inf')
possible = True
ans = 0
for i in r :
for j in range(i+1,N):
for k in r:
if A[i][j] < A[i][k] + A[k][j]:
continue
elif A[i][j] == A[i][k] + A[k][j]:
break
else:
possible = False
break
else:
ans += A[i][j]
print((ans if possible else -1)) | p03600 |
import sys
from copy import deepcopy as dc
input = sys.stdin.buffer.readline
N = int(eval(input()))
d = [list(map(int, input().split())) for _ in range(N)]
d2 = dc(d)
for k in range(N):
for i in range(N):
for j in range(N):
d2[i][j] = min(d2[i][k] + d2[k][j], d2[i][j])
f = 0
for i in range(N):
for j in range(N):
if d[i][j] != d2[i][j]:
f = 1
if f:
print((-1))
else:
res = 0
for i in range(N):
for j in range(N):
x = 1
for k in range(N):
if k != i and k != j:
if d[i][j] == d[i][k] + d[k][j]: x = 0
res += x * d[i][j]
print((res // 2)) | N = int(eval(input()))
a = [list(map(int, input().split())) for _ in range(N)]
b = [a[i][: ] for i in range(N)]
for k in range(N):
for i in range(N):
for j in range(N):
b[i][j] = min(b[i][j], b[i][k] + b[k][j])
inf = 10 ** 10
if a == b:
dp = [[inf] * N for _ in range(N)]
for i in range(N):
for j in range(N):
mn = i
for k in range(N):
if k == j: continue
if a[i][k] + a[k][j] == a[i][j]:
if a[mn][j] > a[k][j]:
mn = k
if dp[mn][j] == inf:
dp[mn][j] = a[mn][j]
elif dp[mn][j] != a[mn][j]:
print((-1))
exit(0)
for i in range(N):
for j in range(N):
if dp[i][j] == inf: dp[i][j] = 0
print((sum([sum(dp[i]) for i in range(N)]) // 2))
else: print((-1)) | p03600 |
from collections import deque
import sys
input = sys.stdin.readline
N = int(eval(input()))
A = [list(map(int, input().split())) for _ in range(N)]
dist = [[float('inf')] * N for _ in range(N)]
for i in range(N):
dist[i][i] = 0
edges = []
for i in range(N-1):
for j in range(i+1, N):
edges.append((A[i][j], i, j))
edges.sort()
edges = deque(edges)
ans = 0
while edges:
d, u, v = edges.popleft()
if d > dist[u][v]:
ans = -1
break
if d < dist[u][v]:
ans += d
for i in range(N-1):
for j in range(i+1, N):
ndist = min(dist[i][j], dist[i][u] + d + dist[v][j], dist[i][v] + d + dist[u][j])
dist[i][j] = dist[j][i] = ndist
print(ans)
| from copy import deepcopy
import sys
input = sys.stdin.readline
def floyd_warshall(dist):
v = len(dist)
for k in range(v):
for i in range(v):
for j in range(v):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
N = int(eval(input()))
A = [list(map(int, input().split())) for _ in range(N)]
dist = deepcopy(A)
floyd_warshall(dist)
edges = []
for u in range(N-1):
for v in range(u+1, N):
edges.append((A[u][v], u, v))
edges.sort()
ans = 0
for d, u, v in edges:
if dist[u][v] < d:
ans = -1
break
ok = False
for w in range(N):
if w == u or w == v:
continue
if dist[u][w] + dist[w][v] == dist[u][v]:
ok = True
break
if not ok:
ans += d
print(ans)
| p03600 |
from heapq import heappush, heappop
INF = 10 ** 20
n = int(eval(input()))
que = []
for i in range(n):
aList = list(map(int, input().split()))
for j in range(i, n):
heappush(que, (aList[j], i, j))
dist = [[INF] * n for _ in range(n)]
ans = 0
while que:
c, i, j = heappop(que)
minDist = INF
for k in range(n):
minDist = min(minDist, dist[i][k] + dist[k][j])
if minDist < c:
print((-1))
break
elif minDist == c:
continue
else:
dist[i][j] = dist[j][i] = c
ans += c
else:
print(ans)
| INF = 10 ** 20
n = int(eval(input()))
edges = [list(map(int, input().split())) for _ in range(n)]
dist = [[INF] * n for _ in range(n)]
edgeList = []
for i in range(n):
for j in range(i, n):
edgeList.append((edges[i][j], i, j))
edgeList.sort()
for k in range(n):
for i in range(n):
for j in range(n):
dist[i][j] = min(dist[i][j], edges[i][k] + edges[k][j])
ans = 0
for c, i, j in edgeList:
minCost = min([dist[i][k] + dist[k][j] for k in range(n) if (k != i and k != j)] + [INF])
if c > minCost:
print((-1))
break
if c < minCost:
ans += c
else:
print(ans) | p03600 |
INF = 10 ** 20
n = int(eval(input()))
edges = [list(map(int, input().split())) for _ in range(n)]
dist = [[INF] * n for _ in range(n)]
edgeList = []
for i in range(n):
for j in range(i, n):
edgeList.append((edges[i][j], i, j))
edgeList.sort()
for k in range(n):
for i in range(n):
for j in range(n):
dist[i][j] = min(dist[i][j], edges[i][k] + edges[k][j])
ans = 0
for c, i, j in edgeList:
minCost = min([dist[i][k] + dist[k][j] for k in range(n) if (k != i and k != j)] + [INF])
if c > minCost:
print((-1))
break
if c < minCost:
ans += c
else:
print(ans) | INF = 10 ** 20
n = int(eval(input()))
edges = [list(map(int, input().split())) for _ in range(n)]
dist = [[INF] * n for _ in range(n)]
edgeList = []
for i in range(n):
for j in range(i, n):
edgeList.append((edges[i][j], i, j))
edgeList.sort()
for k in range(n):
edgesk = edges[k]
for i in range(n):
disti = dist[i]
edgesik = edges[i][k]
for j in range(n):
if disti[j] > edgesik + edgesk[j]:
disti[j] = edgesik + edgesk[j]
ans = 0
for c, i, j in edgeList:
minCost = INF
for k in range(n):
if k in (i, j):continue
if minCost > dist[i][k] + dist[k][j]:
minCost = dist[i][k] + dist[k][j]
if c > minCost:
print((-1))
break
if c < minCost:
ans += c
else:
print(ans) | p03600 |
N=int(eval(input()))
dist=[list(map(int,input().split())) for i in range(N)]
ans=sum([sum(dist[i]) for i in range(N)])
ans//=2
was=set()
for i in range(N):
if ans<0:break
for j in range(i+1,N):
if ans<0:break
for k in range(j+1,N):
a,b,c=dist[i][j],dist[i][k],dist[j][k]
if b<a and c<a:
M=a
S=b+c
check=(i,j)
elif a<b and c<b:
M=b
S=a+c
check=(i,k)
elif a<c and b<c:
M=c
S=a+b
check=(j,k)
else:continue
if S==M:
if check in was:continue
ans-=M
was|={check,}
elif S<M:
ans=-1*float('inf')
break
if ans<0:ans=-1
print(ans) | import sys
input=sys.stdin.readline
N=int(eval(input()))
dist=[list(map(int,input().split())) for i in range(N)]
ans=sum([sum(dist[i]) for i in range(N)])
for i in range(N):
dist[i][i]=float('inf')
ans//=2
def main(ans):
for i in range(N):
for j in range(i+1,N):
Min=min(list(map(sum,list(zip(dist[i],dist[j])))))
if Min<dist[i][j]:
return -1
if Min==dist[i][j]:
ans-=dist[i][j]
return ans
print((main(ans))) | p03600 |
n = int(eval(input()))
A = [list(map(int, input().split())) for _ in range(n)]
def warshal_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])
return d
import copy
B = copy.deepcopy(A)
B = warshal_floyd(B)
ans = 0
for i in range(n):
for j in range(n):
if B[i][j] < A[i][j]:
print((-1))
exit()
else:
for k in range(n):
if k == i or k == j:
continue
if B[i][j] == B[i][k] + B[k][j]:
break
else:
ans += A[i][j]
ans //=2
print(ans) | def main():
n = int(eval(input()))
d = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for i in range(n):
for j in range(n):
if i == j:
continue
flag = True
for k in range(n):
if k == i or k == j:
continue
if d[i][j] > d[i][k]+d[k][j]:
print((-1))
exit()
elif d[i][j] == d[i][k]+d[k][j]:
flag = False
else:
pass
if flag:
ans += d[i][j]
#print(ans)
print((ans//2))
if __name__ == '__main__':
main()
| p03600 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
import heapq
n = int(readline())
dist = [[INF] * n for _ in range(n)]
hq = []
table = [[0] * n for _ in range(n)]
for i in range(n):
a = list(map(int, readline().split()))
for j in range(i + 1, n):
hq.append((a[j], i, j))
table[i][j] = a[j]
for i in range(n):
dist[i][i] = 0
heapq.heapify(hq)
ans = 0
while hq:
cost, u, v = heapq.heappop(hq)
cur = dist[u][v]
if cur > cost:
ans += cost
dist[u][v] = cost
for i in range(n):
dist[i][v] = min(dist[i][v], dist[i][u] + cost)
dist[i][u] = min(dist[i][u], dist[i][v] + cost)
for j in range(n):
dist[i][j] = min(dist[i][j], dist[i][u] + dist[u][j], dist[i][v] + dist[v][j])
for i in range(n):
for j in range(i + 1, n):
if dist[i][j] != table[i][j]:
print((-1))
sys.exit()
print(ans)
if __name__ == '__main__':
main()
| import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
import heapq
n = int(readline())
dist = [[INF] * n for _ in range(n)]
hq = []
table = [[0] * n for _ in range(n)]
for i in range(n):
a = list(map(int, readline().split()))
for j in range(i + 1, n):
hq.append((a[j], i, j))
table[i][j] = a[j]
dist[i][j] = a[j]
dist[j][i] = a[j]
for i in range(n):
dist[i][i] = 0
for i in range(n):
for j in range(n):
for k in range(n):
if dist[i][j] > dist[i][k] + dist[k][j]:
dist[i][j] = dist[i][k] + dist[k][j]
dist[j][i] = dist[i][j]
for i in range(n):
for j in range(i + 1, n):
if dist[i][j] != table[i][j]:
print((-1))
sys.exit()
ans = 0
for i in range(n):
for j in range(i + 1, n):
for k in range(n):
if k != i and k!= j:
if dist[i][j] == dist[i][k] + dist[k][j]:
break
else:
ans += dist[i][j]
print(ans)
if __name__ == '__main__':
main()
| p03600 |
n = int(eval(input()))
a = [list(map(int, input().split())) for _ in range(n)]
#print(a)
for k in range(n-1,-1,-1):
for i in range(n-1,-1,-1):
for j in range(n-1,-1,-1):
#print(k,i,j,a)
if (i==j or k==i or k==j):
continue
if (a[i][k]!=-1 and a[k][j]!=-1 and a[i][j] == a[i][k]+a[k][j]):
a[i][j] = -1
elif (a[i][k]!=-1 and a[k][j]!=-1 and a[i][j] > a[i][k]+a[k][j]):
print((-1))
exit()
#print(a)
ans = 0
for i in range(0,n-1):
for j in range(i,n):
if (a[i][j]!=-1):
ans += a[i][j]
print(ans) | import sys
input = sys.stdin.readline
def main():
n = int(eval(input()))
a = [list(map(int, input().split())) for _ in range(n)]
#print(a)
for k in range(n-1,-1,-1):
for i in range(n-1,-1,-1):
for j in range(n-1,-1,-1):
#print(k,i,j,a)
if (i==j or k==i or k==j):
continue
if (a[i][k]!=-1 and a[k][j]!=-1 and a[i][j] == a[i][k]+a[k][j]):
a[i][j] = -1
elif (a[i][k]!=-1 and a[k][j]!=-1 and a[i][j] > a[i][k]+a[k][j]):
print((-1))
exit()
#print(a)
ans = 0
for i in range(0,n-1):
for j in range(i,n):
if (a[i][j]!=-1):
ans += a[i][j]
print(ans)
if __name__=="__main__":
main()
| p03600 |
N = int(eval(input()))
A,B,Ans = [],[],0
for i in range(N):
x = list(map(int,input().split()))
A.append(x.copy())
B.append(x.copy())
for k in range(N):
for i in range(N):
for j in range(N):
B[i][j] = min(B[i][j],B[i][k]+ B[k][j])
if A!=B:
print((-1))
else:
for i in range(N):
for j in range(i+1,N):
exists = True
for k in range(N):
if k not in (i,j) and B[i][j]==B[i][k]+B[k][j]:
exists = False
if exists:
Ans += B[i][j]
print(Ans)
| N = int(eval(input()))
A,B,Ans = [],[],0
for i in range(N):
x = list(map(int,input().split()))
A.append(x[:])
B.append(x[:])
for k in range(N):
for i in range(N):
for j in range(N):
B[i][j] = min(B[i][j],B[i][k]+ B[k][j])
if A!=B:
print((-1))
else:
for i in range(N):
for j in range(i+1,N):
exists = True
for k in range(N):
if k not in (i,j) and B[i][j]==B[i][k]+B[k][j]:
exists = False
if exists:
Ans += B[i][j]
print(Ans)
| p03600 |
from heapq import heappush, heappop
def prim_heap(edges, n):
visited = [False] * n
heap = []
start = 0
for e in edges[start]:
heappush(heap, e)
visited[start] = True
res = 0
while heap:
cost, v = heappop(heap)
if visited[v]:
continue
visited[v] = True
res += cost
for c,u in edges[v]:
if visited[u]:
continue
heappush(heap, (c,u))
# print(visited)
return res if sum(visited) == n else -1
def warshall(d, n):
e = copy.deepcopy(d)
for k in range(n):
for i in range(n):
for j in range(n):
# print(d[i][k], d[k][j], d[i][j])
if i == k or k == j:
continue
if d[i][k] + d[k][j] < d[i][j]:
e[i][k] = 0
e[k][j] = 0
e[k][i] = 0
e[j][k] = 0
if d[i][k] + d[k][j] == d[i][j]:
# print(d[i][k], d[k][j], d[i][j], i,j,k)
e[i][j] = 0
e[j][i] = 0
return e
import copy
n = int(eval(input()))
edges = []
graph = [list(map(int, input().split())) for i in range(n)]
e = warshall(graph, n)
# print(e)
edge_list = [[] for _ in range(n)]
ans = 0
for i in range(n):
for j in range(n):
if e[i][j] > 0:
edge_list[i].append((e[i][j], j))
if j > i and e[i][j]:
ans += e[i][j]
print((ans if prim_heap(edge_list, n) != -1 else -1))
| def warshall(d, n):
e = copy.deepcopy(d)
for k in range(n):
for i in range(n):
for j in range(n):
# print(d[i][k], d[k][j], d[i][j])
if i == k or k == j:
continue
if d[i][k] + d[k][j] < d[i][j]:
return []
if d[i][k] + d[k][j] == d[i][j]:
# print(d[i][k], d[k][j], d[i][j], i,j,k)
e[i][j] = 0
e[j][i] = 0
return e
import copy
n = int(eval(input()))
edges = []
graph = [list(map(int, input().split())) for i in range(n)]
e = warshall(graph, n)
if e == []:
print((-1))
exit()
# print(e)
edge_list = [[] for _ in range(n)]
ans = 0
for i in range(n):
for j in range(n):
if e[i][j] > 0:
edge_list[i].append((e[i][j], j))
if j > i and e[i][j]:
ans += e[i][j]
print(ans)
| p03600 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, A):
EC = []
for i, r in enumerate(A):
for j, c in enumerate(r):
if c == 0:
break
EC.append((c, i, j))
EC.sort()
ans = 0
for c, i, j in EC:
q = [(0, i)]
min_path = c
f = True
while q:
c2, k = q.pop()
if k != i and c2 + A[k][j] <= min_path:
min_path = c2 + A[k][j]
f = False
else:
for l, c3 in enumerate(A[k]):
if l != i and c3 != 0 and c2 + c3 < c:
q.append((c2 + c3, l))
if min_path != c:
return -1
elif f:
ans += c
return ans
def main():
N = read_int()
A = [read_int_n() for _ in range(N)]
print(slv(N, A))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def warshall_floyd(g):
d = defaultdict(dict)
V = list(g.keys())
for v in g.values():
V.extend(list(v))
V = set(V)
for i in V:
for j in V:
if i in g and j in g[i]:
d[i][j] = g[i][j]
else:
d[i][j] = sys.maxsize
for k in g:
for i in g:
for j in g:
if d[i][j] > d[i][k] + d[k][j]:
d[i][j] = d[i][k] + d[k][j]
return d
@mt
def slv(N, A):
g = defaultdict(dict)
for i, r in enumerate(A):
for j, c in enumerate(r):
g[i][j] = c
g[j][i] = c
d = warshall_floyd(g)
for i in range(N):
for j in range(N):
if A[i][j] != d[i][j]:
return -1
ans = 0
for i in range(N):
for j in range(i, N):
for k in range(N):
if A[i][k] == 0:
continue
if j != k and A[i][k] + A[k][j] == A[i][j]:
break
else:
ans += A[i][j]
return ans
def main():
N = read_int()
A = [read_int_n() for _ in range(N)]
# N = 200
# A = [[random.randint(1, 10000) for _ in range(N)] for __ in range(N)]
# for i in range(N):
# A[i][i] = 0
print(slv(N, A))
if __name__ == '__main__':
main()
| p03600 |
n=int(eval(input()))
d=[]
ans=0
for i in range(n):
tmp=[int(j) for j in input().split()]
d.append(tmp)
for i in range(n):
for j in range(i+1,n):
ans+=d[i][j]
for i in range(n):
for j in range(i+1,n):
for k in range(n):
if i==k or j==k:
continue
if d[i][j]>d[i][k]+d[k][j]:
print((-1))
exit()
elif d[i][j]==d[i][k]+d[k][j]:
ans-=d[i][j]
break
print(ans)
| n=int(eval(input()))
d=[]
for i in range(n):
tmp=[int(j) for j in input().split()]
d.append(tmp)
ans=[[0]*n for i in range(n)]
for i in range(n):
for j in range(i+1,n):
ans[i][j]=d[i][j]
for i in range(n):
for j in range(i+1,n):
for k in range(n):
if i==k or j==k:
continue
if d[i][j]>d[i][k]+d[k][j]:
print((-1))
exit()
elif d[i][j]==d[i][k]+d[k][j]:
ans[i][j]=0
res=0
for i in range(n):
res+=sum(ans[i])
print(res)
| p03600 |
from heapq import *
from collections import defaultdict
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
n=int(input())
aa=LLI(n)
def main():
ans=sum(sum(ar) for ar in aa)//2
for w in range(n):
for u in range(n):
if u==w:continue
aau=aa[u]
for v in range(u):
if v==w:continue
d=aau[w]+aa[w][v]
if d<aau[v]:
print(-1)
exit()
if d==aau[v]:
ans-=d
print(ans)
main()
| import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
n=int(input())
aa=LLI(n)
def main():
ans=sum(sum(ar) for ar in aa)//2
fin=set()
for w in range(n):
aaw=aa[w]
for u in range(n):
if u==w:continue
aau=aa[u]
for v in range(u):
if v==w:continue
d=aau[w]+aaw[v]
if d<aau[v]:
print(-1)
exit()
if d==aau[v] and (u,v) not in fin:
ans-=d
fin.add((u,v))
print(ans)
main()
| p03600 |
N = int(eval(input()))
A = [list(map(int, input().split())) for _ in range(N)]
def main():
for i in range(N):
for j in range(N):
if i == j:
continue
for k in range(N):
if i == k or j == k:
continue
if A[i][j] > A[i][k] + A[k][j]:
print((-1))
return
for i in range(N):
for j in range(N):
if i == j:
continue
for k in range(N):
if i == k or j == k:
continue
if A[i][k] >= A[i][j] + A[k][j]:
A[i][k] = float('INF')
ans = 0
for i in range(N):
for j in range(N):
if A[i][j] == float('INF'):
continue
ans += A[i][j]
A[j][i] = 0
print(ans)
main()
| def main():
N = int(eval(input()))
A = [list(map(int, input().split())) for _ in range(N)]
ans = 0
for i in range(N):
A[i][i] = float('INF')
for i in range(N):
for j in range(i):
if i == j:
A[i][j] = float('INF')
continue
b = min(list(map(sum, list(zip(A[i], A[j])))))
if A[i][j] > b:
print((-1))
return
if b > A[i][j]:
ans += A[i][j]
print(ans)
main()
| p03600 |
n = int(eval(input()))
A = [list(map(int, input().split())) for _ in range(n)]
# 小さい順に調べていく
roads = []
for i in range(n-1):
for j in range(i+1, n):
roads.append((A[i][j], i, j))
roads = sorted(roads)
INF = 10**9*1
AD = [[INF]*n for _ in range(n)]
G = [[] for _ in range(n)]
edges = set()
from collections import deque
ok = True
ans = 0
for a, s, e in roads:
# s to e
q = deque([[s, 0]])
visited = [INF] * n
visited[s] = 0
while q:
node, dist = q.popleft()
if node == e:
# sからeにたどり着いて
if dist == a:
# あたえられた距離と同じならばOK
break
elif dist < a:
# あたえられた距離より小さいならばaは最短距離じゃないNG
ok = False
break
for nn, cost in G[node]:
if dist+cost < visited[nn]:
visited[nn] = dist+cost
q.append([nn, dist+cost])
else:
# sからeにたどり着けなかったら最短距離確定
AD[s][e] = a
G[s].append((e, a))
G[e].append((s, a))
ans += a
if not ok:
break
print((ans if ok else -1)) | n = int(eval(input()))
A = [list(map(int, input().split())) for _ in range(n)]
INF = 10**9 + 1
dp = [[INF]*n for _ in range(n)]
# コスト登録
for i, line in enumerate(A):
for j, a in enumerate(line):
dp[i][j] = a
for k in range(n):
for i in range(n):
for j in range(n):
if i == j:
continue
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j])
ans = 0
for i in range(n-1):
for j in range(i+1, n):
d = dp[i][j]
if d < A[i][j]:
ans = -1
break
else:
for k in range(n):
if k == i or k == j:
continue
if dp[i][k] + dp[k][j] == d:
break
else:
ans += d
if ans == -1:
break
print(ans)
| p03600 |
N = int(eval(input()))
A = [list(map(int, input().split())) for _ in range(N)]
def sol():
for k in range(N):
for i in range(N):
for j in range(N):
d = A[i][k] + A[k][j]
if d < A[i][j]:
return - 1
INF = 10**18
for k in range(N):
for i in range(N):
for j in range(N):
if k == i or k == j:
continue
if A[i][k] + A[k][j] == A[i][j]:
A[i][j] = INF
ans = 0
for i in range(N):
for j in range(i + 1, N):
if A[i][j] < INF:
ans += A[i][j]
return ans
print((sol()))
| N = int(eval(input()))
A = [list(map(int, input().split())) for _ in range(N)]
def sol():
for k in range(N):
for i in range(N):
for j in range(N):
d = A[i][k] + A[k][j]
if d < A[i][j]:
return - 1
ret = 0
for i in range(N):
for j in range(i + 1, N):
for k in range(N):
if k == i or k == j:
continue
if A[i][k] + A[k][j] == A[i][j]:
break
else:
ret += A[i][j]
return ret
print((sol()))
| p03600 |
N, *L = list(map(int, open(0).read().split()))
cost = []
for i, m in enumerate(zip(*[iter(L)]*N)):
cost.append(m)
ans = 0
for i in range(N):
for j in range(i):
m = min(cost[i][k]+cost[k][j] if k!=i and k!=j else 10**10 for k in range(N))
if m<cost[i][j]:
print((-1))
import sys
sys.exit()
if m!=cost[i][j]:
ans += cost[i][j]
print(ans) | N, *L = list(map(int, open(0).read().split()))
cost = []
for m in zip(*[iter(L)]*N):
cost.append(m)
ans = 0
for i in range(N):
for j in range(i):
for k in range(N):
if k==i or k==j:
continue
if cost[i][j]>cost[i][k]+cost[k][j]:
print((-1))
import sys
sys.exit()
if cost[i][j]==cost[i][k]+cost[k][j]:
break
else:
ans += cost[i][j]
print(ans)
| p03600 |
#!/usr/bin/env pypy3
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
import copy
################
class UnionFind():
"""
parents : 親要素(findしない場合は根ではないことの注意)，根の場合は"-(要素数）"
find(x):要素xの属するグループの根を返す
size(x):要素xの属するグループの要素数を返す
same(x,y):x,yが同じグループに属しているか返す
members(x):要素xが属するグループに属する要素をリストで返す
roots:全ての根の要素を返す
group_count():グループの数を返す
all_group_members():{根要素：[そのグループに含まれる要素のリスト]}の辞書を返す
"""
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
################
##########################################
import heapq
class Dijkstra():
"""
・有向 / 無向は問わない(無向の場合は，逆向きの辺もたす)
・負のコストがない場合のみ
・計算量はO(E log|V|)
・heapを使うことで頂点を走査する必要がなくなる（代わりに，距離更新したものは確定でなくともqueに入れておく）
"""
#最短のpathをたす
class Edge():
#重み付き有向辺
def __init__(self, _to, _cost):
self.to =_to
self.cost = _cost
def __init__(self, V):
#引数Vは頂点数
self.G = [[] for _ in range(V)] #隣接リストG[u][i]が頂点uのi番目の辺
self. _E = 0 #辺の数
self._V = V #頂点数
#proparty - 辺の数
def E(self):
return self._E
#proparty - 頂点数
def V(self):
return self._V
def add(self, _from, _to, _cost):
#2頂点と辺のコストを追加
self.G[_from].append(self.Edge(_to,_cost))
self._E +=1
def add2(self, _from, _to, _cost):
#2頂点と辺のコスト（無向）を追加
self.G[_from].append(self.Edge(_to, _cost))
self.G[_to].append(self.Edge(_from, _cost))
self._E +=1
def shortest_path(self,s,g):
#始点sから頂点iまでの最短経路長のリストを返す
que = [] #priority queue
d = [float("inf")] * self.V()
prev = [None]*self.V() #prev[j]は，sからjへ最短経路で行くときのjの一つ前の場所
d[s] = 0
heapq.heappush(que,(0,s)) #始点の距離と頂点番号をヒープに追加
while len(que)!=0:
#キューに格納されてある中で一番コストが小さい頂点を取り出す
cost,v = heapq.heappop(que)
#キューに格納された最短経路長候補がdの距離よりも大きい場合に処理をスキップ
if d[v] < cost:
continue
#頂点vに隣接する各頂点iに対して，vを経由した場合の距離を計算して，これがd[i]よりも小さい場合に更新
for i in range(len(self.G[v])):
e = self.G[v][i] #vのi個目の隣接辺
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost #更新
prev[e.to] = v
heapq.heappush(que,(d[e.to],e.to)) #queに新たな最短経路長候補を追加
#sからgまでの最短経路
path = []
pos = g #今いる場所，ゴールで初期化
for _ in range(self.V()+1):
path.append(pos)
if pos == s:
break
#print("pos:",format(pos))
pos = prev[pos]
path.reverse()
#print(path)
return d[g]#,path
########################
def main():
mod=10**9+7
N=I()
adj=[[] for _ in range(N)]
A=[[]for _ in range(N)]
for i in range(N):
A[i]=LI()
def warshall_floyd(D):
d=copy.deepcopy(D)
#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
mA=[]
for i in range(N):
for j in range(i+1,N):
a=[A[i][j],i,j]
mA.append(a)
mA.sort()
g_cnt=N
ans=0
if A==warshall_floyd(A):
uf=UnionFind(N)
djk = Dijkstra(N)
for i in range(len(mA)):
if g_cnt==1:#とりあえず連結になるまでは新しい辺を足す
d_ij= djk.shortest_path(mA[i][1],mA[i][2])
if d_ij==A[mA[i][1]][mA[i][2]]:#最小を更新できるなら辺をたす
continue
else:
djk.add2(mA[i][1],mA[i][2],mA[i][0])
ans+=mA[i][0]
else:
uf.union(mA[i][1],mA[i][2])
g_cnt = uf.group_count()
djk.add2(mA[i][1],mA[i][2],mA[i][0])
ans+=mA[i][0]
else:
ans=-1
print(ans)
main() | #!/usr/bin/env pypy3
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
inf=10*20
N=I()
A=[[]for _ in range(N)]
A2=[[1]*N for _ in range(N)]
ans=0
for i in range(N):
A[i]=LI()
ans+=sum(A[i])
def warshall_floyd(d):
#d[i][j]: iからjへの最短距離
for k in range(N):
for i in range(N):
if k==i:
continue
for j in range(N):
if j==i or j==k:
continue
dd=d[i][k] + d[k][j]
#d[i][j] = min(d[i][j],d[i][k] + d[k][j])
if dd==d[i][j]:
A2[i][j]=0
elif dd<d[i][j]:
return -1
return 1
if warshall_floyd(A)==-1:
ans=-2
else:
ans=0
for i in range(N):
for j in range(N):
ans+=A[i][j]*A2[i][j]
print((ans//2))
main() | p03600 |
import heapq
from collections import deque
N = int(eval(input()))
A = [[int(a) for a in input().split()] for _ in range(N)]
def dijkstra_heap(s, edge, n):
#始点sから各頂点への最短距離
d = [10**9+1] * n
used = [True] * n #True:未確定
d[s] = 0
used[s] = False
edgelist = []
for a,b in edge[s]:
heapq.heappush(edgelist,a*(10**6)+b)
while len(edgelist):
minedge = heapq.heappop(edgelist)
#まだ使われてない頂点の中から最小の距離のものを探す
if not used[minedge%(10**6)]:
continue
v = minedge%(10**6)
d[v] = minedge//(10**6)
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
return d
Road = [[] for _ in range(N)]
h = []
for i in range(N):
for j in range(i+1, N):
heapq.heappush(h, (A[i][j], i, j))
m = h[0][0]
ans = 0
while h:
t = heapq.heappop(h)
cost = t[0]
i = t[1]
j = t[2]
if cost < 2*m:
Road[i].append((cost, j))
Road[j].append((cost, i))
else:
d = dijkstra_heap(i, Road, N)
if d[j] > cost:
Road[i].append((cost, j))
Road[j].append((cost, i))
elif d[j] < cost:
ans = -1
break
if ans == 0:
for i in range(N):
for t in Road[i]:
ans += t[0]
ans //= 2
print(ans) | import heapq
from collections import deque
N = int(eval(input()))
A = [[int(a) for a in input().split()] for _ in range(N)]
def dijkstra_heap(s, edge, n):
#始点sから各頂点への最短距離
d = [10**9+1] * n
used = [True] * n #True:未確定
d[s] = 0
used[s] = False
edgelist = []
for a,b in edge[s]:
heapq.heappush(edgelist,a*(10**6)+b)
while len(edgelist):
minedge = heapq.heappop(edgelist)
#まだ使われてない頂点の中から最小の距離のものを探す
if not used[minedge%(10**6)]:
continue
v = minedge%(10**6)
d[v] = minedge//(10**6)
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
return d
Road = [[] for _ in range(N)]
h = []
for i in range(N):
for j in range(i+1, N):
heapq.heappush(h, (A[i][j], i, j))
m = h[0][0]
D = [[10**9+1]*N for _ in range(N)]
ans = 0
while h:
t = heapq.heappop(h)
cost = t[0]
i = t[1]
j = t[2]
if cost < 2*m:
Road[i].append((cost, j))
Road[j].append((cost, i))
D[i][j] = cost
D[j][i] = cost
elif D[i][j] > cost:
D[i] = dijkstra_heap(i, Road, N)
if D[i][j] > cost:
Road[i].append((cost, j))
Road[j].append((cost, i))
D[i][j] = cost
D[j][i] = cost
if D[i][j] < cost:
ans = -1
break
if ans == 0:
for i in range(N):
for t in Road[i]:
ans += t[0]
ans //= 2
print(ans) | p03600 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return eval(input())
def main():
N = I()
G = []
dp = []
for _ in range(N):
a = LI()
G.append(a)
dp.append(a)
for i in range(N):
for j in range(N):
for k in range(N):
if G[i][j] > G[i][k] + G[k][j]:
print((-1))
return
for k in range(N):
for i in range(N):
for j in range(N):
if j == k or k == i:
continue
if dp[i][k] == inf or dp[i][j] == inf or dp[j][k] == inf:
continue
if G[i][j] == G[i][k] + G[k][j]:
# i->jは要らない
dp[i][j] = inf
cnt = 0
for i in range(N):
for j in range(N):
if dp[i][j] < inf:
cnt += dp[i][j]
print((cnt // 2))
main()
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return eval(input())
def main():
N = I()
G = []
for _ in range(N):
a = LI()
G.append(a)
dp = copy.deepcopy(G)
for i in range(N):
for j in range(N):
for k in range(N):
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j])
if dp != G:
print((-1))
return
for k in range(N):
for i in range(N):
for j in range(N):
if j == k:
continue
if i == k:
continue
if dp[i][k] == 0 or dp[i][j] == 0 or dp[j][k] == 0:
continue
if dp[i][j] == dp[i][k] + dp[k][j]:
dp[i][j] = 0
dp[j][i] = 0
cnt = 0
for i in range(N):
for j in range(N):
cnt += dp[i][j]
print((cnt // 2))
main()
| p03600 |
import sys
import copy
n = int(eval(input()))
dist = [list(map(int,input().split())) for _ in range(n)]
e = copy.deepcopy(dist)
for k in range(n):
for i in range(n):
for j in range(n):
if dist[i][j]>dist[i][k] + dist[k][j]:
print((-1))
sys.exit()
if dist[i][j]==dist[i][k] + dist[k][j] and i!=j and i!=k and j!=k:
#print(i,j,k)
e[i][j]=float("inf")
#[print(*dist[l]) for l in range(n)]
ans = 0
for i in range(n):
for j in range(n):
if e[i][j]!=float("inf"):
ans += dist[i][j]
print((ans//2)) | import sys
import copy
n = int(eval(input()))
dist = [list(map(int,input().split())) for _ in range(n)]
e = copy.deepcopy(dist)
for k in range(n):
for i in range(n):
for j in range(n):
if dist[i][j]>dist[i][k] + dist[k][j]:
print((-1))
sys.exit()
if i!=j and i!=k and j!=k and dist[i][j]==dist[i][k] + dist[k][j]:
#print(i,j,k)
e[i][j]=float("inf")
#[print(*dist[l]) for l in range(n)]
ans = 0
for i in range(n):
for j in range(n):
if e[i][j]!=float("inf"):
ans += dist[i][j]
print((ans//2))
| p03600 |
def main():
from heapq import heappush, heappop
from operator import itemgetter
n = int(eval(input()))
a = [[int(x) for x in input().split()] for _ in range(n)]
for i in range(n):
for j in range(n):
if a[i][j] != min(a[i][k] + a[k][j] for k in range(n)):
print((-1))
return
h = []
for r, row in enumerate(a):
for c, cell in enumerate(row):
if r == c: break
bit = (1 << r) | (1 << c)
heappush(h, (cell, bit)) # dist,bit
pathes = set()
while h:
dist, bit = heappop(h)
is_path = True
for d1, p1 in pathes:
for d2, p2 in pathes:
xor = p1 ^ p2
if (xor == bit) and (dist >= d1 + d2):
is_path = False
break
if not is_path:
break
if is_path:
pathes.add((dist, bit))
print((sum(map(itemgetter(0), pathes))))
if __name__ == '__main__':
main()
| def main():
from heapq import heappush, heappop
n = int(eval(input()))
a = [[int(x) for x in input().split()] for _ in range(n)]
for i in range(n):
for j in range(n):
if a[i][j] != min(a[i][k] + a[k][j] for k in range(n)):
print((-1))
return
h = []
for r, row in enumerate(a):
for c, cell in enumerate(row):
if r == c: break
heappush(h, (cell, r, c)) # dist,r,c
pathes = []
while h:
dist, r, c = heappop(h)
is_path = True
for k in range(n):
if k == r or k == c: continue
if dist >= a[r][k] + a[k][c]:
is_path = False
break
if is_path:
pathes.append(dist)
print((sum(pathes)))
if __name__ == '__main__':
main()
| p03600 |
def main():
from heapq import heappush, heappop
n = int(eval(input()))
a = [[int(x) for x in input().split()] for _ in range(n)]
for i in range(n):
for j in range(n):
if a[i][j] != min(a[i][k] + a[k][j] for k in range(n)):
print((-1))
return
h = []
for r, row in enumerate(a):
for c, cell in enumerate(row):
if r == c: break
heappush(h, (cell, r, c)) # dist,r,c
pathes = []
while h:
dist, r, c = heappop(h)
is_path = True
for k in range(n):
if k == r or k == c: continue
if dist >= a[r][k] + a[k][c]:
is_path = False
break
if is_path:
pathes.append(dist)
print((sum(pathes)))
if __name__ == '__main__':
main()
| def main():
n = int(eval(input()))
a = [[int(x) for x in input().split()] for _ in range(n)]
for i in range(n):
for j in range(n):
for k in range(n):
if a[i][j] > a[i][k] + a[k][j]:
print((-1))
return
ret = 0
for i in range(n):
for j in range(i):
for k in range(n):
if k == i or k == j: continue
if a[i][j] == a[i][k] + a[k][j]: break # 辺ではない
else:
ret += a[i][j]
print(ret)
if __name__ == '__main__':
main()
| p03600 |
import heapq
N = int(eval(input()))
A = [list(map(int, input().split())) for _ in range(N)]
used = [[False] * N for _ in range(N)]
ans = 0
for i in range(N):
for j in range(N):
via = i
for k in range(N):
if A[i][j] > A[i][k] + A[k][j]:
print((-1))
exit()
if k == i or k == j:
continue
if A[i][j] == A[i][k] + A[k][j]:
via = k
if i >= j:
continue
if not (used[i][via] and used[via][i]):
used[i][via] = True
used[via][i] = True
ans += A[i][via]
if not (used[via][j] and used[j][via]):
used[via][j] = True
used[j][via] = True
ans += A[via][j]
print(ans)
| import heapq
N = int(eval(input()))
A = [list(map(int, input().split())) for _ in range(N)]
ans = 0
for i in range(N):
for j in range(N):
via_k = float('inf')
for k in range(N):
if A[i][j] > A[i][k] + A[k][j]:
print((-1))
exit()
if k == i or k == j:
continue
via_k = min(via_k, A[i][k] + A[k][j])
if i <= j:
continue
if A[i][j] < via_k:
ans += A[i][j]
print(ans)
| p03600 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
#B
#C
"""
a,b,c,d,e,f = LI()
a *= 100
b *= 100
ans = [a,0]
for i in range(f//a+1):
for j in range((f-a*i)//b+1):
for k in range((f-a*i-b*j)//c+1):
for l in range((f-a*i-b*j-c*k)//d+1):
if i or j or k or l:
s = c*k+d*l
w = a*i+b*j
q = w*e//100
if s <= q:
if w+s <= f:
if ans[1]/ans[0] < s/(s+w):
ans = [w+s,s]
print(*ans)
"""
#D
n = I()
a = LIR(n)
d = [[a[i][j] for i in range(n)] for j in range(n)]
l = [[[i] for j in range(n)] for i in range(n)]
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]
l[i][j] = l[i][k]+l[k][j]
if a != d:
print((-1))
quit()
ans = 0
for i in range(n):
for j in range(n):
if len(l[i][j]) == 4:
ans += d[i][j]
ans //= 2
print(ans)
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
| #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
#B
#C
"""
a,b,c,d,e,f = LI()
a *= 100
b *= 100
ans = [a,0]
for i in range(f//a+1):
for j in range((f-a*i)//b+1):
for k in range((f-a*i-b*j)//c+1):
for l in range((f-a*i-b*j-c*k)//d+1):
if i or j or k or l:
s = c*k+d*l
w = a*i+b*j
q = w*e//100
if s <= q:
if w+s <= f:
if ans[1]/ans[0] < s/(s+w):
ans = [w+s,s]
print(*ans)
"""
#D
n = I()
a = LIR(n)
d = [[a[i][j] for i in range(n)] for j in range(n)]
l = [[1 for j in range(n)] for i in range(n)]
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]
l[i][j] = l[i][k]+l[k][j]
if a != d:
print((-1))
quit()
ans = 0
for i in range(n):
for j in range(n):
if l[i][j] == 4:
ans += d[i][j]
ans //= 2
print(ans)
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
| p03600 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
#B
#C
"""
a,b,c,d,e,f = LI()
a *= 100
b *= 100
ans = [a,0]
for i in range(f//a+1):
for j in range((f-a*i)//b+1):
for k in range((f-a*i-b*j)//c+1):
for l in range((f-a*i-b*j-c*k)//d+1):
if i or j or k or l:
s = c*k+d*l
w = a*i+b*j
q = w*e//100
if s <= q:
if w+s <= f:
if ans[1]/ans[0] < s/(s+w):
ans = [w+s,s]
print(*ans)
"""
#D
n = I()
d = LIR(n)
l = [[1 for j in range(n)] for i in range(n)]
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]:
print((-1))
quit()
if d[i][j] == d[i][k]+d[k][j]:
l[i][j] = l[i][k]+l[k][j]
ans = 0
for i in range(n):
for j in range(n):
if l[i][j] == 4:
ans += d[i][j]
ans //= 2
print(ans)
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
| #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
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)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n = I()
d = LIR(n)
for k in range(n):
for i in range(n):
for j in range(n):
if d[i][k]+d[k][j] < d[i][j]:
print((-1))
return
ans = 0
for i in range(n):
for j in range(i+1,n):
for k in range(n):
if k in (i,j):
continue
if d[i][k]+d[k][j] <= d[i][j]:
break
else:
ans += d[i][j]
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
| p03600 |
from functools import reduce
import math
import copy
def main():
# 文字列の2進数を数値にする
# '101' → '5'
# 文字列の頭に'0b'をつけてint()にわたす
# binary = int('0b'+'101',0)
# 2進数で立っているbitを数える
# 101(0x5) → 2
# cnt_bit = bin(5).count('1')
# N! を求める
# f = math.factorial(N)
# N の逆元
# N_inv = pow(N,MOD-2,MOD)
# nCr
# Nの階乗 * rの階乗の逆元 * n-rの階乗の逆元
# 切り捨て
# 4 // 3
# 切り上げ
#-(-4 // 3)
# 初期値用:十分大きい数(100億)
INF = float("inf")
# 大きな素数
MOD = 10**9+7
# 1文字のみを読み込み
# 入力:2
# a = input().rstrip()
# 変数:a='2'
# スペース区切りで標準入力を配列として読み込み
# 入力:2 4 5 7
# a, b, c, d = (int(_) for _ in input().split())
# 変数:a=2 b=4 c=5 d =7
# 1文字ずつ標準入力を配列として読み込み
# 入力:2 4 5 7
# a = list(int(_) for _ in input().split())
# 変数:a = [2, 4, 5, 7]
# 1文字ずつ標準入力を配列として読み込み
# 入力:2457
# a = list(int(_) for _ in input())
# 変数:a = [2, 4, 5, 7]
N = int(eval(input()))
a = []
t_ans = {}
ans = 0
for i in range(N):
a.append(list(int(_) for _ in input().split()))
d = copy.deepcopy(a)
for k in range(N):
for i in range(N):
for j in range(N):
if a[i][j] > a[i][k]+a[k][j]:
print((-1))
exit()
elif a[i][j] == a[i][k]+a[k][j] and a[i][j] != 0 and k!=i and k!=j:
d[i][j] = 0
# if ((i,k) not in t_ans and (k,i) not in t_ans):
# t_ans[i,k] = a[i][k]
# elif (i,k) in t_ans and t_ans[i,k] > a[i][k]:
# t_ans[i,k] = a[i][k]
# elif (k,i) in t_ans and t_ans[k,i] > a[i][k]:
# t_ans[i,k] = a[i][k]
# if ((k,j) not in t_ans and (j,k) not in t_ans):
# t_ans[k,j] = a[k][j]
# elif (k,j) in t_ans and t_ans[k,j] > a[k][j]:
# t_ans[k,j] = a[k][j]
# elif (j,k) in t_ans and t_ans[j,k] > a[k][j]:
# t_ans[j,k] = a[k][j]
for i in range(N):
ans += sum(d[i])
print((ans//2))
if __name__ == '__main__':
main()
| from functools import reduce
import math
import copy
def main():
# 文字列の2進数を数値にする
# '101' → '5'
# 文字列の頭に'0b'をつけてint()にわたす
# binary = int('0b'+'101',0)
# 2進数で立っているbitを数える
# 101(0x5) → 2
# cnt_bit = bin(5).count('1')
# N! を求める
# f = math.factorial(N)
# N の逆元
# N_inv = pow(N,MOD-2,MOD)
# nCr
# Nの階乗 * rの階乗の逆元 * n-rの階乗の逆元
# 切り捨て
# 4 // 3
# 切り上げ
#-(-4 // 3)
# 初期値用:十分大きい数(100億)
INF = float("inf")
# 大きな素数
MOD = 10**9+7
# 1文字のみを読み込み
# 入力:2
# a = input().rstrip()
# 変数:a='2'
# スペース区切りで標準入力を配列として読み込み
# 入力:2 4 5 7
# a, b, c, d = (int(_) for _ in input().split())
# 変数:a=2 b=4 c=5 d =7
# 1文字ずつ標準入力を配列として読み込み
# 入力:2 4 5 7
# a = list(int(_) for _ in input().split())
# 変数:a = [2, 4, 5, 7]
# 1文字ずつ標準入力を配列として読み込み
# 入力:2457
# a = list(int(_) for _ in input())
# 変数:a = [2, 4, 5, 7]
N = int(eval(input()))
a = []
ans = 0
for i in range(N):
a.append(list(int(_) for _ in input().split()))
d = copy.deepcopy(a)
for k in range(N):
for i in range(N):
for j in range(N):
if a[i][j] > a[i][k]+a[k][j]:
print((-1))
exit()
elif a[i][j] == a[i][k]+a[k][j] and a[i][j] != 0 and k!=i and k!=j:
d[i][j] = 0
for i in range(N):
ans += sum(d[i])
print((ans//2))
if __name__ == '__main__':
main()
| p03600 |
import copy
from itertools import product, combinations
N = int(eval(input()))
dp = []
for _ in range(N):
dp.append(list(map(int, input().split(' '))))
original = copy.deepcopy(dp)
for k, i, j in product(list(range(N)), repeat=3):
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j])
if dp == original:
route_set = set()
costs = []
for i in range(N):
for j in range(i + 1, N):
route_set.add(dp[i][j])
costs.append(dp[i][j])
route_set = route_set - set(map(sum, combinations(costs, r=2)))
print((sum([cost for cost in costs if cost in route_set])))
else:
print((-1))
| import copy
from itertools import product, combinations
N = int(eval(input()))
dp = []
for _ in range(N):
dp.append(list(map(int, input().split(' '))))
original = copy.deepcopy(dp)
for k, i, j in product(list(range(N)), repeat=3):
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j])
if dp == original:
cost = 0
for i in range(N):
for j in range(i + 1, N):
for k in range(N):
if k == i or k == j:
continue
if dp[i][j] == dp[i][k] + dp[k][j]:
break
else:
cost += dp[i][j]
print(cost)
else:
print((-1))
| p03600 |
import sys
from itertools import permutations, combinations
def solve():
input = sys.stdin.readline
N = int(eval(input()))
A = [[int(a) for a in input().split()] for _ in range(N)]
length = 0
possible = True
for a in range(N):
for b, l in enumerate(A[a]):
for k in range(N):
if k != a and k != b:
if l > A[a][k] + A[k][b]:
possible = False
break
elif l == A[a][k] + A[k][b]:
break
else: length += l
if not possible:
print((-1))
break
else: print((length // 2))
return 0
if __name__ == "__main__":
solve()
| import sys
from itertools import permutations, combinations
def solve():
input = sys.stdin.readline
N = int(eval(input()))
A = [[int(a) for a in input().split()] for _ in range(N)]
length = 0
possible = True
for a, b in combinations(list(range(N)), 2):
Lab = A[a][b]
for k in range(N):
if k != a and k != b:
if Lab > A[a][k] + A[k][b]:
possible = False
break
elif Lab == A[a][k] + A[k][b]:
break
else: length += Lab
if not possible:
print((-1))
break
else: print(length)
return 0
if __name__ == "__main__":
solve() | p03600 |
import sys
from itertools import permutations, combinations
def solve():
input = sys.stdin.readline
N = int(eval(input()))
A = [[int(a) for a in input().split()] for _ in range(N)]
length = 0
possible = True
for a, b in combinations(list(range(N)), 2):
Lab = A[a][b]
create_pass = True
for k in range(N):
if k != a and k != b:
if Lab > A[a][k] + A[k][b]:
possible = False
break
elif Lab == A[a][k] + A[k][b]:
create_pass = False
break
if create_pass: length += Lab
if not possible:
print((-1))
break
else: print(length)
return 0
if __name__ == "__main__":
solve() | import sys
from itertools import combinations
def solve():
input = sys.stdin.readline
N = int(eval(input()))
A = dict()
for i in range(N):
A[i] = dict()
for j, a in enumerate(list(map(int, input().split()))): A[i][j] = a
length = 0
possible = True
for a, b in combinations(list(range(N)), 2):
Lab = A[a][b]
for k in range(N):
if k != a and k != b:
if Lab < A[a][k] + A[k][b]: continue
if Lab > A[a][k] + A[k][b]: possible = False
break
else: length += Lab
if possible: continue
print((-1))
break
else: print(length)
return 0
if __name__ == "__main__":
solve()
| p03600 |
import sys
from itertools import permutations, combinations
N=eval(input())
d=[ [ float("inf") for j in range(N+1) ] for i in range(N+1) ]
hen=[ [ 0 for j in range(N+1) ] for i in range(N+1) ]
ans=0
for i in range(N):
L=list(map(int, sys.stdin.readline().split()))
d[i][i]=0
for j in range(i+1,N):
lengh=L[j]
d[i+1][j+1]=lengh
d[j+1][i+1]=lengh
hen[i+1][j+1]=lengh
ans+=lengh
d[N][N]=0
P=list( permutations(list(range(1,N+1)),3) )
for i,j,k in P:
a=d[i][j]
b=d[j][k]
c=d[i][k]
if a+b<c:
print(-1)
quit()
if a+b==c and hen[i][k]!=0:
ans-=c
hen[i][k]=0
hen[k][i]=0
print(ans)
| import sys
from itertools import permutations, combinations
N=eval(input())
d=[ [ float("inf") for j in range(N+1) ] for i in range(N+1) ]
KOUHO=[]
for i in range(N):
L=list(map(int, sys.stdin.readline().split()))
d[i][i]=0
for j in range(i+1,N):
length=L[j]
d[i+1][j+1]=length
d[j+1][i+1]=length
KOUHO.append( (length,i+1,j+1))
ans=0
for c,i,j in KOUHO:
for k in range(1,N+1):
if k==i or k==j: continue
a=d[i][k]
b=d[j][k]
if a+b==c:
break
elif a+b<c:
print(-1)
quit()
else:
ans+=c
print(ans)
| p03600 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N = int(readline())
A = [[int(i) for i in readline().split()] for _ in range(N)]
via_min = [[10**15] * N for _ in range(N)]
for i in range(N):
for j in range(N):
for k in range(N):
if k == i or k == j:
continue
via_min[i][j] = min(via_min[i][j], A[i][k] + A[k][j])
ans = 0
for i in range(N):
for j in range(i+1,N):
if via_min[i][j] < A[i][j]:
print((-1))
exit()
elif via_min[i][j] == A[i][j]:
continue
else:
ans += A[i][j]
print(ans)
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N = int(readline())
A = [[int(i) for i in readline().split()] for _ in range(N)]
via_min = [[10**15] * N for _ in range(N)]
ans = 0
for i in range(N-1):
for j in range(i+1,N):
d = A[i][j]
flag = True
for k in range(N):
if k == i or k == j:
continue
tmp = A[i][k] + A[k][j]
if tmp < d:
print((-1))
exit()
elif tmp == d:
flag = False
break
if flag:
ans += d
print(ans)
if __name__ == "__main__":
main()
| p03600 |
import heapq
INFTY = 10**12
def dist(cur,b):
d = [INFTY for _ in range(N)]
d[cur[1]] = 0
hist = [0 for _ in range(N)]
hist[cur[1]] = 1
heap = [cur]
while heap:
cur = heapq.heappop(heap)
hist[cur[1]] = 1
for x in B[cur[1]]:
if hist[x[1]]==0:
if d[x[1]]>cur[0]+x[0]:
d[x[1]] = cur[0]+x[0]
heapq.heappush(heap,(d[x[1]],x[1]))
return d[b]
N = int(eval(input()))
A = {(i,j):INFTY for i in range(N) for j in range(N)}
for i in range(N):
row = list(map(int,input().split()))
for j in range(N):
A[(i,j)] = row[j]
G = list(A.items())
G = sorted(G,key=lambda x:x[1])
B = {i:[] for i in range(N)}
ind = 0
for x in G:
a,b = x[0][0],x[0][1]
d = x[1]
if d>0:
dmin = dist([0,a],b)
# print("dmin({},{})={}".format(a,b,dmin))
if dmin>d:
if (d,b) not in B[a]:
B[a].append((d,b))
if (d,a) not in B[b]:
B[b].append((d,a))
elif d>dmin:
ind = 1
break
# print("B={}".format(B))
if ind==1:
print((-1))
else:
cnt = 0
for a in B:
for x in B[a]:
cnt += x[0]
print((cnt//2)) | N = int(eval(input()))
A = [list(map(int,input().split())) for _ in range(N)]
cnt = 0
for i in range(N-1):
for j in range(i+1,N):
amin = 10**10
for k in range(N):
if k!=i and k!=j:
amin = min(amin,A[i][k]+A[k][j])
if A[i][j]>amin:
cnt = -1
break
elif A[i][j]<amin:
cnt += A[i][j]
if cnt==-1:break
print(cnt) | p03600 |
N = int(eval(input()))
A = [list(map(int,input().split())) for _ in range(N)]
cnt = 0
for i in range(N):
for j in range(N):
cnt += A[i][j]
flg = 0
B = [[0 for _ in range(N)] for _ in range(N)]
for k in range(N):
for i in range(N):
for j in range(N):
if A[i][j]>A[i][k]+A[k][j]:
flg = -1
break
elif A[i][j]==A[i][k]+A[k][j] and A[i][k]*A[k][j]>0 and B[i][j]==0:
cnt -= A[i][j]
B[i][j]=1
if flg==-1:break
if flg==-1:break
if flg==-1:
print((-1))
else:
print((cnt//2)) | N = int(eval(input()))
A = [[0 for _ in range(N+1)]]
for _ in range(N):
a = list(map(int,input().split()))
a.insert(0,0)
A.append(a)
tot = 0
for i in range(1,N):
for j in range(i,N+1):
tot += A[i][j]
for i in range(1,N):
for j in range(i+1,N+1):
for k in range(1,N+1):
if k!=i and k!=j:
if A[i][j]>A[i][k]+A[k][j]:
tot = -1
break
elif A[i][j]==A[i][k]+A[k][j]:
tot -= A[i][j]
break
if tot<0:break
if tot<0:break
print(tot) | p03600 |
from heapq import heappop, heappush
def bfs(x, y):
path = [float('inf')] * N
q = []
heappush(q, (0, x))
path[x] = 0
while q:
s, p = heappop(q)
for np, d in edge[p]:
nd = path[p] + d
if path[np] > nd:
path[np] = nd
heappush(q, (nd, np))
return path[y]
N = int(eval(input()))
A = [list(map(int, input().split())) for _ in range(N)]
q = []
for i in range(N):
for j in range(i + 1, N):
q.append((A[i][j], i, j))
q.sort()
# B = [[float('inf')] * N for _ in range(N)]
ans = 0
edge = [[] for _ in range(N)]
for a, i, j in q:
b = bfs(i, j)
if a < b:
edge[i].append((j, a))
edge[j].append((i, a))
ans += a
elif a == b:
pass
else:
print((-1))
exit()
print(ans)
| N = int(eval(input()))
A = [list(map(int, input().split())) for _ in range(N)]
dp = A
cnt = 0
for i in range(N):
for j in range(N):
if all(dp[i][j] < dp[i][k] + dp[k][j] for k in range(N) if k != i and k != j):
cnt += dp[i][j]
if any(dp[i][j] > dp[i][k] + dp[k][j] for k in range(N)):
print((-1))
exit()
print((cnt // 2))
| p03600 |
N = int(eval(input()))
A = [list(map(int, input().split())) for _ in range(N)]
dp = A
cnt = 0
for i in range(N):
for j in range(N):
if all(dp[i][j] < dp[i][k] + dp[k][j] for k in range(N) if k != i and k != j):
cnt += dp[i][j]
if any(dp[i][j] > dp[i][k] + dp[k][j] for k in range(N)):
print((-1))
exit()
print((cnt // 2))
| N = int(eval(input()))
A = [list(map(int, input().split())) for _ in range(N)]
dp = A
cnt = 0
for i in range(N - 1):
for j in range(i + 1, N):
if all(dp[i][j] < dp[i][k] + dp[k][j] for k in range(N) if k != i and k != j):
cnt += dp[i][j]
if any(dp[i][j] > dp[i][k] + dp[k][j] for k in range(N)):
print((-1))
exit()
print(cnt)
| p03600 |
N = int(eval(input()))
src = [list(map(int,input().split())) for i in range(N)]
ans = 0
for k in range(N):
for i in range(N):
for j in range(N):
if src[i][j] > src[i][k] + src[k][j]:
print((-1))
exit()
for i in range(N-1):
for j in range(i+1,N):
for k in range(N):
if k==i or k==j: continue
if src[i][j] == src[i][k] + src[k][j]:
break
else:
ans += src[i][j]
print(ans) | N = int(eval(input()))
A = [list(map(int,input().split())) for i in range(N)]
for k in range(N):
for i in range(N):
for j in range(N):
if A[i][j] > A[i][k] + A[k][j]:
print((-1))
exit()
ans = 0
for i in range(N-1):
for j in range(i+1,N):
for k in range(N):
if k==i or k==j: continue
if A[i][j] == A[i][k] + A[k][j]:
break
else:
ans += A[i][j]
print(ans) | p03600 |
"""from collections import *
from itertools import *
from bisect import *
from heapq import *
import math
from fractions import gcd"""
from heapq import*
N=int(eval(input()))
A=[list(map(int,input().split())) for i in range(N)]
data=[[] for i in range(N)]
for i in range(N):
for m in range(N):
if i==m:
continue
data[i].append([m,A[i][m],i*300+m])
visited={0}
stack=[]
dic={}
for p,c,i in data[0]:
if c in dic:
dic[c].append([p,i])
else:
dic[c]=[[p,i]]
stack.append(c)
heapify(stack)
value=0
usedpath=set()
while stack:
m=heappop(stack)
a,i=dic[m].pop()
if not a in visited:
visited.add(a)
usedpath.add(i)
value+=m
for p,c,i in data[a]:
if not p in visited:
if c in dic:
dic[c].append([p,i])
else:
dic[c]=[[p,i]]
heappush(stack,c)
idle_max=10**18
d=[[idle_max for i in range(N)] for m in range(N)]
for i in range(N):
d[i][i]=0
for i in usedpath:
i,m=i//300,i%300
d[i][m]=A[i][m]
d[m][i]=A[m][i]
for k in range(N):
for i in range(N):
for j in range(N):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
Alst=[[A[i][m],i,m] for i in range(N) for m in range(N)]
Alst=sorted(Alst,key=lambda x:x[0])
for B,i,m in Alst:
if d[i][m]<A[i][m]:
print((-1))
exit()
if d[i][m]>A[i][m]:
d[i][m]=A[i][m]
d[m][i]=A[m][i]
value+=A[i][m]
for i1 in range(N):
for j in range(N):
d[i1][j] = min(d[i1][j], d[i1][i] + d[i][j])
d[i1][j] = min(d[i1][j], d[i1][m] + d[m][j])
print(value)
| """from collections import *
from itertools import *
from bisect import *
from heapq import *
import math
from fractions import gcd"""
from heapq import*
N=int(eval(input()))
A=[list(map(int,input().split())) for i in range(N)]
for k in range(N):
for i in range(N):
for j in range(N):
if A[i][j]>A[i][k]+A[k][j]:
print((-1))
exit()
res = 0
for i in range(N-1):
for j in range(i+1, N):
for k in range(N):
if k==i or k == j:
continue
if A[i][j]==A[i][k]+A[k][j]:
break
else:
res += A[i][j]
print(res)
| p03600 |
n = int(eval(input()))
a = [list(map(int, input().split())) for i in range(n)]
b = [[1]*n for i in range(n)]
for i in range(n):
for j in range(n):
for k in range(n):
if a[i][k] + a[k][j] < a[i][j]:
print((-1))
exit()
elif a[i][k] + a[k][j] == a[i][j] and i!=k!=j:
b[i][j] = 0
ans = 0
for i in range(n):
for j in range(n):
if b[i][j]:
ans += a[i][j]
print((ans//2)) | n = int(eval(input()))
a = [list(map(int, input().split())) for i in range(n)]
b = [[1]*n for i in range(n)]
for k in range(n):
for i in range(n):
for j in range(n):
if a[i][k] + a[k][j] < a[i][j]:
print((-1))
exit()
elif a[i][k] + a[k][j] == a[i][j] and i!=k!=j:
b[i][j] = 0
ans = 0
for i in range(n):
for j in range(n):
if b[i][j]:
ans += a[i][j]
print((ans//2)) | p03600 |
import copy
N = int(eval(input()))
A = [list(map(int, input().split())) for i in range(N)]
B = copy.deepcopy(A)
ans = 0
for i in range(N):
ans += sum(A[i])
for j in range(N):
if i == j:
continue
for k in range(N):
if k == i or k == j:
continue
else:
if B[i][k] == B[i][j]+B[j][k]:
ans -= B[i][k]
B[i][k] = min(B[i][k], B[i][j]+B[j][k])
if A == B:
print((ans//2))
else:
print((-1))
| import copy
N = int(eval(input()))
A = [list(map(int, input().split())) for i in range(N)]
B = copy.deepcopy(A)
table = [[True]*N for i in range(N)]
ans = 0
for i in range(N):
for j in range(N):
if i == j:
continue
for k in range(N):
if k == i or k == j:
continue
else:
if B[i][k] == B[i][j]+B[j][k]:
table[i][k] = False
B[i][k] = min(B[i][k], B[i][j]+B[j][k])
if A == B:
for i in range(N):
for j in range(N):
if table[i][j]:
ans += B[i][j]
print((ans//2))
else:
print((-1))
| p03600 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.