input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
N=int(input())
A=[]
I=[]
for n in range(N):
a=int(input())
A.append(a)
I.append(1)
def t(I):
#while 2 not in I:
while 1:
a=A[I[-1]-1]
if a in I:
return print(-1)
if a==2:
return print(len(I))
I.append(a)
t(I)
| N=int(input())
A=[int(input()) for n in range(N)]
def t(N,A):
i=1
for n in range(1,N+1):
a=A[i-1]
if a==2:
return print(n)
i=a
return print(-1)
t(N,A)
| p03680 |
#Trained?
N = int(eval(input()))
a = [int(eval(input())) for _ in range(N)]
judge2 = 0
judgeloop = 0
now = 1
tugi = a[0]
rireki = []
n = 1
if tugi == 2:
judge2 += 1
while judge2 == 0 and judgeloop == 0:
n += 1
rireki.append(now)
now = tugi
tugi = a[tugi-1]
if tugi in rireki:
judgeloop += 1
elif tugi == 2:
judge2 += 1
if judgeloop == 1:
print((-1))
elif judge2 == 1:
print(n) | #Trained?
N = int(eval(input()))
a = [int(eval(input())) for _ in range(N)]
now = 1
L = [0]*N
for i in range(N):
L[i] = now
now = a[now-1]
judge = 1
for i in range(N):
if L[i] == 2:
print(i)
judge = 0
break
else:
pass
if judge == 1:
print((-1)) | p03680 |
n = int(eval(input()))
a=[0]
for i in range(n):
a.append(int(eval(input())))
c = 1
k = a[1]
while k != 1:
if k == 2:
print(c)
exit()
k = a[k]
c += 1
print((-1)) | n = int(eval(input()))
a=[0]
for i in range(n):
a.append(int(eval(input())))
c = 1
k = a[1]
while c <= n:
if k == 2:
print(c)
exit()
k = a[k]
c += 1
print((-1)) | p03680 |
N = int(eval(input()))
a = [int(eval(input())) for _ in range(N)]
a = [0] + a
hist = [1, ]
count = 0
i = 1
while i != 2:
i = a[i]
count += 1
if i in hist:
count = -1
break
hist.append(i)
print(count) | N = int(eval(input()))
a = [int(eval(input())) for _ in range(N)]
a = [0] + a
count = 0
i = 1
while i != 2:
j = i
i = a[i]
a[j] = -1
count += 1
if i == -1:
count = -1
break
print(count) | p03680 |
N = int(eval(input()))
a = [int(eval(input())) for _ in range(N)]
a = [0] + a
count = 0
i = 1
while i != 2:
j = i
i = a[i]
a[j] = -1
count += 1
if i == -1:
count = -1
break
print(count) | n = int(eval(input()))
A = [int(eval(input())) for _ in range(n)]
count = 0
i = 1
for _ in range(n):
i = A[i - 1]
count += 1
if i == 2:
print(count)
exit()
print((-1)) | p03680 |
n=int(eval(input()))
a=[int(eval(input())) for _ in range(n)]
b=a[0]
c=1
ans=-1
for i in range(10**5):
if b==2:
ans=c
break
b=a[b-1]
c+=1
print(ans) | n,*a=list(map(int,open(0).read().split()))
i=ans=1
while a[i-1]!=2 and ans<=n:
ans+=1
i=a[i-1]
print((ans if ans<=n else -1)) | p03680 |
n=int(eval(input()))
a=[]
for i in range(n):
a.append(int(eval(input())))
b=['']*n
b[0]='hoge'
c=0
x=0
while True:
c+=1
x=a[x]-1
if b[x]=='hoge':
c=-1
break
else:
b[x]='hoge'
if x==1:
break
print(c)
| # 入力
N=int(eval(input()))
l=[]
for i in range(N):
l.append(int(eval(input())))
# 押してない：0
# 押した：1
l2=[0]*N
# 1番目は「押した：1」にしておく
l2[0]=1
# 回数カウント
c=0
i=1
while True:
# 回数をインクリメント
c+=1
# 次のボタン番号を取得
i=l[i-1]
# 2番目のライトが光る場合は回数を出力して終了
if i==2:
print(c)
exit()
if l2[i-1]==1:
# 無限ループ確定で終了
print((-1))
exit()
else:
# 押した／押してない を更新
l2[i-1]=1 | p03680 |
#!/usr/bin/env python3
import sys
INF = float("inf")
def solve(N: int, a: "List[int]"):
visited = [False]*N
curr = 1
counter = 0
while curr != 2:
curr = a[curr-1]
counter += 1
if curr == 1:
print((-1))
return
print(counter)
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
a = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, a)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
INF = float("inf")
def solve(N: int, a: "List[int]"):
visited = [False]*N
curr = 1
counter = 0
while curr != 2:
if visited[curr-1]:
print((-1))
return
visited[curr-1] = True
curr = a[curr-1]
counter += 1
print(counter)
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
a = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, a)
if __name__ == '__main__':
main()
| p03680 |
n = int(eval(input()))
a = [int(eval(input())) for i in range(n)]
T = [False for i in range(n)]
tmp = 1
T[0] = True
count = 1
while True:
tmp = a[tmp-1]
if T[tmp -1]:
print((-1))
exit()
if tmp == 2:
print(count)
break
count+=1 | n = int(eval(input()))
a = [int(eval(input())) for i in range(n)]
T = [False for i in range(n)]
tmp = 1
T[0] = True
count = 1
while True:
tmp = a[tmp-1]
if T[tmp -1]:
print((-1))
exit()
T[tmp-1] = True
if tmp == 2:
print(count)
break
count+=1 | p03680 |
n = int(eval(input()))
a = [int(eval(input())) for i in range(n)]
b = [0]*n
b[0] = 1
count = 0
c = a[0]
for i in range(n):
if b[c-1] == 0:
b[c-1] = 1
if c == 2:
print((count+1))
break
else:
print((-1))
break
c = a[c-1]
count += 1 | n = int(eval(input()))
a = [int(eval(input())) for i in range(n)]
c, s = 1, a[0]
while s!= 2 and c<n:
c, s = c+1, a[s-1]
print((c if c<n else -1)) | p03680 |
def solve():
N = int(input())
arr = []
for i in range(N):
arr.append(int(input()))
turning_on = 1
count = 0
turned_on_set = [1]
while turning_on != 2:
count += 1
turning_on = arr[turning_on - 1]
if turning_on in turned_on_set:
count = -1
break
turned_on_set.append(turning_on)
print(str(count))
if __name__ == '__main__':
solve()
| def solve():
N = int(input())
arr = []
for i in range(N):
arr.append(int(input()))
turning_on = 1
count = 0
while turning_on != 2:
count += 1
turning_on = arr[turning_on - 1]
if count > N + 1:
count = -1
break
print(str(count))
if __name__ == '__main__':
solve()
| p03680 |
n = int(eval(input()))
a = []
for i in range(n):
a.append(int(eval(input())))
b = a[0]
c = []
while True:
if b == 2:
print((len(c)+1))
exit()
elif b in c:
print((-1))
exit()
else:
c.append(b)
b = a[c[-1]-1] | n = int(eval(input()))
a = []
for i in range(n):
a.append(int(eval(input())))
b = a[0]
c = []
while True:
if b == 2:
print((len(c)+1))
exit()
if len(c)> n:
print((-1))
exit()
else:
c.append(b)
b = a[c[-1]-1] | p03680 |
# ABC065 B - Trained?
N = int(eval(input()))
A = [[int(eval(input())),False] for i in range(N)]
idx = 0
A[0][1] == True
cnt = 1
while cnt != N+1:
if A[idx][1]:
print((-1))
exit()
if A[idx][0] == 2:
print(cnt)
exit()
A[idx][1] = True
idx = A[idx][0]-1
cnt += 1
| n=int(eval(input()))
a=[int(eval(input())) for i in range(n)]
btn=[0]*n
ans=1
i=0
while True:
if btn[i]==1:
print((-1))
exit()
if a[i]==2:
print(ans)
exit()
btn[i]=1
i=a[i]-1
ans+=1
| p03680 |
n = int(eval(input()))
A = [int(eval(input())) for i in range(n)]
B = []
for i, a in enumerate(A):
B.append([i + 1, a])
idx = 1
for i in range(n):
x = B[idx - 1][1]
if x == 2:
print((i + 1))
break
else:
idx = x
else:
print((-1)) | n = int(eval(input()))
A = [int(eval(input())) for i in range(n)]
cnt = 1
x = A[0]
while x != 2 and cnt != n:
x = A[x - 1]
cnt += 1
if cnt == n:
print((-1))
else:
print(cnt) | p03680 |
n = int(eval(input()))
nxt_btn = {i: int(eval(input())) for i in range(1, n + 1)}
num = 0
crr_btn = 1
while True:
num += 1
if nxt_btn[crr_btn] == 1:
num = -1
break
if nxt_btn[crr_btn] == 2:
break
crr_btn = nxt_btn[crr_btn]
print(num)
| n = int(eval(input()))
nxt_btn = {i: int(eval(input())) for i in range(1, n + 1)}
num = -1
crr_btn = 1
for i in range(1, n + 1):
if nxt_btn[crr_btn] == 2:
num = i
break
crr_btn = nxt_btn[crr_btn]
print(num)
| p03680 |
n = int(eval(input()))
a = [int(eval(input())) for i in range(n)]
i = a[0]
num = [1, i]
for k in range(n):
if 2 in num:
print((len(num) - 1))
break
j = a[i-1]
if j in num:
print((-1))
break
num.append(j)
if 2 in num:
print((len(num) - 1))
break
i = a[j-1]
if i in num:
print((-1))
break
num.append(i) | n = int(eval(input()))
a = [int(eval(input())) for i in range(n)]
i = a[0]
for j in range(n):
if i == 2:
print((j + 1))
break
i = a[i-1]
else:
print((-1)) | p03680 |
N = int(eval(input()))
A = [0]
for i in range(N):
a = int(eval(input()))
A.append(a)
ans = 1
now = A[1]
while now != 1 and now != 2:
ans += 1
now = A[now]
if now == 1:
print((-1))
else:
print(ans) | N = int(eval(input()))
A = [0]
for i in range(N):
a = int(eval(input()))
A.append(a)
#print(A)
ans = 1
now = A[1]
visited = {}
while (not now in visited) and now != 2:
ans += 1
visited[now] = 1
now = A[now]
#print(visited)
if now != 2:
print((-1))
else:
print(ans) | p03680 |
n=int(eval(input()))
Alist=[0]+[int(eval(input())) for i in range(n)]
now=1
count=0
Hist=[1]
while now!=2:
now=Alist[now]
count+=1
if now in Hist:
count=-1
break
Hist.append(now)
print(count) | n=int(eval(input()))
Alist=[0]+[int(eval(input())) for i in range(n)]
now=1
count=0
for _ in range(n):
now=Alist[now]
count+=1
if now==2:
print(count)
exit()
print((-1)) | p03680 |
n=int(eval(input()))
Alist=[0]+[int(eval(input())) for i in range(n)]
now=1
Hist=[1]
for i in range(n):
now=Alist[now]
if now==2:
print((i+1))
break
if now in Hist:
print((-1))
break
Hist.append(now) | n=int(eval(input()))
Alist=[0]+[int(eval(input())) for i in range(n)]
now=1
Hist={1}
for i in range(n):
now=Alist[now]
if now==2:
print((i+1))
break
if now in Hist:
print((-1))
break
Hist.add(now) | p03680 |
# https://beta.atcoder.jp/contests/abc065/tasks/abc065_b
import sys
def model():
e = list(map(int, sys.stdin))
cur = e[1]
for i in range(e[0]):
if cur == 2:
print((i + 1))
break
cur = e[cur]
else:
print((-1))
def input_lines():
"""hell?"""
lines = sys.stdin.readlines()
for i in range(1, int(lines[0])+1):
yield i, int(lines[i].strip())
def solve():
d = {i: button for i, button in input_lines()}
count = 1
index = 1
while True:
try:
prev = index
index = d[index]
if index == 2:
print(count)
exit()
elif index is None:
print((-1))
exit()
d[prev] = None
count += 1
except KeyError:
print((-1))
exit()
if __name__ == '__main__':
solve()
# model()
| # https://beta.atcoder.jp/contests/abc065/tasks/abc065_b
import sys
def model():
e = list(map(int, sys.stdin))
cur = e[1]
for i in range(e[0]):
if cur == 2:
print((i + 1))
break
cur = e[cur]
else:
print((-1))
def input_lines():
"""hell?"""
lines = sys.stdin.readlines()
for i in range(1, int(lines[0])+1):
yield i, int(lines[i].strip())
def solve():
d = {i: button for i, button in input_lines()}
count = 1
index = 1
while True:
try:
prev = index
index = d[index]
if index is None:
print((-1))
exit()
elif index == 2:
print(count)
exit()
d[prev] = None
count += 1
except KeyError:
print((-1))
exit()
if __name__ == '__main__':
solve()
# model()
| p03680 |
n=int(eval(input()))
a=[]
for i in range(n):
a.append(int(eval(input()))-1)
'''
#TLEチーンコ
i=0
j=0
b=[]
while True:
j+=1
if a[i]==1:
print(j)
break
elif a[i] in b:
print(-1)
break
else:
b.append(a[i])
i=a[i]
'''
i=0
j=0
while True:
j+=1
if a[i]==1:
print(j)
break
elif j==n:
print((-1))
break
else:
i=a[i]
| n=int(eval(input()))
a=[int(eval(input()))-1 for i in range(n)]
now=0
x=[0]*n
i=0
while x[now]==0:
i+=1
x[now]=1
now=a[now]
if now==1:
print(i)
break
else:
print((-1))
| p03680 |
n = int(eval(input()))
a = []
l = [0]*(n + 1)
cnt = 0
now = 1
for i in range(n):
a.append(int(eval(input())))
for i in range(n):
cnt += 1
now = a[now - 1]
if now == 2:
print(cnt)
exit()
print((-1)) | import sys
input = sys.stdin.readline
def main():
n = int(eval(input()))
a = []
l = [0]*(n + 1)
cnt = 0
now = 1
for i in range(n):
a.append(int(eval(input())))
for i in range(n):
cnt += 1
now = a[now - 1]
if now == 2:
print(cnt)
exit()
print((-1))
main() | p03680 |
import sys
input = sys.stdin.readline
def main():
n = int(eval(input()))
a = []
l = [0]*(n + 1)
cnt = 0
now = 1
for i in range(n):
a.append(int(eval(input())))
for i in range(n):
cnt += 1
now = a[now - 1]
if now == 2:
print(cnt)
exit()
print((-1))
main() | import sys
input = sys.stdin.readline
def main():
n = int(eval(input()))
a = []
l = [0]*(n + 1)
now = 0
for i in range(n):
a.append(int(eval(input())) - 1)
for i in range(n):
now = a[now]
if now == 1:
print((i + 1))
exit()
print((-1))
main() | p03680 |
# import bisect
# import copy
# import fractions
# import math
# import numpy as np
# from collections import Counter, deque
# from itertools import accumulate,permutations, combinations,combinations_with_replacement,product
def resolve():
N=int(eval(input()))
A=[int(eval(input())) for i in range(N)]
temp=[0]*N
i = 0
cnt=0
while True:
if A[i] not in temp:
temp[cnt] = A[i]
if A[i]==2:
print((cnt+1))
break
i=A[i]-1
cnt+=1
else:
print((-1))
break
resolve() | # import bisect
# import copy
# import fractions
# import math
# import numpy as np
# from collections import Counter, deque
# from itertools import accumulate,permutations, combinations,combinations_with_replacement,product
def resolve():
N=int(eval(input()))
A=[int(eval(input())) for i in range(N)]
num=0
cnt=0
for i in range(N):
if A[num]==2:
print((cnt+1))
break
num=A[num]-1
cnt+=1
if i==N-1:
print((-1))
resolve() | p03680 |
#/usr/bin/env python
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
lighted = [0]
ans = 0
while True:
u = lighted[-1]
v = a[u]-1
ans += 1
if v == 1:
print(ans)
exit()
if v not in lighted:
lighted.append(v)
else:
print((-1))
exit()
| #/usr/bin/env python
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
lighted = [0]
ans = 0
for i in range(n):
u = lighted[-1]
v = a[u]-1
ans += 1
if v == 1:
print(ans)
exit()
lighted.append(v)
print((-1))
| p03680 |
#/usr/bin/env python
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
lighted = [0]
ans = 0
for i in range(n):
u = lighted[-1]
v = a[u]-1
ans += 1
if v == 1:
print(ans)
exit()
lighted.append(v)
print((-1))
| #/usr/bin/env python
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
ans = 0
v = 0
for i in range(n):
v = a[v]-1
ans += 1
if v == 1:
print(ans)
exit()
print((-1))
| p03680 |
N, K = list(map(int, input().split()))
# スコア行列[K, K]
# 白チェッカー左下を(x, y)としたときの正解数-誤答数
score_matrix = [[0 for x in range(K+1)] for y in range(K+1)]
base_hope = 0
for i in range(N):
x, y, c = input().split()
x2, y2 = int(x) // K, int(y) // K
x_coord, y_coord = int(x) % K, int(y) % K
# 正解
if ((x2 + y2) % 2 == 0 and c == "W") or ((x2 + y2) % 2 == 1 and c == "B"):
score_matrix[y_coord+1][x_coord+1] += 1
base_hope += 1
# 誤答
else:
score_matrix[y_coord+1][x_coord+1] -= 1
# スコア行列の二次元累積和を求める O(K^2)
xy = [(x, y) for x in range(1, K+1) for y in range(1, K+1)]
for x, y in xy:
score_matrix[y][x] += score_matrix[y][x-1] + score_matrix[y-1][x] - score_matrix[y-1][x-1]
# 希望行列を累積和に基づき計算していく O(K^2)
# 同時に最大値を計算
max_hope = 0
for x, y in xy:
hope = base_hope - score_matrix[K][x-1] - score_matrix[y-1][K] + 2 * score_matrix[y-1][x-1]
true_hope = max(hope, N - hope)
if true_hope > max_hope:
max_hope = true_hope
print(max_hope)
| N, K = list(map(int, input().split()))
score = [[0 for x in range(K+1)] for y in range(K+1)]
base_hope = 0
for i in range(N):
x, y, c = input().split()
x2, y2 = int(x) // K, int(y) // K
x_coord, y_coord = int(x) % K + 1, int(y) % K + 1
if ((x2 + y2) % 2 == 0 and c == "W") or ((x2 + y2) % 2 == 1 and c == "B"):
score[y_coord][x_coord] += 1
base_hope += 1
else:
score[y_coord][x_coord] -= 1
xy = [(x, y) for x in range(K) for y in range(K)]
for x, y in xy:
score[y+1][x+1] += score[y+1][x] + score[y][x+1] - score[y][x]
max_hope = 0
for x, y in xy:
hope = base_hope - score[K][x] - score[y][K] + 2 * score[y][x]
true_hope = max(hope, N - hope)
if true_hope > max_hope:
max_hope = true_hope
print(max_hope) | p03458 |
N, K = list(map(int, input().split()))
score = [[0 for x in range(K+1)] for y in range(K+1)]
base_hope = 0
for i in range(N):
x, y, c = input().split()
x2, y2 = int(x) // K, int(y) // K
x_coord, y_coord = int(x) % K + 1, int(y) % K + 1
if ((x2 + y2) % 2 == 0 and c == "W") or ((x2 + y2) % 2 == 1 and c == "B"):
score[y_coord][x_coord] += 1
base_hope += 1
else:
score[y_coord][x_coord] -= 1
xy = [(x, y) for x in range(K) for y in range(K)]
for x, y in xy:
score[y+1][x+1] += score[y+1][x] + score[y][x+1] - score[y][x]
max_hope = 0
for x, y in xy:
hope = base_hope - score[K][x] - score[y][K] + 2 * score[y][x]
true_hope = max(hope, N - hope)
if true_hope > max_hope:
max_hope = true_hope
print(max_hope) | N, K = list(map(int, input().split()))
score = [[0] * (K+1) for y in range(K+1)]
base_hope = 0
for i in range(N):
x, y, c = input().split()
x2, y2 = int(x) // K, int(y) // K
x_coord, y_coord = int(x) % K + 1, int(y) % K + 1
if ((x2 + y2) % 2 == 0 and c == "W") or ((x2 + y2) % 2 == 1 and c == "B"):
score[y_coord][x_coord] += 1
base_hope += 1
else:
score[y_coord][x_coord] -= 1
xy = [(x, y) for x in range(K) for y in range(K)]
for x, y in xy:
score[y+1][x+1] += score[y+1][x] + score[y][x+1] - score[y][x]
max_hope = 0
for x, y in xy:
hope = base_hope - score[K][x] - score[y][K] + 2 * score[y][x]
true_hope = hope if hope > N - hope else N - hope
if true_hope > max_hope:
max_hope = true_hope
print(max_hope) | p03458 |
#!/usr/bin/env python3
def main():
na = list(map(int, input().split()))
N = na[0]
K = na[1]
x = []
y = []
c = []
for i in range(N):
sa = input().split()
x.append(int(sa[0]))
y.append(int(sa[1]))
c.append(True if sa[2] == 'W' else False)
hopes = [[0 for j in range(K * 2)] for i in range(K * 3)]
xsum = [0 for j in range(K * 2)]
ysum = [[0 for j in range(K * 2)] for i in range(K * 3)]
for i in range(N):
if c[i]:
x[i] += K
xmod = x[i] % (K * 2)
ymod = y[i] % (K * 2)
if K <= xmod and K <= ymod:
xmod -= K
ymod -= K
elif K <= ymod:
xmod += K
ymod -= K
hopes[xmod][ymod] += 1
if xmod < K:
hopes[xmod + K][ymod + K] += 1
hopes[xmod + K * 2][ymod] += 1
else:
hopes[xmod - K][ymod + K] += 1
hopes[xmod + K][ymod + K] += 1
for j in range(K * 2):
for i in range(K):
xsum[j] += hopes[i][j]
for i in range(K):
ysum[i][0] = ysum[i + K * 2][0] = s = sum(hopes[i][:K])
for j in range(1, K):
s += (hopes[i][j + K - 1] - hopes[i][j - 1])
ysum[i][j] = ysum[i + K * 2][j] = s
for i in range(K, K * 2):
ysum[i][0] = s = sum(hopes[i][:K])
for j in range(1, K):
s += (hopes[i][j + K - 1] - hopes[i][j - 1])
ysum[i][j] = s
h0 = []
hmax = h = sum(xsum[:K])
h0.append(h)
for j in range(1, K):
h += (xsum[j + K - 1] - xsum[j - 1])
hmax = max(hmax, h)
h0.append(h)
for j in range(K):
h = h0[j]
for i in range(1, K * 2):
h += (ysum[i + K - 1][j] - ysum[i - 1][j])
hmax = max(hmax, h)
print(hmax)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
def main():
na = list(map(int, input().split()))
N = na[0]
K = na[1]
x = []
y = []
c = []
for i in range(N):
sa = input().split()
x.append(int(sa[0]))
y.append(int(sa[1]))
c.append(True if sa[2] == 'W' else False)
hopes = [[0 for j in range(K)] for i in range(K)]
ysum = [[0 for j in range(K * 2)] for i in range(K)]
score = 0
for i in range(N):
xmod = x[i] % K
ymod = y[i] % K
f = (int(x[i] / K) + int(y[i] / K)) % 2 == 1
c[i] ^= f
if c[i]:
score += 1
h = -1 if c[i] else 1
hopes[xmod][ymod] += h
for i in range(K):
s = 0
for j in range(K):
s += hopes[i][j]
ysum[i][j] = s
for j in range(K):
s -= hopes[i][j]
ysum[i][K + j] = s
smax = 0
for j in range(K):
s = 0
for i in range(K):
s += ysum[i][K + j]
for i in range(K):
s += (ysum[i][j] - ysum[i][K + j])
smax = max(smax, s)
for i in range(K):
s -= (ysum[i][j] - ysum[i][K + j])
smax = max(smax, s)
print((score + smax))
if __name__ == '__main__':
main()
| p03458 |
n, k = list(map(int, input().split()))
mp1 = [[0] * k for _ in range(k)]
mp2 = [[0] * k for _ in range(k)]
for _ in range(n):
x, y, c = input().split()
t = int(x) // k + int(y) // k
x = int(x) % k
y = int(y) % k
if c == "B":
t += 1
if t % 2:
mp1[y][x] += 1
else:
mp2[y][x] += 1
for x in range(1, k):
mp1[0][x] += mp1[0][x - 1]
mp2[0][x] += mp2[0][x - 1]
for y in range(1, k):
acc1 = 0
acc2 = 0
for x in range(k):
acc1 += mp1[y][x]
mp1[y][x] = acc1 + mp1[y - 1][x]
acc2 += mp2[y][x]
mp2[y][x] = acc2 + mp2[y - 1][x]
ans = 0
sum1 = mp1[k - 1][k - 1]
sum2 = mp2[k - 1][k - 1]
mp1k = mp1[k - 1]
mp2k = mp2[k - 1]
for y in range(k):
mp1y = mp1[y]
mp1yk = mp1y[k - 1]
mp2y = mp2[y]
mp2yk = mp2y[k - 1]
for x in range(k):
mp1yx = mp1y[x]
mp2yx = mp2y[x]
mp1kx = mp1k[x]
mp2kx = mp2k[x]
ans = max(ans, 2 * mp1yx + sum1 - mp1yk - mp1kx + mp2kx + mp2yk - 2 * mp2yx)
ans = max(ans, 2 * mp2yx + sum2 - mp2yk - mp2kx + mp1kx + mp1yk - 2 * mp1yx)
print(ans) | def main():
n, k = list(map(int, input().split()))
mp1 = [[0] * k for _ in range(k)]
mp2 = [[0] * k for _ in range(k)]
for _ in range(n):
x, y, c = input().split()
t = int(x) // k + int(y) // k
x = int(x) % k
y = int(y) % k
if c == "B":
t += 1
if t % 2:
mp1[y][x] += 1
else:
mp2[y][x] += 1
mp10 = mp1[0]
mp20 = mp2[0]
for x in range(1, k):
mp10[x] += mp10[x - 1]
mp20[x] += mp20[x - 1]
for y in range(1, k):
acc1 = 0
acc2 = 0
mp1y = mp1[y]
mp2y = mp2[y]
mp1y1 = mp1[y - 1]
mp2y1 = mp2[y - 1]
for x in range(k):
acc1 += mp1y[x]
mp1y[x] = acc1 + mp1y1[x]
acc2 += mp2y[x]
mp2y[x] = acc2 + mp2y1[x]
ans = 0
sum1 = mp1[k - 1][k - 1]
sum2 = mp2[k - 1][k - 1]
mp1k = mp1[k - 1]
mp2k = mp2[k - 1]
for y in range(k):
mp1y = mp1[y]
mp1yk = mp1y[k - 1]
mp2y = mp2[y]
mp2yk = mp2y[k - 1]
for x in range(k):
mp1yx = mp1y[x]
mp2yx = mp2y[x]
mp1kx = mp1k[x]
mp2kx = mp2k[x]
a1 = 2 * mp1yx + sum1 - mp1yk - mp1kx + mp2kx + mp2yk - 2 * mp2yx
a2 = 2 * mp2yx + sum2 - mp2yk - mp2kx + mp1kx + mp1yk - 2 * mp1yx
if ans < a1:
ans = a1
if ans < a2:
ans = a2
print(ans)
main() | p03458 |
n,k=list(map(int,input().split()))
grid=[[0]*k for _ in range(k)]
for i in range(n):
x,y,c=[x for x in input().split()]
x,y=int(x),int(y)
p=(x//k+y//k)%2
if (p==0 and c=="B")|(p==1 and c=="W"): grid[x%k][y%k]+=1
else: grid[x%k][y%k]-=1
for i in range(k):
for j in range(1,k):
grid[i][j]+=grid[i][j-1]
for i in range(1,k):
for j in range(k):
grid[i][j]+=grid[i-1][j]
ans=0
for i in range(k):
for j in range(k):
b=grid[i][j]*4+grid[k-1][k-1]-(grid[i][k-1]+grid[k-1][j])*2
ans=max(ans,(n+b)//2,(n-b)//2)
print(ans) | n,k=list(map(int,input().split()))
grid=[[0]*k for _ in range(k)]
for i in range(n):
x,y,c=[x for x in input().split()]
x,y=int(x),int(y)
p=(x//k+y//k)%2
if (p==0 and c=="B")|(p==1 and c=="W"): grid[x%k][y%k]+=1
else: grid[x%k][y%k]-=1
for i in range(k):
for j in range(1,k):
grid[i][j]+=grid[i][j-1]
for i in range(1,k):
for j in range(k):
grid[i][j]+=grid[i-1][j]
ans=0
for i in range(k):
for j in range(k):
b=grid[i][j]*4+grid[k-1][k-1]-(grid[i][k-1]+grid[k-1][j])*2
ans=max(ans,n+b,n-b)
print((ans//2)) | p03458 |
n,k=list(map(int,input().split()))
grid=[[0]*k for _ in range(k)]
for i in range(n):
x,y,c=[x for x in input().split()]
x,y=int(x),int(y)
p=(x//k+y//k)%2
if (p==0 and c=="B")|(p==1 and c=="W"): grid[x%k][y%k]+=1
else: grid[x%k][y%k]-=1
for i in range(k):
for j in range(1,k):
grid[i][j]+=grid[i][j-1]
for i in range(1,k):
for j in range(k):
grid[i][j]+=grid[i-1][j]
ans=0
for i in range(k):
for j in range(k):
b=grid[i][j]*4+grid[k-1][k-1]-(grid[i][k-1]+grid[k-1][j])*2
ans=max(ans,n+b,n-b)
print((ans//2)) | def main():
n,k=list(map(int,input().split()))
grid=[[0]*k for _ in range(k)]
for i in range(n):
x,y,c=[x for x in input().split()]
x,y=int(x),int(y)
p=(x//k+y//k)%2
if (p==0 and c=="B")|(p==1 and c=="W"): grid[x%k][y%k]+=1
else: grid[x%k][y%k]-=1
for i in range(k):
for j in range(1,k):
grid[i][j]+=grid[i][j-1]
for i in range(1,k):
for j in range(k):
grid[i][j]+=grid[i-1][j]
ans=0
for i in range(k):
for j in range(k):
b=grid[i][j]*4+grid[k-1][k-1]-(grid[i][k-1]+grid[k-1][j])*2
ans=max(ans,n+b,n-b)
print((ans//2))
if __name__ == "__main__":
main() | p03458 |
n,k=list(map(int,input().split()))
a=[(2*k+1)*[0]for _ in range(2*k+1)]
for _ in range(n):
x,y,c=input().split()
x=int(x)
y=int(y)
if c=="B":y+=k
x%=2*k
y%=2*k
a[x+1][y+1]+=1
ans=0
for i in range(1,2*k+1):
for j in range(1,2*k+1):a[i][j]+=a[i-1][j]+a[i][j-1]-a[i-1][j-1]
for i in range(k,2*k+1):
for j in range(k,2*k+1):
t=a[i][j]-a[i-k][j]-a[i][j-k]+a[i-k][j-k]
t+=a[i-k][j-k]
t+=a[2*k][j-k]-a[i][j-k]
t+=a[i-k][2*k]-a[i-k][j]
t+=a[2*k][2*k]-a[i][2*k]-a[2*k][j]+a[i][j]
ans=max(ans,t,n-t)
print(ans) | n,k=list(map(int,input().split()));m=2*k;a=[(m+1)*[0]for _ in[0]*(m+1)];z=lambda i,j:(a[i][j]-a[i-k][j]-a[i][j-k]+a[i-k][j-k])*2+a[m][m]-a[i][m]-a[m][j]+a[i-k][m]+a[m][j-k]
for _ in[0]*n:x,y,c=input().split();x=int(x);y=int(y)+k*(c=="B");a[x%m+1][y%m+1]+=1
for i in range(m):
for j in range(m):a[i+1][j+1]+=a[i][j+1]+a[i+1][j]-a[i][j]
print((max(max(max(z(i,j),n-z(i,j))for j in range(k,m+1))for i in range(k,m+1)))) | p03458 |
ri = lambda: int(input())
rl = lambda: list(map(int,input().split()))
rr = lambda N: [ri() for _ in range(N)]
YN = lambda b: print('YES') if b else print('NO')
INF = 10**18
N,K=rl()
W = [[0 for _ in range(2*K+3)] for _ in range(2*K+3)]
for i in range(N):
x,y,c=input().split()
x = int(x)%(2*K)
y = (int(y) if c=='W' else int(y)+K)%(2*K)
if (x<K)^(y<K):
x %= K
y %= K
W[0][y+1] += 1
W[0][y+K+1] -= 1
W[x+1][0] += 1
W[x+1][y+1] -= 2
W[x+1][y+K+1] += 2
W[x+1][2*K] -= 1
W[x+K+1][0] -= 1
W[x+K+1][y+1] += 2
W[x+K+1][y+K+1] -= 2
W[x+K+1][2*K] += 1
W[2*K][y+1] -= 1
W[2*K][y+K+1] += 1
else:
x %= K
y %= K
W[0][0] += 1
W[x+1][0] -= 1
W[0][y+1] -= 1
W[x+1][y+1] += 2
W[x+K+1][y+1] -= 2
W[x+1][y+K+1] -= 2
W[x+K+1][y+K+1] += 1
W[x+K+1][0] += 1
W[2*K][0] -= 1
W[2*K][y+1] += 1
W[0][y+K+1] += 1
W[0][2*K] -= 1
W[x+1][2*K] += 1
ans = 0
for x in range(0,2*K+1):
for y in range(0,2*K+1):
W[x][y] += W[x][y-1]
for y in range(0,2*K+1):
for x in range(0,2*K+1):
W[x][y] += W[x-1][y]
ans = max(ans,W[x][y])
print(ans)
| ri = lambda: int(input())
rl = lambda: list(map(int,input().split()))
rr = lambda N: [ri() for _ in range(N)]
YN = lambda b: print('YES') if b else print('NO')
INF = 10**18
N,K=rl()
W = [[0 for _ in range(K+3)] for _ in range(K+3)]
for i in range(N):
x,y,c=input().split()
x = int(x)%(2*K)
y = (int(y) if c=='W' else int(y)+K)%(2*K)
if (x<K)^(y<K):
x %= K
y %= K
W[0][y+1] += 1
W[x+1][y+1] -= 2
W[0][K+1] -= 1
W[x+1][K+1] += 1
W[x+1][0] += 1
W[K+1][0] -= 1
W[K+1][y+1] += 1
else:
x %= K
y %= K
W[0][0] += 1
W[x+1][0] -= 1
W[0][y+1] -= 1
W[x+1][y+1] += 2
W[K+1][y+1] -= 1
W[x+1][K+1] -= 1
W[K+1][K+1] += 1
for x in range(0,K+2):
for y in range(0,K+2):
W[x][y] += W[x][y-1]
for y in range(0,K+2):
for x in range(0,K+2):
W[x][y] += W[x-1][y]
ans = 0
for x in range(K+1):
for y in range(K+1):
res = W[x][y]
ans = max(ans,res,N-res)
print(ans)
| p03458 |
import sys
input = sys.stdin.readline
def cumsum_2d(inlist,h,w):
outlist = [ [ inlist[i-1][j-1] if i != 0 and j != 0 else 0 for i in range(k+1) ] for j in range(k+1) ]
for i in range(1,h+1):
tmp = 0
for j in range(1,w+1):
tmp += outlist[i][j]
outlist[i][j] = tmp
for i in range(1,w+1):
tmp = 0
for j in range(1,h+1):
tmp += outlist[j][i]
outlist[j][i] = tmp
return outlist
n, k = [ int(v) for v in input().split() ]
hope = [ [ a for a in input().split() ] for i in range(n) ]
b_board = [ [ 0 for i in range(k)] for j in range(k) ]
w_board = [ [ 0 for i in range(k)] for j in range(k) ]
for h, w, c in hope:
a1, a2 = divmod(int(w),k)
b1, b2 = divmod(int(h),k)
if (a1+b1) % 2 == 1:
if c == "B":
c = "W"
else:
c = "B"
if c == "B":
b_board[int(h)%k][int(w)%k] += 1
else:
w_board[int(h)%k][int(w)%k] += 1
b_board_3 = cumsum_2d(b_board,k,k)
w_board_3 = cumsum_2d(w_board,k,k)
total_b, total_w = b_board_3[k][k], w_board_3[k][k]
ans = 0
for i in range(1,k+1):
for j in range(1,k+1):
b1 = b_board_3[i][j] - b_board_3[0][j] - b_board_3[i][0]
b2 = total_b - b_board_3[i][k] - b_board_3[k][j] + b_board_3[i][j]
w1 = w_board_3[i][j] - w_board_3[0][j] - w_board_3[i][0]
w2 = total_w - w_board_3[i][k] - w_board_3[k][j] + w_board_3[i][j]
ans = max(b1+b2+(total_w-w1-w2),w1+w2+(total_b-b1-b2),ans)
print(ans)
| import sys
input = sys.stdin.readline
def cumsum_2d(inlist,h,w):
outlist = [ [ inlist[i-1][j-1] if i != 0 and j != 0 else 0 for i in range(k+1) ] for j in range(k+1) ]
for i in range(1,h+1):
tmp = 0
for j in range(1,w+1):
tmp += outlist[i][j]
outlist[i][j] = tmp
for i in range(1,w+1):
tmp = 0
for j in range(1,h+1):
tmp += outlist[j][i]
outlist[j][i] = tmp
return outlist
n, k = [ int(v) for v in input().split() ]
hope = [ [ a for a in input().split() ] for i in range(n) ]
b_board = [ [ 0 for i in range(k)] for j in range(k) ]
w_board = [ [ 0 for i in range(k)] for j in range(k) ]
for h, w, c in hope:
a1, a2 = divmod(int(w),k)
b1, b2 = divmod(int(h),k)
if (a1+b1) % 2 == 1:
if c == "B":
c = "W"
else:
c = "B"
if c == "B":
b_board[b2][a2] += 1
else:
w_board[b2][a2] += 1
b_board_3 = cumsum_2d(b_board,k,k)
w_board_3 = cumsum_2d(w_board,k,k)
total_b, total_w = b_board_3[k][k], w_board_3[k][k]
ans = 0
for i in range(1,k+1):
for j in range(1,k+1):
b1 = b_board_3[i][j] - b_board_3[0][j] - b_board_3[i][0]
b2 = total_b - b_board_3[i][k] - b_board_3[k][j] + b_board_3[i][j]
w1 = w_board_3[i][j] - w_board_3[0][j] - w_board_3[i][0]
w2 = total_w - w_board_3[i][k] - w_board_3[k][j] + w_board_3[i][j]
ans = max(b1+b2+(total_w-w1-w2),w1+w2+(total_b-b1-b2),ans)
print(ans) | p03458 |
n, k = list(map(int, input().split()))
favor = [tuple(input().split()) for _ in range(n)]
square = [[0 for _ in range(k)] for _ in range(k)]
initscore = 0
for xc, yc, c in favor:
x = int(xc)
y = int(yc)
x %= 2*k
y %= 2*k
if (x in range(k) and y in range(k)) or (x in range(k, 2*k) and y in range(k, 2*k)):
if c == 'B':
square[x%k][y%k] += 1
else:
square[x%k][y%k] -= 1
initscore += 1
else:
if c == 'B':
square[x%k][y%k] -= 1
initscore += 1
else:
square[x%k][y%k] += 1
cum = [[0 for _ in range(k+1)] for _ in range(k+1)]
for i in range(k):
for j in range(k):
cum[i+1][j+1] = cum[i+1][j] + cum[i][j+1] - cum[i][j] + square[i][j]
maxscore = 0
for i in range(k):
for j in range(k):
score1 = 2*cum[i][j] + cum[k][k] - cum[i][k] - cum[k][j]
score2 = cum[k][k] - score1
maxscore = max(maxscore, initscore + max(score1, score2))
print(maxscore) | n, k = list(map(int, input().split()))
favor = [tuple(input().split()) for _ in range(n)]
square = [[0 for _ in range(k)] for _ in range(k)]
initscore = 0
for xc, yc, c in favor:
x = int(xc)
y = int(yc)
x %= 2*k
y %= 2*k
if (x in range(k) and y in range(k)) or (x in range(k, 2*k) and y in range(k, 2*k)):
if c == 'B':
square[x%k][y%k] += 1
else:
square[x%k][y%k] -= 1
initscore += 1
else:
if c == 'B':
square[x%k][y%k] -= 1
initscore += 1
else:
square[x%k][y%k] += 1
cum = [[0 for _ in range(k+1)] for _ in range(k+1)]
for i in range(k):
for j in range(k):
cum[i+1][j+1] = cum[i+1][j] + cum[i][j+1] - cum[i][j] + square[i][j]
maxscore = 0
for i in range(k):
for j in range(k):
score = cum[i][k] + cum[k][j] - 2*cum[i][j]
maxscore = max(maxscore, max(cum[k][k] - score, score))
print((maxscore + initscore)) | p03458 |
def examA():
N = DI()/dec(7)
ans = N
print(N)
return
def examB():
ans = 0
print(ans)
return
def examC():
ans = 0
print(ans)
return
def examD():
N = I()
n = (N-1).bit_length()
V = [[-1]*(1<<n) for i in range(1<<n)]
#print(V)
for i in range(n):
b1 = 1 << i
b2 = 1 << (i + 1)
for j in range(1<<i):
for k in range(1<<(n-i)):
for l in range(1<<(n-i)):
#print(i,j,k,l,j+k*b2,j+b1+l*b2)
if j+k*b2>=N or j+b1+l*b2>=N:
continue
u,v = sorted([j+k*b2,j+b1+l*b2])
#print(u,v)
V[u][v-1] = i+1
ans = [[]for _ in range(N-1)]
for i in range(N-1):
for v in V[i]:
if v>=0:
ans[i].append(v)
for v in ans:
print((" ".join(map(str,v))))
return
def examE():
ans = 0
print(ans)
return
def examF():
ans = 0
print(ans)
return
def test():
i = I()
li = LI()
lsi = LSI()
si = LS()
print(i)
print(li)
print(lsi)
print(si)
return
from decimal import getcontext,Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(eval(input()))
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(eval(input()))
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = dec("0.000000000001")
alphabet = [chr(ord('a') + i) for i in range(26)]
alphabet_convert = {chr(ord('a') + i): i for i in range(26)}
getcontext().prec = 28
sys.setrecursionlimit(10**7)
if __name__ == '__main__':
examD()
"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
""" | def examA():
N = DI()/dec(7)
ans = N
print(N)
return
def examB():
ans = 0
print(ans)
return
def examC():
ans = 0
print(ans)
return
def examD():
N = I()
n = (N-1).bit_length()
V = [[-1]*(1<<n) for i in range(1<<n)]
#print(V)
for i in range(n):
b1 = 1 << i
b2 = 1 << (i + 1)
for j in range(1<<i):
for k in range(1<<(n-i)):
for l in range(1<<(n-i)):
#print(i,j,k,l,j+k*b2,j+b1+l*b2)
if j+k*b2>=N or j+b1+l*b2>=N:
continue
u,v = sorted([j+k*b2,j+b1+l*b2])
#print(u,v)
V[u][v-1] = i+1
ans = [[]for _ in range(N-1)]
for i in range(N-1):
for v in V[i]:
if v>=0:
ans[i].append(v)
for v in ans:
print((" ".join(map(str,v))))
return
# 解説
def examD2():
N = I()
ans = [[-1]*(N-1-i) for i in range(N-1)]
n = N.bit_length()
for i in range(N):
for j in range(i+1,N):
k = 0
while(True):
if i&(1<<k) != j&(1<<k):
break
k += 1
#print(i,j,j-i)
ans[i][j-i-1] = k+1
for v in ans:
print((" ".join(map(str,v))))
return
def examE():
ans = 0
print(ans)
return
def examF():
ans = 0
print(ans)
return
def test():
i = I()
li = LI()
lsi = LSI()
si = LS()
print(i)
print(li)
print(lsi)
print(si)
return
from decimal import getcontext,Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(eval(input()))
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(eval(input()))
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = dec("0.000000000001")
alphabet = [chr(ord('a') + i) for i in range(26)]
alphabet_convert = {chr(ord('a') + i): i for i in range(26)}
getcontext().prec = 28
sys.setrecursionlimit(10**7)
if __name__ == '__main__':
examD2()
"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
""" | p02930 |
import sys
from collections import defaultdict
if __name__ == '__main__':
n, v = list(map(int, sys.stdin.readline().split()))
a = list(map(int, sys.stdin.readline().split()))
b = list(map(int, sys.stdin.readline().split()))
c = list(map(int, sys.stdin.readline().split()))
d = list(map(int, sys.stdin.readline().split()))
mp = defaultdict(int)
ls = []
for val1 in c:
for val2 in d:
mp[val1+val2] += 1
ans = 0
for val1 in a:
for val2 in b:
ans += mp[v-val1-val2]
print(ans)
| import sys
from collections import defaultdict
if __name__ == '__main__':
n, v = list(map(int, sys.stdin.readline().split()))
a = tuple(map(int, sys.stdin.readline().split()))
b = tuple(map(int, sys.stdin.readline().split()))
c = tuple(map(int, sys.stdin.readline().split()))
d = tuple(map(int, sys.stdin.readline().split()))
mp = defaultdict(int)
ls = []
for val1 in c:
for val2 in d:
mp[val1+val2] += 1
ans = 0
for val1 in a:
for val2 in b:
ans += mp[v-val1-val2]
print(ans)
| p02329 |
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DPL_4_A
AC
"""
import sys
from sys import stdin
from bisect import bisect_right, bisect_left
input = stdin.readline
def main(args):
N, V = list(map(int, input().split()))
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
C = [int(x) for x in input().split()]
D = [int(x) for x in input().split()]
#AB = []
#for i in A:
# for j in B:
# AB.append(i+j)
AB = [a+b for a in A for b in B]
#AB.sort()
#CD = [float('-inf'), float('inf')]
#for i in C:
# for j in D:
# CD.append(i+j)
CD = [c+d for c in C for d in D]
CD.append(float('-inf'))
CD.append(float('inf'))
CD.sort()
count = 0
for ab in AB:
i = bisect_left(CD, V - ab)
j = bisect_right(CD, V - ab)
count += max((j-i), 0)
print(count)
if __name__ == '__main__':
main(sys.argv[1:]) | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DPL_4_A
AC
"""
import sys
from sys import stdin
from bisect import bisect_right, bisect_left
input = stdin.readline
def main(args):
N, V = list(map(int, input().split()))
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
C = [int(x) for x in input().split()]
D = [int(x) for x in input().split()]
AB = tuple(a+b for a in A for b in B)
CD = [c+d for c in C for d in D]
CD.append(float('-inf'))
CD.append(float('inf'))
CD.sort()
count = 0
for ab in AB:
i = bisect_left(CD, V - ab)
j = bisect_right(CD, V - ab)
count += (j-i)
print(count)
if __name__ == '__main__':
main(sys.argv[1:]) | p02329 |
from enum import Enum
class Color(Enum):
BLACK = 0
RED = 1
@staticmethod
def flip(c):
return [Color.RED, Color.BLACK][c.value]
class Node:
__slots__ = ('key', 'left', 'right', 'size', 'color', 'value')
def __init__(self, key, value):
self.key = key
self.value = value
self.left = Leaf
self.right = Leaf
self.size = 1
self.color = Color.RED
def is_red(self):
return self.color == Color.RED
def is_black(self):
return self.color == Color.BLACK
def __str__(self):
if self.color == Color.RED:
key = '*{}'.format(self.key)
else:
key = '{}'.format(self.key)
return "{}[{}] ({}, {})".format(key, self.size,
self.left, self.right)
class LeafNode(Node):
def __init__(self):
self.key = None
self.value = None
self.left = None
self.right = None
self.size = 0
self.color = None
def is_red(self):
return False
def is_black(self):
return False
def __str__(self):
return '-'
Leaf = LeafNode()
class RedBlackBinarySearchTree:
"""Red Black Binary Search Tree with range, min, max.
Originally impremented in the textbook
Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,
Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.
"""
def __init__(self):
self.root = Leaf
def put(self, key, value=None):
def _put(node):
if node is Leaf:
node = Node(key, value)
if node.key > key:
node.left = _put(node.left)
elif node.key < key:
node.right = _put(node.right)
else:
node.value = value
node = self._restore(node)
node.size = node.left.size + node.right.size + 1
return node
self.root = _put(self.root)
self.root.color = Color.BLACK
def _rotate_left(self, node):
assert node.right.is_red()
x = node.right
node.right = x.left
x.left = node
x.color = node.color
node.color = Color.RED
node.size = node.left.size + node.right.size + 1
return x
def _rotate_right(self, node):
assert node.left.is_red()
x = node.left
node.left = x.right
x.right = node
x.color = node.color
node.color = Color.RED
node.size = node.left.size + node.right.size + 1
return x
def _flip_colors(self, node):
node.color = Color.flip(node.color)
node.left.color = Color.flip(node.left.color)
node.right.color = Color.flip(node.right.color)
return node
def __contains__(self, key):
def _contains(node):
if node is Leaf:
return False
if node.key > key:
return _contains(node.left)
elif node.key < key:
return _contains(node.right)
else:
return True
return _contains(self.root)
def get(self, key):
def _get(node):
if node is Leaf:
return None
if node.key > key:
return _get(node.left)
elif node.key < key:
return _get(node.right)
else:
return node.value
return _get(self.root)
def delete(self, key):
def _delete(node):
if node is Leaf:
return Leaf
if node.key > key:
if node.left is Leaf:
return self._balance(node)
if not self._is_red_left(node):
node = self._red_left(node)
node.left = _delete(node.left)
else:
if node.left.is_red():
node = self._rotate_right(node)
if node.key == key and node.right is Leaf:
return Leaf
elif node.right is Leaf:
return self._balance(node)
if not self._is_red_right(node):
node = self._red_right(node)
if node.key == key:
x = self._find_min(node.right)
node.key = x.key
node.value = x.value
node.right = self._delete_min(node.right)
else:
node.right = _delete(node.right)
return self._balance(node)
if self.is_empty():
raise ValueError('delete on empty tree')
if not self.root.left.is_red() and not self.root.right.is_red():
self.root.color = Color.RED
self.root = _delete(self.root)
if not self.is_empty():
self.root.color = Color.BLACK
assert self.is_balanced()
def delete_max(self):
if self.is_empty():
raise ValueError('delete max on empty tree')
if not self.root.left.is_red() and not self.root.right.is_red():
self.root.color = Color.RED
self.root = self._delete_max(self.root)
if not self.is_empty():
self.root.color = Color.BLACK
assert self.is_balanced()
def _delete_max(self, node):
if node.left.is_red():
node = self._rotate_right(node)
if node.right is Leaf:
return Leaf
if not self._is_red_right(node):
node = self._red_right(node)
node.right = self._delete_max(node.right)
return self._balance(node)
def _red_right(self, node):
node = self._flip_colors(node)
if node.left.left.is_red():
node = self._rotate_right(node)
return node
def _is_red_right(self, node):
return (node.right.is_red() or
(node.right.is_black() and node.right.left.is_red()))
def delete_min(self):
if self.is_empty():
raise ValueError('delete min on empty tree')
if not self.root.left.is_red() and not self.root.right.is_red():
self.root.color = Color.RED
self.root = self._delete_min(self.root)
if not self.is_empty():
self.root.color = Color.BLACK
assert self.is_balanced()
def _delete_min(self, node):
if node.left is Leaf:
return Leaf
if not self._is_red_left(node):
node = self._red_left(node)
node.left = self._delete_min(node.left)
return self._balance(node)
def _red_left(self, node):
node = self._flip_colors(node)
if node.right.left.is_red():
node.right = self._rotate_right(node.right)
node = self._rotate_left(node)
return node
def _is_red_left(self, node):
return (node.left.is_red() or
(node.left.is_black() and node.left.left.is_red()))
def _balance(self, node):
if node.right.is_red():
node = self._rotate_left(node)
return self._restore(node)
def _restore(self, node):
if node.right.is_red() and not node.left.is_red():
node = self._rotate_left(node)
if node.left.is_red() and node.left.left.is_red():
node = self._rotate_right(node)
if node.left.is_red() and node.right.is_red():
node = self._flip_colors(node)
node.size = node.left.size + node.right.size + 1
return node
def is_empty(self):
return self.root is Leaf
def is_balanced(self):
if self.is_empty():
return True
try:
left = self._depth(self.root.left)
right = self._depth(self.root.right)
return left == right
except Exception:
return False
@property
def depth(self):
return self._depth(self.root)
def _depth(self, node):
if node is Leaf:
return 0
if node.right.is_red():
raise Exception('right red')
left = self._depth(node.left)
right = self._depth(node.right)
if left != right:
raise Exception('unbalanced')
if node.is_red():
return left
else:
return 1 + left
def __len__(self):
return self.root.size
@property
def max(self):
if self.is_empty():
raise ValueError('max on empty tree')
return self._max(self.root)
def _max(self, node):
x = self._find_max(node)
return x.key
def _find_max(self, node):
if node.right is Leaf:
return node
else:
return self._find_max(node.right)
@property
def min(self):
if self.is_empty():
raise ValueError('min on empty tree')
return self._min(self.root)
def _min(self, node):
x = self._find_min(node)
return x.key
def _find_min(self, node):
if node.left is Leaf:
return node
else:
return self._find_min(node.left)
def range(self, min_, max_):
def _range(node):
if node is Leaf:
return
if node.key > max_:
yield from _range(node.left)
elif node.key < min_:
yield from _range(node.right)
else:
yield from _range(node.left)
yield (node.key, node.value)
yield from _range(node.right)
if min_ > max_:
return
yield from _range(self.root)
class BalancedBstCounter:
def __init__(self):
self.bst = RedBlackBinarySearchTree()
self.count = 0
def up(self, key):
if key in self.bst:
value = self.bst.get(key) + 1
else:
value = 1
self.bst.put(key, value)
self.count += 1
def __contains__(self, key):
if key in self.bst:
return self.bst.get(key) > 0
else:
return False
def get(self, key):
if key in self.bst:
return self.bst.get(key)
else:
return 0
def down(self, key):
if key in self.bst:
value = self.bst.get(key)
self.bst.put(key, 0)
self.count -= value
def range(self, a, b):
for k, v in self.bst.range(a, b):
for _ in range(v):
yield k
def __len__(self):
return self.count
def __str__(self):
return str(self.bst.root)
def run():
q = int(eval(input()))
counter = BalancedBstCounter()
for _ in range(q):
command, *value = [int(x) for x in input().split()]
if command == 0:
counter.up(value[0])
print((len(counter)))
elif command == 1:
print((counter.get(value[0])))
elif command == 2:
counter.down(value[0])
elif command == 3:
for i in counter.range(*value):
print(i)
else:
raise ValueError('invalid command')
if __name__ == '__main__':
run()
|
from enum import Enum
class Color(Enum):
BLACK = 0
RED = 1
@staticmethod
def flip(c):
return [Color.RED, Color.BLACK][c.value]
class Node:
__slots__ = ('key', 'left', 'right', 'size', 'color', 'value')
def __init__(self, key, value):
self.key = key
self.value = value
self.left = Leaf
self.right = Leaf
self.size = 1
self.color = Color.RED
def is_red(self):
return self.color == Color.RED
def is_black(self):
return self.color == Color.BLACK
def __str__(self):
if self.color == Color.RED:
key = '*{}'.format(self.key)
else:
key = '{}'.format(self.key)
return "{}[{}] ({}, {})".format(key, self.size,
self.left, self.right)
class LeafNode(Node):
def __init__(self):
self.key = None
self.value = None
self.left = None
self.right = None
self.size = 0
self.color = None
def is_red(self):
return False
def is_black(self):
return False
def __str__(self):
return '-'
Leaf = LeafNode()
class RedBlackBinarySearchTree:
"""Red Black Binary Search Tree with range, min, max.
Originally impremented in the textbook
Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,
Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.
"""
def __init__(self):
self.root = Leaf
def put(self, key, value=None):
def _put(node):
if node is Leaf:
node = Node(key, value)
if node.key > key:
node.left = _put(node.left)
elif node.key < key:
node.right = _put(node.right)
else:
node.value = value
node = self._restore(node)
node.size = node.left.size + node.right.size + 1
return node
self.root = _put(self.root)
self.root.color = Color.BLACK
def _rotate_left(self, node):
x = node.right
node.right = x.left
x.left = node
x.color = node.color
node.color = Color.RED
node.size = node.left.size + node.right.size + 1
return x
def _rotate_right(self, node):
x = node.left
node.left = x.right
x.right = node
x.color = node.color
node.color = Color.RED
node.size = node.left.size + node.right.size + 1
return x
def _flip_colors(self, node):
node.color = Color.flip(node.color)
node.left.color = Color.flip(node.left.color)
node.right.color = Color.flip(node.right.color)
return node
def __contains__(self, key):
def _contains(node):
if node is Leaf:
return False
if node.key > key:
return _contains(node.left)
elif node.key < key:
return _contains(node.right)
else:
return True
return _contains(self.root)
def get(self, key):
def _get(node):
if node is Leaf:
return None
if node.key > key:
return _get(node.left)
elif node.key < key:
return _get(node.right)
else:
return node.value
return _get(self.root)
def delete(self, key):
def _delete(node):
if node is Leaf:
return Leaf
if node.key > key:
if node.left is Leaf:
return self._balance(node)
if not self._is_red_left(node):
node = self._red_left(node)
node.left = _delete(node.left)
else:
if node.left.is_red():
node = self._rotate_right(node)
if node.key == key and node.right is Leaf:
return Leaf
elif node.right is Leaf:
return self._balance(node)
if not self._is_red_right(node):
node = self._red_right(node)
if node.key == key:
x = self._find_min(node.right)
node.key = x.key
node.value = x.value
node.right = self._delete_min(node.right)
else:
node.right = _delete(node.right)
return self._balance(node)
if self.is_empty():
raise ValueError('delete on empty tree')
if not self.root.left.is_red() and not self.root.right.is_red():
self.root.color = Color.RED
self.root = _delete(self.root)
if not self.is_empty():
self.root.color = Color.BLACK
def delete_max(self):
if self.is_empty():
raise ValueError('delete max on empty tree')
if not self.root.left.is_red() and not self.root.right.is_red():
self.root.color = Color.RED
self.root = self._delete_max(self.root)
if not self.is_empty():
self.root.color = Color.BLACK
def _delete_max(self, node):
if node.left.is_red():
node = self._rotate_right(node)
if node.right is Leaf:
return Leaf
if not self._is_red_right(node):
node = self._red_right(node)
node.right = self._delete_max(node.right)
return self._balance(node)
def _red_right(self, node):
node = self._flip_colors(node)
if node.left.left.is_red():
node = self._rotate_right(node)
return node
def _is_red_right(self, node):
return (node.right.is_red() or
(node.right.is_black() and node.right.left.is_red()))
def delete_min(self):
if self.is_empty():
raise ValueError('delete min on empty tree')
if not self.root.left.is_red() and not self.root.right.is_red():
self.root.color = Color.RED
self.root = self._delete_min(self.root)
if not self.is_empty():
self.root.color = Color.BLACK
def _delete_min(self, node):
if node.left is Leaf:
return Leaf
if not self._is_red_left(node):
node = self._red_left(node)
node.left = self._delete_min(node.left)
return self._balance(node)
def _red_left(self, node):
node = self._flip_colors(node)
if node.right.left.is_red():
node.right = self._rotate_right(node.right)
node = self._rotate_left(node)
return node
def _is_red_left(self, node):
return (node.left.is_red() or
(node.left.is_black() and node.left.left.is_red()))
def _balance(self, node):
if node.right.is_red():
node = self._rotate_left(node)
return self._restore(node)
def _restore(self, node):
if node.right.is_red() and not node.left.is_red():
node = self._rotate_left(node)
if node.left.is_red() and node.left.left.is_red():
node = self._rotate_right(node)
if node.left.is_red() and node.right.is_red():
node = self._flip_colors(node)
node.size = node.left.size + node.right.size + 1
return node
def is_empty(self):
return self.root is Leaf
def is_balanced(self):
if self.is_empty():
return True
try:
left = self._depth(self.root.left)
right = self._depth(self.root.right)
return left == right
except Exception:
return False
@property
def depth(self):
return self._depth(self.root)
def _depth(self, node):
if node is Leaf:
return 0
if node.right.is_red():
raise Exception('right red')
left = self._depth(node.left)
right = self._depth(node.right)
if left != right:
raise Exception('unbalanced')
if node.is_red():
return left
else:
return 1 + left
def __len__(self):
return self.root.size
@property
def max(self):
if self.is_empty():
raise ValueError('max on empty tree')
return self._max(self.root)
def _max(self, node):
x = self._find_max(node)
return x.key
def _find_max(self, node):
if node.right is Leaf:
return node
else:
return self._find_max(node.right)
@property
def min(self):
if self.is_empty():
raise ValueError('min on empty tree')
return self._min(self.root)
def _min(self, node):
x = self._find_min(node)
return x.key
def _find_min(self, node):
if node.left is Leaf:
return node
else:
return self._find_min(node.left)
def range(self, min_, max_):
def _range(node):
if node is Leaf:
return
if node.key > max_:
yield from _range(node.left)
elif node.key < min_:
yield from _range(node.right)
else:
yield from _range(node.left)
yield (node.key, node.value)
yield from _range(node.right)
if min_ > max_:
return
yield from _range(self.root)
class BalancedBstCounter:
def __init__(self):
self.bst = RedBlackBinarySearchTree()
self.count = 0
def up(self, key):
if key in self.bst:
value = self.bst.get(key) + 1
else:
value = 1
self.bst.put(key, value)
self.count += 1
def __contains__(self, key):
if key in self.bst:
return self.bst.get(key) > 0
else:
return False
def get(self, key):
if key in self.bst:
return self.bst.get(key)
else:
return 0
def down(self, key):
if key in self.bst:
value = self.bst.get(key)
self.bst.put(key, 0)
self.count -= value
def range(self, a, b):
for k, v in self.bst.range(a, b):
for _ in range(v):
yield k
def __len__(self):
return self.count
def __str__(self):
return str(self.bst.root)
def run():
q = int(eval(input()))
counter = BalancedBstCounter()
for _ in range(q):
command, *value = [int(x) for x in input().split()]
if command == 0:
counter.up(value[0])
print((len(counter)))
elif command == 1:
print((counter.get(value[0])))
elif command == 2:
counter.down(value[0])
elif command == 3:
for i in counter.range(*value):
print(i)
else:
raise ValueError('invalid command')
if __name__ == '__main__':
run()
| p02458 |
A = list(map(int, input().split()))
B = list(map(int, input().split()))
max_sum = max([sum(A), sum(B)])
print(max_sum) | A, B = [list(map(int, input().split())) for _ in range(2)]
print((max([sum(A), sum(B)]))) | p00433 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
2 20
5 9
4 10
output:
9
1 ??? N ??? 100
1 ??? vi ??? 100
1 ??? wi ??? 10,000,000
1 ??? W ??? 1,000,000,000
"""
import sys
from collections import namedtuple
MAX_N, MAX_V = 100, 100
def solve():
dp = [[float('inf')] * (MAX_N * MAX_V + 1) for _ in range(MAX_N + 1)]
dp[0][0] = 0
for i, item in enumerate(item_list):
v, w = item.value, item.weight
for j in range(MAX_N * MAX_V + 1):
if j < v:
dp[i + 1][j] = dp[i][j]
else:
dp[i + 1][j] = min(dp[i][j], dp[i][j - v] + w)
ans = 0
for i in range(MAX_N * MAX_V + 1):
if dp[c_items][i] <= real_cp:
ans = i
return ans
if __name__ == '__main__':
_input = sys.stdin.readlines()
c_items, real_cp = list(map(int, _input[0].split()))
items = [x.split() for x in _input[1:]]
Item = namedtuple('Item', ('value', 'weight'))
item_list = [Item(int(v), int(w)) for v, w in items]
print((solve())) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
2 20
5 9
4 10
output:
9
1 ??? N ??? 100
1 ??? vi ??? 100
1 ??? wi ??? 10,000,000
1 ??? W ??? 1,000,000,000
"""
import sys
from collections import namedtuple
MAX_V = 100
def solve():
dp = [[float('inf')] * (c_items * MAX_V + 1) for _ in range(c_items + 1)]
dp[0][0] = 0
for i, item in enumerate(item_list):
v, w = item.value, item.weight
for j in range(c_items * MAX_V + 1):
if j < v:
dp[i + 1][j] = dp[i][j]
else:
dp[i + 1][j] = min(dp[i][j], dp[i][j - v] + w)
ans = 0
for i in range(c_items * MAX_V + 1):
if dp[c_items][i] <= knapsack_cp:
ans = i
return ans
if __name__ == '__main__':
_input = sys.stdin.readlines()
c_items, knapsack_cp = list(map(int, _input[0].split()))
items = [x.split() for x in _input[1:]]
Item = namedtuple('Item', ('value', 'weight'))
item_list = [Item(int(v), int(w)) for v, w in items]
print((solve())) | p02319 |
n, k = list(map(int, input().split()))
d = [11, 16, 10, 25, 9, 24, 19, 13, 18, 12, 17]
print((len([x for x in range(d[k], 7 * (n - 1), 11) if x % 7 > 1])))
| n, k = list(map(int, input().split()))
d = [11, 16, 10, 25, 9, 24, 19, 13, 18, 12, 17]
e = 7 * (n - 1)
r = (e - d[k] - 1) // 77
print((5 * r + len([x for x in range(d[k] + 77 * r, e, 11) if x % 7 > 1])))
| p03929 |
n, k = list(map(int, input().split()))
c = 0
for i in range(2, n):
for j in range(2, 7):
if (7 * i + j - 7) * 9 % 11 == k:
c += 1
print(c) | n, k = list(map(int, input().split()))
p = int((n - 2) / 11)
c = p * 5
for i in range(2 + p * 11 , n):
for j in range(2, 7):
if (7 * i + j - 7) * 9 % 11 == k:
c += 1
print(c) | p03929 |
n,k=list(map(int,input().split()))
#(i,j)=7i+j-7
x=0
for i in range(11):
if (9*i)%11==k:
x=i
break
ans=0
for i in range((7*n)//11+1):
s=11*i+x
if s>7*n-7:
continue
if s<=7:
continue
if s%7==0 or s%7==1:
continue
else:
ans+=1
print(ans)
| n,k=list(map(int,input().split()))
#(i,j)=7i+j-7
x=0
for i in range(11):
if (9*i)%11==k:
x=i
break
K=0
L=0
for i in range(1,78):
if i%11!=x:
continue
if i%7<=1:
continue
K+=1
if i<=7:
L+=1
P=0
for i in range(1,7*(n%11)+1):
if i%11!=x:
continue
if i%7<=1:
continue
if i>(7*(n%11)-7):
continue
P+=1
print((K*(n//11)+P-L))
| p03929 |
n,k = list(map(int,input().split()))
count = 0
for i in range(1,6):
for j in range(1,n-1):
if (9*i+9+63*j)%11 == k:
count += 1
print(count) | n,k = list(map(int,input().split()))
a = 4;b = 2;c = 0;d = 9;e = 7
f = [a,b,c,d,e]
ans = 0
for i in range((n-2)%11):
if k in (a,b,c,d,e):
ans += 1
a = (a+8)%11
b = (b+8)%11
c = (c+8)%11
d = (d+8)%11
e = (e+8)%11
print((ans+((n-2)//11)*5)) | p03929 |
#! /usr/bin/env python3
n, k = list(map(int, input().split()))
M = [[(7*i+j-7)%11 for j in range(1, 7+1)] for i in range(1, n+1)]
cnt = 0
f = lambda i, j : sum(M[i+y][j+x] for y in range(3) for x in range(3)) % 11 == k
h = [0] * 11
for i in range(min(n-2, 11)):
for j in range(7-2):
if f(i, j) :
h[i] += 1
cnt = sum(h) * (n // 11)
for i in range(n % 11 - 2):
cnt += h[i%11]
print(cnt) | #! /usr/bin/env python3
n, k = list(map(int, input().split()))
M = [[7*i+j-7 for j in range(1, 7+1)] for i in range(1, min(n+1, 14))]
cnt = 0
f = lambda i, j : sum(M[i+y][j+x] for y in range(3) for x in range(3)) % 11 == k
h = [0] * 11
for i in range(min(max(0, n-2), 11)):
for j in range(7-2):
if f(i, j) :
h[i] += 1
cnt = sum(h) * ((n-2) // 11)
for i in range((n-2) % 11):
cnt += h[i]
print(cnt) | p03929 |
#! /usr/bin/env python3
n, k = list(map(int, input().split()))
n = max(0, n-2)
ans = 0
f = lambda i, j : sum(7*(i+x//3+1)+(j+x%3+1)-7 for x in range(9)) % 11 == k
h = [0] * 11
for i in range(min(n, 11)):
h[i] = sum(1 for x in range(5) if f(i, x))
ans = sum(h) * (n // 11) + sum(h[i] for i in range(n % 11))
print(ans) | #! /usr/bin/env python3
n, k = list(map(int, input().split()))
n = max(0, n-2)
ans = 0
h = [sum((63*i+9*j+81) % 11 == k for j in range(5))for i in range(min(n, 11))]
ans = sum(h) * (n // 11) + sum(h[i] for i in range(n % 11))
print(ans) | p03929 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
3
abcbdab
bdcaba
abc
abc
abc
bc
output:
4
3
2
"""
import sys
sys.setrecursionlimit(int(1e5))
def lcs(A, B):
m, n = len(A), len(B)
count_list = tuple([[0] * (n + 1) for _ in range(m + 1)])
for i in range(1, m + 1):
for j in range(1, n + 1):
if A[i - 1] == B[j - 1]:
count_list[i][j] = count_list[i - 1][j - 1] + 1
else:
count_list[i][j] = max(count_list[i - 1][j], count_list[i][j - 1])
return count_list[m][n]
def lcs_recursive(A, B, m, n):
if m == 0 or n == 0:
return 0
elif A[m - 1] == B[n - 1]:
return 1 + lcs_recursive(A, B, m - 1, n - 1)
else:
return max(lcs_recursive(A, B, m, n - 1), lcs_recursive(A, B, m - 1, n))
if __name__ == '__main__':
_input = sys.stdin.readlines()
pair_num = int(_input[0])
word_list = _input[1:]
# assert len(word_list) == 2 * pair_num
# for k in range(0, len(word_list), 2):
# print(lcs(word_list[k].strip(), word_list[k + 1].strip()))
for pair in zip(word_list[::2], word_list[1::2]):
w1, w2 = [x.strip() for x in pair]
l1, l2 = len(w1), len(w2)
print((lcs_recursive(w1, w2, l1, l2))) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
3
abcbdab
bdcaba
abc
abc
abc
bc
output:
4
3
2
"""
import sys
sys.setrecursionlimit(int(1e5))
def lcs(A, B):
m, n = len(A), len(B)
dp = tuple([[0] * (n + 1) for _ in range(m + 1)])
max_l = 0
for i in range(1, m + 1):
for j in range(1, n + 1):
if A[i - 1] == B[j - 1]:
dp[i][j] = dp[i - 1][j - 1] + 1
else:
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
max_l = max(max_l, dp[i][j])
return max_l
def lcs_recursive(A, B, m, n):
if m == 0 or n == 0:
return 0
elif A[m - 1] == B[n - 1]:
return 1 + lcs_recursive(A, B, m - 1, n - 1)
else:
return max(lcs_recursive(A, B, m, n - 1), lcs_recursive(A, B, m - 1, n))
if __name__ == '__main__':
_input = sys.stdin.readlines()
pair_num = int(_input[0])
word_list = _input[1:]
# assert len(word_list) == 2 * pair_num
# for k in range(0, len(word_list), 2):
# print(lcs(word_list[k].strip(), word_list[k + 1].strip()))
for pair in zip(word_list[::2], word_list[1::2]):
w1, w2 = [x.strip() for x in pair]
# l1, l2 = len(w1), len(w2)
print((lcs(w1, w2))) | p02235 |
import sys
n = int(eval(input()))
primary = [0] * 1000
secondary = [0] * 1000
for i in range(n):
s1 = sys.stdin.readline().strip()
s2 = sys.stdin.readline().strip()
len1 = len(s1)
len2 = len(s2)
for i in range(len1):
primary[i] = 0
secondary[i] = 0
for i in range(len2):
for j in range(len1):
if s1[j] == s2[i]:
matched = 1
else:
matched = 0
if j == 0:
secondary[j] = matched
else:
sc0 = secondary[j-1]
pr0 = primary[j-1] + matched
pr1 = primary[j]
if sc0 > pr0:
if pr0 > pr1:
secondary[j] = sc0
elif sc0 > pr1:
secondary[j] = sc0
else:
secondary[j] = pr1
else:
if sc0 > pr1:
secondary[j] = pr0
elif pr0 > pr1:
secondary[j] = pr0
else:
secondary[j] = pr1
primary, secondary = secondary, primary
print((primary[len1-1]))
| import sys
def len_lcs(s1, s2):
"""Find length of the longest common sequence(LCS) of strings s1 and s2.
The complexity is ~MN.
>>> len_lcs("abc", "abc")
3
>>> len_lcs("abcbdaba", "bdcaba")
5
"""
results = [0] * len(s1)
for i, c2 in enumerate(s2):
sec1, pr1 = 0, 0
for j, c1 in enumerate(s1):
if c1 == c2:
match = 1
else:
match = 0
pr2 = results[j]
mval = max(sec1, pr2, pr1 + match)
results[j] = mval
sec1, pr1 = mval, pr2
return results[-1]
def run():
n = int(eval(input()))
s = []
for line in sys.stdin:
s.append(line.strip())
for i in range(0, 2*n, 2):
print((len_lcs(s[i], s[i+1])))
run()
| p02235 |
import sys
def len_lcs(s1, s2):
"""Find length of the longest common sequence(LCS) of strings s1 and s2.
The complexity is ~MN.
>>> len_lcs("abc", "abc")
3
>>> len_lcs("abcbdaba", "bdcaba")
5
"""
results = [0] * len(s1)
for i, c2 in enumerate(s2):
sec1, pr1 = 0, 0
for j, c1 in enumerate(s1):
if c1 == c2:
match = 1
else:
match = 0
pr2 = results[j]
mval = max(sec1, pr2, pr1 + match)
results[j] = mval
sec1, pr1 = mval, pr2
return results[-1]
n = int(eval(input()))
s = []
for line in sys.stdin:
s.append(line.strip())
for i in range(0, 2*n, 2):
print((len_lcs(s[i], s[i+1])))
| import sys
def len_lcs(s1, s2):
"""Find length of the longest common sequence(LCS) of strings s1 and s2.
The complexity is ~MN.
>>> len_lcs("abc", "abc")
3
>>> len_lcs("abcbdaba", "bdcaba")
5
"""
results = [0] * len(s1)
for i, c2 in enumerate(s2):
sec1, pr1 = 0, 0
for j, c1 in enumerate(s1):
pr2 = results[j]
if c1 == c2:
mval = pr1 + 1
elif sec1 > pr2:
mval = sec1
else:
mval = pr2
results[j] = mval
sec1, pr1 = mval, pr2
return results[-1]
def run():
n = int(eval(input()))
s = []
for line in sys.stdin:
s.append(line.strip())
for i in range(0, 2*n, 2):
print((len_lcs(s[i], s[i+1])))
run()
| p02235 |
e=input
for _ in[0]*int(e()):
X,z=e(),[]
for y in e():
s=i=0
for k in z:
t=X.find(y,s)+1
if t<1:break
if t<k:z[i]=t
s=k;i+=1
else:
t=X.find(y,s)+1
if t:z+=[t]
print((len(z)))
| e=input
a=[]
for _ in[0]*int(e()):
X,z=e(),[]
for y in e():
s=i=0
for k in z:
t=X.find(y,s)+1
if t<1:break
if t<k:z[i]=t
s=k;i+=1
else:
t=X.find(y,s)+1
if t:z+=[t]
a+=[len(z)]
print(*a,sep='\n')
| p02235 |
e=input
a=[]
for _ in[0]*int(e()):
X,z=e(),[]
for y in e():
s=i=0
for k in z:
t=X.find(y,s)+1
if t<1:break
if t<k:z[i]=t
s=k;i+=1
else:
t=X.find(y,s)+1
if t:z+=[t]
a+=[len(z)]
print(*a,sep='\n')
| e=input
a=''
for _ in[0]*int(e()):
X,z=e(),[]
for y in e():
s=i=0
for k in z:
t=X.find(y,s)+1
if t<1:break
if t<k:z[i]=t
s=k;i+=1
else:
t=X.find(y,s)+1
if t:z+=[t]
a+=f'\n{len(z)}'
print((a[1:]))
| p02235 |
e=input
a=[]
for _ in[0]*int(e()):
X,z=e(),[]
for y in e():
s=i=0
for k in z:
t=X.find(y,s)+1
if t<1:break
if t<k:z[i]=t
s=k;i+=1
else:
t=X.find(y,s)+1
if t:z+=[t]
a+=[z]
print(('\n'.join(map(str,list(map(len,a))))))
| e=input
a=[]
for _ in[0]*int(e()):
X,z=e(),[]
for y in e():
s=i=0
for k in z:
t=X.find(y,s)+1
if t<1:break
if t<k:z[i]=t
s=k;i+=1
else:
t=X.find(y,s)+1
if t:z+=[t]
a+=[z]
print(*map(len,a),sep='\n')
| p02235 |
def lcs(X, Y):
X = " " + X
Y = " " + Y
c = [[0 for j in range(len(Y))] for i in range(len(X))]
maxl = 0
for i in range(1,len(X)):
for j in range(1,len(Y)):
if X[i] == Y[j]:
c[i][j] = c[i - 1][j - 1] + 1
else:
c[i][j] = max(c[i - 1][j], c[i][j - 1])
maxl = max(maxl, c[i][j])
return maxl
n = int(input())
for i in range(n):
s1 = input()
s2 = input()
print(lcs(s1, s2)) | def lcs(X, Y):
X = " " + X
Y = " " + Y
#c = [[0 for j in range(len(Y))] for i in range(len(X))]
c = [[0] * len(Y) for i in range(len(X))]
maxl = 0
for i in range(1,len(X)):
for j in range(1,len(Y)):
if X[i] == Y[j]:
c[i][j] = c[i - 1][j - 1] + 1
else:
c[i][j] = max(c[i - 1][j], c[i][j - 1])
maxl = max(maxl, c[i][j])
return maxl
n = int(input())
for i in range(n):
s1 = input()
s2 = input()
print(lcs(s1, s2)) | p02235 |
def lcs(X, Y):
X = " " + X
Y = " " + Y
#c = [[0 for j in xrange(len(Y))] for i in xrange(len(X))]
c = [[0] * len(Y) for i in range(len(X))]
maxl = 0
for i in range(1,len(X)):
for j in range(1,len(Y)):
if X[i] == Y[j]:
c[i][j] = c[i - 1][j - 1] + 1
else:
c[i][j] = max(c[i - 1][j], c[i][j - 1])
maxl = max(maxl, c[i][j])
return maxl
n = int(input())
for i in range(n):
s1 = input()
s2 = input()
print(lcs(s1, s2)) | def lcs(X, Y):
#X = " " + X
#Y = " " + Y
#c = [[0 for j in xrange(len(Y))] for i in xrange(len(X))]
c2 = [0 for i in range(len(Y) + 1)]
#maxl = 0
for i in range(len(X)):
c1 = c2 + []
for j in range(len(Y)):
if X[i] == Y[j]:
c2[j + 1] = c1[j] + 1
elif c2[j + 1] < c2[j]:
c2[j + 1] = c2[j]
return c2[-1]
n = int(input())
for i in range(n):
s1 = input()
s2 = input()
print(lcs(s1, s2)) | p02235 |
#dj 16D8101012J ito jun
import sys
def search(a,b):
na=len(a)
nb=len(b)
array = [[0]*(nb+1) for _ in range(na+1)]
for i,x in enumerate(a,1):
prerow=array[i-1]
row=array[i]
for j,y in enumerate(b,1):
if x == y:
row[j]=prerow[j-1]+1
elif prerow[j] < row[j-1]+1:
row[j] = row[j-1]
else:
row[j] = prerow[j]
return array[-1][-1]
n = int(input())
strs = [list(i) for i in sys.stdin.read().splitlines()]
result = [search(strs[i*2], strs[i*2+1]) for i in range(n)]
print(*result, sep="\n")
| #dj 16D8101012J ito jun
import sys
def search(a,b):
na=len(a)
nb=len(b)
array = [[0]*(nb+1) for _ in range(na+1)]
for i,x in enumerate(a,1):
prerow=array[i-1]
row=array[i]
for j,y in enumerate(b,1):
if x == y:
row[j]=prerow[j-1]+1
elif prerow[j] < row[j-1]:
row[j] = row[j-1]
else:
row[j] = prerow[j]
return array[-1][-1]
n = int(input())
strs = [list(i) for i in sys.stdin.read().splitlines()]
result = [search(strs[i*2], strs[i*2+1]) for i in range(n)]
print(*result, sep="\n")
| p02235 |
def lcs_hs(s1, s2):
from bisect import bisect_left
p = []
append_p = p.append
for i, c in enumerate(s1):
j = s2.find(c)+1
while j:
append_p((i, -j))
j = s2.find(c, j)+1
lis, result = [], 0
append_lis = lis.append
for _, y in sorted(p):
i = bisect_left(lis, -y)
if i >= result:
append_lis(-y)
result += 1
else:
lis[i] = -y
return result
print(*(lcs_hs(input(), input()) for _ in [0]*int(input())), sep="\n")
| def lcs_hs(s1, s2):
from bisect import bisect_left
s2 = s2[::-1]
lis, result = [], 0
append = lis.append
for c in s1:
i = s2.find(c)+1
while i:
j = bisect_left(lis, -i)
if j >= result:
append(-i)
result += 1
else:
lis[j] = -i
i = s2.find(c, i)+1
return result
print(*(lcs_hs(input(), input()) for _ in [0]*int(input())), sep="\n")
| p02235 |
def lcs_hs(s1, s2):
from bisect import bisect_left
s2 = s2[::-1]
lis, result = [], 0
append = lis.append
for c in s1:
i = s2.find(c)+1
while i:
j = bisect_left(lis, -i)
if j >= result:
append(-i)
result += 1
else:
lis[j] = -i
i = s2.find(c, i)+1
return result
print(*(lcs_hs(input(), input()) for _ in [0]*int(input())), sep="\n")
| def lcs_hs(s1, s2):
from bisect import bisect_left
s2, lis, result = s2[::-1], [], 0
find, append = s2.find, lis.append
for c in s1:
i = find(c)+1
while i:
j = bisect_left(lis, -i)
if j >= result:
append(-i)
result += 1
else:
lis[j] = -i
i = find(c, i)+1
return result
print(*(lcs_hs(input(), input()) for _ in [0]*int(input())), sep="\n")
| p02235 |
from itertools import chain
from sys import stdin
def lcs(x, y):
m = len(x)
n = len(y)
c = [[0] * 1001 for i in range(1002)]
# x = " " + x
# y = " " + y
for i in range(1, m + 1):
for j in range(1, n + 1):
if x[i-1] == y[j-1]:
c[i][j] = c[i - 1][j - 1] + 1
else:
c[i][j] = max(c[i - 1][j], c[i][j - 1])
return max(chain.from_iterable(c))
n = int(input().rstrip())
strs = stdin.readlines()
ret = []
for i in range(n):
s1 = strs[i*2].rstrip()
s2 = strs[i*2+1].rstrip()
ret.append(lcs(s1, s2))
print(*ret, sep="\n")
|
from sys import stdin
def lcs(x, y):
m = len(x)
n = len(y)
c = [[0]*(n + 1) for a in range(m + 2)]
for i in range(1, m + 1):
for j in range(1, n + 1):
if x[i-1] == y[j-1]:
c[i][j] = c[i - 1][j - 1] + 1
else:
c[i][j] = max(c[i - 1][j], c[i][j - 1])
return max(max(c))
n = int(input().rstrip())
strs = stdin.readlines()
ret = []
for i in range(n):
s1 = strs[i*2].rstrip()
s2 = strs[i*2+1].rstrip()
ret.append(lcs(s1, s2))
print(*ret, sep="\n") | p02235 |
def lcs(x, y):
a = len(x)
b = len(y)
c1 = [0] * (b + 1)
for i in range(a):
c2 = c1[:]
for j in range(b):
if x[i] == y[j]:
c1[j+1] = c2[j] + 1
elif c1[j+1] < c1[j]:
c1[j+1] = c1[j]
return c1[-1]
n = int(input().rstrip())
ret = []
for i in range(n):
s1 = input().rstrip()
s2 = input().rstrip()
ret.append(lcs(s1, s2))
print(*ret, sep="\n")
| def lcs(x, y):
a = len(x)
b = len(y)
c1 = [0] * (b + 1)
for i in range(a):
e1 = x[i]
c2 = c1[:]
for j in range(b):
if e1 == y[j]:
c1[j+1] = c2[j] + 1
elif c1[j+1] < c1[j]:
c1[j+1] = c1[j]
return c1[-1]
n = int(input().rstrip())
ret = []
for i in range(n):
s1 = input().rstrip()
s2 = input().rstrip()
ret.append(lcs(s1, s2))
print(*ret, sep="\n")
| p02235 |
q = int(input().rstrip())
ans = []
for i in range(q):
x = input().rstrip()
y = input().rstrip()
n = len(x)
m = len(y)
dp1 = [0]*(m+1)
for i in range(n):
s = x[i]
dp2 = dp1[:]
for j in range(m):
if s == y[j]:
dp1[j+1] = dp2[j]+1
elif dp1[j+1] < dp1[j]:
dp1[j+1] = dp1[j]
ans.append(dp1[-1])
print(*ans, sep="\n")
| def calc(x,y):
n = len(x)
m = len(y)
dp1 = [0]*(m+1)
for i in range(n):
s = x[i]
dp2 = dp1[:]
for j in range(m):
if s == y[j]:
dp1[j+1] = dp2[j]+1
elif dp1[j+1] < dp1[j]:
dp1[j+1] = dp1[j]
return dp1[-1]
q = int(input().rstrip())
ans = []
for i in range(q):
x = input()
y = input()
ans.append(calc(x,y))
print(*ans, sep="\n")
| p02235 |
"""
problem statment url: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_10_C
"""
def lcs():
s1 = input()
s2 = input()
la, lb = len(s1), len(s2)
dp1 = [0 for _ in range(lb + 1)]
for i in range(la):
dp2 = dp1 + []
for j in range(lb):
if s1[i] == s2[j]:
dp1[j + 1] = dp2[j] + 1
else:
dp1[j + 1] = dp1[j] if dp1[j] > dp2[j + 1] else dp2[j + 1]
return dp1[-1]
tc = int(input())
for _ in range(tc):
print((lcs())) | """
problem statment url: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_10_C
"""
def lcs():
s1 = input()
s2 = input()
la, lb = len(s1), len(s2)
dp1 = [0 for _ in range(lb + 1)]
for i in range(la):
dp2 = dp1 + []
for j in range(lb):
if s1[i] == s2[j]:
dp1[j + 1] = dp2[j] + 1
elif dp1[j + 1] < dp1[j]:
dp1[j + 1] = dp1[j]
return dp1[-1]
if __name__ == '__main__':
tc = int(input())
for _ in range(tc):
print((lcs())) | p02235 |
def lcs(X, Y):
m = len(X) + 1
n = len(Y) + 1
c = [[0] * n for _ in range(m)]
X = ' ' + X
Y = ' ' + Y
maxl = 0
for i in range(1,m):
for j in range(1,n):
if X[i] == Y[j]:
c[i][j] = c[i-1][j-1] + 1
#elif c[i-1][j] >= c[i][j-1]:
# c[i][j] = c[i-1][j]
else:
c[i][j] = max(c[i][j-1],c[i-1][j])
maxl = max(maxl, c[i][j])
print(maxl)
return 0
def main():
q = int(input())
for i in range(q):
X = input()
Y = input()
lcs(X,Y)
return 0
main() | def lcs(x,y):
a, b = len(x), len(y)
x1 = [0 for k in range(b+1)]
for i in range(a):
e = x[i]
x2 = x1+[]
for j in range(b):
if e == y[j]:
x1[j+1] = x2[j] + 1
elif x1[j+1] < x1[j]:
x1[j+1] = x1[j]
print(max(x1))
return 0
def main():
q = int(input())
for i in range(q):
X = input()
Y = input()
lcs(X,Y)
return 0
main() | p02235 |
import sys
readline = sys.stdin.readline
from collections import defaultdict
from bisect import bisect_left, bisect, insort_left, insort
INF = 10000
def lcs(s1, s2):
c = defaultdict(list)
for i, s in enumerate(s1):
c[s].append(i)
for s in set(s2):
c[s].append(INF)
dp = []
for s2_k in s2:
bgn_idx = 0
for i, cur_idx in enumerate(dp):
chr_idx = c[s2_k][bisect_left(c[s2_k], bgn_idx)]
if chr_idx == INF:
break
dp[i] = min(cur_idx, chr_idx + 1)
bgn_idx = cur_idx
else:
chr_idx = c[s2_k][bisect_left(c[s2_k], bgn_idx)]
if chr_idx != INF:
dp.append(chr_idx + 1)
return len(dp)
def solve():
N = int(eval(input()))
for _ in range(N):
x = readline().strip()
y = readline().strip()
print((lcs(x, y) if len(x) > len(y) else lcs(y, x)))
solve()
| import sys
readline = sys.stdin.readline
for _ in range(int(eval(input()))):
a = readline().strip()
b = readline().strip()
indices = []
for cb in b:
bgn_idx = 0
for i, cur_idx in enumerate(indices):
chr_idx = a.find(cb, bgn_idx) + 1
if not chr_idx:
break
if chr_idx < cur_idx:
indices[i] = chr_idx
bgn_idx = cur_idx
else:
chr_idx = a.find(cb, bgn_idx) + 1
if chr_idx:
indices.append(chr_idx)
print((len(indices)))
| p02235 |
# coding: utf-8
def array2d(d1, d2, init = None):
return [[init for _ in range(d2)] for _ in range(d1)]
def solve():
x = input().strip()
y = input().strip()
# dp[i][j]: x[:i], y[:j] ???LCS
# dp[i][j] = max(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]+1(if x[i]==y[j]))
dp = array2d(len(x), len(y), 0)
for i in range(len(x)):
for j in range(len(y)):
if i == 0 and j == 0:
dp[0][0] = int(x[0] == y[0])
continue
if i > 0:
dp[i][j] = max(dp[i][j], dp[i-1][j])
if j > 0:
dp[i][j] = max(dp[i][j], dp[i][j-1])
if i > 0 and j > 0:
cand = dp[i-1][j-1]
else:
cand = 0
dp[i][j] = max(dp[i][j], cand + (x[i] == y[j]))
return dp[-1][-1]
def main():
cases = int(eval(input()))
for i in range(cases):
print((solve()))
main() | # coding: utf-8
def array2d(d1, d2, init = None):
return [[init for _ in range(d2)] for _ in range(d1)]
def solve():
x = input().strip()
y = input().strip()
# dp[i][j]: x[:i], y[:j] ???LCS
# dp[i][j] = max(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]+1(if x[i]==y[j]))
dp = array2d(len(x), len(y), 0)
dp[0][0] = int(x[0] == y[0])
for j in range(1, len(y)):
dp[0][j] = max(dp[0][j-1], int(x[0] == y[j]))
for i in range(1, len(x)):
dp[i][0] = max(dp[i-1][0], int(x[i] == y[0]))
for j in range(1, len(y)):
dp[i][j] = max(dp[i-1][j], dp[i][j-1])
if x[i] == y[j]:
dp[i][j] = max(dp[i][j], dp[i-1][j-1] + 1)
return dp[-1][-1]
def main():
cases = int(eval(input()))
for i in range(cases):
print((solve()))
main() | p02235 |
import sys
def findLCS(X, Y):
C = [[0 for i in range(1001)] for j in range(1001)]
X, Y = " " + X, " " + Y
m, n, maxl = len(X), len(Y), 0
for i in range(1, m):
for j in range(1, n):
if X[i] == Y[j]:
C[i][j] = C[i - 1][j - 1] + 1
else:
C[i][j] = max(C[i - 1][j], C[i][j - 1])
maxl = max(maxl, C[i][j])
return maxl
lines = sys.stdin.readlines()
N = int(lines[0])
for i in range(N):
X = lines[2 * i + 1].strip()
Y = lines[2 * i + 2].strip()
print(findLCS(X, Y)) | import sys
def findLCS(X, Y):
m, n = len(X), len(Y)
C = [0] * (n + 1)
for i in range(m):
tmp = C[:]
for j in range(n):
if X[i] == Y[j]:
C[j + 1] = tmp[j] + 1
elif C[j + 1] < C[j]:
C[j + 1] = C[j]
return C[-1]
lines = sys.stdin.readlines()
N = int(lines[0])
for i in range(N):
X = lines[2 * i + 1].strip()
Y = lines[2 * i + 2].strip()
print(findLCS(X, Y)) | p02235 |
def LCS():
x = input()
y = input()
i = len(x)
j = len(y)
dsp = [[0 for col in range(j+1)] for row in range(i+1)]
for i in range(1,i+1):
for j in range(1,j+1):
if x[i-1] == y[j-1]:
dsp[i][j] = dsp[i-1][j-1]+1
else:
dsp[i][j] = max(dsp[i-1][j],dsp[i][j-1])
return dsp[i][j]
q = eval(input())
for i in range(q):
print(LCS()) | def LCS():
x = input()
y = input()
i, j = len(x), len(y)
dsp = [[0 for col in range(j+1)] for row in range(i+1)]
for i in range(1,i+1):
for j in range(1,j+1):
if x[i-1] == y[j-1]:
dsp[i][j] = dsp[i-1][j-1]+1
else:
dsp[i][j] = max(dsp[i-1][j],dsp[i][j-1])
print(dsp[i][j])
q = eval(input())
for i in range(q):
LCS() | p02235 |
def LCS():
x = input()
y = input()
i, j = len(x), len(y)
dsp = [[0 for col in range(j+1)] for row in range(i+1)]
for i in range(1,i+1):
for j in range(1,j+1):
if x[i-1] == y[j-1]:
dsp[i][j] = dsp[i-1][j-1]+1
else:
dsp[i][j] = max(dsp[i-1][j],dsp[i][j-1])
print(dsp[-1][-1])
q = eval(input())
for i in range(q):
LCS() | def LCS():
x = input()
y = input()
a, b = len(x), len(y)
dsp1 = [0 for i in range(b+1)]
for i in range(a):
dsp2 = dsp1+[]
for j in range(b):
if x[i] == y[j]:
dsp1[j+1] = dsp2[j] + 1
elif dsp1[j+1] < dsp1[j]:
dsp1[j+1] = dsp1[j]
print(max(dsp1))
n = eval(input())
for a in range(n):
LCS() | p02235 |
def lcs(x,y):
x = " " + x
y = " " + y
c = [[0 for i in range(len(x))] for j in range(len(y))]
for i in range (1,len(y)):
for j in range (1,len(x)):
if x[j] == y[i]:
a = 1
else:
a = 0
c[i][j] = max(c[i][j-1],c[i-1][j],c[i-1][j-1] + a)
return max(max(c))
n = eval(input())
for i in range (n):
x = input()
y = input()
print(lcs(x,y)) | def lcs(x,y):
x = " " + x
y = " " + y
c = [[0 for i in range(len(x))] for j in range(len(y))]
for i in range (1,len(y)):
for j in range (1,len(x)):
if x[j] == y[i]:
c[i][j] = c[i-1][j-1] + 1
else:
c[i][j] = max(c[i][j-1],c[i-1][j])
return max(max(c))
n = eval(input())
for i in range (n):
x = input()
y = input()
print(lcs(x,y)) | p02235 |
def lcs(x,y):
x = " " + x
y = " " + y
c = [[0 for i in range(len(x))] for j in range(len(y))]
for i in range (1,len(y)):
for j in range (1,len(x)):
if x[j] == y[i]:
c[i][j] = c[i-1][j-1] + 1
else:
c[i][j] = max(c[i][j-1],c[i-1][j])
return max(max(c))
n = eval(input())
for i in range (n):
x = input()
y = input()
print(lcs(x,y)) | def lcs(x,y):
x = " " + x
y = " " + y
c = [[0 for i in range(len(x))] for j in range(len(y))]
for i in range (1,len(y)):
for j in range (1,len(x)):
if x[j] == y[i]:
c[i][j] = c[i-1][j-1] + 1
elif c[i-1][j] >= c[i][j-1]:
c[i][j] = c[i-1][j]
else:
c[i][j] = c[i][j-1]
return max(max(c))
n = eval(input())
for i in range (n):
x = input()
y = input()
print(lcs(x,y)) | p02235 |
n = eval(input())
for i in range (n):
x = input()
y = input()
x = " " + x
y = " " + y
c = [[0 for i in range(len(x))] for j in range(len(y))]
for i in range (1,len(y)):
for j in range (1,len(x)):
if x[j] == y[i]:
c[i][j] = c[i-1][j-1] + 1
elif c[i-1][j] >= c[i][j-1]:
c[i][j] = c[i-1][j]
else:
c[i][j] = c[i][j-1]
print(max(max(c))) | def lcs(x,y):
x = " " + x
y = " " + y
c = [[0 for i in range(len(x))] for j in range(len(y))]
for i in range (1,len(y)):
for j in range (1,len(x)):
if x[j] == y[i]:
c[i][j] = c[i-1][j-1] + 1
elif c[i-1][j] >= c[i][j-1]:
c[i][j] = c[i-1][j]
else:
c[i][j] = c[i][j-1]
return max(max(c))
n = eval(input())
for i in range (n):
x = input()
y = input()
print(lcs(x,y)) | p02235 |
def lcs(x,y):
x = " " + x
y = " " + y
c = [[0 for i in range(len(x))] for j in range(len(y))]
for i in range (1,len(y)):
for j in range (1,len(x)):
if x[j] == y[i]:
c[i][j] = c[i-1][j-1] + 1
elif c[i-1][j] >= c[i][j-1]:
c[i][j] = c[i-1][j]
else:
c[i][j] = c[i][j-1]
return max(max(c))
n = eval(input())
for i in range (n):
x = input()
y = input()
print(lcs(x,y)) | def solve():
x = input()
y = input()
a, b = len(x), len(y)
x1 = [0 for k in range(b+1)]
for i in range(a):
e1 = x[i]
x2 = x1+[]
for j in range(b):
if e1 == y[j]:
x1[j+1] = x2[j] + 1
elif x1[j+1] < x1[j]:
x1[j+1] = x1[j]
return x1[-1]
n = eval(input())
for i2 in range(n):
print(solve()) | p02235 |
def lcs():
x, y = input(), input()
x1 = [0 for k in range(len(y)+1)]
for i in range(len(x)):
e = x[i]
x2 = x1 + []
for j in range(len(y)):
if e == y[j]:
x1[j+1] = x2[j] + 1
elif x1[j+1] < x1[j]:
x1[j+1] = x1[j]
print(max(x1))
n = eval(input())
for i in range(n):
lcs() | def lcs():
x, y = input(), input()
b1 = [0 for k in range(len(y)+1)]
for i in range(len(x)):
a = x[i]
b2 = b1 + []
for j in range(len(y)):
if a == y[j]:
b1[j+1] = b2[j] + 1
elif b1[j+1] < b1[j]:
b1[j+1] = b1[j]
print(max(b1))
n = eval(input())
for i in range(n):
lcs() | p02235 |
# -*- coding: utf-8 -*-
def lcs(x, y):
dp = {(0, 0): 0}
for i in range(1, len(x) + 1):
dp[(i, 0)] = 0
for j in range(1, len(y) + 1):
dp[(0, j)] = 0
for i in range(1, len(x) + 1):
for j in range(1, len(y) + 1):
if x[i - 1] == y[j - 1]:
dp[(i, j)] = dp[(i - 1, j - 1)] + 1
else:
dp[(i, j)] = max(dp[(i - 1, j)], dp[(i, j - 1)])
return dp[(len(x), len(y))]
def lcs_sol(x, y):
n = len(x)
m = len(y)
dp = [[0 for j in range(m + 1)] for i in range(n + 1)]
for i in range(1, n + 1):
for j in range(1, m + 1):
if x[i - 1] == y[j - 1]:
dp[i][j] = dp[i - 1][j - 1] + 1
else:
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
return dp[n][m]
if __name__ == '__main__':
import sys
q = int(sys.stdin.readline().strip())
for i in range(q):
x = sys.stdin.readline().strip()
y = sys.stdin.readline().strip()
print((lcs_sol(x, y)))
| # -*- coding: utf-8 -*-
def lcs_sol(x, y):
n = len(x)
m = len(y)
dp = [0 for j in range(m + 1)]
for i in range(1, n + 1):
dp_prev = dp[:]
for j in range(1, m + 1):
if x[i - 1] == y[j - 1]:
dp[j] = dp_prev[j - 1] + 1
else:
dp[j] = max(dp_prev[j], dp[j - 1])
return dp[m]
if __name__ == '__main__':
import sys
q = int(sys.stdin.readline().strip())
for i in range(q):
x = sys.stdin.readline().strip()
y = sys.stdin.readline().strip()
print((lcs_sol(x, y)))
| p02235 |
# -*- coding: utf-8 -*-
def lcs_sol(x, y):
n = len(x)
m = len(y)
dp = [0 for j in range(m + 1)]
for i in range(1, n + 1):
dp_prev = dp[:]
for j in range(1, m + 1):
if x[i - 1] == y[j - 1]:
dp[j] = dp_prev[j - 1] + 1
elif dp_prev[j] < dp[j - 1]:
dp[j] = dp[j - 1]
else:
dp[j] = dp_prev[j]
return dp[m]
if __name__ == '__main__':
import sys
q = int(sys.stdin.readline().strip())
for i in range(q):
x = sys.stdin.readline().strip()
y = sys.stdin.readline().strip()
print((lcs_sol(x, y)))
| # -*- coding: utf-8 -*-
def lcs_sol(x, y):
n = len(x)
m = len(y)
dp = [0 for j in range(m + 1)]
for i in range(1, n + 1):
dp_prev = dp[:]
for j in range(1, m + 1):
if x[i - 1] == y[j - 1]:
dp[j] = dp_prev[j - 1] + 1
elif dp_prev[j] < dp[j - 1]:
dp[j] = dp[j - 1]
return dp[m]
if __name__ == '__main__':
import sys
q = int(sys.stdin.readline().strip())
for i in range(q):
x = sys.stdin.readline().strip()
y = sys.stdin.readline().strip()
print((lcs_sol(x, y)))
| p02235 |
# -*- coding: utf-8 -*-
def lcs_sol(x, y):
n = len(x)
m = len(y)
dp = [0 for j in range(m + 1)]
for i in range(1, n + 1):
dp_prev = dp[:]
for j in range(1, m + 1):
if x[i - 1] == y[j - 1]:
dp[j] = dp_prev[j - 1] + 1
elif dp_prev[j] < dp[j - 1]:
dp[j] = dp[j - 1]
return dp[m]
if __name__ == '__main__':
import sys
q = int(sys.stdin.readline().strip())
for i in range(q):
x = sys.stdin.readline().strip()
y = sys.stdin.readline().strip()
print((lcs_sol(x, y)))
| # -*- coding: utf-8 -*-
def lcs_sol(x, y):
n = len(x)
m = len(y)
dp = [0 for j in range(m + 1)]
for i in range(1, n + 1):
dp_prev = dp[:]
for j in range(1, m + 1):
if x[i - 1] == y[j - 1]:
dp[j] = dp_prev[j - 1] + 1
elif dp_prev[j] < dp[j - 1]:
dp[j] = dp[j - 1]
return dp[m]
# if __name__ == '__main__':
import sys
q = int(sys.stdin.readline().strip())
for i in range(q):
x = sys.stdin.readline().strip()
y = sys.stdin.readline().strip()
print((lcs_sol(x, y)))
| p02235 |
import sys
q = int(sys.stdin.readline().strip())
for _ in range(q):
x = sys.stdin.readline().strip()
y = sys.stdin.readline().strip()
n = len(x)
m = len(y)
dp = [0 for j in range(m + 1)]
for i in range(1, n + 1):
dp_prev = dp[:]
for j in range(1, m + 1):
if x[i - 1] == y[j - 1]:
dp[j] = dp_prev[j - 1] + 1
elif dp_prev[j] < dp[j - 1]:
dp[j] = dp[j - 1]
print((dp[m]))
| # -*- coding: utf-8 -*-
def lcs(x, y):
n = len(x)
m = len(y)
dp = [0 for j in range(m + 1)]
for i in range(1, n + 1):
dp_prev = dp[:]
for j in range(1, m + 1):
if x[i - 1] == y[j - 1]:
dp[j] = dp_prev[j - 1] + 1
elif dp_prev[j] < dp[j - 1]:
dp[j] = dp[j - 1]
else:
dp[j] = dp_prev[j]
return dp[m]
if __name__ == '__main__':
import sys
q = int(sys.stdin.readline().strip())
for i in range(q):
x = sys.stdin.readline().strip()
y = sys.stdin.readline().strip()
print((lcs(x, y)))
| p02235 |
# -*- coding: utf-8 -*-
def lcs(x, y):
n = len(x)
m = len(y)
dp = [0 for j in range(m + 1)]
for i in range(1, n + 1):
dp_prev = dp[:]
for j in range(1, m + 1):
if x[i - 1] == y[j - 1]:
dp[j] = dp_prev[j - 1] + 1
elif dp_prev[j] < dp[j - 1]:
dp[j] = dp[j - 1]
else:
dp[j] = dp_prev[j]
return dp[m]
if __name__ == '__main__':
import sys
q = int(sys.stdin.readline().strip())
for i in range(q):
x = sys.stdin.readline().strip()
y = sys.stdin.readline().strip()
print((lcs(x, y)))
| def m():
e=input
a=''
for _ in[0]*int(e()):
X,z=e(),[]
for y in e():
s=i=0
for k in z:
t=X.find(y,s)+1
if t<1:break
if t<k:z[i]=t
s=k;i+=1
else:
t=X.find(y,s)+1
if t:z+=[t]
a+=f'\n{len(z)}'
print((a[1:]))
if'__main__'==__name__:m()
| p02235 |
def lcs(s, t):
dp = {}
slen = len(s)
tlen = len(t)
for i in range(slen + 1):
dp[i] = {0: 0}
for j in range(tlen + 1):
dp[0][j] = 0
for i in range(1, slen + 1):
for j in range(1, tlen + 1):
if s[i-1] == t[j-1]:
dp[i][j] = dp[i-1][j-1] + 1
else:
dp[i][j] = max(dp[i][j-1], dp[i-1][j])
return dp[slen][tlen]
n = int(input())
for i in range(n):
x = input()
y = input()
print(lcs(x, y)) | def lcs(s, t):
slen = len(s)
tlen = len(t)
dp = [None] * (slen + 1)
for i in range(slen + 1):
dp[i] = [0] * (tlen + 1)
for i in range(1, slen + 1):
for j in range(1, tlen + 1):
if s[i-1] == t[j-1]:
dp[i][j] = dp[i-1][j-1] + 1
else:
dp[i][j] = max(dp[i][j-1], dp[i-1][j])
return dp[slen][tlen]
n = int(input())
for i in range(n):
x = input()
y = input()
print(lcs(x, y)) | p02235 |
DP_MAX = 1000
dp = [0] * (DP_MAX + 1)
for i in range(DP_MAX + 1):
dp[i] = [0] * (DP_MAX + 1)
def lcs(s, t):
slen = len(s)
tlen = len(t)
dp_i = dp[0]
for i in range(1, slen + 1):
dp_i_1 = dp_i
dp_i = dp[i]
for j in range(1, tlen + 1):
if s[i-1] == t[j-1]:
dp_i[j] = dp_i_1[j-1] + 1
else:
dp_i[j] = max(dp_i[j-1], dp_i_1[j])
return dp[slen][tlen]
n = int(input())
for i in range(n):
x = input()
y = input()
print((lcs(x, y))) | def lcs(s, t):
slen = len(s)
tlen = len(t)
dp = [0] * (slen + 1)
dp[0] = [0] * (tlen + 1)
for i in range(1, slen + 1):
dp_prev = dp[i-1]
dp_cur = [0] * (tlen + 1)
c = s[i-1]
for j in range(1, tlen + 1):
if c == t[j-1]:
dp_cur[j] = dp_prev[j-1] + 1
else:
dp_cur[j] = max(dp_cur[j-1], dp_prev[j])
dp[i] = dp_cur
return dp[slen][tlen]
n = int(input())
for i in range(n):
x = input()
y = input()
print((lcs(x, y))) | p02235 |
#!/usr/bin/env python
from sys import stdin
def main():
n = int(stdin.readline())
for _ in range(n):
x = stdin.readline().rstrip()
y = stdin.readline().rstrip()
m = len(x)
n = len(y)
#assert 1 <= m <= 1000
#assert 1 <= n <= 1000
c = [[0]*(n+1) for _ in range(m+1)]
for i in range(1, m+1):
for j in range(1, n+1):
if x[i-1] == y[j-1]:
c[i][j] = c[i-1][j-1] + 1
elif c[i-1][j] >= c[i][j-1]:
c[i][j] = c[i-1][j]
else:
c[i][j] = c[i][j-1]
print(c[-1][-1])
main() | #!/usr/bin/env python
from sys import stdin
def main():
n = int(stdin.readline())
for _ in range(n):
x = stdin.readline().rstrip()
y = stdin.readline().rstrip()
m = len(x)
n = len(y)
c = [[0]*(n+1) for _ in range(m+1)]
cim1 = c[0]
for i, xi in enumerate(x, start=1):
ci = c[i]
for j, yj in enumerate(y, start=1):
if xi == yj:
ci[j] = cim1[j-1] + 1
elif cim1[j] >= ci[j-1]:
ci[j] = cim1[j]
else:
ci[j] = ci[j-1]
cim1 = ci
print(c[-1][-1])
main() | p02235 |
#!/usr/bin/env python
from sys import stdin
def main():
num = int(stdin.readline())
c = [list(range(1001)) for _ in range(1001)]
for _ in range(num):
x = stdin.readline().rstrip()
y = stdin.readline().rstrip()
m = len(x)
n = len(y)
for i in range(m+1):
row = c[i]
for j in range(n+1):
row[j] = 0
cim1 = c[0]
for i, xi in enumerate(x, start=1):
ci = c[i]
for j, yj in enumerate(y, start=1):
if xi == yj:
ci[j] = cim1[j-1] + 1
elif cim1[j] >= ci[j-1]:
ci[j] = cim1[j]
else:
ci[j] = ci[j-1]
cim1 = ci
print(ci[j])
main() | #!/usr/bin/env python
from sys import stdin
def main():
num = int(stdin.readline())
for _ in range(num):
x = stdin.readline().rstrip()
y = stdin.readline().rstrip()
n = len(y) + 1
cim1 = [0] * n
for i, xi in enumerate(x, start=1):
ci = [0] * n
for j, yj in enumerate(y, start=1):
if xi == yj:
ci[j] = cim1[j-1] + 1
elif cim1[j] >= ci[j-1]:
ci[j] = cim1[j]
else:
ci[j] = ci[j-1]
cim1 = ci
print(ci[j])
main() | p02235 |
def main():
n = eval(input())
for i in range(n):
X = input()
Y = input()
print(lcs(X,Y))
def lcs(X,Y):
m = len(X)
n = len(Y)
c = [[0] for i in range(m+1)]
c[0] += [0]*n
for i in range(m):
for j in range(n):
if X[i] == Y[j]:
c[i+1].append(c[i][j] + 1)
else:
if c[i][j+1] >= c[i+1][j]:
c[i+1].append(c[i][j+1])
else:
c[i+1].append(c[i+1][j])
return c[m][n]
if __name__ == "__main__":
main() | def main():
n = eval(input())
for i in range(n):
X = input()
Y = input()
print(lcs(X,Y))
def lcs(X,Y):
m = len(X)
n = len(Y)
r1 = [0 for i in range(n+1)]
for i in range(m):
r0 = r1[:]
for j in range(n):
if X[i] == Y[j]:
r1[j+1] = r0[j] + 1
elif r0[j+1] < r1[j]:
r1[j+1] = r1[j]
return r1[-1]
if __name__ == "__main__":
main() | p02235 |
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_10_C
????????±?????¨??????
"""
import sys
from sys import stdin
input = stdin.readline
C = []
def calc_lcs4(X, Y):
global C
X = ' ' + X
Y = ' ' + Y
m = len(X)
n = len(Y)
C = [[0]*(n+1) for _ in range(m+1)] # ???????????§??¨???
max_lcs = 0
pre_row = C[0]
for i in range(1, m):
row = C[i]
XX = X[i]
for j, YY in enumerate(Y):
if XX == YY:
pr_j1 = pre_row[j - 1]
row[j] = pr_j1 + 1
if pr_j1+1 > max_lcs:
max_lcs = pr_j1 + 1
else:
pr_j = pre_row[j]
r_j1 = row[j-1]
row[j] = max(pr_j, r_j1)
# if pr_j >= r_j1:
# row[j] = pr_j
# else:
# row[j] = r_j1
pre_row = row
print(max_lcs)
if __name__ == '__main__':
num = int(eval(input()))
for _ in range(num):
X = input().strip()
Y = input().strip()
result = calc_lcs4(X, Y) | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_10_C
????????±?????¨??????
"""
import sys
from sys import stdin
input = stdin.readline
C = []
def calc_lcs4(X, Y):
global C
X = ' ' + X
Y = ' ' + Y
m = len(X)
n = len(Y)
C = [[0]*(n+1) for _ in range(m+1)] # ???????????§??¨???
max_lcs = 0
pre_row = C[0]
for i in range(1, m):
row = C[i]
XX = X[i]
for j, YY in enumerate(Y):
if XX == YY:
pr_j1 = pre_row[j - 1]
row[j] = pr_j1 + 1
if pr_j1+1 > max_lcs:
max_lcs = pr_j1 + 1
else:
pr_j = pre_row[j]
r_j1 = row[j-1]
if pr_j >= r_j1:
row[j] = pr_j
else:
row[j] = r_j1
pre_row = row
print(max_lcs)
if __name__ == '__main__':
num = int(eval(input()))
for _ in range(num):
X = input().strip()
Y = input().strip()
result = calc_lcs4(X, Y) | p02235 |
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_10_C
????????±?????¨??????
"""
import sys
from sys import stdin
input = stdin.readline
C = []
def calc_lcs4(X, Y):
global C
X = ' ' + X
Y = ' ' + Y
m = len(X)
n = len(Y)
C = [[0]*(n+1) for _ in range(m+1)] # ???????????§??¨???
max_lcs = 0
pre_row = C[0]
for i in range(1, m):
row = C[i]
XX = X[i]
for j, YY in enumerate(Y):
if XX == YY:
pr_j1 = pre_row[j - 1]
row[j] = pr_j1 + 1
if pr_j1+1 > max_lcs:
max_lcs = pr_j1 + 1
else:
pr_j = pre_row[j]
r_j1 = row[j-1]
if pr_j >= r_j1:
row[j] = pr_j
else:
row[j] = r_j1
pre_row = row
print(max_lcs)
if __name__ == '__main__':
num = int(eval(input()))
for _ in range(num):
X = input().strip()
Y = input().strip()
result = calc_lcs4(X, Y) | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_10_C
????????±?????¨??????
"""
import sys
from sys import stdin
input = stdin.readline
def calc_lcs4(X, Y):
X = ' ' + X
Y = ' ' + Y
m = len(X)
n = len(Y)
C = [[0]*(n+1) for _ in range(m+1)] # ???????????§??¨???
max_lcs = 0
pre_row = C[0]
for i in range(1, m):
row = C[i]
XX = X[i]
for j, YY in enumerate(Y):
if XX == YY:
pr_j1 = pre_row[j - 1]
row[j] = pr_j1 + 1
if pr_j1+1 > max_lcs:
max_lcs = pr_j1 + 1
else:
pr_j = pre_row[j]
r_j1 = row[j-1]
if pr_j >= r_j1:
row[j] = pr_j
else:
row[j] = r_j1
pre_row = row
print(max_lcs)
if __name__ == '__main__':
num = int(eval(input()))
for _ in range(num):
X = input().strip()
Y = input().strip()
result = calc_lcs4(X, Y) | p02235 |
q = int(input())
lcs = {}
for i in range(1010):
lcs[i] = {}
for j in range(1010):
lcs[i][j] = 0
for i in range(q):
X = input()
Y = input()
for i in range(len(X)):
for j in range(len(Y)):
if X[i] == Y[j]:
lcs[i+1][j+1] = lcs[i][j] + 1
else:
lcs[i+1][j+1] = max(lcs[i][j+1],lcs[i+1][j])
print(lcs[len(X)][len(Y)]) | q = int(input())
lcs = [[0 for j in range(1010)] for i in range(1010)]
for i in range(q):
X = input()
Y = input()
for i in range(len(X)):
for j in range(len(Y)):
if X[i] == Y[j]:
lcs[i+1][j+1] = lcs[i][j] + 1
elif lcs[i][j+1] > lcs[i+1][j]:
lcs[i+1][j+1] = lcs[i][j+1]
else:
lcs[i+1][j+1] = lcs[i+1][j]
print(lcs[len(X)][len(Y)]) | p02235 |
q = int(input())
lcs = [[0 for j in range(1010)] for i in range(1010)]
for i in range(q):
X = input()
Y = input()
for i in range(len(X)):
for j in range(len(Y)):
if X[i] == Y[j]:
lcs[i+1][j+1] = lcs[i][j] + 1
elif lcs[i][j+1] > lcs[i+1][j]:
lcs[i+1][j+1] = lcs[i][j+1]
else:
lcs[i+1][j+1] = lcs[i+1][j]
print(lcs[len(X)][len(Y)]) | q = int(input())
for i in range(q):
X = input()
Y = input()
lcs1 = [0 for i in range(len(Y)+1)]
for i in range(len(X)):
lcs2 = lcs1+[]
for j in range(len(Y)):
if X[i] == Y[j]:
lcs2[j+1] = lcs1[j] + 1
elif lcs1[j+1] > lcs2[j]:
lcs2[j+1] = lcs1[j+1]
else:
lcs2[j+1] = lcs2[j]
lcs1 = lcs2
print(lcs2[-1]) | p02235 |
ans = {}
roop = eval(input())
for k in range(roop):
str1 = input()
str2 = input()
len1 = len(str1)
len2 = len(str2)
for i in range (-1, len1):
for j in range(-1, len2):
if(i == -1 or j == -1):
ans[i, j] = 0
else:
if(str1[i] == str2[j]):
ans[i, j] = ans[i - 1, j - 1] + 1
else:
ans[i, j] = max(ans[i - 1, j], ans[i, j - 1])
print(ans[len(str1) - 1, len(str2) - 1]) | roop = eval(input())
for k in range(roop):
str1 = input()
str2 = input()
len1 = len(str1) + 1
len2 = len(str2) + 1
ans = [None] * (len1)
for i in range(len1):
ans[i] = [None] * (len2)
for i in range(len1):
ans[i][0] = 0
for j in range(len2):
ans[0][j] = 0
for i in range (1, len1):
for j in range(1, len2):
if(str1[i - 1] == str2[j - 1]):
ans[i][j] = ans[i -1][j - 1] + 1
else:
ans[i][j] = max(ans[i - 1][j], ans[i][j - 1])
print(ans[len1 - 1][len2 - 1]) | p02235 |
ans = [None] * 1001
for i in range(1001):
ans[i] = [None] * 1001
for i in range(1001):
ans[i][0] = 0
for j in range(1001):
ans[0][j] = 0
roop = eval(input())
for k in range(roop):
str1 = input()
str2 = input()
len1 = len(str1) + 1
len2 = len(str2) + 1
for i in range (1, len1):
for j in range(1, len2):
if(str1[i - 1] == str2[j - 1]):
ans[i][j] = ans[i -1][j - 1] + 1
else:
ans[i][j] = max(ans[i - 1][j], ans[i][j - 1])
print(ans[len1 - 1][len2 - 1]) | n = eval(input())
for k in range(n):
str1 = input()
str2 = input()
after = [0] * (len(str2) + 1)
for i in range(1, len(str1) + 1):
before = after + []
for j in range(1, len(str2) + 1):
if str1[i - 1] == str2[j - 1]:
after[j] = before[j - 1] + 1
else:
after[j] = max(before[j], after[j - 1])
print(after[j]) | p02235 |
n = eval(input())
for k in range(n):
str1 = input()
str2 = input()
after = [0] * (len(str2) + 1)
for i in range(1, len(str1) + 1):
before = after + []
for j in range(1, len(str2) + 1):
if str1[i - 1] == str2[j - 1]:
after[j] = before[j - 1] + 1
else:
after[j] = max(before[j], after[j - 1])
print(after[j]) | n = eval(input())
for k in range(n):
str1 = input()
str2 = input()
after = [0] * (len(str2) + 1)
for i in range(1, len(str1) + 1):
before = after + []
for j in range(1, len(str2) + 1):
if str1[i - 1] == str2[j - 1]:
after[j] = before[j - 1] + 1
elif after[j - 1] > before[j]:
after[j] = after[j - 1]
print(after[j]) | p02235 |
import sys
def lcs(X, Y):
c = [0 for _ in range(len(Y) + 1)]
for i in X:
tmp = c[:]
for ji, yc in enumerate(Y):
j = ji + 1
if i == yc:
c[j] = tmp[j - 1] + 1
else:
c[j] = max(tmp[j], c[j - 1])
return c[-1]
n = int(eval(input()))
for i in range(n):
X = sys.stdin.readline()[:-1]
Y = sys.stdin.readline()[:-1]
print((lcs(X, Y))) | import sys
def lcs(X, Y):
c = [0 for _ in range(len(Y) + 1)]
for i in X:
tmp = c[:]
for ji, yc in enumerate(Y):
j = ji + 1
if i == yc:
c[j] = tmp[j - 1] + 1
elif c[j] < c[j - 1]:
c[j] = c[j - 1]
return c[-1]
n = int(eval(input()))
for i in range(n):
X = sys.stdin.readline()[:-1]
Y = sys.stdin.readline()[:-1]
print((lcs(X, Y))) | p02235 |
import sys
n = eval(input())
for i2 in range(n):
seq1 = input()
seq2 = input()
a,b = len(seq1)+1, len(seq2)+1
length = [[0 for i in range(b)] for j in range(a)]
for i in range(a):
for j in range(b):
if i==0 or j==0:
length[i][j]=0
else:
if seq1[i-1] == seq2[j-1]:
length[i][j] = length[i-1][j-1] + 1
else:
length[i][j] = max(length[i-1][j], length[i][j-1])
print(length[a-1][b-1]) | import sys
def longestcommonsubsequence(seq1, seq2):
a,b = len(seq1)+1, len(seq2)+1
length = [[0 for i in range(b)] for j in range(a)]
for i in range(a):
for j in range(b):
if i==0 or j==0:
pass
length[i][j]=0
else:
if seq1[i-1] == seq2[j-1]:
length[i][j] = length[i-1][j-1] + 1
else:
length[i][j] = max(length[i-1][j], length[i][j-1])
return length[a-1][b-1]
n = eval(input())
for i2 in range(n):
seq1 = input()
seq2 = input()
print(longestcommonsubsequence(seq1, seq2)) | p02235 |
import sys
def longestcommonsubsequence(seq1, seq2):
a,b = len(seq1), len(seq2)
length = [[0 for i in range(b+1)] for j in range(a+1)]
for i in range(a):
e1 = seq1[i]
tmp = length[i]
x = [0 for i2 in range(b+1)]
for j in range(b):
if e1 == seq2[j]:
x[j+1]=tmp[j] + 1
else:
x[j+1]=max(tmp[j+1], x[j])
length[i+1]=x
return length[a][b]
n = eval(input())
for i2 in range(n):
seq1 = input()
seq2 = input()
print(longestcommonsubsequence(seq1, seq2)) | import sys
def longestcommonsubsequence(seq1, seq2):
a,b = len(seq1), len(seq2)
x1 = [0 for i in range(b+1)]
for i in range(a):
e1 = seq1[i]
x2 = x1
x1 = [0]
for j in range(b):
if e1 == seq2[j]:
x1.append(x2[j] + 1)
else:
x1.append(max(x2[j+1], x1[j]))
return x1[-1]
n = eval(input())
for i2 in range(n):
seq1 = input()
seq2 = input()
print(longestcommonsubsequence(seq1, seq2)) | p02235 |
import sys
def longestcommonsubsequence(seq1, seq2):
a,b = len(seq1), len(seq2)
x1 = [0 for i in range(b+1)]
for i in range(a):
e1 = seq1[i]
x2 = x1
x1 = [0]
for j in range(b):
if e1 == seq2[j]:
x1.append(x2[j] + 1)
else:
x1.append(max(x2[j+1], x1[j]))
return x1[-1]
n = eval(input())
for i2 in range(n):
seq1 = input()
seq2 = input()
print(longestcommonsubsequence(seq1, seq2)) | import sys
def longestcommonsubsequence(seq1, seq2):
a,b = len(seq1), len(seq2)
x1 = [0 for i in range(b+1)]
for i in range(a):
e1 = seq1[i]
x2 = x1
x1 = [0 for i in range(b+1)]
for j in range(b):
if e1 == seq2[j]:
x1[j+1]=x2[j] + 1
else:
x1[j+1]=max(x2[j+1], x1[j])
return x1[-1]
n = eval(input())
for i2 in range(n):
seq1 = input()
seq2 = input()
print(longestcommonsubsequence(seq1, seq2)) | p02235 |
import sys
n = eval(input())
for i2 in range(n):
seq1 = input()
seq2 = input()
a,b = len(seq1), len(seq2)
x1 = [0 for i in range(b+1)]
for i in range(a):
e1 = seq1[i]
x2 = x1
x1 = [0 for i in range(b+1)]
for j in range(b):
if e1 == seq2[j]:
x1[j+1]=x2[j] + 1
else:
x1[j+1]=max(x2[j+1], x1[j])
print(x1[-1]) | import sys
def longestcommonsubsequence():
seq1 = input()
seq2 = input()
a,b = len(seq1), len(seq2)
x1 = [0 for i in range(b+1)]
for i in range(a):
e1 = seq1[i]
x2 = x1
x1 = [0 for i in range(b+1)]
for j in range(b):
if e1 == seq2[j]:
x1[j+1]=x2[j] + 1
else:
x1[j+1]=max(x2[j+1], x1[j])
return x1[-1]
n = eval(input())
for i2 in range(n):
print(longestcommonsubsequence()) | p02235 |
import sys
def longestcommonsubsequence():
seq1 = input()
seq2 = input()
a,b = len(seq1), len(seq2)
x1 = [0 for i in range(b+1)]
i=0
for e1 in seq1:
x2 = x1
x1 = [0 for i in range(b+1)]
j=0
for e2 in seq2:
if e1 == e2:
x1[j+1]=x2[j] + 1
else:
x1[j+1]=max(x2[j+1], x1[j])
j += 1
i += 1
return x1[-1]
n = eval(input())
for i2 in range(n):
print(longestcommonsubsequence()) | import sys
def longestcommonsubsequence():
seq1 = input()
seq2 = input()
a,b = len(seq1), len(seq2)
x1 = [0 for i in range(b+1)]
i=0
for e1 in seq1:
x2 = x1
x1 = [0 for i in range(b+1)]
j=0
for j in range(b):
if e1 == seq2[j]:
x1[j+1]=x2[j] + 1
else:
x1[j+1]=max(x2[j+1], x1[j])
i += 1
return x1[-1]
n = eval(input())
for i2 in range(n):
print(longestcommonsubsequence()) | p02235 |
import sys
def longestcommonsubsequence():
seq1 = input()
seq2 = input()
a,b = len(seq1), len(seq2)
x1 = [0 for i in range(b+1)]
for i in range(a):
e1 = seq1[i]
x2 = x1
x1 = [0 for i2 in range(b+1)]
tmp = 0
for j in range(b):
if e1 == seq2[j]:
tmp = x2[j] + 1
else:
tmp = max(x2[j+1], tmp)
x1[j+1] = tmp
return x1[-1]
n = eval(input())
for i2 in range(n):
print(longestcommonsubsequence()) | import sys
def longestcommonsubsequence():
seq1 = input()
seq2 = input()
a, b = len(seq1), len(seq2)
x1 = [0 for i in range(b+1)]
for i in range(a):
e1 = seq1[i]
x2 = x1+[]
#x1 = [0 for i2 in range(b+1)]
for j in range(b):
if e1 == seq2[j]:
x1[j+1] = x2[j] + 1
else:
x1[j+1] = max(x1[j+1], x1[j])
return x1[-1]
n = eval(input())
for i2 in range(n):
print(longestcommonsubsequence()) | p02235 |
import sys
def longestcommonsubsequence():
seq1 = input()
seq2 = input()
a, b = len(seq1), len(seq2)
x1 = [0 for i in range(b+1)]
for i in range(a):
e1 = seq1[i]
x2 = x1+[]
#x1 = [0 for i2 in range(b+1)]
for j in range(b):
if e1 == seq2[j]:
x1[j+1] = x2[j] + 1
else:
x1[j+1] = max(x1[j+1], x1[j])
return x1[-1]
n = eval(input())
for i2 in range(n):
print(longestcommonsubsequence()) | import sys
def longestcommonsubsequence():
seq1 = input()
seq2 = input()
a, b = len(seq1), len(seq2)
x1 = [0 for i in range(b+1)]
for i in range(a):
e1 = seq1[i]
x2 = x1+[]
#x1 = [0 for i2 in range(b+1)]
for j in range(b):
if e1 == seq2[j]:
x1[j+1] = x2[j] + 1
elif x1[j+1]<x1[j]:
x1[j+1] = x1[j]
return x1[-1]
n = eval(input())
for i2 in range(n):
print(longestcommonsubsequence()) | p02235 |
# -*- coding:utf-8 -*-
import sys
def search(x, y):
x_length = len(x)
y_length = len(y)
memo = [[0] * y_length for i in range(x_length)]
for i in range(x_length):
for j in range(y_length):
if i == 0 or j == 0:
if x[i] == y[j]:
memo[i][j] = 1
else:
memo[i][j] = 0
elif x[i] == y[j]:
memo[i][j] = memo[i-1][j-1] + 1
else:
memo[i][j] = max(memo[i-1][j], memo[i][j-1])
return memo[i][j]
if __name__ == "__main__":
n = int(eval(input()))
strs = [list(val) for val in sys.stdin.read().splitlines()]
for i in range(n):
print((search(strs[i*2], strs[i*2+1])))
| # -*- coding:utf-8 -*-
import sys
def search(x, y):
x_length = len(x)
y_length = len(y)
memo = [[0] * (y_length + 1) for i in range(x_length + 1)]
for i, ch_x in enumerate(x, 1):
row = memo[i]
pre_row = memo[i-1]
for j, ch_y in enumerate(y, 1):
if ch_x == ch_y:
row[j] = pre_row[j-1] + 1
else:
row[j] = max(pre_row[j], row[j-1])
return memo[-1][-1]
if __name__ == "__main__":
n = int(input())
strs = [list(val) for val in sys.stdin.read().splitlines()]
result = [search(strs[i*2], strs[i*2+1]) for i in range(n)]
print(*result, sep="\n")
| p02235 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.