input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
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')
|
N, M = list(map(int, input().split()))
edges = [[] for _ in range(N)]
for _ in range(M):
fr, to, dist = list(map(int, input().split()))
fr -= 1
to -= 1
edges[fr].append((to, dist))
edges[to].append((fr, -dist))
INF = 10**18
minDist = [INF] * N
for s in range(N):
if minDist[s] < INF:
continue
st = [s]
minDist[s] = 0
while st:
now = st.pop()
dist = minDist[now]
for to, d in edges[now]:
if minDist[to] == INF:
minDist[to] = dist + d
st.append(to)
continue
if minDist[to] != dist + d:
print('No')
exit()
print('Yes')
|
p03450
|
N, M = list(map(int, input().split()))
edges = [[] for _ in range(N)]
for _ in range(M):
fr, to, dist = list(map(int, input().split()))
fr -= 1
to -= 1
edges[fr].append((to, dist))
edges[to].append((fr, -dist))
INF = 10**18
minDist = [INF] * N
for s in range(N):
if minDist[s] < INF:
continue
st = [s]
minDist[s] = 0
while st:
now = st.pop()
dist = minDist[now]
for to, d in edges[now]:
if minDist[to] == INF:
minDist[to] = dist + d
st.append(to)
continue
if minDist[to] != dist + d:
print('No')
exit()
print('Yes')
|
N, M = list(map(int, input().split()))
edges = [[] for _ in range(N)]
for _ in range(M):
fr, to, dist = list(map(int, input().split()))
fr -= 1
to -= 1
edges[fr].append((to, dist))
edges[to].append((fr, -dist))
def isOk():
visited = [False] * N
INF = 10**18
minDist = [INF] * N
for s in range(N):
if visited[s]:
continue
st = [(s, 0)]
minDist[s] = 0
visited[s] = True
while st:
now, dist = st.pop()
for to, d in edges[now]:
d += dist
if visited[to]:
if minDist[to] != d:
return False
else:
visited[to] = True
minDist[to] = d
st.append((to, d))
return True
print(('Yes' if isOk() else 'No'))
|
p03450
|
#!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list([int(x)-1 for x in stdin.readline().split()])
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#A
def A():
a, b, c = IR(3)
a -= b
print((a % c))
return
#B
def B():
a, b, c, x, ans = II(), II(), II(), II(), 0
for i in range(a + 1):
for j in range(b + 1):
for k in range(c + 1):
if i * 500 + j * 100 + k * 50 == x:
ans += 1
print(ans)
return
#C
def C():
n = II()
a = LI()
dp = [[0] * (n + 1) for i in range(2)]
for i in range(1, n + 1):
dp[0][i] += dp[0][i - 1] + a[i - 1]
a = LI()
for i in range(1, n + 1):
dp[1][i] = max(dp[0][i], dp[1][i - 1]) + a[i - 1]
print((dp[1][-1]))
return
class Value_UnionFind():
def __init__(self,n):
self.par = [i for i in range(n)]
self.differ_weight = [0] * n
self.rank = [0] * n
def root(self,x):
if x == self.par[x]:
return x
r = self.root(self.par[x])
self.differ_weight[x] += self.differ_weight[self.par[x]]
self.par[x] = r
return r
def weight(self, x):
self.root(x)
return self.differ_weight[x]
def unit(self, x, y, w):
w += self.weight(x)
w -= self.weight(y)
x = self.root(x)
y = self.root(y)
if x == y: return False
self.par[y] = x
self.differ_weight[y] = w
return True
def differ(self, x, y):
return self.weight(y) - self.weight(x)
#D
def D():
n, m = LI()
u = Value_UnionFind(n)
for _ in range(m):
l, r, d = LI_()
if not u.unit(l, r, d + 1):
if u.differ(l, r) == d + 1:
continue
else:
print("No")
return
print("Yes")
return
#Solve
if __name__ == '__main__':
D()
|
#!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list([int(x)-1 for x in stdin.readline().split()])
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#A
def A():
a, b, c = IR(3)
a -= b
print((a % c))
return
#B
def B():
a, b, c, x, ans = II(), II(), II(), II(), 0
for i in range(a + 1):
for j in range(b + 1):
for k in range(c + 1):
if i * 500 + j * 100 + k * 50 == x:
ans += 1
print(ans)
return
#C
def C():
n = II()
a = LI()
dp = [[0] * (n + 1) for i in range(2)]
for i in range(1, n + 1):
dp[0][i] += dp[0][i - 1] + a[i - 1]
a = LI()
for i in range(1, n + 1):
dp[1][i] = max(dp[0][i], dp[1][i - 1]) + a[i - 1]
print((dp[1][-1]))
return
class Value_UnionFind():
def __init__(self,n):
self.par = [i for i in range(n)]
self.differ_weight = [0] * n
self.rank = [0] * n
def root(self,x):
if x == self.par[x]:
return x
r = self.root(self.par[x])
self.differ_weight[x] += self.differ_weight[self.par[x]]
self.par[x] = r
return r
def weight(self, x):
self.root(x)
return self.differ_weight[x]
def unit(self, x, y, w):
w += self.weight(x)
w -= self.weight(y)
x = self.root(x)
y = self.root(y)
if x == y: return False
if self.rank[x] < self.rank[y]: x, y, w = y, x, -w
if self.rank[x] == self.rank[y]: self.rank[x] += 1
self.par[y] = x
self.differ_weight[y] = w
return True
def differ(self, x, y):
return self.weight(y) - self.weight(x)
#D
def D():
n, m = LI()
u = Value_UnionFind(n)
for _ in range(m):
l, r, d = LI_()
if not u.unit(l, r, d + 1):
if u.differ(l, r) != d + 1:
print("No")
return
print("Yes")
return
#Solve
if __name__ == '__main__':
D()
|
p03450
|
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
q = [list(map(int, input().split())) for i in range(m)]
g = [[] for i in range(n+1)]
for i in range(m):
a, b, c = q[i]
g[a].append((b, c))
g[b].append((a, -c))
people = [-10**10] * (n+1)
flag = 1
for i in range(1, n+1):
if people[i] != -10**10:
continue
q = [i]
while q:
now = q.pop()
for next, dist in g[now]:
if people[next] == -10**10:
q.append(next)
people[next] = people[now] + dist
else:
if people[next] == people[now] + dist:
continue
else:
flag = 0
break
if flag == 0:
break
if max(people[1:]) - min(people[1:]) > 10**9:
flag = 0
if flag == 1:
print("Yes")
else:
print("No")
|
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
q = [list(map(int, input().split())) for i in range(m)]
g = [[] for i in range(n+1)]
for i in range(m):
a, b, c = q[i]
g[a].append((b, c))
g[b].append((a, -c))
people = [-10**10] * (n+1)
flag = 1
for i in range(1, n+1):
if people[i] != -10**10:
continue
q = [i]
people[i] = 0
while q:
now = q.pop()
for next, dist in g[now]:
if people[next] == -10**10:
q.append(next)
people[next] = people[now] + dist
else:
if people[next] == people[now] + dist:
continue
else:
flag = 0
break
if flag == 0:
break
if max(people[1:]) - min(people[1:]) > 10**9:
flag = 0
if flag == 1:
print("Yes")
else:
print("No")
|
p03450
|
class WeightedUnionFind:
def __init__(self, n):
self.parent = [i for i in range(n + 1)]
self.rank = [0 for _ in range(n + 1)]
self.weight = [0 for _ in range(n + 1)]
def find(self, x):
if self.parent[x] == x:
return x
else:
y = self.find(self.parent[x])
self.weight[x] += self.weight[self.parent[x]]
self.parent[x] = y
return y
def union(self, x, y, w):
rx = self.find(x)
ry = self.find(y)
if rx == ry:
if w != self.diff(x, y):
print("No")
exit()
if self.rank[rx] < self.rank[ry]:
self.parent[rx] = ry
self.weight[rx] = w - self.weight[x] + self.weight[y]
else:
self.parent[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)
def diff(self, x, y):
return self.weight[x] - self.weight[y]
N, M = list(map(int, input().split()))
w_union_find = WeightedUnionFind(N)
for i in range(M):
l, r, d = list(map(int, input().split()))
w_union_find.union(l, r, d)
print("Yes")
|
class WeightedUnionFind:
def __init__(self, n):
self.parent = [i for i in range(n + 1)]
self.rank = [0 for _ in range(n + 1)]
self.weight = [0 for _ in range(n + 1)]
def find(self, x):
if self.parent[x] == x:
return x
else:
y = self.find(self.parent[x])
self.weight[x] += self.weight[self.parent[x]]
self.parent[x] = y
return y
def union(self, x, y, w):
rx = self.find(x)
ry = self.find(y)
if self.rank[rx] < self.rank[ry]:
self.parent[rx] = ry
self.weight[rx] = w - self.weight[x] + self.weight[y]
else:
self.parent[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)
def diff(self, x, y):
return self.weight[x] - self.weight[y]
N, M = list(map(int, input().split()))
items = []
for i in range(M):
items.append(tuple(map(int, input().split())))
wu = WeightedUnionFind(N)
for i in range(M):
l, r, d = items[i]
if wu.same(l, r):
if d == wu.diff(l, r):
continue
else:
print("No")
exit()
else:
wu.union(l, r, d)
print("Yes")
|
p03450
|
import sys
sys.setrecursionlimit(300000)
N, M = list(map(int, input().split()))
nl = [[] for _ in range(N + 1)]
for _ in range(M):
L, R, D = list(map(int, input().split()))
nl[L].append((R, D))
nl[R].append((L, -D))
# print(nl)
seen = [None for _ in range(N + 1)]
def dfs(v, d):
# print("dfs ", v, d)
seen[v] = d
for next_v, D in nl[v]:
next_d = d + D
if seen[next_v] is None:
dfs(next_v, next_d)
else:
if seen[next_v] != next_d:
print('No')
exit(0)
for v in range(1, N + 1): # すべての連結成分に対してDFS
if seen[v] is None:
dfs(v, 0)
print('Yes')
|
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
|
n, m = list(map(int, input().split()))
vertices = {i: [] for i in range(n)}
for _ in range(m):
l, r, d = list(map(int, input().split()))
vertices[l - 1].append((r - 1, d))
vertices[r - 1].append((l - 1, -d))
def answer():
x = [None] * n
while any(i is None for i in x):
i = x.index(None)
x[i] = 0
queue = [i]
while queue:
i0 = queue.pop()
for i1, d in vertices[i0]:
# print(i0, i1, x[i0], x[i1], d)
if x[i1] is None:
x[i1] = x[i0] + d
queue.append(i1)
elif x[i1] != x[i0] + d:
return False
return True
if answer():
print('Yes')
else:
print('No')
|
n, m = list(map(int, input().split()))
vertices = {i: [] for i in range(n)}
for _ in range(m):
l, r, d = list(map(int, input().split()))
vertices[l - 1].append((r - 1, d))
vertices[r - 1].append((l - 1, -d))
def answer():
x = [None] * n
for i in range(n):
if x[i] is not None:
continue
x[i] = 0
queue = [i]
while queue:
i0 = queue.pop()
for i1, d in vertices[i0]:
# print(i0, i1, x[i0], x[i1], d)
if x[i1] is None:
x[i1] = x[i0] + d
queue.append(i1)
elif x[i1] != x[i0] + d:
return False
return True
if answer():
print('Yes')
else:
print('No')
|
p03450
|
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
n,m=list(map(int,input().split()))
E=[[] for _ in range(n)]
for _ in range(m):
u,v,w=list(map(int,input().split()))
u-=1; v-=1
E[v].append((u,w))
# dfsで各連結成分毎に最長経路を計算していく
# 仮に更新されるようなことがあれば矛盾
dist=[INF]*n
visited=[0]*n
def dfs(v)->bool:
d=0
flag=False
visited[v]=1
for nv,w in E[v]:
# ループ検出
if(visited[nv] and dist[nv]==INF):
return False
# nv の最長経路を計算
if(not dfs(nv)):
return False
else:
if(not flag):
d=dist[nv]+w
flag=True
else:
if(d!=dist[nv]+w):
return False
dist[v]=d
return True
print(("Yes" if(all(dfs(v) for v in range(n))) else "No"))
resolve()
|
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
n,m=list(map(int,input().split()))
E=[[] for _ in range(n)]
for _ in range(m):
u,v,w=list(map(int,input().split()))
u-=1; v-=1
E[u].append((v,w))
E[v].append((u,-w))
pos=[INF]*n # position
def dfs(v)->bool:
if(pos[v]!=INF): return True
pos[v]=0
Q=[v]
while(Q):
v=Q.pop()
for nv,w in E[v]:
if(pos[nv]==INF):
pos[nv]=pos[v]+w
Q.append(nv)
else:
if(pos[nv]!=pos[v]+w):
return False
return True
for v in range(n):
if(not dfs(v)):
print("No")
return
print("Yes")
resolve()
|
p03450
|
import queue
n,m = list(map(int,input().split()))
data =[0]
access = [False]*(n+1)
dis = [0]+[" "]*(n)
q = queue.Queue()
for i in range(n):
data.append([])
for i in range(m):
l,r,d = list(map(int,input().split()))
data[l].append((r,d))
data[r].append((l,-d))
for i in range(1,n+1):
data[i].sort(reverse=True)
for i in range(1,n+1):
if data[i]!=[] and not access[i]:
q.put(i)
access[i] = True
dis[i] = 0
while not q.empty():
l = q.get()
for r,d in data[l]:
if access[r]:
if dis[r] ==dis[l]+d:
continue
else:
print("No")
exit(0)
else:
access[r] = True
dis[r] = dis[l]+d
q.put(r)
print("Yes")
|
import queue
n,m = list(map(int,input().split()))
data =[0]
access = [False]*(n+1)
dis = [0]+[" "]*(n)
q = queue.Queue()
for i in range(n):
data.append([])
for i in range(m):
l,r,d = list(map(int,input().split()))
data[l].append((r,d))
data[r].append((l,-d))
for i in range(1,n+1):
data[i].sort(reverse=True)
for i in range(1,n+1):
if data[i]!=[] and not access[i]:
q.put(i)
access[i] = True
dis[i] = 0
while not q.empty():
l = q.get()
while data[l]:
r,d = data[l].pop()
if access[r]:
if dis[r] ==dis[l]+d:
continue
else:
print("No")
exit(0)
else:
access[r] = True
dis[r] = dis[l]+d
q.put(r)
print("Yes")
|
p03450
|
import queue
n,m = list(map(int,input().split()))
data =[0]
access = [False]*(n+1)
dis = [0]+[" "]*(n)
q = queue.Queue()
for i in range(n):
data.append([])
for i in range(m):
l,r,d = list(map(int,input().split()))
data[l].append((r,d))
data[r].append((l,-d))
for i in range(1,n+1):
data[i].sort(reverse=True)
for i in range(1,n+1):
if data[i]!=[] and not access[i]:
q.put(i)
access[i] = True
dis[i] = 0
while not q.empty():
l = q.get()
while data[l]:
r,d = data[l].pop()
if access[r]:
if dis[r] ==dis[l]+d:
continue
else:
print("No")
exit(0)
else:
access[r] = True
dis[r] = dis[l]+d
q.put(r)
print("Yes")
|
import queue
n,m = list(map(int,input().split()))
data =[0]
access = [False]*(n+1)
dis = [0]+[" "]*(n)
q = queue.Queue()
for i in range(n):
data.append([])
for i in range(m):
l,r,d = list(map(int,input().split()))
data[l].append((r,d))
data[r].append((l,-d))
for i in range(1,n+1):
data[i].sort(reverse=True)
for i in range(1,n+1):
if data[i]!=[] and not access[i]:
q.put(i)
access[i] = True
dis[i] = 0
while not q.empty():
l = q.get()
while data[l]:
r,d = data[l].pop()
data[r].remove((l,-d))
if access[r]:
if dis[r] ==dis[l]+d:
continue
else:
print("No")
exit(0)
else:
access[r] = True
dis[r] = dis[l]+d
q.put(r)
print("Yes")
|
p03450
|
n, m = list(map(int, input().split()))
par = list(range(n+1))
dis = [0] * (n+1)
def root(x):
if x == par[x]:
return x
r = root(par[x])
dis[x] += dis[par[x]]
par[x] = r
return r
def cost(x):
# xからxの根までのコスト
if x == par[x]:
return 0
return dis[x] + cost(par[x])
# 確かめ用
def unite(x, y, w):
rootx = root(x)
rooty = root(y)
if rootx != rooty:
if y != rooty:
# 直接yにつなげる
dis[rootx] = w - cost(x)
else:
# 根につなげる
dis[rootx] = w - (dis[x] - dis[y])
# ここで親を更新
par[rootx] = y
else:
if w != cost(x) - cost(y):
print("No")
exit()
for _ in range(m):
l, r, d = list(map(int, input().split()))
# 根が違ってればマージ
# 同じなら入力されたdistanceがこれまでの入力データからなる
# 現在の木の構造から計算した数値とあっているか判断
rootl, rootr = root(l), root(r)
# 確かめ用
a = unite(l, r, d)
if a is not None:
if a == False:
flag = False
"""
ちょっとなにがダメなのかわかんないので確かめる
if rootl != rootr:
# lをrにマージする
if r == rootr:
dis[rootl] = d - cost(l)
else:
dis[rootl] = d - (dis[l] - dis[r]) # (cost(l) - cost(r))
par[rootl] = r
else:
# コストが同じかどうか
if d == cost(l) - cost(r):
continue
else:
print("No")
exit()
"""
print("Yes")
|
n, m = list(map(int, input().split()))
par = list(range(n+1))
dis = [0] * (n+1)
def root(x):
if x == par[x]:
return x
r = root(par[x])
dis[x] += dis[par[x]]
par[x] = r
return r
def cost(x):
# xからxの根までのコスト
if x == par[x]:
return 0
return dis[x] + cost(par[x])
for _ in range(m):
l, r, d = list(map(int, input().split()))
# 根が違ってればマージ
# 同じなら入力されたdistanceがこれまでの入力データからなる
# 現在の木の構造から計算した数値とあっているか判断
# rootl, rootr = root(l), root(r)
# 確かめ用
rootl = root(l)
rootr = root(r)
if rootl != rootr:
if r != rootr:
# 直接yにつなげる
dis[rootl] = d - cost(l)
else:
# 根につなげる
dis[rootl] = d - (dis[l] - dis[r])
# ここで親を更新
par[rootl] = r
else:
if d != cost(l) - cost(r):
print("No")
exit()
"""
ちょっとなにがダメなのかわかんないので確かめる
if rootl != rootr:
# lをrにマージする
if r == rootr:
dis[rootl] = d - cost(l)
else:
dis[rootl] = d - (dis[l] - dis[r]) # (cost(l) - cost(r))
par[rootl] = r
else:
# コストが同じかどうか
if d == cost(l) - cost(r):
continue
else:
print("No")
exit()
"""
print("Yes")
|
p03450
|
n, m = list(map(int, input().split()))
par = list(range(n+1))
dis = [0] * (n+1)
def root(x):
if x == par[x]:
return x
r = root(par[x])
dis[x] += dis[par[x]]
par[x] = r
return r
def cost(x):
# xからxの根までのコスト
if x == par[x]:
return 0
return dis[x] + cost(par[x])
for _ in range(m):
l, r, d = list(map(int, input().split()))
# 根が違ってればマージ
# 同じなら入力されたdistanceがこれまでの入力データからなる
# 現在の木の構造から計算した数値とあっているか判断
# rootl, rootr = root(l), root(r)
# 確かめ用
rootl = root(l)
rootr = root(r)
if rootl != rootr:
if r != rootr:
# 直接yにつなげる
dis[rootl] = d - cost(l)
else:
# 根につなげる
dis[rootl] = d - (dis[l] - dis[r])
# ここで親を更新
par[rootl] = r
else:
if d != cost(l) - cost(r):
print("No")
exit()
"""
ちょっとなにがダメなのかわかんないので確かめる
if rootl != rootr:
# lをrにマージする
if r == rootr:
dis[rootl] = d - cost(l)
else:
dis[rootl] = d - (dis[l] - dis[r]) # (cost(l) - cost(r))
par[rootl] = r
else:
# コストが同じかどうか
if d == cost(l) - cost(r):
continue
else:
print("No")
exit()
"""
print("Yes")
|
n, m = list(map(int, input().split()))
par = list(range(n+1))
dis = [0] * (n+1)
def root(x):
if x == par[x]:
return x
r = root(par[x])
dis[x] += dis[par[x]]
par[x] = r
return r
def cost(x):
# xからxの根までのコスト
if x == par[x]:
return 0
return dis[x] + cost(par[x])
for _ in range(m):
l, r, d = list(map(int, input().split()))
# 根が違ってればマージ
# 同じなら入力されたdistanceがこれまでの入力データからなる
# 現在の木の構造から計算した数値とあっているか判断
# rootl, rootr = root(l), root(r)
# 確かめ用
rootl = root(l)
rootr = root(r)
if rootl != rootr:
if r != rootr:
# 直接yにつなげる
dis[rootl] = d - cost(l)
else:
# 根につなげる
dis[rootl] = d - (cost(l) - cost(r)) # (dis[l] - dis[r])
# ここで親を更新
par[rootl] = r
else:
if d != cost(l) - cost(r):
print("No")
exit()
"""
ちょっとなにがダメなのかわかんないので確かめる
if rootl != rootr:
# lをrにマージする
if r == rootr:
dis[rootl] = d - cost(l)
else:
dis[rootl] = d - (dis[l] - dis[r]) # (cost(l) - cost(r))
par[rootl] = r
else:
# コストが同じかどうか
if d == cost(l) - cost(r):
continue
else:
print("No")
exit()
"""
print("Yes")
|
p03450
|
from collections import defaultdict
g = defaultdict(list)
n, m = list(map(int, input().split()))
if m==0:
print('Yes')
exit()
for i in range(m):
l, r, d = list(map(int, input().split()))
g[l].append((r, d))
g[r].append((l, -1*d))
visited = {}
vv = {k:None for k in list(g.keys())}
def dfs(v):
stack = []
visited[v] = True
stack.append((v,0))
while len(stack)!= 0:
v,w = stack.pop()
vv[v] = w
for c,d in g[v]:
if not visited.get(c, False):
visited[c] = True
stack.append((c,w+d))
f = list(g.keys())[0]
not_visited = list(g.keys())
while True:
dfs(f)
not_visited = list(set(not_visited) - set(visited.keys()))
if not_visited == []: break
else: f = not_visited[0]
for k in list(g.keys()):
v = vv[k]
for c,w in g[k]:
if not v + w == vv[c]:
print('No')
exit()
print('Yes')
|
from collections import defaultdict
g = defaultdict(list)
n, m = list(map(int, input().split()))
if m==0:
print('Yes')
exit()
for i in range(m):
l, r, d = list(map(int, input().split()))
g[l].append((r, d))
g[r].append((l, -1*d))
visited = {}
vv = {k:None for k in list(g.keys())}
def dfs(v):
stack = []
visited[v] = True
stack.append((v,0))
while len(stack)!=0:
v,w = stack.pop()
vv[v] = w
for c,d in g[v]:
if not visited.get(c, False):
visited[c] = True
stack.append((c,w+d))
for f in list(g.keys()):
if not visited.get(f):
dfs(f)
for k in list(g.keys()):
v = vv[k]
for c,w in g[k]:
if not v + w == vv[c]:
print('No')
exit()
print('Yes')
|
p03450
|
n,m = map(int, input().split())
ml = [[-1 for i in range(n)] for j in range(n)]
for i in range(m):
l,r,d = map(int, input().split())
l -= 1
r -= 1
if ml[l][l] == -1 and ml[r][r] == -1:
ml[l][l] = 0
ml[r][r] = d
elif ml[l][l] != -1 and ml[r][r] == -1:
ml[r][r] = d + ml[l][l]
elif ml[l][l] == -1 and ml[r][r] != -1:
ml[l][l] = ml[r][r] - d
else:
if ml[r][r] - ml[l][l] != d:
print('No', flush=True)
import sys
sys.exit()
print('Yes', flush=True)
|
import sys
n,m = list(map(int, input().split()))
# it watches only end of union
# for i in range(m):
# l,r,d = map(int, input().split())
# if ml[l] == -1 and ml[r] == -1:
# ml[l] = 0
# ml[r] = d
# elif ml[l] != -1 and ml[r] == -1:
# ml[r] = d + ml[l]
# if ml[r] > n:
# print('R', i, ml[l], ml[r], flush=True)
# print('No', flush=True)
# sys.exit()
# elif ml[l] == -1 and ml[r] != -1:
# ml[l] = ml[r] - d
# if ml[l] < 1:
# print('L', i, ml[l], ml[r], flush=True)
# print('No', flush=True)
# sys.exit()
# else:
# if ml[r] - ml[l] != d:
# print('B', i, l, ml[l], r, ml[r], d, flush=True)
# print('No', flush=True)
# sys.exit()
# print('Yes', flush=True)
class UnionfindWithWeight():
def __init__(self,n):
self.parents=[-1]*n
self.ranks=[0]*n
self.dist=[0]*n
def find(self,x):
if self.parents[x]<0:
return self.dist[x],x
else:
tmp=self.find(self.parents[x])
self.dist[x]+=tmp[0]
self.parents[x]=tmp[1]
return self.dist[x],self.parents[x]
def union(self,x,y,d):
rx=self.find(x)[-1]
ry=self.find(y)[-1]
diff=d+self.dist[x]-self.dist[y]
if rx==ry:
if diff!=0:
return True
return False
if self.ranks[ry]>self.ranks[rx]:
rx,ry=ry,rx
diff=-diff
self.parents[ry]=rx
self.dist[ry]=diff
if self.ranks[ry]==self.ranks[rx]:
self.ranks[rx]+=1
return False
lrd = []
for i in range(m):
l,r,d = list(map(int, input().split()))
lrd.append([l,r,d])
v=UnionfindWithWeight(n)
for i in lrd:
l, r, d = i
if v.union(l-1,r-1,d):
print('No')
import sys
sys.exit()
print('Yes')
|
p03450
|
import sys
def main():
input = sys.stdin.readline
def inputs():
return (int(x) for x in input().split())
N,M = inputs()
E={i:[] for i in range(1,N+1)}
for i in range(M):
L,R,D = inputs()
E[L].append((R,D))
E[R].append((L,-D))
visited = {i: False for i in list(E.keys())}
dis = [0]*(N+1)
while False in list(visited.values()):
stk = [(list(visited.values()).index(False) + 1, -1, 0)]
flag = True
while stk:
v, p, d = stk.pop()
#print(v,p)
if visited[v]:
if dis[v]!=dis[p]+d:
print("No")
exit()
continue
visited[v] = True
dis[v]=dis[p]+d
for u,d in E[v]:
if u != p:
stk.append((u,v,d))
print("Yes")
main()
|
import sys
def main():
input = sys.stdin.readline
def inputs():
return (int(x) for x in input().split())
N,M = inputs()
E={i:[] for i in range(1,N+1)}
for i in range(M):
L,R,D = inputs()
E[L].append((R,D))
E[R].append((L,-D))
visited = {i: False for i in range(1,N+1)}
dis = [0]*(N+1)
for i in range(1,N+1):
if not visited[i]:
stk = [( i, -1, 0)]
while stk:
v, p, d = stk.pop()
#print(v,p)
if visited[v]:
if dis[v]!=dis[p]+d:
print("No")
exit()
continue
visited[v] = True
dis[v]=dis[p]+d
for u,d in E[v]:
if u != p:
stk.append((u,v,d))
print("Yes")
main()
|
p03450
|
from collections import defaultdict, deque
import sys
readline = sys.stdin.buffer.readline
N, M = list(map(int, readline().split()))
dic = defaultdict(list)
par = [i for i in range(N)]
rank = [0]*N
def find(x):
if par[x]==x:
return x
else:
par[x] = find(par[x])
return par[x]
def unit(x, y):
x = find(x)
y = find(y)
if x==y:
return
elif rank[x]<rank[y]:
par[x] = y
return
elif rank[y]<rank[x]:
par[y] = x
else:
par[y] = x
rank[x] += 1
for i in range(M):
l, r, d = list(map(int, readline().split()))
dic[l-1] += [(r-1,d)]
dic[r-1] += [(l-1,-d)]
unit(l-1, r-1)
dist = [-1]*N
m = []
for x in range(N):
y = find(x)
m += [(y,0)]
dist[y] = 0
m = set(m)
stuck = deque(m)
while stuck:
e, a = stuck.popleft()
flag = False
for c in dic[e]:
p, d = c
x = d + dist[e]
if dist[p]==-1:
dist[p] = x
stuck += [(p, x)]
elif dist[p]!=x:
print('No')
flag = True
break
if flag:
break
else:
print('Yes')
|
from collections import defaultdict, deque
N, M = list(map(int, input().split()))
used = [True]*N
dic = defaultdict(list)
for i in range(M):
l, r, d = list(map(int,input().split()))
l -= 1
r -= 1
used[r] = False
dic[l] += [(r,d)]
dist = [-1]*N
q = deque([])
for i in range(N):
if used[i]:
q += [i]
dist[i] = 0
ans = True
while q:
e = q.popleft()
flag = False
for p, d in dic[e]:
if dist[p]==-1:
dist[p] = d+dist[e]
q += [p]
elif dist[p]!=dist[e]+d:
ans = False
flag = True
break
if flag:
break
if ans:
if -1 not in dist:
print('Yes')
else:
print('No')
else:
print('No')
|
p03450
|
#!/usr/bin/env python3
import sys
# import time
# import math
# import numpy as np
# import scipy.sparse.csgraph as cs # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall
# import random # random, uniform, randint, randrange, shuffle, sample
# import string # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits
# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict # subclass of dict. defaultdict(facroty)
# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from datetime import date, datetime # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj
# from datetime.datetime import strptime # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj
# from datetime import timedelta # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.
# from copy import copy, deepcopy # use deepcopy to copy multi-dimentional matrix without reference
# from functools import reduce # reduce(f, iter[, init])
# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate # accumulate(iter[, f])
from operator import itemgetter # itemgetter(1), itemgetter('key')
# from fractions import gcd # for Python 3.4 (previous contest @AtCoder)
def main():
mod = 1000000007 # 10^9+7
inf = float('inf') # sys.float_info.max = 1.79...e+308
# inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19
sys.setrecursionlimit(10**6) # 1000 -> 1000000
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(input())
def mi(): return map(int, input().split())
def mi_0(): return map(lambda x: int(x)-1, input().split())
def lmi(): return list(map(int, input().split()))
def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
def li(): return list(input())
class UnionFindTree:
def __init__(self, num_of_elm):
'''
0 ... num_of_elem - 1 まで数字で表される (0-index) グループを管理する union find tree を作成する (O(n))
'''
self.n = num_of_elm
self.table = [i for i in range(self.n)] # table[ind] は ind の親の index を表す。ind == table[ind] の時そのグループの root である。
self.rank = [0] * self.n # root となる ind について rank[ind] はその木の深さを表す。それ以外の ind については意味を持たない。
self.group_size = [1] * self.n # root となる ind について group_size[ind] はそのグループに属するメンバの個数を表す。それ以外の ind については意味を持たない。
def _find_set(self, x):
'''
x の属するグループ番号を O(α(n)) で求める
'''
parent = self.table[x]
if x == parent:
return x
else:
root = self._find_set(parent)
# 経路圧縮
self.table[x] = root
return root
def is_same(self, x, y):
'''
x と y が同じグループに属するか O(α(n)) で判定する
'''
return self._find_set(x) == self._find_set(y)
def union(self, x, y):
'''
x と y の属するグループを O(α(n)) で統合する
'''
shallow_root = self._find_set(x)
deep_root = self._find_set(y)
if self.rank[shallow_root] > self.rank[deep_root]:
shallow_root, deep_root = deep_root, shallow_root
# そもそも同一グループだった時
if shallow_root == deep_root:
return False
# グループが異なるので union
else:
self.table[shallow_root] = deep_root
self.group_size[deep_root] += self.group_size[shallow_root]
# 深さが等しかったときはつけ加えられた側の rank をインクリメントする
if self.rank[shallow_root] == self.rank[deep_root]:
self.rank[deep_root] += 1
return True
def akin_num(self, x):
'''
x の属するグループのサイズを O(1) で計算する
'''
x_root = self._find_set(x)
return self.group_size[x_root]
def print_group_id(self):
print([self._find_set(x) for x in self.table])
def dfs_and_check_no_contradict(current, info, point_dict, visited):
visited[current] = True
for v, dist in info[current]:
if v in point_dict and point_dict[current] + dist != point_dict[v]:
return False
if not visited[v]:
point_dict[v] = point_dict[current] + dist
result = dfs_and_check_no_contradict(v, info, point_dict, visited)
if not result:
return False
return True
def no_contradict_p(info):
uf = UnionFindTree(n)
for l in range(n):
for r, _ in info[l]:
uf.union(l, r)
for ind, g in enumerate(uf.table):
if ind == g:
point_dict = {g: 0}
visited = [False] * n
if not dfs_and_check_no_contradict(g, info, point_dict, visited):
return False
# # 距離関係の矛盾は今のところなかった。あとは座標のレンジがおさまるかチェック
# for g, d in point_dict.items():
# if max(d.values()) - min(d.values()) > 10**9: # どうスライド移動しても入らない
# return False
return True
n, m = mi()
info = [[] for _ in range(n)]
for _ in range(m):
l, r, dist = mi_0()
dist += 1
info[l].append((r, dist))
info[r].append((l, -dist))
print('Yes') if no_contradict_p(info) else print('No')
if __name__ == "__main__":
main()
|
#!/usr/bin/env python3
import sys
# import time
# import math
# import numpy as np
# import scipy.sparse.csgraph as cs # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall
# import random # random, uniform, randint, randrange, shuffle, sample
# import string # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits
# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict # subclass of dict. defaultdict(facroty)
# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from datetime import date, datetime # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj
# from datetime.datetime import strptime # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj
# from datetime import timedelta # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.
# from copy import copy, deepcopy # use deepcopy to copy multi-dimentional matrix without reference
# from functools import reduce # reduce(f, iter[, init])
# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate # accumulate(iter[, f])
from operator import itemgetter # itemgetter(1), itemgetter('key')
# from fractions import gcd # for Python 3.4 (previous contest @AtCoder)
def main():
mod = 1000000007 # 10^9+7
inf = float('inf') # sys.float_info.max = 1.79...e+308
# inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19
sys.setrecursionlimit(10**6) # 1000 -> 1000000
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(input())
def mi(): return map(int, input().split())
def mi_0(): return map(lambda x: int(x)-1, input().split())
def lmi(): return list(map(int, input().split()))
def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
def li(): return list(input())
class UnionFindTree:
def __init__(self, num_of_elm):
'''
0 ... num_of_elem - 1 まで数字で表される (0-index) グループを管理する union find tree を作成する (O(n))
'''
self.n = num_of_elm
self.table = [i for i in range(self.n)] # table[ind] は ind の親の index を表す。ind == table[ind] の時そのグループの root である。
self.rank = [0] * self.n # root となる ind について rank[ind] はその木の深さを表す。それ以外の ind については意味を持たない。
self.group_size = [1] * self.n # root となる ind について group_size[ind] はそのグループに属するメンバの個数を表す。それ以外の ind については意味を持たない。
def _find_set(self, x):
'''
x の属するグループ番号を O(α(n)) で求める
'''
parent = self.table[x]
if x == parent:
return x
else:
root = self._find_set(parent)
# 経路圧縮
self.table[x] = root
return root
def is_same(self, x, y):
'''
x と y が同じグループに属するか O(α(n)) で判定する
'''
return self._find_set(x) == self._find_set(y)
def union(self, x, y):
'''
x と y の属するグループを O(α(n)) で統合する
'''
shallow_root = self._find_set(x)
deep_root = self._find_set(y)
if self.rank[shallow_root] > self.rank[deep_root]:
shallow_root, deep_root = deep_root, shallow_root
# そもそも同一グループだった時
if shallow_root == deep_root:
return False
# グループが異なるので union
else:
self.table[shallow_root] = deep_root
self.group_size[deep_root] += self.group_size[shallow_root]
# 深さが等しかったときはつけ加えられた側の rank をインクリメントする
if self.rank[shallow_root] == self.rank[deep_root]:
self.rank[deep_root] += 1
return True
def akin_num(self, x):
'''
x の属するグループのサイズを O(1) で計算する
'''
x_root = self._find_set(x)
return self.group_size[x_root]
def print_group_id(self):
print([self._find_set(x) for x in self.table])
def dfs_and_check_no_contradict(start, info, dist_list, visited):
stack = [start]
while stack:
u = stack[-1]
for v, dist in info[u]:
if dist_list[v] is None:
dist_list[v] = dist_list[u] + dist
elif dist_list[v] != dist_list[u] + dist:
return False
for v, dist in info[u]:
if not visited[v]:
visited[v] = True
stack.append(v)
break
else:
stack.pop()
return True
def no_contradict_p(info):
uf = UnionFindTree(n)
for l in range(n):
for r, _ in info[l]:
uf.union(l, r)
for ind, g in enumerate(uf.table):
if ind == g:
dist_list = [None] * n
dist_list[g] = 0
visited = [False] * n
visited[g] = True
if not dfs_and_check_no_contradict(g, info, dist_list, visited):
return False
# # 距離関係の矛盾は今のところなかった。あとは座標のレンジがおさまるかチェック
# for g, d in point_dict.items():
# if max(d.values()) - min(d.values()) > 10**9: # どうスライド移動しても入らない
# return False
return True
n, m = mi()
info = [[] for _ in range(n)]
for _ in range(m):
l, r, dist = mi_0()
dist += 1
info[l].append((r, dist))
info[r].append((l, -dist))
print('Yes') if no_contradict_p(info) else print('No')
if __name__ == "__main__":
main()
|
p03450
|
#!/usr/bin/env python3
import sys
# import time
# import math
# import numpy as np
# import scipy.sparse.csgraph as cs # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall
# import random # random, uniform, randint, randrange, shuffle, sample
# import string # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits
# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict # subclass of dict. defaultdict(facroty)
# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from datetime import date, datetime # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj
# from datetime.datetime import strptime # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj
# from datetime import timedelta # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.
# from copy import copy, deepcopy # use deepcopy to copy multi-dimentional matrix without reference
# from functools import reduce # reduce(f, iter[, init])
# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate # accumulate(iter[, f])
from operator import itemgetter # itemgetter(1), itemgetter('key')
# from fractions import gcd # for Python 3.4 (previous contest @AtCoder)
def main():
mod = 1000000007 # 10^9+7
inf = float('inf') # sys.float_info.max = 1.79...e+308
# inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19
sys.setrecursionlimit(10**6) # 1000 -> 1000000
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(input())
def mi(): return map(int, input().split())
def mi_0(): return map(lambda x: int(x)-1, input().split())
def lmi(): return list(map(int, input().split()))
def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
def li(): return list(input())
class UnionFindTree:
def __init__(self, num_of_elm):
'''
0 ... num_of_elem - 1 まで数字で表される (0-index) グループを管理する union find tree を作成する (O(n))
'''
self.n = num_of_elm
self.table = [i for i in range(self.n)] # table[ind] は ind の親の index を表す。ind == table[ind] の時そのグループの root である。
self.rank = [0] * self.n # root となる ind について rank[ind] はその木の深さを表す。それ以外の ind については意味を持たない。
self.group_size = [1] * self.n # root となる ind について group_size[ind] はそのグループに属するメンバの個数を表す。それ以外の ind については意味を持たない。
def _find_set(self, x):
'''
x の属するグループ番号を O(α(n)) で求める
'''
parent = self.table[x]
if x == parent:
return x
else:
root = self._find_set(parent)
# 経路圧縮
self.table[x] = root
return root
def is_same(self, x, y):
'''
x と y が同じグループに属するか O(α(n)) で判定する
'''
return self._find_set(x) == self._find_set(y)
def union(self, x, y):
'''
x と y の属するグループを O(α(n)) で統合する
'''
shallow_root = self._find_set(x)
deep_root = self._find_set(y)
if self.rank[shallow_root] > self.rank[deep_root]:
shallow_root, deep_root = deep_root, shallow_root
# そもそも同一グループだった時
if shallow_root == deep_root:
return False
# グループが異なるので union
else:
self.table[shallow_root] = deep_root
self.group_size[deep_root] += self.group_size[shallow_root]
# 深さが等しかったときはつけ加えられた側の rank をインクリメントする
if self.rank[shallow_root] == self.rank[deep_root]:
self.rank[deep_root] += 1
return True
def akin_num(self, x):
'''
x の属するグループのサイズを O(1) で計算する
'''
x_root = self._find_set(x)
return self.group_size[x_root]
def print_group_id(self):
print([self._find_set(x) for x in self.table])
def bfs_and_check_no_contradict(start, info):
visited = [False] * n
dist_list = [None] * n
dist_list[start] = 0
q = deque([start])
while q:
u = q.popleft()
if not visited[u]:
visited[u] = True
for v, dist in info[u]:
if dist_list[v] is None:
dist_list[v] = dist_list[u] + dist
elif dist_list[v] != dist_list[u] + dist:
return False
for v, dist in info[u]:
if not visited[v]:
q.append(v)
return True
def no_contradict_p(info):
uf = UnionFindTree(n)
# group_num = n
for l in range(n):
for r, _ in info[l]:
uf.union(l, r)
# if uf.union(l, r):
# group_num -= 1
# print(group_num)
for ind, g in enumerate(uf.table):
# print(ind)
if ind == g:
if not bfs_and_check_no_contradict(g, info):
return False
# # 距離関係の矛盾は今のところなかった。あとは座標のレンジがおさまるかチェック
# for g, d in point_dict.items():
# if max(d.values()) - min(d.values()) > 10**9: # どうスライド移動しても入らない
# return False
return True
n, m = mi()
info = [[] for _ in range(n)]
for _ in range(m):
l, r, dist = mi_0()
dist += 1
info[l].append((r, dist))
info[r].append((l, -dist))
print('Yes') if no_contradict_p(info) else print('No')
if __name__ == "__main__":
main()
|
#!/usr/bin/env python3
import sys
# import time
# import math
# import numpy as np
# import scipy.sparse.csgraph as cs # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall
# import random # random, uniform, randint, randrange, shuffle, sample
# import string # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits
# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict # subclass of dict. defaultdict(facroty)
# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from datetime import date, datetime # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj
# from datetime.datetime import strptime # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj
# from datetime import timedelta # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.
# from copy import copy, deepcopy # use deepcopy to copy multi-dimentional matrix without reference
# from functools import reduce # reduce(f, iter[, init])
# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate # accumulate(iter[, f])
from operator import itemgetter # itemgetter(1), itemgetter('key')
# from fractions import gcd # for Python 3.4 (previous contest @AtCoder)
def main():
mod = 1000000007 # 10^9+7
inf = float('inf') # sys.float_info.max = 1.79...e+308
# inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19
sys.setrecursionlimit(10**6) # 1000 -> 1000000
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(input())
def mi(): return map(int, input().split())
def mi_0(): return map(lambda x: int(x)-1, input().split())
def lmi(): return list(map(int, input().split()))
def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
def li(): return list(input())
def no_contradict_p(info):
visited = [False] * n
dist_list = [None] * n
def bfs_and_check_no_contradict(start):
dist_list[start] = 0
q = deque([start])
while q:
u = q.popleft()
if not visited[u]:
visited[u] = True
for v, dist in info[u]:
if dist_list[v] is None:
dist_list[v] = dist_list[u] + dist
elif dist_list[v] != dist_list[u] + dist:
return False
for v, dist in info[u]:
if not visited[v]:
q.append(v)
return True
for i in range(n):
if not visited[i]:
if not bfs_and_check_no_contradict(i):
return False
return True
n, m = mi()
info = [[] for _ in range(n)]
for _ in range(m):
l, r, dist = mi_0()
dist += 1
info[l].append((r, dist))
info[r].append((l, -dist))
print('Yes') if no_contradict_p(info) else print('No')
if __name__ == "__main__":
main()
|
p03450
|
def solve(n, query):
for l, r, d in query:
if is_same(l, r):
if d != diff(l, r):
return 'No'
else:
unite(l, r, d)
return 'Yes'
def find(x):
if par[x] < 0:
return x
else:
px = find(par[x])
diff_weight[x] += diff_weight[par[x]]
par[x] = px
return px
def weight(x):
find(x)
return diff_weight[x]
def unite(x, y, w):
w += diff_weight[x]-diff_weight[y]
x = find(x)
y = find(y)
if x == y:
return False
else:
if par[x] > par[y]:
x, y = y, x
w = -w
par[x] += par[y]
par[y] = x
diff_weight[y] = w
return True
def is_same(x, y):
return find(x) == find(y)
def diff(x, y):
return weight(y)-weight(x)
if __name__ == '__main__':
n, m = list(map(int, input().split()))
par = [-1]*(n+1)
diff_weight = [0]*(n+1)
query = []
for _ in range(m):
l, r, d = list(map(int, input().split()))
query.append((l, r, d))
print((solve(n, query)))
|
def solve(n, query):
for l, r, d in query:
if is_same(l, r):
if d != diff(l, r):
return 'No'
else:
unite(l, r, d)
return 'Yes'
def unite(x, y, w):
w += diff_weight[x]-diff_weight[y]
rt_x = find(x)
rt_y = find(y)
if rt_x == rt_y:
return
if rank[rt_x] >= rank[rt_y]:
par[rt_y] = rt_x
diff_weight[rt_y] = w
if rank[rt_x] == rank[rt_y]:
rank[rt_x] += 1
else:
par[rt_x] = rt_y
diff_weight[rt_x] = -w
def find(x):
if par[x] < 0:
return x
else:
px = find(par[x])
diff_weight[x] += diff_weight[par[x]]
par[x] = px
return px
def weight(x):
find(x)
return diff_weight[x]
def is_same(x, y):
return find(x) == find(y)
def diff(x, y):
return weight(y)-weight(x)
if __name__ == '__main__':
n, m = list(map(int, input().split()))
par, rank = [-1]*(n+1), [0]*(n+1)
diff_weight = [0]*(n+1)
query = []
for _ in range(m):
l, r, d = list(map(int, input().split()))
query.append((l, r, d))
print((solve(n, query)))
|
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])
X = [None] * N
def bfs(u):
que = deque([(u, 0)])
X[u] = 0
while que:
u, x = que.popleft()
for nu, add in graph[u]:
nx = x + add
if X[nu] == nx:
continue
if X[nu] is not None and X[nu] != nx:
print('No')
exit()
X[nu] = nx
que.append((nu, nx))
for i in range(N):
if X[i] is None:
bfs(i)
print('Yes')
|
from collections import deque
n, m = list(map(int, input().split()))
tree = [[] for _ in range(n)]
for _ in range(m):
L, R, D = list(map(int, input().split()))
tree[L - 1].append((R - 1, D))
tree[R - 1].append((L - 1, -D))
visited = [None for _ in range(n)]
def bfs(u):
q = deque([[u, 0]])
visited[u] = 0
while q:
u, dist = q.popleft()
for next_u, d in tree[u]:
next_x = dist + d
if visited[next_u] is None:
visited[next_u] = next_x
q.append([next_u, next_x])
elif visited[next_u] == next_x:
continue
else:
print("No")
exit()
for i in range(n):
if visited[i] is None:
bfs(i)
else:
print('Yes')
|
p03450
|
import sys
input=sys.stdin.readline
from collections import deque
N,M=list(map(int,input().split()))
if M==0:
print("Yes")
quit()
G=[[] for i in range(N)]
for i in range(M):
l,r,d=list(map(int,input().split()))
G[l-1].append((l-1,r-1,d))
G[r-1].append((r-1,l-1,-d))
x=["a"]*N
y=[1]*N
z=[[0]*N for i in range(N)]
stack=deque()
for i in range(N):
if y[i]:
stack.extend(G[i])
y[i]=0
if len(stack)==0:
continue
while(stack):
l,r,d=stack.popleft()
if x[l]=="a":
x[l]=0
if x[r]=="a":
x[r]=x[l]+d
continue
if x[r]!=x[l]+d:
print("No")
quit()
y[r]=0
z[l][r]=1
for l1,r1,d1 in G[r]:
if z[l1][r1]:
continue
stack.append((l1,r1,d1))
if max(x)-min(x)>10**9:
print("No")
else:
print("Yes")
|
from collections import deque
N,M=list(map(int,input().split()))
if M==0:
print("Yes")
quit()
G=[[] for i in range(N)]
for i in range(M):
l,r,d=list(map(int,input().split()))
G[l-1].append((l-1,r-1,d))
G[r-1].append((r-1,l-1,-d))
x=["a"]*N
y=[1]*N
z=[[0]*N for i in range(N)]
stack=deque()
for i in range(N):
if y[i]:
stack.extend(G[i])
y[i]=0
if len(stack)==0:
continue
while(stack):
l,r,d=stack.popleft()
if x[l]=="a":
x[l]=0
if x[r]=="a":
x[r]=x[l]+d
continue
if x[r]!=x[l]+d:
print("No")
quit()
y[r]=0
z[l][r]=1
z[r][l]=1
for l1,r1,d1 in G[r]:
if z[l1][r1] or z[r1][l1]:
continue
stack.append((l1,r1,d1))
if max(x)-min(x)>10**9:
print("No")
else:
print("Yes")
|
p03450
|
from collections import deque
N,M=list(map(int,input().split()))
if M==0:
print("Yes")
quit()
G=[[] for i in range(N)]
for i in range(M):
l,r,d=list(map(int,input().split()))
G[l-1].append((l-1,r-1,d))
G[r-1].append((r-1,l-1,-d))
x=["a"]*N
y=[1]*N
z=[[0]*N for i in range(N)]
stack=deque()
for i in range(N):
if y[i]:
stack.extend(G[i])
y[i]=0
if len(stack)==0:
continue
while(stack):
l,r,d=stack.popleft()
if x[l]=="a":
x[l]=0
if x[r]=="a":
x[r]=x[l]+d
continue
if x[r]!=x[l]+d:
print("No")
quit()
y[r]=0
z[l][r]=1
z[r][l]=1
for l1,r1,d1 in G[r]:
if z[l1][r1] or z[r1][l1]:
continue
stack.append((l1,r1,d1))
if max(x)-min(x)>10**9:
print("No")
else:
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が属する集合の個数
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')
|
p03450
|
from sys import stdin
from collections import deque
if __name__ == "__main__":
_in = [_.rstrip() for _ in stdin.readlines()]
N, M = list(map(int,_in[0].split(' '))) # type:list(int)
if M == 0:
TF = 'Yes'
else:
L_R_D_arr = deque([])
for i in range(M):
_ = list(map(int,_in[i+1].split(' '))) # type:list(int)
L_R_D_arr.append(_)
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
iter_ = [float('inf')]*(N+1)
iter_[L_R_D_arr[0][0]] = 0
TF = 'No'
rot_cnt = 0
while len(L_R_D_arr)>0:
if rot_cnt > len(L_R_D_arr):
iter_ = [float('inf')]*(N+1)
iter_[L_R_D_arr[0][0]] = 0
else:
L, R, D = L_R_D_arr[0]
if iter_[L] == float('inf'):
if iter_[R] == float('inf'):
L_R_D_arr.rotate(-1)
rot_cnt += 1
else:
iter_[L] = iter_[R]-D
L_R_D_arr.popleft()
rot_cnt = 0
else:
rot_cnt = 0
if iter_[R] == float('inf'):
iter_[R] = iter_[L]+D
L_R_D_arr.popleft()
elif iter_[R] == iter_[L]+D:
L_R_D_arr.popleft()
else:
break
else:
TF = 'Yes'
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
print(TF)
|
from sys import stdin
def main():
from collections import deque
_in = [_.rstrip() for _ in stdin.readlines()]
N, M = list(map(int,_in[0].split(' '))) # type:list(int)
if M == 0:
TF = 'Yes'
else:
L_R_D_arr = deque([])
for i in range(M):
_ = list(map(int,_in[i+1].split(' '))) # type:list(int)
L_R_D_arr.append(_)
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
iter_ = [float('inf')]*(N+1)
iter_[L_R_D_arr[0][0]] = 0
TF = 'No'
rot_cnt = 0
while len(L_R_D_arr)>0:
if rot_cnt > len(L_R_D_arr):
iter_ = [float('inf')]*(N+1)
iter_[L_R_D_arr[0][0]] = 0
else:
L, R, D = L_R_D_arr[0]
if iter_[L] == float('inf'):
if iter_[R] == float('inf'):
L_R_D_arr.rotate(-1)
rot_cnt += 1
else:
iter_[L] = iter_[R]-D
L_R_D_arr.popleft()
rot_cnt = 0
else:
rot_cnt = 0
if iter_[R] == float('inf'):
iter_[R] = iter_[L]+D
L_R_D_arr.popleft()
elif iter_[R] == iter_[L]+D:
L_R_D_arr.popleft()
else:
break
else:
TF = 'Yes'
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
print(TF)
# 重み付きUnion-Find木
class Weighted_Union_Find():
def __init__(self, N=1, SUM_UNITY=0):
self.par = [i for i in range(N)] # 親ノード
self.rank = [0] * N # ランク
self.diff_weight = [SUM_UNITY] * N
# 経路圧縮
def root(self, x):
if self.par[x] == x:
return x
else:
r = self.root(self.par[x])
self.diff_weight[x] += self.diff_weight[self.par[x]]
self.par[x] = r
return r
# 経路圧縮＋重みを返す
def weight(self, x):
self.root(x)
return self.diff_weight[x]
# xとyが同じグループに属するか判定
def issame(self, x, y):
return self.root(x) == self.root(y)
# xとyの属するグループを1つにまとめる
def merge(self, x, y, w):
w = w + self.weight(x) - self.weight(y)
x = self.root(x)
y = self.root(y)
if x == y:
return False
else:
if self.rank[x] < self.rank[y]:
x, y = y, x
w = -w
elif self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
self.diff_weight[y] = w
return True
# xとyが同じグループにいるとき、xとyの重みの差を返す
def diff(self,x,y):
return self.weight(y) - self.weight(x)
if __name__ == "__main__":
_in = [_.rstrip() for _ in stdin.readlines()]
N, M = list(map(int,_in[0].split(' '))) # type:list(int)
if M == 0:
TF = 'Yes'
else:
L_R_D_arr = []
for i in range(M):
_ = list(map(int,_in[i+1].split(' '))) # type:list(int)
L_R_D_arr.append(_)
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
TF = 'No'
wuf = Weighted_Union_Find(N)
for L,R,D in L_R_D_arr:
L -= 1
R -= 1
if wuf.issame(L,R):
diff = wuf.diff(L,R)
if diff != D:
break
else:
wuf.merge(L,R,D)
else:
TF = 'Yes'
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
print(TF)
|
p03450
|
from collections import deque
inf = 10 ** 10
N,M = list(map(int,input().split()))
graph = [[] for i in range(N)]
dis = [[inf]*N for i in range(N)]
for i in range(M):
L,R,D = list(map(int,input().split()))
L -= 1
R -= 1
graph[L].append(R)
graph[R].append(L)
dis[L][R] = D
dis[R][L] = (-1)*D
data = [inf]*N
det = 0
for i in range(N):
if data[i] != inf:
continue
data[i] = 0
stack = deque()
stack.append(i)
while stack:
x = stack.pop()
for y in graph[x]:
if data[y] == inf:
data[y] = data[x] + dis[x][y]
stack.append(y)
else:
if data[y] - data[x] != dis[x][y]:
det = -1
break
if det == -1:
break
if det == 0:
print("Yes")
else:
print("No")
|
from collections import deque
inf = 10 ** 10
N,M = list(map(int,input().split()))
graph = [[] for i in range(N)]
dis = [[inf]*N for i in range(N)]
for i in range(M):
L,R,D = list(map(int,input().split()))
L -= 1
R -= 1
graph[L].append(R)
graph[R].append(L)
dis[L][R] = D
dis[R][L] = (-1)*D
data = [inf]*N
det = 0
for i in range(N):
if data[i] != inf:
continue
data[i] = 0
stack = deque()
stack.append(i)
while stack:
x = stack.popleft()
for y in graph[x]:
if data[y] == inf:
data[y] = data[x] + dis[x][y]
stack.append(y)
else:
if data[y] - data[x] != dis[x][y]:
det = -1
break
if det == -1:
break
if det == 0:
print("Yes")
else:
print("No")
|
p03450
|
from collections import deque
inf = 10 ** 10
N,M = list(map(int,input().split()))
graph = [[] for i in range(N)]
dis = [[inf]*N for i in range(N)]
for i in range(M):
L,R,D = list(map(int,input().split()))
L -= 1
R -= 1
graph[L].append(R)
graph[R].append(L)
dis[L][R] = D
dis[R][L] = (-1)*D
data = [inf]*N
det = 0
for i in range(N):
if data[i] != inf:
continue
data[i] = 0
stack = deque()
stack.append(i)
while stack:
x = stack.popleft()
for y in graph[x]:
if data[y] == inf:
data[y] = data[x] + dis[x][y]
stack.append(y)
else:
if data[y] - data[x] != dis[x][y]:
det = -1
break
if det == -1:
break
if det == 0:
print("Yes")
else:
print("No")
|
from collections import deque
N,M = list(map(int,input().split()))
graph = [[] for i in range(N)]
dis = [["n/a"]*N for i in range(N)]
for i in range(M):
L,R,D = list(map(int,input().split()))
L -= 1
R -= 1
graph[L].append(R)
graph[R].append(L)
dis[L][R] = D
dis[R][L] = (-1)*D
data = ["n/a"]*N
det = 0
for i in range(N):
if data[i] != "n/a":
continue
data[i] = 0
stack = deque()
stack.append(i)
while stack:
x = stack.popleft()
for y in graph[x]:
if data[y] == "n/a":
data[y] = data[x] + dis[x][y]
stack.append(y)
else:
if data[y] - data[x] != dis[x][y]:
det = -1
break
if det == -1:
break
if det == 0:
print("Yes")
else:
print("No")
|
p03450
|
from collections import deque
import sys
input = sys.stdin.readline
N,M = list(map(int,input().split()))
graph = [[] for i in range(N)]
dis = [[None]*N for i in range(N)]
for i in range(M):
L,R,D = list(map(int,input().split()))
L -= 1
R -= 1
graph[L].append(R)
graph[R].append(L)
dis[L][R] = D
dis[R][L] = (-1)*D
data = [None]*N
for i in range(N):
if data[i] != None:
continue
data[i] = 0
stack = deque()
stack.append(i)
while stack:
x = stack.popleft()
for y in graph[x]:
if data[y] == None:
data[y] = data[x] + dis[x][y]
stack.append(y)
else:
if data[y] - data[x] != dis[x][y]:
print("No")
sys.exit()
print("Yes")
|
from collections import deque
import sys
input = sys.stdin.readline
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()))
L -= 1
R -= 1
graph[L].append([R,D])
graph[R].append([L,-D])
data = [None]*N
for i in range(N):
if data[i] != None:
continue
data[i] = 0
stack = deque()
stack.append(i)
while stack:
x = stack.popleft()
for y in graph[x]:
if data[y[0]] == None:
data[y[0]] = data[x] + y[1]
stack.append(y[0])
else:
if data[y[0]] - data[x] != y[1]:
print("No")
sys.exit()
print("Yes")
|
p03450
|
# -*- coding: utf-8 -*-
### 幅優先探索により矛盾を探す
import sys
from collections import deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N,M = list(map(int,readline().split()))
graph = [[] for _ in range(N)]
for _ in range(M):
L,R,D = list(map(int,readline().split()))
graph[L-1].append((R-1,D))
graph[R-1].append((L-1,-D))
dist = [0]*N
done = [0]*N
def bfs(i):
q = deque([i])
while q:
x = q.popleft()
for y,d in graph[x]:
if done[y] == 0:
done[y] = 1
dist[y] = dist[x]+ d
q.append(y)
else:
if dist[y] != dist[x]+d:
return 0
return 1
for i in range(N):
if done[i] == 0:
done[i] = 1
if bfs(i) == 0:
print('No')
sys.exit()
print('Yes')
|
# -*- coding: utf-8 -*-
#重み付きUnion-Findによる実装
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
#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,readline().split()))
#0-index
par = [-1]*N
wei = [0]*N
for _ in range(M):
l,r,d = list(map(int,readline().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')
|
p03450
|
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return eval(input())
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
N, M = LI()
if M == 0:
print("Yes")
return
uf = UnionFind(N)
G = [[] for _ in range(N)]
for i in range(M):
l, r, d = LI()
l -= 1
r -= 1
G[l].append((r, d))
G[r].append((l, -d))
val = [inf] * N
glb_visited = set()
def bfs(ini):
q = deque([ini])
visited = set()
visited.add(ini)
glb_visited.add(ini)
while q:
v = q.popleft()
for next_v, d in G[v]:
if next_v in visited:
if val[next_v] == val[v] + d:
continue
else:
return False
val[next_v] = val[v] + d
visited.add(next_v)
glb_visited.add(next_v)
q.append(next_v)
return True
can = True
for k in range(N):
if k in glb_visited:
continue
val[k] = 0
if not bfs(k):
can = False
if can:
print("Yes")
else:
print("No")
return
main()
|
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return eval(input())
def main():
N, M = LI()
if M == 0:
print("Yes")
return
G = [[] for _ in range(N)]
for i in range(M):
l, r, d = LI()
l -= 1
r -= 1
G[l].append((r, d))
G[r].append((l, -d))
val = [inf] * N
global_visited = set()
def bfs(ini):
flag = True
q = deque([ini])
visited = set()
visited.add(ini)
while q:
v = q.popleft()
for next_v, d in G[v]:
if next_v in visited:
if val[next_v] == val[v] + d:
continue
else:
return False
val[next_v] = val[v] + d
visited.add(next_v)
global_visited.add(next_v)
q.append(next_v)
return True
can = True
for i in range(N):
if i in global_visited:
continue
v = i
val[v] = 0
if not bfs(v):
can = False
break
if can:
print("Yes")
else:
print("No")
return
main()
|
p03450
|
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
from collections import defaultdict
n,m = list(map(int, input().split()))
ns = defaultdict(set)
for _ in range(m):
u,v,c = list(map(int, input().split()))
u -= 1
v -= 1
ns[u].add((c,v))
ns[v].add((-c,u))
vals = [None] * n
def dijkstra(start):
import heapq
h = [(0, start)] # (距離, ノード番号)
vals[start] = 0
ans = True
while h:
val, u = heapq.heappop(h)
for d, v in ns[u]:
if vals[v] is None:
vals[v] = val+d
heapq.heappush(h, (vals[v], v))
else:
if vals[v]!=val+d:
return False
return ans
for start in range(n):
if vals[start] is not None:
continue
res = dijkstra(start)
if not res:
print("No")
break
else:
print("Yes")
|
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
from collections import defaultdict
n,m = list(map(int, input().split()))
ns = defaultdict(set)
for _ in range(m):
u,v,c = list(map(int, input().split()))
u -= 1
v -= 1
ns[u].add((c,v))
ns[v].add((-c,u))
vals = [None] * n
def dijkstra(start):
h = [start]
vals[start] = 0
ans = True
while h:
u = h.pop()
for d, v in ns[u]:
if vals[v] is None:
vals[v] = vals[u]+d
h.append(v)
else:
if vals[v]!=vals[u]+d:
return False
return ans
for start in range(n):
if vals[start] is not None:
continue
res = dijkstra(start)
if not res:
print("No")
break
else:
print("Yes")
|
p03450
|
def main():
from collections import deque
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
g = tuple(set() for _ in range(N))
h = [0] * N # 入り次数
for _ in range(M):
L, R, D = list(map(int, input().split()))
L -= 1
R -= 1
g[L].add((R, D))
h[R] += 1
dist = [-1] * N
def dfs(s):
dist[s] = 0
dq = deque([s])
while dq:
v = dq.popleft()
for u, d in g[v]:
if ~dist[u]:
if dist[u] != dist[v] + d:
return False
else:
dist[u] = dist[v] + d
dq.append(u)
return True
# 始点からのパスを処理
for s in range(N):
if h[s]: continue # sに入ってくるパスがあるので、sを始点にしない
if ~dist[s]: continue
if not dfs(s):
print('No')
return
# サイクルを処理（どの点も入るパスがあり、処理できていない）
for s in range(N):
if ~dist[s]: continue
if not dfs(s):
print('No')
return
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()))
g = tuple(set() for _ in range(N))
h = [0] * N # 入り次数
for _ in range(M):
L, R, D = list(map(int, input().split()))
L -= 1
R -= 1
g[L].add((R, D))
h[R] += 1
dist = [-1] * N
def dfs(s):
dist[s] = 0
dq = deque([s])
while dq:
v = dq.popleft()
for u, d in g[v]:
if ~dist[u]:
if dist[u] != dist[v] + d:
return False
else:
dist[u] = dist[v] + d
dq.append(u)
return True
# 始点からのパスを処理
for s in range(N):
if h[s]: continue # sに入ってくるパスがあるので、sを始点にしない
# if ~dist[s]: continue
if not dfs(s):
print('No')
return
# サイクルを処理（どの点も入るパスがあり、処理できていない）
for s in range(N):
if ~dist[s]: continue
if not dfs(s):
print('No')
return
print('Yes')
if __name__ == '__main__':
main()
|
p03450
|
class UnionFindTree:
def __init__(self, size):
self.table = [-1 for _ in range(size)]
def find_root(self, x):
while 0 <= self.table[x]:
x = self.table[x]
return x
def union(self, x, y):
r1 = self.find_root(x)
r2 = self.find_root(y)
if r1 != r2:
self.table[r2] = r1
def __repr__(self):
return repr(self.table)
def check(root, group, l, r, d):
seen = set()
table = {}
table[root] = 0
seen.add(root)
while len(seen) != len(group):
for li, ri, di in zip(l, r, d):
if (li not in seen) and (ri not in seen):
continue
if (li in seen) and (ri in seen):
if table[li]+di != table[ri]:
return False
elif li in seen:
table[ri] = table[li] + di
seen.add(ri)
elif ri in seen:
table[li] = table[ri] - di
seen.add(li)
return True
def main():
n, m = list(map(int, input().split()))
l, r, d = [], [], []
seen = set()
tree = UnionFindTree(n+1)
for i in range(m):
li, ri, di = list(map(int, input().split()))
l.append(li)
r.append(ri)
d.append(di)
seen.add(li)
seen.add(ri)
tree.union(li, ri)
groups = {}
for s in seen:
root = tree.find_root(s)
if root not in groups:
groups[root] = set()
groups[root].add(s)
for root in groups:
if not check(root, groups[root], l, r, d):
print('No')
return
print('Yes')
main()
|
class UnionFindTree:
def __init__(self, size):
self.parent = list(range(size))
self.dist = [0] * size
def find_root(self, x):
if self.parent[x] == x:
return x, 0
else:
self.parent[x], d = self.find_root(self.parent[x])
self.dist[x] += d
return self.parent[x], self.dist[x]
def union(self, x, y, d):
r1, d1 = self.find_root(x)
r2, d2 = self.find_root(y)
if r1 != r2:
self.parent[r2] = r1
self.dist[r2] = (d1 - d2) + d
else:
if (d2 - d1) != d:
return False
return True
def main():
n, m = list(map(int, input().split()))
tree = UnionFindTree(n+1)
for i in range(m):
l, r, d = list(map(int, input().split()))
if not tree.union(l, r, d):
print('No')
return
print('Yes')
main()
|
p03450
|
import sys
sys.setrecursionlimit(2147483647)
INF=float('inf')
MOD=10**9+7
input=sys.stdin.readline
n,m=list(map(int,input().split()))
#初期値が0の辞書
from collections import defaultdict
lrd = defaultdict(lambda: [])
yx=[[0]*n for _ in range(n)]
for _ in range(m):
l,r,d=list(map(int,input().split()))
lrd[l-1].append(r-1)
lrd[r-1].append(l-1)
yx[l-1][r-1]=d
def BFD(x):
global checked,answer
checked[x]=1
#print("x>>>",x)
for item in lrd[x]:
#print(lrd,item,x)
ll=min(item,x)
rr=max(item,x)
if answer[item]==-1:
if item<=x:
answer[item]=answer[x]-yx[item][x]
else:
answer[item]=answer[x]+yx[x][item]
else:
if answer[rr]!=answer[ll]+yx[ll][rr]:
print("No")
exit()
if checked[item]==0:
BFD(item)
checked=[0]*n
for i in range(n):
if checked[i]==0:
answer = defaultdict(lambda: -1)
answer[i]=1
BFD(i)
print("Yes")
|
import sys
sys.setrecursionlimit(2147483647)
INF=float('inf')
MOD=10**9+7
input=sys.stdin.readline
n,m=list(map(int,input().split()))
#初期値が0の辞書
from collections import defaultdict
lrd = defaultdict(lambda: [])
lr=defaultdict(lambda: 0)
for _ in range(m):
l,r,d=list(map(int,input().split()))
lrd[l-1].append((r-1,-d))
lrd[r-1].append((l-1,+d))
def BFD(x):
global checked,answer,lrd
checked[x]=1
#print("x>>>",x)
for llrrdd in lrd[x]:
#print(lrd,item,x)
item=llrrdd[0]
if answer[item]==INF:
answer[item]=answer[x]-llrrdd[1]
else:
if answer[item]!=answer[x]-llrrdd[1]:
print("No")
exit()
if checked[item]==0:
BFD(item)
checked=[0]*n
for i in range(n):
if checked[i]==0:
answer = defaultdict(lambda: INF)
answer[i]=1
BFD(i)
print("Yes")
|
p03450
|
import sys
sys.setrecursionlimit(2147483647)
INF=10**10
MOD=10**9+7
input=sys.stdin.readline
n,m=list(map(int,input().split()))
#初期値が0の辞書
from collections import defaultdict
lrd = defaultdict(lambda: [])
lr=defaultdict(lambda: 0)
for _ in range(m):
l,r,d=list(map(int,input().split()))
lrd[l-1].append((r-1,-d))
lrd[r-1].append((l-1,+d))
def BFD(x):
global checked,answer,lrd
checked[x]=1
#print("x>>>",x)
for llrrdd in lrd[x]:
#print(lrd,item,x)
item=llrrdd[0]
if answer[item]==INF:
answer[item]=answer[x]-llrrdd[1]
else:
if answer[item]!=answer[x]-llrrdd[1]:
print("No")
exit()
if checked[item]==0:
BFD(item)
checked=[0]*n
for i in range(n):
if checked[i]==0:
answer = defaultdict(lambda: INF)
answer[i]=1
BFD(i)
print("Yes")
|
import sys
sys.setrecursionlimit(2147483647)
INF=10**10
MOD=10**9+7
input=sys.stdin.readline
n,m=list(map(int,input().split()))
#初期値が0の辞書
#from collections import defaultdict
#lrd = defaultdict(lambda: [])
lrd=[[] for _ in range(n)]
for _ in range(m):
l,r,d=list(map(int,input().split()))
#print("lrd",lrd)
lrd[l-1].append((r-1,-d))
lrd[r-1].append((l-1,+d))
#print(lrd)
def BFD(x):
global checked,answer,lrd
checked[x]=1
#print("x>>>",x,lrd[x])
for llrrdd in lrd[x]:
#print(llrrdd,x)
item=llrrdd[0]
if answer[item]==-10**10:
answer[item]=answer[x]-llrrdd[1]
else:
if answer[item]!=answer[x]-llrrdd[1]:
print("No")
exit()
if checked[item]==0:
BFD(item)
checked=[0]*n
for i in range(n):
if checked[i]==0:
answer = [-10**10]*n
answer[i]=1
BFD(i)
print("Yes")
|
p03450
|
import sys
sys.setrecursionlimit(2147483647)
INF=10**10
MOD=10**9+7
input=sys.stdin.readline
n,m=list(map(int,input().split()))
#初期値が0の辞書
#from collections import defaultdict
#lrd = defaultdict(lambda: [])
lrd=[[] for _ in range(n)]
for _ in range(m):
l,r,d=list(map(int,input().split()))
#print("lrd",lrd)
lrd[l-1].append((r-1,-d))
lrd[r-1].append((l-1,+d))
#print(lrd)
def BFD(x):
global checked,answer,lrd
checked[x]=1
#print("x>>>",x,lrd[x])
for llrrdd in lrd[x]:
#print(llrrdd,x)
item=llrrdd[0]
if answer[item]==-10**10:
answer[item]=answer[x]-llrrdd[1]
else:
if answer[item]!=answer[x]-llrrdd[1]:
print("No")
exit()
if checked[item]==0:
BFD(item)
checked=[0]*n
for i in range(n):
if checked[i]==0:
answer = [-10**10]*n
answer[i]=1
BFD(i)
print("Yes")
|
import sys
sys.setrecursionlimit(100000)
input=sys.stdin.readline
n,m=list(map(int,input().split()))
lrd=[[] for _ in range(n)]
for _ in range(m):
l,r,d=list(map(int,input().split()))
#print("lrd",lrd)
lrd[l-1].append((r-1,-d))
lrd[r-1].append((l-1,+d))
#print(lrd)
def BFD(x):
global checked,answer,lrd
checked[x]=1
#print("x>>>",x,lrd[x])
for llrrdd in lrd[x]:
#print(llrrdd,x)
item=llrrdd[0]
if answer[item]=="first":
answer[item]=answer[x]-llrrdd[1]
else:
if answer[item]!=answer[x]-llrrdd[1]:
print("No")
exit()
if checked[item]==0:
BFD(item)
checked=[0]*n
for i in range(n):
if checked[i]==0:
answer = ["first"]*n
answer[i]=1
BFD(i)
print("Yes")
|
p03450
|
import sys
sys.setrecursionlimit(100000)
input=sys.stdin.readline
n,m=list(map(int,input().split()))
lrd=[[] for _ in range(n)]
for _ in range(m):
l,r,d=list(map(int,input().split()))
#print("lrd",lrd)
lrd[l-1].append((r-1,-d))
lrd[r-1].append((l-1,+d))
#print(lrd)
def BFD(x):
global checked,answer,lrd
checked[x]=1
#print("x>>>",x,lrd[x])
for llrrdd in lrd[x]:
#print(llrrdd,x)
item=llrrdd[0]
if answer[item]=="first":
answer[item]=answer[x]-llrrdd[1]
else:
if answer[item]!=answer[x]-llrrdd[1]:
print("No")
exit()
if checked[item]==0:
BFD(item)
checked=[0]*n
for i in range(n):
if checked[i]==0:
answer = ["first"]*n
answer[i]=1
BFD(i)
print("Yes")
|
import sys
sys.setrecursionlimit(100000)
input=sys.stdin.readline
n,m=list(map(int,input().split()))
lrd=[[] for _ in range(n)]
for _ in range(m):
l,r,d=list(map(int,input().split()))
lrd[l-1].append((r-1,-d))
lrd[r-1].append((l-1,+d))
def BFD(x):
global checked,answer,lrd
checked[x]=1
#print("x>>>",x,lrd[x])
for llrrdd in lrd[x]:
#print(llrrdd,x)
item=llrrdd[0]
if answer[item]=="first":
answer[item]=answer[x]-llrrdd[1]
else:
if answer[item]!=answer[x]-llrrdd[1]:
print("No")
exit()
if checked[item]==0:
BFD(item)
checked=[0]*n
answer = ["first"]*n
for i in range(n):
if checked[i]==0:
answer[i]=1
BFD(i)
print("Yes")
|
p03450
|
from collections import deque
import sys
input = sys.stdin.readline
inf = pow(10, 10)
n, m = list(map(int, input().split()))
a = [inf] * n
edge = [[] for i in range(n)]
for i 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))
flag = True
for i in range(n):
if not flag: break
dist = [10**10]*n
dist[i] = 0
dq = deque([i])
while dq:
now = dq.popleft()
for e in edge[now]:
nnode, d = e
if dist[nnode] == inf:
dist[nnode] = dist[now] + d
dq.append(nnode)
else:
if dist[nnode] != dist[now] + d:
flag = False
break
if flag:
print('Yes')
else:
print('No')
|
from collections import deque
import sys
input = sys.stdin.readline
inf = pow(10, 10)
n, m = list(map(int, input().split()))
a = [inf] * n
edge = [[] for i in range(n)]
for i 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))
flag = True
dist = [inf] * n
for i in range(n):
if not flag: break
if dist[i] == inf:
dist[i] = 0
dq = deque([i])
while dq:
now = dq.popleft()
for e in edge[now]:
nnode, d = e
if dist[nnode] == inf:
dist[nnode] = dist[now] + d
dq.append(nnode)
else:
if dist[nnode] != dist[now] + d:
flag = False
break
if flag:
print('Yes')
else:
print('No')
|
p03450
|
import sys
from collections import deque
def solve():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
Edge = [[] for _ in range(N)]
for _ in range(M):
l, r, d = list(map(int, input().split()))
Edge[l-1].append((r-1, d))
Edge[r-1].append((l-1, -1 * d))
Dist = [10 ** 20] * N
possible = True
for i in range(N):
if Dist[i] == 10 ** 20:
q = deque()
q.append((i, 0))
while q:
nn, nd = q.popleft()
if Dist[nn] == 10 ** 20:
Dist[nn] = nd
for ne, add in Edge[nn]: q.append((ne, nd + add))
else:
if Dist[nn] == nd: continue
else:
possible = False
break
if not possible:
print("No")
break
else: print("Yes")
return 0
if __name__ == "__main__":
solve()
|
import sys
from collections import deque
def solve():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
E = [[] for _ in range(N)]
for _ in range(M):
l, r, d = list(map(int, input().split()))
E[l-1].append((r - 1, d))
E[r-1].append((l - 1, -d))
Pos = [10 ** 20] * N
q = deque()
flag = True
for i in range(N):
if Pos[i] == 10 ** 20:
q.append((i, 0))
minX, maxX = 0, 0
while q:
x, p = q.popleft()
if Pos[x] == 10 ** 20:
minX = min(minX, p)
maxX = max(maxX, p)
Pos[x] = p
for ne, d in E[x]: q.append((ne, p + d))
elif Pos[x] == p: continue
else:
flag = False
break
else:
if maxX - minX <= 10 ** 9: continue
else: flag = False
if not flag:
print("No")
break
else: print("Yes")
#print(Pos)
return 0
if __name__ == "__main__":
solve()
|
p03450
|
import sys
input = sys.stdin.readline
n, m = [int(x) for x in input().split()]
g = [[] for _ in range(n)]
for _ in range(m):
l, r, d = [int(x) for x in input().split()]
l -= 1
r -= 1
g[l].append((r, d))
g[r].append((l, -d))
d = [0] * n
from collections import deque
queue = deque([])
for i in range(n):
if d[i] != 0:
continue
queue.append(i)
while queue:
u = queue.popleft()
for v, d_ in g[u]:
if d[v] == 0 and v != i:
d[v] = d[u] + d_
queue.append(v)
else:
if d[v] != d[u] + d_:
print("No")
sys.exit()
d[i] = 1
print("Yes")
|
n, m = list(map(int, input().split()))
ed = [[] for _ in range(n)] # グラフ
v = [None] * n
for _ in range(m):
l, r, d = list(map(int, input().split()))
ed[l-1].append((r-1, d)) # l -> r
ed[r-1].append((l-1, -d)) # r -> l
visited = [False] * n # 訪問フラグ（非連結の可能性の為）
def dfs(start):
s = [start]
v[start] = 0
while s:
label = s.pop()
if visited[label] == False:
visited[label] = True
for to, dist in ed[label]:
if v[to] is None:
v[to] = v[label] + dist
s.append(to)
else:
if v[to] != v[label] + dist:
return False
return True
is_exist = True
for i in range(n):
if v[i] is None:
if not dfs(i):
print('No')
is_exist = False
break
if is_exist:
print("Yes")
|
p03450
|
import sys
input = sys.stdin.readline
n, m = [int(x) for x in input().split()]
g = [[] for _ in range(n)]
for _ in range(m):
l, r, d = [int(x) for x in input().split()]
g[l - 1].append((r - 1, d))
g[r - 1].append((l - 1, -d))
d = [0] * n
visited = [0] * n
for i in range(n):
if visited[i] != 0:
continue
stack = [i]
d[i] = 1
while stack:
u = stack.pop()
visited[u] = 1
for v, d_ in g[u]:
if d[v] == 0:
d[v] = d[u] + d_
stack.append(v)
else:
if d[v] != d[u] + d_:
print("No")
sys.exit()
print("Yes")
|
import sys
input = sys.stdin.readline
n, m = [int(x) for x in input().split()]
g = [[] for _ in range(n)]
for _ in range(m):
l, r, d = [int(x) for x in input().split()]
g[l - 1].append((r - 1, d))
g[r - 1].append((l - 1, -d))
d = [None] * n
visited = [0] * n
for i in range(n):
if visited[i] != 0:
continue
stack = [i]
d[i] = 1
while stack:
u = stack.pop()
visited[u] = 1
for v, d_ in g[u]:
if d[v] is None:
d[v] = d[u] + d_
stack.append(v)
else:
if d[v] != d[u] + d_:
print("No")
sys.exit()
print("Yes")
|
p03450
|
import sys
sys.setrecursionlimit(100000)
N, M = list(map(int, input().split()))
LRD = [list(map(int, input().split())) for _ in range(M)]
graph = [{} for _ in range(N)]
for l, r, d in LRD:
l, r = l - 1, r - 1
graph[l][r] = d
graph[r][l] = -d
visited = [False] * N
def dfs(v, p, d, depths):
if visited[v]:
return True
visited[v] = True
if depths[v] != -1:
return True
depths[v] = d
for n in graph[v]:
if n == p:
continue
n_depth = d + graph[v][n]
if depths[n] != -1 and depths[n] != n_depth:
return False
result = dfs(n, v, n_depth, depths)
if not result:
return False
return True
for n in range(N):
if not dfs(n, -1, 0, [-1] * N):
print("No")
break
else:
print("Yes")
|
import sys
sys.setrecursionlimit(100000)
N, M = list(map(int, input().split()))
LRD = [list(map(int, input().split())) for _ in range(M)]
graph = [{} for _ in range(N)]
for l, r, d in LRD:
l, r = l - 1, r - 1
graph[l][r] = d
graph[r][l] = -d
visited = [False] * N
depths = [-1] * N
def dfs(v, p, d):
if visited[v]:
return True
visited[v] = True
depths[v] = d
for n in graph[v]:
if n == p:
continue
n_depth = d + graph[v][n]
if depths[n] != -1 and depths[n] != n_depth:
return False
result = dfs(n, v, n_depth)
if not result:
return False
return True
for n in range(N):
if not dfs(n, -1, 0):
print("No")
break
else:
print("Yes")
|
p03450
|
import sys
sys.setrecursionlimit(100000)
N, M = list(map(int, input().split()))
LRD = [list(map(int, input().split())) for _ in range(M)]
graph = [{} for _ in range(N)]
for l, r, d in LRD:
l, r = l - 1, r - 1
graph[l][r] = d
graph[r][l] = -d
visited = [False] * N
depths = [-1] * N
def dfs(v, p, d):
if visited[v]:
return True
visited[v] = True
depths[v] = d
for n in graph[v]:
if n == p:
continue
n_depth = d + graph[v][n]
if depths[n] != -1 and depths[n] != n_depth:
return False
result = dfs(n, v, n_depth)
if not result:
return False
return True
for n in range(N):
if not dfs(n, -1, 0):
print("No")
break
else:
print("Yes")
|
import sys
sys.setrecursionlimit(100000)
N, M = list(map(int, input().split()))
LRD = [list(map(int, input().split())) for _ in range(M)]
graph = [{} for _ in range(N)]
for l, r, d in LRD:
l, r = l - 1, r - 1
graph[l][r] = d
graph[r][l] = -d
visited = [False] * N
depths = [0] * N
def dfs(v):
q = [v]
while q:
cu = q.pop()
for nx, d in list(graph[cu].items()):
if visited[nx]:
if depths[nx] != depths[cu] + d:
return False
else:
visited[nx] = True
depths[nx] = depths[cu] + d
q += [nx]
return True
for n in range(N):
if not visited[n]:
if not dfs(n):
print("No")
break
else:
print("Yes")
|
p03450
|
# coding=utf-8
line = input().split(" ")
N = int(line[0])
M = int(line[1])
if M==0:
print("Yes")
exit()
l = []
for _ in range(M):
line = input().split(" ")
l.append((
int(line[0])-1
,int(line[1])-1
,int(line[2])
))
l.sort()
o = l[0][0]
for i in range(M):
l[i] = (
l[i][0]-o
,l[i][1]-o
,l[i][2]
)
nl = [-1 for x in range(N)]
nl[0] = 0
flag = True
while flag:
flag = False
ll = []
for c in l:
if nl[c[0]]>=0 and nl[c[1]]==-1:
nl[c[1]] = nl[c[0]]+c[2]
elif nl[c[0]]==-1 and nl[c[1]]>=0:
nl[c[0]] = nl[c[1]]-c[2]
elif nl[c[0]]>=0 and nl[c[1]]>=0:
if nl[c[1]]-nl[c[0]]==c[2]:
pass
else:
print("No")
exit()
else:
ll.append(c)
flag = True
l = ll.copy()
print("Yes")
|
# -*- coding: utf-8 -*-
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 unite(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]
n,m = list(map(int, input().split()))
uf = WeightedUnionFind(n)
for _ in range(m):
l,r,d = list(map(int, input().split()))
if uf.same(l,r):
if uf.diff(l,r) != d:
print("No")
exit()
else:
uf.unite(l,r,d)
print("Yes")
|
p03450
|
from collections import deque
from collections import defaultdict
N,M=list(map(int,input().split()))
nl=[ [] for i in range(N+1) ]
cost={}
for i in range(M):
L,R,D=list(map(int,input().split()))
if i==0:start=L
nl[L].append(R)
nl[R].append(L)
cost[(L,R)]=D
cost[(R,L)]=-D
d=[ None for i in range(N+1) ]
V=[ 0 for i in range(N+1) ]
V2=[]
def dfs(start):
q = deque([])
V[start]=1
d[start]=0
q.append(start)
while len(q)!=0:
v=q.pop()
for i in nl[v]:
if V[i]!=1:
V[i]=1
V2.append((v,i))
q.append(i)
d[i]=d[v]+cost[(v,i)]
if (v,i) not in V2:
if d[v]-d[i]!=cost[(i,v)]:
print("No")
quit()
for i in range(1,N+1):
if V[i]==0:
dfs(i)
else:
print("Yes")
|
from collections import deque
from collections import defaultdict
N,M=list(map(int,input().split()))
nl=[ [] for i in range(N+1) ]
cost={}
for i in range(M):
L,R,D=list(map(int,input().split()))
if i==0:start=L
nl[L].append(R)
nl[R].append(L)
cost[(L,R)]=D
cost[(R,L)]=-D
d=[ None for i in range(N+1) ]
V=[ 0 for i in range(N+1) ]
def dfs(start):
q = deque([])
V[start]=1
d[start]=0
q.append(start)
while len(q)!=0:
v=q.pop()
for i in nl[v]:
if V[i]!=1:
V[i]=1
q.append(i)
d[i]=d[v]+cost[(v,i)]
else:
if d[i]-d[v]!=cost[(v,i)]:
print("No")
quit()
for i in range(1,N+1):
if V[i]==0:
dfs(i)
else:
print("Yes")
|
p03450
|
class WeightedUnionFind:
def __init__(self, node:int) -> None:
self.n = node
self.par = [i for i in range(self.n)]
self.rank = [0 for i in range(self.n)]
self.diff_weight = [0 for i in range(self.n)]
# ノードxのルートを求める
def find(self, x:int) -> int:
if x == self.par[x]:
return x
else:
r = self.find(self.par[x])
self.diff_weight[x] += self.diff_weight[self.par[x]]
self.par[x] = r
return self.par[x]
# ノードxのルートからの距離を求める
def weight(self, x:int) -> int:
self.find(x)
return self.diff_weight[x]
# weight(y) - weight(x) = w となるようにする
def unite(self, x:int, y:int, w:int) -> bool:
if self.isSame(x,y):
#print("x and y has already united")
return False
w += self.weight(x)
w -= self.weight(y)
rx = self.find(x)
ry = self.find(y)
if self.rank[rx] < self.rank[ry]:
rx, ry = ry, rx
w = -w
self.par[ry] = self.par[rx]
self.diff_weight[ry] = w
if self.rank[rx] == self.rank[ry]:
self.rank[rx] += 1
return True
def isSame(self, x:int, y:int) -> bool:
return self.find(x) == self.find(y)
def diff(self, x:int, y:int) -> int:
if self.isSame(x,y):
return self.weight(y)-self.weight(x)
else:
raise ValueError("xとyは同じ木に属していません")
N,M = list(map(int, input().split()))
query = []
for _ in range(M):
query.append(tuple(map(int, input().split())))
uf = WeightedUnionFind(N)
consistent = True
for l,r,d in query:
l -= 1
r -= 1
if uf.isSame(l,r):
if d != uf.diff(l,r):
consistent = False
break
else:
uf.unite(l,r,d)
if consistent:
print("Yes")
else:
print("No")
|
from sys import stdin
input = stdin.readline
class WeightedUnionFind:
def __init__(self, node:int) -> None:
self.n = node
self.par = [i for i in range(self.n)]
self.rank = [0 for i in range(self.n)]
self.diff_weight = [0 for i in range(self.n)]
# ノードxのルートを求める
def find(self, x:int) -> int:
if x == self.par[x]:
return x
else:
r = self.find(self.par[x])
self.diff_weight[x] += self.diff_weight[self.par[x]]
self.par[x] = r
return self.par[x]
# ノードxのルートからの距離を求める
def weight(self, x:int) -> int:
self.find(x)
return self.diff_weight[x]
# weight(y) - weight(x) = w となるようにする
def unite(self, x:int, y:int, w:int) -> bool:
if self.isSame(x,y):
#print("x and y has already united")
return False
w += self.weight(x)
w -= self.weight(y)
rx = self.find(x)
ry = self.find(y)
if self.rank[rx] < self.rank[ry]:
rx, ry = ry, rx
w = -w
self.par[ry] = self.par[rx]
self.diff_weight[ry] = w
if self.rank[rx] == self.rank[ry]:
self.rank[rx] += 1
return True
def isSame(self, x:int, y:int) -> bool:
return self.find(x) == self.find(y)
def diff(self, x:int, y:int) -> int:
if self.isSame(x,y):
return self.weight(y)-self.weight(x)
else:
raise ValueError("xとyは同じ木に属していません")
N,M = list(map(int, input().split()))
query = []
for _ in range(M):
query.append(tuple(map(int, input().split())))
uf = WeightedUnionFind(N)
consistent = True
for l,r,d in query:
l -= 1
r -= 1
if uf.isSame(l,r):
if d != uf.diff(l,r):
consistent = False
break
else:
uf.unite(l,r,d)
if consistent:
print("Yes")
else:
print("No")
|
p03450
|
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
class WeightedUnionFind:
def __init__(self, node:int) -> None:
self.n = node
self.par = [i for i in range(self.n)]
self.rank = [0 for i in range(self.n)]
self.diff_weight = [0 for i in range(self.n)]
# ノードxのルートを求める
def find(self, x:int) -> int:
if x == self.par[x]:
return x
else:
r = self.find(self.par[x])
self.diff_weight[x] += self.diff_weight[self.par[x]]
self.par[x] = r
return self.par[x]
# ノードxのルートからの距離を求める
def weight(self, x:int) -> int:
self.find(x)
return self.diff_weight[x]
# weight(y) - weight(x) = w となるようにする
def unite(self, x:int, y:int, w:int) -> bool:
if self.isSame(x,y):
return False
w += self.weight(x)
w -= self.weight(y)
rx = self.find(x)
ry = self.find(y)
if self.rank[rx] < self.rank[ry]:
rx, ry = ry, rx
w = -w
self.par[ry] = self.par[rx]
self.diff_weight[ry] = w
if self.rank[rx] == self.rank[ry]:
self.rank[rx] += 1
return True
def isSame(self, x:int, y:int) -> bool:
return self.find(x) == self.find(y)
def diff(self, x:int, y:int) -> int:
if self.isSame(x,y):
return self.weight(y)-self.weight(x)
else:
raise ValueError("xとyは同じ木に属していません")
n,m = li()
lrd = []
for _ in range(m):
l,r,d = li()
l -= 1
r -= 1
lrd.append((l,r,d))
exist = True
wuf = WeightedUnionFind(n)
for l,r,d in lrd:
wuf.unite(l,r,d)
if wuf.diff(l,r) != d:
exist = False
break
if exist:
print("Yes")
else:
print("No")
|
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
n,m = li()
graph = [[] for _ in range(n)]
for _ in range(m):
l,r,d = li()
l -= 1
r -= 1
graph[l].append((d,r))
graph[r].append((-d,l))
searched = [False]*n
dist = [float("inf") for _ in range(n)]
exist = True
for i in range(n):
if not searched[i]:
dist[i] = 0
searched[i] = True
stack = [(0,i)]
while stack:
cost, cur = stack.pop()
for nex_cost, nex_node in graph[cur]:
if searched[nex_node]:
if cost + nex_cost != dist[nex_node]:
exist = False
else:
stack.append((cost+nex_cost, nex_node))
dist[nex_node] = cost + nex_cost
searched[nex_node] = True
if exist:
print("Yes")
else:
print("No")
|
p03450
|
N, M = list(map(int,input().split()))
L = [0] * M
R = [0] * M
D = [0] * M
for i in range(M):
L[i],R[i],D[i] = list(map(int,input().split()))
# print(L[i],R[i],D[i])
leftside = 0
cand = set()
for i in range(M):
cand.add(L[i])
for i in range(M):
if R[i] in cand:
cand.remove(R[i])
res = True
if M == 0:
res = True
else:
if len(cand) == 0:
res = False
else:
leftside = list(cand)
# print("leftside:",leftside)
ok = True
for c in leftside:
point = [-1] * (N+1)
point[c] = 0
ok = True
while True:
update = False
for i in range(M):
if point[L[i]] != -1:
if point[R[i]] == -1:
update = True
point[R[i]] = point[L[i]] + D[i]
else:
if point[R[i]] != point[L[i]] + D[i]:
ok = False
break
if update == False:
break
res &= ok
print(("Yes" if res == True else "No"))
|
NOT_VISIT = 10**20
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))
visited = [NOT_VISIT for i in range(N)]
def dfs(start):
global graph, visited
if visited[start] != NOT_VISIT:
return True
stack = [start]
visited[start] = 0
while stack:
label = stack.pop()
for nextnode, distance in graph[label]:
if visited[nextnode] == NOT_VISIT:
stack.append(nextnode)
visited[nextnode] = visited[label] + distance
elif visited[nextnode] != visited[label] + distance:
return False
return True
res = True
for i in range(N):
res &= dfs(i)
print(("Yes" if res == True else "No"))
|
p03450
|
import sys
sys.setrecursionlimit(100000000)
N,M = list(map(int,input().split()))
e = [[] for i in range(N)]
t = 0
a = []
for i in range(M):
r,l,d = list(map(int,input().split()))
e[r-1].append([l-1,d])
e[l-1].append([r-1,-d])
a.append(r-1)
a.append(l-1)
t = r-1
col = [ float("inf") for i in range(N) ]
def dfs(i,c):
for node in e[i]:
if col[node[0]] == float("inf"):
col[node[0]] = c + node[1]
dfs(node[0],c+node[1])
elif col[node[0]] != c + node[1]:
print("No")
exit()
dfs(t,0)
a = list(set(a))
for i in a:
if col[i] == float("inf"):
dfs(i,0)
print("Yes")
|
import sys
sys.setrecursionlimit(100000000)
def main():
N,M = list(map(int,input().split()))
e = [[] for i in range(N)]
t = 0
a = []
for i in range(M):
r,l,d = list(map(int,input().split()))
e[r-1].append([l-1,d])
e[l-1].append([r-1,-d])
a.append(r-1)
a.append(l-1)
t = r-1
col = [ float("inf") for i in range(N) ]
def dfs(i,c):
for node in e[i]:
if col[node[0]] == float("inf"):
col[node[0]] = c + node[1]
dfs(node[0],c+node[1])
elif col[node[0]] != c + node[1]:
print("No")
exit()
dfs(t,0)
a = list(set(a))
for i in a:
if col[i] == float("inf"):
dfs(i,0)
print("Yes")
if __name__ == '__main__':
main()
|
p03450
|
n,m=list(map(int,input().split()))
lrd=[list(map(int,input().split())) for _ in range(m)]
g=[[] for _ in range(n)]
for l,r,d in lrd:
g[l-1].append([d,r-1])
g[r-1].append([-d,l-1])
from collections import deque
no_seen=set(range(n))
inf=float('inf')
dst=[inf]*n
while no_seen:
todo=deque([[0,no_seen.pop()]])
#print(todo)
while todo:
d,t=todo.popleft()
no_seen.discard(t)
dst[t]=d
l=g[t]
for di,ti in l:
if dst[ti]!=inf and dst[ti]!=d+di:
print('No')
exit()
elif dst[ti]!=inf and dst[ti]==d+di:
pass
else:
todo.append([d+di,ti])
print('Yes')
|
n,m=list(map(int,input().split()))
lrd=[list(map(int,input().split())) for _ in range(m)]
g=[[] for _ in range(n)]
for l,r,d in lrd:
g[l-1].append([d,r-1])
g[r-1].append([-d,l-1])
no_seen=set(range(n))
inf=float('inf')
dst=[inf]*n
while no_seen:
todo=[[0,no_seen.pop()]]
#print(todo)
while todo:
d,t=todo.pop()
no_seen.discard(t)
l=g[t]
for di,ti in l:
if dst[ti]!=inf and dst[ti]!=d+di:
print('No')
exit()
elif dst[ti]!=inf and dst[ti]==d+di:
pass
else:
todo.append([d+di,ti])
dst[ti]=d+di
print('Yes')
|
p03450
|
import sys
class UnionFind():
def __init__(self, n):
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
class WeightedUnionFind():
def __init__(self, n):
self.parents = [-1] * n
self.par_weight = [0] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
root = self.find(self.parents[x])
self.par_weight[x] += self.par_weight[self.parents[x]]
self.parents[x] = root
return self.parents[x]
def union(self, x, y, w):
w = w + self.weight(x) - self.weight(y)
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
self.parents[y] += self.parents[x]
self.parents[x] = y
self.par_weight[x] = -w
else:
self.parents[x] += self.parents[y]
self.parents[y] = x
self.par_weight[y] = w
def weight(self, x):
if self.parents[x] < 0:
return 0
else:
return self.par_weight[x] + self.weight(self.parents[x])
def diff(self, x, y):
if self.find(x) != self.find(y):
raise Exception('"{}" belongs to a different tree from "{}"'.format(x, y))
return self.weight(y) - self.weight(x)
N, M = list(map(int, input().split()))
uf = WeightedUnionFind(N)
ans = 'No'
for q in sys.stdin.readlines():
L, R, D = list(map(int, q.split()))
L -= 1; R -= 1
if uf.find(L) == uf.find(R):
if uf.diff(L, R) != D:
break
else:
uf.union(L, R, D)
else:
ans = 'Yes'
print(ans)
|
import sys
sys.setrecursionlimit(10 ** 6)
def dfs(p):
result = True
for np, D in edge[p]:
if pos[np] is None:
pos[np] = pos[p] + D
result &= dfs(np)
else:
if pos[p] + D != pos[np]:
result &= False
return result
N, M = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for q in sys.stdin.readlines():
L, R, D = list(map(int, q.split()))
L -= 1; R -= 1
edge[L].append((R, D))
edge[R].append((L, -D))
pos = [None] * N
result = True
for i in range(N):
if pos[i] is None:
pos[i] = 0
result &= dfs(i)
ans = 'Yes' if result else 'No'
print(ans)
|
p03450
|
# coding:utf-8
import sys
input = sys.stdin.readline
INF = float('inf')
def inpl(): return list(map(int, input().split()))
def solve(N, M, info):
distance = [[None] * N for _ in range(N)]
for i in range(N):
distance[i][i] = 0
for L, R, D in info:
distance[L][R] = D
for L, R, D in info:
if L + 1 == R:
continue
if distance[L][R - 1] is None or distance[L + 1][R] is None:
continue
if distance[L][R - 1] + distance[L + 1][R] != D:
break
else:
return 'Yes'
return 'No'
N, M = inpl()
info = []
for i in range(M):
L, R, D = inpl()
if L > R:
L, R = R, L
D = -D
info.append([L - 1, R - 1, D])
print((solve(N, M, info)))
|
# coding:utf-8
import sys
input = sys.stdin.readline
def inpl(): return list(map(int, input().split()))
# ---
class UnionFind:
__slots__ = ['nodes', 'weight']
def __init__(self, size: int) -> None:
self.nodes = [-1] * size
self.weight = [0] * size
# 検索
def find(self, x: int) -> int:
if self.nodes[x] < 0:
return x
else:
parent = self.find(self.nodes[x])
self.weight[x] += self.weight[self.nodes[x]]
self.nodes[x] = parent
return parent
# 併合
# def unite(self, x: int, y: int, w: int) -> bool:
# root_x = self.find(x)
# root_y = self.find(y)
# if root_x == root_y:
# return False
# else:
# rank_x = -self.nodes[root_x]
# rank_y = -self.nodes[root_y]
# if rank_x < rank_y:
# self.nodes[root_x] = root_y
# self.weight[root_x] = w - self.weight[y] - self.weight[x]
# else:
# self.nodes[root_y] = root_x
# self.weight[root_y] = w - self.weight[x] - self.weight[y]
#
# if rank_x == rank_y:
# self.nodes[root_x] += -1
#
# return True
# xとyのルートが等しい時: 入力された重みwが正しいかどうかを判定
# xとyのルートが異なる時: xとyを併合する
# True: 併合した，False: 何もしなかった，ValueError: 入力された重みに矛盾がある
def relate(self, x: int, y: int, w: int) -> bool:
root_x = self.find(x)
root_y = self.find(y)
if root_x == root_y: # 入力された重みwに矛盾がないか判定
# print(x, y, self.weight[x], self.weight[y], w)
# print(self.get_tree())
# print(self.weight)
if self.weight[x] - self.weight[y] == w:
return False
raise ValueError
else:
rank_x = -self.nodes[root_x]
rank_y = -self.nodes[root_y]
if rank_x < rank_y:
self.nodes[root_x] = root_y
self.weight[root_x] = w + self.weight[y] - self.weight[x]
else:
self.nodes[root_y] = root_x
self.weight[root_y] = -w + self.weight[x] - self.weight[y]
if rank_x == rank_y:
self.nodes[root_x] += -1
return True
# UnionFind木の一覧を返す
def get_tree(self) -> dict:
tree = {}
for i, node in enumerate(self.nodes):
if node < 0:
if i not in list(tree.keys()):
tree[i] = []
else:
if self.find(node) in list(tree.keys()):
tree[self.find(node)].append(i)
else:
tree[self.find(node)] = [i]
return tree
N, M = inpl()
uf = UnionFind(N)
relate = uf.relate
try:
for i in range(M):
l, r, d = inpl()
relate(l - 1, r - 1, d)
else:
print('Yes')
except ValueError:
print('No')
|
p03450
|
import sys
input = sys.stdin.readline
def main():
n, m = list(map(int, input().split()))
F = [[] for _ in range(n)]
lrd = [list(map(int, input().split())) for _ in range(m)]
for _ in range(2):
for i in range(m):
l, r, d = lrd[i]
l -= 1
r -= 1
for nr, nd in F[l]:
if r == nr:
if d != nd:
print("No")
exit()
else:
F[nr].append((r, d-nd))
F[r].append((nr, nd-d))
F[l].append((r, d))
for nl, nd in F[r]:
if l == nl:
if -d != nd:
print("No")
exit()
else:
F[l].append((nl, nd+d))
F[nl].append((l, -nd-d))
F[r].append((l, -d))
print("Yes")
if __name__ == "__main__":
main()
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
n, m = list(map(int, input().split()))
G = [[] for _ in range(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))
dist = [float("inf")]*n
def dfs(v):
for nv, d in G[v]:
if dist[nv] == float("inf"):
dist[nv] = dist[v]+d
if not dfs(nv):
return False
else:
if dist[nv] != dist[v]+d:
return False
return True
for i in range(n):
if dist[i] == float("inf"):
dist[i] = 0
if not dfs(i):
print("No")
break
else:
print("Yes")
|
p03450
|
"""from collections import *
from itertools import *
from bisect import *
from heapq import *
import math
from fractions import gcd"""
N,M=list(map(int,input().split()))
LRD=[list(map(int,input().split())) for i in range(M)]
data=[[] for i in range(N+1)]
for m,(l,r,d) in enumerate(LRD):
data[l].append([r,d,m])
data[r].append([l,-d,m])
data2=[set([m[1] for m in data[i]]) for i in range(N+1)]
Mlst=set([i for i in range(M)])
visited=set()
X=[0 for i in range(N+1)]
while Mlst:
stack=[LRD[Mlst.pop()][0]]
while stack:
l=stack.pop()
visited.add(l)
for r,d,m in data[l]:
if not r in visited:
visited.add(r)
X[r]=X[l]+d
stack.append(r)
if m in Mlst:
Mlst.remove(m)
else:
if X[r]!=X[l]+d:
print("No")
exit()
print("Yes")
|
"""from collections import *
from itertools import *
from bisect import *
from heapq import *
import math
from fractions import gcd"""
N,M=list(map(int,input().split()))
LRD=[list(map(int,input().split())) for i in range(M)]
data=[[] for i in range(N+1)]
for m,(l,r,d) in enumerate(LRD):
data[l].append([r,d,m])
data[r].append([l,-d,m])
data2=[set([m[1] for m in data[i]]) for i in range(N+1)]
Nlst=set([i for i in range(1,N)])
Mlst=set([i for i in range(M)])
visited=set()
X=[0 for i in range(N+1)]
while Mlst:
stack=[Nlst.pop()]
while stack:
l=stack.pop()
visited.add(l)
for r,d,m in data[l]:
if m in Mlst:
Mlst.remove(m)
if not r in visited:
visited.add(r)
X[r]=X[l]+d
stack.append(r)
else:
if X[r]!=X[l]+d:
print("No")
exit()
print("Yes")
|
p03450
|
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():
max_v, max_e = list(map(int, input().split()))
uf = WeightedUnionFind(max_v)
k = []
s = 0
for i in range(max_e):
a,b,w= list(map(int, input().split()))
a-=1
b-=1
if uf.same(a,b):
if w != uf.diff(a,b):
print("No")
break
else:
uf.union(a,b,w)
else:
print("Yes")
if __name__ == '__main__':
main()
|
def main():
import sys
input = sys.stdin.readline
def find(x):
if par[x] < 0:
return x
else:
px = find(par[x])
wei[x] += wei[par[x]]
par[x] = px
return px
def weight(x):
find(x)
return wei[x]
def unite(x,y,w):
w += wei[x]-wei[y]
x = find(x)
y = find(y)
if x == y:
return False
else:
if par[x] > par[y]:
x,y = y,x
w = -w
par[x] += par[y]
par[y] = x
wei[y] = w
return True
def same(x,y):
return find(x) == find(y)
def size(x):
return -par[find(x)]
def diff(x,y):
return weight(y)-weight(x)
n,m = list(map(int,input().split()))
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
from heapq import heapify,heappop,heappush,heapreplace
read=sys.stdin.read
readline=sys.stdin.readline
def main():
n,m,*lrd=list(map(int,read().split()))
hp=[]
for l,r,d in zip(*[iter(lrd)]*3):
if l>r:
hp.append((r,l,-d))
else:
hp.append((l,r,d))
heapify(hp)
if not hp:
print('Yes')
return
while hp:
ce=heappop(hp)
while hp:
ne=hp[0]
if ce[0]==ne[0]:
if ce[1]==ne[1]:
if ce[2]!=ne[2]:
print('No')
return
else:
heappop(hp)
else:
heapreplace(hp,(ce[1],ne[1],ne[2]-ce[2]))
else:
break
print('Yes')
if __name__=='__main__':
main()
|
import sys
sys.setrecursionlimit(10**9)
read=sys.stdin.read
class Unionfind():
def __init__(self,n):
self.parents=[-1]*n
self.dist=[0]*n
def find(self,x):
if self.parents[x]<0:
return self.dist[x],x
else:
tmp=self.find(self.parents[x])
self.dist[x]+=tmp[0]
self.parents[x]=tmp[1]
return self.dist[x], self.parents[x]
def union(self,x,y,d):
rx=self.find(x)[1]
ry=self.find(y)[1]
diff=self.dist[y]-self.dist[x]-d
if rx==ry:
if diff!=0:
return True
return False
if diff<0:
rx,ry=ry,rx
diff=-diff
self.parents[ry]=min(self.parents[ry],self.parents[rx]-diff)
self.parents[rx]=ry
self.dist[rx]=diff
return False
def main():
n,m,*lrd=list(map(int,read().split()))
v=Unionfind(n)
for l,r,d in zip(*[iter(lrd)]*3):
if v.union(l-1,r-1,d):
print('No')
break
else:
if max(-d-1 for d in v.parents if d<0) >10**9:
print('No')
else:
print('Yes')
if __name__=='__main__':
main()
|
p03450
|
import sys
sys.setrecursionlimit(10**9)
read=sys.stdin.read
class Unionfind():
def __init__(self,n):
self.parents=[-1]*n
self.dist=[0]*n
def find(self,x):
if self.parents[x]<0:
return x,self.dist[x]
else:
tmp=self.find(self.parents[x])
self.parents[x]=tmp[0]
self.dist[x]+=tmp[1]
return self.parents[x],self.dist[x]
def union(self,x,y,d):
rx=self.find(x)[0]
ry=self.find(y)[0]
diff=self.dist[y]-self.dist[x]-d
if rx==ry:
if diff!=0:
return True
return False
if diff<0:
rx,ry=ry,rx
diff=-diff
self.parents[ry]=min(self.parents[ry],self.parents[rx]-diff)
self.parents[rx]=ry
self.dist[rx]=diff
return False
def main():
n,m,*lrd=list(map(int,read().split()))
v=Unionfind(n)
for l,r,d in zip(*[iter(lrd)]*3):
if v.union(l-1,r-1,d):
print('No')
break
else:
print('Yes')
if __name__=='__main__':
main()
|
import sys
sys.setrecursionlimit(10**9)
read=sys.stdin.read
class Unionfind():
def __init__(self,n):
self.parents=[-1]*n
self.dist=[0]*n
def find(self,x):
if self.parents[x]<0:
return self.dist[x],x
else:
tmp=self.find(self.parents[x])
self.dist[x]+=tmp[0]
self.parents[x]=tmp[1]
return self.dist[x], self.parents[x]
def union(self,x,y,d):
_,rx=self.find(x)
_,ry=self.find(y)
diff=self.dist[y]-self.dist[x]-d
if rx==ry:
if diff!=0:
return True
return False
if diff<0:
rx,ry=ry,rx
diff=-diff
self.parents[ry]=min(self.parents[ry],self.parents[rx]-diff)
self.parents[rx]=ry
self.dist[rx]=diff
return False
def main():
n,m,*lrd=list(map(int,read().split()))
v=Unionfind(n)
for l,r,d in zip(*[iter(lrd)]*3):
if v.union(l-1,r-1,d):
print('No')
break
else:
if max(-d-1 for d in v.parents if d<0) >10**9:
print('No')
else:
print('Yes')
if __name__=='__main__':
main()
|
p03450
|
import sys
input = sys.stdin.readline
inf = float('inf')
mod = 10**9+7
def INT_(n): return int(n)-1
def MI(): return list(map(int, input().split()))
def MF(): return list(map(float, input().split()))
def MI_(): return list(map(INT_, input().split()))
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n: int): return [eval(input()) for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split())) for l in eval(input())]
def I(): return int(eval(input()))
def F(): return float(eval(input()))
def ST(): return input().replace('\n', '')
def main():
class WeightedUnionFind():
def __init__(self, n):
self.nodes = [-1 for _ in range(n)]
self.weight = [0] * n
def get_root(self, x):
if self.nodes[x] < 0:
return x
else:
y = self.get_root(self.nodes[x])
self.weight[x] += self.weight[self.nodes[x]]
self.nodes[x] = y
return y
def unite(self, x, y, w):
w += self.weight[x]-self.weight[y]
root_x = self.get_root(x)
root_y = self.get_root(y)
if root_x != root_y:
# 大きい木の方につないだほうが計算量が減る
if self.nodes[root_x] > self.nodes[root_y]:
root_x, root_y = root_y, root_x
w *= -1
self.nodes[root_x] += self.nodes[root_y]
self.nodes[root_y] = root_x
self.weight[root_y] = w
def diff(self, x, y):
return self.weight[y] - self.weight[x]
def same(self, x, y):
return get_root(x) == get_root(y)
N, M = MI()
edge = [[] for _ in range(N)]
uf = WeightedUnionFind(N)
get_root, unite, nodes, diff, same = uf.get_root, uf.unite, uf.nodes, uf.diff, uf.same
distanse = [0] * N
distanse[0] = 0
rev_edge = [[]for _ in range(N)]
for _ in range(M):
l, r, d = MI_()
d += 1
edge[l].append((r, d))
if same(l, r) and diff(l, r) != d:
print("No")
exit()
else:
unite(l, r, d)
print("Yes")
if __name__ == '__main__':
main()
|
import sys
input = sys.stdin.readline
inf = float('inf')
mod = 10**9+7
def INT_(n): return int(n)-1
def MI(): return list(map(int, input().split()))
def MF(): return list(map(float, input().split()))
def MI_(): return list(map(INT_, input().split()))
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n: int): return [eval(input()) for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split())) for l in eval(input())]
def I(): return int(eval(input()))
def F(): return float(eval(input()))
def ST(): return input().replace('\n', '')
def main():
class WeightedUnionFind():
def __init__(self, n):
self.nodes = [-1 for _ in range(n)]
self.weight = [0] * n
def get_root(self, x):
if self.nodes[x] < 0:
return x
else:
y = self.get_root(self.nodes[x])
self.weight[x] += self.weight[self.nodes[x]]
self.nodes[x] = y
return y
def unite(self, x, y, w):
w += self.weight[x]-self.weight[y]
root_x = self.get_root(x)
root_y = self.get_root(y)
if root_x != root_y:
# 大きい木の方につないだほうが計算量が減る
if self.nodes[root_x] > self.nodes[root_y]:
root_x, root_y = root_y, root_x
w *= -1
self.nodes[root_x] += self.nodes[root_y]
self.nodes[root_y] = root_x
self.weight[root_y] = w
def diff(self, x, y):
return self.weight[y] - self.weight[x]
def same(self, x, y):
return get_root(x) == get_root(y)
N, M = MI()
uf = WeightedUnionFind(N)
get_root, unite, nodes, diff, same = uf.get_root, uf.unite, uf.nodes, uf.diff, uf.same
for _ in range(M):
l, r, d = MI_()
d += 1
if same(l, r) and diff(l, r) != d:
print("No")
exit()
else:
unite(l, r, d)
print("Yes")
if __name__ == '__main__':
main()
|
p03450
|
import sys
sys.setrecursionlimit(10**5)
n, m = [int(i) for i in input().split(" ")]
par = [i for i in range(0, n + 1)]
d2p = [0 for i in range(0, n + 1)]
def root(x):
global par
global d2p
if par[x] == x:
return (x, 0)
else:
r = root(par[x])
par[x] = r[0]
d2p[x] += r[1]
#print(par, d2p)
return (r[0], d2p[x])
def unite(x, y, d):
global par
global d2p
#print(x, y, d)
rx, dx = root(x)
ry, dy = root(y)
if rx != ry:
par[rx] = ry
d2p[rx] = dy + d - dx
#print(par, d2p,"noz")
return True
else:
if dx - dy != d:
#print(rx, ry, dx, dy)
return False
else:
return True
l = [0] * m
r = [0] * m
d = [0] * m
for i in range(0, m):
l[i], r[i], d[i] = [int(j) for j in input().split(" ")]
f = True
for i in range(0, m):
if not unite(l[i], r[i], d[i]):
f = False
break
if f:
print("Yes")
else:
print("No")
|
import sys
sys.setrecursionlimit(10**5)
n, m = [int(i) for i in input().split(" ")]
par = [i for i in range(0, n + 1)]
d2p = [0 for i in range(0, n + 1)]
def d2r(x):
global par
global d2p
k = x
s = 0
while k != par[k]:
s += d2p[k]
k = par[k]
return s
def root(x):
global par
global d2p
#print(par, d2p)
if par[x] == x:
return x
else:
r = root(par[x])
s = d2r(x)
par[x] = r
d2p[x] = s
return r
def unite(x, y, d):
global par
global d2p
#print(x, y, d)
rx = root(x)
dx = d2r(x)
ry = root(y)
dy = d2r(y)
if rx != ry:
par[rx] = ry
d2p[rx] = dy + d - dx
#print(par, d2p,"noz")
return True
else:
if dx - dy != d:
#print(rx, ry, dx, dy)
return False
else:
return True
l = [0] * m
r = [0] * m
d = [0] * m
for i in range(0, m):
l[i], r[i], d[i] = [int(j) for j in input().split(" ")]
f = True
for i in range(0, m):
if not unite(l[i], r[i], d[i]):
f = False
break
if f:
print("Yes")
else:
print("No")
|
p03450
|
import sys
import queue
input = sys.stdin.readline
INF=float('inf')
def solve():
n,m=list(map(int,input().split()))
l=[list(map(int,input().split())) for _ in range(m)]
d=[INF]*n
nbr=[[] for _ in range(n)]
used=[False]*m
for i in range(m):
nbr[l[i][0]-1].append([l[i][0]-1,l[i][1]-1,l[i][2],i])
nbr[l[i][1]-1].append([l[i][1]-1,l[i][0]-1,-l[i][2],i])
#print(nbr)
for i in range(n):
if d[i]==INF:
d[i]=0
q=queue.Queue()
for x in nbr[i]:
q.put(x)
while not q.empty():
eg=q.get()
used[eg[3]]=True
if d[eg[1]]==d[eg[0]]+eg[2]:
pass
elif d[eg[1]]==INF:
d[eg[1]]=d[eg[0]]+eg[2]
else:
print('No')
exit()
for x in nbr[eg[1]]:
if not used[x[3]]:
q.put(x)
#print(d)
print('Yes')
solve()
|
def solve():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
INF=float('inf')
n,m=list(map(int,input().split()))
l=[list(map(int,input().split())) for _ in range(m)]
d=[INF]*n
nbr=[[] for _ in range(n)]
used=[False]*m
for x in l:
x[0]-=1
x[1]-=1
#print(l)
for i in range(m):
nbr[l[i][0]].append(i)
nbr[l[i][1]].append(i)
#print(nbr)
def sol(i):
for x in nbr[i]:
if used[x]:continue
used[x]=True
i1=l[x][0]^l[x][1]^i
dd=d[i]+l[x][2]*(2*(l[x][0]==i)-1)
if d[i1]!=dd and d[i1]!=INF:
print('No')
exit()
elif d[i1]==INF:
d[i1]=dd
sol(i1)
for i in range(n):
if d[i]==INF:
d[i]=0
sol(i)
#print(d)
print('Yes')
solve()
|
p03450
|
N, M = list(map(int, input().split()))
LRD = [tuple(map(int, input().split())) for i in range(M)]
class unionFind:
parent = []
def __init__(self, N):
self.parent = [i for i in range(N)]
self.weight = [0]*N
def root(self, x):
if self.parent[x] == x:
return(x)
else:
p = self.root(self.parent[x])
self.weight[x] += self.weight[self.parent[x]]
self.parent[x] = p
return(self.parent[x])
def same(self, x, y):
x, y = x-1, y-1
return(self.root(x) == self.root(y))
def unite(self, x, y, w):
w -= self.getWeight(x)
w += self.getWeight(y)
x, y = x-1, y-1
x = self.root(x)
y = self.root(y)
if x == y:
return
else:
self.parent[x] = y
self.weight[x] = self.weight[y]+w
return
def getWeight(self, x):
x -= 1
self.root(x)
return(self.weight[x])
G = unionFind(N)
flag = True
for l, r, d in LRD:
if G.same(l, r) == False:
G.unite(l, r, d)
else:
if G.getWeight(l) - G.getWeight(r) == d:
continue
else:
flag = False
break
if flag:
print("Yes")
else:
print("No")
|
class unionFind:
parent = []
def __init__(self, N):
self.parent = [i for i in range(N)]
self.weight = [0]*N
def root(self, x):
if self.parent[x] == x:
return(x)
else:
p = self.root(self.parent[x])
self.weight[x] += self.weight[self.parent[x]]
self.parent[x] = p
return(self.parent[x])
def same(self, x, y):
x, y = x-1, y-1
return(self.root(x) == self.root(y))
def unite(self, x, y, w):
w -= self.getWeight(x)
w += self.getWeight(y)
x, y = x-1, y-1
x = self.root(x)
y = self.root(y)
if x == y:
return
else:
self.parent[x] = y
self.weight[x] = self.weight[y]+w
return
def getWeight(self, x):
x -= 1
self.root(x)
return(self.weight[x])
def main():
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
G = unionFind(N)
for i in range(M):
L, R, D = list(map(int, input().split()))
if G.same(L, R):
x = G.getWeight(L)
y = G.getWeight(R)
if x == y + D:
continue
else:
print("No")
exit(0)
else:
G.unite(L, R, D)
print("Yes")
main()
|
p03450
|
def sub(a, b, n):
r = a[:]
for i in range(len(b)):
r[i] -= b[i] * n
return r
def mult(a, n):
r = a[:]
for i in range(len(a)):
r[i] *= n
return r
def pm(matr):
return ""
def rref(matr):
if len(matr) == 0 or len(matr[0]) == 0:
return matr
pivotCt = 0
for d in range(max(len(matr), len(matr[0])-1)):
#scan for first pivot
pivot = None
for i in range(len(matr)):
allZeroes = True
for j in range(d):
if matr[i][j] != 0:
allZeroes = False
break
if matr[i][d] != 0 and allZeroes:
pivot = mult(matr[i], 1/matr[i][d])
del matr[i]
matr.insert(pivotCt, pivot)
break
if pivot != None:
for i in range(len(matr)):
if i != pivotCt and matr[i][d] != 0:
matr[i] = sub(matr[i], pivot, matr[i][d])
pivotCt += 1
return matr
s = input().split(" ")
vs = int(s[0])
es = int(s[1])
matr = []
for i in range(es):
matr.append([0] * (vs + 1))
q = input().split(" ")
x = int(q[0])
y = int(q[1])
z = int(q[2])
matr[i][x] = 1
matr[i][y] = -1
matr[i][-1] = z
matr = rref(matr)
bad = False
for i in range(len(matr)):
allZeroes = True
for j in range(len(matr[0])-1):
if matr[i][j] != 0:
allZeroes = False
break
if allZeroes and matr[i][-1] != 0:
bad = True
break
if bad:
print("No")
else:
print("Yes")
|
n, m = list(map(int, input().split()))
inf = 10**10
G = [{} for i in range(n)]
for i in range(m):
l, r, d = list(map(int, input().split()))
G[l-1][r-1] = d
G[r-1][l-1] = -d
V = [False for i in range(n)]
D = [inf for i in range(n)]
for i in range(n):
if V[i]:
continue
Q = [i]
D[i] = 0
while Q:
j = Q.pop()
V[j] = True
for k in list(G[j].keys()):
if not V[k]:
Q.append(k)
if D[k] == inf:
D[k] = D[j]+G[j][k]
elif D[k] != D[j]+G[j][k]:
print('No')
exit()
print('Yes')
|
p03450
|
from queue import Queue
import sys
inf = float("inf")
N, M = list(map(int, input().split()))
to = [[] for x in range(N+1)]
cost = [[] for x in range(N+1)]
value = [inf for x in range(N+1)]
for i in range(M):
l, r, d = list(map(int, input().split()))
to[l].append(r)
cost[l].append(d)
to[r].append(l)
cost[r].append(-d)
for i in range(1, N+1):
if value[i] != inf: continue
value[i] = 0
q = Queue()
q.put(i)
while not q.empty():
tmp = q.get()
for j in range(len(to[tmp])):
nxt = to[tmp][j]
nxt_val = value[tmp] + cost[tmp][j]
if value[nxt] != inf:
if value[nxt] == nxt_val: continue
print("No")
sys.exit()
value[nxt] = nxt_val
q.put(nxt)
print("Yes")
|
from queue import Queue
import sys
inf = float("inf")
N, M = list(map(int, input().split()))
dist = [[] for x in range(N+1)]
value = [inf for x in range(N+1)]
for i in range(M):
l, r, d = list(map(int, input().split()))
dist[l].append((r, d))
dist[r].append((l, -d))
for i in range(1, N+1):
if value[i] != inf: continue
value[i] = 0
q = Queue()
q.put(i)
while not q.empty():
tmp = q.get()
for x in dist[tmp]:
nxt = x[0]
nxt_val = value[tmp] + x[1]
if value[nxt] != inf:
if value[nxt] == nxt_val: continue
print("No")
sys.exit()
value[nxt] = nxt_val
q.put(nxt)
print("Yes")
|
p03450
|
n, m = list(map(int, input().split()))
lrd = []
MAX = 999999
p = [[] for _ in range(n)]
for i in range(m):
l, r, d = list(map(int, input().split()))
lrd.append([l-1, r-1, d, 0])
p[l-1].append(i)
p[r-1].append(i)
if m <= 1:
print('Yes')
exit()
a = [MAX for _ in range(n)]
a[lrd[0][0]] = 0
temp = [lrd[0][0]]
next = []
t = 0
s = 0
max_a = 0
min_a = 0
while 1:
next = []
for x in temp:
for y in p[x]:
if lrd[y][0] == x:
t = lrd[y][1]
s = a[x] + lrd[y][2]
else:
t = lrd[y][0]
s = a[x] - lrd[y][2]
lrd[y][3] = 1
if a[t] == MAX:
a[t] = s
next.append(t)
elif a[t] != s:
print('No')
exit()
if len(next) == 0:
target = 0
i = 0
check = 0
for i in range(m):
if lrd[i][3] == 0:
target = lrd[i][0]
check = 1
if check == 0:
break
a[target] = 0
next = [target]
temp = [] + list(set(next))
print('Yes')
|
n, m = list(map(int, input().split()))
lrd = []
MAX = 999999
p = [[] for _ in range(n)]
for i in range(m):
l, r, d = list(map(int, input().split()))
lrd.append([l-1, r-1, d, 0])
p[l-1].append(i)
p[r-1].append(i)
if m <= 1:
print('Yes')
exit()
a = [MAX for _ in range(n)]
target = lrd[0][0]
a[target] = 0
temp = [target]
t = 0
while 1:
next = []
for x in temp:
for y in p[x]:
if lrd[y][3] == 1:
continue
if lrd[y][0] == x:
t = lrd[y][1]
d = a[x] + lrd[y][2]
else:
t = lrd[y][0]
d = a[x] - lrd[y][2]
lrd[y][3] = 1
if a[t] == MAX:
a[t] = d
next.append(t)
elif a[t] != d:
print('No')
exit()
if len(next) == 0:
check = 0
for i in range(m):
if lrd[i][3] == 0:
check = 1
target = lrd[i][0]
break
if check == 1:
temp = [target]
a[target] = 0
continue
else:
break
temp = [] + list(set(next))
print('Yes')
|
p03450
|
def main():
n, m = list(map(int, input().split()))
g = [[] for i 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))
dis = [0] * n
visited = [False] * n
stack = list(range(n))
while len(stack):
v = stack[-1]
stack.pop()
if visited[v]:
continue
visited[v] = True
for u, d in g[v]:
if not visited[u]:
dis[u] = dis[v] + d
stack.append(u)
for v in range(n):
for u, d in g[v]:
if dis[v] + d != dis[u]:
print('No')
return
print('Yes')
if __name__ == '__main__':
main()
|
def main():
n, m = list(map(int, input().split()))
g = [[] for i 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))
dis = [0] * n
visited = [False] * n
for i in range(n):
if visited[i]:
continue
stack = list([i])
visited[i] = True
while len(stack):
v = stack[-1]
stack.pop()
for u, d in g[v]:
if not visited[u]:
dis[u] = dis[v] + d
stack.append(u)
visited[u] = True
for v in range(n):
for u, d in g[v]:
if dis[v] + d != dis[u]:
print('No')
return
print('Yes')
if __name__ == '__main__':
main()
|
p03450
|
import sys
def main():
n, m = list(map(int, sys.stdin.readline().split()))
g = [[] for i in range(n)]
for i in range(m):
l, r, d = list(map(int, sys.stdin.readline().split()))
g[l - 1].append((r - 1, d))
g[r - 1].append((l - 1, -d))
dis = [0] * n
visited = [False] * n
for i in range(n):
if visited[i]:
continue
stack = list([i])
visited[i] = True
while len(stack):
v = stack[-1]
stack.pop()
for u, d in g[v]:
if not visited[u]:
dis[u] = dis[v] + d
stack.append(u)
visited[u] = True
for v in range(n):
for u, d in g[v]:
if dis[v] + d != dis[u]:
print('No')
return
print('Yes')
if __name__ == '__main__':
main()
|
import sys
def main():
n, m = list(map(int, sys.stdin.readline().split()))
g = [[] for i in range(n)]
deg = [0] * n
lines = sys.stdin.read().splitlines()
for line in lines:
l, r, d = list(map(int, line.split()))
g[l - 1].append((r - 1, d))
deg[r - 1] += 1
dis = [-1] * n
for i in range(n):
if deg[i]:
continue
stack = list([i])
dis[i] = 0
while len(stack):
v = stack[-1]
stack.pop()
for u, d in g[v]:
if dis[u] == -1:
dis[u] = dis[v] + d
stack.append(u)
for v in range(n):
for u, d in g[v]:
if dis[v] + d != dis[u]:
print('No')
return
print('Yes')
if __name__ == '__main__':
main()
|
p03450
|
import sys
def main():
n, m = list(map(int, sys.stdin.readline().split()))
g = [[] for i in range(n)]
deg = [0] * n
lines = sys.stdin.read().splitlines()
for line in lines:
l, r, d = list(map(int, line.split()))
g[l - 1].append((r - 1, d))
deg[r - 1] += 1
dis = [-1] * n
for i in range(n):
if deg[i]:
continue
stack = list([i])
dis[i] = 0
while len(stack):
v = stack[-1]
stack.pop()
for u, d in g[v]:
if dis[u] == -1:
dis[u] = dis[v] + d
stack.append(u)
for v in range(n):
for u, d in g[v]:
if dis[v] + d != dis[u]:
print('No')
return
print('Yes')
if __name__ == '__main__':
main()
|
import sys
def main():
n, m = list(map(int, sys.stdin.readline().split()))
g = [[] for i in range(n)]
deg = [0] * n
for i in range(m):
l, r, d = list(map(int, sys.stdin.readline().split()))
g[l - 1].append((r - 1, d))
deg[r - 1] += 1
dis = [-1] * n
for i in range(n):
if deg[i]:
continue
stack = list([i])
dis[i] = 0
while len(stack):
v = stack[-1]
stack.pop()
for u, d in g[v]:
if dis[u] == -1:
dis[u] = dis[v] + d
stack.append(u)
for v in range(n):
for u, d in g[v]:
if dis[v] + d != dis[u]:
print('No')
return
print('Yes')
if __name__ == '__main__':
main()
|
p03450
|
N,M = list(map(int,input().split()))
num = [0] * N
far = [0] * N
RD = []
tps = []
p = []
for i in range(N):
RD.append([])
p.append(set([i]))
for i in range(M):
L,R,D = list(map(int,input().split()))
num[R-1] += 1
RD[L-1].append([R-1,D])
Q = []
for i in range(N):
if num[i] == 0:
Q.append(i)
while len(Q) > 0:
q = Q.pop(0)
num[q] -= 1
tps.append(q)
for rd in RD[q]:
r = rd[0]
num[r] -= 1
if num[r] == 0:
Q.append(r)
flag = True
for i in range(N):
if num[i] > 0:
flag = False
maxfar = 0
#print (flag)
if flag:
for i in tps:
for ra in RD[i]:
if len(p[ra[0]] & p[i]) > 0 and far[ra[0]] != far[i] + ra[1]:
flag = False
p[ra[0]] = p[ra[0]] | p[i]
far[ra[0]] = max(far[ra[0]],far[i] + ra[1])
maxfar = max(maxfar,far[ra[0]])
#print (far)
if flag and maxfar <= 10 ** 9:
print ("Yes")
else:
print ("No")
|
N,M = list(map(int,input().split()))
point = ["x"] * N
lis = []
notend = set([])
for i in range(N):
lis.append([])
notend = notend | set([i])
for i in range(M):
L,R,D = list(map(int,input().split()))
lis[L-1].append([R-1,D])
lis[R-1].append([L-1,-1 * D])
ans = "Yes"
Q = []
while True:
if len(notend) > 0:
Q.append(notend.pop())
else:
break
nmin = 0
nmax = 0
while len(Q) > 0:
q = Q.pop(0)
if point[q] == "x":
point[q] = 0
for rd in lis[q]:
#ind = bisect.bisect_left(notend,rd[0])
#print (ind,notend,rd[0])
if rd[0] in notend:
notend = notend - set([rd[0]])
point[rd[0]] = point[q] + rd[1]
nmin = min(nmin,point[rd[0]])
nmax = max(nmin,point[rd[0]])
Q.append(rd[0])
elif point[rd[0]] != point[q] + rd[1]:
ans = "No"
break
if ans == "No":
break
if nmax - nmin > 10 ** 9:
ans = "No"
if ans == "No":
break
print (ans)
|
p03450
|
import heapq
n, m = list(map(int, input().split()))
if m == 0:
print('Yes')
exit()
lrd = [list(map(int, input().split())) for _ in range(m)]
lrd.sort()
di = {i:'?' for i in range(n+1)}
di[lrd[0][0]] = 0
while lrd:
l, r, d = lrd.pop(0)
if di[l] == '?' and di[r] == '?':
lrd += [[l, r, d]]
elif di[l] != '?' and di[r] == '?':
di[r] = di[l] + d
elif di[l] == '?' and di[r] != '?':
di[l] = di[r] - d
else:
if di[l] + d != di[r]:
print('No')
exit()
print('Yes')
|
import sys
sys.setrecursionlimit(10**5)
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
self.weight = [0]*(n+1)
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
r = self.Find_Root(self.root[x])
self.weight[x] += self.weight[self.root[x]]
self.root[x] = r
return r
def GetWeight(self, x):
self.Find_Root(x)
return self.weight[x]
def Unite(self, x, y, w):
w += self.GetWeight(x)
w -= self.GetWeight(y)
x = self.Find_Root(x)
y = self.Find_Root(y)
if(x == y):
return False
if self.rnk[x] < self.rnk[y]:
x, y = y, x
w = -w
if self.rnk[x] == self.rnk[y]:
self.rnk[x] += 1
self.root[y] = x
self.weight[y] = w
return True
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
def Count(self, x):
return -self.root[self.Find_Root(x)]
def Diff(self, x, y):
return self.GetWeight(y) - self.GetWeight(x)
n, m = list(map(int, input().split()))
if m == 0:
print('Yes')
exit()
lrd = [list(map(int, input().split())) for _ in range(m)]
uf = UnionFind(n)
for l, r, d in lrd:
if uf.isSameGroup(l, r)==False:
uf.Unite(l, r, d)
else:
if uf.Diff(l, r) != d:
print('No')
exit()
print('Yes')
|
p03450
|
import sys
sys.setrecursionlimit(10**5)
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
self.weight = [0]*(n+1)
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
r = self.Find_Root(self.root[x])
self.weight[x] += self.weight[self.root[x]]
self.root[x] = r
return r
def GetWeight(self, x):
self.Find_Root(x)
return self.weight[x]
def Unite(self, x, y, w):
w += self.GetWeight(x)
w -= self.GetWeight(y)
x = self.Find_Root(x)
y = self.Find_Root(y)
if(x == y):
return False
if self.rnk[x] < self.rnk[y]:
x, y = y, x
w = -w
if self.rnk[x] == self.rnk[y]:
self.rnk[x] += 1
self.root[y] = x
self.weight[y] = w
return True
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
def Count(self, x):
return -self.root[self.Find_Root(x)]
def Diff(self, x, y):
return self.GetWeight(y) - self.GetWeight(x)
n, m = list(map(int, input().split()))
if m == 0:
print('Yes')
exit()
lrd = [list(map(int, input().split())) for _ in range(m)]
uf = UnionFind(n)
for l, r, d in lrd:
if uf.isSameGroup(l, r)==False:
uf.Unite(l, r, d)
else:
if uf.Diff(l, r) != d:
print('No')
exit()
print('Yes')
|
import sys
sys.setrecursionlimit(10**5)
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
self.weight = [0]*(n+1)
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
r = self.Find_Root(self.root[x])
self.weight[x] += self.weight[self.root[x]]
self.root[x] = r
return r
def GetWeight(self, x):
self.Find_Root(x)
return self.weight[x]
def Unite(self, x, y, w):
w += self.GetWeight(x)
w -= self.GetWeight(y)
x = self.Find_Root(x)
y = self.Find_Root(y)
if(x == y):
return False
if self.rnk[x] < self.rnk[y]:
x, y = y, x
w = -w
if self.rnk[x] == self.rnk[y]:
self.rnk[x] += 1
self.root[y] = x
self.weight[y] = w
return True
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
def Count(self, x):
return -self.root[self.Find_Root(x)]
def Diff(self, x, y):
return self.GetWeight(y) - self.GetWeight(x)
N, M = list(map(int, input().split()))
uf = UnionFind(N+1)
for _ in range(M):
l, r, d = list(map(int, input().split()))
if not uf.isSameGroup(l, r):
uf.Unite(l, r, d)
else:
if uf.Diff(l, r) != d:
print('No')
exit()
print('Yes')
|
p03450
|
I=lambda:list(map(int,input().split()))
n,m=I()
r=list(range(n))
y=[[] for i in r]
z=[None for i in r]
for _ in [0]*m:
i,j,k=I()
y[i-1]+=[[j-1, k]]
y[j-1]+=[[i-1,-k]]
for i in r:
if z[i]==None:
z[i]=0
q=[i]
while q:
p=q.pop()
for j,k in y[p]:
if z[j]==None:
q+=[j]
z[j]=z[p]+k
elif z[j]!=z[p]+k:
print("No")
exit()
print("Yes")
|
I=lambda:list(map(int,input().split()))
n,m=I()
r=list(range(n))
y=[[] for i in r]
z=[None for i in r]
for _ in [0]*m:
i,j,k=I()
y[i-1]+=[[j-1, k]]
y[j-1]+=[[i-1,-k]]
for i in r:
if z[i]==None:
z[i]=0
q=[i]
while q:
p=q.pop()
for j,k in y[p]:
if z[j]==None:
q+=[j]
z[j]=z[p]+k
elif z[j]!=z[p]+k:
print("No")
exit()
print("Yes")
|
p03450
|
#http://at274.hatenablog.com/entry/2018/02/03/140504
#重み付きUnion-Find木
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]
N,M = list(map(int,input().split()))
uf = WeightedUnionFind(N)
for _ in range(M):
L,R,D = list(map(int,input().split()))
L -= 1; R -= 1
if uf.find(L) == uf.find(R):
if uf.diff(L,R) != D:
print("No")
break
else:
uf.union(L,R,D)
else:
print("Yes")
|
#http://at274.hatenablog.com/entry/2018/02/03/140504
#重み付きUnion-Find木
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]
import sys
input = sys.stdin.readline #文字列入力では注意！
N,M = list(map(int,input().split()))
uf = WeightedUnionFind(N)
for _ in range(M):
L,R,D = list(map(int,input().split()))
L -= 1; R -= 1
if uf.find(L) == uf.find(R):
if uf.diff(L,R) != D:
print("No")
break
else:
uf.union(L,R,D)
else:
print("Yes")
|
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])
#print(graph)
x = [None for i in range(N)]
def f():
for i in range(N):
if x[i] == None:
x[i] = 0
q = deque([i])
while len(q):
j = q.popleft()
for k,d in graph[j]:
if x[k] == None:
q.append(k)
x[k] = x[j]+d
elif x[k] != x[j]+d:
return False
return True
if f():
print("Yes")
else:
print("No")
|
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])
x = [None for i in range(N)]
def f():
for i in range(N):
if x[i] == None:
x[i] = 0
q = deque([i])
while len(q):
j = q.popleft()
for k,d in graph[j]:
if x[k] == None:
q.append(k)
x[k] = x[j]+d
elif x[k] != x[j]+d:
return False
return True
if f():
print("Yes")
else:
print("No")
|
p03450
|
import sys
sys.setrecursionlimit(10**5+5)
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[r-1].append((l-1,-d))
graph[l-1].append((r-1,d))
INF=10**9
x_list=[INF]*n
def dfs(x):
for i in graph[x]:
if x_list[i[0]]==INF:
x_list[i[0]]=x_list[x]+i[1]
dfs(i[0])
else:
if x_list[i[0]]==x_list[x]+i[1]:
pass
else:
print('No')
sys.exit()
for i in range(n):
if x_list[i]==INF:
x_list[i]=0
dfs(i)
print('Yes')
|
import sys
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[r-1].append((l-1,-d))
graph[l-1].append((r-1,d))
INF=10**9
x_list=[INF]*n
stack=[]
for i in range(n):
if x_list[i]==INF:
x_list[i]=0
stack.append(i)
while len(stack)>0:
now=stack.pop()
for j in graph[now]:
if x_list[j[0]]==INF:
x_list[j[0]]=x_list[now]+j[1]
stack.append(j[0])
else:
if x_list[j[0]]==x_list[now]+j[1]:
pass
else:
print('No')
sys.exit()
print('Yes')
|
p03450
|
def solve():
n, m = list(map(int, input().split()))
edge = {v:[] for v in range(1,n+1)}
dist = {}
for i in range(m):
l, r, d = list(map(int, input().split()))
edge[l].append(r)
edge[r].append(l)
dist[l,r] = d
dist[r,l] = -d
return "Yes" if ok(edge, dist, n) else "No"
def ok(edge, dist, n):
used = [False] * (n+1)
used[0] = True
path = {}
for s in range(1, n+1):
if used[s]:
continue
que = [s]
path[s, s] = 0
used[s] = True
while que:
u = que.pop(0)
for v in edge[u]:
d = path[s,u] + dist[u,v]
if not (s,v) in path:
path[s,v] = d
if not used[v]:
que.append(v)
used[v] = True
elif d != path[s,v]:
return False
return True
print(solve())
|
def solve():
n, m = list(map(int, input().split()))
edge = {v:[] for v in range(1,n+1)}
dist = {}
for i in range(m):
l, r, d = list(map(int, input().split()))
edge[l].append(r)
edge[r].append(l)
dist[l,r] = d
dist[r,l] = -d
return "Yes" if ok(edge, dist, n) else "No"
def ok(edge, dist, n):
used = [False] * (n+1)
used[0] = True
path = {}
for s in range(1, n+1):
if used[s]:
continue
que = [s]
path[s, s] = 0
used[s] = True
while que:
u = que.pop()
for v in edge[u]:
d = path[s,u] + dist[u,v]
if not used[v]:
path[s,v] = d
que.append(v)
used[v] = True
elif d != path[s,v]:
return False
return True
print(solve())
|
p03450
|
import collections
n, m = list(map(int, input().split()))
es = [collections.deque() for _ in range(n)]
for _ in range(m):
l, r, d = list(map(int, input().split()))
l -= 1
r -= 1
es[l].append((l, r, d))
es[r].append((r, l, -d))
visited = [False for _ in range(n)]
for i in range(n):
if not visited[i]:
visited[i] = True
if len(es[i]) == 0:
continue
distances = [float('inf') for _ in range(n)]
distances[i] = 0
q = collections.deque()
for e in es[i]:
q.append(e)
while q:
j, k, d = q.popleft()
if visited[k] and distances[k] != distances[j] + d:
print('No')
exit()
distances[k] = distances[j] + d
visited[k] = True
while es[k]:
ee = es[k].popleft()
if len(es[ee[1]]) > 0:
q.append(ee)
print('Yes')
|
import collections
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
es = [collections.deque() for _ in range(n)]
for _ in range(m):
l, r, d = list(map(int, input().split()))
l -= 1
r -= 1
es[l].append((l, r, d))
es[r].append((r, l, -d))
visited = [False] * n
for i in range(n):
if not visited[i]:
visited[i] = True
if len(es[i]) == 0:
continue
distances = [float('inf')] * n
distances[i] = 0
q = collections.deque()
for e in es[i]:
q.append(e)
while q:
j, k, d = q.popleft()
if visited[k] and distances[k] != distances[j] + d:
print('No')
exit()
distances[k] = distances[j] + d
visited[k] = True
while es[k]:
ee = es[k].popleft()
if len(es[ee[1]]) > 0:
q.append(ee)
print('Yes')
|
p03450
|
from collections import deque
import sys
input = sys.stdin.readline
def main():
N, M = list(map(int, input().split()))
adj = [[] for _ in range(N + 1)]
for _ in range(M):
L, R, D = list(map(int, input().split()))
adj[L].append((R, D))
adj[R].append((L, -D))
seen = [0] * (N + 1)
def dfs(adj, seen, start):
inf = 10 ** 10
que = deque()
que.append(start)
x = [inf] * (N + 1)
x[start] = 0
while que:
v = que.pop()
seen[v] = 1
for u, d in adj[v]:
if seen[u] == 0:
que.append(u)
if x[u] == inf:
x[u] = x[v] + d
else:
if x[u] != x[v] + d:
print('No')
sys.exit()
return seen
for i in range(1, N + 1):
if seen[i] == 0:
seen = dfs(adj, seen, i)
print('Yes')
if __name__ == '__main__':
main()
|
from collections import deque
import sys
import time
input = sys.stdin.readline
def main():
t1 = time.time()
N, M = list(map(int, input().split()))
adj = [[] for _ in range(N + 1)]
for _ in range(M):
L, R, D = list(map(int, input().split()))
adj[L].append((R, D))
adj[R].append((L, -D))
seen = [0] * (N + 1)
def dfs(adj, seen, start):
inf = 10 ** 10
que = deque()
que.append(start)
x = [inf] * (N + 1)
x[start] = 0
while que:
v = que.pop()
seen[v] = 1
for u, d in adj[v]:
if seen[u] == 0:
que.append(u)
if x[u] == inf:
x[u] = x[v] + d
else:
if x[u] != x[v] + d:
print('No')
sys.exit()
t2 = time.time()
if t2 - t1 > 1.8:
print('Yes')
sys.exit()
return seen
for i in range(1, N + 1):
if seen[i] == 0:
seen = dfs(adj, seen, i)
print('Yes')
if __name__ == '__main__':
main()
|
p03450
|
from collections import deque, defaultdict
import sys
input = sys.stdin.readline
def main():
N, M = list(map(int, input().split()))
adj = defaultdict(lambda: [])
for _ in range(M):
L, R, D = list(map(int, input().split()))
adj[L].append((R, D))
adj[R].append((L, -D))
seen = [0] * (N + 1)
def dfs(adj, start):
inf = 10 ** 10
que = deque()
que.append(start)
x = [inf] * (N + 1)
x[start] = 0
while que:
v = que.pop()
seen[v] = 1
for u, d in adj[v]:
if seen[u] == 0:
que.append(u)
if x[u] == inf:
x[u] = x[v] + d
else:
if x[u] != x[v] + d:
print('No')
sys.exit()
for i in range(1, N + 1):
if seen[i] == 0:
dfs(adj, i)
print('Yes')
if __name__ == '__main__':
main()
|
from collections import deque, defaultdict
import sys
input = sys.stdin.readline
def main():
inf = 10 ** 10
N, M = list(map(int, input().split()))
x = [inf] * (N + 1)
adj = defaultdict(lambda: [])
for _ in range(M):
L, R, D = list(map(int, input().split()))
adj[L].append((R, D))
adj[R].append((L, -D))
seen = [0] * (N + 1)
def dfs(adj, start):
que = deque()
que.append(start)
x[start] = 0
while que:
v = que.pop()
seen[v] = 1
for u, d in adj[v]:
if seen[u] == 0:
que.append(u)
if x[u] == inf:
x[u] = x[v] + d
else:
if x[u] != x[v] + d:
print('No')
sys.exit()
for i in range(1, N + 1):
if seen[i] == 0:
dfs(adj, i)
print('Yes')
if __name__ == '__main__':
main()
|
p03450
|
N,M=list(map(int,input().split()))
if M==0:
print("Yes")
exit(0)
INF=10**9+1
dist=[INF]*N
from collections import deque
info=deque()
for i in range(M):
L,R,d=list(map(int,input().split()))
L,R=L-1,R-1
info.append([L,R,d])
L,R,d=info.popleft()
dist[L]=0
dist[R]=d
while info:
L,R,d=info.popleft()
if dist[L]==INF and dist[R]==INF:
info.append([L,R,d])
else:
if dist[L]!=INF and dist[R]==INF:
dist[R]=dist[L]+d
elif dist[L]==INF and dist[R]!=INF:
dist[L]=dist[R]-d
else:
if dist[L]+d!=dist[R]:
print("No")
exit(0)
print("Yes")
|
# 人を頂点と見なしたグラフを作る。有向で、逆向きの場合は正負を反転させて辺を張る
# 頂点からの距離を記録し、一致しない箇所があればNG。
# 全ての辺を通るまで続ける。
# 辺の情報を[{0から行ける頂点},{1から行ける頂点},...]で管理する
# 親には進まないようにしてDFSする
N,M = list(map(int,input().split()))
E = [[] for i in range(N)]
for i in range(M):
L,R,D = list(map(int,input().split()))
E[L-1].append([R-1,D])
E[R-1].append([L-1,-D])
from collections import deque
# 頂点、親、距離
INF = 10 ** 10
dist = [INF] * N
for i in range(N):
if dist[i] != INF:
continue
dist[i] = 0
q = deque()
q.append(i)
while q:
v = q.popleft()
for child in E[v]:
if dist[child[0]] == INF:
dist[child[0]] = dist[v] + child[1]
q.append(child[0])
else:
if dist[child[0]] != dist[v] + child[1]:
print("No")
exit(0)
else:
print("Yes")
|
p03450
|
# 人を頂点と見なしたグラフを作る。有向で、逆向きの場合は正負を反転させて辺を張る
# 頂点からの距離を記録し、一致しない箇所があればNG。
# 全ての辺を通るまで続ける。
# 辺の情報を[{0から行ける頂点},{1から行ける頂点},...]で管理する
# 親には進まないようにしてDFSする
N,M = list(map(int,input().split()))
E = [[] for i in range(N)]
for i in range(M):
L,R,D = list(map(int,input().split()))
E[L-1].append([R-1,D])
E[R-1].append([L-1,-D])
INF = 10 ** 10
from collections import deque
# 頂点、親、距離
dist = [INF] * N
for i in range(N):
if dist[i] != INF:
continue
q = deque()
q.append([i,-1,0])
while q:
v,parent,d = q.popleft()
# print("v",v,"dist[v]",dist[v],"d",d)
if dist[v] == INF:
# 初めてくる場所
dist[v] = d
else:
# 初めてではない場合
if dist[v] != d:
print("No")
exit(0)
else:
continue
for child in E[v]:
if child == parent:
continue
q.append([child[0],v,d + child[1]])
else:
print("Yes")
|
# 人を頂点と見なしたグラフを作る。有向で、逆向きの場合は正負を反転させて辺を張る
# 頂点からの距離を記録し、一致しない箇所があればNG。
# 全ての辺を通るまで続ける。
# 辺の情報を[{0から行ける頂点},{1から行ける頂点},...]で管理する
# 親には進まないようにしてDFSする
N,M = list(map(int,input().split()))
E = [[] for i in range(N)]
for i in range(M):
L,R,D = list(map(int,input().split()))
E[L-1].append([R-1,D])
E[R-1].append([L-1,-D])
from collections import deque
# 頂点、親、距離
INF = 10 ** 10
dist = [INF] * N
for i in range(N):
if dist[i] != INF:
continue
dist[i] = 0
q = deque()
# 頂点、親
q.append([i,-1])
while q:
v,parent = q.popleft()
for child in E[v]:
if child[0] == parent:
continue
if dist[child[0]] == INF:
dist[child[0]] = dist[v] + child[1]
q.append([child[0],v])
else:
if dist[child[0]] != dist[v] + child[1]:
print("No")
exit(0)
else:
print("Yes")
|
p03450
|
# 人を頂点と見なしたグラフを作る。有向で、逆向きの場合は正負を反転させて辺を張る
# 頂点からの距離を記録し、一致しない箇所があればNG。
# 全ての辺を通るまで続ける。
# 辺の情報を[{0から行ける頂点},{1から行ける頂点},...]で管理する
# 親には進まないようにしてDFSする
N,M = list(map(int,input().split()))
E = [[] for i in range(N)]
for i in range(M):
L,R,D = list(map(int,input().split()))
E[L-1].append([R-1,D])
E[R-1].append([L-1,-D])
from collections import deque
# 頂点、親、距離
INF = 10 ** 10
dist = [INF] * N
for i in range(N):
if dist[i] != INF:
continue
dist[i] = 0
q = deque()
# 頂点、親
q.append([i,-1])
while q:
v,parent = q.pop()
for child in E[v]:
if child[0] == parent:
continue
if dist[child[0]] == INF:
dist[child[0]] = dist[v] + child[1]
q.append([child[0],v])
else:
if dist[child[0]] != dist[v] + child[1]:
print("No")
exit(0)
else:
print("Yes")
|
# 人を頂点と見なしたグラフを作る。有向で、逆向きの場合は正負を反転させて辺を張る
# 頂点からの距離を記録し、一致しない箇所があればNG。
# 全ての辺を通るまで続ける。
# 辺の情報を[{0から行ける頂点},{1から行ける頂点},...]で管理する
# 親には進まないようにしてDFSする
N,M = list(map(int,input().split()))
E = [[] for i in range(N)]
for i in range(M):
L,R,D = list(map(int,input().split()))
E[L-1].append([R-1,D])
E[R-1].append([L-1,-D])
from collections import deque
# 頂点、親、距離
INF = 10 ** 10
dist = [INF] * N
for i in range(N):
if dist[i] != INF:
continue
dist[i] = 0
q = deque()
# 頂点、親
q.append([i,-1])
while q:
v,parent = q.popleft()
for child in E[v]:
if child[0] == parent:
continue
if dist[child[0]] == INF:
dist[child[0]] = dist[v] + child[1]
q.append([child[0],v])
else:
if dist[child[0]] != dist[v] + child[1]:
print("No")
exit(0)
else:
print("Yes")
|
p03450
|
import sys
sys.setrecursionlimit(65536)
N,M=list(map(int, input().split()))
path=[[] for _ in range(N+1)]
for _ in range(M):
l,r,d=list(map(int, input().split()))
path[l].append((r,+d))
path[r].append((l,-d))
cost=[None for _ in range(N+1)]
def dfs(i, c):
if cost[i] is None:
cost[i] = c
for j,d in path[i]:
if not dfs(j, c+d):
return False
return cost[i] == c
ans = "Yes"
for i in range(1, N+1):
if cost[i] is None and not dfs(i, 0):
ans = "No"
break
print(ans)
|
import sys
sys.setrecursionlimit(1145141919)
N,M=list(map(int, input().split()))
path=[[] for _ in range(N+1)]
for _ in range(M):
l,r,d=list(map(int, input().split()))
path[l].append((r,+d))
path[r].append((l,-d))
cost=[None for _ in range(N+1)]
def walk(i, c):
if cost[i] is None:
cost[i] = c
for j,d in path[i]:
if not walk(j, c+d):
return False
return cost[i] == c
ans = "Yes"
for i in range(1, N+1):
if cost[i] is None and not walk(i, 0):
ans = "No"
break
print(ans)
|
p03450
|
from queue import Queue
n,m = list(map(int,input().split()))
e = []
for i in range(n+1):
e.append([])
for i in range(m):
l,r,d = list(map(int,input().split()))
e[l].append([r,d])
e[r].append([l,-d])
#print(e)
c = [0]*(n+1) #チェック用
p = [0]*(n+1) #位置
flag = True
k = 1
while k < n:
if c[k] == 2:
k += 1
continue
q = Queue()
q.put(k)
p[k] = 0
c[k] = 1
while not q.empty():
x = q.get()
c[x] = 2
for t in e[x]:
y = t[0]
d = t[1]
if c[y] == 0:
p[y] = p[x] + d
c[y] = 1
q.put(y)
elif c[y] == 1:
if not p[y] == p[x] + d:
print("No")
quit()
else:
w = 1
print("Yes")
|
n,m = list(map(int,input().split()))
c = list(range(n+1)) #色
a = [] #色ごとのリスト
for i in range(n+1):
a.append([i])
b = [1]*(n+1) #色ごとの頂点数
p = [0]*(n+1) #位置
#print(a)
for i in range(m):
x,y,d = list(map(int,input().split()))
u = c[x]
v = c[y]
if b[u] < b[v]:
x,y = y,x
u,v = v,u
d = -d
if u != v:
l = d + p[x] - p[y]
for t in a[v]:
c[t] = u
p[t] += l
a[u] += a[v]
a[v] = []
b[u] += b[v]
b[v] = 0
else:
if not p[y]-p[x] == d:
#print(p)
print("No")
quit()
print("Yes")
|
p03450
|
import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, M, *LRD = list(map(int, read().split()))
G = [[] for _ in range(N)]
for l, r, d in zip(*[iter(LRD)] * 3):
G[l - 1].append((r - 1, d))
G[r - 1].append((l - 1, -d))
seen = [False] * N
for i in range(N):
if seen[i]:
continue
dist = [-1] * N
dist[i] = 0
queue = deque([i])
while queue:
v = queue.popleft()
for nv, d in G[v]:
if seen[nv]:
if dist[nv] != dist[v] + d:
print('No')
return
else:
dist[nv] = dist[v] + d
seen[nv] = True
queue.append(nv)
print('Yes')
return
if __name__ == '__main__':
main()
|
import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, M, *LRD = list(map(int, read().split()))
G = [[] for _ in range(N)]
for l, r, d in zip(*[iter(LRD)] * 3):
G[l - 1].append((r - 1, d))
G[r - 1].append((l - 1, -d))
dist = [INF] * N
for i in range(N):
if dist[i] != INF:
continue
dist[i] = 0
queue = deque([i])
while queue:
v = queue.popleft()
for nv, d in G[v]:
if dist[nv] != INF:
if dist[nv] != dist[v] + d:
print('No')
return
else:
dist[nv] = dist[v] + d
queue.append(nv)
print('Yes')
return
if __name__ == '__main__':
main()
|
p03450
|
import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, M, *LRD = list(map(int, read().split()))
G = [[] for _ in range(N)]
for l, r, d in zip(*[iter(LRD)] * 3):
G[l - 1].append((r - 1, d))
G[r - 1].append((l - 1, -d))
seen = [False] * N
for i in range(N):
if seen[i]:
continue
dist = [-1] * N
dist[i] = 0
queue = deque([i])
while queue:
v = queue.popleft()
for nv, d in G[v]:
if seen[nv]:
if dist[nv] != dist[v] + d:
print('No')
return
else:
dist[nv] = dist[v] + d
seen[nv] = True
queue.append(nv)
print('Yes')
return
if __name__ == '__main__':
main()
|
import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, M, *LRD = list(map(int, read().split()))
G = [[] for _ in range(N)]
for l, r, d in zip(*[iter(LRD)] * 3):
G[l - 1].append((r - 1, d))
G[r - 1].append((l - 1, -d))
seen = [False] * N
dist = [-1] * N
for i in range(N):
if seen[i]:
continue
dist[i] = 0
queue = deque([i])
while queue:
v = queue.popleft()
for nv, d in G[v]:
if seen[nv]:
if dist[nv] != dist[v] + d:
print('No')
return
else:
dist[nv] = dist[v] + d
seen[nv] = True
queue.append(nv)
print('Yes')
return
if __name__ == '__main__':
main()
|
p03450
|
import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
class UnionFindWeighted:
# Reference: https://note.nkmk.me/python-union-find/
def __init__(self, n):
self.n = n
self.parents = [-1] * n
self.weight = [0] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
root = self.find(self.parents[x])
self.weight[x] += self.weight[self.parents[x]]
self.parents[x] = root
return root
def union(self, x, y, w):
w += -self.weight[x] + self.weight[y]
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y, w = y, x, -w
self.parents[x] += self.parents[y]
self.parents[y] = x
self.weight[y] = -w
def same(self, x, y):
return self.find(x) == self.find(y)
def diff(self, x, y):
return self.weight[x] - self.weight[y]
def main():
N, M, *LRD = list(map(int, read().split()))
uf = UnionFindWeighted(N)
for l, r, d in zip(*[iter(LRD)] * 3):
l -= 1
r -= 1
if uf.same(l, r) and uf.diff(l, r) != d:
print('No')
return
else:
uf.union(l, r, d)
print('Yes')
return
if __name__ == '__main__':
main()
|
import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
class UnionFindWeighted:
# Reference: https://note.nkmk.me/python-union-find/
def __init__(self, n):
self.n = n
self.parents = [-1] * n
self.weight = [0] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
root = self.find(self.parents[x])
self.weight[x] += self.weight[self.parents[x]]
self.parents[x] = root
return root
def union(self, x, y, w):
rx = self.find(x)
ry = self.find(y)
if rx == ry:
return
if self.parents[rx] > self.parents[ry]:
x, y, rx, ry, w = y, x, ry, rx, -w
self.parents[rx] += self.parents[ry]
self.parents[ry] = rx
self.weight[ry] = self.weight[x] - self.weight[y] - w
def same(self, x, y):
return self.find(x) == self.find(y)
def diff(self, x, y):
return self.weight[x] - self.weight[y]
def main():
N, M, *LRD = list(map(int, read().split()))
uf = UnionFindWeighted(N)
for l, r, d in zip(*[iter(LRD)] * 3):
l -= 1
r -= 1
if uf.same(l, r) and uf.diff(l, r) != d:
print('No')
return
else:
uf.union(l, r, d)
print('Yes')
return
if __name__ == '__main__':
main()
|
p03450
|
import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
class UnionFindWeighted:
# Reference: https://note.nkmk.me/python-union-find/
def __init__(self, n):
self.n = n
self.parents = [-1] * n
self.weight = [0] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
root = self.find(self.parents[x])
self.weight[x] += self.weight[self.parents[x]]
self.parents[x] = root
return root
def union(self, x, y, w):
rx = self.find(x)
ry = self.find(y)
if rx == ry:
return
if self.parents[rx] > self.parents[ry]:
x, y, rx, ry, w = y, x, ry, rx, -w
self.parents[rx] += self.parents[ry]
self.parents[ry] = rx
self.weight[ry] = self.weight[x] - self.weight[y] - w
def same(self, x, y):
return self.find(x) == self.find(y)
def diff(self, x, y):
return self.weight[x] - self.weight[y]
def main():
N, M, *LRD = list(map(int, read().split()))
uf = UnionFindWeighted(N)
for l, r, d in zip(*[iter(LRD)] * 3):
l -= 1
r -= 1
if uf.same(l, r) and uf.diff(l, r) != d:
print('No')
return
else:
uf.union(l, r, d)
print('Yes')
return
if __name__ == '__main__':
main()
|
import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
class UnionFindWeighted:
# Reference:
# https://note.nkmk.me/python-union-find/
# https://at274.hatenablog.com/entry/2018/02/03/140504
# https://qiita.com/drken/items/cce6fc5c579051e64fab
def __init__(self, n):
self.n = n
self.parents = [-1] * n
self.weight = [0] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
root = self.find(self.parents[x])
self.weight[x] += self.weight[self.parents[x]]
self.parents[x] = root
return root
def union(self, x, y, w):
rx = self.find(x)
ry = self.find(y)
if rx == ry:
return
if self.parents[rx] > self.parents[ry]:
x, y, rx, ry, w = y, x, ry, rx, -w
self.parents[rx] += self.parents[ry]
self.parents[ry] = rx
self.weight[ry] = self.weight[x] - self.weight[y] + w
def same(self, x, y):
return self.find(x) == self.find(y)
def diff(self, x, y):
return self.weight[y] - self.weight[x]
def main():
N, M, *LRD = list(map(int, read().split()))
uf = UnionFindWeighted(N)
for l, r, d in zip(*[iter(LRD)] * 3):
l -= 1
r -= 1
if uf.same(l, r) and uf.diff(l, r) != d:
print('No')
return
else:
uf.union(l, r, d)
print('Yes')
return
if __name__ == '__main__':
main()
|
p03450
|
from collections import deque
n,m=list(map(int,input().split()))
G=[[] for i 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])
for i in range(n):
dist=[None]*n
q=deque()
if dist[i]==None:
dist[i]=0
q.append(i)
while q:
cur=q.popleft()
for nx,d in G[cur]:
if dist[nx]==None:
dist[nx]=dist[cur]+d
q.append(nx)
elif dist[nx]!=dist[cur]+d:
print('No')
exit()
print('Yes')
|
from collections import deque
n,m=list(map(int,input().split()))
G=[[] for i in range(n)]
dist=[None]*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])
for i in range(n):
q=deque()
if dist[i]==None:
dist[i]=0
q.append(i)
while q:
cur=q.popleft()
for nx,d in G[cur]:
if dist[nx]==None:
dist[nx]=dist[cur]+d
q.append(nx)
elif dist[nx]!=dist[cur]+d:
print('No')
exit()
print('Yes')
|
p03450
|
n,m=list(map(int,input().split()))
G=[[] for i 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])
dist=[None]*n
from collections import deque
for i in range(n):
q=deque()
if dist[i]==None:
dist[i]=0
q.append(i)
while q:
cur=q.popleft()
for nx,nxd in G[cur]:
if dist[nx]==None:
dist[nx]=dist[cur]+nxd
q.append(nx)
elif dist[nx]!=dist[cur]+nxd:
print("No")
exit(0)
print("Yes")
|
n,m=list(map(int,input().split()))
lrd=[tuple(map(int,input().split())) for i in range(m)]
class WeightedUnionFind:
def __init__(self,n):
self.parent = [i for i in range(n)]
self.rank = [0] * n
self.count = 0
self.weight = [0] * n
def root(self,a):
if self.parent[a] == a:
return a
else:
pa = self.root(self.parent[a])
self.weight[a] += self.weight[self.parent[a]]
self.parent[a] = pa
return pa
def is_same(self,a,b):
return self.root(a) == self.root(b)
def unite(self,a,b,w):
ra = self.root(a)
rb = self.root(b)
if ra == rb: return
if self.rank[ra] < self.rank[rb]:
self.parent[ra] = rb
self.weight[ra] = w - self.weight[a] + self.weight[b]
else:
self.parent[rb] = ra
self.weight[rb] = -w - self.weight[b] + self.weight[a]
if self.rank[ra] == self.rank[rb]: self.rank[ra] += 1
self.count += 1
def diff(self,a,b):
return self.weight[a] - self.weight[b]
uf=WeightedUnionFind(n)
for l,r,d in lrd:
l,r=l-1,r-1
if uf.is_same(l,r):
if uf.diff(l,r)!=d:
print('No')
exit(0)
else:
uf.unite(l,r,d)
print('Yes')
|
p03450
|
import collections
from collections import deque
import sys
input = sys.stdin.readline
def tree(s):
flag=True
INF=-10**9
dis = [INF for i in range(n)]
dis[s]=0
def bfs():
d = deque()
d.append(s)
while len(d):
x = d.popleft()
for i,j in vec[x]:
if dis[i] == INF:
dis[i]=dis[x]+j
d.append(i)
else:
if dis[i]==dis[x]+j:
continue
else:
print('No')
exit()
return flag
return bfs()
n,m = list(map(int, input().split()))
a = [list(map(int, input().split())) for i in range(m)]
vec= [[] for i in range(n)]
for i in range(m):
vec[a[i][0]-1].append((a[i][1]-1,a[i][2]))
vec[a[i][1]-1].append((a[i][0]-1,-a[i][2]))
INF=float('inf')
visited=[INF]*n
for i in range(n):
if visited[i]==INF:
tree(i)
print('Yes')
|
import collections
from collections import deque
import sys
input = sys.stdin.readline
def bfs(s):
d = deque()
d.append(s)
dis[s]=0
flag=True
while len(d):
x = d.popleft()
for i,j in vec[x]:
if dis[i] == INF:
dis[i]=dis[x]+j
d.append(i)
else:
if dis[i]==dis[x]+j:
continue
else:
print('No')
exit()
return flag
n,m = list(map(int, input().split()))
a = [list(map(int, input().split())) for i in range(m)]
vec= [[] for i in range(n)]
for i in range(m):
vec[a[i][0]-1].append((a[i][1]-1,a[i][2]))
vec[a[i][1]-1].append((a[i][0]-1,-a[i][2]))
INF=float('inf')
dis=[INF]*n
for i in range(n):
if dis[i]==INF:
bfs(i)
print('Yes')
|
p03450
|
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])
def func():
visited = [False for i in range(n)]
x = [None for i in range(n)]
for i in range(n):
if visited[i] == False:
q = [i]
while q:
j = q.pop()
visited[j] = True
if x[j] == None:
x[j] = 0
for k, d in graph[j]:
if visited[k] == False:
q.append(k)
if x[k] == None:
x[k] = x[j] + d
elif x[k] != x[j] + d:
return False
return True
if func():
print('Yes')
else:
print('No')
|
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])
def func():
x = [None for i in range(n)]
for i in range(n):
if x[i] == None:
x[i] = 0
q = [i]
while q:
j = q.pop()
for k, d in graph[j]:
if x[k] == None:
q.append(k)
x[k] = x[j] + d
elif x[k] != x[j] + d:
return False
return True
if func():
print('Yes')
else:
print('No')
|
p03450
|
N,M = list(map(int,input().split()))
info = [list(map(int,input().split())) for i in range(M)]
nodes = [i for i in range(N)]
rank = [0]*N
diff_weight = [0]*N
def root(x):
if nodes[x] == x:
return x
root_x = root(nodes[x])
diff_weight[x] += diff_weight[nodes[x]]
nodes[x] = root_x
return root_x
def weight(x):
root(x)
return diff_weight[x]
def unite(x,y,w):
w += weight(x); w -= weight(y)
x = root(x); y = root(y)
if x == y:
return
if rank[x] >= rank[y]:
nodes[y] = x
diff_weight[y] = w
if rank[x] == rank[y]:
rank[x] += 1
else:
nodes[x] = y
diff_weight[x] = -w
def same(x,y):
return root(x) == root(y)
def diff(x,y):
return weight(y) - weight(x)
ans = "Yes"
for L,R,D in info:
L -= 1; R -= 1
unite(L,R,D)
if diff(L,R) != D:
ans = "No"
break
print(ans)
|
N,M = list(map(int,input().split()))
info = [list(map(int,input().split())) for i in range(M)]
nodes = [-1]*N
diff_weight = [0]*N
def root(x):
if nodes[x] < 0:
return x
root_x = root(nodes[x])
diff_weight[x] += diff_weight[nodes[x]]
nodes[x] = root_x
return root_x
def weight(x):
root(x)
return diff_weight[x]
def unite(x,y,w):
w += weight(x); w -= weight(y)
x = root(x); y = root(y)
if x == y:
return
rank_x = -nodes[x]; rank_y = -nodes[y]
if rank_x >= rank_y:
nodes[y] = x
diff_weight[y] = w
if rank_x == rank_y:
nodes[x] -= 1
else:
nodes[x] = y
diff_weight[x] = -w
def same(x,y):
return root(x) == root(y)
def diff(x,y):
return weight(y) - weight(x)
ans = "Yes"
for L,R,D in info:
L -= 1; R -= 1
unite(L,R,D)
if diff(L,R) != D:
ans = "No"
break
print(ans)
|
p03450
|
N,M = list(map(int,input().split()))
info = [list(map(int,input().split())) for i in range(M)]
nodes = [-1]*N
diff_weight = [0]*N
def root(x):
if nodes[x] < 0:
return x
root_x = root(nodes[x])
diff_weight[x] += diff_weight[nodes[x]]
nodes[x] = root_x
return root_x
def weight(x):
root(x)
return diff_weight[x]
def unite(x,y,w):
w += weight(x); w -= weight(y)
x = root(x); y = root(y)
if x == y:
return
rank_x = -nodes[x]; rank_y = -nodes[y]
if rank_x >= rank_y:
nodes[y] = x
diff_weight[y] = w
if rank_x == rank_y:
nodes[x] -= 1
else:
nodes[x] = y
diff_weight[x] = -w
def same(x,y):
return root(x) == root(y)
def diff(x,y):
return weight(y) - weight(x)
ans = "Yes"
for L,R,D in info:
L -= 1; R -= 1
unite(L,R,D)
if diff(L,R) != D:
ans = "No"
break
print(ans)
|
def prepare(n):
global nodes,diff_weight
# ノードは-1で初期化, Nは頂点数
nodes = [-1]*n
# 差分重みは0で初期化, Nは頂点数
diff_weight = [0]*n
# 差分重みの累積和をとることでxの重みが分かる
def weight(x):
# xの重みを知りたいので経路圧縮
root(x)
return diff_weight[x]
# xからyへの重み
def diff(x,y):
return weight(y) - weight(x)
# x,yの根が同じ->True
def same(x,y):
return root(x) == root(y)
# xの木の高さを返す
def rank(x):
return -nodes[x]
def root(x):
# ノードが負 <=> xは根
if nodes[x] < 0:
return x
else:
# 再帰的に根を調べる
root_x = root(nodes[x])
# 根に近いものから親の重みを足す. これがxを根に直接繋いだ時の重みになる
diff_weight[x] += diff_weight[nodes[x]]
# xを根に直接繋ぎ直す
nodes[x] = root_x
return root_x
def unite(x,y,w):
# 以下x,yの根について考えるので,重みを補正
w += weight(x); w -= weight(y)
x = root(x); y = root(y)
# 根が同じならreturn (自己ループを考慮)
if x == y:
return
rank_x = rank(x); rank_y = rank(y)
# xの方が木が高いことを想定しているのでx,yをスワップ,wを-wに
if rank_x < rank_y:
x,y = y,x; w = -w
# 木の高さが同じ場合は繋いだ後の高さが1だけ高くなる
if rank_x == rank_y:
nodes[x] -= 1
# 低い木の根を高い木の根に繋ぎ直す
nodes[y] = x
# 低い木の根の差分重みを設定
diff_weight[y] = w
N,M = list(map(int,input().split()))
prepare(N)
ans = "Yes"
for _ in range(M):
L,R,D = list(map(int,input().split()))
L -= 1; R -= 1
unite(L,R,D)
if diff(L,R) != D:
ans = "No"
print(ans)
|
p03450
|
class Unionfind:
__slots__ = ["nodes","diff_weight"]
def __init__(self, n):
self.nodes = [-1]*n
self.diff_weight = [0]*n
def root(self, x):
if self.nodes[x] < 0:
return x
else:
root_x = self.root(self.nodes[x])
self.diff_weight[x] += self.diff_weight[self.nodes[x]]
self.nodes[x] = root_x
return root_x
def unite(self, x, y, w=0):
w += self.weight(x); w -= self.weight(y)
x = self.root(x); y = self.root(y)
if x == y:
return
rank_x = -self.nodes[x]; rank_y = -self.nodes[y]
if rank_x < rank_y:
x, y = y, x; w = -w
if rank_x == rank_y:
self.nodes[x] -= 1
self.nodes[y] = x
self.diff_weight[y] = w
def weight(self, x):
self.root(x)
return self.diff_weight[x]
def diff(self, x, y):
return self.weight(y) - self.weight(x)
def same(self, x, y):
return self.root(x) == self.root(y)
def rank(self, x):
return -self.nodes[self.root(x)]
N,M = list(map(int,input().split()))
uf = Unionfind(N)
ans = "Yes"
for _ in range(M):
L, R, D = list(map(int,input().split()))
L -= 1; R -= 1
uf.unite(L, R, D)
if uf.diff(L, R) != D:
ans = "No"
break
print(ans)
|
import sys
input = sys.stdin.readline
class Unionfind:
__slots__ = ["nodes","diff_weight"]
def __init__(self, n):
self.nodes = [-1]*n
self.diff_weight = [0]*n
def root(self, x):
if self.nodes[x] < 0:
return x
else:
root_x = self.root(self.nodes[x])
self.diff_weight[x] += self.diff_weight[self.nodes[x]]
self.nodes[x] = root_x
return root_x
def unite(self, x, y, w=0):
w += self.weight(x); w -= self.weight(y)
x = self.root(x); y = self.root(y)
if x == y:
return
rank_x = -self.nodes[x]; rank_y = -self.nodes[y]
if rank_x < rank_y:
x, y = y, x; w = -w
if rank_x == rank_y:
self.nodes[x] -= 1
self.nodes[y] = x
self.diff_weight[y] = w
def weight(self, x):
self.root(x)
return self.diff_weight[x]
def diff(self, x, y):
return self.weight(y) - self.weight(x)
def same(self, x, y):
return self.root(x) == self.root(y)
def rank(self, x):
return -self.nodes[self.root(x)]
N,M = list(map(int,input().split()))
uf = Unionfind(N)
ans = "Yes"
for _ in range(M):
L, R, D = list(map(int,input().split()))
L -= 1; R -= 1
uf.unite(L, R, D)
if uf.diff(L, R) != D:
ans = "No"
break
print(ans)
|
p03450
|
import sys
input = sys.stdin.readline
class WeightedUnionfind:
__slots__ = ['nodes','diff_weight']
def __init__(self, n):
self.nodes = [-1]*n
self.diff_weight = [0]*n
def root(self, x):
if self.nodes[x] < 0:
return x
else:
root_x = self.root(self.nodes[x])
self.diff_weight[x] += self.diff_weight[self.nodes[x]]
self.nodes[x] = root_x
return root_x
def unite(self, x, y, w=0):
w += self.weight(x); w -= self.weight(y)
x = self.root(x); y = self.root(y)
if x == y:
return
rank_x = -self.nodes[x]; rank_y = -self.nodes[y]
if rank_x < rank_y:
x, y = y, x; w = -w
if rank_x == rank_y:
self.nodes[x] -= 1
self.nodes[y] = x
self.diff_weight[y] = w
def weight(self, x):
self.root(x)
return self.diff_weight[x]
def diff(self, x, y):
return self.weight(y) - self.weight(x)
def same(self, x, y):
return self.root(x) == self.root(y)
def rank(self, x):
return -self.nodes[self.root(x)]
N,M = list(map(int,input().split()))
info = [list(map(int,input().split())) for i in range(M)]
wuf = WeightedUnionfind(N+1)
ans = "Yes"
for L,R,D in info:
if wuf.same(L,R):
if wuf.diff(L,R) != D:
ans = "No"
else:
pass
else:
wuf.unite(L,R,D)
print(ans)
|
import sys
input = sys.stdin.readline
class WeightedUnionfind:
__slots__ = ['nodes','diff_weight']
def __init__(self, n):
self.nodes = [-1]*n
self.diff_weight = [0]*n
def root(self, x):
if self.nodes[x] < 0:
return x
else:
root_x = self.root(self.nodes[x])
self.diff_weight[x] += self.diff_weight[self.nodes[x]]
self.nodes[x] = root_x
return root_x
def unite(self, x, y, w=0):
w += self.weight(x); w -= self.weight(y)
x = self.root(x); y = self.root(y)
if x == y:
return
size_x = -self.nodes[x]; size_y = -self.nodes[y]
if size_x < size_y:
x, y = y, x; w = -w
self.nodes[x] += self.nodes[y]
self.nodes[y] = x
self.diff_weight[y] = w
def weight(self, x):
self.root(x)
return self.diff_weight[x]
def diff(self, x, y):
return self.weight(y) - self.weight(x)
def same(self, x, y):
return self.root(x) == self.root(y)
def size(self, x):
return -self.nodes[self.root(x)]
N,M = list(map(int,input().split()))
wuf = WeightedUnionfind(N)
ans = "Yes"
for _ in range(M):
L,R,D = list(map(int,input().split()))
L -= 1; R -= 1
if not wuf.same(L,R):
wuf.unite(L,R,D)
else:
if wuf.diff(L,R) != D:
ans = "No"
break
print(ans)
|
p03450
|
#PyPy遅え
import sys
sys.setrecursionlimit(400000000)
inf=1000000000000000000
n,m=list(map(int,input().split()))
x=[inf]*n
#まだ訪問してなければTrue
check=[True]*n
#どこと関係があるかを記録する(maybe right)
lrd=[[] for i in range(n)]
for i in range(m):
l,r,d=list(map(int,input().split()))
l-=1
r-=1
lrd[l].append((r,d))
lrd[r].append((l,-d))
#wrong thought
#どっちも決まってない場合の処理
#決まってるとこからやれば良い
#ソートして順番に決めておく
#記録した関係から辿っていく
#まず初めのやつ決定
#非連結な場合を忘れていた
f=False
def bfs(z):
#globalくらいちゃんとしろ
global lrd,check,x,f
if f:return
for i in range(len(lrd[z])):
k=lrd[z][i]
if check[k[0]]:
x[k[0]]=x[z]+k[1]
check[k[0]]=False
bfs(k[0])
else:
if x[k[0]]!=x[z]+k[1]:
f=True
return
st=0
while any(check):
for i in range(st,n):
if len(lrd[i])!=0 and check[i]:
st=i
break
else:
check[i]=False
else:
break
x[st]=0
check[st]=False
bfs(st)
#print(check)
if f:
print("No")
else:
print("Yes")
|
#PyPy遅え
import sys
sys.setrecursionlimit(100000000)
inf=1000000000000000000
n,m=list(map(int,input().split()))
x=[inf]*n
#まだ訪問してなければTrue
check=[True]*n
#どこと関係があるかを記録する(maybe right)
lrd=[[] for i in range(n)]
for i in range(m):
l,r,d=list(map(int,input().split()))
l-=1
r-=1
lrd[l].append((r,d))
lrd[r].append((l,-d))
#wrong thought
#どっちも決まってない場合の処理
#決まってるとこからやれば良い
#ソートして順番に決めておく
#記録した関係から辿っていく
#まず初めのやつ
st=-1
for i in range(n):
if len(lrd[i])>=1:
st=i
break
def bfs(z):
#globalくらいちゃんとしろ
global lrd,check,x
for i in range(len(lrd[z])):
k=lrd[z][i]
if check[k[0]]:
x[k[0]]=x[z]+k[1]
check[k[0]]=False
bfs(k[0])
st=0
while any(check):
for i in range(st,n):
if len(lrd[i])!=0 and check[i]:
st=i
break
else:
check[i]=False
else:
break
x[st]=0
check[st]=False
bfs(st)
for i in range(n):
l=len(lrd[i])
for j in range(l):
k=lrd[i][j]
if x[k[0]]!=x[i]+k[1]:
print("No")
sys.exit()
print("Yes")
|
p03450
|
N, M = list(map(int, input().split()))
e_IN = [[] for _ in range(N+1)]
e_OUT = [[] for _ in range(N+1)]
for _ in range(M):
l, r, d = list(map(int, input().split()))
e_OUT[l].append((r, d))
e_IN[r].append((l, d))
posx = [-1] * (N + 1)
def dfs(v):
# 0<=x<=10**9に注意
node = [v]
posx[v] = 0
diameter = 0
while node:
s = node.pop()
ds = posx[s]
for t, dt in e_OUT[s]:
dist = ds + dt
if posx[t] != -1:
if posx[t] != dist:
return False
else:
continue
posx[t] = dist
node.append(t)
diameter = max(diameter, dist)
if diameter <= 10 ** 9:
return True
else:
return False
ans = "Yes"
for i in range(N + 1):
if len(e_IN[i]) == 0:
posx[i] = 0
bl = dfs(i)
if not bl:
ans = "No"
break
if - 1 in posx:
ans = "No"
print(ans)
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
N, M = list(map(int, readline().split()))
e_IN = [[] for _ in range(N+1)]
e_OUT = [[] for _ in range(N+1)]
for _ in range(M):
l, r, d = list(map(int, readline().split()))
e_OUT[l].append((r, d))
e_IN[r].append((l, d))
posx = [-1] * (N + 1)
def dfs(v):
# 0<=x<=10**9に注意
node = [v]
posx[v] = 0
diameter = 0
while node:
s = node.pop()
ds = posx[s]
for t, dt in e_OUT[s]:
dist = ds + dt
if posx[t] != -1:
if posx[t] != dist:
return False
else:
continue
posx[t] = dist
node.append(t)
diameter = max(diameter, dist)
if diameter <= 10 ** 9:
return True
else:
return False
ans = "Yes"
for i in range(N + 1):
if len(e_IN[i]) == 0:
posx[i] = 0
bl = dfs(i)
if not bl:
ans = "No"
break
if - 1 in posx:
ans = "No"
print(ans)
|
p03450
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
N, M = list(map(int, readline().split()))
e_IN = [[] for _ in range(N+1)]
e_OUT = [[] for _ in range(N+1)]
for _ in range(M):
l, r, d = list(map(int, readline().split()))
e_OUT[l].append((r, d))
e_IN[r].append((l, d))
posx = [-1] * (N + 1)
def dfs(v):
# 0<=x<=10**9に注意
node = [v]
posx[v] = 0
diameter = 0
while node:
s = node.pop()
ds = posx[s]
for t, dt in e_OUT[s]:
dist = ds + dt
if posx[t] != -1:
if posx[t] != dist:
return False
else:
continue
posx[t] = dist
node.append(t)
diameter = max(diameter, dist)
if diameter <= 10 ** 9:
return True
else:
return False
ans = "Yes"
for i in range(N + 1):
if len(e_IN[i]) == 0:
posx[i] = 0
bl = dfs(i)
if not bl:
ans = "No"
break
if - 1 in posx:
ans = "No"
print(ans)
|
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
N, M = list(map(int, input().split()))
edge = [[] for _ in range(N + 1)]
for _ in range(M):
s, t, d = list(map(int, input().split()))
edge[s].append((t, d))
edge[t].append((s, -d))
dist = [None] * (N + 1)
def isOK(v):
node = [v]
if dist[v] is None:
dist[v] = 0
while node:
s = node.pop()
for t, d in edge[s]:
if dist[t] is None:
dist[t] = dist[s] + d
node.append(t)
else:
if dist[t] != dist[s] + d:
return False
return True
ans = "Yes"
for i in range(1, N + 1):
if dist[i] is not None:
continue
if not isOK(i):
ans = "No"
break
print(ans)
|
p03450
|
n, m = list(map(int, input().split()))
inf = 10**10
G = [{} for i in range(n)]
for i in range(m):
l, r, d = list(map(int, input().split()))
G[l-1][r-1] = d
G[r-1][l-1] = -d
V = [False for i in range(n)]
D = [inf for i in range(n)]
for i in range(n):
if V[i]:
continue
Q = [i]
D[i] = 0
while Q:
j = Q.pop()
V[j] = True
for k in list(G[j].keys()):
if not V[k]:
Q.append(k)
if D[k] == inf:
D[k] = D[j]+G[j][k]
elif D[k] != D[j]+G[j][k]:
print('No')
exit()
print('Yes')
|
n, m = list(map(int, input().split()))
inf = 10**10
# G[i][j] = iからjへの距離
G = [{} for i in range(n)]
for i in range(m):
l, r, d = list(map(int, input().split()))
G[l-1][r-1] = d
G[r-1][l-1] = -d
# D[j] = jの属する連結成分のトップからjへの距離
D = [inf for i in range(n)]
# まだ探索していないiをトップとして探索する
for i in range(n):
if D[i] != inf:
continue
Q = [i]
D[i] = 0
while Q:
j = Q.pop()
for k in list(G[j].keys()):
if D[k] == inf:
Q.append(k)
if D[k] == inf:
D[k] = D[j]+G[j][k]
elif D[k] != D[j]+G[j][k]:
print('No')
exit()
print('Yes')
|
p03450
|
import math
n = int(eval(input()))
for i in range(n):
xa, ya, ra, xb, yb, rb = list(map(float, input().split()))
d = math.sqrt((xb - xa) ** 2 + (yb - ya) ** 2)
if d < ra - rb:
print((2))
elif d < rb - ra:
print((-2))
elif abs(rb - ra) <= d and d <= ra + rb:
print((1))
else:
print((0))
|
import math
n = int(eval(input()))
for i in range(n):
xa, ya, ra, xb, yb, rb = list(map(float, input().split()))
d = math.sqrt((xb - xa) ** 2 + (yb - ya) ** 2)
if d < ra - rb:
print((2))
elif d < rb - ra:
print((-2))
elif d <= ra + rb:
print((1))
else:
print((0))
|
p00023
|
A, B, C, D, E, F = list(map(int, input().split()))
c = []
ans_list = []
for i in range(1, F // (100 * A) + 1):
for j in range(F // (100 * B) + 1):
a = 100 * A * i + 100 * B * j
if a > F:
break
for k in range((F - a) // C + 1):
for l in range((F - a) // D + 1):
b = k * C + l * D
if (A * i + B * j) * E >= b and a + b <= F:
c.append(100 * b / (a + b))
ans_list.append([a + b, b])
else:
break
ans = ans_list[c.index(max(c))]
print((' '.join(map(str, ans))))
|
A, B, C, D, E, F = list(map(int, input().split()))
ans = [100 * A, 0]
c = 0
for i in range(1, F // (100 * A) + 1):
for j in range(F // (100 * B) + 1):
a = 100 * A * i + 100 * B * j
if a > F:
break
for k in range((F - a) // C + 1):
for l in range((F - a) // D + 1):
b = k * C + l * D
concentration = 100 * b / (a + b)
if (A * i + B * j) * E >= b and a + b <= F:
if concentration > c:
c = concentration
ans = [a + b, b]
else:
break
print((' '.join(map(str, ans))))
|
p03599
|
A, B, C, D, E, F = list(map(int, input().split()))
ans = [100 * A, 0]
c = 0
for i in range(1, F // (100 * A) + 1):
for j in range((F - 100 * A * i) // (100 * B) + 1):
a = 100 * A * i + 100 * B * j
if a > F:
break
for k in range((F - a) // C + 1):
for l in range((F - a - C * k) // D + 1):
b = k * C + l * D
concentration = 100 * b / (a + b)
if (A * i + B * j) * E >= b and a + b <= F:
if concentration > c:
c = concentration
ans = [a + b, b]
else:
break
print((' '.join(map(str, ans))))
|
A, B, C, D, E, F = list(map(int, input().split()))
ans = [100 * A, 0]
c = 0
for i in range(1, F // (100 * A) + 1):
for j in range((F - 100 * A * i) // (100 * B) + 1):
a = 100 * A * i + 100 * B * j
for k in range((F - a) // C + 1):
for l in range((F - a - C * k) // D + 1):
b = k * C + l * D
concentration = 100 * b / (a + b)
if (A * i + B * j) * E >= b:
if concentration > c:
c = concentration
ans = [a + b, b]
else:
break
print((' '.join(map(str, ans))))
|
p03599
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.