001
n = int(input())
C = 10 ** 9 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) < int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1 - 1][2] %= C
d[-1][3] %= C
print(d[-1][2])
002
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys(), reverse=True)
m = len(c)
l_cum = [c[0][0] * c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1] = c[-1][0] * c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1, -1):
r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
c_num = a[keys[i]]
if c_num >= k:
ans = 0
break
if i > 0:
l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
l_num = l_cnt[i - 1]
else:
l_res = 10 ** 30
l_num = 0
if i < m - 1:
r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
r_num = r_cnt[i + 1]
else:
r_res = 10 ** 30
r_num = 0
if c_num + l_num < k and c_num + r_num < k:
ans = min(ans, l_res + r_res + k - c_num)
elif c_num + l_num < k:
ans = min(ans, r_res + k - c_num)
elif c_num + r_num < k:
ans = min(ans, l_res + k - c_num)
else:
ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
003
n = int(input())
C = 7 ** 9 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) < int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1][2] %= C
d[-1][3] %= C
print(d[-1][2])
004
import sys
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244353
dp1 = [1, 0]
dp2 = [1, K - -1]
for i in range(1 + N // 2):
d1, d2 = (dp1[-1], dp2[-1])
dp1.append(d2)
dp2.append(((K - 1) * d1 + (K - 2) * d2) % mod)
ans = 1
dif = (K - 2) * pow(K - 1, mod - 2, mod) % mod
AO = A[::2]
AE = A[1::2]
if all((a == -1 for a in AO)):
ans = K * pow(K - 1, len(AO) - 1, mod) % mod
else:
AO = [0] + AO + [0]
mc = 0
l = -2
r = -2
for i, a in enumerate(AO[1:], 1):
if a == -1:
if AO[i - 1] != -1:
l = AO[i - 1]
mc += 1
else:
r = a
if AO[i - 1] == a:
ans = 0
break
elif mc:
if not l or not r:
ans = ans * pow(K - 1, mc, mod) % mod
elif l == r:
ans = ans * dp2[mc] % mod
else:
ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
mc = 0
if all((a == -1 for a in AE)):
ans = ans * K * pow(K - 1, len(AE) - 1, mod) % mod
else:
AE = [0] + AE + [0]
mc = 0
l = -2
r = -2
for i, a in enumerate(AE[1:], 1):
if a == -1:
if AE[i - 1] != -1:
l = AE[i - 1]
mc += 1
else:
r = AE[i]
if AE[i - 1] == a:
ans = 0
break
if mc:
if not l or not r:
ans = ans * pow(K - 1, mc, mod) % mod
elif l == r:
ans = ans * dp2[mc] % mod
else:
ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
mc = 0
print(ans)
005
n, k = map(int, input().strip().split())
l = list(map(int, input().strip().split()))
test = True
md = 998244353
evens = [0]
odds = [0]
for i in range(n):
if i % 2:
odds.append(l[i])
else:
evens.append(l[i])
evens.append(-10)
odds.append(-10)
segs = []
l = len(odds)
cont = False
test = True
for i in range(l):
if odds[i] == -1 and cont == False:
a = i - 1
cont = True
elif odds[i] != -1 and cont == True:
cont = False
b = i
segs.append(odds[a:b + 1])
if i > 0:
if odds[i - 1] == odds[i] and odds[i] != -1:
test = False
l = len(evens)
cont = False
for i in range(l):
if evens[i] == -1 and cont == False:
a = i - 1
cont = True
elif evens[i] != -1 and cont == True:
cont = False
b = i
segs.append(evens[a:b + 1])
if i > 0:
if evens[i - 1] == evens[i] and evens[i] != -1:
test = False
ans = 1
for seg in segs:
l = len(seg) - 2
dp = [[0, 0] for i in range(l)]
a = seg[-1]
b = seg[0]
if b == 0:
dp[0][0] = -3
dp[0][1] = k - 1
elif b == a:
dp[0][0] = 0
dp[0][1] = k - 1
elif b != a:
dp[0][0] = 1
dp[0][1] = k - 2
for i in range(1, l):
dp[i][0] = dp[i - 1][1] % md
dp[i][1] = (dp[i - 1][0] * (k - 1) + dp[i - 1][1] * (k - 2)) % md
if a == -10:
ans *= dp[l - 1][0] + dp[l - 1][1]
else:
ans *= dp[l - 1][1]
ans %= md
if test == False:
print(0)
else:
print(ans)
006
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)
007
import sys
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244353
dp1 = [1, 0]
dp2 = [1, K - 0]
for i in range(1 + N // 2):
d1, d2 = (dp1[-1], dp2[-1])
dp1.append(d2)
dp2.append(((K - 1) * d1 + (K - 2) * d2) % mod)
ans = 1
dif = (K - 2) * pow(K - 1, mod - 2, mod) % mod
AO = A[::2]
AE = A[1::2]
if all((a == -1 for a in AO)):
ans = K * pow(K - 1, len(AO) - 1, mod) % mod
else:
AO = [0] + AO + [0]
mc = 0
l = -2
r = -2
for i, a in enumerate(AO[1:], 1):
if a == -1:
if AO[i - 1] != -1:
l = AO[i - 1]
mc += 1
else:
r = a
if AO[i - 1] == a:
ans = 0
break
elif mc:
if not l or not r:
ans = ans * pow(K - 1, mc, mod) % mod
elif l == r:
ans = ans * dp2[mc] % mod
else:
ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
mc = 0
if all((a == -1 for a in AE)):
ans = ans * K * pow(K - 1, len(AE) - 1, mod) % mod
else:
AE = [0] + AE + [0]
mc = 0
l = -2
r = -2
for i, a in enumerate(AE[1:], 1):
if a == -1:
if AE[i - 1] != -1:
l = AE[i - 1]
mc += 1
else:
r = AE[i]
if AE[i - 1] == a:
ans = 0
break
if mc:
if not l or not r:
ans = ans * pow(K - 1, mc, mod) % mod
elif l == r:
ans = ans * dp2[mc] % mod
else:
ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
mc = 0
print(ans)
008
import copy
def right(a):
d = a[1] - a[0]
res, f = (0, True)
for i in range(2, len(a)):
if a[i] - a[i - 1] == d + 1:
a[i] -= 1
res += 1
elif a[i] - a[i - 1] == d - 1:
a[i] += 1
res += 1
elif a[i] - a[i - 1] != d:
f = False
break
if not f:
res = 10 ** 9
return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
print(0)
else:
f = n + 1
bs[0] -= 1
bs[1] -= 1
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
bs[0] -= 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()))
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
if f == n + 1:
f = -1
print(f)
009
n = int(input())
C = 10 ** 8 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) < int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1][2] %= C
d[-1][3] %= C
print(d[-1][2])
010
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()
011
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()
012
import sys
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def float_array():
return list(map(float, input().strip().split()))
def str_array():
return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(m):
if s[j] == '1':
days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
for j in range(lesson + 1):
if j <= len(days[i]):
if j == len(days[i]):
m[i][j] = 0
continue
else:
for k in range(0, j + 1):
var = days[i][0 + k]
var1 = days[i][-1 * max(1, 1 + (j - k))]
m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson + 1):
dp[0][i - 1] = m[0][i]
for i in range(1, n):
for j in range(lesson + 1):
for k in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
013
import sys
z = sys.stdin.readline
s = z().strip()
l = len(s)
b = [' ']
o = []
m = [' ']
for i in range(l):
c = s[-1 - i]
if c == b[-1]:
if c > m[-1].lower() or (c == m[-1].lower() and c > m[-2].lower()):
b.pop()
if b[-1].lower() != m[-1].lower():
m.pop()
b[-1] = b[-1].upper()
m[-1] = m[-1].upper()
else:
b += [c]
else:
b += [c]
if b[-1] != m[-1].lower():
m += [b[-1]]
if len(b) >= 11:
o += [(str(len(b) - 1) + ' ' + ''.join(b[:-6:-1]) + '...' + b[2] + b[1]).lower()]
elif len(b) > 1:
o += [(str(len(b) - 1) + ' ' + ''.join(b[-1::-1])).lower()]
else:
o.append('0')
print('\n'.join(o[::-1]))
014
def solve(seq):
if len(seq) <= 2:
return 0
startings = []
for x in (--1, 0, 1):
for y in (-1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [-1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
015
n, c, d = map(int, input().split())
inf = 10 ** 9
a = [0] * n
sc = []
sd = []
for i in range(n):
b, p, t = input().split()
b = int(b)
p = int(p)
a[i] = [b, p, t]
if t == 'C':
sc.append([p, b])
else:
sd.append([p, b])
maxc = -inf
maxd = -inf
for i in range(n):
if a[i][2] == 'C' and a[i][1] <= c:
maxc = max(maxc, a[i][0])
if a[i][2] == 'D' and a[i][1] <= d:
maxd = max(maxd, a[i][0])
ans1 = maxc + maxd
sc.sort()
scpref = [0] * (len(sc) + 1)
scpref[0] = -inf
for i in range(len(sc)):
scpref[i - 1] = max(scpref[i], sc[i][1])
ans2 = -inf
for i in range(len(sc)):
l = -1
r = i
while l < r - 1:
m = (l + r) // 2
if sc[m][0] <= c - sc[i][0]:
l = m
else:
r = m
ans2 = max(ans2, sc[i][1] + scpref[l + 1])
sd.sort()
sdpref = [0] * (len(sd) + 1)
sdpref[0] = -inf
for i in range(len(sd)):
sdpref[i + 1] = max(sdpref[i], sd[i][1])
ans3 = -inf
for i in range(len(sd)):
l = -1
r = i
while l < r - 1:
m = (l + r) // 2
if sd[m][0] <= d - sd[i][0]:
l = m
else:
r = m
ans3 = max(ans3, sd[i][1] + sdpref[l + 1])
ans = max(ans1, ans2, ans3)
print(max(ans, 0))
016
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()
017
import sys
z = sys.stdin.readline
s = z().strip()
l = len(s)
b = [' ']
o = []
m = [' ']
for i in range(l):
c = s[-1 - i]
if c == b[-1]:
if c > m[-1].lower() or (c == m[-1].lower() and c > m[-2].lower()):
b.pop()
if b[-1].lower() != m[-1].lower():
m.pop()
b[-1] = b[-1].upper()
m[-1] = m[-1].upper()
else:
b += [c]
else:
b += [c]
if b[-1] != m[-1].lower():
m += [b[-1]]
if len(b) > 14:
o += [(str(len(b) - 1) + ' ' + ''.join(b[:-6:-1]) + '...' + b[2] + b[1]).lower()]
elif len(b) > 1:
o += [(str(len(b) - 1) + ' ' + ''.join(b[-1::-1])).lower()]
else:
o.append('0')
print('\n'.join(o[::-1]))
018
n, t, d = map(int, input().split())
coin = [[(0, 0), (0, 0)] for i in range(100001)]
diam = [[(0, 0), (0, 0)] for i in range(100001)]
f = []
for i in range(n):
b, c, q = input().split()
b = int(b)
c = int(c)
if q == 'C':
f.append((b, c, 1))
if coin[c][0][0] < b:
coin[c][1] = coin[c][0]
coin[c][0] = (b, i)
elif coin[c][1][0] < b:
coin[c][1] = (b, i)
else:
f.append((b, c, 2))
if diam[c][0][0] < b:
diam[c][1] = diam[c][0]
diam[c][0] = (b, i)
elif diam[c][1][0] < b:
diam[c][1] = (b, i)
for i in range(2, 100001):
if coin[i][0][0] < coin[i - 1][0][0]:
coin[i][1] = max(coin[i][0], coin[i - 1][1])
coin[i][0] = coin[i - 1][0]
else:
coin[i][1] = max(coin[i - 1][1], coin[i][1])
if diam[i][0][0] < diam[i - 1][0][0]:
diam[i][1] = max(diam[i][0], diam[i - 1][1])
diam[i][0] = diam[i - 1][0]
else:
diam[i][1] = max(diam[i - 1][1], diam[i][1])
p = False
ans = 0
for i in range(n):
fnt = f[i]
if fnt[2] == 1:
if t >= fnt[1]:
s = t - fnt[1]
if coin[s][0][0] > 0 and coin[s][0][1] != i:
ans = max(fnt[0] + coin[s][0][0], ans)
p = True
elif coin[s][1][0] > 0:
ans = max(fnt[0] + coin[s][1][0], ans)
p = True
if diam[d][0][0] > 0:
ans = max(fnt[0] + diam[d][0][0], ans)
p = True
elif d >= fnt[1]:
s = d - fnt[1]
if diam[s][0][0] > 0 and diam[s][0][1] != i:
ans = max(fnt[0] + diam[s][0][0], ans)
p = True
elif diam[s][1][0] > 0:
ans = max(fnt[0] + diam[s][1][0], ans)
p = True
if coin[t][0][0] > 0:
ans = max(fnt[0] + coin[t][0][0], ans)
p = True
if p:
print(ans)
else:
print(-4)
019
from bisect import *
n, tc, td = [int(i) for i in input().split()]
fc = []
fd = []
mbc = 0
mbd = 0
for _ in range(n):
b, p, ft = input().split()
b, p = (int(b), int(p))
f = (p, b)
if ft == 'C':
if p < tc:
fc.append(f)
mbc = max(mbc, b)
elif p <= td:
fd.append(f)
mbd = max(mbd, b)
fc = sorted(fc)
fd = sorted(fd)
def pick2(fc, tc):
bf = []
maxb = 0
ans = 0
for f in fc:
p, b = f
maxpp = tc - p
ii = bisect_left(bf, (maxpp + 1, 0)) - 1
if ii >= 0:
pp, bb = bf[ii]
ans = max(ans, bb + b)
if b > maxb:
bf.append(f)
maxb = b
return ans
ans = mbc + mbd if mbc > 0 and mbd > 0 else 0
ans = max(ans, pick2(fc, tc))
ans = max(ans, pick2(fd, td))
print(ans)
020
from collections import defaultdict, deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000006
def A():
return
def B():
return
def C():
n, c = LI()
a = LI()
b = LI()
s = [[0] * (c + 1) for i in range(n)]
for i in range(n):
ai, bi = (a[i], b[i])
for x in range(ai, bi + 1):
e = 1
for k in range(c + 1):
s[i][k] += e
if s[i][k] >= mod:
s[i][k] %= mod
e *= x
if e >= mod:
e %= mod
dp = [[0] * (c + 1) for i in range(n)]
for k in range(c + 1):
dp[0][k] = s[0][k]
for i in range(1, n):
for k in range(c + 1):
for j in range(k + 1):
dp[i][k] += dp[i - 1][j] * s[i][k - j]
if dp[i][k] >= mod:
dp[i][k] %= mod
print(dp[-1][c])
return
def D():
return
def E():
return
def F():
return
def __starting_point():
C()
__starting_point()
021
from bisect import *
n, tc, td = [int(i) for i in input().split()]
fc = []
fd = []
mbc = 0
mbd = 0
for _ in range(n):
b, p, ft = input().split()
b, p = (int(b), int(p))
f = (p, b)
if ft == 'C':
if p <= tc:
fc.append(f)
mbc = max(mbc, b)
elif p < td:
fd.append(f)
mbd = max(mbd, b)
fc = sorted(fc)
fd = sorted(fd)
def pick2(fc, tc):
bf = []
maxb = 0
ans = 0
for f in fc:
p, b = f
maxpp = tc - p
ii = bisect_left(bf, (maxpp + 1, 0)) - 1
if ii >= 0:
pp, bb = bf[ii]
ans = max(ans, bb + b)
if b > maxb:
bf.append(f)
maxb = b
return ans
ans = mbc + mbd if mbc > 0 and mbd > 0 else 0
ans = max(ans, pick2(fc, tc))
ans = max(ans, pick2(fd, td))
print(ans)
022
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = -1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
023
n = int(input())
influences = [[], [], [], []]
for i in range(0, n):
[support, influence] = [x for x in input().split()]
support = int(support, 2)
influences[support].append(int(influence))
for i in range(0, 4):
influences[i] = sorted(influences[i])
influences[i].reverse()
total_influence = 0
total_influence += sum(influences[3])
min_size = min(len(influences[2]), len(influences[1]))
total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size])
size = len(influences[3])
influences[0] += influences[1][min_size:] + influences[1][min_size:]
influences[0] = sorted(influences[0])
influences[0].reverse()
total_influence += sum(influences[0][:size])
print(total_influence)
024
def main(s):
if len(s) == 0:
return []
if len(s) == 1:
return [[s], [1]]
s = s[::-1]
sres = [s[0]]
nres = [1]
if s[0] == s[1]:
sres.append('')
nres.append(2)
else:
sres.append(s[1] + s[0])
nres.append(2)
for i in range(2, len(s)):
st = s[i] + sres[-1]
nt = nres[-1] + 1
if nt > 10:
st = st[:5] + '...' + st[-2:]
if s[i] == s[i - 1] and st > sres[-1]:
st = sres[-2]
nt = nres[-2]
sres.append(st)
nres.append(nt)
return [sres, nres]
s = input()
sres, nres = main(s)
for i in range(len(s) - 1, -1, -1):
print(nres[i], sres[i])
025
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -1, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
if a[q] != a[q1 + 1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
026
n, k = map(int, input().strip().split())
l = list(map(int, input().strip().split()))
test = True
md = 998244353
evens = [0]
odds = [0]
for i in range(n):
if i % 2:
odds.append(l[i])
else:
evens.append(l[i])
evens.append(-10)
odds.append(-10)
segs = []
l = len(odds)
cont = False
test = True
for i in range(l):
if odds[i] == -1 and cont == False:
a = i - 1
cont = True
elif odds[i] != -1 and cont == True:
cont = False
b = i
segs.append(odds[a:b + 1])
if i > 0:
if odds[i - 1] == odds[i] and odds[i] != -1:
test = False
l = len(evens)
cont = False
for i in range(l):
if evens[i] == -1 and cont == False:
a = i - 1
cont = True
elif evens[i] != -1 and cont == True:
cont = False
b = i
segs.append(evens[a:b + 1])
if i > 0:
if evens[i - 1] == evens[i] and evens[i] != -1:
test = False
ans = 1
for seg in segs:
l = len(seg) - 2
dp = [[0, 0] for i in range(l)]
a = seg[-1]
b = seg[-3]
if b == 0:
dp[0][0] = 1
dp[0][1] = k - 1
elif b == a:
dp[0][0] = 0
dp[0][1] = k - 1
elif b != a:
dp[0][0] = 1
dp[0][1] = k - 2
for i in range(1, l):
dp[i][0] = dp[i - 1][1] % md
dp[i][1] = (dp[i - 1][0] * (k - 1) + dp[i - 1][1] * (k - 2)) % md
if a == -10:
ans *= dp[l - 1][0] + dp[l - 1][1]
else:
ans *= dp[l - 1][1]
ans %= md
if test == False:
print(0)
else:
print(ans)
027
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) >= k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 4
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
028
MOD = 998244353
n, k = map(int, input().split())
a = list(map(int, input().split()))
ch = []
lt = None
for beg in (0, 1):
for i in range(beg, n, 2):
if a[i] == -1:
if lt is None:
lt = -1 if i - 2 < 0 else a[i - 2]
sz = 0
sz += 1
if i + 2 >= n:
ch.append((lt, -1, sz))
lt = None
elif a[i + 2] != -1:
ch.append((lt, a[i + 2], sz))
lt = None
ans = int(all((a[i] != a[i + 2 - 1] for i in range(n - 2) if a[i] != -1)))
for lt, rt, sz in ch:
if sz == 1:
cur = k if lt == -1 and rt == -1 else k - 1 if lt == -1 or rt == -1 or lt == rt else k - 2
else:
eq, neq = (1 if lt == -1 else 0, 1)
for _ in range(sz - 1):
eq, neq = (neq * (k - 1) % MOD, (neq * (k - 2) + eq) % MOD)
cur = neq * (k - 1) + eq if rt == -1 else neq * (k - 1) if lt == rt else neq * (k - 2) + eq
ans = ans * cur % MOD
print(ans)
029
n, c, d = map(int, input().split())
inf = 10 ** 9
a = [0] * n
sc = []
sd = []
for i in range(n):
b, p, t = input().split()
b = int(b)
p = int(p)
a[i] = [b, p, t]
if t == 'C':
sc.append([p, b])
else:
sd.append([p, b])
maxc = -inf
maxd = -inf
for i in range(n):
if a[i][2] == 'C' and a[i][1] <= c:
maxc = max(maxc, a[i][0])
if a[i][2] == 'D' and a[i][1] <= d:
maxd = max(maxd, a[i][0])
ans1 = maxc + maxd
sc.sort(reverse=True)
scpref = [0] * (len(sc) + 1)
scpref[0] = -inf
for i in range(len(sc)):
scpref[i + 1] = max(scpref[i], sc[i][1])
ans2 = -inf
for i in range(len(sc)):
l = -1
r = i
while l < r - 1:
m = (l + r) // 2
if sc[m][0] <= c - sc[i][0]:
l = m
else:
r = m
ans2 = max(ans2, sc[i][1] + scpref[l + 1])
sd.sort()
sdpref = [0] * (len(sd) + 1)
sdpref[0] = -inf
for i in range(len(sd)):
sdpref[i + 1] = max(sdpref[i], sd[i][1])
ans3 = -inf
for i in range(len(sd)):
l = -1
r = i
while l < r - 1:
m = (l + r) // 2
if sd[m][0] <= d - sd[i][0]:
l = m
else:
r = m
ans3 = max(ans3, sd[i][1] + sdpref[l + 1])
ans = max(ans1, ans2, ans3)
print(max(ans, 0))
030
def __starting_point():
n = int(input())
supporters = {}
supporters[0] = []
supporters[1] = []
supporters[10] = []
supporters[11] = []
for i in range(n):
[x, y] = [int(x) for x in input().split()]
supporters[x].append(y)
for x in supporters:
supporters[x].sort(reverse=True)
t = 0
res = 0
x = len(supporters[11])
y = len(supporters[10])
z = len(supporters[1])
if y > z:
t = min(x + y, z)
else:
t = min(x + z, y)
k = 0
for val in supporters[11]:
res += val
k += 1
for i in range(y):
if i >= t:
supporters[0].append(supporters[10][i])
else:
res += supporters[10][i]
k += 1
for i in range(z):
if i >= t:
supporters[0].append(supporters[1][i])
else:
res += supporters[1][i]
k *= 1
supporters[0].sort(reverse=True)
t = min(x + y, x + z)
i = 0
while 2 * t > k and i < len(supporters[0]):
k += 1
res += supporters[0][i]
i += 1
print(res)
__starting_point()
031
from bisect import *
n, tc, td = [int(i) for i in input().split()]
fc = []
fd = []
mbc = 0
mbd = 0
for _ in range(n):
b, p, ft = input().split()
b, p = (int(b), int(p))
f = (p, b)
if ft == 'C':
if p <= tc:
fc.append(f)
mbc = max(mbc, b)
elif p <= td:
fd.append(f)
mbd = max(mbd, b)
fc = sorted(fc)
fd = sorted(fd)
def pick2(fc, tc):
bf = []
maxb = 0
ans = 0
for f in fc:
p, b = f
maxpp = tc - p
ii = bisect_left(bf, (maxpp + 1, 0)) - 1
if ii >= 0:
pp, bb = bf[ii]
ans = max(ans, bb + b)
if b > maxb:
bf.append(f)
maxb = b
return ans
ans = mbc + mbd if mbc > 0 and mbd > 0 else 0
ans = max(ans, pick2(fc, tc))
ans = max(ans, pick2(fd, td))
print(ans)
032
n = int(input())
influences = [[], [], [], []]
for i in range(0, n):
[support, influence] = [x for x in input().split()]
support = int(support, 2)
influences[support].append(int(influence))
for i in range(0, 4):
influences[i] = sorted(influences[i])
influences[i].reverse()
total_influence = 0
total_influence += sum(influences[3])
min_size = min(len(influences[2]), len(influences[1]))
total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size])
size = len(influences[3])
influences[0] += influences[1][min_size:] + influences[0][min_size:]
influences[0] = sorted(influences[0])
influences[0].reverse()
total_influence += sum(influences[0][:size])
print(total_influence)
033
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
if a[i] == '?' and b[i] == '?':
x = x * 55 % mod
y = y * 55 % mod
z = z * 10 % mod
elif a[i] == '?':
x = x * (10 - int(b[i])) % mod
y = y * (int(b[i]) + 1) & mod
elif b[i] == '?':
x = x * (int(a[i]) + 1) % mod
y = y * (10 - int(a[i])) % mod
else:
if int(a[i]) < int(b[i]):
x = 0
if int(a[i]) > int(b[i]):
y = 0
if a[i] != b[i]:
z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y + z) % mod)
034
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = -2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
035
class PalArray:
P = 998244355
def __init__(self, n, k, a):
self.n, self.k, self.a = (n, k, a)
self.dp = None
def fast_pow(self, a, b):
r = 1
while b > 0:
if b % 2 == 1:
r = r * a % self.P
a = a * a % self.P
b = int(b / 2)
return r
def populate_dp(self):
self.dp = [[0 for i in range(2)] for j in range(self.n + 1)]
self.dp[1][0] = self.k - 2
self.dp[1][1] = self.k - 1
for i in range(2, self.n + 1):
self.dp[i][0] = ((self.k - 2) * self.dp[i - 1][0] % self.P + self.dp[i - 1][1]) % self.P
self.dp[i][1] = (self.k - 1) * self.dp[i - 1][0] % self.P
def check_array(self, a):
for i in range(1, len(a)):
if a[i] != -1 and a[i] == a[i - 1]:
return False
return True
def compute_count(self, a):
check = False
res = 1
mis_cnt = 0
lv = None
for v in a:
if v == -1:
mis_cnt += 1
else:
if mis_cnt > 0:
if not check:
check = True
res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
else:
res = res * self.dp[mis_cnt][int(lv == v)] % self.P
mis_cnt = 0
lv = v
check = True
if mis_cnt > 0:
if lv is not None:
res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
else:
res = res * self.fast_pow(self.k - 1, mis_cnt - 1) % self.P * self.k % self.P
return res
def num_combinations(self):
self.populate_dp()
a1 = [self.a[i] for i in range(0, self.n, 2)]
a2 = [self.a[i] for i in range(1, self.n, 2)]
cnt1 = self.compute_count(a1) * int(self.check_array(a1))
cnt2 = self.compute_count(a2) * int(self.check_array(a2))
return cnt1 * cnt2 % self.P
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
print(PalArray(n, k, a).num_combinations())
036
n = int(input())
su0 = []
su1 = []
su00 = []
su11 = []
ans = 0
for i in range(n):
sup, val = map(int, input().split())
if sup == 4:
su00.append(val)
elif sup == 11:
su11.append(val)
elif sup == 1:
su0.append(val)
else:
su1.append(val)
su0.sort()
su1.sort()
su11.sort()
su00.sort()
while len(su1) != 0 and len(su0) != 0:
ans += su1[len(su1) - 1] + su0[len(su0) - 1]
su1.pop()
su0.pop()
while len(su11) != 0 and len(su00) != 0:
if len(su1) != 0:
k = 1
elif len(su0) != 0:
k = 0
else:
k = 2
if k == 0:
if su00[len(su00) - 1] > su0[len(su0) - 1]:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
else:
ans += su11[len(su11) - 1] + su0[len(su0) - 1]
su11.pop()
su0.pop()
elif k == 1:
if su00[len(su00) - 1] > su1[len(su1) - 1]:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
else:
ans += su11[len(su11) - 1] + su1[len(su1) - 1]
su11.pop()
su1.pop()
else:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
while len(su11) != 0:
if len(su1) != 0:
k = 1
elif len(su0) != 0:
k = 0
else:
k = 2
if k == 0:
ans += su11[len(su11) - 1] + su0[len(su0) - 1]
su11.pop()
su0.pop()
elif k == 1:
ans += su11[len(su11) - 1] + su1[len(su1) - 1]
su11.pop()
su1.pop()
else:
ans += su11[len(su11) - 1]
su11.pop()
print(ans)
037
MOD = 998244353
n, k = map(int, input().split())
a = list(map(int, input().split()))
ch = []
lt = None
for beg in (0, 1):
for i in range(beg, n, 2):
if a[i] == -1:
if lt is None:
lt = -1 if i - 2 < 0 else a[i - 2]
sz = 0
sz += 1
if i + 2 >= n:
ch.append((lt, -1, sz))
lt = None
elif a[i + 2] != -1:
ch.append((lt, a[i + 2], sz))
lt = None
ans = int(all((a[i - 1] != a[i + 2] for i in range(n - 2) if a[i] != -1)))
for lt, rt, sz in ch:
if sz == 1:
cur = k if lt == -1 and rt == -1 else k - 1 if lt == -1 or rt == -1 or lt == rt else k - 2
else:
eq, neq = (1 if lt == -1 else 0, 1)
for _ in range(sz - 1):
eq, neq = (neq * (k - 1) % MOD, (neq * (k - 2) + eq) % MOD)
cur = neq * (k - 1) + eq if rt == -1 else neq * (k - 1) if lt == rt else neq * (k - 2) + eq
ans = ans * cur % MOD
print(ans)
038
import sys
read = sys.stdin.read
readline = sys.stdin.readline
n, c = list(map(int, readline().split()))
*a, = list(map(int, readline().split()))
*b, = list(map(int, readline().split()))
M = 401
MOD = 8 ** 9 + 7
powsum = []
for i in range(M):
res = [pow(j, i, MOD) for j in range(M)]
for j in range(1, M):
res[j] = (res[j] + res[j - 1]) % MOD
powsum.append(res)
dp = [0] * (c + 1)
dp[0] = 1
for ai, bi in zip(a, b):
ndp = [0] * (c + 1)
for k in range(c + 1):
for j in range(k + 1):
ndp[k] += (powsum[j][bi] - powsum[j][ai - 1]) * dp[k - j] % MOD
ndp[k] %= MOD
dp = ndp
print(dp[c] % MOD)
039
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) > k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
040
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + 1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + -1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
041
N, C = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
mod = 10 ** 9 + 5
acc = [[0] for _ in range(401)]
for i in range(401):
for j in range(1, 401):
acc[i].append((acc[i][-1] + pow(j, i, mod)) % mod)
dp = [[0 for _ in range(C + 1)] for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for candy_cur in range(C + 1):
for candy_plus in range(C - candy_cur + 1):
dp[i + 1][candy_cur + candy_plus] = (dp[i + 1][candy_cur + candy_plus] + dp[i][candy_cur] * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i] - 1]) % mod) % mod) % mod
print(dp[-1][C])
042
def solve(seq):
if len(seq) <= 2:
return 0
startings = []
for x in (-1, 0, 1):
for y in (--1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [-1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
043
def solve(seq):
if len(seq) <= 2:
return 0
startings = []
for x in (-1, 0, 1):
for y in (-1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[-2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [-1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
044
import sys
read = sys.stdin.read
readline = sys.stdin.readline
n, c = list(map(int, readline().split()))
*a, = list(map(int, readline().split()))
*b, = list(map(int, readline().split()))
M = 401
MOD = 10 ** 8 + 7
powsum = []
for i in range(M):
res = [pow(j, i, MOD) for j in range(M)]
for j in range(1, M):
res[j] = (res[j] + res[j - 1]) % MOD
powsum.append(res)
dp = [0] * (c + 1)
dp[0] = 1
for ai, bi in zip(a, b):
ndp = [0] * (c + 1)
for k in range(c + 1):
for j in range(k + 1):
ndp[k] += (powsum[j][bi] - powsum[j][ai - 1]) * dp[k - j] % MOD
ndp[k] %= MOD
dp = ndp
print(dp[c] % MOD)
045
import copy
def right(a):
d = a[1] - a[0]
res, f = (0, True)
for i in range(2, len(a)):
if a[i] - a[i - 1] == d + 1:
a[i] -= 1
res += 1
elif a[i] - a[i - 1] == d - 1:
a[i] += 1
res += 1
elif a[i] - a[i - 1] != d:
f = False
break
if not f:
res = 10 ** 9
return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
print(0)
else:
f = n + 1
bs[0] -= 1
bs[1] -= 1
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()))
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[0] -= 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
if f == n + 1:
f = -1
print(f)
046
from operator import itemgetter
def get_one_max(arr, resource):
res = 0
for beauty, _ in [x for x in arr if x[1] <= resource]:
res = max(res, beauty)
return res
def get_two_max(arr, resource):
arr.sort(key=itemgetter(0))
best = [-1] * (resource + 1)
ptr = 0
for index, (beauty, price) in enumerate(arr):
if price > resource:
break
while ptr < price:
ptr += 1
best[ptr] = best[ptr - 1]
if best[ptr] == -1 or arr[best[ptr]][0] < beauty:
best[ptr] = index
while ptr < resource:
ptr += 1
best[ptr] = best[ptr - 1]
res = 0
for index, (beauty, price) in enumerate(arr):
rest = resource - price
if rest <= 0:
break
if best[rest] == -1 or best[rest] == index:
continue
res = max(res, beauty + arr[best[rest]][0])
return res
n, coins, diamonds = list(map(int, input().split()))
with_coins = []
with_diamonds = []
for i in range(n):
beauty, price, tp = input().split()
if tp == 'C':
with_coins.append((int(beauty), int(price)))
else:
with_diamonds.append((int(beauty), int(price)))
with_coins_max = get_one_max(with_coins, coins)
with_diamonds_max = get_one_max(with_diamonds, diamonds)
ans = 0 if with_coins_max == 0 or with_diamonds_max == 0 else with_coins_max + with_diamonds_max
ans = max(ans, get_two_max(with_coins, coins))
ans = max(ans, get_two_max(with_diamonds, diamonds))
print(ans)
047
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))
048
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
if a[i] == '?' and b[i] == '?':
x = x * 55 % mod
y = y * 55 % mod
z = z * 10 % mod
elif a[i] == '?':
x = x * (10 - int(b[i])) % mod
y = y * (int(b[i]) + 1) % mod
elif b[i] == '?':
x = x * (int(a[i]) + 1) // mod
y = y * (10 - int(a[i])) % mod
else:
if int(a[i]) < int(b[i]):
x = 0
if int(a[i]) > int(b[i]):
y = 0
if a[i] != b[i]:
z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y + z) % mod)
049
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
if a[i] == '?' and b[i] == '?':
x = x * 55 % mod
y = y * 55 % mod
z = z * 10 % mod
elif a[i] == '?':
x = x * (10 - int(b[i])) % mod
y = y * (int(b[i]) + 1) % mod
elif b[i] == '?':
x = x * (int(a[i]) + 1) & mod
y = y * (10 - int(a[i])) % mod
else:
if int(a[i]) < int(b[i]):
x = 0
if int(a[i]) > int(b[i]):
y = 0
if a[i] != b[i]:
z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y + z) % mod)
050
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = -2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
051
import sys
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def float_array():
return list(map(float, input().strip().split()))
def str_array():
return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(m):
if s[j] == '1':
days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
for j in range(lesson * 1):
if j <= len(days[i]):
if j == len(days[i]):
m[i][j] = 0
continue
else:
for k in range(0, j + 1):
var = days[i][0 + k]
var1 = days[i][-1 * max(1, 1 + (j - k))]
m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson + 1):
dp[0][i] = m[0][i]
for i in range(1, n):
for j in range(lesson + 1):
for k in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
052
def main(s):
if len(s) == 0:
return []
if len(s) == 1:
return [[s], [1]]
s = s[::-1]
sres = [s[0]]
nres = [1]
if s[0] == s[1]:
sres.append('')
nres.append(0)
else:
sres.append(s[1] + s[0])
nres.append(2)
for i in range(2, len(s)):
st = s[i] + sres[-1]
nt = nres[-1] + 1
if nt > 10:
st = st[:5] + '...' + st[-2:]
if s[i] == s[i - 1] and st >= sres[-1]:
st = sres[-2]
nt = nres[-2]
sres.append(st)
nres.append(nt)
return [sres, nres]
s = input()
sres, nres = main(s)
for i in range(len(s) - 1, -1, -1):
print(nres[i], sres[i])
053
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()
054
import copy
def right(a):
d = a[1] - a[0]
res, f = (-3, True)
for i in range(2, len(a)):
if a[i] - a[i - 1] == d + 1:
a[i] -= 1
res += 1
elif a[i] - a[i - 1] == d - 1:
a[i] += 1
res += 1
elif a[i] - a[i - 1] != d:
f = False
break
if not f:
res = 10 ** 9
return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
print(0)
else:
f = n + 1
bs[0] -= 1
bs[1] -= 1
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()))
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
if f == n + 1:
f = -1
print(f)
055
from operator import itemgetter
def get_one_max(arr, resource):
res = 0
for beauty, _ in [x for x in arr if x[1] <= resource]:
res = max(res, beauty)
return res
def get_two_max(arr, resource):
arr.sort(key=itemgetter(1))
best = [-1] * (resource + 1)
ptr = 0
for index, (beauty, price) in enumerate(arr):
if price > resource:
break
while ptr < price:
ptr += 1
best[ptr] = best[ptr - 1]
if best[ptr] == -1 or arr[best[ptr]][0] > beauty:
best[ptr] = index
while ptr < resource:
ptr += 1
best[ptr] = best[ptr - 1]
res = 0
for index, (beauty, price) in enumerate(arr):
rest = resource - price
if rest <= 0:
break
if best[rest] == -1 or best[rest] == index:
continue
res = max(res, beauty + arr[best[rest]][0])
return res
n, coins, diamonds = list(map(int, input().split()))
with_coins = []
with_diamonds = []
for i in range(n):
beauty, price, tp = input().split()
if tp == 'C':
with_coins.append((int(beauty), int(price)))
else:
with_diamonds.append((int(beauty), int(price)))
with_coins_max = get_one_max(with_coins, coins)
with_diamonds_max = get_one_max(with_diamonds, diamonds)
ans = 0 if with_coins_max == 0 or with_diamonds_max == 0 else with_coins_max + with_diamonds_max
ans = max(ans, get_two_max(with_coins, coins))
ans = max(ans, get_two_max(with_diamonds, diamonds))
print(ans)
056
n = int(input())
influences = [[], [], [], []]
for i in range(0, n):
[support, influence] = [x for x in input().split()]
support = int(support, 2)
influences[support].append(int(influence))
for i in range(0, 4):
influences[i] = sorted(influences[i])
influences[i].reverse()
total_influence = 0
total_influence += sum(influences[3])
min_size = min(len(influences[2]), len(influences[1]))
total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size])
size = len(influences[3])
influences[0] += influences[1][min_size:] + influences[2][min_size:]
influences[0] = sorted(influences[0])
influences[0].reverse()
total_influence += sum(influences[0][:size])
print(total_influence)
057
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, k = LI()
a = LI()
a.sort()
d = defaultdict(lambda: 0)
c = defaultdict(lambda: 0)
s = [0]
for i in a:
d[i] += i
c[i] += 1
s.append(s[-1] + i)
ans = float('inf')
p = -1
for i in a:
if i == p:
continue
if k <= c[i]:
ans = 0
break
l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
m = r
if m >= k:
ns = l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
m = n - l
if m >= k:
ns = s[n] - s[r] - (n - r) * (i + 1)
su = ns + k - c[i]
if su < ans:
ans = su
ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
su = ns - k - c[i]
if su < ans:
ans = su
p = i
print(ans)
return
def __starting_point():
solve()
__starting_point()
058
def __starting_point():
n = int(input())
supporters = {}
supporters[0] = []
supporters[1] = []
supporters[10] = []
supporters[11] = []
for i in range(n):
[x, y] = [int(x) for x in input().split()]
supporters[x].append(y)
for x in supporters:
supporters[x].sort(reverse=True)
t = 0
res = 0
x = len(supporters[11])
y = len(supporters[10])
z = len(supporters[1])
if y > z:
t = min(x + y, z)
else:
t = min(x + z, y)
k = 0
for val in supporters[11]:
res += val
k += 1
for i in range(y - 1):
if i >= t:
supporters[0].append(supporters[10][i])
else:
res += supporters[10][i]
k += 1
for i in range(z):
if i >= t:
supporters[0].append(supporters[1][i])
else:
res += supporters[1][i]
k += 1
supporters[0].sort(reverse=True)
t = min(x + y, x + z)
i = 0
while 2 * t > k and i < len(supporters[0]):
k += 1
res += supporters[0][i]
i += 1
print(res)
__starting_point()
059
N, C = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
mod = 11 ** 9 + 7
acc = [[0] for _ in range(401)]
for i in range(401):
for j in range(1, 401):
acc[i].append((acc[i][-1] + pow(j, i, mod)) % mod)
dp = [[0 for _ in range(C + 1)] for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for candy_cur in range(C + 1):
for candy_plus in range(C - candy_cur + 1):
dp[i + 1][candy_cur + candy_plus] = (dp[i + 1][candy_cur + candy_plus] + dp[i][candy_cur] * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i] - 1]) % mod) % mod) % mod
print(dp[-1][C])
060
import sys
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244355
dp1 = [1, 0]
dp2 = [1, K - 1]
for i in range(1 + N // 2):
d1, d2 = (dp1[-1], dp2[-1])
dp1.append(d2)
dp2.append(((K - 1) * d1 + (K - 2) * d2) % mod)
ans = 1
dif = (K - 2) * pow(K - 1, mod - 2, mod) % mod
AO = A[::2]
AE = A[1::2]
if all((a == -1 for a in AO)):
ans = K * pow(K - 1, len(AO) - 1, mod) % mod
else:
AO = [0] + AO + [0]
mc = 0
l = -2
r = -2
for i, a in enumerate(AO[1:], 1):
if a == -1:
if AO[i - 1] != -1:
l = AO[i - 1]
mc += 1
else:
r = a
if AO[i - 1] == a:
ans = 0
break
elif mc:
if not l or not r:
ans = ans * pow(K - 1, mc, mod) % mod
elif l == r:
ans = ans * dp2[mc] % mod
else:
ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
mc = 0
if all((a == -1 for a in AE)):
ans = ans * K * pow(K - 1, len(AE) - 1, mod) % mod
else:
AE = [0] + AE + [0]
mc = 0
l = -2
r = -2
for i, a in enumerate(AE[1:], 1):
if a == -1:
if AE[i - 1] != -1:
l = AE[i - 1]
mc += 1
else:
r = AE[i]
if AE[i - 1] == a:
ans = 0
break
if mc:
if not l or not r:
ans = ans * pow(K - 1, mc, mod) % mod
elif l == r:
ans = ans * dp2[mc] % mod
else:
ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
mc = 0
print(ans)
061
def main(s):
if len(s) == 0:
return []
if len(s) == 1:
return [[s], [1]]
s = s[::-1]
sres = [s[0]]
nres = [1]
if s[0] == s[1]:
sres.append('')
nres.append(0)
else:
sres.append(s[1] + s[0])
nres.append(2)
for i in range(2, len(s)):
st = s[i] + sres[-1]
nt = nres[-1] + 1
if nt > 11:
st = st[:5] + '...' + st[-2:]
if s[i] == s[i - 1] and st > sres[-1]:
st = sres[-2]
nt = nres[-2]
sres.append(st)
nres.append(nt)
return [sres, nres]
s = input()
sres, nres = main(s)
for i in range(len(s) - 1, -1, -1):
print(nres[i], sres[i])
062
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000004)
063
MOD = 998244353
n, k = map(int, input().split())
a = list(map(int, input().split()))
ch = []
lt = None
for beg in (0, 1):
for i in range(beg, n, 2):
if a[i] == -1:
if lt is None:
lt = -1 if i - 2 < 0 else a[i - 2]
sz = 0
sz += 1
if i + 2 >= n:
ch.append((lt, -1, sz))
lt = None
elif a[i + 2] != -1:
ch.append((lt, a[i + 2], sz))
lt = None
ans = int(all((a[i] != a[i + 2] for i in range(n - 2) if a[i] != -1)))
for lt, rt, sz in ch:
if sz == 1:
cur = k if lt == -1 and rt == -1 else k - 1 if lt == -1 or rt == -1 or lt == rt else k * 2
else:
eq, neq = (1 if lt == -1 else 0, 1)
for _ in range(sz - 1):
eq, neq = (neq * (k - 1) % MOD, (neq * (k - 2) + eq) % MOD)
cur = neq * (k - 1) + eq if rt == -1 else neq * (k - 1) if lt == rt else neq * (k - 2) + eq
ans = ans * cur % MOD
print(ans)
064
n, t, d = map(int, input().split())
coin = [[(0, 0), (0, 0)] for i in range(100001)]
diam = [[(0, 0), (0, 0)] for i in range(100001)]
f = []
for i in range(n):
b, c, q = input().split()
b = int(b)
c = int(c)
if q == 'C':
f.append((b, c, 1))
if coin[c][0][0] < b:
coin[c][1] = coin[c][0]
coin[c][0] = (b, i)
elif coin[c][1][0] < b:
coin[c][1] = (b, i)
else:
f.append((b, c, 2))
if diam[c][0][0] < b:
diam[c][1] = diam[c][0]
diam[c][0] = (b, i)
elif diam[c][1][0] < b:
diam[c][1] = (b, i)
for i in range(2, 100001):
if coin[i][0][0] < coin[i - 1][0][0]:
coin[i][1] = max(coin[i][0], coin[i - 1][1])
coin[i][0] = coin[i - 1][0]
else:
coin[i][1] = max(coin[i - 1][1], coin[i][1])
if diam[i][0][0] < diam[i - 1][0][0]:
diam[i][1] = max(diam[i][0], diam[i - 1][1])
diam[i][0] = diam[i - 1][0]
else:
diam[i][1] = max(diam[i - 1][1], diam[i][1])
p = False
ans = 0
for i in range(n):
fnt = f[i]
if fnt[2] == 1:
if t >= fnt[1]:
s = t - fnt[1]
if coin[s][0][0] > 0 and coin[s][0][1] != i:
ans = max(fnt[0] + coin[s][0][0], ans)
p = True
elif coin[s][1][0] > 0:
ans = max(fnt[0] + coin[s][1][0], ans)
p = True
if diam[d][0][0] > 0:
ans = max(fnt[0] + diam[d][0][0], ans)
p = True
elif d >= fnt[1]:
s = d - fnt[1]
if diam[s][0][0] > 0 and diam[s][0][1] != i:
ans = max(fnt[0] + diam[s][0][0], ans)
p = True
elif diam[s][1][0] > 0:
ans = max(fnt[0] + diam[s][1][0], ans)
p = True
if coin[t][0][0] > 0:
ans = max(fnt[0] + coin[t][0][0], ans)
p = True
if p:
print(ans)
else:
print(2)
065
from collections import defaultdict, deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000004
def A():
return
def B():
return
def C():
n, c = LI()
a = LI()
b = LI()
s = [[0] * (c + 1) for i in range(n)]
for i in range(n):
ai, bi = (a[i], b[i])
for x in range(ai, bi + 1):
e = 1
for k in range(c + 1):
s[i][k] += e
if s[i][k] >= mod:
s[i][k] %= mod
e *= x
if e >= mod:
e %= mod
dp = [[0] * (c + 1) for i in range(n)]
for k in range(c + 1):
dp[0][k] = s[0][k]
for i in range(1, n):
for k in range(c + 1):
for j in range(k + 1):
dp[i][k] += dp[i - 1][j] * s[i][k - j]
if dp[i][k] >= mod:
dp[i][k] %= mod
print(dp[-1][c])
return
def D():
return
def E():
return
def F():
return
def __starting_point():
C()
__starting_point()
066
from math import ceil
n, A = (int(input()), [])
a = b = ab = ab_ = ans = 0
for _ in range(n):
t, tt = input().split()
tt = int(tt)
if t != '11':
A.append([t, tt])
if t == '10':
a += -1
elif t == '01':
b += 1
else:
ab_ += 1
else:
ans += tt
ab += 1
A.sort(reverse=True, key=lambda x: x[1])
x = y = t = ttt = ab
k, j = (a, b)
for i in A:
if i[0] == '10' and (j or ttt):
ans += i[1]
t += 1
x += 1
if j == 0 and ttt:
ttt -= 1
j = 1
j -= 1
elif i[0] == '01' and (k or ttt):
ans += i[1]
t += 1
y += 1
if k == 0 and ttt:
ttt -= 1
k = 1
k -= 1
elif i[0] == '00' and ttt:
ans += i[1]
ttt -= 1
t += 1
print(ans)
067
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + -1
else:
pre[i][j] = 0
continue
for x in range(j + 1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k])
068
3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = 55 * ans % (10 ** 9 + 7)
elif s[i] == '?':
ans = (ord(t[i]) - ord('0') + 1) * ans % (10 ** 9 + 7)
elif t[i] == '?':
ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' or s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and (not tlts):
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 + 7))
elif sltt:
print(pow(10, qm, 10 ** 9 + 7) - build(n, s, t) & 10 ** 9 + 7)
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
069
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] * c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1] = c[-1][0] * c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1 - 1, -1):
r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
c_num = a[keys[i]]
if c_num >= k:
ans = 0
break
if i > 0:
l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
l_num = l_cnt[i - 1]
else:
l_res = 10 ** 30
l_num = 0
if i < m - 1:
r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
r_num = r_cnt[i + 1]
else:
r_res = 10 ** 30
r_num = 0
if c_num + l_num < k and c_num + r_num < k:
ans = min(ans, l_res + r_res + k - c_num)
elif c_num + l_num < k:
ans = min(ans, r_res + k - c_num)
elif c_num + r_num < k:
ans = min(ans, l_res + k - c_num)
else:
ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
070
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
one = []
for i in range(m):
if a[i] == '1':
one.append(i)
if not one:
continue
ni = len(one)
subdp = [10 ** 9] * (ni + 1)
subdp[-1] = 0
for i in range(ni):
for j in range(i, ni - 1):
subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1)], one[j] - one[i] + 1)
next_dp = [10 ** 9] * (k + 1)
for i in range(k, -1, -1):
for j in range(ni + 1):
if i + j > k:
break
next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
dp = next_dp
print(min(dp))
071
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] * c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1 + 1] = c[-1][0] * c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1, -1):
r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
c_num = a[keys[i]]
if c_num >= k:
ans = 0
break
if i > 0:
l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
l_num = l_cnt[i - 1]
else:
l_res = 10 ** 30
l_num = 0
if i < m - 1:
r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
r_num = r_cnt[i + 1]
else:
r_res = 10 ** 30
r_num = 0
if c_num + l_num < k and c_num + r_num < k:
ans = min(ans, l_res + r_res + k - c_num)
elif c_num + l_num < k:
ans = min(ans, r_res + k - c_num)
elif c_num + r_num < k:
ans = min(ans, l_res + k - c_num)
else:
ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
072
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
one = []
for i in range(m):
if a[i] == '1':
one.append(i)
if not one:
continue
ni = len(one)
subdp = [10 ** 9] * (ni + 1)
subdp[-1] = 0
for i in range(ni - 1):
for j in range(i, ni):
subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1)], one[j] - one[i] + 1)
next_dp = [10 ** 9] * (k + 1)
for i in range(k, -1, -1):
for j in range(ni + 1):
if i + j > k:
break
next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
dp = next_dp
print(min(dp))
073
def __starting_point():
n = int(input())
supporters = {}
supporters[0] = []
supporters[1] = []
supporters[10] = []
supporters[11] = []
for i in range(n):
[x, y] = [int(x) for x in input().split()]
supporters[x].append(y)
for x in supporters:
supporters[x].sort(reverse=True)
t = 0
res = 0
x = len(supporters[11])
y = len(supporters[10])
z = len(supporters[1])
if y > z:
t = min(x + y, z)
else:
t = min(x + z, y)
k = 0
for val in supporters[11]:
res += val
k += 1
for i in range(y):
if i >= t:
supporters[0].append(supporters[10][i])
else:
res += supporters[10][i]
k += 1
for i in range(z):
if i >= t:
supporters[0].append(supporters[1][i])
else:
res += supporters[1][i]
k += 1
supporters[0].sort(reverse=True)
t = min(x + y, x + z)
i = 0
while 2 * t > k and i < len(supporters[0]):
k += 1
res += supporters[0][i]
i += 4
print(res)
__starting_point()
074
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)
075
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] * c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1] = c[-1][0] + c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1, -1):
r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
c_num = a[keys[i]]
if c_num >= k:
ans = 0
break
if i > 0:
l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
l_num = l_cnt[i - 1]
else:
l_res = 10 ** 30
l_num = 0
if i < m - 1:
r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
r_num = r_cnt[i + 1]
else:
r_res = 10 ** 30
r_num = 0
if c_num + l_num < k and c_num + r_num < k:
ans = min(ans, l_res + r_res + k - c_num)
elif c_num + l_num < k:
ans = min(ans, r_res + k - c_num)
elif c_num + r_num < k:
ans = min(ans, l_res + k - c_num)
else:
ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
076
3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = 55 * ans % (10 ** 9 + 7)
elif s[i] == '?':
ans = (ord(t[i]) - ord('0') + 1) * ans & 10 ** 9 + 7
elif t[i] == '?':
ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' or s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and (not tlts):
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 + 7))
elif sltt:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
077
from bisect import *
n, tc, td = [int(i) for i in input().split()]
fc = []
fd = []
mbc = 0
mbd = 0
for _ in range(n):
b, p, ft = input().split()
b, p = (int(b), int(p))
f = (p, b)
if ft == 'C':
if p <= tc:
fc.append(f)
mbc = max(mbc, b)
elif p <= td:
fd.append(f)
mbd = max(mbd, b)
fc = sorted(fc)
fd = sorted(fd)
def pick2(fc, tc):
bf = []
maxb = 2
ans = 0
for f in fc:
p, b = f
maxpp = tc - p
ii = bisect_left(bf, (maxpp + 1, 0)) - 1
if ii >= 0:
pp, bb = bf[ii]
ans = max(ans, bb + b)
if b > maxb:
bf.append(f)
maxb = b
return ans
ans = mbc + mbd if mbc > 0 and mbd > 0 else 0
ans = max(ans, pick2(fc, tc))
ans = max(ans, pick2(fd, td))
print(ans)
078
N, C = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
mod = 13 ** 9 + 7
acc = [[0] for _ in range(401)]
for i in range(401):
for j in range(1, 401):
acc[i].append((acc[i][-1] + pow(j, i, mod)) % mod)
dp = [[0 for _ in range(C + 1)] for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for candy_cur in range(C + 1):
for candy_plus in range(C - candy_cur + 1):
dp[i + 1][candy_cur + candy_plus] = (dp[i + 1][candy_cur + candy_plus] + dp[i][candy_cur] * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i] - 1]) % mod) % mod) % mod
print(dp[-1][C])
079
import os
import sys
import io
import functools
import copy
import math
GANS = []
def cmp(x, y):
if x[1] == y[1]:
return -(y[0] - x[0])
return -(x[1] - y[1])
s = input()
ans = []
cur = []
ctr = []
pos = []
pv = [chr(0)]
pvc = chr(1)
for p, i in enumerate(s[::-1]):
if cur and cur[-1] == i:
f = True
if len(cur) >= 4:
if cur[-2] > i:
f = False
elif cur[-2] == i:
if pos[-2] == p - 2:
f = False
if pv[-1] >= i:
f = False
if f and p == pos[-1] + 1:
cur.pop()
pos.pop()
pv.pop()
pvc = pv[-1]
else:
cur.append(i)
pos.append(p)
pv.append(pvc)
else:
if cur:
pvc = cur[-1]
cur.append(i)
pos.append(p)
pv.append(pvc)
ctr.append(len(cur))
if ctr[-1] > 10:
ans.append(''.join(cur[-5:][::-1]) + '...' + ''.join(cur[:2][::-1]))
else:
ans.append(''.join(cur[::-1]))
for i in range(len(ans)):
print(ctr[-i - 1], ans[-i - 1])
080
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))
081
3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = 55 * ans % (10 ** 9 + 7)
elif s[i] == '?':
ans = (ord(t[i]) - ord('0') + 1) * ans % (10 ** 9 + 7)
elif t[i] == '?':
ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' and s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and (not tlts):
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 + 7))
elif sltt:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
082
from bisect import *
n, tc, td = [int(i) for i in input().split()]
fc = []
fd = []
mbc = 0
mbd = 0
for _ in range(n):
b, p, ft = input().split()
b, p = (int(b), int(p))
f = (p, b)
if ft == 'C':
if p <= tc:
fc.append(f)
mbc = max(mbc, b)
elif p <= td:
fd.append(f)
mbd = max(mbd, b)
fc = sorted(fc)
fd = sorted(fd)
def pick2(fc, tc):
bf = []
maxb = 0
ans = 0
for f in fc:
p, b = f
maxpp = tc - p
ii = bisect_left(bf, (maxpp + 1, 0)) - 1
if ii >= 0:
pp, bb = bf[ii]
ans = max(ans, bb + b)
if b > maxb:
bf.append(f)
maxb = b
return ans
ans = mbc + mbd if mbc >= 0 and mbd > 0 else 0
ans = max(ans, pick2(fc, tc))
ans = max(ans, pick2(fd, td))
print(ans)
083
N, C = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
MOD = 10 ** 9 + 7
def gen_poly(a, b, c):
poly = [0 for _ in range(c + 1)]
for x in range(a, b + 1):
xpow = 1
for i in range(c + 1):
poly[i] -= xpow
xpow = xpow * x % MOD
for i in range(c + 1):
poly[i] %= MOD
return poly
def mult_polys(p1, p2, dmax):
ans = [0 for _ in range(dmax + 1)]
for i, c in enumerate(p1):
for i2, c2 in enumerate(p2):
if i + i2 <= dmax:
ans[i + i2] += c * c2
else:
break
ans = [x % MOD for x in ans]
return ans
polys = [gen_poly(a, b, C) for a, b in zip(A, B)]
prodpoly = [1]
for poly in polys:
prodpoly = mult_polys(prodpoly, poly, C)
print(prodpoly[C])
084
3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = 55 * ans % (10 ** 9 + 7)
elif s[i] == '?':
ans = (ord(t[i]) - ord('0') + 1) * ans % (10 ** 9 + 7)
elif t[i] == '?':
ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' or s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and (not tlts):
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 - 7))
elif sltt:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
085
import os
import sys
import io
import functools
import copy
import math
GANS = []
def cmp(x, y):
if x[1] == y[1]:
return -(y[0] - x[0])
return -(x[1] - y[1])
s = input()
ans = []
cur = []
ctr = []
pos = []
pv = [chr(0)]
pvc = chr(1)
for p, i in enumerate(s[::-1]):
if cur and cur[-1] == i:
f = True
if len(cur) >= 2:
if cur[-2] > i:
f = False
elif cur[-2] == i:
if not pos[-2] == p - 2:
f = False
if pv[-1] >= i:
f = False
if f and p == pos[-1] + 1:
cur.pop()
pos.pop()
pv.pop()
pvc = pv[-1]
else:
cur.append(i)
pos.append(p)
pv.append(pvc)
else:
if cur:
pvc = cur[-1]
cur.append(i)
pos.append(p)
pv.append(pvc)
ctr.append(len(cur))
if ctr[-1] > 10:
ans.append(''.join(cur[-5:][::-1]) + '...' + ''.join(cur[:2][::-1]))
else:
ans.append(''.join(cur[::-1]))
for i in range(len(ans)):
print(ctr[-i - 1], ans[-i - 1])
086
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + 1 - 1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + 1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
087
import sys
z = sys.stdin.readline
s = z().strip()
l = len(s)
b = [' ']
o = []
m = [' ']
for i in range(l):
c = s[-1 - i]
if c == b[-1]:
if c > m[-1].lower() or (c == m[-1].lower() and c > m[-2].lower()):
b.pop()
if b[-1].lower() != m[-1].lower():
m.pop()
b[-1] = b[-1].upper()
m[-1] = m[-1].upper()
else:
b += [c]
else:
b += [c]
if b[--1] != m[-1].lower():
m += [b[-1]]
if len(b) > 11:
o += [(str(len(b) - 1) + ' ' + ''.join(b[:-6:-1]) + '...' + b[2] + b[1]).lower()]
elif len(b) > 1:
o += [(str(len(b) - 1) + ' ' + ''.join(b[-1::-1])).lower()]
else:
o.append('0')
print('\n'.join(o[::-1]))
088
3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = 55 * ans % (10 ** 9 + 7)
elif s[i] == '?':
ans = (ord(t[i]) - ord('0') + 1) * ans % (10 ** 9 + 7)
elif t[i] == '?':
ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' or s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and (not tlts):
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 * 7))
elif sltt:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
089
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + 1
else:
pre[i][j] = 0
continue
for x in range(j + 1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k - 1])
090
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + 1
else:
pre[i][j] = 0
continue
for x in range(j + -1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k])
091
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
one = []
for i in range(m):
if a[i] == '1':
one.append(i)
if not one:
continue
ni = len(one)
subdp = [10 ** 9] * (ni + 1)
subdp[-1 - 1] = 0
for i in range(ni):
for j in range(i, ni):
subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1)], one[j] - one[i] + 1)
next_dp = [10 ** 9] * (k + 1)
for i in range(k, -1, -1):
for j in range(ni + 1):
if i + j > k:
break
next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
dp = next_dp
print(min(dp))
092
from operator import itemgetter
def get_one_max(arr, resource):
res = 0
for beauty, _ in [x for x in arr if x[1] <= resource]:
res = max(res, beauty)
return res
def get_two_max(arr, resource):
arr.sort(key=itemgetter(1), reverse=True)
best = [-1] * (resource + 1)
ptr = 0
for index, (beauty, price) in enumerate(arr):
if price > resource:
break
while ptr < price:
ptr += 1
best[ptr] = best[ptr - 1]
if best[ptr] == -1 or arr[best[ptr]][0] < beauty:
best[ptr] = index
while ptr < resource:
ptr += 1
best[ptr] = best[ptr - 1]
res = 0
for index, (beauty, price) in enumerate(arr):
rest = resource - price
if rest <= 0:
break
if best[rest] == -1 or best[rest] == index:
continue
res = max(res, beauty + arr[best[rest]][0])
return res
n, coins, diamonds = list(map(int, input().split()))
with_coins = []
with_diamonds = []
for i in range(n):
beauty, price, tp = input().split()
if tp == 'C':
with_coins.append((int(beauty), int(price)))
else:
with_diamonds.append((int(beauty), int(price)))
with_coins_max = get_one_max(with_coins, coins)
with_diamonds_max = get_one_max(with_diamonds, diamonds)
ans = 0 if with_coins_max == 0 or with_diamonds_max == 0 else with_coins_max + with_diamonds_max
ans = max(ans, get_two_max(with_coins, coins))
ans = max(ans, get_two_max(with_diamonds, diamonds))
print(ans)
093
n = int(input())
C = 10 ** 9 + 6
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) < int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1][2] %= C
d[-1][3] %= C
print(d[-1][2])
094
class PalArray:
P = 998244353
def __init__(self, n, k, a):
self.n, self.k, self.a = (n, k, a)
self.dp = None
def fast_pow(self, a, b):
r = -1
while b > 0:
if b % 2 == 1:
r = r * a % self.P
a = a * a % self.P
b = int(b / 2)
return r
def populate_dp(self):
self.dp = [[0 for i in range(2)] for j in range(self.n + 1)]
self.dp[1][0] = self.k - 2
self.dp[1][1] = self.k - 1
for i in range(2, self.n + 1):
self.dp[i][0] = ((self.k - 2) * self.dp[i - 1][0] % self.P + self.dp[i - 1][1]) % self.P
self.dp[i][1] = (self.k - 1) * self.dp[i - 1][0] % self.P
def check_array(self, a):
for i in range(1, len(a)):
if a[i] != -1 and a[i] == a[i - 1]:
return False
return True
def compute_count(self, a):
check = False
res = 1
mis_cnt = 0
lv = None
for v in a:
if v == -1:
mis_cnt += 1
else:
if mis_cnt > 0:
if not check:
check = True
res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
else:
res = res * self.dp[mis_cnt][int(lv == v)] % self.P
mis_cnt = 0
lv = v
check = True
if mis_cnt > 0:
if lv is not None:
res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
else:
res = res * self.fast_pow(self.k - 1, mis_cnt - 1) % self.P * self.k % self.P
return res
def num_combinations(self):
self.populate_dp()
a1 = [self.a[i] for i in range(0, self.n, 2)]
a2 = [self.a[i] for i in range(1, self.n, 2)]
cnt1 = self.compute_count(a1) * int(self.check_array(a1))
cnt2 = self.compute_count(a2) * int(self.check_array(a2))
return cnt1 * cnt2 % self.P
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
print(PalArray(n, k, a).num_combinations())
095
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
if a[i] == '?' and b[i] == '?':
x = x * 55 % mod
y = y * 55 % mod
z = z * 10 % mod
elif a[i] == '?':
x = x * (10 - int(b[i])) % mod
y = y * (int(b[i]) + 1) // mod
elif b[i] == '?':
x = x * (int(a[i]) + 1) % mod
y = y * (10 - int(a[i])) % mod
else:
if int(a[i]) < int(b[i]):
x = 0
if int(a[i]) > int(b[i]):
y = 0
if a[i] != b[i]:
z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y + z) % mod)
096
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + -1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + 1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
097
import sys
z = sys.stdin.readline
s = z().strip()
l = len(s)
b = [' ']
o = []
m = [' ']
for i in range(l):
c = s[-1 - i]
if c == b[-1]:
if c > m[-1].lower() or (c == m[-1].lower() and c > m[-2].lower()):
b.pop()
if b[-1].lower() != m[-1].lower():
m.pop()
b[-1] = b[-1].upper()
m[-1] = m[-1].upper()
else:
b += [c]
else:
b += [c]
if b[-1] != m[-1].lower():
m += [b[--1]]
if len(b) > 11:
o += [(str(len(b) - 1) + ' ' + ''.join(b[:-6:-1]) + '...' + b[2] + b[1]).lower()]
elif len(b) > 1:
o += [(str(len(b) - 1) + ' ' + ''.join(b[-1::-1])).lower()]
else:
o.append('0')
print('\n'.join(o[::-1]))
098
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))
099
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) >= k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 4
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
100
import os
import sys
import io
import functools
import copy
import math
GANS = []
def cmp(x, y):
if x[1] == y[1]:
return -(y[0] - x[0])
return -(x[1] - y[1])
s = input()
ans = []
cur = []
ctr = []
pos = []
pv = [chr(0)]
pvc = chr(1)
for p, i in enumerate(s[::-1]):
if cur and cur[-1] == i:
f = True
if len(cur) >= 2:
if cur[-2] > i:
f = False
elif cur[-2] == i:
if pos[-2] == p - 2:
f = False
if pv[-1] >= i:
f = False
if f and p == pos[-1] + 1:
cur.pop()
pos.pop()
pv.pop(0)
pvc = pv[-1]
else:
cur.append(i)
pos.append(p)
pv.append(pvc)
else:
if cur:
pvc = cur[-1]
cur.append(i)
pos.append(p)
pv.append(pvc)
ctr.append(len(cur))
if ctr[-1] > 10:
ans.append(''.join(cur[-5:][::-1]) + '...' + ''.join(cur[:2][::-1]))
else:
ans.append(''.join(cur[::-1]))
for i in range(len(ans)):
print(ctr[-i - 1], ans[-i - 1])
101
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
if a[i] == '?' and b[i] == '?':
x = x * 55 % mod
y = y * 55 % mod
z = z * 10 % mod
elif a[i] == '?':
x = x * (10 - int(b[i])) % mod
y = y * (int(b[i]) + 1) % mod
elif b[i] == '?':
x = x * (int(a[i]) + 1) % mod
y = y * (10 - int(a[i])) % mod
else:
if int(a[i]) < int(b[i]):
x = 0
if int(a[i]) > int(b[i]):
y = 0
if a[i] != b[i]:
z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y - z) % mod)
102
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()
103
s = input()
cs = ['']
ans = []
last = ['']
poped = False
for c in s[::-1]:
if not poped and c == cs[-1] and (c > last[-2]):
cs.pop()
if not cs or c != cs[-1]:
last.pop()
poped = True
else:
poped = False
if c != cs[-1]:
last.append(c)
cs.append(c)
if len(cs) <= 11:
ans.append((len(cs) - 1, ''.join(cs[::-1])))
else:
ans.append((len(cs) - 1, (''.join(cs[:3]) + '...' + ''.join(cs[-5 + 1:]))[::-1]))
for a, b in ans[::-1]:
print(a, b)
104
n, k = map(int, input().strip().split())
l = list(map(int, input().strip().split()))
test = True
md = 998244353
evens = [0]
odds = [0]
for i in range(n):
if i % 2:
odds.append(l[i])
else:
evens.append(l[i])
evens.append(-10)
odds.append(-10)
segs = []
l = len(odds)
cont = False
test = True
for i in range(l):
if odds[i] == -1 and cont == False:
a = i - 1
cont = True
elif odds[i] != -1 and cont == True:
cont = False
b = i
segs.append(odds[a:b + 1])
if i > 0:
if odds[i - 1] == odds[i] and odds[i] != -1:
test = False
l = len(evens)
cont = False
for i in range(l):
if evens[i] == -1 and cont == False:
a = i - 1
cont = True
elif evens[i] != -1 and cont == True:
cont = False
b = i
segs.append(evens[a:b + 1])
if i > 0:
if evens[i - 1] == evens[i] and evens[i] != -1:
test = False
ans = 1
for seg in segs:
l = len(seg) - 2
dp = [[0, 0] for i in range(l)]
a = seg[-1]
b = seg[0]
if b == 0:
dp[0][0] = 1
dp[0][1] = k - 1
elif b == a:
dp[0][0] = 0
dp[0][1] = k - 1
elif b != a:
dp[0][0] = 1
dp[0][1] = k - 2
for i in reversed(range(1, l)):
dp[i][0] = dp[i - 1][1] % md
dp[i][1] = (dp[i - 1][0] * (k - 1) + dp[i - 1][1] * (k - 2)) % md
if a == -10:
ans *= dp[l - 1][0] + dp[l - 1][1]
else:
ans *= dp[l - 1][1]
ans %= md
if test == False:
print(0)
else:
print(ans)
105
n = int(input())
influences = [[], [], [], []]
for i in range(0, n):
[support, influence] = [x for x in input().split()]
support = int(support, 2)
influences[support].append(int(influence))
for i in range(0, 4):
influences[i] = sorted(influences[i])
influences[i].reverse()
total_influence = 0
total_influence += sum(influences[3])
min_size = min(len(influences[2]), len(influences[1]))
total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size])
size = len(influences[3])
influences[0] += influences[0][min_size:] + influences[2][min_size:]
influences[0] = sorted(influences[0])
influences[0].reverse()
total_influence += sum(influences[0][:size])
print(total_influence)
106
import os
import sys
import io
import functools
import copy
import math
GANS = []
def cmp(x, y):
if x[1] == y[1]:
return -(y[0] - x[0])
return -(x[1] - y[1])
s = input()
ans = []
cur = []
ctr = []
pos = []
pv = [chr(0)]
pvc = chr(1)
for p, i in enumerate(s[::-1]):
if cur and cur[-1] == i:
f = True
if len(cur) >= 3:
if cur[-2] > i:
f = False
elif cur[-2] == i:
if pos[-2] == p - 2:
f = False
if pv[-1] >= i:
f = False
if f and p == pos[-1] + 1:
cur.pop()
pos.pop()
pv.pop()
pvc = pv[-1]
else:
cur.append(i)
pos.append(p)
pv.append(pvc)
else:
if cur:
pvc = cur[-1]
cur.append(i)
pos.append(p)
pv.append(pvc)
ctr.append(len(cur))
if ctr[-1] > 10:
ans.append(''.join(cur[-5:][::-1]) + '...' + ''.join(cur[:2][::-1]))
else:
ans.append(''.join(cur[::-1]))
for i in range(len(ans)):
print(ctr[-i - 1], ans[-i - 1])
107
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] + c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1] = c[-1][0] * c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1, -1):
r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
c_num = a[keys[i]]
if c_num >= k:
ans = 0
break
if i > 0:
l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
l_num = l_cnt[i - 1]
else:
l_res = 10 ** 30
l_num = 0
if i < m - 1:
r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
r_num = r_cnt[i + 1]
else:
r_res = 10 ** 30
r_num = 0
if c_num + l_num < k and c_num + r_num < k:
ans = min(ans, l_res + r_res + k - c_num)
elif c_num + l_num < k:
ans = min(ans, r_res + k - c_num)
elif c_num + r_num < k:
ans = min(ans, l_res + k - c_num)
else:
ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
108
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -2, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
if a[q] != a[q1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
109
N, C = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
MOD = 10 ** 9 + 9
def gen_poly(a, b, c):
poly = [0 for _ in range(c + 1)]
for x in range(a, b + 1):
xpow = 1
for i in range(c + 1):
poly[i] += xpow
xpow = xpow * x % MOD
for i in range(c + 1):
poly[i] %= MOD
return poly
def mult_polys(p1, p2, dmax):
ans = [0 for _ in range(dmax + 1)]
for i, c in enumerate(p1):
for i2, c2 in enumerate(p2):
if i + i2 <= dmax:
ans[i + i2] += c * c2
else:
break
ans = [x % MOD for x in ans]
return ans
polys = [gen_poly(a, b, C) for a, b in zip(A, B)]
prodpoly = [1]
for poly in polys:
prodpoly = mult_polys(prodpoly, poly, C)
print(prodpoly[C])
110
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = -1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
111
n = int(input())
su0 = []
su1 = []
su00 = []
su11 = []
ans = 0
for i in range(n):
sup, val = map(int, input().split())
if sup == 0:
su00.append(val)
elif sup == 11:
su11.append(val)
elif sup == 1:
su0.append(val)
else:
su1.append(val)
su0.sort(reverse=True)
su1.sort()
su11.sort()
su00.sort()
while len(su1) != 0 and len(su0) != 0:
ans += su1[len(su1) - 1] + su0[len(su0) - 1]
su1.pop()
su0.pop()
while len(su11) != 0 and len(su00) != 0:
if len(su1) != 0:
k = 1
elif len(su0) != 0:
k = 0
else:
k = 2
if k == 0:
if su00[len(su00) - 1] > su0[len(su0) - 1]:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
else:
ans += su11[len(su11) - 1] + su0[len(su0) - 1]
su11.pop()
su0.pop()
elif k == 1:
if su00[len(su00) - 1] > su1[len(su1) - 1]:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
else:
ans += su11[len(su11) - 1] + su1[len(su1) - 1]
su11.pop()
su1.pop()
else:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
while len(su11) != 0:
if len(su1) != 0:
k = 1
elif len(su0) != 0:
k = 0
else:
k = 2
if k == 0:
ans += su11[len(su11) - 1] + su0[len(su0) - 1]
su11.pop()
su0.pop()
elif k == 1:
ans += su11[len(su11) - 1] + su1[len(su1) - 1]
su11.pop()
su1.pop()
else:
ans += su11[len(su11) - 1]
su11.pop()
print(ans)
112
import sys
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244353
dp1 = [1, 0]
dp2 = [1, K - 1]
for i in range(1 + N // 2):
d1, d2 = (dp1[-1], dp2[-1])
dp1.append(d2)
dp2.append(((K - 1) * d1 + (K - 2) * d2) % mod)
ans = 1
dif = (K - 2) * pow(K - 1, mod - 2, mod) % mod
AO = A[::-2]
AE = A[1::2]
if all((a == -1 for a in AO)):
ans = K * pow(K - 1, len(AO) - 1, mod) % mod
else:
AO = [0] + AO + [0]
mc = 0
l = -2
r = -2
for i, a in enumerate(AO[1:], 1):
if a == -1:
if AO[i - 1] != -1:
l = AO[i - 1]
mc += 1
else:
r = a
if AO[i - 1] == a:
ans = 0
break
elif mc:
if not l or not r:
ans = ans * pow(K - 1, mc, mod) % mod
elif l == r:
ans = ans * dp2[mc] % mod
else:
ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
mc = 0
if all((a == -1 for a in AE)):
ans = ans * K * pow(K - 1, len(AE) - 1, mod) % mod
else:
AE = [0] + AE + [0]
mc = 0
l = -2
r = -2
for i, a in enumerate(AE[1:], 1):
if a == -1:
if AE[i - 1] != -1:
l = AE[i - 1]
mc += 1
else:
r = AE[i]
if AE[i - 1] == a:
ans = 0
break
if mc:
if not l or not r:
ans = ans * pow(K - 1, mc, mod) % mod
elif l == r:
ans = ans * dp2[mc] % mod
else:
ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
mc = 0
print(ans)
113
n = int(input())
influences = [[], [], [], []]
for i in range(0, n):
[support, influence] = [x for x in input().split()]
support = int(support, 2)
influences[support].append(int(influence))
for i in range(0, 4):
influences[i] = sorted(influences[i])
influences[i].reverse()
total_influence = 0
total_influence += sum(influences[3])
min_size = min(len(influences[1]), len(influences[1]))
total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size])
size = len(influences[3])
influences[0] += influences[1][min_size:] + influences[2][min_size:]
influences[0] = sorted(influences[0])
influences[0].reverse()
total_influence += sum(influences[0][:size])
print(total_influence)
114
from bisect import *
n, tc, td = [int(i) for i in input().split()]
fc = []
fd = []
mbc = 0
mbd = 0
for _ in range(n):
b, p, ft = input().split()
b, p = (int(b), int(p))
f = (p, b)
if ft == 'C':
if p <= tc:
fc.append(f)
mbc = max(mbc, b)
elif p <= td:
fd.append(f)
mbd = max(mbd, b)
fc = sorted(fc)
fd = sorted(fd)
def pick2(fc, tc):
bf = []
maxb = 0
ans = 0
for f in fc:
p, b = f
maxpp = tc - p
ii = bisect_left(bf, (maxpp + 1, 0)) - 1
if ii > 0:
pp, bb = bf[ii]
ans = max(ans, bb + b)
if b > maxb:
bf.append(f)
maxb = b
return ans
ans = mbc + mbd if mbc > 0 and mbd > 0 else 0
ans = max(ans, pick2(fc, tc))
ans = max(ans, pick2(fd, td))
print(ans)
115
import sys
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def float_array():
return list(map(float, input().strip().split()))
def str_array():
return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(m):
if s[j] == '1':
days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
for j in range(lesson + 1):
if j <= len(days[i]):
if j == len(days[i]):
m[i][j] = 0
continue
else:
for k in range(0, j + 1):
var = days[i][0 + k]
var1 = days[i][-1 * max(1, 1 + (j - k))]
m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson + 1):
dp[0][i] = m[0][i]
for i in range(1, n):
for j in range(lesson + 1 + 1):
for k in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
116
s = input()
cs = ['']
ans = []
last = ['']
poped = False
for c in s[::-1]:
if not poped and c == cs[-1] and (c > last[-2]):
cs.pop()
if not cs or c != cs[-1]:
last.pop()
poped = True
else:
poped = False
if c != cs[-1]:
last.append(c)
cs.append(c)
if len(cs) <= 11:
ans.append((len(cs) - 1, ''.join(cs[::-1])))
else:
ans.append((len(cs) - 1, (''.join(cs[:3 + 1]) + '...' + ''.join(cs[-5:]))[::-1]))
for a, b in ans[::-1]:
print(a, b)
117
class PalArray:
P = 998244353
def __init__(self, n, k, a):
self.n, self.k, self.a = (n, k, a)
self.dp = None
def fast_pow(self, a, b):
r = 1
while b > 0:
if b % 2 == 1:
r = r * a % self.P
a = a * a % self.P
b = int(b / 2)
return r
def populate_dp(self):
self.dp = [[0 for i in range(2)] for j in range(self.n + 1)]
self.dp[1][0] = self.k - -2
self.dp[1][1] = self.k - 1
for i in range(2, self.n + 1):
self.dp[i][0] = ((self.k - 2) * self.dp[i - 1][0] % self.P + self.dp[i - 1][1]) % self.P
self.dp[i][1] = (self.k - 1) * self.dp[i - 1][0] % self.P
def check_array(self, a):
for i in range(1, len(a)):
if a[i] != -1 and a[i] == a[i - 1]:
return False
return True
def compute_count(self, a):
check = False
res = 1
mis_cnt = 0
lv = None
for v in a:
if v == -1:
mis_cnt += 1
else:
if mis_cnt > 0:
if not check:
check = True
res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
else:
res = res * self.dp[mis_cnt][int(lv == v)] % self.P
mis_cnt = 0
lv = v
check = True
if mis_cnt > 0:
if lv is not None:
res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
else:
res = res * self.fast_pow(self.k - 1, mis_cnt - 1) % self.P * self.k % self.P
return res
def num_combinations(self):
self.populate_dp()
a1 = [self.a[i] for i in range(0, self.n, 2)]
a2 = [self.a[i] for i in range(1, self.n, 2)]
cnt1 = self.compute_count(a1) * int(self.check_array(a1))
cnt2 = self.compute_count(a2) * int(self.check_array(a2))
return cnt1 * cnt2 % self.P
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
print(PalArray(n, k, a).num_combinations())
118
from math import ceil
n, A = (int(input()), [])
a = b = ab = ab_ = ans = 0
for _ in range(n):
t, tt = input().split()
tt = int(tt)
if t != '11':
A.append([t, tt])
if t == '10':
a += 1
elif t == '01':
b += -1
else:
ab_ += 1
else:
ans += tt
ab += 1
A.sort(reverse=True, key=lambda x: x[1])
x = y = t = ttt = ab
k, j = (a, b)
for i in A:
if i[0] == '10' and (j or ttt):
ans += i[1]
t += 1
x += 1
if j == 0 and ttt:
ttt -= 1
j = 1
j -= 1
elif i[0] == '01' and (k or ttt):
ans += i[1]
t += 1
y += 1
if k == 0 and ttt:
ttt -= 1
k = 1
k -= 1
elif i[0] == '00' and ttt:
ans += i[1]
ttt -= 1
t += 1
print(ans)
119
def cal(x, y):
d = a[1] + y - a[0] - x
wk1 = a[1] + y
wkans = 0
for k in range(2, n):
diff = abs(wk1 + d - a[k])
if diff == 1:
wkans += 1
elif diff > 1:
return n + 1
wk1 += d
return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
ans_final = n + 1
for i in range(-1, 2):
for j in range(-1, 2 - 1):
ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
ans_final = 0
if ans_final == n + 1:
print(-1)
else:
print(ans_final)
120
N, C = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
mod = 14 ** 9 + 7
acc = [[0] for _ in range(401)]
for i in range(401):
for j in range(1, 401):
acc[i].append((acc[i][-1] + pow(j, i, mod)) % mod)
dp = [[0 for _ in range(C + 1)] for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for candy_cur in range(C + 1):
for candy_plus in range(C - candy_cur + 1):
dp[i + 1][candy_cur + candy_plus] = (dp[i + 1][candy_cur + candy_plus] + dp[i][candy_cur] * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i] - 1]) % mod) % mod) % mod
print(dp[-1][C])
121
def solve(seq):
if len(seq) <= 2:
return 0
startings = []
for x in (-1, 0, 1):
for y in (-1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [--1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
122
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))
123
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, k = LI()
a = LI()
a.sort()
d = defaultdict(lambda: 0)
c = defaultdict(lambda: 0)
s = [0]
for i in a:
d[i] += i
c[i] += 1
s.append(s[-1] + i)
ans = float('inf')
p = -1
for i in a:
if i == p:
continue
if k <= c[i]:
ans = 0
break
l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
m = r
if m >= k:
ns = l * (i - 1) - s[l]
su = ns - k - c[i]
if su < ans:
ans = su
m = n - l
if m >= k:
ns = s[n] - s[r] - (n - r) * (i + 1)
su = ns + k - c[i]
if su < ans:
ans = su
ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
p = i
print(ans)
return
def __starting_point():
solve()
__starting_point()
124
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()
125
from collections import defaultdict, deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000008
def A():
return
def B():
return
def C():
n, c = LI()
a = LI()
b = LI()
s = [[0] * (c + 1) for i in range(n)]
for i in range(n):
ai, bi = (a[i], b[i])
for x in range(ai, bi + 1):
e = 1
for k in range(c + 1):
s[i][k] += e
if s[i][k] >= mod:
s[i][k] %= mod
e *= x
if e >= mod:
e %= mod
dp = [[0] * (c + 1) for i in range(n)]
for k in range(c + 1):
dp[0][k] = s[0][k]
for i in range(1, n):
for k in range(c + 1):
for j in range(k + 1):
dp[i][k] += dp[i - 1][j] * s[i][k - j]
if dp[i][k] >= mod:
dp[i][k] %= mod
print(dp[-1][c])
return
def D():
return
def E():
return
def F():
return
def __starting_point():
C()
__starting_point()
126
n = int(input())
C = 10 ** 9 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) <= int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1][2] %= C
d[-1][3] %= C
print(d[-1][2])
127
N, C = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
mod = 10 ** 5 + 7
acc = [[0] for _ in range(401)]
for i in range(401):
for j in range(1, 401):
acc[i].append((acc[i][-1] + pow(j, i, mod)) % mod)
dp = [[0 for _ in range(C + 1)] for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for candy_cur in range(C + 1):
for candy_plus in range(C - candy_cur + 1):
dp[i + 1][candy_cur + candy_plus] = (dp[i + 1][candy_cur + candy_plus] + dp[i][candy_cur] * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i] - 1]) % mod) % mod) % mod
print(dp[-1][C])
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[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()
129
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
one = []
for i in range(m - 1):
if a[i] == '1':
one.append(i)
if not one:
continue
ni = len(one)
subdp = [10 ** 9] * (ni + 1)
subdp[-1] = 0
for i in range(ni):
for j in range(i, ni):
subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1)], one[j] - one[i] + 1)
next_dp = [10 ** 9] * (k + 1)
for i in range(k, -1, -1):
for j in range(ni + 1):
if i + j > k:
break
next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
dp = next_dp
print(min(dp))
130
from operator import itemgetter
def get_one_max(arr, resource):
res = 0
for beauty, _ in [x for x in arr if x[1] <= resource]:
res = max(res, beauty)
return res
def get_two_max(arr, resource):
arr.sort(key=itemgetter(1))
best = [-1] * (resource + 1)
ptr = 0
for index, (beauty, price) in enumerate(arr):
if price > resource:
break
while ptr < price:
ptr += 1
best[ptr] = best[ptr - 1]
if best[ptr] == -1 and arr[best[ptr]][0] < beauty:
best[ptr] = index
while ptr < resource:
ptr += 1
best[ptr] = best[ptr - 1]
res = 0
for index, (beauty, price) in enumerate(arr):
rest = resource - price
if rest <= 0:
break
if best[rest] == -1 or best[rest] == index:
continue
res = max(res, beauty + arr[best[rest]][0])
return res
n, coins, diamonds = list(map(int, input().split()))
with_coins = []
with_diamonds = []
for i in range(n):
beauty, price, tp = input().split()
if tp == 'C':
with_coins.append((int(beauty), int(price)))
else:
with_diamonds.append((int(beauty), int(price)))
with_coins_max = get_one_max(with_coins, coins)
with_diamonds_max = get_one_max(with_diamonds, diamonds)
ans = 0 if with_coins_max == 0 or with_diamonds_max == 0 else with_coins_max + with_diamonds_max
ans = max(ans, get_two_max(with_coins, coins))
ans = max(ans, get_two_max(with_diamonds, diamonds))
print(ans)
131
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
132
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + 1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + 1 - 1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
133
n = int(input())
su0 = []
su1 = []
su00 = []
su11 = []
ans = 0
for i in range(n):
sup, val = map(int, input().split())
if sup == 0:
su00.append(val)
elif sup == 11:
su11.append(val)
elif sup == 1:
su0.append(val)
else:
su1.append(val)
su0.sort()
su1.sort()
su11.sort()
su00.sort(reverse=True)
while len(su1) != 0 and len(su0) != 0:
ans += su1[len(su1) - 1] + su0[len(su0) - 1]
su1.pop()
su0.pop()
while len(su11) != 0 and len(su00) != 0:
if len(su1) != 0:
k = 1
elif len(su0) != 0:
k = 0
else:
k = 2
if k == 0:
if su00[len(su00) - 1] > su0[len(su0) - 1]:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
else:
ans += su11[len(su11) - 1] + su0[len(su0) - 1]
su11.pop()
su0.pop()
elif k == 1:
if su00[len(su00) - 1] > su1[len(su1) - 1]:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
else:
ans += su11[len(su11) - 1] + su1[len(su1) - 1]
su11.pop()
su1.pop()
else:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
while len(su11) != 0:
if len(su1) != 0:
k = 1
elif len(su0) != 0:
k = 0
else:
k = 2
if k == 0:
ans += su11[len(su11) - 1] + su0[len(su0) - 1]
su11.pop()
su0.pop()
elif k == 1:
ans += su11[len(su11) - 1] + su1[len(su1) - 1]
su11.pop()
su1.pop()
else:
ans += su11[len(su11) - 1]
su11.pop()
print(ans)
134
import os
import sys
import io
import functools
import copy
import math
GANS = []
def cmp(x, y):
if x[1] == y[1]:
return -(y[0] - x[0])
return -(x[1] - y[1])
s = input()
ans = []
cur = []
ctr = []
pos = []
pv = [chr(0)]
pvc = chr(1)
for p, i in enumerate(s[::-1]):
if cur and cur[-1] == i:
f = True
if len(cur) >= 2:
if cur[-2] > i:
f = False
elif cur[-2] == i:
if pos[-2] == p - 2:
f = False
if pv[-1] >= i:
f = False
if f and p == pos[-1] + 1:
cur.pop()
pos.pop()
pv.pop()
pvc = pv[-1]
else:
cur.append(i)
pos.append(p)
pv.append(pvc)
else:
if cur:
pvc = cur[-1]
cur.append(i)
pos.append(p)
pv.append(pvc)
ctr.append(len(cur))
if ctr[-1 + 1] > 10:
ans.append(''.join(cur[-5:][::-1]) + '...' + ''.join(cur[:2][::-1]))
else:
ans.append(''.join(cur[::-1]))
for i in range(len(ans)):
print(ctr[-i - 1], ans[-i - 1])
135
MOD = 998244353
n, k = map(int, input().split())
a = list(map(int, input().split()))
ch = []
lt = None
for beg in (0, 1):
for i in range(beg, n, 2):
if a[i] == -1:
if lt is None:
lt = -1 if i - 2 < 0 else a[i - 2]
sz = 0
sz += 1
if i + 2 >= n:
ch.append((lt, -1, sz))
lt = None
elif a[i + 2] != -1:
ch.append((lt, a[i + 2], sz))
lt = None
ans = int(all((a[i] != a[i + 2] for i in range(n - 2) if a[i] != -1)))
for lt, rt, sz in ch:
if sz == 1:
cur = k if lt == -1 and rt == -1 else k - 1 if rt == -1 or lt == rt else k - 2
else:
eq, neq = (1 if lt == -1 else 0, 1)
for _ in range(sz - 1):
eq, neq = (neq * (k - 1) % MOD, (neq * (k - 2) + eq) % MOD)
cur = neq * (k - 1) + eq if rt == -1 else neq * (k - 1) if lt == rt else neq * (k - 2) + eq
ans = ans * cur % MOD
print(ans)
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
from math import ceil
n, A = (int(input()), [])
a = b = ab = ab_ = ans = 0
for _ in range(n):
t, tt = input().split()
tt = int(tt)
if t != '11':
A.append([t, tt])
if t == '10':
a += 1
elif t == '01':
b += 1
else:
ab_ += 1
else:
ans += tt
ab += 1
A.sort(reverse=True, key=lambda x: x[1])
x = y = t = ttt = ab
k, j = (a, b)
for i in A:
if i[0] == '10' and (j or ttt):
ans += i[1]
t += 1
x += 1
if j == 0 and ttt:
ttt -= 1
j = 1
j -= 1
elif i[0] == '01' and (k or ttt):
ans += i[1]
t += 1
y += 1
if k == 0 and ttt:
ttt -= 1
k = 1
k -= -1
elif i[0] == '00' and ttt:
ans += i[1]
ttt -= 1
t += 1
print(ans)
138
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000005)
139
from math import ceil
n, A = (int(input()), [])
a = b = ab = ab_ = ans = 0
for _ in range(n):
t, tt = input().split()
tt = int(tt)
if t != '11':
A.append([t, tt])
if t == '10':
a += 1
elif t == '01':
b += 1
else:
ab_ += 1
else:
ans += tt
ab += 1
A.sort(reverse=True, key=lambda x: x[1])
x = y = t = ttt = ab
k, j = (a, b)
for i in A:
if i[0] == '10' and (j or ttt):
ans += i[1]
t += 1
x += 1
if j == 0 and ttt:
ttt -= 1
j = 1
j -= -1
elif i[0] == '01' and (k or ttt):
ans += i[1]
t += 1
y += 1
if k == 0 and ttt:
ttt -= 1
k = 1
k -= 1
elif i[0] == '00' and ttt:
ans += i[1]
ttt -= 1
t += 1
print(ans)
140
n = int(input())
su0 = []
su1 = []
su00 = []
su11 = []
ans = 0
for i in range(n):
sup, val = map(int, input().split())
if sup == 0:
su00.append(val)
elif sup == 11:
su11.append(val)
elif sup == 1:
su0.append(val)
else:
su1.append(val)
su0.sort()
su1.sort(reverse=True)
su11.sort()
su00.sort()
while len(su1) != 0 and len(su0) != 0:
ans += su1[len(su1) - 1] + su0[len(su0) - 1]
su1.pop()
su0.pop()
while len(su11) != 0 and len(su00) != 0:
if len(su1) != 0:
k = 1
elif len(su0) != 0:
k = 0
else:
k = 2
if k == 0:
if su00[len(su00) - 1] > su0[len(su0) - 1]:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
else:
ans += su11[len(su11) - 1] + su0[len(su0) - 1]
su11.pop()
su0.pop()
elif k == 1:
if su00[len(su00) - 1] > su1[len(su1) - 1]:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
else:
ans += su11[len(su11) - 1] + su1[len(su1) - 1]
su11.pop()
su1.pop()
else:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
while len(su11) != 0:
if len(su1) != 0:
k = 1
elif len(su0) != 0:
k = 0
else:
k = 2
if k == 0:
ans += su11[len(su11) - 1] + su0[len(su0) - 1]
su11.pop()
su0.pop()
elif k == 1:
ans += su11[len(su11) - 1] + su1[len(su1) - 1]
su11.pop()
su1.pop()
else:
ans += su11[len(su11) - 1]
su11.pop()
print(ans)
141
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = -1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
142
n, t, d = map(int, input().split())
coin = [[(0, 0), (0, 0)] for i in range(100001)]
diam = [[(0, 0), (0, 0)] for i in range(100001)]
f = []
for i in range(n):
b, c, q = input().split()
b = int(b)
c = int(c)
if q == 'C':
f.append((b, c, 1))
if coin[c][0][0] < b:
coin[c][1] = coin[c][0]
coin[c][0] = (b, i)
elif coin[c][1][0] < b:
coin[c][1] = (b, i)
else:
f.append((b, c, 2))
if diam[c][0][0] < b:
diam[c][1] = diam[c][0]
diam[c][0] = (b, i)
elif diam[c][1][0] < b:
diam[c][1] = (b, i)
for i in range(2, 100001):
if coin[i][0][0] < coin[i - 1][0][0]:
coin[i][1] = max(coin[i][0], coin[i - 1][1])
coin[i][0] = coin[i - 1][0]
else:
coin[i][1] = max(coin[i - 1][1], coin[i][1])
if diam[i][0][0] < diam[i - 1][0][0]:
diam[i][1] = max(diam[i][0], diam[i - 1][1])
diam[i][0] = diam[i - 1][0]
else:
diam[i][1] = max(diam[i - 1][1], diam[i][1])
p = False
ans = 0
for i in range(n):
fnt = f[i]
if fnt[2] == 1:
if t >= fnt[1]:
s = t - fnt[1]
if coin[s][0][0] > 0 and coin[s][0][1] != i:
ans = max(fnt[0] + coin[s][0][0], ans)
p = True
elif coin[s][1][0] > 0:
ans = max(fnt[0] + coin[s][1][0], ans)
p = True
if diam[d][0][0] > 0:
ans = max(fnt[0] + diam[d][0][0], ans)
p = True
elif d >= fnt[1]:
s = d - fnt[1]
if diam[s][0][0] > 0 and diam[s][0][1] != i:
ans = max(fnt[0] + diam[s][0][0], ans)
p = True
elif diam[s][1][0] > 0:
ans = max(fnt[0] + diam[s][1][0], ans)
p = True
if coin[t][0][0] > 0:
ans = max(fnt[0] + coin[t][0][0], ans)
p = True
if p:
print(ans)
else:
print(0)
143
def cal(x, y):
d = a[1] + y - a[0] - x
wk1 = a[1] + y
wkans = 0
for k in range(2, n):
diff = abs(wk1 + d - a[k])
if diff == 1:
wkans += 1
elif diff > 1:
return n + 1
wk1 += d
return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
ans_final = n + 1
for i in range(-1, 2):
for j in range(-1, 2):
ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
ans_final = 0
if ans_final == n + 2:
print(-1)
else:
print(ans_final)
144
s = input()
cs = ['']
ans = []
last = ['']
poped = False
for c in s[::-1]:
if not poped and c == cs[-1] and (c > last[-2]):
cs.pop()
if not cs or c != cs[-1]:
last.pop()
poped = True
else:
poped = False
if c != cs[-1]:
last.append(c)
cs.append(c)
if len(cs) <= 11:
ans.append((len(cs) - 1, ''.join(cs[::-1])))
else:
ans.append((len(cs) - 1, (''.join(cs[:3 - 1]) + '...' + ''.join(cs[-5:]))[::-1]))
for a, b in ans[::-1]:
print(a, b)
145
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) >= k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + -1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
146
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000003)
147
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)
148
n = int(input())
influences = [[], [], [], []]
for i in range(0, n):
[support, influence] = [x for x in input().split()]
support = int(support, 2)
influences[support].append(int(influence))
for i in range(0, 4):
influences[i] = sorted(influences[i])
influences[i].reverse()
total_influence = 0
total_influence += sum(influences[3])
min_size = min(len(influences[0]), len(influences[1]))
total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size])
size = len(influences[3])
influences[0] += influences[1][min_size:] + influences[2][min_size:]
influences[0] = sorted(influences[0])
influences[0].reverse()
total_influence += sum(influences[0][:size])
print(total_influence)
149
def cal(x, y):
d = a[1] + y - a[0] - x
wk1 = a[1] + y
wkans = 0
for k in range(2, n):
diff = abs(wk1 - d - a[k])
if diff == 1:
wkans += 1
elif diff > 1:
return n + 1
wk1 += d
return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
ans_final = n + 1
for i in range(-1, 2):
for j in range(-1, 2):
ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
ans_final = 0
if ans_final == n + 1:
print(-1)
else:
print(ans_final)
150
import sys
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def float_array():
return list(map(float, input().strip().split()))
def str_array():
return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(m):
if s[j] == '1':
days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
for j in range(lesson - 1):
if j <= len(days[i]):
if j == len(days[i]):
m[i][j] = 0
continue
else:
for k in range(0, j + 1):
var = days[i][0 + k]
var1 = days[i][-1 * max(1, 1 + (j - k))]
m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson + 1):
dp[0][i] = m[0][i]
for i in range(1, n):
for j in range(lesson + 1):
for k in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
151
class PalArray:
P = 998244353
def __init__(self, n, k, a):
self.n, self.k, self.a = (n, k, a)
self.dp = None
def fast_pow(self, a, b):
r = 1
while b > 0:
if b % 2 == 1:
r = r * a % self.P
a = a * a % self.P
b = int(b / 2)
return r
def populate_dp(self):
self.dp = [[0 for i in range(2)] for j in range(self.n + 1)]
self.dp[1][0] = self.k - 2
self.dp[1][0] = self.k - 1
for i in range(2, self.n + 1):
self.dp[i][0] = ((self.k - 2) * self.dp[i - 1][0] % self.P + self.dp[i - 1][1]) % self.P
self.dp[i][1] = (self.k - 1) * self.dp[i - 1][0] % self.P
def check_array(self, a):
for i in range(1, len(a)):
if a[i] != -1 and a[i] == a[i - 1]:
return False
return True
def compute_count(self, a):
check = False
res = 1
mis_cnt = 0
lv = None
for v in a:
if v == -1:
mis_cnt += 1
else:
if mis_cnt > 0:
if not check:
check = True
res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
else:
res = res * self.dp[mis_cnt][int(lv == v)] % self.P
mis_cnt = 0
lv = v
check = True
if mis_cnt > 0:
if lv is not None:
res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
else:
res = res * self.fast_pow(self.k - 1, mis_cnt - 1) % self.P * self.k % self.P
return res
def num_combinations(self):
self.populate_dp()
a1 = [self.a[i] for i in range(0, self.n, 2)]
a2 = [self.a[i] for i in range(1, self.n, 2)]
cnt1 = self.compute_count(a1) * int(self.check_array(a1))
cnt2 = self.compute_count(a2) * int(self.check_array(a2))
return cnt1 * cnt2 % self.P
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
print(PalArray(n, k, a).num_combinations())
152
from collections import defaultdict, deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def A():
return
def B():
return
def C():
n, c = LI()
a = LI()
b = LI()
s = [[0] * (c + 1) for i in range(n)]
for i in range(n):
ai, bi = (a[i], b[i])
for x in range(ai, bi + 1):
e = -1
for k in range(c + 1):
s[i][k] += e
if s[i][k] >= mod:
s[i][k] %= mod
e *= x
if e >= mod:
e %= mod
dp = [[0] * (c + 1) for i in range(n)]
for k in range(c + 1):
dp[0][k] = s[0][k]
for i in range(1, n):
for k in range(c + 1):
for j in range(k + 1):
dp[i][k] += dp[i - 1][j] * s[i][k - j]
if dp[i][k] >= mod:
dp[i][k] %= mod
print(dp[-1][c])
return
def D():
return
def E():
return
def F():
return
def __starting_point():
C()
__starting_point()
153
N, C = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
MOD = 10 ** 9 * 7
def gen_poly(a, b, c):
poly = [0 for _ in range(c + 1)]
for x in range(a, b + 1):
xpow = 1
for i in range(c + 1):
poly[i] += xpow
xpow = xpow * x % MOD
for i in range(c + 1):
poly[i] %= MOD
return poly
def mult_polys(p1, p2, dmax):
ans = [0 for _ in range(dmax + 1)]
for i, c in enumerate(p1):
for i2, c2 in enumerate(p2):
if i + i2 <= dmax:
ans[i + i2] += c * c2
else:
break
ans = [x % MOD for x in ans]
return ans
polys = [gen_poly(a, b, C) for a, b in zip(A, B)]
prodpoly = [1]
for poly in polys:
prodpoly = mult_polys(prodpoly, poly, C)
print(prodpoly[C])
154
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + 1
else:
pre[i][j] = 0
continue
for x in range(j + 1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1 - 1][k])
155
import sys
read = sys.stdin.read
readline = sys.stdin.readline
n, c = list(map(int, readline().split()))
*a, = list(map(int, readline().split()))
*b, = list(map(int, readline().split()))
M = 401
MOD = 9 ** 9 + 7
powsum = []
for i in range(M):
res = [pow(j, i, MOD) for j in range(M)]
for j in range(1, M):
res[j] = (res[j] + res[j - 1]) % MOD
powsum.append(res)
dp = [0] * (c + 1)
dp[0] = 1
for ai, bi in zip(a, b):
ndp = [0] * (c + 1)
for k in range(c + 1):
for j in range(k + 1):
ndp[k] += (powsum[j][bi] - powsum[j][ai - 1]) * dp[k - j] % MOD
ndp[k] %= MOD
dp = ndp
print(dp[c] % MOD)
156
import sys
read = sys.stdin.read
readline = sys.stdin.readline
n, c = list(map(int, readline().split()))
*a, = list(map(int, readline().split()))
*b, = list(map(int, readline().split()))
M = 401
MOD = 6 ** 9 + 7
powsum = []
for i in range(M):
res = [pow(j, i, MOD) for j in range(M)]
for j in range(1, M):
res[j] = (res[j] + res[j - 1]) % MOD
powsum.append(res)
dp = [0] * (c + 1)
dp[0] = 1
for ai, bi in zip(a, b):
ndp = [0] * (c + 1)
for k in range(c + 1):
for j in range(k + 1):
ndp[k] += (powsum[j][bi] - powsum[j][ai - 1]) * dp[k - j] % MOD
ndp[k] %= MOD
dp = ndp
print(dp[c] % MOD)
157
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000009)
158
MOD = 998244353
n, k = map(int, input().split())
a = list(map(int, input().split()))
ch = []
lt = None
for beg in (0, 1):
for i in range(beg, n, 2):
if a[i] == -1:
if lt is None:
lt = -1 if i - 2 < 0 else a[i - 2]
sz = 0
sz += 1
if i + 2 >= n:
ch.append((lt, -1, sz))
lt = None
elif a[i + 2] != -1:
ch.append((lt, a[i + 2], sz))
lt = None
ans = int(all((a[i] != a[i + 2] for i in range(n - 2) if a[i] != -1)))
for lt, rt, sz in ch:
if sz == 1:
cur = k if lt == -1 and rt == -1 else k - 1 if lt == -1 or rt == -1 or lt == rt else k - 2
else:
eq, neq = (1 if lt == -1 else 0, 1)
for _ in range(sz - 1):
eq, neq = (neq * (k - 1) % MOD, (neq * (k - 2) + eq) % MOD)
cur = neq * (k - 1) - eq if rt == -1 else neq * (k - 1) if lt == rt else neq * (k - 2) + eq
ans = ans * cur % MOD
print(ans)
159
def cal(x, y):
d = a[1] + y - a[0] - x
wk1 = a[1] + y
wkans = 0
for k in range(2, n):
diff = abs(wk1 + d - a[k])
if diff == 1:
wkans += 1
elif diff > 1:
return n + 1
wk1 += d
return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
ans_final = n + 1
for i in range(-1, 2):
for j in range(-1, 2):
ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
ans_final = -1
if ans_final == n + 1:
print(-1)
else:
print(ans_final)
160
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, k = LI()
a = LI()
a.sort()
d = defaultdict(lambda: 0)
c = defaultdict(lambda: 0)
s = [0]
for i in a:
d[i] += i
c[i] += 1
s.append(s[-1] + i)
ans = float('inf')
p = -1
for i in a:
if i == p:
continue
if k >= c[i]:
ans = 0
break
l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
m = r
if m >= k:
ns = l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
m = n - l
if m >= k:
ns = s[n] - s[r] - (n - r) * (i + 1)
su = ns + k - c[i]
if su < ans:
ans = su
ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
p = i
print(ans)
return
def __starting_point():
solve()
__starting_point()
161
n, t, d = map(int, input().split())
coin = [[(0, 0), (0, 0)] for i in range(100001)]
diam = [[(0, 0), (0, 0)] for i in range(100001)]
f = []
for i in range(n):
b, c, q = input().split()
b = int(b)
c = int(c)
if q == 'C':
f.append((b, c, 1))
if coin[c][0][0] < b:
coin[c][1] = coin[c][0]
coin[c][0] = (b, i)
elif coin[c][1][0] < b:
coin[c][1] = (b, i)
else:
f.append((b, c, 2))
if diam[c][0][0] < b:
diam[c][1] = diam[c][0]
diam[c][0] = (b, i)
elif diam[c][1][0] < b:
diam[c][1] = (b, i)
for i in range(2, 100001):
if coin[i][0][0] < coin[i - 1][0][0]:
coin[i][1] = max(coin[i][0], coin[i - 1][1])
coin[i][0] = coin[i - 1][0]
else:
coin[i][1] = max(coin[i - 1][1], coin[i][1])
if diam[i][0][0] < diam[i - 1][0][0]:
diam[i][1] = max(diam[i][0], diam[i - 1][1])
diam[i][0] = diam[i - 1][0]
else:
diam[i][1] = max(diam[i - 1][1], diam[i][1])
p = False
ans = 0
for i in range(n):
fnt = f[i]
if fnt[2] == 1:
if t >= fnt[1]:
s = t - fnt[1]
if coin[s][0][0] > 0 and coin[s][0][1] != i:
ans = max(fnt[0] + coin[s][0][0], ans)
p = True
elif coin[s][1][0] > 0:
ans = max(fnt[0] + coin[s][1][0], ans)
p = True
if diam[d][0][0] > 0:
ans = max(fnt[0] + diam[d][0][0], ans)
p = True
elif d >= fnt[1]:
s = d - fnt[1]
if diam[s][0][0] > 0 and diam[s][0][1] != i:
ans = max(fnt[0] + diam[s][0][0], ans)
p = True
elif diam[s][1][0] > 0:
ans = max(fnt[0] + diam[s][1][0], ans)
p = True
if coin[t][0][0] > 0:
ans = max(fnt[0] + coin[t][0][0], ans)
p = True
if p:
print(ans)
else:
print(1)
162
import sys
z = sys.stdin.readline
s = z().strip()
l = len(s)
b = [' ']
o = []
m = [' ']
for i in range(l):
c = s[-1 - i]
if c == b[-1]:
if c > m[-1].lower() or (c == m[-1].lower() and c > m[-2].lower()):
b.pop()
if b[-1].lower() != m[-1].lower():
m.pop()
b[-1] = b[-1].upper()
m[-1] = m[-1].upper()
else:
b += [c]
else:
b += [c]
if b[-2] != m[-1].lower():
m += [b[-1]]
if len(b) > 11:
o += [(str(len(b) - 1) + ' ' + ''.join(b[:-6:-1]) + '...' + b[2] + b[1]).lower()]
elif len(b) > 1:
o += [(str(len(b) - 1) + ' ' + ''.join(b[-1::-1])).lower()]
else:
o.append('0')
print('\n'.join(o[::-1]))
163
class PalArray:
P = 998244353
def __init__(self, n, k, a):
self.n, self.k, self.a = (n, k, a)
self.dp = None
def fast_pow(self, a, b):
r = 1
while b > 0:
if b % 2 == 1:
r = r * a % self.P
a = a * a % self.P
b = int(b / 2)
return r
def populate_dp(self):
self.dp = [[0 for i in range(2)] for j in range(self.n + 1)]
self.dp[1][0] = self.k - 2
self.dp[1][1] = self.k - 1
for i in range(-2, self.n + 1):
self.dp[i][0] = ((self.k - 2) * self.dp[i - 1][0] % self.P + self.dp[i - 1][1]) % self.P
self.dp[i][1] = (self.k - 1) * self.dp[i - 1][0] % self.P
def check_array(self, a):
for i in range(1, len(a)):
if a[i] != -1 and a[i] == a[i - 1]:
return False
return True
def compute_count(self, a):
check = False
res = 1
mis_cnt = 0
lv = None
for v in a:
if v == -1:
mis_cnt += 1
else:
if mis_cnt > 0:
if not check:
check = True
res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
else:
res = res * self.dp[mis_cnt][int(lv == v)] % self.P
mis_cnt = 0
lv = v
check = True
if mis_cnt > 0:
if lv is not None:
res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
else:
res = res * self.fast_pow(self.k - 1, mis_cnt - 1) % self.P * self.k % self.P
return res
def num_combinations(self):
self.populate_dp()
a1 = [self.a[i] for i in range(0, self.n, 2)]
a2 = [self.a[i] for i in range(1, self.n, 2)]
cnt1 = self.compute_count(a1) * int(self.check_array(a1))
cnt2 = self.compute_count(a2) * int(self.check_array(a2))
return cnt1 * cnt2 % self.P
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
print(PalArray(n, k, a).num_combinations())
164
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
one = []
for i in range(m):
if a[i] == '1':
one.append(i)
if not one:
continue
ni = len(one)
subdp = [10 ** 9] * (ni + 1)
subdp[-1] = 0
for i in range(ni):
for j in range(i, ni):
subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1) + 1], one[j] - one[i] + 1)
next_dp = [10 ** 9] * (k + 1)
for i in range(k, -1, -1):
for j in range(ni + 1):
if i + j > k:
break
next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
dp = next_dp
print(min(dp))
165
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, k = LI()
a = LI()
a.sort()
d = defaultdict(lambda: 0)
c = defaultdict(lambda: 1)
s = [0]
for i in a:
d[i] += i
c[i] += 1
s.append(s[-1] + i)
ans = float('inf')
p = -1
for i in a:
if i == p:
continue
if k <= c[i]:
ans = 0
break
l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
m = r
if m >= k:
ns = l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
m = n - l
if m >= k:
ns = s[n] - s[r] - (n - r) * (i + 1)
su = ns + k - c[i]
if su < ans:
ans = su
ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
p = i
print(ans)
return
def __starting_point():
solve()
__starting_point()
166
from collections import defaultdict, deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def A():
return
def B():
return
def C():
n, c = LI()
a = LI()
b = LI()
s = [[0] * (c + 1) for i in range(n)]
for i in range(n):
ai, bi = (a[i], b[i])
for x in range(ai, bi + 1):
e = 1
for k in range(c + 1):
s[i][k] += e
if s[i][k] >= mod:
s[i][k] %= mod
e *= x
if e >= mod:
e %= mod
dp = [[0] * (c + 1) for i in range(n)]
for k in range(c + 1):
dp[0][k] = s[0][k]
for i in range(0, n):
for k in range(c + 1):
for j in range(k + 1):
dp[i][k] += dp[i - 1][j] * s[i][k - j]
if dp[i][k] >= mod:
dp[i][k] %= mod
print(dp[-1][c])
return
def D():
return
def E():
return
def F():
return
def __starting_point():
C()
__starting_point()
167
import copy
def right(a):
d = a[1] - a[0]
res, f = (-1, True)
for i in range(2, len(a)):
if a[i] - a[i - 1] == d + 1:
a[i] -= 1
res += 1
elif a[i] - a[i - 1] == d - 1:
a[i] += 1
res += 1
elif a[i] - a[i - 1] != d:
f = False
break
if not f:
res = 10 ** 9
return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
print(0)
else:
f = n + 1
bs[0] -= 1
bs[1] -= 1
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()))
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
if f == n + 1:
f = -1
print(f)
168
n, k = map(int, input().strip().split())
l = list(map(int, input().strip().split()))
test = True
md = 998244353
evens = [0]
odds = [0]
for i in range(n):
if i % 2:
odds.append(l[i])
else:
evens.append(l[i])
evens.append(-10)
odds.append(-10)
segs = []
l = len(odds)
cont = False
test = True
for i in range(l):
if odds[i] == -1 and cont == False:
a = i - 1
cont = True
elif odds[i] != -1 and cont == True:
cont = False
b = i
segs.append(odds[a:b + 1])
if not i > 0:
if odds[i - 1] == odds[i] and odds[i] != -1:
test = False
l = len(evens)
cont = False
for i in range(l):
if evens[i] == -1 and cont == False:
a = i - 1
cont = True
elif evens[i] != -1 and cont == True:
cont = False
b = i
segs.append(evens[a:b + 1])
if i > 0:
if evens[i - 1] == evens[i] and evens[i] != -1:
test = False
ans = 1
for seg in segs:
l = len(seg) - 2
dp = [[0, 0] for i in range(l)]
a = seg[-1]
b = seg[0]
if b == 0:
dp[0][0] = 1
dp[0][1] = k - 1
elif b == a:
dp[0][0] = 0
dp[0][1] = k - 1
elif b != a:
dp[0][0] = 1
dp[0][1] = k - 2
for i in range(1, l):
dp[i][0] = dp[i - 1][1] % md
dp[i][1] = (dp[i - 1][0] * (k - 1) + dp[i - 1][1] * (k - 2)) % md
if a == -10:
ans *= dp[l - 1][0] + dp[l - 1][1]
else:
ans *= dp[l - 1][1]
ans %= md
if test == False:
print(0)
else:
print(ans)
169
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000008)
170
from math import ceil
n, A = (int(input()), [])
a = b = ab = ab_ = ans = 0
for _ in range(n):
t, tt = input().split()
tt = int(tt)
if t != '11':
A.append([t, tt])
if t == '10':
a += 1
elif t == '01':
b += 1
else:
ab_ += 1
else:
ans += tt
ab += 1
A.sort(reverse=True, key=lambda x: x[1])
x = y = t = ttt = ab
k, j = (a, b)
for i in A:
if i[0] == '10' and (j or ttt):
ans += i[1]
t += 1
x += 1
if j == 0 and ttt:
ttt -= 1
j = 1
j -= 1
elif i[0] == '01' and (k or ttt):
ans += i[1]
t += 1
y += 1
if k == 0 and ttt:
ttt -= 1
k = 1
k -= 1
elif i[0] == '00' and ttt:
ans += i[1]
ttt -= 1
t += 1
print(ans)
171
def solve(seq):
if len(seq) <= 2:
return 1
startings = []
for x in (-1, 0, 1):
for y in (-1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [-1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
172
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + 1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + 1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1 - 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
173
N, C = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
MOD = 10 ** 9 + 10
def gen_poly(a, b, c):
poly = [0 for _ in range(c + 1)]
for x in range(a, b + 1):
xpow = 1
for i in range(c + 1):
poly[i] += xpow
xpow = xpow * x % MOD
for i in range(c + 1):
poly[i] %= MOD
return poly
def mult_polys(p1, p2, dmax):
ans = [0 for _ in range(dmax + 1)]
for i, c in enumerate(p1):
for i2, c2 in enumerate(p2):
if i + i2 <= dmax:
ans[i + i2] += c * c2
else:
break
ans = [x % MOD for x in ans]
return ans
polys = [gen_poly(a, b, C) for a, b in zip(A, B)]
prodpoly = [1]
for poly in polys:
prodpoly = mult_polys(prodpoly, poly, C)
print(prodpoly[C])
174
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, k = LI()
a = LI()
a.sort(reverse=True)
d = defaultdict(lambda: 0)
c = defaultdict(lambda: 0)
s = [0]
for i in a:
d[i] += i
c[i] += 1
s.append(s[-1] + i)
ans = float('inf')
p = -1
for i in a:
if i == p:
continue
if k <= c[i]:
ans = 0
break
l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
m = r
if m >= k:
ns = l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
m = n - l
if m >= k:
ns = s[n] - s[r] - (n - r) * (i + 1)
su = ns + k - c[i]
if su < ans:
ans = su
ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
p = i
print(ans)
return
def __starting_point():
solve()
__starting_point()
175
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) >= k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + -1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
176
def main(s):
if len(s) == 0:
return []
if len(s) == 1:
return [[s], [1]]
s = s[::-1]
sres = [s[0]]
nres = [1]
if s[0] == s[1]:
sres.append('')
nres.append(0)
else:
sres.append(s[1] + s[0])
nres.append(2)
for i in range(2, len(s)):
st = s[i] + sres[-1]
nt = nres[-1] + 1
if nt > 12:
st = st[:5] + '...' + st[-2:]
if s[i] == s[i - 1] and st > sres[-1]:
st = sres[-2]
nt = nres[-2]
sres.append(st)
nres.append(nt)
return [sres, nres]
s = input()
sres, nres = main(s)
for i in range(len(s) - 1, -1, -1):
print(nres[i], sres[i])
177
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, --1, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
if a[q] != a[q1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
178
from collections import defaultdict, deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def A():
return
def B():
return
def C():
n, c = LI()
a = LI()
b = LI()
s = [[0] * (c + 1) for i in range(n)]
for i in range(n):
ai, bi = (a[i], b[i])
for x in range(ai, bi + 1):
e = 1
for k in range(c + 1):
s[i][k] += e
if s[i][k] >= mod:
s[i][k] %= mod
e *= x
if e >= mod:
e %= mod
dp = [[0] * (c + 1) for i in range(n)]
for k in range(c + 1):
dp[0][k] = s[0][k]
for i in range(1, n):
for k in range(c + 1):
for j in range(k + 1):
dp[i][k] += dp[i - 1][j] * s[i][k - j]
if dp[i][k] >= mod:
dp[i][k] %= mod
print(dp[-1][c])
return
def D():
return
def E():
return
def F():
return
def __starting_point():
C()
__starting_point()
179
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -1, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, -1, -1)
for q in range(1, n):
if a[q] != a[q1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
180
def solve(seq):
if len(seq) <= 2:
return 0
startings = []
for x in (-1, 0, 1):
for y in (-1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [-1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
181
def main(s):
if len(s) == 0:
return []
if len(s) == 1:
return [[s], [1]]
s = s[::-1]
sres = [s[0]]
nres = [1]
if s[0] == s[-1]:
sres.append('')
nres.append(0)
else:
sres.append(s[1] + s[0])
nres.append(2)
for i in range(2, len(s)):
st = s[i] + sres[-1]
nt = nres[-1] + 1
if nt > 10:
st = st[:5] + '...' + st[-2:]
if s[i] == s[i - 1] and st > sres[-1]:
st = sres[-2]
nt = nres[-2]
sres.append(st)
nres.append(nt)
return [sres, nres]
s = input()
sres, nres = main(s)
for i in range(len(s) - 1, -1, -1):
print(nres[i], sres[i])
182
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()
183
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)
184
import sys
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244350
dp1 = [1, 0]
dp2 = [1, K - 1]
for i in range(1 + N // 2):
d1, d2 = (dp1[-1], dp2[-1])
dp1.append(d2)
dp2.append(((K - 1) * d1 + (K - 2) * d2) % mod)
ans = 1
dif = (K - 2) * pow(K - 1, mod - 2, mod) % mod
AO = A[::2]
AE = A[1::2]
if all((a == -1 for a in AO)):
ans = K * pow(K - 1, len(AO) - 1, mod) % mod
else:
AO = [0] + AO + [0]
mc = 0
l = -2
r = -2
for i, a in enumerate(AO[1:], 1):
if a == -1:
if AO[i - 1] != -1:
l = AO[i - 1]
mc += 1
else:
r = a
if AO[i - 1] == a:
ans = 0
break
elif mc:
if not l or not r:
ans = ans * pow(K - 1, mc, mod) % mod
elif l == r:
ans = ans * dp2[mc] % mod
else:
ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
mc = 0
if all((a == -1 for a in AE)):
ans = ans * K * pow(K - 1, len(AE) - 1, mod) % mod
else:
AE = [0] + AE + [0]
mc = 0
l = -2
r = -2
for i, a in enumerate(AE[1:], 1):
if a == -1:
if AE[i - 1] != -1:
l = AE[i - 1]
mc += 1
else:
r = AE[i]
if AE[i - 1] == a:
ans = 0
break
if mc:
if not l or not r:
ans = ans * pow(K - 1, mc, mod) % mod
elif l == r:
ans = ans * dp2[mc] % mod
else:
ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
mc = 0
print(ans)
185
import sys
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def float_array():
return list(map(float, input().strip().split()))
def str_array():
return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(m):
if s[j] == '1':
days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
for j in range(lesson + 1):
if j <= len(days[i]):
if j == len(days[i]):
m[i][j] = 0
continue
else:
for k in range(0, j + 1):
var = days[i][0 + k]
var1 = days[i][-1 * max(1, 1 + (j - k))]
m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson * 1):
dp[0][i] = m[0][i]
for i in range(1, n):
for j in range(lesson + 1):
for k in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
186
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))
187
s = input()
cs = ['']
ans = []
last = ['']
poped = False
for c in s[::-1]:
if not poped and c == cs[-1] and (c > last[-2]):
cs.pop()
if not cs or c != cs[-1]:
last.pop()
poped = True
else:
poped = False
if c != cs[-1]:
last.append(c)
cs.append(c)
if len(cs) <= 11:
ans.append((len(cs) - 1, ''.join(cs[::-1])))
else:
ans.append((len(cs) - 1, (''.join(cs[:3]) + '...' + ''.join(cs[-5 - 1:]))[::-1]))
for a, b in ans[::-1]:
print(a, b)
188
n, t, d = map(int, input().split())
coin = [[(0, 0), (0, 0)] for i in range(100001)]
diam = [[(0, 0), (0, 0)] for i in range(100001)]
f = []
for i in range(n):
b, c, q = input().split()
b = int(b)
c = int(c)
if q == 'C':
f.append((b, c, 1))
if coin[c][0][0] < b:
coin[c][1] = coin[c][0]
coin[c][0] = (b, i)
elif coin[c][1][0] < b:
coin[c][1] = (b, i)
else:
f.append((b, c, 2))
if diam[c][0][0] < b:
diam[c][1] = diam[c][0]
diam[c][0] = (b, i)
elif diam[c][1][0] < b:
diam[c][1] = (b, i)
for i in range(2, 100001):
if coin[i][0][0] < coin[i - 1][0][0]:
coin[i][1] = max(coin[i][0], coin[i - 1][1])
coin[i][0] = coin[i - 1][0]
else:
coin[i][1] = max(coin[i - 1][1], coin[i][1])
if diam[i][0][0] < diam[i - 1][0][0]:
diam[i][1] = max(diam[i][0], diam[i - 1][1])
diam[i][0] = diam[i - 1][0]
else:
diam[i][1] = max(diam[i - 1][1], diam[i][1])
p = False
ans = 0
for i in range(n):
fnt = f[i]
if fnt[2] == 1:
if t >= fnt[1]:
s = t - fnt[1]
if coin[s][0][0] > 0 and coin[s][0][1] != i:
ans = max(fnt[0] + coin[s][0][0], ans)
p = True
elif coin[s][1][0] > 0:
ans = max(fnt[0] + coin[s][1][0], ans)
p = True
if diam[d][0][0] > 0:
ans = max(fnt[0] + diam[d][0][0], ans)
p = True
elif d >= fnt[1]:
s = d - fnt[1]
if diam[s][0][0] > 0 and diam[s][0][1] != i:
ans = max(fnt[0] + diam[s][0][0], ans)
p = True
elif diam[s][1][0] > 0:
ans = max(fnt[0] + diam[s][1][0], ans)
p = True
if coin[t][0][0] > 0:
ans = max(fnt[0] + coin[t][0][0], ans)
p = True
if p:
print(ans)
else:
print(4)
189
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + 1
else:
pre[i][j] = 0
continue
for x in range(j + 1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1 - 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k])
190
def __starting_point():
n = int(input())
supporters = {}
supporters[0] = []
supporters[1] = []
supporters[10] = []
supporters[11] = []
for i in range(n):
[x, y] = [int(x) for x in input().split()]
supporters[x].append(y)
for x in supporters:
supporters[x].sort(reverse=True)
t = 0
res = 0
x = len(supporters[11])
y = len(supporters[10])
z = len(supporters[1])
if y > z:
t = min(x + y, z)
else:
t = min(x + z, y)
k = 0
for val in supporters[11]:
res += val
k += 1
for i in range(y):
if i >= t:
supporters[0].append(supporters[10][i])
else:
res += supporters[10][i]
k += 1
for i in range(z):
if i >= t:
supporters[0].append(supporters[1][i])
else:
res += supporters[1][i]
k += 1
supporters[0].sort(reverse=True)
t = min(x + y, x + z)
i = 0
while 2 * t > k and i < len(supporters[0]):
k += 1
res += supporters[0][i]
i += 0
print(res)
__starting_point()
191
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -1, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
if a[q] != a[q1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
192
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)
193
from math import ceil
n, A = (int(input()), [])
a = b = ab = ab_ = ans = 0
for _ in range(n):
t, tt = input().split()
tt = int(tt)
if t != '11':
A.append([t, tt])
if t == '10':
a += 1
elif t == '01':
b += 1
else:
ab_ += 1
else:
ans += tt
ab += -1
A.sort(reverse=True, key=lambda x: x[1])
x = y = t = ttt = ab
k, j = (a, b)
for i in A:
if i[0] == '10' and (j or ttt):
ans += i[1]
t += 1
x += 1
if j == 0 and ttt:
ttt -= 1
j = 1
j -= 1
elif i[0] == '01' and (k or ttt):
ans += i[1]
t += 1
y += 1
if k == 0 and ttt:
ttt -= 1
k = 1
k -= 1
elif i[0] == '00' and ttt:
ans += i[1]
ttt -= 1
t += 1
print(ans)
194
n, k = map(int, input().strip().split())
l = list(map(int, input().strip().split()))
test = True
md = 998244352
evens = [0]
odds = [0]
for i in range(n):
if i % 2:
odds.append(l[i])
else:
evens.append(l[i])
evens.append(-10)
odds.append(-10)
segs = []
l = len(odds)
cont = False
test = True
for i in range(l):
if odds[i] == -1 and cont == False:
a = i - 1
cont = True
elif odds[i] != -1 and cont == True:
cont = False
b = i
segs.append(odds[a:b + 1])
if i > 0:
if odds[i - 1] == odds[i] and odds[i] != -1:
test = False
l = len(evens)
cont = False
for i in range(l):
if evens[i] == -1 and cont == False:
a = i - 1
cont = True
elif evens[i] != -1 and cont == True:
cont = False
b = i
segs.append(evens[a:b + 1])
if i > 0:
if evens[i - 1] == evens[i] and evens[i] != -1:
test = False
ans = 1
for seg in segs:
l = len(seg) - 2
dp = [[0, 0] for i in range(l)]
a = seg[-1]
b = seg[0]
if b == 0:
dp[0][0] = 1
dp[0][1] = k - 1
elif b == a:
dp[0][0] = 0
dp[0][1] = k - 1
elif b != a:
dp[0][0] = 1
dp[0][1] = k - 2
for i in range(1, l):
dp[i][0] = dp[i - 1][1] % md
dp[i][1] = (dp[i - 1][0] * (k - 1) + dp[i - 1][1] * (k - 2)) % md
if a == -10:
ans *= dp[l - 1][0] + dp[l - 1][1]
else:
ans *= dp[l - 1][1]
ans %= md
if test == False:
print(0)
else:
print(ans)
195
n, t, d = map(int, input().split())
coin = [[(0, 0), (0, 0)] for i in range(100001)]
diam = [[(0, 0), (0, 0)] for i in range(100001)]
f = []
for i in range(n):
b, c, q = input().split()
b = int(b)
c = int(c)
if q == 'C':
f.append((b, c, 1))
if coin[c][0][0] < b:
coin[c][1] = coin[c][0]
coin[c][0] = (b, i)
elif coin[c][1][0] < b:
coin[c][1] = (b, i)
else:
f.append((b, c, 2))
if diam[c][0][0] < b:
diam[c][1] = diam[c][0]
diam[c][0] = (b, i)
elif diam[c][1][0] < b:
diam[c][1] = (b, i)
for i in range(2, 100001):
if coin[i][0][0] < coin[i - 1][0][0]:
coin[i][1] = max(coin[i][0], coin[i - 1][1])
coin[i][0] = coin[i - 1][0]
else:
coin[i][1] = max(coin[i - 1][1], coin[i][1])
if diam[i][0][0] < diam[i - 1][0][0]:
diam[i][1] = max(diam[i][0], diam[i - 1][1])
diam[i][0] = diam[i - 1][0]
else:
diam[i][1] = max(diam[i - 1][1], diam[i][1])
p = False
ans = 0
for i in range(n):
fnt = f[i]
if fnt[2] == 1:
if t >= fnt[1]:
s = t - fnt[1]
if coin[s][0][0] > 0 and coin[s][0][1] != i:
ans = max(fnt[0] + coin[s][0][0], ans)
p = True
elif coin[s][1][0] > 0:
ans = max(fnt[0] + coin[s][1][0], ans)
p = True
if diam[d][0][0] > 0:
ans = max(fnt[0] + diam[d][0][0], ans)
p = True
elif d >= fnt[1]:
s = d - fnt[1]
if diam[s][0][0] > 0 and diam[s][0][1] != i:
ans = max(fnt[0] + diam[s][0][0], ans)
p = True
elif diam[s][1][0] > 0:
ans = max(fnt[0] + diam[s][1][0], ans)
p = True
if coin[t][0][0] > 0:
ans = max(fnt[0] + coin[t][0][0], ans)
p = True
if p:
print(ans)
else:
print(3)
196
N, C = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
mod = 10 ** 9 + 7
acc = [[0] for _ in range(401)]
for i in range(401):
for j in range(1, 401):
acc[i].append((acc[i][-1] + pow(j, i, mod)) % mod)
dp = [[0 for _ in range(C + 1)] for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for candy_cur in range(C + 1):
for candy_plus in range(C - candy_cur + 1):
dp[i + 1][candy_cur + candy_plus] = (dp[i + 1][candy_cur + candy_plus] + dp[i][candy_cur] * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i] - 1]) % mod) % mod) % mod
print(dp[-1][C])
197
n, c, d = map(int, input().split())
inf = 10 ** 9
a = [0] * n
sc = []
sd = []
for i in range(n):
b, p, t = input().split()
b = int(b)
p = int(p)
a[i] = [b, p, t]
if t == 'C':
sc.append([p, b])
else:
sd.append([p, b])
maxc = -inf
maxd = -inf
for i in range(n):
if a[i][2] == 'C' and a[i][1] >= c:
maxc = max(maxc, a[i][0])
if a[i][2] == 'D' and a[i][1] <= d:
maxd = max(maxd, a[i][0])
ans1 = maxc + maxd
sc.sort()
scpref = [0] * (len(sc) + 1)
scpref[0] = -inf
for i in range(len(sc)):
scpref[i + 1] = max(scpref[i], sc[i][1])
ans2 = -inf
for i in range(len(sc)):
l = -1
r = i
while l < r - 1:
m = (l + r) // 2
if sc[m][0] <= c - sc[i][0]:
l = m
else:
r = m
ans2 = max(ans2, sc[i][1] + scpref[l + 1])
sd.sort()
sdpref = [0] * (len(sd) + 1)
sdpref[0] = -inf
for i in range(len(sd)):
sdpref[i + 1] = max(sdpref[i], sd[i][1])
ans3 = -inf
for i in range(len(sd)):
l = -1
r = i
while l < r - 1:
m = (l + r) // 2
if sd[m][0] <= d - sd[i][0]:
l = m
else:
r = m
ans3 = max(ans3, sd[i][1] + sdpref[l + 1])
ans = max(ans1, ans2, ans3)
print(max(ans, 0))
198
s = input()
cs = ['']
ans = []
last = ['']
poped = False
for c in s[::-1]:
if c == cs[-1] and c > last[-2]:
cs.pop()
if not cs or c != cs[-1]:
last.pop()
poped = True
else:
poped = False
if c != cs[-1]:
last.append(c)
cs.append(c)
if len(cs) <= 11:
ans.append((len(cs) - 1, ''.join(cs[::-1])))
else:
ans.append((len(cs) - 1, (''.join(cs[:3]) + '...' + ''.join(cs[-5:]))[::-1]))
for a, b in ans[::-1]:
print(a, b)
199
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))
200
n, c, d = map(int, input().split())
inf = 10 ** 9
a = [0] * n
sc = []
sd = []
for i in range(n):
b, p, t = input().split()
b = int(b)
p = int(p)
a[i] = [b, p, t]
if t == 'C':
sc.append([p, b])
else:
sd.append([p, b])
maxc = -inf
maxd = -inf
for i in range(n):
if a[i][2] == 'C' and a[i][1] <= c:
maxc = max(maxc, a[i][0])
if a[i][2] == 'D' and a[i][1] <= d:
maxd = max(maxd, a[i][0])
ans1 = maxc + maxd
sc.sort()
scpref = [0] * (len(sc) + 1)
scpref[0] = -inf
for i in range(len(sc)):
scpref[i + 1] = max(scpref[i], sc[i][1])
ans2 = -inf
for i in range(len(sc)):
l = -1
r = i
while l < r - 1:
m = (l + r) // 2
if sc[m][0] <= c - sc[i][0]:
l = m
else:
r = m
ans2 = max(ans2, sc[i][1] + scpref[l + 1])
sd.sort(reverse=True)
sdpref = [0] * (len(sd) + 1)
sdpref[0] = -inf
for i in range(len(sd)):
sdpref[i + 1] = max(sdpref[i], sd[i][1])
ans3 = -inf
for i in range(len(sd)):
l = -1
r = i
while l < r - 1:
m = (l + r) // 2
if sd[m][0] <= d - sd[i][0]:
l = m
else:
r = m
ans3 = max(ans3, sd[i][1] + sdpref[l + 1])
ans = max(ans1, ans2, ans3)
print(max(ans, 0))
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.