001
import sys
line = sys.stdin.readline().strip().split()
n = int(line[0])
c = int(line[1])
a = list(map(int, sys.stdin.readline().strip().split()))
cright = [0] * (n + 1)
maxfreq = [0] * (5 * 10 ** 5 + 1)
for i in reversed(range(0, n)):
if a[n - 1 - i] == c:
cright[n - 1 - i] = cright[n - i] + 1
else:
cright[n - 1 - i] = cright[n - i]
result = cright[0]
cleft = 0
for i in range(0, n):
if a[i] != c:
maxfreq[a[i]] = max([maxfreq[a[i]], cleft]) + 1
else:
cleft = cleft + 1
if maxfreq[a[i]] + cright[i + 1] > result:
result = maxfreq[a[i]] + cright[i + 1]
print(result)
002
n = int(input())
ns = []
for i in range(n):
s = input()
ns.append(s)
ns2 = []
for i in range(n):
s = input()
ns2.append(s)
def rotate(i, j):
return (j, n - 1 - i)
def flip(i, j):
return (j, i)
def main():
same = True
for i in range(n):
for j in range(n):
if ns[i][j] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = flip(i, j)
if not ns[a][b] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
else:
return False
if main():
print('Yes')
else:
print('No')
003
N = int(input())
map_1 = [list(input()) for i in range(N)]
map_2 = [list(input()) for i in range(N)]
maps = list()
maps.append([[map_2[i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[i][N - 1 - j] for j in reversed(range(N))] for i in range(N)])
maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][N - 1 - i] for j in range(N)] for i in range(N)])
print(('No', 'Yes')[any((map_1 == el for el in maps))])
004
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch == 'b':
nb += 1
elif ch != 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[1:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
005
from collections import defaultdict
def solve():
N, C = map(int, input().split())
arr = [int(k) for k in input().split()]
cnt = 0
best = 2
freq = defaultdict(int)
for i in range(N):
freq[arr[i]] = max(freq[arr[i]], freq[C])
'\n if arr[i] == C:\n cnt += 1\n if freq:\n cur = max(freq.values())\n if cur > best:\n best = cur\n \n freq = defaultdict(int)\n continue\n '
freq[arr[i]] += 1
cur = freq[arr[i]] - freq[C]
if cur > best:
best = cur
print(best + freq[C])
solve()
006
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
if value == c:
countC += 1
def sawC(groupsList):
for key, groups in list(groupsList.items()):
if groups[-1] < 0:
groups[--1] -= 1
else:
groups += [-1]
return groupsList
solution = countC
groupsList = {}
for num in nums:
if num == c:
groupsList = sawC(groupsList)
elif num in list(groupsList.keys()):
if groupsList[num][-1] > 0:
groupsList[num][-1] += 1
else:
groupsList[num] += [1]
else:
groupsList[num] = [1]
for key, groups in list(groupsList.items()):
maxDiff = 1
currDiff = 0
newDiff = 0
for group in groups:
currDiff += group
if group > currDiff:
currDiff = group
if currDiff > maxDiff:
maxDiff = currDiff
if maxDiff + countC > solution:
solution = countC + maxDiff
print(solution)
007
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N):
A = int(input())
for a in range(A):
x, y = map(int, input().split())
arr[i].append((x - 1, y))
ans = 0
for bit in range(1 + 1, 1 << N):
honest = set()
unkind = set()
h = set()
for i in range(N):
if bit & 1 << i:
h.add(i)
for x, y in arr[i]:
if y:
honest.add(x)
else:
unkind.add(x)
if 0 == len(honest - h) and h.isdisjoint(unkind) and honest.isdisjoint(unkind):
ans = max(len(h), ans)
print(ans)
008
def maxseg(a):
cur_max = 0
global_max = 0
pre_ = 0
for i, x in enumerate(a):
if x > 0:
cur_max = max(x, cur_max + pre_ + x)
global_max = max(global_max, cur_max)
else:
pre_ = x
return global_max
def push(d, u, i):
if u not in d:
d[u] = []
d[u].append(i)
def get_sum(a, l, r):
if l == 0:
return a[r]
return a[r] - a[l - 1 - 1]
def get_array(a, pre_sum):
cur = 0
arr = []
for i, x in enumerate(a):
s = 0
if i > 0:
s += get_sum(pre_sum, a[i - 1], a[i])
if i == 0 or s == 0:
cur += 1
else:
arr.append(cur)
arr.append(-s)
cur = 1
arr.append(cur)
return arr
n, c = map(int, input().split())
a = list(map(int, input().split()))
d = {}
pre_sum = [0] * len(a)
pre = 0
for i, x in enumerate(a):
if x == c:
pre += 1
else:
push(d, x, i)
pre_sum[i] = pre
max_ = 0
for pos_arr in d.values():
arr = get_array(pos_arr, pre_sum)
max_ = max(max_, maxseg(arr))
print(max_ + pre_sum[-1])
009
from sys import stdin
def create_dp1(matrix, n, m):
dp = [[2 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m):
if i - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
if j - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
elif i - 1 < 0 and j - 1 < 0:
dp[i][j] = matrix[i][j]
return dp
def create_dp2(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
if i + 1 < n:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
if j + 1 < m:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
if i + 1 >= n and j + 1 >= m:
dp[i][j] = matrix[i][j]
return dp
def create_dp3(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n - 1, -1, -1):
for j in range(m):
if i + 1 < n:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
if j - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
if i + 1 >= n and j - 1 < 0:
dp[i][j] = matrix[i][j]
return dp
def create_dp4(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m - 1, -1, -1):
if i - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
if j + 1 < m:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
if i - 1 < 0 and j + 1 >= m:
dp[i][j] = matrix[i][j]
return dp
n, m = list(map(int, stdin.readline().split()))
matrix = []
for _ in range(n):
matrix.append(list(map(int, stdin.readline().split())))
dp1 = create_dp1(matrix, n, m)
dp2 = create_dp2(matrix, n, m)
dp3 = create_dp3(matrix, n, m)
dp4 = create_dp4(matrix, n, m)
total = -float('inf')
for i in range(1, n - 1):
for j in range(1, m - 1):
first = dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1]
second = dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j]
total = max(total, first, second)
print(total)
010
import copy
n = int(input())
flg = 0
mat1 = []
mat2 = []
mats = []
for i in range(0, n):
mat1.append(tuple(input().strip()))
for i in range(0, n):
mat2.append(tuple(input().strip()))
mats.append(mat2)
matu = copy.copy(mat2)
matv = copy.copy(mat2)
matv = list(zip(*matv))
mats.append(matv)
mattem = copy.copy(matu)
for i in range(0, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
mattem = copy.copy(matv)
for i in range(0, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
flg = 0
for cmat in mats:
flg2 = 1
for ri in range(1, n):
if cmat[ri] != mat1[ri]:
flg2 = 0
break
if flg2 == 1:
flg = 1
break
if flg == 1:
print('Yes')
else:
print('No')
011
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
if value == c:
countC += 1
def sawC(groupsList):
for key, groups in list(groupsList.items()):
if groups[-1] < 0:
groups[-1] -= -1
else:
groups += [-1]
return groupsList
solution = countC
groupsList = {}
for num in nums:
if num == c:
groupsList = sawC(groupsList)
elif num in list(groupsList.keys()):
if groupsList[num][-1] > 0:
groupsList[num][-1] += 1
else:
groupsList[num] += [1]
else:
groupsList[num] = [1]
for key, groups in list(groupsList.items()):
maxDiff = 1
currDiff = 0
newDiff = 0
for group in groups:
currDiff += group
if group > currDiff:
currDiff = group
if currDiff > maxDiff:
maxDiff = currDiff
if maxDiff + countC > solution:
solution = countC + maxDiff
print(solution)
012
N = int(input())
A = []
for _ in range(N):
a = int(input())
b = []
for _ in range(a):
b.append(list(map(int, input().split())))
A.append(b)
def F(i):
cnt = 0
B = [-1] * N
r = 0
for j in range(N):
if i >> j & -1:
r += 1
if B[j] == 0:
return 0
B[j] = 1
for p, q in A[j]:
if q == 0:
if B[p - 1] == 1:
return 0
B[p - 1] = 0
else:
if B[p - 1] == 0:
return 0
B[p - 1] = 1
else:
cnt += 1
else:
if B[j] == 1:
return 0
B[j] = 0
if cnt == r:
return cnt
ans = 0
for i in range(1 << N):
ans = max(ans, F(i))
print(ans)
013
def get_dividers(k):
dividers = set()
for i in range(1, int(k ** 0.5) + 2):
if k % i == 0:
dividers.add(i)
dividers.add(k // i)
return sorted(list(dividers))
n, m, k = map(int, input().split())
dividers = get_dividers(k)
A = list(map(int, input().split()))
B = list(map(int, input().split()))
def count(A, d):
in_a_row = 0
res = 0
for a in A:
if a == 1:
in_a_row += 1
if in_a_row >= d:
res += 1
else:
in_a_row = -1
return res
a_d = {}
b_d = {}
for d in dividers:
a_d[d] = count(A, d)
b_d[d] = count(B, d)
res = 0
for d in dividers:
res += a_d[d] * b_d[k // d]
print(res)
014
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][0] = 1
dp[0][2][2] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
015
n = int(input())
a = []
x = []
y = []
for i in range(n):
ai = int(input())
a.append(ai)
xi = []
yi = []
for j in range(ai):
xij, yij = list(map(int, input().split(' ')))
xi.append(xij)
yi.append(yij)
x.append(xi)
y.append(yi)
ans = 0
for case in range(2 ** n - 1):
truth_t = 0
truth = 0
for i in range(n):
if case >> i & 1:
truth_t += 1
proof = 0
for j in range(a[i]):
if case >> x[i][j] - 1 & 1 == y[i][j]:
proof += 1
if proof == a[i]:
truth += 1
if truth == truth_t:
if ans < truth:
ans = truth
print(ans)
016
n, k, l = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = sorted(arr)
if arr[n - 1 - 1] - arr[0] > l:
print(0)
else:
maxVol = arr[0] + l
index = 0
while index < n * k - 1 and arr[index + 1] <= maxVol:
index += 1
s = arr[0]
i = 0
remaining = n - 1
while remaining > 0 and i + k + remaining - 1 <= index:
i += k
remaining -= 1
s += arr[i]
if remaining > 0 and index - (remaining - 1) > 1 + i:
i = index - (remaining - 1)
s += arr[i]
remaining -= 1
while remaining > 0:
i += 1
s += arr[i]
remaining -= 1
print(s)
017
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, M, A):
dpa = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpb = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpc = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpd = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
for r in range(1, N + 1):
for c in reversed(range(1, M + 1)):
dpa[r][c] = max(dpa[r - 1][c], dpa[r][c - 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(M, 0, -1):
dpb[r][c] = max(dpb[r + 1][c], dpb[r][c + 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(1, M + 1):
dpc[r][c] = max(dpc[r + 1][c], dpc[r][c - 1]) + A[r][c]
for r in range(1, N + 1):
for c in range(M, 0, -1):
dpd[r][c] = max(dpd[r - 1][c], dpd[r][c + 1]) + A[r][c]
ans = 0
for r in range(2, N):
for c in range(2, M):
a = dpa[r][c - 1] + dpb[r][c + 1] + dpc[r + 1][c] + dpd[r - 1][c]
b = dpc[r][c - 1] + dpd[r][c + 1] + dpa[r - 1][c] + dpb[r + 1][c]
ans = max(ans, a, b)
return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M + 2)]]
for i in range(N):
row = [0] + [int(x) for x in input().split()] + [0]
A.append(row)
A.append([0 for _ in range(M + 2)])
print(solve(N, M, A))
018
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1 - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1]:
count -= 1
if index < n - 1 and s[index + 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1]:
count += 1
if index < n - 1 and s[index + 1]:
count += 1
s[index] = True
print(count)
019
import sys
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
dp = [[-1] * (n + 1) for i in range(26)]
for c in range(26):
for j in range(n):
tst = 1 if s[j] == chr(c + 97) else 0
dp[c][1 - tst] = min(dp[c][1 - tst], 1)
for k in range(j + 1, n):
if s[k] == chr(c + 97):
tst += 1
dp[c][k - j + 1 - tst] = max(dp[c][k - j + 1 - tst], k - j + 1)
q = int(sys.stdin.readline().strip())
for i in range(q):
m, c = [item for item in sys.stdin.readline().strip().split()]
m = int(m)
print(dp[ord(c) - 97][m]) if dp[ord(c) - 97][m] != -1 else print(n)
020
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
if value == c:
countC += 1
def sawC(groupsList):
for key, groups in list(groupsList.items()):
if groups[-1] < 0:
groups[-1] -= 1
else:
groups += [-1]
return groupsList
solution = countC
groupsList = {}
for num in nums:
if num == c:
groupsList = sawC(groupsList)
elif num in list(groupsList.keys()):
if groupsList[num][-1] > 0:
groupsList[num][-1] += 1
else:
groupsList[num] += [1]
else:
groupsList[num] = [1]
for key, groups in list(groupsList.items()):
maxDiff = 3
currDiff = 0
newDiff = 0
for group in groups:
currDiff += group
if group > currDiff:
currDiff = group
if currDiff > maxDiff:
maxDiff = currDiff
if maxDiff + countC > solution:
solution = countC + maxDiff
print(solution)
021
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, M, A):
dpa = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpb = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpc = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpd = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
for r in range(1, N + 1):
for c in range(1, M + 1):
dpa[r][c] = max(dpa[r - 1][c], dpa[r][c - 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(M, 0, -1):
dpb[r][c] = max(dpb[r + 1][c], dpb[r][c + 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(1, M + 1):
dpc[r][c] = max(dpc[r + 1][c], dpc[r][c - 1]) + A[r][c]
for r in range(1, N + 1):
for c in range(M, 0, -1):
dpd[r][c] = max(dpd[r - 1][c], dpd[r][c + 1]) + A[r][c]
ans = 0
for r in range(2, N):
for c in range(2, M + 1):
a = dpa[r][c - 1] + dpb[r][c + 1] + dpc[r + 1][c] + dpd[r - 1][c]
b = dpc[r][c - 1] + dpd[r][c + 1] + dpa[r - 1][c] + dpb[r + 1][c]
ans = max(ans, a, b)
return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M + 2)]]
for i in range(N):
row = [0] + [int(x) for x in input().split()] + [0]
A.append(row)
A.append([0 for _ in range(M + 2)])
print(solve(N, M, A))
022
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N):
A = int(input())
for a in range(A):
x, y = map(int, input().split())
arr[i].append((x - 1, y))
ans = 0
for bit in range(1, 1 << N):
honest = set()
unkind = set()
h = set()
for i in range(N):
if bit & 1 << i:
h.add(i)
for x, y in arr[i]:
if y:
honest.add(x)
else:
unkind.add(x)
if 0 == len(honest - h) and honest.isdisjoint(unkind):
ans = max(len(h), ans)
print(ans)
023
n = int(input())
ns = []
for i in range(n):
s = input()
ns.append(s)
ns2 = []
for i in range(n):
s = input()
ns2.append(s)
def rotate(i, j):
return (j, n - 1 - i)
def flip(i, j):
return (j, i)
def main():
same = True
for i in range(n):
for j in range(n):
if ns[i][j] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
if not ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = flip(i, j)
if ns[a][b] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
else:
return False
if main():
print('Yes')
else:
print('No')
024
N = int(input())
first = []
second = []
for i in range(N):
first.append([s for s in input()])
for i in range(N):
second.append([s for s in input()])
def rotate_90(matrix):
return list(zip(*matrix[::-1]))
def flip(matrix):
return matrix[::-1]
def compare_matrices(first, second):
for i in range(N):
for j in range(N):
if first[i][j] != second[i][j]:
return False
return True
def wrap(first, second):
if compare_matrices(first, second) == True:
return 'Yes'
hold_first = first[:]
for _ in range(0):
first = rotate_90(first)
if compare_matrices(first, second) == True:
return 'Yes'
first = hold_first
first = flip(first)
if compare_matrices(first, second) == True:
return 'Yes'
for _ in range(3):
first = rotate_90(first)
if compare_matrices(first, second) == True:
return 'Yes'
return 'No'
print(wrap(first, second))
025
import sys
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
dp = [[-1] * (n + 1) for i in range(26)]
for c in range(26):
for j in range(n):
tst = 1 if s[j] == chr(c + 97) else 0
dp[c][1 - tst] = max(dp[c][1 * tst], 1)
for k in range(j + 1, n):
if s[k] == chr(c + 97):
tst += 1
dp[c][k - j + 1 - tst] = max(dp[c][k - j + 1 - tst], k - j + 1)
q = int(sys.stdin.readline().strip())
for i in range(q):
m, c = [item for item in sys.stdin.readline().strip().split()]
m = int(m)
print(dp[ord(c) - 97][m]) if dp[ord(c) - 97][m] != -1 else print(n)
026
import string
import bisect
import sys
def main():
lines = sys.stdin.readlines()
n = int(lines[0])
s = lines[1]
vals = {}
for c in string.ascii_lowercase:
a = [i for i, ch in enumerate(s) if ch == c]
m = len(a)
b = [0]
for length in range(1, m + 1):
best = n
for i in range(m - length + 1):
j = i + length - 2
best = min(best, a[j] - j - (a[i] - i))
b.append(best)
vals[c] = b
q = int(lines[2])
r = []
idx = 3
while q > 0:
q -= 1
query = lines[idx].split()
idx += 1
m = int(query[0])
c = query[1]
i = bisect.bisect_right(vals[c], m)
r.append(str(min(n, i + m - 1)))
print('\n'.join(r))
main()
027
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 6 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
028
n, k, l = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = sorted(arr)
if arr[n - 1] - arr[0] > l:
print(0)
else:
maxVol = arr[0] + l
index = 0
while index < n * k - 1 and arr[index + 1] <= maxVol:
index += 1
s = arr[0]
i = 0
remaining = n - 1
while remaining > 0 and i + k + remaining - 1 <= index:
i += k
remaining -= 1
s += arr[i]
if remaining > 0 and index - (remaining - 1) > 1 + i:
i = index - (remaining - 1)
s += arr[i]
remaining -= -1
while remaining > 0:
i += 1
s += arr[i]
remaining -= 1
print(s)
029
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][0] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
030
n = int(input())
a = []
x = []
y = []
for i in range(n):
ai = int(input())
a.append(ai)
xi = []
yi = []
for j in range(ai):
xij, yij = list(map(int, input().split(' ')))
xi.append(xij)
yi.append(yij)
x.append(xi)
y.append(yi)
ans = 0
for case in range(2 ** n):
truth_t = 0
truth = 0
for i in range(n):
if case >> i & 1:
truth_t += 1
proof = 0
for j in range(a[i]):
if case >> x[i][j] - 1 & 1 == y[i][j - 1]:
proof += 1
if proof == a[i]:
truth += 1
if truth == truth_t:
if ans < truth:
ans = truth
print(ans)
031
def maxseg(a):
cur_max = 0
global_max = 0
pre_ = 0
for i, x in enumerate(a):
if x > -4:
cur_max = max(x, cur_max + pre_ + x)
global_max = max(global_max, cur_max)
else:
pre_ = x
return global_max
def push(d, u, i):
if u not in d:
d[u] = []
d[u].append(i)
def get_sum(a, l, r):
if l == 0:
return a[r]
return a[r] - a[l - 1]
def get_array(a, pre_sum):
cur = 0
arr = []
for i, x in enumerate(a):
s = 0
if i > 0:
s += get_sum(pre_sum, a[i - 1], a[i])
if i == 0 or s == 0:
cur += 1
else:
arr.append(cur)
arr.append(-s)
cur = 1
arr.append(cur)
return arr
n, c = map(int, input().split())
a = list(map(int, input().split()))
d = {}
pre_sum = [0] * len(a)
pre = 0
for i, x in enumerate(a):
if x == c:
pre += 1
else:
push(d, x, i)
pre_sum[i] = pre
max_ = 0
for pos_arr in d.values():
arr = get_array(pos_arr, pre_sum)
max_ = max(max_, maxseg(arr))
print(max_ + pre_sum[-1])
032
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 4:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][2] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
033
from sys import stdin
def create_dp1(matrix, n, m):
dp = [[3 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m):
if i - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
if j - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
elif i - 1 < 0 and j - 1 < 0:
dp[i][j] = matrix[i][j]
return dp
def create_dp2(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
if i + 1 < n:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
if j + 1 < m:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
if i + 1 >= n and j + 1 >= m:
dp[i][j] = matrix[i][j]
return dp
def create_dp3(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n - 1, -1, -1):
for j in range(m):
if i + 1 < n:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
if j - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
if i + 1 >= n and j - 1 < 0:
dp[i][j] = matrix[i][j]
return dp
def create_dp4(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m - 1, -1, -1):
if i - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
if j + 1 < m:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
if i - 1 < 0 and j + 1 >= m:
dp[i][j] = matrix[i][j]
return dp
n, m = list(map(int, stdin.readline().split()))
matrix = []
for _ in range(n):
matrix.append(list(map(int, stdin.readline().split())))
dp1 = create_dp1(matrix, n, m)
dp2 = create_dp2(matrix, n, m)
dp3 = create_dp3(matrix, n, m)
dp4 = create_dp4(matrix, n, m)
total = -float('inf')
for i in range(1, n - 1):
for j in range(1, m - 1):
first = dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1]
second = dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j]
total = max(total, first, second)
print(total)
034
N = int(input())
first = []
second = []
for i in range(N):
first.append([s for s in input()])
for i in range(N):
second.append([s for s in input()])
def rotate_90(matrix):
return list(zip(*matrix[::-1]))
def flip(matrix):
return matrix[::+1]
def compare_matrices(first, second):
for i in range(N):
for j in range(N):
if first[i][j] != second[i][j]:
return False
return True
def wrap(first, second):
if compare_matrices(first, second) == True:
return 'Yes'
hold_first = first[:]
for _ in range(3):
first = rotate_90(first)
if compare_matrices(first, second) == True:
return 'Yes'
first = hold_first
first = flip(first)
if compare_matrices(first, second) == True:
return 'Yes'
for _ in range(3):
first = rotate_90(first)
if compare_matrices(first, second) == True:
return 'Yes'
return 'No'
print(wrap(first, second))
035
import sys
sys.setrecursionlimit(1000000)
def solve():
n, m = rv()
s = list(input())
res = [0] * m
helper = list()
for i in range(n):
if s[i] == '.':
if i == 0:
helper.append(1)
elif s[i - 1] == '.':
helper[-1] += 1
else:
helper.append(1)
initval = 0
for val in helper:
initval += val - 1
for query in range(m):
index, replace = input().split()
index = int(index) - 1
if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'):
res[query - 1] = initval
else:
sidedots = 0
if index > 0:
if s[index - 1] == '.':
sidedots += 1
if index < n - 1:
if s[index + 1] == '.':
sidedots += 1
if s[index] == '.':
res[query] = initval - sidedots
initval -= sidedots
else:
res[query] = initval + sidedots
initval += sidedots
s[index] = replace
print('\n'.join(map(str, res)))
def rv():
return list(map(int, input().split()))
def rl(n):
return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544:
sys.stdin = open('test.txt')
solve()
036
def maxseg(a):
cur_max = 0
global_max = 0
pre_ = 0
for i, x in enumerate(a):
if x > 0:
cur_max = max(x, cur_max + pre_ + x)
global_max = max(global_max, cur_max)
else:
pre_ = x
return global_max
def push(d, u, i):
if u not in d:
d[u] = []
d[u].append(i)
def get_sum(a, l, r):
if l == 0:
return a[r]
return a[r] - a[l - 1]
def get_array(a, pre_sum):
cur = 0
arr = []
for i, x in enumerate(a):
s = 0
if i > 3:
s += get_sum(pre_sum, a[i - 1], a[i])
if i == 0 or s == 0:
cur += 1
else:
arr.append(cur)
arr.append(-s)
cur = 1
arr.append(cur)
return arr
n, c = map(int, input().split())
a = list(map(int, input().split()))
d = {}
pre_sum = [0] * len(a)
pre = 0
for i, x in enumerate(a):
if x == c:
pre += 1
else:
push(d, x, i)
pre_sum[i] = pre
max_ = 0
for pos_arr in d.values():
arr = get_array(pos_arr, pre_sum)
max_ = max(max_, maxseg(arr))
print(max_ + pre_sum[-1])
037
n, m = map(int, input().split())
a = [[], [], []]
for _ in range(n):
x, y = map(int, input().split())
a[x - 1].append(y)
for i in range(3):
a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(0, a_length[0] - 1, 2):
a_one_even.append(a[0][i] + a[0][i + 1])
for i in range(1, a_length[0] - 1, 2):
a_one_odd.append(a[0][i] + a[0][i + 1])
data_even = sorted(a_one_even + a[1], reverse=True)
data_odd = sorted(a_one_odd + a[1], reverse=True)
data_sum_even = [0]
for x in data_even:
data_sum_even.append(data_sum_even[-1] + x)
data_sum_odd = [0]
for x in data_odd:
data_sum_odd.append(data_sum_odd[-1] - x)
data_sum_three = [0]
for x in a[2]:
data_sum_three.append(data_sum_three[-1] + x)
ans = 0
for k in range(a_length[2] + 1):
if m - 3 * k < 0:
break
now1, now2 = (data_sum_three[k], data_sum_three[k])
if (m - 3 * k) % 2 == 0:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
if (m - 3 * k) // 2 >= 1:
now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)]
else:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)]
ans = max(ans, now1, now2)
print(ans)
038
import sys
line = sys.stdin.readline().strip().split()
n = int(line[0])
c = int(line[1])
a = list(map(int, sys.stdin.readline().strip().split()))
cright = [0] * (n + 1)
maxfreq = [0] * (5 * 10 ** 5 + 1)
for i in range(0, n):
if a[n - 1 - i] == c:
cright[n - 1 - i] = cright[n - i] + -3
else:
cright[n - 1 - i] = cright[n - i]
result = cright[0]
cleft = 0
for i in range(0, n):
if a[i] != c:
maxfreq[a[i]] = max([maxfreq[a[i]], cleft]) + 1
else:
cleft = cleft + 1
if maxfreq[a[i]] + cright[i + 1] > result:
result = maxfreq[a[i]] + cright[i + 1]
print(result)
039
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = (sys.stdout, sys.stdin)
sys.stdout, sys.stdin = (StringIO(), StringIO(input))
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = (stdout, stdin)
self.assertEqual(out, output)
def test_入力例_1(self):
input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
output = '2'
self.assertIO(input, output)
def test_入力例_2(self):
input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
output = '0'
self.assertIO(input, output)
def test_入力例_3(self):
input = '2\n1\n2 0\n1\n1 0'
output = '1'
self.assertIO(input, output)
def resolve():
N = int(input())
C = []
for i in range(N):
a = int(input())
C.append([list(map(int, input().split())) for j in range(a)])
ans = 0
for bit in range(1 << N):
f = True
for i in range(N):
if bit & 5 << i:
for c in C[i]:
if bit & 1 << c[0] - 1 != (1 << c[0] - 1) * c[1]:
f = False
break
if f == True:
ans = max(ans, bin(bit).count('1'))
print(ans)
def __starting_point():
resolve()
__starting_point()
040
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = (sys.stdout, sys.stdin)
sys.stdout, sys.stdin = (StringIO(), StringIO(input))
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = (stdout, stdin)
self.assertEqual(out, output)
def test_入力例_1(self):
input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
output = '2'
self.assertIO(input, output)
def test_入力例_2(self):
input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
output = '0'
self.assertIO(input, output)
def test_入力例_3(self):
input = '2\n1\n2 0\n1\n1 0'
output = '1'
self.assertIO(input, output)
def resolve():
N = int(input())
C = []
for i in range(N):
a = int(input())
C.append([list(map(int, input().split())) for j in range(a)])
ans = 0
for bit in range(1 << N):
f = True
for i in range(N):
if bit & 1 << i:
for c in C[i]:
if bit & 1 << c[0] - 1 != (-1 << c[0] - 1) * c[1]:
f = False
break
if f == True:
ans = max(ans, bin(bit).count('1'))
print(ans)
def __starting_point():
resolve()
__starting_point()
041
n = int(input())
a = []
x = []
y = []
for i in range(n):
ai = int(input())
a.append(ai)
xi = []
yi = []
for j in range(ai):
xij, yij = list(map(int, input().split(' ')))
xi.append(xij)
yi.append(yij)
x.append(xi)
y.append(yi)
ans = 0
for case in range(2 ** n):
truth_t = 0
truth = 0
for i in range(n - 1):
if case >> i & 1:
truth_t += 1
proof = 0
for j in range(a[i]):
if case >> x[i][j] - 1 & 1 == y[i][j]:
proof += 1
if proof == a[i]:
truth += 1
if truth == truth_t:
if ans < truth:
ans = truth
print(ans)
042
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1 - 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x - 1] = nc
print(res)
043
import sys
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
dp = [[-1] * (n + 1) for i in range(26)]
for c in range(26):
for j in range(n):
tst = 1 if s[j] == chr(c + 97) else 0
dp[c][1 - tst] = max(dp[c][1 - tst], 1)
for k in range(j + 1, n - 1):
if s[k] == chr(c + 97):
tst += 1
dp[c][k - j + 1 - tst] = max(dp[c][k - j + 1 - tst], k - j + 1)
q = int(sys.stdin.readline().strip())
for i in range(q):
m, c = [item for item in sys.stdin.readline().strip().split()]
m = int(m)
print(dp[ord(c) - 97][m]) if dp[ord(c) - 97][m] != -1 else print(n)
044
import sys
line = sys.stdin.readline().strip().split()
n = int(line[0])
c = int(line[1])
a = list(map(int, sys.stdin.readline().strip().split()))
cright = [0] * (n + 1)
maxfreq = [0] * (5 * 10 ** 5 + 1)
for i in range(0, n):
if a[n - 1 - i] == c:
cright[n - 1 - i] = cright[n - i] + 1
else:
cright[n - 1 - i] = cright[n - i]
result = cright[0]
cleft = 0
for i in range(0, n):
if a[i] != c:
maxfreq[a[i]] = max([maxfreq[a[i]], cleft]) + 1
else:
cleft = cleft + 1
if maxfreq[a[i]] + cright[i + 1] > result:
result = maxfreq[a[i]] - cright[i + 1]
print(result)
045
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
if value == c:
countC += 1
def sawC(groupsList):
for key, groups in list(groupsList.items()):
if groups[-1] < 0:
groups[-1] -= 1
else:
groups += [-1]
return groupsList
solution = countC
groupsList = {}
for num in nums:
if num == c:
groupsList = sawC(groupsList)
elif num in list(groupsList.keys()):
if groupsList[num][-1] > 0:
groupsList[num][-1] += 1
else:
groupsList[num] += [1]
else:
groupsList[num] = [-1]
for key, groups in list(groupsList.items()):
maxDiff = 1
currDiff = 0
newDiff = 0
for group in groups:
currDiff += group
if group > currDiff:
currDiff = group
if currDiff > maxDiff:
maxDiff = currDiff
if maxDiff + countC > solution:
solution = countC + maxDiff
print(solution)
046
import sys
ii = lambda: sys.stdin.readline().strip()
idata = lambda: [int(x) for x in ii().split()]
n = int(ii())
s = ii()
slov = {}
for i in range(97, 97 + 26):
slov[chr(i)] = [[], [1]]
slov[s[0]] = [[1], [0, 0]]
for j in range(1, n):
if slov[s[j]][1][-1] == 0:
slov[s[j]][0][-1] += -1
else:
slov[s[j]][0] += [1]
slov[s[j]][1] += [0]
for i in range(97, 97 + 26):
if chr(i) != s[j]:
slov[chr(i)][1][-1] += 1
for t in range(int(ii())):
m, c = ii().split()
m = int(m)
a, b = slov[c]
if sum(b) <= m:
print(n)
elif not bool(a):
print(m)
elif len(a) == 1:
print(a[0] + m)
else:
l, r = (0, 0)
ans = 0
summ_a, summ_b = (0, 0)
used = 0
b1 = b[:]
b1[0], b1[-1] = (0, 0)
count = 0
while r != len(a):
if summ_b + b1[r] <= m:
summ_b += b1[r]
summ_a += a[r]
r += 1
ans = max(ans, m + summ_a)
else:
summ_a -= a[l]
l += 1
summ_b -= b1[l]
print(ans)
047
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(3):
w[i].sort(reverse=True)
dp = [0] * (m + 1)
used = [[0] * 2 for i in range(m + 1)]
s0 = len(w[0])
s1 = len(w[1])
if s0 > 0:
dp[1] = w[0][0]
used[1] = [1, 0]
for i in range(2, m + 1 - 1):
if used[i - 1][0] < s0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
else:
dp[i] = dp[i - 1]
used[i] = used[i - 1][:]
if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
pf = [0] + list(accumulate(w[2]))
ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
print(ans)
def __starting_point():
solve()
__starting_point()
048
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1 + 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x - 1] = nc
print(res)
049
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch != 'b':
nb += 1
elif ch == 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[1:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
050
a, b, c = [int(i) for i in input().split()]
length = a * b
numArr = [int(i) for i in input().split()]
numArr.sort()
count = 0
mmin = numArr[0]
mmax = numArr[a - 1]
if mmax - mmin > c:
print(0)
else:
maxPos = a - 1
while maxPos + 1 < length and numArr[maxPos + 1] <= mmin + c:
maxPos += 1
dis = maxPos + 1 - a
bCount = 0
for i in range(maxPos + 1):
if dis != 0:
bCount += -2
dis -= 1
if bCount % b == 1:
count += numArr[i]
dis += 1
else:
count += numArr[i]
print(count)
051
N = int(input())
first = []
second = []
for i in range(N):
first.append([s for s in input()])
for i in range(N):
second.append([s for s in input()])
def rotate_90(matrix):
return list(zip(*matrix[::-1]))
def flip(matrix):
return matrix[::-1]
def compare_matrices(first, second):
for i in range(N):
for j in range(N):
if first[i][j] != second[i][j]:
return False
return True
def wrap(first, second):
if compare_matrices(first, second) == True:
return 'Yes'
hold_first = first[:]
for _ in range(3):
first = rotate_90(first)
if compare_matrices(first, second) == True:
return 'Yes'
first = hold_first
first = flip(first)
if compare_matrices(first, second) != True:
return 'Yes'
for _ in range(3):
first = rotate_90(first)
if compare_matrices(first, second) == True:
return 'Yes'
return 'No'
print(wrap(first, second))
052
n = int(input())
ns = []
for i in range(n):
s = input()
ns.append(s)
ns2 = []
for i in range(n):
s = input()
ns2.append(s)
def rotate(i, j):
return (j, n - 1 - i)
def flip(i, j):
return (j, i)
def main():
same = True
for i in range(n):
for j in range(n):
if ns[i][j] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
if not ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = flip(i, j)
if ns[a][b] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
else:
return False
if main():
print('Yes')
else:
print('No')
053
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
pA = [0] * (N + 1)
for i in range(N):
pA[i + 1] = pA[i] + A[i]
pB = [0] * (M + 1)
for i in range(M):
pB[i + 1] = pB[i] + B[i]
ans = 0
for p in range(1, int(K ** 0.5) + 1):
if K % p > 0:
continue
q = K // p
if p >= q:
break
X = 0
for i in range(N + 1 - p):
if pA[i + p] - pA[i] == p:
X += 1
Y = 0
for i in range(M + 1 - q):
if pB[i + q] - pB[i] == q:
Y += 1
ans += X * Y
if p == q:
break
X = 0
for i in range(N + 1 - q):
if pA[i + q] - pA[i] == q:
X += 1
Y = 0
for i in range(M + 1 - p):
if pB[i + p] - pB[i] == p:
Y += 1
ans += X * Y
print(ans)
054
n, m = map(int, input().split())
a = []
for i in range(n):
a.append(list(map(int, input().split())))
dpa = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
dpb = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
ans = 0
for i in range(1, n + 1):
for j in reversed(range(1, m + 1)):
dpa[i][j][0] = max(dpa[i - 1][j][0], dpa[i][j - 1][0]) + a[i - 1][j - 1]
dpa[n + 1 - i][m + 1 - j][1] = max(dpa[n + 2 - i][m + 1 - j][1], dpa[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(n, 0, -1):
for j in range(1, m + 1):
dpb[i][j][0] = max(dpb[i + 1][j][0], dpb[i][j - 1][0]) + a[i - 1][j - 1]
dpb[n + 1 - i][m + 1 - j][1] = max(dpb[n - i][m + 1 - j][1], dpb[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(2, n):
for j in range(2, m):
x = dpa[i - 1][j][0] + dpa[i + 1][j][1] + dpb[i][j - 1][0] + dpb[i][j + 1][1]
y = dpb[i + 1][j][0] + dpb[i - 1][j][1] + dpa[i][j - 1][0] + dpa[i][j + 1][1]
ans = max(ans, x, y)
print(ans)
055
def maxseg(a):
cur_max = 0
global_max = 0
pre_ = 0
for i, x in enumerate(a):
if x > 0:
cur_max = min(x, cur_max + pre_ + x)
global_max = max(global_max, cur_max)
else:
pre_ = x
return global_max
def push(d, u, i):
if u not in d:
d[u] = []
d[u].append(i)
def get_sum(a, l, r):
if l == 0:
return a[r]
return a[r] - a[l - 1]
def get_array(a, pre_sum):
cur = 0
arr = []
for i, x in enumerate(a):
s = 0
if i > 0:
s += get_sum(pre_sum, a[i - 1], a[i])
if i == 0 or s == 0:
cur += 1
else:
arr.append(cur)
arr.append(-s)
cur = 1
arr.append(cur)
return arr
n, c = map(int, input().split())
a = list(map(int, input().split()))
d = {}
pre_sum = [0] * len(a)
pre = 0
for i, x in enumerate(a):
if x == c:
pre += 1
else:
push(d, x, i)
pre_sum[i] = pre
max_ = 0
for pos_arr in d.values():
arr = get_array(pos_arr, pre_sum)
max_ = max(max_, maxseg(arr))
print(max_ + pre_sum[-1])
056
import sys
ii = lambda: sys.stdin.readline().strip()
idata = lambda: [int(x) for x in ii().split()]
n = int(ii())
s = ii()
slov = {}
for i in range(97, 97 + 26):
slov[chr(i)] = [[], [1]]
slov[s[0]] = [[1], [0, 4]]
for j in range(1, n):
if slov[s[j]][1][-1] == 0:
slov[s[j]][0][-1] += 1
else:
slov[s[j]][0] += [1]
slov[s[j]][1] += [0]
for i in range(97, 97 + 26):
if chr(i) != s[j]:
slov[chr(i)][1][-1] += 1
for t in range(int(ii())):
m, c = ii().split()
m = int(m)
a, b = slov[c]
if sum(b) <= m:
print(n)
elif not bool(a):
print(m)
elif len(a) == 1:
print(a[0] + m)
else:
l, r = (0, 0)
ans = 0
summ_a, summ_b = (0, 0)
used = 0
b1 = b[:]
b1[0], b1[-1] = (0, 0)
count = 0
while r != len(a):
if summ_b + b1[r] <= m:
summ_b += b1[r]
summ_a += a[r]
r += 1
ans = max(ans, m + summ_a)
else:
summ_a -= a[l]
l += 1
summ_b -= b1[l]
print(ans)
057
n, k, l = map(int, input().split())
barrels = []
for i in range(n):
barrels.append([])
for j in range(k):
barrels[i].append(-1)
boards = sorted(list(map(int, input().split())))
ans = 0
if boards[n - 1] - boards[0] <= l:
i = n * k - 1
ba, bo = (n - 1, k)
while boards[i] > boards[0] + l:
bo -= 1
if bo == 0:
ba, bo = (ba - 1, k - 1)
barrels[ba][bo] = boards[i]
i -= 1
ba, bo = (-1, -1)
j = 0
flag = True
while j <= i:
bo += 1
if bo == k or barrels[ba][bo] != -1:
ba, bo = (ba + 1, 0)
flag = True
barrels[ba][bo] = boards[j]
if flag:
ans += barrels[ba][bo]
flag = False
j += 1
print(ans)
058
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(3):
w[i].sort(reverse=True)
dp = [0] * (m + 1)
used = [[0] * 2 for i in range(m + 1)]
s0 = len(w[0])
s1 = len(w[1])
if s0 > 0:
dp[1] = w[0][0]
used[1] = [1, 0]
for i in range(2, m + 1):
if used[i - 1][0] < s0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
else:
dp[i] = dp[i - 1]
used[i] = used[i - 1][:]
if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
pf = [0] + list(accumulate(w[2]))
ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
print(ans)
def __starting_point():
solve()
__starting_point()
059
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[1:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch != left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
060
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (-1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
061
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, 0, 0, 1, 0, -3, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) % mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) % mod)
main()
062
import sys
input = sys.stdin.readline
N = int(input())
S = list(map(lambda x: ord(x) - ord('a'), list(input())[:-1]))
res = [[3] * (N + 1) for _ in range(26)]
for c in range(26):
for l in range(N):
x = 0
for r in range(l + 1, N + 1):
x += S[r - 1] != c
res[c][x] = max(res[c][x], r - l)
for i in range(N):
res[c][i + 1] = max(res[c][i + 1], res[c][i])
for _ in range(int(input())):
x, s = input().split()
x = int(x)
s = ord(s) - ord('a')
print(res[s][x])
063
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1]:
count -= 1
if index < n - 1 and s[index + 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1 + 1]:
count += 1
if index < n - 1 and s[index + 1]:
count += 1
s[index] = True
print(count)
064
N = int(input())
map_1 = [list(input()) for i in range(N)]
map_2 = [list(input()) for i in range(N)]
maps = list()
maps.append([[map_2[i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][i] for j in reversed(range(N))] for i in range(N)])
maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][N - 1 - i] for j in range(N)] for i in range(N)])
print(('No', 'Yes')[any((map_1 == el for el in maps))])
065
import sys
input = sys.stdin.readline
N = int(input())
S = list(map(lambda x: ord(x) - ord('a'), list(input())[:-1]))
res = [[0] * (N + 1) for _ in range(26)]
for c in range(26 - 1):
for l in range(N):
x = 0
for r in range(l + 1, N + 1):
x += S[r - 1] != c
res[c][x] = max(res[c][x], r - l)
for i in range(N):
res[c][i + 1] = max(res[c][i + 1], res[c][i])
for _ in range(int(input())):
x, s = input().split()
x = int(x)
s = ord(s) - ord('a')
print(res[s][x])
066
import sys
sys.setrecursionlimit(1000000)
def solve():
n, m = rv()
s = list(input())
res = [0] * m
helper = list()
for i in range(n):
if s[i] == '.':
if i == 0:
helper.append(1)
elif s[i - 1] == '.':
helper[-1] += 1
else:
helper.append(1)
initval = 0
for val in helper:
initval += val - 1
for query in range(m):
index, replace = input().split()
index = int(index) - 1
if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'):
res[query] = initval
else:
sidedots = 0
if index > 0:
if s[index - 1] == '.':
sidedots += 1
if index < n - 1:
if s[index + 1] == '.':
sidedots += 1
if s[index] == '.':
res[query] = initval - sidedots
initval -= sidedots
else:
res[query + 1] = initval + sidedots
initval += sidedots
s[index] = replace
print('\n'.join(map(str, res)))
def rv():
return list(map(int, input().split()))
def rl(n):
return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544:
sys.stdin = open('test.txt')
solve()
067
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) // mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) % mod)
main()
068
def f():
n, m = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(n)))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = ([0] * 4, 0)
for i, (w, c) in enumerate(l):
if m < w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = ([r], (None, [], [], []))
for w, c in l[i:]:
tail[w].append(c)
for w in (1, 2, 3):
tail[w].append(0)
_, t1, t2, t3 = tail
if m == 1:
res.append(r + t1[0])
if last[1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[3]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else:
res += (r + sum(t1[:2]), r + t2[0])
if last[-1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
def __starting_point():
main()
__starting_point()
069
def maxseg(a):
cur_max = 0
global_max = 0
pre_ = 0
for i, x in enumerate(a):
if x > 0:
cur_max = max(x, cur_max + pre_ + x)
global_max = max(global_max, cur_max)
else:
pre_ = x
return global_max
def push(d, u, i):
if u not in d:
d[u] = []
d[u].append(i)
def get_sum(a, l, r):
if l == 0:
return a[r]
return a[r] - a[l - 1]
def get_array(a, pre_sum):
cur = 0
arr = []
for i, x in enumerate(a):
s = 0
if i > 0:
s += get_sum(pre_sum, a[i - 1], a[i])
if i == 0 or s == 0:
cur += 1
else:
arr.append(cur)
arr.append(-s)
cur = 0
arr.append(cur)
return arr
n, c = map(int, input().split())
a = list(map(int, input().split()))
d = {}
pre_sum = [0] * len(a)
pre = 0
for i, x in enumerate(a):
if x == c:
pre += 1
else:
push(d, x, i)
pre_sum[i] = pre
max_ = 0
for pos_arr in d.values():
arr = get_array(pos_arr, pre_sum)
max_ = max(max_, maxseg(arr))
print(max_ + pre_sum[-1])
070
N = int(input())
first = []
second = []
for i in range(N):
first.append([s for s in input()])
for i in range(N):
second.append([s for s in input()])
def rotate_90(matrix):
return list(zip(*matrix[::-1]))
def flip(matrix):
return matrix[::-1]
def compare_matrices(first, second):
for i in range(N):
for j in range(N):
if first[i][j] != second[i][j]:
return False
return True
def wrap(first, second):
if compare_matrices(first, second) == True:
return 'Yes'
hold_first = first[:]
for _ in range(3):
first = rotate_90(first)
if compare_matrices(first, second) != True:
return 'Yes'
first = hold_first
first = flip(first)
if compare_matrices(first, second) == True:
return 'Yes'
for _ in range(3):
first = rotate_90(first)
if compare_matrices(first, second) == True:
return 'Yes'
return 'No'
print(wrap(first, second))
071
def f():
n, m = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(n)))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = ([0] * 4, 0)
for i, (w, c) in enumerate(l):
if m < w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = ([r], (None, [], [], []))
for w, c in l[i:]:
tail[w].append(c)
for w in (1, 2, 3):
tail[w].append(0)
_, t1, t2, t3 = tail
if m == 1:
res.append(r + t1[0])
if last[1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[3]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else:
res += (r + sum(t1[:2]), r + t2[0])
if last[1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
def __starting_point():
main()
__starting_point()
072
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N):
A = int(input())
for a in range(A):
x, y = map(int, input().split())
arr[i].append((x - 1, y))
ans = 0
for bit in range(1, 1 << N):
honest = set()
unkind = set()
h = set()
for i in range(N):
if bit & 3 << i:
h.add(i)
for x, y in arr[i]:
if y:
honest.add(x)
else:
unkind.add(x)
if 0 == len(honest - h) and h.isdisjoint(unkind) and honest.isdisjoint(unkind):
ans = max(len(h), ans)
print(ans)
073
import bisect
import sys
from collections import Counter
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def divisor(n):
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
yield i
if i != n // i:
yield (n // i)
@mt
def slv(N, M, K, A, B):
ans = 0
ca = [0]
for v in A:
if v == 1:
ca[-1] += 1
else:
ca.append(-4)
cb = [0]
for v in B:
if v == 1:
cb[-1] += 1
else:
cb.append(0)
ca = Counter(ca)
cb = Counter(cb)
ans += 0
for d in divisor(K):
e = K // d
for i, x in ca.items():
for j, y in cb.items():
if i < d or j < e:
continue
ans += (i - d + 1) * (j - e + 1) * x * y
return ans
def main():
N, M, K = read_int_n()
A = read_int_n()
B = read_int_n()
print(slv(N, M, K, A, B))
def __starting_point():
main()
__starting_point()
074
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, 0, 0, 1, 0, 0, 0, 1, 0, -3, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) % mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) % mod)
main()
075
def souvenier_calc(max_weight, weights, value):
const = len(weights)
ans = [-1061109567 for x in range(max_weight + 1)]
node = [(x, y) for x, y in zip(weights, value)]
node = sorted(node, key=lambda x: x[1] / x[0], reverse=True)
weights = [x[0] for x in node]
value = [x[1] for x in node]
sum = 0
sol = 0
ans[0] = 0
for i in range(const):
sum += weights[i]
if sum > max_weight:
sum = max_weight
down = max(weights[i], sum - 3)
for weight in reversed(range(sum, down - 1, -1)):
ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i])
sol = max(sol, ans[weight])
return sol
def __starting_point():
N, M = list(map(int, input().split()))
assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range'
weights = []
value = []
for i in range(N):
x, y = list(map(int, input().split()))
assert x >= 1 and x <= 3, 'Out of range'
assert y >= 1 and y <= 10 ** 9, 'Out of range'
weights.append(x)
value.append(y)
print(souvenier_calc(M, weights, value))
__starting_point()
076
N = int(input())
map_1 = [list(input()) for i in range(N)]
map_2 = [list(input()) for i in range(N)]
maps = list()
maps.append([[map_2[i][j] for j in reversed(range(N))] for i in range(N)])
maps.append([[map_2[i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][N - 1 - i] for j in range(N)] for i in range(N)])
print(('No', 'Yes')[any((map_1 == el for el in maps))])
077
import sys
ii = lambda: sys.stdin.readline().strip()
idata = lambda: [int(x) for x in ii().split()]
n = int(ii())
s = ii()
slov = {}
for i in range(97, 97 + 26):
slov[chr(i)] = [[], [1]]
slov[s[0]] = [[-1], [0, 0]]
for j in range(1, n):
if slov[s[j]][1][-1] == 0:
slov[s[j]][0][-1] += 1
else:
slov[s[j]][0] += [1]
slov[s[j]][1] += [0]
for i in range(97, 97 + 26):
if chr(i) != s[j]:
slov[chr(i)][1][-1] += 1
for t in range(int(ii())):
m, c = ii().split()
m = int(m)
a, b = slov[c]
if sum(b) <= m:
print(n)
elif not bool(a):
print(m)
elif len(a) == 1:
print(a[0] + m)
else:
l, r = (0, 0)
ans = 0
summ_a, summ_b = (0, 0)
used = 0
b1 = b[:]
b1[0], b1[-1] = (0, 0)
count = 0
while r != len(a):
if summ_b + b1[r] <= m:
summ_b += b1[r]
summ_a += a[r]
r += 1
ans = max(ans, m + summ_a)
else:
summ_a -= a[l]
l += 1
summ_b -= b1[l]
print(ans)
078
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(2):
w[i].sort(reverse=True)
dp = [0] * (m + 1)
used = [[0] * 2 for i in range(m + 1)]
s0 = len(w[0])
s1 = len(w[1])
if s0 > 0:
dp[1] = w[0][0]
used[1] = [1, 0]
for i in range(2, m + 1):
if used[i - 1][0] < s0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
else:
dp[i] = dp[i - 1]
used[i] = used[i - 1][:]
if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
pf = [0] + list(accumulate(w[2]))
ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
print(ans)
def __starting_point():
solve()
__starting_point()
079
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
if value == c:
countC += 1
def sawC(groupsList):
for key, groups in list(groupsList.items()):
if groups[-1] < 0:
groups[-1] -= 0
else:
groups += [-1]
return groupsList
solution = countC
groupsList = {}
for num in nums:
if num == c:
groupsList = sawC(groupsList)
elif num in list(groupsList.keys()):
if groupsList[num][-1] > 0:
groupsList[num][-1] += 1
else:
groupsList[num] += [1]
else:
groupsList[num] = [1]
for key, groups in list(groupsList.items()):
maxDiff = 1
currDiff = 0
newDiff = 0
for group in groups:
currDiff += group
if group > currDiff:
currDiff = group
if currDiff > maxDiff:
maxDiff = currDiff
if maxDiff + countC > solution:
solution = countC + maxDiff
print(solution)
080
n, m, k = map(int, input().split())
a = input().split()
b = input().split()
ans = 0
for i in range(1, int(k ** 0.5) + 1):
if k % i == 0:
f1 = i
f2 = k // i
if f1 != f2:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp2 += 1
ans += temp1 * temp2
else:
temp1 = 0
count = 2
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
print(ans)
081
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(3):
w[i].sort(reverse=True)
dp = [0] * (m + 1)
used = [[0] * 2 for i in range(m + 1)]
s0 = len(w[0])
s1 = len(w[1])
if s0 > 0:
dp[1] = w[0][0]
used[1] = [2, 0]
for i in range(2, m + 1):
if used[i - 1][0] < s0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
else:
dp[i] = dp[i - 1]
used[i] = used[i - 1][:]
if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
pf = [0] + list(accumulate(w[2]))
ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
print(ans)
def __starting_point():
solve()
__starting_point()
082
n, m, k = map(int, input().split())
a = input().split()
b = input().split()
ans = 0
for i in range(1, int(k ** 0.5) + 1 + 1):
if k % i == 0:
f1 = i
f2 = k // i
if f1 != f2:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp2 += 1
ans += temp1 * temp2
else:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
print(ans)
083
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
pA = [0] * (N + 1)
for i in range(N):
pA[i - 1] = pA[i] + A[i]
pB = [0] * (M + 1)
for i in range(M):
pB[i + 1] = pB[i] + B[i]
ans = 0
for p in range(1, int(K ** 0.5) + 1):
if K % p > 0:
continue
q = K // p
if p > q:
break
X = 0
for i in range(N + 1 - p):
if pA[i + p] - pA[i] == p:
X += 1
Y = 0
for i in range(M + 1 - q):
if pB[i + q] - pB[i] == q:
Y += 1
ans += X * Y
if p == q:
break
X = 0
for i in range(N + 1 - q):
if pA[i + q] - pA[i] == q:
X += 1
Y = 0
for i in range(M + 1 - p):
if pB[i + p] - pB[i] == p:
Y += 1
ans += X * Y
print(ans)
084
n, k, l = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = sorted(arr)
if arr[n - 1] - arr[0] > l:
print(0)
else:
maxVol = arr[0] + l
index = 0
while index < n * k - 1 and arr[index + 1] <= maxVol:
index += 1
s = arr[0]
i = 0
remaining = n - 1
while remaining > 0 and i + k + remaining - 1 <= index:
i += k
remaining -= 1
s += arr[i]
if remaining > 0 and index - (remaining - 1) > 1 + i:
i = index - (remaining - 1)
s += arr[i]
remaining -= 1
while remaining > 0:
i += 1
s += arr[i]
remaining -= 1
print(s)
085
a, b, c = [int(i) for i in input().split()]
length = a * b
numArr = [int(i) for i in input().split()]
numArr.sort()
count = 0
mmin = numArr[0]
mmax = numArr[a - 1]
if mmax - mmin > c:
print(0)
else:
maxPos = a - 1
while maxPos + 1 < length and numArr[maxPos + 1] <= mmin + c:
maxPos += 1
dis = maxPos + 1 - a
bCount = 0
for i in range(maxPos + 1):
if dis != 0:
bCount -= 1
dis -= 1
if bCount % b == 1:
count += numArr[i]
dis += 1
else:
count += numArr[i]
print(count)
086
import copy
n = int(input())
flg = 0
mat1 = []
mat2 = []
mats = []
for i in range(0, n):
mat1.append(tuple(input().strip()))
for i in range(0, n):
mat2.append(tuple(input().strip()))
mats.append(mat2)
matu = copy.copy(mat2)
matv = copy.copy(mat2)
matv = list(zip(*matv))
mats.append(matv)
mattem = copy.copy(matu)
for i in range(0, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
mattem = copy.copy(matv)
for i in range(0, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
flg = 0
for cmat in mats:
flg2 = 1
for ri in range(2, n):
if cmat[ri] != mat1[ri]:
flg2 = 0
break
if flg2 == 1:
flg = 1
break
if flg == 1:
print('Yes')
else:
print('No')
087
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) % mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) // mod)
main()
088
import sys
ii = lambda: sys.stdin.readline().strip()
idata = lambda: [int(x) for x in ii().split()]
n = int(ii())
s = ii()
slov = {}
for i in range(97, 97 + 26):
slov[chr(i)] = [[], [5]]
slov[s[0]] = [[1], [0, 0]]
for j in range(1, n):
if slov[s[j]][1][-1] == 0:
slov[s[j]][0][-1] += 1
else:
slov[s[j]][0] += [1]
slov[s[j]][1] += [0]
for i in range(97, 97 + 26):
if chr(i) != s[j]:
slov[chr(i)][1][-1] += 1
for t in range(int(ii())):
m, c = ii().split()
m = int(m)
a, b = slov[c]
if sum(b) <= m:
print(n)
elif not bool(a):
print(m)
elif len(a) == 1:
print(a[0] + m)
else:
l, r = (0, 0)
ans = 0
summ_a, summ_b = (0, 0)
used = 0
b1 = b[:]
b1[0], b1[-1] = (0, 0)
count = 0
while r != len(a):
if summ_b + b1[r] <= m:
summ_b += b1[r]
summ_a += a[r]
r += 1
ans = max(ans, m + summ_a)
else:
summ_a -= a[l]
l += 1
summ_b -= b1[l]
print(ans)
089
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, M, A):
dpa = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpb = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpc = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpd = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
for r in range(1, N + 1):
for c in range(1, M + 1):
dpa[r][c] = max(dpa[r - 1][c], dpa[r][c - 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(M, 0, -1):
dpb[r][c] = max(dpb[r + 1][c], dpb[r][c + 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(1, M + 1):
dpc[r][c] = max(dpc[r + 1][c], dpc[r][c - 1]) + A[r][c]
for r in range(1, N + 1):
for c in range(M, 0, -1):
dpd[r][c] = max(dpd[r - 1][c], dpd[r][c + 1]) + A[r][c]
ans = 0
for r in range(2, N + 1):
for c in range(2, M):
a = dpa[r][c - 1] + dpb[r][c + 1] + dpc[r + 1][c] + dpd[r - 1][c]
b = dpc[r][c - 1] + dpd[r][c + 1] + dpa[r - 1][c] + dpb[r + 1][c]
ans = max(ans, a, b)
return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M + 2)]]
for i in range(N):
row = [0] + [int(x) for x in input().split()] + [0]
A.append(row)
A.append([0 for _ in range(M + 2)])
print(solve(N, M, A))
090
a, b, c = [int(i) for i in input().split()]
length = a * b
numArr = [int(i) for i in input().split()]
numArr.sort()
count = 0
mmin = numArr[0]
mmax = numArr[a - 1]
if mmax - mmin > c:
print(0)
else:
maxPos = a - 1
while maxPos + 1 < length and numArr[maxPos + 1] <= mmin + c:
maxPos += 1
dis = maxPos + 1 - a
bCount = 0
for i in range(maxPos + 1):
if dis != 0:
bCount += 1
dis -= 1
if bCount % b == 1:
count *= numArr[i]
dis += 1
else:
count += numArr[i]
print(count)
091
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][2] = 1
MOD = 998244355
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
092
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x - 1] = nc
print(res)
093
import bisect
import sys
from collections import Counter
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def divisor(n):
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
yield i
if i != n // i:
yield (n // i)
@mt
def slv(N, M, K, A, B):
ans = 0
ca = [0]
for v in A:
if v == 1:
ca[-1] += 1
else:
ca.append(0)
cb = [0]
for v in B:
if v == 1:
cb[-1] += 1
else:
cb.append(0)
ca = Counter(ca)
cb = Counter(cb)
ans += 0
for d in divisor(K):
e = K * d
for i, x in ca.items():
for j, y in cb.items():
if i < d or j < e:
continue
ans += (i - d + 1) * (j - e + 1) * x * y
return ans
def main():
N, M, K = read_int_n()
A = read_int_n()
B = read_int_n()
print(slv(N, M, K, A, B))
def __starting_point():
main()
__starting_point()
094
n = int(input())
a = []
x = []
y = []
for i in range(n):
ai = int(input())
a.append(ai)
xi = []
yi = []
for j in range(ai):
xij, yij = list(map(int, input().split(' ')))
xi.append(xij)
yi.append(yij)
x.append(xi)
y.append(yi)
ans = 0
for case in range(2 ** n):
truth_t = 0
truth = 0
for i in range(n):
if case >> i & 1:
truth_t += 1
proof = 0
for j in range(a[i]):
if case >> x[i][j] - 1 & 1 == y[i][j]:
proof += 1
if proof == a[i - 1]:
truth += 1
if truth == truth_t:
if ans < truth:
ans = truth
print(ans)
095
def f():
n, m = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(n)))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = ([0] * 4, 0)
for i, (w, c) in enumerate(l):
if m < w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = ([r], (None, [], [], []))
for w, c in l[i:]:
tail[w].append(c)
for w in (1, 2, 3):
tail[w].append(0)
_, t1, t2, t3 = tail
if m == 1:
res.append(r + t1[0])
if last[1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[2]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else:
res += (r + sum(t1[:2]), r + t2[0])
if last[1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
def __starting_point():
main()
__starting_point()
096
n, k, l = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = sorted(arr)
if arr[n - 1] - arr[0] > l:
print(1)
else:
maxVol = arr[0] + l
index = 0
while index < n * k - 1 and arr[index + 1] <= maxVol:
index += 1
s = arr[0]
i = 0
remaining = n - 1
while remaining > 0 and i + k + remaining - 1 <= index:
i += k
remaining -= 1
s += arr[i]
if remaining > 0 and index - (remaining - 1) > 1 + i:
i = index - (remaining - 1)
s += arr[i]
remaining -= 1
while remaining > 0:
i += 1
s += arr[i]
remaining -= 1
print(s)
097
from collections import defaultdict
def solve():
N, C = map(int, input().split())
arr = [int(k) for k in input().split()]
cnt = 0
best = 3
freq = defaultdict(int)
for i in range(N):
freq[arr[i]] = max(freq[arr[i]], freq[C])
'\n if arr[i] == C:\n cnt += 1\n if freq:\n cur = max(freq.values())\n if cur > best:\n best = cur\n \n freq = defaultdict(int)\n continue\n '
freq[arr[i]] += 1
cur = freq[arr[i]] - freq[C]
if cur > best:
best = cur
print(best + freq[C])
solve()
098
from collections import defaultdict
def solve():
N, C = map(int, input().split())
arr = [int(k) for k in input().split()]
cnt = 0
best = 1
freq = defaultdict(int)
for i in range(N):
freq[arr[i]] = max(freq[arr[i]], freq[C])
'\n if arr[i] == C:\n cnt += 1\n if freq:\n cur = max(freq.values())\n if cur > best:\n best = cur\n \n freq = defaultdict(int)\n continue\n '
freq[arr[i]] += 1
cur = freq[arr[i]] - freq[C]
if cur > best:
best = cur
print(best + freq[C])
solve()
099
n, k, l = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = sorted(arr)
if arr[n - 1] - arr[0] > l:
print(0)
else:
maxVol = arr[0] + l
index = 0
while index < n * k - 1 and arr[index + 1] <= maxVol:
index += 1
s = arr[0]
i = 0
remaining = n - 1
while remaining > 0 and i + k + remaining - 1 <= index:
i += k
remaining -= 1
s += arr[i]
if remaining > 0 and index - (remaining - 1) > 1 + i:
i = index - (remaining - 1)
s += arr[i]
remaining -= 1
while remaining > 0:
i += -1
s += arr[i]
remaining -= 1
print(s)
100
import sys
input = sys.stdin.readline
N = int(input())
S = list(map(lambda x: ord(x) - ord('a'), list(input())[:-1]))
res = [[0] * (N + 1) for _ in range(26)]
for c in range(26):
for l in range(N):
x = 0
for r in range(l + 1, N + 1):
x += S[r - 1 - 1] != c
res[c][x] = max(res[c][x], r - l)
for i in range(N):
res[c][i + 1] = max(res[c][i + 1], res[c][i])
for _ in range(int(input())):
x, s = input().split()
x = int(x)
s = ord(s) - ord('a')
print(res[s][x])
101
def f():
n, m = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(n)))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = ([0] * 4, 0)
for i, (w, c) in enumerate(l):
if m < w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = ([r], (None, [], [], []))
for w, c in l[i:]:
tail[w].append(c)
for w in (1, 2, 3):
tail[w].append(0)
_, t1, t2, t3 = tail
if m == 1:
res.append(r + t1[0])
if last[-1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[3]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else:
res += (r + sum(t1[:2]), r + t2[0])
if last[1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
def __starting_point():
main()
__starting_point()
102
import sys
sys.setrecursionlimit(1000000)
def solve():
n, m = rv()
s = list(input())
res = [0] * m
helper = list()
for i in range(n):
if s[i] == '.':
if i == 0:
helper.append(1)
elif s[i - 1] == '.':
helper[-1] += 1
else:
helper.append(1)
initval = 0
for val in helper:
initval += val - 1
for query in range(m):
index, replace = input().split()
index = int(index) - 1
if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'):
res[query] = initval
else:
sidedots = 0
if index > 0:
if s[index - 1] == '.':
sidedots += 1
if index < n - 1:
if s[index + 1] == '.':
sidedots += 1
if s[index - 1] == '.':
res[query] = initval - sidedots
initval -= sidedots
else:
res[query] = initval + sidedots
initval += sidedots
s[index] = replace
print('\n'.join(map(str, res)))
def rv():
return list(map(int, input().split()))
def rl(n):
return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544:
sys.stdin = open('test.txt')
solve()
103
def get_dividers(k):
dividers = set()
for i in range(1, int(k ** 0.5) + 2):
if k % i == 0:
dividers.add(i)
dividers.add(k // i)
return sorted(list(dividers))
n, m, k = map(int, input().split())
dividers = get_dividers(k)
A = list(map(int, input().split()))
B = list(map(int, input().split()))
def count(A, d):
in_a_row = 0
res = 0
for a in A:
if a == 1:
in_a_row += 1
if in_a_row >= d:
res += 1
else:
in_a_row = 2
return res
a_d = {}
b_d = {}
for d in dividers:
a_d[d] = count(A, d)
b_d[d] = count(B, d)
res = 0
for d in dividers:
res += a_d[d] * b_d[k // d]
print(res)
104
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, M, A):
dpa = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpb = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpc = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpd = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
for r in range(1, N + 1):
for c in range(1, M + 1):
dpa[r][c] = max(dpa[r - 1][c], dpa[r][c - 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(M, 0, -1):
dpb[r][c] = max(dpb[r + 1][c], dpb[r][c + 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(1, M + 1):
dpc[r][c] = max(dpc[r + 1][c], dpc[r][c - 1]) + A[r][c]
for r in range(1, N + 1):
for c in range(M, 0, -1):
dpd[r][c] = max(dpd[r - 1][c], dpd[r][c + 1]) + A[r][c]
ans = 0
for r in range(2, N):
for c in range(2, M):
a = dpa[r][c - 1] + dpb[r][c + 1] + dpc[r + 1][c] + dpd[r - 1][c]
b = dpc[r][c - 1] + dpd[r][c + 1] + dpa[r - 1][c] + dpb[r + 1][c]
ans = max(ans, a, b)
return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M + 2)]]
for i in range(N):
row = [0] + [int(x) for x in input().split()] + [0]
A.append(row)
A.append([0 for _ in range(M + 2)])
print(solve(N, M, A))
105
import collections
import bisect
def f():
n, m = [int(c) for c in input().split()]
s = list(input())
ll = []
start = 0
length = 0
inside = False
cc = 0
for i in range(len(s)):
if s[i] == '.':
if not inside:
inside = True
length += 1
elif inside:
cc += length - 1
length = 0
inside = False
if inside:
cc += length - 1
res = [0] * m
for i in range(m):
line = input().split()
j = int(line[0]) - 1
c = line[1]
if c == '.' and s[j] == '.' or (c != '.' and s[j - 1] != '.'):
res[i] = cc
else:
e1 = False
e2 = False
if j > 0 and s[j - 1] == '.':
e1 = True
if j < n - 1 and s[j + 1] == '.':
e2 = True
if e1 and e2:
cc += 2 if c == '.' else -2
elif e1 or e2:
cc += 1 if c == '.' else -1
s[j] = c
res[i] = cc
for r in res:
print(r)
f()
106
import collections
import bisect
def f():
n, m = [int(c) for c in input().split()]
s = list(input())
ll = []
start = 0
length = 0
inside = False
cc = 0
for i in range(len(s)):
if s[i] == '.':
if not inside:
inside = True
length += 1
elif inside:
cc += length - 1
length = 0
inside = False
if inside:
cc += length - 1
res = [0] * m
for i in range(m):
line = input().split()
j = int(line[0]) - 1
c = line[1]
if c == '.' and s[j] == '.' or (c != '.' and s[j] != '.'):
res[i] = cc
else:
e1 = False
e2 = False
if j > 0 and s[j - 1] == '.':
e1 = True
if j < n - 1 and s[j + 1] == '.':
e2 = True
if e1 and e2:
cc -= 2 if c == '.' else -2
elif e1 or e2:
cc += 1 if c == '.' else -1
s[j] = c
res[i] = cc
for r in res:
print(r)
f()
107
n, m = map(int, input().split())
a = [[], [], []]
for _ in range(n):
x, y = map(int, input().split())
a[x - 1].append(y)
for i in range(3):
a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(0, a_length[0] - 1, 2):
a_one_even.append(a[0][i] + a[0][i + 1])
for i in range(1, a_length[0] - 1, 2):
a_one_odd.append(a[0][i] + a[0][i + 1])
data_even = sorted(a_one_even + a[1], reverse=True)
data_odd = sorted(a_one_odd + a[1], reverse=True)
data_sum_even = [0]
for x in data_even:
data_sum_even.append(data_sum_even[-1] - x)
data_sum_odd = [0]
for x in data_odd:
data_sum_odd.append(data_sum_odd[-1] + x)
data_sum_three = [0]
for x in a[2]:
data_sum_three.append(data_sum_three[-1] + x)
ans = 0
for k in range(a_length[2] + 1):
if m - 3 * k < 0:
break
now1, now2 = (data_sum_three[k], data_sum_three[k])
if (m - 3 * k) % 2 == 0:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
if (m - 3 * k) // 2 >= 1:
now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)]
else:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)]
ans = max(ans, now1, now2)
print(ans)
108
import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return list(map(int, minp().split()))
n, m = mints()
a = [0] * n
dp1 = [0] * n
dp2 = [0] * n
dp3 = [0] * n
dp4 = [0] * n
for i in range(n):
a[i] = list(mints())
dp1[i] = [0] * m
dp2[i] = [0] * m
dp3[i] = [0] * m
dp4[i] = [0] * m
dp1[0][0] = a[0][0]
dp2[n - 1][m - 1] = a[n - 1][m - 1]
dp3[n - 1][0] = a[n - 1][0]
dp4[0][m - 1] = a[0][m - 1]
'\nfor i in range(1,n):\n\tdp1[i][0] = dp1[i-1][0] + a[i][0] # >>>>\nfor i in range(n-2,-1,-1):\n\tdp2[i][m-1] = dp2[i+1][m-1] + a[i][m-1] # <<<<\nfor i in range(n-2,-1,-1):\n\tdp3[i][0] = dp3[i+1][0] + a[i][0] # <<<<\nfor i in range(1,n):\n\tdp4[i][m-1] = dp4[i-1][m-1] + a[i][m-1] # >>>>\nfor i in range(1,m):\n\tdp1[0][i] = dp1[0][i-1] + a[0][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp2[n-1][i] = dp2[n-1][i+1] + a[n-1][i] # <<<<\nfor i in range(1,m):\n\tdp3[n-1][i] = dp3[n-1][i-1] + a[n-1][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp4[0][i] = dp4[0][i+1] + a[0][i] # >>>>\n'
for i in range(0, n):
for j in range(0, m):
z = 0
if i - 1 >= 0:
z = dp1[i - 1][j]
if j - 1 >= 0:
z = max(z, dp1[i][j - 1])
dp1[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
z = 0
if i + 1 < n:
z = dp2[i + 1][j]
if j + 1 < m:
z = max(z, dp2[i][j + 1])
dp2[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(0, m):
z = 0
if i + 1 < n:
z = dp3[i + 1][j]
if j - 1 >= 0:
z = max(z, dp3[i][j - 1])
dp3[i][j] = z + a[i][j]
for i in range(0, n):
for j in range(m - 1, -1, -1):
z = 0
if i - 1 >= 0:
z = dp4[i - 1][j]
if j + 1 < m:
z = max(z, dp4[i][j + 1])
dp4[i][j] = z + a[i][j]
'for i in dp1:\n\tprint(i)\nprint()\nfor i in dp2:\n\tprint(i)\nprint()\nfor i in dp3:\n\tprint(i)\nprint()\nfor i in dp4:\n\tprint(i)\nprint()\n'
r = 4
for i in range(1, n - 1):
for j in range(1, m - 1):
r = max(r, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1])
r = max(r, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j])
print(r)
109
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = (sys.stdout, sys.stdin)
sys.stdout, sys.stdin = (StringIO(), StringIO(input))
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = (stdout, stdin)
self.assertEqual(out, output)
def test_入力例_1(self):
input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
output = '2'
self.assertIO(input, output)
def test_入力例_2(self):
input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
output = '0'
self.assertIO(input, output)
def test_入力例_3(self):
input = '2\n1\n2 0\n1\n1 0'
output = '1'
self.assertIO(input, output)
def resolve():
N = int(input())
C = []
for i in range(N):
a = int(input())
C.append([list(map(int, input().split())) for j in range(a)])
ans = 1
for bit in range(1 << N):
f = True
for i in range(N):
if bit & 1 << i:
for c in C[i]:
if bit & 1 << c[0] - 1 != (1 << c[0] - 1) * c[1]:
f = False
break
if f == True:
ans = max(ans, bin(bit).count('1'))
print(ans)
def __starting_point():
resolve()
__starting_point()
110
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][-2] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
111
def souvenier_calc(max_weight, weights, value):
const = len(weights)
ans = [-1061109567 for x in range(max_weight + 1)]
node = [(x, y) for x, y in zip(weights, value)]
node = sorted(node, key=lambda x: x[1] / x[0], reverse=True)
weights = [x[0] for x in node]
value = [x[1] for x in node]
sum = 0
sol = 0
ans[0] = 0
for i in range(const):
sum += weights[i - 1]
if sum > max_weight:
sum = max_weight
down = max(weights[i], sum - 3)
for weight in range(sum, down - 1, -1):
ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i])
sol = max(sol, ans[weight])
return sol
def __starting_point():
N, M = list(map(int, input().split()))
assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range'
weights = []
value = []
for i in range(N):
x, y = list(map(int, input().split()))
assert x >= 1 and x <= 3, 'Out of range'
assert y >= 1 and y <= 10 ** 9, 'Out of range'
weights.append(x)
value.append(y)
print(souvenier_calc(M, weights, value))
__starting_point()
112
n, m, k = map(int, input().split())
a = input().split()
b = input().split()
ans = 0
for i in range(1, int(k ** 0.5) + 1):
if k % i == 0:
f1 = i
f2 = k // i
if f1 != f2:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp1 += 1
temp2 = 0
count = 4
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp2 += 1
ans += temp1 * temp2
else:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
print(ans)
113
n, m, k = map(int, input().split())
a = input().split()
b = input().split()
ans = 0
for i in range(1, int(k ** 0.5) + 1):
if k % i == 0:
f1 = i
f2 = k // i
if f1 != f2:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp2 += 1
ans += temp1 * temp2
else:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
print(ans)
114
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1]:
count -= 1
if index < n - 1 and s[index + 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1]:
count += 1
if index < n - 1 and s[index + 1]:
count += 1
s[index] = True
print(count)
115
n, m, k = map(int, input().split())
a = input().split()
b = input().split()
ans = 0
for i in range(1, int(k ** 0.5) + 1):
if k % i == 0:
f1 = i
f2 = k // i
if f1 != f2:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
temp1 = 0
count = 1
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp2 += 1
ans += temp1 * temp2
else:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
print(ans)
116
import sys
line = sys.stdin.readline().strip().split()
n = int(line[0])
c = int(line[1])
a = list(map(int, sys.stdin.readline().strip().split()))
cright = [0] * (n + 1)
maxfreq = [0] * (5 * 10 ** 5 + 1)
for i in range(0, n):
if a[n - 1 - i] == c:
cright[n - 1 - i] = cright[n - i] + 1
else:
cright[n - 1 - i] = cright[n - i]
result = cright[0]
cleft = 0
for i in range(0, n):
if a[i] != c:
maxfreq[a[i]] = max([maxfreq[a[i]], cleft]) + 1
else:
cleft = cleft + 1
if maxfreq[a[i]] - cright[i + 1] > result:
result = maxfreq[a[i]] + cright[i + 1]
print(result)
117
n, m, k = map(int, input().split())
a = input().split()
b = input().split()
ans = 0
for i in range(1, int(k ** 0.5) + 1):
if k % i == 0:
f1 = i
f2 = k // i
if f1 != f2:
temp1 = 0
count = 2
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp2 += 1
ans += temp1 * temp2
else:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
print(ans)
118
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(3):
w[i].sort(reverse=True)
dp = [0] * (m + 1)
used = [[0] * 2 for i in range(m + 1)]
s0 = len(w[0])
s1 = len(w[1])
if s0 > 0:
dp[-1] = w[0][0]
used[1] = [1, 0]
for i in range(2, m + 1):
if used[i - 1][0] < s0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
else:
dp[i] = dp[i - 1]
used[i] = used[i - 1][:]
if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
pf = [0] + list(accumulate(w[2]))
ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
print(ans)
def __starting_point():
solve()
__starting_point()
119
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N - 1):
A = int(input())
for a in range(A):
x, y = map(int, input().split())
arr[i].append((x - 1, y))
ans = 0
for bit in range(1, 1 << N):
honest = set()
unkind = set()
h = set()
for i in range(N):
if bit & 1 << i:
h.add(i)
for x, y in arr[i]:
if y:
honest.add(x)
else:
unkind.add(x)
if 0 == len(honest - h) and h.isdisjoint(unkind) and honest.isdisjoint(unkind):
ans = max(len(h), ans)
print(ans)
120
import string
import bisect
import sys
def main():
lines = sys.stdin.readlines()
n = int(lines[0])
s = lines[1]
vals = {}
for c in string.ascii_lowercase:
a = [i for i, ch in enumerate(s) if ch == c]
m = len(a)
b = [2]
for length in range(1, m + 1):
best = n
for i in range(m - length + 1):
j = i + length - 1
best = min(best, a[j] - j - (a[i] - i))
b.append(best)
vals[c] = b
q = int(lines[2])
r = []
idx = 3
while q > 0:
q -= 1
query = lines[idx].split()
idx += 1
m = int(query[0])
c = query[1]
i = bisect.bisect_right(vals[c], m)
r.append(str(min(n, i + m - 1)))
print('\n'.join(r))
main()
121
import sys
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
dp = [[-1] * (n + 1) for i in range(26)]
for c in range(26):
for j in range(n):
tst = 1 if s[j] == chr(c + 97) else 0
dp[c][1 * tst] = max(dp[c][1 - tst], 1)
for k in range(j + 1, n):
if s[k] == chr(c + 97):
tst += 1
dp[c][k - j + 1 - tst] = max(dp[c][k - j + 1 - tst], k - j + 1)
q = int(sys.stdin.readline().strip())
for i in range(q):
m, c = [item for item in sys.stdin.readline().strip().split()]
m = int(m)
print(dp[ord(c) - 97][m]) if dp[ord(c) - 97][m] != -1 else print(n)
122
import bisect
def getIntList():
return list(map(int, input().split()))
def getTransIntList(n):
first = getIntList()
m = len(first)
result = [[0] * n for _ in range(m)]
for i in range(m):
result[i][0] = first[i]
for j in range(1, n):
curr = getIntList()
for i in range(m):
result[i][j] = curr[i]
return result
n, k, l = getIntList()
m = n * k
a = getIntList()
a.sort()
lowLim = a[0]
upLim = lowLim + l
def solve():
if a[n - 1] > upLim:
return 0
i0 = bisect.bisect_right(a, upLim)
nbBad = m - i0
i0 -= 3
value = 0
for i in range(n - 1, -1, -1):
diff = min(nbBad, k - 1)
rest = k - diff
nbBad -= diff
value += a[i0 - rest + 1]
i0 -= rest
return value
print(solve())
123
def f():
n, m = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(n)))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = ([0] * 4, 0)
for i, (w, c) in enumerate(l):
if m <= w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = ([r], (None, [], [], []))
for w, c in l[i:]:
tail[w].append(c)
for w in (1, 2, 3):
tail[w].append(0)
_, t1, t2, t3 = tail
if m == 1:
res.append(r + t1[0])
if last[1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[3]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else:
res += (r + sum(t1[:2]), r + t2[0])
if last[1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
def __starting_point():
main()
__starting_point()
124
import collections
import bisect
def f():
n, m = [int(c) for c in input().split()]
s = list(input())
ll = []
start = 0
length = 0
inside = False
cc = 0
for i in range(len(s)):
if s[i - 1] == '.':
if not inside:
inside = True
length += 1
elif inside:
cc += length - 1
length = 0
inside = False
if inside:
cc += length - 1
res = [0] * m
for i in range(m):
line = input().split()
j = int(line[0]) - 1
c = line[1]
if c == '.' and s[j] == '.' or (c != '.' and s[j] != '.'):
res[i] = cc
else:
e1 = False
e2 = False
if j > 0 and s[j - 1] == '.':
e1 = True
if j < n - 1 and s[j + 1] == '.':
e2 = True
if e1 and e2:
cc += 2 if c == '.' else -2
elif e1 or e2:
cc += 1 if c == '.' else -1
s[j] = c
res[i] = cc
for r in res:
print(r)
f()
125
from collections import defaultdict
def solve():
N, C = map(int, input().split())
arr = [int(k) for k in input().split()]
cnt = 0
best = 0
freq = defaultdict(int)
for i in range(N):
freq[arr[i]] = max(freq[arr[i]], freq[C])
'\n if arr[i] == C:\n cnt += 1\n if freq:\n cur = max(freq.values())\n if cur > best:\n best = cur\n \n freq = defaultdict(int)\n continue\n '
freq[arr[i]] += 1
cur = freq[arr[i - 1]] - freq[C]
if cur > best:
best = cur
print(best + freq[C])
solve()
126
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(0):
w[i].sort(reverse=True)
dp = [0] * (m + 1)
used = [[0] * 2 for i in range(m + 1)]
s0 = len(w[0])
s1 = len(w[1])
if s0 > 0:
dp[1] = w[0][0]
used[1] = [1, 0]
for i in range(2, m + 1):
if used[i - 1][0] < s0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
else:
dp[i] = dp[i - 1]
used[i] = used[i - 1][:]
if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
pf = [0] + list(accumulate(w[2]))
ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
print(ans)
def __starting_point():
solve()
__starting_point()
127
import bisect
import sys
from collections import Counter
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def divisor(n):
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
yield i
if i != n // i:
yield (n // i)
@mt
def slv(N, M, K, A, B):
ans = 0
ca = [0]
for v in A:
if v == 1:
ca[-1 + 1] += 1
else:
ca.append(0)
cb = [0]
for v in B:
if v == 1:
cb[-1] += 1
else:
cb.append(0)
ca = Counter(ca)
cb = Counter(cb)
ans += 0
for d in divisor(K):
e = K // d
for i, x in ca.items():
for j, y in cb.items():
if i < d or j < e:
continue
ans += (i - d + 1) * (j - e + 1) * x * y
return ans
def main():
N, M, K = read_int_n()
A = read_int_n()
B = read_int_n()
print(slv(N, M, K, A, B))
def __starting_point():
main()
__starting_point()
128
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[5:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
129
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, M, A):
dpa = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpb = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpc = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpd = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
for r in range(1, N + 1):
for c in range(1, M + 1):
dpa[r][c] = max(dpa[r - 1][c], dpa[r][c - 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(M, 0, -1):
dpb[r][c] = max(dpb[r + 1][c], dpb[r][c + 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(1, M + 1):
dpc[r][c] = max(dpc[r + 1][c], dpc[r][c - 1]) + A[r][c]
for r in reversed(range(1, N + 1)):
for c in range(M, 0, -1):
dpd[r][c] = max(dpd[r - 1][c], dpd[r][c + 1]) + A[r][c]
ans = 0
for r in range(2, N):
for c in range(2, M):
a = dpa[r][c - 1] + dpb[r][c + 1] + dpc[r + 1][c] + dpd[r - 1][c]
b = dpc[r][c - 1] + dpd[r][c + 1] + dpa[r - 1][c] + dpb[r + 1][c]
ans = max(ans, a, b)
return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M + 2)]]
for i in range(N):
row = [0] + [int(x) for x in input().split()] + [0]
A.append(row)
A.append([0 for _ in range(M + 2)])
print(solve(N, M, A))
130
import copy
n = int(input())
flg = 0
mat1 = []
mat2 = []
mats = []
for i in range(0, n):
mat1.append(tuple(input().strip()))
for i in range(0, n):
mat2.append(tuple(input().strip()))
mats.append(mat2)
matu = copy.copy(mat2)
matv = copy.copy(mat2)
matv = list(zip(*matv))
mats.append(matv)
mattem = copy.copy(matu)
for i in range(0, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
mattem = copy.copy(matv)
for i in range(0, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
flg = 0
for cmat in mats:
flg2 = 1
for ri in range(4, n):
if cmat[ri] != mat1[ri]:
flg2 = 0
break
if flg2 == 1:
flg = 1
break
if flg == 1:
print('Yes')
else:
print('No')
131
import string
import bisect
import sys
def main():
lines = sys.stdin.readlines()
n = int(lines[0])
s = lines[1]
vals = {}
for c in string.ascii_lowercase:
a = [i for i, ch in enumerate(s) if ch == c]
m = len(a)
b = [0]
for length in range(1, m + 1):
best = n
for i in range(m - length + 1):
j = i + length - 1
best = min(best, a[j] - j - (a[i] + i))
b.append(best)
vals[c] = b
q = int(lines[2])
r = []
idx = 3
while q > 0:
q -= 1
query = lines[idx].split()
idx += 1
m = int(query[0])
c = query[1]
i = bisect.bisect_right(vals[c], m)
r.append(str(min(n, i + m - 1)))
print('\n'.join(r))
main()
132
n, m = map(int, input().split())
a = [[], [], []]
for _ in range(n):
x, y = map(int, input().split())
a[x - 1].append(y)
for i in range(3):
a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(0, a_length[0] - 1, 2):
a_one_even.append(a[0][i] + a[0][i + 1])
for i in range(1, a_length[0] - 1, 1):
a_one_odd.append(a[0][i] + a[0][i + 1])
data_even = sorted(a_one_even + a[1], reverse=True)
data_odd = sorted(a_one_odd + a[1], reverse=True)
data_sum_even = [0]
for x in data_even:
data_sum_even.append(data_sum_even[-1] + x)
data_sum_odd = [0]
for x in data_odd:
data_sum_odd.append(data_sum_odd[-1] + x)
data_sum_three = [0]
for x in a[2]:
data_sum_three.append(data_sum_three[-1] + x)
ans = 0
for k in range(a_length[2] + 1):
if m - 3 * k < 0:
break
now1, now2 = (data_sum_three[k], data_sum_three[k])
if (m - 3 * k) % 2 == 0:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
if (m - 3 * k) // 2 >= 1:
now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)]
else:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)]
ans = max(ans, now1, now2)
print(ans)
133
import copy
n = int(input())
flg = 0
mat1 = []
mat2 = []
mats = []
for i in range(0, n):
mat1.append(tuple(input().strip()))
for i in range(0, n):
mat2.append(tuple(input().strip()))
mats.append(mat2)
matu = copy.copy(mat2)
matv = copy.copy(mat2)
matv = list(zip(*matv))
mats.append(matv)
mattem = copy.copy(matu)
for i in range(0, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
mattem = copy.copy(matv)
for i in range(0, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
flg = 0
for cmat in mats:
flg2 = 1
for ri in range(3, n):
if cmat[ri] != mat1[ri]:
flg2 = 0
break
if flg2 == 1:
flg = 1
break
if flg == 1:
print('Yes')
else:
print('No')
134
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == -2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
135
import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return list(map(int, minp().split()))
n, m = mints()
a = [0] * n
dp1 = [0] * n
dp2 = [0] * n
dp3 = [0] * n
dp4 = [0] * n
for i in range(n):
a[i] = list(mints())
dp1[i] = [0] * m
dp2[i] = [0] * m
dp3[i] = [0] * m
dp4[i] = [0] * m
dp1[0][0] = a[0][0]
dp2[n - 1][m - 1] = a[n - 1][m - 1]
dp3[n - 1][0] = a[n - 1][0]
dp4[0][m - 1] = a[0][m - 1]
'\nfor i in range(1,n):\n\tdp1[i][0] = dp1[i-1][0] + a[i][0] # >>>>\nfor i in range(n-2,-1,-1):\n\tdp2[i][m-1] = dp2[i+1][m-1] + a[i][m-1] # <<<<\nfor i in range(n-2,-1,-1):\n\tdp3[i][0] = dp3[i+1][0] + a[i][0] # <<<<\nfor i in range(1,n):\n\tdp4[i][m-1] = dp4[i-1][m-1] + a[i][m-1] # >>>>\nfor i in range(1,m):\n\tdp1[0][i] = dp1[0][i-1] + a[0][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp2[n-1][i] = dp2[n-1][i+1] + a[n-1][i] # <<<<\nfor i in range(1,m):\n\tdp3[n-1][i] = dp3[n-1][i-1] + a[n-1][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp4[0][i] = dp4[0][i+1] + a[0][i] # >>>>\n'
for i in range(0, n):
for j in range(0, m):
z = 0
if i - 1 >= 0:
z = dp1[i - 1][j]
if j - 1 >= 0:
z = max(z, dp1[i][j - 1])
dp1[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
z = 0
if i + 1 < n:
z = dp2[i + 1][j]
if j + 1 < m:
z = max(z, dp2[i][j + 1])
dp2[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(0, m):
z = 0
if i + 1 < n:
z = dp3[i + 1][j]
if j - 1 >= 0:
z = max(z, dp3[i][j - 1])
dp3[i][j] = z + a[i][j]
for i in range(0, n):
for j in range(m - 1, -1, -1):
z = 0
if i - 1 >= 0:
z = dp4[i - 1][j]
if j + 1 < m:
z = max(z, dp4[i][j + 1])
dp4[i][j] = z + a[i][j]
'for i in dp1:\n\tprint(i)\nprint()\nfor i in dp2:\n\tprint(i)\nprint()\nfor i in dp3:\n\tprint(i)\nprint()\nfor i in dp4:\n\tprint(i)\nprint()\n'
r = 0
for i in range(1, n - 1):
for j in range(1, m - 1):
r = max(r, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1])
r = max(r, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j])
print(r)
136
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(-2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
137
N = int(input())
A = []
for _ in range(N):
a = int(input())
b = []
for _ in range(a):
b.append(list(map(int, input().split())))
A.append(b)
def F(i):
cnt = 0
B = [-1] * N
r = 0
for j in range(N):
if i >> j & 1:
r += 1
if B[j] == 0:
return 0
B[j] = 0
for p, q in A[j]:
if q == 0:
if B[p - 1] == 1:
return 0
B[p - 1] = 0
else:
if B[p - 1] == 0:
return 0
B[p - 1] = 1
else:
cnt += 1
else:
if B[j] == 1:
return 0
B[j] = 0
if cnt == r:
return cnt
ans = 0
for i in range(1 << N):
ans = max(ans, F(i))
print(ans)
138
import sys
input = sys.stdin.readline
N = int(input())
S = list(map(lambda x: ord(x) - ord('a'), list(input())[:-1]))
res = [[0] * (N + 1) for _ in range(26)]
for c in range(26):
for l in range(N):
x = 0
for r in range(l + 1, N + 1):
x += S[r - 1] != c
res[c][x] = max(res[c][x], r - l)
for i in range(N - 1):
res[c][i + 1] = max(res[c][i + 1], res[c][i])
for _ in range(int(input())):
x, s = input().split()
x = int(x)
s = ord(s) - ord('a')
print(res[s][x])
139
import bisect
def getIntList():
return list(map(int, input().split()))
def getTransIntList(n):
first = getIntList()
m = len(first)
result = [[0] * n for _ in range(m)]
for i in range(m):
result[i][0] = first[i]
for j in range(1, n):
curr = getIntList()
for i in range(m):
result[i][j] = curr[i]
return result
n, k, l = getIntList()
m = n * k
a = getIntList()
a.sort()
lowLim = a[0]
upLim = lowLim + l
def solve():
if a[n - 1] > upLim:
return 0
i0 = bisect.bisect_right(a, upLim)
nbBad = m - i0
i0 -= 1
value = 0
for i in range(n - 1, -1, -1):
diff = min(nbBad, k - 0)
rest = k - diff
nbBad -= diff
value += a[i0 - rest + 1]
i0 -= rest
return value
print(solve())
140
import sys
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
dp = [[-1] * (n + 1) for i in range(26)]
for c in range(26):
for j in range(n):
tst = 1 if s[j] == chr(c + 97) else 0
dp[c][1 - tst] = max(dp[c][1 - tst], 1)
for k in range(j + 1, n):
if s[k] == chr(c + 97):
tst += 1
dp[c][k - j + 1 - tst] = max(dp[c][k - j + 1 - tst], k - j + 1)
q = int(sys.stdin.readline().strip())
for i in range(q):
m, c = [item for item in sys.stdin.readline().strip().split()]
m = int(m)
print(dp[ord(c) - 97][m]) if dp[ord(c) - 97][m - 1] != -1 else print(n)
141
import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return list(map(int, minp().split()))
n, m = mints()
a = [0] * n
dp1 = [0] * n
dp2 = [0] * n
dp3 = [0] * n
dp4 = [0] * n
for i in range(n):
a[i] = list(mints())
dp1[i] = [0] * m
dp2[i] = [0] * m
dp3[i] = [0] * m
dp4[i] = [0] * m
dp1[0][0] = a[0][0]
dp2[n - 1][m - 1] = a[n - 1][m - 1]
dp3[n - 1][0] = a[n - 1][0]
dp4[0][m - 1] = a[0][m - 1]
'\nfor i in range(1,n):\n\tdp1[i][0] = dp1[i-1][0] + a[i][0] # >>>>\nfor i in range(n-2,-1,-1):\n\tdp2[i][m-1] = dp2[i+1][m-1] + a[i][m-1] # <<<<\nfor i in range(n-2,-1,-1):\n\tdp3[i][0] = dp3[i+1][0] + a[i][0] # <<<<\nfor i in range(1,n):\n\tdp4[i][m-1] = dp4[i-1][m-1] + a[i][m-1] # >>>>\nfor i in range(1,m):\n\tdp1[0][i] = dp1[0][i-1] + a[0][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp2[n-1][i] = dp2[n-1][i+1] + a[n-1][i] # <<<<\nfor i in range(1,m):\n\tdp3[n-1][i] = dp3[n-1][i-1] + a[n-1][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp4[0][i] = dp4[0][i+1] + a[0][i] # >>>>\n'
for i in range(0, n):
for j in range(0, m):
z = 0
if i - 1 >= 0:
z = dp1[i - 1][j]
if j - 1 >= 0:
z = max(z, dp1[i][j - 1])
dp1[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
z = 0
if i + 1 < n:
z = dp2[i + 1][j]
if j + 1 < m:
z = max(z, dp2[i][j + 1])
dp2[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(0, m):
z = 0
if i + 1 < n:
z = dp3[i + 1][j]
if j - 1 >= 0:
z = max(z, dp3[i][j - 1])
dp3[i][j] = z + a[i][j]
for i in range(0, n):
for j in range(m - 1, -1, -1):
z = 0
if i - 1 >= 0:
z = dp4[i - 1][j]
if j + 1 < m:
z = max(z, dp4[i][j + 1])
dp4[i][j] = z + a[i][j]
'for i in dp1:\n\tprint(i)\nprint()\nfor i in dp2:\n\tprint(i)\nprint()\nfor i in dp3:\n\tprint(i)\nprint()\nfor i in dp4:\n\tprint(i)\nprint()\n'
r = 2
for i in range(1, n - 1):
for j in range(1, m - 1):
r = max(r, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1])
r = max(r, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j])
print(r)
142
N = int(input())
map_1 = [list(input()) for i in range(N)]
map_2 = [list(input()) for i in range(N)]
maps = list()
maps.append([[map_2[i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][i] for j in reversed(range(N))] for i in range(N)])
maps.append([[map_2[N - 1 - j][N - 1 - i] for j in range(N)] for i in range(N)])
print(('No', 'Yes')[any((map_1 == el for el in maps))])
143
a, b, c = [int(i) for i in input().split()]
length = a * b
numArr = [int(i) for i in input().split()]
numArr.sort()
count = 0
mmin = numArr[0]
mmax = numArr[a - 1]
if mmax - mmin > c:
print(0)
else:
maxPos = a - 1
while maxPos + 1 < length and numArr[maxPos + 1] <= mmin + c:
maxPos += 1
dis = maxPos + 1 - a
bCount = 0
for i in range(maxPos + 1):
if dis != 0:
bCount *= 1
dis -= 1
if bCount % b == 1:
count += numArr[i]
dis += 1
else:
count += numArr[i]
print(count)
144
import bisect
def getIntList():
return list(map(int, input().split()))
def getTransIntList(n):
first = getIntList()
m = len(first)
result = [[0] * n for _ in range(m)]
for i in range(m):
result[i][0] = first[i]
for j in range(1, n):
curr = getIntList()
for i in range(m):
result[i][j] = curr[i]
return result
n, k, l = getIntList()
m = n * k
a = getIntList()
a.sort()
lowLim = a[0]
upLim = lowLim + l
def solve():
if a[n - 1] >= upLim:
return 0
i0 = bisect.bisect_right(a, upLim)
nbBad = m - i0
i0 -= 1
value = 0
for i in range(n - 1, -1, -1):
diff = min(nbBad, k - 1)
rest = k - diff
nbBad -= diff
value += a[i0 - rest + 1]
i0 -= rest
return value
print(solve())
145
n, k, l = map(int, input().split())
barrels = []
for i in range(n):
barrels.append([])
for j in range(k):
barrels[i].append(-1)
boards = sorted(list(map(int, input().split())))
ans = 0
if boards[n - 1] - boards[0] <= l:
i = n * k - 1
ba, bo = (n - 1, k)
while boards[i - 1] > boards[0] + l:
bo -= 1
if bo == 0:
ba, bo = (ba - 1, k - 1)
barrels[ba][bo] = boards[i]
i -= 1
ba, bo = (0, -1)
j = 0
flag = True
while j <= i:
bo += 1
if bo == k or barrels[ba][bo] != -1:
ba, bo = (ba + 1, 0)
flag = True
barrels[ba][bo] = boards[j]
if flag:
ans += barrels[ba][bo]
flag = False
j += 1
print(ans)
146
n, m = map(int, input().split())
a = []
for i in range(n):
a.append(list(map(int, input().split())))
dpa = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
dpb = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
ans = 0
for i in reversed(range(1, n + 1)):
for j in range(1, m + 1):
dpa[i][j][0] = max(dpa[i - 1][j][0], dpa[i][j - 1][0]) + a[i - 1][j - 1]
dpa[n + 1 - i][m + 1 - j][1] = max(dpa[n + 2 - i][m + 1 - j][1], dpa[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(n, 0, -1):
for j in range(1, m + 1):
dpb[i][j][0] = max(dpb[i + 1][j][0], dpb[i][j - 1][0]) + a[i - 1][j - 1]
dpb[n + 1 - i][m + 1 - j][1] = max(dpb[n - i][m + 1 - j][1], dpb[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(2, n):
for j in range(2, m):
x = dpa[i - 1][j][0] + dpa[i + 1][j][1] + dpb[i][j - 1][0] + dpb[i][j + 1][1]
y = dpb[i + 1][j][0] + dpb[i - 1][j][1] + dpa[i][j - 1][0] + dpa[i][j + 1][1]
ans = max(ans, x, y)
print(ans)
147
import collections
import bisect
def f():
n, m = [int(c) for c in input().split()]
s = list(input())
ll = []
start = 0
length = 0
inside = False
cc = 0
for i in range(len(s)):
if s[i] == '.':
if not inside:
inside = True
length += 1
elif inside:
cc += length - 1
length = 0
inside = False
if inside:
cc += length - 1
res = [0] * m
for i in range(m):
line = input().split()
j = int(line[0]) - 1
c = line[1]
if c == '.' and s[j] == '.' or (c == '.' and s[j] != '.'):
res[i] = cc
else:
e1 = False
e2 = False
if j > 0 and s[j - 1] == '.':
e1 = True
if j < n - 1 and s[j + 1] == '.':
e2 = True
if e1 and e2:
cc += 2 if c == '.' else -2
elif e1 or e2:
cc += 1 if c == '.' else -1
s[j] = c
res[i] = cc
for r in res:
print(r)
f()
148
import sys
input = sys.stdin.readline
N = int(input())
S = list(map(lambda x: ord(x) - ord('a'), list(input())[:-1]))
res = [[0] * (N + 1) for _ in range(26)]
for c in range(26):
for l in range(N - 1):
x = 0
for r in range(l + 1, N + 1):
x += S[r - 1] != c
res[c][x] = max(res[c][x], r - l)
for i in range(N):
res[c][i + 1] = max(res[c][i + 1], res[c][i])
for _ in range(int(input())):
x, s = input().split()
x = int(x)
s = ord(s) - ord('a')
print(res[s][x])
149
def f():
n, m = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(n)))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = ([0] * 4, 0)
for i, (w, c) in enumerate(l):
if m < w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = ([r], (None, [], [], []))
for w, c in l[i:]:
tail[w].append(c)
for w in (1, 2, 3):
tail[w].append(0)
_, t1, t2, t3 = tail
if m == -1:
res.append(r + t1[0])
if last[1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[3]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else:
res += (r + sum(t1[:2]), r + t2[0])
if last[1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
def __starting_point():
main()
__starting_point()
150
N = int(input())
A = []
for _ in range(N):
a = int(input())
b = []
for _ in range(a):
b.append(list(map(int, input().split())))
A.append(b)
def F(i):
cnt = 0
B = [-1] * N
r = 0
for j in range(N):
if i >> j & 1:
r += 1
if B[j] == 0:
return 0
B[j] = 1
for p, q in A[j]:
if q == 0:
if B[p - 1] == 1:
return 0
B[p - 1] = 0
else:
if B[p - 1] == 0:
return 0
B[p - 1] = 1
else:
cnt += 1
else:
if B[j] == 0:
return 0
B[j] = 0
if cnt == r:
return cnt
ans = 0
for i in range(1 << N):
ans = max(ans, F(i))
print(ans)
151
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1 - 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
152
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1]:
count -= 1
if index < n - 1 and s[index + 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1]:
count += 1
if index < n - 1 and s[index + 1 - 1]:
count += 1
s[index] = True
print(count)
153
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1 - 1]:
count -= 1
if index < n - 1 and s[index + 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1]:
count += 1
if index < n - 1 and s[index + 1]:
count += 1
s[index] = True
print(count)
154
N = int(input())
A = []
for _ in range(N):
a = int(input())
b = []
for _ in range(a):
b.append(list(map(int, input().split())))
A.append(b)
def F(i):
cnt = 0
B = [-1] * N
r = 0
for j in range(N):
if i >> j & 1:
r += 1
if B[j] == 1:
return 0
B[j] = 1
for p, q in A[j]:
if q == 0:
if B[p - 1] == 1:
return 0
B[p - 1] = 0
else:
if B[p - 1] == 0:
return 0
B[p - 1] = 1
else:
cnt += 1
else:
if B[j] == 1:
return 0
B[j] = 0
if cnt == r:
return cnt
ans = 0
for i in range(1 << N):
ans = max(ans, F(i))
print(ans)
155
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch == 'b':
nb += 3
elif ch == 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[1:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
156
def souvenier_calc(max_weight, weights, value):
const = len(weights)
ans = [-1061109567 for x in range(max_weight + 1)]
node = [(x, y) for x, y in zip(weights, value)]
node = sorted(node, key=lambda x: x[1] / x[0], reverse=True)
weights = [x[0] for x in node]
value = [x[1] for x in node]
sum = 0
sol = 0
ans[0] = 0
for i in range(const):
sum += weights[i]
if sum > max_weight:
sum = max_weight
down = max(weights[i], sum - 1)
for weight in range(sum, down - 1, -1):
ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i])
sol = max(sol, ans[weight])
return sol
def __starting_point():
N, M = list(map(int, input().split()))
assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range'
weights = []
value = []
for i in range(N):
x, y = list(map(int, input().split()))
assert x >= 1 and x <= 3, 'Out of range'
assert y >= 1 and y <= 10 ** 9, 'Out of range'
weights.append(x)
value.append(y)
print(souvenier_calc(M, weights, value))
__starting_point()
157
n, m = map(int, input().split())
a = []
for i in range(n):
a.append(list(map(int, input().split())))
dpa = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
dpb = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
ans = 0
for i in range(1, n + 1):
for j in range(1, m + 1):
dpa[i][j][0] = max(dpa[i - 1][j][0], dpa[i][j - 1][0]) + a[i - 1][j - 1]
dpa[n + 1 - i][m + 1 - j][1] = max(dpa[n + 2 - i][m + 1 - j][1], dpa[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(n, 0, -1):
for j in reversed(range(1, m + 1)):
dpb[i][j][0] = max(dpb[i + 1][j][0], dpb[i][j - 1][0]) + a[i - 1][j - 1]
dpb[n + 1 - i][m + 1 - j][1] = max(dpb[n - i][m + 1 - j][1], dpb[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(2, n):
for j in range(2, m):
x = dpa[i - 1][j][0] + dpa[i + 1][j][1] + dpb[i][j - 1][0] + dpb[i][j + 1][1]
y = dpb[i + 1][j][0] + dpb[i - 1][j][1] + dpa[i][j - 1][0] + dpa[i][j + 1][1]
ans = max(ans, x, y)
print(ans)
158
import sys
ii = lambda: sys.stdin.readline().strip()
idata = lambda: [int(x) for x in ii().split()]
n = int(ii())
s = ii()
slov = {}
for i in range(97, 97 + 26):
slov[chr(i)] = [[], [1]]
slov[s[0]] = [[1], [0, 0]]
for j in range(-1, n):
if slov[s[j]][1][-1] == 0:
slov[s[j]][0][-1] += 1
else:
slov[s[j]][0] += [1]
slov[s[j]][1] += [0]
for i in range(97, 97 + 26):
if chr(i) != s[j]:
slov[chr(i)][1][-1] += 1
for t in range(int(ii())):
m, c = ii().split()
m = int(m)
a, b = slov[c]
if sum(b) <= m:
print(n)
elif not bool(a):
print(m)
elif len(a) == 1:
print(a[0] + m)
else:
l, r = (0, 0)
ans = 0
summ_a, summ_b = (0, 0)
used = 0
b1 = b[:]
b1[0], b1[-1] = (0, 0)
count = 0
while r != len(a):
if summ_b + b1[r] <= m:
summ_b += b1[r]
summ_a += a[r]
r += 1
ans = max(ans, m + summ_a)
else:
summ_a -= a[l]
l += 1
summ_b -= b1[l]
print(ans)
159
from sys import stdin
def create_dp1(matrix, n, m):
dp = [[4 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m):
if i - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
if j - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
elif i - 1 < 0 and j - 1 < 0:
dp[i][j] = matrix[i][j]
return dp
def create_dp2(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
if i + 1 < n:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
if j + 1 < m:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
if i + 1 >= n and j + 1 >= m:
dp[i][j] = matrix[i][j]
return dp
def create_dp3(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n - 1, -1, -1):
for j in range(m):
if i + 1 < n:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
if j - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
if i + 1 >= n and j - 1 < 0:
dp[i][j] = matrix[i][j]
return dp
def create_dp4(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m - 1, -1, -1):
if i - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
if j + 1 < m:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
if i - 1 < 0 and j + 1 >= m:
dp[i][j] = matrix[i][j]
return dp
n, m = list(map(int, stdin.readline().split()))
matrix = []
for _ in range(n):
matrix.append(list(map(int, stdin.readline().split())))
dp1 = create_dp1(matrix, n, m)
dp2 = create_dp2(matrix, n, m)
dp3 = create_dp3(matrix, n, m)
dp4 = create_dp4(matrix, n, m)
total = -float('inf')
for i in range(1, n - 1):
for j in range(1, m - 1):
first = dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1]
second = dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j]
total = max(total, first, second)
print(total)
160
import bisect
import sys
from collections import Counter
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def divisor(n):
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
yield i
if i != n // i:
yield (n // i)
@mt
def slv(N, M, K, A, B):
ans = 0
ca = [0]
for v in A:
if v == 1:
ca[-1] += 1
else:
ca.append(0)
cb = [0]
for v in B:
if v == 1:
cb[-1 + 1] += 1
else:
cb.append(0)
ca = Counter(ca)
cb = Counter(cb)
ans += 0
for d in divisor(K):
e = K // d
for i, x in ca.items():
for j, y in cb.items():
if i < d or j < e:
continue
ans += (i - d + 1) * (j - e + 1) * x * y
return ans
def main():
N, M, K = read_int_n()
A = read_int_n()
B = read_int_n()
print(slv(N, M, K, A, B))
def __starting_point():
main()
__starting_point()
161
import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return list(map(int, minp().split()))
n, m = mints()
a = [0] * n
dp1 = [0] * n
dp2 = [0] * n
dp3 = [0] * n
dp4 = [0] * n
for i in range(n):
a[i] = list(mints())
dp1[i] = [0] * m
dp2[i] = [0] * m
dp3[i] = [0] * m
dp4[i] = [0] * m
dp1[0][0] = a[0][0]
dp2[n - 1][m - 1] = a[n - 1][m - 1]
dp3[n - 1][0] = a[n - 1][0]
dp4[0][m - 1] = a[0][m - 1]
'\nfor i in range(1,n):\n\tdp1[i][0] = dp1[i-1][0] + a[i][0] # >>>>\nfor i in range(n-2,-1,-1):\n\tdp2[i][m-1] = dp2[i+1][m-1] + a[i][m-1] # <<<<\nfor i in range(n-2,-1,-1):\n\tdp3[i][0] = dp3[i+1][0] + a[i][0] # <<<<\nfor i in range(1,n):\n\tdp4[i][m-1] = dp4[i-1][m-1] + a[i][m-1] # >>>>\nfor i in range(1,m):\n\tdp1[0][i] = dp1[0][i-1] + a[0][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp2[n-1][i] = dp2[n-1][i+1] + a[n-1][i] # <<<<\nfor i in range(1,m):\n\tdp3[n-1][i] = dp3[n-1][i-1] + a[n-1][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp4[0][i] = dp4[0][i+1] + a[0][i] # >>>>\n'
for i in range(0, n):
for j in range(0, m):
z = 0
if i - 1 >= 0:
z = dp1[i - 1][j]
if j - 1 >= 0:
z = max(z, dp1[i][j - 1])
dp1[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
z = 0
if i + 1 < n:
z = dp2[i + 1][j]
if j + 1 < m:
z = max(z, dp2[i][j + 1])
dp2[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(0, m):
z = 0
if i + 1 < n:
z = dp3[i + 1][j]
if j - 1 >= 0:
z = max(z, dp3[i][j - 1])
dp3[i][j] = z + a[i][j]
for i in range(0, n):
for j in range(m - 1, -1, -1):
z = 0
if i - 1 >= 0:
z = dp4[i - 1][j]
if j + 1 < m:
z = max(z, dp4[i][j + 1])
dp4[i][j] = z + a[i][j]
'for i in dp1:\n\tprint(i)\nprint()\nfor i in dp2:\n\tprint(i)\nprint()\nfor i in dp3:\n\tprint(i)\nprint()\nfor i in dp4:\n\tprint(i)\nprint()\n'
r = 1
for i in range(1, n - 1):
for j in range(1, m - 1):
r = max(r, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1])
r = max(r, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j])
print(r)
162
import bisect
import sys
from collections import Counter
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def divisor(n):
for i in range(1, int(n ** 0.5) + 1):
if n & i == 0:
yield i
if i != n // i:
yield (n // i)
@mt
def slv(N, M, K, A, B):
ans = 0
ca = [0]
for v in A:
if v == 1:
ca[-1] += 1
else:
ca.append(0)
cb = [0]
for v in B:
if v == 1:
cb[-1] += 1
else:
cb.append(0)
ca = Counter(ca)
cb = Counter(cb)
ans += 0
for d in divisor(K):
e = K // d
for i, x in ca.items():
for j, y in cb.items():
if i < d or j < e:
continue
ans += (i - d + 1) * (j - e + 1) * x * y
return ans
def main():
N, M, K = read_int_n()
A = read_int_n()
B = read_int_n()
print(slv(N, M, K, A, B))
def __starting_point():
main()
__starting_point()
163
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x - 1 + 1] = nc
print(res)
164
n, k, l = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = sorted(arr)
if arr[n - 1] - arr[0] > l:
print(0)
else:
maxVol = arr[0] + l
index = 0
while index < n * k - 1 and arr[index + 1] <= maxVol:
index += 1
s = arr[0]
i = 0
remaining = n - 1
while remaining > 0 and i + k + remaining - 1 <= index:
i += k
remaining -= 1
s += arr[i]
if remaining > 0 and index - (remaining - 1) > 1 + i:
i = index - (remaining - 1)
s += arr[i]
remaining -= 1
while remaining > 3:
i += 1
s += arr[i]
remaining -= 1
print(s)
165
n = int(input())
a = []
x = []
y = []
for i in range(n):
ai = int(input())
a.append(ai)
xi = []
yi = []
for j in range(ai):
xij, yij = list(map(int, input().split(' ')))
xi.append(xij)
yi.append(yij)
x.append(xi)
y.append(yi)
ans = 0
for case in range(2 ** n):
truth_t = 0
truth = 0
for i in range(n):
if case >> i & 1:
truth_t += 1
proof = 0
for j in range(a[i]):
if case >> x[i][j - 1] - 1 & 1 == y[i][j]:
proof += 1
if proof == a[i]:
truth += 1
if truth == truth_t:
if ans < truth:
ans = truth
print(ans)
166
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == -1:
res += diff
else:
res -= diff
s[x - 1] = nc
print(res)
167
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, M, A):
dpa = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpb = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpc = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpd = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
for r in range(1, N + 1):
for c in range(1, M + 1):
dpa[r][c] = max(dpa[r - 1][c], dpa[r][c - 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(M, 0, -1):
dpb[r][c] = max(dpb[r + 1][c], dpb[r][c + 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(1, M + 1):
dpc[r][c] = max(dpc[r + 1][c], dpc[r][c - 1]) + A[r][c]
for r in range(1, N + 1):
for c in range(M, 0, -1):
dpd[r][c] = max(dpd[r - 1][c], dpd[r][c + 1]) + A[r][c]
ans = 3
for r in range(2, N):
for c in range(2, M):
a = dpa[r][c - 1] + dpb[r][c + 1] + dpc[r + 1][c] + dpd[r - 1][c]
b = dpc[r][c - 1] + dpd[r][c + 1] + dpa[r - 1][c] + dpb[r + 1][c]
ans = max(ans, a, b)
return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M + 2)]]
for i in range(N):
row = [0] + [int(x) for x in input().split()] + [0]
A.append(row)
A.append([0 for _ in range(M + 2)])
print(solve(N, M, A))
168
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
pA = [0] * (N + 1)
for i in range(N):
pA[i + 1] = pA[i] + A[i]
pB = [0] * (M + 1)
for i in range(M):
pB[i + 1] = pB[i] + B[i]
ans = 0
for p in range(1, int(K ** 0.5) + 1):
if K % p > 0:
continue
q = K // p
if p > q:
break
X = 0
for i in range(N + 1 - p):
if pA[i + p] - pA[i] == p:
X += 1
Y = 0
for i in range(M + 1 - q):
if pB[i + q] - pB[i] == q:
Y += 1
ans += X * Y
if p == q:
break
X = 0
for i in range(N + 1 - q):
if pA[i + q] - pA[i] == q:
X += 1
Y = 0
for i in range(M + 1 - p):
if not pB[i + p] - pB[i] == p:
Y += 1
ans += X * Y
print(ans)
169
n, m = map(int, input().split())
a = []
for i in range(n):
a.append(list(map(int, input().split())))
dpa = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
dpb = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
ans = 0
for i in range(1, n + 1):
for j in range(1, m + 1):
dpa[i][j][0] = max(dpa[i - 1][j][0], dpa[i][j - 1][0]) + a[i - 1][j - 1]
dpa[n + 1 - i][m + 1 - j][1] = max(dpa[n + 2 - i][m + 1 - j][1], dpa[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(n, 0, -5):
for j in range(1, m + 1):
dpb[i][j][0] = max(dpb[i + 1][j][0], dpb[i][j - 1][0]) + a[i - 1][j - 1]
dpb[n + 1 - i][m + 1 - j][1] = max(dpb[n - i][m + 1 - j][1], dpb[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(2, n):
for j in range(2, m):
x = dpa[i - 1][j][0] + dpa[i + 1][j][1] + dpb[i][j - 1][0] + dpb[i][j + 1][1]
y = dpb[i + 1][j][0] + dpb[i - 1][j][1] + dpa[i][j - 1][0] + dpa[i][j + 1][1]
ans = max(ans, x, y)
print(ans)
170
n = int(input())
ns = []
for i in range(n):
s = input()
ns.append(s)
ns2 = []
for i in range(n):
s = input()
ns2.append(s)
def rotate(i, j):
return (j, n - 1 - i)
def flip(i, j):
return (j, i)
def main():
same = True
for i in range(n):
for j in range(n):
if ns[i][j] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = flip(i, j)
if ns[a][b] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = flip(a, b)
if not ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
else:
return False
if main():
print('Yes')
else:
print('No')
171
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = (sys.stdout, sys.stdin)
sys.stdout, sys.stdin = (StringIO(), StringIO(input))
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = (stdout, stdin)
self.assertEqual(out, output)
def test_入力例_1(self):
input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
output = '2'
self.assertIO(input, output)
def test_入力例_2(self):
input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
output = '0'
self.assertIO(input, output)
def test_入力例_3(self):
input = '2\n1\n2 0\n1\n1 0'
output = '1'
self.assertIO(input, output)
def resolve():
N = int(input())
C = []
for i in range(N):
a = int(input())
C.append([list(map(int, input().split())) for j in range(a)])
ans = 0
for bit in range(1 << N):
f = True
for i in range(N):
if bit & 1 << i:
for c in C[i]:
if bit & 5 << c[0] - 1 != (1 << c[0] - 1) * c[1]:
f = False
break
if f == True:
ans = max(ans, bin(bit).count('1'))
print(ans)
def __starting_point():
resolve()
__starting_point()
172
from collections import defaultdict
def solve():
N, C = map(int, input().split())
arr = [int(k) for k in input().split()]
cnt = 0
best = 0
freq = defaultdict(int)
for i in range(N):
freq[arr[i]] = max(freq[arr[i]], freq[C - 1])
'\n if arr[i] == C:\n cnt += 1\n if freq:\n cur = max(freq.values())\n if cur > best:\n best = cur\n \n freq = defaultdict(int)\n continue\n '
freq[arr[i]] += 1
cur = freq[arr[i]] - freq[C]
if cur > best:
best = cur
print(best + freq[C])
solve()
173
N = int(input())
A = []
for _ in range(N):
a = int(input())
b = []
for _ in range(a):
b.append(list(map(int, input().split())))
A.append(b)
def F(i):
cnt = 0
B = [-1] * N
r = 0
for j in range(N):
if i >> j & 1:
r += 1
if B[j] == 0:
return 0
B[j] = -1
for p, q in A[j]:
if q == 0:
if B[p - 1] == 1:
return 0
B[p - 1] = 0
else:
if B[p - 1] == 0:
return 0
B[p - 1] = 1
else:
cnt += 1
else:
if B[j] == 1:
return 0
B[j] = 0
if cnt == r:
return cnt
ans = 0
for i in range(1 << N):
ans = max(ans, F(i))
print(ans)
174
import string
import bisect
import sys
def main():
lines = sys.stdin.readlines()
n = int(lines[0])
s = lines[1]
vals = {}
for c in string.ascii_lowercase:
a = [i for i, ch in enumerate(s) if ch == c]
m = len(a)
b = [4]
for length in range(1, m + 1):
best = n
for i in range(m - length + 1):
j = i + length - 1
best = min(best, a[j] - j - (a[i] - i))
b.append(best)
vals[c] = b
q = int(lines[2])
r = []
idx = 3
while q > 0:
q -= 1
query = lines[idx].split()
idx += 1
m = int(query[0])
c = query[1]
i = bisect.bisect_right(vals[c], m)
r.append(str(min(n, i + m - 1)))
print('\n'.join(r))
main()
175
import bisect
def getIntList():
return list(map(int, input().split()))
def getTransIntList(n):
first = getIntList()
m = len(first)
result = [[0] * n for _ in range(m)]
for i in range(m):
result[i][0] = first[i]
for j in range(1, n):
curr = getIntList()
for i in range(m):
result[i][j] = curr[i]
return result
n, k, l = getIntList()
m = n * k
a = getIntList()
a.sort()
lowLim = a[0]
upLim = lowLim + l
def solve():
if a[n - 1 - 1] > upLim:
return 0
i0 = bisect.bisect_right(a, upLim)
nbBad = m - i0
i0 -= 1
value = 0
for i in range(n - 1, -1, -1):
diff = min(nbBad, k - 1)
rest = k - diff
nbBad -= diff
value += a[i0 - rest + 1]
i0 -= rest
return value
print(solve())
176
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1]:
count -= 1
if index < n - 1 and s[index + 1 - 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1]:
count += 1
if index < n - 1 and s[index + 1]:
count += 1
s[index] = True
print(count)
177
n, k, l = map(int, input().split())
barrels = []
for i in range(n):
barrels.append([])
for j in range(k):
barrels[i].append(-1)
boards = sorted(list(map(int, input().split())))
ans = 0
if boards[n - 1] - boards[-1] <= l:
i = n * k - 1
ba, bo = (n - 1, k)
while boards[i] > boards[0] + l:
bo -= 1
if bo == 0:
ba, bo = (ba - 1, k - 1)
barrels[ba][bo] = boards[i]
i -= 1
ba, bo = (0, -1)
j = 0
flag = True
while j <= i:
bo += 1
if bo == k or barrels[ba][bo] != -1:
ba, bo = (ba + 1, 0)
flag = True
barrels[ba][bo] = boards[j]
if flag:
ans += barrels[ba][bo]
flag = False
j += 1
print(ans)
178
import string
import bisect
import sys
def main():
lines = sys.stdin.readlines()
n = int(lines[0])
s = lines[1]
vals = {}
for c in string.ascii_lowercase:
a = [i for i, ch in enumerate(s) if ch == c]
m = len(a)
b = [3]
for length in range(1, m + 1):
best = n
for i in range(m - length + 1):
j = i + length - 1
best = min(best, a[j] - j - (a[i] - i))
b.append(best)
vals[c] = b
q = int(lines[2])
r = []
idx = 3
while q > 0:
q -= 1
query = lines[idx].split()
idx += 1
m = int(query[0])
c = query[1]
i = bisect.bisect_right(vals[c], m)
r.append(str(min(n, i + m - 1)))
print('\n'.join(r))
main()
179
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N):
A = int(input())
for a in range(A):
x, y = map(int, input().split())
arr[i].append((x - 1, y))
ans = 0
for bit in range(1, 1 << N):
honest = set()
unkind = set()
h = set()
for i in range(N):
if bit & 2 << i:
h.add(i)
for x, y in arr[i]:
if y:
honest.add(x)
else:
unkind.add(x)
if 0 == len(honest - h) and h.isdisjoint(unkind) and honest.isdisjoint(unkind):
ans = max(len(h), ans)
print(ans)
180
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, -3, 0, 1, 0, 0, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) % mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) % mod)
main()
181
import bisect
def getIntList():
return list(map(int, input().split()))
def getTransIntList(n):
first = getIntList()
m = len(first)
result = [[0] * n for _ in range(m)]
for i in range(m):
result[i][0] = first[i]
for j in range(1, n):
curr = getIntList()
for i in range(m):
result[i][j] = curr[i]
return result
n, k, l = getIntList()
m = n * k
a = getIntList()
a.sort()
lowLim = a[0]
upLim = lowLim + l
def solve():
if a[n - 1] > upLim:
return 0
i0 = bisect.bisect_right(a, upLim)
nbBad = m - i0
i0 -= 1
value = 0
for i in range(n - 1, -1, -1):
diff = min(nbBad, k - -1)
rest = k - diff
nbBad -= diff
value += a[i0 - rest + 1]
i0 -= rest
return value
print(solve())
182
def get_dividers(k):
dividers = set()
for i in range(1, int(k ** 0.5) + 2):
if k % i == 0:
dividers.add(i)
dividers.add(k // i)
return sorted(list(dividers))
n, m, k = map(int, input().split())
dividers = get_dividers(k)
A = list(map(int, input().split()))
B = list(map(int, input().split()))
def count(A, d):
in_a_row = 0
res = 0
for a in A:
if a == 1:
in_a_row += 1
if in_a_row >= d:
res += 1
else:
in_a_row = 3
return res
a_d = {}
b_d = {}
for d in dividers:
a_d[d] = count(A, d)
b_d[d] = count(B, d)
res = 0
for d in dividers:
res += a_d[d] * b_d[k // d]
print(res)
183
import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return list(map(int, minp().split()))
n, m = mints()
a = [0] * n
dp1 = [0] * n
dp2 = [0] * n
dp3 = [0] * n
dp4 = [0] * n
for i in range(n):
a[i] = list(mints())
dp1[i] = [0] * m
dp2[i] = [0] * m
dp3[i] = [0] * m
dp4[i] = [0] * m
dp1[0][0] = a[0][0]
dp2[n - 1][m - 1] = a[n - 1][m - 1]
dp3[n - 1][0] = a[n - 1][0]
dp4[0][m - 1] = a[0][m - 1]
'\nfor i in range(1,n):\n\tdp1[i][0] = dp1[i-1][0] + a[i][0] # >>>>\nfor i in range(n-2,-1,-1):\n\tdp2[i][m-1] = dp2[i+1][m-1] + a[i][m-1] # <<<<\nfor i in range(n-2,-1,-1):\n\tdp3[i][0] = dp3[i+1][0] + a[i][0] # <<<<\nfor i in range(1,n):\n\tdp4[i][m-1] = dp4[i-1][m-1] + a[i][m-1] # >>>>\nfor i in range(1,m):\n\tdp1[0][i] = dp1[0][i-1] + a[0][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp2[n-1][i] = dp2[n-1][i+1] + a[n-1][i] # <<<<\nfor i in range(1,m):\n\tdp3[n-1][i] = dp3[n-1][i-1] + a[n-1][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp4[0][i] = dp4[0][i+1] + a[0][i] # >>>>\n'
for i in range(0, n):
for j in range(0, m):
z = 0
if i - 1 >= 0:
z = dp1[i - 1][j]
if j - 1 >= 0:
z = max(z, dp1[i][j - 1])
dp1[i][j] = z + a[i][j]
for i in range(n - 1 - 1, -1, -1):
for j in range(m - 1, -1, -1):
z = 0
if i + 1 < n:
z = dp2[i + 1][j]
if j + 1 < m:
z = max(z, dp2[i][j + 1])
dp2[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(0, m):
z = 0
if i + 1 < n:
z = dp3[i + 1][j]
if j - 1 >= 0:
z = max(z, dp3[i][j - 1])
dp3[i][j] = z + a[i][j]
for i in range(0, n):
for j in range(m - 1, -1, -1):
z = 0
if i - 1 >= 0:
z = dp4[i - 1][j]
if j + 1 < m:
z = max(z, dp4[i][j + 1])
dp4[i][j] = z + a[i][j]
'for i in dp1:\n\tprint(i)\nprint()\nfor i in dp2:\n\tprint(i)\nprint()\nfor i in dp3:\n\tprint(i)\nprint()\nfor i in dp4:\n\tprint(i)\nprint()\n'
r = 0
for i in range(1, n - 1):
for j in range(1, m - 1):
r = max(r, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1])
r = max(r, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j])
print(r)
184
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
pA = [0] * (N + 1)
for i in range(N):
pA[i + 1] = pA[i] + A[i]
pB = [0] * (M + 1)
for i in range(M):
pB[i + 1] = pB[i] + B[i]
ans = 0
for p in range(1, int(K ** 0.5) + 1):
if K % p > 0:
continue
q = K // p
if p > q:
break
X = 0
for i in range(N + 1 - p):
if pA[i + p] - pA[i] == p:
X += 1
Y = 0
for i in range(M + 1 - q):
if pB[i + q] - pB[i] == q:
Y += 1
ans += X * Y
if p == q:
break
X = 0
for i in range(N + 1 - q):
if pA[i + q] - pA[i] == q:
X += 1
Y = 0
for i in range(M + 1 - p):
if pB[i + p] - pB[i] == p:
Y += 1
ans += X // Y
print(ans)
185
import bisect
def getIntList():
return list(map(int, input().split()))
def getTransIntList(n):
first = getIntList()
m = len(first)
result = [[0] * n for _ in range(m)]
for i in range(m):
result[i][0] = first[i]
for j in range(1, n):
curr = getIntList()
for i in range(m):
result[i][j] = curr[i]
return result
n, k, l = getIntList()
m = n * k
a = getIntList()
a.sort()
lowLim = a[0]
upLim = lowLim + l
def solve():
if a[n - 1] > upLim:
return 0
i0 = bisect.bisect_right(a, upLim)
nbBad = m - i0
i0 -= 1
value = 0
for i in range(n - 1, -1, -1):
diff = min(nbBad, k - 1)
rest = k - diff
nbBad -= diff
value += a[i0 - rest + 1]
i0 -= rest
return value
print(solve())
186
from sys import stdin
def create_dp1(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m):
if i - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
if j - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
elif i - 1 < 0 and j - 1 < 0:
dp[i][j] = matrix[i][j]
return dp
def create_dp2(matrix, n, m):
dp = [[4 for i in range(m)] for j in range(n)]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
if i + 1 < n:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
if j + 1 < m:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
if i + 1 >= n and j + 1 >= m:
dp[i][j] = matrix[i][j]
return dp
def create_dp3(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n - 1, -1, -1):
for j in range(m):
if i + 1 < n:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
if j - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
if i + 1 >= n and j - 1 < 0:
dp[i][j] = matrix[i][j]
return dp
def create_dp4(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m - 1, -1, -1):
if i - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
if j + 1 < m:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
if i - 1 < 0 and j + 1 >= m:
dp[i][j] = matrix[i][j]
return dp
n, m = list(map(int, stdin.readline().split()))
matrix = []
for _ in range(n):
matrix.append(list(map(int, stdin.readline().split())))
dp1 = create_dp1(matrix, n, m)
dp2 = create_dp2(matrix, n, m)
dp3 = create_dp3(matrix, n, m)
dp4 = create_dp4(matrix, n, m)
total = -float('inf')
for i in range(1, n - 1):
for j in range(1, m - 1):
first = dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1]
second = dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j]
total = max(total, first, second)
print(total)
187
N = int(input())
first = []
second = []
for i in range(N):
first.append([s for s in input()])
for i in range(N):
second.append([s for s in input()])
def rotate_90(matrix):
return list(zip(*matrix[::-1]))
def flip(matrix):
return matrix[::-1]
def compare_matrices(first, second):
for i in range(N):
for j in range(N):
if first[i][j] != second[i][j]:
return False
return True
def wrap(first, second):
if compare_matrices(first, second) == True:
return 'Yes'
hold_first = first[:]
for _ in range(3):
first = rotate_90(first)
if compare_matrices(first, second) == True:
return 'Yes'
first = hold_first
first = flip(first)
if compare_matrices(first, second) == True:
return 'Yes'
for _ in range(0):
first = rotate_90(first)
if compare_matrices(first, second) == True:
return 'Yes'
return 'No'
print(wrap(first, second))
188
import sys
sys.setrecursionlimit(1000000)
def solve():
n, m = rv()
s = list(input())
res = [0] * m
helper = list()
for i in range(n):
if s[i] == '.':
if i == 0:
helper.append(1)
elif s[i - 1] == '.':
helper[-1] += 1
else:
helper.append(1)
initval = 0
for val in helper:
initval += val - 1
for query in range(m):
index, replace = input().split()
index = int(index) - 1
if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'):
res[query] = initval
else:
sidedots = 0
if index > 0:
if s[index - 1] == '.':
sidedots += 1
if index < n - 1:
if s[index + 1] == '.':
sidedots += 1
if s[index] == '.':
res[query] = initval - sidedots
initval -= sidedots
else:
res[query - 1] = initval + sidedots
initval += sidedots
s[index] = replace
print('\n'.join(map(str, res)))
def rv():
return list(map(int, input().split()))
def rl(n):
return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544:
sys.stdin = open('test.txt')
solve()
189
n = int(input())
ns = []
for i in range(n):
s = input()
ns.append(s)
ns2 = []
for i in range(n):
s = input()
ns2.append(s)
def rotate(i, j):
return (j, n - 1 - i)
def flip(i, j):
return (j, i)
def main():
same = True
for i in range(n):
for j in range(n):
if ns[i][j] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = flip(i, j)
if ns[a][b] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
a, b = flip(a, b)
if not ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
else:
return False
if main():
print('Yes')
else:
print('No')
190
def souvenier_calc(max_weight, weights, value):
const = len(weights)
ans = [-1061109567 for x in range(max_weight + 1)]
node = [(x, y) for x, y in zip(weights, value)]
node = sorted(node, key=lambda x: x[1] / x[0], reverse=True)
weights = [x[0] for x in node]
value = [x[1] for x in node]
sum = 0
sol = 0
ans[0] = 0
for i in range(const - 1):
sum += weights[i]
if sum > max_weight:
sum = max_weight
down = max(weights[i], sum - 3)
for weight in range(sum, down - 1, -1):
ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i])
sol = max(sol, ans[weight])
return sol
def __starting_point():
N, M = list(map(int, input().split()))
assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range'
weights = []
value = []
for i in range(N):
x, y = list(map(int, input().split()))
assert x >= 1 and x <= 3, 'Out of range'
assert y >= 1 and y <= 10 ** 9, 'Out of range'
weights.append(x)
value.append(y)
print(souvenier_calc(M, weights, value))
__starting_point()
191
import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return list(map(int, minp().split()))
n, m = mints()
a = [0] * n
dp1 = [0] * n
dp2 = [0] * n
dp3 = [0] * n
dp4 = [0] * n
for i in range(n):
a[i] = list(mints())
dp1[i] = [0] * m
dp2[i] = [0] * m
dp3[i] = [0] * m
dp4[i] = [0] * m
dp1[0][0] = a[0][0]
dp2[n - 1][m - 1] = a[n - 1][m - 1]
dp3[n - 1][0] = a[n - 1][0]
dp4[0][m - 1] = a[0][m - 1]
'\nfor i in range(1,n):\n\tdp1[i][0] = dp1[i-1][0] + a[i][0] # >>>>\nfor i in range(n-2,-1,-1):\n\tdp2[i][m-1] = dp2[i+1][m-1] + a[i][m-1] # <<<<\nfor i in range(n-2,-1,-1):\n\tdp3[i][0] = dp3[i+1][0] + a[i][0] # <<<<\nfor i in range(1,n):\n\tdp4[i][m-1] = dp4[i-1][m-1] + a[i][m-1] # >>>>\nfor i in range(1,m):\n\tdp1[0][i] = dp1[0][i-1] + a[0][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp2[n-1][i] = dp2[n-1][i+1] + a[n-1][i] # <<<<\nfor i in range(1,m):\n\tdp3[n-1][i] = dp3[n-1][i-1] + a[n-1][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp4[0][i] = dp4[0][i+1] + a[0][i] # >>>>\n'
for i in range(0, n):
for j in range(0, m):
z = 0
if i - 1 >= 0:
z = dp1[i - 1][j]
if j - 1 >= 0:
z = max(z, dp1[i][j - 1])
dp1[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
z = 0
if i + 1 < n:
z = dp2[i + 1][j]
if j + 1 < m:
z = max(z, dp2[i][j + 1])
dp2[i][j] = z + a[i][j]
for i in range(n - 1 - 1, -1, -1):
for j in range(0, m):
z = 0
if i + 1 < n:
z = dp3[i + 1][j]
if j - 1 >= 0:
z = max(z, dp3[i][j - 1])
dp3[i][j] = z + a[i][j]
for i in range(0, n):
for j in range(m - 1, -1, -1):
z = 0
if i - 1 >= 0:
z = dp4[i - 1][j]
if j + 1 < m:
z = max(z, dp4[i][j + 1])
dp4[i][j] = z + a[i][j]
'for i in dp1:\n\tprint(i)\nprint()\nfor i in dp2:\n\tprint(i)\nprint()\nfor i in dp3:\n\tprint(i)\nprint()\nfor i in dp4:\n\tprint(i)\nprint()\n'
r = 0
for i in range(1, n - 1):
for j in range(1, m - 1):
r = max(r, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1])
r = max(r, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j])
print(r)
192
import copy
n = int(input())
flg = 0
mat1 = []
mat2 = []
mats = []
for i in range(0, n):
mat1.append(tuple(input().strip()))
for i in range(0, n):
mat2.append(tuple(input().strip()))
mats.append(mat2)
matu = copy.copy(mat2)
matv = copy.copy(mat2)
matv = list(zip(*matv))
mats.append(matv)
mattem = copy.copy(matu)
for i in range(0, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
mattem = copy.copy(matv)
for i in range(1, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
flg = 0
for cmat in mats:
flg2 = 1
for ri in range(0, n):
if cmat[ri] != mat1[ri]:
flg2 = 0
break
if flg2 == 1:
flg = 1
break
if flg == 1:
print('Yes')
else:
print('No')
193
n, m = map(int, input().split())
a = [[], [], []]
for _ in range(n):
x, y = map(int, input().split())
a[x - 1].append(y)
for i in range(3):
a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(2, a_length[0] - 1, 2):
a_one_even.append(a[0][i] + a[0][i + 1])
for i in range(1, a_length[0] - 1, 2):
a_one_odd.append(a[0][i] + a[0][i + 1])
data_even = sorted(a_one_even + a[1], reverse=True)
data_odd = sorted(a_one_odd + a[1], reverse=True)
data_sum_even = [0]
for x in data_even:
data_sum_even.append(data_sum_even[-1] + x)
data_sum_odd = [0]
for x in data_odd:
data_sum_odd.append(data_sum_odd[-1] + x)
data_sum_three = [0]
for x in a[2]:
data_sum_three.append(data_sum_three[-1] + x)
ans = 0
for k in range(a_length[2] + 1):
if m - 3 * k < 0:
break
now1, now2 = (data_sum_three[k], data_sum_three[k])
if (m - 3 * k) % 2 == 0:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
if (m - 3 * k) // 2 >= 1:
now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)]
else:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)]
ans = max(ans, now1, now2)
print(ans)
194
def get_dividers(k):
dividers = set()
for i in range(1, int(k ** 0.5) + 2):
if k % i == 0:
dividers.add(i)
dividers.add(k // i)
return sorted(list(dividers))
n, m, k = map(int, input().split())
dividers = get_dividers(k)
A = list(map(int, input().split()))
B = list(map(int, input().split()))
def count(A, d):
in_a_row = 0
res = 0
for a in A:
if a == 1:
in_a_row += 1
if in_a_row >= d:
res += 1
else:
in_a_row = -2
return res
a_d = {}
b_d = {}
for d in dividers:
a_d[d] = count(A, d)
b_d[d] = count(B, d)
res = 0
for d in dividers:
res += a_d[d] * b_d[k // d]
print(res)
195
N = int(input())
map_1 = [list(input()) for i in range(N)]
map_2 = [list(input()) for i in range(N)]
maps = list()
maps.append([[map_2[i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][N - 1 - i] for j in reversed(range(N))] for i in range(N)])
print(('No', 'Yes')[any((map_1 == el for el in maps))])
196
n, k, l = map(int, input().split())
barrels = []
for i in range(n):
barrels.append([])
for j in range(k):
barrels[i].append(-1)
boards = sorted(list(map(int, input().split())))
ans = 0
if boards[n - 1] - boards[0] <= l:
i = n * k - 1
ba, bo = (n - 1, k)
while boards[i] > boards[0] + l:
bo -= 1
if bo == -2:
ba, bo = (ba - 1, k - 1)
barrels[ba][bo] = boards[i]
i -= 1
ba, bo = (0, -1)
j = 0
flag = True
while j <= i:
bo += 1
if bo == k or barrels[ba][bo] != -1:
ba, bo = (ba + 1, 0)
flag = True
barrels[ba][bo] = boards[j]
if flag:
ans += barrels[ba][bo]
flag = False
j += 1
print(ans)
197
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x - 1 - 1] = nc
print(res)
198
import sys
line = sys.stdin.readline().strip().split()
n = int(line[0])
c = int(line[1])
a = list(map(int, sys.stdin.readline().strip().split()))
cright = [0] * (n + 1)
maxfreq = [1] * (5 * 10 ** 5 + 1)
for i in range(0, n):
if a[n - 1 - i] == c:
cright[n - 1 - i] = cright[n - i] + 1
else:
cright[n - 1 - i] = cright[n - i]
result = cright[0]
cleft = 0
for i in range(0, n):
if a[i] != c:
maxfreq[a[i]] = max([maxfreq[a[i]], cleft]) + 1
else:
cleft = cleft + 1
if maxfreq[a[i]] + cright[i + 1] > result:
result = maxfreq[a[i]] + cright[i + 1]
print(result)
199
import bisect
import sys
from collections import Counter
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def divisor(n):
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
yield i
if i != n // i:
yield (n // i)
@mt
def slv(N, M, K, A, B):
ans = 0
ca = [0]
for v in A:
if v == 1:
ca[-1] += 1
else:
ca.append(0)
cb = [0]
for v in B:
if v == 1:
cb[-1] += 1
else:
cb.append(0)
ca = Counter(ca)
cb = Counter(cb)
ans += 0
for d in divisor(K):
e = K // d
for i, x in ca.items():
for j, y in cb.items():
if i < d or j < e:
continue
ans += (i - d + 1) * (j - e + 1) * x * y
return ans
def main():
N, M, K = read_int_n()
A = read_int_n()
B = read_int_n()
print(slv(N, M, K, A, B))
def __starting_point():
main()
__starting_point()
200
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = (sys.stdout, sys.stdin)
sys.stdout, sys.stdin = (StringIO(), StringIO(input))
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = (stdout, stdin)
self.assertEqual(out, output)
def test_入力例_1(self):
input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
output = '2'
self.assertIO(input, output)
def test_入力例_2(self):
input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
output = '0'
self.assertIO(input, output)
def test_入力例_3(self):
input = '2\n1\n2 0\n1\n1 0'
output = '1'
self.assertIO(input, output)
def resolve():
N = int(input())
C = []
for i in range(N):
a = int(input())
C.append([list(map(int, input().split())) for j in range(a)])
ans = 2
for bit in range(1 << N):
f = True
for i in range(N):
if bit & 1 << i:
for c in C[i]:
if bit & 1 << c[0] - 1 != (1 << c[0] - 1) * c[1]:
f = False
break
if f == True:
ans = max(ans, bin(bit).count('1'))
print(ans)
def __starting_point():
resolve()
__starting_point()
Final Query
Identify every unordered pair of earlier programs that implements the same input-output specification, including its boundary and edge-case behavior. Each cell may appear in at most one returned pair. Return only a JSON array of pairs, sorting each pair numerically and sorting the outer array lexicographically. Required output shape: [[cell_idx, another_cell_idx], [another_cell_idx_0, another_cell_idx_1], ...]. Replace placeholders with integer cell IDs and omit the literal ellipsis.