input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import time
from array import array
def solve(i, m):
if m == 0:
return True
if i >= n:
return False
return solve(i+1, m) or solve(i+1, m-A[i])
if __name__ == '__main__':
n = int(input())
A = array('I', list(map(int, input().split())))
q = int(input())
m = array('I', list(map(int, input().split())))
start = time.time()
for m_i in m:
print("yes" if solve(0, m_i) else "no")
end = time.time()
#print end - start | import time
def sequence(A, n):
dic = {}
def solve(i, m):
if (i, m) in dic:
return dic[(i, m)]
if m == 0:
dic[(i, m)] = True
elif i >= n:
dic[(i, m)] = False
elif solve(i+1, m):
dic[(i, m)] = True
elif solve(i+1, m-A[i]):
dic[(i, m)] = True
else:
dic[(i, m)] = False
return dic[(i, m)]
return solve
if __name__ == '__main__':
n = int(input())
A = list(map(int, input().split()))
q = int(input())
m = list(map(int, input().split()))
#start = time.time()
solve = sequence(A, n)
for m_i in m:
print("yes" if solve(0, m_i) else "no")
#end = time.time()
#print end - start | p02271 |
import itertools
numA = int(input().rstrip())
listA = list(map(int,input().rstrip().split(" ")))
numQ = int(input().rstrip())
listQ = list(map(int,input().rstrip().split(" ")))
sumA = []
cnt = 0
for i in range(1,numA+1):
tmpComb = list(itertools.combinations(listA, i))
for nums in tmpComb:
sumA.append(sum(nums))
for i in range(numQ):
if sumA.count(listQ[i]) > 0:
print("yes")
else:
print("no") | import itertools
numA = int(input().rstrip())
listA = list(map(int,input().rstrip().split(" ")))
numQ = int(input().rstrip())
listQ = list(map(int,input().rstrip().split(" ")))
sumA = set([])
cnt = 0
for i in range(1,numA+1):
tmpComb = list(itertools.combinations(listA, i))
for nums in tmpComb:
sumA.add(sum(nums))
for i in range(numQ):
if listQ[i] in sumA:
print("yes")
else:
print("no") | p02271 |
# coding: utf-8
N = int(eval(input()))
A = [int(i) for i in input().split()]
q = int(eval(input()))
m = [int(i) for i in input().split()]
MAX_LENGTH = len(A)
#i番目以降の値を使ってmを作ればTrueを返す
def fullSearch(i, m):
#終了条件
if m == 0:
return True
elif i >= MAX_LENGTH:
return False
else:
#全探索かっこわるい
return fullSearch(i + 1, m) or fullSearch(i + 1, m - A[i])
for i in m:
print(("yes" if fullSearch(0, i) else "no")) | # coding: utf-8
N = int(eval(input()))
A = [int(i) for i in input().split()]
q = int(eval(input()))
m = [int(i) for i in input().split()]
MAX_LENGTH = len(A)
dp = [[-1 for i in range(max(m) + 1)] for j in range(MAX_LENGTH + 1)]
# i番目以降の値を使ってmを作ればTrueを返す
def fullSearch(i, m):
# 終了条件
if m < 0:
return False
elif dp[i][m] != -1:
return dp[i][m]
elif m == 0:
return True
elif i >= MAX_LENGTH:
return False
else:
# 全探索かっこわるい
res = fullSearch(i + 1, m) or fullSearch(i + 1, m - A[i])
# のでメモ化
dp[i][m] = res
return res
for mi in m:
print(("yes" if fullSearch(0, mi) else "no")) | p02271 |
import itertools as it
n = int(eval(input()))
A = list(map(int, input().split()))
q = int(eval(input()))
m = list(map(int, input().split()))
s = set()
for i in range(n):
li= list(it.combinations(A, i+1))
for j in range(len(li)):
s.add(sum(li[j]))
for k in range(q):
print(('yes' if m[k] in s else 'no')) | from itertools import combinations
n = int(eval(input()))
A = list(map(int, input().split()))
q = int(eval(input()))
m = list(map(int, input().split()))
l = set(sum(t) for i in range(n) for t in combinations(A, i+1))
for j in m:
print(('yes' if j in l else 'no'))
| p02271 |
n = int(eval(input()))
A = list(map(int, input().split()))
q = int(eval(input()))
M = list(map(int, input().split()))
def solve(i, m):
if m == 0:
return True
if i >= n:
return False
res = solve(i + 1, m) or solve(i + 1, m - A[i])
return res
for m in M:
if solve(0, m):
print('yes')
else:
print('no') | n = int(eval(input()))
A = list(map(int, input().split()))
q = int(eval(input()))
M = list(map(int, input().split()))
memo = {}
def solve(i, m):
if m == 0:
return True
if i >= n:
return False
if memo.get((i, m), None) == None:
memo[(i, m)] = solve(i + 1, m) or solve(i + 1, m - A[i])
return memo[(i, m)]
for m in M:
if solve(0, m):
print('yes')
else:
print('no') | p02271 |
# coding=utf-8
def solve(i, m):
global A
if m == 0:
ever_calc[i][m] = True
return True
elif m < 0:
ever_calc[i][m] = False
return False
elif i == n:
ever_calc[i][m] = False
return False
else:
result = (solve(i+1, m) or solve(i+1, m-A[i]))
ever_calc[i][m] = result
return result
n = int(eval(input()))
A = tuple(map(int, input().split()))
q = int(eval(input()))
M = tuple(map(int, input().split()))
sum_A = sum(A)
ever_calc = [[None] * 2000 for i in range(n+1)]
for m in M:
if m > sum_A:
print('no')
elif solve(0, m):
print('yes')
else:
print('no') | # coding=utf-8
def solve(i, m):
global A
if ever_calc[i][m] != None:
return ever_calc[i][m]
if m == 0:
ever_calc[i][m] = True
return True
elif m < 0:
ever_calc[i][m] = False
return False
elif i == n:
ever_calc[i][m] = False
return False
else:
result = (solve(i+1, m) or solve(i+1, m-A[i]))
ever_calc[i][m] = result
return result
n = int(eval(input()))
A = tuple(map(int, input().split()))
q = int(eval(input()))
M = tuple(map(int, input().split()))
sum_A = sum(A)
ever_calc = [[None] * 2000 for i in range(n+1)]
for m in M:
if m > sum_A:
print('no')
elif solve(0, m):
print('yes')
else:
print('no') | p02271 |
import sys
def exhaustiveSearch(A, m):
for i in range(len(A)):
if m == A[i]:
return True
elif m > A[i]:
if exhaustiveSearch(A[:i] + A[i + 1:], m - A[i]):
return True
return False
if __name__ == "__main__":
lines = sys.stdin.readlines()
A = list(map(int, lines[1].split()))
M = list(map(int, lines[3].split()))
for m in M:
if exhaustiveSearch(A, m):
print("yes")
else:
print("no") | import sys
def exhaustiveSearch(A, m):
if len(A) == 1 and A[0] != m:
return False
elif A[0] == m:
return True
return exhaustiveSearch(A[1:], m) or exhaustiveSearch(A[1:], m - A[0])
if __name__ == "__main__":
lines = sys.stdin.readlines()
A = list(map(int, lines[1].split()))
M = list(map(int, lines[3].split()))
for m in M:
if exhaustiveSearch(A, m):
print("yes")
else:
print("no") | p02271 |
import sys
def exhaustiveSearch(A, m):
if len(A) == 1 and A[0] != m or m < 0:
return False
elif A[0] == m:
return True
return exhaustiveSearch(A[1:], m) or exhaustiveSearch(A[1:], m - A[0])
if __name__ == "__main__":
lines = sys.stdin.readlines()
A = list(map(int, lines[1].split()))
M = list(map(int, lines[3].split()))
for m in M:
if exhaustiveSearch(A, m):
print("yes")
else:
print("no") | import sys
def exhaustiveSearch(A, m, i):
if A[i] == m:
return True
elif i == len(A) - 1:
return False
return exhaustiveSearch(A, m, i + 1) or exhaustiveSearch(A, m - A[i], i + 1)
if __name__ == "__main__":
lines = sys.stdin.readlines()
A = list(map(int, lines[1].split()))
M = list(map(int, lines[3].split()))
for m in M:
if exhaustiveSearch(A, m, 0):
print("yes")
else:
print("no") | p02271 |
import sys
def exhaustiveSearch(A, m, i):
if A[i] == m:
return True
elif i == len(A) - 1 or m < 0:
return False
return exhaustiveSearch(A, m, i + 1) or exhaustiveSearch(A, m - A[i], i + 1)
if __name__ == "__main__":
lines = sys.stdin.readlines()
A = list(map(int, lines[1].split()))
M = list(map(int, lines[3].split()))
for m in M:
if exhaustiveSearch(A, m, 0):
print("yes")
else:
print("no") | import sys
def exhaustiveSearch(A, m, i, s):
if A[i] == m:
return True
elif i == len(A) - 1 or m < 0 or m > s:
return False
return exhaustiveSearch(A, m, i + 1, s) or exhaustiveSearch(A, m - A[i], i + 1, s)
if __name__ == "__main__":
lines = sys.stdin.readlines()
A = list(map(int, lines[1].split()))
M = list(map(int, lines[3].split()))
s = sum(A)
for m in M:
if exhaustiveSearch(A, m, 0, s):
print("yes")
else:
print("no") | p02271 |
n= int(eval(input()))
A = list(map(int, input().split()))
q = int(eval(input()))
Mi = list(map(int, input().split()))
def solve(i,m):
if m == 0:
return True
if i >= n:
return False
res = solve(i+1, m) or solve(i + 1, m - A[i])
return res
for m in Mi:
if solve(0, m):
print("yes")
else:
print("no") | n= int(eval(input()))
A = list(map(int, input().split()))
q = int(eval(input()))
Mi = list(map(int, input().split()))
PS={}
def solve(i,m):
if m == 0:
return True
if (i,m) in PS:
return PS[(i,m)]
if i >= n:
return False
res = solve(i+1, m) or solve(i + 1, m - A[i])
PS[(i,m)] = res
return res
for m in Mi:
if solve(0, m):
print("yes")
else:
print("no") | p02271 |
isExist = [False]*2001
n = int( eval(input()) )
A = [ int( val ) for val in input().rstrip().split( ' ' ) ]
for i in A:
for j in range( 2000-i, 0, -1 ):
if isExist[j]:
isExist[ i+j ] = True
isExist[i] = True
q = int( eval(input()) )
M = [ int( val ) for val in input().rstrip().split( ' ' ) ]
for i in range( 0, q ):
if isExist[ M[i] ]:
print( "yes" )
else:
print( "no" ) | isExist = [False]*2001
n = int( input() )
A = [ int( val ) for val in input().rstrip().split( ' ' ) ]
for i in A:
for j in range( 2000-i, 0, -1 ):
if isExist[j]:
isExist[ i+j ] = True
isExist[i] = True
q = int( input() )
M = [ int( val ) for val in input().rstrip().split( ' ' ) ]
for i in range( 0, q ):
if isExist[ M[i] ]:
print( "yes" )
else:
print( "no" ) | p02271 |
n = int(eval(input()))
A = list(map(int, input().split()))
q = int(eval(input()))
mi = list(map(int, input().split()))
def solve(i, m):
if (m == 0):
return True
if (i >= n):
return False
res = solve(i + 1, m) or solve(i + 1, m - A[i])
return res
for j in mi:
if solve(0, j):
print("yes")
else:
print("no") | n = int(eval(input()))
A = list(map(int, input().split()))
q = int(eval(input()))
mi = list(map(int, input().split()))
t = {}
def solve(i, m):
if (m == 0):
return True
if (i >= n):
return False
if (i,m) in t:
return t[(i,m)]
res = solve(i + 1, m) or solve(i + 1, m - A[i])
t[(i,m)] = res
return res
for m in mi:
if solve(0, m):
print("yes")
else:
print("no") | p02271 |
def solve(Mi,i):
if Mi == 0: return True
if i < n and Mi > 0:
r1 = solve(Mi-A[i],i+1)
r2 = solve(Mi,i+1)
if r1: return r1
if r2: return r2
n = eval(input())
A = list(map(int,input().split()))
q = eval(input())
M = list(map(int,input().split()))
for Mi in M:
print("yes" if solve(Mi,0) else "no") | def solve(Mi,i):
if Mi == 0: return True
if i < n and min(A[i:]) <= Mi <= sum(A[i:]):
r1 = solve(Mi-A[i],i+1)
r2 = solve(Mi,i+1)
if r1: return r1
if r2: return r2
n = eval(input())
A = list(map(int,input().split()))
q = eval(input())
M = list(map(int,input().split()))
for Mi in M:
print("yes" if solve(Mi,0) else "no") | p02271 |
n1 = eval(input())
A = list(map(int, input().split()))
n2 = eval(input())
q = list(map(int, input().split()))
list = set()
def solve(i,m):
if m == 0:
return True
if i >= n1:
return False
res = solve(i+1,m) or solve(i+1,m-A[i])
return res
for m in q:
if solve(0,m):
print("yes")
else:
print("no") | n1 = eval(input())
A = list(map(int, input().split()))
n2 = eval(input())
q = list(map(int, input().split()))
list = set()
def solve(i,m):
if m == 0:
return True
if i >= n1 or m > sum(A):
return False
res = solve(i+1,m) or solve(i+1,m-A[i])
return res
for m in q:
if solve(0,m):
print("yes")
else:
print("no") | p02271 |
def solve(arr, m):
dict = {}
return solve_rec(0, arr, m, dict)
def solve_rec(i, arr, m, dict):
key = str(i) + '-' + str(m)
res = False
if key in dict:
res = dict[key]
elif m == 0:
res = True
elif i >= len(arr):
res = False
else:
res1 = solve_rec(i + 1, arr, m, dict)
res2 = solve_rec(i + 1, arr, m - arr[i], dict)
res = res1 or res2
dict[key] = res
return res
n = int(eval(input()))
arr = list(map(int, input().split()))
q = int(eval(input()))
targets = list(map(int, input().split()))
for i in range(q):
res = solve(arr, targets[i])
if res == True:
print('yes')
else:
print('no')
|
def solve(a, m):
dict = {}
return solve_(a, 0, m, dict)
def solve_(a, i, m, dict):
res = False
key = str(i) + '-' + str(m)
if key in dict:
res = dict[key]
elif m == 0:
res = True
elif i >= len(a):
res = False
else:
res1 = solve_(a, i + 1, m, dict)
res2 = solve_(a, i + 1, m - a[i], dict)
res = res1 or res2
dict[key] = res
return res
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
m = list(map(int, input().split()))
for i in range(q):
if solve(a, m[i]):
print('yes')
else:
print('no')
| p02271 |
def subset_sum(s, a):
dict = {}
return subset_rec(0, s, a, dict)
def subset_rec(i, s, a, dict):
key = str(i) + '-' + str(s)
ret = False
if key in dict:
ret = dict[key]
elif s == 0:
ret = True
elif i >= len(a):
ret = False
else:
ret = subset_rec(i+1, s-a[i], a, dict) or subset_rec(i+1, s, a, dict)
dict[key] = ret
return ret
n = int(eval(input()))
a = list(map(int, input().split()))
p = int(eval(input()))
q = list(map(int, input().split()))
for i in range(p):
if subset_sum(q[i], a):
print('yes')
else:
print('no')
| def subset_sum(s, a):
dict = {}
return subset_rec(0, s, a, dict)
def subset_rec(i, s, a, dict):
key = str(i) + '-' + str(s)
if key in dict:
ret = dict[key]
elif s == 0:
ret = True
elif i >= len(a):
ret = False
else:
ret = subset_rec(i+1, s-a[i], a, dict) or subset_rec(i+1, s, a, dict)
dict[key] = ret
return ret
n = int(eval(input()))
a = list(map(int, input().split()))
p = int(eval(input()))
q = list(map(int, input().split()))
for i in range(p):
if subset_sum(q[i], a):
print('yes')
else:
print('no')
| p02271 |
def subset_sum(s, a):
dict = {}
return subset_rec(0, s, a, dict)
def subset_rec(i, s, a, dict):
key = str(i) + '-' + str(s)
if key in dict:
ret = dict[key]
elif s == 0:
ret = True
elif i >= len(a):
ret = False
else:
ret = subset_rec(i+1, s-a[i], a, dict) or subset_rec(i+1, s, a, dict)
dict[key] = ret
return ret
n = int(eval(input()))
a = list(map(int, input().split()))
p = int(eval(input()))
q = list(map(int, input().split()))
for i in range(p):
if subset_sum(q[i], a):
print('yes')
else:
print('no')
| def subset_sum(s, a):
n = len(a)
dp = [[False for x in range(s+1)] for x in range(n+1)]
for i in range(n):
v = a[i]
for j in range(s+1):
if v == j:
dp[i+1][j] = True
elif v > j:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = dp[i][j] or dp[i][j-v]
return dp[n][s]
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
m = list(map(int, input().split()))
for i in range(q):
if subset_sum(m[i], a) == True:
print('yes')
else:
print('no')
| p02271 |
def subset_sum(n, s, a):
dp = [[0 for x in range(s+1)] for x in range(n+1)]
for i in range(n):
v = a[i]
for j in range(s+1):
if v==j or (v<j and dp[i][j-v]>0):
dp[i+1][j] = dp[i][j] + 1
else:
dp[i+1][j] = dp[i][j]
return dp[n][s] > 0
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
m = list(map(int, input().split()))
for i in range(q):
if subset_sum(n, m[i], a) == True:
print('yes')
else:
print('no')
| def subset_sum(n, s, a):
dp = [[0 for x in range(s+1)] for x in range(n+1)]
dp[0][0]=1
for i in range(n):
v = a[i]
for j in range(s+1):
if v > j:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = dp[i][j]+dp[i][j-v]
return dp[n][s] > 0
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
m = list(map(int, input().split()))
for i in range(q):
if subset_sum(n, m[i], a) == True:
print('yes')
else:
print('no')
| p02271 |
n = int(eval(input()))
A = list(map(int, input().split()))
q = int(eval(input()))
M = list(map(int, input().split()))
def rec(i, m):
if m == 0:
return True
if i >= n:
return False
res = rec(i + 1, m)
if m - A[i] >= 0:
res |= rec(i + 1, m - A[i])
return res
for m in M:
if rec(0, m):
print('yes')
else:
print('no')
| n = int(eval(input()))
A = list(map(int, input().split()))
q = int(eval(input()))
M = list(map(int, input().split()))
bits = 1
for a in A:
bits |= bits << a
for m in M:
print(('yes' if (bits >> m) & 1 else 'no'))
| p02271 |
n = eval(input())
A = list(map(int, input().split()))
q = eval(input())
M = list(map(int, input().split()))
def solve(i,m):
if m == 0:
return True
if i >= n:
return False
res = solve(i+1,m) or solve(i+1, m - A[i])
return res
for m in M:
if solve(0, m):
print('yes')
else:
print('no') | n = eval(input())
A = list(map(int, input().split()))
q = eval(input())
M = list(map(int, input().split()))
min = min(A)
sum = sum(A)
def solve(i,m):
if sum < m:
return False
if m == 0:
return True
if i >= n:
return False
res = solve(i+1,m) or solve(i+1, m - A[i])
return res
for m in M:
if solve(0, m):
print('yes')
else:
print('no')
| p02271 |
from itertools import combinations
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
m = list(map(int, input().split()))
s = set()
for i in range(1, n):
for j in combinations(a, i):
s.add(sum(j))
for ans in m:
print(('yes' if ans in s else 'no')) | from itertools import combinations
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
m = list(map(int, input().split()))
s = set()
for i in range(1, n + 1):
for j in combinations(a, i):
s.add(sum(j))
for ans in m:
print(('yes' if ans in s else 'no')) | p02271 |
from collections import deque
class MyClass():
def load(self):
self.n = eval(input())
self.A = list(map(int,input().split()))
self.q = eval(input())
self.M = list(map(int,input().split()))
def main(self):
self.load()
W = list(map(self.solve,self.M))
for w in W:
print(w)
def solve(self,m):
qA = deque(self.A)
for j in range(self.n):
w = self.rec(m,list(qA))
if w:
break
qA.popleft()
if w:
return "yes"
else:
return "no"
def rec(self,m,A):
if len(A) == 1:
r1 = False
else:
r1 = self.rec(m,A[1:])
m_new = m - A[0]
if m_new < 0:
r2 = False
elif m_new == 0:
r2 = True
else:
if len(A) == 1:
r2 = False
else:
r2 = self.rec(m_new,A[1:])
if r1 or r2:
return True
else:
return False
if __name__ == "__main__":
MC = MyClass()
MC.main() | from collections import deque
class MyClass():
def load(self):
self.n = eval(input())
self.A = list(map(int,input().split()))
self.q = eval(input())
self.M = list(map(int,input().split()))
def main(self):
self.load()
W = list(map(self.solve,self.M))
for w in W:
print(w)
def solve(self,m):
qA = deque(self.A)
for j in range(self.n):
w = self.rec(m,list(qA))
if w:
break
qA.popleft()
if w:
return "yes"
else:
return "no"
def rec(self,m,A):
if len(A) == 0:
return False
else:
r1 = self.rec(m,A[1:])
m_new = m - A[0]
if m_new < 0:
r2 = False
elif m_new == 0:
r2 = True
else:
r2 = self.rec(m_new,A[1:])
if r1 or r2:
return True
else:
return False
if __name__ == "__main__":
MC = MyClass()
MC.main() | p02271 |
class MyClass():
def main(self):
self.n = eval(input())
self.A = list(map(int,input().split()))
self.q = eval(input())
self.M = list(map(int,input().split()))
W = list(map(self.solve,self.M))
for w in W:
print(w)
def solve(self,m):
w = self.rec(m,self.A)
if w:
return "yes"
else:
return "no"
def rec(self,m,A):
if len(A) == 1:
r1 = False
else:
r1 = self.rec(m,A[1:])
m_new = m - A[0]
if m_new < 0:
r2 = False
elif m_new == 0:
r2 = True
elif len(A) == 1 or m_new < min(A[1:]):
r2 = False
else:
r2 = self.rec(m_new,A[1:])
if r1 or r2:
return True
else:
return False
if __name__ == "__main__":
MC = MyClass()
MC.main() | class MyClass():
def main(self):
self.n = eval(input())
self.A = list(map(int,input().split()))
self.q = eval(input())
self.M = list(map(int,input().split()))
W = list(map(self.solve,self.M))
for w in W:
print(w)
def solve(self,m):
w = self.rec(m,self.A)
if w:
return "yes"
else:
return "no"
def rec(self,m,A):
if len(A) == 1:
r1 = False
else:
r1 = self.rec(m,A[1:])
m_new = m - A[0]
if m_new == 0:
r2 = True
elif len(A) > 1 and min(A[1:]) <= m_new <= sum(A[1:]):
r2 = self.rec(m_new,A[1:])
else:
r2 = False
if r1 or r2:
return True
else:
return False
if __name__ == "__main__":
MC = MyClass()
MC.main() | p02271 |
from itertools import combinations
n, a, q, ms = int(eval(input())), list(map(int, input().split())), eval(input()), list(map(int, input().split()))
cache = {}
def sum_a(tmp, t):
global a, cache
if t in cache:
return tmp + cache[t]
elif len(t) == 1:
return tmp + a[t[0]]
else:
cache[t] = result = sum_a(tmp + a[t[0]], t[1:])
return result
l = list(sum_a(0, t) for i in range(n) for t in combinations(list(range(n)), i + 1))
for m in ms:
print(('yes' if m in l else 'no')) | from itertools import combinations
n, a, q, ms, cache = int(eval(input())), list(map(int, input().split())), eval(input()), list(map(int, input().split())), {}
def sum_a(tmp, t):
global a, cache
if t in cache:
return tmp + cache[t]
elif len(t) == 1:
return tmp + a[t[0]]
else:
cache[t] = result = sum_a(tmp + a[t[0]], t[1:])
return result
l = set(sum_a(0, t) for i in range(n) for t in combinations(list(range(n)), i + 1))
for m in ms:
print(('yes' if m in l else 'no')) | p02271 |
from itertools import combinations
n, a, q, ms, cache = int(eval(input())), list(map(int, input().split())), eval(input()), list(map(int, input().split())), {}
l = set(sum(t) for i in range(n) for t in combinations(a, i + 1))
for m in ms:
print(('yes' if m in l else 'no')) | from itertools import combinations
n, a, q = int(eval(input())), list(map(int, input().split())), eval(input())
l = set(sum(t) for i in range(n) for t in combinations(a, i + 1))
for m in map(int, input().split()):
print(('yes' if m in l else 'no')) | p02271 |
a_len = int(eval(input()))
a_ar = sorted([int(n) for n in input().split(" ")])
b_len = int(eval(input()))
b_ar = [int(n) for n in input().split(" ")]
dp = [0 for n in range(2001)]
for a in a_ar:
new_dp = dp[:]
new_dp[a] = 1
for i,d in enumerate(dp):
if d and i + a <= 2000:
new_dp[i + a] = 1
elif i + a > 2000:
break
dp = new_dp
for b in b_ar:
if dp[b]:
print("yes")
else:
print("no") | a_len = int(eval(input()))
a_ar = sorted([int(n) for n in input().split(" ")])
b_len = int(eval(input()))
b_ar = [int(n) for n in input().split(" ")]
max_b = max(b_ar)
dp = [0 for n in range(max_b + 1)]
for a in a_ar:
new_dp = dp[:]
new_dp[a] = 1
for i,d in enumerate(dp):
if d and i + a <= max_b:
new_dp[i + a] = 1
dp = new_dp
for b in b_ar:
if dp[b]:
print("yes")
else:
print("no") | p02271 |
eval(input())
A = list(map(int,input().split()))
eval(input())
M = list(map(int,input().split()))
def solve(i,m):
a = 0
if a ==m:
return True
if i >= len(A):
return False
res = solve(i+1,m) or solve(i+1,m-A[i])
return res
for k in M:
print(("yes" if solve(0,k) else "no"))
| eval(input())
A = list(map(int,input().split()))
eval(input())
M = list(map(int,input().split()))
d = {}
def solve(i,s):
if i == len(A):
d[s] = 0
return s
solve(i+1,s)
solve(i+1,s+A[i])
return 1
solve(0,0)
for a in M:
if a in d:
print("yes")
else:
print("no")
| p02271 |
n = int(input())
A = list(map(int, input().strip().split(' ')))
q = int(input())
M = list(map(int, input().strip().split(' ')))
memo = []
for i in range(len(A)+1):
memo.append([None]*2000)
def solve(i,m):
if memo[i][m] != None: return memo[i][m]
if m == 0:
memo[i][m] = True
return True
elif i >= n:
memo[i][m] = False
return False
else:
return solve(i+1,m) | solve(i+1,m-A[i])
for m in M:
if solve(0,m): print("yes")
else: print("no") | n = int(input())
A = list(map(int, input().strip().split(' ')))
q = int(input())
M = list(map(int, input().strip().split(' ')))
memo = []
for i in range(len(A)+1):
memo.append([None]*2000)
def solve(i,m):
if memo[i][m] != None: return memo[i][m]
if m == 0:
memo[i][m] = True
return True
elif i >= n:
memo[i][m] = False
return False
else:
ret = solve(i+1,m) | solve(i+1,m-A[i])
memo[i][m] = ret
return ret
for m in M:
if solve(0,m): print("yes")
else: print("no") | p02271 |
# -*- coding:utf-8 -*-
import sys
def exhaustive(n, target, lst):
if n == target:
return True
if n > target or lst == []:
return False
else:
for i, val in enumerate(lst, 1):
if exhaustive(n + val, target, lst[i:]):
return True
return False
def main(data, targets):
for target in targets:
if exhaustive(0, target, data):
print("yes")
else:
print("no")
if __name__ == "__main__":
lst = [val.split() for val in sys.stdin.read().splitlines()]
data = [int(n) for n in lst[1]]
targets = [int(n) for n in lst[3]]
main(data, targets) | # -*- coding:utf-8 -*-
import sys
def exhaustive(lst, size):
result = []
for i in range(0, 1 << size):
total = 0
for j in range(0, size):
if (i & 0x01) == 1:
total += lst[j]
i = i >> 1
result.append(total)
return result
if __name__ == "__main__":
lst = [val.split() for val in sys.stdin.read().splitlines()]
n, data, m, targets = [[int(n) for n in inner_lst] for inner_lst in lst]
result = exhaustive(data, int(n[0]))
print(("\n".join(["yes" if x in result else "no" for x in targets]))) | p02271 |
n = eval(input())
A = list(map(int, input().split()))
q = eval(input())
M = list(map(int, input().split()))
def solve(i, m):
if m == 0:
return True
if i >= n:
return False
res = solve(i+1, m) or solve(i+1, m - A[i])
return res
for m in M:
if solve(0,m):
print("yes")
else:
print("no") | n = eval(input())
A = list(map(int, input().split()))
q = eval(input())
M = list(map(int, input().split()))
def solve(i, m):
if m == 0:
return True
if i >= n or m > sum(A):
return False
res = solve(i+1, m) or solve(i+1, m - A[i])
return res
for m in M:
if solve(0,m):
print("yes")
else:
print("no") | p02271 |
#!/usr/bin/env python3
import sys
YES = "Yes" # type: str
NO = "No" # type: str
def solve(s: str, x: int, y: int):
LENS = len(s)
s_list = list(map(len,s.split("T")))
x_s_list = s_list[0::2]
y_s_list = s_list[1::2]
x_dp = [[False]*(2*LENS+1) for _ in range(len(x_s_list))]
## answer = x_dp[-1][x+LENS]
for index,count in enumerate(x_s_list):
## 最初は
if index == 0:
x_dp[index][count+LENS] = True
continue
for j in range(2*LENS+1):
if j-count >= 0 and j+count< 2*LENS+1:
x_dp[index][j] = x_dp[index-1][j-count] or x_dp[index-1][j+count]
elif j-count >= 0:
x_dp[index][j] = x_dp[index-1][j-count]
elif j+count< 2*LENS+1:
x_dp[index][j] = x_dp[index-1][j+count]
y_dp = [[False]*(2*LENS+1) for _ in range(len(y_s_list))]
for index,count in enumerate(y_s_list):
## 最初は
if index == 0:
y_dp[index][count+LENS] = True
y_dp[index][-count+LENS] = True
continue
for j in range(2*LENS+1):
if j-count >= 0 and j+count< 2*LENS+1:
y_dp[index][j] = y_dp[index-1][j-count] or y_dp[index-1][j+count]
elif j-count >= 0:
y_dp[index][j] = y_dp[index-1][j-count]
elif j+count< 2*LENS+1:
y_dp[index][j] = y_dp[index-1][j+count]
if not y_dp:
if y != 0:
print(NO)
else:
if x_dp[-1][x+LENS]:
print(YES)
else:
print(NO)
return
if not x_dp:
if x != 0:
print(NO)
else:
if y_dp[-1][y+LENS]:
print(YES)
else:
print(NO)
return
if x_dp[-1][x+LENS] and y_dp[-1][y+LENS]:
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
x = int(next(tokens)) # type: int
y = int(next(tokens)) # type: int
solve(s, x, y)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
YES = "Yes" # type: str
NO = "No" # type: str
def solve(s: str, x: int, y: int):
s_list = list(map(len,s.split("T")))
x_s_list = s_list[0::2]
y_s_list = s_list[1::2]
x_dp = [set() for _ in range(len(x_s_list))]
for index,count in enumerate(x_s_list):
## 最初は
if index == 0:
x_dp[index].add(count)
continue
for j in x_dp[index-1]:
x_dp[index].add(j-count)
x_dp[index].add(j+count)
y_dp = [set() for _ in range(len(y_s_list))]
for index,count in enumerate(y_s_list):
## 最初は
if index == 0:
y_dp[index].add(count)
y_dp[index].add(-count)
continue
for j in y_dp[index-1]:
y_dp[index].add(j-count)
y_dp[index].add(j+count)
if not y_dp:
if y != 0:
print(NO)
else:
if x in x_dp[-1]:
print(YES)
else:
print(NO)
return
if not x_dp:
if x != 0:
print(NO)
else:
if y in y_dp[-1]:
print(YES)
else:
print(NO)
return
if x in x_dp[-1] and y in y_dp[-1]:
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
x = int(next(tokens)) # type: int
y = int(next(tokens)) # type: int
solve(s, x, y)
if __name__ == '__main__':
main()
| p03488 |
s=[len(c) for c in list(input().split("T"))]
x,y=list(map(int,input().split()))
XX=s[::2]
YY=s[1::2]
X=[XX[0]]
Y=[0]
XXX=[]
for i in range(1,len(XX)):
for j in X:
XXX.append(j+XX[i])
XXX.append(j-XX[i])
X=XXX
XXX=[]
YYY=[]
for i in range(len(YY)):
for j in Y:
YYY.append(j+YY[i])
YYY.append(j-YY[i])
Y=YYY
YYY=[]
if x in X and y in Y:
print("Yes")
else:
print("No") | s=[len(c) for c in list(input().split("T"))]
x,y=list(map(int,input().split()))
XX=s[::2]
YY=s[1::2]
X=set([XX[0]])
Y=set([0])
XXX=[]
for i in range(1,len(XX)):
for j in X:
XXX.append(j+XX[i])
XXX.append(j-XX[i])
X=set(XXX)
XXX=[]
YYY=[]
for i in range(len(YY)):
for j in Y:
YYY.append(j+YY[i])
YYY.append(j-YY[i])
Y=set(YYY)
YYY=[]
if x in X and y in Y:
print("Yes")
else:
print("No") | p03488 |
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
def main():
order_F = []
order_F = input().rstrip().split('T')
x, y = list(map(int, input().split()))
vert_DP = [False] * 8001
side_DP = [False] * 8001
vert_DP[0] = True
side_DP[0] = True
vert_sum = 0
side_sum = 0
distance = [len(order_F[i]) for i in range(len(order_F))]
order_len = len(order_F)
x -= len(order_F[0])
for i in range(1, order_len):
if i % 2 == 0:
side_sum += distance[i]
for j in reversed(list(range(8001 - distance[i]))):
if side_DP[j]:
side_DP[j + distance[i]] = True
else:
vert_sum += distance[i]
for j in reversed(list(range(8001 - distance[i]))):
if vert_DP[j]:
vert_DP[j + distance[i]] = True
if side_sum < x or vert_sum < y:
print("No")
elif (side_sum - x) % 2 == 1 or (vert_sum - y) % 2 == 1:
print("No")
else:
if side_DP[(side_sum - x)//2] and vert_DP[(vert_sum - y)//2]:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
| import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
def main():
order_F = []
order_F = input().rstrip().split('T')
x, y = list(map(int, input().split()))
vert_DP = [False] * 8001
side_DP = [False] * 8001
vert_DP[0] = True
side_DP[0] = True
vert_sum = 0
side_sum = 0
distance = [len(order_F[i]) for i in range(len(order_F))]
order_len = len(order_F)
x -= len(order_F[0])
vert_last = 0
side_last = 0
for i in range(1, order_len):
if i % 2 == 0:
side_sum += distance[i]
for j in reversed(list(range(side_last+1))):
if side_DP[j]:
side_DP[j + distance[i]] = True
side_last += distance[i]
else:
vert_sum += distance[i]
for j in reversed(list(range(vert_last+1))):
if vert_DP[j]:
vert_DP[j + distance[i]] = True
vert_last += distance[i]
if side_sum < x or vert_sum < y:
print("No")
elif (side_sum - x) % 2 == 1 or (vert_sum - y) % 2 == 1:
print("No")
else:
if side_DP[(side_sum - x)//2] and vert_DP[(vert_sum - y)//2]:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
| p03488 |
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
def main():
order_F = []
order_F = input().rstrip().split('T')
x, y = list(map(int, input().split()))
distance = [len(i) for i in order_F]
x -= distance[0]
side = []
vert = []
sum_s = 0
sum_v = 0
s_append = side.append
v_append = vert.append
s_append(0)
v_append(0)
for i in range(1, len(distance)):
if i%2 == 0:
sum_s += distance[i]
for j in reversed(list(range(len(side)))):
s_append(side[j] + distance[i])
else:
sum_v += distance[i]
for j in reversed(list(range(len(vert)))):
v_append(vert[j] + distance[i])
if (sum_s - x)/2 in side and (sum_v - y)/2 in vert:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
| def main():
order = [len(el) for el in list(map(str, input().rstrip().split("T")))]
x_points = {order[0]}
y_points = {0}
for val in order[2::2]:
plus_val = {x + val for x in list(x_points)}
minus_val = {x - val for x in list(x_points)}
x_points = plus_val | minus_val
for val in order[1::2]:
plus_val = {y + val for y in list(y_points)}
minus_val = {y - val for y in list(y_points)}
y_points = plus_val | minus_val
target_x, target_y = list(map(int, input().split()))
if target_x in x_points and target_y in y_points:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
| p03488 |
from sys import stdout
printn = lambda x: stdout.write(str(x))
inn = lambda : int(eval(input()))
inl = lambda: list(map(int, input().split()))
inm = lambda: list(map(int, input().split()))
ins = lambda : input().strip()
DBG = True # and False
BIG = 999999999
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
k = 8000
def foo(fe,x,ev):
n = len(fe)
d = [ [False]*(2*k+1) for i in range(n+1) ]
d[0][k] = True
if len(fe)>0:
d[1][fe[0]+k] = True
if not ev:
d[1][-fe[0]+k] = True
for i in range(1,n):
for j in range(-k,k+1):
if d[i][j+k]:
d[i+1][j+fe[i]+k] = True
d[i+1][j-fe[i]+k] = True
return d[n][x+k]
s = ins()
x,y = inm()
f = [ [], [] ]
strk = 0
turn = 0
n = len(s)
for i in range(n):
if s[i]=='T':
f[turn].append(strk)
turn = 1 - turn
strk = 0
else:
strk += 1
f[turn].append(strk)
if foo(f[0],x,True) and foo(f[1],y,False):
print('Yes')
else:
print('No')
| from sys import stdout
printn = lambda x: stdout.write(str(x))
inn = lambda : int(eval(input()))
inl = lambda: list(map(int, input().split()))
inm = lambda: list(map(int, input().split()))
ins = lambda : input().strip()
DBG = True # and False
BIG = 999999999
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
def foo(fe,x,ev):
k = sum(fe)+1
n = len(fe)
d = [ [False]*(2*k+1) for i in range(n+1) ]
d[0][k] = True
if len(fe)>0:
d[1][fe[0]+k] = True
if not ev:
d[1][-fe[0]+k] = True
for i in range(1,n):
for j in range(-k,k+1):
if d[i][j+k]:
d[i+1][j+fe[i]+k] = True
d[i+1][j-fe[i]+k] = True
return -k<=x<=k and d[n][x+k]
s = ins()
x,y = inm()
f = [ [], [] ]
strk = 0
turn = 0
n = len(s)
for i in range(n):
if s[i]=='T':
f[turn].append(strk)
turn = 1 - turn
strk = 0
else:
strk += 1
f[turn].append(strk)
if foo(f[0],x,True) and foo(f[1],y,False):
print('Yes')
else:
print('No')
| p03488 |
from collections import defaultdict
s = input().split('T')
dx = list(map(len, s[0::2]))
dy = list(map(len, s[1::2]))
lx = sum(dx)
ly = sum(dy)
x, y = list(map(int, input().split()))
dp = [defaultdict(bool) for _ in range(len(dx))]
dp[0][dx[0]] = True
for i in range(1, len(dx)):
for j in range(-lx, lx + 1):
dp[i][j] = dp[i - 1][j - dx[i]] or dp[i - 1][j + dx[i]]
x_ok = dp[len(dx) - 1][x]
if len(dy) > 0:
dp = [defaultdict(bool) for _ in range(len(dy))]
dp[0][dy[0]] = True
dp[0][-dy[0]] = True
for i in range(1, len(dy)):
for j in range(-ly, ly + 1):
dp[i][j] = dp[i - 1][j - dy[i]] or dp[i - 1][j + dy[i]]
y_ok = dp[len(dy) - 1][y]
else:
y_ok = y == 0
print(('Yes' if x_ok and y_ok else 'No'))
| s = input().split('T')
dx = list(map(len, s[0::2]))
dy = list(map(len, s[1::2]))
x, y = list(map(int, input().split()))
def check(start, ds, goal):
cands = {start}
for d in ds:
new_cands = set()
for c in cands:
new_cands.add(c - d)
new_cands.add(c + d)
cands = new_cands
return goal in cands
x_ok = check(dx[0], dx[1:], x)
y_ok = check(0, dy, y)
print(('Yes' if x_ok and y_ok else 'No'))
| p03488 |
import sys
s = sys.stdin.readline().rstrip()
x, y = list(map(int, sys.stdin.readline().split()))
def reachable(deltas, goal):
if not deltas:
if goal == 0:
return True
else:
return False
s = sum(deltas)
if goal < -s or s < goal:
return False
res = [False] * (s * 2 + 1)
res[s] = True
for d in deltas:
prev = res.copy()
res = [False] * (s * 2 + 1)
for i in range(s*2+1):
if prev[i]:
res[i+d] = res[i-d] = True
return res[s + goal]
def main():
gx = x; gy = y
dx = []
dy = []
direction = 0
origin_x = 0
for i in s:
if i == 'T':
break
origin_x += 1
gx -= origin_x
tmp = 0
for i in s[origin_x:] + 'T':
if i == 'T':
if direction == 0:
if tmp != 0:
dx.append(tmp)
direction = 1
else:
if tmp != 0:
dy.append(tmp)
direction = 0
tmp = 0
else:
tmp += 1
return 'Yes' if reachable(dx, gx) & reachable(dy, gy) else 'No'
if __name__ == '__main__':
ans = main()
print(ans) | import sys
s = sys.stdin.readline().rstrip()
x, y = list(map(int, sys.stdin.readline().split()))
def reachable(deltas, goal):
if not deltas:
if goal == 0:
return True
else:
return False
s = sum(deltas)
if goal < -s or s < goal:
return False
if (s - goal) & 1:
return False
a = (s - goal) // 2
res = [False] * (a + 1)
res[0] = True
for d in deltas:
for i in range(a, -1, -1):
if res[i] and i + d <= a:
res[i+d] = True
return res[a]
def main():
gx = x; gy = y
dx = []
dy = []
direction = 0
origin_x = 0
for i in s:
if i == 'T':
break
origin_x += 1
gx -= origin_x
tmp = 0
for i in s[origin_x:] + 'T':
if i == 'T':
if direction == 0:
if tmp != 0:
dx.append(tmp)
direction = 1
else:
if tmp != 0:
dy.append(tmp)
direction = 0
tmp = 0
else:
tmp += 1
return 'Yes' if reachable(dx, gx) & reachable(dy, gy) else 'No'
if __name__ == '__main__':
ans = main()
print(ans) | p03488 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
move = None
tx = None
ty = None
@lru_cache(maxsize=None)
def fx(cx, i):
if i >= len(move):
return cx == tx
m = move[i]
if fx(cx+m, i+2) or fx(cx-m, i+2):
return True
else:
return False
@lru_cache(maxsize=None)
def fy(cy, i):
if i >= len(move):
return cy == ty
m = move[i]
if fy(cy+m, i+2) or fy(cy-m, i+2):
return True
else:
return False
@mt
def slv(S, x, y):
global move
global tx
global ty
tx = x
ty = y
move = list(map(lambda x: len(x), S.split('T')))
return 'Yes' if fx(move[0], 2) and fy(0, 1) else 'No'
def main():
S = read_str().strip()
x, y = read_int_n()
print(slv(S, x, y))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
move = None
tx = None
ty = None
@mt
def slv(S, x, y):
tx = x
ty = y
move = list(map(lambda x: len(x), S.split('T')))
xm = [move[0]]
for i in range(2, len(move), 2):
xm_ = []
for x in xm:
xm_.append(x + move[i])
xm_.append(x - move[i])
xm = set(xm_)
ym = [0]
for i in range(1, len(move), 2):
ym_ = []
for y in ym:
ym_.append(y + move[i])
ym_.append(y - move[i])
ym = set(ym_)
return 'Yes' if tx in xm and ty in ym else 'No'
def main():
S = read_str().strip()
x, y = read_int_n()
print(slv(S, x, y))
if __name__ == '__main__':
main()
| p03488 |
import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
s = input().rstrip()
gx, gy = list(map(int, input().split()))
rx, ry = 0, 0
head, inst = 0, []
while head < len(s) and s[head] == "F":
head += 1
rx += 1
while head < len(s):
tcnt = 0
while head < len(s) and s[head] == "T":
tcnt += 1
head += 1
fcnt = 0
while head < len(s) and s[head] == "F":
fcnt += 1
head += 1
inst.append((tcnt % 2, fcnt))
f_total = sum([f for (_, f) in inst])
f_rem = [0] * (len(inst) + 1)
f_rem[len(inst)] = 0
for i in range(len(inst) - 1, -1, -1):
f_rem[i] = f_rem[i + 1] + inst[i][1]
assert f_rem[0] == f_total
visited = set()
def reach(i, x, y, dx, dy):
dist = abs(gx - x) + abs(gy - y)
# print(f"i={i} ({x},{y}) dist={dist}: inst={inst[i:]}")
if i == len(inst):
return dist == 0
if (i, x, y, dx, dy) in visited:
return False
visited.add((i, x, y, dx, dy))
if dist > f_rem[i] or dist % 2 != f_rem[i] % 2:
return False
t, f = inst[i]
if t:
dy, dx = dx, -dy
if reach(i + 1, x + f * dx, y + f * dy, dx, dy):
return True
if reach(i + 1, x - f * dx, y - f * dy, -dx, -dy):
return True
return False
print(("Yes" if reach(0, rx, ry, 1, 0) else "No"))
| """Knapsack"""
import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
s = input().rstrip()
gx, gy = list(map(int, input().split()))
rx, ry = 0, 0
head, inst = 0, []
while head < len(s) and s[head] == "F":
head += 1
rx += 1
xlist, ylist = [], []
heading_x = True
while head < len(s):
tcnt = 0
while head < len(s) and s[head] == "T":
tcnt += 1
head += 1
if head == len(s):
break
fcnt = 0
while head < len(s) and s[head] == "F":
fcnt += 1
head += 1
if ((tcnt % 2) == 1) ^ heading_x:
heading_x = True
xlist.append(fcnt)
else:
heading_x = False
ylist.append(fcnt)
def fill(fs, goal_offset):
f_total = sum(fs)
if f_total < goal_offset:
return False
if f_total == goal_offset:
return True
f_diff = f_total - goal_offset
if f_diff % 2 == 1:
return False
f_diff //= 2
diffs = {0}
for f in fs:
for d in list(diffs):
d2 = f + d
if d2 > f_diff:
continue
if d2 == f_diff:
return True
diffs.add(d2)
return False
if fill(xlist, abs(gx - rx)) and fill(ylist, abs(gy - ry)):
print("Yes")
else:
print("No")
| p03488 |
s=list(map(len,input().split("T")))
x,y=list(map(int,input().split()))
def f(t,w):
for i in range(1<<len(t)):
z=0
for j in range(len(t)):
z+=[1,-1][i>>j&1]*t[j]
if z==w:
return True
return False
print(("Yes"if f(s[2::2],x-s[0]) and f(s[1::2],y) else "No")) | s=list(map(len,input().split("T")))
x,y=list(map(int,input().split()))
def f(t,w):
m=[{} for i in range(len(t)+1)]
m[0][0]=1
for i in range(len(t)):
for z in m[i]:
m[i+1][z+t[i]]=1
m[i+1][z-t[i]]=1
return w in m[len(t)]
print((["No","Yes"][f(s[2::2],x-s[0]) and f(s[1::2],y)])) | p03488 |
# -*- coding: utf-8 -*-
nF = list(map(str, input().split('T')))
finalx, finaly = list(map(int, input().split()))
x = []
y = []
for i in range(len(nF)):
if i % 2 == 0:
x.append(len(nF[i]))
else:
y.append(len(nF[i]))
posy = [0]
if len(x) == 0:
posx = [0]
elif len(x) == 1:
posx = [x[0]]
else:
posx = [x[0]]
for i in range(1, len(x)):
plus_x = list([elem + x[i] for elem in posx])
minus_x = list([elem - x[i] for elem in posx])
plus_x.extend(minus_x)
posx = plus_x
if len(y) >= 1:
for i in range(len(y)):
plus_y= list([elem + y[i] for elem in posy])
minus_y= list([elem - y[i] for elem in posy])
plus_y.extend(minus_y)
posy = plus_y
if finalx in posx and finaly in posy:
print('Yes')
else:
print('No')
| # -*- coding: utf-8 -*-
nF = list(map(str, input().split('T')))
finalx, finaly = list(map(int, input().split()))
x = []
y = []
for i in range(len(nF)):
if i % 2 == 0:
x.append(len(nF[i]))
else:
y.append(len(nF[i]))
posy = [0]
if len(x) == 0:
posx = [0]
elif len(x) == 1:
posx = [x[0]]
else:
posx = [x[0]]
for i in range(1, len(x)):
plus_x = list([elem + x[i] for elem in posx])
minus_x = list([elem - x[i] for elem in posx])
plus_x.extend(minus_x)
posx = list(set(plus_x))
if len(y) >= 1:
for i in range(len(y)):
plus_y= list([elem + y[i] for elem in posy])
minus_y= list([elem - y[i] for elem in posy])
plus_y.extend(minus_y)
posy = list(set(plus_y))
if finalx in posx and finaly in posy:
print('Yes')
else:
print('No')
| p03488 |
# -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1: arr.append([temp, 1])
if arr==[]: arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
S = S()
gx,gy = IL()
data = [0]
flag = 0
for s in S:
if s == "F":
if flag:
flag = 0
data.append(1)
else:
data[-1] = data[-1]+1
else:
if flag == 0:
flag = 1
data.append(1)
else:
data[-1] = 1-data[-1]
if len(data)%2 == 0:
data.pop()
data = data[::-1]
shote = data.pop()
gx -= shote
D = [[0],[0]]
f = 0
while data:
f ^= data.pop()
D[f].append(data.pop())
dpx = [[0 for i in range(20000)] for j in range(len(D[0]))]
dpy = [[0 for i in range(20000)] for j in range(len(D[1]))]
dpx[0][10000] = 1
dpy[0][10000] = 1
for j in range(1,len(D[0])):
d = D[0][j]
for i in range(20000):
if i+d < 20000:
if dpx[j-1][i+d]:
dpx[j][i] = 1
if 0 <= i-j:
if dpx[j-1][i-d]:
dpx[j][i] = 1
for j in range(1,len(D[1])):
d = D[1][j]
for i in range(20000):
if i+d < 20000:
if dpy[j-1][i+d]:
dpy[j][i] = 1
if 0 <= i-j:
if dpy[j-1][i-d]:
dpy[j][i] = 1
if dpx[-1][10000+gx] and dpy[-1][10000+gy]:
print("Yes")
else:
print("No") | # -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1: arr.append([temp, 1])
if arr==[]: arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
S = S()
gx,gy = IL()
data = [0]
flag = 0
for s in S:
if s == "F":
if flag:
flag = 0
data.append(1)
else:
data[-1] = data[-1]+1
else:
if flag == 0:
flag = 1
data.append(1)
else:
data[-1] = 1-data[-1]
if len(data)%2 == 0:
data.pop()
data = data[::-1]
shote = data.pop()
gx -= shote
D = [[0],[0]]
f = 0
while data:
f ^= data.pop()
D[f].append(data.pop())
SUMX = sum(D[0])
SUMY = sum(D[1])
dpx = [[0 for i in range(SUMX*2+1)] for j in range(len(D[0]))]
dpy = [[0 for i in range(SUMY*2+1)] for j in range(len(D[1]))]
dpx[0][SUMX] = 1
dpy[0][SUMY] = 1
for j in range(1,len(D[0])):
d = D[0][j]
for i in range(SUMX*2+1):
if i+d < SUMX*2+1:
if dpx[j-1][i+d]:
dpx[j][i] = 1
if 0 <= i-d:
if dpx[j-1][i-d]:
dpx[j][i] = 1
for j in range(1,len(D[1])):
d = D[1][j]
for i in range(SUMY*2+1):
if i+d < SUMY*2+1:
if dpy[j-1][i+d]:
dpy[j][i] = 1
if 0 <= i-d:
if dpy[j-1][i-d]:
dpy[j][i] = 1
if (0<= SUMX+gx < SUMX*2+1) and (0<= SUMY+gy < SUMY*2+1):
if dpx[-1][SUMX+gx] and dpy[-1][SUMY+gy]:
print("Yes")
exit()
print("No") | p03488 |
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
from pprint import pprint
from copy import deepcopy
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
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
s = S() + 'T'
x, y = LI()
t_flag = 0
# 0の時横移動、1の時縦移動。
flag = 0
y_now = x_now = 1 << 8000
f_cnt = 0
for j in s:
if j == 'T':
if not flag:
flag = 1
x_now >>= f_cnt
elif t_flag:
y_now = y_now >> f_cnt | y_now << f_cnt
else:
x_now = x_now >> f_cnt | x_now << f_cnt
t_flag ^= 1
f_cnt = 0
else:
f_cnt += 1
if (1 << 8000 + y) & y_now and (1 << 8000 - x) & x_now:
print('Yes')
else:
print('No') | 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
from pprint import pprint
from copy import deepcopy
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
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
s = S() + 'T'
x, y = LI()
t_flag = 0
# 0の時横移動、1の時縦移動。
flag = 0
y_now = x_now = 1 << 8000
f_cnt = 0
for j in s:
if j == 'T':
if not flag:
flag = 1
x_now >>= f_cnt
elif t_flag:
y_now = y_now >> f_cnt | y_now << f_cnt
else:
x_now = x_now >> f_cnt | x_now << f_cnt
t_flag ^= 1
f_cnt = 0
else:
f_cnt += 1
if 1 << 8000 + y & y_now and 1 << 8000 - x & x_now:
print('Yes')
else:
print('No') | p03488 |
from copy import deepcopy as dc
S=list(map(len,input().split("T")))
x,y=list(map(int,input().split()))
x=abs(x-S[0])
y=abs(y)
L=S[2::2]
R=S[1::2]
sumL=sum(L)
sumR=sum(R)
flag=0
if sumL>=x and sumR>=y and (sumL-x)%2==0 and (sumR-y)%2==0 and flag==0:
setL={0}
setR={0}
setL1={0}
setR1={0}
gL=(sumL-x)//2
gR=(sumR-y)//2
if gL==0:
flag=1
else:
for i in L:
setL=dc(setL1)
for j in setL:
k=i+j
if k<gL:
setL1.add(k)
elif k==gL:
flag=1
break
if flag==1:
break
if flag==1:
if gR==0:
flag=2
else:
for i in R:
for j in setR:
setR=dc(setR1)
k=i+j
if k<gR:
setR1.add(k)
elif k==gR:
flag=2
break
if flag==2:
break
if flag==2:
print("Yes")
else:
print("No") | from itertools import accumulate
S=list(map(len,input().split("T")))
x,y=list(map(int,input().split()))
x=abs(x-S[0])
y=abs(y)
L=S[2::2]
R=S[1::2]
La=list(accumulate(L))
Ra=list(accumulate(R))
sumL=sum(L)
sumR=sum(R)
flag=0
if sumL>=x and sumR>=y and (sumL-x)%2==0 and (sumR-y)%2==0 and flag==0:
setL1={0}
setR1={0}
gL=(sumL-x)//2
gR=(sumR-y)//2
if gL==0:
flag=1
else:
for cnt,i in enumerate(L):
setL=setL1
setL1=set()
s=setL1.add
h=sumL-La[cnt]
for j in setL:
k=i+j
#if k<gL and h+k>=gL:
s(k)
#if j<gL and h+j>=gL:
s(j)
if k==gL:
flag=1
break
if flag==1:
break
if flag==1:
if gR==0:
flag=2
else:
for cnt,i in enumerate(R):
setR=setR1
setR1=set()
s=setR1.add
h=sumR-Ra[cnt]
for j in setR:
k=i+j
#if k<gR and h+k>=gR:
s(k)
#if j<gR and h+j>=gR:
s(j)
if k==gR:
flag=2
break
if flag==2:
break
if flag==2:
print("Yes")
else:
print("No") | p03488 |
from itertools import accumulate
S=list(map(len,input().split("T")))
x,y=list(map(int,input().split()))
x=abs(x-S[0])
y=abs(y)
L=S[2::2]
R=S[1::2]
La=list(accumulate(L))
Ra=list(accumulate(R))
sumL=sum(L)
sumR=sum(R)
flag=0
if sumL>=x and sumR>=y and (sumL-x)%2==0 and (sumR-y)%2==0 and flag==0:
setL1={0}
setR1={0}
gL=(sumL-x)//2
gR=(sumR-y)//2
if gL==0:
flag=1
else:
for i in L:
setL=setL1
setL1=set()
s=setL1.add
for j in setL:
k=i+j
s(k)
s(j)
if k==gL:
flag=1
break
if flag==1:
break
if flag==1:
if gR==0:
flag=2
else:
for i in R:
setR=setR1
setR1=set()
s=setR1.add
for j in setR:
k=i+j
s(k)
s(j)
if k==gR:
flag=2
break
if flag==2:
break
if flag==2:
print("Yes")
else:
print("No") | S=list(map(len,input().split("T")))
x,y=list(map(int,input().split()))
x=abs(x-S[0])
y=abs(y)
L=S[2::2]
R=S[1::2]
sumL=sum(L)
sumR=sum(R)
flag=0
if sumL>=x and sumR>=y and (sumL-x)%2==0 and (sumR-y)%2==0 and flag==0:
setL1={0}
setR1={0}
gL=(sumL-x)//2
gR=(sumR-y)//2
if gL==0:
flag=1
else:
for i in L:
setL=setL1
setL1=set()
s=setL1.add
for j in setL:
k=i+j
s(k)
s(j)
if k==gL:
flag=1
break
if flag==1:
break
if flag==1:
if gR==0:
flag=2
else:
for i in R:
setR=setR1
setR1=set()
s=setR1.add
for j in setR:
k=i+j
s(k)
s(j)
if k==gR:
flag=2
break
if flag==2:
break
if flag==2:
print("Yes")
else:
print("No") | p03488 |
def check(a, numlist):
goal = a+sum(numlist)
if goal %2 == 1:
return False
goal /=2
oklist =[0]
for x in numlist:
addlist = [ok+x for ok in oklist]
oklist += addlist
return goal in oklist
s = [len(x) for x in input().split('T')]
x,y = [int(i) for i in input().split()]
x = x-s[0]
sx = s[2::2]
sy = s[1::2]
if check(x,sx) and check(y,sy):
print("Yes")
else:
print("No") | def check(a, numlist):
goal = a+sum(numlist)
if goal %2 == 1:
return False
goal /=2
okset ={0}
for x in numlist:
addset = {ok+x for ok in okset}
okset |= addset
return goal in okset
s = [len(x) for x in input().split('T')]
x,y = [int(i) for i in input().split()]
x = x-s[0]
sx = s[2::2]
sy = s[1::2]
if check(x,sx) and check(y,sy):
print("Yes")
else:
print("No") | p03488 |
st = input().split("T")
x, y = list(map(int, input().split()))
XL = []; YL = []; t = 0
for i in range(len(st)):
if i % 2 == 0:
XL.append(len(st[i]))
else:
YL.append(len(st[i]))
t += len(st[i])
T = max([x, y, t])
xx = [[False for j in range(2*T+1)] for i in range(len(XL)+1)]
yy = [[False for j in range(2*T+1)] for i in range(len(YL)+1)]
xx[0][T]=True
yy[0][T]=True
xx[1][T+XL[0]]=True
for i in range(2, len(XL)+1):
for j in range(2*T+1):
if j-XL[i-1] < 0:
xx[i][j]=xx[i-1][j+XL[i-1]]
elif j+XL[i-1] > 2*T:
xx[i][j]=xx[i-1][j-XL[i-1]]
else:
xx[i][j]=xx[i-1][j-XL[i-1]] or xx[i-1][j+XL[i-1]]
for i in range(1,len(YL)+1):
for j in range(2*T+1):
if j-YL[i-1] < 0:
yy[i][j]=yy[i-1][j+YL[i-1]]
elif j+YL[i-1] > 2*T:
yy[i][j]=yy[i-1][j-YL[i-1]]
else:
yy[i][j]=yy[i-1][j-YL[i-1]] or yy[i-1][j+YL[i-1]]
if xx[len(XL)][x+T] and yy[len(YL)][y+T]:
print("Yes")
else:
print("No")
| st = input().split("T")
x, y = list(map(int, input().split()))
XL = []; YL = []; t = 0
for i in range(len(st)):
if i % 2 == 0:
XL.append(len(st[i]))
else:
YL.append(len(st[i]))
t += len(st[i])
if abs(x) + abs(y) > t:
print("No")
else:
T = max([abs(x), abs(y), t])
xx = [[False for j in range(2*T+1)] for i in range(len(XL)+1)]
yy = [[False for j in range(2*T+1)] for i in range(len(YL)+1)]
xx[0][T]=True
yy[0][T]=True
xx[1][T+XL[0]]=True
for i in range(2, len(XL)+1):
for j in range(2*T+1):
if j-XL[i-1] < 0:
xx[i][j]=xx[i-1][j+XL[i-1]]
elif j+XL[i-1] > 2*T:
xx[i][j]=xx[i-1][j-XL[i-1]]
else:
xx[i][j]=xx[i-1][j-XL[i-1]] or xx[i-1][j+XL[i-1]]
for i in range(1,len(YL)+1):
for j in range(2*T+1):
if j-YL[i-1] < 0:
yy[i][j]=yy[i-1][j+YL[i-1]]
elif j+YL[i-1] > 2*T:
yy[i][j]=yy[i-1][j-YL[i-1]]
else:
yy[i][j]=yy[i-1][j-YL[i-1]] or yy[i-1][j+YL[i-1]]
if xx[len(XL)][x+T] and yy[len(YL)][y+T]:
print("Yes")
else:
print("No")
| p03488 |
st = input().split("T")
x, y = list(map(int, input().split()))
XL = []; YL = []; t = 0
for i in range(len(st)):
if i % 2 == 0:
XL.append(len(st[i]))
else:
YL.append(len(st[i]))
t += len(st[i])
if abs(x) + abs(y) > t:
print("No")
else:
T = max([abs(x), abs(y), t])
xx = [[False for j in range(2*T+1)] for i in range(len(XL)+1)]
yy = [[False for j in range(2*T+1)] for i in range(len(YL)+1)]
xx[0][T]=True
yy[0][T]=True
xx[1][T+XL[0]]=True
for i in range(2, len(XL)+1):
for j in range(2*T+1):
if j-XL[i-1] < 0:
xx[i][j]=xx[i-1][j+XL[i-1]]
elif j+XL[i-1] > 2*T:
xx[i][j]=xx[i-1][j-XL[i-1]]
else:
xx[i][j]=xx[i-1][j-XL[i-1]] or xx[i-1][j+XL[i-1]]
for i in range(1,len(YL)+1):
for j in range(2*T+1):
if j-YL[i-1] < 0:
yy[i][j]=yy[i-1][j+YL[i-1]]
elif j+YL[i-1] > 2*T:
yy[i][j]=yy[i-1][j-YL[i-1]]
else:
yy[i][j]=yy[i-1][j-YL[i-1]] or yy[i-1][j+YL[i-1]]
if xx[len(XL)][x+T] and yy[len(YL)][y+T]:
print("Yes")
else:
print("No")
| s=input().split("T")
x,y=list(map(int,input().split()))
A=[]
B=[]
for i,j in enumerate(s):
if i%2==0:
A.append(len(j))
else:
B.append(len(j))
T=max([sum(A),sum(B),abs(x),abs(y)])
X=len(A)
Y=len(B)
if abs(x)+abs(y)>sum(A)+sum(B):
print("No")
exit()
dpx=[[False for i in range(2*T+1)] for _ in range(X+1)]
dpy=[[False for i in range(2*T+1)] for _ in range(Y+1)]
dpx[0][T]=True
dpy[0][T]=True
for l in range(X):
for i in range(2*T+1):
if dpx[l][i]:
dpx[l+1][i+A[l]]=True
if l==0:
continue
dpx[l+1][i-A[l]]=True
for r in range(Y):
for i in range(2*T+1):
if dpy[r][i]:
dpy[r+1][i-B[r]]=True
dpy[r+1][i+B[r]]=True
if dpx[X][x+T] and dpy[Y][y+T]:
print("Yes")
else:
print("No")
| p03488 |
# D - FT Robot
# coding: utf-8
def check(d, to_d):
meu = [0]
for i in to_d:
hoge = []
for j in meu:
hoge.append(j+i), hoge.append(j-i)
meu = hoge
return d in meu
S = [ len(F) for F in input().split('T') ]
x, y = list(map(int, input().split()))
to_x, to_y = S[2::2], S[1::2]
print("Yes" if check(x-S[0],to_x) and check(y,to_y) else "No") | # D - FT Robot
# coding: utf-8
def check(d, to_d):
meu = [0]
for i in to_d:
hoge = []
for j in meu:
if not j+i in hoge : hoge.append(j+i)
if not j-i in hoge : hoge.append(j-i)
meu = hoge
return d in meu
S = list(map(len, input().split('T')))
x, y = list(map(int, input().split()))
to_x, to_y = S[2::2], S[1::2]
print("Yes" if check(x-S[0],to_x) and check(y,to_y) else "No") | p03488 |
# D - FT Robot
# coding: utf-8
def check(d, to_d):
meu = [0]
for i in to_d:
hoge = []
for j in meu:
if not j+i in hoge : hoge.append(j+i)
if not j-i in hoge : hoge.append(j-i)
meu = hoge
return d in meu
# S = map(len, raw_input().split('T'))
a = input()
S = list(map(len, a.split('T')))
x, y = list(map(int, input().split()))
to_x, to_y = S[2::2], S[1::2]
print("Yes" if check(x-S[0],to_x) and check(y,to_y) else "No") | # D - FT Robot
# coding: utf-8
def check(d, to_d):
meu = set([0])
for i in to_d:
hoge = set([])
for j in meu: hoge.add(j+i), hoge.add(j-i)
meu = hoge
return d in meu
S = list(map(len, input().split('T')))
x, y = list(map(int, input().split()))
to_x, to_y = S[2::2], S[1::2]
print("Yes" if check(x-S[0],to_x) and check(y,to_y) else "No")
| p03488 |
s=list(input().split("T"))
#print s
x,y=list(map(int,input().split()))
cx,cy=len(s[0]),0
lx=[len(_) for _ in s[2::2]]
ly=[len(_) for _ in s[1::2]]
#print lx
#print ly
memo_x=[set((cx,))]
for ind_i,i in enumerate(lx):
next_memo_x = set()
for j in memo_x[ind_i]:
next_memo_x.add(j+i)
next_memo_x.add(j-i)
memo_x.append(next_memo_x)
#print memo_x
memo_y=[set((cy,))]
for ind_i,i in enumerate(ly):
next_memo_y = set()
for j in memo_y[ind_i]:
next_memo_y.add(j+i)
next_memo_y.add(j-i)
memo_y.append(next_memo_y)
#print memo_y
if x in memo_x[-1] and y in memo_y[-1]:
print("Yes")
else:
print("No")
| s=list(input().split("T"))
x,y=list(map(int,input().split()))
lx=[len(_) for _ in s[2::2]]
ly=[len(_) for _ in s[1::2]]
dpx=set()
dpx.add(len(s[0]))
for i in lx:
tmp=set()
for j in dpx:
tmp.add(j+i)
tmp.add(j-i)
dpx=tmp
dpy=set()
dpy.add(0)
for i in ly:
tmp=set()
for j in dpy:
tmp.add(j+i)
tmp.add(j-i)
dpy=tmp
print("Yes" if x in dpx and y in dpy else "No")
| p03488 |
import sys
## io ##
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list([x-1 for x in MII()])
## dp ##
def DD2(d1,d2,init=0): return [[init]*d2 for _ in range(d1)]
def DD3(d1,d2,d3,init=0): return [DD2(d2,d3,init) for _ in range(d1)]
## math ##
MOD=10**9+7
def divc(x,y): return -(-x//y)
def divf(x,y): return x//y
def gcd(x,y):
while y: x,y = y,x%y
return x
def lcm(x,y): return x*y//gcd(x,y)
def get_primes(MAX_NUM=10**3):
"""Return a list of prime numbers"""
is_prime = [True] * MAX_NUM
is_prime[0] = False
is_prime[1] = False
primes = []
for i in range(MAX_NUM):
if is_prime[i]:
primes.append(i)
for j in range(2*i, MAX_NUM, i):
is_prime[j] = False
return primes
## libs ##
from itertools import accumulate as acc
from collections import deque, Counter
from heapq import heapify, heappop, heappush
from bisect import bisect_left
#======================================================#
def main():
s = IS()
x, y = MII()
n = len(s)
dpx = DD2(n,10**5,init=False)
dpy = DD2(n,10**5,init=False)
ff = s.split('T')
ffx = [len(f) for f in ff[::2]]
ffy = [len(f) for f in ff[1::2]]
nx = len(ffx)
ny = len(ffy)
if len(ffx) > 0:
dpx[0][ffx[0]] = True
for i in range(1, nx):
for j in range(-8000, 8001):
dpx[i][j] = dpx[i-1][j-ffx[i]] or dpx[i-1][j+ffx[i]]
if len(ffy) > 0:
dpy[0][ffy[0]] = dpy[0][-ffy[0]]= True
for i in range(1, ny):
for j in range(-8000, 8001):
dpy[i][j] = dpy[i-1][j-ffy[i]] or dpy[i-1][j+ffy[i]]
if dpx[nx-1][x] and dpy[ny-1][y]: print('Yes')
else: print('No')
if __name__ == '__main__':
main() | import sys
## io ##
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list([x-1 for x in MII()])
## dp ##
def DD2(d1,d2,init=0): return [[init]*d2 for _ in range(d1)]
def DD3(d1,d2,d3,init=0): return [DD2(d2,d3,init) for _ in range(d1)]
## math ##
MOD=10**9+7
def divc(x,y): return -(-x//y)
def divf(x,y): return x//y
def gcd(x,y):
while y: x,y = y,x%y
return x
def lcm(x,y): return x*y//gcd(x,y)
def get_primes(MAX_NUM=10**3):
"""Return a list of prime numbers"""
is_prime = [True] * MAX_NUM
is_prime[0] = False
is_prime[1] = False
primes = []
for i in range(MAX_NUM):
if is_prime[i]:
primes.append(i)
for j in range(2*i, MAX_NUM, i):
is_prime[j] = False
return primes
## libs ##
from itertools import accumulate as acc
from collections import deque, Counter
from heapq import heapify, heappop, heappush
from bisect import bisect_left
#======================================================#
def main():
s = IS()
x, y = MII()
ff = s.split('T')
ffx = [len(f) for f in ff[::2]]
ffy = [len(f) for f in ff[1::2]]
nx = ffx.pop(0)
ny = 0
ffx.sort(reverse=True)
ffy.sort(reverse=True)
for fx in ffx:
if x >= nx: nx += fx
else: nx -= fx
for fy in ffy:
if y >= ny: ny += fy
else: ny -= fy
if nx == x and ny == y: print('Yes')
else: print('No')
if __name__ == '__main__':
main() | p03488 |
s=input().split('T')
x,y=list(map(int,input().split()))
dx,dy={0},{0}
for i,a in enumerate(map(len,s[::2])):
if i:dx=set(t+a for t in dx)|set(t-a for t in dx)
else:dx={a}
for b in map(len,s[1::2]):dy=set(t+b for t in dy)|set(t-b for t in dy)
if x in dx and y in dy:print('Yes')
else:print('No') | t,*s=input().split('T')
x,y=list(map(int,input().split()))
dx,dy={len(t)},{0}
for a in map(len,s[1::2]):dx=set(t+a for t in dx)|set(t-a for t in dx)
for b in map(len,s[::2]):dy=set(t+b for t in dy)|set(t-b for t in dy)
if x in dx and y in dy:print('Yes')
else:print('No') | p03488 |
s = [len(i) for i in input().split("T")]
x,y = (int(i) for i in input().split())
xl,yl,flag = [],[],False
for i in range(len(s)):
if i%2==0: xl.append(s[i])
else: yl.append(s[i])
x,y,xl = abs(x-xl[0]),abs(y),xl[1:]
xs,ys,lenx,leny,xl2,yl2 = sum(xl),sum(yl),len(xl),len(yl),[0],[0]
a,b = [[0 for i in range(xs+1)] for i in range(len(xl)+1)],[[0 for i in range(ys+1)] for i in range(len(yl)+1)]
a[0][0],b[0][0] = 1,1
if xs>=x and (xs-x)%2==0 and ys>=y and (ys-y)%2==0: x2,y2,flag = (xs-x)//2,(ys-y)//2,True
else: print("No")
if flag:
for i in range(lenx): xl2.append(xl2[-1]+xl[i])
for i in range(leny): yl2.append(yl2[-1]+yl[i])
for i in range(lenx):
for j in range(xl2[i+1]+1):
if xl[i]<=j: a[i+1][j] = a[i][j-xl[i]] | a[i][j]
else: a[i+1][j] = a[i][j]
for i in range(leny):
for j in range(yl2[i+1]+1):
if yl[i]<=j: b[i+1][j] = b[i][j-yl[i]] | b[i][j]
else: b[i+1][j] = b[i][j]
if a[-1][x2] and b[-1][y2]: print("Yes")
else: print("No") | s = [len(i) for i in input().split("T")]
x,y = (int(i) for i in input().split())
xl,yl,flag = [],[],False
for i in range(len(s)):
if i%2==0: xl.append(s[i])
else: yl.append(s[i])
x,y,xl = abs(x-xl[0]),abs(y),xl[1:]
xs,ys,lenx,leny,xl2,yl2 = sum(xl),sum(yl),len(xl),len(yl),[0],[0]
a,b = [[0 for i in range(xs+1)] for i in range(lenx+1)],[[0 for i in range(ys+1)] for i in range(leny+1)]
a[0][0],b[0][0] = 1,1
if xs>=x and (xs-x)%2==0 and ys>=y and (ys-y)%2==0: x2,y2,flag = (xs-x)//2,(ys-y)//2,True
else: print("No")
if flag:
for i in range(lenx):
for j in range(x2+1):
if xl[i]<=j: a[i+1][j] = a[i][j-xl[i]] | a[i][j]
else: a[i+1][j] = a[i][j]
for i in range(leny):
for j in range(y2+1):
if yl[i]<=j: b[i+1][j] = b[i][j-yl[i]] | b[i][j]
else: b[i+1][j] = b[i][j]
if a[-1][x2] and b[-1][y2]: print("Yes")
else: print("No") | p03488 |
S = input().split('T')
N = len(S)
X = []
Y = []
for i in range(N):
if i%2:
Y.append(len(S[i]))
else:
X.append(len(S[i]))
Xsum = sum(X)
Ysum = sum(Y)
from collections import defaultdict,deque
dpx = defaultdict(int)# 初期値を0にした辞書
dpy = defaultdict(int)# 初期値を0にした辞書
dpx[Xsum] = 1
dpy[Ysum] = 1
que = deque()
for i,x in enumerate(X):
if i == 0:
continue
for k,v in list(dpx.items()):
if v:
que.append(k-2*x)
while que:
q = que.popleft()
dpx[q] = 1
for i,y in enumerate(Y):
for k,v in list(dpy.items()):
if v:
que.append(k-2*y)
while que:
q = que.popleft()
dpy[q] = 1
x,y = list(map(int,input().split()))
print(('Yes' if dpx[x] and dpy[y] else 'No'))
| S = input().split('T')
S = [len(s) for s in S]
X = S[::2]
Y = S[1::2]
from collections import defaultdict,deque
dpx = defaultdict(int)# 初期値を0にした辞書
dpy = defaultdict(int)# 初期値を0にした辞書
dpx[sum(X)] = 1
dpy[sum(Y)] = 1
que = deque()
for i,x in enumerate(X):
if i == 0:
continue
for k,v in list(dpx.items()):
if v:
que.append(k-2*x)
while que:
q = que.popleft()
dpx[q] = 1
for i,y in enumerate(Y):
for k,v in list(dpy.items()):
if v:
que.append(k-2*y)
while que:
q = que.popleft()
dpy[q] = 1
x,y = list(map(int,input().split()))
print(('Yes' if dpx[x] and dpy[y] else 'No'))
| p03488 |
import sys
sys.setrecursionlimit(10**7)
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 II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7
def can_reach(x, default_pos, x_moves):
for tries in range(2**len(x_moves)):
result = default_pos
for digit in range(len(x_moves)):
result += (x_moves[digit] if tries & (1<<digit) else -x_moves[digit])
if result == x:
return True
return False
def main():
s = SI()
x, y = LI()
x_moves = []
y_moves = []
moving_x = True
for i in s.split('T'):
if moving_x:
x_moves.append(len(i))
else:
y_moves.append(len(i))
moving_x = not moving_x
if can_reach(x, x_moves[0], x_moves[1:]) and can_reach(y, 0, y_moves):
print('Yes')
else:
print('No')
main() | import sys
sys.setrecursionlimit(10**7)
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 II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7
# def can_reach(x, default_pos, x_moves):
# for tries in range(2**len(x_moves)): # x_moves は最大 4000, 2**100 で既に 10**30 なのでぜんぜん間に合わない。
# result = default_pos
# for digit in range(len(x_moves)):
# result += (x_moves[digit] if tries & (1<<digit) else -x_moves[digit])
# if result == x:
# return True
# return False
def can_reach(x_aim, default_pos, x_moves): # ソートして貪欲？
for i in sorted(x_moves, reverse=True):
if x_aim > default_pos:
default_pos += i
else:
default_pos -= i
if default_pos == x_aim:
return True
else:
return False
def main():
s = SI()
x, y = LI()
x_moves = []
y_moves = []
moving_x = True
for i in s.split('T'):
if moving_x:
x_moves.append(len(i))
else:
y_moves.append(len(i))
moving_x = not moving_x
if can_reach(x, x_moves[0], x_moves[1:]) and can_reach(y, 0, y_moves):
print('Yes')
else:
print('No')
main() | p03488 |
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby
#from itertools import product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil
#from operator import itemgetter
#inf = 10**17
#mod = 10**9 + 7
s = input().rstrip() + 'T'
x,y = list(map(int, input().split()))
# 奇数はy方向, 偶数はx方向
l = []
susumu = 0
for i in range(len(s)):
if s[i] == 'T':
l.append(susumu)
susumu = 0
else:
susumu += 1
b = len(l)
dp = [[0]*16001 for _ in range(3)]
dp[0][8000] = 1
dp[1][8000] = 1
for i in range(b):
if i==0:
dp[2][8000+l[i]] = 1
elif i%2 == 0:
for j in range(16000):
if dp[0][j]:
dp[2][j-l[i]] = 1
dp[2][j+l[i]] = 1
elif i%2 == 1:
for j in range(16000):
if dp[0][j]:
dp[2][j-l[i]] = 1
dp[2][j+l[i]] = 1
dp = dp[1:] + [[0]*16000]
if b%2 == 0:
if dp[0][x+8000] == 1 and dp[1][y+8000] == 1:
print('Yes')
else:
print('No')
else:
if dp[1][x+8000] == 1 and dp[0][y+8000] == 1:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main() | def main():
import sys
input = sys.stdin.readline
s = input().rstrip()
x,y = list(map(int, input().split()))
f = s.split('T')
dx_list = list(map(len, f[::2]))
dy_list = list(map(len, f[1::2]))
nx = dx_list.pop(0)
ny = 0
dx_list.sort(reverse=True)
dy_list.sort(reverse=True)
for dx in dx_list:
if x >= nx:
nx += dx
else:
nx -= dx
for dy in dy_list:
if y >= ny:
ny += dy
else:
ny -= dy
if nx == x and ny == y:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main() | p03488 |
s = list(map(len, input().split("T")))
*x, = list(map(int,input().split()))
x[0] -= s[0]
s = s[1:]
ans = True
for j in range(2):
dp = [False]*(8000*2+1)
dp[8000] = True
MAX, MIN = 8000, 8000
for i in range(j, len(s), 2):
dp_new = [False]*(8000*2+1)
MIN_ = 8000*2+1
MAX_ = -1
for k in range(MIN, MAX+1):
if dp[k]:
dp_new[k-s[i]] = True
MIN_ = min(MIN_, k-s[i])
dp_new[k+s[i]] = True
MAX_ = max(MAX_, k+s[i])
dp = dp_new
MIN, MAX = MIN_, MAX_
ans = ans and dp[x[1-j]+8000]
print((["No","Yes"][ans]))
| s = list(map(len, input().split("T")))
*x, = list(map(int,input().split()))
x[0] -= s[0]
s = s[1:]
moveX, moveY = [], []
for i in range(len(s)):
if i%2 == 0:
moveY.append(s[i])
else:
moveX.append(s[i])
X = [x[0]]
Y = [x[1]]
for x in moveX:
X_ = []
for cx in X:
X_.append(cx+x)
X_.append(cx-x)
X = list(set(X_))
for y in moveY:
Y_ = []
for cy in Y:
Y_.append(cy+y)
Y_.append(cy-y)
Y = list(set(Y_))
print((["No","Yes"][0 in X and 0 in Y]))
| p03488 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def check(vec, init_pos, target_pos):
base = 8000
dp = [[False] * 16001 for _ in range(len(vec) + 1)]
dp[0][init_pos + base] = True
for i in range(len(vec)):
for j in range(16001):
if j - vec[i] >= 0 and dp[i][j - vec[i]] or j + vec[i] <= 16000 and dp[i][j + vec[i]]:
dp[i + 1][j] = True
return dp[len(vec)][target_pos + base]
def main():
S = readline().strip()
x, y = list(map(int, readline().split()))
idx = len(S)
for i, c in enumerate(S):
if c == 'T':
idx = i
break
init_x = idx
step = [[0] for _ in range(2)]
i = 0
for c in S[idx:]:
if c == 'T':
i = 1 - i
step[i].append(0)
else:
step[i][-1] += 1
ok = check(step[0], init_x, x) and check(step[1], 0, y)
if ok:
print('Yes')
else:
print('No')
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def check(vec, init_pos, target_pos):
base = 8000
dp = [False] * 16001
dp[init_pos + base] = True
for i in range(len(vec)):
dp, dp_prev = [False] * 16001, dp
for j in range(16001):
if (
j - vec[i] >= 0
and dp_prev[j - vec[i]]
or j + vec[i] <= 16000
and dp_prev[j + vec[i]]
):
dp[j] = True
return dp[target_pos + base]
def main():
S = readline().strip()
x, y = list(map(int, readline().split()))
idx = len(S)
for i, c in enumerate(S):
if c == 'T':
idx = i
break
init_x = idx
step = [[0] for _ in range(2)]
i = 0
for c in S[idx:]:
if c == 'T':
i = 1 - i
step[i].append(0)
else:
step[i][-1] += 1
ok = check(step[0], init_x, x) and check(step[1], 0, y)
if ok:
print('Yes')
else:
print('No')
return
if __name__ == '__main__':
main()
| p03488 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def check(vec, init_pos, target_pos):
base = 8000
dp = [False] * 16001
dp[init_pos + base] = True
for i in range(len(vec)):
dp, dp_prev = [False] * 16001, dp
for j in range(16001):
if (
j - vec[i] >= 0
and dp_prev[j - vec[i]]
or j + vec[i] <= 16000
and dp_prev[j + vec[i]]
):
dp[j] = True
return dp[target_pos + base]
def main():
S = readline().strip()
x, y = list(map(int, readline().split()))
idx = len(S)
for i, c in enumerate(S):
if c == 'T':
idx = i
break
init_x = idx
step = [[0] for _ in range(2)]
i = 0
for c in S[idx:]:
if c == 'T':
i = 1 - i
step[i].append(0)
else:
step[i][-1] += 1
ok = check(step[0], init_x, x) and check(step[1], 0, y)
if ok:
print('Yes')
else:
print('No')
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def check(vec, init_pos, target_pos):
base = 8000
dp = [False] * 16001
dp[init_pos + base] = True
for i in range(len(vec)):
dp, dp_prev = [False] * 16001, dp
for j in range(16001):
if (
j - vec[i] >= 0
and dp_prev[j - vec[i]]
or j + vec[i] <= 16000
and dp_prev[j + vec[i]]
):
dp[j] = True
return dp[target_pos + base]
def main():
S = readline().strip()
x, y = list(map(int, readline().split()))
idx = len(S)
for i, c in enumerate(S):
if c == 'T':
idx = i
break
init_x = idx
step = [[] for _ in range(2)]
i = 0
for c in S[idx:]:
if c == 'T':
i = 1 - i
step[i].append(0)
else:
step[i][-1] += 1
for row in step:
row = [v for v in row if v != 0]
if not row:
row = [0]
ok = check(step[0], init_x, x) and check(step[1], 0, y)
if ok:
print('Yes')
else:
print('No')
return
if __name__ == '__main__':
main()
| p03488 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def check(vec, init_pos, target_pos):
base = 8000
dp = [False] * 16001
dp[init_pos + base] = True
for i in range(len(vec)):
dp, dp_prev = [False] * 16001, dp
for j in range(16001):
if (
j - vec[i] >= 0
and dp_prev[j - vec[i]]
or j + vec[i] <= 16000
and dp_prev[j + vec[i]]
):
dp[j] = True
return dp[target_pos + base]
def main():
S = readline().strip()
x, y = list(map(int, readline().split()))
idx = len(S)
for i, c in enumerate(S):
if c == 'T':
idx = i
break
init_x = idx
step = [[] for _ in range(2)]
i = 0
for c in S[idx:]:
if c == 'T':
i = 1 - i
step[i].append(0)
else:
step[i][-1] += 1
for row in step:
row = [v for v in row if v != 0]
if not row:
row = [0]
ok = check(step[0], init_x, x) and check(step[1], 0, y)
if ok:
print('Yes')
else:
print('No')
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def check(vec, init_pos, target_pos):
dp = {init_pos}
for nv in vec:
dp_next = set()
for v in dp:
dp_next.add(v - nv)
dp_next.add(v + nv)
dp = dp_next
return target_pos in dp
def main():
S = readline().strip()
x, y = list(map(int, readline().split()))
L = [len(commands) for commands in S.split('T')]
init_x = L[0]
x_commands = L[2::2]
y_commands = L[1::2]
ok = check(x_commands, init_x, x) and check(y_commands, 0, y)
if ok:
print('Yes')
else:
print('No')
return
if __name__ == '__main__':
main()
| p03488 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def check(vec, init_pos, target_pos):
dp = {init_pos}
for nv in vec:
dp_next = set()
for v in dp:
dp_next.add(v - nv)
dp_next.add(v + nv)
dp = dp_next
return target_pos in dp
def main():
S = readline().strip()
x, y = list(map(int, readline().split()))
L = [len(commands) for commands in S.split('T')]
init_x = L[0]
x_commands = L[2::2]
y_commands = L[1::2]
ok = check(x_commands, init_x, x) and check(y_commands, 0, y)
if ok:
print('Yes')
else:
print('No')
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def check(vec, init_pos, target_pos):
dp = {init_pos}
for nv in vec:
dp_next = set()
for v in dp:
dp_next.add(v - nv)
dp_next.add(v + nv)
dp = dp_next
return target_pos in dp
def main():
S = readline().strip()
x, y = list(map(int, readline().split()))
L = [len(commands) for commands in S.split('T')]
init_x = L[0]
x_commands = [c for c in L[2::2] if c != 0]
y_commands = [c for c in L[1::2] if c != 0]
ok = check(x_commands, init_x, x) and check(y_commands, 0, y)
if ok:
print('Yes')
else:
print('No')
return
if __name__ == '__main__':
main()
| p03488 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def check(vec, init_pos, target_pos):
dp = {init_pos}
for nv in vec:
dp_next = set()
for v in dp:
dp_next.add(v - nv)
dp_next.add(v + nv)
dp = dp_next
return target_pos in dp
def main():
S = readline().strip()
x, y = list(map(int, readline().split()))
L = [len(commands) for commands in S.split('T')]
init_x = L[0]
x_commands = [c for c in L[2::2] if c != 0]
y_commands = [c for c in L[1::2] if c != 0]
ok = check(x_commands, init_x, x) and check(y_commands, 0, y)
if ok:
print('Yes')
else:
print('No')
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def check(vec, init_pos, target_pos):
dp = {init_pos}
for nv in vec:
if nv == 0:
continue
dp_next = set()
for v in dp:
dp_next.add(v - nv)
dp_next.add(v + nv)
dp = dp_next
return target_pos in dp
def main():
S = readline().strip()
x, y = list(map(int, readline().split()))
L = [len(commands) for commands in S.split('T')]
init_x = L[0]
x_commands = L[2::2]
y_commands = L[1::2]
ok = check(x_commands, init_x, x) and check(y_commands, 0, y)
if ok:
print('Yes')
else:
print('No')
return
if __name__ == '__main__':
main()
| p03488 |
#!/usr/bin/env python3
import sys, heapq
sys.setrecursionlimit(300000)
YES = "Yes" # type: str
NO = "No" # type: str
def solve(N: int, S: "List[str]"):
tmp = []
for i in range(N):
cur = 0
mn = 0
for c in S[i]:
if c == '(':
cur += 1
else:
cur -= 1
mn = min(mn, cur)
tmp.append((mn, cur, cur - mn))
tmp.sort(key=lambda x: (x[0], x[1]), reverse=True)
#print(tmp)
cur = 0
idx = 0
q = []
count = 0
while idx < N or len(q) > 0:
while idx < N and cur + tmp[idx][0] >= 0:
heapq.heappush(q, (-tmp[idx][2], -tmp[idx][1], -tmp[idx][0]))
idx += 1
if len(q) == 0:
print(NO)
return
#print(count, q)
diff, cnt, mn = heapq.heappop(q)
diff, cnt, mn = -diff, -cnt, -mn
#print(cnt, mn)
if cur + mn < 0:
print(NO)
return
cur += cnt
count += 1
#print(cur)
if cur == 0:
ret = YES
else:
ret = NO
print(ret)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
S = [next(tokens) for _ in range(N)] # type: "List[str]"
solve(N, S)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys, heapq
sys.setrecursionlimit(300000)
YES = "Yes" # type: str
NO = "No" # type: str
def solve(N: int, S: "List[str]"):
tmp = []
for i in range(N):
cur = 0
mn = 0
for c in S[i]:
if c == '(':
cur += 1
else:
cur -= 1
mn = min(mn, cur)
tmp.append((mn, cur))
tmp.sort(key=lambda x: (x[1] < 0, (-x[0] if x[1] >= 0 else -(x[1] - x[0]))))
#tmp.sort(key=lambda x: (x[1] < 0, -x[0], x[1]))
#print(tmp)
cur = 0
for mn, cnt in tmp:
#print(cur, mn, cnt)
if abs(mn) > cur:
print(NO)
return
cur += cnt
if cur == 0:
ret = YES
else:
ret = NO
print(ret)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
S = [next(tokens) for _ in range(N)] # type: "List[str]"
solve(N, S)
if __name__ == '__main__':
main()
| p02686 |
N = int(eval(input()))
D, E = [], []
t,l = 0, 0
res = 0
for _ in range(N):
S = input().rstrip()
x,y = 0,0
for s in S:
if s=="(": x+=1
else: x=max(x-1,0)
for s in reversed(S):
if s==")": y+=1
else: y=max(y-1,0)
D.append((x,y))
D.sort(key=lambda x:x[1])
t = 0
for x,y in D:
if x-y>=0:
if t>=y: t+=x-y
else: print("No"); exit()
D.sort(key=lambda x:x[0])
s = 0
for x,y in D:
if y-x>=0:
if s>=x: s+=y-x
else: print("No"); exit()
if t!=s: print("No")
else: print("Yes")
| import sys
input = sys.stdin.readline
N = int(eval(input()))
D, E = [], []
t,l = 0, 0
res = 0
for _ in range(N):
S = input().rstrip()
x,y = 0,0
for s in S:
if s=="(": x+=1
else: x=max(x-1,0)
for s in reversed(S):
if s==")": y+=1
else: y=max(y-1,0)
D.append((x,y))
D.sort(key=lambda x:x[1])
t = 0
for x,y in D:
if x-y>=0:
if t>=y: t+=x-y
else: print("No"); exit()
D.sort(key=lambda x:x[0])
s = 0
for x,y in D:
if y-x>=0:
if s>=x: s+=y-x
else: print("No"); exit()
if t!=s: print("No")
else: print("Yes")
| p02686 |
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)
from heapq import heappush, heappop
def input():
return sys.stdin.readline().strip()
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
return [ int(input()) for _ in range(n)]
# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
return map(int, open(0).read().split())
def rangeI(it, l, r):
for i, e in enumerate(it):
if l <= i < r:
yield e
elif l >= r:
break
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
INF = 999999999999999999999999
MOD = 10**9+7
n = int(input())
S = [ input() for _ in range(n)]
left = 0
right = 0
l_ok = [False] * n
r_ok = [False] * n
LMR = [0] * n
MIN_LMR = [0] * n
for i,s in enumerate(S):
l = 0
r = 0
lok = True
for j,c in enumerate(s):
if c == "(":
l += 1
else:
r += 1
if r > l:
lok = False
MIN_LMR[i] = min(MIN_LMR[i], l-r)
LMR[i] = l - r
l = 0
r = 0
rok = True
for j in range(len(s)-1, -1, -1):
if s[j] == "(":
l += 1
if l > r:
rok = False
break
else:
r += 1
left += s.count("(")
right += s.count(")")
l_ok[i] = lok
r_ok[i] = rok
# log(l_ok)
# log(r_ok)
if left != right:
print("No")
exit()
positives = [ (MIN_LMR[i], LMR[i]) for i,x in enumerate(LMR) if x > 0 ]
zeros = [ (MIN_LMR[i], LMR[i]) for i,x in enumerate(LMR) if x == 0 ]
negatives = [ (MIN_LMR[i], LMR[i]) for i,x in enumerate(LMR) if x < 0]
for i in range(len(negatives)):
min_lmr, lmr = negatives[i]
min_lmr = min_lmr - lmr
lmr = -1 * lmr
negatives[i] = (min_lmr, lmr)
positives.sort(reverse=True)
negatives.sort(reverse=True)
h = 0
for min_lmr, lmr in positives + zeros:
if h+min_lmr < 0:
print("No")
exit()
h += lmr
h = 0
for min_lmr, lmr in negatives:
if h+min_lmr < 0:
print("No")
exit()
h += lmr
print("Yes")
| import sys
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline().strip()
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
n = int(input())
S = [ input() for _ in range(n)]
left = 0
right = 0
LMR = [0] * n
MIN_LMR = [0] * n
for i,s in enumerate(S):
l = 0
r = 0
lok = True
for j,c in enumerate(s):
if c == "(":
l += 1
else:
r += 1
if r > l:
lok = False
MIN_LMR[i] = min(MIN_LMR[i], l-r)
LMR[i] = l - r
left += l
right += r
if left != right:
print("No")
exit()
positives = [ (MIN_LMR[i], LMR[i]) for i,x in enumerate(LMR) if x > 0 ]
zeros = [ (MIN_LMR[i], LMR[i]) for i,x in enumerate(LMR) if x == 0 ]
negatives = [ (MIN_LMR[i], LMR[i]) for i,x in enumerate(LMR) if x < 0]
for i in range(len(negatives)):
# 負の要素だけ、裏返して末尾から見た値に変換する
min_lmr, lmr = negatives[i]
min_lmr = min_lmr - lmr
lmr = -1 * lmr
negatives[i] = (min_lmr, lmr)
positives.sort(reverse=True)
negatives.sort(reverse=True)
h = 0
for min_lmr, lmr in positives + zeros:
if h+min_lmr < 0:
print("No")
exit()
h += lmr
h = 0
for min_lmr, lmr in negatives:
if h+min_lmr < 0:
print("No")
exit()
h += lmr
print("Yes")
| p02686 |
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, cos, radians, pi, sin
from operator import mul
from functools import reduce
from operator import mul
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
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)]
n = I()
A = []
B = []
for _ in range(n):
s = S()
ret = 0
ret2 = 0
for i in s:
if ret and i == ')':
ret -= 1
elif i == '(':
ret += 1
else:
ret2 += 1
if ret2 > ret:
A += [(ret, ret2)]
else:
B += [(ret, ret2)]
A.sort()
B.sort(key=lambda x:x[1], reverse=True)
L = A + B
now = 0
for x, y in L:
if x > now:
print('No')
exit()
now = now - x + y
if now:
print('No')
else:
print('Yes')
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
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, acos, asin, atan, sqrt, tan, cos, pi
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
n = I()
plus = []
minus = []
for _ in range(n):
s = S()
ret = 0
ret2 = 0
for i in s:
if ret and i == ')':
ret -= 1
elif i == '(':
ret += 1
else:
ret2 += 1
if ret2 > ret:
plus += [(ret, ret2)]
else:
minus += [(ret, ret2)]
plus.sort()
minus.sort(key=lambda x:x[1], reverse=True)
L = plus + minus
now = 0
for x, y in L:
if x > now:
print("No")
exit()
now = now - x + y
if now:
print("No")
else:
print("Yes") | p02686 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
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, acos, asin, atan, sqrt, tan, cos, pi
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
n = I()
plus = []
minus = []
for _ in range(n):
s = S()
ret = 0
ret2 = 0
for i in s:
if ret and i == ')':
ret -= 1
elif i == '(':
ret += 1
else:
ret2 += 1
if ret2 > ret:
plus += [(ret, ret2)]
else:
minus += [(ret, ret2)]
plus.sort()
minus.sort(key=lambda x:x[1], reverse=True)
L = plus + minus
now = 0
for x, y in L:
if x > now:
print("No")
exit()
now = now - x + y
if now:
print("No")
else:
print("Yes") | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
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, acos, asin, atan, sqrt, tan, cos, pi
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
n = I()
plus = []
minus = []
for _ in range(n):
s = S()
ret = 0
ret2 = 0
for i in s:
if ret and i == ')':
ret -= 1
elif i == '(':
ret += 1
else:
ret2 += 1
if ret2 > ret:
plus += [(ret, ret2)]
else:
minus += [(ret, ret2)]
plus.sort()
minus.sort(key=lambda x:x[1], reverse=True)
L = plus + minus
now = 0
for x, y in L:
now -= x
if now < 0:
print("No")
exit()
now += y
if now:
print("No")
else:
print("Yes") | p02686 |
# -*- coding: utf-8 -*-
N = int(input().strip())
S_list = [input().strip() for _ in range(N)]
#-----
def count_brackets(brackets):
cnt = 0
min_cnt = float("inf")
for i in range(len(brackets)):
if brackets[i] == "(":
cnt += 1
else: # brackets[i] == ")"
cnt -= 1
min_cnt = min(min_cnt, cnt)
return cnt, min_cnt
#-----
tmp_cnt_plus = []
tmp_cnt_minus = []
for S in S_list:
cnt, min_cnt = count_brackets(S)
if cnt >= 0:
tmp_cnt_plus.append( (cnt, min_cnt) )
else: # cnt < 0
tmp_cnt_minus.append( (cnt, min_cnt) )
tmp_cnt_plus.sort(key=lambda x: -x[1])
tmp_cnt_minus.sort(key=lambda x: -(x[0]-x[1]) )
sum_bracket = 0
flag = True
for cnt, min_cnt in (tmp_cnt_plus + tmp_cnt_minus):
if (sum_bracket + min_cnt) < 0:
flag = False
break
sum_bracket += cnt
if (sum_bracket == 0) and flag:
print("Yes")
else:
print("No")
| # -*- coding: utf-8 -*-
N = int(input().strip())
S_list = [input().strip() for _ in range(N)]
#-----
def count_brackets(brackets):
cnt = 0
min_cnt = 0
for i in range(len(brackets)):
if brackets[i] == "(":
cnt += 1
else: # brackets[i] == ")"
cnt -= 1
min_cnt = min(min_cnt, cnt)
return cnt, min_cnt
tmp_cnt_plus = []
tmp_cnt_minus = []
for S in S_list:
cnt, min_cnt = count_brackets(S)
if cnt == min_cnt == 0:
continue
if cnt >= 0:
tmp_cnt_plus.append( (cnt, min_cnt) )
else: # cnt < 0
tmp_cnt_minus.append( (cnt, min_cnt) )
tmp_cnt_plus.sort(key=lambda x: -x[1])
tmp_cnt_minus.sort(key=lambda x: -(x[0]-x[1]) )
sum_bracket = 0
flag = True
for cnt, min_cnt in (tmp_cnt_plus + tmp_cnt_minus):
if (sum_bracket + min_cnt) < 0:
flag = False
break
sum_bracket += cnt
if (sum_bracket == 0) and flag:
print("Yes")
else:
print("No")
| p02686 |
import heapq
import sys
input = sys.stdin.readline
n = int(eval(input()))
sss = [input()[:-1] for _ in range(n)]
a = []
b = []
ss = 0
ii = 0
for i in sss:
mi = 0
ma = 0
s = 0
for j in i:
if j == "(":
s += 1
else:
s -= 1
mi = min(mi, s)
ma = max(ma, s)
ss += s
if s >= 0:
a.append([-s, mi, ma, ii])
else:
b.append([s, mi - s, ma - s, ii])
ii += 1
if ss != 0:
print("No")
exit()
a.sort(reverse=1, key=lambda x: x[1])
b.sort(reverse=1, key=lambda x: x[1])
def ok1(a):
s = 0
heap = []
i = 0
while True:
while i < len(a) and a[i][1] + s >= 0:
heapq.heappush(heap, a[i])
i += 1
if i < len(a) and not heap:
print("No")
exit()
if not heap:
break
kkk = 0
for j in sss[heapq.heappop(heap)[-1]]:
kkk += 1
if j == "(":
s += 1
else:
s -= 1
if s < 0:
print("No")
exit()
def ok(a):
s = 0
heap = []
i = 0
while True:
while i < len(a) and a[i][1] + s >= 0:
heapq.heappush(heap, a[i])
i += 1
if i < len(a) and not heap:
print("No")
exit()
if not heap:
break
kkk = 0
for j in reversed(sss[heapq.heappop(heap)[-1]]):
kkk += 1
if j == ")":
s += 1
else:
s -= 1
if s < 0:
print("No")
exit()
ok1(a)
ok(b)
print("Yes")
| import heapq
import sys
input = sys.stdin.readline
n = int(eval(input()))
sss = [input()[:-1] for _ in range(n)]
a = []
b = []
ss = 0
ii = 0
for i in sss:
mi = 0
ma = 0
s = 0
for j in i:
if j == "(":
s += 1
else:
s -= 1
mi = min(mi, s)
ma = max(ma, s)
ss += s
if s >= 0:
a.append([s, mi, ma, ii])
else:
mi = 0
ma = 0
s = 0
for j in reversed(i):
if j == ")":
s += 1
else:
s -= 1
mi = min(mi, s)
ma = max(ma, s)
b.append([s, mi, ma, ii])
ii += 1
if ss != 0:
print("No")
exit()
a.sort(reverse=1, key=lambda x: x[1])
b.sort(reverse=1, key=lambda x: x[1])
def ok(a):
s = 0
for i, j, _, _ in a:
if s + j < 0:
print("No")
exit()
s += i
ok(a)
ok(b)
print("Yes")
| p02686 |
n = int(input())
def gb(s):
bal,m = 0,0
for l in s:
bal += 1 if l == '(' else -1
m = min(m, bal)
return (bal,m)
rs = [gb(input()) for _ in range(n)]
rs.sort(key = lambda x: (0,-x[1], x[0]) if x[0]>=0 else (1,x[1] - x[0], -x[0]))
def f(rs):
s = 0
for aa,bb in rs:
if s + bb < 0: return False
s += aa
return s == 0
print('Yes' if f(rs) else 'No') | n = int(input())
def gb(s):
bal,m = 0,0
for l in s:
bal += 1 if l == '(' else -1
m = min(m, bal)
return (bal,m)
-1 -1 -1 -3 -5 -11 -23
-23 -11 -5 -3 -1 -1 -1
rs = [gb(input()) for _ in range(n)]
rs.sort(key = lambda x: (0, -x[1]) if x[0]>=0 else (1,x[1] - x[0], x[0]))
def f(rs):
s = 0
for aa,bb in rs:
if s + bb < 0: return False
s += aa
return s == 0
print('Yes' if f(rs) else 'No') | p02686 |
from sys import exit
from itertools import accumulate,chain
n,*s=open(0).read().split()
t=list([2*x.count("(")-len(x) for x in s])
if sum(t)!=0:
print("No")
exit()
#pypyではinitialだめ
st=[[t_,min(accumulate(s_,lambda a,b: a+(1 if b=="(" else -1),initial=0))] for s_,t_ in zip(s,t)]
now=sum([x[0] for x in [x for x in st if x[1]>=0]])
v=list([x for x in st if x[1]<0 and x[0]>=0])
w=list([x for x in st if x[1]<0 and x[0]<0])
v.sort(reverse=True,key=lambda z:z[1])
w.sort(key=lambda z:z[0]-z[1],reverse=True)
for sub in chain(v,w):
if now+sub[1]<0:
print("No");exit()
now+=sub[0]
print("Yes")
| from sys import exit
from itertools import accumulate,chain
n,*s=open(0).read().split()
t=[2*(i.count("("))-len(i) for i in s]
if sum(t)!=0:
print("No");exit()
#pypyではinitialだめ
st=[[t_,min(accumulate(s_,lambda a,b: a+(1 if b=="(" else -1),initial=0))] for s_,t_ in zip(s,t)]
now=0
v=list([x for x in st if x[0]>=0])
w=list([x for x in st if x[0]<0])
v.sort(reverse=True,key=lambda z:z[1])
w.sort(key=lambda z:z[0]-z[1],reverse=True)
for sub in chain(v,w):
if now+sub[1]<0:
print("No");exit()
now+=sub[0]
print("Yes")
| p02686 |
N,L=map(int,input().split());print(*(sorted([input() for _ in range(N)])),sep='')
| n,l=map(int,input().split());print(*sorted([input() for _ in range(n)]),sep='')
| p04044 |
# _*_ coding:utf-8 _*_
# Atcoder_Beginners_Contest042-B
# TODO https://atcoder.jp/contests/abc042/tasks/abc042_b
import time
from contextlib import contextmanager
# from time import sleep
@contextmanager
def timer(title):
t0 = time.time()
yield
print(("{} - done in {:.0f}s".format(title,time.time()-t0) ))
def makeString(givenStringCount):
givenStringsList = []
lineRange = list(range(0,givenStringCount,+1))
for i in lineRange:
givenStringsList.append(input().strip())
givenStringsSortedList = sorted(givenStringsList,reverse=False)
smallString = "".join(givenStringsSortedList)
answer = smallString
return answer
if __name__ == '__main__':
N,_ = list(map(int,input().strip().split(' ')))
# with timer("makeString"):
solution=makeString(N)
print(("{}".format(solution))) | # Problem: https://atcoder.jp/contests/abc042/tasks/abc042_b
# Python 1st Try
import sys
# from collections import defaultdict
# import heapq,copy
# from collections import deque
def II(): return int(sys.stdin.readline())
def MI(): return list(map(int, sys.stdin.readline().split()))
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def solver(allNum, longLeng, eachString):
result = ''
eachString.sort()
result = "".join(eachString)
return result
if __name__ == "__main__":
N, L = MI()
SI = []
for _ in range(0, N, +1):
getStrList = sys.stdin.readline().split()
SI.append(getStrList[0])
print(("{}".format(solver(N, L, SI))))
| p04044 |
N,L=map(int,input().split())
S=[]
for i in range (N):
S.append(input())
K=sorted(S)
for i in range (N):
print(K[i],end="")
print()
| N,L=map(int,input().split())
S=[]
for i in range(N):
S.append(input())
M=sorted(S)
for i in range(N):
print(M[i],end="")
print()
| p04044 |
#!usr/bin/env python3
from collections import defaultdict
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n): 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)]
mod = 1000000007
#A
"""
a = LI()
i = a.count(5)
j = a.count(7)
if i == 2 and j == 1:
print("YES")
else:
print("NO")
"""
#B
n,l = LI()
s = SR(n)
s.sort()
for i in s:
for j in i:
print(j,end = "")
print()
#C
"""
def check(n):
n = list(map(int,list(str(n))))
s = 0
for i in n:
s += f[i]
return s == 0
n,k = LI()
d = LI()
f = [0 for i in range(10)]
for i in d:
f[i] = 1
while 1:
if check(n):
print(n)
quit()
n += 1
"""
#D
"""
def f(x,y):
return fact[x-1+h-y]*fact[y-1+w-x]*inv_fact[x-1]*inv_fact[y-1]*inv_fact[w-x]*inv_fact[h-y]%mod
h,w,a,b = LI()
fact = [1]*(h+w+1)
for i in range(h+w):
fact[i+1] = fact[i]*(i+1)%mod
inv_fact = [0]*(h+w+1)
inv_fact[h+w] = pow(fact[-1],mod-2,mod)
for i in range(h+w)[::-1]:
inv_fact[i] = inv_fact[i+1]*(i+1)%mod
ans = 0
for i in range(1,min(w-b,h-a)+1):
ans += f(b+i,a+i)
ans %= mod
print(ans)
"""
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n,l = LI()
s = [input() for i in range(n)]
s.sort()
for i in s:
print(i,end = "")
print()
return
#Solve
if __name__ == "__main__":
solve()
| p04044 |
n, l = map(int, input().split())
s = sorted([input() for _ in range(n)])
print(*s, sep='')
| n, l = map(int, input().split())
print(*sorted([input() for _ in range(n)]), sep='')
| p04044 |
import sys
input = sys.stdin.readline
N, L = [int(x) for x in input().split()]
S = []
for _ in range(N):
S.append(input().rstrip())
S.sort()
print(("".join(S))) | import sys
input = sys.stdin.readline
n, l = [int(x) for x in input().split()]
s = [input().rstrip() for _ in range(n)]
s.sort()
print(("".join(s))) | p04044 |
N, L = map(int, input().split())
s = [input() for i in range(N)]
s.sort()
print(*s, sep="")
| N, L = map(int, input().split())
s = sorted([input() for i in range(N)])
print(*s, sep="")
| p04044 |
N,L = map(int,input().split())
S = sorted([input() for n in range(N)])
print(*S,sep="")
| N,L = map(int,input().split())
print(*sorted([input() for n in range(N)]),sep="")
| p04044 |
n, l = map(int, input().split())
print(*sorted([input() for i in range(n)]), sep="")
| n,l = map(int, input().split())
s = []
for _ in range(n):
s.append(input())
print(*sorted(s), sep='')
| p04044 |
from itertools import permutations
N, L = map(int, input().split())
S = [input() for _ in range(N)]
p = list(permutations(S))
print(*sorted(p)[0], sep='')
| N, L = map(int, input().split())
S = sorted(list(input() for _ in range(N)))
print(*S, sep='')
| p04044 |
# -*- coding: utf-8 -*-
n,l = map(int,input().split())
s = [input() for i in range(n)]
s = sorted(s)
print(*s,sep="")
| n,l = map(int,input().split())
s = sorted([input() for i in range(n)])
print(*s,sep="")
| p04044 |
import math
n,x = list(map(int,input().split()))
xl = list(map(int,input().split()))
dis = []
ans = 0
for i in range(n):
dis.append(abs(x-xl[i]))
for i in range(n):
ans = math.gcd(ans,dis[i])
print(ans) | N,X = list(map(int,input().split()))
x = list(map(int,input().split()))
ans = 0
from math import gcd
for i in range(N):
ans = gcd(ans,abs(X-x[i]))
print(ans) | p03262 |
import math
n,x=list(map(int,input().split()));l=[abs(x-i) for i in list(map(int,input().split()))]
if len(l)>1:
r=math.gcd(l[0],l[1])
for i in range(1,len(l)):
r=math.gcd(r,l[i])
else:
print((l[0]))
exit()
print(r) | import math
n,x=list(map(int,input().split()));l=[abs(x-i) for i in list(map(int,input().split()))];r=0
for i in range(len(l)): r=math.gcd(r,l[i])
print(r) | p03262 |
def solve(X, xs):
divs = list(range(1, int(10 ** 4.5) + 1))
def divisors(X, smaller_only=False):
fwd, bwd = [], []
for p in divs:
if X % p == 0:
fwd.append(p)
if not smaller_only and X // p != p:
bwd.append(X // p)
bwd.reverse()
return fwd + bwd
s = None
for x in xs:
ds = set(divisors(abs(x - X)))
if s:
s &= ds
else:
s = ds
return max(s)
def test():
print((solve(1, [2 ** i for i in range(30)])))
if __name__=='__main__':
N, X = list(map(int, input().split()))
xs = list(map(int, input().split()))
print((solve(X, xs)))
| try:
from math import gcd # >=Python 3.5
except:
from fractions import gcd # <Python 3.5 (AtCoder : 3.4)
def solve(X, xs):
xs = list(xs) + [X]
xs.sort()
zs = [x - xs[0] for x in xs]
for z in zs:
if z == 0:
D = z
else:
D = gcd(D, z)
return D
def test():
print((solve(13, [16 + 3 * 102485 * i for i in range(10**5)])))
if __name__=='__main__':
N, X = list(map(int, input().split()))
xs = list(map(int, input().split()))
print((solve(X, xs)))
| p03262 |
from math import gcd
from functools import reduce
_, X = list(map(int, input().split()))
x = set(map(int, input().split()))
x.add(X)
x = sorted(x)
print((reduce(gcd, (j - i for i, j in zip(x[:-1], x[1:]))))) | from math import gcd
from functools import reduce
_, X = list(map(int, input().split()))
print((reduce(gcd, (abs(i - X) for i in set(map(int, input().split())))))) | p03262 |
import math
def main():
n, s = list(map(int, input().split()))
xs = sorted(list(map(int, input().split())))
for i in range(n):
xs[i] = abs(xs[i] - s)
for i in range(1, n):
xs[i] = math.gcd(xs[i], xs[i-1])
print((xs[n-1]))
if __name__ == "__main__":
main()
| from math import gcd
def main():
n, x = list(map(int, input().split()))
xs = list(map(int, input().split()))
xs.append(x)
xs.sort()
diff = []
for i in range(1, n+1):
diff.append(xs[i] - xs[i-1])
ans = diff[0]
for i in range(1, n):
ans = gcd(ans, diff[i])
print(ans)
if __name__ == "__main__":
main()
| p03262 |
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
def gcd(m, n):
x = max(m, n)
y = min(m, n)
if x%y:
while x%y:
z = x%y
x, y = y, x
else:
return z
else:
return y
x.append(X)
x.sort()
# print(x)
# d = []
# for i in range(N):
# d.append(x[i+1]-x[i])
# print(d)
for i in range(N):
if i == 0:
c = x[i+1]-x[i]
else:
c = gcd(x[i+1]-x[i], c)
print(c)
| N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
def gcd(m, n):
x = max(m, n)
y = min(m, n)
# if x%y:
# while x%y:
# z = x%y
# x, y = y, x
# else:
# return z
# else:
# return y
if y == 0:
return x
else:
return gcd(y, x%y)
x.append(X)
x.sort()
# print(x)
# d = []
# for i in range(N):
# d.append(x[i+1]-x[i])
# print(d)
for i in range(N):
if i == 0:
c = x[i+1]-x[i]
else:
c = gcd(x[i+1]-x[i], c)
print(c)
| p03262 |
import math
# 最大公約数を求める問題
N, X = list(map(int, input().split()))
x = [int(_) for _ in input().split()]
if N == 1:
print((abs(x[0]-X)))
exit()
x.sort()
# N > 1と仮定
for i in range(N-1):
if x[i] < X and x[i+1] > X:
x = x[:i+1] + [X] + x[i+1:]
break
elif x[i] >= X:
x = [X] + x
elif x[i+1] <= X:
x = x + [X]
if len(x) >= 3:
base = math.gcd(x[1]-x[0], x[2]-x[1])
for i in range(2, N):
diff = x[i+1] - x[i]
base = math.gcd(base, diff)
print(base)
else:
print((x[1] - x[0]))
| import math
# 最大公約数を求める問題
N, X = list(map(int, input().split()))
x = [int(_) for _ in input().split()]
if N == 1:
print((abs(x[0]-X)))
exit()
x.sort()
# N > 1と仮定
for i in range(N-1):
if x[i] < X and x[i+1] > X:
x = x[:i+1] + [X] + x[i+1:]
break
elif x[i] >= X:
x = [X] + x
break
elif x[i+1] <= X:
x = x + [X]
break
if len(x) >= 3:
base = math.gcd(x[1]-x[0], x[2]-x[1])
for i in range(2, N):
diff = x[i+1] - x[i]
base = math.gcd(base, diff)
print(base)
else:
print((x[1] - x[0]))
| p03262 |
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
def main():
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
y = [abs(X-a) for a in x]
cnt = set(make_divisors(y[0]))
for d in y:
cnt.intersection_update(make_divisors(d))
if len(cnt) == 1:
print((1))
return
ans = max(cnt)
print(ans)
if __name__ == "__main__":
main()
| def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
def main():
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
y = [abs(X-a) for a in x]
cnt = set(make_divisors(min(y)))
for d in y:
tmp = []
for c in cnt:
if d%c == 0:
tmp.append(c)
cnt.intersection_update(set(tmp))
if len(cnt) == 1:
print((1))
return
ans = max(cnt)
print(ans)
if __name__ == "__main__":
main()
| p03262 |
f=lambda:[*list(map(int,input().split()))]
n,x=f()
l=f()
d=[l[i+1]-l[i] for i in range(n-1)]
a=abs(x-l[0])
from math import *
for i in d:
a=gcd(a,i)
print(a) | f=lambda:[*list(map(int,input().split()))]
n,x=f()
d=[abs(i-x) for i in f()]
a=d.pop()
from math import *
for i in d:
a=gcd(a,i)
print(a) | p03262 |
n, x = list(map(int, input().split()))
a = list(map(int, input().split()))
if n == 1:
print((abs(x-a[0])))
exit()
else:
a.sort()
box = [a[i+1]-a[i] for i in range(n-1)]
b = min(box)
for i in range(1,b+1):
for j in range(n-1):
if box[j]%i:
break
if j == n-2:
ans = i
d = abs(x-a[0])
if ans <= d:
for i in range(1,ans+1):
if d%i:
continue
else:
temp = i
print(temp)
else:
for i in range(1,d+1):
if ans%i:
continue
else:
temp = i
print(temp)
| n, x = list(map(int, input().split()))
a = list(map(int, input().split()))
if n == 1:
print((abs(x-a[0])))
exit()
else:
a.append(x)
a.sort()
box = [a[i+1]-a[i] for i in range(n)]
b = min(box)
for i in range(1,b+1):
for j in range(n-1):
if box[j]%i:
break
if j == n-2:
ans = i
print(ans)
| p03262 |
def gcd(a,b):
if b == 0:
return a
else:
return gcd(b,a%b)
N,A = list(map(int,input().split()))
X = sorted(map(int,input().split()))
Y = []
for x in X:
Y.append(abs(A-x))
ans = max(Y)
for y in Y:
ans = gcd(y,ans)
print(ans) | N,S = list(map(int,input().split()))
X = list(map(int,input().split()))
def gcd(a,b):
if b == 0:
return a
return gcd(b,a%b)
new_X = []
for x in X:
new_X.append(abs(S-x))
ans = new_X[0]
for x in new_X:
ans = min(ans,gcd(ans,x))
print(ans) | p03262 |
n,m = list(map(int,input().split()))
aa = list(map(int,input().split()))
bb = [abs(a-m) for a in aa]
def gcd(a,b):
while b:
a, b = b, a % b
return a
if len(aa) == 1:
print((abs(aa[0]-m)))
else:
while len(bb) > 1:
a, b = bb.pop(), bb.pop()
bb.append(gcd(a,b))
print((bb[0])) | n,m = list(map(int,input().split()))
aa = list(map(int,input().split()))
bb = [abs(a-m) for a in aa]
def gcd(a,b):
while b:
a, b = b, a % b
return a
ans = bb[0]
if len(aa) == 1:
print((abs(aa[0]-m)))
else:
for b in bb:
ans = gcd(ans,b)
print(ans) | p03262 |
from math import gcd
n,m = list(map(int, input().split()))
x = list(map(int, input().split()))
x.append(m)
x = sorted(x)
dis = [0]*n
for i in range(n): dis[i] = x[i+1] - x[i]
ans = dis[0]
for i in range(1,n): ans = gcd(ans,dis[i])
print(ans) | from math import gcd
n,m = list(map(int, input().split()))
x = list(map(int, input().split()))
x.append(m)
x = sorted(x)
l = [0]*n
for i in range(n): l[i] = x[i+1] - x[i]
ans = l[0]
for i in range(1,n): ans = gcd(ans,l[i])
print(ans) | p03262 |
from math import gcd
n,m = list(map(int, input().split()))
x = list(map(int, input().split()))
x.append(m)
x = sorted(x)
l = [0]*n
for i in range(n): l[i] = x[i+1] - x[i]
ans = l[0]
for i in range(1,n): ans = gcd(ans,l[i])
print(ans) | from math import gcd
n,x = list(map(int, input().split()))
l = sorted([x]+list(map(int, input().split())))
nums = [0]*n
for i in range(n): nums[i] = l[i+1] - l[i]
ans = nums[0]
for i in range(1,n):
ans = gcd(ans,nums[i])
print(ans) | p03262 |
N, X = [int(i) for i in input().split()]
x_ls = [int(i) for i in input().split()]
x_ls = [abs(x - X) for x in x_ls]
while True:
if all([x % min(x_ls) == 0 for x in x_ls]):
break
else:
x_ls = [x % min(x_ls) for x in x_ls]
x_ls = [x for x in x_ls if x != 0]
print((min(x_ls))) | N, X = [int(i) for i in input().split()]
x_ls = [int(i) for i in input().split()]
x_ls = [abs(x - X) for x in x_ls]
while True:
min_x = min(x_ls)
x_ls = [x % min_x for x in x_ls]
if not any(x_ls):
break
x_ls = [x for x in x_ls if x != 0]
print(min_x) | p03262 |
n,x=list(map(int,input().split()))
X=list(map(int,input().split()))
X.append(x)
X.sort()
dif=[]
for i in range(n):
dif.append(X[i+1]-X[i])
for j in range(max(dif),0,-1):
if all(x%j==0 for x in dif):
print(j)
break | n,x=list(map(int,input().split()))
X=list(map(int,input().split()))
dif=[]
for i in range(n):
dif.append(abs(X[i]-x))
def gcd(a,b):
a,b=max(a,b),min(a,b)
if b>0:
return gcd(b,a%b)
else:
return a
ans=dif[0]
for i in range(1,n):
ans=gcd(ans,dif[i])
print(ans) | p03262 |
from functools import reduce
from collections import Counter
N, X = list(map(int, input().split()))
loc = list(map(int, input().split()))
mem = {}
def prime_factors(n):
if mem.get(n) is not None:
return mem[n]
else:
i = 2
factors = []
while i*i <= n:
if n % i == 0:
factors.append(i)
n = n // i
else:
i += 1
if n > 1:
factors.append(n)
mem[n] = factors
return factors
def find_shared_factors(factor1, factor2):
counters = [Counter(factor1), Counter(factor2)]
if len(factor1) > 0 and len(factor2) > 0:
return list(reduce(lambda x, y: x & y, counters).elements())
elif len(factor2) == 0:
return factor1
else:
return factor2
factors = []
for l in loc:
factors = find_shared_factors(prime_factors(abs(l-X)), factors)
for i in range(N):
for j in range(N):
if i < j:
factors = find_shared_factors(prime_factors(abs(loc[i]-loc[j])), factors)
r = reduce(lambda x,y: x*y, factors) if len(factors) > 0 else abs(max(loc)-X)
print(r) | from functools import reduce
N, X = list(map(int, input().split()))
loc = list(map(int, input().split()))
def gcd(a,b):
if b == 0:
return a
else:
return gcd(b, a%b)
print((reduce(gcd, [abs(l-X) for l in loc]))) | p03262 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.