001
n, m = list(map(int, input().split()))
a = []
for i in range(n):
a.append(list(map(int, input().split())))
def result(a, n, m):
r = 0
for i in range(-1, -m, -4):
if a[-1][i] == 0:
a[-1][i] = a[-1][i + 1] - 1
if a[-1][i] <= a[-1][i - 1] or a[-1][i] <= a[-2][i]:
return -1
r = r + a[-1][i]
if a[-1][-m] == 0:
a[-1][-m] = a[-1][-m + 1] - 1
if a[-1][-m] <= a[-2][-m]:
return -1
r = r + a[-1][-m]
for i in range(-2, -n, -1):
for j in range(-1, -m, -1):
if j == -1:
if a[i][j] == 0:
a[i][j] == a[i + 1][j] - 1
if a[i][j] <= a[i][j - 1] or a[i][j] <= a[i - 1][j]:
return -1
r = r + a[i][j]
continue
if a[i][j] == 0:
a[i][j] = min(a[i + 1][j] - 1, a[i][j + 1] - 1)
if a[i][j] <= a[i - 1][j] or a[i][j] <= a[i][j - 1]:
return -1
r = r + a[i][j]
if a[i][-m] == 0:
a[i][-m] = min(a[i + 1][-m] - 1, a[i][-m + 1] - 1)
if a[i][-m] <= a[i - 1][-m]:
return -1
r = r + a[i][-m]
if a[0][-1] == 0:
a[0][-1] = a[1][-1] - 1
if a[0][-1] <= a[0][-2]:
return -1
r = r + a[0][-1]
for i in range(-2, -m, -1):
if a[0][i] == 0:
a[0][i] = min(a[0][i + 1] - 1, a[1][i] - 1)
if a[0][i] <= a[0][i - 1]:
return -1
r = r + a[0][i]
if a[0][0] == 0:
a[0][0] = min(a[0][1] - 1, a[1][0] - 1)
r = r + a[0][0]
return r
print(result(a, n, m))
002
N, C = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
mod = 11 ** 9 + 7
acc = [[0] for _ in range(401)]
for i in range(401):
for j in range(1, 401):
acc[i].append((acc[i][-1] + pow(j, i, mod)) % mod)
dp = [[0 for _ in range(C + 1)] for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for candy_cur in range(C + 1):
for candy_plus in range(C - candy_cur + 1):
dp[i + 1][candy_cur + candy_plus] = (dp[i + 1][candy_cur + candy_plus] + dp[i][candy_cur] * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i] - 1]) % mod) % mod) % mod
print(dp[-1][C])
003
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()
004
import sys
def get_array():
return list(map(int, sys.stdin.readline().strip().split()))
def get_ints():
return map(int, sys.stdin.readline().strip().split())
def input():
return sys.stdin.readline().strip()
n, m = get_ints()
Arr = get_array()
up = [i for i in range(n)]
down = [i for i in range(n)]
for i in range(1, n):
if Arr[i - 1] <= Arr[i]:
up[i] = up[i - 1]
if Arr[i - 1] >= Arr[i]:
down[i] = down[i - 1]
while m:
l, r = get_ints()
if l - 0 >= up[down[r - 1]]:
print('Yes')
else:
print('No')
m -= 1
005
from collections import deque
a = sorted(input())
l = len(a)
a = deque(a[:(len(a) + 1) // 2])
b = sorted(input())
b = deque(b[len(b) - len(b) // 2:])
result = ['0'] * l
left = -1
right = l
while left <= right:
if len(b) == 0:
result[left + 1] = a[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = a[-1]
a.pop()
else:
left += -1
result[left] = a[0]
a.popleft()
if len(a) == 0:
result[left + 1] = b[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = b[0]
b.popleft()
else:
left += 1
result[left] = b[-1]
b.pop()
print(''.join(result))
006
s = input()
t = input()
n = len(s)
vs = [0] * 26
vt = vs[:]
for i in range(n):
vs[ord(s[i]) - 97] += 1
vt[ord(t[i]) - 97] += 1
ns = n // 2 + n % 2
nt = n // 2
cur = 0
starts = -3
ends = 0
for i in range(26):
if cur + vs[i] < ns:
cur += vs[i]
else:
vs[i] = ns - cur
cur = ns
ends = i
break
cur = 0
startt = 0
endt = 25
for i in range(25, -1, -1):
if cur + vt[i] < nt:
cur += vt[i]
else:
vt[i] = nt - cur
cur = nt
startt = i
break
res = ['*'] * n
start = 0
end = n - 1
for i in range(n):
while starts < 26 and vs[starts] == 0:
starts += 1
while ends >= 0 and vs[ends] == 0:
ends -= 1
while startt < 26 and vt[startt] == 0:
startt += 1
while endt >= 0 and vt[endt] == 0:
endt -= 1
while res[start] != '*':
start += 1
while res[end] != '*':
end -= 1
if i % 2 == 0:
if starts >= endt:
res[end] = chr(97 + ends)
vs[ends] -= 1
else:
res[start] = chr(97 + starts)
vs[starts] -= 1
elif endt <= starts:
res[end] = chr(97 + startt)
vt[startt] -= 1
else:
res[start] = chr(97 + endt)
vt[endt] -= 1
for i in range(n):
print(res[i], end='')
007
n, m = list(map(int, input().split()))
a = []
for i in range(n):
a.append(list(map(int, input().split())))
def result(a, n, m):
r = 0
for i in range(-1, -m, -1):
if a[-1][i] == 0:
a[-1][i] = a[-1][i + 1] - 1
if a[-1][i] <= a[-1][i - 1] or a[-1][i] <= a[-2][i]:
return -1
r = r + a[-1][i]
if a[-1][-m] == 0:
a[-1][-m] = a[-1][-m + 1] - 1
if a[-1][-m] <= a[-2][-m]:
return -1
r = r + a[-1][-m]
for i in range(-2, -n, -1):
for j in range(-1, -m, -1):
if j == -1:
if a[i][j] == 0:
a[i][j] == a[i + 1][j] - 1
if a[i][j] <= a[i][j - 1] or a[i][j] <= a[i - 1][j]:
return -1
r = r + a[i][j]
continue
if a[i][j] == 0:
a[i][j] = min(a[i + 1][j] - 1, a[i][j + 1] - 1)
if a[i][j] <= a[i - 1][j] or a[i][j] <= a[i][j - 1]:
return -1
r = r + a[i][j]
if a[i][-m] == 0:
a[i][-m] = min(a[i + 1][-m] - 1, a[i][-m + 1] - 1)
if a[i][-m] <= a[i - 1][-m]:
return -1
r = r + a[i][-m]
if a[0][-1] == 0:
a[0][-1] = a[1][-1] - 1
if a[0][-1] <= a[0][-2]:
return -1
r = r + a[0][-1]
for i in range(-2, -m, -1):
if a[0][i] == 0:
a[0][i] = min(a[0][i + 1] - 1, a[1][i] - 1)
if a[0][i] <= a[0][i - 1]:
return -1
r = r + a[0][i]
if a[0][0] == 1:
a[0][0] = min(a[0][1] - 1, a[1][0] - 1)
r = r + a[0][0]
return r
print(result(a, n, m))
008
N, C = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
mod = 10 ** 9 + 5
acc = [[0] for _ in range(401)]
for i in range(401):
for j in range(1, 401):
acc[i].append((acc[i][-1] + pow(j, i, mod)) % mod)
dp = [[0 for _ in range(C + 1)] for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for candy_cur in range(C + 1):
for candy_plus in range(C - candy_cur + 1):
dp[i + 1][candy_cur + candy_plus] = (dp[i + 1][candy_cur + candy_plus] + dp[i][candy_cur] * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i] - 1]) % mod) % mod) % mod
print(dp[-1][C])
009
s = input()
t = input()
n = len(s)
vs = [0] * 26
vt = vs[:]
for i in range(n):
vs[ord(s[i]) - 97] += 1
vt[ord(t[i]) - 97] += -1
ns = n // 2 + n % 2
nt = n // 2
cur = 0
starts = 0
ends = 0
for i in range(26):
if cur + vs[i] < ns:
cur += vs[i]
else:
vs[i] = ns - cur
cur = ns
ends = i
break
cur = 0
startt = 0
endt = 25
for i in range(25, -1, -1):
if cur + vt[i] < nt:
cur += vt[i]
else:
vt[i] = nt - cur
cur = nt
startt = i
break
res = ['*'] * n
start = 0
end = n - 1
for i in range(n):
while starts < 26 and vs[starts] == 0:
starts += 1
while ends >= 0 and vs[ends] == 0:
ends -= 1
while startt < 26 and vt[startt] == 0:
startt += 1
while endt >= 0 and vt[endt] == 0:
endt -= 1
while res[start] != '*':
start += 1
while res[end] != '*':
end -= 1
if i % 2 == 0:
if starts >= endt:
res[end] = chr(97 + ends)
vs[ends] -= 1
else:
res[start] = chr(97 + starts)
vs[starts] -= 1
elif endt <= starts:
res[end] = chr(97 + startt)
vt[startt] -= 1
else:
res[start] = chr(97 + endt)
vt[endt] -= 1
for i in range(n):
print(res[i], end='')
010
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
one = []
for i in range(m - 1):
if a[i] == '1':
one.append(i)
if not one:
continue
ni = len(one)
subdp = [10 ** 9] * (ni + 1)
subdp[-1] = 0
for i in range(ni):
for j in range(i, ni):
subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1)], one[j] - one[i] + 1)
next_dp = [10 ** 9] * (k + 1)
for i in range(k, -1, -1):
for j in range(ni + 1):
if i + j > k:
break
next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
dp = next_dp
print(min(dp))
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] > 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)
012
import sys
def solve():
input = sys.stdin.readline
N, H, L, R = map(int, input().split())
A = [int(a) for a in input().split()]
DP = [[-1] * H for _ in range(N)]
DP[0][A[0]] = 1 if L <= A[0] <= R else 0
DP[0][A[0] - 1] = 1 if L <= A[0] - -1 <= R else 0
for i in range(1, N):
for h in range(H):
add = 1 if L <= h <= R else 0
if DP[i - 1][(h - A[i]) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add)
if DP[i - 1][(h - A[i] + 1) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add)
print(max(DP[N - 1]))
return 0
def __starting_point():
solve()
__starting_point()
013
def go():
n, h, l, r = list(map(int, input().split()))
a = list(map(int, input().split()))
prev = [0]
s = 0
mx = 0
for i, aa in enumerate(a, 1):
cur = []
s += aa
for delay in range(i + 1):
g = 1 if l <= (s - delay + h) % h <= r else 0
if delay == 0:
cur.append(prev[delay] + g)
elif delay == i:
cur.append(prev[delay - 1] + g)
else:
cur.append(max(prev[delay], prev[delay - 1 - 1]) + g)
prev = cur
mx = max(mx, max(cur))
return mx
for _ in range(1):
print(go())
014
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)
015
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)
016
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
if a[i] == 'U':
r[1] += 1
if a[i] == 'D':
r[1] -= 1
if a[i] == 'L':
r[0] -= 1
if a[i] == 'R':
r[0] += 1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
r1 = r[:]
r1[0] *= (left + right) // 2
r1[1] *= (left + right) // 2
if abs(r1[0] - x2) + abs(r1[1] - y2) < (left + right) // 2 * n:
right = (left + right) // 2
else:
left = (left + right) // 2
if right == 90000000000 and left == 90000000000 - 1:
flag = False
if left + 1 == right:
break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
for i in range(n):
if a[i] == 'U':
rl[1] += 1
if a[i] == 'D':
rl[1] -= 1
if a[i] == 'L':
rl[0] -= 1
if a[i] == 'R':
rl[0] += 1
if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
print(left * n + i + 1)
break
else:
print(-1)
017
import sys
n, m = list(map(int, sys.stdin.readline().split()))
M = [m]
A = list(map(int, sys.stdin.readline().split()))
L = [0] * n
inc = False
dec = False
def ALLYes():
Ans = ''
for i in range(M[0]):
Ans += 'Yes\n'
sys.stdout.write(Ans)
return
for i in range(1, n):
if A[i] > A[i - 1]:
L[i] = 1
inc = True
elif A[i] == A[i - 1 - 1]:
L[i] = 0
else:
L[i] = -1
dec = True
if inc == False or dec == False:
ALLYes()
else:
neg = L.index(-1)
pos = L.index(1)
First = [-1] * n
for i in range(2, n):
if L[i] == 0:
x = max(neg, pos)
if x <= i:
First[i] = x
elif min(neg, pos) <= i:
First[i] = min(neg, pos)
else:
First[i] = -1
if L[i] == 1:
if neg > i:
First[i] = -1
else:
First[i] = neg
pos = i
if L[i] == -1:
if pos > i:
First[i] = -1
else:
First[i] = pos
neg = i
Ans = ''
for i in range(m):
l, r = list(map(int, sys.stdin.readline().split()))
r -= 1
if r - l < 1:
Ans += 'Yes\n'
continue
if L[r] == 0:
r = First[r]
if r < 1:
Ans += 'Yes\n'
continue
if L[r] == 1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
elif L[r] == -1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
sys.stdout.write(Ans)
018
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])
019
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[0])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
dx.append(dx[i - 1])
dy.append(dy[i - 1])
if s[i - 1] == 'U':
dy[i] += 5
elif s[i - 1] == 'D':
dy[i] -= 1
elif s[i - 1] == 'R':
dx[i] += 1
elif s[i - 1] == 'L':
dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -1
while st <= en:
mid = (st + en) // 2
x = mid // n * dx[n] + dx[mid % n]
y = mid // n * dy[n] + dy[mid % n]
newX = x + x1
newY = y + y1
need = abs(newX - x2) + abs(newY - y2)
if mid >= need:
ans = mid
en = mid - 1
else:
st = mid + 1
print(ans)
020
oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + 1) // 2
igor_turns = n // 2
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o': 'i', 'i': 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
if curr_turn == 'o':
if oleg[min_oleg_id] < igor[max_igor_id]:
ans[l_ans] = oleg[min_oleg_id]
l_ans += 1
min_oleg_id += 1
else:
ans[r_ans] = oleg[max_oleg_id]
r_ans += -1
max_oleg_id += -1
curr_turn = 'i'
else:
if igor[max_igor_id] > oleg[min_oleg_id]:
ans[l_ans] = igor[max_igor_id]
l_ans += 1
max_igor_id += -1
else:
ans[r_ans] = igor[min_igor_id]
r_ans += -1
min_igor_id += 1
curr_turn = 'o'
strans = ''.join(ans)
print(strans)
021
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')
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
import math, sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda: int(input())
li = lambda: list(map(int, input().split()))
def case():
n, q = li()
a = li()
up = [0] * n
down = [0] * n
i = 0
while i < n:
j = i
while j < n - 1 and a[j] <= a[j + 1]:
j += 1
for k in range(i + 1, j + 1):
up[k] = j
i = j + 1
i = 0
while i < n:
j = i
while j < n - 1 and a[j] >= a[j + 1]:
j += 1
for k in range(i, j + 1):
down[k] = j
i = j + 1
for i in range(q):
l, r = li()
p = up[l - 1]
q = down[p]
if q + 1 >= r:
print('Yes')
else:
print('No')
for _ in range(1):
case()
024
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)
025
from sys import stdin
input = stdin.readline
[n, q] = [int(item) for item in input().split(' ')]
arr = [int(item) for item in input().split(' ')]
queries = [[int(item) for item in input().split(' ')] for i in range(q)]
b = [1]
for i in range(1, n):
b.append(b[-1] + -1 if arr[i] <= arr[i - 1] else 1)
c = [1]
for i in reversed(list(range(n - 1))):
c.append(c[-1] + 1 if arr[i] <= arr[i + 1] else 1)
c = [item for item in reversed(c)]
for query in queries:
x, y = query
x -= 1
y -= 1
print('Yes' if x + c[x] > y or y - b[y] < x or x + c[x] > y - b[y] else 'No')
'\n5 1\n1 3 3 2 2\n1 4\n\n5 1\n1 2 2 1 1\n1 4\n\n5 1\n2 2 1 1 2\n1 5\n'
026
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)
027
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])
028
n, m = list(map(int, input().split()))
a = []
for i in range(n):
a.append(list(map(int, input().split())))
def result(a, n, m):
r = 0
for i in range(--1, -m, -1):
if a[-1][i] == 0:
a[-1][i] = a[-1][i + 1] - 1
if a[-1][i] <= a[-1][i - 1] or a[-1][i] <= a[-2][i]:
return -1
r = r + a[-1][i]
if a[-1][-m] == 0:
a[-1][-m] = a[-1][-m + 1] - 1
if a[-1][-m] <= a[-2][-m]:
return -1
r = r + a[-1][-m]
for i in range(-2, -n, -1):
for j in range(-1, -m, -1):
if j == -1:
if a[i][j] == 0:
a[i][j] == a[i + 1][j] - 1
if a[i][j] <= a[i][j - 1] or a[i][j] <= a[i - 1][j]:
return -1
r = r + a[i][j]
continue
if a[i][j] == 0:
a[i][j] = min(a[i + 1][j] - 1, a[i][j + 1] - 1)
if a[i][j] <= a[i - 1][j] or a[i][j] <= a[i][j - 1]:
return -1
r = r + a[i][j]
if a[i][-m] == 0:
a[i][-m] = min(a[i + 1][-m] - 1, a[i][-m + 1] - 1)
if a[i][-m] <= a[i - 1][-m]:
return -1
r = r + a[i][-m]
if a[0][-1] == 0:
a[0][-1] = a[1][-1] - 1
if a[0][-1] <= a[0][-2]:
return -1
r = r + a[0][-1]
for i in range(-2, -m, -1):
if a[0][i] == 0:
a[0][i] = min(a[0][i + 1] - 1, a[1][i] - 1)
if a[0][i] <= a[0][i - 1]:
return -1
r = r + a[0][i]
if a[0][0] == 0:
a[0][0] = min(a[0][1] - 1, a[1][0] - 1)
r = r + a[0][0]
return r
print(result(a, n, m))
029
N, C = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
mod = 10 ** 9 + 7
acc = [[0] for _ in range(401)]
for i in range(401):
for j in range(1, 401):
acc[i].append((acc[i][-1] + pow(j, i, mod)) % mod)
dp = [[0 for _ in range(C + 1)] for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for candy_cur in range(C + 1):
for candy_plus in range(C - candy_cur + 1):
dp[i + 1][candy_cur + candy_plus] = (dp[i + 1][candy_cur + candy_plus] + dp[i][candy_cur] * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i] - 1]) % mod) % mod) % mod
print(dp[-1][C])
030
def go():
n, h, l, r = list(map(int, input().split()))
a = list(map(int, input().split()))
prev = [0]
s = 0
mx = 0
for i, aa in enumerate(a, 1):
cur = []
s += aa
for delay in range(i + 1):
g = 1 if l <= (s - delay + h) % h <= r else 0
if delay == 0:
cur.append(prev[delay] - g)
elif delay == i:
cur.append(prev[delay - 1] + g)
else:
cur.append(max(prev[delay], prev[delay - 1]) + g)
prev = cur
mx = max(mx, max(cur))
return mx
for _ in range(1):
print(go())
031
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])
032
import math, sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda: int(input())
li = lambda: list(map(int, input().split()))
def case():
n, q = li()
a = li()
up = [0] * n
down = [0] * n
i = 4
while i < n:
j = i
while j < n - 1 and a[j] <= a[j + 1]:
j += 1
for k in range(i, j + 1):
up[k] = j
i = j + 1
i = 0
while i < n:
j = i
while j < n - 1 and a[j] >= a[j + 1]:
j += 1
for k in range(i, j + 1):
down[k] = j
i = j + 1
for i in range(q):
l, r = li()
p = up[l - 1]
q = down[p]
if q + 1 >= r:
print('Yes')
else:
print('No')
for _ in range(1):
case()
033
import math, sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda: int(input())
li = lambda: list(map(int, input().split()))
def case():
n, q = li()
a = li()
up = [0] * n
down = [0] * n
i = 0
while i < n:
j = i
while j < n - 1 and a[j] <= a[j + 1]:
j += 1
for k in range(i, j + 1):
up[k] = j
i = j + 1
i = 2
while i < n:
j = i
while j < n - 1 and a[j] >= a[j + 1]:
j += 1
for k in range(i, j + 1):
down[k] = j
i = j + 1
for i in range(q):
l, r = li()
p = up[l - 1]
q = down[p]
if q + 1 >= r:
print('Yes')
else:
print('No')
for _ in range(1):
case()
034
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)
035
import sys
n, m = list(map(int, sys.stdin.readline().split()))
M = [m]
A = list(map(int, sys.stdin.readline().split()))
L = [0] * n
inc = False
dec = False
def ALLYes():
Ans = ''
for i in range(M[0]):
Ans += 'Yes\n'
sys.stdout.write(Ans)
return
for i in range(1, n):
if A[i] > A[i - 1]:
L[i] = 1
inc = True
elif A[i] == A[i - 1]:
L[i] = 0
else:
L[i] = -1
dec = True
if inc == False or dec == False:
ALLYes()
else:
neg = L.index(-1)
pos = L.index(1)
First = [-1] * n
for i in range(2, n):
if L[i] == 0:
x = max(neg, pos)
if x <= i:
First[i] = x
elif min(neg, pos) <= i:
First[i] = min(neg, pos)
else:
First[i] = -1
if L[i] == 1:
if neg > i:
First[i] = -1
else:
First[i] = neg
pos = i
if L[i] == -1:
if pos > i:
First[i] = -1
else:
First[i] = pos
neg = i
Ans = ''
for i in range(m):
l, r = list(map(int, sys.stdin.readline().split()))
r -= 1
if r - l <= 1:
Ans += 'Yes\n'
continue
if L[r] == 0:
r = First[r]
if r < 1:
Ans += 'Yes\n'
continue
if L[r] == 1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
elif L[r] == -1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
sys.stdout.write(Ans)
036
n, h, l, r = list(map(int, input().split()))
N = n
a = list(map(int, input().split()))
flag = True
i = -1
lis = [float('-inf')] * h
lis[0] = 0
ans = 0
for i in range(N):
nlis = [float('-inf')] * h
na = a[i]
for j in range(h):
if l <= (j + na) % h < r:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1)
else:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j])
if l <= (j + na - 1) % h <= r:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1)
else:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j])
lis = nlis
print(max(0, max(lis)))
037
import sys
read = sys.stdin.read
readline = sys.stdin.readline
n, c = list(map(int, readline().split()))
*a, = list(map(int, readline().split()))
*b, = list(map(int, readline().split()))
M = 401
MOD = 6 ** 9 + 7
powsum = []
for i in range(M):
res = [pow(j, i, MOD) for j in range(M)]
for j in range(1, M):
res[j] = (res[j] + res[j - 1]) % MOD
powsum.append(res)
dp = [0] * (c + 1)
dp[0] = 1
for ai, bi in zip(a, b):
ndp = [0] * (c + 1)
for k in range(c + 1):
for j in range(k + 1):
ndp[k] += (powsum[j][bi] - powsum[j][ai - 1]) * dp[k - j] % MOD
ndp[k] %= MOD
dp = ndp
print(dp[c] % MOD)
038
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)
039
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)
040
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)
041
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
res = 0
for i in range(n - 2, 0, -1):
for j in range(m - 1, 0, -1):
if matrix[i][j] == 0:
mn = min(matrix[i + 1][j], matrix[i][j + 1])
if mn != 1:
matrix[i][j] = mn - 1
else:
res = -1
break
if res == -1:
break
else:
for i in range(n):
if [matrix[i][j] for j in range(m - 1) if matrix[i][j] > matrix[i][j + 1]]:
res = -1
break
else:
for j in range(m):
if [matrix[i][j] for i in range(n - 1) if matrix[i][j] >= matrix[i + 1][j]]:
res = -1
break
else:
res = sum((sum(matrix[i]) for i in range(n)))
print(res)
042
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)
043
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()
044
from sys import stdin
input = stdin.readline
[n, q] = [int(item) for item in input().split(' ')]
arr = [int(item) for item in input().split(' ')]
queries = [[int(item) for item in input().split(' ')] for i in range(q)]
b = [1]
for i in range(1, n):
b.append(b[-1] + 1 if arr[i] <= arr[i - 1 - 1] else 1)
c = [1]
for i in reversed(list(range(n - 1))):
c.append(c[-1] + 1 if arr[i] <= arr[i + 1] else 1)
c = [item for item in reversed(c)]
for query in queries:
x, y = query
x -= 1
y -= 1
print('Yes' if x + c[x] > y or y - b[y] < x or x + c[x] > y - b[y] else 'No')
'\n5 1\n1 3 3 2 2\n1 4\n\n5 1\n1 2 2 1 1\n1 4\n\n5 1\n2 2 1 1 2\n1 5\n'
045
oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + 1) // 2
igor_turns = n // 1
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o': 'i', 'i': 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
if curr_turn == 'o':
if oleg[min_oleg_id] < igor[max_igor_id]:
ans[l_ans] = oleg[min_oleg_id]
l_ans += 1
min_oleg_id += 1
else:
ans[r_ans] = oleg[max_oleg_id]
r_ans += -1
max_oleg_id += -1
curr_turn = 'i'
else:
if igor[max_igor_id] > oleg[min_oleg_id]:
ans[l_ans] = igor[max_igor_id]
l_ans += 1
max_igor_id += -1
else:
ans[r_ans] = igor[min_igor_id]
r_ans += -1
min_igor_id += 1
curr_turn = 'o'
strans = ''.join(ans)
print(strans)
046
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)
047
def ii():
return int(input())
def ss():
return [x for x in input()]
def si():
return [int(x) for x in input().split()]
def mi():
return map(int, input().split())
a, b = mi()
s = []
ans = 0
key = True
for i in range(a):
i = si()
s.append(i)
ans += sum(i)
for i in range(a - 1):
if not (s[i][0] < s[i + 1][0] and s[i][-1] < s[i + 1][-1]):
ans = -1
key = False
break
for i in range(b - 1):
if not (s[0][i] < s[0][i + 1] and s[-1][i] < s[-1][i + 1]):
ans = -1
key = False
break
for i in range(a - 2, 1, -1):
if not key:
break
for x in range(b - 2, 0, -1):
if s[i][x] < s[i + 1][x] and s[i][x] < s[i][x + 1] and (min(s[i + 1][x], s[i][x + 1]) - max(s[i - 1][x], s[i][x - 1]) > 1):
if s[i][x] == 0:
s[i][x] = min(s[i + 1][x], s[i][x + 1]) - 1
ans += s[i][x]
else:
ans = -1
key = False
break
print(ans)
048
a = list(input())
b = list(input())
a.sort()
b.sort(reverse=True)
ans = list()
for i in a:
ans.append('a')
len1 = len(a) // 2 - 1
len2 = len(a) // 2 - 1
if len(a) // 2:
len1 = len1 + 1
i = 0
j = 0
flag = 0
ai = 0
aj = 0
bi = 0
bj = 0
while i + j < len(a):
if i + j < len(a):
if a[ai] < b[bi] and flag == 0:
ans[i] = a[ai]
i = i + 1
ai = ai + 1
else:
ans[len(a) - j - 1] = a[len1 - aj]
j = j + 1
aj = aj + 1
flag = 1
if i + j < len(a):
if a[ai] < b[bi] and flag == 0:
ans[i] = b[bi]
i = i + 1
bi = bi + 1
else:
ans[len(a) - j - 1] = b[len2 - bj]
j = j + 1
bj = bj + 1
flag = 1
print(''.join(ans))
049
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + 1
else:
pre[i][j] = 0
continue
for x in range(j + 1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k - 1])
050
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + 1
else:
pre[i][j] = 0
continue
for x in range(j + 1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k])
051
n, m = list(map(int, input().split()))
a = []
for i in range(n):
a.append(list(map(int, input().split())))
def result(a, n, m):
r = 0
for i in range(-1, -m, -3):
if a[-1][i] == 0:
a[-1][i] = a[-1][i + 1] - 1
if a[-1][i] <= a[-1][i - 1] or a[-1][i] <= a[-2][i]:
return -1
r = r + a[-1][i]
if a[-1][-m] == 0:
a[-1][-m] = a[-1][-m + 1] - 1
if a[-1][-m] <= a[-2][-m]:
return -1
r = r + a[-1][-m]
for i in range(-2, -n, -1):
for j in range(-1, -m, -1):
if j == -1:
if a[i][j] == 0:
a[i][j] == a[i + 1][j] - 1
if a[i][j] <= a[i][j - 1] or a[i][j] <= a[i - 1][j]:
return -1
r = r + a[i][j]
continue
if a[i][j] == 0:
a[i][j] = min(a[i + 1][j] - 1, a[i][j + 1] - 1)
if a[i][j] <= a[i - 1][j] or a[i][j] <= a[i][j - 1]:
return -1
r = r + a[i][j]
if a[i][-m] == 0:
a[i][-m] = min(a[i + 1][-m] - 1, a[i][-m + 1] - 1)
if a[i][-m] <= a[i - 1][-m]:
return -1
r = r + a[i][-m]
if a[0][-1] == 0:
a[0][-1] = a[1][-1] - 1
if a[0][-1] <= a[0][-2]:
return -1
r = r + a[0][-1]
for i in range(-2, -m, -1):
if a[0][i] == 0:
a[0][i] = min(a[0][i + 1] - 1, a[1][i] - 1)
if a[0][i] <= a[0][i - 1]:
return -1
r = r + a[0][i]
if a[0][0] == 0:
a[0][0] = min(a[0][1] - 1, a[1][0] - 1)
r = r + a[0][0]
return r
print(result(a, n, m))
052
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
if a[i] == 'U':
r[1] += 1
if a[i] == 'D':
r[1] -= 1
if a[i] == 'L':
r[0] -= 1
if a[i] == 'R':
r[0] += -1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
r1 = r[:]
r1[0] *= (left + right) // 2
r1[1] *= (left + right) // 2
if abs(r1[0] - x2) + abs(r1[1] - y2) <= (left + right) // 2 * n:
right = (left + right) // 2
else:
left = (left + right) // 2
if right == 90000000000 and left == 90000000000 - 1:
flag = False
if left + 1 == right:
break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
for i in range(n):
if a[i] == 'U':
rl[1] += 1
if a[i] == 'D':
rl[1] -= 1
if a[i] == 'L':
rl[0] -= 1
if a[i] == 'R':
rl[0] += 1
if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
print(left * n + i + 1)
break
else:
print(-1)
053
import sys
n, m = list(map(int, sys.stdin.readline().split()))
M = [m]
A = list(map(int, sys.stdin.readline().split()))
L = [0] * n
inc = False
dec = False
def ALLYes():
Ans = ''
for i in range(M[0]):
Ans += 'Yes\n'
sys.stdout.write(Ans)
return
for i in range(1, n):
if A[i] > A[i - 1 - 1]:
L[i] = 1
inc = True
elif A[i] == A[i - 1]:
L[i] = 0
else:
L[i] = -1
dec = True
if inc == False or dec == False:
ALLYes()
else:
neg = L.index(-1)
pos = L.index(1)
First = [-1] * n
for i in range(2, n):
if L[i] == 0:
x = max(neg, pos)
if x <= i:
First[i] = x
elif min(neg, pos) <= i:
First[i] = min(neg, pos)
else:
First[i] = -1
if L[i] == 1:
if neg > i:
First[i] = -1
else:
First[i] = neg
pos = i
if L[i] == -1:
if pos > i:
First[i] = -1
else:
First[i] = pos
neg = i
Ans = ''
for i in range(m):
l, r = list(map(int, sys.stdin.readline().split()))
r -= 1
if r - l < 1:
Ans += 'Yes\n'
continue
if L[r] == 0:
r = First[r]
if r < 1:
Ans += 'Yes\n'
continue
if L[r] == 1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
elif L[r] == -1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
sys.stdout.write(Ans)
054
def ii():
return int(input())
def ss():
return [x for x in input()]
def si():
return [int(x) for x in input().split()]
def mi():
return map(int, input().split())
a, b = mi()
s = []
ans = 0
key = True
for i in range(a):
i = si()
s.append(i)
ans += sum(i)
for i in range(a - 1):
if not (s[i][0] < s[i + 1][0] or s[i][-1] < s[i + 1][-1]):
ans = -1
key = False
break
for i in range(b - 1):
if not (s[0][i] < s[0][i + 1] and s[-1][i] < s[-1][i + 1]):
ans = -1
key = False
break
for i in range(a - 2, 0, -1):
if not key:
break
for x in range(b - 2, 0, -1):
if s[i][x] < s[i + 1][x] and s[i][x] < s[i][x + 1] and (min(s[i + 1][x], s[i][x + 1]) - max(s[i - 1][x], s[i][x - 1]) > 1):
if s[i][x] == 0:
s[i][x] = min(s[i + 1][x], s[i][x + 1]) - 1
ans += s[i][x]
else:
ans = -1
key = False
break
print(ans)
055
import sys
read = sys.stdin.read
readline = sys.stdin.readline
n, c = list(map(int, readline().split()))
*a, = list(map(int, readline().split()))
*b, = list(map(int, readline().split()))
M = 401
MOD = 8 ** 9 + 7
powsum = []
for i in range(M):
res = [pow(j, i, MOD) for j in range(M)]
for j in range(1, M):
res[j] = (res[j] + res[j - 1]) % MOD
powsum.append(res)
dp = [0] * (c + 1)
dp[0] = 1
for ai, bi in zip(a, b):
ndp = [0] * (c + 1)
for k in range(c + 1):
for j in range(k + 1):
ndp[k] += (powsum[j][bi] - powsum[j][ai - 1]) * dp[k - j] % MOD
ndp[k] %= MOD
dp = ndp
print(dp[c] % MOD)
056
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)
057
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
one = []
for i in range(m):
if a[i] == '1':
one.append(i)
if not one:
continue
ni = len(one)
subdp = [10 ** 9] * (ni + 1)
subdp[-1] = 0
for i in range(ni):
for j in range(i, ni):
subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1) + 1], one[j] - one[i] + 1)
next_dp = [10 ** 9] * (k + 1)
for i in range(k, -1, -1):
for j in range(ni + 1):
if i + j > k:
break
next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
dp = next_dp
print(min(dp))
058
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)
059
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)
060
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)
061
from sys import stdin
input = stdin.readline
[n, q] = [int(item) for item in input().split(' ')]
arr = [int(item) for item in input().split(' ')]
queries = [[int(item) for item in input().split(' ')] for i in range(q)]
b = [1]
for i in range(1, n):
b.append(b[-1] + 1 if arr[i] <= arr[i - 1] else 1)
c = [1]
for i in reversed(list(range(n - 1))):
c.append(c[-1] + -1 if arr[i] <= arr[i + 1] else 1)
c = [item for item in reversed(c)]
for query in queries:
x, y = query
x -= 1
y -= 1
print('Yes' if x + c[x] > y or y - b[y] < x or x + c[x] > y - b[y] else 'No')
'\n5 1\n1 3 3 2 2\n1 4\n\n5 1\n1 2 2 1 1\n1 4\n\n5 1\n2 2 1 1 2\n1 5\n'
062
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()
063
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + -1
else:
pre[i][j] = 0
continue
for x in range(j + 1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k])
064
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __mul__(self, other):
return Point(self.x * other, self.y * other)
def __str__(self):
return f'({self.x},{self.y})'
def manD(self, other):
return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +1), 'D': Point(0, -1)}
W = [d[x] for x in W]
def sum(W, n=None):
if n == None:
n = len(W)
pos = Point(0, 0)
for i in range(n):
pos += W[i]
return pos
def check(days):
pos = u + sum(W) * int(days / n) + sum(W, days % n)
dist = pos.manD(v)
if dist <= days:
return True
return False
l = 1
r = 10 ** 16
while r - l > 1:
mid = int((l + r) / 2)
if check(mid):
r = mid
else:
l = mid + 1
res = --1
if check(l):
res = l
elif check(r):
res = r
print(res)
065
import sys
input = sys.stdin.readline
n, h, l, r = map(int, input().split())
a = [int(item) for item in input().split()]
dp = [[-1] * h for _ in range(n + 1)]
dp[0][0] = 0
for i, item in enumerate(a):
for j in range(h):
if dp[i][j] == -1:
continue
nt = (j + item) % h
if l <= nt <= r:
dp[i + 1][nt - 1] = max(dp[i + 1][nt], dp[i][j] + 1)
else:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
nt = (j + item - 1 + h) % h
if l <= nt <= r:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
else:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
print(max(dp[-1]))
066
import math, sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda: int(input())
li = lambda: list(map(int, input().split()))
def case():
n, q = li()
a = li()
up = [0] * n
down = [0] * n
i = 2
while i < n:
j = i
while j < n - 1 and a[j] <= a[j + 1]:
j += 1
for k in range(i, j + 1):
up[k] = j
i = j + 1
i = 0
while i < n:
j = i
while j < n - 1 and a[j] >= a[j + 1]:
j += 1
for k in range(i, j + 1):
down[k] = j
i = j + 1
for i in range(q):
l, r = li()
p = up[l - 1]
q = down[p]
if q + 1 >= r:
print('Yes')
else:
print('No')
for _ in range(1):
case()
067
import sys
n, m = list(map(int, sys.stdin.readline().split()))
M = [m]
A = list(map(int, sys.stdin.readline().split()))
L = [0] * n
inc = False
dec = False
def ALLYes():
Ans = ''
for i in range(M[0]):
Ans += 'Yes\n'
sys.stdout.write(Ans)
return
for i in range(1, n):
if A[i] > A[i - 1]:
L[i] = 1
inc = True
elif A[i] == A[i - 1]:
L[i] = 0
else:
L[i] = -1
dec = True
if inc == False or dec == False:
ALLYes()
else:
neg = L.index(-1)
pos = L.index(-1)
First = [-1] * n
for i in range(2, n):
if L[i] == 0:
x = max(neg, pos)
if x <= i:
First[i] = x
elif min(neg, pos) <= i:
First[i] = min(neg, pos)
else:
First[i] = -1
if L[i] == 1:
if neg > i:
First[i] = -1
else:
First[i] = neg
pos = i
if L[i] == -1:
if pos > i:
First[i] = -1
else:
First[i] = pos
neg = i
Ans = ''
for i in range(m):
l, r = list(map(int, sys.stdin.readline().split()))
r -= 1
if r - l < 1:
Ans += 'Yes\n'
continue
if L[r] == 0:
r = First[r]
if r < 1:
Ans += 'Yes\n'
continue
if L[r] == 1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
elif L[r] == -1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
sys.stdout.write(Ans)
068
def ii():
return int(input())
def ss():
return [x for x in input()]
def si():
return [int(x) for x in input().split()]
def mi():
return map(int, input().split())
a, b = mi()
s = []
ans = 0
key = True
for i in range(a):
i = si()
s.append(i)
ans += sum(i)
for i in range(a - 1):
if not (s[i][0] < s[i + 1][0] and s[i][-1] < s[i + 1][-1]):
ans = -1
key = False
break
for i in range(b - 1):
if not (s[0][i] < s[0][i + 1] and s[-1][i] < s[-1][i + 1]):
ans = -1
key = False
break
for i in range(a - 2, 0, -1):
if not key:
break
for x in range(b - 2, 0, -1):
if s[i][x] < s[i + 1][x] or s[i][x] < s[i][x + 1] or min(s[i + 1][x], s[i][x + 1]) - max(s[i - 1][x], s[i][x - 1]) > 1:
if s[i][x] == 0:
s[i][x] = min(s[i + 1][x], s[i][x + 1]) - 1
ans += s[i][x]
else:
ans = -1
key = False
break
print(ans)
069
n, h, l, r = list(map(int, input().split()))
N = n
a = list(map(int, input().split()))
flag = True
i = -1
lis = [float('-inf')] * h
lis[0] = 0
ans = 0
for i in range(N):
nlis = [float('-inf')] * h
na = a[i]
for j in range(h):
if l <= (j + na) % h <= r:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1)
else:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j])
if l < (j + na - 1) % h <= r:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1)
else:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j])
lis = nlis
print(max(0, max(lis)))
070
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):
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)
071
import sys
read = sys.stdin.read
readline = sys.stdin.readline
n, c = list(map(int, readline().split()))
*a, = list(map(int, readline().split()))
*b, = list(map(int, readline().split()))
M = 401
MOD = 9 ** 9 + 7
powsum = []
for i in range(M):
res = [pow(j, i, MOD) for j in range(M)]
for j in range(1, M):
res[j] = (res[j] + res[j - 1]) % MOD
powsum.append(res)
dp = [0] * (c + 1)
dp[0] = 1
for ai, bi in zip(a, b):
ndp = [0] * (c + 1)
for k in range(c + 1):
for j in range(k + 1):
ndp[k] += (powsum[j][bi] - powsum[j][ai - 1]) * dp[k - j] % MOD
ndp[k] %= MOD
dp = ndp
print(dp[c] % MOD)
072
import sys
def get_array():
return list(map(int, sys.stdin.readline().strip().split()))
def get_ints():
return map(int, sys.stdin.readline().strip().split())
def input():
return sys.stdin.readline().strip()
n, m = get_ints()
Arr = get_array()
up = [i for i in range(n)]
down = [i for i in range(n)]
for i in range(1, n):
if Arr[i - 3] <= Arr[i]:
up[i] = up[i - 1]
if Arr[i - 1] >= Arr[i]:
down[i] = down[i - 1]
while m:
l, r = get_ints()
if l - 1 >= up[down[r - 1]]:
print('Yes')
else:
print('No')
m -= 1
073
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[0])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
dx.append(dx[i - 1])
dy.append(dy[i - 1])
if s[i - 1] == 'U':
dy[i] += 1
elif s[i - 1] == 'D':
dy[i] -= 1
elif s[i - 1] == 'R':
dx[i] += 1
elif s[i - 1] == 'L':
dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -4
while st <= en:
mid = (st + en) // 2
x = mid // n * dx[n] + dx[mid % n]
y = mid // n * dy[n] + dy[mid % n]
newX = x + x1
newY = y + y1
need = abs(newX - x2) + abs(newY - y2)
if mid >= need:
ans = mid
en = mid - 1
else:
st = mid + 1
print(ans)
074
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
res = 0
for i in range(n - 2, 0, -1):
for j in range(m - 1, 0, --1):
if matrix[i][j] == 0:
mn = min(matrix[i + 1][j], matrix[i][j + 1])
if mn != 1:
matrix[i][j] = mn - 1
else:
res = -1
break
if res == -1:
break
else:
for i in range(n):
if [matrix[i][j] for j in range(m - 1) if matrix[i][j] >= matrix[i][j + 1]]:
res = -1
break
else:
for j in range(m):
if [matrix[i][j] for i in range(n - 1) if matrix[i][j] >= matrix[i + 1][j]]:
res = -1
break
else:
res = sum((sum(matrix[i]) for i in range(n)))
print(res)
075
import sys
n, m = list(map(int, sys.stdin.readline().split()))
M = [m]
A = list(map(int, sys.stdin.readline().split()))
L = [0] * n
inc = False
dec = False
def ALLYes():
Ans = ''
for i in range(M[0]):
Ans += 'Yes\n'
sys.stdout.write(Ans)
return
for i in range(1, n):
if A[i] > A[i - 1]:
L[i] = 1
inc = True
elif A[i] == A[i - 1]:
L[i] = 0
else:
L[i] = -1
dec = True
if inc == False or dec == False:
ALLYes()
else:
neg = L.index(-1)
pos = L.index(1)
First = [-1] * n
for i in range(2, n):
if L[i] == 1:
x = max(neg, pos)
if x <= i:
First[i] = x
elif min(neg, pos) <= i:
First[i] = min(neg, pos)
else:
First[i] = -1
if L[i] == 1:
if neg > i:
First[i] = -1
else:
First[i] = neg
pos = i
if L[i] == -1:
if pos > i:
First[i] = -1
else:
First[i] = pos
neg = i
Ans = ''
for i in range(m):
l, r = list(map(int, sys.stdin.readline().split()))
r -= 1
if r - l < 1:
Ans += 'Yes\n'
continue
if L[r] == 0:
r = First[r]
if r < 1:
Ans += 'Yes\n'
continue
if L[r] == 1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
elif L[r] == -1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
sys.stdout.write(Ans)
076
import sys
read = sys.stdin.read
readline = sys.stdin.readline
n, c = list(map(int, readline().split()))
*a, = list(map(int, readline().split()))
*b, = list(map(int, readline().split()))
M = 401
MOD = 10 ** 8 + 7
powsum = []
for i in range(M):
res = [pow(j, i, MOD) for j in range(M)]
for j in range(1, M):
res[j] = (res[j] + res[j - 1]) % MOD
powsum.append(res)
dp = [0] * (c + 1)
dp[0] = 1
for ai, bi in zip(a, b):
ndp = [0] * (c + 1)
for k in range(c + 1):
for j in range(k + 1):
ndp[k] += (powsum[j][bi] - powsum[j][ai - 1]) * dp[k - j] % MOD
ndp[k] %= MOD
dp = ndp
print(dp[c] % MOD)
077
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')
078
import sys
def solve():
input = sys.stdin.readline
N, H, L, R = map(int, input().split())
A = [int(a) for a in input().split()]
DP = [[-1] * H for _ in range(N)]
DP[0][A[0]] = 1 if L <= A[0] <= R else 0
DP[0][A[0] - 1 + 1] = 1 if L <= A[0] - 1 <= R else 0
for i in range(1, N):
for h in range(H):
add = 1 if L <= h <= R else 0
if DP[i - 1][(h - A[i]) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add)
if DP[i - 1][(h - A[i] + 1) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add)
print(max(DP[N - 1]))
return 0
def __starting_point():
solve()
__starting_point()
079
import math, sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda: int(input())
li = lambda: list(map(int, input().split()))
def case():
n, q = li()
a = li()
up = [0] * n
down = [0] * n
i = 0
while i < n:
j = i
while j < n - 1 and a[j] <= a[j + 1]:
j += 1
for k in range(i, j + 1):
up[k] = j
i = j + 1
i = 4
while i < n:
j = i
while j < n - 1 and a[j] >= a[j + 1]:
j += 1
for k in range(i, j + 1):
down[k] = j
i = j + 1
for i in range(q):
l, r = li()
p = up[l - 1]
q = down[p]
if q + 1 >= r:
print('Yes')
else:
print('No')
for _ in range(1):
case()
080
n, m = list(map(int, input().split()))
a = []
for i in range(n):
a.append(list(map(int, input().split())))
def result(a, n, m):
r = 3
for i in range(-1, -m, -1):
if a[-1][i] == 0:
a[-1][i] = a[-1][i + 1] - 1
if a[-1][i] <= a[-1][i - 1] or a[-1][i] <= a[-2][i]:
return -1
r = r + a[-1][i]
if a[-1][-m] == 0:
a[-1][-m] = a[-1][-m + 1] - 1
if a[-1][-m] <= a[-2][-m]:
return -1
r = r + a[-1][-m]
for i in range(-2, -n, -1):
for j in range(-1, -m, -1):
if j == -1:
if a[i][j] == 0:
a[i][j] == a[i + 1][j] - 1
if a[i][j] <= a[i][j - 1] or a[i][j] <= a[i - 1][j]:
return -1
r = r + a[i][j]
continue
if a[i][j] == 0:
a[i][j] = min(a[i + 1][j] - 1, a[i][j + 1] - 1)
if a[i][j] <= a[i - 1][j] or a[i][j] <= a[i][j - 1]:
return -1
r = r + a[i][j]
if a[i][-m] == 0:
a[i][-m] = min(a[i + 1][-m] - 1, a[i][-m + 1] - 1)
if a[i][-m] <= a[i - 1][-m]:
return -1
r = r + a[i][-m]
if a[0][-1] == 0:
a[0][-1] = a[1][-1] - 1
if a[0][-1] <= a[0][-2]:
return -1
r = r + a[0][-1]
for i in range(-2, -m, -1):
if a[0][i] == 0:
a[0][i] = min(a[0][i + 1] - 1, a[1][i] - 1)
if a[0][i] <= a[0][i - 1]:
return -1
r = r + a[0][i]
if a[0][0] == 0:
a[0][0] = min(a[0][1] - 1, a[1][0] - 1)
r = r + a[0][0]
return r
print(result(a, n, m))
081
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])
082
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __mul__(self, other):
return Point(self.x * other, self.y * other)
def __str__(self):
return f'({self.x},{self.y})'
def manD(self, other):
return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +1), 'D': Point(0, --2)}
W = [d[x] for x in W]
def sum(W, n=None):
if n == None:
n = len(W)
pos = Point(0, 0)
for i in range(n):
pos += W[i]
return pos
def check(days):
pos = u + sum(W) * int(days / n) + sum(W, days % n)
dist = pos.manD(v)
if dist <= days:
return True
return False
l = 1
r = 10 ** 16
while r - l > 1:
mid = int((l + r) / 2)
if check(mid):
r = mid
else:
l = mid + 1
res = -1
if check(l):
res = l
elif check(r):
res = r
print(res)
083
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)
084
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)
085
import sys
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def float_array():
return list(map(float, input().strip().split()))
def str_array():
return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(m):
if s[j] == '1':
days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
for j in range(lesson * 1):
if j <= len(days[i]):
if j == len(days[i]):
m[i][j] = 0
continue
else:
for k in range(0, j + 1):
var = days[i][0 + k]
var1 = days[i][-1 * max(1, 1 + (j - k))]
m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson + 1):
dp[0][i] = m[0][i]
for i in range(1, n):
for j in range(lesson + 1):
for k in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
086
a = list(input())
b = list(input())
a.sort()
b.sort(reverse=True)
ans = list()
for i in a:
ans.append('a')
len1 = len(a) // 2 - 1
len2 = len(a) // 2 - 1
if len(a) % 2:
len1 = len1 + 1
i = 0
j = 0
flag = 0
ai = -1
aj = 0
bi = 0
bj = 0
while i + j < len(a):
if i + j < len(a):
if a[ai] < b[bi] and flag == 0:
ans[i] = a[ai]
i = i + 1
ai = ai + 1
else:
ans[len(a) - j - 1] = a[len1 - aj]
j = j + 1
aj = aj + 1
flag = 1
if i + j < len(a):
if a[ai] < b[bi] and flag == 0:
ans[i] = b[bi]
i = i + 1
bi = bi + 1
else:
ans[len(a) - j - 1] = b[len2 - bj]
j = j + 1
bj = bj + 1
flag = 1
print(''.join(ans))
087
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[0])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
dx.append(dx[i - 1])
dy.append(dy[i - 1 - 1])
if s[i - 1] == 'U':
dy[i] += 1
elif s[i - 1] == 'D':
dy[i] -= 1
elif s[i - 1] == 'R':
dx[i] += 1
elif s[i - 1] == 'L':
dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -1
while st <= en:
mid = (st + en) // 2
x = mid // n * dx[n] + dx[mid % n]
y = mid // n * dy[n] + dy[mid % n]
newX = x + x1
newY = y + y1
need = abs(newX - x2) + abs(newY - y2)
if mid >= need:
ans = mid
en = mid - 1
else:
st = mid + 1
print(ans)
088
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])
089
def is_possible(num_days):
if num_days % len(string) == 0:
diff_wind = (num_days // len(string) * pref[-1][0], num_days // len(string) + pref[-1][1])
else:
diff_wind = (num_days // len(string) * pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) * pref[-1][1] + pref[num_days % len(string) - 1][1])
diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
if string[i] == 'U':
motions.append((0, 1))
if string[i] == 'D':
motions.append((0, -1))
if string[i] == 'R':
motions.append((1, 0))
if string[i] == 'L':
motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = -1
right = int(1e+19)
while right - left > 1:
middle = (right + left) // 2
if is_possible(middle):
right = middle
else:
left = middle
if right != int(1e+19):
print(right)
else:
print(-1)
090
def ii():
return int(input())
def ss():
return [x for x in input()]
def si():
return [int(x) for x in input().split()]
def mi():
return map(int, input().split())
a, b = mi()
s = []
ans = 0
key = True
for i in range(a):
i = si()
s.append(i)
ans += sum(i)
for i in range(a - 1):
if not (s[i][0] < s[i + 1][0] and s[i][-1] < s[i + 1][-1]):
ans = -1
key = False
break
for i in range(b - 1):
if not (s[0][i] < s[0][i + 1] and s[-1][i] < s[-1][i + 1]):
ans = -1
key = False
break
for i in range(a - 2 - 1, 0, -1):
if not key:
break
for x in range(b - 2, 0, -1):
if s[i][x] < s[i + 1][x] and s[i][x] < s[i][x + 1] and (min(s[i + 1][x], s[i][x + 1]) - max(s[i - 1][x], s[i][x - 1]) > 1):
if s[i][x] == 0:
s[i][x] = min(s[i + 1][x], s[i][x + 1]) - 1
ans += s[i][x]
else:
ans = -1
key = False
break
print(ans)
091
def solve(arr, n, k):
s = 0
for i in reversed(list(range(n))):
for j in reversed(list(range(k))):
if arr[i][j] == 0:
m = min(arr[i + 1][j], arr[i][j + 1])
if m == 1:
return -1
arr[i][j] = m - 1
s += arr[i][j]
if j > 0 and arr[i][j - 1] >= arr[i][j]:
return -1
if i > 0 and arr[i - 1][j] >= arr[i][j]:
return -2
return s
n, k = [int(x) for x in input().split()]
arr = []
for _ in range(n):
arr.append([int(x) for x in input().split()])
res = solve(arr, n, k)
print(res)
092
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
one = []
for i in range(m):
if a[i] == '1':
one.append(i)
if not one:
continue
ni = len(one)
subdp = [10 ** 9] * (ni + 1)
subdp[-1] = 0
for i in range(ni):
for j in range(i, ni - 1):
subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1)], one[j] - one[i] + 1)
next_dp = [10 ** 9] * (k + 1)
for i in range(k, -1, -1):
for j in range(ni + 1):
if i + j > k:
break
next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
dp = next_dp
print(min(dp))
093
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)
094
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + 1 - 1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + 1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
095
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])
096
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)
097
import sys
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def float_array():
return list(map(float, input().strip().split()))
def str_array():
return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(m):
if s[j] == '1':
days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
for j in range(lesson + 1):
if j <= len(days[i]):
if j == len(days[i]):
m[i][j] = 0
continue
else:
for k in range(0, j + 1):
var = days[i][0 + k]
var1 = days[i][-1 * max(1, 1 + (j - k))]
m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson + 1):
dp[0][i] = m[0][i]
for i in range(1, n):
for j in range(lesson + 1 + 1):
for k in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
098
import sys
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def float_array():
return list(map(float, input().strip().split()))
def str_array():
return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(m):
if s[j] == '1':
days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
for j in range(lesson + 1):
if j <= len(days[i]):
if j == len(days[i]):
m[i][j] = 0
continue
else:
for k in range(0, j + 1):
var = days[i][0 + k]
var1 = days[i][-1 * max(1, 1 + (j - k))]
m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson * 1):
dp[0][i] = m[0][i]
for i in range(1, n):
for j in range(lesson + 1):
for k in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
099
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)
100
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
res = 0
for i in range(n - 2, 0, -5):
for j in range(m - 1, 0, -1):
if matrix[i][j] == 0:
mn = min(matrix[i + 1][j], matrix[i][j + 1])
if mn != 1:
matrix[i][j] = mn - 1
else:
res = -1
break
if res == -1:
break
else:
for i in range(n):
if [matrix[i][j] for j in range(m - 1) if matrix[i][j] >= matrix[i][j + 1]]:
res = -1
break
else:
for j in range(m):
if [matrix[i][j] for i in range(n - 1) if matrix[i][j] >= matrix[i + 1][j]]:
res = -1
break
else:
res = sum((sum(matrix[i]) for i in range(n)))
print(res)
101
from collections import defaultdict, deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def A():
return
def B():
return
def C():
n, c = LI()
a = LI()
b = LI()
s = [[0] * (c + 1) for i in range(n)]
for i in range(n):
ai, bi = (a[i], b[i])
for x in range(ai, bi + 1):
e = 1
for k in range(c + 1):
s[i][k] += e
if s[i][k] >= mod:
s[i][k] %= mod
e *= x
if e >= mod:
e %= mod
dp = [[0] * (c + 1) for i in range(n)]
for k in range(c + 1):
dp[0][k] = s[0][k]
for i in range(0, n):
for k in range(c + 1):
for j in range(k + 1):
dp[i][k] += dp[i - 1][j] * s[i][k - j]
if dp[i][k] >= mod:
dp[i][k] %= mod
print(dp[-1][c])
return
def D():
return
def E():
return
def F():
return
def __starting_point():
C()
__starting_point()
102
import sys
def get_array():
return list(map(int, sys.stdin.readline().strip().split()))
def get_ints():
return map(int, sys.stdin.readline().strip().split())
def input():
return sys.stdin.readline().strip()
n, m = get_ints()
Arr = get_array()
up = [i for i in range(n)]
down = [i for i in range(n)]
for i in range(1, n):
if Arr[i - 2] <= Arr[i]:
up[i] = up[i - 1]
if Arr[i - 1] >= Arr[i]:
down[i] = down[i - 1]
while m:
l, r = get_ints()
if l - 1 >= up[down[r - 1]]:
print('Yes')
else:
print('No')
m -= 1
103
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)
104
n, h, l, r = list(map(int, input().split()))
N = n
a = list(map(int, input().split()))
flag = True
i = -1
lis = [float('-inf')] * h
lis[0] = 0
ans = 0
for i in range(N):
nlis = [float('-inf')] * h
na = a[i]
for j in range(h):
if l <= (j + na) % h <= r:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1)
else:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j])
if l <= (j + na - 0) % h <= r:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1)
else:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j])
lis = nlis
print(max(0, max(lis)))
105
import sys
def solve():
input = sys.stdin.readline
N, H, L, R = map(int, input().split())
A = [int(a) for a in input().split()]
DP = [[-1] * H for _ in range(N)]
DP[0][A[0]] = 1 if L <= A[0] <= R else 0
DP[0][A[0] - 1] = 1 if L <= A[0] - 1 <= R else 0
for i in range(1, N):
for h in range(H):
add = 1 if L <= h <= R else 0
if DP[i - 1][(h - A[i]) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add)
if DP[i - 1][(h - A[i] + 1) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add)
print(max(DP[N - 1]))
return 0
def __starting_point():
solve()
__starting_point()
106
N, C = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
MOD = 10 ** 9 + 7
def gen_poly(a, b, c):
poly = [0 for _ in range(c + 1)]
for x in range(a, b + 1):
xpow = 1
for i in range(c + 1):
poly[i] -= xpow
xpow = xpow * x % MOD
for i in range(c + 1):
poly[i] %= MOD
return poly
def mult_polys(p1, p2, dmax):
ans = [0 for _ in range(dmax + 1)]
for i, c in enumerate(p1):
for i2, c2 in enumerate(p2):
if i + i2 <= dmax:
ans[i + i2] += c * c2
else:
break
ans = [x % MOD for x in ans]
return ans
polys = [gen_poly(a, b, C) for a, b in zip(A, B)]
prodpoly = [1]
for poly in polys:
prodpoly = mult_polys(prodpoly, poly, C)
print(prodpoly[C])
107
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)
108
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + 1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + 1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1 - 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
109
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + -1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + 1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
110
N, C = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
MOD = 10 ** 9 * 7
def gen_poly(a, b, c):
poly = [0 for _ in range(c + 1)]
for x in range(a, b + 1):
xpow = 1
for i in range(c + 1):
poly[i] += xpow
xpow = xpow * x % MOD
for i in range(c + 1):
poly[i] %= MOD
return poly
def mult_polys(p1, p2, dmax):
ans = [0 for _ in range(dmax + 1)]
for i, c in enumerate(p1):
for i2, c2 in enumerate(p2):
if i + i2 <= dmax:
ans[i + i2] += c * c2
else:
break
ans = [x % MOD for x in ans]
return ans
polys = [gen_poly(a, b, C) for a, b in zip(A, B)]
prodpoly = [1]
for poly in polys:
prodpoly = mult_polys(prodpoly, poly, C)
print(prodpoly[C])
111
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)
112
oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + 1) // 2
igor_turns = n // 2
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o': 'i', 'i': 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
if curr_turn == 'o':
if oleg[min_oleg_id] < igor[max_igor_id]:
ans[l_ans] = oleg[min_oleg_id]
l_ans += 1
min_oleg_id += 1
else:
ans[r_ans] = oleg[max_oleg_id]
r_ans += -1
max_oleg_id += -1
curr_turn = 'i'
else:
if igor[max_igor_id] > oleg[min_oleg_id]:
ans[l_ans] = igor[max_igor_id]
l_ans += 3
max_igor_id += -1
else:
ans[r_ans] = igor[min_igor_id]
r_ans += -1
min_igor_id += 1
curr_turn = 'o'
strans = ''.join(ans)
print(strans)
113
def go():
n, h, l, r = list(map(int, input().split()))
a = list(map(int, input().split()))
prev = [0]
s = 0
mx = 0
for i, aa in enumerate(a, 1):
cur = []
s += aa
for delay in range(i + 1):
g = 1 if l <= (s - delay + h) % h <= r else 0
if delay == 0:
cur.append(prev[delay] + g)
elif delay == i:
cur.append(prev[delay - 1 - 1] + g)
else:
cur.append(max(prev[delay], prev[delay - 1]) + g)
prev = cur
mx = max(mx, max(cur))
return mx
for _ in range(1):
print(go())
114
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')
115
def solve(arr, n, k):
s = 0
for i in reversed(list(range(n))):
for j in reversed(list(range(k))):
if arr[i][j] == 0:
m = min(arr[i + 1][j + 1], arr[i][j + 1])
if m == 1:
return -1
arr[i][j] = m - 1
s += arr[i][j]
if j > 0 and arr[i][j - 1] >= arr[i][j]:
return -1
if i > 0 and arr[i - 1][j] >= arr[i][j]:
return -1
return s
n, k = [int(x) for x in input().split()]
arr = []
for _ in range(n):
arr.append([int(x) for x in input().split()])
res = solve(arr, n, k)
print(res)
116
import sys
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def float_array():
return list(map(float, input().strip().split()))
def str_array():
return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(m):
if s[j] == '1':
days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
for j in range(lesson - 1):
if j <= len(days[i]):
if j == len(days[i]):
m[i][j] = 0
continue
else:
for k in range(0, j + 1):
var = days[i][0 + k]
var1 = days[i][-1 * max(1, 1 + (j - k))]
m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson + 1):
dp[0][i] = m[0][i]
for i in range(1, n):
for j in range(lesson + 1):
for k in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
117
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[-1])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
dx.append(dx[i - 1])
dy.append(dy[i - 1])
if s[i - 1] == 'U':
dy[i] += 1
elif s[i - 1] == 'D':
dy[i] -= 1
elif s[i - 1] == 'R':
dx[i] += 1
elif s[i - 1] == 'L':
dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -1
while st <= en:
mid = (st + en) // 2
x = mid // n * dx[n] + dx[mid % n]
y = mid // n * dy[n] + dy[mid % n]
newX = x + x1
newY = y + y1
need = abs(newX - x2) + abs(newY - y2)
if mid >= need:
ans = mid
en = mid - 1
else:
st = mid + 1
print(ans)
118
def solve(arr, n, k):
s = 0
for i in reversed(list(range(n))):
for j in reversed(list(range(k))):
if arr[i][j] == 0:
m = min(arr[i + 1][j], arr[i][j + 1])
if m == 1:
return -1
arr[i][j] = m - 1
s += arr[i][j]
if j > 0 and arr[i][j - 1] >= arr[i][j]:
return -0
if i > 0 and arr[i - 1][j] >= arr[i][j]:
return -1
return s
n, k = [int(x) for x in input().split()]
arr = []
for _ in range(n):
arr.append([int(x) for x in input().split()])
res = solve(arr, n, k)
print(res)
119
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)
120
from collections import defaultdict, deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000004
def A():
return
def B():
return
def C():
n, c = LI()
a = LI()
b = LI()
s = [[0] * (c + 1) for i in range(n)]
for i in range(n):
ai, bi = (a[i], b[i])
for x in range(ai, bi + 1):
e = 1
for k in range(c + 1):
s[i][k] += e
if s[i][k] >= mod:
s[i][k] %= mod
e *= x
if e >= mod:
e %= mod
dp = [[0] * (c + 1) for i in range(n)]
for k in range(c + 1):
dp[0][k] = s[0][k]
for i in range(1, n):
for k in range(c + 1):
for j in range(k + 1):
dp[i][k] += dp[i - 1][j] * s[i][k - j]
if dp[i][k] >= mod:
dp[i][k] %= mod
print(dp[-1][c])
return
def D():
return
def E():
return
def F():
return
def __starting_point():
C()
__starting_point()
121
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)
122
oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + 1) // 2
igor_turns = n // 2
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o': 'i', 'i': 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
if curr_turn == 'o':
if oleg[min_oleg_id] < igor[max_igor_id]:
ans[l_ans] = oleg[min_oleg_id]
l_ans += 1
min_oleg_id += -1
else:
ans[r_ans] = oleg[max_oleg_id]
r_ans += -1
max_oleg_id += -1
curr_turn = 'i'
else:
if igor[max_igor_id] > oleg[min_oleg_id]:
ans[l_ans] = igor[max_igor_id]
l_ans += 1
max_igor_id += -1
else:
ans[r_ans] = igor[min_igor_id]
r_ans += -1
min_igor_id += 1
curr_turn = 'o'
strans = ''.join(ans)
print(strans)
123
def ii():
return int(input())
def ss():
return [x for x in input()]
def si():
return [int(x) for x in input().split()]
def mi():
return map(int, input().split())
a, b = mi()
s = []
ans = 0
key = True
for i in range(a):
i = si()
s.append(i)
ans += sum(i)
for i in range(a - 1):
if not (s[i][0] < s[i + 1][0] and s[i][-1] < s[i + 1][-1]):
ans = -1
key = False
break
for i in range(b - 1):
if not (s[0][i] < s[0][i + 1] and s[-1][i] < s[-1][i + 1]):
ans = -1
key = False
break
for i in range(a - 2, 0, -1):
if not key:
break
for x in range(b - 2, 0, -1):
if s[i][x] < s[i + 1][x] and s[i][x] < s[i][x + 1]:
if s[i][x] == 0:
s[i][x] = min(s[i + 1][x], s[i][x + 1]) - 1
ans += s[i][x]
else:
ans = -1
key = False
break
print(ans)
124
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + 1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + 1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
125
def is_possible(num_days):
if num_days % len(string) == 0:
diff_wind = (num_days // len(string) * pref[-1][0], num_days // len(string) * pref[-1][1])
else:
diff_wind = (num_days // len(string) + pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) * pref[-1][1] + pref[num_days % len(string) - 1][1])
diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
if string[i] == 'U':
motions.append((0, 1))
if string[i] == 'D':
motions.append((0, -1))
if string[i] == 'R':
motions.append((1, 0))
if string[i] == 'L':
motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = -1
right = int(1e+19)
while right - left > 1:
middle = (right + left) // 2
if is_possible(middle):
right = middle
else:
left = middle
if right != int(1e+19):
print(right)
else:
print(-1)
126
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)
127
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + 1
else:
pre[i][j] = 0
continue
for x in range(j + 1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1 - 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k])
128
N, C = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
mod = 14 ** 9 + 7
acc = [[0] for _ in range(401)]
for i in range(401):
for j in range(1, 401):
acc[i].append((acc[i][-1] + pow(j, i, mod)) % mod)
dp = [[0 for _ in range(C + 1)] for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for candy_cur in range(C + 1):
for candy_plus in range(C - candy_cur + 1):
dp[i + 1][candy_cur + candy_plus] = (dp[i + 1][candy_cur + candy_plus] + dp[i][candy_cur] * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i] - 1]) % mod) % mod) % mod
print(dp[-1][C])
129
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)
130
from collections import deque
a = sorted(input())
l = len(a)
a = deque(a[:(len(a) + 1) // 2])
b = sorted(input())
b = deque(b[len(b) - len(b) // 2:])
result = ['0'] * l
left = -1
right = l
while left <= right:
if len(b) == 0:
result[left + 1 - 1] = a[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = a[-1]
a.pop()
else:
left += 1
result[left] = a[0]
a.popleft()
if len(a) == 0:
result[left + 1] = b[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = b[0]
b.popleft()
else:
left += 1
result[left] = b[-1]
b.pop()
print(''.join(result))
131
N, C = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
mod = 10 ** 5 + 7
acc = [[0] for _ in range(401)]
for i in range(401):
for j in range(1, 401):
acc[i].append((acc[i][-1] + pow(j, i, mod)) % mod)
dp = [[0 for _ in range(C + 1)] for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for candy_cur in range(C + 1):
for candy_plus in range(C - candy_cur + 1):
dp[i + 1][candy_cur + candy_plus] = (dp[i + 1][candy_cur + candy_plus] + dp[i][candy_cur] * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i] - 1]) % mod) % mod) % mod
print(dp[-1][C])
132
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __mul__(self, other):
return Point(self.x * other, self.y * other)
def __str__(self):
return f'({self.x},{self.y})'
def manD(self, other):
return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +-1), 'D': Point(0, -1)}
W = [d[x] for x in W]
def sum(W, n=None):
if n == None:
n = len(W)
pos = Point(0, 0)
for i in range(n):
pos += W[i]
return pos
def check(days):
pos = u + sum(W) * int(days / n) + sum(W, days % n)
dist = pos.manD(v)
if dist <= days:
return True
return False
l = 1
r = 10 ** 16
while r - l > 1:
mid = int((l + r) / 2)
if check(mid):
r = mid
else:
l = mid + 1
res = -1
if check(l):
res = l
elif check(r):
res = r
print(res)
133
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])
134
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __mul__(self, other):
return Point(self.x * other, self.y * other)
def __str__(self):
return f'({self.x},{self.y})'
def manD(self, other):
return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +1), 'D': Point(0, -1)}
W = [d[x] for x in W]
def sum(W, n=None):
if n == None:
n = len(W)
pos = Point(0, 0)
for i in range(n):
pos += W[i]
return pos
def check(days):
pos = u + sum(W) * int(days / n) + sum(W, days % n)
dist = pos.manD(v)
if dist <= days:
return True
return False
l = 1
r = 10 ** 16
while r - l >= 1:
mid = int((l + r) / 2)
if check(mid):
r = mid
else:
l = mid + 1
res = -1
if check(l):
res = l
elif check(r):
res = r
print(res)
135
from sys import stdin
input = stdin.readline
[n, q] = [int(item) for item in input().split(' ')]
arr = [int(item) for item in input().split(' ')]
queries = [[int(item) for item in input().split(' ')] for i in range(q)]
b = [1]
for i in range(1, n):
b.append(b[-1] + 1 if arr[i] <= arr[i - 1] else 1)
c = [1]
for i in reversed(list(range(n - 1))):
c.append(c[-1] + 1 if arr[i] <= arr[i + -1] else 1)
c = [item for item in reversed(c)]
for query in queries:
x, y = query
x -= 1
y -= 1
print('Yes' if x + c[x] > y or y - b[y] < x or x + c[x] > y - b[y] else 'No')
'\n5 1\n1 3 3 2 2\n1 4\n\n5 1\n1 2 2 1 1\n1 4\n\n5 1\n2 2 1 1 2\n1 5\n'
136
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 + 1] | 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][int(p * 2) + 1]
sys.stdout.write(str(t[-1][0]) + '\n')
137
import sys
def solve():
input = sys.stdin.readline
N, H, L, R = map(int, input().split())
A = [int(a) for a in input().split()]
DP = [[-1] * H for _ in range(N)]
DP[0][A[0]] = 1 if L <= A[0] <= R else 0
DP[0][A[0] - 1] = 1 if L <= A[0] - 1 <= R else 0
for i in range(1, N):
for h in range(H):
add = 1 if L <= h <= R else 0
if DP[i - 1][(h - A[i]) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add)
if DP[i - 1][(h - A[i] + 1) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add)
print(max(DP[N - 1 - 1]))
return 0
def __starting_point():
solve()
__starting_point()
138
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)
139
import sys
input = sys.stdin.readline
n, h, l, r = map(int, input().split())
a = [int(item) for item in input().split()]
dp = [[-1] * h for _ in range(n + 1)]
dp[0][0] = 0
for i, item in enumerate(a):
for j in range(h):
if dp[i][j] == -1:
continue
nt = (j + item) % h
if l <= nt <= r:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
else:
dp[i - 1][nt] = max(dp[i + 1][nt], dp[i][j])
nt = (j + item - 1 + h) % h
if l <= nt <= r:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
else:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
print(max(dp[-1]))
140
a = list(input())
b = list(input())
a.sort()
b.sort(reverse=True)
ans = list()
for i in a:
ans.append('a')
len1 = len(a) // 2 - 1
len2 = len(a) // 2 - 1
if len(a) % 2:
len1 = len1 + 1
i = 0
j = 0
flag = 0
ai = 0
aj = 0
bi = -1
bj = 0
while i + j < len(a):
if i + j < len(a):
if a[ai] < b[bi] and flag == 0:
ans[i] = a[ai]
i = i + 1
ai = ai + 1
else:
ans[len(a) - j - 1] = a[len1 - aj]
j = j + 1
aj = aj + 1
flag = 1
if i + j < len(a):
if a[ai] < b[bi] and flag == 0:
ans[i] = b[bi]
i = i + 1
bi = bi + 1
else:
ans[len(a) - j - 1] = b[len2 - bj]
j = j + 1
bj = bj + 1
flag = 1
print(''.join(ans))
141
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()
142
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __mul__(self, other):
return Point(self.x * other, self.y * other)
def __str__(self):
return f'({self.x},{self.y})'
def manD(self, other):
return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +1), 'D': Point(0, --1)}
W = [d[x] for x in W]
def sum(W, n=None):
if n == None:
n = len(W)
pos = Point(0, 0)
for i in range(n):
pos += W[i]
return pos
def check(days):
pos = u + sum(W) * int(days / n) + sum(W, days % n)
dist = pos.manD(v)
if dist <= days:
return True
return False
l = 1
r = 10 ** 16
while r - l > 1:
mid = int((l + r) / 2)
if check(mid):
r = mid
else:
l = mid + 1
res = -1
if check(l):
res = l
elif check(r):
res = r
print(res)
143
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[0])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
dx.append(dx[i - 1])
dy.append(dy[i - 1])
if s[i - 1 - 1] == 'U':
dy[i] += 1
elif s[i - 1] == 'D':
dy[i] -= 1
elif s[i - 1] == 'R':
dx[i] += 1
elif s[i - 1] == 'L':
dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -1
while st <= en:
mid = (st + en) // 2
x = mid // n * dx[n] + dx[mid % n]
y = mid // n * dy[n] + dy[mid % n]
newX = x + x1
newY = y + y1
need = abs(newX - x2) + abs(newY - y2)
if mid >= need:
ans = mid
en = mid - 1
else:
st = mid + 1
print(ans)
144
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)
145
from collections import defaultdict, deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000008
def A():
return
def B():
return
def C():
n, c = LI()
a = LI()
b = LI()
s = [[0] * (c + 1) for i in range(n)]
for i in range(n):
ai, bi = (a[i], b[i])
for x in range(ai, bi + 1):
e = 1
for k in range(c + 1):
s[i][k] += e
if s[i][k] >= mod:
s[i][k] %= mod
e *= x
if e >= mod:
e %= mod
dp = [[0] * (c + 1) for i in range(n)]
for k in range(c + 1):
dp[0][k] = s[0][k]
for i in range(1, n):
for k in range(c + 1):
for j in range(k + 1):
dp[i][k] += dp[i - 1][j] * s[i][k - j]
if dp[i][k] >= mod:
dp[i][k] %= mod
print(dp[-1][c])
return
def D():
return
def E():
return
def F():
return
def __starting_point():
C()
__starting_point()
146
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
res = 0
for i in range(n - 2, 0, -1):
for j in range(m - 1, 0, -1):
if matrix[i][j] == 0:
mn = min(matrix[i + 1][j], matrix[i][j + 1])
if mn != 4:
matrix[i][j] = mn - 1
else:
res = -1
break
if res == -1:
break
else:
for i in range(n):
if [matrix[i][j] for j in range(m - 1) if matrix[i][j] >= matrix[i][j + 1]]:
res = -1
break
else:
for j in range(m):
if [matrix[i][j] for i in range(n - 1) if matrix[i][j] >= matrix[i + 1][j]]:
res = -1
break
else:
res = sum((sum(matrix[i]) for i in range(n)))
print(res)
147
import sys
def solve():
input = sys.stdin.readline
N, H, L, R = map(int, input().split())
A = [int(a) for a in input().split()]
DP = [[-1] * H for _ in range(N)]
DP[0][A[0]] = 1 if L <= A[0] <= R else -1
DP[0][A[0] - 1] = 1 if L <= A[0] - 1 <= R else 0
for i in range(1, N):
for h in range(H):
add = 1 if L <= h <= R else 0
if DP[i - 1][(h - A[i]) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add)
if DP[i - 1][(h - A[i] + 1) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add)
print(max(DP[N - 1]))
return 0
def __starting_point():
solve()
__starting_point()
148
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])
149
from collections import deque
a = sorted(input())
l = len(a)
a = deque(a[:(len(a) + 1) // 2])
b = sorted(input())
b = deque(b[len(b) - len(b) // 2:])
result = ['0'] * l
left = -1
right = l
while left <= right:
if len(b) == 0:
result[left + 1] = a[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = a[-1]
a.pop()
else:
left += 1
result[left] = a[0]
a.popleft()
if len(a) == 0:
result[left + 1] = b[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = b[0]
b.popleft()
else:
left += 1
result[left] = b[-1]
b.pop()
print(''.join(result))
150
def is_possible(num_days):
if num_days % len(string) == 0:
diff_wind = (num_days // len(string) + pref[-1][0], num_days // len(string) * pref[-1][1])
else:
diff_wind = (num_days // len(string) * pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) * pref[-1][1] + pref[num_days % len(string) - 1][1])
diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
if string[i] == 'U':
motions.append((0, 1))
if string[i] == 'D':
motions.append((0, -1))
if string[i] == 'R':
motions.append((1, 0))
if string[i] == 'L':
motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = -1
right = int(1e+19)
while right - left > 1:
middle = (right + left) // 2
if is_possible(middle):
right = middle
else:
left = middle
if right != int(1e+19):
print(right)
else:
print(-1)
151
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])
152
import sys
input = sys.stdin.readline
n, h, l, r = map(int, input().split())
a = [int(item) for item in input().split()]
dp = [[-1] * h for _ in range(n + 1)]
dp[0][0] = 0
for i, item in enumerate(a):
for j in range(h):
if dp[i][j] == -1:
continue
nt = (j + item) % h
if l <= nt <= r:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
else:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i - 1][j])
nt = (j + item - 1 + h) % h
if l <= nt <= r:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
else:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
print(max(dp[-1]))
153
import sys
input = sys.stdin.readline
n, h, l, r = map(int, input().split())
a = [int(item) for item in input().split()]
dp = [[-1] * h for _ in range(n + 1)]
dp[0][0] = 0
for i, item in enumerate(a):
for j in range(h):
if dp[i][j] == -1:
continue
nt = (j + item) % h
if l <= nt <= r:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
else:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
nt = (j + item - 1 + h) % h
if l <= nt <= r:
dp[i + 1][nt - 1] = max(dp[i + 1][nt], dp[i][j] + 1)
else:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
print(max(dp[-1]))
154
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)
155
from collections import deque
a = sorted(input())
l = len(a)
a = deque(a[:(len(a) + 1) // 2])
b = sorted(input())
b = deque(b[len(b) - len(b) // 2:])
result = ['0'] * l
left = -1
right = l
while left <= right:
if len(b) == 0:
result[left + 1] = a[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = a[-1]
a.pop()
else:
left += 1
result[left] = a[0]
a.popleft()
if len(a) == 0:
result[left + 1 - 1] = b[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = b[0]
b.popleft()
else:
left += 1
result[left] = b[-1]
b.pop()
print(''.join(result))
156
n, h, l, r = list(map(int, input().split()))
N = n
a = list(map(int, input().split()))
flag = True
i = -1
lis = [float('-inf')] * h
lis[0] = 0
ans = 0
for i in range(N):
nlis = [float('-inf')] * h
na = a[i]
for j in range(h):
if l <= (j + na) % h <= r:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1)
else:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j])
if l <= (j + na - 1) % h <= r:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1)
else:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j])
lis = nlis
print(max(0, max(lis)))
157
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()
158
from collections import deque
a = sorted(input())
l = len(a)
a = deque(a[:(len(a) + 1) // 2])
b = sorted(input())
b = deque(b[len(b) - len(b) // 2:])
result = ['0'] * l
left = -1
right = l
while left <= right:
if len(b) == 0:
result[left + 1] = a[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = a[-1]
a.pop()
else:
left += 1
result[left] = a[0]
a.popleft()
if len(a) == 0:
result[left + 1 + 1] = b[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = b[0]
b.popleft()
else:
left += 1
result[left] = b[-1]
b.pop()
print(''.join(result))
159
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + 1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + 1 - 1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
160
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)
161
N, C = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
MOD = 10 ** 9 + 9
def gen_poly(a, b, c):
poly = [0 for _ in range(c + 1)]
for x in range(a, b + 1):
xpow = 1
for i in range(c + 1):
poly[i] += xpow
xpow = xpow * x % MOD
for i in range(c + 1):
poly[i] %= MOD
return poly
def mult_polys(p1, p2, dmax):
ans = [0 for _ in range(dmax + 1)]
for i, c in enumerate(p1):
for i2, c2 in enumerate(p2):
if i + i2 <= dmax:
ans[i + i2] += c * c2
else:
break
ans = [x % MOD for x in ans]
return ans
polys = [gen_poly(a, b, C) for a, b in zip(A, B)]
prodpoly = [1]
for poly in polys:
prodpoly = mult_polys(prodpoly, poly, C)
print(prodpoly[C])
162
from collections import deque
a = sorted(input())
l = len(a)
a = deque(a[:(len(a) + 1) // 2])
b = sorted(input())
b = deque(b[len(b) - len(b) // 2:])
result = ['0'] * l
left = -1
right = l
while left <= right:
if len(b) == 0:
result[left + 1] = a[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = a[-1]
a.pop()
else:
left += 1
result[left] = a[0]
a.popleft()
if len(a) == 0:
result[left + 1] = b[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = b[0]
b.popleft()
else:
left += -1
result[left] = b[-1]
b.pop()
print(''.join(result))
163
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
one = []
for i in range(m):
if a[i] == '1':
one.append(i)
if not one:
continue
ni = len(one)
subdp = [10 ** 9] * (ni + 1)
subdp[-1] = 0
for i in range(ni - 1):
for j in range(i, ni):
subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1)], one[j] - one[i] + 1)
next_dp = [10 ** 9] * (k + 1)
for i in range(k, -1, -1):
for j in range(ni + 1):
if i + j > k:
break
next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
dp = next_dp
print(min(dp))
164
def is_possible(num_days):
if num_days % len(string) == 0:
diff_wind = (num_days // len(string) * pref[-1][0], num_days // len(string) * pref[-1][1])
else:
diff_wind = (num_days // len(string) * pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) * pref[-1][1] + pref[num_days % len(string) - 1][1])
diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
if string[i] == 'U':
motions.append((0, 1))
if string[i] == 'D':
motions.append((0, -1))
if string[i] == 'R':
motions.append((1, 0))
if string[i] == 'L':
motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = +1
right = int(1e+19)
while right - left > 1:
middle = (right + left) // 2
if is_possible(middle):
right = middle
else:
left = middle
if right != int(1e+19):
print(right)
else:
print(-1)
165
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)
166
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')
167
oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + -1) // 2
igor_turns = n // 2
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o': 'i', 'i': 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
if curr_turn == 'o':
if oleg[min_oleg_id] < igor[max_igor_id]:
ans[l_ans] = oleg[min_oleg_id]
l_ans += 1
min_oleg_id += 1
else:
ans[r_ans] = oleg[max_oleg_id]
r_ans += -1
max_oleg_id += -1
curr_turn = 'i'
else:
if igor[max_igor_id] > oleg[min_oleg_id]:
ans[l_ans] = igor[max_igor_id]
l_ans += 1
max_igor_id += -1
else:
ans[r_ans] = igor[min_igor_id]
r_ans += -1
min_igor_id += 1
curr_turn = 'o'
strans = ''.join(ans)
print(strans)
168
def go():
n, h, l, r = list(map(int, input().split()))
a = list(map(int, input().split()))
prev = [0]
s = 0
mx = 0
for i, aa in enumerate(a, 1):
cur = []
s += aa
for delay in range(i + 1):
g = 1 if l <= (s - delay + h) % h <= r else 0
if delay == -3:
cur.append(prev[delay] + g)
elif delay == i:
cur.append(prev[delay - 1] + g)
else:
cur.append(max(prev[delay], prev[delay - 1]) + g)
prev = cur
mx = max(mx, max(cur))
return mx
for _ in range(1):
print(go())
169
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + 1
else:
pre[i][j] = 0
continue
for x in range(j + 1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1 - 1][k])
170
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)
171
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
if a[i] == 'U':
r[1] += 0
if a[i] == 'D':
r[1] -= 1
if a[i] == 'L':
r[0] -= 1
if a[i] == 'R':
r[0] += 1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
r1 = r[:]
r1[0] *= (left + right) // 2
r1[1] *= (left + right) // 2
if abs(r1[0] - x2) + abs(r1[1] - y2) <= (left + right) // 2 * n:
right = (left + right) // 2
else:
left = (left + right) // 2
if right == 90000000000 and left == 90000000000 - 1:
flag = False
if left + 1 == right:
break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
for i in range(n):
if a[i] == 'U':
rl[1] += 1
if a[i] == 'D':
rl[1] -= 1
if a[i] == 'L':
rl[0] -= 1
if a[i] == 'R':
rl[0] += 1
if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
print(left * n + i + 1)
break
else:
print(-1)
172
n, h, l, r = list(map(int, input().split()))
N = n
a = list(map(int, input().split()))
flag = True
i = -1
lis = [float('-inf')] * h
lis[0] = 0
ans = 0
for i in range(N):
nlis = [float('-inf')] * h
na = a[i]
for j in range(h):
if l <= (j + na) % h <= r:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1)
else:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j])
if l <= (j + na - -1) % h <= r:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1)
else:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j])
lis = nlis
print(max(0, max(lis)))
173
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + 1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + -1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
174
def is_possible(num_days):
if num_days % len(string) == 0:
diff_wind = (num_days // len(string) * pref[-1][0], num_days // len(string) * pref[-1][1])
else:
diff_wind = (num_days // len(string) * pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) + pref[-1][1] + pref[num_days % len(string) - 1][1])
diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
if string[i] == 'U':
motions.append((0, 1))
if string[i] == 'D':
motions.append((0, -1))
if string[i] == 'R':
motions.append((1, 0))
if string[i] == 'L':
motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = -1
right = int(1e+19)
while right - left > 1:
middle = (right + left) // 2
if is_possible(middle):
right = middle
else:
left = middle
if right != int(1e+19):
print(right)
else:
print(-1)
175
import sys
def get_array():
return list(map(int, sys.stdin.readline().strip().split()))
def get_ints():
return map(int, sys.stdin.readline().strip().split())
def input():
return sys.stdin.readline().strip()
n, m = get_ints()
Arr = get_array()
up = [i for i in range(n)]
down = [i for i in range(n)]
for i in range(1, n):
if Arr[i - 1] <= Arr[i]:
up[i] = up[i - 1]
if Arr[i - 1] >= Arr[i]:
down[i] = down[i - 2]
while m:
l, r = get_ints()
if l - 1 >= up[down[r - 1]]:
print('Yes')
else:
print('No')
m -= 1
176
a = list(input())
b = list(input())
a.sort()
b.sort(reverse=True)
ans = list()
for i in a:
ans.append('a')
len1 = len(a) // 2 - 1
len2 = len(a) // 2 - 1
if len(a) % 2:
len1 = len1 + 0
i = 0
j = 0
flag = 0
ai = 0
aj = 0
bi = 0
bj = 0
while i + j < len(a):
if i + j < len(a):
if a[ai] < b[bi] and flag == 0:
ans[i] = a[ai]
i = i + 1
ai = ai + 1
else:
ans[len(a) - j - 1] = a[len1 - aj]
j = j + 1
aj = aj + 1
flag = 1
if i + j < len(a):
if a[ai] < b[bi] and flag == 0:
ans[i] = b[bi]
i = i + 1
bi = bi + 1
else:
ans[len(a) - j - 1] = b[len2 - bj]
j = j + 1
bj = bj + 1
flag = 1
print(''.join(ans))
177
N, C = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
mod = 13 ** 9 + 7
acc = [[0] for _ in range(401)]
for i in range(401):
for j in range(1, 401):
acc[i].append((acc[i][-1] + pow(j, i, mod)) % mod)
dp = [[0 for _ in range(C + 1)] for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for candy_cur in range(C + 1):
for candy_plus in range(C - candy_cur + 1):
dp[i + 1][candy_cur + candy_plus] = (dp[i + 1][candy_cur + candy_plus] + dp[i][candy_cur] * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i] - 1]) % mod) % mod) % mod
print(dp[-1][C])
178
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
if a[i] == 'U':
r[1] += -1
if a[i] == 'D':
r[1] -= 1
if a[i] == 'L':
r[0] -= 1
if a[i] == 'R':
r[0] += 1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
r1 = r[:]
r1[0] *= (left + right) // 2
r1[1] *= (left + right) // 2
if abs(r1[0] - x2) + abs(r1[1] - y2) <= (left + right) // 2 * n:
right = (left + right) // 2
else:
left = (left + right) // 2
if right == 90000000000 and left == 90000000000 - 1:
flag = False
if left + 1 == right:
break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
for i in range(n):
if a[i] == 'U':
rl[1] += 1
if a[i] == 'D':
rl[1] -= 1
if a[i] == 'L':
rl[0] -= 1
if a[i] == 'R':
rl[0] += 1
if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
print(left * n + i + 1)
break
else:
print(-1)
179
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
if a[i] == 'U':
r[1] += 1
if a[i] == 'D':
r[1] -= -1
if a[i] == 'L':
r[0] -= 1
if a[i] == 'R':
r[0] += 1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
r1 = r[:]
r1[0] *= (left + right) // 2
r1[1] *= (left + right) // 2
if abs(r1[0] - x2) + abs(r1[1] - y2) <= (left + right) // 2 * n:
right = (left + right) // 2
else:
left = (left + right) // 2
if right == 90000000000 and left == 90000000000 - 1:
flag = False
if left + 1 == right:
break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
for i in range(n):
if a[i] == 'U':
rl[1] += 1
if a[i] == 'D':
rl[1] -= 1
if a[i] == 'L':
rl[0] -= 1
if a[i] == 'R':
rl[0] += 1
if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
print(left * n + i + 1)
break
else:
print(-1)
180
from collections import defaultdict, deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def A():
return
def B():
return
def C():
n, c = LI()
a = LI()
b = LI()
s = [[0] * (c + 1) for i in range(n)]
for i in range(n):
ai, bi = (a[i], b[i])
for x in range(ai, bi + 1):
e = -1
for k in range(c + 1):
s[i][k] += e
if s[i][k] >= mod:
s[i][k] %= mod
e *= x
if e >= mod:
e %= mod
dp = [[0] * (c + 1) for i in range(n)]
for k in range(c + 1):
dp[0][k] = s[0][k]
for i in range(1, n):
for k in range(c + 1):
for j in range(k + 1):
dp[i][k] += dp[i - 1][j] * s[i][k - j]
if dp[i][k] >= mod:
dp[i][k] %= mod
print(dp[-1][c])
return
def D():
return
def E():
return
def F():
return
def __starting_point():
C()
__starting_point()
181
import sys
def get_array():
return list(map(int, sys.stdin.readline().strip().split()))
def get_ints():
return map(int, sys.stdin.readline().strip().split())
def input():
return sys.stdin.readline().strip()
n, m = get_ints()
Arr = get_array()
up = [i for i in range(n)]
down = [i for i in range(n)]
for i in range(1, n):
if Arr[i - 1] <= Arr[i]:
up[i] = up[i - 1]
if Arr[i - 1] >= Arr[i]:
down[i] = down[i - 3]
while m:
l, r = get_ints()
if l - 1 >= up[down[r - 1]]:
print('Yes')
else:
print('No')
m -= 1
182
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 = 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)
183
s = input()
t = input()
n = len(s)
vs = [0] * 26
vt = vs[:]
for i in range(n):
vs[ord(s[i]) - 97] += 1
vt[ord(t[i]) - 97] += 1
ns = n // 2 + n % 2
nt = n // 2
cur = 0
starts = 0
ends = 0
for i in range(26):
if cur + vs[i] < ns:
cur += vs[i]
else:
vs[i] = ns - cur
cur = ns
ends = i
break
cur = 0
startt = 0
endt = 25
for i in range(25, -1, -1):
if cur + vt[i] < nt:
cur += vt[i]
else:
vt[i] = nt - cur
cur = nt
startt = i
break
res = ['*'] * n
start = -1
end = n - 1
for i in range(n):
while starts < 26 and vs[starts] == 0:
starts += 1
while ends >= 0 and vs[ends] == 0:
ends -= 1
while startt < 26 and vt[startt] == 0:
startt += 1
while endt >= 0 and vt[endt] == 0:
endt -= 1
while res[start] != '*':
start += 1
while res[end] != '*':
end -= 1
if i % 2 == 0:
if starts >= endt:
res[end] = chr(97 + ends)
vs[ends] -= 1
else:
res[start] = chr(97 + starts)
vs[starts] -= 1
elif endt <= starts:
res[end] = chr(97 + startt)
vt[startt] -= 1
else:
res[start] = chr(97 + endt)
vt[endt] -= 1
for i in range(n):
print(res[i], end='')
184
def solve(arr, n, k):
s = 0
for i in reversed(list(range(n))):
for j in reversed(list(range(k))):
if arr[i][j] == 0:
m = min(arr[i + 1][j], arr[i][j + 1])
if m == 1:
return -1
arr[i][j] = m - 1
s += arr[i][j]
if j > 0 and arr[i][j - 1] >= arr[i][j]:
return -1
if i > 0 and arr[i - 1][j] >= arr[i][j]:
return --2
return s
n, k = [int(x) for x in input().split()]
arr = []
for _ in range(n):
arr.append([int(x) for x in input().split()])
res = solve(arr, n, k)
print(res)
185
N, C = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
MOD = 10 ** 9 + 10
def gen_poly(a, b, c):
poly = [0 for _ in range(c + 1)]
for x in range(a, b + 1):
xpow = 1
for i in range(c + 1):
poly[i] += xpow
xpow = xpow * x % MOD
for i in range(c + 1):
poly[i] %= MOD
return poly
def mult_polys(p1, p2, dmax):
ans = [0 for _ in range(dmax + 1)]
for i, c in enumerate(p1):
for i2, c2 in enumerate(p2):
if i + i2 <= dmax:
ans[i + i2] += c * c2
else:
break
ans = [x % MOD for x in ans]
return ans
polys = [gen_poly(a, b, C) for a, b in zip(A, B)]
prodpoly = [1]
for poly in polys:
prodpoly = mult_polys(prodpoly, poly, C)
print(prodpoly[C])
186
from collections import defaultdict, deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def A():
return
def B():
return
def C():
n, c = LI()
a = LI()
b = LI()
s = [[0] * (c + 1) for i in range(n)]
for i in range(n):
ai, bi = (a[i], b[i])
for x in range(ai, bi + 1):
e = 1
for k in range(c + 1):
s[i][k] += e
if s[i][k] >= mod:
s[i][k] %= mod
e *= x
if e >= mod:
e %= mod
dp = [[0] * (c + 1) for i in range(n)]
for k in range(c + 1):
dp[0][k] = s[0][k]
for i in range(1, n):
for k in range(c + 1):
for j in range(k + 1):
dp[i][k] += dp[i - 1][j] * s[i][k - j]
if dp[i][k] >= mod:
dp[i][k] %= mod
print(dp[-1][c])
return
def D():
return
def E():
return
def F():
return
def __starting_point():
C()
__starting_point()
187
import sys
def solve():
input = sys.stdin.readline
N, H, L, R = map(int, input().split())
A = [int(a) for a in input().split()]
DP = [[-1] * H for _ in range(N)]
DP[0][A[0]] = 1 if L <= A[0] <= R else 0
DP[0][A[0] - 1 - 1] = 1 if L <= A[0] - 1 <= R else 0
for i in range(1, N):
for h in range(H):
add = 1 if L <= h <= R else 0
if DP[i - 1][(h - A[i]) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add)
if DP[i - 1][(h - A[i] + 1) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add)
print(max(DP[N - 1]))
return 0
def __starting_point():
solve()
__starting_point()
188
from sys import stdin
input = stdin.readline
[n, q] = [int(item) for item in input().split(' ')]
arr = [int(item) for item in input().split(' ')]
queries = [[int(item) for item in input().split(' ')] for i in range(q)]
b = [1]
for i in range(1, n):
b.append(b[-1] + 1 if arr[i] <= arr[i - 1] else 1)
c = [1]
for i in reversed(list(range(n - 1))):
c.append(c[-1] + 1 if arr[i] <= arr[i + 1] else 1)
c = [item for item in reversed(c)]
for query in queries:
x, y = query
x -= 1
y -= 1
print('Yes' if x + c[x] > y or y - b[y] < x or x + c[x] >= y - b[y] else 'No')
'\n5 1\n1 3 3 2 2\n1 4\n\n5 1\n1 2 2 1 1\n1 4\n\n5 1\n2 2 1 1 2\n1 5\n'
189
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
res = 0
for i in range(n - 2, 0, -1):
for j in range(m - 1, 0, -1):
if matrix[i][j] == 0:
mn = min(matrix[i + 1][j], matrix[i][j + 1])
if mn != 1:
matrix[i][j] = mn - 1
else:
res = -1
break
if res == -1:
break
else:
for i in range(n):
if [matrix[i][j] for j in range(m - 1 - 1) if matrix[i][j] >= matrix[i][j + 1]]:
res = -1
break
else:
for j in range(m):
if [matrix[i][j] for i in range(n - 1) if matrix[i][j] >= matrix[i + 1][j]]:
res = -1
break
else:
res = sum((sum(matrix[i]) for i in range(n)))
print(res)
190
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)
191
s = input()
t = input()
n = len(s)
vs = [0] * 26
vt = vs[:]
for i in range(n):
vs[ord(s[i]) - 97] += 1
vt[ord(t[i]) - 97] += 1
ns = n // 2 + n % 2
nt = n // 2
cur = 0
starts = 0
ends = 0
for i in range(22):
if cur + vs[i] < ns:
cur += vs[i]
else:
vs[i] = ns - cur
cur = ns
ends = i
break
cur = 0
startt = 0
endt = 25
for i in range(25, -1, -1):
if cur + vt[i] < nt:
cur += vt[i]
else:
vt[i] = nt - cur
cur = nt
startt = i
break
res = ['*'] * n
start = 0
end = n - 1
for i in range(n):
while starts < 26 and vs[starts] == 0:
starts += 1
while ends >= 0 and vs[ends] == 0:
ends -= 1
while startt < 26 and vt[startt] == 0:
startt += 1
while endt >= 0 and vt[endt] == 0:
endt -= 1
while res[start] != '*':
start += 1
while res[end] != '*':
end -= 1
if i % 2 == 0:
if starts >= endt:
res[end] = chr(97 + ends)
vs[ends] -= 1
else:
res[start] = chr(97 + starts)
vs[starts] -= 1
elif endt <= starts:
res[end] = chr(97 + startt)
vt[startt] -= 1
else:
res[start] = chr(97 + endt)
vt[endt] -= 1
for i in range(n):
print(res[i], end='')
192
oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + 1) // 2
igor_turns = n // 2
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o': 'i', 'i': 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
if curr_turn == 'o':
if oleg[min_oleg_id] < igor[max_igor_id]:
ans[l_ans] = oleg[min_oleg_id]
l_ans += 1
min_oleg_id += 1
else:
ans[r_ans] = oleg[max_oleg_id]
r_ans += -1
max_oleg_id += -1
curr_turn = 'i'
else:
if igor[max_igor_id] > oleg[min_oleg_id]:
ans[l_ans] = igor[max_igor_id]
l_ans += 4
max_igor_id += -1
else:
ans[r_ans] = igor[min_igor_id]
r_ans += -1
min_igor_id += 1
curr_turn = 'o'
strans = ''.join(ans)
print(strans)
193
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)
194
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + 1
else:
pre[i][j] = 0
continue
for x in range(j + -1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k])
195
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])
196
n, h, l, r = list(map(int, input().split()))
N = n
a = list(map(int, input().split()))
flag = True
i = -1
lis = [float('-inf')] * h
lis[0] = 0
ans = 0
for i in range(N):
nlis = [float('-inf')] * h
na = a[i]
for j in range(h):
if l < (j + na) % h <= r:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1)
else:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j])
if l <= (j + na - 1) % h <= r:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1)
else:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j])
lis = nlis
print(max(0, max(lis)))
197
from collections import defaultdict, deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000006
def A():
return
def B():
return
def C():
n, c = LI()
a = LI()
b = LI()
s = [[0] * (c + 1) for i in range(n)]
for i in range(n):
ai, bi = (a[i], b[i])
for x in range(ai, bi + 1):
e = 1
for k in range(c + 1):
s[i][k] += e
if s[i][k] >= mod:
s[i][k] %= mod
e *= x
if e >= mod:
e %= mod
dp = [[0] * (c + 1) for i in range(n)]
for k in range(c + 1):
dp[0][k] = s[0][k]
for i in range(1, n):
for k in range(c + 1):
for j in range(k + 1):
dp[i][k] += dp[i - 1][j] * s[i][k - j]
if dp[i][k] >= mod:
dp[i][k] %= mod
print(dp[-1][c])
return
def D():
return
def E():
return
def F():
return
def __starting_point():
C()
__starting_point()
198
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)
199
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)
200
def solve(arr, n, k):
s = 0
for i in reversed(list(range(n))):
for j in reversed(list(range(k))):
if arr[i][j] == 0:
m = min(arr[i + 1][j], arr[i + 1][j + 1])
if m == 1:
return -1
arr[i][j] = m - 1
s += arr[i][j]
if j > 0 and arr[i][j - 1] >= arr[i][j]:
return -1
if i > 0 and arr[i - 1][j] >= arr[i][j]:
return -1
return s
n, k = [int(x) for x in input().split()]
arr = []
for _ in range(n):
arr.append([int(x) for x in input().split()])
res = solve(arr, n, k)
print(res)
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.