input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
N = int(eval(input()))
I = [[int(i) for i in input().split()] for j in range(N)]
current, time = (0, 0), 0
for i in range(N):
dist = abs(current[0] - I[i][1]) + abs(current[1] - I[i][2])
if dist > I[i][0] - time or (I[i][0]- time - dist) % 2 == 1:
print("No")
break
current, time = (I[i][1], I[i][2]), I[i][0]
else:
print("Yes") | import sys
def solve():
N = int(eval(input()))
cx, cy = 0, 0
nt = 0
for _ in range(N):
t, x, y = list(map(int, input().split()))
rem = t - nt - abs(x - cx) - abs(y - cy)
if rem < 0 or rem % 2 > 0:
print("No")
break
cx, cy = x, y
nt = t
else: print("Yes")
return 0
if __name__ == "__main__":
solve() | p03457 |
# -*- coding: utf-8 -*-
def compare(x):
return x[0]
def find(x, lst):
for value in lst:
if value[0] == x:
return True
return False
n = int(input())
lst = [[0, 0, 0]]
for i in range(n):
lst.append(list(map(int, input().split())))
lst.sort(key=compare)
x = lst[len(lst) - 1][0]
for i in range(1, x):
if not find(i, lst):
lst.append([i, -1, -1])
lst.sort(key=compare)
points = [[0, 0]]
flg = False
try:
for i in range(1, x + 1):
fix = False
wk = []
for point in points:
wk.append((point[0] + 1, point[1]))
wk.append((point[0] - 1, point[1]))
wk.append((point[0], point[1] + 1))
wk.append((point[0], point[1] - 1))
wk = list(set(wk))
ps = (lst[i][1], lst[i][2])
x = point[0]
y = point[1]
if (i == lst[i][0]) and (x >= 0) and (y >= 0) and ((x + 1, y) == ps or (x - 1, y) == ps or (x, y + 1) == ps or (x, y - 1) == ps):
flg = True
wk = [ps]
break
points = list(set(wk))
if (i == lst[i][0]) and (lst[i][1] >= 0) and (not flg):
break
finally:
print('Yes') if flg else print('No')
| # -*- coding: utf-8 -*-
n = int(input())
points = []
for i in range(n):
points.append(list(map(int, input().split())))
flg = False
for point in points:
flg = (point[0] >= (point[1] + point[2])) and ((point[0] % 2 == 1) and ((point[1] + point[2]) % 2 == 1) or (point[0] % 2 == 0) and ((point[1] + point[2]) % 2 == 0))
if not flg:
break
print('Yes') if flg else print('No')
| p03457 |
import sys
can = True; eval(input())
e = [[0, 0, 0]] + [list(map(int, e.split())) for e in sys.stdin]
for a, b in zip(e[1:], e):
t = a[0] - b[0] - abs(a[1] - b[1]) - abs(a[2] - b[2])
if t < 0 or t % 2 == 1: can = False; break
print((['No', 'Yes'][can])) | import sys
ans = 'Yes'; eval(input())
for e in sys.stdin:
t, x, y = list(map(int, e.split()))
t = t - x - y
if t < 0 or t % 2 == 1: ans = 'No'; break
print(ans) | p03457 |
N = int(eval(input()))
T = 0
X = 0
Y = 0
ans = 'Yes'
for i in range(N):
t, x, y = list(map(int, input().split()))
if abs(X-x)+abs(Y-y)>abs(T-t) or (((X-x)+(Y-y))-(T - t))%2==1:
ans = 'No'
else:
T = t
X = x
Y = y
print(ans) | N = int(eval(input()))
xc, yc, tc = 0, 0, 0
ans = 'Yes'
for i in range(N):
t, x, y = list(map(int, input().split()))
if (t - tc - abs(x-xc) - abs(y-yc)) % 2 == 0 and t - tc - abs(x-xc) - abs(y-yc) >= 0:
xc, yc, tc = x, y, t
else:
ans = 'No'
break
print(ans)
| p03457 |
N = int(eval(input()))
txys = [list(map(int, input().split())) for _ in range(N) ]
txys.insert(0, [0, 0, 0])
for i in range(N):
t1, x1, y1 = txys[i]
t2, x2, y2 = txys[i+1]
dt = t2 - t1
tIsEven = dt % 2 == 0
dist = abs(x1 - x2) + abs(y1 - y2)
xyIsEven = dist % 2 == 0
if tIsEven != xyIsEven or dist > dt:
print("No")
exit()
print("Yes")
| N = int(eval(input()))
txys = [list(map(int, input().split())) for _ in range(N) ]
txys.insert(0, [0, 0, 0])
for i in range(N):
t1, x1, y1 = txys[i]
t2, x2, y2 = txys[i+1]
dt = t2 - t1
dist = abs(x1 - x2) + abs(y1 - y2)
if dt % 2 != dist % 2 or dist > dt:
print("No")
exit()
print("Yes")
| p03457 |
n = int(eval(input()))
l = []
for i in range(n):
t,x,y = list(map(int,input().split()))
l.append([t,x,y])
for i in range(n):
t,x,y = l[i][0],l[i][1],l[i][2]
if x+y > t or (t-(x+y))%2 != 0:
print('No')
exit()
l.sort()
for i in range(n-1):
t,x,y = l[i][0],l[i][1],l[i][2]
t_,x_,y_ = l[i+1][0],l[i+1][1],l[i+1][2]
if t_ - t < (abs(x-x_)+abs(y-y_)):
print('No')
exit()
print('Yes') | n = int(eval(input()))
l = [[0,0,0]]
for i in range(n):
t,x,y = list(map(int,input().split()))
l.append([t,x,y])
for i in range(n):
t,x,y = l[i][0],l[i][1],l[i][2]
t_,x_,y_ = l[i+1][0],l[i+1][1],l[i+1][2]
if t_ - t < (abs(x-x_)+abs(y-y_)) or (t_-t-(abs(x-x_)+abs(y-y_)))%2 != 0:
print('No')
exit()
print('Yes') | p03457 |
def dist(x,y):
return abs(x[0]-y[0])+abs(x[1]-y[1])
N = int(eval(input()))
X = [list(map(int,input().split())) for _ in range(N)]
flag = 0
t1,x1,y1 = 0,0,0
for i in range(N):
t2,x2,y2 = X[i]
d = dist((x1,y1),(x2,y2))
dt = t2-t1
if dt>=d and (dt-d)%2==0:
t1,x1,y1 = X[i]
else:
flag=1
break
if flag==0:
print("Yes")
else:
print("No") | def dist(x,y):
return abs(x[0]-y[0])+abs(x[1]-y[1])
N = int(eval(input()))
X = [list(map(int,input().split())) for _ in range(N)]
flag = 0
t1 = 0
x1,y1 = 0,0
for i in range(N):
t2,x2,y2 = X[i]
dt = t2-t1
d = dist((x1,y1),(x2,y2))
if dt>=d and (dt-d)%2==0:
t1,x1,y1 = t2,x2,y2
continue
flag = 1
break
if flag==0:
print("Yes")
else:
print("No") | p03457 |
N = int(eval(input()))
t = [0] * (N+1)
x = [0] * (N+1)
y = [0] * (N+1)
for i in range(N):
t[i+1], x[i+1], y[i+1] = list(map(int, input().split()))
f = True
for i in range(N):
dt = t[i+1] - t[i]
dist = abs(x[i+1]-x[i]) + abs(y[i+1]-y[i])
if dt < dist:
f = False
if dist%2 != dt%2:
f = False
print(('Yes' if f else 'No')) | n = int(eval(input()))
for i in range(n):
t,x,y=list(map(int,input().split()))
if (x + y) > t or (x + y + t) % 2:
print("No")
exit()
print("Yes")
| p03457 |
n = int(eval(input()))
x = 0
y = 0
time = 0
for i in range(n):
m = list(map(int,input().split()))
if (m[0]-time)>=abs(m[1]-x)+abs(m[2]-y):
if ((m[0]-time) -(abs(m[1]-x) + abs(m[2]-y)))%2 ==0:
x = m[1]
y = m[2]
time = m[0]
if i == n-1:
print("Yes")
else:
print("No")
break
else:
print("No")
break | a = int(eval(input()))
x = 0
y = 0
time = 0
for i in range(a):
aa,b,c = list(map(int,input().split()))
if (abs(b-x) + abs(c-y)) %2 == (aa - time)%2 and abs(b-x) + abs(c-y) <= aa - time:
x = b
y = c
time = aa
else:
print("No")
break
if i == a-1:
print("Yes") | p03457 |
n,*l=list(map(int,open(0).read().split()));print(("YNeos"[any((i+j+k)%2+(i<j+k)for i,j,k in zip(*[iter([abs(i-j)for i,j in zip([0,0,0]+l,l)])]*3))::2])) | _,*l=list(map(int,open(0).read().split()));print(("YNeos"[any((t+x+y)%2+(t<x+y)for t,x,y in zip(*[iter(l)]*3))::2])) | p03457 |
class Coodinate (object):
"""Coodinate object
This class contains infomation about the coodinates.
Each instance can have up to 3-dimensional(x,y,z) space coodinates.
params
------------------------------
x : int or floot ,default 0
y : int or floot ,default 0
z : int or floot ,default 0
This class have following methods.
------------------------------
distance : Calculate the straight-line distance between 2 points in Euclidean space.
midpoint : Calculate the midpoint(halfway) between 2 points.
manhattan_distance : Calculate the distance between 2 points that is sum of the absolute values their Cartesian coordinates.
"""
def __init__(self,x=0,y=0,z=0):
self.x=x
self.y=y
self.z=z
def __str__(self):
if self.z==0:
if self.y==0:
return "( {} )".format(self.x)
else :
return "( {} , {} )".format(self.x,self.y)
else:
return "( {} , {} , {} )".format(self.x,self.y,self.z)
def distance(self,other):
"""Calculate the straight-line distance between 2 points in Euclidean space.
params
----------
self : Coodinate object
other : Coodinate object
return
----------
distance : floot
"""
x_diff_sq=(self.x-other.x)**2
y_diff_sq=(self.y-other.y)**2
z_diff_sq=(self.z-other.z)**2
return (x_diff_sq + y_diff_sq +z_diff_sq)**0.5
def midpoint(self,other):
"""Calculate the midpoint(halfway) between 2 points.
params
----------
self : Coodinate object
other : Coodinate object
return
----------
midpoint : tupul
"""
x_midpoint=(self.x+other.x)/2
y_midpoint=(self.y+other.y)/2
z_midpoint=(self.z+other.z)/2
if self.z == other.z ==0 :
if self.y == other.y==0:
return(x_midpoint)
else:
return(x_midpoint,y_midpoint)
return(x_midpoint,y_midpoint,z_midpoint)
def manhattan_distance(self,other):
"""Calculate the distance between 2 points that is sum of the absolute values their Cartesian coordinates.
params
----------
self : Coodinate object
other : Coodinate object
return
----------
manhattan_distance : floot
"""
x_diff_abs=abs(self.x - other.x)
y_diff_abs=abs(self.y - other.y)
z_diff_abs=abs(self.z - other.z)
return(x_diff_abs + y_diff_abs + z_diff_abs)
# AtCoder Beginner Contest 086
# C - Traveling
N=int(eval(input()))
T=0
now=Coodinate()
for i in range (N):
t, x, y =list(map(int,input().split()))
time =t-T
location = Coodinate(x,y)
destination = Coodinate.manhattan_distance(location,now)
if time >= destination and time%2==destination%2:
T=t
now=location
else :
print("No")
exit()
print("Yes") | # AtCoder Beginner Contest 086
# C - Traveling
N=int(eval(input()))
T=0
X,Y=0,0
for i in range (N):
t, x, y =list(map(int,input().split()))
time =t-T
distance=abs((x+y)-(X+Y))
if time >= distance and time%2==distance%2:
T=t
X,Y=x,y
else :
print("No")
exit()
print("Yes") | p03457 |
N = int(eval(input()))
All = [list(map(int, input().split())) for _ in range(N)]
t = [row[0] for row in All]
x = [row[1] for row in All]
y = [row[2] for row in All]
pre_x = 0
pre_y = 0
pre_t = 0
can = True
for n in range(N):
can2 = False
T = abs(t[n] - pre_t)
dx = abs(x[n] - pre_x)
dy = abs(y[n] - pre_y)
# print(T,dx,dy)
if dx + dy == 0 and T % 2 == 0:
can2 = True
# print("成功")
elif dx + dy == 0 and T % 2 != 0:
can2 = False
# print("失敗")
break
if (T % (dx + dy)) == 0:
can2 = True
# print("成功")
if can2 == False:
can = False
# print("失敗")
break
pre_t = t[n]
pre_x = x[n]
pre_y = y[n]
if can == True:
print("Yes")
else:
print("No")
| N = int(eval(input()))
All = [list(map(int, input().split())) for _ in range(N)]
pre_x = 0
pre_y = 0
pre_t = 0
can = True
for n in range(N):
can2 = False
T = All[n][0] - pre_t
d = abs(All[n][1] - pre_x) + abs(All[n][2] - pre_y)
# print(T, d)
if d <= T and T % 2 == d % 2:
can2 = True
if can2 == False:
can = False
break
pre_t = All[n][0]
pre_x = All[n][1]
pre_y = All[n][2]
if can == True:
print("Yes")
else:
print("No") | p03457 |
N=int(eval(input()))
T=[list(map(int,input().split())) for i in range(N)]
for i in range(N):
t=T[i][0]
j=T[i][1]+T[i][2]
if t<j or (t+j)%2:
print("No")
exit()
print("Yes") | N=int(eval(input()))
for i in range(N):
t,x,y=list(map(int, input().split()))
j=x+y
if t<j or (t+j)%2:
print("No")
exit()
print("Yes") | p03457 |
#入力受け取り
n = int(eval(input()))
tourList = []
for i in range(n):
array = list(map(int, input().strip().split()))
tourList.append(array)
#DebugPrint
currentTime = 0
currentX = 0
currentY = 0
loop=0
for i in range(len(tourList)) :
Time = tourList[i][0]
X = tourList[i][1]
Y = tourList[i][2]
Time = Time - currentTime
X = X - currentX
Y = Y - currentY
flag=False
Z=0 #往復調整用
while (X+Y+Z) <= Time :
if X+Y+Z == Time:
flag=True
break
else:
Z+=2
#継続判定
if flag == False:
print("No")
exit()
currentTime = Time
currentX = X
currentY = Y
print("Yes")
#最初の点がまず実現可能か
|
#入力受け取り
n = int(eval(input()))
tourList = []
for i in range(n):
array = list(map(int, input().strip().split()))
tourList.append(array)
#DebugPrint
currentTime = 0
currentX = 0
currentY = 0
for i in range(len(tourList)) :
Time = tourList[i][0]
X = tourList[i][1]
Y = tourList[i][2]
Time = Time - currentTime
X = X - currentX
Y = Y - currentY
flag=False
NUM = abs(X)+abs(Y)
if( (Time-NUM)%2==0 and NUM <= Time):
flag=True
# while (X+Y+Z) <= Time :
# if X+Y+Z == Time:
# flag=True
# break
# else:
# Z+=2
#継続判定
if flag == False:
print("No")
exit()
currentTime = Time
currentX = X
currentY = Y
print("Yes")
#最初の点がまず実現可能か
| p03457 |
import unittest
def is_ある時刻での判定(t, d):
# 時刻t >= d でないと実現不可能
if t < d:
return True
# 偶奇が一致しないと実現不可能
if not (t % 2 == d % 2):
return True
return False
def can_not_realize(N, t_list, x_list, y_list) -> bool:
# 各時刻ごとの判定
for t, x, y in zip(t_list, x_list, y_list):
d = x + y
if is_ある時刻での判定(t, d):
return True
# t_n と t_n+1 間 での移動判定
for i in range(N):
if i + 1 >= N:
break
t = t_list[i + 1] - t_list[i]
diff_x = abs(x_list[i + 1] - x_list[i])
diff_y = abs(y_list[i + 1] - y_list[i])
d = diff_x + diff_y
if is_ある時刻での判定(t, d):
return True
return False
def actual(N, t_list, x_list, y_list):
if can_not_realize(N, t_list, x_list, y_list):
return 'No'
return 'Yes'
N = int(eval(input()))
t_list, x_list, y_list = [], [], []
for _ in range(N):
t, x, y = list(map(int, input().split()))
t_list.append(t)
x_list.append(x)
y_list.append(y)
print((actual(N, t_list, x_list, y_list)))
| def can_not_realize(N, t_list, x_list, y_list) -> bool:
# t_n と t_n+1 間 での移動判定
for i in range(N):
diff_t = t_list[i + 1] - t_list[i]
diff_x = abs(x_list[i + 1] - x_list[i])
diff_y = abs(y_list[i + 1] - y_list[i])
sum_of_moving = diff_x + diff_y
# 時刻t >= sum_of_moving でないと実現不可能
if diff_t < sum_of_moving:
return True
# 偶奇が一致しないと実現不可能
if not (diff_t % 2 == sum_of_moving % 2):
return True
return False
def actual(N, t_list, x_list, y_list):
# t=0 で (0,0) を追加する
t_list = [0] + t_list
x_list = [0] + x_list
y_list = [0] + y_list
if can_not_realize(N, t_list, x_list, y_list):
return 'No'
return 'Yes'
N = int(eval(input()))
t_list, x_list, y_list = [], [], []
for _ in range(N):
t, x, y = list(map(int, input().split()))
t_list.append(t)
x_list.append(x)
y_list.append(y)
print((actual(N, t_list, x_list, y_list))) | p03457 |
n=int(eval(input()))
nowx, nowy, nowt = 0, 0, 0
for i in range(n):
t,x,y = list(map(int,input().split()))
k = t-nowt-abs(nowx-x)-abs(nowy-y)
if k >= 0 and k % 2 == 0:
nowx, nowy, nowt = x, y, t
else:
print("No")
exit()
print("Yes")
| n = int(eval(input()))
t = 0
x = 0
y = 0
for _ in range(n):
nt, nx, ny = list(map(int,input().split()))
sa = nt-t
t = nt
kyori = abs(nx-x) + abs(ny-y)
x = nx
y = ny
if kyori > sa or (sa-kyori) % 2 == 1:
print("No")
exit()
print("Yes") | p03457 |
def is_reachable(dept, dest):
distance = abs(dest[1] - dept[1]) + abs(dest[2] - dept[2])
time = dest[0] - dept[0]
if (time - distance >= 0) and ((time - distance) % 2 == 0):
return True
else:
return False
N = int(eval(input()))
itin = [(0, 0, 0)]
itin_append = itin.append
for n in range(N):
itin_append(tuple(map(int, input().split())))
for n in range(N):
if is_reachable(itin[n], itin[n + 1]):
continue
else:
print('No')
break
else:
print('Yes')
| import sys
N = int(eval(input()))
t, x, y = 0, 0, 0
ans = 'No'
for s in sys.stdin.readlines():
nt, nx, ny = list(map(int, s.split()))
T = nt - t
D = abs(nx - x) + abs(ny - y)
if T < D or T % 2 != D % 2:
break
t, x, y = nt, nx, ny
else:
ans = 'Yes'
print(ans)
| p03457 |
n = int(eval(input()))
points = []
for i in range(n):
points.append(list(map(int, input().split(" "))))
t_pre, x_pre, y_pre = 0, 0, 0
reachable = True
for point in points:
t, x, y = list(map(int, point))
diff_t = t - t_pre
p = x + y
p_pre = x_pre + y_pre
move = 0
for _ in range(diff_t):
move += 1 if p > (p_pre + move) else -1
if p - p_pre != move:
reachable = False
break
t_pre, x_pre, y_pre = t, x, y
print(("Yes" if reachable == True else "No")) | n = int(eval(input()))
t = [0]
x = [0]
y = [0]
for _ in range(n):
t_tmp, x_tmp, y_tmp = list(map(int, input().split(" ")))
t.append(t_tmp)
x.append(x_tmp)
y.append(y_tmp)
reachable = True
for j in range(1, n + 1):
dt = t[j] - t[j - 1]
dist = abs(x[j] - x[j - 1]) + abs(y[j] - y[j - 1])
if dt < dist or dist % 2 != dt % 2:
reachable = False
print(("Yes" if reachable == True else "No"))
| p03457 |
# coding: utf-8
import math
n = int(eval(input()))
t = 0
x = 0
y = 0
txy = []
for i in range(n):
ti, xi, yi = list(map(int, input().split()))
txy.append((ti, xi, yi))
for ti, xi, yi in txy:
if abs(xi - x) + abs(yi - y) > abs(ti - t):
print("No")
exit()
elif (abs(xi - x) + abs(yi - y) - abs(ti - t)) % 2 != 0:
print("No")
exit()
else:
t = ti
x = xi
y = yi
print("Yes")
| # coding: utf-8
import math
n = int(eval(input()))
t = 0
x = 0
y = 0
# txy = []
# for i in range(n):
# ti, xi, yi = list(map(int, input().split()))
# txy.append((ti, xi, yi))
for i in range(n):
ti, xi, yi = list(map(int, input().split()))
if abs(xi - x) + abs(yi - y) > abs(ti - t):
print("No")
exit()
elif (abs(xi - x) + abs(yi - y) - abs(ti - t)) % 2 != 0:
print("No")
exit()
else:
t = ti
x = xi
y = yi
print("Yes")
| p03457 |
N = int(eval(input()))
TXY = [tuple(map(int,input().split())) for i in range(N)]
ct = cx = cy = 0
for t,x,y in TXY:
dt = t-ct
d = abs(cx-x)+abs(cy-y)
if dt < d or dt%2 != d%2:
print('No')
exit()
ct,cx,cy = t,x,y
print('Yes') | N = int(eval(input()))
TXY = [tuple(map(int,input().split())) for i in range(N)]
ct = cx = cy = 0
for t,x,y in TXY:
d = abs(cx-x) + abs(cy-y)
if d > t-ct or d%2 != (t-ct)%2:
print('No')
exit()
ct,cx,cy = t,x,y
print('Yes') | p03457 |
def validation(l1, l2):
dif_t = abs(l2[0] - l1[0])
dif_x = abs(l2[1] - l1[1])
dif_y = l2[2] - l1[2]
if dif_x + dif_y > dif_t:
return False
elif dif_t % 2 == 0:
if (dif_x + dif_y) % 2 != 0:
return False
else:
return True
elif dif_t % 2 != 0:
if (dif_x + dif_y) % 2 == 0:
return False
return True
else:
return True
n = int(eval(input()))
l1 = [0,0,0]
ans = "Yes"
for _ in range(n):
l2 = list(map(int, input().split()))
if validation(l1, l2):
l1 = l2
else:
ans = "No"
print(ans) | n = int(eval(input()))
current_time = 0
current_pos = 0
ans = True
for _ in range(n):
t, x, y = list(map(int, input().split()))
time_dif = t - current_time # 3
pos_dif = (x+y) - current_pos # 3
if time_dif % 2 == 1 and pos_dif % 2 == 1 and pos_dif <= time_dif:
current_time += time_dif
current_pos += pos_dif
elif time_dif % 2 == 0 and pos_dif % 2 == 0 and pos_dif <= time_dif:
current_time += time_dif
current_pos += pos_dif
else:
ans = False
if ans:
print("Yes")
else:
print("No")
| p03457 |
from sys import stdin
input = stdin.readline
N = int(eval(input()))
txy = [[int(j) for j in input().split()] for i in range(N)]
def main():
pt = 0
px = 0
py = 0
flg = False
for t, x, y in txy:
# 到達 あるいは 通過
if abs(x - px) + abs(y - py) <= t - pt:
# 距離と時間の偶奇が一致しない 戻れない
if (abs(x - px) + abs(y - py)) % 2 != (t - pt) % 2:
break
else:
pt = t
px = x
py = y
# 到達しない
else:
break
else:
# break しなかった 完走
flg = True
print(("Yes" if flg else "No"))
return
main()
| from sys import stdin
input = stdin.readline
N = int(eval(input()))
txy = [[int(j) for j in input().split()] for i in range(N)]
def main():
pt = 0
px = 0
py = 0
flg = False
for t, x, y in txy:
d = abs(x - px) + abs(y - py)
dt = t - pt
# 到達 あるいは 通過
if d <= dt:
# 距離と時間の偶奇が一致しない 戻れない
if d % 2 != dt % 2:
break
else:
pt = t
px = x
py = y
# 到達しない
else:
break
else:
# break しなかった 完走
flg = True
print(("Yes" if flg else "No"))
return
main()
| p03457 |
from sys import stdin
input = stdin.readline
N = int(eval(input()))
txy = [[int(j) for j in input().split()] for i in range(N)]
def main():
pt = 0
px = 0
py = 0
flg = False
for t, x, y in txy:
dt = t - pt - abs(x - px) - abs(y - py)
# 余った時間が奇数 戻れない
if dt < 0 or dt % 2 == 1:
break
pt = t
px = x
py = y
else:
# break しなかった 完走
flg = True
print(("Yes" if flg else "No"))
return
main()
| from sys import stdin
input = stdin.readline
lines = stdin.readlines
N = int(eval(input()))
txy = ((list(map(int, line.split()))) for line in lines())
def main():
pt = 0
px = 0
py = 0
flg = False
for t, x, y in txy:
dt = t - pt - abs(x - px) - abs(y - py)
# 余った時間が奇数 戻れない
if dt < 0 or dt % 2 == 1:
break
pt = t
px = x
py = y
else:
# break しなかった 完走
flg = True
print(("Yes" if flg else "No"))
return
main()
| p03457 |
N = int(eval(input()))
t,x,y = 0,0,0
for i in range(N):
T,X,Y = list(map(int,input().split()))
d = abs(x-X)+abs(y-Y)
if (T-t)-d >= 0 and ((T-t)-d)%2 == 0:
t,x,y = T,X,Y
continue
else:
print('No')
exit()
print('Yes') | import sys
input = sys.stdin.readline
N = int(eval(input()))
t,x,y = 0,0,0
for i in range(N):
T,X,Y = list(map(int,input().split()))
d = abs(x-X)+abs(y-Y)
if (T-t)-d >= 0 and ((T-t)-d)%2 == 0:
t,x,y = T,X,Y
continue
else:
print('No')
exit()
print('Yes') | p03457 |
n = int(eval(input()))
TXY = [[0,0,0]] + [list(map(int, input().split())) for _ in range(n)]
diff = [[t2 - t1, abs(x2 - x1), abs(y2 - y1)] for (t1, x1, y1), (t2, x2, y2) in zip(TXY, TXY[1:])]
for t, x, y in diff:
if x + y > t or (t - (x + y)) % 2 == 1:
print("No")
exit()
print("Yes") | n = int(eval(input()))
TXY = [[0,0,0]] + [list(map(int, input().split())) for _ in range(n)]
diff = [[t2 - t1, abs(x2 - x1), abs(y2 - y1)] for (t1, x1, y1), (t2, x2, y2) in zip(TXY, TXY[1:])]
if all([x + y <= t and (t - (x + y)) % 2 == 0 for t, x, y in diff]):
print("Yes")
else:
print("No") | p03457 |
r = 1
t = 0
m = 0
N = int(eval(input()))
txy = []
for i in range(N):
txy.append([int(x) for x in input().split()])
for i in txy:
t = i[0] - t
m = abs((i[1] + i[2]) - m)
if i[0] % 2 == 0:
if (i[1] + i[2]) % 2 != 0:
print("No")
break
elif t < m:
print("No")
break
else:
if (i[1] + i[2]) % 2 != 1:
print("No")
break
elif t < m:
print("No")
break
if r == N and t >= m:
print("Yes")
r += 1
|
r = 1
t = 0
m = 0
N = int(eval(input()))
txy = []
for i in range(N):
txy.append([int(x) for x in input().split()])
for i in txy:
t = i[0] - t
m = abs((i[1] + i[2]) - m)
if t < m:
print("No")
break
elif (t - m) % 2 != 0:
print("No")
break
if r == N and t >= m:
print("Yes")
r += 1
| p03457 |
import sys
default_x = 0
default_y = 0
n = int(eval(input()))
a = []
#標準入力をN分読み込み
for i in range(n):
a.append(list(map(int,input().split())))
times = 0
for i in range(n):
for j in range(a[i][0]+times):
if default_x < a[i][1]:
default_x += 1
elif default_x > a[i][1]:
default_x -= 1
elif default_y < a[i][2]:
default_y += 1
elif default_y > a[i][2]:
default_y -= 1
else:
default_y -= 1
if default_x != a[i][1] or default_y != a[i][2]:
print('No')
sys.exit()
times = a[i][0]
print('Yes') | n = int(eval(input()))
travel = list()
#start point
travel.append((0,0,0))
for i in range(n):
travel.append(tuple(map(int,input().split())))
for j in range(n):
dist = abs(travel[j][0]-travel[j+1][0])
dd = abs(travel[j][1]-travel[j+1][1])+abs(travel[j][2]-travel[j+1][2])
#fail
if dist < dd or (dd%2 != dist%2):
print("No")
exit(0)
print("Yes")
| p03457 |
import sys
N = int(sys.stdin.readline())
TXY = [
tuple(map(int, sys.stdin.readline().split())) for _ in range(N)
]
def check(st, sx, sy, et, ex, ey):
if abs(sx - ex) + abs(sy - ey) > et - st:
return False
points = [(sx, sy)]
for _ in range(et - st):
new_points = set()
for px, py in points:
new_points.add((px + 1, py))
new_points.add((px - 1, py))
new_points.add((px, py + 1))
new_points.add((px, py - 1))
points = list(new_points)
if (ex, ey) in points:
return True
return False
def main():
TXY.insert(0, (0, 0, 0))
for i in range(len(TXY) - 1):
args = TXY[i] + TXY[i + 1]
if not check(*args):
print('No')
return
print('Yes')
main() | import sys
N = int(sys.stdin.readline())
TXY = [
tuple(map(int, sys.stdin.readline().split())) for _ in range(N)
]
def check(st, sx, sy, et, ex, ey):
timespan = et - st
diff = abs(sx - ex) + abs(sy - ey)
if diff > timespan:
return False
if (timespan - diff) % 2 == 0:
return True
return False
def main():
TXY.insert(0, (0, 0, 0))
for i in range(len(TXY) - 1):
args = TXY[i] + TXY[i + 1]
if not check(*args):
print('No')
return
print('Yes')
main() | p03457 |
n = int(eval(input()))
a0 = [0,0,0]
ans = "Yes"
for i in range(n):
ai = list(map(int,input().split()))
t = ai[0] - a0[0]
d = abs(ai[1] - a0[1])+ abs(ai[2] - a0[2])
if t < d or t%2 != d%2:
ans = "No"
a0 = ai
print(ans) | n = int(eval(input()))
t0,x0,y0 = 0,0,0
for i in range(n):
t,x,y = list(map(int, input().split()))
if abs(t0-t)%2 != (abs(x0-x)+abs(y0-y))%2 or (abs(x0-x)+abs(y0-y)) > abs(t0-t):
print("No")
exit()
t0,x0,y0, = t,x,y
else:
print("Yes") | p03457 |
N=int(eval(input()))
txy=[list(map(int,input().split())) for i in range(N)]
ans=0
for i in range(N):
t,x,y=txy[i][0],txy[i][1],txy[i][2]
if x+y<=t and t%2==(x+y)%2:ans+=1
print(("Yes" if ans==N else "No")) | n = int(eval(input()))
txy = [list(map(int, input().split())) for _ in range(n)]
for i in range(n):
t, x, y = txy[i]
if x + y > t or (t - x - y) % 2:
print("No")
exit()
print("Yes")
| p03457 |
def difference(two_lists):
return [abs(two_lists[1][i] - two_lists[0][i]) for i in range(3)]
n = int(eval(input()))
txy = [[0, 0, 0]] + [list(map(int, input().split())) for _ in range(n)]
dtxy = list(map(difference, list(zip(txy, txy[1:]))))
for i in range(n):
dt, dx, dy = dtxy[i]
if dx + dy > dt or (dt - dx - dy) % 2:
print("No")
exit()
print("Yes") | n = int(eval(input()))
for _ in range(n):
t, x, y = list(map(int, input().split()))
if x + y > t or (t - x - y) % 2:
print("No")
exit()
print("Yes") | p03457 |
n = int(eval(input()))
pretime, prex, prey = 0, 0, 0
for i in range(n):
nowtime, nowx, nowy = list(map(int, input().split()))
time = nowtime - pretime
x = abs(nowx - prex)
y = abs(nowy - prey)
if x+y > time:
print("No")
exit()
if (x+y) % 2 != time % 2:
print("No")
exit()
pretime = nowtime
prex, prey = nowx, nowy
else:
print("Yes") | n = int(eval(input()))
for i in range(n):
t,x,y=list(map(int,input().split()))
if(not((x+y)<=t and (x+y)%2 == t%2)):
print("No")
exit()
print("Yes") | p03457 |
n=int(eval(input()))
t,x,y=[0],[0],[0]
for i in range(n):
T,X,Y=list(map(int,input().split()))
t.append(T)
x.append(X)
y.append(Y)
#print(t,x,y)
for i in range(n):
time=t[i+1]-t[i]
dx=abs(x[i+1]-x[i])
dy=abs(y[i+1]-y[i])
if time<dx+dy or (time+dx+dy)%2!=0:
print('No')
exit()
print('Yes') | n=int(eval(input()))
t,x,y=[],[],[]
for i in range(n):
a,b,c=list(map(int,input().split()))
t.append(a)
x.append(b)
y.append(c)
current=[0,0]
for i in range(n):
next=[x[i]-current[0],y[i]-current[1]]
if abs(sum(next))>t[i] or (abs(sum(next))+t[i])%2!=0:
print('No')
exit()
print('Yes') | p03457 |
N = int(eval(input()))
D = [input().split() for i in range(N)]
DD = []
for i in range(N):
DD.append([int(D[i][0]),int(D[i][1]),int(D[i][2])])
diff = [[0,0,0],[DD[0][0]-0,DD[0][1]-0,DD[0][2]-0]]
for i in range(N-1):
diff.append([DD[i+1][0]-DD[i][0],DD[i+1][1]-DD[i][1],DD[i+1][2]-DD[i][2]])
def judge(t, x, y):
if t < (abs(x) + abs(y)):
return 1
else:
if (t % 2) == ((abs(x) + abs(y)) % 2):
return 0
else:
return 1
count = 0
for i in range(N+1):
count += judge(diff[i][0], diff[i][1], diff[i][2])
if count >= 1:
print("No")
else:
print("Yes") | N = int(eval(input()))
for _ in range(N):
t, x, y = list(map(int, input().split()))
if x + y > t or (t + x + y)%2 != 0:
print("No")
quit()
print("Yes") | p03457 |
N=int(eval(input()))
clear_flag=0
tmp=0
tmp_x=0
tmp_y=0
for i in range(N):
txy=list(map(int,input().split()))
x=0
y=0
next_flag=0
for x_plus in range(txy[0]-tmp+1):
if next_flag==1:
break
for x_minus in range(txy[0]-tmp+1-x_plus):
if next_flag==1:
break
for y_plus in range(txy[0]-tmp+1-x_plus-x_minus):
y_minus=txy[0]-tmp-x_plus-x_minus-y_plus
x=x_plus-x_minus+tmp_x
y=y_plus-y_minus+tmp_y
if x==txy[1] and y==txy[2]:
next_flag=1
clear_flag+=1
tmp=txy[0]
tmp_x=txy[1]
tmp_y=txy[2]
break
if clear_flag==N:
print("Yes")
else:
print("No") | N=int(eval(input()))
clear_flag=0
for i in range(N):
txy=list(map(int,input().split()))
if txy[0]>=(txy[1]+txy[2]) and (txy[0]+txy[1]+txy[2])%2==0:
clear_flag+=1
else:
break
if clear_flag==N:
print("Yes")
else:
print("No") | p03457 |
N = int(eval(input()))
x = [list(map(int, input().split())) for i in range(N)]
cnt = 0
sum = 0
flag = 0
T = X = Y = 0
for i in range(N):
cnt = x[i][0] - T
sum = abs(x[i][1]- X) + abs(x[i][2]- Y)
T = x[i][0]
X = x[i][1]
Y = x[i][2]
if cnt < sum or cnt % 2 != sum % 2:
flag = 1
break
if flag == 0:
print("Yes")
else:
print("No")
| N = int(eval(input()))
x = [list(map(int, input().split())) for i in range(N)]
cnt = 0
sum = 0
flag = 0
for i in range(N):
if i == 0:
cnt = x[i][0]
sum = x[i][1] + x[i][2]
else:
cnt = x[i][0] - x[i-1][0]
sum = abs(x[i][1]-x[i-1][1]) + abs(x[i][2]-x[i-1][2])
if cnt < sum or cnt % 2 != sum % 2:
flag = 1
break
if flag == 0:
print("Yes")
else:
print("No")
| p03457 |
# -*- coding: utf-8 -*-
option = {(0, 0)}
def main():
global option
last_list = [0, 0, 0]
N = int(eval(input()))
for i in range(N):
this_list = list(map(int, input().split()))
add_option(this_list[0] - last_list[0], (this_list[1], this_list[2]))
if (this_list[1], this_list[2]) not in option:
print('No')
return
option = {(this_list[1], this_list[2])}
last_list = this_list
print('Yes')
def add_option(step, this_postion):
global option
xi, yi = this_postion
for i in range(step):
temp_option = set()
rest = step - i
for position in option:
x, y = position
diff = abs(x - xi) + abs(y - yi)
if rest % 2 != diff % 2:
continue
if diff > rest:
continue
if x < 100000:
temp_option.add((x + 1, y))
if y < 100000:
temp_option.add((x, y + 1))
if x > 0:
temp_option.add((x - 1, y))
if y > 0:
temp_option.add((x, y - 1))
option = temp_option
main()
| # -*- coding: utf-8 -*-
judge = 'Yes'
N = int(eval(input()))
for i in range(N):
t, x, y = list(map(int, input().split()))
if t < (x + y) or t % 2 != (x + y) % 2:
judge = 'No'
print(judge)
| p03457 |
n = int(eval(input()))
for i in range(n):
t, x, y = list(map(int, input().split()))
if x + y > t or (x + y) % 2 != t % 2:
print('No')
exit()
print("Yes") | n = int(eval(input()))
for i in range(n):
t, x, y = list(map(int, input().split()))
if t < x + y or t % 2 != (x + y) % 2:
print("No")
exit()
print("Yes") | p03457 |
n = int(input())
txy = [list(map(int, input().split())) for i in range(n)]
loc_x=0
loc_y=0
judge=0
for i in range(n):
if txy[i][0]%2==0:
if (txy[i][1]+txy[i][2])%2!=0:
judge+=1
elif (txy[i][1]+txy[i][2])%2==0:
judge+=1
temp = abs(loc_x-txy[i][1])+abs(loc_y-txy[i][2])
if i == 0:
if temp > txy[0][0]:
judge+=1
else:
if temp > txy[i][0]-txy[i-1][0]:
judge+=1
loc_x = txy[i][1]
loc_y = txy[i][2]
print('No') if judge else print('Yes')
| n = int(input())
txy = [list(map(int, input().split())) for i in range(n)]
loc_x=0
loc_y=0
judge=0
for i in range(n):
if judge!=0:
break
if txy[i][0]%2==0:
if (txy[i][1]+txy[i][2])%2!=0:
judge+=1
elif (txy[i][1]+txy[i][2])%2==0:
judge+=1
temp = abs(loc_x-txy[i][1])+abs(loc_y-txy[i][2])
if i == 0:
if temp > txy[0][0]:
judge+=1
else:
if temp > txy[i][0]-txy[i-1][0]:
judge+=1
loc_x = txy[i][1]
loc_y = txy[i][2]
print('No') if judge else print('Yes')
| p03457 |
N=int(eval(input()))
t0=0
x0=0
y0=0
for i in range(N):
t,x,y=list(map(int,input().split()))
d=abs(x-x0)+abs(y-y0)
if d>t-t0:
print("No")
exit()
else:
if ((t-t0)-d)%2!=0:
print("No")
exit()
t0=t
x0=x
y0=y
print("Yes") | N=int(eval(input()))
t0=0
x0=0
y0=0
ans="Yes"
for i in range(N):
t,x,y=list(map(int,input().split()))
d=abs(x-x0)+abs(y-y0)
dt=t-t0
if d>dt:
ans="No"
else:
if (dt-d)%2!=0:
ans="No"
t0=t
x0=x
y0=y
print(ans) | p03457 |
def c_Traveling(N, P):
t_old = x_old = y_old = 0
for t, x, y in P:
t1 = t - t_old
x1 = x - x_old
y1 = y - y_old
cond1 = abs(x1) + abs(y1)
cond2 = t1 % 2
cond3 = cond1 % 2
if t1 >= cond1 and cond2 == cond3:
pass
else:
return 'No'
t_old, x_old, y_old = t, x, y
return 'Yes'
N = int(eval(input()))
P = [[int(i) for i in input().split()] for j in range(N)]
print((c_Traveling(N, P))) | def c_traveling(N, P):
t = x = y = 0 # 初期時刻には原点にいる
for t_next, x_next, y_next in P:
dt = t_next - t
dd = abs(x_next - x) + abs(y_next - y)
if dt >= dd and dt % 2 == dd % 2:
# 制限時間は次の座標へのマンハッタン距離以上持っていないとたどり着けない
# 制限時間と距離の偶奇が一致していないと次の座標で止まることができない
t, x, y = t_next, x_next, y_next
else:
return 'No'
return 'Yes'
N = int(eval(input()))
P = [[int(i) for i in input().split()] for j in range(N)]
print((c_traveling(N, P))) | p03457 |
import sys
input = sys.stdin.readline
class Deer:
def __init__(self):
self.x = 0
self.y = 0
self.t = 0
def move(self, ti, xi, yi):
time_interval = ti - self.t
manhattan_distance = abs(xi - self.x) + abs(yi - self.y)
val = time_interval - manhattan_distance
if (val >= 0) and (val % 2 == 0):
self.x = xi
self.y = yi
self.t = ti
return True
else:
return False
AtCoDeer = Deer()
N = int(eval(input()))
flag = True
for _ in range(N):
ti, xi, yi = list(map(int, input().split()))
flag = flag and AtCoDeer.move(ti, xi, yi)
if flag:
print('Yes')
else:
print('No')
| import sys
input = sys.stdin.readline
N = int(eval(input()))
flag = True
for _ in range(N):
t, x, y = list(map(int, input().split()))
if (t < x + y) or (x + y + t) % 2:
flag = False
if flag:
print('Yes')
else:
print('No')
| p03457 |
import sys
N = int(eval(input()))
t, x, y = 0, 0, 0
for i in range(N):
in_t, in_x, in_y = list(map(int, input().split()))
t = in_t - t
x = abs(in_x - x)
y = abs(in_y - y)
if (t >= x + y) & ((t - (x + y)) % 2 == 0):
continue
print('No')
sys.exit()
print('Yes') | import sys
N = int(eval(input()))
for _ in range(N):
t, x, y = list(map(int, input().split()))
if (t >= x + y) & ((t - (x + y)) % 2 == 0):
continue
print('No')
sys.exit()
print('Yes') | p03457 |
n = int(eval(input()))
info = [list(map(int, input().split())) for i in range(n)]
info.insert(0, [0, 0, 0])
x_diff, y_diff = 0, 0
for i in range(n):
dt = info[i+1][0] - info[i][0]
x_diff = abs(info[i+1][1] - info[i][1])
y_diff = abs(info[i+1][2] - info[i][2])
if dt < x_diff + y_diff:
print('No')
exit()
if dt%2 != (x_diff + y_diff)%2:
print('No')
exit()
print('Yes')
| n = int(eval(input()))
for i in range(n):
t,x,y=list(map(int,input().split()))
if (x + y) > t or (x + y + t) % 2:
print("No")
exit()
print("Yes")
| p03457 |
N = int(eval(input()))
T = [[0, 0]]
for _ in range(N):
t, x, y = list(map(int, input().split()))
T.append((t, x + y))
for i in range(N):
dt = T[i+1][0] - T[i][0]
dxy = abs(T[i+1][1] - T[i][1])
if dt < dxy or dt % 2 != dxy % 2:
print("No")
break
else:
print("Yes") | T = [[0, 0]]
for i in range(int(eval(input()))):
t, x, y = list(map(int, input().split()))
T.append((t, x + y))
dt = T[i+1][0] - T[i][0]
dxy = abs(T[i+1][1] - T[i][1])
if dt < dxy or dt % 2 != dxy % 2:
print("No")
break
else:
print("Yes") | p03457 |
import math
import sys
n = int(eval(input()))
for i in range(n):
t,x,y = list(map(int, input().split()))
d = abs(x)+abs(y)
if d > t or (d - t) % 2 != 0:
print('No')
exit()
print('Yes')
| import math
import sys
n = int(eval(input()))
for i in range(n):
t,x,y = list(map(int, sys.stdin.readline().split()))
d = abs(x)+abs(y)
if d > t or (d - t) % 2 != 0:
print('No')
exit()
print('Yes')
| p03457 |
N = int(eval(input()))
now_x = 0
now_y = 0
now_t = 0
Flag = False
for i in range(N):
t , x, y = list(map(int,input().split()))
dx = abs(x - now_x)
dy = abs(y - now_y)
dt = abs(t - now_t)
if (dt - (dx + dy)) % 2 != 0 or dt < (dx + dy):
Flag = True
now_x = x
now_y = y
now_t = t
print(("No" if Flag else "Yes")) | N = int(eval(input()))
now_t, now_x, now_y = 0, 0, 0
for i in range(N):
next_t, next_x, next_y = list(map(int, input().split()))
distance = abs(next_x - now_x) + abs(next_y - now_y)
spent_time = next_t - now_t
if spent_time < distance or distance % 2 != spent_time % 2:
print('No')
exit()
now_t, now_x, now_y = next_t, next_x, next_y
print('Yes') | p03457 |
n = int(eval(input()))
t = 0
x = 0
y = 0
judge = True
for i in range(n):
t1, x1, y1 = list(map(int, input().split()))
if (abs(x1 - x) + abs(y1 - y))/(t1 - t) > 1 or (abs(x1 - x) + abs(y1 - y))%2 != (t1 - t)%2:
judge = False
x = x1
y = y1
t = t1
if judge == True:
print("Yes")
else:
print("No") | import sys
input = sys.stdin.readline
n = int(eval(input()))
t = 0
x = 0
y = 0
judge = True
for i in range(n):
t1, x1, y1 = list(map(int, input().split()))
if (abs(x1 - x) + abs(y1 - y))/(t1 - t) > 1 or (abs(x1 - x) + abs(y1 - y))%2 != (t1 - t)%2:
judge = False
x = x1
y = y1
t = t1
if judge == True:
print("Yes")
else:
print("No") | p03457 |
import sys
input = sys.stdin.readline
n = int(eval(input()))
t = 0
x = 0
y = 0
judge = True
l = [list(map(int, input().split())) for _ in range(n)]
for t1, x1, y1 in l:
if (abs(x1 - x) + abs(y1 - y))/(t1 - t) > 1 or (abs(x1 - x) + abs(y1 - y))%2 != (t1 - t)%2:
print("No")
exit()
x = x1
y = y1
t = t1
print("Yes") | import sys
input = sys.stdin.readline
n = int(eval(input()))
t = 0
x = 0
y = 0
judge = True
l = [tuple(map(int, input().split())) for _ in range(n)]
for t1, x1, y1 in l:
if (abs(x1 - x) + abs(y1 - y))/(t1 - t) > 1 or (abs(x1 - x) + abs(y1 - y))%2 != (t1 - t)%2:
print("No")
exit()
x = x1
y = y1
t = t1
print("Yes") | p03457 |
import sys
input = sys.stdin.readline
n = int(eval(input()))
t = 0
x = 0
y = 0
l = [tuple(map(int, input().split())) for _ in range(n)]
for t1, x1, y1 in l:
if (abs(x1 - x) + abs(y1 - y))/(t1 - t) > 1:
print("No")
exit()
if (abs(x1 - x) + abs(y1 - y))%2 != (t1 - t)%2:
print("No")
exit()
x = x1
y = y1
t = t1
print("Yes") | import sys
input = sys.stdin.readline
def main():
n = int(eval(input()))
t = 0
x = 0
y = 0
l = [tuple(map(int, input().split())) for _ in range(n)]
for t1, x1, y1 in l:
if (abs(x1 - x) + abs(y1 - y))/(t1 - t) > 1:
print("No")
exit()
if (abs(x1 - x) + abs(y1 - y))%2 != (t1 - t)%2:
print("No")
exit()
x = x1
y = y1
t = t1
print("Yes")
main() | p03457 |
n=int(input())
txy=[]
for _ in range(n):
t,x,y=map(int, input().split())
txy.append((t,x,y))
def isOk(txy):
now_pos=0
now_t=0
for t,x,y in txy:
move=x+y-now_pos
time=t-now_t
if time>=move and time%2==move%2:
continue
else:
return False
return True
print("Yes") if isOk(txy) else print("No")
| import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
N = int(eval(input()))
TXY = [list(map(int, input().split())) for _ in range(N)]
nx, ny = 0, 0
time = 0
ans = "Yes"
for i in range(N):
t, x, y = TXY[i]
dt = t - time
move = abs(nx - x) + abs(ny - y)
if move > dt:
ans = "No"
break
if dt % 2 != move % 2:
ans = "No"
break
time, nx, ny = t, x, y
print(ans)
| p03457 |
def solve():
def measurement(a, b, w):
a_root = root[a]
b_root = root[b]
if a_root != b_root:
a_member = member[a_root]
b_member = member[b_root]
offset = w - (weight[b] - weight[a])
if len(a_member) > len(b_member):
a_member.extend(b_member)
for n in b_member:
root[n] = a_root
weight[n] += offset
else:
b_member.extend(a_member)
for n in a_member:
root[n] = b_root
weight[n] -= offset
def inquiry(a, b):
if root[a] == root[b]:
return weight[b] - weight[a]
else:
return 'UNKNOWN'
def operation(line):
if line[0] == '!':
a, b, w = map(int, line[2:].split())
measurement(a, b, w)
else:
a, b = map(int, line[2:].split())
return inquiry(a, b)
import sys
file_input = sys.stdin.readlines()
while True:
N, M = map(int, file_input[0].split())
if N == 0:
break
root = [i for i in range(N + 1)]
member = [[i] for i in range(N + 1)]
weight = [0] * (N + 1)
ans = (operation(line) for line in file_input[1:M+1])
ans = filter(lambda x: x != None, ans)
print(*ans, sep='\n')
del file_input[:M+1]
solve()
| def solve():
def measurement(a, b, w):
a_root = root[a]
b_root = root[b]
if a_root != b_root:
a_member = member[a_root]
b_member = member[b_root]
offset = w - (weight[b] - weight[a])
if len(a_member) > len(b_member):
a_member.extend(b_member)
for n in b_member:
root[n] = a_root
weight[n] += offset
else:
b_member.extend(a_member)
for n in a_member:
root[n] = b_root
weight[n] -= offset
def inquiry(a, b):
if root[a] == root[b]:
return weight[b] - weight[a]
else:
return 'UNKNOWN'
import sys
file_input = sys.stdin.readlines()
ans = []
while True:
N, M = map(int, file_input[0].split())
if N == 0:
break
root = [i for i in range(N + 1)]
member = [[i] for i in range(N + 1)]
weight = [0] * (N + 1)
for line in file_input[1:M+1]:
if line[0] == '!':
a, b, w = map(int, line[2:].split())
measurement(a, b, w)
else:
a, b= map(int, line[2:].split())
ans.append(inquiry(a, b))
del file_input[:M+1]
print(*ans, sep='\n')
solve()
| p00909 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys,collections,itertools,re,math,fractions,decimal,random,array,bisect,heapq
# decimal.getcontext().prec = 50
sys.setrecursionlimit(100000)
MOD = 10**9 + 7
def dijkstra(g, v_size, st):
"""Dijkstra method"""
d = [float('inf')] * v_size
d[st] = 0
que = [(0, st)] # (min_dist, vertex)
heapq.heapify(que)
while len(que) > 0:
dist, v0 = heapq.heappop(que)
if d[v0] < dist: continue
for v1, dist in g[v0]:
if d[v1] > d[v0] + dist:
d[v1] = d[v0] + dist
heapq.heappush(que, (d[v1], v1))
return d
def solve(f):
n, m = f.read_int_list()
s, t = f.read_int_list()
g = collections.defaultdict(list)
for m in range(m):
u, v, d = f.read_int_list()
g[u-1].append((v-1, d))
g[v-1].append((u-1, d))
d = dijkstra(g, n, s-1)
cand = []
for i in range(n):
if d[t-1] == d[i]*2: cand.append((i,i))
memo = [-1]*n
memo[t-1] = 1
def count(v):
if memo[v] >= 0: return memo[v]
res = 0
for vi, di in g[v]:
if d[v]+di == d[vi]:
c = count(vi)
res = (res+c)%MOD
if c > 0 and d[v]*2 < d[t-1] < (d[v] + di)*2:
cand.append((v, vi))
memo[v] = res
return res
memo2 = [-1]*n
memo2[s-1] = 1
def count2(v):
if memo2[v] >= 0: return memo2[v]
res = 0
for vi, di in g[v]:
if d[v]-di == d[vi]:
res = (res+count2(vi))%MOD
memo2[v] = res
return res
count(s-1)
count2(t-1)
cnt = []
for v1, v2 in cand:
cnt.append((memo2[v1]*memo[v2])%MOD)
s = sum(cnt)
ans = 0
for ci in cnt:
ans = (ans+ci*(s-ci))%MOD
return ans
class Reader(object):
def __init__(self, filename=None):
self.file = open(filename) if filename is not None else None
self.case = 1
def __readline(self):
return self.file.next().strip() if self.file else input()
def next_case(self):
next(self.file)
self.case += 1
def read_int(self): return int(self.__readline())
def read_float(self): return float(self.__readline())
def read_long(self): return int(self.__readline())
def read_decimal(self): return decimal.Decimal(self.__readline())
def read_str(self): return self.__readline()
def read_int_list(self): return list(map(int, self.__readline().split()))
def read_float_list(self): return list(map(float, self.__readline().split()))
def read_long_list(self): return list(map(int, self.__readline().split()))
def read_decimal_list(self): return list(map(decimal.Decimal, self.__readline().split()))
def read_str_list(self): return self.__readline().split()
if __name__ == '__main__':
filename = sys.argv[1] if len(sys.argv) > 1 else None
f = Reader(filename)
if f.file:
while True:
print("Case #%d\n"%f.case, solve(f))
try:
f.next_case()
except StopIteration:
break
else:
print(solve(f))
| #!/usr/bin/python
# -*- coding: utf-8 -*-
import sys,collections,itertools,re,math,fractions,decimal,random,array,bisect,heapq
# decimal.getcontext().prec = 50
sys.setrecursionlimit(100000)
MOD = 10**9 + 7
def dijkstra(g, v_size, st):
"""Dijkstra method"""
d = [float('inf')] * v_size
d[st] = 0
que = [(0, st)] # (min_dist, vertex)
heapq.heapify(que)
while len(que) > 0:
dist, v0 = heapq.heappop(que)
if d[v0] < dist: continue
for v1, dist in g[v0]:
if d[v1] > d[v0] + dist:
d[v1] = d[v0] + dist
heapq.heappush(que, (d[v1], v1))
return d
def solve(f):
n, m = f.read_int_list()
s, t = f.read_int_list()
g = collections.defaultdict(list)
for m in range(m):
u, v, d = f.read_int_list()
g[u-1].append((v-1, d))
g[v-1].append((u-1, d))
d = dijkstra(g, n, s-1)
cand = []
for i in range(n):
if d[t-1] == d[i]*2: cand.append((i,i))
memo = [0]*n
memo[t-1] = 1
ary = [(d[i], i) for i in range(n)]
ary.sort(reverse=True)
for _, v in ary:
for vi, di in g[v]:
if d[v]-di == d[vi]:
memo[vi] = (memo[vi]+memo[v])%MOD
if d[vi]*2 < d[t-1] < (d[vi] + di)*2:
cand.append((vi, v))
memo2 = [0]*n
memo2[s-1] = 1
ary.sort()
for _, v in ary:
for vi, di in g[v]:
if d[v]+di == d[vi]:
memo2[vi] = (memo2[vi]+memo2[v])%MOD
cnt = []
for v1, v2 in cand:
cnt.append((memo2[v1]*memo[v2])%MOD)
s = sum(cnt)
ans = 0
for ci in cnt:
ans = (ans+ci*(s-ci))%MOD
return ans
class Reader(object):
def __init__(self, filename=None):
self.file = open(filename) if filename is not None else None
self.case = 1
def __readline(self):
return self.file.next().strip() if self.file else input()
def next_case(self):
next(self.file)
self.case += 1
def read_int(self): return int(self.__readline())
def read_float(self): return float(self.__readline())
def read_long(self): return int(self.__readline())
def read_decimal(self): return decimal.Decimal(self.__readline())
def read_str(self): return self.__readline()
def read_int_list(self): return list(map(int, self.__readline().split()))
def read_float_list(self): return list(map(float, self.__readline().split()))
def read_long_list(self): return list(map(int, self.__readline().split()))
def read_decimal_list(self): return list(map(decimal.Decimal, self.__readline().split()))
def read_str_list(self): return self.__readline().split()
if __name__ == '__main__':
filename = sys.argv[1] if len(sys.argv) > 1 else None
f = Reader(filename)
if f.file:
while True:
print("Case #%d\n"%f.case, solve(f))
try:
f.next_case()
except StopIteration:
break
else:
print(solve(f))
| p03453 |
from heapq import heappush, heappop
import sys
#input = sys.stdin.readline
INF = 10**18
mod = 10**9+7
def dijkstra(start, n, graph):
route_cnt = [start] * n
route_cnt[start] = 1
que = [(0, start)]
dist = [INF] * n
dist[start] = 0
while que:
min_dist, u = heappop(que)
if min_dist > dist[u]:
continue
for c, v in graph[u]:
if dist[u] + c < dist[v]:
dist[v] = dist[u] + c
route_cnt[v] = route_cnt[u]
heappush(que, (dist[u] + c , v))
elif dist[u] + c == dist[v]:
route_cnt[v] = (route_cnt[v] + route_cnt[u]) % mod
return route_cnt, dist
N, M = list(map(int, input().split()))
S, T = list(map(int, input().split()))
G = [[] for _ in range(N)]
edges = []
for _ in range(M):
u, v, d = list(map(int, input().split()))
G[u-1].append((d, v-1))
G[v-1].append((d, u-1))
edges.append((v-1, u-1, d))
num_s, dist_s = dijkstra(S-1, N, G)
num_t, dist_t = dijkstra(T-1, N, G)
ans = num_s[T-1]**2%mod
l = dist_s[T-1]
for u, v, d in edges:
if dist_s[v]<dist_s[u]:
u, v = v, u
if dist_s[u]*2<l<dist_s[v]*2 and dist_s[u]+dist_t[v]+d == l:
ans-=(num_s[u]*num_t[v])**2
ans%=mod
for v in range(N):
if dist_s[v] == dist_t[v] == l/2:
ans-=(num_t[v]*num_s[v])**2
ans%=mod
print((ans%mod))
| from heapq import heappush, heappop
import sys
input = sys.stdin.readline
INF = 10**18
mod = 10**9+7
def dijkstra(start, n, graph):
route_cnt = [start] * n
route_cnt[start] = 1
que = [(0, start)]
dist = [INF] * n
dist[start] = 0
while que:
min_dist, u = heappop(que)
if min_dist > dist[u]:
continue
for c, v in graph[u]:
if dist[u] + c < dist[v]:
dist[v] = dist[u] + c
route_cnt[v] = route_cnt[u]
heappush(que, (dist[u] + c , v))
elif dist[u] + c == dist[v]:
route_cnt[v] = (route_cnt[v] + route_cnt[u]) % mod
return route_cnt, dist
N, M = list(map(int, input().split()))
S, T = list(map(int, input().split()))
G = [[] for _ in range(N)]
edges = []
for _ in range(M):
u, v, d = list(map(int, input().split()))
G[u-1].append((d, v-1))
G[v-1].append((d, u-1))
edges.append((v-1, u-1, d))
num_s, dist_s = dijkstra(S-1, N, G)
num_t, dist_t = dijkstra(T-1, N, G)
ans = num_s[T-1]**2%mod
l = dist_s[T-1]
for u, v, d in edges:
if dist_s[v]<dist_s[u]:
u, v = v, u
if dist_s[u]*2<l<dist_s[v]*2 and dist_s[u]+dist_t[v]+d == l:
ans-=(num_s[u]**2%mod)*(num_t[v]**2%mod)
ans%=mod
for v in range(N):
if dist_s[v] == dist_t[v] == l/2:
ans-=(num_t[v]**2%mod)*(num_s[v]**2%mod)
ans%=mod
print((ans%mod))
| p03453 |
from collections import defaultdict
from functools import reduce
import heapq as hq
from sys import stdin
MOD = 10**9+7
N,M = list(map(int,stdin.readline().split()))
S,T = list(map(int,stdin.readline().split()))
S,T = S-1,T-1
E = defaultdict(list)
lines = stdin.readlines()
for line in lines:
u,v,d = list(map(int,line.split()))
E[u-1].append((v-1,d))
E[v-1].append((u-1,d))
dS = [None]*N
dT = [None]*N
Q = [(0,S,False),(0,T,True)]
D = float('inf')
while Q:
d,v,f = hq.heappop(Q)
if d*2 > D:
break
dM = dT if f else dS
dN = dS if f else dT
if dM[v] is None:
dM[v] = d
for u,dd in E[v]:
if dM[u] is None and (d+dd)*2 <= D:
hq.heappush(Q,(d+dd,u,f))
if dN[v] is not None:
D = min(dN[v]+d,D)
del Q
def helper(start,dist):
cnts = [0]*N
cnts[start] = 1
for d,v in sorted((d,v) for v,d in enumerate(dist) if d is not None):
c = cnts[v]
for u,dd in E[v]:
if dd+d == dist[u]:
cnts[u] = (cnts[u]+c) % MOD
return cnts
Sn = helper(S,dS)
Tn = helper(T,dT)
def it():
for v in range(N):
if dS[v] is not None:
ds = dS[v]
if dT[v] == ds and ds*2 == D:
yield Sn[v]*Tn[v] % MOD
else:
for u,d in E[v]:
if dT[u] is not None and abs(dT[u]-ds) < d and ds+d+dT[u] == D:
yield Sn[v]*Tn[u] % MOD
X = list(it())
total = reduce(lambda a,b:(a+b)%MOD, X,0)
total = total*total % MOD
sub = reduce(lambda a,b:(a+b)%MOD, [x*x % MOD for x in X],0)
print(((total-sub)%MOD)) | from functools import reduce
import heapq as hq
from sys import stdin
MOD = 10**9+7
N,M = list(map(int,stdin.readline().split()))
S,T = list(map(int,stdin.readline().split()))
S,T = S-1,T-1
inf = float('inf')
E = [[] for _ in range(N)]
lines = stdin.readlines()
for line in lines:
u,v,d = list(map(int,line.split()))
E[u-1].append((v-1,d))
E[v-1].append((u-1,d))
dS = [inf]*N
dT = [inf]*N
Q = [(0,S,False),(0,T,True)]
D = inf
while Q:
d,v,f = hq.heappop(Q)
if d*2 > D:
break
dM = dT if f else dS
dN = dS if f else dT
if dM[v] > d:
dM[v] = d
for u,dd in E[v]:
if dM[u] > d and (d+dd)*2 <= D:
hq.heappush(Q,(d+dd,u,f))
D = min(dN[v]+d,D)
del Q
def helper(start,dist):
cnts = [0]*N
cnts[start] = 1
for d,v in sorted((d,v) for v,d in enumerate(dist) if d != inf):
c = cnts[v]
for u,dd in E[v]:
if dd+d == dist[u]:
cnts[u] = (cnts[u]+c) % MOD
return cnts
Sn = helper(S,dS)
Tn = helper(T,dT)
def it():
for v in range(N):
if dS[v] != inf:
ds = dS[v]
if dT[v] == ds and ds*2 == D:
yield Sn[v]*Tn[v] % MOD
else:
for u,d in E[v]:
if abs(dT[u]-ds) < d and ds+d+dT[u] == D:
yield Sn[v]*Tn[u] % MOD
X = tuple(it())
total = reduce(lambda a,b:(a+b)%MOD, X,0)
total = total*total % MOD
sub = reduce(lambda a,b:(a+b)%MOD, [x*x % MOD for x in X],0)
print(((total-sub)%MOD)) | p03453 |
from collections import defaultdict
from heapq import heappop, heappush
import sys
sys.setrecursionlimit(200000)
MOD, INF = 1000000007, float('inf')
def get_patterns_func(s, ancestors):
cache = {s: 1}
def get_patterns(v):
if v in cache:
return cache[v]
return sum(get_patterns(a) for a in ancestors[v])
return get_patterns
def solve(s, t, links):
q = [(0, 0, s, -1, 0), (0, 0, t, -1, 1)]
visited_fwd, visited_bwd = [INF] * n, [INF] * n
ancestors_fwd, ancestors_bwd = defaultdict(set), defaultdict(set)
collision_nodes, collision_links = set(), set()
limit = 0
while q:
cost, cost_a, v, a, is_bwd = heappop(q)
if is_bwd:
visited_self = visited_bwd
visited_opp = visited_fwd
ancestors_self = ancestors_bwd
else:
visited_self = visited_fwd
visited_opp = visited_bwd
ancestors_self = ancestors_fwd
relax_flag = False
cost_preceding = visited_self[v]
if cost_preceding == INF:
visited_self[v] = cost
relax_flag = True
elif cost > cost_preceding:
continue
ancestors_self[v].add(a)
cost_opp = visited_opp[v]
if cost_opp != INF:
limit = cost + cost_opp
if cost == cost_opp:
collision_nodes.add(v)
else:
collision_links.add((v, a) if is_bwd else (a, v))
break
if relax_flag:
for u, du in list(links[v].items()):
nc = cost + du
if visited_self[u] < nc:
continue
heappush(q, (nc, cost, u, v, is_bwd))
collision_time = limit / 2
while q:
cost, cost_a, v, a, is_bwd = heappop(q)
if cost > limit:
break
visited_self = visited_bwd if is_bwd else visited_fwd
if visited_self[v] == INF:
visited_self[v] = cost
if is_bwd:
if cost == collision_time:
ancestors_bwd[v].add(a)
continue
if cost_a == collision_time:
collision_nodes.add(a)
elif cost == collision_time:
collision_nodes.add(v)
ancestors_fwd[v].add(a)
else:
collision_links.add((a, v))
patterns_fwd = get_patterns_func(s, ancestors_fwd)
patterns_bwd = get_patterns_func(t, ancestors_bwd)
shortest_count = 0
collision_count = 0
for v in collision_nodes:
if visited_fwd[v] == visited_bwd[v]:
r = patterns_fwd(v) * patterns_bwd(v)
shortest_count += r
shortest_count %= MOD
collision_count += r * r
collision_count %= MOD
for u, v in collision_links:
if visited_fwd[u] + visited_bwd[v] + links[u][v] == limit:
r = patterns_fwd(u) * patterns_bwd(v)
shortest_count += r
shortest_count %= MOD
collision_count += r * r
collision_count %= MOD
return (shortest_count ** 2 - collision_count) % MOD
n, m = list(map(int, input().split()))
s, t = list(map(int, input().split()))
s -= 1
t -= 1
links = [{} for _ in range(n)]
for uvd in sys.stdin.readlines():
u, v, d = list(map(int, uvd.split()))
# for _ in range(m):
# u, v, d = map(int, input().split())
u -= 1
v -= 1
links[u][v] = d
links[v][u] = d
print((solve(s, t, links)))
| from heapq import heappop, heappush
import sys
MOD, INF = 1000000007, float('inf')
def solve(s, t, links):
q = [(0, 0, s, -1, 0), (0, 0, t, -1, 1)]
visited_fwd, visited_bwd = [INF] * n, [INF] * n
patterns_fwd, patterns_bwd = [0] * (n + 1), [0] * (n + 1)
patterns_fwd[-1] = patterns_bwd[-1] = 1
collision_nodes, collision_links = set(), set()
limit = 0
while q:
cost, cost_a, v, a, is_bwd = heappop(q)
if is_bwd:
visited_self = visited_bwd
visited_opp = visited_fwd
patterns_self = patterns_bwd
else:
visited_self = visited_fwd
visited_opp = visited_bwd
patterns_self = patterns_fwd
relax_flag = False
cost_preceding = visited_self[v]
if cost_preceding == INF:
visited_self[v] = cost
relax_flag = True
elif cost > cost_preceding:
continue
patterns_self[v] += patterns_self[a]
cost_opp = visited_opp[v]
if cost_opp != INF:
limit = cost + cost_opp
if cost == cost_opp:
collision_nodes.add(v)
else:
collision_links.add((v, a) if is_bwd else (a, v))
break
if relax_flag:
for u, du in list(links[v].items()):
nc = cost + du
if visited_self[u] < nc:
continue
heappush(q, (nc, cost, u, v, is_bwd))
collision_time = limit / 2
while q:
cost, cost_a, v, a, is_bwd = heappop(q)
if cost > limit:
break
visited_self = visited_bwd if is_bwd else visited_fwd
if visited_self[v] == INF:
visited_self[v] = cost
if is_bwd:
if cost == collision_time:
patterns_bwd[v] += patterns_bwd[a]
continue
if cost_a == collision_time:
collision_nodes.add(a)
elif cost == collision_time:
collision_nodes.add(v)
patterns_fwd[v] += patterns_fwd[a]
else:
collision_links.add((a, v))
shortest_count = 0
collision_count = 0
for v in collision_nodes:
if visited_fwd[v] == visited_bwd[v]:
r = patterns_fwd[v] * patterns_bwd[v]
shortest_count += r
shortest_count %= MOD
collision_count += r * r
collision_count %= MOD
for u, v in collision_links:
if visited_fwd[u] + visited_bwd[v] + links[u][v] == limit:
r = patterns_fwd[u] * patterns_bwd[v]
shortest_count += r
shortest_count %= MOD
collision_count += r * r
collision_count %= MOD
return (shortest_count ** 2 - collision_count) % MOD
n, m = list(map(int, input().split()))
s, t = list(map(int, input().split()))
s -= 1
t -= 1
links = [{} for _ in range(n)]
for uvd in sys.stdin.readlines():
u, v, d = list(map(int, uvd.split()))
# for _ in range(m):
# u, v, d = map(int, input().split())
u -= 1
v -= 1
links[u][v] = d
links[v][u] = d
print((solve(s, t, links)))
| p03453 |
from heapq import *
from collections import defaultdict
import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def main():
md = 10 ** 9 + 7
inf = 10 ** 15
to = defaultdict(list)
n, m = map(int, input().split())
s, t = map(int1, input().split())
for ei in range(m):
u, v, d = map(int, input().split())
u, v = u - 1, v - 1
to[u].append([v, d])
to[v].append([u, d])
# sからのダイクストラで
# 各頂点までの最短距離dists
# sからのルート数way_s
# 逆向きのダグot
# 以上を作る
dists = [inf] * n
way_s = [0] * n
ot = defaultdict(list)
hp = []
heappush(hp, [0, s])
way_s[s] = 1
u = -1
while u != t:
dist, u = heappop(hp)
if dists[u] != inf: continue
dists[u] = dist
for v, d in to[u]:
if dists[v] == inf:
heappush(hp, [dist + d, v])
elif dists[v] == dist - d:
way_s[u] += way_s[v]
ot[u].append(v)
#print(dists)
#print(way_s)
#print(ot)
# tからのbfsで
# sからのルート数way_tを作りながら
# 衝突するルート数way_colを計算していく
way_t = [0] * n
way_col = 0
half = dists[t] / 2
way_t[t] = 1
hp = []
heappush(hp, [-dists[t], t])
while hp:
dist, u = heappop(hp)
if -dist == half:
way_col += pow(way_t[u] * way_s[u], 2, md)
way_col %= md
continue
way = way_t[u]
for v in ot[u]:
if dists[v] < half:
way_col += pow(way_t[u] * way_s[v], 2, md)
way_col %= md
else:
way_t[v] += way
heappush(hp, [-dists[v], v])
#print(way_col)
# 全ルートから衝突するルートを引いて答え
ans = pow(way_s[t], 2, md) - way_col
ans %= md
print(ans)
main()
| import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
from heapq import *
def solve():
dist = [inf] * n
cnt = [0] * n
hp = []
heappush(hp, (0, s))
dist[s] = 0
cnt[s] = 1
while hp:
d, u = heappop(hp)
if d > dist[t]: break
if d > dist[u]: continue
for v, c in to[u]:
nd = d + c
if nd == dist[v]: cnt[v] += cnt[u]
elif nd < dist[v]:
dist[v] = nd
cnt[v] = cnt[u]
heappush(hp, (nd, v))
distr = [inf] * n
cntr = [0] * n
hp = []
heappush(hp, (0, t))
distr[t] = 0
cntr[t] = 1
while hp:
d, u = heappop(hp)
#print(d,u,hp,distr,cntr)
if d * 2 > dist[t]: continue
if d > distr[u]: continue
for v, c in to[u]:
nd = d + c
if nd == distr[v]: cntr[v] += cntr[u]
elif nd < distr[v]:
distr[v] = nd
cntr[v] = cntr[u]
heappush(hp, (nd, v))
ans = pow(cnt[t], 2, md)
dt = dist[t]
for u in range(n):
if dist[u] * 2 == dt:
ans -= (cnt[u] * cntr[u])**2
ans %= md
for u, v, c in uvd:
for _ in range(2):
if dist[u] + distr[v] + c == dt and dist[u] * 2 < dt and distr[v] * 2 < dt:
ans -= (cnt[u] * cntr[v])**2
ans %= md
u, v = v, u
print(ans)
md = 10 ** 9 + 7
inf = 10 ** 16
n, m = MI()
s, t = MI1()
to = [[] for _ in range(n)]
uvd = []
for _ in range(m):
u, v, d = MI()
to[u - 1].append((v - 1, d))
to[v - 1].append((u - 1, d))
uvd.append((u - 1, v - 1, d))
solve()
| p03453 |
import sys
readline = sys.stdin.readline
from heapq import heappop as hpp, heappush as hp
def dijkstra(N, s, Edge):
inf = geta
dist = [inf] * N
dist[s] = 0
Q = [s]
dp = [0]*N
dp[s] = 1
while Q:
k = hpp(Q)
dn, vn = divmod(k, geta)
if dn > dist[vn]:
continue
for k in Edge[vn]:
df, vf = divmod(k, geta)
if dist[vn] + df < dist[vf]:
dist[vf] = dist[vn] + df
dp[vf] = dp[vn]
hp(Q, ((dn + df)*geta)+vf)
elif dist[vn] + df == dist[vf]:
dp[vf] = (dp[vf] + dp[vn]) % MOD
return dist, dp
MOD = 10**9+7
N, M = list(map(int, readline().split()))
S, T = list(map(int, readline().split()))
S -= 1
T -= 1
geta = 10**15
Edge = [[] for _ in range(N)]
for _ in range(M):
u, v, d = list(map(int, readline().split()))
u -= 1
v -= 1
Edge[u].append(d*geta+v)
Edge[v].append(d*geta+u)
dists, dps = dijkstra(N, S, Edge)
distt, dpt = dijkstra(N, T, Edge)
st = dists[T]
onpath = [i for i in range(N) if dists[i] + distt[i] == st]
ans = dps[T]**2%MOD
for i in onpath:
if 2*dists[i] == 2*distt[i] == st:
ans = (ans - pow(dps[i]*dpt[i], 2, MOD))%MOD
for k in Edge[i]:
cost, vf = divmod(k, geta)
if dists[i] + cost + distt[vf] == st:
if 2*dists[i] < st < 2*dists[vf]:
ans = (ans - pow(dps[i]*dpt[vf], 2, MOD))%MOD
print(ans)
| import sys
readline = sys.stdin.readline
from heapq import heappop as hpp, heappush as hp
def dijkstra(N, s, Edge):
inf = geta
dist = [inf] * N
dist[s] = 0
Q = [(0, s)]
dp = [0]*N
dp[s] = 1
while Q:
dn, vn = hpp(Q)
if dn > dist[vn]:
continue
for df, vf in Edge[vn]:
if dist[vn] + df < dist[vf]:
dist[vf] = dist[vn] + df
dp[vf] = dp[vn]
hp(Q, (dn + df,vf))
elif dist[vn] + df == dist[vf]:
dp[vf] = (dp[vf] + dp[vn]) % MOD
return dist, dp
MOD = 10**9+7
N, M = list(map(int, readline().split()))
S, T = list(map(int, readline().split()))
S -= 1
T -= 1
geta = 10**15
Edge = [[] for _ in range(N)]
for _ in range(M):
u, v, d = list(map(int, readline().split()))
u -= 1
v -= 1
Edge[u].append((d, v))
Edge[v].append((d, u))
dists, dps = dijkstra(N, S, Edge)
distt, dpt = dijkstra(N, T, Edge)
st = dists[T]
onpath = [i for i in range(N) if dists[i] + distt[i] == st]
ans = dps[T]**2%MOD
for i in onpath:
if 2*dists[i] == 2*distt[i] == st:
ans = (ans - pow(dps[i]*dpt[i], 2, MOD))%MOD
for cost, vf in Edge[i]:
if dists[i] + cost + distt[vf] == st:
if 2*dists[i] < st < 2*dists[vf]:
ans = (ans - pow(dps[i]*dpt[vf], 2, MOD))%MOD
print(ans) | p03453 |
mod=10**9+7
class Dijkstra():
""" ダイクストラ法
重み付きグラフにおける単一始点最短路アルゴリズム
* 使用条件
- 負のコストがないこと
- 有向グラフ、無向グラフともにOK
* 計算量はO(E*log(V))
* ベルマンフォード法より高速なので、負のコストがないならばこちらを使うとよい
"""
class Edge():
""" 重み付き有向辺 """
def __init__(self, _to, _cost):
self.to = _to
self.cost = _cost
def __init__(self, V):
""" 重み付き有向辺
無向辺を表現したいときは、_fromと_toを逆にした有向辺を加えればよい
Args:
V(int): 頂点の数
"""
self.G = [[] for i in range(V)] # 隣接リストG[u][i] := 頂点uのi個目の隣接辺
self._E = 0 # 辺の数
self._V = V # 頂点の数
@property
def E(self):
""" 辺数
無向グラフのときは、辺数は有向グラフの倍になる
"""
return self._E
@property
def V(self):
""" 頂点数 """
return self._V
def add(self, _from, _to, _cost):
""" 2頂点と、辺のコストを追加する """
self.G[_from].append(self.Edge(_to, _cost))
def shortest_path(self, s):
""" 始点sから頂点iまでの最短路を格納したリストを返す
Args:
s(int): 始点s
Returns:
d(list): d[i] := 始点sから頂点iまでの最短コストを格納したリスト。
到達不可の場合、値はfloat("inf")
"""
import heapq
que = [] # プライオリティキュー（ヒープ木）
d = [10**15] * self.V
d[s] = 0
cnt=[0]*self.V
cnt[s]=1
heapq.heappush(que, (0, s)) # 始点の(最短距離, 頂点番号)をヒープに追加する
while len(que) != 0:
cost, v = heapq.heappop(que)
# キューに格納されている最短経路の候補がdの距離よりも大きければ、他の経路で最短経路が存在するので、処理をスキップ
if d[v] < cost: continue
for i in range(len(self.G[v])):
# 頂点vに隣接する各頂点に関して、頂点vを経由した場合の距離を計算し、今までの距離(d)よりも小さければ更新する
e = self.G[v][i] # vのi個目の隣接辺e
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost # dの更新
heapq.heappush(que, (d[e.to], e.to)) # キューに新たな最短経路の候補(最短距離, 頂点番号)の情報をpush
cnt[e.to]=cnt[v]%mod
elif d[e.to]==d[v]+e.cost:
cnt[e.to]+=cnt[v]
cnt[e.to]%=mod
return d,cnt
import sys
input=sys.stdin.readline
N,M=list(map(int,input().split()))
S,T=list(map(int,input().split()))
mati=Dijkstra(N)
Edge=[]
Edge_append=Edge.append
for i in range(M):
u,v,d=list(map(int,input().split()))
mati.add(u-1,v-1,d)
mati.add(v-1,u-1,d)
Edge_append((u-1,v-1,d))
Edge_append((v-1,u-1,d))
spath,Sways=mati.shortest_path(S-1)
tpath,Tways=mati.shortest_path(T-1)
ans=Sways[T-1]*Tways[S-1]
ans%=mod
for u,v,d in Edge:
ans-=(Tways[v]*Sways[u])**2*(spath[u]+d+tpath[v]==spath[T-1] and (tpath[v]+d>spath[u]>=tpath[v] or tpath[v]+d>=spath[u]+d>tpath[v]))
ans%=mod
for i in range(N):
ans-=(Tways[i]*Sways[i])**2*(spath[i]+tpath[i]==spath[T-1] and spath[i]==tpath[i])
ans%=mod
print((ans%mod))
| mod=10**9+7
class Dijkstra():
""" ダイクストラ法
重み付きグラフにおける単一始点最短路アルゴリズム
* 使用条件
- 負のコストがないこと
- 有向グラフ、無向グラフともにOK
* 計算量はO(E*log(V))
* ベルマンフォード法より高速なので、負のコストがないならばこちらを使うとよい
"""
class Edge():
""" 重み付き有向辺 """
def __init__(self, _to, _cost):
self.to = _to
self.cost = _cost
def __init__(self, V):
""" 重み付き有向辺
無向辺を表現したいときは、_fromと_toを逆にした有向辺を加えればよい
Args:
V(int): 頂点の数
"""
self.G = [[] for i in range(V)] # 隣接リストG[u][i] := 頂点uのi個目の隣接辺
self._E = 0 # 辺の数
self._V = V # 頂点の数
@property
def E(self):
""" 辺数
無向グラフのときは、辺数は有向グラフの倍になる
"""
return self._E
@property
def V(self):
""" 頂点数 """
return self._V
def add(self, _from, _to, _cost):
""" 2頂点と、辺のコストを追加する """
self.G[_from].append(self.Edge(_to, _cost))
self._E += 1
def edge(self,_from):
return self.G[_from]
def shortest_path(self, s):
""" 始点sから頂点iまでの最短路を格納したリストを返す
Args:
s(int): 始点s
Returns:
d(list): d[i] := 始点sから頂点iまでの最短コストを格納したリスト。
到達不可の場合、値はfloat("inf")
"""
import heapq
que = [] # プライオリティキュー（ヒープ木）
d = [10**15] * self.V
d[s] = 0
cnt=[0]*self.V
cnt[s]=1
heapq.heappush(que, (0, s)) # 始点の(最短距離, 頂点番号)をヒープに追加する
while len(que) != 0:
cost, v = heapq.heappop(que)
# キューに格納されている最短経路の候補がdの距離よりも大きければ、他の経路で最短経路が存在するので、処理をスキップ
if d[v] < cost: continue
for i in range(len(self.G[v])):
# 頂点vに隣接する各頂点に関して、頂点vを経由した場合の距離を計算し、今までの距離(d)よりも小さければ更新する
e = self.G[v][i] # vのi個目の隣接辺e
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost # dの更新
heapq.heappush(que, (d[e.to], e.to)) # キューに新たな最短経路の候補(最短距離, 頂点番号)の情報をpush
cnt[e.to]=cnt[v]%mod
elif d[e.to]==d[v]+e.cost:
cnt[e.to]+=cnt[v]
cnt[e.to]%=mod
return d,cnt
import sys
input=sys.stdin.readline
sys.setrecursionlimit(1000000)
N,M=list(map(int,input().split()))
S,T=list(map(int,input().split()))
mati=Dijkstra(N)
for i in range(M):
u,v,d=list(map(int,input().split()))
mati.add(u-1,v-1,d)
mati.add(v-1,u-1,d)
spath,Sways=mati.shortest_path(S-1)
tpath,Tways=mati.shortest_path(T-1)
ans=Sways[T-1]*Tways[S-1]
ans%=mod
for u in range(N):
for e in mati.edge(u):
v=e.to
d=e.cost
ans-=(Tways[v]*Sways[u])**2*(spath[u]+d+tpath[v]==spath[T-1] and spath[u]+d!=tpath[v] and spath[u]!=tpath[v]+d and (tpath[v]+d>=spath[u]>=tpath[v] or tpath[v]+d>=spath[u]+d>=tpath[v]))
ans%=mod
for i in range(N):
ans-=(Tways[i]*Sways[i])**2*(spath[i]+tpath[i]==spath[T-1] and spath[i]==tpath[i])
ans%=mod
print((ans%mod))
| p03453 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n, m = LI()
s, t = LI()
graph = [[] for _ in range(n)]
for i in range(m):
u, v, d = list(map(int, input().split()))
graph[u - 1] += [(v - 1, d)]
graph[v - 1] += [(u - 1, d)]
vst = s - 1
v_g = t - 1
checked = [0] * n
dist = [INF] * n
route_cnt = [0] * n
route_cnt[vst] = 1
dist[vst] = 0
for _ in range(n):
min_dist = INF
for i in range(n):
if checked[i] == 0 and dist[i] < min_dist:
target_v = i
min_dist = dist[i]
checked[target_v] = 1
for to_v, cost in graph[target_v]:
if checked[to_v]:
continue
if dist[target_v] + cost < dist[to_v]:
dist[to_v] = dist[target_v] + cost
route_cnt[to_v] = route_cnt[target_v]
elif dist[target_v] + cost == dist[to_v]:
route_cnt[to_v] = (route_cnt[to_v] + route_cnt[target_v]) % mod
if target_v == v_g:
break
total_dist = dist[v_g]
half_dist = dist[v_g] / 2
enc_li = []
checked = [0] * n
reverse_dist = [INF] * n
reverse_route_cnt = [0] * n
reverse_route_cnt[v_g] = 1
reverse_dist[v_g] = 0
for _ in range(n):
min_dist = INF
for i in range(n):
if checked[i] == 0 and reverse_dist[i] < min_dist:
target_v = i
min_dist = reverse_dist[i]
checked[target_v] = 1
for to_v, cost in graph[target_v]:
if checked[to_v] or reverse_dist[target_v] + cost != total_dist - dist[to_v]:
continue
if reverse_dist[target_v] + cost < reverse_dist[to_v]:
reverse_dist[to_v] = reverse_dist[target_v] + cost
reverse_route_cnt[to_v] = reverse_route_cnt[target_v]
elif reverse_dist[target_v] + cost == reverse_dist[to_v]:
reverse_route_cnt[to_v] = (reverse_route_cnt[target_v] + reverse_route_cnt[to_v]) % mod
if reverse_dist[target_v] <= half_dist < reverse_dist[to_v]:
enc_li += [(to_v, target_v)]
ret = 0
for from_v, to_v, in enc_li:
ret += route_cnt[from_v] * reverse_route_cnt[to_v] % mod
ret %= mod
print(((route_cnt[v_g] ** 2 % mod - ret) % mod))
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 15
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n, m = LI()
s, t = LI()
G = [[] for _ in range(n)]
for i in range(m):
a, b, c = LI()
G[a - 1] += [(b - 1, c)]
G[b - 1] += [(a - 1, c)]
def dijkstra(graph, start=0):
route_cnt = [start] * n
route_cnt[start] = 1
que = [(0, start)]
dist = [INF] * n
dist[start] = 0
while que:
min_dist, u = heappop(que)
if min_dist > dist[u]:
continue
for v, c in graph[u]:
if dist[u] + c < dist[v]:
dist[v] = dist[u] + c
route_cnt[v] = route_cnt[u]
heappush(que, (dist[u] + c , v))
elif dist[u] + c == dist[v]:
route_cnt[v] = (route_cnt[v] + route_cnt[u]) % mod
return route_cnt, dist
route_cnt, dist = dijkstra(G, s - 1)
r_route_cnt, r_dist = dijkstra(G, t - 1)
total_dist = dist[t - 1]
ret = 0
for i in range(n):
if dist[i] == r_dist[i]:
ret = ret + (route_cnt[i] * r_route_cnt[i] % mod) ** 2 % mod
for u in range(n):
for v, c in G[u]:
if dist[u] < total_dist / 2 < dist[v] and dist[u] + c + r_dist[v] == total_dist:
ret = (ret + route_cnt[u] ** 2 % mod * r_route_cnt[v] ** 2 % mod) % mod
print(((route_cnt[t - 1] ** 2 - ret) % mod)) | p03453 |
# ARC090E
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
n, m = list(map(int, input().split()))
s, t = list(map(int, input().split()))
s -= 1
t -= 1
from collections import defaultdict
ns = defaultdict(set)
ds = [None] * m
es = {}
for i in range(m):
u, v, d = list(map(int, input().split()))
ns[u-1].add(v-1)
ns[v-1].add(u-1)
ds[i] = d
es[u-1,v-1] = i
es[v-1,u-1] = i
def dijkstra(start):
import heapq
h = []
heapq.heapify(h)
vals = [None] * n
nums = [None] * n
nums[start] = 1
prevs = defaultdict(dict)
heapq.heappush(h, (0, start)) # (距離, ノード番号, 種類数)
while h:
val, u = heapq.heappop(h)
# print(val, u)
vals[u] = val
for v in ns[u]:
d = ds[es[u,v]]
if vals[v] is None or vals[v]>val+d:
vals[v] = val+d
nums[v] = nums[u]
for vv in ns[v]:
prevs[v] = {}
prevs[v][u] = nums[u]
heapq.heappush(h, (val+d, v))
elif vals[v] is not None and vals[v]==val+d:
prevs[v][u] = nums[u] if u not in prevs[v] else prevs[v][u] + nums[u]
nums[v] += nums[u]
# heapq.heappush(h, (val+d, v))
return vals, nums, prevs
vals1, nums1, prevs1 = dijkstra(s)
vals2, nums2, prevs2 = dijkstra(t)
T = vals1[t]
ss = set()
q = [t]
while q:
u = q.pop()
ss.add(u)
for v in list(prevs1[u].keys()):
if v not in ss:
q.append(v)
c1 = 0 # 頂点で衝突するペアの数
for u in range(n):
if vals1[u]==T/2 and u in ss:
c1 += (nums1[u] * nums2[u])**2
c2 = 0 # エッジ(端点除く)で衝突するペアの数
for u in range(n):
if vals1[u]>=T/2 or u not in ss:
continue
for v in ns[u]:
if vals1[u]>vals1[v] or v not in ss:
continue
if vals1[u] + ds[es[u,v]] > T/2:
c2 += (nums1[u] * nums2[v])**2
# print(u,v, (nums1[u] * nums2[v])**2)
print((nums1[t]**2 - (c1+c2))) | # ARC090E
def hoge():
M = 10**9 + 7
import sys
input = lambda : sys.stdin.readline().rstrip()
n, m = list(map(int, input().split()))
s, t = list(map(int, input().split()))
s -= 1
t -= 1
from collections import defaultdict
ns = defaultdict(set)
for i in range(m):
u, v, d = list(map(int, input().split()))
ns[u-1].add((v-1, d))
ns[v-1].add((u-1, d))
def _dijkstra(N, s, Edge):
import heapq
geta = 10**15
inf = geta
dist = [inf] * N
dist[s] = 0
Q = [(0, s)]
dp = [0]*N
dp[s] = 1
while Q:
dn, vn = heapq.heappop(Q)
if dn > dist[vn]:
continue
for vf, df in Edge[vn]:
if dist[vn] + df < dist[vf]:
dist[vf] = dist[vn] + df
dp[vf] = dp[vn]
heapq.heappush(Q, (dn + df,vf))
elif dist[vn] + df == dist[vf]:
dp[vf] = (dp[vf] + dp[vn]) % M
return dist, dp
def dijkstra(start):
import heapq
vals = [None] * n
nums = [None] * n
nums[start] = 1
h = [(0, start)] # (距離, ノード番号)
vals[start] = 0
while h:
val, u = heapq.heappop(h)
for v, d in ns[u]:
if vals[v] is None or vals[v]>val+d:
vals[v] = val+d
nums[v] = nums[u]
heapq.heappush(h, (vals[v], v))
elif vals[v] is not None and vals[v]==val+d:
nums[v] = (nums[v] + nums[u]) % M
return vals, nums
vals1, nums1 = dijkstra(s)
vals2, nums2 = dijkstra(t)
T = vals1[t]
c1 = 0 # 頂点で衝突するペアの数
c2 = 0 # エッジ(端点除く)で衝突するペアの数
for u in range(n):
if 2*vals1[u]==T and 2*vals2[u]==T:
c1 = (c1 + pow((nums1[u] * nums2[u]), 2, M)) % M
for v,d in ns[u]:
if (vals1[u]+d+vals2[v]==T) and (2*vals1[u] < T < 2*(vals1[u] + d)):
c2 = (c2 + (nums1[u] * nums2[v])**2) % M
print(((nums1[t]*nums2[s] - (c1+c2)) % M))
hoge() | p03453 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def 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 input()
def pf(s): return print(s, flush=True)
def main():
n,m = LI()
s,t = LI()
e = collections.defaultdict(list)
for _ in range(m):
u,v,d = LI()
e[u].append((v,d))
e[v].append((u,d))
def search(s,t):
d = collections.defaultdict(lambda: [inf, 0])
d[s] = [0, 1]
q = []
heapq.heappush(q, (0, s))
v = collections.defaultdict(bool)
while len(q):
k, u = heapq.heappop(q)
if v[u]:
continue
v[u] = True
if u == t:
return d
uc = d[u][1]
for uv, ud in e[u]:
if v[uv]:
continue
vd = k + ud
if d[uv][0] > vd:
d[uv] = [vd, uc]
heapq.heappush(q, (vd, uv))
elif d[uv][0] == vd:
d[uv][1] += uc
return d
d1 = search(s,t)
rd = d1[t][0]
kk = rd / 2.0
def search2(s,t):
d = collections.defaultdict(lambda: [inf, 0])
d[s] = [0, 1]
q = []
heapq.heappush(q, (0, s))
v = collections.defaultdict(bool)
while len(q):
k, u = heapq.heappop(q)
if v[u]:
continue
v[u] = True
if u == t or k > kk:
return d
uc = d[u][1]
dt = d1[u][0]
for uv, ud in e[u]:
if v[uv] or dt - ud != d1[uv][0]:
continue
vd = k + ud
if d[uv][0] > vd:
d[uv] = [vd, uc]
heapq.heappush(q, (vd, uv))
elif d[uv][0] == vd:
d[uv][1] += uc
return d
d2 = search2(t,s)
r = d1[t][1] ** 2 % mod
for k in list(d1.keys()):
t,c = d1[k]
if t > kk:
continue
if t == kk:
if d2[k][0] == t:
r -= (c**2 * d2[k][1]**2) % mod
continue
for uv, ud in e[k]:
if d2[uv][0] >= kk or t + ud + d2[uv][0] != rd:
continue
r -= (c**2 * d2[uv][1]**2) % mod
return r % mod
print(main())
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def 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 input()
def pf(s): return print(s, flush=True)
def main():
n,m = LI()
s,t = LI()
e = collections.defaultdict(list)
for _ in range(m):
u,v,d = LI()
e[u].append((v,d))
e[v].append((u,d))
def search(s,t):
d = collections.defaultdict(lambda: [inf, 0])
d[s] = [0, 1]
q = []
heapq.heappush(q, (0, s))
v = collections.defaultdict(bool)
while len(q):
k, u = heapq.heappop(q)
if v[u]:
continue
v[u] = True
if u == t:
return d
uc = d[u][1]
for uv, ud in e[u]:
if v[uv]:
continue
vd = k + ud
if d[uv][0] < vd:
continue
if d[uv][0] > vd:
d[uv] = [vd, uc]
heapq.heappush(q, (vd, uv))
elif d[uv][0] == vd:
d[uv][1] += uc
return d
d1 = search(s,t)
d2 = search(t,s)
rd = d1[t][0]
kk = rd / 2.0
r = d1[t][1] ** 2 % mod
for k in list(d1.keys()):
t,c = d1[k]
if t > kk:
continue
if t == kk:
if d2[k][0] == t:
r -= (c**2 * d2[k][1]**2) % mod
continue
for uv, ud in e[k]:
if d2[uv][0] >= kk or t + ud + d2[uv][0] != rd:
continue
r -= (c**2 * d2[uv][1]**2) % mod
return r % mod
print(main())
| p03453 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def 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 input()
def pf(s): return print(s, flush=True)
def main():
n,m = LI()
s,t = LI()
e = collections.defaultdict(list)
for _ in range(m):
u,v,d = LI()
e[u].append((v,d))
e[v].append((u,d))
def search(s,t):
d = collections.defaultdict(lambda: [inf, 0])
d[s] = [0, 1]
q = []
heapq.heappush(q, (0, s))
v = collections.defaultdict(bool)
while len(q):
k, u = heapq.heappop(q)
if v[u]:
continue
v[u] = True
if u == t:
return d
uc = d[u][1]
for uv, ud in e[u]:
if v[uv]:
continue
vd = k + ud
if d[uv][0] < vd:
continue
if d[uv][0] > vd:
d[uv] = [vd, uc]
heapq.heappush(q, (vd, uv))
elif d[uv][0] == vd:
d[uv][1] += uc
return d
d1 = search(s,t)
d2 = search(t,s)
rd = d1[t][0]
kk = rd / 2.0
r = d1[t][1] ** 2 % mod
for k in list(d1.keys()):
t,c = d1[k]
if t > kk:
continue
if t == kk:
if d2[k][0] == t:
r -= (c**2 * d2[k][1]**2) % mod
continue
for uv, ud in e[k]:
if d2[uv][0] >= kk or t + ud + d2[uv][0] != rd:
continue
r -= (c**2 * d2[uv][1]**2) % mod
return r % mod
print(main())
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def 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 input()
def pf(s): return print(s, flush=True)
def main():
n,m = LI()
s,t = LI()
e = collections.defaultdict(list)
for _ in range(m):
u,v,d = LI()
e[u].append((v,d))
e[v].append((u,d))
def search(s,t):
d = collections.defaultdict(lambda: inf)
dc = collections.defaultdict(int)
d[s] = 0
dc[s] = 1
q = []
heapq.heappush(q, (0, s))
v = collections.defaultdict(bool)
while len(q):
k, u = heapq.heappop(q)
if v[u]:
continue
v[u] = True
if u == t:
return (d,dc)
uc = dc[u]
for uv, ud in e[u]:
if v[uv]:
continue
vd = k + ud
if d[uv] < vd:
continue
if d[uv] > vd:
d[uv] = vd
dc[uv] = uc
heapq.heappush(q, (vd, uv))
elif d[uv] == vd:
dc[uv] += uc
return (d,dc)
d1,dc1 = search(s,t)
d2,dc2 = search(t,s)
rd = d1[t]
kk = rd / 2.0
r = dc1[t] ** 2 % mod
for k in list(d1.keys()):
t = d1[k]
c = dc1[k]
if t > kk:
continue
if t == kk:
if d2[k] == t:
r -= (c**2 * dc2[k]**2) % mod
continue
for uv, ud in e[k]:
if d2[uv] >= kk or t + ud + d2[uv] != rd:
continue
r -= (c**2 * dc2[uv]**2) % mod
return r % mod
print(main())
| p03453 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def 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 input()
def pf(s): return print(s, flush=True)
def main():
n,m = LI()
s,t = LI()
e = collections.defaultdict(list)
for _ in range(m):
u,v,d = LI()
e[u].append((v,d))
e[v].append((u,d))
def search(s,t):
d = collections.defaultdict(lambda: inf)
dc = collections.defaultdict(int)
d[s] = 0
dc[s] = 1
q = []
heapq.heappush(q, (0, s))
v = collections.defaultdict(bool)
while len(q):
k, u = heapq.heappop(q)
if v[u]:
continue
v[u] = True
if u == t:
return (d,dc)
uc = dc[u]
for uv, ud in e[u]:
if v[uv]:
continue
vd = k + ud
if d[uv] < vd:
continue
if d[uv] > vd:
d[uv] = vd
dc[uv] = uc
heapq.heappush(q, (vd, uv))
elif d[uv] == vd:
dc[uv] += uc
return (d,dc)
d1,dc1 = search(s,t)
d2,dc2 = search(t,s)
rd = d1[t]
kk = rd / 2.0
r = dc1[t] ** 2 % mod
for k in list(d1.keys()):
t = d1[k]
c = dc1[k]
if t > kk:
continue
if t == kk:
if d2[k] == t:
r -= (c**2 * dc2[k]**2) % mod
continue
for uv, ud in e[k]:
if d2[uv] >= kk or t + ud + d2[uv] != rd:
continue
r -= (c**2 * dc2[uv]**2) % mod
return r % mod
print(main())
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def 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 input()
def pf(s): return print(s, flush=True)
def main():
n,m = LI()
s,t = LI()
e = collections.defaultdict(list)
for _ in range(m):
u,v,d = LI()
e[u].append((v,d))
e[v].append((u,d))
def search(s,t):
d = collections.defaultdict(lambda: inf)
dc = collections.defaultdict(int)
d[s] = 0
dc[s] = 1
q = []
heapq.heappush(q, (0, s))
v = collections.defaultdict(bool)
while len(q):
k, u = heapq.heappop(q)
if v[u]:
continue
v[u] = True
dc[u] %= mod
if u == t:
return (d,dc)
uc = dc[u]
for uv, ud in e[u]:
if v[uv]:
continue
vd = k + ud
if d[uv] < vd:
continue
if d[uv] > vd:
d[uv] = vd
dc[uv] = uc
heapq.heappush(q, (vd, uv))
elif d[uv] == vd:
dc[uv] += uc
return (d,dc)
d1,dc1 = search(s,t)
d2,dc2 = search(t,s)
rd = d1[t]
kk = rd / 2.0
r = dc1[t] ** 2 % mod
for k in list(d1.keys()):
t = d1[k]
c = dc1[k]
if t > kk:
continue
if t == kk:
if d2[k] == t:
r -= (c**2 * dc2[k]**2) % mod
continue
for uv, ud in e[k]:
if d2[uv] >= kk or t + ud + d2[uv] != rd:
continue
r -= (c**2 * dc2[uv]**2) % mod
return r % mod
print(main())
| p03453 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def 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 input()
def pf(s): return print(s, flush=True)
def main():
n,m = LI()
s,t = LI()
e = collections.defaultdict(list)
for _ in range(m):
u,v,d = LI()
e[u].append((v,d))
e[v].append((u,d))
def search(s,t):
d = collections.defaultdict(lambda: inf)
dc = collections.defaultdict(int)
d[s] = 0
dc[s] = 1
q = []
heapq.heappush(q, (0, s))
v = collections.defaultdict(bool)
while len(q):
k, u = heapq.heappop(q)
if v[u]:
continue
v[u] = True
dc[u] %= mod
if u == t:
return (d,dc)
uc = dc[u]
for uv, ud in e[u]:
if v[uv]:
continue
vd = k + ud
if d[uv] < vd:
continue
if d[uv] > vd:
d[uv] = vd
dc[uv] = uc
heapq.heappush(q, (vd, uv))
elif d[uv] == vd:
dc[uv] += uc
return (d,dc)
d1,dc1 = search(s,t)
d2,dc2 = search(t,s)
rd = d1[t]
kk = rd / 2.0
r = dc1[t] ** 2 % mod
for k in list(d1.keys()):
t = d1[k]
c = dc1[k]
if t > kk:
continue
if t == kk:
if d2[k] == t:
r -= (c**2 * dc2[k]**2) % mod
continue
for uv, ud in e[k]:
if d2[uv] >= kk or t + ud + d2[uv] != rd:
continue
r -= (c**2 * dc2[uv]**2) % mod
return r % mod
print(main())
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def 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 input()
def pf(s): return print(s, flush=True)
def main():
n,m = LI()
s,t = LI()
e = collections.defaultdict(list)
for _ in range(m):
u,v,d = LI()
e[u].append((v,d))
e[v].append((u,d))
def search(s,t):
d = collections.defaultdict(lambda: inf)
dc = collections.defaultdict(int)
d[s] = 0
dc[s] = 1
q = []
heapq.heappush(q, (0, s))
v = collections.defaultdict(bool)
while len(q):
k, u = heapq.heappop(q)
if v[u]:
continue
v[u] = True
dc[u] %= mod
if u == t:
return (d,dc)
uc = dc[u]
for uv, ud in e[u]:
if v[uv]:
continue
vd = k + ud
if d[uv] < vd:
continue
if d[uv] > vd:
d[uv] = vd
dc[uv] = uc
heapq.heappush(q, (vd, uv))
elif d[uv] == vd:
dc[uv] += uc
return (d,dc)
d1,dc1 = search(s,t)
d2,dc2 = search(t,s)
rd = d1[t]
kk = rd / 2.0
r = dc1[t] ** 2 % mod
for k in list(d1.keys()):
t = d1[k]
c = dc1[k]
if t > kk:
continue
if t == kk:
if d2[k] == t:
r -= pow(c,2,mod) * pow(dc2[k],2,mod) % mod
continue
for uv, ud in e[k]:
if d2[uv] >= kk or t + ud + d2[uv] != rd:
continue
r -= pow(c,2,mod) * pow(dc2[uv],2,mod) % mod
return r % mod
print(main())
| p03453 |
import heapq
def dijkstra(start: int, graph: list) -> list:
"""dijkstra法: 始点startから各頂点への最短距離を求める
計算量: O((E+V)logV)
"""
INF = 10 ** 18
MOD = 10 ** 9 + 7
n = len(graph)
dist = [INF] * n
ptn = [0] * n
dist[start] = 0
ptn[start] = 1
q = [(0, start)] # q = [(startからの距離, 現在地)]
while q:
d, v = heapq.heappop(q)
if dist[v] < d:
continue
for nxt_v, cost in graph[v]:
if dist[v] + cost == dist[nxt_v]:
ptn[nxt_v] += ptn[v]
ptn[nxt_v] %= MOD
if dist[v] + cost < dist[nxt_v]:
dist[nxt_v] = dist[v] + cost
ptn[nxt_v] = ptn[v]
ptn[nxt_v] %= MOD
heapq.heappush(q, (dist[nxt_v], nxt_v))
return dist, ptn
n, m = list(map(int, input().split()))
s, t = list(map(int, input().split()))
info = [list(map(int, input().split())) for i in range(m)]
MOD = 10 ** 9 + 7
s -= 1
t -= 1
graph = [[] for i in range(n)]
for a, b, cost in info:
a -= 1
b -= 1
graph[a].append((b, cost))
graph[b].append((a, cost))
dist_st, ptn_st = dijkstra(s, graph)
dist_ts, ptn_ts = dijkstra(t, graph)
min_cost, max_ptn = dist_st[t], ptn_st[t]
all_ptn = (max_ptn * max_ptn) % MOD
# 最短路で使用する頂点を復元
use = [False] * n
use[t] = True
stack = [t]
while stack:
v = stack.pop()
for prv_v, cost in graph[v]:
if use[prv_v]:
continue
if dist_st[v] == dist_st[prv_v] + cost:
use[prv_v] = True
stack.append(prv_v)
# 頂点上で出会うとき
for i in range(n):
if dist_st[i] == dist_ts[i] and use[i]:
all_ptn -= (ptn_st[i] * ptn_ts[i]) ** 2
all_ptn %= MOD
# 辺上で出会うとき
for a, b, cost in info:
a -= 1
b -= 1
if abs(dist_st[a] - dist_st[b]) != cost:
continue
if (not use[a]) or (not use[b]):
continue
if dist_st[a] > dist_st[b]:
a, b = b, a
if dist_st[a] < dist_ts[a] and dist_st[b] > dist_ts[b]:
all_ptn -= (ptn_st[a] * ptn_ts[b]) ** 2
all_ptn %= MOD
print(all_ptn) | import heapq
import sys
input = sys.stdin.buffer.readline
def dijkstra(start: int, graph: list) -> list:
"""dijkstra法: 始点startから各頂点への最短距離を求める
計算量: O((E+V)logV)
"""
INF = 10 ** 18
MOD = 10 ** 9 + 7
n = len(graph)
dist = [INF] * n
ptn = [0] * n
dist[start] = 0
ptn[start] = 1
q = [(0, start)] # q = [(startからの距離, 現在地)]
while q:
d, v = heapq.heappop(q)
if dist[v] < d:
continue
for nxt_v, cost in graph[v]:
if dist[v] + cost == dist[nxt_v]:
ptn[nxt_v] += ptn[v]
ptn[nxt_v] %= MOD
if dist[v] + cost < dist[nxt_v]:
dist[nxt_v] = dist[v] + cost
ptn[nxt_v] = ptn[v]
ptn[nxt_v] %= MOD
heapq.heappush(q, (dist[nxt_v], nxt_v))
return dist, ptn
n, m = list(map(int, input().split()))
s, t = list(map(int, input().split()))
info = [list(map(int, input().split())) for i in range(m)]
MOD = 10 ** 9 + 7
s -= 1
t -= 1
graph = [[] for i in range(n)]
for a, b, cost in info:
a -= 1
b -= 1
graph[a].append((b, cost))
graph[b].append((a, cost))
dist_st, ptn_st = dijkstra(s, graph)
dist_ts, ptn_ts = dijkstra(t, graph)
min_cost, max_ptn = dist_st[t], ptn_st[t]
all_ptn = (max_ptn * max_ptn) % MOD
# 最短路で使用する頂点を復元
use = [False] * n
use[t] = True
stack = [t]
while stack:
v = stack.pop()
for prv_v, cost in graph[v]:
if use[prv_v]:
continue
if dist_st[v] == dist_st[prv_v] + cost:
use[prv_v] = True
stack.append(prv_v)
# 頂点上で出会うとき
for i in range(n):
if dist_st[i] == dist_ts[i] and use[i]:
all_ptn -= (ptn_st[i] * ptn_ts[i]) ** 2
all_ptn %= MOD
# 辺上で出会うとき
for a, b, cost in info:
a -= 1
b -= 1
if abs(dist_st[a] - dist_st[b]) != cost:
continue
if (not use[a]) or (not use[b]):
continue
if dist_st[a] > dist_st[b]:
a, b = b, a
if dist_st[a] < dist_ts[a] and dist_st[b] > dist_ts[b]:
all_ptn -= (ptn_st[a] * ptn_ts[b]) ** 2
all_ptn %= MOD
print(all_ptn) | p03453 |
# 写経
# https://atcoder.jp/contests/agc011/submissions/1157055
class UnionFind:
def __init__(self, n):
self.v = [-1 for _ in range(n)]
def find(self, x):
if self.v[x] < 0:
return x
else:
self.v[x] = self.find(self.v[x])
return self.v[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if -self.v[x] < -self.v[y]:
x, y = y, x
self.v[x] += self.v[y]
self.v[y] = x
def root(self, x):
return self.v[x] < 0
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.v[self.find(x)]
N, M = list(map(int, input().split()))
uf = UnionFind(2 * N)
for _ in range(M):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
uf.unite(u, N + v)
uf.unite(N + u, v)
alone = 0
bi = 0
unko = 0
for u in range(N):
if uf.root(u) or uf.root(N + u):
if uf.size(u) == 1:
alone += 1
elif uf.same(u, N + u):
unko += 1
else:
bi += 1
ans = 0
ans += alone * N
ans += N * alone
ans -= alone * alone
ans += bi * bi * 2
ans += bi * unko
ans += unko * bi
ans += unko * unko
print(ans)
| '''
写経
https://youtu.be/cJ-WjtA34GQ?t=1899
https://atcoder.jp/contests/agc011/submissions/1157055
http://noshi91.hatenablog.com/entry/2018/04/17/183132
https://camypaper.bitbucket.io/2016/12/18/adc2016/
'''
class UnionFind:
def __init__(self, n):
self.v = [-1 for _ in range(n)] # 根(負): 連結頂点数 * (-1) / 子(正): 根の頂点番号(0-indexed)
def find(self, x): # xを含む木における根の頂点番号を返す
if self.v[x] < 0: # (負)は根
return x
else: # 根の頂点番号
self.v[x] = self.find(self.v[x]) # uniteでは, 旧根に属する頂点の根が旧根のままなので更新
return self.v[x]
def unite(self, x, y): # 違う根に属していたらrankが低くなるように連結
x = self.find(x)
y = self.find(y)
if x == y:
return
if -self.v[x] < -self.v[y]: # size比較, (-1) * (連結頂点数 * (-1)), (正)同士の大小比較
x, y = y, x # 連結頂点数が少ない方をyにすると, findでの更新回数が減る？
self.v[x] += self.v[y] # 連結頂点数の和を取る, 連結頂点数 * (-1)
self.v[y] = x # 連結頂点数が少ないy(引数yの根の頂点番号)の根をx(引数xの根の頂点番号)にする
def root(self, x):
return self.v[x] < 0 # (負)は根
def same(self, x, y):
return self.find(x) == self.find(y) # 同じ根に属するか
def size(self, x):
return -self.v[self.find(x)] # 連結頂点数を返す
N, M = list(map(int, input().split()))
uf = UnionFind(2 * N) # 全頂点 * 2(赤, 青の塗り分け)
for _ in range(M):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
uf.unite(u, N + v) # u, v: 赤で塗る / N + u, N + v: 青で塗る
uf.unite(N + u, v) # 隣り合う頂点を赤, 青または青, 赤で着色したものとして, 集合に加える(二部グラフならば矛盾※が出ない)
# print(uf.v)
alone = 0
bi = 0
unko = 0
for u in range(N):
if uf.root(u) or uf.root(N + u): # 根になりうる場合, 単独/二部はどちらもTrue, 二部グラフではない場合は, どちらかの頂点がTrue
if uf.size(u) == 1: # 単独ならu, N + uのどちらも単独なので, 片方調べればよい
alone += 1
elif uf.same(u, N + u): # ※同じ頂点の赤, 青が同じ集合にあれば塗り分けについて矛盾しており, 二部グラフではない
unko += 1
else:
bi += 1 # 二部グラフ
ans = 0
ans += alone * N
ans += N * alone
ans -= alone * alone
ans += bi * bi * 2
ans += bi * unko
ans += unko * bi
ans += unko * unko
print(ans)
| p03787 |
import queue
n,m=list(map(int,input().split()))
vis,ci,cb,cc=[0]*(n+1),0,0,0
g=[[] for i in range(n+1)]
def dfs(x):
stk,flag=queue.LifoQueue(),True
stk.put((x,1))
while not stk.empty():
u,col=stk.get()
if vis[u]:
flag&=(vis[u]==col)
continue
vis[u]=col
for i in g[u]:
stk.put((i,3-col))
return flag
for i in range(m):
u,v=list(map(int,input().split()))
g[u]+=[v]
g[v]+=[u]
for i in range(1,n+1):
if vis[i]==0:
if len(g[i])==0:
ci+=1
else:
if dfs(i):
cb+=1
else:
cc+=1
print((ci*ci+2*ci*(n-ci)+cc*cc+2*cb*cc+2*cb*cb)) | n,m=list(map(int,input().split()))
vis,ci,cb,cc=[0]*(n+1),0,0,0
g=[[] for i in range(n+1)]
for i in range(m):
u,v=list(map(int,input().split()))
g[u]+=[v]
g[v]+=[u]
for i in range(1,n+1):
if vis[i]==0:
if len(g[i])==0:
ci+=1
else:
s,f=[(i,1)],True
while len(s):
u,col=s.pop()
if vis[u]:
f&=(vis[u]==col)
continue
vis[u]=col
for i in g[u]:
s+=[(i,3-col)]
cb+=f
cc+=f^1
print((ci*ci+2*ci*(n-ci)+cc*cc+2*cb*cc+2*cb*cb)) | p03787 |
print((2*input().count('+')-4)) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
S = read().rstrip().decode('utf-8')
answer = 4-2*S.count('-')
print(answer) | p03315 |
import sys
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
S = LS2()
a = S.count('+')
b = S.count('-')
print((a-b)) | import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
S = LS2()
print((S.count('+')-S.count('-')))
| p03315 |
print((-4+2*input().count('+')))
| print((2*input().count('+')-4))
| p03315 |
from bisect import bisect_left as bl
def search_left(in_ind, alst, outs, doors):
tmp = bl(outs, in_ind)
if tmp == 0:
return 0
out_ind = outs[tmp - 1]
right_door = bl(doors, in_ind) - 1
if right_door < 0:
return alst[in_ind]
left_door = bl(doors, out_ind)
ret = alst[in_ind]
for door_ind in doors[left_door:right_door + 1]:
if out_ind < door_ind < in_ind:
ret = min(ret, -alst[door_ind] - (in_ind - door_ind))
ret = max(0, ret)
return ret
def search_right(in_ind, alst, outs, doors):
tmp = bl(outs, in_ind)
if tmp == len(outs):
return 0
out_ind = outs[tmp]
right_door = bl(doors, out_ind) - 1
if right_door < 0:
return alst[in_ind]
left_door = bl(doors, in_ind)
ret = alst[in_ind]
for door_ind in doors[left_door:right_door + 1]:
if in_ind < door_ind < out_ind:
ret = min(ret, -alst[door_ind] - (door_ind - in_ind))
ret = max(0, ret)
return ret
def main():
w = int(eval(input()))
alst = list(map(int, input().split()))
outs = []
ins = []
doors = []
for ind, a in enumerate(alst):
if a > 0:
ins.append(ind)
elif a == 0:
outs.append(ind)
else:
doors.append(ind)
ans = 0
for in_ind in ins:
ans += max(search_left(in_ind, alst, outs, doors), search_right(in_ind, alst, outs, doors))
print(ans)
main()
| w = int(eval(input()))
alst = list(map(int, input().split()))
INF = 10 ** 20
acc = -INF
left = []
for i in range(w):
a = alst[i]
if a == 0:
acc = INF
elif a > 0:
acc -= 1
elif a < 0:
acc = min(acc - 1, -a)
left.append(acc)
acc = -INF
right = []
for i in range(w):
a = alst[w - i - 1]
if a == 0:
acc = INF
elif a > 0:
acc -= 1
elif a < 0:
acc = min(acc - 1, -a)
right.append(acc)
right.reverse()
print((sum([max(0, min(alst[i], max(left[i], right[i]))) for i in range(w)])))
| p01713 |
from queue import PriorityQueue
class State:
def __init__(self,index,time):
self.index=index
self.time=time
def __lt__(self,state):
return self.time>state.time
while 1:
try: n=int(eval(input()))
except: break
a=list(map(int,input().split()))
ts=[float("inf")]*n
vis=[False]*n
pq=PriorityQueue()
for i in range(n):
if a[i]==0:
pq.put(State(i,int(1e9)))
while pq.qsize():
cur=pq.get()
if cur.index<0 or n<=cur.index or vis[cur.index] or cur.time<0: continue
vis[cur.index]=True
if a[cur.index]<0:
cur.time=min(cur.time,-a[cur.index]-1)
ts[cur.index]=cur.time
pq.put(State(cur.index-1,cur.time-1))
pq.put(State(cur.index+1,cur.time-1))
res=0
for i in range(n):
if a[i]>0 and vis[i]:
res+=min(a[i],ts[i]+1)
print(res) | n=int(eval(input()))
a=list(map(int,input().split()))
ts=[0]*n
for indices in list(range(n)),reversed(list(range(n))):
t=0
for i in indices:
if a[i]==0: t=float("inf")
if a[i]<0: t=min(t,-a[i])
if a[i]>0: ts[i]=max(ts[i],min(a[i],t))
t-=1
print((sum(ts))) | p01713 |
N = int(eval(input()))
A = list(map(int, input().split()))
x = []
y = []
P = sorted((a for a in A if a >= 0), reverse=True)
Q = sorted(a for a in A if a < 0)
if not Q:
M = sum(P[:-2]) + (P[-2] - P[-1])
for _ in range(N - 2):
X = P.pop()
Y = P.pop()
x.append(X)
y.append(Y)
P.append(X - Y)
Y = P.pop()
X = P.pop()
x.append(X)
y.append(Y)
elif not P:
M = -sum(Q[:-2]) - (Q[-2] - Q[-1])
for _ in range(N - 1):
X = Q.pop()
Y = Q.pop()
x.append(X)
y.append(Y)
Q.append(X - Y)
else:
M = sum(abs(a) for a in A)
for _ in range(N - 1):
if len(P) == 1:
X = P.pop()
Y = Q.pop()
x.append(X)
y.append(Y)
P.append(X - Y)
else:
X = Q.pop()
Y = P.pop()
x.append(X)
y.append(Y)
Q.append(X - Y)
print(M)
for X, Y in zip(x, y):
print(('{} {}'.format(X, Y)))
| # 入力
N = int(eval(input()))
A = list(map(int, input().split()))
# 正-負をなるべく多く達成するように操作する
P = sorted((a for a in A if a >= 0), reverse=True)
Q = sorted(a for a in A if a < 0)
x, y = [], []
if len(P) == 2 and not Q:
Y, X = P.pop(), P.pop()
x.append(X)
y.append(Y)
P.append(X - Y)
if len(P) >= 3 and not Q:
X, Y = P.pop(), P.pop()
x.append(X)
y.append(Y)
Q.append(X - Y)
if not P and len(Q) >= 2:
X, Y = Q.pop(), Q.pop()
x.append(X)
y.append(Y)
P.append(X - Y)
while len(P) >= 2 and Q:
X, Y = Q.pop(), P.pop()
x.append(X)
y.append(Y)
Q.append(X - Y)
while Q:
X, Y = P.pop(), Q.pop()
x.append(X)
y.append(Y)
P.append(X - Y)
ans = (
'{}\n{}'.format(
P[0],
'\n'.join(
'{} {}'.format(X, Y)
for X, Y in zip(x, y)
)
)
)
# 出力
print(ans)
| p03007 |
from collections import deque
N = int(eval(input()))
A = (list(map(int, input().split())))
A = sorted(A)
A = deque(A)
l = []
for i in range(N - 1):
if i == N - 2:
ans = A[1] - A[0]
l.append("{} {}".format(A[1], A[0]))
elif i == N - 3:
left = A.popleft()
right = A.pop()
center = A.pop()
temp_left = abs(right - (left - center))
temp_right = abs(left - (right - center))
if temp_left >= temp_right:
A.appendleft(left - center)
A.append(right)
l.append("{} {}".format(left, center))
else:
A.append(right - center)
A.appendleft(left)
l.append("{} {}".format(right, center))
else:
left = A.popleft()
left2 = A.popleft()
right = A.pop()
right2 = A.pop()
temp_left = abs(right - (left - right2))
temp_right = abs(left - (right - left2))
if temp_left >= temp_right:
A.appendleft(left2)
A.appendleft(left - right2)
A.append(right)
l.append("{} {}".format(left, right2))
else:
A.append(right2)
A.append(right - left2)
A.appendleft(left)
l.append("{} {}".format(right, left2))
print(ans)
for line in l:
print(line) | N = int(eval(input()))
A = list(map(int, input().split()))
A = sorted(A)
leftest_val = A[0]
rightest_val = A[-1]
left_idx = 1
right_idx = N - 2
history = []
for i in range(N - 1):
left_val = A[left_idx]
right_val = A[right_idx]
if i == N - 2:
history.append("{} {}".format(rightest_val, leftest_val))
print((rightest_val - leftest_val))
elif left_val < 0:
history.append("{} {}".format(rightest_val, left_val))
rightest_val -= left_val
left_idx += 1
else:
history.append("{} {}".format(leftest_val, right_val))
leftest_val -= right_val
right_idx -= 1
for h in history:
print(h) | p03007 |
S = input()[::-1]
word = ['dream'[::-1], 'dreamer'[::-1], 'erase'[::-1], 'eraser'[::-1]]
judge = [True, True, True, True]
count = 0
while any(judge):
for i in range(len(word)):
if S[:len(word[i])] == word[i]:
S = S[len(word[i]):]
else:
count += 1
if S == '':
print('YES')
exit()
if count == 4:
print('NO')
exit()
count = 0 | a,b,c,d=[i[::-1] for i in ['dream','dreamer','erase','eraser']]
s,j=input()[::-1],True
while j:
j=False
for i in [a,b,c,d]:
if s.startswith(i): s=s[len(i):];j=True
print(('YNEOS'[len(s)>0::2])) | p03854 |
#!/usr/bin/env python3
import sys
YES = "YES" # type: str
NO = "NO" # type: str
def solve(S: str):
while len(S)>4:
if S[:11]=="dreameraser":
S=S[11:]
elif S[:10] == "dreamerase":
S= S[10:]
elif S[:6]=="eraser":
S= S[6:]
elif S[:5] == "erase" or S[:5]== "dream":
S=S[5:]
elif S[:7] == "dreamer":
S=S[7:]
else:
print(NO)
if len(S) == 0:
print(YES)
else:
print(NO)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
S = next(tokens) # type: str
solve(S)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
YES = "YES" # type: str
NO = "NO" # type: str
def solve(S: str):
S = S[::-1]
while len(S)>4:
if S[:6]=="resare":
S= S[6:]
elif S[:5] == "esare" or S[:5]== "maerd":
S=S[5:]
elif S[:7] == "remaerd":
S=S[7:]
else:
print(NO)
return
if len(S) == 0:
print(YES)
else:
print(NO)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
S = next(tokens) # type: str
solve(S)
if __name__ == '__main__':
main()
| p03854 |
S = input()[::-1]
day_dream_word = ["dreamer", "dream", "eraser", "erase"]
day_dream_word = list([s[::-1] for s in day_dream_word])
T = ""
res = False
partial_res = True
while not res and partial_res:
partial_res = False
for add_word in day_dream_word:
nextT = T
nextT += add_word
if S == nextT:
res = True
break
if S[:len(nextT)] == nextT:
partial_res = True
break
T = nextT
if res:
print('YES')
else:
print('NO') | S = input()[::-1]
day_dream_word = ["dreamer", "dream", "eraser", "erase"]
day_dream_word = list([s[::-1] for s in day_dream_word])
T = ""
Tindex = 0
res = False
partial_res = True
while not res and partial_res:
partial_res = False
for add_word in day_dream_word:
nextTindex = Tindex + len(add_word)
if S[Tindex:nextTindex] == add_word:
if len(S) == nextTindex:
res = True
break
else:
partial_res = True
break
Tindex = nextTindex
if res:
print('YES')
else:
print('NO') | p03854 |
A = ["dream", "dreamer", "erase", "eraser"]
for i in range(4):
A[i] = A[i][::-1]
S = input()[::-1]
idx = 0
while idx < len(S):
flag = False
for i in range(4):
if len(S) - idx < len(A[i]):
continue
else:
if S[idx:idx+len(A[i])] == A[i]:
flag = True
idx += len(A[i])
break
else:
continue
if idx >= len(S) or flag == False:
break
print((["NO","YES"][idx == len(S)])) | A = ['dream', 'dreamer', 'erase', 'eraser']
for i in range(len(A)):
A[i] = A[i][::-1]
s = input()[::-1]
i = 0
while True:
f = True
for a in A:
if len(a) > len(s) - i:
continue
if s[i:i+len(a)] == a:
i += len(a)
f = False
break
else:
if i == len(s):
print('YES')
exit()
if f == True:
print('NO')
exit()
print('YES') | p03854 |
s=input().replace("eraser","").replace("erase","").replace("dreamer","").replace("dream","")
print(("YES" if s=="" else "NO")) | s=input().replace("eraser","").replace("erase","").replace("dreamer","").replace("dream","")
if s in "":
print("YES")
else:
print("NO") | p03854 |
# coding: utf-8
"""this is python work script"""
CHECK_WORDS = ['dream', 'dreamer', 'erase', 'eraser']
def check_word(word, check_word_list):
find_word = False
# print(word, check_word_list)
for i, cw in enumerate(check_word_list):
find_result = word.find(cw)
# print(i, cw, find_result)
# # remove check word if not find it in string
# if find_result == -1:
# check_word_list.remove(cw)
# remove word if find it in string head
if find_result == 0:
word_length = len(cw)
word = word[word_length:]
find_word = True
# print(word, check_word_list)
return find_word, word
def solver(word, check_word_list):
"""solve this problem"""
wip = True
while wip:
wip, word = check_word(word, check_word_list)
answer = 'NO'
if len(word) == 0:
answer = 'YES'
return answer
def reverse_string_list(string_list):
answer_list = []
for word in string_list:
answer_list.append(word[::-1])
return answer_list
def main():
"""main function"""
word = input().rstrip()[::-1]
word_list = reverse_string_list(CHECK_WORDS)
answer = solver(word=word, check_word_list=word_list)
print(answer)
if __name__ == '__main__':
main()
| # coding: utf-8
"""this is python work script"""
def solver(word):
"""solve this problem"""
check_result = word.replace('eraser', '').replace('erase', '').replace('dreamer', '').replace('dream', '')
answer = 'YES'
if check_result:
answer = 'NO'
return answer
def main():
"""main function"""
input_word = input().rstrip()
answer = solver(input_word)
print(answer)
if __name__ == '__main__':
main()
| p03854 |
s = input()[::-1]
s = s.replace("eraser"[::-1], "")
s = s.replace("erase"[::-1], "")
s = s.replace("dreamer"[::-1], "")
s = s.replace("dream"[::-1], "")
if s == "":
print("YES")
else:
print("NO") | s = input()[::-1]
words = ["eraser","erase","dreamer","dream"]
for i in words:
s = s.replace(i[::-1], "")
if s == "": print("YES")
else: print("NO") | p03854 |
S = input()[::-1]
devide = ['dream', 'dreamer', 'erase', 'eraser']
for i in range(4):
devide[i] = devide[i] [::-1]
flag = True
i = 0
while i < len(S):
flag2 = False
for j in range(4):
if devide[j] == S[i : i+len(devide[j])]:
flag2 = True
i += len(devide[j])
if not flag2:
flag = False
break
print(('YES' if flag == True else 'NO')) | S = input().replace('eraser', '').replace('erase', '').replace('dreamer', '').replace('dream', '')
print(('YES' if len(S) == 0 else 'NO')) | p03854 |
def main():
S = input()[::-1]
tar = {'maerd', 'remaerd', 'esare', 'resare'}
i = 0
while i < len(S):
if S[i] == 'm':
if S[i:i+5] == 'maerd':
i += 5
else:
return print("NO")
elif S[i] == 'e':
if S[i:i+5] == 'esare':
i += 5
else:
return print("NO")
elif S[i] == 'r':
if S[i:i+6] == 'resare':
i += 6
elif S[i:i+7] == 'remaerd':
i += 7
else:
return print("NO")
else:
return print("NO")
print("YES")
if __name__ == '__main__':
main()
| def main():
S = input()
S = S[::-1]
ans = ["maerd", "remaerd", "esare", "resare"]
while S:
for a in ans:
if S[:5] in ans:
S = S.replace(S[:5], "", 1)
break
elif S[:6] in ans:
S = S.replace(S[:6], "", 1)
break
elif S[:7] in ans:
S = S.replace(S[:7], "", 1)
break
else:
return print("NO")
else:
return print("YES")
if __name__ == '__main__':
main()
| p03854 |
S = input()[::-1]
W = []
for w in ['dreamer', 'eraser', 'erase', 'dream']:
W.append(w[::-1])
while 1:
flg = False
for w in W:
if S.startswith(w):
S = S[len(w):]
flg = True
if not flg:
print('NO')
exit()
if not S:
break
print('YES')
| S = input()[::-1]
W = []
for w in ['dreamer', 'eraser', 'erase', 'dream']:
W.append(w[::-1])
idx = 0
while 1:
flg = False
for w in W:
if S.startswith(w, idx):
idx += len(w)
flg = True
if not flg:
print('NO')
exit()
if len(S) <= idx:
break
print('YES')
| p03854 |
import sys
input = sys.stdin.readline
S = list(input().rstrip())
while S:
if S[-1] == "m":
if S[-5:] == ["d", "r", "e", "a", "m"]:
S = S[:-5]
else:
print("NO")
sys.exit()
elif S[-1] == "e":
if S[-5:] == ["e", "r", "a", "s", "e"]:
S = S[:-5]
else:
print("NO")
elif S[-6:] == list("eraser"):
S = S[:-6]
elif S[-7:] == list("dreamer"):
S = S[:-7]
else:
print("NO")
sys.exit()
print("YES")
| import sys
input = sys.stdin.readline
S = input().rstrip()
while S:
if S[-5:] == "dream":
S = S[:-5]
elif S[-5:] == "erase":
S = S[:-5]
elif S[-6:] == "eraser":
S = S[:-6]
elif S[-7:] == "dreamer":
S = S[:-7]
else:
print("NO")
sys.exit()
print("YES")
| p03854 |
import sys
S=input()
judge=["dream","dreamer","erase","eraser"]
S_pointer=0
V=set()
V.add(0)
cnt=0
while cnt<len(S)/5+1:
tmp=set()
for i in V:
for j in judge:
if S[i:i+7].find(j)==0:
if i+len(j)==len(S):
tmp.add(i+len(j))
print("YES")
sys.exit()
else:
tmp.add(i+len(j))
V=V|tmp
cnt+=1
#print V
print("YES" if max(V)==len(S) else "NO") | import sys
S=input()
judge=["dream","dreamer","erase","eraser"]
V=set()
V.add(0)
cnt=0
while cnt<len(S):
tmp=set()
for i in V:
for j in judge:
if S[i:i+7].find(j)==0:
tmp.add(i+len(j))
if i+len(j)==len(S):
print("YES")
sys.exit()
V=tmp
cnt+=1
else:
print("NO")
| p03854 |
s=input()[::-1]
p=["maerd","remaerd","resare","esare"]
while True:
if s[:5]==p[0]:s=s.replace(p[0],"",1)
elif s[:5]==p[3]:s=s.replace(p[3],"",1)
elif s[:7]==p[1]:s=s.replace(p[1],"",1)
elif s[:6]==p[2]:s=s.replace(p[2],"",1)
else:
if s=="":print("YES");break
else:print("NO");break
| s=input()[::-1]
p=["maerd","remaerd","resare","esare"]
while True:
if s[:5]==p[0]:s=s[5:]
elif s[:5]==p[3]:s=s[5:]
elif s[:7]==p[1]:s=s[7:]
elif s[:6]==p[2]:s=s[6:]
else:
if s=="":print("YES");break
else:print("NO");break
| p03854 |
from re import sub
dest = input().rstrip("\n")
suffixes = ["dream$", "dreamer$", "erase$", "eraser$"]
while True:
len_before = len(dest)
for suffix in suffixes:
dest = sub(suffix, "", dest)
if len(dest) == len_before:
break
print(("YES" if not dest else "NO"))
| dest = input().rstrip("\n")
suffixes = ["dream", "dreamer", "erase", "eraser"]
cut_lens = [-5, -7, -5, -6]
while True:
for suffix, cut_len in zip(suffixes, cut_lens):
if dest.endswith(suffix):
dest = dest[:cut_len]
break
else:
break
print(("YES" if not dest else "NO"))
| p03854 |
def examA():
S = SI()
T = SI()
N = len(S)
ans = "No"
for i in range(N):
cur = S[i:] + S[:i]
#print(cur)
if cur==T:
ans = "Yes"
print(ans)
return
def examB():
H, W = LI()
S = [SI()for _ in range(H)]
flag = True
ans = 0
print(ans)
return
def examC():
L, R = LI()
ans = inf
if R-L>=3000:
R = L+3000
for l in range(L, R + 1):
for r in range(l+1, R + 1):
now = (l*r) %2019
ans = min(ans,now)
print(ans)
return
def examD():
T = {"dream", "dreamer", "erase", "eraser"}
S = SI()
ans = "NO"
t = ""
for s in S[::-1]:
t += s
if t[::-1] in T:
t = ""
if t=="":
ans = "YES"
print(ans)
return
def examE():
N = 50
K = I()
base = K//N
A = [base+i for i in range(N)]
rest = K%N
for i in range(rest):
A[-i-1] += 1
print(N)
print((" ".join(map(str,A))))
return
def examF():
N = 20
C = [2**i for i in range(N)]
L = I()
cur = 1
V = [[i+1, i+2, 0]for i in range(N-1)]
now = 1
while(now<N):
if C[now]<=L:
cur = C[now]
V.append([now,now+1,C[now-1]])
now += 1
else:
break
#print(cur)
for i in range(now)[::-1]:
if C[i]<=L-cur:
cost = cur
V.append([i+1,N,cost])
cur += C[i]
print((N,len(V)))
for s,t,c in V:
print((s,t,c))
return
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(eval(input()))
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]
sys.setrecursionlimit(10**7)
if __name__ == '__main__':
examD()
"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
""" | def examA():
S = SI()
T = SI()
N = len(S)
ans = "No"
for i in range(N):
cur = S[i:] + S[:i]
#print(cur)
if cur==T:
ans = "Yes"
print(ans)
return
def examB():
H, W = LI()
S = [SI()for _ in range(H)]
flag = True
ans = 0
print(ans)
return
def examC():
L, R = LI()
ans = inf
if R-L>=3000:
R = L+3000
for l in range(L, R + 1):
for r in range(l+1, R + 1):
now = (l*r) %2019
ans = min(ans,now)
print(ans)
return
def examD():
T = {"dream", "dreamer", "erase", "eraser"}
S = SI()
ans = "NO"
t = ""
for s in S[::-1]:
t += s
if t[::-1] in T:
t = ""
if len(t)>10:
print(ans)
return
if t=="":
ans = "YES"
print(ans)
return
def examE():
N = 50
K = I()
base = K//N
A = [base+i for i in range(N)]
rest = K%N
for i in range(rest):
A[-i-1] += 1
print(N)
print((" ".join(map(str,A))))
return
def examF():
N = 20
C = [2**i for i in range(N)]
L = I()
cur = 1
V = [[i+1, i+2, 0]for i in range(N-1)]
now = 1
while(now<N):
if C[now]<=L:
cur = C[now]
V.append([now,now+1,C[now-1]])
now += 1
else:
break
#print(cur)
for i in range(now)[::-1]:
if C[i]<=L-cur:
cost = cur
V.append([i+1,N,cost])
cur += C[i]
print((N,len(V)))
for s,t,c in V:
print((s,t,c))
return
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(eval(input()))
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]
sys.setrecursionlimit(10**7)
if __name__ == '__main__':
examD()
"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
""" | p03854 |
S = input().strip()
cur = 0
flag = 0
while cur<len(S):
if S[cur:cur+11]=="dreameraser":
cur += 11
elif S[cur:cur+10]=="dreamerase":
cur += 10
elif S[cur:cur+7]=="dreamer":
cur += 7
elif S[cur:cur+6]=="eraser":
cur += 6
elif S[cur:cur+5]=="dream" or S[cur:cur+5]=="erase":
cur += 5
else:
flag = 1
break
if flag==0:
print("YES")
else:
print("NO") | S = input().strip()
N = len(S)
if N<5:
print("NO")
else:
flag = 0
cur = N
while cur>0:
if cur>=7 and S[cur-7:cur]=="dreamer":
cur -= 7
elif cur>=6 and S[cur-6:cur]=="eraser":
cur -= 6
elif cur>=5 and S[cur-5:cur] in ["dream","erase"]:
cur -= 5
else:
flag = 1
break
if flag==0:
print("YES")
else:
print("NO") | p03854 |
S = input().strip()
N = len(S)
cur = 0
flag = 0
while cur<N:
if S[cur:cur+5]=="dream":
if cur+5==N:
cur += 5
elif cur+5<N and S[cur+5]=="d":
cur += 5
elif S[cur:cur+7]=="dreamer":
if cur+7==N:
cur += 7
elif S[cur+7] in ["d","e"]:
cur += 7
elif S[cur+7]=="a":
cur += 5
else:
flag = 1
break
elif S[cur:cur+5]=="erase":
if cur+5==N:
cur += 5
elif cur+5<N and S[cur+5]=="r":
cur += 6
elif cur+5<N and S[cur+5] in ["d","e"]:
cur += 5
else:
flag = 1
break
else:
flag=1
break
if flag==0:
print("YES")
else:
print("NO") | S = input().strip()
N = len(S)
cur = 0
flag = 0
while cur<N:
if S[cur:cur+5]=="dream":
if cur+5==N:
cur += 5
elif cur+5<N and S[cur+5]=="d":
cur += 5
elif S[cur:cur+7]=="dreamer":
if cur+7==N:
cur += 7
elif S[cur+7] in ["d","e"]:
cur += 7
elif S[cur+7]=="a":
cur += 5
else:
flag = 1
break
else:
flag=1
break
elif S[cur:cur+5]=="erase":
if cur+5==N:
cur += 5
elif cur+5<N and S[cur+5]=="r":
cur += 6
elif cur+5<N and S[cur+5] in ["d","e"]:
cur += 5
else:
flag = 1
break
else:
flag=1
break
if flag==0:
print("YES")
else:
print("NO") | p03854 |
S = input()
words = ("dream", "dreamer", "erase", "eraser")
for _ in range((len(S) + 4) // 5):
for word in words:
if S.endswith(word):
S = S[: -len(word)]
print("NO") if S else print("YES")
| S = input()
for w in ("eraser", "erase", "dreamer", "dream"):
S = S.replace(w, "")
print("NO") if S else print("YES")
| p03854 |
s=input()[::-1]
words=["dreamer","eraser","dream","erase"]
add=0
while add!=len(s):
cnt=0
for i in words:
length=len(i)
word=s[add:add+length][::-1]
if word==i:
add +=length
break
else:cnt +=1
if cnt==4:print("NO");exit()
print("YES") | s=input()[::-1]
T=["dream","dreamer","erase","eraser"]
l,n=0,len(s)
while l!=n:
flag=0
for i in T:
word=i[::-1]
if s[l:l+len(word)]==word:
l +=len(word)
flag=1
break
if flag==0:print("NO");exit()
print("YES") | p03854 |
s=input()[::-1]
T=["dream","dreamer","erase","eraser"]
l,n=0,len(s)
while l!=n:
flag=0
for i in T:
word=i[::-1]
if s[l:l+len(word)]==word:
l +=len(word)
flag=1
break
if flag==0:print("NO");exit()
print("YES") | s=input()[::-1]
T=["dream","dreamer","erase","eraser"]
l,n=0,len(s)
while l!=n:
flag=0
for i in T:
word=i[::-1]
if s[l:l+len(word)]==word:
l +=len(word)
flag=1
if flag==0:print("NO");exit()
print("YES") | p03854 |
def c_daydream(S):
import re
# Sを逆にしたものから該当する文字を除いていき、空文字列にできるか？
s = S[::-1]
dict = ['dream'[::-1], 'dreamer'[::-1], 'erase'[::-1], 'eraser'[::-1]]
n = len(s)
while n > 0:
for d in dict:
if s.startswith(d):
s = re.sub('^' + d, '', s)
break
else:
return 'NO'
n = len(s)
return 'YES'
S = input().strip()
print((c_daydream(S))) | def c_daydream(S):
# Sを逆にしたものから文字列を除いていき、空文字にできるか？
s = S[::-1]
n = len(s)
while True:
if n == 0:
return 'YES'
elif n >= 5 and s[:5] == 'maerd':
s = s[5:]
elif n >= 7 and s[:7] == 'remaerd':
s = s[7:]
elif n >= 5 and s[:5] == 'esare':
s = s[5:]
elif n >= 6 and s[:6] == 'resare':
s = s[6:]
else:
return 'NO'
n = len(s)
return None
S = input().strip()
print((c_daydream(S))) | p03854 |
s=input().replace("eraser","").replace("erase","").replace("dreamer","").replace("dream","")
if s:
print("NO")
else:
print("YES") | s = input().replace("eraser", "") .replace("erase", "").replace("dreamer", "").replace("dream", "")
print(("NO" if s else "YES")) | p03854 |
import bisect
import copy
import heapq
import sys
import itertools
import math
import queue
input = sys.stdin.readline
sys.setrecursionlimit(100000)
mod = 10 ** 9 + 7
def read_values(): return list(map(int, input().split()))
def read_index(): return [int(x) - 1 for x in input().split()]
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]
class V:
def __init__(self, f, v=None):
self.f = f
self.v = v
def __str__(self):
return str(self.v)
def ud(self, n):
if n is None:
return
if self.v is None:
self.v = n
return
self.v = self.f(self.v, n)
def main():
N = int(eval(input()))
A = read_list()
dp = [[[-10 ** 20 for _ in range(2)] for _ in range(N // 2 + 5)] for _ in range(N + 1)]
dp[1][0][0] = 0
dp[1][1][1] = A[0]
for i in range(1, N):
for k in range(max(0, i // 2 - 2), i // 2 + 2):
dp[i + 1][k][0] = max(dp[i][k][1], dp[i][k][0])
dp[i + 1][k + 1][1] = dp[i][k][0] + A[i]
print((max(dp[N][N // 2])))
if __name__ == "__main__":
main()
| import bisect
import copy
import heapq
import sys
import itertools
import math
import queue
input = sys.stdin.readline
sys.setrecursionlimit(100000)
mod = 10 ** 9 + 7
def read_values(): return list(map(int, input().split()))
def read_index(): return [int(x) - 1 for x in input().split()]
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]
class V:
def __init__(self, f, v=None):
self.f = f
self.v = v
def __str__(self):
return str(self.v)
def ud(self, n):
if n is None:
return
if self.v is None:
self.v = n
return
self.v = self.f(self.v, n)
def main():
N = int(eval(input()))
A = read_list()
dp = [[-10 ** 20 for _ in range(2)] for _ in range(N // 2 + 5)]
dp[0][0] = 0
dp[1][1] = A[0]
for i in range(1, N):
for k in range(i // 2 + 2, max(0, i // 2 - 2), -1):
dp[k][0] = max(dp[k][1], dp[k][0])
dp[k][1] = dp[k - 1][0] + A[i]
print((max(dp[N // 2])))
if __name__ == "__main__":
main()
| p02716 |
import sys
sys.setrecursionlimit(2*1000000)
N = int(eval(input()))
A = list(map(int, input().split(" ")))
dp_dict = {}
inf = -1*1000000000
def dp(i, j):
if j == 1:
return A[i]
if i+2 >= N:
return inf
if N//2-j < i//2-1:
return inf
temp = max([dp(i+2, j-1)+A[i], dp(i+1, j)])
dp_dict[(i, j)] = temp
return temp
select = N//2
if select == 1:
print((max(A)))
else:
print((dp(0, select))) | N = int(eval(input()))
A = [0]+list(map(int, input().split(" ")))
dp_list = [{0, 0}, {0: 0, 1: A[1]}, {0: 0, 1: A[1] if A[1] > A[2] else A[2]}]
for i in range(3, N+1):
b = (i-1)//2
f = (i+1)//2
dp_list.append({})
for j in range(b, f+1):
if j in dp_list[i-1]:
dp_list[i][j] = dp_list[i-2][j-1]+A[i] if dp_list[i -
2][j-1]+A[i] > dp_list[i-1][j] else dp_list[i-1][j]
else:
dp_list[i][j] = dp_list[i-2][j-1]+A[i]
print((dp_list[-1][N//2])) | p02716 |
from collections import defaultdict
N = int(eval(input()))
A = list(map(int, input().split()))
# dp[(i, x, flg)] := i番目までみてx個選んでいる時の最大値。flgは最後の１つをとったかどうか。
dp = defaultdict(lambda: -float('inf'))
dp[(0, 0, 0)] = 0
for i, a in enumerate(A, start=1):
j = i // 2
for x in range(j - 1, j + 2):
dp[(i, x, 0)] = max(dp[(i - 1, x, 0)], dp[(i - 1, x, 1)])
dp[(i, x, 1)] = dp[(i - 1, x - 1, 0)] + a
print((max(dp[(N, N // 2, 0)], dp[(N, N // 2, 1)])))
| from collections import defaultdict
N = int(eval(input()))
A = list(map(int, input().split()))
# dp[(i, x, flg)] := i番目までみてx個選んでいる時の最大値。flgは最後の１つをとったかどうか。
dp = defaultdict(lambda: -float('inf'))
dp[(0, 0, 0)] = 0
for i, a in enumerate(A, start=1):
for x in range((i - 1) // 2, (i + 1) // 2 + 1):
dp[(i, x, 0)] = max(dp[(i - 1, x, 0)], dp[(i - 1, x, 1)])
dp[(i, x, 1)] = dp[(i - 1, x - 1, 0)] + a
print((max(dp[(N, N // 2, 0)], dp[(N, N // 2, 1)])))
| p02716 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.