input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
dp = [False] * (10 ** 5 + 10)
for i in range(1, K+1):
dp[i] = not all(dp[i-a] if i-a >= 0 else True for a in A)
print(("First" if dp[K] else "Second"))
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
dp = [False] * (10 ** 5 + 10)
for i in range(1, K+1):
# dp[i-a]の中でどこか一つでもFalseになるdp[i]があればTrueを設定する
# dp[i-a]がFalseということは、次の手番の相手を負かす取り方が存在するということになるので、この手番でa個取って相手の順番に回してしまえば勝ちが確定する
# お互いが交互に数字を言っていって、最後に30を言ったほうの負け（最大+3）まで
# みたいなゲームと同じ構造だと考えていい。上記のゲームで勝つには最後の数から逆算していけば、勝てる数字がわかるのと似ている
dp[i] = not all(dp[i-a] if i-a >= 0 else True for a in A)
print(("First" if dp[K] else "Second"))
|
p03170
|
n, k = list(map(int, input().split()))
arr = list(map(int, input().split()))
dp = [False] * (k + 1)
for i in range(1, k+1):
for a in arr:
if i - a >= 0 and not dp[i - a]:
dp[i] = True
print(("First" if dp[k] else "Second"))
|
n, k = list(map(int, input().split()))
arr = list(map(int, input().split()))
dp = [False] * (k + 1)
for i in range(k + 1):
if not dp[i]:
for a in arr:
if i + a > k:
break
dp[i + a] = True
print(("First" if dp[k] else "Second"))
|
p03170
|
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate
#from itertools import product
from bisect import bisect_left,bisect_right
import heapq
from math import floor, ceil
#from operator import itemgetter
#inf = 10**17
#mod = 10**9 + 7
N,K = list(map(int, input().split()))
a = list(map(int, input().split()))
dp = [0]*(K+1)
for i in range(1, K+1):
for j in a:
if i-j < 0:
continue
if dp[i-j] == 0:
dp[i] = 1
break
if dp[K]:
print('First')
else:
print('Second')
if __name__ == '__main__':
main()
|
def main():
N, K, *A = list(map(int, open(0).read().split()))
dp = [0] * (K + 1)
for i in range(K):
if dp[i]:
continue
for a in A:
if i + a > K:
break
dp[i + a] = 1
print(("First" if dp[-1] else "Second"))
if __name__ == "__main__":
main()
|
p03170
|
import sys
sys.setrecursionlimit(10**7)
N, K = list(map(int, input().split()))
A = [int(i) for i in input().split()]
def func():
for i in range(1, K+1):
for j in range(N):
if i - A[j] >= 0:
dp[i] |= ~dp[i - A[j]]
dp = [0 for i in range(K+1)]
func()
if dp[K]: print("First")
else: print("Second")
|
import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
A = [int(i) for i in input().split()]
dp = [0 for i in range(K+1)]
for i in range(K+1):
if not dp[i]:
for j in range(N):
if i + A[j] < K + 1:
dp[i+A[j]] = 1
if dp[K]: print("First")
else: print("Second")
|
p03170
|
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
dp = [False] * (K+1)
for i in range(1, K+1):
for j in range(N):
if 0 <= i - a[j] and not dp[i-a[j]]:
dp[i] = True
print(("First" if dp[K] else "Second"))
|
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
dp = [False] * (K+1)
for i in range(1, K+1):
for j in range(N):
if 0 <= i - a[j] and not dp[i-a[j]]:
dp[i] = True
break
print(("First" if dp[K] else "Second"))
|
p03170
|
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
dp = [False]*(k+1)
for i in range(1,k+1):
for j in range(n):
if i-a[j]<0:
break
if dp[i-a[j]]==False:
dp[i] = True
if dp[k]==True:
print("First")
else:
print("Second")
|
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
dp = [False]*(k+1)
for i in range(1,k+1):
for j in range(n):
if i-a[j]<0:
break
if dp[i-a[j]]==False:
dp[i] = True
break
if dp[k]==True:
print("First")
else:
print("Second")
|
p03170
|
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
dp=[False]*(k+1)
for i in range(k+1):
for j in range(n):
if i-a[j]>=0:
dp[i]|=not dp[i-a[j]]
if dp[k]:
print('First')
else:
print('Second')
|
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
dp=[False]*(2*k+1)
for i in range(k+1):
for j in a:dp[i+j]|=not dp[i]
if dp[k]:
print('First')
else:
print('Second')
|
p03170
|
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
dp=[0]*(2*k+1)
for i in range(k+1):
for j in a:dp[i+j]|=~dp[i]
if dp[k]:
print('First')
else:
print('Second')
|
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
dp=[False]*(2*k+1)
for i in range(k+1):
for j in a:dp[i+j]|=not dp[i]
if dp[k]:
print('First')
else:
print('Second')
|
p03170
|
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
dp = [0] * (K + 1)
for i in range(1, K + 1):
for j in range(N):
if i - a[j] >= 0 and dp[i - a[j]] == 0:
dp[i] = 1
print(('First' if dp[K] else 'Second'))
|
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
dp = [0] * (K + 1)
for i in range(1, K + 1):
for j in a:
if i - j >= 0 and dp[i - j] == 0:
dp[i] = 1
print(('First' if dp[K] else 'Second'))
|
p03170
|
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
mini=min(a)
dp1=[-1 for i in range(k+1)]
dp2=[-1 for i in range(k+1)]
for x in range(k+1):
if x == 0 or mini > x:
dp1[x]=False
dp2[x]=False
continue
dp1[x]=False
dp2[x]=False
for v in a:
if v>x:
continue
dp1[x]=dp1[x] or not dp2[x-v]
dp2[x]=dp2[x] or not dp1[x-v]
if dp1[k]:
print("First")
else:
print("Second")
|
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
mini=min(a)
dp=[-1 for i in range(k+1)]
for x in range(k+1):
if x == 0 or mini > x:
dp[x]=False
continue
dp[x]=False
for v in a:
if v>x:
continue
dp[x]=dp[x] or not dp[x-v]
if dp[k]:
print("First")
else:
print("Second")
|
p03170
|
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
dp=[False]*(k+1)
for i in range(1,len(dp)):
for x in a:
if i-x>=0:
dp[i]|=not dp[i-x]
print((("Second","First")[dp[k]]))
|
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
dp=[False]*(k+1+max(a))
for i in range(1+k):
if not dp[i]:
for x in a:
dp[i+x]=True
print((("Second","First")[dp[k]]))
|
p03170
|
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
def main():
n,k=LI()
dp=[0]*100100
l=LI()
for i in range(k):
for x in l:
if i+x<=k:
if dp[i+x]==0 and dp[i]==0:
dp[i+x]=1
# print(dp[:k+1])
return 'First' if dp[k] else 'Second'
# main()
print((main()))
|
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
def main():
n,k=LI()
l=LI()
dp=[0]*100100
for i in range(k):
for x in l:
y=dp[i]
if y==0 and i+x<100100:
dp[i+x]=1
if dp[k]==1:
return 'First'
return 'Second'
# main()
print((main()))
|
p03170
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
dp = [0] * (k+1)
for i in range(k+1):
dp[i] = 0
for j in a:
if j > i:
break
dp[i] = dp[i] or (1 - dp[i-j])
print((['Second', 'First'][dp[k]]))
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
dp = [0] * (k+1) #残りの石iで回ってきたときの勝敗
for i in range(k+1):
dp[i] = 0
for j in a:
if j > i:
break
if 1 - dp[i-j]:
dp[i] = 1
break
print((['Second', 'First'][dp[k]]))
|
p03170
|
import sys
input = sys.stdin.readline
n, k = list(map(int, input().split()))
a_list = list(map(int, input().split()))
dp = [False]*(k+1)
for i in range(1,k+1):
for j in range(n):
if i-a_list[j] >= 0:
dp[i] |= not(dp[i-a_list[j]])
if dp[k]:
print('First')
else:
print('Second')
|
import sys
input = sys.stdin.readline
def main():
n, k = list(map(int, input().split()))
a_list = list(map(int, input().split()))
dp = [False]*(k+1)
for i in range(1,k+1):
for j in range(n):
if i-a_list[j] >= 0:
dp[i] |= not(dp[i-a_list[j]])
if dp[k]:
print('First')
else:
print('Second')
main()
|
p03170
|
import sys
input = sys.stdin.readline
N = int(eval(input()))
S = [ord(c) for c in input().rstrip()]
Q = int(eval(input()))
k = list(map(int, input().split()))
dd = ord('D')
mm = ord('M')
cc = ord('C')
for l in k:
D = M = tmp = ans = 0
for i in range(N):
if i >= l:
if S[i-l] == dd:
tmp -= M
D -= 1
if S[i-l] == mm:
M -= 1
if S[i] == dd:
D += 1
if S[i] == mm:
M += 1
tmp += D
if S[i] == cc:
ans += tmp
print(ans)
|
import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
S = input().rstrip()
Q = int(eval(input()))
k = list(map(int, input().split()))
for l in k:
D = 0
M = 0
tmp = 0
ans = 0
for i in range(N):
if i >= l:
if S[i-l] == 'D':
tmp -= M
D -= 1
if S[i-l] == 'M':
M -= 1
if S[i] == 'D':
D += 1
if S[i] == 'M':
M += 1
tmp += D
if S[i] == 'C':
ans += tmp
print(ans)
main()
|
p03216
|
import sys
sys.setrecursionlimit(10**7)
readline = sys.stdin.buffer.readline
def readstr():return readline().rstrip().decode()
def readstrs():return list(readline().decode().split())
def readint():return int(readline())
def readints():return list(map(int,readline().split()))
def printrows(x):print(('\n'.join(map(str,x))))
def printline(x):print((' '.join(map(str,x))))
N = readint()
S = readstr()
Q = readint()
K = readints()
if 'D' not in S:
printrows([0]*Q)
exit()
ans = []
for k in K:
m = 0
c = 0
a = [0]
d = S.find('D')
e = S.rfind('D')
for i in range(d+1,min(N,d+k)):
if S[i]=='M':
m += 1
if S[i]=='C':
c += 1
a[-1] += m
a.append(a[-1])
for i in range(d+1,N):
if i+k-1<N:
if S[i+k-1]=='M':
m += 1
elif S[i+k-1]=='C':
c += 1
a[-1] += m
if S[i-1]=='M':
m -= 1
a[-1] -= c
elif S[i-1]=='C':
c -= 1
if S[i]=='D':
if i==e:
break
else:
a.append(a[-1])
ans.append(sum(a))
printrows(ans)
|
import sys
sys.setrecursionlimit(10**7)
readline = sys.stdin.buffer.readline
def readstr():return readline().rstrip().decode()
def readstrs():return list(readline().decode().split())
def readint():return int(readline())
def readints():return list(map(int,readline().split()))
def printrows(x):print(('\n'.join(map(str,x))))
def printline(x):print((' '.join(map(str,x))))
N = readint()
S = readstr()
Q = readint()
K = readints()
if 'D' not in S:
printrows([0]*Q)
exit()
d = S.find('D')
e = S.rfind('D')
ans = []
for k in K:
m = 0
c = 0
a = 0
for i in range(d+1,min(N,d+k)):
if S[i]=='M':
m += 1
if S[i]=='C':
c += 1
a += m
b = a
for i in range(d+1,N):
if i+k-1<N:
if S[i+k-1]=='M':
m += 1
elif S[i+k-1]=='C':
c += 1
a += m
if S[i-1]=='M':
m -= 1
a -= c
elif S[i-1]=='C':
c -= 1
if S[i]=='D':
b += a
if i==e:
break
ans.append(b)
printrows(ans)
|
p03216
|
import sys
rl = sys.stdin.readline
N = int(rl())
S = rl()
Q = int(rl())
ks = list(map(int,rl().split()))
ans = []
for k in ks:
d = m = 0
dm = dmc = 0
for i in range(N):
if i >= k:
if S[i-k] == 'D':
d -= 1
dm -= m
elif S[i-k] == 'M':
m -= 1
if S[i] == 'D':
d += 1
elif S[i] == 'M':
m += 1
dm += d
elif S[i] == 'C':
dmc += dm
ans.append(dmc)
print(*ans,sep='\n')
|
import sys
input = sys.stdin.readline
N = int(input())
S = input()
Q = int(input())
K = list(map(int,input().split()))
ans = []
for k in K:
d = m = dm = dmc = 0
for i in range(N):
if i >= k:
if S[i-k] == 'D':
d -= 1
dm -= m
elif S[i-k] == 'M':
m -= 1
if S[i] == 'D':
d += 1
elif S[i] == 'M':
m += 1
dm += d
elif S[i] == 'C':
dmc += dm
ans.append(dmc)
print(*ans, sep='\n')
|
p03216
|
N = int(eval(input()))
S = input().strip()
qn = int(eval(input()))
qs = list(map(int, input().split()))
dp = [[0,0,0]]
As = [0]*qn
d=m=dm=0
for i, w in enumerate(S):
i += 1
if w=="D":
d+=1
elif w == "M":
m+=1
dm+=d
elif w == "C":
for j, q in enumerate(qs):
ll = max(i-q, 0)
dd, mm, dmm = dp[ll]
As[j] += dm - dmm - dd*(m-mm)
dp.append([d,m,dm])
for a in As:
print(a)
|
N = int(eval(input()))
S = input().strip()
qn = int(eval(input()))
qs = list(map(int, input().split()))
dd,mm,cc = [0],[0],[0]
As = [0]*qn
d=m=dm=0
for i, w in enumerate(S):
i += 1
if w=="D":
d+=1
elif w == "M":
m+=1
dm+=d
elif w == "C":
for j, q in enumerate(qs):
ll = max(i-q, 0)
As[j] += dm - cc[ll] - dd[ll]*(m-mm[ll])
dd.append(d)
mm.append(m)
cc.append(dm)
for a in As:
print(a)
|
p03216
|
N = int(eval(input()))
S = input().strip()
qn = int(eval(input()))
qs = list(map(int, input().split()))
dp = [[0,0,0]]
As = [0]*qn
d=m=dm=0
for i, w in enumerate(S):
i += 1
if w=="D":
d+=1
elif w == "M":
m+=1
dm+=d
elif w == "C":
for j, q in enumerate(qs):
ll = max(i-q, 0)
dd, mm, dmm = dp[ll]
As[j] += dm - dmm - dd*(m-mm)
dp.append([d,m,dm])
for a in As:
print(a)
|
N = int(eval(input()))
S = input().strip()
qn = int(eval(input()))
qs = list(map(int, input().split()))
dd,mm,cc = [0],[0],[0]
As = [0]*qn
d=m=dm=0
for i, w in enumerate(S):
i += 1
if w=="D":
d+=1
elif w == "M":
m+=1
dm+=d
elif w == "C":
for j, q in enumerate(qs):
ll = max(i-q, 0)
As[j] += dm - cc[ll] - dd[ll]*(m-mm[ll])
dd.append(d)
mm.append(m)
cc.append(dm)
for a in As:
print(a)
|
p03216
|
# -*- coding: utf-8 -*-
s = input().strip()
#----------
loc_A=len(s)+1
loc_Z=-1
for i in range(len(s)):
if s[i] == "Z" and loc_Z < i:
loc_Z = i
elif s[i] == "A" and i < loc_A:
loc_A = i
print(( loc_Z - (loc_A - 1) ))
|
# -*- coding: utf-8 -*-
s=input().strip()
for i,word in enumerate(s):
if word == "A":
start = i
break
for i,word in enumerate( reversed(s) ):
if word == "Z":
end = len(s)-1-i
break
print(( end-start+1 ))
|
p03814
|
import sys
sys.setrecursionlimit(10000000)
import os
import math
import bisect
import collections
import itertools
import heapq
import re
import queue
# import fractions
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
S = iss()
s,e = 0,0
for i in range(len(S)):
if S[i] == 'A':
s = i
break
for i in range(len(S)):
if S[::-1][i] == 'Z':
e = i
break
print((len(S) - s - e))
if __name__ == '__main__':
main()
|
import sys
sys.setrecursionlimit(10000000)
import os
import math
import bisect
import collections
import itertools
import heapq
import re
import queue
# import fractions
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
S = iss()
A, Z = MAX, 0
for i in range(len(S)):
if S[i] == 'A':
A = min(A, i)
elif S[i] == 'Z':
Z = max(Z, i)
print((Z - A + 1))
if __name__ == '__main__':
main()
|
p03814
|
string = input().rstrip("\n")
string_r = "".join(reversed(string))
print((len(string) - string_r.index("Z") - string.index("A")))
|
[print(len(string) - string[::-1].index("Z") - string.index("A")) for string in [input()]]
|
p03814
|
prime = [False] * (10 ** 6)
prime[0] = True
prime[1] = True
for i in range(2, 10 ** 6):
if prime[i] == False:
for j in range(i * 2, 10 ** 6, i):
prime[j] = True
while True:
a, d, n = list(map(int, input().split()))
if a == 0:
break
cnt = 0
for i in range(a, 10 ** 6, d):
if prime[i] == False:
cnt += 1
if cnt == n:
print(i)
break
|
import math
prime = [False] * (10 ** 6)
prime[0] = True
prime[1] = True
limit = int(math.sqrt(10 ** 6) + 1)
for i in range(2, limit):
if prime[i] == False:
for j in range(i * 2, 10 ** 6, i):
prime[j] = True
while True:
a, d, n = list(map(int, input().split()))
if a == 0:
break
cnt = 0
for i in range(a, 10 ** 6, d):
if prime[i] == False:
cnt += 1
if cnt == n:
print(i)
break
|
p00722
|
def shuffle(deck,x,y):
cnter = 0
i = 0
sectiona = []
while (cnter < x):
nextsize = deck[i][1] - deck[i][0] + 1
if(x-cnter >= nextsize):
sectiona.append(deck[i])
cnter += nextsize
i += 1
else:
sectiona.append([deck[i][0],deck[i][0] + x-cnter - 1])
deck[i][0] = deck[i][0] + x-cnter
cnter = x
sectionb = []
while (cnter < y):
nextsize = deck[i][1] - deck[i][0] + 1
if(y-cnter >= nextsize):
sectionb.append(deck[i])
cnter += nextsize
i += 1
else:
sectionb.append([deck[i][0],deck[i][0] + y-cnter - 1])
deck[i][0] = deck[i][0] + y-cnter
cnter = y
newdeck = deck[i:] + sectionb + sectiona
return newdeck
def hitnum(a,r):
if a[1] <= r:
return a[1]-a[0]+1
elif a[0] <= r:
return r-a[0]+1
else:
return 0
while True:
n = int(eval(input()))
if n==0: break
deck = [[1,n]]
m = int(eval(input()))
p,q,r = list(map(int,input().split()))
for i in range(m):
x,y = list(map(int,input().split()))
deck = shuffle(deck, x, y)
deck = shuffle(deck,0,p-1)
answer = 0
cnter = 0
i = 0
while (cnter < q-p+1):
nextsize = deck[i][1] - deck[i][0] + 1
if(q-p+1-cnter >= nextsize):
answer += hitnum(deck[i],r)
cnter += nextsize
i += 1
else:
answer += hitnum([deck[i][0],deck[i][0] + q-p+1-cnter - 1],r)
deck[i][0] = deck[i][0] + q-p+1-cnter
cnter = q-p+1
print(answer)
|
def shuffle(deck,x,y):
cnter = 0
i = 0
sectiona = sectionb = []
while (cnter < x):
nextsize = deck[i][1] - deck[i][0] + 1
if(x-cnter >= nextsize):
cnter += nextsize
i += 1
else:
sectiona = [[deck[i][0],deck[i][0] + x-cnter - 1]]
deck[i][0] = deck[i][0] + x-cnter
cnter = x
memoa = i
while (cnter < y):
nextsize = deck[i][1] - deck[i][0] + 1
if(y-cnter >= nextsize):
cnter += nextsize
i += 1
else:
sectionb = [[deck[i][0],deck[i][0] + y-cnter - 1]]
deck[i][0] = deck[i][0] + y-cnter
cnter = y
newdeck = deck[i:] + deck[memoa:i] + sectionb + deck[0:memoa] + sectiona
return newdeck
def hitnum(a,r):
if a[1] <= r:
return a[1]-a[0]+1
elif a[0] <= r:
return r-a[0]+1
else:
return 0
while True:
n = int(eval(input()))
if n==0: break
deck = [[1,n]]
m = int(eval(input()))
p,q,r = list(map(int,input().split()))
for i in range(m):
x,y = list(map(int,input().split()))
deck = shuffle(deck, x, y)
deck = shuffle(deck,0,p-1)
answer = 0
cnter = 0
i = 0
while (cnter < q-p+1):
nextsize = deck[i][1] - deck[i][0] + 1
if(q-p+1-cnter >= nextsize):
answer += hitnum(deck[i],r)
cnter += nextsize
i += 1
else:
answer += hitnum([deck[i][0],deck[i][0] + q-p+1-cnter - 1],r)
deck[i][0] = deck[i][0] + q-p+1-cnter
cnter = q-p+1
print(answer)
|
p00459
|
import sys
N = int(sys.stdin.readline().strip())
T = list(map(int, sys.stdin.readline().strip().split()))
A = list(map(int, sys.stdin.readline().strip().split()))
# i番目の山が取りうる高さの下限、上限
cand = [[1, float("inf")] for _ in range(N)]
l_max = 0
for i in range(N):
if l_max < T[i]:
l_max = T[i]
if cand[i][0] > T[i] or cand[i][1] < T[i]:
# print("here1", cand[i][0], cand[i][1], T[i])
print((0))
sys.exit()
else:
cand[i] = [T[i], T[i]]
else:
cand[i][1] = min(cand[i][1], T[i])
r_max = 0
for i in range(N-1, -1, -1):
if r_max < A[i]:
r_max = A[i]
if cand[i][0] > A[i] or cand[i][1] < A[i]:
# print("here2", cand[i][0], cand[i][1], A[i])
print((0))
sys.exit()
else:
cand[i] = [A[i], A[i]]
else:
cand[i][1] = min(cand[i][1], A[i])
# print(l_max, r_max)
if l_max != r_max:
print((0))
else:
ans = 1
for h_min, h_max in cand:
ans *= (h_max - h_min + 1)
ans %= 10**9 + 7
print(ans)
|
import sys
input = sys.stdin.readline
N = int(eval(input()))
T = list(map(int, input().split()))
A = list(map(int, input().split()))
if N == 1:
if T[0] == A[0]:
print((1))
else:
print((0))
sys.exit()
mod = 10**9 + 7
ans = 1
for i in range(N):
if i == 0:
if A[i] < T[i]:
print((0))
sys.exit()
elif i == N-1:
if T[i] < A[i]:
print((0))
sys.exit()
else:
if T[i-1] < T[i] and A[i+1] < A[i] and T[i] != A[i]:
print((0))
sys.exit()
else:
if T[i-1] < T[i]:
if A[i] < T[i]:
print((0))
sys.exit()
elif A[i+1] < A[i]:
if T[i] < A[i]:
print((0))
sys.exit()
else:
ans *= min(T[i], A[i])
ans %= mod
print(ans)
|
p03959
|
# code-festival-2016-qualcC - 二人のアルピニスト / Two Alpinists
from bisect import bisect_left as bs
def main():
"""
/----\ <- xi (= yi)
/ \--\
/ \
xi yi
0 ~ xi / xi ~ yi / yi+1 ~ N-1
"""
N = int(eval(input()))
T = tuple(map(int, input().split()))
A = tuple(map(int, input().split()))
x, y = T[-1], A[0] # max of x, y
xi, yi = T.index(x), N - A[::-1].index(y) - 1 # indices of x, y
if x != y or xi > yi:
print((0))
return
MOD = 10 ** 9 + 7
ans, cur = 1, 0
for i in T[: xi + 1]:
if i > cur: # point of new altitude -> no choice (ans * 1)
cur = i
else:
ans = (ans * cur) % MOD # mulitple choices (1, 2, ..., cur)
for _ in range(xi + 1, yi):
ans = (ans * cur) % MOD
for i in A[yi + 1 :]:
if i < cur:
cur = i
else:
ans = (ans * cur) % MOD
print(ans)
if __name__ == "__main__":
main()
|
# code-festival-2016-qualcC - 二人のアルピニスト / Two Alpinists
def main():
"""
/----\ <- x = y
/ \--\
/ \
xi yi
0 ~ xi / xi ~ yi / yi+1 ~ N-1
"""
N = int(eval(input()))
T = tuple(map(int, input().split()))
A = tuple(map(int, input().split()))
x, y = T[-1], A[0] # max of x, y
xi, yi = T.index(x), N - A[::-1].index(y) - 1 # indices of x, y
if x != y or xi > yi: # corner case
print((0))
return
MOD = 10 ** 9 + 7
ans, cur = 1, 0
for i in T[: xi + 1]:
if i > cur: # point of new altitude -> no choice (ans * 1)
cur = i
else:
ans = (ans * cur) % MOD # mulitple choices (1, 2, ..., cur)
for _ in range(xi + 1, yi):
ans = (ans * cur) % MOD
for i in A[yi + 1 :]:
if i < cur:
cur = i
else:
ans = (ans * cur) % MOD
print(ans)
if __name__ == "__main__":
main()
|
p03959
|
#!/usr/bin/env python3
#CODEFESTIVAL2016 qualC C
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n = I()
t = LI()
a = LI()
x = [0]*n
y = [0]*n
if a[0] != t[-1]:
print((0))
quit()
for i in range(1,n):
if t[i] > t[i-1]:
x[i] = 1
for i in range(1,n)[::-1]:
if a[i] < a[i-1]:
y[i-1] = 1
ans = 1
for i in range(1,n-1):
if x[i] == 1 and y[i] == 1:
if t[i] != a[i]:
print((0))
quit()
continue
elif x[i] == 1:
if a[i] >= t[i]:
continue
else:
print((0))
quit()
elif y[i] == 1:
if a[i] <= t[i]:
continue
else:
print((0))
quit()
ans *= min(t[i],a[i])
ans %= mod
print(ans)
|
#!/usr/bin/env python3
#CODEFESTIVAL2016 qualC C
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n = I()
t = LI()
a = LI()
x = [0]*n
y = [0]*n
if a[0] != t[-1]:
print((0))
quit()
for i in range(1,n):
if t[i] > t[i-1]:
x[i] = 1
for i in range(1,n)[::-1]:
if a[i] < a[i-1]:
y[i-1] = 1
ans = 1
for i in range(1,n-1):
if x[i] == 1 and y[i] == 1:
if t[i] != a[i]:
print((0))
quit()
elif x[i] == 1:
if a[i] < t[i]:
print((0))
quit()
elif y[i] == 1:
if a[i] > t[i]:
print((0))
quit()
else:
ans *= min(t[i],a[i])
ans %= mod
print(ans)
|
p03959
|
n = int(eval(input()))
t = list(map(int, input().split()))
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
ans, l, r = 1, 0, n - 1
for i in range(1, n):
if t[i] == t[i - 1]:
ans = ans * t[i] % mod
if t[i] == a[i]:
l = i
break
for i in range(n - 1)[::-1]:
if a[i] == a[i + 1]:
ans = ans * a[i] % mod
if t[i] == a[i]:
r = i
break
if t[l] != max(t) or a[r] != max(a) or max(t) != max(a):
print((0))
else:
print((ans * pow(t[l], max(r - l - 1, 0), mod) % mod))
|
n = int(eval(input()))
t = list(map(int, input().split()))
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
ans = 1
if n == 1:
print((int(t == a)))
exit()
for i in range(1, n - 1):
ht, ha = 0, 0
if t[i - 1] < t[i] and a[i] > a[i + 1]:
if t[i] != a[i]:
print((0))
break
elif t[i - 1] < t[i]:
if t[i] > a[i]:
print((0))
break
elif a[i] > a[i + 1]:
if t[i] < a[i]:
print((0))
break
else:
ans = ans * min(t[i], a[i]) % mod
else:
print(ans)
|
p03959
|
n = int(eval(input()))
T = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
p = 10 ** 9 + 7
B = [10**9] * n
if max(T) != max(A):
print((0))
exit()
h = 0
for i, t in enumerate(T):
if h < t:
B[i] = 1
h = t
else:
B[i] = h
h = 0
for i, a in zip(list(range(n-1, -1, -1)), A[::-1]):
if h < a:
B[i] = 1
h = a
elif B[i] == 1 and T[i] > A[i]:
print((0))
exit(0)
elif B[i] > h:
B[i] = h
ans = 1
for b in B:
ans *= b
print((ans%p))
|
n = int(eval(input()))
T = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
p = 10 ** 9 + 7
B = [10**9] * n
if max(T) != max(A):
print((0))
exit()
h = 0
for i, t in enumerate(T):
if h < t:
B[i] = 1
h = t
else:
B[i] = h
h = 0
for i, a in zip(list(range(n-1, -1, -1)), A[::-1]):
if h < a:
B[i] = 1
h = a
elif B[i] == 1 and T[i] > A[i]:
print((0))
exit(0)
elif B[i] > h:
B[i] = h
ans = 1
for b in B:
ans *= b
ans %= p
print(ans)
|
p03959
|
from itertools import groupby
from functools import reduce
MOD = 1000000007
def max_t():
i, t_max = 0, 0
for j, v in enumerate(t):
if v < t_max:
print((0))
quit(0)
if v > t_max:
t_max = v
i = j
return i, t_max
def validate_a(i, t_max):
for v in a[:i + 1]:
if v != t_max:
print((0))
quit(0)
for v in a[i + 1:]:
if v > t_max:
print((0))
quit(0)
if __name__ == '__main__':
n = int(eval(input()))
t = [int(s) for s in input().split()]
a = [int(s) for s in input().split()]
i, t_max = max_t()
validate_a(i, t_max)
highests = [min(x, y) for x, y in zip(a, t)]
print((reduce(lambda x, y: x * y % MOD, (v ** ((length - 1) if v < t_max else max(length - 2, 0)) for v, length in ((v, len(list(l))) for v, l in groupby(highests))))))
|
from itertools import groupby
from functools import reduce
MOD = 1000000007
def mod_pow(x, k):
ret = 1
while k > 0:
if k & 1:
ret *= x
ret %= MOD
k >>= 1
x *= x
x %= MOD
return ret
def max_t():
i, t_max = 0, 0
for j, v in enumerate(t):
if v < t_max:
print((0))
quit(0)
if v > t_max:
t_max = v
i = j
return i, t_max
def validate_a(i, t_max):
for v in a[:i + 1]:
if v != t_max:
print((0))
quit(0)
for v in a[i + 1:]:
if v > t_max:
print((0))
quit(0)
if __name__ == '__main__':
n = int(eval(input()))
t = [int(s) for s in input().split()]
a = [int(s) for s in input().split()]
i, t_max = max_t()
validate_a(i, t_max)
highests = [min(x, y) for x, y in zip(a, t)]
print((reduce(lambda x, y: x * y % MOD, (mod_pow(v, ((length - 1) if v < t_max else max(length - 2, 0))) for v, length in ((v, len(list(l))) for v, l in groupby(highests))))))
|
p03959
|
N = int(eval(input()))
T = list(map(int,input().split()))
A = list(map(int,input().split()))
A.append(1)
count = 0
Tmax = 1
Amax = 1
T2 = [0] * N
A2 = [0] * N
ans = 1
for i in range(N):
if T[i] > Tmax and A[i] > A[i+1] and T[i] != A[i]:
ans = 0
break
elif T[i] > Tmax and A[i] > A[i+1] and T[i] == A[i]:
count = 1
Tmax = T[i]
Amax = A[i+1]
elif T[i] > Tmax and A[i] == A[i+1] and T[i] > A[i]:
ans = 0
break
elif T[i] > Tmax and A[i] == A[i+1] and T[i] <= A[i]:
count = 1
Tmax = T[i]
elif T[i] == Tmax and A[i] > A[i+1] and A[i] > T[i]:
ans = 0
break
elif T[i] == Tmax and A[i] > A[i+1] and A[i] <= T[i]:
count = 1
Amax = A[i+1]
else:
count = min(A[i],T[i])
ans *= count
ans = ans % (10**9+7)
print(ans)
|
N = int(eval(input()))
T = list(map(int,input().split()))
A = list(map(int,input().split()))
A.append(1)
count = 0
Tmax = 1
Amax = 1
T2 = [0] * N
A2 = [0] * N
ans = 1
for i in range(N):
if T[i] > Tmax:
Tmax = T[i]
if A[i] > A[i+1]:
Amax = A[i+1]
if T[i] == A[i]:
count = 1
else:
ans = 0
break
else:
if T[i] > A[i]:
ans = 0
break
else:
count = 1
else:
if A[i] > A[i+1]:
Amax = A[i+1]
if A[i] > T[i]:
ans = 0
break
else:
count = 1
else:
count = min(A[i],T[i])
ans *= count
ans = ans % (10**9+7)
print(ans)
|
p03959
|
#import numpy as np
from functools import *
import sys
sys.setrecursionlimit(100000)
input = sys.stdin.readline
def acinput():
return list(map(int, input().split(" ")))
def II():
return int(eval(input()))
mod = 10**9+7
def factorial(n):
fact = 1
for integer in range(1, n + 1):
fact *= integer
return fact
def serch(x, count):
#print("top", x, count)
for d in directions:
nx = d+x
#print(nx)
if np.all(0 <= nx) and np.all(nx < (H, W)):
if field[nx[0]][nx[1]] == "E":
count += 1
field[nx[0]][nx[1]] = "V"
count = serch(nx, count)
continue
if field[nx[0]][nx[1]] == "#":
field[nx[0]][nx[1]] = "V"
count = serch(nx, count)
return count
N=II()
t=acinput()
a=acinput()
st = [[] for i in range(N)]
st[0]=[t[0],t[0]]
for i in range(1,N):
if t[i-1]<t[i]:
st[i]=[t[i],t[i]]
else:
st[i]=[1,st[i-1][1]]
sa = [[] for i in range(N)]
sa[N-1] = [a[N-1], a[N-1]]
for i in reversed(list(range(N-1))):
if a[i] > a[i+1]:
sa[i] = [a[i], a[i]]
else:
sa[i] = [1,sa[i+1][1]]
def diff(x):
return x[1]-x[0]
res=1
for i in range(N):
x=max(sa[i])-min(st[i])+1
y=max(st[i])-min(sa[i])+1
#print(x,y,np.diff(sa))
if x<=0 or y<=0:
res=0
break
res*= min(x,y,diff(sa[i])+1,diff(st[i])+1)%mod
print((res%mod))
|
import sys
input = sys.stdin.readline
def acinput():
return list(map(int, input().split(" ")))
def II():
return int(eval(input()))
mod = 10**9+7
def factorial(n):
fact = 1
for integer in range(1, n + 1):
fact *= integer
return fact
def serch(x, count):
#print("top", x, count)
for d in directions:
nx = d+x
#print(nx)
if np.all(0 <= nx) and np.all(nx < (H, W)):
if field[nx[0]][nx[1]] == "E":
count += 1
field[nx[0]][nx[1]] = "V"
count = serch(nx, count)
continue
if field[nx[0]][nx[1]] == "#":
field[nx[0]][nx[1]] = "V"
count = serch(nx, count)
return count
N=II()
t=acinput()
a=acinput()
st = [[] for i in range(N)]
st[0]=[t[0],t[0]]
for i in range(1,N):
if t[i-1]<t[i]:
st[i]=[t[i],t[i]]
else:
st[i]=[1,st[i-1][1]]
sa = [[] for i in range(N)]
sa[N-1] = [a[N-1], a[N-1]]
for i in reversed(list(range(N-1))):
if a[i] > a[i+1]:
sa[i] = [a[i], a[i]]
else:
sa[i] = [1,sa[i+1][1]]
def diff(x):
return x[1]-x[0]
res=1
for i in range(N):
x=max(sa[i])-min(st[i])+1
y=max(st[i])-min(sa[i])+1
#print(x,y,np.diff(sa))
if x<=0 or y<=0:
res=0
break
res=res* min(x,y,diff(sa[i])+1,diff(st[i])+1)
res=res%mod
print((res%mod))
#print(st)
#print(sa)
|
p03959
|
def inpl(): return [int(i) for i in input().split()]
mod = 10**9+7
N = int(eval(input()))
T = inpl()
A = inpl()
summit = T[-1]
S = [i == j == summit for i, j in zip(A, T)]
ans, pre = 1, 0
if A[0] != summit:
ans = 0
if not any(S):
ans = 0
k = sum([min(i, j) == summit for i, j in zip(A, T)])
for i in T:
if i == summit:
break
if i == pre:
ans = ans*pre %mod
else:
pre = i
pre = 0
for i in reversed(A):
if i == summit:
break
if i == pre:
ans = ans*pre %mod
else:
pre = i
print((ans*summit**max(k-2, 0)%mod))
|
import sys
mod = 10**9 + 7
def nai():
print((0))
sys.exit()
N = int(eval(input()))
T = list(map(int, input().split()))
A = list(map(int, input().split()))
M = max(A)
if M != max(T):
nai()
iT = T.index(M)
iA = N - 1 - A[::-1].index(M)
if iA < iT:
nai()
ans = pow(M, max(0, iA - iT - 1), mod)
pre = -1
for t in T[:iT]:
if pre == t:
ans = t*ans%mod
pre = t
pre = -1
for a in A[::-1]:
if a == M:
break
if pre == a:
ans = a*ans%mod
pre = a
print(ans)
|
p03959
|
N=int(eval(input()))
*T, = list(map(int,input().split()))
*A, = list(map(int,input().split()))
mod = 10**9+7
mT = [T[0]]*N
MT = [T[0]]*N
for i,t in enumerate(T[1:],1):
if t>T[i-1]:
mT[i] = t
MT[i] = t
else:
mT[i] = 1
MT[i] = t
mA = [A[-1]]*N
MA = [A[-1]]*N
for i,a in enumerate(A[-2::-1],2):
if a>A[-i+1]:
mA[-i] = a
MA[-i] = a
else:
mA[-i] = 1
MA[-i] = a
m = [max(a,t) for a,t in zip(mA,mT)]
M = [min(a,t) for a,t in zip(MA,MT)]
ans = 1
for a,b in zip(m,M):
ans *= max(0,b-a+1)
ans %= mod
print(ans)
|
N=int(eval(input()))
*T, = [0] + list(map(int,input().split())) + [0]
*A, = [0] + list(map(int,input().split())) + [0]
mod = 10**9+7
M = list(map(min,list(zip(A,T))))[1:-1]
m = [max(T[i] if T[i]>T[i-1] else 1, A[i] if A[i]>A[i+1] else 1) for i in range(1,N+1)]
ans = 1
for a,b in zip(m,M): ans = ans * max(0,b-a+1) % mod
print(ans)
|
p03959
|
def read():
return [int(i) for i in input().split(" ")]
N = int(eval(input()))
T = read()
A = read()
t = [(i != j, i) for i, j in zip(T, [None] + T)]
a = [(i != j, i) for i, j in zip(A, (A + [None])[1:])]
P = 1
for p, q in zip(t, a):
if(p[0]):
if(q[0]):
if(p[1] != q[1]):
print((0))
exit()
elif(q[1] < p[1]):
print((0))
exit()
elif(q[0]):
if(p[1] < q[1]):
print((0))
exit()
else:
P = P * min(p[1], q[1]) % (10 ** 9 + 7)
print(P)
|
def read():
return [int(i) for i in input().split(" ")]
N = int(eval(input()))
T = read()
A = read()
T = [(i != j, i) for i, j in zip(T, [None] + T)]
A = [(i != j, i) for i, j in zip(A, (A + [None])[1:])]
P = 1
for p, q in zip(T, A):
if(p[0]):
if(q[0]):
if(p[1] != q[1]):
print((0))
exit()
else:
if(q[1] < p[1]):
print((0))
exit()
elif(q[0]):
if(p[1] < q[1]):
print((0))
exit()
else:
P = P * min(p[1], q[1]) % (10 ** 9 + 7)
print(P)
|
p03959
|
mod = 10 ** 9 + 7
N = int(eval(input()))
T = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
HT = [False] * N
for i in range(1, N):
if T[i - 1] < T[i]:
HT[i] = True
HT[0] = True
HA = [False] * N
for i in range(N - 1):
if A[i] > A[i + 1]:
HA[i] = True
HA[-1] = True
ans = 1
for i in range(N):
if HT[i] and HA[i]:
ans *= 1 if T[i] == A[i] else 0
elif HT[i]:
ans *= 1 if T[i] <= A[i] else 0
elif HA[i]:
ans *= 1 if T[i] >= A[i] else 0
else:
ans = (ans * min(T[i], A[i])) % mod
if ans == 0:
break
print(ans)
|
mod = 10 ** 9 + 7
N = int(eval(input()))
T = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
HT = [False] * N
for i in range(1, N):
if T[i - 1] < T[i]:
HT[i] = True
HT[0] = True
HA = [False] * N
for i in range(N - 1):
if A[i] > A[i + 1]:
HA[i] = True
HA[-1] = True
ans = 1
for ht, ha, t, a in zip(HT, HA, T, A):
if ht and ha:
ans *= 1 if t == a else 0
elif ht:
ans *= 1 if t <= a else 0
elif ha:
ans *= 1 if t >= a else 0
else:
ans = (ans * min(t, a)) % mod
print(ans)
|
p03959
|
N = int(eval(input()))
T = [int(t) for t in input().split()]
A = [int(a) for a in input().split()]
mod = 7 + 10**9
TS, AS = [None for i in range(N)], [None for j in range(N)] #山の高さが一意に決まるならTrue
TS[0], AS[-1] = True, True
for i in range(1, N):
if T[i] > T[i-1]: TS[i] = True
else: TS[i] = False
if A[N-1-i] > A[N-i]: AS[N-1-i] = True
else: AS[N-1-i] = False
Ans = 1
for i in range(N):
if TS[i] and AS[i]:
if T[i] != A[i]:
Ans = 0
break
elif TS[i]:
if A[i] < T[i]:
Ans = 0
break
elif AS[i]:
if T[i] < A[i]:
Ans = 0
break
else:
Ans *= min(T[i], A[i])
Ans %= mod
print(Ans)
|
import sys
def solve():
input = sys.stdin.readline
N = int(eval(input()))
T = [int(t) for t in input().split()]
A = [int(a) for a in input().split()]
mod = 7 + 10 ** 9
Ans = 1
H = [-1] * N
H[0] = T[0]
for i in range(1, N):
if T[i] > T[i-1]: H[i] = T[i]
if H[N-1] > -1 and H[N-1] != A[N-1]: Ans = 0
else: H[N-1] = A[N-1]
for i in reversed(list(range(N-1))):
if A[i] > A[i+1]:
if H[i] > -1 and H[i] != A[i]: Ans = 0
elif T[i] < A[i]: Ans = 0
else: H[i] = A[i]
else:
if H[i] == -1:
Ans *= min(T[i], A[i])
Ans %= mod
print(Ans)
return 0
if __name__ == "__main__":
solve()
|
p03959
|
n=int(eval(input()))
a=[0]+list(map(int,input().split()))
b=list(map(int,input().split()))+[0]
c=[[0,0]for i in range(n)]
p=0
mod=10**9+7
for i in range(n,0,-1):
if a[i-1]!=a[i]:
c[i-1]=[1,a[i]]
else:
c[i-1]=[0,a[i]]
for i in range(n):
if b[i]!=b[i+1]:
if c[i][0]==1:
if b[i]!=c[i][1]:
print((0))
break
else:
if b[i]<=c[i][1]:
c[i]=[1,b[i]]
else:
print((0))
break
else:
if c[i][0]!=1:
c[i]=[0,min(b[i],c[i][1])]
else:
if c[i][1]>b[i]:
print((0))
break
else:
d=1
for i in range(n):
if c[i][0]!=1:
d*=c[i][1]%mod
print((d%mod))
|
n=int(eval(input()))
a=[0]+list(map(int,input().split()))
b=list(map(int,input().split()))+[0]
c=[[0,0]for i in range(n)]
p=0
mod=10**9+7
d=1
for i in range(n,0,-1):
if a[i-1]!=a[i]:
c[i-1]=[1,a[i]]
else:
c[i-1]=[0,a[i]]
for i in range(n):
if b[i]!=b[i+1]:
if c[i][0]==1:
if b[i]!=c[i][1]:
print((0))
break
else:
if b[i]<=c[i][1]:
c[i]=[1,b[i]]
else:
print((0))
break
else:
if c[i][0]!=1:
c[i]=[0,min(b[i],c[i][1])]
else:
if c[i][1]>b[i]:
print((0))
break
if c[i][0]!=1:
d=d*c[i][1]%mod
else:
print(d)
|
p03959
|
p = 10**9+7
N = int(eval(input()))
T = list(map(int,input().split()))
A = list(map(int,input().split()))
H = [0 for _ in range(N)]
cnt = 1
H[0] = T[0]
for i in range(1,N):
if T[i]>T[i-1]:
H[i] = T[i]
if H[-1]>0 and H[-1]!=A[-1]:
cnt = 0
else:
H[-1] = A[-1]
for i in range(-2,-N-1,-1):
if H[i]==0 and A[i]>A[i+1]:
if A[i]<=T[i]:
H[i] = A[i]
else:
cnt = 0
break
elif H[i]>0 and A[i]>A[i+1]:
if H[i]==A[i]:continue
else:
cnt = 0
break
if cnt==1:
for i in range(1,N-1):
if H[i]==0:
cnt = (cnt*min(T[i],A[i]))%p
print(cnt)
|
p = 10**9+7
N = int(eval(input()))
T = list(map(int,input().split()))
A = list(map(int,input().split()))
H = [0 for _ in range(N)]
flag = 0
if T[N-1]!=A[0]:
flag = 1
hmax = A[0]
if flag==0:
indmaxT=0
H[0] = T[0]
for i in range(1,N):
if T[i]>T[i-1]:
H[i] = T[i]
if H[i]==hmax:
indmaxT = i
break
indmaxA = N-1
H[N-1] = A[N-1]
for i in range(N-2,-1,-1):
if A[i]>A[i+1]:
H[i]=A[i]
if H[i]==hmax:
indmaxA = i
break
if indmaxA<indmaxT:
flag = 1
if flag==1:
print((0))
else:
cnt = 1
cur = 0
for i in range(1,indmaxT):
if H[i]==0:
cnt = (cnt*H[cur])%p
elif H[i]>0:
cur = i
cur = N-1
for i in range(N-2,indmaxA,-1):
if H[i]==0:
cnt = (cnt*H[cur])%p
elif H[i]>0:
cur = i
for i in range(indmaxT+1,indmaxA):
cnt = (cnt*hmax)%p
print(cnt)
|
p03959
|
MOD = 1000000007
def union(x,y):
if len(x)==1:
if len(y)==1:
return (1 if x[0]==y[0] else 0)
else:
return (1 if y[-1]>=x[0] else 0)
if len(x)>1:
if len(y)==1:
return (1 if x[-1]>=y[0] else 0)
else:
return min(len(x),len(y))
n = int(eval(input()))
a = list([int(x) % MOD for x in input().split()])
b = list([int(x) % MOD for x in input().split()])
x = [[] for _ in range(n)]
y = [[] for _ in range(n)]
z = 1
x[0] += [a[0]]
y[n-1] += [b[n-1]]
for i in range(1,n):
if a[i-1]<a[i]:
x[i] += [a[i]]
else:
x[i] += list(range(1,a[i]+1))
for j in range(n-1, 0, -1):
if b[j-1]>b[j]:
y[j-1] += [b[j-1]]
else:
y[j-1] += list(range(1,b[j-1]+1))
for i in range(0,n):
z *= union(x[i],y[i]) % MOD
z = z % MOD
print(z)
|
import sys
MOD = 1000000007
def union(x,y):
if len(x)==1:
if len(y)==1:
return (1 if x[0]==y[0] else 0)
else:
return (1 if y[-1]>=x[0] else 0)
if len(x)>1:
if len(y)==1:
return (1 if x[-1]>=y[0] else 0)
else:
return min(len(x),len(y))
n = int(eval(input()))
a = list([int(x) % MOD for x in input().split()])
b = list([int(x) % MOD for x in input().split()])
x = [0 for _ in range(n)]
y = [0 for _ in range(n)]
x[0] = 1
y[-1] = 1
z = 1
for i in range(1,n):
if a[i-1]<a[i]:
x[i] = 1
else:
x[i] = 0
for j in range(n-1, 0, -1):
if b[j-1]>b[j]:
y[j-1] += 1
else:
y[j-1] += 0
for i in range(n):
if x[i] == 1 and y[i] == 0:
if a[i] > b[i]:
print((0))
sys.exit()
elif x[i] == 0 and y[i] == 1:
if a[i] < b[i]:
print((0))
sys.exit()
elif x[i] == 1 and y[i] == 1:
if a[i] != b[i]:
print((0))
sys.exit()
else:
z *= min(a[i],b[i])
z = z % MOD
print(z)
|
p03959
|
import sys
n = int(eval(input()))
t = list(map(int, input().split()))
a = list(map(int, input().split()))
h = [min(t[i],a[i]) for i in range(n)]
fixed = [False] * n
fixed[0] = True; fixed[n-1] = True
if a[n-1] > t[n-1] or t[0] > a[0]:
print((0))
sys.exit(0)
# takahashi check
for i in range(1,n):
if t[i] > t[i-1]:
fixed[i] = True
if t[i] > a[i]:
print((0))
sys.exit(0)
# aoki check
for i in range(n-2, -1, -1):
if a[i] > a[i+1]:
fixed[i] = True
if a[i] > t[i]:
print((0))
sys.exit(0)
# calc ans
ans = 1
for i in range(n):
if not fixed[i]:
ans = ans * h[i] % (10**9+7)
print(ans)
|
n = int(eval(input()))
t = list(map(int, input().split()))
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
yama = [0] * n
# tは、t[i] == t[i + 1]だったら左の以外全部ありうる
yama[0] = t[0]
if t[0] > a[0]:
print((0))
exit()
for i in range(n - 1):
if t[i] < t[i + 1]:
# i + 1の高さ確定
yama[i + 1] = t[i + 1]
if t[i + 1] > a[i + 1]:
print((0))
exit()
for i in range(n - 1, 0, -1):
if a[i - 1] > a[i]:
yama[i - 1] = a[i - 1]
if a[i - 1] > t[i - 1]:
print((0))
exit()
if a[n - 1] > t[n - 1]:
print((0))
exit()
yama[n - 1] = a[n - 1]
ans = 1
for i in range(1, n - 1):
if yama[i] == 0:
ans = (ans * min(a[i], t[i])) % mod
print(ans)
|
p03959
|
mod=10**9+7
n=int(eval(input()))
T=[int(i) for i in input().split()]
A=[int(i) for i in input().split()]
Tres=[0]*n
Ares=[0]*n
Tres[0]=[0,T[0]]
Ares[-1]=[0,A[-1]]
for i in range(1,n):
if T[i]!=T[i-1]:
Tres[i]=[0,T[i]]
else:
Tres[i]=[1,T[i]]
if A[-i-1]!=A[-i]:
Ares[-i-1]=[0,A[-i-1]]
else:
Ares[-i-1]=[1,A[-i-1]]
ans=1
for i in range(n):
ta,tb=Tres[i]
aa,ab=Ares[i]
if ta==1 and aa==1:
ans=ans*min(tb,ab)
elif ta==0 and aa==1 and tb>ab:
ans=0
elif ta==1 and aa==0 and tb<ab:
ans=0
elif ta==0 and aa==0 and tb!=ab:
ans=0
print((ans%mod))
|
mod=10**9+7
n=int(eval(input()))
T=[int(i) for i in input().split()]
A=[int(i) for i in input().split()]
Tres=[0]*n
Ares=[0]*n
Tres[0]=[0,T[0]]
Ares[-1]=[0,A[-1]]
for i in range(1,n):
if T[i]>T[i-1]:
Tres[i]=[0,T[i]]
else:
Tres[i]=[1,T[i]]
if A[-i-1]>A[-i]:
Ares[-i-1]=[0,A[-i-1]]
else:
Ares[-i-1]=[1,A[-i-1]]
ans=1
for i in range(n):
ta,tb=Tres[i]
aa,ab=Ares[i]
if ta==1 and aa==1:
ans=ans*min(tb,ab)%mod
elif ta==0 and aa==1 and tb>ab:
ans=0
elif ta==1 and aa==0 and tb<ab:
ans=0
elif ta==0 and aa==0 and tb!=ab:
ans=0
print((ans%mod))
|
p03959
|
from collections import defaultdict, deque
import sys
N, M = list(map(int, input().split()))
edges = [list(range(N)) for i in range(N)]
for i in range(N):
edges[i].remove(i)
for _ in range(M):
a, b = list(map(int, input().split()))
edges[a-1].remove(b-1)
edges[b-1].remove(a-1)
size = defaultdict(lambda: [0, 0])
color = [-1]*N
def set_color(root):
que = deque([root])
color[root] = 0
size[root][0]+=1
while que:
v = que.pop()
for nv in edges[v]:
if color[nv]<0:
c = 1- color[v]
color[nv] = c
size[root][c]+=1
que.append(nv)
elif color[nv] == color[v]:
print((-1))
sys.exit()
for i in range(N):
if color[i]<0:
set_color(i)
S = set([0])
for a, b in list(size.values()):
S = set(s+b for s in S)|set(s+a for s in S)
ans = min(x*(x-1)//2+(N-x)*(N-x-1)//2 for x in S)
print(ans)
|
from collections import defaultdict, deque
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
edges = [list(range(N)) for i in range(N)]
for i in range(N):
edges[i].remove(i)
for _ in range(M):
a, b = list(map(int, input().split()))
edges[a-1].remove(b-1)
edges[b-1].remove(a-1)
size = defaultdict(lambda: [0, 0])
color = [-1]*N
def set_color(root):
que = deque([root])
color[root] = 0
size[root][0]+=1
while que:
v = que.pop()
for nv in edges[v]:
if color[nv]<0:
c = 1- color[v]
color[nv] = c
size[root][c]+=1
que.append(nv)
elif color[nv] == color[v]:
print((-1))
sys.exit()
for i in range(N):
if color[i]<0:
set_color(i)
S = set([0])
for a, b in list(size.values()):
S = set(s+b for s in S)|set(s+a for s in S)
ans = min(x*(x-1)//2+(N-x)*(N-x-1)//2 for x in S)
print(ans)
|
p03321
|
from collections import defaultdict, deque
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
edges = [list(range(N)) for i in range(N)]
for i in range(N):
edges[i].remove(i)
for _ in range(M):
a, b = list(map(int, input().split()))
edges[a-1].remove(b-1)
edges[b-1].remove(a-1)
size = defaultdict(lambda: [0, 0])
color = [-1]*N
def set_color(root):
que = deque([root])
color[root] = 0
size[root][0]+=1
while que:
v = que.pop()
for nv in edges[v]:
if color[nv]<0:
c = 1- color[v]
color[nv] = c
size[root][c]+=1
que.append(nv)
elif color[nv] == color[v]:
print((-1))
sys.exit()
for i in range(N):
if color[i]<0:
set_color(i)
S = set([0])
for a, b in list(size.values()):
S = set(s+b for s in S)|set(s+a for s in S)
ans = min(x*(x-1)//2+(N-x)*(N-x-1)//2 for x in S)
print(ans)
|
from collections import defaultdict, deque
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
edges = [set(range(N)) for i in range(N)]
for i in range(N):
edges[i].remove(i)
for _ in range(M):
a, b = list(map(int, input().split()))
edges[a-1].remove(b-1)
edges[b-1].remove(a-1)
size = defaultdict(lambda: [0, 0])
color = [-1]*N
def set_color(root):
que = deque([root])
color[root] = 0
size[root][0]+=1
while que:
v = que.pop()
for nv in edges[v]:
if color[nv]<0:
c = 1- color[v]
color[nv] = c
size[root][c]+=1
que.append(nv)
elif color[nv] == color[v]:
print((-1))
sys.exit()
for i in range(N):
if color[i]<0:
set_color(i)
S = set([0])
for a, b in list(size.values()):
S = set(s+b for s in S)|set(s+a for s in S)
ans = min(x*(x-1)//2+(N-x)*(N-x-1)//2 for x in S)
print(ans)
|
p03321
|
from itertools import product
def dfs(links, fixed, s):
q = [(s, 0)]
cnt = [0, 0]
while q:
v, c = q.pop()
if fixed[v] > -1:
if fixed[v] != c:
return False
continue
fixed[v] = c
cnt[c] += 1
for u in links[v]:
q.append((u, c ^ 1))
return cnt
def is_bipartite(n, links):
fixed = [-1] * n
can = []
for i in range(n):
if fixed[i] > -1:
continue
cnt = dfs(links, fixed, i)
if cnt == False:
return -1
can.append(cnt)
mx = float('inf')
for p in product(*can):
s = sum(p)
t = n - s
tmx = max(s, t)
mx = min(mx, tmx)
mn = n - mx
return (mx * (mx - 1) + mn * (mn - 1)) // 2
n, m = list(map(int, input().split()))
links = [set(range(n)) - {i} for i in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
links[a].remove(b)
links[b].remove(a)
print((is_bipartite(n, links)))
|
def dfs(links, fixed, s):
q = [(s, 0)]
cnt = [0, 0]
while q:
v, c = q.pop()
if fixed[v] > -1:
if fixed[v] != c:
return False
continue
fixed[v] = c
cnt[c] += 1
for u in links[v]:
q.append((u, c ^ 1))
return (max(cnt), min(cnt))
def is_bipartite(n, links):
fixed = [-1] * n
l, r = 0, 0
can = []
for i in range(n):
if fixed[i] > -1:
continue
cnt = dfs(links, fixed, i)
if cnt == False:
return -1
can.append(cnt)
can.sort(reverse=True)
for cnt in can:
j = 0 if cnt[0] > cnt[1] else 1
if l > r:
j ^= 1
l += cnt[j]
r += cnt[j ^ 1]
return (l * (l - 1) + r * (r - 1)) // 2
n, m = list(map(int, input().split()))
links = [set(range(n)) - {i} for i in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
links[a].remove(b)
links[b].remove(a)
print((is_bipartite(n, links)))
|
p03321
|
N, M = list(map(int, input().split()))
E = [[] for _ in range(N+1)]
E_mat = [[0]*(N+1) for _ in range(N+1)]
for _ in range(M):
a, b = list(map(int, input().split()))
E[a].append(b)
E[b].append(a)
E_mat[a][b] = 1
E_mat[b][a] = 1
E_inv = [[] for _ in range(N+1)]
for v, e_mat in enumerate(E_mat[1:], 1):
for u, e in enumerate(e_mat[1:], 1):
if e==0 and v!=u:
E_inv[v].append(u)
colors = [0] * (N+1)
def dfs(v, c):
colors[v] = c
cnts[c] += 1
for u in E_inv[v]:
if colors[u] == c:
print((-1))
exit()
if colors[u] != 0:
continue
dfs(u, -c)
K = []
for v in range(1, N+1):
cnts = [0, 0, 0]
if colors[v] == 0:
dfs(v, 1)
K.append(cnts[1:])
dp = 1
for a, b in K:
dp = dp<<a | dp<<b
dp = bin(dp)[:1:-1]
ans = 0
mi = float("inf")
for i, c in enumerate(dp):
if c=="1":
if mi > abs(N/2-i):
mi = abs(N/2-i)
ans = i
print((ans*(ans-1)//2 + (N-ans)*(N-ans-1)//2))
|
def main():
N, M = list(map(int, input().split()))
E_mat = [[0]*(N+1) for _ in range(N+1)]
for _ in range(M):
a, b = list(map(int, input().split()))
E_mat[a][b] = 1
E_mat[b][a] = 1
E_inv = [[] for _ in range(N+1)]
for v, e_mat in enumerate(E_mat[1:], 1):
for u, e in enumerate(e_mat[1:], 1):
if e==0 and v!=u:
E_inv[v].append(u)
colors = [0] * (N+1)
def dfs(v, c):
colors[v] = c
cnts[c] += 1
for u in E_inv[v]:
if colors[u] == c:
print((-1))
exit()
if colors[u] != 0:
continue
dfs(u, -c)
K = []
for v in range(1, N+1):
cnts = [0, 0, 0]
if colors[v] == 0:
dfs(v, 1)
K.append(cnts[1:])
dp = 1
for a, b in K:
dp = dp<<a | dp<<b
dp = bin(dp)[:1:-1]
ans = 0
mi = float("inf")
for i, c in enumerate(dp):
if c=="1":
if mi > abs(N/2-i):
mi = abs(N/2-i)
ans = i
print((ans*(ans-1)//2 + (N-ans)*(N-ans-1)//2))
main()
|
p03321
|
# import math
# n,k = list(map(int,input().split()))
# print(math.ceil((n-1)/(k-1)))
n,m = list(map(int,input().split()))
road = {}
whole = []
for i in range(1,n+1):
whole.append(i)
road[i] = []
whole = set(whole)
for i in range(m):
a,b = list(map(int, input().split()))
road[a].append(b)
road[b].append(a)
taka = []
hashi = []
used = []
no = 0
for x in road:
l = []
r = []
l1 = []
r1 = []
if x in used:
continue
else:
l.append(x)
l1.append(x)
used.append(x)
for y in whole - set(road[x]):
if y not in used:
r.append(y)
r1.append(y)
used.append(y)
while l1 != [] or r1 != []:
while r1 != []:
t = r1.pop()
for y in whole-set(road[t]):
if y not in used and y not in l:
l.append(y)
l1.append(y)
used.append(y)
while l1 != []:
t = l1.pop()
for y in whole-set(road[t]):
if y not in used and y not in r:
r.append(y)
r1.append(y)
used.append(y)
for i in range(len(l)):
for j in range(i+1,len(l)):
if l[j] not in road[l[i]]:
no = 1
break
if no == 1:break
if no == 1:break
for i in range(len(r)):
for j in range(i+1,len(r)):
if r[j] not in road[r[i]]:
no = 1
break
if no == 1:break
if no == 1:break
taka.append(len(l))
hashi.append(len(r))
if no == 1:print((-1))
else:
res = [abs(taka[i]-hashi[i]) for i in range(len(taka))]
res.sort(reverse=-1)
delta = 0
for x in res:
if delta>0:delta-=x
else:delta+=x
left = (n+delta)/2
right = (n-delta)/2
result = int((left*(left-1)+right*(right-1))/2)
print(result)
|
# import math
# n,k = list(map(int,input().split()))
# print(math.ceil((n-1)/(k-1)))
n,m = list(map(int,input().split()))
road = {}
whole = []
for i in range(1,n+1):
whole.append(i)
road[i] = set()
whole = set(whole)
for i in range(m):
a,b = list(map(int, input().split()))
road[a].add(b)
road[b].add(a)
taka = []
hashi = []
used = set()
no = 0
for x in road:
l = set()
r = set()
l1 = []
r1 = []
if x in used:
continue
else:
l.add(x)
l1.append(x)
used.add(x)
for y in whole - road[x]:
if y not in used:
r.add(y)
r1.append(y)
used.add(y)
while l1 != [] or r1 != []:
while r1 != []:
t = r1.pop()
for y in whole-road[t]-used-l:
l.add(y)
l1.append(y)
used.add(y)
while l1 != []:
t = l1.pop()
for y in whole-road[t]-used-r:
r.add(y)
r1.append(y)
used.add(y)
r = list(r)
l = list(l)
for i in range(len(l)):
for j in range(i+1,len(l)):
if l[j] not in road[l[i]]:
no = 1
break
if no == 1:break
if no == 1:break
for i in range(len(r)):
for j in range(i+1,len(r)):
if r[j] not in road[r[i]]:
no = 1
break
if no == 1:break
if no == 1:break
taka.append(len(l))
hashi.append(len(r))
if no == 1:print((-1))
else:
res = [abs(taka[i]-hashi[i]) for i in range(len(taka))]
res.sort(reverse=-1)
delta = 0
for x in res:
if delta>0:delta-=x
else:delta+=x
left = (n+delta)/2
right = (n-delta)/2
result = int((left*(left-1)+right*(right-1))/2)
print(result)
|
p03321
|
N,M=list(map(int,input().split()))
edge=[set([]) for i in range(N)]
for i in range(M):
a,b=list(map(int,input().split()))
edge[a-1].add(b-1)
edge[b-1].add(a-1)
cedge=[[] for i in range(N)]
for i in range(N):
for j in range(N):
if j not in edge[i] and j!=i:
cedge[i].append(j)
ans=[]
def is_bipartgraph():
color=[0]*N
used=[False]*N
for i in range(N):
if not used[i]:
stack=[(i,1)]
black=0
white=0
while stack:
v,c=stack.pop()
color[v]=c
black+=(not used[v])*(c==1)
white+=(not used[v])*(c==-1)
used[v]=True
for nv in cedge[v]:
if color[nv]==color[v]:
return False
elif color[nv]==0:
stack.append((nv,-c))
ans.append([black,white])
return True
if is_bipartgraph():
dp=[[False for i in range(0,N+1)] for j in range(len(ans))]
a,b=ans[0]
dp[0][a],dp[0][b]=True,True
for i in range(1,len(ans)):
a,b=ans[i]
for j in range(0,N+1):
test=False
if j>=a:
test=test|dp[i-1][j-a]
if j>=b:
test=test|dp[i-1][j-b]
dp[i][j]=test
ans=0
for i in range(0,N+1):
if dp[-1][i] and abs(ans-N/2)>abs(i-N/2):
ans=i
ans2=N-ans
print((ans*(ans-1)//2+ans2*(ans2-1)//2))
else:
print((-1))
|
N,M=list(map(int,input().split()))
edge=[set([]) for i in range(N)]
for i in range(M):
a,b=list(map(int,input().split()))
edge[a-1].add(b-1)
edge[b-1].add(a-1)
cedge=[[] for i in range(N)]
for i in range(N):
for j in range(N):
if j not in edge[i] and j!=i:
cedge[i].append(j)
ans=[]
def is_bipartgraph():
color=[0]*N
used=[False]*N
for i in range(N):
if not used[i]:
stack=[(i,1)]
black=0
white=0
while stack:
v,c=stack.pop()
if not used[v]:
color[v]=c
black+=(c==1)
white+=(c==-1)
used[v]=True
for nv in cedge[v]:
if color[nv]==color[v]:
return False
elif color[nv]==0:
stack.append((nv,-c))
ans.append([black,white])
return True
if is_bipartgraph():
dp=[[False for i in range(0,N+1)] for j in range(len(ans))]
a,b=ans[0]
dp[0][a],dp[0][b]=True,True
for i in range(1,len(ans)):
a,b=ans[i]
for j in range(0,N+1):
test=False
if j>=a:
test=test|dp[i-1][j-a]
if j>=b:
test=test|dp[i-1][j-b]
dp[i][j]=test
ans=0
for i in range(0,N+1):
if dp[-1][i] and abs(ans-N/2)>abs(i-N/2):
ans=i
ans2=N-ans
print((ans*(ans-1)//2+ans2*(ans2-1)//2))
else:
print((-1))
|
p03321
|
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from operator import mul
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n, m = LI()
G = [set(range(n)) for _ in range(n)]
for i in range(n):
G[i].remove(i)
for _ in range(m):
a, b = LI()
G[a - 1].remove(b - 1)
G[b - 1].remove(a - 1)
color = [0] * n
def bipartite_or_not(s):
color[s] = 1
dq = deque([s])
b = 1
w = 0
while dq:
u = dq.popleft()
for v in G[u]:
if color[v] and color[u] != color[v]:
continue
elif color[v] and color[u] == color[v]:
print((-1))
exit()
color[v] = -color[u]
if color[v] == 1:
b += 1
else:
w += 1
dq += [v]
return b, w
bit = 1 << n
for i in range(n):
if color[i]:
continue
x = bipartite_or_not(i)
p, q = x
d = abs(p - q)
bit = bit << d | bit >> d
for j in range(n):
if bit >> (n - j) & 1:
y, z = (n + j) // 2, (n - j) // 2
print((y * (y - 1) // 2 + z * (z - 1) // 2))
break
|
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from operator import mul
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n, m = LI()
G = [set(range(n)) for _ in range(n)]
for i in range(n):
G[i].remove(i)
for _ in range(m):
a, b = LI()
G[a - 1].remove(b - 1)
G[b - 1].remove(a - 1)
color = [0] * n
def bipartite_or_not(s):
color[s] = 1
dq = deque([s])
b = 1
w = 0
while dq:
u = dq.popleft()
for v in G[u]:
if color[v] and color[u] != color[v]:
continue
elif color[v] and color[u] == color[v]:
print((-1))
exit()
color[v] = -color[u]
if color[v] == 1:
b += 1
else:
w += 1
dq += [v]
return b, w
bit = 1
for i in range(n):
if color[i]:
continue
p, q = bipartite_or_not(i)
bit = bit << p | bit << q
for j in range(n // 2, -1, -1):
if bit >> j & 1:
print((n * (n - 1) // 2 - j * (n - j)))
break
|
p03321
|
def main():
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in [0]*m]
n_hozon = n
g = [set() for _ in [0]*n]
[g[a-1].add(b-1) for a, b in ab]
[g[b-1].add(a-1) for a, b in ab]
s = set([i for i in range(n)])
# 題意：できるだけ辺が少なくなるように2つの完全グラフに分けたい
# まず、2つの完全グラフに分けられるのかを調べる必要がある。
# これが不可能であれば-1を出力して即座に終了。
# 分けられるのであれば、できるだけ街の数を均等にしたい。
# 以下のアルゴリズムを考える。
# まずお互い繋がっていない都市の組A,Bを選ぶ。
# すると、Aにしか繋がっていない街、Bにしか繋がっていない街、
# 両方に繋がっている街の3グループに分かれる。
# このうち、最後のグループについて、
# 最初に戻って同様の処理を行う。
# 街がなくなるか、両方に繋がっている街のグループが完全グラフに
# なった時点で終了。
# 上記のアルゴリズムにより、(A,B)の列と最後に残った街の数が求められる。
# これをもとに、動的計画法で考えられる街の振り分け方を全て洗い出す。
# 最も均等に近く振り分けた場合について、完全グラフの辺数を計算して
# 出力すれば問題が解ける。
a_list, b_list = [], []
while True:
#print(n, m)
# print(s)
# print(g)
# 完全グラフかどうか
#print(n, m, g, s)
if m == n*(n-1)//2:
break
a = [-1, 10**10]
for i in s:
l = len(g[i])
if l < a[1]:
a = [i, l]
a = a[0]
b = [-1, 10**10]
for i in s-g[a]-{a}:
l = len(g[i])
if l < b[1]:
b = [i, l]
b = b[0]
#print(a, b)
a_set, b_set = {a}, {b}
s.remove(a)
s.remove(b)
n -= 2
remain = set()
for i in s:
flag_a = True
for j in a_set:
if j not in g[i]:
flag_a = False
else:
g[i].remove(j)
g[j].remove(i)
m -= 1
flag_b = True
for j in b_set:
if j not in g[i]:
flag_b = False
else:
g[i].remove(j)
g[j].remove(i)
m -= 1
#print(i, flag_a, flag_b)
if flag_a == flag_b == False:
print((-1))
return
elif flag_a == False or flag_b == False:
# print(remain)
q = {i}
flag = flag_a # True→Aに入れる
while q:
#print(q, "q")
qq = set()
while q:
i = q.pop()
if flag:
a_set.add(i)
else:
b_set.add(i)
for j in remain:
if j not in g[i]:
qq.add(j)
else:
g[i].remove(j)
g[j].remove(i)
m -= 1
for j in q:
g[i].remove(j)
g[j].remove(i)
m -= 1
for i in qq:
remain.remove(i)
flag ^= True
q = qq
else:
remain.add(i)
# print(g)
for i in (a_set | b_set)-{a}-{b}:
s.remove(i)
n -= 1
a_list.append(len(a_set))
b_list.append(len(b_set))
m = n
n = n_hozon
k = len(a_list)
if k == 1:
dp = [False]*(n+1)
a = a_list[0]
b = b_list[0]
ans = 10**10
for i in range(m+1):
ans = min(ans, (a+i)*(a+i-1)//2+(n-a-i)*(n-a-i-1)//2)
print(ans)
return
dp = [False]*(n+1)
dp[0] = True
for i in range(k):
a, b = a_list[i], b_list[i]
maxab = max(a, b)
dp2 = [False]*(n+1)
for j in range(n-maxab+1):
dp2[j+a] |= dp[j]
dp2[j+b] |= dp[j]
dp = dp2
dp2 = [False]*(n+1)
for j in range(m+1):
for i in range(n-j+1):
dp2[i+j] |= dp[i]
ans = 10**10
for i in range(n+1):
if dp2[i] is False:
continue
j = n-i
ans = min(ans, i*(i-1)//2+j*(j-1)//2)
print(ans)
main()
|
# 問題の趣旨：できるだけ辺が少なくなるように2つの完全グラフに分けたい
# まず、2つの完全グラフに分けられるのかを調べる必要がある。
# これが不可能であれば-1を出力して即座に終了。
# 分けられる場合は、できるだけ街の数を均等にしたい。
# 以下のアルゴリズムを考える。
# まずお互い繋がっていない都市の組A,Bを選ぶ。
# すると、Aにしか繋がっていない街、Bにしか繋がっていない街、
# 両方に繋がっている街の3グループに分かれる。
# 最初の2グループについてはグループのサイズを保存しておく。
# 最後のグループが空でない場合は、このグループに対してまた同様の処理を行う。
# 街がなくなるか、両方に繋がっている街のグループが
# 完全グラフになった時点で終了。
# 上記のアルゴリズムにより、グループのサイズの列と最後に残った街の数が求められる。
# これをもとに、動的計画法で考えられる街の振り分け方を全て洗い出す。
# 最も均等に近く振り分けた場合について、完全グラフの辺数を計算して
# 出力すれば問題が解ける。
def main():
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in [0]*m]
rest = n # 残りの辺
g = [set() for _ in [0]*n]
[g[a-1].add(b-1) for a, b in ab]
[g[b-1].add(a-1) for a, b in ab]
s = set([i for i in range(n)])
a_list, b_list = [], []
while True:
if m == rest*(rest-1)//2:
break
a = [-1, 10**10]
for i in s:
length = len(g[i])
if length < a[1]:
a = [i, length]
a = a[0]
b = [-1, 10**10]
for i in s-g[a]-{a}:
length = len(g[i])
if length < b[1]:
b = [i, length]
b = b[0]
a_set, b_set = {a}, {b}
s.remove(a)
s.remove(b)
rest -= 2
remain = set() # 最後のグループ
for i in s:
flag_a = True
for j in a_set:
if j not in g[i]:
flag_a = False
else:
g[i].remove(j)
g[j].remove(i)
m -= 1
flag_b = True
for j in b_set:
if j not in g[i]:
flag_b = False
else:
g[i].remove(j)
g[j].remove(i)
m -= 1
if flag_a+flag_b == 0:
print((-1))
return
elif flag_a*flag_b == 0:
q = {i}
flag = flag_a # True→A、False→B
while q:
qq = set()
while q:
i = q.pop()
if flag:
a_set.add(i)
else:
b_set.add(i)
for j in remain:
if j not in g[i]:
qq.add(j)
else:
g[i].remove(j)
g[j].remove(i)
m -= 1
for j in q:
g[i].remove(j)
g[j].remove(i)
m -= 1
for i in qq:
remain.remove(i)
flag ^= True
q = qq
else:
remain.add(i)
for i in (a_set | b_set)-{a}-{b}:
s.remove(i)
rest -= 1
a_list.append(len(a_set))
b_list.append(len(b_set))
k = len(a_list)
dp = [False]*(n+1)
dp[0] = True
for i in range(k):
a, b = a_list[i], b_list[i]
dp2 = [False]*(n+1)
for j in range(n-max(a, b)+1):
dp2[j+a] |= dp[j]
dp2[j+b] |= dp[j]
dp = dp2
ans = 10**10
for j in range(rest+1):
for i in range(n-j+1):
if dp[i]:
p = i+j
q = n-p
ans = min(ans, p*(p-1)//2+q*(q-1)//2)
print(ans)
main()
|
p03321
|
from collections import deque
n, m = list(map(int, input().split()))
info = [list(map(int, input().split())) for i in range(m)]
matrix = [[0]*n for i in range(n)]
for i in range(m):
a, b = info[i]
a -= 1
b -= 1
matrix[a][b] = 1
matrix[b][a] = 1
graph = [[] for i in range(n)]
for i in range(n):
for j in range(i+1, n):
if matrix[i][j] == 0:
graph[i].append(j)
graph[j].append(i)
def coloring(graph):
n = len(graph)
visited = [-1] * n
ans = []
for i in range(n):
if visited[i] >= 0:
continue
visited[i] = 0
q = deque([i])
num = [1, 0]
while q:
_from = q.pop()
for to in graph[_from]:
if visited[to] == visited[_from]:
return [[-1, -1]]
if visited[to] >= 0:
continue
visited[to] = visited[_from] ^ 1
num[visited[to]] += 1
q.append(to)
ans.append(num)
return ans
num = coloring(graph)
if num[0][0] == -1:
print((-1))
exit()
dp = [[False]*(n+1) for _ in range(len(num) + 1)]
dp[0][0] = True
for i in range(len(num)):
a, b = num[i]
for j in range(n+1):
if j-a >= 0:
dp[i+1][j] = dp[i][j-a] or dp[i+1][j]
if j-b >= 0:
dp[i+1][j] = dp[i][j-b] or dp[i+1][j]
ans = 10**20
for i, boolian in enumerate(dp[len(num)]):
if boolian:
tmp_ans = i * (i-1) // 2 + (n-i) * (n-i-1) // 2
ans = min(tmp_ans, ans)
print(ans)
|
import sys
input = sys.stdin.readline
def is_bipartite(graph, s):
"""二部グラフ判定する"""
n = len(graph)
col = [-1] * n
col[s] = 0
stack = [s]
used[s] = True
while stack:
v = stack.pop()
for nxt_v in graph[v]:
used[nxt_v] = True
if col[nxt_v] == -1:
col[nxt_v] = col[v] ^ 1
stack.append(nxt_v)
elif col[nxt_v] ^ col[v] == 0:
return False
return True
def color_bipartite(graph, s):
"""二部グラフを彩色する"""
n = len(graph)
col = [-1] * n
col[s] = 0
stack = [s]
while stack:
v = stack.pop()
for nxt_v in graph[v]:
if col[nxt_v] == -1:
col[nxt_v] = col[v] ^ 1
stack.append(nxt_v)
return col
n, m = list(map(int, input().split()))
info = [list(map(int, input().split())) for i in range(m)]
graph = [set() for i in range(n)]
for a, b in info:
a -= 1
b -= 1
graph[a].add(b)
graph[b].add(a)
comp_graph = [[] for i in range(n)]
for a in range(n):
for b in range(n):
if b in graph[a] or a == b:
continue
comp_graph[a].append(b)
cnt0 = []
cnt1 = []
used = [False] * n
for i in range(n):
if used[i]:
continue
used[i] = True
if not is_bipartite(comp_graph, i):
print((-1))
exit()
col = color_bipartite(comp_graph, i)
cnt0.append(col.count(0))
cnt1.append(col.count(1))
dp = [[False] * (n + 1) for i in range(len(cnt0) + 1)]
dp[0][0] = True
for i in range(len(cnt0)):
wei0 = cnt0[i]
wei1 = cnt1[i]
for w in range(n + 1):
if w + wei0 < n + 1:
dp[i + 1][w + wei0] = (dp[i][w] or dp[i + 1][w + wei0])
if w + wei1 < n + 1:
dp[i + 1][w + wei1] = (dp[i][w] or dp[i + 1][w + wei1])
ans = 10 ** 18
for num in range(n + 1):
if dp[-1][num]:
c0 = num
c1 = n - num
res = c0 * (c0 - 1) // 2 + c1 * (c1 - 1) // 2
ans = min(ans, res)
print(ans)
|
p03321
|
n,m=list(map(int,input().split()))
a=[False]*n
g=[[] for _ in [0]*n]
for _ in range(m):
l,r,d=list(map(int,input().split()))
g[l-1].append((r-1,d))
g[r-1].append((l-1,-d))
for i in range(n):
if not(a[i]):
a[i]=0
q=[i]
while q:
j=q.pop()
for x,e in g[j]:
if not(a[x]):
a[x]=a[j]+e
q.append(x)
elif a[x]!=a[j]+e:
print("No")
exit()
print("Yes")
|
n,m=list(map(int,input().split()))
a=[None]*n
g=[[] for _ in range(n)]
for _ in range(m):
l,r,d=list(map(int,input().split()))
g[l-1].append((r-1,d))
g[r-1].append((l-1,-d))
for i in range(n):
if a[i]==None:
a[i]=0
q=[i]
while q:
j=q.pop()
for x,e in g[j]:
if a[x]==None:
a[x]=a[j]+e
q.append(x)
elif a[x]!=a[j]+e:
print("No")
exit()
print("Yes")
|
p03450
|
class WeightedUnionFind():
def __init__(self,n):
self.n = n
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.weight = [0 for _ in range(n)]
def find(self,x):
root = x
stack = [root]
while self.parents[root] != root:
root = self.parents[root]
stack.append(root)
while stack:
s = stack.pop()
self.weight[s] += self.weight[self.parents[s]]
while self.parents[x] != root:
parent = self.parents[x]
self.parents[x] = root
x = parent
return root
def unite(self,x,y,w):
xroot = self.find(x)
yroot = self.find(y)
if xroot == yroot:
return
xrank = self.rank[xroot]
yrank = self.rank[yroot]
if xrank < yrank:
self.parents[xroot] = yroot
self.weight[xroot] = w-self.weight[x]+self.weight[y]
else:
self.parents[yroot] = xroot
self.weight[yroot] = -w+self.weight[x]-self.weight[y]
if xrank == yrank:
self.rank[xroot] += 1
def diff(self,x,y):
return self.weight[x]-self.weight[y]
N,M = list(map(int,input().split()))
uf = WeightedUnionFind(N)
for _ in range(M):
l,r,d = list(map(int,input().split()))
if uf.find(l-1) == uf.find(r-1):
if uf.diff(l-1,r-1) != d:
print('No')
break
else:
uf.unite(l-1,r-1,d)
else:
print('Yes')
|
class DSUWeighted():
def __init__(self, n):
self.n = n
self.par_size = [-1] * n
self.wt = [0] * n
def leader(self, a):
#assert 0 <= a < self.n
x = a
order = [x]
while self.par_size[x] >= 0:
x = self.par_size[x]
order.append(x)
for s in order[:-1][::-1]:
self.wt[s] += self.wt[self.par_size[s]]
self.par_size[s] = x
return x
def same(self, a, b):
#assert 0 <= a < self.n
#assert 0 <= b < self.n
return self.leader(a) == self.leader(b)
def merge(self, a, b, w):
#assert 0 <= a < self.n
#assert 0 <= b < self.n
x = self.leader(a)
y = self.leader(b)
w += self.wt[a] - self.wt[b]
if x == y: return x
if -self.par_size[x] < -self.par_size[y]:
x, y = y, x
w = -w
self.par_size[x] += self.par_size[y]
self.par_size[y] = x
self.wt[y] = w
return x
def diff(self, x, y):
return self.wt[y] - self.wt[x]
import sys
input = sys.stdin.buffer.readline
N, M = list(map(int, input().split()))
uf = DSUWeighted(N)
for _ in range(M):
l, r, d = list(map(int, input().split()))
if uf.same(l - 1, r - 1):
if uf.diff(l - 1, r - 1) != d:
print('No')
break
else:
uf.merge(l - 1, r - 1, d)
else:
print('Yes')
|
p03450
|
#重み付きUnion-Find
#xの根を求める
def find(x):
if par[x] < 0:
return x
else:
px = find(par[x])
wei[x] += wei[par[x]]
par[x] = px
return px
#xの根から距離
def weight(x):
find(x)
return wei[x]
#w[y]=w[x]+wとなるようにxとyを併合
def unite(x,y,w):
w += wei[x]-wei[y]
x = find(x)
y = find(y)
if x == y:
return False
else:
#sizeの大きいほうがx
if par[x] > par[y]:
x,y = y,x
w = -w
par[x] += par[y]
par[y] = x
wei[y] = w
return True
#xとyが同じ集合に属するかの判定
def same(x,y):
return find(x) == find(y)
#x,yが同じ集合に属するときのwei[y]-wei[x]
def diff(x,y):
return weight(y)-weight(x)
n,m = [int(i) for i in input().split()]
par = [-1]*n
wei = [0]*n
for i in range(m):
l,r,d = [int(i) for i in input().split()]
if not same(l-1,r-1):
unite(l-1,r-1,d)
else:
if diff(l-1,r-1) == d:
continue
else:
print('No')
exit()
print('Yes')
|
#重み付きUnion-Find
#xの根を求める
def find(x):
if par[x] < 0:
return x
else:
px = find(par[x])
wei[x] += wei[par[x]]
par[x] = px
return px
#xの根から距離
def weight(x):
find(x)
return wei[x]
#w[y]=w[x]+wとなるようにxとyを併合
def unite(x,y,w):
w += wei[x]-wei[y]
x = find(x)
y = find(y)
if x == y:
return False
else:
#sizeの大きいほうがx
if par[x] > par[y]:
x,y = y,x
w = -w
par[x] += par[y]
par[y] = x
wei[y] = w
return True
#xとyが同じ集合に属するかの判定
def same(x,y):
return find(x) == find(y)
#x,yが同じ集合に属するときのwei[y]-wei[x]
def diff(x,y):
return weight(y)-weight(x)
import sys
input = sys.stdin.readline
n,m = [int(i) for i in input().split()]
par = [-1]*n
wei = [0]*n
for i in range(m):
l,r,d = [int(i) for i in input().split()]
if not same(l-1,r-1):
unite(l-1,r-1,d)
else:
if diff(l-1,r-1) == d:
continue
else:
print('No')
exit()
print('Yes')
|
p03450
|
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys
def main():
n, m = list(map(int, sys.stdin.readline().split()))
lrds = tuple(tuple(map(int, line.split())) for line in sys.stdin.readlines())
g = tuple([] for _ in range(n))
x = [None] * n
for l, r, d in lrds:
l -= 1
r -= 1
g[l].append((r, d))
g[r].append((l, -d))
for i in range(n):
if x[i]:
continue
stack = [i]
x[i] = 0
while len(stack):
v = stack.pop()
for u, d in g[v]:
if not x[u]:
stack.append(u)
x[u] = x[v] + d
for v in range(n):
for u, d in g[v]:
if x[v] + d != x[u]:
print('No')
sys.exit()
print('Yes')
if __name__ == '__main__':
main()
|
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys
def main():
n, m = list(map(int, sys.stdin.readline().split()))
lrds = ((list(map(int, line.split()))) for line in sys.stdin.readlines())
g = tuple([] for _ in range(n))
x = [None] * n
for l, r, d in lrds:
l -= 1
r -= 1
g[l].append((r, d))
g[r].append((l, -d))
for i in range(n):
if x[i] is not None:
continue
stack = [i]
x[i] = 0
while len(stack):
v = stack.pop()
for u, d in g[v]:
if x[u] is None:
stack.append(u)
x[u] = x[v] + d
for v in range(n):
for u, d in g[v]:
if x[v] + d != x[u]:
print('No')
sys.exit()
print('Yes')
if __name__ == '__main__':
main()
|
p03450
|
from collections import deque
n, m = list(map(int, input().split()))
graph = [[] for _ in range(n)]
for i in range(m):
l, r, d = list(map(int, input().split()))
l -= 1
r -= 1
graph[r].append((l, i, -d))
graph[l].append((r, i, d))
check_v = [False for _ in range(n)]
check_e = [False for _ in range(m)]
max_int = 10 ** 10
point = [max_int for _ in range(n)]
for v in range(n):
Q = deque()
if not check_v[v]:
Q.append(v)
while Q:
v = Q.popleft()
for next_v, e, d in graph[v]:
if not check_e[e]:
if point[v] == max_int:
point[v] = 0
if point[next_v] == max_int:
point[next_v] = point[v] + d
else:
if point[next_v] != point[v] + d:
print('No')
exit()
check_e[e] = True
if not check_v[next_v]:
Q.append(next_v)
check_v[v] = True
print('Yes')
|
from collections import deque
n, m = list(map(int, input().split()))
graph = [[] for _ in range(n)]
for i in range(m):
l, r, d = list(map(int, input().split()))
l -= 1
r -= 1
graph[r].append((l, r, -d))
graph[l].append((r, l, d))
max_int = 10 ** 10
point = [None for _ in range(n)]
for v in range(n):
Q = deque()
if point[v] is not None:
continue
Q.extend(graph[v])
while Q:
next_v, v, d = Q.popleft()
if point[v] is None:
point[v] = 0
if point[next_v] is not None:
if point[next_v] != point[v] + d:
print('No')
exit()
else:
continue
point[next_v] = point[v] + d
Q.extend(graph[next_v])
print('Yes')
|
p03450
|
def topo_sort(g):
from collections import deque
V = len(g)
deg = [0]*V
for src in range(V):
for dst in g[src]:
deg[dst] += 1
ans = list(v for v in range(V) if deg[v]==0)
deq = deque(ans)
used = [0]*V
while deq:
v = deq.popleft()
for t in g[v]:
deg[t] -= 1
if deg[t]==0:
deq.append(t)
ans.append(t)
return ans
def resolve():
N, M = list(map(int, input().split()))
LRD = [list(map(int, input().split())) for _ in range(M)]
adj_list = [[] for _ in range(N)]
adj_matrix = [[None for _ in range(N)] for __ in range(N)]
for lrd in LRD:
l, r, d = lrd
adj_list[l-1].append(r-1)
adj_matrix[l-1][r-1] = d
#top_order = topological_sort(adj_list)
top_order = topo_sort(adj_list)
if len(top_order) != len(adj_list):
print("No")
return
acc = 0
start = top_order[0]
now = top_order[0]
for i in range(1, len(top_order)):
nxt = top_order[i]
if adj_matrix[now][nxt] is not None:
if adj_matrix[start][nxt] is not None and acc+adj_matrix[now][nxt] != adj_matrix[start][nxt]:
print("No")
return
acc += adj_matrix[now][nxt]
now = nxt
print("Yes")
if '__main__' == __name__:
resolve()
|
def resolve():
N, M = list(map(int, input().split()))
LRD = [list(map(int, input().split())) for _ in range(M)]
adj_list = [[] for _ in range(N)]
for lrd in LRD:
l, r, d = lrd
adj_list[l-1].append((l-1, r-1, d))
adj_list[r-1].append((r-1, l-1, -d))
X = [None]*N
import collections
for i in range(N):
if X[i] is not None:
continue
q = collections.deque(adj_list[i])
X[i] = 0
while q:
src, nxt, d = q.pop()
if X[nxt] is not None:
if X[nxt] != X[src] + d:
print("No")
return
else:
X[nxt] = X[src] + d
q.extend(adj_list[nxt])
print("Yes")
if '__main__' == __name__:
resolve()
|
p03450
|
import collections
def main():
N, M = list(map(int, input().split()))
graph = collections.defaultdict(dict)
for _ in range(M):
L, R, D = list(map(int, input().split()))
graph[L][R] = D
graph[R][L] = -D
visited = set()
for i in range(1, N+1):
if i not in visited:
cur = dict()
cur[i] = 0
while True:
temp = dict()
for j in cur:
for k in graph[j]:
l = cur[j] + graph[j][k]
if k not in cur:
temp[k] = l
elif k in cur and cur[k] != l:
return "No"
elif k in temp and temp[k] != l:
return "No"
for k in temp:
cur[k] = temp[k]
if len(temp) == 0:
break
return "Yes"
if __name__ == '__main__':
print((main()))
|
import collections
def main():
N, M = list(map(int, input().split()))
graph = collections.defaultdict(dict)
for _ in range(M):
L, R, D = list(map(int, input().split()))
graph[L][R] = D
graph[R][L] = -D
visited = set()
used = set()
for i in range(1, N+1):
if i not in visited:
dist = dict()
dist[i] = 0
cur = [i]
visited.add(i)
while cur:
temp = []
for j in cur:
for k in graph[j]:
if (j, k) not in used and (k, j) not in used:
used.add((j, k))
used.add((k, j))
if k not in dist:
dist[k] = dist[j] + graph[j][k]
temp.append(k)
visited.add(k)
elif k in dist:
if dist[k] != dist[j] + graph[j][k]:
return "No"
cur = temp
return "Yes"
if __name__ == '__main__':
print((main()))
|
p03450
|
from collections import deque
def sol():
n,m=list(map(int,input().split()))
t,w={},{}
p,q=set(),set()
for i in range(m):
l,r,d=[int(i) for i in input().split()]
t[(l,r)]=d
if l in w:
w[l].add((r,d))
else:
w[l]={(r,d)}
p.add(l)
q.add(r)
s=p-q
#chk=set()
chk=deque()
if len(s)==0:
print((["No","Yes"][m==0]))
exit()
for i in s:
#chk.add((i,0))
chk.append((i,0))
while len(chk):
x=chk.pop()
if x[0] in w:
for j in w[x[0]]:
if (i,j[0]) in t and t[(i,j[0])]!=x[1]+j[1]:
#if (x[0],j[0]) in t and t[(i,j[0])]!=
print("No")
exit()
elif (i,j[0]) not in t:
t[(i,j[0])]=x[1]+j[1]
#chk.add((j[0],x[1]+j[1]))
chk.append((j[0],x[1]+j[1]))
else:
#chk.add((j[0],x[1]+j[1]))
chk.append((j[0],x[1]+j[1]))
print("Yes")
if __name__=="__main__":
sol()
|
def sol():
n,m=list(map(int,input().split()))
t,w={},{}
p,q=set(),set()
for i in range(m):
l,r,d=[int(i) for i in input().split()]
if l in w: w[l].add((r,d))
else: w[l]={(r,d)}
p.add(l)
q.add(r)
s=p-q
chk=set()
if len(s)==0:
print((["No","Yes"][m==0]))
exit()
for i in s:
chk.add((i,0))
while len(chk):
x=chk.pop()
if x[0] in w:
for j in w[x[0]]:
if (i,j[0]) in t and t[(i,j[0])]!=t[(i,x[0])]+j[1]:
print("No")
exit()
elif (i,j[0]) not in t:
#t[(i,j[0])]=t[(i,x[0])]+j[1]
t[(i,j[0])]=x[1]+j[1]
chk.add((j[0],x[1]+j[1]))
print("Yes")
if __name__=="__main__":
sol()
|
p03450
|
N, M = list(map(int, input().split()))
LRDi = []
for _ in range(M):
a = list(map(int, input().split()))
LRDi.append(a)
tree = [None] * (N + 1)
def parent(n):
if tree[n] is None:
return [n, 0]
d = distance_to_root(n)
p = parent(tree[n][0])
tree[n][0] = p[0]
tree[n][1] = d
return tree[n]
def distance_to_root(n):
if tree[n] is None:
return 0
d = distance_to_root(tree[n][0])
return d + tree[n][1]
for l, r, d in LRDi:
lp = parent(l)
rp = parent(r)
if lp[0] != rp[0]:
rd = distance_to_root(r)
tree[rp[0]] = [lp[0], lp[1] + d - rd]
else:
d1 = distance_to_root(l)
d2 = distance_to_root(r)
if d1 + d != d2:
print("No")
exit()
print("Yes")
|
N, M = list(map(int, input().split()))
LRDi = []
for _ in range(M):
a = list(map(int, input().split()))
LRDi.append(a)
tree = [None] * (N + 1)
def parent(n):
if tree[n] is None:
return [n, 0]
p = parent(tree[n][0])
if p[0] == tree[n][0]:
return tree[n]
d = distance_to_root(n)
tree[n][0] = p[0]
tree[n][1] = d
return tree[n]
def distance_to_root(n):
ret = 0
nn = n
while tree[nn] is not None:
ret += tree[nn][1]
nn = tree[nn][0]
return ret
for l, r, d in LRDi:
lp = parent(l)
rp = parent(r)
if lp[0] != rp[0]:
rd = distance_to_root(r)
tree[rp[0]] = [lp[0], lp[1] + d - rd]
else:
d1 = distance_to_root(l)
d2 = distance_to_root(r)
if d1 + d != d2:
print("No")
exit()
print("Yes")
|
p03450
|
#!/usr/bin/env python3
def main():
na = list(map(int, input().split()))
N = na[0]
M = na[1]
lrd_list = []
for i in range(M):
na = list(map(int, input().split()))
lrd_list.append((na[0], na[1], na[2]))
tpl_list = []
for lrd in lrd_list:
l = lrd[0]
r = lrd[1]
l_idx = r_idx = -1
for i, tpl in enumerate(tpl_list):
if l_idx == -1 and l in tpl[0]:
l_idx = i
if r_idx == -1 and r in tpl[0]:
r_idx = i
if l_idx != -1 and r_idx != -1:
break
if 0 <= l_idx and 0 <= r_idx:
if l_idx == r_idx:
tpl_list[l_idx][1].append(lrd)
else:
tpl_l = tpl_list[l_idx]
tpl_r = tpl_list.pop(r_idx)
tpl_list[l_idx] = (tpl_l[0] | tpl_r[0], tpl_l[1] + [lrd] + tpl_r[1])
elif 0 <= l_idx:
tpl_list[l_idx][0].add(r)
tpl_list[l_idx][1].append(lrd)
elif 0 <= r_idx:
tpl_list[r_idx][0].add(l)
tpl_list[r_idx][1].append(lrd)
else:
tpl_list.append((set([l, r]), [lrd]))
positions = [None for i in range(N+1)]
consistent = True
for tpl in tpl_list:
for lrd in tpl[1]:
l, r, d = lrd
if positions[l] is None and positions[r] is None:
positions[l] = 0
positions[r] = d
elif positions[l] is None:
positions[l] = positions[r] - d
elif positions[r] is None:
positions[r] = positions[l] + d
else:
if positions[l] + d != positions[r]:
consistent = False
break
if not consistent:
break
print(('Yes' if consistent else 'No'))
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
def main():
na = list(map(int, input().split()))
N = na[0]
M = na[1]
lrd_list = []
for i in range(M):
na = list(map(int, input().split()))
lrd_list.append((na[0], na[1], na[2]))
l_list = [None for i in range(N+1)]
r_list = [None for i in range(N+1)]
for lrd in lrd_list:
l = lrd[0]
r = lrd[1]
if l_list[l] is None:
l_list[l] = [lrd]
else:
l_list[l].append(lrd)
if r_list[r] is None:
r_list[r] = [lrd]
else:
r_list[r].append(lrd)
positions = [None for i in range(N+1)]
consistent = True
i = 1
while consistent and i <= N:
s = []
p = 0
positions[i] = p
s.append(i)
while consistent and 0 < len(s):
j = s.pop()
p = positions[j]
if not l_list[j] is None:
for lrd in l_list[j]:
l, r, d = lrd
if positions[r] is None:
positions[r] = p + d
s.append(r)
elif positions[r] != p + d:
consistent = False
break
if not consistent:
break
if not r_list[j] is None:
for lrd in r_list[j]:
l, r, d = lrd
if positions[l] is None:
positions[l] = p - d
s.append(l)
elif positions[l] != p - d:
consistent = False
break
while consistent and i <= N and (not positions[i] is None):
i += 1
print(('Yes' if consistent else 'No'))
if __name__ == '__main__':
main()
|
p03450
|
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, M = list(map(int, input().split()))
G = [[float('inf')] * N for _ in range(N)]
for i in range(N):
G[i][i] = 0
LRD = [None] * M
for i in range(M):
L, R, D = list(map(int, input().split()))
L -= 1
R -= 1
G[L][R] = D
LRD[i] = (L, R, D)
floyd_warshall(G)
for L, R, D in LRD:
if G[L][R] != D or G[R][L] != float('inf'):
print('No')
exit()
print('Yes')
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N, M = list(map(int, input().split()))
G = [[] for _ in range(N)]
has_parent = [False] * N
LRD = [None] * M
for i in range(M):
L, R, D = list(map(int, input().split()))
L -= 1
R -= 1
G[L].append((R, D))
G[R].append((L, -D))
def dfs(v):
visited[v] = True
for u, d in G[v]:
if dist[u] == float('inf'):
dist[u] = dist[v] + d
elif dist[u] != dist[v] + d:
print('No')
exit()
if not visited[u]:
dfs(u)
dist = []
visited = [False] * N
for v in range(N):
if not visited[v]:
dist = [float('inf')] * N
dist[v] = 0
dfs(v)
print('Yes')
|
p03450
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N, M = list(map(int, input().split()))
G = [[] for _ in range(N)]
has_parent = [False] * N
LRD = [None] * M
for i in range(M):
L, R, D = list(map(int, input().split()))
L -= 1
R -= 1
G[L].append((R, D))
G[R].append((L, -D))
def dfs(v):
visited[v] = True
for u, d in G[v]:
if dist[u] == float('inf'):
dist[u] = dist[v] + d
elif dist[u] != dist[v] + d:
print('No')
exit()
if not visited[u]:
dfs(u)
dist = []
visited = [False] * N
for v in range(N):
if not visited[v]:
dist = [float('inf')] * N
dist[v] = 0
dfs(v)
print('Yes')
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N, M = list(map(int, input().split()))
G = [[] for _ in range(N)]
has_parent = [False] * N
for i in range(M):
L, R, D = list(map(int, input().split()))
L -= 1
R -= 1
G[L].append((R, D))
has_parent[R] = True
def dfs(v):
visited[v] = True
for u, d in G[v]:
if dist[u] == float('inf'):
dist[u] = dist[v] + d
if dist[u] != dist[v] + d:
print('No')
exit()
dfs(u)
dist = []
visited = [False] * N
for v in range(N):
if not has_parent[v]:
dist = [float('inf')] * N
dist[v] = 0
dfs(v)
if all(visited):
print('Yes')
else:
print('No')
|
p03450
|
def main():
N, M = list(map(int,input().split()))
INF = 10**9+7
if M == 0:
print("Yes")
return
x = [[INF for _ in range(N)] for _ in range(N)]
for i in range(M):
l, r, d = list(map(int, input().split()))
l, r = l-1, r-1
x[l][r] = d
x[r][l] = -d
ans_exist = True
for k in range(N):
for i in range(N):
for j in range(N):
if x[i][j] == INF:
continue
x[i][j] = min(x[i][j], x[i][k]+x[k][j])
for i in range(N):
for j in range(N):
if x[i][j] == x[j][i] and x[i][j] == INF:
continue
if x[i][j] != -x[j][i]:
ans_exist = False
break
if ans_exist:
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
|
def main():
N, M = list(map(int,input().split()))
if M == 0:
print("Yes")
return
x = [[] for _ in range(N)]
ans = [0 for _ in range(N)]
for i in range(M):
l, r, d = list(map(int, input().split()))
l, r = l-1, r-1
x[l].append([r, d])
x[r].append([l, -d])
visited = [False for _ in range(N)]
def dfs(i):
vs = [i]
while vs:
v = vs.pop()
for nex in x[v]:
if not visited[nex[0]]:
visited[nex[0]] = True
ans[nex[0]] = ans[v]+nex[1]
vs.append(nex[0])
else:
if ans[nex[0]] != ans[v]+nex[1]:
return False
return True
ans_exist = True
for i in range(N):
if not visited[i]:
visited[i] = True
ans_exist = dfs(i)
if not ans_exist:
break
if ans_exist:
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
|
p03450
|
N,M = list(map(int,input().split()))
Dlist = [[0 for i in range(N+1)] for j in range(N+1)]
L2Rdic = {i:[] for i in range(N+1)}
R2Ldic = {i:[] for i in range(N+1)}
flag=True
for _ in range(M):
L,R,D=list(map(int,input().split()))
if Dlist[L][R]==0:
Dlist[L][R]=D
L2Rdic[L].append(R)
R2Ldic[R].append(L)
elif Dlist[L][R]!=D:
flag=False
for r in L2Rdic[R]:
if Dlist[L][r]==0:
Dlist[L][r]=D+Dlist[R][r]
L2Rdic[L].append(r)
R2Ldic[r].append(L)
elif Dlist[L][r]!=D+Dlist[R][r]:
flag=False
for l in R2Ldic[L]:
if Dlist[l][R]==0:
Dlist[l][R]=Dlist[l][L]+D
L2Rdic[l].append(R)
R2Ldic[R].append(l)
elif Dlist[l][R]!=Dlist[l][L]+D:
flag=False
if flag==False:
print('No')
exit()
print('Yes')
|
N,M = list(map(int,input().split()))
L2R = {i:[] for i in range(N+1)}
R2L = {i:[] for i in range(N+1)}
for _ in range(M):
L,R,D=list(map(int,input().split()))
L2R[L].append((R,D,L))
R2L[R].append((L,-D,R))
x = [0 for i in range(N+1)]
f = [True for i in range(N+1)]
for i in range(1,N+1):
if f[i]:
f[i]=False
x[i]=i
que=L2R[i]+R2L[i]
while len(que)>0:
tmp = []
for end,d,begin in que:
if f[end]:
f[end]=False
x[end]=d+x[begin]
tmp+=L2R[end]+R2L[end]
elif x[end]!=d+x[begin]:
print('No')
exit()
que=tmp
print('Yes')
|
p03450
|
# ABC087D
# https://atcoder.jp/contests/abc087/tasks/arc090_b
def Find(x, par, diff_weight):
if par[x] < 0:
return x
else:
px = Find(par[x], par, diff_weight)
diff_weight[x] += diff_weight[par[x]]
par[x] = px
return px
def Unite(x, y, par, rank, diff_weight, w):
w += diff_weight[x] - diff_weight[y]
x = Find(x, par, diff_weight)
y = Find(y, par, diff_weight)
if x != y:
if rank[x] < rank[y]:
x, y = y, x
w = -w
if rank[x] == rank[y]:
rank[x] += 1
par[x] += par[y]
par[y] = x
diff_weight[y] = w
def Same(x, y, par, diff_weight):
return Find(x, par,diff_weight) == Find(y, par, diff_weight)
def Size(x, par, diff_weight):
return -par[Find(x, par, diff_weight)]
def Weight(x, par, diff_weight):
Find(x, par, diff_weight)
return diff_weight[x]
def Diff(x, y, par, diff_weight):
return Weight(y, par, diff_weight) - Weight(x, par, diff_weight)
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
par = [-1]*n
rank = [0]*n
diff_weight = [0]*n
for i in range(m):
l, r, d = list(map(int, input().split()))
l, r = l-1 ,r-1
if not Same(l, r, par, diff_weight):
Unite(l, r, par, rank, diff_weight, d)
else:
if d != Diff(l, r, par, diff_weight):
print('No')
exit()
print('Yes')
|
def Find(x, par, diff_weight):
if par[x] < 0:
return x
else:
px = Find(par[x], par, diff_weight)
diff_weight[x] += diff_weight[par[x]]
par[x] = px
return px
def Unite(x, y, par, rank, diff_weight, w):
w += diff_weight[x] - diff_weight[y]
x = Find(x, par, diff_weight)
y = Find(y, par, diff_weight)
if x != y:
if rank[x] < rank[y]:
x, y = y, x
w = -w
if rank[x] == rank[y]:
rank[x] += 1
par[x] += par[y]
par[y] = x
diff_weight[y] = w
def Same(x, y, par, diff_weight):
return Find(x, par,diff_weight) == Find(y, par, diff_weight)
def Size(x, par, diff_weight):
return -par[Find(x, par, diff_weight)]
def Weight(x, par, diff_weight):
Find(x, par, diff_weight)
return diff_weight[x]
def Diff(x, y, par, diff_weight):
return Weight(y, par, diff_weight) - Weight(x, par, diff_weight)
import sys
input = sys.stdin.buffer.readline
n, m = list(map(int, input().split()))
par = [-1]*n
rank = [0]*n
diff_weight = [0]*n
for i in range(m):
l, r, d = list(map(int, input().split()))
l, r = l-1, r-1
if not Same(l, r, par, diff_weight):
Unite(l, r, par, rank, diff_weight, d)
else:
if Diff(l, r, par, diff_weight) != d:
print('No')
exit()
else:
print('Yes')
|
p03450
|
import sys
from collections import deque
sys.setrecursionlimit(10**7)
n, m = [int(i) for i in sys.stdin.readline().split()]
parent = [i for i in range(n)]
graph = {j:[] for j in range(n)}
for i in range(m):
l, r, d = [int(i) for i in sys.stdin.readline().split()]
l -= 1
r -= 1
graph[l].append((r, d))
graph[r].append((l, -d))
yet = set(list(range(n)))
x_ls = [None for i in range(n)]
x_ls[0] = 0
que = deque([0])
flg = True
while len(que) > 0:
cur = que.popleft()
if cur in yet:
yet.remove(cur)
cur_pos = x_ls[cur]
for _next, dis in graph[cur]:
if x_ls[_next] is None:
x_ls[_next] = cur_pos + dis
que.append(_next)
else:
if x_ls[_next] != cur_pos + dis:
flg = False
break
if not flg:
break
if len(que) == 0 and len(yet) > 0:
root = list(yet)[0]
que.append(root)
x_ls[root] = 0
yet.remove(root)
if flg:
print("Yes")
else:
print("No")
|
import sys
sys.setrecursionlimit(10**7)
n, m = [int(i) for i in sys.stdin.readline().split()]
parent = [i for i in range(n)]
graph = {j:[] for j in range(n)}
for i in range(m):
l, r, d = [int(i) for i in sys.stdin.readline().split()]
l -= 1
r -= 1
graph[l].append((r, d))
graph[r].append((l, -d))
already = set()
x_ls = [None for i in range(n)]
x_ls[0] = 0
stack = list(range(n))[::-1]
flg = True
while len(stack) > 0:
cur = stack.pop(-1)
if cur in already:
continue
if x_ls[cur] is None:
cur_pos = 0
else:
cur_pos = x_ls[cur]
already.add(cur)
for _next, dis in graph[cur]:
if x_ls[_next] is None:
x_ls[_next] = cur_pos + dis
stack.append(_next)
else:
if x_ls[_next] != cur_pos + dis:
flg = False
break
if not flg:
break
if flg:
print("Yes")
else:
print("No")
|
p03450
|
import sys
from itertools import accumulate as acc
sys.setrecursionlimit(10**6)
class UnionFind():
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1]*(n+1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0]*(n+1)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y):
# 入力ノードのrootノードを見つける
x = self.Find_Root(x)
y = self.Find_Root(y)
# すでに同じ木に属していた場合
if(x == y):
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
# rnkが同じ（深さに差がない場合）は1増やす
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズを返す
def Count(self, x):
return -self.root[self.Find_Root(x)]
def cur(n):
tmp=[dic[n][j] for j in range(len(dic[n]))]
for i in dic[n]:
x[i]=x[n]+memo[n][i]
dic[i].remove(n)
dic[n].remove(i)
for i in tmp:
cur(i)
INF=10**10
N,M=list(map(int,input().split()))
if M==0: print(("Yes"),sys.exit())
dic=[[] for i in range(N+1)]
memo=[[-INF for j in range(N+1)] for i in range(N+1)]
tree=UnionFind(N)
dist=[list(map(int,input().split())) for i in range(M)]
for i in range(M):
l,r,d=dist[i]
tree.Unite(l,r)
memo[l][r]=d
memo[r][l]=-d
dic[l].append(r)
dic[r].append(l)
s=set()
for i in range(1,N+1):
s.add(tree.Find_Root(i))
x=[-INF]*(N+1)
for i in s:
x[i]=0
cur(i)
for i in range(M):
l,r,d=dist[i]
if x[r]-x[l]!=d: print(("No"),sys.exit())
print("Yes")
|
import sys
class UnionFind():
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1]*(n+1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0]*(n+1)
self.potential=[0]*(n+1)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
r = self.Find_Root(self.root[x])
self.potential[x] += self.potential[self.root[x]]
self.root[x]=r
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y, d):
d+=self.potential[x]-self.potential[y]
# 入力ノードのrootノードを見つける
x = self.Find_Root(x)
y = self.Find_Root(y)
# すでに同じ木に属していた場合
if(x == y):
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
self.potential[y]=d
else:
self.root[y] += self.root[x]
self.root[x] = y
self.potential[x]=-d
# rnkが同じ（深さに差がない場合）は1増やす
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズを返す
def Count(self, x):
return -self.root[self.Find_Root(x)]
def dist(self,x,y):
if self.isSameGroup(x,y):
return self.potential[y]-self.potential[x]
else: return -10**10
INF=10**10
N,M=list(map(int,input().split()))
if M==0 or N<=2: print(("Yes"),sys.exit())
tree=UnionFind(N)
dist=[list(map(int,input().split())) for i in range(M)]
for i in range(M):
l,r,d=dist[i]
if tree.isSameGroup(l,r) and tree.dist(l,r)!=d: print(("No"),sys.exit())
tree.Unite(l,r,d)
for i in range(M):
l,r,d=dist[i]
if tree.dist(l,r)!=d:
print("No")
sys.exit()
print("Yes")
|
p03450
|
import sys
class UnionFind():
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1]*(n+1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0]*(n+1)
self.potential=[0]*(n+1)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
r = self.Find_Root(self.root[x])
self.potential[x] += self.potential[self.root[x]]
self.root[x]=r
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y, d):
d+=self.potential[x]-self.potential[y]
# 入力ノードのrootノードを見つける
x = self.Find_Root(x)
y = self.Find_Root(y)
# すでに同じ木に属していた場合
if(x == y):
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
self.potential[y]=d
else:
self.root[y] += self.root[x]
self.root[x] = y
self.potential[x]=-d
# rnkが同じ（深さに差がない場合）は1増やす
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズを返す
def Count(self, x):
return -self.root[self.Find_Root(x)]
def dist(self,x,y):
if self.isSameGroup(x,y):
return self.potential[y]-self.potential[x]
else: return -10**10
INF=10**10
N,M=list(map(int,input().split()))
if M==0: print(("Yes"),sys.exit())
tree=UnionFind(N)
dist=[list(map(int,input().split())) for i in range(M)]
for i in range(M):
l,r,d=dist[i]
if tree.isSameGroup(l,r) and tree.dist(l,r)!=d: print(("No"),sys.exit())
tree.Unite(l,r,d)
for i in range(M):
l,r,d=dist[i]
if tree.dist(l,r)!=d:
print("No")
sys.exit()
print("Yes")
|
import sys
class UnionFind():
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1]*(n+1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0]*(n+1)
self.potential=[0]*(n+1)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
r = self.Find_Root(self.root[x])
self.potential[x] += self.potential[self.root[x]]
self.root[x]=r
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y, d):
d+=self.potential[x]-self.potential[y]
# 入力ノードのrootノードを見つける
x = self.Find_Root(x)
y = self.Find_Root(y)
# すでに同じ木に属していた場合
if(x == y):
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
self.potential[y]=d
else:
self.root[y] += self.root[x]
self.root[x] = y
self.potential[x]=-d
# rnkが同じ（深さに差がない場合）は1増やす
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズを返す
def Count(self, x):
return -self.root[self.Find_Root(x)]
def dist(self,x,y):
if self.isSameGroup(x,y):
return self.potential[y]-self.potential[x]
else: return -10**10
INF=10**10
N,M=list(map(int,input().split()))
if M==0: print(("Yes"),sys.exit())
tree=UnionFind(N)
dist=[list(map(int,input().split())) for i in range(M)]
for i in range(M):
l,r,d=dist[i]
if tree.isSameGroup(l,r) and tree.dist(l,r)!=d: print(("No"),sys.exit())
tree.Unite(l,r,d)
print("Yes")
|
p03450
|
import collections, sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
graph = [[] for i in range(n + 1)]
for i in range(m):
l, r, d = list(map(int, input().split()))
graph[l].append([r, d])
graph[r].append([l, -d])
flags = [False for i in range(n + 1)]
place = [0 for i in range(n + 1)]
num = 0
flag = True
while num <= n:
if flag == False:
break
if flags[num] == True:
num += 1
continue
if graph[num] == []:
flags[num] = True
num += 1
continue
queue = collections.deque([num])
while queue:
if flag == False:
break
test = queue.popleft()
flags[test] = True
for i in graph[test]:
if flags[i[0]] == True:
if place[i[0]] - place[test] != i[1]:
flag = False
break
else:
place[i[0]] = place[test] + i[1]
queue.append(i[0])
else:
num += 1
if flag == True:
print("Yes")
else:
print("No")
|
import collections, sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
graph = [[] for i in range(n + 1)]
for i in range(m):
l, r, d = list(map(int, input().split()))
graph[l].append([r, d])
graph[r].append([l, -d])
place = [None for i in range(n + 1)]
num = 0
flag = True
while num <= n:
if flag == False:
break
if place[num] != None:
num += 1
continue
place[num] = 0
queue = collections.deque([num])
while queue:
if flag == False:
break
test = queue.popleft()
for i in graph[test]:
if place[i[0]] != None:
if place[i[0]] - place[test] != i[1]:
flag = False
break
else:
place[i[0]] = place[test] + i[1]
queue.append(i[0])
else:
num += 1
if flag == True:
print("Yes")
else:
print("No")
|
p03450
|
# 解説みたよ
import sys
sys.setrecursionlimit(10000000)
input = sys.stdin.readline
n, m = list(map(int, input().split()))
es = [[] for i in range(n)]
l, r, d = [0] * m, [0] * m, [0] * m
for i in range(m):
l[i], r[i], d[i] = list(map(int, input().split()))
l[i] -= 1
r[i] -= 1
es[l[i]].append((r[i], d[i]))
es[r[i]].append((l[i], -d[i]))
INF = 1000000000000
value = [INF] * n
def dfs(v):
for i, d in es[v]:
if value[i] == INF:
value[i] = value[v] + d
dfs(i)
for i in range(n):
if value[i] == INF:
value[i] = 0
dfs(i)
for i, j, k in zip(l, r, d):
if value[j] - value[i] != k:
print("No")
exit()
print("Yes")
|
# 解説みたよ
import sys
sys.setrecursionlimit(10000000)
input = sys.stdin.readline
n, m = list(map(int, input().split()))
es = [[] for i in range(n)]
l, r, d = [0] * m, [0] * m, [0] * m
for i in range(m):
l[i], r[i], d[i] = list(map(int, input().split()))
l[i] -= 1
r[i] -= 1
es[l[i]].append((r[i], d[i]))
es[r[i]].append((l[i], -d[i]))
INF = 1000000000000
value = [INF] * n
def dfs(v):
for i, di in es[v]:
if value[i] == INF:
value[i] = value[v] + di
dfs(i)
for i in range(n):
if value[i] == INF:
value[i] = 0
dfs(i)
for i, j, k in zip(l, r, d):
if value[j] - value[i] != k:
print("No")
exit()
print("Yes")
|
p03450
|
n,m=list(map(int,input().split()))
ans=[10**10]*n
edge=[[]for _ in range(n)]
for _ in range(m):
l,r,d=list(map(int,input().split()))
l-=1
r-=1
edge[l].append([r,d])
edge[r].append([l,-d])
for i in range(n):
if ans[i]==10**10:
ans[i]=0
Q=[i]
while Q:
P=[]
for i in Q:
for j,d in edge[i]:
if ans[j]==10**10:
P+=[j]
ans[j]=ans[i]+d
Q=P
for i in range(n):
for j,k in edge[i]:
if ans[i]+k!=ans[j]:print("No");exit()
print("Yes")
|
n,m=list(map(int,input().split()))
ans=[10**10]*n
edge=[[]for _ in range(n)]
for _ in range(m):
l,r,d=list(map(int,input().split()))
l-=1;r-=1
edge[l].append((r,d))
edge[r].append((l,-d))
for i in range(n):
if ans[i]==10**10:
ans[i]=0
Q=[i]
while Q:
P=[]
for j in Q:
for k,d in edge[j]:
if ans[k]==10**10:
ans[k]=ans[j]+d
P.append(k)
elif ans[j]+d!=ans[k]:
print("No");exit()
Q=P
print("Yes")
|
p03450
|
class WeightsUnionfind:
def __init__(self,n):
self.Tree=[i for i in range(n)]
self.dWeights=[0]*n
self.wrong=0
def find(self,x):
if x==self.Tree[x]:
return x
else:
root=self.find(self.Tree[x])
self.dWeights[x]=self.weigh(x)
self.Tree[x]=root
return root
def weigh(self,x):
if x==self.Tree[x]:
return 0
else:
w=self.weigh(self.Tree[x])+self.dWeights[x]
return w
def unite(self,x,y,w):
s1=self.find(x)
s2=self.find(y)
if s1==s2:
if self.weigh(y)-self.weigh(x)!=w:
self.wrong=1
else:
self.Tree[s1]=s2
self.dWeights[s1]=self.weigh(y)-self.weigh(x)-w
N,M=list(map(int,input().split()))
wuf=WeightsUnionfind(N)
F=0
for m in range(M):
l,r,d=list(map(int,input().split()))
wuf.unite(l-1,r-1,d)
if wuf.wrong==1:
print("No")
else:
print("Yes")
|
class WeightsUnionfind:
def __init__(self,n):
self.Tree=[i for i in range(n)]
self.dWeights=[0]*n
self.rank=[0]*n
self.wrong=0
def find(self,x):
if x==self.Tree[x]:
return x
else:
root=self.find(self.Tree[x])
self.dWeights[x]=self.weigh(x)
self.Tree[x]=root
return root
def weigh(self,x):
if x==self.Tree[x]:
return 0
else:
w=self.weigh(self.Tree[x])+self.dWeights[x]
return w
def unite(self,x,y,w):
s1=self.find(x)
s2=self.find(y)
if s1==s2:
if self.weigh(y)-self.weigh(x)!=w:
self.wrong=1
else:
if self.rank[s1]>self.rank[s2]:
self.Tree[s2]=s1
self.dWeights[s2]=self.weigh(x)-self.weigh(y)+w
elif self.rank[s1]<self.rank[s2]:
self.Tree[s1]=s2
self.dWeights[s1]=self.weigh(y)-self.weigh(x)-w
else:
self.Tree[s2]=s1
self.rank[s1]+=1
self.dWeights[s2]=self.weigh(x)-self.weigh(y)+w
N,M=list(map(int,input().split()))
wuf=WeightsUnionfind(N)
F=0
for m in range(M):
l,r,d=list(map(int,input().split()))
wuf.unite(l-1,r-1,d)
if wuf.wrong==1:
print("No")
else:
print("Yes")
|
p03450
|
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
def dfs(u, cost):
visited[u] = True
for v, w in edge[u]:
if costs.get(v) and costs[v] != cost + w:
print("No")
sys.exit()
costs[v] = cost + w
dfs(v, cost + w)
from collections import defaultdict
n, m = list(map(int, readline().split()))
edge = defaultdict(list)
for _ in range(m):
l, r, d = list(map(int, readline().split()))
edge[l].append((r, d))
visited = [False] * (n + 1)
for u in range(1, n + 1):
costs = dict()
if not visited[u]:
dfs(u, 0)
print("Yes")
if __name__ == '__main__':
main()
|
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
from collections import defaultdict, deque
n, m = list(map(int, readline().split()))
edge = defaultdict(list)
for _ in range(m):
l, r, d = list(map(int, readline().split()))
edge[l].append((r, d))
edge[r].append((l, -d))
visited = [False] * (n + 1)
for x in range(1, n + 1):
costs = dict()
if not visited[x]:
costs[x] = 0
que = deque()
que.append((x, 0))
while que:
u, cost = que.popleft()
visited[u] = True
while edge[u]:
v, w = edge[u].pop()
if v in costs:
if costs[v] != cost + w:
print("No")
sys.exit()
costs[v] = cost + w
que.append((v, cost + w))
print("Yes")
if __name__ == '__main__':
main()
|
p03450
|
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
graph = [[] for _ in range(N + 1)]
for _ in range(M):
L, R, D = list(map(int, input().split()))
graph[L].append((R, D))
graph[R].append((L, -D))
d = ['a'] * (N + 1)
def calc(start): #startからの連結成分をチェックする
d[start] = 0
stack = [start]
while len(stack) != 0:
tmp = stack.pop()
for next_, diff in graph[tmp]:
if d[next_] == 'a':
d[next_] = d[tmp] + diff
stack.append(next_)
else:
if d[next_] == d[tmp] + diff:
pass
else:
print ('No')
exit()
return
# for i in graph:
# print (i)
for i in range(1, N):
if d[i] == 'a':
calc(i)
print ('Yes')
|
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
graph = [[] for _ in range(N + 1)]
for _ in range(M):
L, R, D = list(map(int, input().split()))
graph[L].append((R, D))
graph[R].append((L, -D))
d = [None] * (N + 1)
def calc(start): #startからの連結成分をチェックする
d[start] = 0
stack = [start]
while len(stack) != 0:
tmp = stack.pop()
for next_, diff in graph[tmp]:
if d[next_] == None:
d[next_] = d[tmp] + diff
stack.append(next_)
else:
if d[next_] == d[tmp] + diff:
pass
else:
print ('No')
exit()
return
# for i in graph:
# print (i)
for i in range(1, N):
if d[i] == None:
calc(i)
print ('Yes')
|
p03450
|
from collections import deque
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
G = [[] for _ in range(N + 1)]
for _ in range(M):
l, r, d = list(map(int, input().split()))
G[l].append((r, -d))
G[r].append((l, d))
MIN = -10 ** 18
lst = [MIN] * (N + 1)
que = deque()
for i in range(1, N + 1):
if lst[i] == MIN:
que.append(i)
lst[i] = 0
while que:
tmp = que.popleft()
for next_, d in G[tmp]:
if lst[next_] == MIN:
lst[next_] = lst[tmp] + d
que.append(next_)
continue
if lst[next_] == lst[tmp] + d:
continue
else:
print ('No')
exit()
print ('Yes')
|
from collections import deque
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
G = [[] for _ in range(N + 1)]
for _ in range(M):
l, r, d = list(map(int, input().split()))
G[l].append((r, -d))
G[r].append((l, d))
MIN = -10 ** 18
lst = [MIN] * (N + 1)
que = deque()
que_append = que.append
que_popleft = que.popleft
for i in range(1, N + 1):
if lst[i] == MIN:
que_append(i)
lst[i] = 0
while que:
tmp = que_popleft()
for next_, d in G[tmp]:
if lst[next_] == MIN:
lst[next_] = lst[tmp] + d
que_append(next_)
continue
if lst[next_] == lst[tmp] + d:
continue
else:
print ('No')
exit()
print ('Yes')
|
p03450
|
from collections import deque
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
G = [[] for _ in range(N + 1)]
for _ in range(M):
l, r, d = list(map(int, input().split()))
G[l].append((r, -d))
G[r].append((l, d))
MIN = -10 ** 18
lst = [MIN] * (N + 1)
que = deque()
que_append = que.append
que_popleft = que.popleft
for i in range(1, N + 1):
if lst[i] == MIN:
que_append(i)
lst[i] = 0
while que:
tmp = que_popleft()
for next_, d in G[tmp]:
if lst[next_] == MIN:
lst[next_] = lst[tmp] + d
que_append(next_)
continue
if lst[next_] == lst[tmp] + d:
continue
else:
print ('No')
exit()
print ('Yes')
|
def main():
from collections import deque
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
G = [[] for _ in range(N + 1)]
for _ in range(M):
l, r, d = list(map(int, input().split()))
G[l].append((r, -d))
G[r].append((l, d))
MIN = -10 ** 18
lst = [MIN] * (N + 1)
que = deque()
que_append = que.append
que_popleft = que.popleft
for i in range(1, N + 1):
if lst[i] == MIN:
que_append(i)
lst[i] = 0
while que:
tmp = que_popleft()
for next_, d in G[tmp]:
if lst[next_] == MIN:
lst[next_] = lst[tmp] + d
que_append(next_)
continue
if lst[next_] == lst[tmp] + d:
continue
else:
print ('No')
exit()
print ('Yes')
if __name__ == '__main__':
main()
|
p03450
|
from collections import deque
N, M = map(int, input().split())
L = []
R = []
D = []
for i in range(M):
l, r, d = map(int, input().split())
L.append(l)
R.append(r)
D.append(d)
inf = float("inf")
class WDG(): # 重み付き有向グラフ(隣接リスト表現)
class node():
def __init__(self, index=0, weight=0, next=None):
self.index = index
self.weight = weight
self.next = next
def __init__(self, N, M, L, R, D):
self.heads = []
self.x = [None] * N
self.N = N
self.q = deque()
for i in range(N):
head = WDG.node()
head.next = head
head.index = i
self.heads.append(head)
for i in range(M):
new1 = WDG.node(R[i] - 1, D[i], head)
new2 = WDG.node(L[i] - 1, -D[i], head)
self.insert(L[i] - 1, new1)
self.insert(R[i] - 1, new2)
def insert(self, start, new):
new.next = self.heads[start].next
self.heads[start].next = new
def show_graph(self):
for i in self.heads:
node = i.next
print("{}=>".format(i.index + 1), end="")
while node != i:
print("{}({})".format(node.index + 1, node.weight), end=" ")
node = node.next
print("")
def _DFS(self, s_head): # 始点sから到達できる連結成分を深さ優先探索
node = s_head.next
while node != s_head:
new_x = self.x[s_head.index] + node.weight
if self.x[node.index] is None:
#print("node{}".format(node.index + 1))
self.x[node.index] = new_x
if not self._DFS(self.heads[node.index]):
return False
elif self.x[node.index] != new_x:
#print("node{}NG".format(node.index + 1))
return False
node = node.next
return True
def DFS(self): # すべての点を訪れるまで深さ優先探索
for i in range(self.N):
node = self.heads[i]
if self.x[node.index] is None:
self.x[node.index] = 0
if not self._DFS(self.heads[node.index]):
return "No"
return "Yes"
def _BFS(self, s_head):
self.q.append(s_head)
while len(self.q) != 0:
p = self.q.popleft()
node = p.next
while node != p:
if self.x[node.index] is None:
self.x[node.index] = self.x[p.index] + node.weight
self.q.append(self.heads[node.index])
elif self.x[node.index] != self.x[p.index] + node.weight:
return False
node = node.next
return True
def BFS(self):
for i in range(self.N):
node = self.heads[i]
if self.x[i]is None:
self.x[i] = 0
if not self._BFS(node):
return "No"
return "Yes"
G = WDG(N, M, L, R, D)
# G.show_graph()
# print(G.DFS())
print(G.BFS())
|
from collections import deque
N, M = list(map(int, input().split()))
G = [[] for _ in range(N)]
for i in range(M):
l, r, d = list(map(int, input().split()))
G[l - 1].append((r - 1, d))
G[r - 1].append((l - 1, -d))
q = deque()
x = [None] * N
def _BFS(start):
q.append(start)
while len(q) != 0:
p = q.popleft()
for index, d in G[p]:
if x[index] is None:
x[index] = x[p] + d
q.append(index)
elif x[index] != x[p] + d:
return False
return True
def BFS():
for i in range(N):
if x[i] is None:
x[i] = 0
if not _BFS(i):
return "No"
return "Yes"
print((BFS()))
|
p03450
|
from collections import deque
n, m = list(map(int, input().split()))
graph = [[] for i in range(n)]
for i in range(m):
l, r, d = list(map(int, input().split()))
graph[l-1].append((r-1, d))
graph[r-1].append((l-1, -d))
for i in range(n):
x = [-1 for i in range(n)]
if x[i] == -1:
x[i] = 0
q = deque([i])
while q:
s = q.popleft()
for node, dist in graph[s]:
if x[node] == -1:
q.append(node)
x[node] = x[s] + dist
elif x[node] != x[s] + dist:
print("No")
exit()
print("Yes")
|
n, m = list(map(int, input().split()))
par = [i for i in range(n)]
rank = [0 for i in range(n)]
diff_weight = [0 for i in range(n)]
def root(x):
if par[x] == x:
return x
r = root(par[x])
diff_weight[x] += diff_weight[par[x]]
par[x] = r
return par[x]
def issame(x, y):
return root(x) == root(y)
def weight(x):
root(x)
return diff_weight[x]
def diff(x, y):
return weight(y) - weight(x)
def merge(x, y, w):
w += weight(x)
w -= weight(y)
x = root(x)
y = root(y)
if x == y:
return False
if rank[x] < rank[y]:
x, y = y, x
w = -w
if rank[x] == rank[y]:
rank[x] += 1
par[y] = x
diff_weight[y] = w
return True
for i in range(m):
l, r, d = list(map(int, input().split()))
if issame(l-1, r-1):
di = diff(l-1, r-1)
if di != d:
print("No")
exit()
else:
merge(l-1, r-1, d)
print("Yes")
|
p03450
|
from bisect import bisect_left
from copy import deepcopy
from operator import itemgetter
n, m = (int(x) for x in input().split())
LRD = [tuple(int(x) for x in input().split()) for _ in range(m)]
LRD.sort(key=itemgetter(0, 1))
INF = 10**18
while LRD:
X = [INF] * n
TBD = [] # To be determined
X[LRD[0][0] - 1] = 0
for l, r, d in LRD:
l -= 1
r -= 1
if X[l] == X[r] == INF:
TBD.append((l, r, d))
elif X[l] != INF and X[r] == INF:
X[r] = X[l] + d
elif X[l] == INF and X[r] != INF:
X[l] = X[r] - d
else:
if X[r] - X[l] != d:
print("No")
exit()
else:
continue
LRD = deepcopy(TBD)
LRD.sort(key=itemgetter(0, 1))
X.sort()
xmax = X[bisect_left(X, INF) - 1]
xmin = X[0]
if xmax - xmin >= 10**9:
print("No")
exit()
print("Yes")
|
n, m = (int(x) for x in input().split())
LRD = [tuple(int(x) for x in input().split()) for _ in range(m)]
G = [[] for _ in range(n)]
dist = dict()
for l, r, d in LRD:
l -= 1
r -= 1
G[l].append(r)
G[r].append(l)
dist[(l, r)] = d
dist[(r, l)] = -d
INF = 10**18
X = [INF] * n
for i in range(n):
stack = [i]
while stack:
u = stack.pop()
if X[u] == INF:
X[u] = 0
for v in G[u]: # u -> v
if X[v] == INF:
X[v] = X[u] + dist[(u, v)]
stack.append(v)
else:
if X[v] != X[u] + dist[(u, v)]:
print("No")
exit()
print("Yes")
|
p03450
|
#重み付きUnion-Find
#xの根を求める
def find(x):
if par[x] < 0:
return x
else:
px = find(par[x])
wei[x] += wei[par[x]]
par[x] = px
return px
#xの根から距離
def weight(x):
find(x)
return wei[x]
#w[y]=w[x]+wとなるようにxとyを併合
def unite(x,y,w):
w += wei[x]-wei[y]
x = find(x)
y = find(y)
if x == y:
return False
else:
#sizeの大きいほうがx
if par[x] > par[y]:
x,y = y,x
w = -w
par[x] += par[y]
par[y] = x
wei[y] = w
return True
#xとyが同じ集合に属するかの判定
def same(x,y):
return find(x) == find(y)
#xが属する集合の個数
def size(x):
return -par[find(x)]
#x,yが同じ集合に属するときのwei[y]-wei[x]
def diff(x,y):
return weight(y)-weight(x)
n,m = list(map(int,input().split()))
#初期化
#par:根なら-size,子なら親の頂点
#wei:親からの距離,根なら0
par = [-1]*n
wei = [0]*n
for i in range(m):
l,r,d = list(map(int,input().split()))
l,r = l-1,r-1
if same(l,r):
if d != diff(l,r):
print('No')
exit()
else:
unite(l,r,d)
print('Yes')
|
def main():
import sys
input = sys.stdin.readline
#重み付きUnion-Find
#xの根を求める
def find(x):
if par[x] < 0:
return x
else:
px = find(par[x])
wei[x] += wei[par[x]]
par[x] = px
return px
#xの根から距離
def weight(x):
find(x)
return wei[x]
#w[y]=w[x]+wとなるようにxとyを併合
def unite(x,y,w):
w += wei[x]-wei[y]
x = find(x)
y = find(y)
if x == y:
return False
else:
#sizeの大きいほうがx
if par[x] > par[y]:
x,y = y,x
w = -w
par[x] += par[y]
par[y] = x
wei[y] = w
return True
#xとyが同じ集合に属するかの判定
def same(x,y):
return find(x) == find(y)
#xが属する集合の個数
def size(x):
return -par[find(x)]
#x,yが同じ集合に属するときのwei[y]-wei[x]
def diff(x,y):
return weight(y)-weight(x)
n,m = list(map(int,input().split()))
#初期化
#par:根なら-size,子なら親の頂点
#wei:親からの距離,根なら0
par = [-1]*n
wei = [0]*n
for i in range(m):
l,r,d = list(map(int,input().split()))
l,r = l-1,r-1
if same(l,r):
if d != diff(l,r):
print('No')
exit()
else:
unite(l,r,d)
print('Yes')
if __name__ == '__main__':
main()
|
p03450
|
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def TUPLE(): return tuple(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#mod = 998244353
from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10
N, M = MAP()
LRD = [LIST() for _ in range(M)]
graph = [[] for _ in range(N)]
for L, R, D in LRD:
graph[L-1].append((R-1, D))
graph[R-1].append((L-1, -D))
check = [1]*N
i = 0
while i < N:
while check[i] == 0:
i += 1
if i == N:
print("Yes")
exit()
check[i] = 0
dis = defaultdict(int)
dis[i] = 0
q = deque([i])
while q:
p = q.popleft()
for v, dist in graph[p]:
if check[v] == 1:
check[v] = 0
dis[v] = dis[p] + dist
q.append(v)
if check[v] == 0 and dis[v] != dis[p] + dist:
print("No")
exit()
|
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def TUPLE(): return tuple(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#mod = 998244353
from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10
N, M = MAP()
LRD = [LIST() for _ in range(M)]
graph = [[] for _ in range(N)]
for L, R, D in LRD:
graph[L-1].append((R-1, D))
graph[R-1].append((L-1, -D))
check = [1]*N
i = 0
while 1:
while check[i] == 0:
i += 1
if i == N:
print("Yes")
exit()
check[i] = 0
dis = defaultdict(int)
dis[i] = 0
q = deque([i])
while q:
p = q.popleft()
for v, dist in graph[p]:
if check[v] == 1:
check[v] = 0
dis[v] = dis[p] + dist
q.append(v)
if check[v] == 0 and dis[v] != dis[p] + dist:
print("No")
exit()
|
p03450
|
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def TUPLE(): return tuple(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#mod = 998244353
from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10
N, M = MAP()
LRD = [LIST() for _ in range(M)]
graph = [[] for _ in range(N)]
for L, R, D in LRD:
graph[L-1].append((R-1, D))
graph[R-1].append((L-1, -D))
check = [1]*N
i = 0
while 1:
while check[i] == 0:
i += 1
if i == N:
print("Yes")
exit()
check[i] = 0
dis = defaultdict(int)
dis[i] = 0
q = deque([i])
while q:
p = q.popleft()
for v, dist in graph[p]:
if check[v] == 1:
check[v] = 0
dis[v] = dis[p] + dist
q.append(v)
if check[v] == 0 and dis[v] != dis[p] + dist:
print("No")
exit()
|
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def TUPLE(): return tuple(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#mod = 998244353
from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10
N, M = MAP()
graph = defaultdict(list)
for _ in range(M):
L, R, D = MAP()
graph[L-1].append((R-1, D))
graph[R-1].append((L-1, -D))
num = [None]*N
for i in range(N):
if num[i] != None:
continue
q = deque([i])
num[i] = 0
while q:
n = q.popleft()
for node, weight in graph[n]:
if num[node] == None:
num[node] = num[n] + weight
q.append(node)
elif num[node] != num[n] + weight:
print("No")
exit()
else:
print("Yes")
|
p03450
|
from collections import deque
N, M = list(map(int, input().split()))
L = []
R = []
D = []
G = [[] for _ in range(N+1)]
for _ in range(M):
tmpl, tmpr, tmpd = list(map(int, input().split()))
# if tmpl > tmpr:
# tmpl, tmpr = tmpr, tmpl
# tmpd *= -1
L.append(tmpl)
R.append(tmpr)
D.append(tmpd)
G[tmpl].append((tmpr, tmpd))
G[tmpr].append((tmpl, -tmpd))
field = [None] * (N+1)
def dfs(i):
q = deque()
q.append(i)
field[i] = 0
used = [False]*(N+1)
used[i] = True
while q:
tmp = q.pop()
for elem in G[tmp]:
if used[elem[0]]:
if field[elem[0]] is not None:
if field[elem[0]] != field[tmp]+elem[1]:
return False
continue
q.append(elem[0])
if field[elem[0]] == None:
field[elem[0]] = field[tmp]+elem[1]
used[elem[0]] = True
else:
if field[elem[0]] != field[tmp]+elem[1]:
return False
return True
for i in range(1, N+1):
if field[i] == None:
if not dfs(i):
print('No')
exit()
print('Yes')
|
from collections import deque
N, M = list(map(int, input().split()))
#L = []
#R = []
#D = []
G = [[] for _ in range(N+1)]
for _ in range(M):
tmpl, tmpr, tmpd = list(map(int, input().split()))
# L.append(tmpl)
# R.append(tmpr)
# D.append(tmpd)
G[tmpl].append((tmpr, tmpd))
G[tmpr].append((tmpl, -tmpd))
field = [None] * (N+1)
def dfs(i):
q = deque()
q.append(i)
field[i] = 0
#used = [False]*(N+1)
#used[i] = True
while q:
tmp = q.pop()
for elem in G[tmp]:
if field[elem[0]] is not None:
if field[elem[0]] != field[tmp]+elem[1]:
return False
continue
else:
q.append(elem[0])
field[elem[0]] = field[tmp]+elem[1]
# if used[elem[0]]:
# if field[elem[0]] is not None:
# if field[elem[0]] != field[tmp]+elem[1]:
# return False
# continue
# q.append(elem[0])
# if field[elem[0]] == None:
# field[elem[0]] = field[tmp]+elem[1]
# used[elem[0]] = True
# else:
# if field[elem[0]] != field[tmp]+elem[1]:
# return False
return True
for i in range(1, N+1):
if field[i] == None:
if not dfs(i):
print('No')
exit()
print('Yes')
|
p03450
|
from collections import deque
N, M = list(map(int, input().split()))
#L = []
#R = []
#D = []
G = [[] for _ in range(N+1)]
for _ in range(M):
tmpl, tmpr, tmpd = list(map(int, input().split()))
# L.append(tmpl)
# R.append(tmpr)
# D.append(tmpd)
G[tmpl].append((tmpr, tmpd))
G[tmpr].append((tmpl, -tmpd))
field = [None] * (N+1)
def dfs(i):
q = deque()
q.append(i)
field[i] = 0
#used = [False]*(N+1)
#used[i] = True
while q:
tmp = q.pop()
for elem in G[tmp]:
if field[elem[0]] is not None:
if field[elem[0]] != field[tmp]+elem[1]:
return False
continue
else:
q.append(elem[0])
field[elem[0]] = field[tmp]+elem[1]
# if used[elem[0]]:
# if field[elem[0]] is not None:
# if field[elem[0]] != field[tmp]+elem[1]:
# return False
# continue
# q.append(elem[0])
# if field[elem[0]] == None:
# field[elem[0]] = field[tmp]+elem[1]
# used[elem[0]] = True
# else:
# if field[elem[0]] != field[tmp]+elem[1]:
# return False
return True
for i in range(1, N+1):
if field[i] == None:
if not dfs(i):
print('No')
exit()
print('Yes')
|
from collections import deque
N, M = list(map(int, input().split()))
G = [[] for _ in range(N+1)]
for _ in range(M):
tmpl, tmpr, tmpd = list(map(int, input().split()))
G[tmpl].append((tmpr, tmpd))
G[tmpr].append((tmpl, -tmpd))
field = [None] * (N+1)
def dfs(i):
q = deque()
q.append(i)
field[i] = 0
while q:
tmp = q.pop()
for elem in G[tmp]:
if field[elem[0]] is not None:
if field[elem[0]] != field[tmp]+elem[1]:
return False
continue
else:
q.append(elem[0])
field[elem[0]] = field[tmp]+elem[1]
return True
for i in range(1, N+1):
if field[i] is None:
if not dfs(i):
print('No')
exit()
print('Yes')
|
p03450
|
def main():
import sys
input = sys.stdin.buffer.readline
N, M = (int(i) for i in input().split())
par = [i for i in range(N)]
rank = [1]*N
weight = [0]*N
def find_root(x):
if par[x] == x:
return x
else:
r = find_root(par[x])
weight[x] += weight[par[x]]
par[x] = r
return par[x]
def get_weight(x):
find_root(x)
return weight[x]
def get_diff(x, y):
return get_weight(y) - get_weight(x)
def is_same_group(x, y):
return find_root(x) == find_root(y)
def unite(x, y, w):
w += get_weight(x)
w -= get_weight(y)
x = find_root(x)
y = find_root(y)
if x == y:
return
if rank[x] < rank[y]:
x, y = y, x
w = -w
rank[x] += rank[y]
par[y] = x
weight[y] = w
def size(x):
# 連結成分のサイズを返す
return rank[find_root(x)]
for i in range(M):
le, ri, d = (int(i) for i in input().split())
le -= 1
ri -= 1
if is_same_group(le, ri):
diff = get_diff(le, ri)
if diff != d:
return print("No")
else:
unite(le, ri, d)
print("Yes")
if __name__ == '__main__':
main()
|
class WeightedUnionFind:
""" あっとさんありがとうございます """
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
# 根への距離を管理
self.weight = [0] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
y = self.find(self.par[x])
# 親への重みを追加しながら根まで走査
self.weight[x] += self.weight[self.par[x]]
self.par[x] = y
return y
# 併合
def union(self, x, y, w):
rx = self.find(x)
ry = self.find(y)
# xの木の高さ < yの木の高さ
if self.rank[rx] < self.rank[ry]:
self.par[rx] = ry
self.weight[rx] = w - self.weight[x] + self.weight[y]
# xの木の高さ ≧ yの木の高さ
else:
self.par[ry] = rx
self.weight[ry] = -w - self.weight[y] + self.weight[x]
# 木の高さが同じだった場合の処理
if self.rank[rx] == self.rank[ry]:
self.rank[rx] += 1
# 同じ集合に属するか
def same(self, x, y):
return self.find(x) == self.find(y)
# xからyへのコスト
def diff(self, x, y):
return self.weight[x] - self.weight[y]
def main():
import sys
input = sys.stdin.buffer.readline
N, M = (int(i) for i in input().split())
uf = WeightedUnionFind(N)
LRD = [[int(i) for i in input().split()] for j in range(M)]
for le, ri, d in LRD:
if uf.same(le, ri):
if uf.diff(le, ri) != d:
return print("No")
uf.union(le, ri, d)
print("Yes")
if __name__ == '__main__':
main()
|
p03450
|
N, M = list(map(int, input().split()))
LRD = [list(map(int, input().split())) for _ in range(M)]
roots = [(i,0) for i in range(N+1)] #(root, distance_to_root)
def find_root(a, roots=roots):
if roots[a][0] == a:
return (a,0)
else:
r, d = find_root(roots[a][0])
roots[a] = (r, roots[a][1] + d)
return roots[a]
def unite(l, r, d, roots=roots):
root_l, d_l = find_root(l)
root_r, d_r = find_root(r)
if root_l == root_r:
if d_l == d + d_r:
return True
else:
return False
else:
roots[root_l] = (r, d - d_l)
return True
for l,r,d in LRD:
if not unite(l,r,d):
print('No')
break
else:
print('Yes')
|
N, M = list(map(int, input().split()))
LRD = [list(map(int, input().split())) for _ in range(M)]
roots = [(i,0) for i in range(N+1)] #(root, distance_from_i_to_root)
def find_root(a, roots=roots):
if roots[a][0] == a:
return (a,0)
else:
r, d = find_root(roots[a][0])
roots[a] = (r, roots[a][1] + d)
return roots[a]
def unite(l, r, d, roots=roots):
root_l, d_l = find_root(l)
root_r, d_r = find_root(r)
if root_l == root_r:
if d_l == d + d_r:
return True
else:
return False
else:
roots[root_l] = (root_r, d + d_r - d_l)
return True
for l,r,d in LRD:
if not unite(l,r,d):
print('No')
break
else:
print('Yes')
|
p03450
|
from collections import deque
n, m = list(map(int, input().split()))
graph = [[] for _ in range(n)]
for _ in range(m):
l, r, d = list(map(int, input().split()))
graph[l-1].append((r-1, d))
graph[r-1].append((l-1, -d))
seen = [False]*n
dist = [None]*n
for i in range(n):
if seen[i]:
continue
q = deque([i])
dist[i] = 0
while q:
node = q.popleft()
seen[node] = True
for c_node, d in graph[node]:
if dist[c_node] is None:
dist[c_node] = dist[node] + d
elif dist[c_node] != dist[node] + d:
print('No')
exit(0)
if not seen[c_node]:
q.append(c_node)
print('Yes')
|
from collections import deque
n, m = list(map(int, input().split()))
graph = [[] for _ in range(n)]
for _ in range(m):
l, r, d = list(map(int, input().split()))
graph[l-1].append((r-1, d))
graph[r-1].append((l-1, -d))
seen = [False]*n
dist = [None]*n
for i in range(n):
if seen[i]:
continue
q = deque([i])
dist[i] = 0
while q:
node = q.popleft()
if seen[node]:
continue
seen[node] = True
for c_node, d in graph[node]:
if dist[c_node] is None:
dist[c_node] = dist[node] + d
elif dist[c_node] != dist[node] + d:
print('No')
exit(0)
if not seen[c_node]:
q.append(c_node)
print('Yes')
|
p03450
|
import heapq
INF = float('inf')
class UnionFind:
def __init__(self, size: int):
self.__size = size
self.__root = [-1] * size
def find(self, u: int)->int:
if self.__root[u] < 0:
return u
self.__root[u] = self.find(self.__root[u])
return self.__root[u]
def same(self, u: int, v: int)->bool:
return self.find(u) == self.find(v)
def unite(self, u: int, v: int):
x, y = self.find(u), self.find(v)
if x == y:
return
if self.__root[y] < self.__root[x]:
x, y = y, x
self.__root[x] += self.__root[y]
self.__root[y] = x
def print(self):
print(self.__root)
class PriorityQueue:
def __init__(self):
self.__queue = []
self.__count = 0
def enqueue(self, v):
self.__count += 1
heapq.heappush(self.__queue, v)
def dequeue(self):
self.__count -= 1
return heapq.heappop(self.__queue)
def is_empty(self)->bool:
return self.__count == 0
def dijkstra(V: int, E: list, s: int, t: int)->int:
'''dijkstra 法を使って u -> v の距離を求める。
:param V: 頂点数
:param E: 辺の集合
:param s: 始点
:param t: 終点
:return: 距離
'''
d = [INF] * (V)
d[s] = 0
q = PriorityQueue()
for v in range(V):
q.enqueue((d[v], v))
while not q.is_empty():
_, u = q.dequeue()
for v, c in E[u]:
if d[u] + c < d[v]:
d[v] = d[u] + c
q.enqueue((d[v], v))
return d[t]
def people_on_a_line(N: int, M: int, queries: list)->bool:
E = [[] for _ in range(N)]
uf = UnionFind(N)
for l, r, d in queries:
if uf.same(l-1, r-1):
if d != dijkstra(N, E, l-1, r-1):
return False
else:
uf.unite(l-1, r-1)
E[l-1].append((r-1, d))
E[r-1].append((l-1, -d))
return True
if __name__ == "__main__":
M = 0
N, M = map(int, input().split())
queries = [tuple(int(s) for s in input().split()) for _ in range(M)]
yes = people_on_a_line(N, M, queries)
print('Yes' if yes else 'No')
|
class WeightenedUnionFind:
def __init__(self, size: int):
self.__size = size
self.__root = [-1] * size
self.__diff_weight = [0] * size
def find(self, u: int)->int:
if self.__root[u] < 0:
return u
r = self.find(self.__root[u])
self.__diff_weight[u] += self.__diff_weight[self.__root[u]]
self.__root[u] = r
return self.__root[u]
def same(self, u: int, v: int)->bool:
return self.find(u) == self.find(v)
def unite(self, u: int, v: int, w: int):
w += self.weight(u)
w -= self.weight(v)
x, y = self.find(u), self.find(v)
if x == y:
return
if self.__root[y] < self.__root[x]:
x, y = y, x
w = -w
self.__root[x] += self.__root[y]
self.__root[y] = x
self.__diff_weight[y] = w
def weight(self, u: int)->int:
self.find(u)
return self.__diff_weight[u]
def diff_weight(self, u: int, v: int)->int:
return self.weight(v) - self.weight(u)
def people_on_a_line(N: int, M: int, queries: list)->bool:
uf = WeightenedUnionFind(N)
for l, r, d in queries:
if uf.same(l-1, r-1):
if d != uf.diff_weight(l-1, r-1):
return False
else:
uf.unite(l-1, r-1, d)
return True
if __name__ == "__main__":
M = 0
N, M = list(map(int, input().split()))
queries = [tuple(int(s) for s in input().split()) for _ in range(M)]
yes = people_on_a_line(N, M, queries)
print(('Yes' if yes else 'No'))
|
p03450
|
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict
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, M, LRD):
# print(LRD)
g = [[] for _ in range(N)]
ns = set([])
for l ,r, d in LRD:
g[l-1].append((r-1,d))
g[r-1].append((l-1,-d))
ns.add(l-1)
ns.add(r-1)
G = [None for _ in range(N)]
if M == 0:
return 'Yes'
ns = {n:n for n in ns}
while ns:
q = [list(ns.keys())[0]]
ns.pop(q[0])
# print(q)
G[q[0]] = 0
while q:
n = q.pop(0)
for r, d in g[n]:
if G[r] is None:
G[r] = G[n] + d
q.append(r)
if r in ns:
ns.pop(r)
else:
if G[r] != G[n] + d:
return 'No'
# pass
return 'Yes'
def main():
N, M = read_int_n()
LRD = [read_int_n() for _ in range(M)]
# N = 100000
# M = 200000
# LRD = [[random.randint(1, N), random.randint(1, N), random.randint(1, 10000)] for _ in range(M) ]
print(slv(N, M, LRD))
if __name__ == '__main__':
main()
|
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict
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, M, LRD):
# print(LRD)
g = [[] for _ in range(N)]
ns = set([])
for l ,r, d in LRD:
g[l-1].append((r-1,d))
g[r-1].append((l-1,-d))
ns.add(l-1)
ns.add(r-1)
G = [None for _ in range(N)]
if M == 0:
return 'Yes'
ns = {n:n for n in ns}
while ns:
# q = [list(ns.keys())[0]]
for k in ns.keys():
q = [k]
break
ns.pop(q[0])
# print(q)
G[q[0]] = 0
while q:
n = q.pop()
for r, d in g[n]:
if G[r] is None:
G[r] = G[n] + d
q.append(r)
# if r in ns:
ns.pop(r)
else:
if G[r] != G[n] + d:
return 'No'
# pass
return 'Yes'
def main():
N, M = read_int_n()
LRD = [read_int_n() for _ in range(M)]
# N = 100000
# M = 200000
# LRD = [[random.randint(1, N), random.randint(1, N), random.randint(1, 10000)] for _ in range(M) ]
print(slv(N, M, LRD))
if __name__ == '__main__':
main()
|
p03450
|
# Union Find 木
from sys import setrecursionlimit
def find(parent, diff_weight, i):
t = parent[i]
if t < 0:
return i
t = find(parent, diff_weight, t)
diff_weight[i] += diff_weight[parent[i]]
parent[i] = t
return t
def weight(parent, diff_weight, i):
find(parent, diff_weight, i)
return diff_weight[i]
def unite(parent, diff_weight, i, j, d):
d -= weight(parent, diff_weight, j)
d += weight(parent, diff_weight, i)
i = find(parent, diff_weight, i)
j = find(parent, diff_weight, j)
if i == j:
return
diff_weight[j] = d
parent[i] += parent[j]
parent[j] = i
setrecursionlimit(10 ** 6)
N, M = list(map(int, input().split()))
LRD = [tuple(map(int, input().split())) for _ in range(M)]
parent = [-1] * (N + 1)
diff_weight = [0] * (N + 1)
for L, R, D in LRD:
i = find(parent, diff_weight, L)
j = find(parent, diff_weight, R)
if i != j:
unite(parent, diff_weight, L, R, D)
else:
if weight(parent, diff_weight, L) + D != weight(parent, diff_weight, R):
print('No')
exit()
print('Yes')
|
# Union Find 木
from sys import setrecursionlimit, stdin
def find(parent, diff_weight, i):
t = parent[i]
if t < 0:
return i
t = find(parent, diff_weight, t)
diff_weight[i] += diff_weight[parent[i]]
parent[i] = t
return t
def weight(parent, diff_weight, i):
find(parent, diff_weight, i)
return diff_weight[i]
def unite(parent, diff_weight, i, j, d):
d -= weight(parent, diff_weight, j)
d += weight(parent, diff_weight, i)
i = find(parent, diff_weight, i)
j = find(parent, diff_weight, j)
if i == j:
return
diff_weight[j] = d
parent[i] += parent[j]
parent[j] = i
setrecursionlimit(10 ** 6)
N, M = list(map(int, stdin.readline().split()))
LRD = [tuple(map(int, stdin.readline().split())) for _ in range(M)]
parent = [-1] * (N + 1)
diff_weight = [0] * (N + 1)
for L, R, D in LRD:
i = find(parent, diff_weight, L)
j = find(parent, diff_weight, R)
if i != j:
unite(parent, diff_weight, L, R, D)
else:
if weight(parent, diff_weight, L) + D != weight(parent, diff_weight, R):
print('No')
exit()
print('Yes')
|
p03450
|
# Union Find 木
from sys import setrecursionlimit, stdin
def find(parent, diff_weight, i):
t = parent[i]
if t < 0:
return i
t = find(parent, diff_weight, t)
diff_weight[i] += diff_weight[parent[i]]
parent[i] = t
return t
def weight(parent, diff_weight, i):
find(parent, diff_weight, i)
return diff_weight[i]
def unite(parent, diff_weight, i, j, d):
d -= weight(parent, diff_weight, j)
d += weight(parent, diff_weight, i)
i = find(parent, diff_weight, i)
j = find(parent, diff_weight, j)
if i == j:
return
diff_weight[j] = d
parent[i] += parent[j]
parent[j] = i
setrecursionlimit(10 ** 6)
N, M = list(map(int, stdin.readline().split()))
LRD = [tuple(map(int, stdin.readline().split())) for _ in range(M)]
parent = [-1] * (N + 1)
diff_weight = [0] * (N + 1)
for L, R, D in LRD:
i = find(parent, diff_weight, L)
j = find(parent, diff_weight, R)
if i != j:
unite(parent, diff_weight, L, R, D)
else:
if weight(parent, diff_weight, L) + D != weight(parent, diff_weight, R):
print('No')
exit()
print('Yes')
|
# 深さ優先探索
from sys import stdin
N, M = list(map(int, stdin.readline().split()))
links = [[] for _ in range(N + 1)]
for _ in range(M):
L, R, D = list(map(int, stdin.readline().split()))
links[L].append((R, D))
links[R].append((L, -D))
t = [None] * (N + 1)
for i in range(1, N + 1):
if t[i] is not None:
continue
t[i] = 0
s = [i]
while s:
j = s.pop()
for k, l in links[j]:
if t[k] is None:
t[k] = t[j] + l
s.append(k)
else:
if t[k] != t[j] + l:
print('No')
exit()
print('Yes')
|
p03450
|
def main():
from collections import deque
import sys
input = sys.stdin.readline
n,m = list(map(int,input().split()))
e = [[] for i in range(n)]
for i in range(m):
a,b,c = list(map(int,input().split()))
a -= 1
b -= 1
e[a].append([b,c])
e[b].append([a,-c])
dis = [False]*n
def search(x):
q = deque([])
dis[x] = 0
q.append((x,0))
while q:
now,cnt = q.popleft()
for nex,d in e[now]:
if dis[nex] == False:
dis[nex] = cnt+d
q.append((nex,cnt+d))
else:
if dis[nex] != cnt+d:
print("No")
exit()
for i in range(n):
if e[i] and dis[i] == False:
search(i)
print("Yes")
if __name__ == "__main__":
main()
|
def main():
from collections import deque
import sys
input = sys.stdin.readline
n,m = list(map(int,input().split()))
e = [[] for i in range(n)]
for i in range(m):
a,b,c = list(map(int,input().split()))
a -= 1
b -= 1
e[a].append([b,c])
e[b].append([a,-c])
dis = [float("INF")]*n
def search(x):
q = deque([])
dis[x] = 0
q.append(x)
while q:
now = q.popleft()
for nex,d in e[now]:
if dis[nex] == float("INF"):
dis[nex] = dis[now]+d
q.append(nex)
else:
if dis[nex] != dis[now]+d:
print("No")
exit()
for i in range(n):
if e[i] and dis[i] == float("INF"):
search(i)
print("Yes")
if __name__ == "__main__":
main()
|
p03450
|
from collections import defaultdict
import sys
input = sys.stdin.readline
inf = float('INF')
n, m = list(map(int, input().split()))
if m == 0:
print('Yes')
exit()
edges = defaultdict(list)
for i in range(m):
left, right, dist = list(map(int, input().split()))
edges[left-1].append([right-1, dist])
edges[right-1].append([left-1, -dist])
seen = [inf] * n
for node in range(n):
if seen[node] != inf:
continue
seen[node] = 0
todo = []
while edges[node]:
to, dis = edges[node].pop()
todo.append([to, dis])
while todo:
new, dis = todo.pop()
if seen[new] == inf:
seen[new] = dis
elif seen[new] != dis:
print('No')
exit()
while edges[new]:
to, n_dis = edges[new].pop()
todo.append([to, dis + n_dis])
print('Yes')
|
from collections import defaultdict
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
if m == 0:
print('Yes')
exit()
edges = defaultdict(list)
for i in range(m):
left, right, dist = list(map(int, input().split()))
edges[left-1].append((right-1, dist))
edges[right-1].append((left-1, -dist))
seen = [None] * n
for node in range(n):
if seen[node] is not None:
continue
seen[node] = 0
todo = []
while edges[node]:
to, dis = edges[node].pop()
seen[to] = dis
todo.append([to, dis])
while todo:
new, dis = todo.pop()
while edges[new]:
to, n_dis = edges[new].pop()
if seen[to] is None:
seen[to] = dis + n_dis
elif seen[to] != dis + n_dis:
print('No')
exit()
todo.append([to, dis + n_dis])
print('Yes')
|
p03450
|
import sys
sys.setrecursionlimit(10000)
INF = float('inf')
class WeightedUnionFind:
def __init__(self, nodes):
"""
:param collections.Iterable nodes:
"""
self._parents = {k: k for k in nodes}
self._ranks = {k: 0 for k in nodes}
self._sizes = {k: 1 for k in nodes}
# 直近の親からの重み。root なら 0
self._weights = {k: 0 for k in nodes}
def unite(self, x, y, w):
"""
x が属する木と y が属する木を併合
:param x:
:param y:
:param w: x と y の重みの差; (重み y) - (重み x)
:return:
"""
# それぞれの root をくっつけたいので root 間の重みに変換
# x が上、y が下
w += self.weight(x)
w -= self.weight(y)
x = self.find(x)
y = self.find(y)
if x == y:
return
# rank が小さい方が下
if self._ranks[x] > self._ranks[y]:
# x が root
self._parents[y] = x
self._sizes[x] += self._sizes[y]
self._weights[x] = 0
self._weights[y] = w
else:
# y が root
self._parents[x] = y
self._sizes[y] += self._sizes[x]
self._weights[x] = -w
self._weights[y] = 0
if self._ranks[x] == self._ranks[y]:
self._ranks[y] += 1
def find(self, x):
"""
x が属する木の root
:param x:
:return:
"""
if self._parents[x] == x:
return x
root = self.find(self._parents[x])
self._weights[x] += self._weights[self._parents[x]]
self._parents[x] = root
return root
def size(self, x):
"""
x が属する木のノード数
:param x:
:return:
"""
return self._sizes[self.find(x)]
def weight(self, x):
"""
:param x:
:return:
"""
# 経路圧縮
self.find(x)
return self._weights[x]
def diff(self, x, y):
"""
(y の重み) - (x の重み)
:param x:
:param y:
:return:
"""
if self.find(x) == self.find(y):
return self.weight(y) - self.weight(x)
return float('inf')
N, M = list(map(int, input().split()))
uf = WeightedUnionFind([i + 1 for i in range(N)])
ok = True
for _ in range(M):
l, r, d = list(map(int, input().split()))
if uf.find(l) == uf.find(r) and uf.diff(l, r) != d:
ok = False
break
uf.unite(l, r, d)
if ok:
print('Yes')
else:
print('No')
|
import sys
import time
sys.setrecursionlimit(10000)
INF = float('inf')
class WeightedUnionFind:
def __init__(self, nodes):
"""
:param collections.Iterable nodes:
"""
self._parents = {k: k for k in nodes}
self._ranks = {k: 0 for k in nodes}
self._sizes = {k: 1 for k in nodes}
# 直近の親からの重み。root なら 0
self._weights = {k: 0 for k in nodes}
def unite(self, x, y, w):
"""
x が属する木と y が属する木を併合
:param x:
:param y:
:param w: x と y の重みの差; (重み y) - (重み x)
:return:
"""
rx = self.find(x)
ry = self.find(y)
if rx == ry:
return
# rank が小さい方が下
if self._ranks[rx] > self._ranks[ry]:
# x が root
self._parents[ry] = rx
self._sizes[rx] += self._sizes[ry]
# root 間の重みに変換
self._weights[ry] = w + self._weights[x] - self._weights[y]
else:
# y が root
self._parents[rx] = ry
self._sizes[ry] += self._sizes[rx]
# root 間の重みに変換
self._weights[rx] = -w + self._weights[y] - self._weights[x]
if self._ranks[rx] == self._ranks[ry]:
self._ranks[ry] += 1
def find(self, x):
"""
x が属する木の root
:param x:
:return:
"""
if self._parents[x] == x:
return x
root = self.find(self._parents[x])
self._weights[x] += self._weights[self._parents[x]]
self._parents[x] = root
return root
def size(self, x):
"""
x が属する木のノード数
:param x:
:return:
"""
return self._sizes[self.find(x)]
def weight(self, x):
"""
:param x:
:return:
"""
# 経路圧縮
self.find(x)
return self._weights[x]
def diff(self, x, y):
"""
(y の重み) - (x の重み)
:param x:
:param y:
:return:
"""
if self.find(x) == self.find(y):
return self._weights[y] - self._weights[x]
return float('inf')
N, M = list(map(int, input().split()))
uf = WeightedUnionFind([i + 1 for i in range(N)])
ok = True
for _ in range(M):
l, r, d = list(map(int, input().split()))
if uf.find(l) == uf.find(r) and uf.diff(l, r) != d:
ok = False
break
uf.unite(l, r, d)
if ok:
print('Yes')
else:
print('No')
|
p03450
|
import sys
import time
sys.setrecursionlimit(10000)
INF = float('inf')
class WeightedUnionFind:
def __init__(self, nodes):
"""
:param collections.Iterable nodes:
"""
self._parents = {k: k for k in nodes}
self._ranks = {k: 0 for k in nodes}
self._sizes = {k: 1 for k in nodes}
# 直近の親からの重み。root なら 0
self._weights = {k: 0 for k in nodes}
def unite(self, x, y, w):
"""
x が属する木と y が属する木を併合
:param x:
:param y:
:param w: x と y の重みの差; (重み y) - (重み x)
:return:
"""
rx = self.find(x)
ry = self.find(y)
if rx == ry:
return
# rank が小さい方が下
if self._ranks[rx] > self._ranks[ry]:
# x が root
self._parents[ry] = rx
self._sizes[rx] += self._sizes[ry]
# root 間の重みに変換
self._weights[ry] = w + self._weights[x] - self._weights[y]
else:
# y が root
self._parents[rx] = ry
self._sizes[ry] += self._sizes[rx]
# root 間の重みに変換
self._weights[rx] = -w + self._weights[y] - self._weights[x]
if self._ranks[rx] == self._ranks[ry]:
self._ranks[ry] += 1
def find(self, x):
"""
x が属する木の root
:param x:
:return:
"""
if self._parents[x] == x:
return x
root = self.find(self._parents[x])
self._weights[x] += self._weights[self._parents[x]]
self._parents[x] = root
return root
def size(self, x):
"""
x が属する木のノード数
:param x:
:return:
"""
return self._sizes[self.find(x)]
def weight(self, x):
"""
:param x:
:return:
"""
# 経路圧縮
self.find(x)
return self._weights[x]
def diff(self, x, y):
"""
(y の重み) - (x の重み)
:param x:
:param y:
:return:
"""
if self.find(x) == self.find(y):
return self._weights[y] - self._weights[x]
return float('inf')
N, M = list(map(int, input().split()))
uf = WeightedUnionFind([i + 1 for i in range(N)])
ok = True
for _ in range(M):
l, r, d = list(map(int, input().split()))
if uf.find(l) == uf.find(r) and uf.diff(l, r) != d:
ok = False
break
uf.unite(l, r, d)
if ok:
print('Yes')
else:
print('No')
|
import sys
sys.setrecursionlimit(10000)
INF = float('inf')
class WeightedUnionFind:
def __init__(self, size):
"""
:param collections.Iterable nodes:
"""
self._parents = [i for i in range(size)]
self._ranks = [0 for _ in range(size)]
self._sizes = [1 for _ in range(size)]
# 直近の親からの重み。root なら 0
self._weights = [0 for _ in range(size)]
def unite(self, x, y, w):
"""
x が属する木と y が属する木を併合
:param x:
:param y:
:param w: x と y の重みの差; (重み y) - (重み x)
:return:
"""
rx = self.find(x)
ry = self.find(y)
if rx == ry:
return
# rank が小さい方が下
if self._ranks[rx] > self._ranks[ry]:
# x が root
self._parents[ry] = rx
self._sizes[rx] += self._sizes[ry]
# root 間の重みに変換
self._weights[ry] = w + self._weights[x] - self._weights[y]
else:
# y が root
self._parents[rx] = ry
self._sizes[ry] += self._sizes[rx]
# root 間の重みに変換
self._weights[rx] = -w + self._weights[y] - self._weights[x]
if self._ranks[rx] == self._ranks[ry]:
self._ranks[ry] += 1
def find(self, x):
"""
x が属する木の root
:param x:
:return:
"""
if self._parents[x] == x:
return x
root = self.find(self._parents[x])
self._weights[x] += self._weights[self._parents[x]]
self._parents[x] = root
return root
def size(self, x):
"""
x が属する木のノード数
:param x:
:return:
"""
return self._sizes[self.find(x)]
def weight(self, x):
"""
:param x:
:return:
"""
# 経路圧縮
self.find(x)
return self._weights[x]
def diff(self, x, y):
"""
(y の重み) - (x の重み)
:param x:
:param y:
:return:
"""
if self.find(x) == self.find(y):
return self._weights[y] - self._weights[x]
return float('inf')
N, M = list(map(int, input().split()))
uf = WeightedUnionFind(N + 1)
ok = True
for _ in range(M):
l, r, d = list(map(int, input().split()))
if uf.find(l) == uf.find(r) and uf.diff(l, r) != d:
ok = False
break
uf.unite(l, r, d)
if ok:
print('Yes')
else:
print('No')
|
p03450
|
n, m = list(map(int, input().split()))
G = [[] for _ in range(n)]
indeg = [0] * n
for _ in range(m):
l, r, d = list(map(int, input().split()))
l -= 1
r -= 1
G[r].append((l, d))
indeg[r] += 1
from collections import deque
ng = False
visited = [0] * n
for start, deg in enumerate(indeg):
if deg == 0 or visited[start] == 1:
continue
st = deque([[start, 0]])
visited_cost = [-1] * n
while st:
i, cost = st.pop()
for ni, nd in G[i]:
if visited_cost[ni] == -1:
# まだ記録されていない
visited[ni] = 1
visited_cost[ni] = cost + nd
st.append([ni, cost + nd])
elif visited_cost[ni] == cost + nd:
visited[ni] = 1
continue
else:
# 既に記録されていて、矛盾している場合
# 終了
ng = True
break
if ng:
break
if ng:
break
print(('No' if ng else 'Yes'))
|
n, m = list(map(int, input().split()))
G = [[] for _ in range(n)]
indeg = [0] * n
for _ in range(m):
l, r, d = list(map(int, input().split()))
l -= 1
r -= 1
G[l].append((r, d))
G[r].append((l, -d))
from collections import deque
ng = False
visited = [0] * n
visited_cost = [0] * n
for start in range(n):
if visited[start]:
continue
visited[start] = 1
st = deque([[start, 0]])
while st:
i, cost = st.pop()
for ni, nd in G[i]:
if visited[ni] == 0:
visited[ni] = 1
visited_cost[ni] = cost + nd
st.append([ni, cost + nd])
else:
# 既に記録されていて、矛盾している場合
if visited_cost[ni] != cost + nd:
# 終了
ng = True
break
if ng:
break
if ng:
break
print(('No' if ng else 'Yes'))
|
p03450
|
N,M = list(map(int,input().split()))
LRD = [(lambda x: [int(x[0])-1,int(x[1])-1,int(x[2])])(input().split()) for _ in [0]*M]
connect = [[] for _ in range(N)]
for L,R,D in LRD:
connect[L].append([R,D])
connect[R].append([L,-D])
ans = True
n = [None] * N
q = []
n0 = 0
while ans:
n[n0] = 0
q.append(n0)
for i in q:
for j,d in connect[i]:
if n[j] == None:
n[j] = n[i] + d
q.append(j)
elif n[j]-n[i] != d:
ans = False
break
if not ans:
break
for i in range(n0,N):
if n[i] == None:
n0 = i
break
else:
break
if ans:
print("Yes")
else:
print("No")
|
N,M = list(map(int,input().split()))
LRD = [(lambda x: [int(x[0])-1,int(x[1])-1,int(x[2])])(input().split()) for _ in [0]*M]
connect = [[] for _ in range(N)]
for L,R,D in LRD:
connect[L].append([R,D])
connect[R].append([L,-D])
ans = True
n = [None] * N
n0 = 0
while ans:
q = [n0]
n[n0] = 0
for i in q:
for j,d in connect[i]:
if n[j] == None:
n[j] = n[i] + d
q.append(j)
elif n[j]-n[i] != d:
ans = False
break
if not ans:
break
for i in range(n0,N):
if n[i] == None:
n0 = i
break
else:
break
if ans:
print("Yes")
else:
print("No")
|
p03450
|
N,M = list(map(int,input().split()))
LRD = [list(map(int,input().split())) for _ in [0]*M]
E = [{} for _ in [0]*N]
for L,R,D in LRD:
E[L-1][R-1] = D
E[R-1][L-1] = -D
V = [-1]*N
breakFlg = False
for i in range(N):
if V[i]!=-1:continue
V[0] = 0
q = [i]
while q:
j = q.pop()
v = V[j]
for k,d in list(E[j].items()):
if V[k] == -1:
V[k] = v+d
q.append(k)
ans = True
for l,e in enumerate(E):
for r,d in list(e.items()):
ans = ans and V[r]-V[l]==d
if not ans:break
print(("Yes" if ans else "No"))
|
N,M = list(map(int,input().split()))
LRD = [list(map(int,input().split())) for _ in [0]*M]
E = [{} for _ in [0]*N]
for L,R,D in LRD:
E[L-1][R-1] = D
E[R-1][L-1] = -D
V = [None]*N
breakFlg = False
for i in range(N):
if V[i]!=None:continue
V[i] = 0
q = [i]
while q:
j = q.pop()
v = V[j]
for k,d in list(E[j].items()):
if V[k] == None:
V[k] = v+d
q.append(k)
ans = True
for l,e in enumerate(E):
for r,d in list(e.items()):
ans = ans and V[r]-V[l]==d
if not ans:break
print(("Yes" if ans else "No"))
|
p03450
|
class UnionFind:
def __init__(self, size):
self.parent = list(range(size))
self.height = [0] * size
self.size = [1] * size
self.component = size
def root(self, index):
if self.parent[index] == index: # 根の場合
return index
rootIndex = self.root(self.parent[index]) # 葉の場合親の根を取得
self.parent[index] = rootIndex # 親の付け直し
return rootIndex
def union(self, index1, index2): # 結合
root1 = self.root(index1)
root2 = self.root(index2)
if root1 == root2: # 連結されている場合
return
self.component -= 1 # 連結成分を減らす
if self.height[root1] < self.height[root2]:
self.parent[root1] = root2 # root2に結合
self.size[root2] += self.size[root1]
else:
self.parent[root2] = root1 # root1に結合
self.size[root1] += self.size[root2]
if self.height[root1] == self.height[root2]:
self.height[root1] += 1
return
def isSameRoot(self, index1, index2):
return self.root(index1) == self.root(index2)
def sizeOfSameRoot(self, index):
return self.size[self.root(index)]
def getComponent(self):
return self.component
N, M = list(map(int, input().split()))
INF = 10**18
tree = UnionFind(N)
edges = [[] for _ in range(N)]
degree = [0] * N
for _ in range(M):
fr, to, d = list(map(int, input().split()))
fr -= 1
to -= 1
edges[to].append((fr, d))
degree[fr] += 1
tree.union(fr, to)
D = [INF] * N
for i in range(N):
D[tree.root(i)] = min(D[tree.root(i)], degree[i])
if max([D[i] for i in range(N) if tree.root(i) == i]) != 0:
print('No')
exit()
V = set()
for start in range(N):
if degree[start] > 0:
continue
minDist = [INF] * N
st = [(start, 0)]
W = set()
while st:
now, dist = st.pop()
W.add(now)
if minDist[now] == dist:
continue
if minDist[now] != INF and minDist[now] != dist:
print('No')
exit()
minDist[now] = dist
for to, d in edges[now]:
if minDist[to] == d + dist or to in V:
continue
st.append((to, dist + d))
V |= W
print('Yes')
|
class UnionFind:
def __init__(self, size):
self.parent = list(range(size))
self.height = [0] * size
self.size = [1] * size
self.component = size
def root(self, index):
if self.parent[index] == index: # 根の場合
return index
rootIndex = self.root(self.parent[index]) # 葉の場合親の根を取得
self.parent[index] = rootIndex # 親の付け直し
return rootIndex
def union(self, index1, index2): # 結合
root1 = self.root(index1)
root2 = self.root(index2)
if root1 == root2: # 連結されている場合
return
self.component -= 1 # 連結成分を減らす
if self.height[root1] < self.height[root2]:
self.parent[root1] = root2 # root2に結合
self.size[root2] += self.size[root1]
else:
self.parent[root2] = root1 # root1に結合
self.size[root1] += self.size[root2]
if self.height[root1] == self.height[root2]:
self.height[root1] += 1
return
def isSameRoot(self, index1, index2):
return self.root(index1) == self.root(index2)
def sizeOfSameRoot(self, index):
return self.size[self.root(index)]
def getComponent(self):
return self.component
N, M = list(map(int, input().split()))
INF = 10**18
tree = UnionFind(N)
edges = [[] for _ in range(N)]
for _ in range(M):
fr, to, d = list(map(int, input().split()))
fr -= 1
to -= 1
edges[to].append((fr, d))
edges[fr].append((to, -d))
tree.union(fr, to)
minDist = [INF] * N
for start in range(N):
if tree.root(start) != start:
continue
st = [(start, 0)]
while st:
now, dist = st.pop()
if minDist[now] == dist:
continue
if minDist[now] != INF and minDist[now] != dist:
print('No')
exit()
minDist[now] = dist
for to, d in edges[now]:
if minDist[to] == d + dist:
continue
st.append((to, dist + d))
print('Yes')
|
p03450
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.