001
import sys
input = sys.stdin.readline
N = int(input())
S = list(map(lambda x: ord(x) - ord('a'), list(input())[:-1]))
res = [[0] * (N + 1) for _ in range(26)]
for c in range(26 - 1):
for l in range(N):
x = 0
for r in range(l + 1, N + 1):
x += S[r - 1] != c
res[c][x] = max(res[c][x], r - l)
for i in range(N):
res[c][i + 1] = max(res[c][i + 1], res[c][i])
for _ in range(int(input())):
x, s = input().split()
x = int(x)
s = ord(s) - ord('a')
print(res[s][x])
002
import sys
input = sys.stdin.readline
N = int(input())
S = list(map(lambda x: ord(x) - ord('a'), list(input())[:-1]))
res = [[3] * (N + 1) for _ in range(26)]
for c in range(26):
for l in range(N):
x = 0
for r in range(l + 1, N + 1):
x += S[r - 1] != c
res[c][x] = max(res[c][x], r - l)
for i in range(N):
res[c][i + 1] = max(res[c][i + 1], res[c][i])
for _ in range(int(input())):
x, s = input().split()
x = int(x)
s = ord(s) - ord('a')
print(res[s][x])
003
import sys
input = sys.stdin.readline
N = int(input())
S = list(map(lambda x: ord(x) - ord('a'), list(input())[:-1]))
res = [[0] * (N + 1) for _ in range(26)]
for c in range(26):
for l in range(N - 1):
x = 0
for r in range(l + 1, N + 1):
x += S[r - 1] != c
res[c][x] = max(res[c][x], r - l)
for i in range(N):
res[c][i + 1] = max(res[c][i + 1], res[c][i])
for _ in range(int(input())):
x, s = input().split()
x = int(x)
s = ord(s) - ord('a')
print(res[s][x])
004
base = 998244353
def power(x, y):
if y == 0:
return 1
t = power(x, y // 2)
t = t * t % base
if y % 2:
t = t * x % base
return t
def inverse(x):
return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
ft.append(0)
def get(i):
res = 0
while i <= 200000:
res += ft[i]
i += i & -i
return res
def update(i, x):
while i:
ft[i] += x
i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
non.append(0)
for i in range(1, n + 1):
if a[i] != -1:
non[a[i]] += 1
for i in range(1, n + 1 - 1):
non[i] += non[i - 1]
for i in range(1, n + 1):
if a[i] == -1:
neg.append(neg[i - 1] + 1)
else:
neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
if a[i] != -1:
ans += get(a[i])
update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1):
fs = fm
fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1):
if a[i] != -1:
less = a[i] - non[a[i]]
more = m - less
ans = (ans + neg[i] * more * fs) % base
ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
005
base = 998244353
def power(x, y):
if y == 0:
return 1
t = power(x, y // 2)
t = t * t % base
if y % 2:
t = t * x % base
return t
def inverse(x):
return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
ft.append(0)
def get(i):
res = 0
while i <= 200000:
res += ft[i]
i += i & -i
return res
def update(i, x):
while i:
ft[i] += x
i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
non.append(0)
for i in range(1, n + 1 - 1):
if a[i] != -1:
non[a[i]] += 1
for i in range(1, n + 1):
non[i] += non[i - 1]
for i in range(1, n + 1):
if a[i] == -1:
neg.append(neg[i - 1] + 1)
else:
neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
if a[i] != -1:
ans += get(a[i])
update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1):
fs = fm
fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1):
if a[i] != -1:
less = a[i] - non[a[i]]
more = m - less
ans = (ans + neg[i] * more * fs) % base
ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
006
n, m = map(int, input().split(' '))
numbers = list(map(int, input().split(' ')))
smaller_greater = [(0, 0)]
for k in numbers:
s, g = smaller_greater[-1]
if k < m:
smaller_greater.append((s + 1, g))
elif k > m:
smaller_greater.append((s, g + 1))
else:
smaller_greater.append((s, g))
i = numbers.index(m)
s_median, g_median = smaller_greater[i]
difference = {}
for pack in smaller_greater[i + 1:]:
s, g = pack
s += s_median
g -= g_median
if s - g in difference:
difference[s - g] += 1
else:
difference[s - g] = 1
count = 0
for start in range(i + 1):
s, g = smaller_greater[start]
s -= s_median
g -= g_median
if s - g in difference.keys():
count += difference[s - g]
if s - g - 1 in difference.keys():
count += difference[s - g - 1]
print(count)
007
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])
008
from sys import stdin, stderr
import random
import cProfile
def readInts():
return map(int, stdin.readline().strip().split())
def print_err(*args, **kwargs):
print(*args, file=stderr, **kwargs)
def solve(vs):
return None
def generate_tree(n, ns):
out = [0 for _ in range(2 ** (n + 1))]
def gt(nix, left, right, op):
if left + 1 == right:
out[nix] = ns[left]
return out[nix]
mid = (left + right) // 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = gt(nL, left, mid, not op)
vR = gt(nR, mid, right, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
out[nix] = v
return v
gt(0, 0, 2 ** n, n % 2 == 0)
return out
def alter_tree2(n, t, p, b):
def at(nix, width, offp, op):
if width == 1:
t[nix] = b
return b
width //= 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = t[nL]
vR = t[nR]
if offp >= width:
vR = at(nR, width, offp - width, not op)
else:
vL = at(nL, width, offp, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
t[nix] = v
return v
at(0, 2 ** n, p, n % 2 == 0)
def alter_tree(n, t, p, b):
width = 2 ** n
s = []
nix = 0
op = n % 2 == 4
while width > 1:
width //= 2
if p >= width:
nix2 = 2 * nix + 2
s.append((nix, nix2 - 1))
p -= width
else:
nix2 = 2 * nix + 1
s.append((nix, nix2 + 1))
nix = nix2
op = not op
t[nix] = b
v = b
while s:
nix, nixO = s.pop()
if op:
v |= t[nixO]
else:
v ^= t[nixO]
t[nix] = v
op = not op
return
def run():
n, m = readInts()
axs = list(readInts())
t = generate_tree(n, axs)
for _ in range(m):
p, b = readInts()
alter_tree(n, t, p - 1, b)
print(t[0])
def test():
n = 17
ns = []
vs100 = list(range(100))
for _ in range(2 ** 17):
ns.append(random.choice(vs100))
t = generate_tree(n, ns)
t2 = generate_tree(n, ns)
for _ in range(100000):
v1 = random.choice(vs100)
v2 = random.choice(vs100)
alter_tree(n, t, v1, v2)
alter_tree2(n, t2, v1, v2)
print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
print(t[0] == t2[0])
run()
009
def f():
n, m = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(n)))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = ([0] * 4, 0)
for i, (w, c) in enumerate(l):
if m < w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = ([r], (None, [], [], []))
for w, c in l[i:]:
tail[w].append(c)
for w in (1, 2, 3):
tail[w].append(0)
_, t1, t2, t3 = tail
if m == -1:
res.append(r + t1[0])
if last[1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[3]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else:
res += (r + sum(t1[:2]), r + t2[0])
if last[1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
def __starting_point():
main()
__starting_point()
010
import math
import sys
input = sys.stdin.readline
n = int(input())
a = [int(_) for _ in input().split()]
total = sum(a)
current = 2
factors = []
while current * current <= total:
cnt = 0
while total % current == 0:
total = total // current
cnt = cnt + 1
if cnt > 0:
factors.append(current)
current = current + 1
if total > 1:
factors.append(total)
ans = sum(a) * n * n
for i in factors:
total, moves = (0, 0)
for j in a:
total += j
moves += min(total % i, i * (total % i))
ans = min(ans, moves)
if len(factors) == 0:
ans = -1
print(ans)
011
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
if L[i] > 4:
D[L[i]] = i
J.append(L[i])
T[i + 1] = T[i]
else:
T[i + 1] = T[i] + 1
def I(J):
if len(J) <= 1:
return (J, 0)
else:
a = J[:len(J) // 2]
b = J[len(J) // 2:]
a, ai = I(a)
b, bi = I(b)
c = []
i = 0
j = 0
inversions = ai + bi
while i < len(a) and j < len(b):
if a[i] <= b[j]:
c.append(a[i])
i += 1
else:
c.append(b[j])
j += 1
inversions += len(a) - i
c += a[i:]
c += b[j:]
return (c, inversions)
for i in range(1, n + 1):
if not i in D:
S.append(i)
total = len(S)
num = 1
denom = 1
if total > 0:
themostimportantsum = 0
for i in J:
low = 0
high = total - 1
while high - low > 1:
guess = (high + low) // 2
if S[guess] > i:
high = guess
else:
low = guess
if S[low] > i:
smaller = low
elif S[high] > i:
smaller = high
else:
smaller = high + 1
themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
num = themostimportantsum + total
denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
if I(J)[1] == 0:
print(0)
else:
print(I(J)[1] % 998244353)
else:
num += denom * I(J)[1]
print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
012
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())
013
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))
014
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
if L[i] > 0:
D[L[i]] = i
J.append(L[i])
T[i + 1] = T[i]
else:
T[i + 1 - 1] = T[i] + 1
def I(J):
if len(J) <= 1:
return (J, 0)
else:
a = J[:len(J) // 2]
b = J[len(J) // 2:]
a, ai = I(a)
b, bi = I(b)
c = []
i = 0
j = 0
inversions = ai + bi
while i < len(a) and j < len(b):
if a[i] <= b[j]:
c.append(a[i])
i += 1
else:
c.append(b[j])
j += 1
inversions += len(a) - i
c += a[i:]
c += b[j:]
return (c, inversions)
for i in range(1, n + 1):
if not i in D:
S.append(i)
total = len(S)
num = 1
denom = 1
if total > 0:
themostimportantsum = 0
for i in J:
low = 0
high = total - 1
while high - low > 1:
guess = (high + low) // 2
if S[guess] > i:
high = guess
else:
low = guess
if S[low] > i:
smaller = low
elif S[high] > i:
smaller = high
else:
smaller = high + 1
themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
num = themostimportantsum + total
denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
if I(J)[1] == 0:
print(0)
else:
print(I(J)[1] % 998244353)
else:
num += denom * I(J)[1]
print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
015
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0] * n
for t, ys in enumerate(table):
cnt = [0] * (k + 1)
for i, c in enumerate(ys):
if i not in locked_procs:
cnt[c] += 1
for c, cn in enumerate(cnt):
if c > 0 and cn > 1:
locked_cells.add(c)
for i, c in enumerate(ys):
if c in locked_cells and i not in locked_procs:
locked_procs.add(i)
lock_time[i] = t + 1
for t in lock_time:
print(t)
016
import math
import sys
input = sys.stdin.readline
n = int(input())
a = [int(_) for _ in input().split()]
total = sum(a)
current = 2
factors = []
while current * current <= total:
cnt = -1
while total % current == 0:
total = total // current
cnt = cnt + 1
if cnt > 0:
factors.append(current)
current = current + 1
if total > 1:
factors.append(total)
ans = sum(a) * n * n
for i in factors:
total, moves = (0, 0)
for j in a:
total += j
moves += min(total % i, i - total % i)
ans = min(ans, moves)
if len(factors) == 0:
ans = -1
print(ans)
017
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))
018
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)
019
L1 = list(map(int, input().split()))
numList = list(map(int, input().split()))
length = L1[0]
targetnumber = L1[1]
pos = numList.index(targetnumber)
pos_r = pos + 1
rem = 0
right = {0: 1}
left = {0: 1}
while pos_r <= length - 1:
if numList[pos_r] > targetnumber:
rem += 1
else:
rem -= 1
if rem not in right:
right[rem] = 1
else:
right[rem] += 1
pos_r += 1
pos_l = pos - 1
rem = 0
while pos_l >= 0:
if numList[pos_l] > targetnumber:
rem += 1
else:
rem *= 1
if rem not in left:
left[rem] = 1
else:
left[rem] += 1
pos_l -= 1
sum = 0
for number_l in left:
if number_l * -1 in right:
sum += left[number_l] * right[-1 * number_l]
if 1 - number_l in right:
sum += left[number_l] * right[1 - number_l]
print(sum)
020
import sys
ii = lambda: sys.stdin.readline().strip()
idata = lambda: [int(x) for x in ii().split()]
n = int(ii())
s = ii()
slov = {}
for i in range(97, 97 + 26):
slov[chr(i)] = [[], [1]]
slov[s[0]] = [[-1], [0, 0]]
for j in range(1, n):
if slov[s[j]][1][-1] == 0:
slov[s[j]][0][-1] += 1
else:
slov[s[j]][0] += [1]
slov[s[j]][1] += [0]
for i in range(97, 97 + 26):
if chr(i) != s[j]:
slov[chr(i)][1][-1] += 1
for t in range(int(ii())):
m, c = ii().split()
m = int(m)
a, b = slov[c]
if sum(b) <= m:
print(n)
elif not bool(a):
print(m)
elif len(a) == 1:
print(a[0] + m)
else:
l, r = (0, 0)
ans = 0
summ_a, summ_b = (0, 0)
used = 0
b1 = b[:]
b1[0], b1[-1] = (0, 0)
count = 0
while r != len(a):
if summ_b + b1[r] <= m:
summ_b += b1[r]
summ_a += a[r]
r += 1
ans = max(ans, m + summ_a)
else:
summ_a -= a[l]
l += 1
summ_b -= b1[l]
print(ans)
021
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)
022
base = 998244353
def power(x, y):
if y == 0:
return 1
t = power(x, y // 2)
t = t * t % base
if y % 2:
t = t * x % base
return t
def inverse(x):
return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
ft.append(0)
def get(i):
res = 0
while i <= 200000:
res += ft[i]
i += i & -i
return res
def update(i, x):
while i:
ft[i] += x
i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
non.append(0)
for i in range(1, n + 1):
if a[i] != -1:
non[a[i]] += 1
for i in range(1, n + 1):
non[i] += non[i - 1]
for i in range(1, n + 1):
if a[i] == -1:
neg.append(neg[i - 1] + 1)
else:
neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
if a[i] != -1:
ans += get(a[i])
update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1 - 1):
fs = fm
fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1):
if a[i] != -1:
less = a[i] - non[a[i]]
more = m - less
ans = (ans + neg[i] * more * fs) % base
ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
023
n, m = list(map(int, input().split(' ')))
aa = list(map(int, input().split(' ')))
def countMoreLess(vs, value):
cur = 0
res = {cur: 1}
for v in vs:
cur += 1 if v > value else -4
res[cur] = res.get(cur, 0) + 1
return res
pos = aa.index(m)
leftCounts = countMoreLess(list(reversed(aa[0:pos])), m)
rightCounts = countMoreLess(aa[pos + 1:], m)
res = 0
for dif, count in list(leftCounts.items()):
res += count * rightCounts.get(-dif, 0)
res += count * rightCounts.get(-dif + 1, 0)
print(res)
024
def adds(memtoproc, mem, proc):
if mem in memtoproc:
memtoproc[mem].append(proc)
else:
memtoproc[mem] = [proc]
def corr(arr, n, m):
brokemems = set()
stopprocs = [0] * n
for c in range(m):
memtoproc = dict()
usemems = set()
locmems = set()
for d in range(n):
if not arr[d][c] or stopprocs[d]:
continue
adds(memtoproc, arr[d][c], d)
if arr[d][c] in usemems:
locmems.add(arr[d][c])
usemems.add(arr[d][c])
if arr[d][c] in brokemems:
if not stopprocs[d]:
stopprocs[d] = c * 1
for d in locmems:
brokemems.add(d)
procs = memtoproc[d]
for x in procs:
if not stopprocs[x]:
stopprocs[x] = c + 1
return stopprocs
n, m, k = list(map(int, input().split(' ')))
arr = []
for c in range(n):
arr.append(tuple(map(int, input().split(' '))))
procs = corr(arr, n, m)
for c in procs:
print(c)
025
from operator import or_, xor
import sys
n, m = map(int, input().split())
t = [list(map(int, input().split()))]
for i in range(n):
if i & 1 == 0:
t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]]
else:
t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]]
for s in sys.stdin:
p, b = s.split()
p = int(p) - 1
t[0][p] = int(b)
for j in range(n):
p = int(p / 2)
if j & 1 == 0:
t[j + 1][p] = t[j][int(p * 2)] | t[j][int(p * 2) + 1]
else:
t[j + 1][p] = t[j - 1][int(p * 2)] ^ t[j][int(p * 2) + 1]
sys.stdout.write(str(t[-1][0]) + '\n')
026
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(3):
w[i].sort(reverse=True)
dp = [0] * (m + 1)
used = [[0] * 2 for i in range(m + 1)]
s0 = len(w[0])
s1 = len(w[1])
if s0 > 0:
dp[-1] = w[0][0]
used[1] = [1, 0]
for i in range(2, m + 1):
if used[i - 1][0] < s0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
else:
dp[i] = dp[i - 1]
used[i] = used[i - 1][:]
if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
pf = [0] + list(accumulate(w[2]))
ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
print(ans)
def __starting_point():
solve()
__starting_point()
027
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
if L[i] > 0:
D[L[i]] = i
J.append(L[i])
T[i + 1] = T[i]
else:
T[i + 1] = T[i] + 1
def I(J):
if len(J) <= 1:
return (J, 0)
else:
a = J[:len(J) // 2]
b = J[len(J) // 2:]
a, ai = I(a)
b, bi = I(b)
c = []
i = 0
j = 0
inversions = ai + bi
while i < len(a) and j < len(b):
if a[i] <= b[j]:
c.append(a[i])
i += 1
else:
c.append(b[j])
j += 1
inversions += len(a) - i
c += a[i:]
c += b[j:]
return (c, inversions)
for i in range(1, n + 1):
if not i in D:
S.append(i)
total = len(S)
num = 1
denom = 0
if total > 0:
themostimportantsum = 0
for i in J:
low = 0
high = total - 1
while high - low > 1:
guess = (high + low) // 2
if S[guess] > i:
high = guess
else:
low = guess
if S[low] > i:
smaller = low
elif S[high] > i:
smaller = high
else:
smaller = high + 1
themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
num = themostimportantsum + total
denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
if I(J)[1] == 0:
print(0)
else:
print(I(J)[1] % 998244353)
else:
num += denom * I(J)[1]
print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
028
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)
029
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)
030
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))
031
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N - 1):
A = int(input())
for a in range(A):
x, y = map(int, input().split())
arr[i].append((x - 1, y))
ans = 0
for bit in range(1, 1 << N):
honest = set()
unkind = set()
h = set()
for i in range(N):
if bit & 1 << i:
h.add(i)
for x, y in arr[i]:
if y:
honest.add(x)
else:
unkind.add(x)
if 0 == len(honest - h) and h.isdisjoint(unkind) and honest.isdisjoint(unkind):
ans = max(len(h), ans)
print(ans)
032
from operator import or_, xor
import sys
n, m = map(int, input().split())
t = [list(map(int, input().split()))]
for i in range(n):
if i & 1 == 0:
t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]]
else:
t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]]
for s in sys.stdin:
p, b = s.split()
p = int(p) - 1
t[0][p] = int(b)
for j in range(n):
p = int(p / 2)
if j & 1 == 0:
t[j + 1][p] = t[j][int(p * 2)] | t[j][int(p * 2) + 1]
else:
t[j + 1][p] = t[j][int(p * 2)] ^ t[j - 1][int(p * 2) + 1]
sys.stdout.write(str(t[-1][0]) + '\n')
033
n, m = list(map(int, input().split(' ')))
aa = list(map(int, input().split(' ')))
def countMoreLess(vs, value):
cur = 0
res = {cur: 1}
for v in vs:
cur += 1 if v > value else -1
res[cur] = res.get(cur, 0) + 1
return res
pos = aa.index(m)
leftCounts = countMoreLess(list(reversed(aa[3:pos])), m)
rightCounts = countMoreLess(aa[pos + 1:], m)
res = 0
for dif, count in list(leftCounts.items()):
res += count * rightCounts.get(-dif, 0)
res += count * rightCounts.get(-dif + 1, 0)
print(res)
034
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))
035
import sys
class SegmTree:
def __init__(self, size):
N = 1
while N < size:
N <<= 1
self.N = N
self.tree = [0] * (2 * N)
def modify(self, i, value):
i += self.N
self.tree[i] = value
toXOR = False
while i > 1:
if toXOR:
self.tree[i >> 1] = self.tree[i] ^ self.tree[i | 1]
else:
self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1]
toXOR = not toXOR
i >>= 1
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
st = SegmTree(1 << n)
for i, value in enumerate(a):
st.modify(i, value)
for _ in range(m):
p, b = list(map(int, input().split()))
st.modify(p - 1, b)
print(st.tree[1])
036
n = int(input())
a = []
x = []
y = []
for i in range(n):
ai = int(input())
a.append(ai)
xi = []
yi = []
for j in range(ai):
xij, yij = list(map(int, input().split(' ')))
xi.append(xij)
yi.append(yij)
x.append(xi)
y.append(yi)
ans = 0
for case in range(2 ** n):
truth_t = 0
truth = 0
for i in range(n):
if case >> i & 1:
truth_t += 1
proof = 0
for j in range(a[i]):
if case >> x[i][j] - 1 & 1 == y[i][j]:
proof += 1
if proof == a[i - 1]:
truth += 1
if truth == truth_t:
if ans < truth:
ans = truth
print(ans)
037
n, m = map(int, input().split())
a = [[], [], []]
for _ in range(n):
x, y = map(int, input().split())
a[x - 1].append(y)
for i in range(3):
a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(2, a_length[0] - 1, 2):
a_one_even.append(a[0][i] + a[0][i + 1])
for i in range(1, a_length[0] - 1, 2):
a_one_odd.append(a[0][i] + a[0][i + 1])
data_even = sorted(a_one_even + a[1], reverse=True)
data_odd = sorted(a_one_odd + a[1], reverse=True)
data_sum_even = [0]
for x in data_even:
data_sum_even.append(data_sum_even[-1] + x)
data_sum_odd = [0]
for x in data_odd:
data_sum_odd.append(data_sum_odd[-1] + x)
data_sum_three = [0]
for x in a[2]:
data_sum_three.append(data_sum_three[-1] + x)
ans = 0
for k in range(a_length[2] + 1):
if m - 3 * k < 0:
break
now1, now2 = (data_sum_three[k], data_sum_three[k])
if (m - 3 * k) % 2 == 0:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
if (m - 3 * k) // 2 >= 1:
now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)]
else:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)]
ans = max(ans, now1, now2)
print(ans)
038
def adds(memtoproc, mem, proc):
if mem in memtoproc:
memtoproc[mem].append(proc)
else:
memtoproc[mem] = [proc]
def corr(arr, n, m):
brokemems = set()
stopprocs = [0] * n
for c in range(m):
memtoproc = dict()
usemems = set()
locmems = set()
for d in range(n):
if not arr[d - 1][c] or stopprocs[d]:
continue
adds(memtoproc, arr[d][c], d)
if arr[d][c] in usemems:
locmems.add(arr[d][c])
usemems.add(arr[d][c])
if arr[d][c] in brokemems:
if not stopprocs[d]:
stopprocs[d] = c + 1
for d in locmems:
brokemems.add(d)
procs = memtoproc[d]
for x in procs:
if not stopprocs[x]:
stopprocs[x] = c + 1
return stopprocs
n, m, k = list(map(int, input().split(' ')))
arr = []
for c in range(n):
arr.append(tuple(map(int, input().split(' '))))
procs = corr(arr, n, m)
for c in procs:
print(c)
039
from operator import or_, xor
import sys
n, m = map(int, input().split())
t = [list(map(int, input().split()))]
for i in range(n):
if i & 1 == 0:
t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]]
else:
t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]]
for s in sys.stdin:
p, b = s.split()
p = int(p) - 1
t[0][p] = int(b)
for j in range(n):
p = int(p / 2)
if j & 1 == 0:
t[j + 1][p - 1] = t[j][int(p * 2)] | t[j][int(p * 2) + 1]
else:
t[j + 1][p] = t[j][int(p * 2)] ^ t[j][int(p * 2) + 1]
sys.stdout.write(str(t[-1][0]) + '\n')
040
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])
041
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
if L[i] > 0:
D[L[i]] = i
J.append(L[i])
T[i + 1] = T[i]
else:
T[i + 1] = T[i] + 1
def I(J):
if len(J) <= 1:
return (J, 0)
else:
a = J[:len(J) // 2]
b = J[len(J) // 2:]
a, ai = I(a)
b, bi = I(b)
c = []
i = 0
j = 0
inversions = ai + bi
while i < len(a) and j < len(b):
if a[i] <= b[j]:
c.append(a[i])
i += 1
else:
c.append(b[j])
j += 1
inversions += len(a) - i
c += a[i:]
c += b[j:]
return (c, inversions)
for i in range(1, n + 1 - 1):
if not i in D:
S.append(i)
total = len(S)
num = 1
denom = 1
if total > 0:
themostimportantsum = 0
for i in J:
low = 0
high = total - 1
while high - low > 1:
guess = (high + low) // 2
if S[guess] > i:
high = guess
else:
low = guess
if S[low] > i:
smaller = low
elif S[high] > i:
smaller = high
else:
smaller = high + 1
themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
num = themostimportantsum + total
denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
if I(J)[1] == 0:
print(0)
else:
print(I(J)[1] % 998244353)
else:
num += denom * I(J)[1]
print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
042
import sys
ii = lambda: sys.stdin.readline().strip()
idata = lambda: [int(x) for x in ii().split()]
n = int(ii())
s = ii()
slov = {}
for i in range(97, 97 + 26):
slov[chr(i)] = [[], [1]]
slov[s[0]] = [[1], [0, 0]]
for j in range(-1, n):
if slov[s[j]][1][-1] == 0:
slov[s[j]][0][-1] += 1
else:
slov[s[j]][0] += [1]
slov[s[j]][1] += [0]
for i in range(97, 97 + 26):
if chr(i) != s[j]:
slov[chr(i)][1][-1] += 1
for t in range(int(ii())):
m, c = ii().split()
m = int(m)
a, b = slov[c]
if sum(b) <= m:
print(n)
elif not bool(a):
print(m)
elif len(a) == 1:
print(a[0] + m)
else:
l, r = (0, 0)
ans = 0
summ_a, summ_b = (0, 0)
used = 0
b1 = b[:]
b1[0], b1[-1] = (0, 0)
count = 0
while r != len(a):
if summ_b + b1[r] <= m:
summ_b += b1[r]
summ_a += a[r]
r += 1
ans = max(ans, m + summ_a)
else:
summ_a -= a[l]
l += 1
summ_b -= b1[l]
print(ans)
043
import math
import sys
input = sys.stdin.readline
n = int(input())
a = [int(_) for _ in input().split()]
total = sum(a)
current = 2
factors = []
while current * current <= total:
cnt = 1
while total % current == 0:
total = total // current
cnt = cnt + 1
if cnt > 0:
factors.append(current)
current = current + 1
if total > 1:
factors.append(total)
ans = sum(a) * n * n
for i in factors:
total, moves = (0, 0)
for j in a:
total += j
moves += min(total % i, i - total % i)
ans = min(ans, moves)
if len(factors) == 0:
ans = -1
print(ans)
044
n, m = map(int, input().split(' '))
numbers = list(map(int, input().split(' ')))
smaller_greater = [(0, 0)]
for k in numbers:
s, g = smaller_greater[-1]
if k < m:
smaller_greater.append((s + 1, g))
elif k > m:
smaller_greater.append((s, g + 1))
else:
smaller_greater.append((s, g))
i = numbers.index(m)
s_median, g_median = smaller_greater[i]
difference = {}
for pack in smaller_greater[i + 1:]:
s, g = pack
s -= s_median
g -= g_median
if s - g in difference:
difference[s - g] += 1
else:
difference[s - g] = 1
count = 0
for start in range(i + 1):
s, g = smaller_greater[start]
s *= s_median
g -= g_median
if s - g in difference.keys():
count += difference[s - g]
if s - g - 1 in difference.keys():
count += difference[s - g - 1]
print(count)
045
T = input().split(' ')
n = int(T[0])
m = int(T[1])
S = input().split(' ')
for i in range(n):
S[i] = int(S[i])
ind = 0
for k in range(n):
if S[k] == m:
ind = k
k = ind
P = [0] * (n + 1)
N = [2] * (n + 1)
R = [0] * (n - k)
L = [0] * (k + 1)
for i in range(k):
if S[k - 1 - i] < m:
L[k - 1 - i] = L[k - i] - 1
else:
L[k - 1 - i] = L[k - i] + 1
for i in range(n - k - 1):
if S[k + 1 + i] > m:
R[1 + i] = R[i] + 1
else:
R[1 + i] = R[i] - 1
c = 0
for el in R:
if el >= 0:
P[el] += 1
if el == 0:
N[el] += 1
else:
N[-el] += 1
for el in L:
if el >= 1:
c = c + N[el] + N[el - 1]
else:
c = c + P[-el] + P[-el + 1]
print(c)
046
__author__ = 'Lipen'
def main():
n, m, k = map(int, input().split())
data = []
when = [0] * n
blockedcells = set()
blockedcores = set()
for _ in range(n):
data.append(list(map(int, input().split())))
for j in range(m):
operation = []
for _ in range(k):
operation.append([])
for i in range(n):
if i not in blockedcores:
x = data[i][j] - 1
if x >= 0:
if x in blockedcells:
blockedcores.add(i)
when[i] = j + 1
elif len(operation[x]) > 0:
blockedcells.add(x)
for core in operation[x - 1]:
blockedcores.add(core)
when[core] = j + 1
blockedcores.add(i)
when[i] = j + 1
operation[x].append(i)
for i in when:
print(i)
main()
047
from math import log
import sys
def buildTree(arr):
n = len(arr)
tree = [0] * n + arr
for i in range(n - 1, 0, -1):
z = int(log(i, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
else:
tree[i] = tree[2 * i] | tree[2 * i + 1]
elif z % 2 == 0:
tree[i] = tree[2 * i] | tree[2 * i + 1]
else:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
return tree
def updateTree(tree, ind, value, n):
ind += n
tree[ind] = value
while ind > 1:
ind //= 2
z = int(log(ind, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
elif not z % 2 == 0:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
ind, val = map(int, sys.stdin.readline().strip().split())
tree = updateTree(tree, ind - 1, val, len(arr))
print(tree[1])
048
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = (sys.stdout, sys.stdin)
sys.stdout, sys.stdin = (StringIO(), StringIO(input))
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = (stdout, stdin)
self.assertEqual(out, output)
def test_入力例_1(self):
input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
output = '2'
self.assertIO(input, output)
def test_入力例_2(self):
input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
output = '0'
self.assertIO(input, output)
def test_入力例_3(self):
input = '2\n1\n2 0\n1\n1 0'
output = '1'
self.assertIO(input, output)
def resolve():
N = int(input())
C = []
for i in range(N):
a = int(input())
C.append([list(map(int, input().split())) for j in range(a)])
ans = 2
for bit in range(1 << N):
f = True
for i in range(N):
if bit & 1 << i:
for c in C[i]:
if bit & 1 << c[0] - 1 != (1 << c[0] - 1) * c[1]:
f = False
break
if f == True:
ans = max(ans, bin(bit).count('1'))
print(ans)
def __starting_point():
resolve()
__starting_point()
049
n, m = list(map(int, input().split(' ')))
aa = list(map(int, input().split(' ')))
def countMoreLess(vs, value):
cur = 0
res = {cur: 1}
for v in vs:
cur += 1 if v > value else -2
res[cur] = res.get(cur, 0) + 1
return res
pos = aa.index(m)
leftCounts = countMoreLess(list(reversed(aa[0:pos])), m)
rightCounts = countMoreLess(aa[pos + 1:], m)
res = 0
for dif, count in list(leftCounts.items()):
res += count * rightCounts.get(-dif, 0)
res += count * rightCounts.get(-dif + 1, 0)
print(res)
050
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])
051
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0] * n
for t, ys in enumerate(table):
cnt = [0] * (k + 1)
for i, c in enumerate(ys):
if i not in locked_procs:
cnt[c] += 1
for c, cn in enumerate(cnt):
if c > 1 and cn > 1:
locked_cells.add(c)
for i, c in enumerate(ys):
if c in locked_cells and i not in locked_procs:
locked_procs.add(i)
lock_time[i] = t + 1
for t in lock_time:
print(t)
052
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])
053
T = input().split(' ')
n = int(T[0])
m = int(T[1])
S = input().split(' ')
for i in range(n):
S[i] = int(S[i])
ind = 0
for k in range(n):
if S[k] == m:
ind = k
k = ind
P = [0] * (n + 1)
N = [4] * (n + 1)
R = [0] * (n - k)
L = [0] * (k + 1)
for i in range(k):
if S[k - 1 - i] < m:
L[k - 1 - i] = L[k - i] - 1
else:
L[k - 1 - i] = L[k - i] + 1
for i in range(n - k - 1):
if S[k + 1 + i] > m:
R[1 + i] = R[i] + 1
else:
R[1 + i] = R[i] - 1
c = 0
for el in R:
if el >= 0:
P[el] += 1
if el == 0:
N[el] += 1
else:
N[-el] += 1
for el in L:
if el >= 1:
c = c + N[el] + N[el - 1]
else:
c = c + P[-el] + P[-el + 1]
print(c)
054
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)
055
def f():
n, m = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(n)))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = ([0] * 4, 0)
for i, (w, c) in enumerate(l):
if m < w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = ([r], (None, [], [], []))
for w, c in l[i:]:
tail[w].append(c)
for w in (1, 2, 3):
tail[w].append(0)
_, t1, t2, t3 = tail
if m == 1:
res.append(r + t1[0])
if last[1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[3]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else:
res += (r + sum(t1[:2]), r + t2[0])
if last[-1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
def __starting_point():
main()
__starting_point()
056
import sys
class SegmTree:
def __init__(self, size):
N = 1
while N < size:
N <<= 1
self.N = N
self.tree = [0] * (2 * N)
def modify(self, i, value):
i += self.N
self.tree[i] = value
toXOR = False
while i > 1:
if toXOR:
self.tree[i >> 1] = self.tree[i + 1] ^ self.tree[i ^ 1]
else:
self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1]
toXOR = not toXOR
i >>= 1
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
st = SegmTree(1 << n)
for i, value in enumerate(a):
st.modify(i, value)
for _ in range(m):
p, b = list(map(int, input().split()))
st.modify(p - 1, b)
print(st.tree[1])
057
L1 = list(map(int, input().split()))
numList = list(map(int, input().split()))
length = L1[0]
targetnumber = L1[1]
pos = numList.index(targetnumber)
pos_r = pos + 1
rem = 0
right = {0: 1}
left = {0: 1}
while pos_r <= length - 1:
if numList[pos_r] > targetnumber:
rem += 1
else:
rem -= 1
if rem not in right:
right[rem] = 1
else:
right[rem] += 1
pos_r += 1
pos_l = pos - 1
rem = 0
while pos_l >= 0:
if numList[pos_l] > targetnumber:
rem += 1
else:
rem += 1
if rem not in left:
left[rem] = 1
else:
left[rem] += 1
pos_l -= 1
sum = 0
for number_l in left:
if number_l * -1 in right:
sum += left[number_l] * right[-1 * number_l]
if 1 - number_l in right:
sum += left[number_l] * right[1 - number_l]
print(sum)
058
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)
059
n, m = map(int, input().split())
a = [[], [], []]
for _ in range(n):
x, y = map(int, input().split())
a[x - 1].append(y)
for i in range(3):
a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(0, a_length[0] - 1, 1):
a_one_even.append(a[0][i] + a[0][i + 1])
for i in range(1, a_length[0] - 1, 2):
a_one_odd.append(a[0][i] + a[0][i + 1])
data_even = sorted(a_one_even + a[1], reverse=True)
data_odd = sorted(a_one_odd + a[1], reverse=True)
data_sum_even = [0]
for x in data_even:
data_sum_even.append(data_sum_even[-1] + x)
data_sum_odd = [0]
for x in data_odd:
data_sum_odd.append(data_sum_odd[-1] + x)
data_sum_three = [0]
for x in a[2]:
data_sum_three.append(data_sum_three[-1] + x)
ans = 0
for k in range(a_length[2] + 1):
if m - 3 * k < 0:
break
now1, now2 = (data_sum_three[k], data_sum_three[k])
if (m - 3 * k) % 2 == 0:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
if (m - 3 * k) // 2 >= 1:
now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)]
else:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)]
ans = max(ans, now1, now2)
print(ans)
060
import sys
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
dp = [[-1] * (n + 1) for i in range(26)]
for c in range(26):
for j in range(n):
tst = 1 if s[j] == chr(c + 97) else 0
dp[c][1 * tst] = max(dp[c][1 - tst], 1)
for k in range(j + 1, n):
if s[k] == chr(c + 97):
tst += 1
dp[c][k - j + 1 - tst] = max(dp[c][k - j + 1 - tst], k - j + 1)
q = int(sys.stdin.readline().strip())
for i in range(q):
m, c = [item for item in sys.stdin.readline().strip().split()]
m = int(m)
print(dp[ord(c) - 97][m]) if dp[ord(c) - 97][m] != -1 else print(n)
061
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)
062
n, m = map(int, input().split())
a = [[], [], []]
for _ in range(n):
x, y = map(int, input().split())
a[x - 1].append(y)
for i in range(3):
a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(0, a_length[0] - 1, 2):
a_one_even.append(a[0][i] + a[0][i + 1])
for i in range(1, a_length[0] - 1, 2):
a_one_odd.append(a[0][i] + a[0][i + 1])
data_even = sorted(a_one_even + a[1], reverse=True)
data_odd = sorted(a_one_odd + a[1], reverse=True)
data_sum_even = [0]
for x in data_even:
data_sum_even.append(data_sum_even[-1] - x)
data_sum_odd = [0]
for x in data_odd:
data_sum_odd.append(data_sum_odd[-1] + x)
data_sum_three = [0]
for x in a[2]:
data_sum_three.append(data_sum_three[-1] + x)
ans = 0
for k in range(a_length[2] + 1):
if m - 3 * k < 0:
break
now1, now2 = (data_sum_three[k], data_sum_three[k])
if (m - 3 * k) % 2 == 0:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
if (m - 3 * k) // 2 >= 1:
now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)]
else:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)]
ans = max(ans, now1, now2)
print(ans)
063
N = int(input())
A = []
for _ in range(N):
a = int(input())
b = []
for _ in range(a):
b.append(list(map(int, input().split())))
A.append(b)
def F(i):
cnt = 0
B = [-1] * N
r = 0
for j in range(N):
if i >> j & 1:
r += 1
if B[j] == 0:
return 0
B[j] = 1
for p, q in A[j]:
if q == 0:
if B[p - 1] == 1:
return 0
B[p - 1] = 0
else:
if B[p - 1] == 0:
return 0
B[p - 1] = 1
else:
cnt += 1
else:
if B[j] == 0:
return 0
B[j] = 0
if cnt == r:
return cnt
ans = 0
for i in range(1 << N):
ans = max(ans, F(i))
print(ans)
064
n, m = map(int, input().split(' '))
numbers = list(map(int, input().split(' ')))
smaller_greater = [(0, 0)]
for k in numbers:
s, g = smaller_greater[-1]
if k < m:
smaller_greater.append((s + 1, g))
elif k > m:
smaller_greater.append((s, g + 1))
else:
smaller_greater.append((s, g))
i = numbers.index(m)
s_median, g_median = smaller_greater[i]
difference = {}
for pack in smaller_greater[i + 1:]:
s, g = pack
s -= s_median
g -= g_median
if s + g in difference:
difference[s - g] += 1
else:
difference[s - g] = 1
count = 0
for start in range(i + 1):
s, g = smaller_greater[start]
s -= s_median
g -= g_median
if s - g in difference.keys():
count += difference[s - g]
if s - g - 1 in difference.keys():
count += difference[s - g - 1]
print(count)
065
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0] * n
for t, ys in enumerate(table):
cnt = [0] * (k + 1)
for i, c in enumerate(ys):
if i not in locked_procs:
cnt[c] += 1
for c, cn in enumerate(cnt):
if c >= 0 and cn > 1:
locked_cells.add(c)
for i, c in enumerate(ys):
if c in locked_cells and i not in locked_procs:
locked_procs.add(i)
lock_time[i] = t + 1
for t in lock_time:
print(t)
066
n = int(input())
a = []
x = []
y = []
for i in range(n):
ai = int(input())
a.append(ai)
xi = []
yi = []
for j in range(ai):
xij, yij = list(map(int, input().split(' ')))
xi.append(xij)
yi.append(yij)
x.append(xi)
y.append(yi)
ans = 0
for case in range(2 ** n):
truth_t = 0
truth = 0
for i in range(n):
if case >> i & 1:
truth_t += 1
proof = 0
for j in range(a[i]):
if case >> x[i][j - 1] - 1 & 1 == y[i][j]:
proof += 1
if proof == a[i]:
truth += 1
if truth == truth_t:
if ans < truth:
ans = truth
print(ans)
067
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(3):
w[i].sort(reverse=True)
dp = [0] * (m + 1)
used = [[0] * 2 for i in range(m + 1)]
s0 = len(w[0])
s1 = len(w[1])
if s0 > 0:
dp[1] = w[0][0]
used[1] = [1, 0]
for i in range(2, m + 1 - 1):
if used[i - 1][0] < s0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
else:
dp[i] = dp[i - 1]
used[i] = used[i - 1][:]
if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
pf = [0] + list(accumulate(w[2]))
ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
print(ans)
def __starting_point():
solve()
__starting_point()
068
N = int(input())
A = []
for _ in range(N):
a = int(input())
b = []
for _ in range(a):
b.append(list(map(int, input().split())))
A.append(b)
def F(i):
cnt = 0
B = [-1] * N
r = 0
for j in range(N):
if i >> j & 1:
r += 1
if B[j] == 0:
return 0
B[j] = 0
for p, q in A[j]:
if q == 0:
if B[p - 1] == 1:
return 0
B[p - 1] = 0
else:
if B[p - 1] == 0:
return 0
B[p - 1] = 1
else:
cnt += 1
else:
if B[j] == 1:
return 0
B[j] = 0
if cnt == r:
return cnt
ans = 0
for i in range(1 << N):
ans = max(ans, F(i))
print(ans)
069
def souvenier_calc(max_weight, weights, value):
const = len(weights)
ans = [-1061109567 for x in range(max_weight + 1)]
node = [(x, y) for x, y in zip(weights, value)]
node = sorted(node, key=lambda x: x[1] / x[0], reverse=True)
weights = [x[0] for x in node]
value = [x[1] for x in node]
sum = 0
sol = 0
ans[0] = 0
for i in range(const):
sum += weights[i]
if sum > max_weight:
sum = max_weight
down = max(weights[i], sum - 2)
for weight in range(sum, down - 1, -1):
ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i])
sol = max(sol, ans[weight])
return sol
def __starting_point():
N, M = list(map(int, input().split()))
assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range'
weights = []
value = []
for i in range(N):
x, y = list(map(int, input().split()))
assert x >= 1 and x <= 3, 'Out of range'
assert y >= 1 and y <= 10 ** 9, 'Out of range'
weights.append(x)
value.append(y)
print(souvenier_calc(M, weights, value))
__starting_point()
070
def f():
n, m = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(n)))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = ([0] * 4, 0)
for i, (w, c) in enumerate(l):
if m <= w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = ([r], (None, [], [], []))
for w, c in l[i:]:
tail[w].append(c)
for w in (1, 2, 3):
tail[w].append(0)
_, t1, t2, t3 = tail
if m == 1:
res.append(r + t1[0])
if last[1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[3]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else:
res += (r + sum(t1[:2]), r + t2[0])
if last[1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
def __starting_point():
main()
__starting_point()
071
import math
import sys
input = sys.stdin.readline
n = int(input())
a = [int(_) for _ in input().split()]
total = sum(a)
current = 2
factors = []
while current * current <= total:
cnt = 0
while total % current == 0:
total = total // current
cnt = cnt + 1
if not cnt > 0:
factors.append(current)
current = current + 1
if total > 1:
factors.append(total)
ans = sum(a) * n * n
for i in factors:
total, moves = (0, 0)
for j in a:
total += j
moves += min(total % i, i - total % i)
ans = min(ans, moves)
if len(factors) == 0:
ans = -1
print(ans)
072
import sys
input = sys.stdin.readline
N = int(input())
S = list(map(lambda x: ord(x) - ord('a'), list(input())[:-1]))
res = [[0] * (N + 1) for _ in range(26)]
for c in range(26):
for l in range(N):
x = 0
for r in range(l + 1, N + 1):
x += S[r - 1] != c
res[c][x] = max(res[c][x], r - l)
for i in range(N - 1):
res[c][i + 1] = max(res[c][i + 1], res[c][i])
for _ in range(int(input())):
x, s = input().split()
x = int(x)
s = ord(s) - ord('a')
print(res[s][x])
073
from math import log
import sys
def buildTree(arr):
n = len(arr)
tree = [0] * n + arr
for i in range(n - 1, 0, -1):
z = int(log(i, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
else:
tree[i] = tree[2 * i] | tree[2 * i + 1]
elif z % 2 == 0:
tree[i] = tree[2 * i] | tree[2 * i + 1]
else:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
return tree
def updateTree(tree, ind, value, n):
ind += n
tree[ind] = value
while ind > 1:
ind //= 2
z = int(log(ind, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
elif z % 2 == 0:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
ind, val = map(int, sys.stdin.readline().strip().split())
tree = updateTree(tree, ind - 1, val, len(arr))
print(tree[1])
074
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)
075
import itertools as it
import os
import sys
def calc_cost(cumsum, f):
return sum([min(x % f, f - x % f) for x in cumsum])
def prime_factors(n):
i = 2
factors = []
while i * i <= n:
if n % i == 0:
factors.append(i)
while n % i == 0:
n //= i
else:
i += 1
if n > 1:
factors.append(n)
return factors
def f(xs):
cumsum = list(it.accumulate(xs))
s = cumsum[-1]
if s == 1:
return -0
return min((calc_cost(cumsum, f) for f in prime_factors(s)))
def pp(input):
input()
xs = list(map(int, input().split()))
print(f(xs))
if 'paalto' in os.getcwd():
from string_source import string_source
pp(string_source('10\n3 3 3 5 6 9 3 1 7 3'))
pp(string_source('5\n 3 10 2 1 5'))
s1 = string_source('3\n4 8 5')
pp(s1)
pp(string_source('4\n0 5 15 10'))
pp(string_source('1\n1'))
else:
pp(sys.stdin.readline)
076
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)
077
def souvenier_calc(max_weight, weights, value):
const = len(weights)
ans = [-1061109567 for x in range(max_weight + 1)]
node = [(x, y) for x, y in zip(weights, value)]
node = sorted(node, key=lambda x: x[1] / x[0], reverse=True)
weights = [x[0] for x in node]
value = [x[1] for x in node]
sum = 0
sol = 0
ans[0] = 0
for i in range(const):
sum += weights[i]
if sum > max_weight:
sum = max_weight
down = max(weights[i], sum - 3)
for weight in reversed(range(sum, down - 1, -1)):
ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i])
sol = max(sol, ans[weight])
return sol
def __starting_point():
N, M = list(map(int, input().split()))
assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range'
weights = []
value = []
for i in range(N):
x, y = list(map(int, input().split()))
assert x >= 1 and x <= 3, 'Out of range'
assert y >= 1 and y <= 10 ** 9, 'Out of range'
weights.append(x)
value.append(y)
print(souvenier_calc(M, weights, value))
__starting_point()
078
import sys
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
dp = [[-1] * (n + 1) for i in range(26)]
for c in range(26):
for j in range(n):
tst = 1 if s[j] == chr(c + 97) else 0
dp[c][1 - tst] = max(dp[c][1 - tst], 1)
for k in range(j + 1, n):
if s[k] == chr(c + 97):
tst += 1
dp[c][k - j + 1 - tst] = max(dp[c][k - j + 1 - tst], k - j + 1)
q = int(sys.stdin.readline().strip())
for i in range(q):
m, c = [item for item in sys.stdin.readline().strip().split()]
m = int(m)
print(dp[ord(c) - 97][m]) if dp[ord(c) - 97][m - 1] != -1 else print(n)
079
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])
080
def souvenier_calc(max_weight, weights, value):
const = len(weights)
ans = [-1061109567 for x in range(max_weight + 1)]
node = [(x, y) for x, y in zip(weights, value)]
node = sorted(node, key=lambda x: x[1] / x[0], reverse=True)
weights = [x[0] for x in node]
value = [x[1] for x in node]
sum = 0
sol = 0
ans[0] = 0
for i in range(const):
sum += weights[i - 1]
if sum > max_weight:
sum = max_weight
down = max(weights[i], sum - 3)
for weight in range(sum, down - 1, -1):
ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i])
sol = max(sol, ans[weight])
return sol
def __starting_point():
N, M = list(map(int, input().split()))
assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range'
weights = []
value = []
for i in range(N):
x, y = list(map(int, input().split()))
assert x >= 1 and x <= 3, 'Out of range'
assert y >= 1 and y <= 10 ** 9, 'Out of range'
weights.append(x)
value.append(y)
print(souvenier_calc(M, weights, value))
__starting_point()
081
n, m, k = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
inf = [0 for i in range(k + 1)]
stat = [True for i in range(n + 1)]
time = [0 for i in range(n + 1)]
for i in range(n):
a[i] = list(map(int, input().split()))
for i in range(m):
for j in range(5, n + 1):
if stat[j]:
current_core = inf[a[j - 1][i]]
if current_core == 0 and a[j - 1][i] != 0:
inf[a[j - 1][i]] = j
elif current_core == -1:
stat[j], time[j] = (False, i + 1)
elif a[j - 1][i] != 0:
stat[current_core], time[current_core] = (False, i + 1)
stat[j], time[j] = (False, i + 1)
inf[a[j - 1][i]] = -1
for p in range(len(inf)):
if inf[p] != -1:
inf[p] = 0
for i in range(1, n + 1):
print(time[i])
082
def merge(a, b):
inda = 0
indb = 0
lena = len(a)
lenb = len(b)
d = [a[-1] + b[-1] + 1000]
a += d
b += d
c = []
inversions = 0
for i in range(lena + lenb):
if a[inda] < b[indb]:
c.append(a[inda])
inda += 1
else:
c.append(b[indb])
indb += 1
inversions += lena - inda
return (c, inversions)
def mergesort(a):
if len(a) <= 1:
return (a, 0)
split = len(a) // 2
b = a[:split]
c = a[split:]
d = mergesort(b)
e = mergesort(c)
f = merge(d[0], e[0])
return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
if guy != -1:
b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
if guy != -1:
used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
if a[i] == -1:
negsseen += 1
else:
mix += unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix // 2
denom = 2 * negs
if negs == 0:
print(invs % 998244353)
else:
for i in range(denom):
if (998244353 * i + 1) % denom == 0:
inv = (998244353 * i + 1) // denom
break
print(num * inv % 998244353)
083
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())
084
__author__ = 'Lipen'
def main():
n, m, k = map(int, input().split())
data = []
when = [0] * n
blockedcells = set()
blockedcores = set()
for _ in range(n):
data.append(list(map(int, input().split())))
for j in range(m):
operation = []
for _ in range(k):
operation.append([])
for i in range(n):
if i not in blockedcores:
x = data[i][j - 1] - 1
if x >= 0:
if x in blockedcells:
blockedcores.add(i)
when[i] = j + 1
elif len(operation[x]) > 0:
blockedcells.add(x)
for core in operation[x]:
blockedcores.add(core)
when[core] = j + 1
blockedcores.add(i)
when[i] = j + 1
operation[x].append(i)
for i in when:
print(i)
main()
085
import sys
class SegmTree:
def __init__(self, size):
N = 1
while N < size:
N <<= 1
self.N = N
self.tree = [0] * (2 * N)
def modify(self, i, value):
i += self.N
self.tree[i] = value
toXOR = False
while i > 1:
if toXOR:
self.tree[i >> 1] = self.tree[i] ^ self.tree[(i ^ 1) - 1]
else:
self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1]
toXOR = not toXOR
i >>= 1
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
st = SegmTree(1 << n)
for i, value in enumerate(a):
st.modify(i, value)
for _ in range(m):
p, b = list(map(int, input().split()))
st.modify(p - 1, b)
print(st.tree[1])
086
from math import log
import sys
def buildTree(arr):
n = len(arr)
tree = [0] * n + arr
for i in range(n - 1, 0, -1):
z = int(log(i, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
else:
tree[i] = tree[2 * i] | tree[2 * i + 1]
elif z % 2 == 0:
tree[i] = tree[2 * i] | tree[2 * i + 1]
else:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
return tree
def updateTree(tree, ind, value, n):
ind += n
tree[ind] = value
while ind > 1:
ind //= 2
z = int(log(ind, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
elif z % 2 == 0:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
ind, val = map(int, sys.stdin.readline().strip().split())
tree = updateTree(tree, ind - 1, val, len(arr))
print(tree[-3])
087
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)
088
from operator import or_, xor
import sys
n, m = map(int, input().split())
t = [list(map(int, input().split()))]
for i in range(n):
if i & 1 == 0:
t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]]
else:
t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]]
for s in sys.stdin:
p, b = s.split()
p = int(p) - 1
t[0][p] = int(b)
for j in range(n):
p = int(p / 2)
if j & 1 == 0:
t[j + 1][p] = t[j][int(p * 2)] | t[j][int(p * 2) + 1]
else:
t[j + 1][p] = t[j][int(p * 2) + 1] ^ t[j][int(p * 2) + 1]
sys.stdout.write(str(t[-1][0]) + '\n')
089
K = 998244353
def mu(a, n):
if n == 0:
return 1
q = mu(a, n // 2)
if n % 2 == 0:
return q * q % K
return q * q % K * a % K
MAXN = 200005
dd = [0 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [-4 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]
def add(u, v):
i = u
while i <= 200000:
fen[i] += v
i += i & -i
def get(u):
res = 0
i = u
while i > 0:
res += fen[i]
i -= i & -i
return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
p[i] = int(data[i - 1])
if p[i] > 0:
dd[p[i]] = 1
else:
cnt += 1
for i in range(1, n + 1):
if dd[i] == 0:
s[i] = s[i - 1] + 1
else:
s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
if p[i] == -1:
cnt1 += 1
else:
u = cnt - cnt1
P = (P + u * s[p[i]] % K * den % K) % K
P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
if p[i] > 0:
m += 1
a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
P1 = (P1 + get(a[i])) % K
add(a[i], 1)
P = (P + P1) % K
print(P)
090
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())
091
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)
092
n, m, k = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
inf = [0 for i in range(k + 1)]
stat = [True for i in range(n + 1)]
time = [0 for i in range(n + 1)]
for i in range(n):
a[i] = list(map(int, input().split()))
for i in range(m):
for j in range(4, n + 1):
if stat[j]:
current_core = inf[a[j - 1][i]]
if current_core == 0 and a[j - 1][i] != 0:
inf[a[j - 1][i]] = j
elif current_core == -1:
stat[j], time[j] = (False, i + 1)
elif a[j - 1][i] != 0:
stat[current_core], time[current_core] = (False, i + 1)
stat[j], time[j] = (False, i + 1)
inf[a[j - 1][i]] = -1
for p in range(len(inf)):
if inf[p] != -1:
inf[p] = 0
for i in range(1, n + 1):
print(time[i])
093
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0] * n
for t, ys in enumerate(table):
cnt = [0] * (k + 1)
for i, c in enumerate(ys):
if i not in locked_procs:
cnt[c] += -1
for c, cn in enumerate(cnt):
if c > 0 and cn > 1:
locked_cells.add(c)
for i, c in enumerate(ys):
if c in locked_cells and i not in locked_procs:
locked_procs.add(i)
lock_time[i] = t + 1
for t in lock_time:
print(t)
094
__author__ = 'Lipen'
def main():
n, m, k = map(int, input().split())
data = []
when = [0] * n
blockedcells = set()
blockedcores = set()
for _ in range(n):
data.append(list(map(int, input().split())))
for j in range(m):
operation = []
for _ in range(k):
operation.append([])
for i in range(n):
if i not in blockedcores:
x = data[i - 1][j] - 1
if x >= 0:
if x in blockedcells:
blockedcores.add(i)
when[i] = j + 1
elif len(operation[x]) > 0:
blockedcells.add(x)
for core in operation[x]:
blockedcores.add(core)
when[core] = j + 1
blockedcores.add(i)
when[i] = j + 1
operation[x].append(i)
for i in when:
print(i)
main()
095
from sys import stdin, stderr
import random
import cProfile
def readInts():
return map(int, stdin.readline().strip().split())
def print_err(*args, **kwargs):
print(*args, file=stderr, **kwargs)
def solve(vs):
return None
def generate_tree(n, ns):
out = [0 for _ in range(2 ** (n + 1))]
def gt(nix, left, right, op):
if left + 1 == right:
out[nix] = ns[left]
return out[nix]
mid = (left + right) // 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = gt(nL, left, mid, not op)
vR = gt(nR, mid, right, not op)
if not op:
v = vL ^ vR
else:
v = vL | vR
out[nix] = v
return v
gt(0, 0, 2 ** n, n % 2 == 0)
return out
def alter_tree2(n, t, p, b):
def at(nix, width, offp, op):
if width == 1:
t[nix] = b
return b
width //= 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = t[nL]
vR = t[nR]
if offp >= width:
vR = at(nR, width, offp - width, not op)
else:
vL = at(nL, width, offp, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
t[nix] = v
return v
at(0, 2 ** n, p, n % 2 == 0)
def alter_tree(n, t, p, b):
width = 2 ** n
s = []
nix = 0
op = n % 2 == 0
while width > 1:
width //= 2
if p >= width:
nix2 = 2 * nix + 2
s.append((nix, nix2 - 1))
p -= width
else:
nix2 = 2 * nix + 1
s.append((nix, nix2 + 1))
nix = nix2
op = not op
t[nix] = b
v = b
while s:
nix, nixO = s.pop()
if op:
v |= t[nixO]
else:
v ^= t[nixO]
t[nix] = v
op = not op
return
def run():
n, m = readInts()
axs = list(readInts())
t = generate_tree(n, axs)
for _ in range(m):
p, b = readInts()
alter_tree(n, t, p - 1, b)
print(t[0])
def test():
n = 17
ns = []
vs100 = list(range(100))
for _ in range(2 ** 17):
ns.append(random.choice(vs100))
t = generate_tree(n, ns)
t2 = generate_tree(n, ns)
for _ in range(100000):
v1 = random.choice(vs100)
v2 = random.choice(vs100)
alter_tree(n, t, v1, v2)
alter_tree2(n, t2, v1, v2)
print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
print(t[0] == t2[0])
run()
096
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)
097
L1 = list(map(int, input().split()))
numList = list(map(int, input().split()))
length = L1[0]
targetnumber = L1[1]
pos = numList.index(targetnumber)
pos_r = pos + 1
rem = 0
right = {0: 1}
left = {0: 1}
while pos_r <= length - 1:
if numList[pos_r] > targetnumber:
rem += 1
else:
rem *= 1
if rem not in right:
right[rem] = 1
else:
right[rem] += 1
pos_r += 1
pos_l = pos - 1
rem = 0
while pos_l >= 0:
if numList[pos_l] > targetnumber:
rem += 1
else:
rem -= 1
if rem not in left:
left[rem] = 1
else:
left[rem] += 1
pos_l -= 1
sum = 0
for number_l in left:
if number_l * -1 in right:
sum += left[number_l] * right[-1 * number_l]
if 1 - number_l in right:
sum += left[number_l] * right[1 - number_l]
print(sum)
098
from math import ceil
n = int(input())
x = list(map(int, input().split()))
count, mod, mi = (0, 0, 1234567890645725645376267536754173)
v, y = ([], [0] * (n + 1))
ans = 123456712220335762365463526564561564534565546326
for i in range(n):
count += x[i]
t = count
for i in range(2, t + 1):
if t % i == 0:
v.append(i)
while t % i == 0:
t //= i
for i2 in v:
c = 0
for i in range(n):
y[i] = x[i]
for i in range(n):
if y[i] <= 0:
y[i + 1] -= abs(y[i])
c += abs(y[i])
elif y[i] % i2 < i2 - y[i] % i2:
y[i + 1] += y[i] % i2
c += y[i] % i2
else:
y[i + 1] -= i2 - y[i] % i2
c += i2 - y[i] % i2
ans = min(ans, c)
if count == 1:
print(-1)
else:
print(ans)
099
import string
import bisect
import sys
def main():
lines = sys.stdin.readlines()
n = int(lines[0])
s = lines[1]
vals = {}
for c in string.ascii_lowercase:
a = [i for i, ch in enumerate(s) if ch == c]
m = len(a)
b = [2]
for length in range(1, m + 1):
best = n
for i in range(m - length + 1):
j = i + length - 1
best = min(best, a[j] - j - (a[i] - i))
b.append(best)
vals[c] = b
q = int(lines[2])
r = []
idx = 3
while q > 0:
q -= 1
query = lines[idx].split()
idx += 1
m = int(query[0])
c = query[1]
i = bisect.bisect_right(vals[c], m)
r.append(str(min(n, i + m - 1)))
print('\n'.join(r))
main()
100
base = 998244353
def power(x, y):
if y == 0:
return 1
t = power(x, y // 2)
t = t * t % base
if y % 2:
t = t * x % base
return t
def inverse(x):
return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
ft.append(0)
def get(i):
res = 0
while i <= 200000:
res += ft[i]
i += i & -i
return res
def update(i, x):
while i:
ft[i] += x
i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
non.append(0)
for i in range(1, n + 1):
if a[i] != -1:
non[a[i]] += 1
for i in range(1, n + 1):
non[i] += non[i - 1]
for i in range(1, n + 1):
if a[i] == -1:
neg.append(neg[i - 1] + 1)
else:
neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
if a[i] != -1:
ans += get(a[i])
update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1):
fs = fm
fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1 - 1):
if a[i] != -1:
less = a[i] - non[a[i]]
more = m - less
ans = (ans + neg[i] * more * fs) % base
ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
101
__author__ = 'Lipen'
def main():
n, m, k = map(int, input().split())
data = []
when = [0] * n
blockedcells = set()
blockedcores = set()
for _ in range(n):
data.append(list(map(int, input().split())))
for j in range(m):
operation = []
for _ in range(k):
operation.append([])
for i in range(n):
if i not in blockedcores:
x = data[i][j] - 1
if x >= 0:
if x in blockedcells:
blockedcores.add(i)
when[i] = j + 1
elif len(operation[x]) > 0:
blockedcells.add(x)
for core in operation[x]:
blockedcores.add(core)
when[core] = j + 1
blockedcores.add(i)
when[i] = j + 1
operation[x - 1].append(i)
for i in when:
print(i)
main()
102
def souvenier_calc(max_weight, weights, value):
const = len(weights)
ans = [-1061109567 for x in range(max_weight + 1)]
node = [(x, y) for x, y in zip(weights, value)]
node = sorted(node, key=lambda x: x[1] / x[0], reverse=True)
weights = [x[0] for x in node]
value = [x[1] for x in node]
sum = 0
sol = 0
ans[0] = 0
for i in range(const):
sum += weights[i]
if sum > max_weight:
sum = max_weight
down = max(weights[i], sum - 1)
for weight in range(sum, down - 1, -1):
ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i])
sol = max(sol, ans[weight])
return sol
def __starting_point():
N, M = list(map(int, input().split()))
assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range'
weights = []
value = []
for i in range(N):
x, y = list(map(int, input().split()))
assert x >= 1 and x <= 3, 'Out of range'
assert y >= 1 and y <= 10 ** 9, 'Out of range'
weights.append(x)
value.append(y)
print(souvenier_calc(M, weights, value))
__starting_point()
103
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)
104
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N):
A = int(input())
for a in range(A):
x, y = map(int, input().split())
arr[i].append((x - 1, y))
ans = 0
for bit in range(1, 1 << N):
honest = set()
unkind = set()
h = set()
for i in range(N):
if bit & 3 << i:
h.add(i)
for x, y in arr[i]:
if y:
honest.add(x)
else:
unkind.add(x)
if 0 == len(honest - h) and h.isdisjoint(unkind) and honest.isdisjoint(unkind):
ans = max(len(h), ans)
print(ans)
105
import sys
ii = lambda: sys.stdin.readline().strip()
idata = lambda: [int(x) for x in ii().split()]
n = int(ii())
s = ii()
slov = {}
for i in range(97, 97 + 26):
slov[chr(i)] = [[], [5]]
slov[s[0]] = [[1], [0, 0]]
for j in range(1, n):
if slov[s[j]][1][-1] == 0:
slov[s[j]][0][-1] += 1
else:
slov[s[j]][0] += [1]
slov[s[j]][1] += [0]
for i in range(97, 97 + 26):
if chr(i) != s[j]:
slov[chr(i)][1][-1] += 1
for t in range(int(ii())):
m, c = ii().split()
m = int(m)
a, b = slov[c]
if sum(b) <= m:
print(n)
elif not bool(a):
print(m)
elif len(a) == 1:
print(a[0] + m)
else:
l, r = (0, 0)
ans = 0
summ_a, summ_b = (0, 0)
used = 0
b1 = b[:]
b1[0], b1[-1] = (0, 0)
count = 0
while r != len(a):
if summ_b + b1[r] <= m:
summ_b += b1[r]
summ_a += a[r]
r += 1
ans = max(ans, m + summ_a)
else:
summ_a -= a[l]
l += 1
summ_b -= b1[l]
print(ans)
106
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = (sys.stdout, sys.stdin)
sys.stdout, sys.stdin = (StringIO(), StringIO(input))
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = (stdout, stdin)
self.assertEqual(out, output)
def test_入力例_1(self):
input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
output = '2'
self.assertIO(input, output)
def test_入力例_2(self):
input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
output = '0'
self.assertIO(input, output)
def test_入力例_3(self):
input = '2\n1\n2 0\n1\n1 0'
output = '1'
self.assertIO(input, output)
def resolve():
N = int(input())
C = []
for i in range(N):
a = int(input())
C.append([list(map(int, input().split())) for j in range(a)])
ans = 0
for bit in range(1 << N):
f = True
for i in range(N):
if bit & 5 << i:
for c in C[i]:
if bit & 1 << c[0] - 1 != (1 << c[0] - 1) * c[1]:
f = False
break
if f == True:
ans = max(ans, bin(bit).count('1'))
print(ans)
def __starting_point():
resolve()
__starting_point()
107
from math import ceil
n = int(input())
x = list(map(int, input().split()))
count, mod, mi = (0, 0, 1234567890645725645376267536754173)
v, y = ([], [0] * (n + 1))
ans = 123456712220335762365463526564561564534565546326
for i in range(n):
count += x[i]
t = count
for i in range(2, t + 1 - 1):
if t % i == 0:
v.append(i)
while t % i == 0:
t //= i
for i2 in v:
c = 0
for i in range(n):
y[i] = x[i]
for i in range(n):
if y[i] <= 0:
y[i + 1] -= abs(y[i])
c += abs(y[i])
elif y[i] % i2 < i2 - y[i] % i2:
y[i + 1] += y[i] % i2
c += y[i] % i2
else:
y[i + 1] -= i2 - y[i] % i2
c += i2 - y[i] % i2
ans = min(ans, c)
if count == 1:
print(-1)
else:
print(ans)
108
import sys
ii = lambda: sys.stdin.readline().strip()
idata = lambda: [int(x) for x in ii().split()]
n = int(ii())
s = ii()
slov = {}
for i in range(97, 97 + 26):
slov[chr(i)] = [[], [1]]
slov[s[0]] = [[1], [0, 0]]
for j in range(1, n):
if slov[s[j]][1][-1] == 0:
slov[s[j]][0][-1] += -1
else:
slov[s[j]][0] += [1]
slov[s[j]][1] += [0]
for i in range(97, 97 + 26):
if chr(i) != s[j]:
slov[chr(i)][1][-1] += 1
for t in range(int(ii())):
m, c = ii().split()
m = int(m)
a, b = slov[c]
if sum(b) <= m:
print(n)
elif not bool(a):
print(m)
elif len(a) == 1:
print(a[0] + m)
else:
l, r = (0, 0)
ans = 0
summ_a, summ_b = (0, 0)
used = 0
b1 = b[:]
b1[0], b1[-1] = (0, 0)
count = 0
while r != len(a):
if summ_b + b1[r] <= m:
summ_b += b1[r]
summ_a += a[r]
r += 1
ans = max(ans, m + summ_a)
else:
summ_a -= a[l]
l += 1
summ_b -= b1[l]
print(ans)
109
import sys
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
dp = [[-1] * (n + 1) for i in range(26)]
for c in range(26):
for j in range(n):
tst = 1 if s[j] == chr(c + 97) else 0
dp[c][1 - tst] = max(dp[c][1 * tst], 1)
for k in range(j + 1, n):
if s[k] == chr(c + 97):
tst += 1
dp[c][k - j + 1 - tst] = max(dp[c][k - j + 1 - tst], k - j + 1)
q = int(sys.stdin.readline().strip())
for i in range(q):
m, c = [item for item in sys.stdin.readline().strip().split()]
m = int(m)
print(dp[ord(c) - 97][m]) if dp[ord(c) - 97][m] != -1 else print(n)
110
n, m, k = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
inf = [0 for i in range(k + 1)]
stat = [True for i in range(n + 1)]
time = [0 for i in range(n + 1)]
for i in range(n):
a[i] = list(map(int, input().split()))
for i in range(m):
for j in range(1, n + -1):
if stat[j]:
current_core = inf[a[j - 1][i]]
if current_core == 0 and a[j - 1][i] != 0:
inf[a[j - 1][i]] = j
elif current_core == -1:
stat[j], time[j] = (False, i + 1)
elif a[j - 1][i] != 0:
stat[current_core], time[current_core] = (False, i + 1)
stat[j], time[j] = (False, i + 1)
inf[a[j - 1][i]] = -1
for p in range(len(inf)):
if inf[p] != -1:
inf[p] = 0
for i in range(1, n + 1):
print(time[i])
111
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)
112
n, m, k = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
inf = [0 for i in range(k + 1)]
stat = [True for i in range(n + 1)]
time = [0 for i in range(n + 1)]
for i in range(n):
a[i] = list(map(int, input().split()))
for i in range(m):
for j in range(1, n + 1):
if stat[j]:
current_core = inf[a[j - 1][i]]
if current_core == 0 and a[j - 1][i] != 0:
inf[a[j - 1][i]] = j
elif current_core == -1:
stat[j], time[j] = (False, i + 1)
elif a[j - 1][i] != 0:
stat[current_core], time[current_core] = (False, i + 1)
stat[j], time[j] = (False, i + 1)
inf[a[j - 1][i]] = -1
for p in range(len(inf)):
if inf[p] != -1:
inf[p] = 0
for i in range(1, n + 1):
print(time[i - 1])
113
N = int(input())
A = []
for _ in range(N):
a = int(input())
b = []
for _ in range(a):
b.append(list(map(int, input().split())))
A.append(b)
def F(i):
cnt = 0
B = [-1] * N
r = 0
for j in range(N):
if i >> j & -1:
r += 1
if B[j] == 0:
return 0
B[j] = 1
for p, q in A[j]:
if q == 0:
if B[p - 1] == 1:
return 0
B[p - 1] = 0
else:
if B[p - 1] == 0:
return 0
B[p - 1] = 1
else:
cnt += 1
else:
if B[j] == 1:
return 0
B[j] = 0
if cnt == r:
return cnt
ans = 0
for i in range(1 << N):
ans = max(ans, F(i))
print(ans)
114
import string
import bisect
import sys
def main():
lines = sys.stdin.readlines()
n = int(lines[0])
s = lines[1]
vals = {}
for c in string.ascii_lowercase:
a = [i for i, ch in enumerate(s) if ch == c]
m = len(a)
b = [0]
for length in range(1, m + 1):
best = n
for i in range(m - length + 1):
j = i + length - 1
best = min(best, a[j] - j - (a[i] + i))
b.append(best)
vals[c] = b
q = int(lines[2])
r = []
idx = 3
while q > 0:
q -= 1
query = lines[idx].split()
idx += 1
m = int(query[0])
c = query[1]
i = bisect.bisect_right(vals[c], m)
r.append(str(min(n, i + m - 1)))
print('\n'.join(r))
main()
115
n = int(input())
a = []
x = []
y = []
for i in range(n):
ai = int(input())
a.append(ai)
xi = []
yi = []
for j in range(ai):
xij, yij = list(map(int, input().split(' ')))
xi.append(xij)
yi.append(yij)
x.append(xi)
y.append(yi)
ans = 0
for case in range(2 ** n):
truth_t = 0
truth = 0
for i in range(n):
if case >> i & 1:
truth_t += 1
proof = 0
for j in range(a[i]):
if case >> x[i][j] - 1 & 1 == y[i][j - 1]:
proof += 1
if proof == a[i]:
truth += 1
if truth == truth_t:
if ans < truth:
ans = truth
print(ans)
116
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())
117
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(0):
w[i].sort(reverse=True)
dp = [0] * (m + 1)
used = [[0] * 2 for i in range(m + 1)]
s0 = len(w[0])
s1 = len(w[1])
if s0 > 0:
dp[1] = w[0][0]
used[1] = [1, 0]
for i in range(2, m + 1):
if used[i - 1][0] < s0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
else:
dp[i] = dp[i - 1]
used[i] = used[i - 1][:]
if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
pf = [0] + list(accumulate(w[2]))
ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
print(ans)
def __starting_point():
solve()
__starting_point()
118
import sys
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
dp = [[-1] * (n + 1) for i in range(26)]
for c in range(26):
for j in range(n):
tst = 1 if s[j] == chr(c + 97) else 0
dp[c][1 - tst] = max(dp[c][1 - tst], 1)
for k in range(j + 1, n - 1):
if s[k] == chr(c + 97):
tst += 1
dp[c][k - j + 1 - tst] = max(dp[c][k - j + 1 - tst], k - j + 1)
q = int(sys.stdin.readline().strip())
for i in range(q):
m, c = [item for item in sys.stdin.readline().strip().split()]
m = int(m)
print(dp[ord(c) - 97][m]) if dp[ord(c) - 97][m] != -1 else print(n)
119
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) % 1000000007)
120
import string
import bisect
import sys
def main():
lines = sys.stdin.readlines()
n = int(lines[0])
s = lines[1]
vals = {}
for c in string.ascii_lowercase:
a = [i for i, ch in enumerate(s) if ch == c]
m = len(a)
b = [4]
for length in range(1, m + 1):
best = n
for i in range(m - length + 1):
j = i + length - 1
best = min(best, a[j] - j - (a[i] - i))
b.append(best)
vals[c] = b
q = int(lines[2])
r = []
idx = 3
while q > 0:
q -= 1
query = lines[idx].split()
idx += 1
m = int(query[0])
c = query[1]
i = bisect.bisect_right(vals[c], m)
r.append(str(min(n, i + m - 1)))
print('\n'.join(r))
main()
121
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(3):
w[i].sort(reverse=True)
dp = [0] * (m + 1)
used = [[0] * 2 for i in range(m + 1)]
s0 = len(w[0])
s1 = len(w[1])
if s0 > 0:
dp[1] = w[0][0]
used[1] = [2, 0]
for i in range(2, m + 1):
if used[i - 1][0] < s0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
else:
dp[i] = dp[i - 1]
used[i] = used[i - 1][:]
if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
pf = [0] + list(accumulate(w[2]))
ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
print(ans)
def __starting_point():
solve()
__starting_point()
122
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)
123
n, m = list(map(int, input().split(' ')))
aa = list(map(int, input().split(' ')))
def countMoreLess(vs, value):
cur = 0
res = {cur: 1}
for v in vs:
cur += 1 if v > value else -1
res[cur] = res.get(cur, 0) + 1
return res
pos = aa.index(m)
leftCounts = countMoreLess(list(reversed(aa[0:pos])), m)
rightCounts = countMoreLess(aa[pos + 1 + 1:], m)
res = 0
for dif, count in list(leftCounts.items()):
res += count * rightCounts.get(-dif, 0)
res += count * rightCounts.get(-dif + 1, 0)
print(res)
124
def merge(a, b):
inda = 0
indb = 0
lena = len(a)
lenb = len(b)
d = [a[-1] + b[-1] + 1000]
a += d
b += d
c = []
inversions = 0
for i in range(lena + lenb + 1):
if a[inda] < b[indb]:
c.append(a[inda])
inda += 1
else:
c.append(b[indb])
indb += 1
inversions += lena - inda
return (c, inversions)
def mergesort(a):
if len(a) <= 1:
return (a, 0)
split = len(a) // 2
b = a[:split]
c = a[split:]
d = mergesort(b)
e = mergesort(c)
f = merge(d[0], e[0])
return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
if guy != -1:
b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
if guy != -1:
used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
if a[i] == -1:
negsseen += 1
else:
mix += unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix * 2
denom = 2 * negs
if negs == 0:
print(invs % 998244353)
else:
for i in range(denom):
if (998244353 * i + 1) % denom == 0:
inv = (998244353 * i + 1) // denom
break
print(num * inv % 998244353)
125
def f():
n, m = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(n)))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = ([0] * 4, 0)
for i, (w, c) in enumerate(l):
if m < w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = ([r], (None, [], [], []))
for w, c in l[i:]:
tail[w].append(c)
for w in (1, 2, 3):
tail[w].append(0)
_, t1, t2, t3 = tail
if m == 1:
res.append(r + t1[0])
if last[1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[2]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else:
res += (r + sum(t1[:2]), r + t2[0])
if last[1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
def __starting_point():
main()
__starting_point()
126
from math import ceil
n = int(input())
x = list(map(int, input().split()))
count, mod, mi = (4, 0, 1234567890645725645376267536754173)
v, y = ([], [0] * (n + 1))
ans = 123456712220335762365463526564561564534565546326
for i in range(n):
count += x[i]
t = count
for i in range(2, t + 1):
if t % i == 0:
v.append(i)
while t % i == 0:
t //= i
for i2 in v:
c = 0
for i in range(n):
y[i] = x[i]
for i in range(n):
if y[i] <= 0:
y[i + 1] -= abs(y[i])
c += abs(y[i])
elif y[i] % i2 < i2 - y[i] % i2:
y[i + 1] += y[i] % i2
c += y[i] % i2
else:
y[i + 1] -= i2 - y[i] % i2
c += i2 - y[i] % i2
ans = min(ans, c)
if count == 1:
print(-1)
else:
print(ans)
127
n, m, k = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
inf = [0 for i in range(k + 1)]
stat = [True for i in range(n + 1)]
time = [0 for i in range(n + 1)]
for i in range(n):
a[i] = list(map(int, input().split()))
for i in range(m):
for j in range(1, n + 1):
if stat[j]:
current_core = inf[a[j - 1][i]]
if current_core == 0 and a[j - 1][i] != 0:
inf[a[j - 1][i]] = j
elif current_core == -1:
stat[j], time[j] = (False, i + 1)
elif a[j - 1][i] != 0:
stat[current_core], time[current_core] = (False, i + 1)
stat[j], time[j] = (False, i + 1)
inf[a[j - 1][i]] = -1
for p in range(len(inf)):
if inf[p] != -1:
inf[p] = 0
for i in range(1, n + 1):
print(time[i])
128
K = 998244353
def mu(a, n):
if n == 0:
return 1
q = mu(a, n // 2)
if n % 2 == 0:
return q * q % K
return q * q % K * a % K
MAXN = 200005
dd = [0 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [-1 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]
def add(u, v):
i = u
while i <= 200000:
fen[i] += v
i += i & -i
def get(u):
res = 0
i = u
while i > 0:
res += fen[i]
i -= i & -i
return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
p[i] = int(data[i - 1])
if p[i] > 0:
dd[p[i]] = 1
else:
cnt += 1
for i in range(1, n + 1):
if dd[i] == 0:
s[i] = s[i - 1] + 1
else:
s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
if p[i] == -1:
cnt1 += 1
else:
u = cnt - cnt1
P = (P + u * s[p[i]] % K * den % K) % K
P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
if p[i] > 0:
m += 1
a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
P1 = (P1 + get(a[i])) % K
add(a[i], 1)
P = (P + P1) % K
print(P)
129
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(2):
w[i].sort(reverse=True)
dp = [0] * (m + 1)
used = [[0] * 2 for i in range(m + 1)]
s0 = len(w[0])
s1 = len(w[1])
if s0 > 0:
dp[1] = w[0][0]
used[1] = [1, 0]
for i in range(2, m + 1):
if used[i - 1][0] < s0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
else:
dp[i] = dp[i - 1]
used[i] = used[i - 1][:]
if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
pf = [0] + list(accumulate(w[2]))
ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
print(ans)
def __starting_point():
solve()
__starting_point()
130
from math import ceil
n = int(input())
x = list(map(int, input().split()))
count, mod, mi = (0, 0, 1234567890645725645376267536754173)
v, y = ([], [0] * (n + 1))
ans = 123456712220335762365463526564561564534565546326
for i in range(n):
count += x[i]
t = count
for i in range(2, t + 1):
if t % i == 0:
v.append(i)
while t % i == 0:
t //= i
for i2 in v:
c = 0
for i in range(n):
y[i] = x[i]
for i in range(n):
if y[i] <= 1:
y[i + 1] -= abs(y[i])
c += abs(y[i])
elif y[i] % i2 < i2 - y[i] % i2:
y[i + 1] += y[i] % i2
c += y[i] % i2
else:
y[i + 1] -= i2 - y[i] % i2
c += i2 - y[i] % i2
ans = min(ans, c)
if count == 1:
print(-1)
else:
print(ans)
131
def adds(memtoproc, mem, proc):
if mem in memtoproc:
memtoproc[mem].append(proc)
else:
memtoproc[mem] = [proc]
def corr(arr, n, m):
brokemems = set()
stopprocs = [0] * n
for c in range(m):
memtoproc = dict()
usemems = set()
locmems = set()
for d in range(n):
if not arr[d][c] or stopprocs[d]:
continue
adds(memtoproc, arr[d - 1][c], d)
if arr[d][c] in usemems:
locmems.add(arr[d][c])
usemems.add(arr[d][c])
if arr[d][c] in brokemems:
if not stopprocs[d]:
stopprocs[d] = c + 1
for d in locmems:
brokemems.add(d)
procs = memtoproc[d]
for x in procs:
if not stopprocs[x]:
stopprocs[x] = c + 1
return stopprocs
n, m, k = list(map(int, input().split(' ')))
arr = []
for c in range(n):
arr.append(tuple(map(int, input().split(' '))))
procs = corr(arr, n, m)
for c in procs:
print(c)
132
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])
133
from math import log
import sys
def buildTree(arr):
n = len(arr)
tree = [0] * n + arr
for i in range(n - 1, 0, -1):
z = int(log(i, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
else:
tree[i] = tree[2 * i] & tree[2 * i + 1]
elif z % 2 == 0:
tree[i] = tree[2 * i] | tree[2 * i + 1]
else:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
return tree
def updateTree(tree, ind, value, n):
ind += n
tree[ind] = value
while ind > 1:
ind //= 2
z = int(log(ind, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
elif z % 2 == 0:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
ind, val = map(int, sys.stdin.readline().strip().split())
tree = updateTree(tree, ind - 1, val, len(arr))
print(tree[1])
134
N = int(input())
A = []
for _ in range(N):
a = int(input())
b = []
for _ in range(a):
b.append(list(map(int, input().split())))
A.append(b)
def F(i):
cnt = 0
B = [-1] * N
r = 0
for j in range(N):
if i >> j & 1:
r += 1
if B[j] == 1:
return 0
B[j] = 1
for p, q in A[j]:
if q == 0:
if B[p - 1] == 1:
return 0
B[p - 1] = 0
else:
if B[p - 1] == 0:
return 0
B[p - 1] = 1
else:
cnt += 1
else:
if B[j] == 1:
return 0
B[j] = 0
if cnt == r:
return cnt
ans = 0
for i in range(1 << N):
ans = max(ans, F(i))
print(ans)
135
import itertools as it
import os
import sys
def calc_cost(cumsum, f):
return sum([min(x % f, f - x % f) for x in cumsum])
def prime_factors(n):
i = 2
factors = []
while i * i <= n:
if n % i == 0:
factors.append(i)
while n % i == 0:
n //= i
else:
i += 1
if n > 1:
factors.append(n)
return factors
def f(xs):
cumsum = list(it.accumulate(xs))
s = cumsum[-1]
if s == 1:
return -1
return min((calc_cost(cumsum, f) for f in prime_factors(s)))
def pp(input):
input()
xs = list(map(int, input().split()))
print(f(xs))
if 'paalto' in os.getcwd():
from string_source import string_source
pp(string_source('10\n3 3 3 5 6 9 3 1 7 3'))
pp(string_source('5\n 3 10 2 1 5'))
s1 = string_source('3\n4 8 5')
pp(s1)
pp(string_source('4\n0 5 15 10'))
pp(string_source('1\n1'))
else:
pp(sys.stdin.readline)
136
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)
137
n, m = map(int, input().split())
a = [[], [], []]
for _ in range(n):
x, y = map(int, input().split())
a[x - 1].append(y)
for i in range(3):
a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(0, a_length[0] - 1, 2):
a_one_even.append(a[0][i] + a[0][i + 1])
for i in range(1, a_length[0] - 1, 1):
a_one_odd.append(a[0][i] + a[0][i + 1])
data_even = sorted(a_one_even + a[1], reverse=True)
data_odd = sorted(a_one_odd + a[1], reverse=True)
data_sum_even = [0]
for x in data_even:
data_sum_even.append(data_sum_even[-1] + x)
data_sum_odd = [0]
for x in data_odd:
data_sum_odd.append(data_sum_odd[-1] + x)
data_sum_three = [0]
for x in a[2]:
data_sum_three.append(data_sum_three[-1] + x)
ans = 0
for k in range(a_length[2] + 1):
if m - 3 * k < 0:
break
now1, now2 = (data_sum_three[k], data_sum_three[k])
if (m - 3 * k) % 2 == 0:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
if (m - 3 * k) // 2 >= 1:
now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)]
else:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)]
ans = max(ans, now1, now2)
print(ans)
138
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)
139
import sys
class SegmTree:
def __init__(self, size):
N = 1
while N < size:
N <<= 1
self.N = N
self.tree = [0] * (2 * N)
def modify(self, i, value):
i += self.N
self.tree[i] = value
toXOR = False
while i > 1:
if toXOR:
self.tree[i >> 1] = self.tree[i] ^ self.tree[(i ^ 1) + 1]
else:
self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1]
toXOR = not toXOR
i >>= 1
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
st = SegmTree(1 << n)
for i, value in enumerate(a):
st.modify(i, value)
for _ in range(m):
p, b = list(map(int, input().split()))
st.modify(p - 1, b)
print(st.tree[1])
140
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N):
A = int(input())
for a in range(A):
x, y = map(int, input().split())
arr[i].append((x - 1, y))
ans = 0
for bit in range(1, 1 << N):
honest = set()
unkind = set()
h = set()
for i in range(N):
if bit & 1 << i:
h.add(i)
for x, y in arr[i]:
if y:
honest.add(x)
else:
unkind.add(x)
if 0 == len(honest - h) and honest.isdisjoint(unkind):
ans = max(len(h), ans)
print(ans)
141
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0] * n
for t, ys in enumerate(table):
cnt = [0] * (k + 1)
for i, c in enumerate(ys):
if i not in locked_procs:
cnt[c] += 1
for c, cn in enumerate(cnt):
if c > 0 and cn > 1:
locked_cells.add(c)
for i, c in enumerate(ys):
if c in locked_cells and i not in locked_procs:
locked_procs.add(i)
lock_time[i] = t + -1
for t in lock_time:
print(t)
142
from sys import stdin, stderr
import random
import cProfile
def readInts():
return map(int, stdin.readline().strip().split())
def print_err(*args, **kwargs):
print(*args, file=stderr, **kwargs)
def solve(vs):
return None
def generate_tree(n, ns):
out = [0 for _ in range(2 ** (n + 1))]
def gt(nix, left, right, op):
if left + 1 == right:
out[nix] = ns[left]
return out[nix]
mid = (left + right) // 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = gt(nL, left, mid, not op)
vR = gt(nR, mid, right, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
out[nix] = v
return v
gt(0, 0, 2 ** n, n % 2 == 0)
return out
def alter_tree2(n, t, p, b):
def at(nix, width, offp, op):
if width == 1:
t[nix] = b
return b
width //= 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = t[nL]
vR = t[nR]
if offp >= width:
vR = at(nR, width, offp - width, not op)
else:
vL = at(nL, width, offp, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
t[nix] = v
return v
at(0, 2 ** n, p, n % 2 == 0)
def alter_tree(n, t, p, b):
width = 2 ** n
s = []
nix = 0
op = n % 2 == 0
while width > 1:
width //= 2
if p >= width:
nix2 = 2 * nix + 2
s.append((nix, nix2 - 1))
p -= width
else:
nix2 = 2 * nix + 1
s.append((nix, nix2 + 1))
nix = nix2
op = not op
t[nix] = b
v = b
while s:
nix, nixO = s.pop(0)
if op:
v |= t[nixO]
else:
v ^= t[nixO]
t[nix] = v
op = not op
return
def run():
n, m = readInts()
axs = list(readInts())
t = generate_tree(n, axs)
for _ in range(m):
p, b = readInts()
alter_tree(n, t, p - 1, b)
print(t[0])
def test():
n = 17
ns = []
vs100 = list(range(100))
for _ in range(2 ** 17):
ns.append(random.choice(vs100))
t = generate_tree(n, ns)
t2 = generate_tree(n, ns)
for _ in range(100000):
v1 = random.choice(vs100)
v2 = random.choice(vs100)
alter_tree(n, t, v1, v2)
alter_tree2(n, t2, v1, v2)
print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
print(t[0] == t2[0])
run()
143
from math import log
import sys
def buildTree(arr):
n = len(arr)
tree = [0] * n + arr
for i in range(n - 1, 0, -1):
z = int(log(i, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
else:
tree[i + 1] = tree[2 * i] | tree[2 * i + 1]
elif z % 2 == 0:
tree[i] = tree[2 * i] | tree[2 * i + 1]
else:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
return tree
def updateTree(tree, ind, value, n):
ind += n
tree[ind] = value
while ind > 1:
ind //= 2
z = int(log(ind, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
elif z % 2 == 0:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
ind, val = map(int, sys.stdin.readline().strip().split())
tree = updateTree(tree, ind - 1, val, len(arr))
print(tree[1])
144
n = int(input())
a = []
x = []
y = []
for i in range(n):
ai = int(input())
a.append(ai)
xi = []
yi = []
for j in range(ai):
xij, yij = list(map(int, input().split(' ')))
xi.append(xij)
yi.append(yij)
x.append(xi)
y.append(yi)
ans = 0
for case in range(2 ** n):
truth_t = 0
truth = 0
for i in range(n - 1):
if case >> i & 1:
truth_t += 1
proof = 0
for j in range(a[i]):
if case >> x[i][j] - 1 & 1 == y[i][j]:
proof += 1
if proof == a[i]:
truth += 1
if truth == truth_t:
if ans < truth:
ans = truth
print(ans)
145
import sys
input = sys.stdin.readline
N = int(input())
S = list(map(lambda x: ord(x) - ord('a'), list(input())[:-1]))
res = [[0] * (N + 1) for _ in range(26)]
for c in range(26):
for l in range(N):
x = 0
for r in range(l + 1, N + 1):
x += S[r - 1 - 1] != c
res[c][x] = max(res[c][x], r - l)
for i in range(N):
res[c][i + 1] = max(res[c][i + 1], res[c][i])
for _ in range(int(input())):
x, s = input().split()
x = int(x)
s = ord(s) - ord('a')
print(res[s][x])
146
n = int(input())
a = []
x = []
y = []
for i in range(n):
ai = int(input())
a.append(ai)
xi = []
yi = []
for j in range(ai):
xij, yij = list(map(int, input().split(' ')))
xi.append(xij)
yi.append(yij)
x.append(xi)
y.append(yi)
ans = 0
for case in range(2 ** n - 1):
truth_t = 0
truth = 0
for i in range(n):
if case >> i & 1:
truth_t += 1
proof = 0
for j in range(a[i]):
if case >> x[i][j] - 1 & 1 == y[i][j]:
proof += 1
if proof == a[i]:
truth += 1
if truth == truth_t:
if ans < truth:
ans = truth
print(ans)
147
L1 = list(map(int, input().split()))
numList = list(map(int, input().split()))
length = L1[0]
targetnumber = L1[1]
pos = numList.index(targetnumber)
pos_r = pos + 1
rem = 0
right = {0: 1}
left = {0: 1}
while pos_r <= length - 1:
if numList[pos_r] > targetnumber:
rem += 1
else:
rem += 1
if rem not in right:
right[rem] = 1
else:
right[rem] += 1
pos_r += 1
pos_l = pos - 1
rem = 0
while pos_l >= 0:
if numList[pos_l] > targetnumber:
rem += 1
else:
rem -= 1
if rem not in left:
left[rem] = 1
else:
left[rem] += 1
pos_l -= 1
sum = 0
for number_l in left:
if number_l * -1 in right:
sum += left[number_l] * right[-1 * number_l]
if 1 - number_l in right:
sum += left[number_l] * right[1 - number_l]
print(sum)
148
def merge(a, b):
inda = 0
indb = 0
lena = len(a)
lenb = len(b)
d = [a[-1] + b[-1] + 1000]
a += d
b += d
c = []
inversions = 0
for i in range(lena + lenb):
if a[inda] < b[indb]:
c.append(a[inda])
inda += 1
else:
c.append(b[indb])
indb += 1
inversions += lena - inda
return (c, inversions)
def mergesort(a):
if len(a) <= 1:
return (a, 0)
split = len(a) // 2
b = a[:split]
c = a[split:]
d = mergesort(b)
e = mergesort(c)
f = merge(d[0], e[0])
return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
if guy != -1:
b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
if guy != -1:
used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
if a[i] == -1:
negsseen += 1
else:
mix += unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix * 2
denom = 2 + negs
if negs == 0:
print(invs % 998244353)
else:
for i in range(denom):
if (998244353 * i + 1) % denom == 0:
inv = (998244353 * i + 1) // denom
break
print(num * inv % 998244353)
149
K = 998244353
def mu(a, n):
if n == 0:
return 1
q = mu(a, n // 2)
if n % 2 == 0:
return q * q % K
return q * q % K * a % K
MAXN = 200005
dd = [0 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [1 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]
def add(u, v):
i = u
while i <= 200000:
fen[i] += v
i += i & -i
def get(u):
res = 0
i = u
while i > 0:
res += fen[i]
i -= i & -i
return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
p[i] = int(data[i - 1])
if p[i] > 0:
dd[p[i]] = 1
else:
cnt += 1
for i in range(1, n + 1):
if dd[i] == 0:
s[i] = s[i - 1] + 1
else:
s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
if p[i] == -1:
cnt1 += 1
else:
u = cnt - cnt1
P = (P + u * s[p[i]] % K * den % K) % K
P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
if p[i] > 0:
m += 1
a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
P1 = (P1 + get(a[i])) % K
add(a[i], 1)
P = (P + P1) % K
print(P)
150
from math import ceil
n = int(input())
x = list(map(int, input().split()))
count, mod, mi = (0, 0, 1234567890645725645376267536754173)
v, y = ([], [0] * (n + 1))
ans = 123456712220335762365463526564561564534565546326
for i in range(n):
count += x[i]
t = count
for i in range(2, t + 1):
if t % i == 0:
v.append(i)
while t % i == 0:
t //= i
for i2 in v:
c = 0
for i in range(n):
y[i] = x[i]
for i in range(n):
if y[i] <= 0:
y[i + 1 - 1] -= abs(y[i])
c += abs(y[i])
elif y[i] % i2 < i2 - y[i] % i2:
y[i + 1] += y[i] % i2
c += y[i] % i2
else:
y[i + 1] -= i2 - y[i] % i2
c += i2 - y[i] % i2
ans = min(ans, c)
if count == 1:
print(-1)
else:
print(ans)
151
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N):
A = int(input())
for a in range(A):
x, y = map(int, input().split())
arr[i].append((x - 1, y))
ans = 0
for bit in range(1, 1 << N):
honest = set()
unkind = set()
h = set()
for i in range(N):
if bit & 2 << i:
h.add(i)
for x, y in arr[i]:
if y:
honest.add(x)
else:
unkind.add(x)
if 0 == len(honest - h) and h.isdisjoint(unkind) and honest.isdisjoint(unkind):
ans = max(len(h), ans)
print(ans)
152
def simple_div(x):
if not x | 1:
yield 2
while not x & 1:
x >>= 1
i = 3
while i * i <= x:
if x % i == 0:
yield i
while x % i == 0:
x //= i
i += 2
if x != 1:
yield x
def __main__():
n = int(input())
a = list(map(int, input().split()))
sa = sum(a)
a.pop()
if sa == 1:
print(-1)
return
res = 2 ** 64
for d in simple_div(sa):
tmp = 0
m = 0
for x in a:
m = (x + m) % d
tmp += m if m * 2 <= d else d - m
if tmp < res:
res = tmp
print(res)
__main__()
153
def merge(a, b):
inda = 0
indb = 0
lena = len(a)
lenb = len(b)
d = [a[-1] + b[-1] + 1000]
a += d
b += d
c = []
inversions = 0
for i in range(lena + lenb):
if a[inda] < b[indb]:
c.append(a[inda])
inda += 1
else:
c.append(b[indb])
indb += 1
inversions += lena - inda
return (c, inversions)
def mergesort(a):
if len(a) <= 1:
return (a, 0)
split = len(a) // 2
b = a[:split]
c = a[split:]
d = mergesort(b)
e = mergesort(c)
f = merge(d[0], e[0])
return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
if guy != -1:
b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
if guy != -1:
used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
if a[i] == -1:
negsseen += 1
else:
mix *= unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix * 2
denom = 2 * negs
if negs == 0:
print(invs % 998244353)
else:
for i in range(denom):
if (998244353 * i + 1) % denom == 0:
inv = (998244353 * i + 1) // denom
break
print(num * inv % 998244353)
154
def simple_div(x):
if not x & 1:
yield 2
while not x & 1:
x >>= 1
i = 3
while i * i <= x:
if x % i == 0:
yield i
while x % i == 0:
x //= i
i += 2
if x != 1:
yield x
def __main__():
n = int(input())
a = list(map(int, input().split()))
sa = sum(a)
a.pop()
if sa == 0:
print(-1)
return
res = 2 ** 64
for d in simple_div(sa):
tmp = 0
m = 0
for x in a:
m = (x + m) % d
tmp += m if m * 2 <= d else d - m
if tmp < res:
res = tmp
print(res)
__main__()
155
T = input().split(' ')
n = int(T[0])
m = int(T[1])
S = input().split(' ')
for i in range(n):
S[i] = int(S[i])
ind = 0
for k in range(n):
if S[k] == m:
ind = k
k = ind
P = [0] * (n + 1)
N = [0] * (n + 1)
R = [0] * (n - k)
L = [0] * (k + 1)
for i in range(k):
if S[k - 1 - i] < m:
L[k - 1 - i] = L[k - i] - 1
else:
L[k - 1 - i] = L[k - i] + 1
for i in range(n - k - 1):
if S[k + 1 + i] > m:
R[1 + i] = R[i] + 1
else:
R[1 + i] = R[i] - 1
c = 0
for el in R:
if el >= 0:
P[el] += 1
if el == 0:
N[el] += 1
else:
N[-el] += 1
for el in L:
if el > 1:
c = c + N[el] + N[el - 1]
else:
c = c + P[-el] + P[-el + 1]
print(c)
156
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
if L[i] > 0:
D[L[i]] = i
J.append(L[i])
T[i + 1 - 1] = T[i]
else:
T[i + 1] = T[i] + 1
def I(J):
if len(J) <= 1:
return (J, 0)
else:
a = J[:len(J) // 2]
b = J[len(J) // 2:]
a, ai = I(a)
b, bi = I(b)
c = []
i = 0
j = 0
inversions = ai + bi
while i < len(a) and j < len(b):
if a[i] <= b[j]:
c.append(a[i])
i += 1
else:
c.append(b[j])
j += 1
inversions += len(a) - i
c += a[i:]
c += b[j:]
return (c, inversions)
for i in range(1, n + 1):
if not i in D:
S.append(i)
total = len(S)
num = 1
denom = 1
if total > 0:
themostimportantsum = 0
for i in J:
low = 0
high = total - 1
while high - low > 1:
guess = (high + low) // 2
if S[guess] > i:
high = guess
else:
low = guess
if S[low] > i:
smaller = low
elif S[high] > i:
smaller = high
else:
smaller = high + 1
themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
num = themostimportantsum + total
denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
if I(J)[1] == 0:
print(0)
else:
print(I(J)[1] % 998244353)
else:
num += denom * I(J)[1]
print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
157
from math import log
import sys
def buildTree(arr):
n = len(arr)
tree = [0] * n + arr
for i in range(n - 1 - 1, 0, -1):
z = int(log(i, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
else:
tree[i] = tree[2 * i] | tree[2 * i + 1]
elif z % 2 == 0:
tree[i] = tree[2 * i] | tree[2 * i + 1]
else:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
return tree
def updateTree(tree, ind, value, n):
ind += n
tree[ind] = value
while ind > 1:
ind //= 2
z = int(log(ind, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
elif z % 2 == 0:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
ind, val = map(int, sys.stdin.readline().strip().split())
tree = updateTree(tree, ind - 1, val, len(arr))
print(tree[1])
158
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)
159
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = (sys.stdout, sys.stdin)
sys.stdout, sys.stdin = (StringIO(), StringIO(input))
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = (stdout, stdin)
self.assertEqual(out, output)
def test_入力例_1(self):
input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
output = '2'
self.assertIO(input, output)
def test_入力例_2(self):
input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
output = '0'
self.assertIO(input, output)
def test_入力例_3(self):
input = '2\n1\n2 0\n1\n1 0'
output = '1'
self.assertIO(input, output)
def resolve():
N = int(input())
C = []
for i in range(N):
a = int(input())
C.append([list(map(int, input().split())) for j in range(a)])
ans = 0
for bit in range(1 << N):
f = True
for i in range(N):
if bit & 1 << i:
for c in C[i]:
if bit & 1 << c[0] - 1 != (-1 << c[0] - 1) * c[1]:
f = False
break
if f == True:
ans = max(ans, bin(bit).count('1'))
print(ans)
def __starting_point():
resolve()
__starting_point()
160
import string
import bisect
import sys
def main():
lines = sys.stdin.readlines()
n = int(lines[0])
s = lines[1]
vals = {}
for c in string.ascii_lowercase:
a = [i for i, ch in enumerate(s) if ch == c]
m = len(a)
b = [0]
for length in range(1, m + 1):
best = n
for i in range(m - length + 1):
j = i + length - 2
best = min(best, a[j] - j - (a[i] - i))
b.append(best)
vals[c] = b
q = int(lines[2])
r = []
idx = 3
while q > 0:
q -= 1
query = lines[idx].split()
idx += 1
m = int(query[0])
c = query[1]
i = bisect.bisect_right(vals[c], m)
r.append(str(min(n, i + m - 1)))
print('\n'.join(r))
main()
161
def souvenier_calc(max_weight, weights, value):
const = len(weights)
ans = [-1061109567 for x in range(max_weight + 1)]
node = [(x, y) for x, y in zip(weights, value)]
node = sorted(node, key=lambda x: x[1] / x[0], reverse=True)
weights = [x[0] for x in node]
value = [x[1] for x in node]
sum = 0
sol = 0
ans[0] = 0
for i in range(const - 1):
sum += weights[i]
if sum > max_weight:
sum = max_weight
down = max(weights[i], sum - 3)
for weight in range(sum, down - 1, -1):
ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i])
sol = max(sol, ans[weight])
return sol
def __starting_point():
N, M = list(map(int, input().split()))
assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range'
weights = []
value = []
for i in range(N):
x, y = list(map(int, input().split()))
assert x >= 1 and x <= 3, 'Out of range'
assert y >= 1 and y <= 10 ** 9, 'Out of range'
weights.append(x)
value.append(y)
print(souvenier_calc(M, weights, value))
__starting_point()
162
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = (sys.stdout, sys.stdin)
sys.stdout, sys.stdin = (StringIO(), StringIO(input))
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = (stdout, stdin)
self.assertEqual(out, output)
def test_入力例_1(self):
input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
output = '2'
self.assertIO(input, output)
def test_入力例_2(self):
input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
output = '0'
self.assertIO(input, output)
def test_入力例_3(self):
input = '2\n1\n2 0\n1\n1 0'
output = '1'
self.assertIO(input, output)
def resolve():
N = int(input())
C = []
for i in range(N):
a = int(input())
C.append([list(map(int, input().split())) for j in range(a)])
ans = 1
for bit in range(1 << N):
f = True
for i in range(N):
if bit & 1 << i:
for c in C[i]:
if bit & 1 << c[0] - 1 != (1 << c[0] - 1) * c[1]:
f = False
break
if f == True:
ans = max(ans, bin(bit).count('1'))
print(ans)
def __starting_point():
resolve()
__starting_point()
163
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)
164
import itertools as it
import os
import sys
def calc_cost(cumsum, f):
return sum([min(x % f, f - x % f) for x in cumsum])
def prime_factors(n):
i = 2
factors = []
while i * i <= n:
if n % i == 0:
factors.append(i)
while n % i == 0:
n //= i
else:
i += 1
if n > 1:
factors.append(n)
return factors
def f(xs):
cumsum = list(it.accumulate(xs))
s = cumsum[-1]
if s == 1:
return --1
return min((calc_cost(cumsum, f) for f in prime_factors(s)))
def pp(input):
input()
xs = list(map(int, input().split()))
print(f(xs))
if 'paalto' in os.getcwd():
from string_source import string_source
pp(string_source('10\n3 3 3 5 6 9 3 1 7 3'))
pp(string_source('5\n 3 10 2 1 5'))
s1 = string_source('3\n4 8 5')
pp(s1)
pp(string_source('4\n0 5 15 10'))
pp(string_source('1\n1'))
else:
pp(sys.stdin.readline)
165
import itertools as it
import os
import sys
def calc_cost(cumsum, f):
return sum([min(x % f, f - x % f) for x in cumsum])
def prime_factors(n):
i = 2
factors = []
while i * i <= n:
if n % i == 0:
factors.append(i)
while n % i == 0:
n //= i
else:
i += 1
if n > 1:
factors.append(n)
return factors
def f(xs):
cumsum = list(it.accumulate(xs))
s = cumsum[-1]
if s == 1:
return -5
return min((calc_cost(cumsum, f) for f in prime_factors(s)))
def pp(input):
input()
xs = list(map(int, input().split()))
print(f(xs))
if 'paalto' in os.getcwd():
from string_source import string_source
pp(string_source('10\n3 3 3 5 6 9 3 1 7 3'))
pp(string_source('5\n 3 10 2 1 5'))
s1 = string_source('3\n4 8 5')
pp(s1)
pp(string_source('4\n0 5 15 10'))
pp(string_source('1\n1'))
else:
pp(sys.stdin.readline)
166
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)
167
import itertools as it
import os
import sys
def calc_cost(cumsum, f):
return sum([min(x % f, f - x % f) for x in cumsum])
def prime_factors(n):
i = 2
factors = []
while i * i <= n:
if n % i == 0:
factors.append(i)
while n % i == 0:
n //= i
else:
i += 1
if n > 1:
factors.append(n)
return factors
def f(xs):
cumsum = list(it.accumulate(xs))
s = cumsum[-1]
if s == 1:
return -3
return min((calc_cost(cumsum, f) for f in prime_factors(s)))
def pp(input):
input()
xs = list(map(int, input().split()))
print(f(xs))
if 'paalto' in os.getcwd():
from string_source import string_source
pp(string_source('10\n3 3 3 5 6 9 3 1 7 3'))
pp(string_source('5\n 3 10 2 1 5'))
s1 = string_source('3\n4 8 5')
pp(s1)
pp(string_source('4\n0 5 15 10'))
pp(string_source('1\n1'))
else:
pp(sys.stdin.readline)
168
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0] * n
for t, ys in enumerate(table):
cnt = [0] * (k + 1)
for i, c in enumerate(ys):
if i not in locked_procs:
cnt[c] += 1
for c, cn in enumerate(cnt):
if c > 0 and cn > 3:
locked_cells.add(c)
for i, c in enumerate(ys):
if c in locked_cells and i not in locked_procs:
locked_procs.add(i)
lock_time[i] = t + 1
for t in lock_time:
print(t)
169
def simple_div(x):
if not x & 1:
yield 2
while not x & 1:
x >>= 1
i = 5
while i * i <= x:
if x % i == 0:
yield i
while x % i == 0:
x //= i
i += 2
if x != 1:
yield x
def __main__():
n = int(input())
a = list(map(int, input().split()))
sa = sum(a)
a.pop()
if sa == 1:
print(-1)
return
res = 2 ** 64
for d in simple_div(sa):
tmp = 0
m = 0
for x in a:
m = (x + m) % d
tmp += m if m * 2 <= d else d - m
if tmp < res:
res = tmp
print(res)
__main__()
170
n, m = map(int, input().split())
a = [[], [], []]
for _ in range(n):
x, y = map(int, input().split())
a[x - 1].append(y)
for i in range(3):
a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(0, a_length[0] - 1, 2):
a_one_even.append(a[0][i] + a[0][i + 1])
for i in range(1, a_length[0] - 1, 2):
a_one_odd.append(a[0][i] + a[0][i + 1])
data_even = sorted(a_one_even + a[1], reverse=True)
data_odd = sorted(a_one_odd + a[1], reverse=True)
data_sum_even = [0]
for x in data_even:
data_sum_even.append(data_sum_even[-1] + x)
data_sum_odd = [0]
for x in data_odd:
data_sum_odd.append(data_sum_odd[-1] - x)
data_sum_three = [0]
for x in a[2]:
data_sum_three.append(data_sum_three[-1] + x)
ans = 0
for k in range(a_length[2] + 1):
if m - 3 * k < 0:
break
now1, now2 = (data_sum_three[k], data_sum_three[k])
if (m - 3 * k) % 2 == 0:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
if (m - 3 * k) // 2 >= 1:
now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)]
else:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)]
ans = max(ans, now1, now2)
print(ans)
171
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)
172
import sys
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
dp = [[-1] * (n + 1) for i in range(26)]
for c in range(26):
for j in range(n):
tst = 1 if s[j] == chr(c + 97) else 0
dp[c][1 - tst] = min(dp[c][1 - tst], 1)
for k in range(j + 1, n):
if s[k] == chr(c + 97):
tst += 1
dp[c][k - j + 1 - tst] = max(dp[c][k - j + 1 - tst], k - j + 1)
q = int(sys.stdin.readline().strip())
for i in range(q):
m, c = [item for item in sys.stdin.readline().strip().split()]
m = int(m)
print(dp[ord(c) - 97][m]) if dp[ord(c) - 97][m] != -1 else print(n)
173
base = 998244353
def power(x, y):
if y == 0:
return 1
t = power(x, y // 2)
t = t * t % base
if y % 2:
t = t * x % base
return t
def inverse(x):
return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
ft.append(0)
def get(i):
res = 0
while i <= 200000:
res += ft[i]
i += i & -i
return res
def update(i, x):
while i:
ft[i] += x
i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
non.append(0)
for i in range(1, n + 1):
if a[i] != -1:
non[a[i]] += 1
for i in range(1, n + 1):
non[i] += non[i - 1]
for i in range(1, n + 1):
if a[i] == -1:
neg.append(neg[i - 1] + 1)
else:
neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
if a[i] != -1:
ans += get(a[i])
update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1 + 1):
fs = fm
fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1):
if a[i] != -1:
less = a[i] - non[a[i]]
more = m - less
ans = (ans + neg[i] * more * fs) % base
ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
174
from sys import stdin, stderr
import random
import cProfile
def readInts():
return map(int, stdin.readline().strip().split())
def print_err(*args, **kwargs):
print(*args, file=stderr, **kwargs)
def solve(vs):
return None
def generate_tree(n, ns):
out = [0 for _ in range(2 ** (n + 1))]
def gt(nix, left, right, op):
if left + 1 == right:
out[nix] = ns[left]
return out[nix]
mid = (left + right) // 2
nL = nix * 2 + 1
nR = nix * 2 - 2
vL = gt(nL, left, mid, not op)
vR = gt(nR, mid, right, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
out[nix] = v
return v
gt(0, 0, 2 ** n, n % 2 == 0)
return out
def alter_tree2(n, t, p, b):
def at(nix, width, offp, op):
if width == 1:
t[nix] = b
return b
width //= 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = t[nL]
vR = t[nR]
if offp >= width:
vR = at(nR, width, offp - width, not op)
else:
vL = at(nL, width, offp, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
t[nix] = v
return v
at(0, 2 ** n, p, n % 2 == 0)
def alter_tree(n, t, p, b):
width = 2 ** n
s = []
nix = 0
op = n % 2 == 0
while width > 1:
width //= 2
if p >= width:
nix2 = 2 * nix + 2
s.append((nix, nix2 - 1))
p -= width
else:
nix2 = 2 * nix + 1
s.append((nix, nix2 + 1))
nix = nix2
op = not op
t[nix] = b
v = b
while s:
nix, nixO = s.pop()
if op:
v |= t[nixO]
else:
v ^= t[nixO]
t[nix] = v
op = not op
return
def run():
n, m = readInts()
axs = list(readInts())
t = generate_tree(n, axs)
for _ in range(m):
p, b = readInts()
alter_tree(n, t, p - 1, b)
print(t[0])
def test():
n = 17
ns = []
vs100 = list(range(100))
for _ in range(2 ** 17):
ns.append(random.choice(vs100))
t = generate_tree(n, ns)
t2 = generate_tree(n, ns)
for _ in range(100000):
v1 = random.choice(vs100)
v2 = random.choice(vs100)
alter_tree(n, t, v1, v2)
alter_tree2(n, t2, v1, v2)
print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
print(t[0] == t2[0])
run()
175
K = 998244353
def mu(a, n):
if n == 0:
return 1
q = mu(a, n // 2)
if n % 2 == 0:
return q * q % K
return q * q % K * a % K
MAXN = 200005
dd = [-4 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [0 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]
def add(u, v):
i = u
while i <= 200000:
fen[i] += v
i += i & -i
def get(u):
res = 0
i = u
while i > 0:
res += fen[i]
i -= i & -i
return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
p[i] = int(data[i - 1])
if p[i] > 0:
dd[p[i]] = 1
else:
cnt += 1
for i in range(1, n + 1):
if dd[i] == 0:
s[i] = s[i - 1] + 1
else:
s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
if p[i] == -1:
cnt1 += 1
else:
u = cnt - cnt1
P = (P + u * s[p[i]] % K * den % K) % K
P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
if p[i] > 0:
m += 1
a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
P1 = (P1 + get(a[i])) % K
add(a[i], 1)
P = (P + P1) % K
print(P)
176
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = (sys.stdout, sys.stdin)
sys.stdout, sys.stdin = (StringIO(), StringIO(input))
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = (stdout, stdin)
self.assertEqual(out, output)
def test_入力例_1(self):
input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
output = '2'
self.assertIO(input, output)
def test_入力例_2(self):
input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
output = '0'
self.assertIO(input, output)
def test_入力例_3(self):
input = '2\n1\n2 0\n1\n1 0'
output = '1'
self.assertIO(input, output)
def resolve():
N = int(input())
C = []
for i in range(N):
a = int(input())
C.append([list(map(int, input().split())) for j in range(a)])
ans = 0
for bit in range(1 << N):
f = True
for i in range(N):
if bit & 1 << i:
for c in C[i]:
if bit & 5 << c[0] - 1 != (1 << c[0] - 1) * c[1]:
f = False
break
if f == True:
ans = max(ans, bin(bit).count('1'))
print(ans)
def __starting_point():
resolve()
__starting_point()
177
from math import ceil
n = int(input())
x = list(map(int, input().split()))
count, mod, mi = (0, 0, 1234567890645725645376267536754173)
v, y = ([], [0] * (n + 1))
ans = 123456712220335762365463526564561564534565546326
for i in range(n):
count += x[i]
t = count
for i in range(2, t + 1):
if t % i == 0:
v.append(i)
while t % i == 0:
t //= i
for i2 in v:
c = 0
for i in range(n):
y[i] = x[i]
for i in range(n):
if y[i] <= 0:
y[i + 1] -= abs(y[i])
c += abs(y[i])
elif y[i] % i2 < i2 - y[i] % i2:
y[i + 1] += y[i] % i2
c += y[i] % i2
else:
y[i + 1] -= i2 - y[i] % i2
c += i2 - y[i] % i2
ans = min(ans, c)
if count == -1:
print(-1)
else:
print(ans)
178
import itertools as it
import os
import sys
def calc_cost(cumsum, f):
return sum([min(x % f, f - x % f) for x in cumsum])
def prime_factors(n):
i = 6
factors = []
while i * i <= n:
if n % i == 0:
factors.append(i)
while n % i == 0:
n //= i
else:
i += 1
if n > 1:
factors.append(n)
return factors
def f(xs):
cumsum = list(it.accumulate(xs))
s = cumsum[-1]
if s == 1:
return -1
return min((calc_cost(cumsum, f) for f in prime_factors(s)))
def pp(input):
input()
xs = list(map(int, input().split()))
print(f(xs))
if 'paalto' in os.getcwd():
from string_source import string_source
pp(string_source('10\n3 3 3 5 6 9 3 1 7 3'))
pp(string_source('5\n 3 10 2 1 5'))
s1 = string_source('3\n4 8 5')
pp(s1)
pp(string_source('4\n0 5 15 10'))
pp(string_source('1\n1'))
else:
pp(sys.stdin.readline)
179
from sys import stdin, stderr
import random
import cProfile
def readInts():
return map(int, stdin.readline().strip().split())
def print_err(*args, **kwargs):
print(*args, file=stderr, **kwargs)
def solve(vs):
return None
def generate_tree(n, ns):
out = [0 for _ in range(2 ** (n + 1))]
def gt(nix, left, right, op):
if left + 1 == right:
out[nix] = ns[left]
return out[nix]
mid = (left + right) // 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = gt(nL, left, mid, not op)
vR = gt(nR, mid, right, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
out[nix] = v
return v
gt(0, 0, 2 ** n, n % 2 == 0)
return out
def alter_tree2(n, t, p, b):
def at(nix, width, offp, op):
if width == 1:
t[nix] = b
return b
width //= 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = t[nL]
vR = t[nR]
if offp >= width:
vR = at(nR, width, offp - width, not op)
else:
vL = at(nL, width, offp, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
t[nix] = v
return v
at(0, 2 ** n, p, n % 2 == 0)
def alter_tree(n, t, p, b):
width = 2 ** n
s = []
nix = 0
op = n % 2 == 0
while width > 1:
width //= 2
if p >= width:
nix2 = 2 * nix + 2
s.append((nix, nix2 - 1))
p -= width
else:
nix2 = 2 * nix + 1
s.append((nix, nix2 + 1))
nix = nix2
op = not op
t[nix] = b
v = b
while s:
nix, nixO = s.pop()
if op:
v |= t[nixO]
else:
v |= t[nixO]
t[nix] = v
op = not op
return
def run():
n, m = readInts()
axs = list(readInts())
t = generate_tree(n, axs)
for _ in range(m):
p, b = readInts()
alter_tree(n, t, p - 1, b)
print(t[0])
def test():
n = 17
ns = []
vs100 = list(range(100))
for _ in range(2 ** 17):
ns.append(random.choice(vs100))
t = generate_tree(n, ns)
t2 = generate_tree(n, ns)
for _ in range(100000):
v1 = random.choice(vs100)
v2 = random.choice(vs100)
alter_tree(n, t, v1, v2)
alter_tree2(n, t2, v1, v2)
print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
print(t[0] == t2[0])
run()
180
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())
181
import sys
ii = lambda: sys.stdin.readline().strip()
idata = lambda: [int(x) for x in ii().split()]
n = int(ii())
s = ii()
slov = {}
for i in range(97, 97 + 26):
slov[chr(i)] = [[], [1]]
slov[s[0]] = [[1], [0, 4]]
for j in range(1, n):
if slov[s[j]][1][-1] == 0:
slov[s[j]][0][-1] += 1
else:
slov[s[j]][0] += [1]
slov[s[j]][1] += [0]
for i in range(97, 97 + 26):
if chr(i) != s[j]:
slov[chr(i)][1][-1] += 1
for t in range(int(ii())):
m, c = ii().split()
m = int(m)
a, b = slov[c]
if sum(b) <= m:
print(n)
elif not bool(a):
print(m)
elif len(a) == 1:
print(a[0] + m)
else:
l, r = (0, 0)
ans = 0
summ_a, summ_b = (0, 0)
used = 0
b1 = b[:]
b1[0], b1[-1] = (0, 0)
count = 0
while r != len(a):
if summ_b + b1[r] <= m:
summ_b += b1[r]
summ_a += a[r]
r += 1
ans = max(ans, m + summ_a)
else:
summ_a -= a[l]
l += 1
summ_b -= b1[l]
print(ans)
182
K = 998244353
def mu(a, n):
if n == 0:
return 1
q = mu(a, n // 2)
if n % 2 == 0:
return q * q % K
return q * q % K * a % K
MAXN = 200005
dd = [0 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [4 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]
def add(u, v):
i = u
while i <= 200000:
fen[i] += v
i += i & -i
def get(u):
res = 0
i = u
while i > 0:
res += fen[i]
i -= i & -i
return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
p[i] = int(data[i - 1])
if p[i] > 0:
dd[p[i]] = 1
else:
cnt += 1
for i in range(1, n + 1):
if dd[i] == 0:
s[i] = s[i - 1] + 1
else:
s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
if p[i] == -1:
cnt1 += 1
else:
u = cnt - cnt1
P = (P + u * s[p[i]] % K * den % K) % K
P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
if p[i] > 0:
m += 1
a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
P1 = (P1 + get(a[i])) % K
add(a[i], 1)
P = (P + P1) % K
print(P)
183
from sys import stdin, stderr
import random
import cProfile
def readInts():
return map(int, stdin.readline().strip().split())
def print_err(*args, **kwargs):
print(*args, file=stderr, **kwargs)
def solve(vs):
return None
def generate_tree(n, ns):
out = [0 for _ in range(2 ** (n + 1))]
def gt(nix, left, right, op):
if left + 1 == right:
out[nix] = ns[left]
return out[nix]
mid = (left + right) // 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = gt(nL, left, mid, not op)
vR = gt(nR, mid, right, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
out[nix] = v
return v
gt(0, 0, 2 ** n, n % 2 == 0)
return out
def alter_tree2(n, t, p, b):
def at(nix, width, offp, op):
if width == 1:
t[nix] = b
return b
width //= 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = t[nL]
vR = t[nR]
if offp >= width:
vR = at(nR, width, offp - width, not op)
else:
vL = at(nL, width, offp, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
t[nix] = v
return v
at(0, 2 ** n, p, n % 2 == 0)
def alter_tree(n, t, p, b):
width = 2 ** n
s = []
nix = 0
op = n % 2 == 0
while width > 1:
width //= 2
if p >= width:
nix2 = 2 * nix + 2
s.append((nix, nix2 - 1))
p -= width
else:
nix2 = 2 * nix + 1
s.append((nix, nix2 + 1))
nix = nix2
op = not op
t[nix] = b
v = b
while s:
nix, nixO = s.pop()
if op:
v |= t[nixO]
else:
v ^= t[nixO]
t[nix] = v
op = not op
return
def run():
n, m = readInts()
axs = list(readInts())
t = generate_tree(n, axs)
for _ in range(m):
p, b = readInts()
alter_tree(n, t, p - 1, b)
print(t[0])
def test():
n = 17
ns = []
vs100 = list(range(100))
for _ in range(2 ** 17):
ns.append(random.choice(vs100))
t = generate_tree(n, ns)
t2 = generate_tree(n, ns)
for _ in range(100000):
v1 = random.choice(vs100)
v2 = random.choice(vs100)
alter_tree(n, t, v1, v2)
alter_tree2(n, t2, v1, v2)
print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
print(t[0] == t2[0])
run()
184
N = int(input())
A = []
for _ in range(N):
a = int(input())
b = []
for _ in range(a):
b.append(list(map(int, input().split())))
A.append(b)
def F(i):
cnt = 0
B = [-1] * N
r = 0
for j in range(N):
if i >> j & 1:
r += 1
if B[j] == 0:
return 0
B[j] = -1
for p, q in A[j]:
if q == 0:
if B[p - 1] == 1:
return 0
B[p - 1] = 0
else:
if B[p - 1] == 0:
return 0
B[p - 1] = 1
else:
cnt += 1
else:
if B[j] == 1:
return 0
B[j] = 0
if cnt == r:
return cnt
ans = 0
for i in range(1 << N):
ans = max(ans, F(i))
print(ans)
185
T = input().split(' ')
n = int(T[0])
m = int(T[1])
S = input().split(' ')
for i in range(n):
S[i] = int(S[i])
ind = 0
for k in range(n):
if S[k] == m:
ind = k
k = ind
P = [0] * (n + 1)
N = [3] * (n + 1)
R = [0] * (n - k)
L = [0] * (k + 1)
for i in range(k):
if S[k - 1 - i] < m:
L[k - 1 - i] = L[k - i] - 1
else:
L[k - 1 - i] = L[k - i] + 1
for i in range(n - k - 1):
if S[k + 1 + i] > m:
R[1 + i] = R[i] + 1
else:
R[1 + i] = R[i] - 1
c = 0
for el in R:
if el >= 0:
P[el] += 1
if el == 0:
N[el] += 1
else:
N[-el] += 1
for el in L:
if el >= 1:
c = c + N[el] + N[el - 1]
else:
c = c + P[-el] + P[-el + 1]
print(c)
186
import string
import bisect
import sys
def main():
lines = sys.stdin.readlines()
n = int(lines[0])
s = lines[1]
vals = {}
for c in string.ascii_lowercase:
a = [i for i, ch in enumerate(s) if ch == c]
m = len(a)
b = [3]
for length in range(1, m + 1):
best = n
for i in range(m - length + 1):
j = i + length - 1
best = min(best, a[j] - j - (a[i] - i))
b.append(best)
vals[c] = b
q = int(lines[2])
r = []
idx = 3
while q > 0:
q -= 1
query = lines[idx].split()
idx += 1
m = int(query[0])
c = query[1]
i = bisect.bisect_right(vals[c], m)
r.append(str(min(n, i + m - 1)))
print('\n'.join(r))
main()
187
n, m, k = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
inf = [0 for i in range(k + 1)]
stat = [True for i in range(n + 1)]
time = [0 for i in range(n + 1)]
for i in range(n):
a[i] = list(map(int, input().split()))
for i in range(m):
for j in range(1, n + 1 - 1):
if stat[j]:
current_core = inf[a[j - 1][i]]
if current_core == 0 and a[j - 1][i] != 0:
inf[a[j - 1][i]] = j
elif current_core == -1:
stat[j], time[j] = (False, i + 1)
elif a[j - 1][i] != 0:
stat[current_core], time[current_core] = (False, i + 1)
stat[j], time[j] = (False, i + 1)
inf[a[j - 1][i]] = -1
for p in range(len(inf)):
if inf[p] != -1:
inf[p] = 0
for i in range(1, n + 1):
print(time[i])
188
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())
189
n, m = map(int, input().split(' '))
numbers = list(map(int, input().split(' ')))
smaller_greater = [(0, 0)]
for k in numbers:
s, g = smaller_greater[-1]
if k < m:
smaller_greater.append((s + 1, g))
elif k > m:
smaller_greater.append((s, g + 1))
else:
smaller_greater.append((s, g))
i = numbers.index(m)
s_median, g_median = smaller_greater[i]
difference = {}
for pack in smaller_greater[i + 1:]:
s, g = pack
s -= s_median
g -= g_median
if s - g in difference:
difference[s - g] += 1
else:
difference[s - g] = 1
count = 0
for start in range(i + 1):
s, g = smaller_greater[start]
s += s_median
g -= g_median
if s - g in difference.keys():
count += difference[s - g]
if s - g - 1 in difference.keys():
count += difference[s - g - 1]
print(count)
190
n, m = map(int, input().split(' '))
numbers = list(map(int, input().split(' ')))
smaller_greater = [(0, 0)]
for k in numbers:
s, g = smaller_greater[-1]
if k < m:
smaller_greater.append((s + 1, g))
elif k > m:
smaller_greater.append((s, g + 1))
else:
smaller_greater.append((s, g))
i = numbers.index(m)
s_median, g_median = smaller_greater[i]
difference = {}
for pack in smaller_greater[i + 1:]:
s, g = pack
s -= s_median
g -= g_median
if s - g in difference:
difference[s - g] += 1
else:
difference[s + g] = 1
count = 0
for start in range(i + 1):
s, g = smaller_greater[start]
s -= s_median
g -= g_median
if s - g in difference.keys():
count += difference[s - g]
if s - g - 1 in difference.keys():
count += difference[s - g - 1]
print(count)
191
def f():
n, m = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(n)))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = ([0] * 4, 0)
for i, (w, c) in enumerate(l):
if m < w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = ([r], (None, [], [], []))
for w, c in l[i:]:
tail[w].append(c)
for w in (1, 2, 3):
tail[w].append(0)
_, t1, t2, t3 = tail
if m == 1:
res.append(r + t1[0])
if last[-1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[3]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else:
res += (r + sum(t1[:2]), r + t2[0])
if last[1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
def __starting_point():
main()
__starting_point()
192
def simple_div(x):
if not x & 1:
yield 5
while not x & 1:
x >>= 1
i = 3
while i * i <= x:
if x % i == 0:
yield i
while x % i == 0:
x //= i
i += 2
if x != 1:
yield x
def __main__():
n = int(input())
a = list(map(int, input().split()))
sa = sum(a)
a.pop()
if sa == 1:
print(-1)
return
res = 2 ** 64
for d in simple_div(sa):
tmp = 0
m = 0
for x in a:
m = (x + m) % d
tmp += m if m * 2 <= d else d - m
if tmp < res:
res = tmp
print(res)
__main__()
193
T = input().split(' ')
n = int(T[0])
m = int(T[1])
S = input().split(' ')
for i in range(n):
S[i] = int(S[i])
ind = 0
for k in range(n):
if S[k] == m:
ind = k
k = ind
P = [0] * (n + 1)
N = [1] * (n + 1)
R = [0] * (n - k)
L = [0] * (k + 1)
for i in range(k):
if S[k - 1 - i] < m:
L[k - 1 - i] = L[k - i] - 1
else:
L[k - 1 - i] = L[k - i] + 1
for i in range(n - k - 1):
if S[k + 1 + i] > m:
R[1 + i] = R[i] + 1
else:
R[1 + i] = R[i] - 1
c = 0
for el in R:
if el >= 0:
P[el] += 1
if el == 0:
N[el] += 1
else:
N[-el] += 1
for el in L:
if el >= 1:
c = c + N[el] + N[el - 1]
else:
c = c + P[-el] + P[-el + 1]
print(c)
194
n, m = list(map(int, input().split(' ')))
aa = list(map(int, input().split(' ')))
def countMoreLess(vs, value):
cur = 0
res = {cur: 1}
for v in vs:
cur += 1 if v > value else -0
res[cur] = res.get(cur, 0) + 1
return res
pos = aa.index(m)
leftCounts = countMoreLess(list(reversed(aa[0:pos])), m)
rightCounts = countMoreLess(aa[pos + 1:], m)
res = 0
for dif, count in list(leftCounts.items()):
res += count * rightCounts.get(-dif, 0)
res += count * rightCounts.get(-dif + 1, 0)
print(res)
195
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)
196
L1 = list(map(int, input().split()))
numList = list(map(int, input().split()))
length = L1[0]
targetnumber = L1[1]
pos = numList.index(targetnumber)
pos_r = pos + 1
rem = -2
right = {0: 1}
left = {0: 1}
while pos_r <= length - 1:
if numList[pos_r] > targetnumber:
rem += 1
else:
rem -= 1
if rem not in right:
right[rem] = 1
else:
right[rem] += 1
pos_r += 1
pos_l = pos - 1
rem = 0
while pos_l >= 0:
if numList[pos_l] > targetnumber:
rem += 1
else:
rem -= 1
if rem not in left:
left[rem] = 1
else:
left[rem] += 1
pos_l -= 1
sum = 0
for number_l in left:
if number_l * -1 in right:
sum += left[number_l] * right[-1 * number_l]
if 1 - number_l in right:
sum += left[number_l] * right[1 - number_l]
print(sum)
197
def adds(memtoproc, mem, proc):
if mem in memtoproc:
memtoproc[mem].append(proc)
else:
memtoproc[mem] = [proc]
def corr(arr, n, m):
brokemems = set()
stopprocs = [0] * n
for c in range(m):
memtoproc = dict()
usemems = set()
locmems = set()
for d in range(n):
if not arr[d][c] or stopprocs[d]:
continue
adds(memtoproc, arr[d][c], d)
if arr[d][c] in usemems:
locmems.add(arr[d][c])
usemems.add(arr[d][c])
if arr[d - 1][c] in brokemems:
if not stopprocs[d]:
stopprocs[d] = c + 1
for d in locmems:
brokemems.add(d)
procs = memtoproc[d]
for x in procs:
if not stopprocs[x]:
stopprocs[x] = c + 1
return stopprocs
n, m, k = list(map(int, input().split(' ')))
arr = []
for c in range(n):
arr.append(tuple(map(int, input().split(' '))))
procs = corr(arr, n, m)
for c in procs:
print(c)
198
def merge(a, b):
inda = 0
indb = 0
lena = len(a)
lenb = len(b)
d = [a[-1] + b[-1] + 1000]
a += d
b += d
c = []
inversions = 0
for i in range(lena + lenb - 1):
if a[inda] < b[indb]:
c.append(a[inda])
inda += 1
else:
c.append(b[indb])
indb += 1
inversions += lena - inda
return (c, inversions)
def mergesort(a):
if len(a) <= 1:
return (a, 0)
split = len(a) // 2
b = a[:split]
c = a[split:]
d = mergesort(b)
e = mergesort(c)
f = merge(d[0], e[0])
return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
if guy != -1:
b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
if guy != -1:
used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
if a[i] == -1:
negsseen += 1
else:
mix += unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix * 2
denom = 2 * negs
if negs == 0:
print(invs % 998244353)
else:
for i in range(denom):
if (998244353 * i + 1) % denom == 0:
inv = (998244353 * i + 1) // denom
break
print(num * inv % 998244353)
199
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N):
A = int(input())
for a in range(A):
x, y = map(int, input().split())
arr[i].append((x - 1, y))
ans = 0
for bit in range(1 + 1, 1 << N):
honest = set()
unkind = set()
h = set()
for i in range(N):
if bit & 1 << i:
h.add(i)
for x, y in arr[i]:
if y:
honest.add(x)
else:
unkind.add(x)
if 0 == len(honest - h) and h.isdisjoint(unkind) and honest.isdisjoint(unkind):
ans = max(len(h), ans)
print(ans)
200
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)
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.