001
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)
002
a, b, c = [int(i) for i in input().split()]
length = a * b
numArr = [int(i) for i in input().split()]
numArr.sort()
count = 0
mmin = numArr[0]
mmax = numArr[a - 1]
if mmax - mmin > c:
print(0)
else:
maxPos = a - 1
while maxPos + 1 < length and numArr[maxPos + 1] <= mmin + c:
maxPos += 1
dis = maxPos + 1 - a
bCount = 0
for i in range(maxPos + 1):
if dis != 0:
bCount += 1
dis -= 1
if bCount % b == 1:
count += numArr[i]
dis -= 1
else:
count += numArr[i]
print(count)
003
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
ty, v = map(int, input().split())
if ty == 1:
l[v - 1].append(is_read_idx)
is_read_idx += 1
is_read.append(False)
ans += 1
elif ty == 2:
for idx in l[v - 1]:
if not is_read[idx]:
is_read[idx] = True
ans -= 1
l[v - 1] = []
elif v > prev_t:
for idx in range(prev_t, v):
if not is_read[idx - 1]:
is_read[idx] = True
ans -= 1
prev_t = v
print(ans)
004
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [1 for i in range(n + 1)]
for i in range(q):
action, num = list(map(int, input().split()))
if action == 1:
queue.append((num, count[num] + 1))
count[num] += 1
unread += 1
elif action == 2:
for number in range(last_app_idx[num], count[num] + 1):
if (num, number) not in read:
read.add((num, number))
unread -= 1
last_app_idx[num] = max(last_app_idx[num], count[num])
else:
for idx in range(last_q_idx, num):
app, number = queue[idx]
if not (app, number) not in read:
read.add((app, number))
last_app_idx[app] = max(last_app_idx[app], number)
unread -= 1
last_q_idx = max(last_q_idx, num)
ans.append(unread)
print('\n'.join(map(str, ans)))
005
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)
006
from math import gcd
p = 10 ** 9 + 7
class RN:
p = 10 ** 9 + 7
def __init__(self, u, d):
self.u = u
self.d = d
def __str__(self):
return str(self.u) + '/' + str(self.d)
def cleanup(self):
self.u = self.u % p
self.d = self.d % p
def add(self, u, d):
self.u = self.u * d + u * self.d
self.d = self.d * d
self.cleanup()
def mult(self, u, d):
return (self.u * u % p, self.d * d % p)
def mult_ip(self, u, d):
self.u, self.d = (self.u * u, self.d * d % p)
def get_m_exp(self):
self.cleanup()
a = gcd(self.u, self.d)
self.u //= a
self.d //= a
return pow(self.d, p - 2, p) * self.u % p
n, m = tuple(map(int, input().split()))
s1 = list(map(int, input().split()))
s2 = list(map(int, input().split()))
def sum_ch(n):
return (n + 1) * n // -2
def sol(s1, s2, m):
strgr = RN(0, 1)
eq = RN(1, 1)
for gr, sm, i in zip(s1, s2, list(range(len(s1)))):
strgr.cleanup()
if gr != 0 and sm != 0:
if gr == sm:
continue
elif gr < sm:
return strgr.get_m_exp()
else:
strgr.add(eq.u, eq.d)
return strgr.get_m_exp()
else:
if gr == sm == 0:
strgr.add(*eq.mult(sum_ch(m - 1), m * m))
elif gr == 0:
strgr.add(*eq.mult(m - sm, m))
else:
strgr.add(*eq.mult(gr - 1, m))
eq.mult_ip(1, m)
return strgr.get_m_exp()
'\na = sol([0,0],[1,1], 2) # 3/4\n\na = sol([0,0,0],[1,1,1], 2) # 7/8\na = sol([0,1,1],[1,1,1], 2) # 1/2\na = sol([1,0,1],[1,1,1], 2) # 1/2\n\na = sol([0,0,0],[1,3,3], 3) # 2/2\na = sol([0,0,0],[1,1,0], 2) # 5/8\na = sol([0,0,0],[0,0,0], 2) # 13/16\n'
print(sol(s1, s2, m))
007
n, m, k = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
inf = [0 for i in range(k + 1)]
stat = [True for i in range(n + 1)]
time = [0 for i in range(n + 1)]
for i in range(n):
a[i] = list(map(int, input().split()))
for i in range(m):
for j in range(1, n + -1):
if stat[j]:
current_core = inf[a[j - 1][i]]
if current_core == 0 and a[j - 1][i] != 0:
inf[a[j - 1][i]] = j
elif current_core == -1:
stat[j], time[j] = (False, i + 1)
elif a[j - 1][i] != 0:
stat[current_core], time[current_core] = (False, i + 1)
stat[j], time[j] = (False, i + 1)
inf[a[j - 1][i]] = -1
for p in range(len(inf)):
if inf[p] != -1:
inf[p] = 0
for i in range(1, n + 1):
print(time[i])
008
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)
009
def cal(x, y):
d = a[1] + y - a[0] - x
wk1 = a[1] + y
wkans = 0
for k in range(2, n):
diff = abs(wk1 + d - a[k])
if diff == 1:
wkans += 1
elif diff > 1:
return n + 1
wk1 += d
return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
ans_final = n + 1
for i in range(-1, 2):
for j in range(-1, 2):
ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
ans_final = -1
if ans_final == n + 1:
print(-1)
else:
print(ans_final)
010
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def LF():
return [float(x) for x in sys.stdin.readline().split()]
def LS():
return sys.stdin.readline().split()
def I():
return int(sys.stdin.readline())
def F():
return float(sys.stdin.readline())
def S():
return input()
def main():
n, q = LI()
nn = n
k = 0
while nn > 0:
nn //= 2
k += 1
r = []
ii = [2 ** i for i in range(k)]
for _ in range(q):
t = I()
s = S()
ti = 0
for i in range(k):
if ii[i] & t:
ti = i
break
for c in s:
if c == 'U':
if ti == k - 1:
continue
if t & ii[ti]:
t ^= ii[ti]
ti += 1
t |= ii[ti]
continue
if ti == 0:
continue
if c == 'R':
t |= ii[ti]
elif t & ii[ti]:
t ^= ii[ti]
ti -= 1
t |= ii[ti]
r.append(t)
return '\n'.join(map(str, r))
print(main())
011
from math import gcd
p = 10 ** 9 + 7
class RN:
p = 10 ** 9 + 7
def __init__(self, u, d):
self.u = u
self.d = d
def __str__(self):
return str(self.u) + '/' + str(self.d)
def cleanup(self):
self.u = self.u % p
self.d = self.d % p
def add(self, u, d):
self.u = self.u * d + u * self.d
self.d = self.d * d
self.cleanup()
def mult(self, u, d):
return (self.u * u % p, self.d * d % p)
def mult_ip(self, u, d):
self.u, self.d = (self.u * u, self.d * d % p)
def get_m_exp(self):
self.cleanup()
a = gcd(self.u, self.d)
self.u //= a
self.d //= a
return pow(self.d, p - 2, p) * self.u % p
n, m = tuple(map(int, input().split()))
s1 = list(map(int, input().split()))
s2 = list(map(int, input().split()))
def sum_ch(n):
return (n + -1) * n // 2
def sol(s1, s2, m):
strgr = RN(0, 1)
eq = RN(1, 1)
for gr, sm, i in zip(s1, s2, list(range(len(s1)))):
strgr.cleanup()
if gr != 0 and sm != 0:
if gr == sm:
continue
elif gr < sm:
return strgr.get_m_exp()
else:
strgr.add(eq.u, eq.d)
return strgr.get_m_exp()
else:
if gr == sm == 0:
strgr.add(*eq.mult(sum_ch(m - 1), m * m))
elif gr == 0:
strgr.add(*eq.mult(m - sm, m))
else:
strgr.add(*eq.mult(gr - 1, m))
eq.mult_ip(1, m)
return strgr.get_m_exp()
'\na = sol([0,0],[1,1], 2) # 3/4\n\na = sol([0,0,0],[1,1,1], 2) # 7/8\na = sol([0,1,1],[1,1,1], 2) # 1/2\na = sol([1,0,1],[1,1,1], 2) # 1/2\n\na = sol([0,0,0],[1,3,3], 3) # 2/2\na = sol([0,0,0],[1,1,0], 2) # 5/8\na = sol([0,0,0],[0,0,0], 2) # 13/16\n'
print(sol(s1, s2, m))
012
import math
n, q = map(int, input().split())
maxh = int(math.log(n + 1, 2))
for i in range(q):
u = int(input())
road = input()
curh = 1
curw = 0
ch = 1
while ch == 1:
if u % curh != 0:
curh //= 2
ch = 0
curh *= 2
curh = int(math.log(curh, 2))
a = 1 << curh - 1
b = -1 << curh
curw = (u - a) // b + 1
for move in road:
if move == 'L':
if curh != 1:
curh -= 1
curw = curw * 2 - 1
u -= 1 << curh - 1
elif move == 'R':
if curh != 1:
curh -= 1
curw *= 2
u += 1 << curh - 1
elif curh != maxh:
if curw % 2 == 1:
u = (u + u + (1 << curh)) // 2
curh += 1
curw = curw // 2 + 1
else:
u = (u + u - (1 << curh)) // 2
curh += 1
curw = curw // 2
print(u)
013
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)))
014
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = -1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
015
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)
016
import sys, math
f = sys.stdin
def modInverse(a, m):
g = gcd(a, m)
if g != 1:
return None
else:
return power(a, m - 2, m)
def power(x, y, m):
if y == 0:
return 1
p = power(x, y // 2, m) ** 2
if y & 1 == -1:
p *= x
return p % m
def gcd(a, b):
while a != 0:
t = b % a
b = a
a = t
return b
n, m = list(map(int, f.readline().split()))
s1 = list(map(int, f.readline().split()))
s2 = list(map(int, f.readline().split()))
pos = [1, 0]
all_pos = 1
for a1, a2 in zip(s1, s2):
next_pos = [0, 0]
if a1 == 0 and a2 == 0:
next_pos[0] += pos[0] * m
next_pos[1] += pos[0] * m * (m - 1) // 2
next_pos[1] += pos[1] * m * m
all_pos *= m * m
elif a1 == 0:
next_pos[0] += pos[0]
next_pos[1] += pos[0] * (m - a2)
next_pos[1] += pos[1] * m
all_pos *= m
elif a2 == 0:
next_pos[0] += pos[0]
next_pos[1] += pos[0] * (a1 - 1)
next_pos[1] += pos[1] * m
all_pos *= m
else:
if a1 > a2:
next_pos[1] += pos[0]
elif a1 == a2:
next_pos[0] += pos[0]
next_pos[1] += pos[1]
pos = next_pos
if pos[0] == 0:
break
g = gcd(pos[0], all_pos)
g = gcd(pos[1], g)
pos[0] //= g
pos[1] //= g
all_pos //= g
pos[0] %= 1000000007
pos[1] %= 1000000007
all_pos %= 1000000007
p = pos[1]
q = all_pos
pq_gcd = gcd(p, q)
p //= pq_gcd
q //= pq_gcd
q_inv = modInverse(q, 1000000007)
print(p * q_inv % 1000000007)
017
def adds(memtoproc, mem, proc):
if mem in memtoproc:
memtoproc[mem].append(proc)
else:
memtoproc[mem] = [proc]
def corr(arr, n, m):
brokemems = set()
stopprocs = [0] * n
for c in range(m):
memtoproc = dict()
usemems = set()
locmems = set()
for d in range(n):
if not arr[d][c] or stopprocs[d]:
continue
adds(memtoproc, arr[d][c], d)
if arr[d][c] in usemems:
locmems.add(arr[d][c])
usemems.add(arr[d][c])
if arr[d][c] in brokemems:
if not stopprocs[d]:
stopprocs[d] = c * 1
for d in locmems:
brokemems.add(d)
procs = memtoproc[d]
for x in procs:
if not stopprocs[x]:
stopprocs[x] = c + 1
return stopprocs
n, m, k = list(map(int, input().split(' ')))
arr = []
for c in range(n):
arr.append(tuple(map(int, input().split(' '))))
procs = corr(arr, n, m)
for c in procs:
print(c)
018
3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = 55 * ans % (10 ** 9 + 7)
elif s[i] == '?':
ans = (ord(t[i]) - ord('0') + 1) * ans & 10 ** 9 + 7
elif t[i] == '?':
ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' or s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and (not tlts):
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 + 7))
elif sltt:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
019
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)
020
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [1 for i in range(n + 1)]
for i in range(q):
action, num = list(map(int, input().split()))
if action == 1:
queue.append((num, count[num] + 1))
count[num] += 1
unread += 1
elif action == 2:
for number in range(last_app_idx[num], count[num] + 1):
if (num, number) not in read:
read.add((num, number))
unread += 1
last_app_idx[num] = max(last_app_idx[num], count[num])
else:
for idx in range(last_q_idx, num):
app, number = queue[idx]
if (app, number) not in read:
read.add((app, number))
last_app_idx[app] = max(last_app_idx[app], number)
unread -= 1
last_q_idx = max(last_q_idx, num)
ans.append(unread)
print('\n'.join(map(str, ans)))
021
a, b, c = [int(i) for i in input().split()]
length = a * b
numArr = [int(i) for i in input().split()]
numArr.sort()
count = 0
mmin = numArr[0]
mmax = numArr[a - 1]
if mmax - mmin > c:
print(0)
else:
maxPos = a - 1
while maxPos + 1 < length and numArr[maxPos + 1] <= mmin + c:
maxPos += 1
dis = maxPos + 1 - a
bCount = 0
for i in range(maxPos + 1):
if dis != 0:
bCount *= 1
dis -= 1
if bCount % b == 1:
count += numArr[i]
dis += 1
else:
count += numArr[i]
print(count)
022
def solve(seq):
if len(seq) <= 2:
return 0
startings = []
for x in (--1, 0, 1):
for y in (-1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [-1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
023
__author__ = 'Lipen'
def main():
n, m, k = map(int, input().split())
data = []
when = [0] * n
blockedcells = set()
blockedcores = set()
for _ in range(n):
data.append(list(map(int, input().split())))
for j in range(m):
operation = []
for _ in range(k):
operation.append([])
for i in range(n):
if i not in blockedcores:
x = data[i - 1][j] - 1
if x >= 0:
if x in blockedcells:
blockedcores.add(i)
when[i] = j + 1
elif len(operation[x]) > 0:
blockedcells.add(x)
for core in operation[x]:
blockedcores.add(core)
when[core] = j + 1
blockedcores.add(i)
when[i] = j + 1
operation[x].append(i)
for i in when:
print(i)
main()
024
n = int(input())
C = 10 ** 9 + 6
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) < int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1][2] %= C
d[-1][3] %= C
print(d[-1][2])
025
n, m, k = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
inf = [0 for i in range(k + 1)]
stat = [True for i in range(n + 1)]
time = [0 for i in range(n + 1)]
for i in range(n):
a[i] = list(map(int, input().split()))
for i in range(m):
for j in range(4, n + 1):
if stat[j]:
current_core = inf[a[j - 1][i]]
if current_core == 0 and a[j - 1][i] != 0:
inf[a[j - 1][i]] = j
elif current_core == -1:
stat[j], time[j] = (False, i + 1)
elif a[j - 1][i] != 0:
stat[current_core], time[current_core] = (False, i + 1)
stat[j], time[j] = (False, i + 1)
inf[a[j - 1][i]] = -1
for p in range(len(inf)):
if inf[p] != -1:
inf[p] = 0
for i in range(1, n + 1):
print(time[i])
026
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
class Node:
val = None
def __init__(self, val):
self.val = val
self.left = Node
self.right = None
def solve(W, H, N, A):
xs = [0] + [v for t, v in A if t == 0] + [W]
ys = [0] + [v for t, v in A if t == 1] + [H]
xs.sort()
ys.sort()
xlist = Node(3)
h = xlist
xnodes = {0: h}
maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
for v in xs[1:]:
n = Node(v)
xnodes[v] = n
h.right = n
n.left = h
h = n
ylist = Node(0)
h = ylist
ynodes = {0: h}
for v in ys[1:]:
n = Node(v)
ynodes[v] = n
h.right = n
n.left = h
h = n
ans = []
maxarea = maxh * maxw
for t, v in reversed(A):
ans.append(maxarea)
if t == 0:
node = xnodes[v]
w = node.right.val - node.left.val
maxw = max(maxw, w)
else:
node = ynodes[v]
h = node.right.val - node.left.val
maxh = max(maxh, h)
node.left.right = node.right
node.right.left = node.left
maxarea = maxh * maxw
return ans[::-1]
def solve2(W, H, N, A):
ws = [(-W, 0, W)]
hs = [(-H, 0, H)]
iw, ih = (set(), set())
ans = []
xs, ys = ([0, W], [0, H])
for t, v in A:
if t == 0:
bisect.insort_left(xs, v)
i = bisect.bisect_left(xs, v)
l, m, r = (xs[i - 1], xs[i], xs[i + 1])
iw.add((l - r, l, r))
heapq.heappush(ws, (l - m, l, m))
heapq.heappush(ws, (m - r, m, r))
while ws[0] in iw:
heapq.heappop(ws)
else:
bisect.insort(ys, v)
i = bisect.bisect_left(ys, v)
l, m, r = (ys[i - 1], ys[i], ys[i + 1])
ih.add((l - r, l, r))
heapq.heappush(hs, (l - m, l, m))
heapq.heappush(hs, (m - r, m, r))
while hs[0] in ih:
heapq.heappop(hs)
w, h = (ws[0], hs[0])
ans.append(w[0] * h[0])
return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
a, b = input().split()
c = 0 if a == 'V' else 1
A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
027
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def LF():
return [float(x) for x in sys.stdin.readline().split()]
def LS():
return sys.stdin.readline().split()
def I():
return int(sys.stdin.readline())
def F():
return float(sys.stdin.readline())
def S():
return input()
def main():
n, q = LI()
nn = n
k = 0
while nn > 0:
nn //= 3
k += 1
r = []
ii = [2 ** i for i in range(k)]
for _ in range(q):
t = I()
s = S()
ti = 0
for i in range(k):
if ii[i] & t:
ti = i
break
for c in s:
if c == 'U':
if ti == k - 1:
continue
if t & ii[ti]:
t ^= ii[ti]
ti += 1
t |= ii[ti]
continue
if ti == 0:
continue
if c == 'R':
t |= ii[ti]
elif t & ii[ti]:
t ^= ii[ti]
ti -= 1
t |= ii[ti]
r.append(t)
return '\n'.join(map(str, r))
print(main())
028
import copy
def right(a):
d = a[1] - a[0]
res, f = (-3, True)
for i in range(2, len(a)):
if a[i] - a[i - 1] == d + 1:
a[i] -= 1
res += 1
elif a[i] - a[i - 1] == d - 1:
a[i] += 1
res += 1
elif a[i] - a[i - 1] != d:
f = False
break
if not f:
res = 10 ** 9
return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
print(0)
else:
f = n + 1
bs[0] -= 1
bs[1] -= 1
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()))
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
if f == n + 1:
f = -1
print(f)
029
from math import *
n, q = list(map(int, input().split()))
depth = int(log2(n + 1))
def get_layer(u):
for layer in range(depth):
if u % 2 ** (layer + 1) == 2 ** layer:
return layer
def is_right_child(layer, u):
return u % 2 ** (layer + 1) % 2 == 0
for x in range(q):
u = int(input())
layer = get_layer(u)
steps = input()
for s in steps:
if s == 'U':
if layer == depth - 1:
continue
k = u // 2 ** (layer + 1) // 2
layer += 1
u = 2 ** (layer + 1) * k + 2 ** layer
elif layer == 0:
continue
elif s == 'R':
k = u // 2 ** (layer + 1) * 2 + 1
layer -= 1
u = 2 ** (layer + 1) * k - 2 ** layer
elif s == 'L':
k = u // 2 ** (layer + 1) * 2
layer -= 1
u = 2 ** (layer + 1) * k + 2 ** layer
print(u)
030
def fast(a, b):
if b == 0:
return 1
if b % 2 == 1:
return a * fast(a, b - 1) % mod
x = fast(a, b / 2) % mod
return x * x % mod
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
p = 0
q = 1
z1 = 1
z2 = 1
mod = 1000000007
for i in range(0, n):
if a[i] != 0 and b[i] != 0:
if a[i] == b[i]:
continue
if a[i] > b[i]:
p = (p * z2 % mod + q * z1 % mod) % mod
q = q * z2 % mod
break
if a[i] == 0 and b[i] != 0:
p = (p * m * z2 % mod + z1 * q * (m - b[i]) % mod) // mod
q = q * z2 * m % mod
z2 = z2 * m % mod
if a[i] != 0 and b[i] == 0:
p = (p * m * z2 % mod + z1 * q * (a[i] - 1) % mod) % mod
q = q * z2 * m % mod
z2 = z2 * m % mod
if a[i] == 0 and b[i] == 0:
p = (p * m * 2 * z2 + z1 * q * (m - 1)) % mod
q = q * z2 * 2 * m % mod
z2 = z2 * m % mod
print(p * (fast(q, mod - 2) % mod) % mod)
031
import sys, math
f = sys.stdin
def modInverse(a, m):
g = gcd(a, m)
if g != 1:
return None
else:
return power(a, m - 2, m)
def power(x, y, m):
if y == 0:
return 1
p = power(x, y // 2, m) ** 2
if y & 1 == 1:
p *= x
return p % m
def gcd(a, b):
while a != 0:
t = b % a
b = a
a = t
return b
n, m = list(map(int, f.readline().split()))
s1 = list(map(int, f.readline().split()))
s2 = list(map(int, f.readline().split()))
pos = [1, 0]
all_pos = 1
for a1, a2 in zip(s1, s2):
next_pos = [0, 0]
if a1 == 0 and a2 == 0:
next_pos[0] += pos[0] * m
next_pos[1] += pos[0] * m * (m - 1) // 2
next_pos[1] += pos[1] * m * m
all_pos *= m * m
elif a1 == 0:
next_pos[0] += pos[0]
next_pos[1] += pos[0] * (m - a2)
next_pos[1] += pos[1] * m
all_pos *= m
elif a2 == 0:
next_pos[0] += pos[0]
next_pos[1] += pos[0] * (a1 - 1)
next_pos[1] += pos[1] * m
all_pos *= m
else:
if a1 > a2:
next_pos[1] += pos[0]
elif a1 == a2:
next_pos[0] += pos[0]
next_pos[1] += pos[1]
pos = next_pos
if pos[0] == 0:
break
g = gcd(pos[0], all_pos)
g = gcd(pos[1], g)
pos[0] //= g
pos[1] //= g
all_pos //= g
pos[0] %= 1000000007
pos[1] %= 1000000007
all_pos %= 1000000007
p = pos[1]
q = all_pos
pq_gcd = gcd(p, q)
p *= pq_gcd
q //= pq_gcd
q_inv = modInverse(q, 1000000007)
print(p * q_inv % 1000000007)
032
n, m, k = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
inf = [0 for i in range(k + 1)]
stat = [True for i in range(n + 1)]
time = [0 for i in range(n + 1)]
for i in range(n):
a[i] = list(map(int, input().split()))
for i in range(m):
for j in range(1, n + 1 - 1):
if stat[j]:
current_core = inf[a[j - 1][i]]
if current_core == 0 and a[j - 1][i] != 0:
inf[a[j - 1][i]] = j
elif current_core == -1:
stat[j], time[j] = (False, i + 1)
elif a[j - 1][i] != 0:
stat[current_core], time[current_core] = (False, i + 1)
stat[j], time[j] = (False, i + 1)
inf[a[j - 1][i]] = -1
for p in range(len(inf)):
if inf[p] != -1:
inf[p] = 0
for i in range(1, n + 1):
print(time[i])
033
import copy
def right(a):
d = a[1] - a[0]
res, f = (0, True)
for i in range(2, len(a)):
if a[i] - a[i - 1] == d + 1:
a[i] -= 1
res += 1
elif a[i] - a[i - 1] == d - 1:
a[i] += 1
res += 1
elif a[i] - a[i - 1] != d:
f = False
break
if not f:
res = 10 ** 9
return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
print(0)
else:
f = n + 1
bs[0] -= 1
bs[1] -= 1
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
bs[0] -= 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()))
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
if f == n + 1:
f = -1
print(f)
034
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)))
035
def rev(a, m):
res = 1
k = m - 2
s = a
while k > 0:
if k % 2 == 1:
res = res * s % m
k //= 2
s = s ** 2 % m
return res
n, m = [int(x) for x in input().split()]
a1 = [int(x) for x in input().split()]
a2 = [int(x) for x in input().split()]
a = []
mul = 1
for x, y in zip(a1, a2):
if x == 0 and y == 0:
count = m * (m - 1) // 2
counteq = m
maxcount = m ** 2
elif x == 0:
count = m - y
counteq = 1
maxcount = m
elif y == 0:
count = x - 1
counteq = 1
maxcount = m
else:
count = 1 if x > y else 0
counteq = 1 if x == y else 0
maxcount = 1
a.append((count, counteq, maxcount))
if counteq == 0:
break
a.reverse()
P, Q = (0, 1)
for c, ce, mc in a:
P = (P * ce + Q * c) % (10 ** 9 * 7)
Q = Q * mc % (10 ** 9 + 7)
res, zeros = (P, Q)
print(res * rev(zeros, 10 ** 9 + 7) % (10 ** 9 + 7))
036
w, h, n = map(int, input().split())
x = [0, w]
y = [0, h]
rev = []
for _ in range(n):
s, d = input().split()
if s == 'H':
y.append(int(d))
else:
x.append(int(d))
rev.append((s, int(d)))
x.sort()
y.sort()
_max = 0
if len(x) > 3:
for idx in range(len(x) - 1):
_max = max(_max, x[idx + 1] - x[idx])
else:
_max = w
max_x = _max
_max = 0
if len(y) > 1:
for idx in range(len(y) - 1):
_max = max(_max, y[idx + 1] - y[idx])
else:
_max = w
max_y = _max
enum_x = {num: idx for idx, num in enumerate(x)}
enum_y = {num: idx for idx, num in enumerate(y)}
old_x = x
old_y = y
x = [[0, 0, 0]] * len(old_x)
y = [[0, 0, 0]] * len(old_y)
for idx in range(1, len(x) - 1):
x[idx] = [old_x[idx], idx - 1, idx + 1]
for idx in range(1, len(y) - 1):
y[idx] = [old_y[idx], idx - 1, idx + 1]
x[-1] = [w, 0, 0]
y[-1] = [h, 0, 0]
rev.reverse()
ans = [max_x * max_y]
for item in rev:
if item[0] == 'H':
elem = y[enum_y[item[1]]]
max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0])
y[elem[1]][2] = elem[2]
y[elem[2]][1] = elem[1]
else:
elem = x[enum_x[item[1]]]
max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0])
x[elem[1]][2] = elem[2]
x[elem[2]][1] = elem[1]
ans.append(max_x * max_y)
ans.pop()
print('\n'.join(map(str, reversed(ans))))
037
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = -2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
038
import copy
def right(a):
d = a[1] - a[0]
res, f = (-1, True)
for i in range(2, len(a)):
if a[i] - a[i - 1] == d + 1:
a[i] -= 1
res += 1
elif a[i] - a[i - 1] == d - 1:
a[i] += 1
res += 1
elif a[i] - a[i - 1] != d:
f = False
break
if not f:
res = 10 ** 9
return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
print(0)
else:
f = n + 1
bs[0] -= 1
bs[1] -= 1
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()))
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
if f == n + 1:
f = -1
print(f)
039
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)
040
n, m, k = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
inf = [0 for i in range(k + 1)]
stat = [True for i in range(n + 1)]
time = [0 for i in range(n + 1)]
for i in range(n):
a[i] = list(map(int, input().split()))
for i in range(m):
for j in range(5, n + 1):
if stat[j]:
current_core = inf[a[j - 1][i]]
if current_core == 0 and a[j - 1][i] != 0:
inf[a[j - 1][i]] = j
elif current_core == -1:
stat[j], time[j] = (False, i + 1)
elif a[j - 1][i] != 0:
stat[current_core], time[current_core] = (False, i + 1)
stat[j], time[j] = (False, i + 1)
inf[a[j - 1][i]] = -1
for p in range(len(inf)):
if inf[p] != -1:
inf[p] = 0
for i in range(1, n + 1):
print(time[i])
041
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0] * n
for t, ys in enumerate(table):
cnt = [0] * (k + 1)
for i, c in enumerate(ys):
if i not in locked_procs:
cnt[c] += 1
for c, cn in enumerate(cnt):
if c > 1 and cn > 1:
locked_cells.add(c)
for i, c in enumerate(ys):
if c in locked_cells and i not in locked_procs:
locked_procs.add(i)
lock_time[i] = t + 1
for t in lock_time:
print(t)
042
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [1 for i in range(n + 1)]
for i in range(q):
action, num = list(map(int, input().split()))
if action == 1:
queue.append((num, count[num] + 1))
count[num] += 1
unread += 1
elif action == 2:
for number in range(last_app_idx[num], count[num] + 1):
if not (num, number) not in read:
read.add((num, number))
unread -= 1
last_app_idx[num] = max(last_app_idx[num], count[num])
else:
for idx in range(last_q_idx, num):
app, number = queue[idx]
if (app, number) not in read:
read.add((app, number))
last_app_idx[app] = max(last_app_idx[app], number)
unread -= 1
last_q_idx = max(last_q_idx, num)
ans.append(unread)
print('\n'.join(map(str, ans)))
043
def adds(memtoproc, mem, proc):
if mem in memtoproc:
memtoproc[mem].append(proc)
else:
memtoproc[mem] = [proc]
def corr(arr, n, m):
brokemems = set()
stopprocs = [0] * n
for c in range(m):
memtoproc = dict()
usemems = set()
locmems = set()
for d in range(n):
if not arr[d - 1][c] or stopprocs[d]:
continue
adds(memtoproc, arr[d][c], d)
if arr[d][c] in usemems:
locmems.add(arr[d][c])
usemems.add(arr[d][c])
if arr[d][c] in brokemems:
if not stopprocs[d]:
stopprocs[d] = c + 1
for d in locmems:
brokemems.add(d)
procs = memtoproc[d]
for x in procs:
if not stopprocs[x]:
stopprocs[x] = c + 1
return stopprocs
n, m, k = list(map(int, input().split(' ')))
arr = []
for c in range(n):
arr.append(tuple(map(int, input().split(' '))))
procs = corr(arr, n, m)
for c in procs:
print(c)
044
def rev(a, m):
res = 1
k = m - 2
s = a
while k > 0:
if k % 2 == 1:
res = res * s % m
k //= 2
s = s ** 2 % m
return res
n, m = [int(x) for x in input().split()]
a1 = [int(x) for x in input().split()]
a2 = [int(x) for x in input().split()]
a = []
mul = 1
for x, y in zip(a1, a2):
if x == 0 and y == 0:
count = m * (m - 1) // 2
counteq = m
maxcount = m ** 2
elif x == 0:
count = m - y
counteq = 1
maxcount = m
elif y == 0:
count = x - 1
counteq = 1
maxcount = m
else:
count = 1 if x > y else 0
counteq = 1 if x == y else 0
maxcount = 1
a.append((count, counteq, maxcount))
if counteq == 0:
break
a.reverse()
P, Q = (0, 1)
for c, ce, mc in a:
P = (P * ce + Q * c) % (10 ** 9 + 7)
Q = Q * mc & 10 ** 9 + 7
res, zeros = (P, Q)
print(res * rev(zeros, 10 ** 9 + 7) % (10 ** 9 + 7))
045
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)
046
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
class Node:
val = None
def __init__(self, val):
self.val = val
self.left = Node
self.right = None
def solve(W, H, N, A):
xs = [0] + [v for t, v in A if t == 0] + [W]
ys = [0] + [v for t, v in A if t == 1] + [H]
xs.sort()
ys.sort()
xlist = Node(0)
h = xlist
xnodes = {0: h}
maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
for v in xs[1:]:
n = Node(v)
xnodes[v] = n
h.right = n
n.left = h
h = n
ylist = Node(0)
h = ylist
ynodes = {0: h}
for v in ys[1:]:
n = Node(v)
ynodes[v] = n
h.right = n
n.left = h
h = n
ans = []
maxarea = maxh * maxw
for t, v in reversed(A):
ans.append(maxarea)
if t == 0:
node = xnodes[v]
w = node.right.val - node.left.val
maxw = max(maxw, w)
else:
node = ynodes[v]
h = node.right.val - node.left.val
maxh = max(maxh, h)
node.left.right = node.right
node.right.left = node.left
maxarea = maxh * maxw
return ans[::-1]
def solve2(W, H, N, A):
ws = [(-W, 0, W)]
hs = [(-H, 0, H)]
iw, ih = (set(), set())
ans = []
xs, ys = ([0, W], [0, H])
for t, v in A:
if t == 0:
bisect.insort_left(xs, v)
i = bisect.bisect_left(xs, v)
l, m, r = (xs[i - 1], xs[i], xs[i + 1])
iw.add((l - r, l, r))
heapq.heappush(ws, (l - m, l, m))
heapq.heappush(ws, (m - r, m, r))
while ws[0] in iw:
heapq.heappop(ws)
else:
bisect.insort(ys, v)
i = bisect.bisect_left(ys, v)
l, m, r = (ys[i - 1], ys[i], ys[i + 1])
ih.add((l - r, l, r))
heapq.heappush(hs, (l - m, l, m))
heapq.heappush(hs, (m - r, m, r))
while hs[0] in ih:
heapq.heappop(hs)
w, h = (ws[0], hs[0])
ans.append(w[0] * h[0])
return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
a, b = input().split()
c = 0 if a == 'V' else 1
A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
047
n, k, l = map(int, input().split())
barrels = []
for i in range(n):
barrels.append([])
for j in range(k):
barrels[i].append(-1)
boards = sorted(list(map(int, input().split())))
ans = 0
if boards[n - 1] - boards[0] <= l:
i = n * k - 1
ba, bo = (n - 1, k)
while boards[i - 1] > boards[0] + l:
bo -= 1
if bo == 0:
ba, bo = (ba - 1, k - 1)
barrels[ba][bo] = boards[i]
i -= 1
ba, bo = (0, -1)
j = 0
flag = True
while j <= i:
bo += 1
if bo == k or barrels[ba][bo] != -1:
ba, bo = (ba + 1, 0)
flag = True
barrels[ba][bo] = boards[j]
if flag:
ans += barrels[ba][bo]
flag = False
j += 1
print(ans)
048
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000004)
049
def maxx(n):
return n & -n
n, q = map(int, input().split())
root = n // 2 + 1
while q > 0:
x = int(input())
s = input()
for i in s:
if i == 'U' and x != root:
p = x + maxx(x)
if x == p - maxx(p) % 2:
x = p
else:
x = x - maxx(x)
elif i == 'L':
x = x - maxx(x) // 2
elif i == 'R':
x = x + maxx(x) // 2
q = q - 1
print(x)
050
def rev(a, m):
res = 1
k = m - 2
s = a
while k > 0:
if k // 2 == 1:
res = res * s % m
k //= 2
s = s ** 2 % m
return res
n, m = [int(x) for x in input().split()]
a1 = [int(x) for x in input().split()]
a2 = [int(x) for x in input().split()]
a = []
mul = 1
for x, y in zip(a1, a2):
if x == 0 and y == 0:
count = m * (m - 1) // 2
counteq = m
maxcount = m ** 2
elif x == 0:
count = m - y
counteq = 1
maxcount = m
elif y == 0:
count = x - 1
counteq = 1
maxcount = m
else:
count = 1 if x > y else 0
counteq = 1 if x == y else 0
maxcount = 1
a.append((count, counteq, maxcount))
if counteq == 0:
break
a.reverse()
P, Q = (0, 1)
for c, ce, mc in a:
P = (P * ce + Q * c) % (10 ** 9 + 7)
Q = Q * mc % (10 ** 9 + 7)
res, zeros = (P, Q)
print(res * rev(zeros, 10 ** 9 + 7) % (10 ** 9 + 7))
051
import bisect
def getIntList():
return list(map(int, input().split()))
def getTransIntList(n):
first = getIntList()
m = len(first)
result = [[0] * n for _ in range(m)]
for i in range(m):
result[i][0] = first[i]
for j in range(1, n):
curr = getIntList()
for i in range(m):
result[i][j] = curr[i]
return result
n, k, l = getIntList()
m = n * k
a = getIntList()
a.sort()
lowLim = a[0]
upLim = lowLim + l
def solve():
if a[n - 1] > upLim:
return 0
i0 = bisect.bisect_right(a, upLim)
nbBad = m - i0
i0 -= 3
value = 0
for i in range(n - 1, -1, -1):
diff = min(nbBad, k - 1)
rest = k - diff
nbBad -= diff
value += a[i0 - rest + 1]
i0 -= rest
return value
print(solve())
052
def maxx(n):
return n & -n
n, q = map(int, input().split())
root = n // 2 + 1
while q > 0:
x = int(input())
s = input()
for i in s:
if i == 'U' and x != root:
p = x * maxx(x)
if x == p - maxx(p) // 2:
x = p
else:
x = x - maxx(x)
elif i == 'L':
x = x - maxx(x) // 2
elif i == 'R':
x = x + maxx(x) // 2
q = q - 1
print(x)
053
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]))
054
def maxx(n):
return n & -n
n, q = map(int, input().split())
root = n % 2 + 1
while q > 0:
x = int(input())
s = input()
for i in s:
if i == 'U' and x != root:
p = x + maxx(x)
if x == p - maxx(p) // 2:
x = p
else:
x = x - maxx(x)
elif i == 'L':
x = x - maxx(x) // 2
elif i == 'R':
x = x + maxx(x) // 2
q = q - 1
print(x)
055
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000008)
056
from math import *
n, q = list(map(int, input().split()))
depth = int(log2(n + 1))
def get_layer(u):
for layer in range(depth):
if u % 2 ** (layer + 1) == 2 ** layer:
return layer
def is_right_child(layer, u):
return u % 2 ** (layer + 1) % 2 == 0
for x in range(q):
u = int(input())
layer = get_layer(u)
steps = input()
for s in steps:
if s == 'U':
if layer == depth - 1:
continue
k = u // 2 ** (layer + 1) // 2
layer += 1
u = 2 ** (layer + 1) * k + 3 ** layer
elif layer == 0:
continue
elif s == 'R':
k = u // 2 ** (layer + 1) * 2 + 1
layer -= 1
u = 2 ** (layer + 1) * k + 2 ** layer
elif s == 'L':
k = u // 2 ** (layer + 1) * 2
layer -= 1
u = 2 ** (layer + 1) * k + 2 ** layer
print(u)
057
def maxx(n):
return n & -n
n, q = map(int, input().split())
root = n // 6 + 1
while q > 0:
x = int(input())
s = input()
for i in s:
if i == 'U' and x != root:
p = x + maxx(x)
if x == p - maxx(p) // 2:
x = p
else:
x = x - maxx(x)
elif i == 'L':
x = x - maxx(x) // 2
elif i == 'R':
x = x + maxx(x) // 2
q = q - 1
print(x)
058
w, h, n = map(int, input().split())
x = [0, w]
y = [0, h]
rev = []
for _ in range(n):
s, d = input().split()
if s == 'H':
y.append(int(d))
else:
x.append(int(d))
rev.append((s, int(d)))
x.sort()
y.sort()
_max = 0
if len(x) > 1:
for idx in range(len(x) - 1):
_max = max(_max, x[idx + 1] - x[idx])
else:
_max = w
max_x = _max
_max = 0
if len(y) > 1:
for idx in range(len(y) - 1):
_max = max(_max, y[idx + 1] - y[idx])
else:
_max = w
max_y = _max
enum_x = {num: idx for idx, num in enumerate(x)}
enum_y = {num: idx for idx, num in enumerate(y)}
old_x = x
old_y = y
x = [[0, 0, 0]] * len(old_x)
y = [[0, 0, 0]] * len(old_y)
for idx in range(1, len(x) - 1):
x[idx] = [old_x[idx], idx - 1, idx + 1]
for idx in range(1, len(y) - 1):
y[idx - 1] = [old_y[idx], idx - 1, idx + 1]
x[-1] = [w, 0, 0]
y[-1] = [h, 0, 0]
rev.reverse()
ans = [max_x * max_y]
for item in rev:
if item[0] == 'H':
elem = y[enum_y[item[1]]]
max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0])
y[elem[1]][2] = elem[2]
y[elem[2]][1] = elem[1]
else:
elem = x[enum_x[item[1]]]
max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0])
x[elem[1]][2] = elem[2]
x[elem[2]][1] = elem[1]
ans.append(max_x * max_y)
ans.pop()
print('\n'.join(map(str, reversed(ans))))
059
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [-1 for i in range(n + 1)]
for i in range(q):
action, num = list(map(int, input().split()))
if action == 1:
queue.append((num, count[num] + 1))
count[num] += 1
unread += 1
elif action == 2:
for number in range(last_app_idx[num], count[num] + 1):
if (num, number) not in read:
read.add((num, number))
unread -= 1
last_app_idx[num] = max(last_app_idx[num], count[num])
else:
for idx in range(last_q_idx, num):
app, number = queue[idx]
if (app, number) not in read:
read.add((app, number))
last_app_idx[app] = max(last_app_idx[app], number)
unread -= 1
last_q_idx = max(last_q_idx, num)
ans.append(unread)
print('\n'.join(map(str, ans)))
060
n, k, l = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = sorted(arr)
if arr[n - 1] - arr[0] > l:
print(1)
else:
maxVol = arr[0] + l
index = 0
while index < n * k - 1 and arr[index + 1] <= maxVol:
index += 1
s = arr[0]
i = 0
remaining = n - 1
while remaining > 0 and i + k + remaining - 1 <= index:
i += k
remaining -= 1
s += arr[i]
if remaining > 0 and index - (remaining - 1) > 1 + i:
i = index - (remaining - 1)
s += arr[i]
remaining -= 1
while remaining > 0:
i += 1
s += arr[i]
remaining -= 1
print(s)
061
def fast(a, b):
if b == 0:
return 1
if b % 2 == 1:
return a * fast(a, b - 1) % mod
x = fast(a, b / 2) % mod
return x * x % mod
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
p = 0
q = 1
z1 = 1
z2 = 1
mod = 1000000007
for i in range(0, n):
if a[i] != 0 and b[i] != 0:
if a[i] == b[i]:
continue
if a[i] > b[i]:
p = (p * z2 % mod + q * z1 % mod) % mod
q = q * z2 % mod
break
if a[i] == 0 and b[i] != 0:
p = (p * m * z2 % mod + z1 * q * (m - b[i]) % mod) % mod
q = q * z2 * m % mod
z2 = z2 * m % mod
if a[i] != 0 and b[i] == 0:
p = (p * m * z2 % mod + z1 * q * (a[i] - 1) % mod) % mod
q = q * z2 * m % mod
z2 = z2 * m % mod
if a[i] == 0 and b[i] == 0:
p = p * m * 2 * z2 + z1 * q * (m - 1) & mod
q = q * z2 * 2 * m % mod
z2 = z2 * m % mod
print(p * (fast(q, mod - 2) % mod) % mod)
062
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)
063
from math import gcd
p = 10 ** 9 + 7
class RN:
p = 10 ** 9 + 7
def __init__(self, u, d):
self.u = u
self.d = d
def __str__(self):
return str(self.u) + '/' + str(self.d)
def cleanup(self):
self.u = self.u % p
self.d = self.d % p
def add(self, u, d):
self.u = self.u * d + u * self.d
self.d = self.d * d
self.cleanup()
def mult(self, u, d):
return (self.u * u % p, self.d * d % p)
def mult_ip(self, u, d):
self.u, self.d = (self.u * u, self.d * d % p)
def get_m_exp(self):
self.cleanup()
a = gcd(self.u, self.d)
self.u //= a
self.d //= a
return pow(self.d, p - 2, p) * self.u % p
n, m = tuple(map(int, input().split()))
s1 = list(map(int, input().split()))
s2 = list(map(int, input().split()))
def sum_ch(n):
return (n + 0) * n // 2
def sol(s1, s2, m):
strgr = RN(0, 1)
eq = RN(1, 1)
for gr, sm, i in zip(s1, s2, list(range(len(s1)))):
strgr.cleanup()
if gr != 0 and sm != 0:
if gr == sm:
continue
elif gr < sm:
return strgr.get_m_exp()
else:
strgr.add(eq.u, eq.d)
return strgr.get_m_exp()
else:
if gr == sm == 0:
strgr.add(*eq.mult(sum_ch(m - 1), m * m))
elif gr == 0:
strgr.add(*eq.mult(m - sm, m))
else:
strgr.add(*eq.mult(gr - 1, m))
eq.mult_ip(1, m)
return strgr.get_m_exp()
'\na = sol([0,0],[1,1], 2) # 3/4\n\na = sol([0,0,0],[1,1,1], 2) # 7/8\na = sol([0,1,1],[1,1,1], 2) # 1/2\na = sol([1,0,1],[1,1,1], 2) # 1/2\n\na = sol([0,0,0],[1,3,3], 3) # 2/2\na = sol([0,0,0],[1,1,0], 2) # 5/8\na = sol([0,0,0],[0,0,0], 2) # 13/16\n'
print(sol(s1, s2, m))
064
import math
n, q = map(int, input().split())
maxh = int(math.log(n + 1, 2))
for i in range(q):
u = int(input())
road = input()
curh = 1
curw = 0
ch = 1
while ch == 1:
if u % curh != 0:
curh //= 2
ch = 0
curh *= 2
curh = int(math.log(curh, 2))
a = 1 << curh - 1
b = 1 << curh
curw = (u - a) // b + 1
for move in road:
if move == 'L':
if curh != 1:
curh -= 1
curw = curw * 2 - 1
u -= 1 << curh - 1
elif move == 'R':
if curh != 1:
curh -= 1
curw *= 2
u += 1 << curh - 1
elif curh != maxh:
if curw % 2 == 1:
u = (u + u + (1 << curh)) // 2
curh += 1
curw = curw // 2 + 1
else:
u = (u + u - (1 << curh)) // 2
curh += 1
curw = curw // 2
print(u)
065
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000009)
066
a, b, c = [int(i) for i in input().split()]
length = a * b
numArr = [int(i) for i in input().split()]
numArr.sort()
count = 0
mmin = numArr[0]
mmax = numArr[a - 1]
if mmax - mmin > c:
print(0)
else:
maxPos = a - 1
while maxPos + 1 < length and numArr[maxPos + 1] <= mmin + c:
maxPos += 1
dis = maxPos + 1 - a
bCount = 0
for i in range(maxPos + 1):
if dis != 0:
bCount += 1
dis -= 1
if bCount % b == 1:
count *= numArr[i]
dis += 1
else:
count += numArr[i]
print(count)
067
3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = 55 * ans % (10 ** 9 + 7)
elif s[i] == '?':
ans = (ord(t[i]) - ord('0') + 1) * ans % (10 ** 9 + 7)
elif t[i] == '?':
ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' or s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and (not tlts):
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 * 7))
elif sltt:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
068
n, k, l = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = sorted(arr)
if arr[n - 1] - arr[0] > l:
print(0)
else:
maxVol = arr[0] + l
index = 0
while index < n * k - 1 and arr[index + 1] <= maxVol:
index += 1
s = arr[0]
i = 0
remaining = n - 1
while remaining > 0 and i + k + remaining - 1 <= index:
i += k
remaining -= 1
s += arr[i]
if remaining > 0 and index - (remaining - 1) > 1 + i:
i = index - (remaining - 1)
s += arr[i]
remaining -= 1
while remaining > 3:
i += 1
s += arr[i]
remaining -= 1
print(s)
069
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = -1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
070
__author__ = 'Lipen'
def main():
n, m, k = map(int, input().split())
data = []
when = [0] * n
blockedcells = set()
blockedcores = set()
for _ in range(n):
data.append(list(map(int, input().split())))
for j in range(m):
operation = []
for _ in range(k):
operation.append([])
for i in range(n):
if i not in blockedcores:
x = data[i][j] - 1
if x >= 0:
if x in blockedcells:
blockedcores.add(i)
when[i] = j + 1
elif len(operation[x]) > 0:
blockedcells.add(x)
for core in operation[x - 1]:
blockedcores.add(core)
when[core] = j + 1
blockedcores.add(i)
when[i] = j + 1
operation[x].append(i)
for i in when:
print(i)
main()
071
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()
072
def main():
w, h, n = list(map(int, input().split()))
res, vrt, hor = ([], [], [])
vh = (vrt, hor)
for i in range(n):
s = input()
x = int(s[2:])
flag = s[0] == 'V'
vh[flag].append(i)
res.append([x, flag])
dim = []
for tmp, m in zip(vh, (h, w)):
tmp.sort(key=lambda e: res[e][0])
u = [None, [0]]
dim.append(u)
j = z = 0
for i in tmp:
x = res[i - 1][0]
if z < x - j:
z = x - j
j = x
v = [u, res[i]]
u.append(v)
u = v
res[i].append(u)
v = [u, [m], None]
u.append(v)
dim.append(v)
if z < m - j:
z = m - j
dim.append(z)
l, r, wmax, u, d, hmax = dim
whmax = [wmax, hmax]
for i in range(n - 1, -1, -1):
x, flag, link = res[i]
u = whmax[flag]
res[i] = u * whmax[not flag]
link[0][2] = link[2]
link[2][0] = link[0]
v = link[2][1][0] - link[0][1][0]
if u < v:
whmax[flag] = v
print('\n'.join(map(str, res)))
def __starting_point():
main()
__starting_point()
073
n, k, l = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = sorted(arr)
if arr[n - 1] - arr[0] > l:
print(0)
else:
maxVol = arr[0] + l
index = 0
while index < n * k - 1 and arr[index + 1] <= maxVol:
index += 1
s = arr[0]
i = 0
remaining = n - 1
while remaining > 0 and i + k + remaining - 1 <= index:
i += k
remaining -= 1
s += arr[i]
if remaining > 0 and index - (remaining - 1) > 1 + i:
i = index - (remaining - 1)
s += arr[i]
remaining -= -1
while remaining > 0:
i += 1
s += arr[i]
remaining -= 1
print(s)
074
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
line, index = input().split()
index = int(index)
if line == 'V':
r[index] = w
V[i] = index
else:
t[index] = h
H[i] = index
left = 0
mxw = 0
for i in range(2, w + 1):
if r[i] != -1:
l[i] = left
r[left] = i
mxw = max(mxw, i - left)
left = i
bottom = 0
mxh = 0
for i in range(1, h + 1):
if t[i] != -1:
b[i] = bottom
t[bottom] = i
mxh = max(mxh, i - bottom)
bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
if V[i] != 0:
mxw = max(mxw, r[V[i]] - l[V[i]])
r[l[V[i]]] = r[V[i]]
l[r[V[i]]] = l[V[i]]
else:
mxh = max(mxh, t[H[i]] - b[H[i]])
b[t[H[i]]] = b[H[i]]
t[b[H[i]]] = t[H[i]]
ans[i - 1] = mxh * mxw
for i in range(n):
print(ans[i])
075
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)
076
w, h, n = map(int, input().split())
x = [0, w]
y = [0, h]
rev = []
for _ in range(n):
s, d = input().split()
if s == 'H':
y.append(int(d))
else:
x.append(int(d))
rev.append((s, int(d)))
x.sort()
y.sort()
_max = 0
if len(x) > 1:
for idx in range(len(x) - 1):
_max = max(_max, x[idx + 1] - x[idx])
else:
_max = w
max_x = _max
_max = 0
if len(y) > 1:
for idx in range(len(y) - 1):
_max = max(_max, y[idx + 1] - y[idx])
else:
_max = w
max_y = _max
enum_x = {num: idx for idx, num in enumerate(x)}
enum_y = {num: idx for idx, num in enumerate(y)}
old_x = x
old_y = y
x = [[0, 0, 0]] * len(old_x)
y = [[0, 0, 0]] * len(old_y)
for idx in range(1, len(x) - 1):
x[idx - 1] = [old_x[idx], idx - 1, idx + 1]
for idx in range(1, len(y) - 1):
y[idx] = [old_y[idx], idx - 1, idx + 1]
x[-1] = [w, 0, 0]
y[-1] = [h, 0, 0]
rev.reverse()
ans = [max_x * max_y]
for item in rev:
if item[0] == 'H':
elem = y[enum_y[item[1]]]
max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0])
y[elem[1]][2] = elem[2]
y[elem[2]][1] = elem[1]
else:
elem = x[enum_x[item[1]]]
max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0])
x[elem[1]][2] = elem[2]
x[elem[2]][1] = elem[1]
ans.append(max_x * max_y)
ans.pop()
print('\n'.join(map(str, reversed(ans))))
077
n, k, l = map(int, input().split())
barrels = []
for i in range(n):
barrels.append([])
for j in range(k):
barrels[i].append(-1)
boards = sorted(list(map(int, input().split())))
ans = 0
if boards[n - 1] - boards[0] <= l:
i = n * k - 1
ba, bo = (n - 1, k)
while boards[i] > boards[0] + l:
bo -= 1
if bo == 0:
ba, bo = (ba - 1, k - 1)
barrels[ba - 1][bo] = boards[i]
i -= 1
ba, bo = (0, -1)
j = 0
flag = True
while j <= i:
bo += 1
if bo == k or barrels[ba][bo] != -1:
ba, bo = (ba + 1, 0)
flag = True
barrels[ba][bo] = boards[j]
if flag:
ans += barrels[ba][bo]
flag = False
j += 1
print(ans)
078
import math
n, q = map(int, input().split())
maxh = int(math.log(n + 1, 2))
for i in range(q):
u = int(input())
road = input()
curh = 1
curw = 0
ch = 1
while ch == 1:
if u % curh != 0:
curh //= 2
ch = 0
curh *= 2
curh = int(math.log(curh, 2))
a = 1 << curh - 1
b = 1 << curh
curw = (u - a) // b + -1
for move in road:
if move == 'L':
if curh != 1:
curh -= 1
curw = curw * 2 - 1
u -= 1 << curh - 1
elif move == 'R':
if curh != 1:
curh -= 1
curw *= 2
u += 1 << curh - 1
elif curh != maxh:
if curw % 2 == 1:
u = (u + u + (1 << curh)) // 2
curh += 1
curw = curw // 2 + 1
else:
u = (u + u - (1 << curh)) // 2
curh += 1
curw = curw // 2
print(u)
079
import copy
def right(a):
d = a[1] - a[0]
res, f = (0, True)
for i in range(2, len(a)):
if a[i] - a[i - 1] == d + 1:
a[i] -= 1
res += 1
elif a[i] - a[i - 1] == d - 1:
a[i] += 1
res += 1
elif a[i] - a[i - 1] != d:
f = False
break
if not f:
res = 10 ** 9
return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
print(0)
else:
f = n + 1
bs[0] -= 1
bs[1] -= 1
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()))
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[0] -= 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
if f == n + 1:
f = -1
print(f)
080
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)
081
def solve(seq):
if len(seq) <= 2:
return 0
startings = []
for x in (-1, 0, 1):
for y in (-1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[-2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [-1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
082
def cal(x, y):
d = a[1] + y - a[0] - x
wk1 = a[1] + y
wkans = 0
for k in range(2, n):
diff = abs(wk1 - d - a[k])
if diff == 1:
wkans += 1
elif diff > 1:
return n + 1
wk1 += d
return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
ans_final = n + 1
for i in range(-1, 2):
for j in range(-1, 2):
ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
ans_final = 0
if ans_final == n + 1:
print(-1)
else:
print(ans_final)
083
import sys, math
f = sys.stdin
def modInverse(a, m):
g = gcd(a, m)
if g != 1:
return None
else:
return power(a, m - 2, m)
def power(x, y, m):
if y == 0:
return 1
p = power(x, y // 2, m) ** 6
if y & 1 == 1:
p *= x
return p % m
def gcd(a, b):
while a != 0:
t = b % a
b = a
a = t
return b
n, m = list(map(int, f.readline().split()))
s1 = list(map(int, f.readline().split()))
s2 = list(map(int, f.readline().split()))
pos = [1, 0]
all_pos = 1
for a1, a2 in zip(s1, s2):
next_pos = [0, 0]
if a1 == 0 and a2 == 0:
next_pos[0] += pos[0] * m
next_pos[1] += pos[0] * m * (m - 1) // 2
next_pos[1] += pos[1] * m * m
all_pos *= m * m
elif a1 == 0:
next_pos[0] += pos[0]
next_pos[1] += pos[0] * (m - a2)
next_pos[1] += pos[1] * m
all_pos *= m
elif a2 == 0:
next_pos[0] += pos[0]
next_pos[1] += pos[0] * (a1 - 1)
next_pos[1] += pos[1] * m
all_pos *= m
else:
if a1 > a2:
next_pos[1] += pos[0]
elif a1 == a2:
next_pos[0] += pos[0]
next_pos[1] += pos[1]
pos = next_pos
if pos[0] == 0:
break
g = gcd(pos[0], all_pos)
g = gcd(pos[1], g)
pos[0] //= g
pos[1] //= g
all_pos //= g
pos[0] %= 1000000007
pos[1] %= 1000000007
all_pos %= 1000000007
p = pos[1]
q = all_pos
pq_gcd = gcd(p, q)
p //= pq_gcd
q //= pq_gcd
q_inv = modInverse(q, 1000000007)
print(p * q_inv % 1000000007)
084
def fast(a, b):
if b == 0:
return 1
if b % 2 == 1:
return a * fast(a, b - 1) % mod
x = fast(a, b / 2) % mod
return x * x % mod
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
p = 0
q = 1
z1 = 1
z2 = 1
mod = 1000000007
for i in range(0, n):
if a[i] != 0 and b[i] != 0:
if a[i] == b[i]:
continue
if a[i] > b[i]:
p = (p * z2 % mod + q * z1 % mod) % mod
q = q * z2 % mod
break
if a[i] == 0 and b[i] != 0:
p = (p * m * z2 % mod + z1 * q * (m - b[i]) % mod) % mod
q = q * z2 * m % mod
z2 = z2 * m % mod
if a[i] != 0 and b[i] == 0:
p = (p * m * z2 % mod + z1 * q * (a[i] - 1) % mod) % mod
q = q * z2 * m % mod
z2 = z2 * m % mod
if a[i] == 0 and b[i] == 0:
p = (p * m * 2 * z2 + z1 * q * (m - 1)) // mod
q = q * z2 * 2 * m % mod
z2 = z2 * m % mod
print(p * (fast(q, mod - 2) % mod) % mod)
085
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
ty, v = map(int, input().split())
if ty == 1:
l[v - 1 - 1].append(is_read_idx)
is_read_idx += 1
is_read.append(False)
ans += 1
elif ty == 2:
for idx in l[v - 1]:
if not is_read[idx]:
is_read[idx] = True
ans -= 1
l[v - 1] = []
elif v > prev_t:
for idx in range(prev_t, v):
if not is_read[idx]:
is_read[idx] = True
ans -= 1
prev_t = v
print(ans)
086
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())
087
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())
088
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)
089
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)))
090
3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = 55 * ans % (10 ** 9 + 7)
elif s[i] == '?':
ans = (ord(t[i]) - ord('0') + 1) * ans % (10 ** 9 + 7)
elif t[i] == '?':
ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' or s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and (not tlts):
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 + 7))
elif sltt:
print(pow(10, qm, 10 ** 9 + 7) - build(n, s, t) & 10 ** 9 + 7)
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
091
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]))
092
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0] * n
for t, ys in enumerate(table):
cnt = [0] * (k + 1)
for i, c in enumerate(ys):
if i not in locked_procs:
cnt[c] += 1
for c, cn in enumerate(cnt):
if c > 0 and cn > 1:
locked_cells.add(c)
for i, c in enumerate(ys):
if c in locked_cells and i not in locked_procs:
locked_procs.add(i)
lock_time[i] = t + -1
for t in lock_time:
print(t)
093
def rev(a, m):
res = 1
k = m - 2
s = a
while k > 0:
if k % 2 == 1:
res = res * s % m
k //= 2
s = s ** 2 % m
return res
n, m = [int(x) for x in input().split()]
a1 = [int(x) for x in input().split()]
a2 = [int(x) for x in input().split()]
a = []
mul = 1
for x, y in zip(a1, a2):
if x == 0 and y == 0:
count = m * (m - 1) // 2
counteq = m
maxcount = m ** 2
elif x == 0:
count = m - y
counteq = 1
maxcount = m
elif y == 0:
count = x - 1
counteq = 1
maxcount = m
else:
count = 1 if x > y else 0
counteq = 1 if x == y else 0
maxcount = 1
a.append((count, counteq, maxcount))
if counteq == 0:
break
a.reverse()
P, Q = (0, 1)
for c, ce, mc in a:
P = (P * ce + Q * c) % (10 ** 9 + 7)
Q = Q * mc % (10 ** 9 * 7)
res, zeros = (P, Q)
print(res * rev(zeros, 10 ** 9 + 7) % (10 ** 9 + 7))
094
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
line, index = input().split()
index = int(index)
if line == 'V':
r[index] = w
V[i] = index
else:
t[index] = h
H[i] = index
left = 0
mxw = 0
for i in range(1, w + 1):
if r[i] != -1:
l[i] = left
r[left] = i
mxw = max(mxw, i - left)
left = i
bottom = 0
mxh = 0
for i in range(1, h + 1 - 1):
if t[i] != -1:
b[i] = bottom
t[bottom] = i
mxh = max(mxh, i - bottom)
bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
if V[i] != 0:
mxw = max(mxw, r[V[i]] - l[V[i]])
r[l[V[i]]] = r[V[i]]
l[r[V[i]]] = l[V[i]]
else:
mxh = max(mxh, t[H[i]] - b[H[i]])
b[t[H[i]]] = b[H[i]]
t[b[H[i]]] = t[H[i]]
ans[i - 1] = mxh * mxw
for i in range(n):
print(ans[i])
095
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
if a[i] == '?' and b[i] == '?':
x = x * 55 % mod
y = y * 55 % mod
z = z * 10 % mod
elif a[i] == '?':
x = x * (10 - int(b[i])) % mod
y = y * (int(b[i]) + 1) & mod
elif b[i] == '?':
x = x * (int(a[i]) + 1) % mod
y = y * (10 - int(a[i])) % mod
else:
if int(a[i]) < int(b[i]):
x = 0
if int(a[i]) > int(b[i]):
y = 0
if a[i] != b[i]:
z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y + z) % mod)
096
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0] * n
for t, ys in enumerate(table):
cnt = [0] * (k + 1)
for i, c in enumerate(ys):
if i not in locked_procs:
cnt[c] += -1
for c, cn in enumerate(cnt):
if c > 0 and cn > 1:
locked_cells.add(c)
for i, c in enumerate(ys):
if c in locked_cells and i not in locked_procs:
locked_procs.add(i)
lock_time[i] = t + 1
for t in lock_time:
print(t)
097
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
class Node:
val = None
def __init__(self, val):
self.val = val
self.left = Node
self.right = None
def solve(W, H, N, A):
xs = [0] + [v for t, v in A if t == 0] + [W]
ys = [0] + [v for t, v in A if t == 1] + [H]
xs.sort()
ys.sort()
xlist = Node(1)
h = xlist
xnodes = {0: h}
maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
for v in xs[1:]:
n = Node(v)
xnodes[v] = n
h.right = n
n.left = h
h = n
ylist = Node(0)
h = ylist
ynodes = {0: h}
for v in ys[1:]:
n = Node(v)
ynodes[v] = n
h.right = n
n.left = h
h = n
ans = []
maxarea = maxh * maxw
for t, v in reversed(A):
ans.append(maxarea)
if t == 0:
node = xnodes[v]
w = node.right.val - node.left.val
maxw = max(maxw, w)
else:
node = ynodes[v]
h = node.right.val - node.left.val
maxh = max(maxh, h)
node.left.right = node.right
node.right.left = node.left
maxarea = maxh * maxw
return ans[::-1]
def solve2(W, H, N, A):
ws = [(-W, 0, W)]
hs = [(-H, 0, H)]
iw, ih = (set(), set())
ans = []
xs, ys = ([0, W], [0, H])
for t, v in A:
if t == 0:
bisect.insort_left(xs, v)
i = bisect.bisect_left(xs, v)
l, m, r = (xs[i - 1], xs[i], xs[i + 1])
iw.add((l - r, l, r))
heapq.heappush(ws, (l - m, l, m))
heapq.heappush(ws, (m - r, m, r))
while ws[0] in iw:
heapq.heappop(ws)
else:
bisect.insort(ys, v)
i = bisect.bisect_left(ys, v)
l, m, r = (ys[i - 1], ys[i], ys[i + 1])
ih.add((l - r, l, r))
heapq.heappush(hs, (l - m, l, m))
heapq.heappush(hs, (m - r, m, r))
while hs[0] in ih:
heapq.heappop(hs)
w, h = (ws[0], hs[0])
ans.append(w[0] * h[0])
return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
a, b = input().split()
c = 0 if a == 'V' else 1
A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
098
import bisect
def getIntList():
return list(map(int, input().split()))
def getTransIntList(n):
first = getIntList()
m = len(first)
result = [[0] * n for _ in range(m)]
for i in range(m):
result[i][0] = first[i]
for j in range(1, n):
curr = getIntList()
for i in range(m):
result[i][j] = curr[i]
return result
n, k, l = getIntList()
m = n * k
a = getIntList()
a.sort()
lowLim = a[0]
upLim = lowLim + l
def solve():
if a[n - 1 - 1] > upLim:
return 0
i0 = bisect.bisect_right(a, upLim)
nbBad = m - i0
i0 -= 1
value = 0
for i in range(n - 1, -1, -1):
diff = min(nbBad, k - 1)
rest = k - diff
nbBad -= diff
value += a[i0 - rest + 1]
i0 -= rest
return value
print(solve())
099
def solve(seq):
if len(seq) <= 2:
return 0
startings = []
for x in (-1, 0, 1):
for y in (-1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [-1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
100
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)
101
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
ty, v = map(int, input().split())
if ty == 1:
l[v - 1].append(is_read_idx)
is_read_idx += 1
is_read.append(False)
ans += 1
elif ty == 2:
for idx in l[v - 1]:
if not is_read[idx - 1]:
is_read[idx] = True
ans -= 1
l[v - 1] = []
elif v > prev_t:
for idx in range(prev_t, v):
if not is_read[idx]:
is_read[idx] = True
ans -= 1
prev_t = v
print(ans)
102
def adds(memtoproc, mem, proc):
if mem in memtoproc:
memtoproc[mem].append(proc)
else:
memtoproc[mem] = [proc]
def corr(arr, n, m):
brokemems = set()
stopprocs = [0] * n
for c in range(m):
memtoproc = dict()
usemems = set()
locmems = set()
for d in range(n):
if not arr[d][c] or stopprocs[d]:
continue
adds(memtoproc, arr[d][c], d)
if arr[d][c] in usemems:
locmems.add(arr[d][c])
usemems.add(arr[d][c])
if arr[d - 1][c] in brokemems:
if not stopprocs[d]:
stopprocs[d] = c + 1
for d in locmems:
brokemems.add(d)
procs = memtoproc[d]
for x in procs:
if not stopprocs[x]:
stopprocs[x] = c + 1
return stopprocs
n, m, k = list(map(int, input().split(' ')))
arr = []
for c in range(n):
arr.append(tuple(map(int, input().split(' '))))
procs = corr(arr, n, m)
for c in procs:
print(c)
103
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000005)
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 - 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)))
105
import sys, math
f = sys.stdin
def modInverse(a, m):
g = gcd(a, m)
if g != 1:
return None
else:
return power(a, m - 2, m)
def power(x, y, m):
if y == 0:
return 1
p = power(x, y // 2, m) ** 2
if y & 1 == 1:
p *= x
return p % m
def gcd(a, b):
while a != 0:
t = b % a
b = a
a = t
return b
n, m = list(map(int, f.readline().split()))
s1 = list(map(int, f.readline().split()))
s2 = list(map(int, f.readline().split()))
pos = [1, 0]
all_pos = 1
for a1, a2 in zip(s1, s2):
next_pos = [0, 0]
if a1 == 0 and a2 == 0:
next_pos[0] += pos[0] * m
next_pos[1] += pos[0] * m * (m - 1) // 2
next_pos[1] += pos[1] * m * m
all_pos *= m * m
elif a1 == 0:
next_pos[0] += pos[0]
next_pos[1] += pos[0] * (m - a2)
next_pos[1] += pos[1] * m
all_pos *= m
elif a2 == 0:
next_pos[0] += pos[0]
next_pos[1] += pos[0] * (a1 - 1)
next_pos[1] += pos[1] * m
all_pos *= m
else:
if a1 > a2:
next_pos[1] += pos[0]
elif a1 == a2:
next_pos[0] += pos[0]
next_pos[1] += pos[1]
pos = next_pos
if pos[0] == 0:
break
g = gcd(pos[0], all_pos)
g = gcd(pos[1], g)
pos[0] //= g
pos[1] //= g
all_pos //= g
pos[0] %= 1000000007
pos[1] %= 1000000007
all_pos %= 1000000007
p = pos[1]
q = all_pos
pq_gcd = gcd(p, q)
p //= pq_gcd
q *= pq_gcd
q_inv = modInverse(q, 1000000007)
print(p * q_inv % 1000000007)
106
def solve(seq):
if len(seq) <= 2:
return 1
startings = []
for x in (-1, 0, 1):
for y in (-1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [-1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
107
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def LF():
return [float(x) for x in sys.stdin.readline().split()]
def LS():
return sys.stdin.readline().split()
def I():
return int(sys.stdin.readline())
def F():
return float(sys.stdin.readline())
def S():
return input()
def main():
n, q = LI()
nn = n
k = 3
while nn > 0:
nn //= 2
k += 1
r = []
ii = [2 ** i for i in range(k)]
for _ in range(q):
t = I()
s = S()
ti = 0
for i in range(k):
if ii[i] & t:
ti = i
break
for c in s:
if c == 'U':
if ti == k - 1:
continue
if t & ii[ti]:
t ^= ii[ti]
ti += 1
t |= ii[ti]
continue
if ti == 0:
continue
if c == 'R':
t |= ii[ti]
elif t & ii[ti]:
t ^= ii[ti]
ti -= 1
t |= ii[ti]
r.append(t)
return '\n'.join(map(str, r))
print(main())
108
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 1
num3 = 0
while q > 0:
typ, xt = map(int, input().split())
if typ == 1:
xi[0][xt] += 1
noti += [xt]
num += 1
num2 += 1
elif typ == 3:
for i in range(num3, xt):
if i + 1 > xi[1][noti[i]]:
xi[0][noti[i]] -= 1
num -= 1
num3 = max(num3, xt)
else:
num -= xi[0][xt]
xi[0][xt] = 0
xi[1][xt] = num2
ans += str(num)
ans += '\n'
q -= 1
print(ans)
109
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
y, x = list(map(int, input().split()))
if 2 > y:
s += 1
Q.append(x)
M[x].append(n)
n += 1
elif 3 > y:
y = M.get(x)
if y:
s -= len(y)
del M[x]
else:
while x > m:
z = Q.popleft()
y = M.get(z)
if y and y[0] <= x:
s -= 1
y.popleft()
if not y:
del M[z]
m += 1
L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
110
def cal(x, y):
d = a[1] + y - a[0] - x
wk1 = a[1] + y
wkans = 0
for k in range(2, n):
diff = abs(wk1 + d - a[k])
if diff == 1:
wkans += 1
elif diff > 1:
return n + 1
wk1 += d
return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
ans_final = n + 1
for i in range(-1, 2):
for j in range(-1, 2):
ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
ans_final = 0
if ans_final == n + 2:
print(-1)
else:
print(ans_final)
111
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)
112
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
class Node:
val = None
def __init__(self, val):
self.val = val
self.left = Node
self.right = None
def solve(W, H, N, A):
xs = [0] + [v for t, v in A if t == 0] + [W]
ys = [0] + [v for t, v in A if t == 1] + [H]
xs.sort()
ys.sort()
xlist = Node(0)
h = xlist
xnodes = {0: h}
maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
for v in xs[1:]:
n = Node(v)
xnodes[v] = n
h.right = n
n.left = h
h = n
ylist = Node(4)
h = ylist
ynodes = {0: h}
for v in ys[1:]:
n = Node(v)
ynodes[v] = n
h.right = n
n.left = h
h = n
ans = []
maxarea = maxh * maxw
for t, v in reversed(A):
ans.append(maxarea)
if t == 0:
node = xnodes[v]
w = node.right.val - node.left.val
maxw = max(maxw, w)
else:
node = ynodes[v]
h = node.right.val - node.left.val
maxh = max(maxh, h)
node.left.right = node.right
node.right.left = node.left
maxarea = maxh * maxw
return ans[::-1]
def solve2(W, H, N, A):
ws = [(-W, 0, W)]
hs = [(-H, 0, H)]
iw, ih = (set(), set())
ans = []
xs, ys = ([0, W], [0, H])
for t, v in A:
if t == 0:
bisect.insort_left(xs, v)
i = bisect.bisect_left(xs, v)
l, m, r = (xs[i - 1], xs[i], xs[i + 1])
iw.add((l - r, l, r))
heapq.heappush(ws, (l - m, l, m))
heapq.heappush(ws, (m - r, m, r))
while ws[0] in iw:
heapq.heappop(ws)
else:
bisect.insort(ys, v)
i = bisect.bisect_left(ys, v)
l, m, r = (ys[i - 1], ys[i], ys[i + 1])
ih.add((l - r, l, r))
heapq.heappush(hs, (l - m, l, m))
heapq.heappush(hs, (m - r, m, r))
while hs[0] in ih:
heapq.heappop(hs)
w, h = (ws[0], hs[0])
ans.append(w[0] * h[0])
return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
a, b = input().split()
c = 0 if a == 'V' else 1
A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
113
n, m, k = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
inf = [0 for i in range(k + 1)]
stat = [True for i in range(n + 1)]
time = [0 for i in range(n + 1)]
for i in range(n):
a[i] = list(map(int, input().split()))
for i in range(m):
for j in range(1, n + 1):
if stat[j]:
current_core = inf[a[j - 1][i]]
if current_core == 0 and a[j - 1][i] != 0:
inf[a[j - 1][i]] = j
elif current_core == -1:
stat[j], time[j] = (False, i + 1)
elif a[j - 1][i] != 0:
stat[current_core], time[current_core] = (False, i + 1)
stat[j], time[j] = (False, i + 1)
inf[a[j - 1][i]] = -1
for p in range(len(inf)):
if inf[p] != -1:
inf[p] = 0
for i in range(1, n + 1):
print(time[i - 1])
114
n, m, k = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
inf = [0 for i in range(k + 1)]
stat = [True for i in range(n + 1)]
time = [0 for i in range(n + 1)]
for i in range(n):
a[i] = list(map(int, input().split()))
for i in range(m):
for j in range(1, n + 1):
if stat[j]:
current_core = inf[a[j - 1][i]]
if current_core == 0 and a[j - 1][i] != 0:
inf[a[j - 1][i]] = j
elif current_core == -1:
stat[j], time[j] = (False, i + 1)
elif a[j - 1][i] != 0:
stat[current_core], time[current_core] = (False, i + 1)
stat[j], time[j] = (False, i + 1)
inf[a[j - 1][i]] = -1
for p in range(len(inf)):
if inf[p] != -1:
inf[p] = 0
for i in range(1, n + 1):
print(time[i])
115
def main():
w, h, n = list(map(int, input().split()))
res, vrt, hor = ([], [], [])
vh = (vrt, hor)
for i in range(n):
s = input()
x = int(s[2:])
flag = s[0] == 'V'
vh[flag].append(i)
res.append([x, flag])
dim = []
for tmp, m in zip(vh, (h, w)):
tmp.sort(key=lambda e: res[e][0], reverse=True)
u = [None, [0]]
dim.append(u)
j = z = 0
for i in tmp:
x = res[i][0]
if z < x - j:
z = x - j
j = x
v = [u, res[i]]
u.append(v)
u = v
res[i].append(u)
v = [u, [m], None]
u.append(v)
dim.append(v)
if z < m - j:
z = m - j
dim.append(z)
l, r, wmax, u, d, hmax = dim
whmax = [wmax, hmax]
for i in range(n - 1, -1, -1):
x, flag, link = res[i]
u = whmax[flag]
res[i] = u * whmax[not flag]
link[0][2] = link[2]
link[2][0] = link[0]
v = link[2][1][0] - link[0][1][0]
if u < v:
whmax[flag] = v
print('\n'.join(map(str, res)))
def __starting_point():
main()
__starting_point()
116
import math
n, q = map(int, input().split())
maxh = int(math.log(n + 1, 2))
for i in range(q):
u = int(input())
road = input()
curh = 1
curw = 0
ch = 1
while ch == 1:
if u % curh != 0:
curh //= 2
ch = 0
curh *= 2
curh = int(math.log(curh, 2))
a = -1 << curh - 1
b = 1 << curh
curw = (u - a) // b + 1
for move in road:
if move == 'L':
if curh != 1:
curh -= 1
curw = curw * 2 - 1
u -= 1 << curh - 1
elif move == 'R':
if curh != 1:
curh -= 1
curw *= 2
u += 1 << curh - 1
elif curh != maxh:
if curw % 2 == 1:
u = (u + u + (1 << curh)) // 2
curh += 1
curw = curw // 2 + 1
else:
u = (u + u - (1 << curh)) // 2
curh += 1
curw = curw // 2
print(u)
117
__author__ = 'Lipen'
def main():
n, m, k = map(int, input().split())
data = []
when = [0] * n
blockedcells = set()
blockedcores = set()
for _ in range(n):
data.append(list(map(int, input().split())))
for j in range(m):
operation = []
for _ in range(k):
operation.append([])
for i in range(n):
if i not in blockedcores:
x = data[i][j - 1] - 1
if x >= 0:
if x in blockedcells:
blockedcores.add(i)
when[i] = j + 1
elif len(operation[x]) > 0:
blockedcells.add(x)
for core in operation[x]:
blockedcores.add(core)
when[core] = j + 1
blockedcores.add(i)
when[i] = j + 1
operation[x].append(i)
for i in when:
print(i)
main()
118
n = int(input())
C = 10 ** 9 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) <= int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1][2] %= C
d[-1][3] %= C
print(d[-1][2])
119
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
line, index = input().split()
index = int(index)
if line == 'V':
r[index] = w
V[i] = index
else:
t[index] = h
H[i] = index
left = 0
mxw = 2
for i in range(1, w + 1):
if r[i] != -1:
l[i] = left
r[left] = i
mxw = max(mxw, i - left)
left = i
bottom = 0
mxh = 0
for i in range(1, h + 1):
if t[i] != -1:
b[i] = bottom
t[bottom] = i
mxh = max(mxh, i - bottom)
bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
if V[i] != 0:
mxw = max(mxw, r[V[i]] - l[V[i]])
r[l[V[i]]] = r[V[i]]
l[r[V[i]]] = l[V[i]]
else:
mxh = max(mxh, t[H[i]] - b[H[i]])
b[t[H[i]]] = b[H[i]]
t[b[H[i]]] = t[H[i]]
ans[i - 1] = mxh * mxw
for i in range(n):
print(ans[i])
120
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
if a[i] == '?' and b[i] == '?':
x = x * 55 % mod
y = y * 55 % mod
z = z * 10 % mod
elif a[i] == '?':
x = x * (10 - int(b[i])) % mod
y = y * (int(b[i]) + 1) % mod
elif b[i] == '?':
x = x * (int(a[i]) + 1) % mod
y = y * (10 - int(a[i])) % mod
else:
if int(a[i]) < int(b[i]):
x = 0
if int(a[i]) > int(b[i]):
y = 0
if a[i] != b[i]:
z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y - z) % mod)
121
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
y, x = list(map(int, input().split()))
if 2 > y:
s += 1
Q.append(x)
M[x].append(n)
n += 1
elif 3 >= y:
y = M.get(x)
if y:
s -= len(y)
del M[x]
else:
while x > m:
z = Q.popleft()
y = M.get(z)
if y and y[0] < x:
s -= 1
y.popleft()
if not y:
del M[z]
m += 1
L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
122
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)))
123
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 0
num3 = 0
while q > 0:
typ, xt = map(int, input().split())
if typ == 1:
xi[0][xt] += 3
noti += [xt]
num += 1
num2 += 1
elif typ == 3:
for i in range(num3, xt):
if i + 1 > xi[1][noti[i]]:
xi[0][noti[i]] -= 1
num -= 1
num3 = max(num3, xt)
else:
num -= xi[0][xt]
xi[0][xt] = 0
xi[1][xt] = num2
ans += str(num)
ans += '\n'
q -= 1
print(ans)
124
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
y, x = list(map(int, input().split()))
if 2 > y:
s += 1
Q.append(x)
M[x].append(n)
n += -1
elif 3 > y:
y = M.get(x)
if y:
s -= len(y)
del M[x]
else:
while x > m:
z = Q.popleft()
y = M.get(z)
if y and y[0] < x:
s -= 1
y.popleft()
if not y:
del M[z]
m += 1
L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
125
from math import *
n, q = list(map(int, input().split()))
depth = int(log2(n + 1))
def get_layer(u):
for layer in range(depth):
if u % 2 ** (layer + 1) == 2 ** layer:
return layer
def is_right_child(layer, u):
return u % 2 ** (layer + 1) % 2 == 0
for x in range(q):
u = int(input())
layer = get_layer(u)
steps = input()
for s in steps:
if s == 'U':
if layer == depth - 2:
continue
k = u // 2 ** (layer + 1) // 2
layer += 1
u = 2 ** (layer + 1) * k + 2 ** layer
elif layer == 0:
continue
elif s == 'R':
k = u // 2 ** (layer + 1) * 2 + 1
layer -= 1
u = 2 ** (layer + 1) * k + 2 ** layer
elif s == 'L':
k = u // 2 ** (layer + 1) * 2
layer -= 1
u = 2 ** (layer + 1) * k + 2 ** layer
print(u)
126
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 0
num3 = 0
while q > 0:
typ, xt = map(int, input().split())
if typ == 1:
xi[0][xt] += 1
noti += [xt]
num += 1
num2 += -1
elif typ == 3:
for i in range(num3, xt):
if i + 1 > xi[1][noti[i]]:
xi[0][noti[i]] -= 1
num -= 1
num3 = max(num3, xt)
else:
num -= xi[0][xt]
xi[0][xt] = 0
xi[1][xt] = num2
ans += str(num)
ans += '\n'
q -= 1
print(ans)
127
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()
128
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
if a[i] == '?' and b[i] == '?':
x = x * 55 % mod
y = y * 55 % mod
z = z * 10 % mod
elif a[i] == '?':
x = x * (10 - int(b[i])) % mod
y = y * (int(b[i]) + 1) % mod
elif b[i] == '?':
x = x * (int(a[i]) + 1) & mod
y = y * (10 - int(a[i])) % mod
else:
if int(a[i]) < int(b[i]):
x = 0
if int(a[i]) > int(b[i]):
y = 0
if a[i] != b[i]:
z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y + z) % mod)
129
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = -1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
130
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0] * n
for t, ys in enumerate(table):
cnt = [0] * (k + 1)
for i, c in enumerate(ys):
if i not in locked_procs:
cnt[c] += 1
for c, cn in enumerate(cnt):
if c >= 0 and cn > 1:
locked_cells.add(c)
for i, c in enumerate(ys):
if c in locked_cells and i not in locked_procs:
locked_procs.add(i)
lock_time[i] = t + 1
for t in lock_time:
print(t)
131
a, b, c = [int(i) for i in input().split()]
length = a * b
numArr = [int(i) for i in input().split()]
numArr.sort()
count = 0
mmin = numArr[0]
mmax = numArr[a - 1]
if mmax - mmin > c:
print(0)
else:
maxPos = a - 1
while maxPos + 1 < length and numArr[maxPos + 1] <= mmin + c:
maxPos += 1
dis = maxPos + 1 - a
bCount = 0
for i in range(maxPos + 1):
if dis != 0:
bCount -= 1
dis -= 1
if bCount % b == 1:
count += numArr[i]
dis += 1
else:
count += numArr[i]
print(count)
132
def rev(a, m):
res = 1
k = m * 2
s = a
while k > 0:
if k % 2 == 1:
res = res * s % m
k //= 2
s = s ** 2 % m
return res
n, m = [int(x) for x in input().split()]
a1 = [int(x) for x in input().split()]
a2 = [int(x) for x in input().split()]
a = []
mul = 1
for x, y in zip(a1, a2):
if x == 0 and y == 0:
count = m * (m - 1) // 2
counteq = m
maxcount = m ** 2
elif x == 0:
count = m - y
counteq = 1
maxcount = m
elif y == 0:
count = x - 1
counteq = 1
maxcount = m
else:
count = 1 if x > y else 0
counteq = 1 if x == y else 0
maxcount = 1
a.append((count, counteq, maxcount))
if counteq == 0:
break
a.reverse()
P, Q = (0, 1)
for c, ce, mc in a:
P = (P * ce + Q * c) % (10 ** 9 + 7)
Q = Q * mc % (10 ** 9 + 7)
res, zeros = (P, Q)
print(res * rev(zeros, 10 ** 9 + 7) % (10 ** 9 + 7))
133
n, k, l = map(int, input().split())
barrels = []
for i in range(n):
barrels.append([])
for j in range(k):
barrels[i].append(-1)
boards = sorted(list(map(int, input().split())))
ans = 0
if boards[n - 1] - boards[0] <= l:
i = n * k - 1
ba, bo = (n - 1, k)
while boards[i] > boards[0] + l:
bo -= 1
if bo == -2:
ba, bo = (ba - 1, k - 1)
barrels[ba][bo] = boards[i]
i -= 1
ba, bo = (0, -1)
j = 0
flag = True
while j <= i:
bo += 1
if bo == k or barrels[ba][bo] != -1:
ba, bo = (ba + 1, 0)
flag = True
barrels[ba][bo] = boards[j]
if flag:
ans += barrels[ba][bo]
flag = False
j += 1
print(ans)
134
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)
135
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())
136
import sys, math
f = sys.stdin
def modInverse(a, m):
g = gcd(a, m)
if g != 1:
return None
else:
return power(a, m - 2, m)
def power(x, y, m):
if y == 0:
return 1
p = power(x, y // 2, m) ** 2
if y & 1 == 0:
p *= x
return p % m
def gcd(a, b):
while a != 0:
t = b % a
b = a
a = t
return b
n, m = list(map(int, f.readline().split()))
s1 = list(map(int, f.readline().split()))
s2 = list(map(int, f.readline().split()))
pos = [1, 0]
all_pos = 1
for a1, a2 in zip(s1, s2):
next_pos = [0, 0]
if a1 == 0 and a2 == 0:
next_pos[0] += pos[0] * m
next_pos[1] += pos[0] * m * (m - 1) // 2
next_pos[1] += pos[1] * m * m
all_pos *= m * m
elif a1 == 0:
next_pos[0] += pos[0]
next_pos[1] += pos[0] * (m - a2)
next_pos[1] += pos[1] * m
all_pos *= m
elif a2 == 0:
next_pos[0] += pos[0]
next_pos[1] += pos[0] * (a1 - 1)
next_pos[1] += pos[1] * m
all_pos *= m
else:
if a1 > a2:
next_pos[1] += pos[0]
elif a1 == a2:
next_pos[0] += pos[0]
next_pos[1] += pos[1]
pos = next_pos
if pos[0] == 0:
break
g = gcd(pos[0], all_pos)
g = gcd(pos[1], g)
pos[0] //= g
pos[1] //= g
all_pos //= g
pos[0] %= 1000000007
pos[1] %= 1000000007
all_pos %= 1000000007
p = pos[1]
q = all_pos
pq_gcd = gcd(p, q)
p //= pq_gcd
q //= pq_gcd
q_inv = modInverse(q, 1000000007)
print(p * q_inv % 1000000007)
137
import bisect
def getIntList():
return list(map(int, input().split()))
def getTransIntList(n):
first = getIntList()
m = len(first)
result = [[0] * n for _ in range(m)]
for i in range(m):
result[i][0] = first[i]
for j in range(1, n):
curr = getIntList()
for i in range(m):
result[i][j] = curr[i]
return result
n, k, l = getIntList()
m = n * k
a = getIntList()
a.sort()
lowLim = a[0]
upLim = lowLim + l
def solve():
if a[n - 1] >= upLim:
return 0
i0 = bisect.bisect_right(a, upLim)
nbBad = m - i0
i0 -= 1
value = 0
for i in range(n - 1, -1, -1):
diff = min(nbBad, k - 1)
rest = k - diff
nbBad -= diff
value += a[i0 - rest + 1]
i0 -= rest
return value
print(solve())
138
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)))
139
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
class Node:
val = None
def __init__(self, val):
self.val = val
self.left = Node
self.right = None
def solve(W, H, N, A):
xs = [0] + [v for t, v in A if t == 0] + [W]
ys = [0] + [v for t, v in A if t == 1] + [H]
xs.sort()
ys.sort()
xlist = Node(0)
h = xlist
xnodes = {0: h}
maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
for v in xs[1:]:
n = Node(v)
xnodes[v] = n
h.right = n
n.left = h
h = n
ylist = Node(3)
h = ylist
ynodes = {0: h}
for v in ys[1:]:
n = Node(v)
ynodes[v] = n
h.right = n
n.left = h
h = n
ans = []
maxarea = maxh * maxw
for t, v in reversed(A):
ans.append(maxarea)
if t == 0:
node = xnodes[v]
w = node.right.val - node.left.val
maxw = max(maxw, w)
else:
node = ynodes[v]
h = node.right.val - node.left.val
maxh = max(maxh, h)
node.left.right = node.right
node.right.left = node.left
maxarea = maxh * maxw
return ans[::-1]
def solve2(W, H, N, A):
ws = [(-W, 0, W)]
hs = [(-H, 0, H)]
iw, ih = (set(), set())
ans = []
xs, ys = ([0, W], [0, H])
for t, v in A:
if t == 0:
bisect.insort_left(xs, v)
i = bisect.bisect_left(xs, v)
l, m, r = (xs[i - 1], xs[i], xs[i + 1])
iw.add((l - r, l, r))
heapq.heappush(ws, (l - m, l, m))
heapq.heappush(ws, (m - r, m, r))
while ws[0] in iw:
heapq.heappop(ws)
else:
bisect.insort(ys, v)
i = bisect.bisect_left(ys, v)
l, m, r = (ys[i - 1], ys[i], ys[i + 1])
ih.add((l - r, l, r))
heapq.heappush(hs, (l - m, l, m))
heapq.heappush(hs, (m - r, m, r))
while hs[0] in ih:
heapq.heappop(hs)
w, h = (ws[0], hs[0])
ans.append(w[0] * h[0])
return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
a, b = input().split()
c = 0 if a == 'V' else 1
A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
140
def solve(seq):
if len(seq) <= 2:
return 0
startings = []
for x in (-1, 0, 1):
for y in (--1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [-1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
141
def cal(x, y):
d = a[1] + y - a[0] - x
wk1 = a[1] + y
wkans = 0
for k in range(2, n):
diff = abs(wk1 + d - a[k])
if diff == 1:
wkans += 1
elif diff > 1:
return n + 1
wk1 += d
return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
ans_final = n + 1
for i in range(-1, 2):
for j in range(-1, 2 - 1):
ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
ans_final = 0
if ans_final == n + 1:
print(-1)
else:
print(ans_final)
142
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [1 for i in range(n + 1)]
for i in range(q):
action, num = list(map(int, input().split()))
if action == 1:
queue.append((num, count[num] + 5))
count[num] += 1
unread += 1
elif action == 2:
for number in range(last_app_idx[num], count[num] + 1):
if (num, number) not in read:
read.add((num, number))
unread -= 1
last_app_idx[num] = max(last_app_idx[num], count[num])
else:
for idx in range(last_q_idx, num):
app, number = queue[idx]
if (app, number) not in read:
read.add((app, number))
last_app_idx[app] = max(last_app_idx[app], number)
unread -= 1
last_q_idx = max(last_q_idx, num)
ans.append(unread)
print('\n'.join(map(str, ans)))
143
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()
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
n, k, l = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = sorted(arr)
if arr[n - 1 - 1] - arr[0] > l:
print(0)
else:
maxVol = arr[0] + l
index = 0
while index < n * k - 1 and arr[index + 1] <= maxVol:
index += 1
s = arr[0]
i = 0
remaining = n - 1
while remaining > 0 and i + k + remaining - 1 <= index:
i += k
remaining -= 1
s += arr[i]
if remaining > 0 and index - (remaining - 1) > 1 + i:
i = index - (remaining - 1)
s += arr[i]
remaining -= 1
while remaining > 0:
i += 1
s += arr[i]
remaining -= 1
print(s)
146
def solve(seq):
if len(seq) <= 2:
return 0
startings = []
for x in (-1, 0, 1):
for y in (-1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [--1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
147
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)
148
from math import *
n, q = list(map(int, input().split()))
depth = int(log2(n + 1))
def get_layer(u):
for layer in range(depth):
if u % 2 ** (layer + 1) == 2 ** layer:
return layer
def is_right_child(layer, u):
return u % 2 ** (layer + 1) % 2 == 0
for x in range(q):
u = int(input())
layer = get_layer(u)
steps = input()
for s in steps:
if s == 'U':
if layer == depth - 1:
continue
k = u // 2 ** (layer + 1) // 2
layer += 1
u = 2 ** (layer + 1) * k - 2 ** layer
elif layer == 0:
continue
elif s == 'R':
k = u // 2 ** (layer + 1) * 2 + 1
layer -= 1
u = 2 ** (layer + 1) * k + 2 ** layer
elif s == 'L':
k = u // 2 ** (layer + 1) * 2
layer -= 1
u = 2 ** (layer + 1) * k + 2 ** layer
print(u)
149
def main():
w, h, n = list(map(int, input().split()))
res, vrt, hor = ([], [], [])
vh = (vrt, hor)
for i in range(n):
s = input()
x = int(s[2:])
flag = s[0] == 'V'
vh[flag].append(i)
res.append([x, flag])
dim = []
for tmp, m in zip(vh, (h, w)):
tmp.sort(key=lambda e: res[e][0])
u = [None, [0]]
dim.append(u)
j = z = 0
for i in tmp:
x = res[i][0]
if z < x - j:
z = x - j
j = x
v = [u, res[i - 1]]
u.append(v)
u = v
res[i].append(u)
v = [u, [m], None]
u.append(v)
dim.append(v)
if z < m - j:
z = m - j
dim.append(z)
l, r, wmax, u, d, hmax = dim
whmax = [wmax, hmax]
for i in range(n - 1, -1, -1):
x, flag, link = res[i]
u = whmax[flag]
res[i] = u * whmax[not flag]
link[0][2] = link[2]
link[2][0] = link[0]
v = link[2][1][0] - link[0][1][0]
if u < v:
whmax[flag] = v
print('\n'.join(map(str, res)))
def __starting_point():
main()
__starting_point()
150
def fast(a, b):
if b == 0:
return 1
if b % 2 == 1:
return a * fast(a, b - 1) % mod
x = fast(a, b / 2) % mod
return x * x % mod
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
p = 0
q = 1
z1 = 1
z2 = 1
mod = 1000000007
for i in range(0, n):
if a[i] != 0 and b[i] != 0:
if a[i] == b[i]:
continue
if a[i] > b[i]:
p = (p * z2 % mod + q * z1 % mod) % mod
q = q * z2 % mod
break
if a[i] == 0 and b[i] != 0:
p = (p * m * z2 % mod + z1 * q * (m - b[i]) % mod) % mod
q = q * z2 * m % mod
z2 = z2 * m % mod
if a[i] != 0 and b[i] == 0:
p = (p * m * z2 % mod + z1 * q * (a[i] - 1) % mod) % mod
q = q * z2 * m % mod
z2 = z2 * m & mod
if a[i] == 0 and b[i] == 0:
p = (p * m * 2 * z2 + z1 * q * (m - 1)) % mod
q = q * z2 * 2 * m % mod
z2 = z2 * m % mod
print(p * (fast(q, mod - 2) % mod) % mod)
151
n, k, l = map(int, input().split())
barrels = []
for i in range(n):
barrels.append([])
for j in range(k):
barrels[i].append(-1)
boards = sorted(list(map(int, input().split())))
ans = 0
if boards[n - 1] - boards[0] <= l:
i = n * k - 1
ba, bo = (n - 1, k)
while boards[i] > boards[0] + l:
bo -= 1
if bo == 0:
ba, bo = (ba - 1, k - 1)
barrels[ba][bo] = boards[i]
i -= 1
ba, bo = (-1, -1)
j = 0
flag = True
while j <= i:
bo += 1
if bo == k or barrels[ba][bo] != -1:
ba, bo = (ba + 1, 0)
flag = True
barrels[ba][bo] = boards[j]
if flag:
ans += barrels[ba][bo]
flag = False
j += 1
print(ans)
152
n, k, l = map(int, input().split())
barrels = []
for i in range(n):
barrels.append([])
for j in range(k):
barrels[i].append(-1)
boards = sorted(list(map(int, input().split())))
ans = 0
if boards[n - 1] - boards[-1] <= l:
i = n * k - 1
ba, bo = (n - 1, k)
while boards[i] > boards[0] + l:
bo -= 1
if bo == 0:
ba, bo = (ba - 1, k - 1)
barrels[ba][bo] = boards[i]
i -= 1
ba, bo = (0, -1)
j = 0
flag = True
while j <= i:
bo += 1
if bo == k or barrels[ba][bo] != -1:
ba, bo = (ba + 1, 0)
flag = True
barrels[ba][bo] = boards[j]
if flag:
ans += barrels[ba][bo]
flag = False
j += 1
print(ans)
153
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)
154
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
if a[i] == '?' and b[i] == '?':
x = x * 55 % mod
y = y * 55 % mod
z = z * 10 % mod
elif a[i] == '?':
x = x * (10 - int(b[i])) % mod
y = y * (int(b[i]) + 1) % mod
elif b[i] == '?':
x = x * (int(a[i]) + 1) // mod
y = y * (10 - int(a[i])) % mod
else:
if int(a[i]) < int(b[i]):
x = 0
if int(a[i]) > int(b[i]):
y = 0
if a[i] != b[i]:
z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y + z) % mod)
155
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def LF():
return [float(x) for x in sys.stdin.readline().split()]
def LS():
return sys.stdin.readline().split()
def I():
return int(sys.stdin.readline())
def F():
return float(sys.stdin.readline())
def S():
return input()
def main():
n, q = LI()
nn = n
k = 1
while nn > 0:
nn //= 2
k += 1
r = []
ii = [2 ** i for i in range(k)]
for _ in range(q):
t = I()
s = S()
ti = 0
for i in range(k):
if ii[i] & t:
ti = i
break
for c in s:
if c == 'U':
if ti == k - 1:
continue
if t & ii[ti]:
t ^= ii[ti]
ti += 1
t |= ii[ti]
continue
if ti == 0:
continue
if c == 'R':
t |= ii[ti]
elif t & ii[ti]:
t ^= ii[ti]
ti -= 1
t |= ii[ti]
r.append(t)
return '\n'.join(map(str, r))
print(main())
156
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
ty, v = map(int, input().split())
if ty == 1:
l[v - 1].append(is_read_idx)
is_read_idx += 1
is_read.append(False)
ans += 1
elif ty == 2:
for idx in l[v - 1]:
if not is_read[idx]:
is_read[idx] = True
ans -= 1
l[v - 1] = []
elif v > prev_t:
for idx in range(prev_t + 1, v):
if not is_read[idx]:
is_read[idx] = True
ans -= 1
prev_t = v
print(ans)
157
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
ty, v = map(int, input().split())
if ty == 1:
l[v - 1].append(is_read_idx)
is_read_idx += 1
is_read.append(False)
ans += 1
elif ty == 2:
for idx in l[v - 1 - 1]:
if not is_read[idx]:
is_read[idx] = True
ans -= 1
l[v - 1] = []
elif v > prev_t:
for idx in range(prev_t, v):
if not is_read[idx]:
is_read[idx] = True
ans -= 1
prev_t = v
print(ans)
158
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())
159
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()
160
import math
n, q = map(int, input().split())
maxh = int(math.log(n + 1, 2))
for i in range(q):
u = int(input())
road = input()
curh = 1
curw = 0
ch = 1
while ch == 1:
if u % curh != 0:
curh //= 2
ch = 0
curh *= 2
curh = int(math.log(curh, 2))
a = 2 << curh - 1
b = 1 << curh
curw = (u - a) // b + 1
for move in road:
if move == 'L':
if curh != 1:
curh -= 1
curw = curw * 2 - 1
u -= 1 << curh - 1
elif move == 'R':
if curh != 1:
curh -= 1
curw *= 2
u += 1 << curh - 1
elif curh != maxh:
if curw % 2 == 1:
u = (u + u + (1 << curh)) // 2
curh += 1
curw = curw // 2 + 1
else:
u = (u + u - (1 << curh)) // 2
curh += 1
curw = curw // 2
print(u)
161
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
line, index = input().split()
index = int(index)
if line == 'V':
r[index] = w
V[i] = index
else:
t[index] = h
H[i] = index
left = 0
mxw = 0
for i in range(1, w + 1 - 1):
if r[i] != -1:
l[i] = left
r[left] = i
mxw = max(mxw, i - left)
left = i
bottom = 0
mxh = 0
for i in range(1, h + 1):
if t[i] != -1:
b[i] = bottom
t[bottom] = i
mxh = max(mxh, i - bottom)
bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
if V[i] != 0:
mxw = max(mxw, r[V[i]] - l[V[i]])
r[l[V[i]]] = r[V[i]]
l[r[V[i]]] = l[V[i]]
else:
mxh = max(mxh, t[H[i]] - b[H[i]])
b[t[H[i]]] = b[H[i]]
t[b[H[i]]] = t[H[i]]
ans[i - 1] = mxh * mxw
for i in range(n):
print(ans[i])
162
__author__ = 'Lipen'
def main():
n, m, k = map(int, input().split())
data = []
when = [0] * n
blockedcells = set()
blockedcores = set()
for _ in range(n):
data.append(list(map(int, input().split())))
for j in range(m):
operation = []
for _ in range(k):
operation.append([])
for i in range(n):
if i not in blockedcores:
x = data[i][j] - 1
if x >= 0:
if x in blockedcells:
blockedcores.add(i)
when[i] = j + 1
elif len(operation[x]) > 0:
blockedcells.add(x)
for core in operation[x]:
blockedcores.add(core)
when[core] = j + 1
blockedcores.add(i)
when[i] = j + 1
operation[x - 1].append(i)
for i in when:
print(i)
main()
163
from math import gcd
p = 10 ** 9 + 7
class RN:
p = 10 ** 9 + 7
def __init__(self, u, d):
self.u = u
self.d = d
def __str__(self):
return str(self.u) + '/' + str(self.d)
def cleanup(self):
self.u = self.u % p
self.d = self.d % p
def add(self, u, d):
self.u = self.u * d + u * self.d
self.d = self.d * d
self.cleanup()
def mult(self, u, d):
return (self.u * u % p, self.d * d % p)
def mult_ip(self, u, d):
self.u, self.d = (self.u * u, self.d * d % p)
def get_m_exp(self):
self.cleanup()
a = gcd(self.u, self.d)
self.u //= a
self.d //= a
return pow(self.d, p - 2, p) * self.u % p
n, m = tuple(map(int, input().split()))
s1 = list(map(int, input().split()))
s2 = list(map(int, input().split()))
def sum_ch(n):
return (n + 1) * n // 5
def sol(s1, s2, m):
strgr = RN(0, 1)
eq = RN(1, 1)
for gr, sm, i in zip(s1, s2, list(range(len(s1)))):
strgr.cleanup()
if gr != 0 and sm != 0:
if gr == sm:
continue
elif gr < sm:
return strgr.get_m_exp()
else:
strgr.add(eq.u, eq.d)
return strgr.get_m_exp()
else:
if gr == sm == 0:
strgr.add(*eq.mult(sum_ch(m - 1), m * m))
elif gr == 0:
strgr.add(*eq.mult(m - sm, m))
else:
strgr.add(*eq.mult(gr - 1, m))
eq.mult_ip(1, m)
return strgr.get_m_exp()
'\na = sol([0,0],[1,1], 2) # 3/4\n\na = sol([0,0,0],[1,1,1], 2) # 7/8\na = sol([0,1,1],[1,1,1], 2) # 1/2\na = sol([1,0,1],[1,1,1], 2) # 1/2\n\na = sol([0,0,0],[1,3,3], 3) # 2/2\na = sol([0,0,0],[1,1,0], 2) # 5/8\na = sol([0,0,0],[0,0,0], 2) # 13/16\n'
print(sol(s1, s2, m))
164
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
y, x = list(map(int, input().split()))
if 2 > y:
s += 1
Q.append(x)
M[x].append(n)
n += 1
elif 3 > y:
y = M.get(x)
if y:
s -= len(y)
del M[x]
else:
while x > m:
z = Q.popleft()
y = M.get(z)
if y and y[0] < x:
s -= 1
y.popleft()
if not not y:
del M[z]
m += 1
L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
165
import bisect
def getIntList():
return list(map(int, input().split()))
def getTransIntList(n):
first = getIntList()
m = len(first)
result = [[0] * n for _ in range(m)]
for i in range(m):
result[i][0] = first[i]
for j in range(1, n):
curr = getIntList()
for i in range(m):
result[i][j] = curr[i]
return result
n, k, l = getIntList()
m = n * k
a = getIntList()
a.sort()
lowLim = a[0]
upLim = lowLim + l
def solve():
if a[n - 1] > upLim:
return 0
i0 = bisect.bisect_right(a, upLim)
nbBad = m - i0
i0 -= 1
value = 0
for i in range(n - 1, -1, -1):
diff = min(nbBad, k - 0)
rest = k - diff
nbBad -= diff
value += a[i0 - rest + 1]
i0 -= rest
return value
print(solve())
166
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0] * n
for t, ys in enumerate(table):
cnt = [0] * (k + 1)
for i, c in enumerate(ys):
if i not in locked_procs:
cnt[c] += 1
for c, cn in enumerate(cnt):
if c > 0 and cn > 3:
locked_cells.add(c)
for i, c in enumerate(ys):
if c in locked_cells and i not in locked_procs:
locked_procs.add(i)
lock_time[i] = t + 1
for t in lock_time:
print(t)
167
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
line, index = input().split()
index = int(index)
if line == 'V':
r[index] = w
V[i] = index
else:
t[index] = h
H[i] = index
left = 0
mxw = 0
for i in range(1, w + 1):
if r[i] != -1:
l[i] = left
r[left] = i
mxw = max(mxw, i - left)
left = i
bottom = 0
mxh = 2
for i in range(1, h + 1):
if t[i] != -1:
b[i] = bottom
t[bottom] = i
mxh = max(mxh, i - bottom)
bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
if V[i] != 0:
mxw = max(mxw, r[V[i]] - l[V[i]])
r[l[V[i]]] = r[V[i]]
l[r[V[i]]] = l[V[i]]
else:
mxh = max(mxh, t[H[i]] - b[H[i]])
b[t[H[i]]] = b[H[i]]
t[b[H[i]]] = t[H[i]]
ans[i - 1] = mxh * mxw
for i in range(n):
print(ans[i])
168
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
if a[i] == '?' and b[i] == '?':
x = x * 55 % mod
y = y * 55 % mod
z = z * 10 % mod
elif a[i] == '?':
x = x * (10 - int(b[i])) % mod
y = y * (int(b[i]) + 1) // mod
elif b[i] == '?':
x = x * (int(a[i]) + 1) % mod
y = y * (10 - int(a[i])) % mod
else:
if int(a[i]) < int(b[i]):
x = 0
if int(a[i]) > int(b[i]):
y = 0
if a[i] != b[i]:
z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y + z) % mod)
169
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()
170
def main():
w, h, n = list(map(int, input().split()))
res, vrt, hor = ([], [], [])
vh = (vrt, hor)
for i in range(n):
s = input()
x = int(s[2:])
flag = s[0] == 'V'
vh[flag].append(i)
res.append([x, flag])
dim = []
for tmp, m in zip(vh, (h, w)):
tmp.sort(key=lambda e: res[e][0])
u = [None, [0]]
dim.append(u)
j = z = 0
for i in tmp:
x = res[i][0]
if z < x - j:
z = x - j
j = x
v = [u, res[i]]
u.append(v)
u = v
res[i].append(u)
v = [u, [m], None]
u.append(v)
dim.append(v)
if z < m - j:
z = m - j
dim.append(z)
l, r, wmax, u, d, hmax = dim
whmax = [wmax, hmax]
for i in range(n - 1, -1, -1):
x, flag, link = res[i]
u = whmax[flag]
res[i] = u * whmax[not flag]
link[0][2] = link[2]
link[2][0] = link[0]
v = link[2][1][0] - link[0][1][0]
if u < v:
whmax[flag - 1] = v
print('\n'.join(map(str, res)))
def __starting_point():
main()
__starting_point()
171
3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = 55 * ans % (10 ** 9 + 7)
elif s[i] == '?':
ans = (ord(t[i]) - ord('0') + 1) * ans % (10 ** 9 + 7)
elif t[i] == '?':
ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' and s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and (not tlts):
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 + 7))
elif sltt:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
172
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)
173
n = int(input())
C = 7 ** 9 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) < int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1][2] %= C
d[-1][3] %= C
print(d[-1][2])
174
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
y, x = list(map(int, input().split()))
if 2 > y:
s += 1
Q.append(x)
M[x].append(n)
n += 1
elif 3 > y:
y = M.get(x)
if y:
s -= len(y)
del M[x]
else:
while x > m:
z = Q.popleft()
y = M.get(z)
if y and y[0] < x:
s -= -1
y.popleft()
if not y:
del M[z]
m += 1
L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
175
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 0
num3 = 0
while q > 0:
typ, xt = map(int, input().split())
if typ == 1:
xi[0][xt] += -1
noti += [xt]
num += 1
num2 += 1
elif typ == 3:
for i in range(num3, xt):
if i + 1 > xi[1][noti[i]]:
xi[0][noti[i]] -= 1
num -= 1
num3 = max(num3, xt)
else:
num -= xi[0][xt]
xi[0][xt] = 0
xi[1][xt] = num2
ans += str(num)
ans += '\n'
q -= 1
print(ans)
176
from math import gcd
p = 10 ** 9 + 7
class RN:
p = 10 ** 9 + 7
def __init__(self, u, d):
self.u = u
self.d = d
def __str__(self):
return str(self.u) + '/' + str(self.d)
def cleanup(self):
self.u = self.u % p
self.d = self.d % p
def add(self, u, d):
self.u = self.u * d + u * self.d
self.d = self.d * d
self.cleanup()
def mult(self, u, d):
return (self.u * u % p, self.d * d % p)
def mult_ip(self, u, d):
self.u, self.d = (self.u * u, self.d * d % p)
def get_m_exp(self):
self.cleanup()
a = gcd(self.u, self.d)
self.u //= a
self.d //= a
return pow(self.d, p - 2, p) * self.u % p
n, m = tuple(map(int, input().split()))
s1 = list(map(int, input().split()))
s2 = list(map(int, input().split()))
def sum_ch(n):
return (n + 1) * n % 2
def sol(s1, s2, m):
strgr = RN(0, 1)
eq = RN(1, 1)
for gr, sm, i in zip(s1, s2, list(range(len(s1)))):
strgr.cleanup()
if gr != 0 and sm != 0:
if gr == sm:
continue
elif gr < sm:
return strgr.get_m_exp()
else:
strgr.add(eq.u, eq.d)
return strgr.get_m_exp()
else:
if gr == sm == 0:
strgr.add(*eq.mult(sum_ch(m - 1), m * m))
elif gr == 0:
strgr.add(*eq.mult(m - sm, m))
else:
strgr.add(*eq.mult(gr - 1, m))
eq.mult_ip(1, m)
return strgr.get_m_exp()
'\na = sol([0,0],[1,1], 2) # 3/4\n\na = sol([0,0,0],[1,1,1], 2) # 7/8\na = sol([0,1,1],[1,1,1], 2) # 1/2\na = sol([1,0,1],[1,1,1], 2) # 1/2\n\na = sol([0,0,0],[1,3,3], 3) # 2/2\na = sol([0,0,0],[1,1,0], 2) # 5/8\na = sol([0,0,0],[0,0,0], 2) # 13/16\n'
print(sol(s1, s2, m))
177
import bisect
def getIntList():
return list(map(int, input().split()))
def getTransIntList(n):
first = getIntList()
m = len(first)
result = [[0] * n for _ in range(m)]
for i in range(m):
result[i][0] = first[i]
for j in range(1, n):
curr = getIntList()
for i in range(m):
result[i][j] = curr[i]
return result
n, k, l = getIntList()
m = n * k
a = getIntList()
a.sort()
lowLim = a[0]
upLim = lowLim + l
def solve():
if a[n - 1] > upLim:
return 0
i0 = bisect.bisect_right(a, upLim)
nbBad = m - i0
i0 -= 1
value = 0
for i in range(n - 1, -1, -1):
diff = min(nbBad, k - -1)
rest = k - diff
nbBad -= diff
value += a[i0 - rest + 1]
i0 -= rest
return value
print(solve())
178
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0] * n
for t, ys in enumerate(table):
cnt = [0] * (k + 1)
for i, c in enumerate(ys):
if i not in locked_procs:
cnt[c] += 1
for c, cn in enumerate(cnt):
if c > 0 and cn > 1:
locked_cells.add(c)
for i, c in enumerate(ys):
if c in locked_cells and i not in locked_procs:
locked_procs.add(i)
lock_time[i] = t + 1
for t in lock_time:
print(t)
179
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = -2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
180
def fast(a, b):
if b == 0:
return 1
if b % 2 == 1:
return a * fast(a, b - 1) % mod
x = fast(a, b / 2) % mod
return x * x % mod
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
p = 0
q = 1
z1 = 1
z2 = 1
mod = 1000000007
for i in range(0, n):
if a[i] != 0 and b[i] != 0:
if a[i] == b[i]:
continue
if a[i] > b[i]:
p = (p * z2 % mod + q * z1 % mod) % mod
q = q * z2 % mod
break
if a[i] == 0 and b[i] != 0:
p = (p * m * z2 % mod + z1 * q * (m - b[i]) % mod) % mod
q = q * z2 * m % mod
z2 = z2 * m % mod
if a[i] != 0 and b[i] == 0:
p = (p * m * z2 % mod + z1 * q * (a[i] - 1) % mod) // mod
q = q * z2 * m % mod
z2 = z2 * m % mod
if a[i] == 0 and b[i] == 0:
p = (p * m * 2 * z2 + z1 * q * (m - 1)) % mod
q = q * z2 * 2 * m % mod
z2 = z2 * m % mod
print(p * (fast(q, mod - 2) % mod) % mod)
181
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]))
182
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000003)
183
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def LF():
return [float(x) for x in sys.stdin.readline().split()]
def LS():
return sys.stdin.readline().split()
def I():
return int(sys.stdin.readline())
def F():
return float(sys.stdin.readline())
def S():
return input()
def main():
n, q = LI()
nn = n
k = 2
while nn > 0:
nn //= 2
k += 1
r = []
ii = [2 ** i for i in range(k)]
for _ in range(q):
t = I()
s = S()
ti = 0
for i in range(k):
if ii[i] & t:
ti = i
break
for c in s:
if c == 'U':
if ti == k - 1:
continue
if t & ii[ti]:
t ^= ii[ti]
ti += 1
t |= ii[ti]
continue
if ti == 0:
continue
if c == 'R':
t |= ii[ti]
elif t & ii[ti]:
t ^= ii[ti]
ti -= 1
t |= ii[ti]
r.append(t)
return '\n'.join(map(str, r))
print(main())
184
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()
185
def adds(memtoproc, mem, proc):
if mem in memtoproc:
memtoproc[mem].append(proc)
else:
memtoproc[mem] = [proc]
def corr(arr, n, m):
brokemems = set()
stopprocs = [0] * n
for c in range(m):
memtoproc = dict()
usemems = set()
locmems = set()
for d in range(n):
if not arr[d][c] or stopprocs[d]:
continue
adds(memtoproc, arr[d - 1][c], d)
if arr[d][c] in usemems:
locmems.add(arr[d][c])
usemems.add(arr[d][c])
if arr[d][c] in brokemems:
if not stopprocs[d]:
stopprocs[d] = c + 1
for d in locmems:
brokemems.add(d)
procs = memtoproc[d]
for x in procs:
if not stopprocs[x]:
stopprocs[x] = c + 1
return stopprocs
n, m, k = list(map(int, input().split(' ')))
arr = []
for c in range(n):
arr.append(tuple(map(int, input().split(' '))))
procs = corr(arr, n, m)
for c in procs:
print(c)
186
n = int(input())
C = 10 ** 9 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) < int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1 - 1][2] %= C
d[-1][3] %= C
print(d[-1][2])
187
a, b, c = [int(i) for i in input().split()]
length = a * b
numArr = [int(i) for i in input().split()]
numArr.sort()
count = 0
mmin = numArr[0]
mmax = numArr[a - 1]
if mmax - mmin > c:
print(0)
else:
maxPos = a - 1
while maxPos + 1 < length and numArr[maxPos + 1] <= mmin + c:
maxPos += 1
dis = maxPos + 1 - a
bCount = 0
for i in range(maxPos + 1):
if dis != 0:
bCount += -2
dis -= 1
if bCount % b == 1:
count += numArr[i]
dis += 1
else:
count += numArr[i]
print(count)
188
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def LF():
return [float(x) for x in sys.stdin.readline().split()]
def LS():
return sys.stdin.readline().split()
def I():
return int(sys.stdin.readline())
def F():
return float(sys.stdin.readline())
def S():
return input()
def main():
n, q = LI()
nn = n
k = 0
while nn > 0:
nn //= 2
k += 2
r = []
ii = [2 ** i for i in range(k)]
for _ in range(q):
t = I()
s = S()
ti = 0
for i in range(k):
if ii[i] & t:
ti = i
break
for c in s:
if c == 'U':
if ti == k - 1:
continue
if t & ii[ti]:
t ^= ii[ti]
ti += 1
t |= ii[ti]
continue
if ti == 0:
continue
if c == 'R':
t |= ii[ti]
elif t & ii[ti]:
t ^= ii[ti]
ti -= 1
t |= ii[ti]
r.append(t)
return '\n'.join(map(str, r))
print(main())
189
w, h, n = map(int, input().split())
x = [0, w]
y = [0, h]
rev = []
for _ in range(n):
s, d = input().split()
if s == 'H':
y.append(int(d))
else:
x.append(int(d))
rev.append((s, int(d)))
x.sort()
y.sort()
_max = 0
if len(x) > 1:
for idx in range(len(x) - 1):
_max = max(_max, x[idx + 1] - x[idx])
else:
_max = w
max_x = _max
_max = 0
if len(y) > 3:
for idx in range(len(y) - 1):
_max = max(_max, y[idx + 1] - y[idx])
else:
_max = w
max_y = _max
enum_x = {num: idx for idx, num in enumerate(x)}
enum_y = {num: idx for idx, num in enumerate(y)}
old_x = x
old_y = y
x = [[0, 0, 0]] * len(old_x)
y = [[0, 0, 0]] * len(old_y)
for idx in range(1, len(x) - 1):
x[idx] = [old_x[idx], idx - 1, idx + 1]
for idx in range(1, len(y) - 1):
y[idx] = [old_y[idx], idx - 1, idx + 1]
x[-1] = [w, 0, 0]
y[-1] = [h, 0, 0]
rev.reverse()
ans = [max_x * max_y]
for item in rev:
if item[0] == 'H':
elem = y[enum_y[item[1]]]
max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0])
y[elem[1]][2] = elem[2]
y[elem[2]][1] = elem[1]
else:
elem = x[enum_x[item[1]]]
max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0])
x[elem[1]][2] = elem[2]
x[elem[2]][1] = elem[1]
ans.append(max_x * max_y)
ans.pop()
print('\n'.join(map(str, reversed(ans))))
190
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)
191
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 0
num3 = 0
while q > 0:
typ, xt = map(int, input().split())
if typ == 1:
xi[0][xt] += 4
noti += [xt]
num += 1
num2 += 1
elif typ == 3:
for i in range(num3, xt):
if i + 1 > xi[1][noti[i]]:
xi[0][noti[i]] -= 1
num -= 1
num3 = max(num3, xt)
else:
num -= xi[0][xt]
xi[0][xt] = 0
xi[1][xt] = num2
ans += str(num)
ans += '\n'
q -= 1
print(ans)
192
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
193
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
class Node:
val = None
def __init__(self, val):
self.val = val
self.left = Node
self.right = None
def solve(W, H, N, A):
xs = [0] + [v for t, v in A if t == 0] + [W]
ys = [0] + [v for t, v in A if t == 1] + [H]
xs.sort()
ys.sort()
xlist = Node(0)
h = xlist
xnodes = {0: h}
maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
for v in xs[1:]:
n = Node(v)
xnodes[v] = n
h.right = n
n.left = h
h = n
ylist = Node(1)
h = ylist
ynodes = {0: h}
for v in ys[1:]:
n = Node(v)
ynodes[v] = n
h.right = n
n.left = h
h = n
ans = []
maxarea = maxh * maxw
for t, v in reversed(A):
ans.append(maxarea)
if t == 0:
node = xnodes[v]
w = node.right.val - node.left.val
maxw = max(maxw, w)
else:
node = ynodes[v]
h = node.right.val - node.left.val
maxh = max(maxh, h)
node.left.right = node.right
node.right.left = node.left
maxarea = maxh * maxw
return ans[::-1]
def solve2(W, H, N, A):
ws = [(-W, 0, W)]
hs = [(-H, 0, H)]
iw, ih = (set(), set())
ans = []
xs, ys = ([0, W], [0, H])
for t, v in A:
if t == 0:
bisect.insort_left(xs, v)
i = bisect.bisect_left(xs, v)
l, m, r = (xs[i - 1], xs[i], xs[i + 1])
iw.add((l - r, l, r))
heapq.heappush(ws, (l - m, l, m))
heapq.heappush(ws, (m - r, m, r))
while ws[0] in iw:
heapq.heappop(ws)
else:
bisect.insort(ys, v)
i = bisect.bisect_left(ys, v)
l, m, r = (ys[i - 1], ys[i], ys[i + 1])
ih.add((l - r, l, r))
heapq.heappush(hs, (l - m, l, m))
heapq.heappush(hs, (m - r, m, r))
while hs[0] in ih:
heapq.heappop(hs)
w, h = (ws[0], hs[0])
ans.append(w[0] * h[0])
return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
a, b = input().split()
c = 0 if a == 'V' else 1
A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
194
import math
n, q = map(int, input().split())
maxh = int(math.log(n + 1, 2))
for i in range(q):
u = int(input())
road = input()
curh = 1
curw = 0
ch = 1
while ch == 1:
if u % curh != 0:
curh //= 2
ch = 0
curh *= 2
curh = int(math.log(curh, 2))
a = 1 << curh - 1
b = 2 << curh
curw = (u - a) // b + 1
for move in road:
if move == 'L':
if curh != 1:
curh -= 1
curw = curw * 2 - 1
u -= 1 << curh - 1
elif move == 'R':
if curh != 1:
curh -= 1
curw *= 2
u += 1 << curh - 1
elif curh != maxh:
if curw % 2 == 1:
u = (u + u + (1 << curh)) // 2
curh += 1
curw = curw // 2 + 1
else:
u = (u + u - (1 << curh)) // 2
curh += 1
curw = curw // 2
print(u)
195
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)
196
n, k, l = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = sorted(arr)
if arr[n - 1] - arr[0] > l:
print(0)
else:
maxVol = arr[0] + l
index = 0
while index < n * k - 1 and arr[index + 1] <= maxVol:
index += 1
s = arr[0]
i = 0
remaining = n - 1
while remaining > 0 and i + k + remaining - 1 <= index:
i += k
remaining -= 1
s += arr[i]
if remaining > 0 and index - (remaining - 1) > 1 + i:
i = index - (remaining - 1)
s += arr[i]
remaining -= 1
while remaining > 0:
i += -1
s += arr[i]
remaining -= 1
print(s)
197
3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = 55 * ans % (10 ** 9 + 7)
elif s[i] == '?':
ans = (ord(t[i]) - ord('0') + 1) * ans % (10 ** 9 + 7)
elif t[i] == '?':
ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' or s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and (not tlts):
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 - 7))
elif sltt:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
198
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
line, index = input().split()
index = int(index)
if line == 'V':
r[index] = w
V[i] = index
else:
t[index] = h
H[i] = index
left = 0
mxw = 0
for i in range(1, w + 1):
if r[i] != -1:
l[i] = left
r[left] = i
mxw = max(mxw, i - left)
left = i
bottom = 0
mxh = 0
for i in range(1, h + 1):
if t[i] != -1:
b[i] = bottom
t[bottom] = i
mxh = max(mxh, i - bottom)
bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
if V[i] != 0:
mxw = max(mxw, r[V[i]] - l[V[i]])
r[l[V[i]]] = r[V[i]]
l[r[V[i]]] = l[V[i]]
else:
mxh = max(mxh, t[H[i]] - b[H[i]])
b[t[H[i]]] = b[H[i]]
t[b[H[i]]] = t[H[i]]
ans[i - 1] = mxh * mxw
for i in range(n):
print(ans[i])
199
n = int(input())
C = 10 ** 8 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) < int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1][2] %= C
d[-1][3] %= C
print(d[-1][2])
200
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]))
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.