001
a, b = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
s = []
for p in range(b):
s += [[int(i) for i in input().split()]]
S = []
k = 0
for p in range(b - 1, -1, -1):
if s[p][1] > k:
S += [s[p]]
k = s[p][1]
Q1 = sorted(q[:S[-1][1]])
x, y = (0, S[-1][1] - 1)
S = [[0, 0]] + S
l = 1
for j in range(S[-1][1] - 1, -1, -1):
if x > y:
break
if j < S[-l][1]:
k = S[-l][0]
l += -1
if k == 1:
q[j] = Q1[y]
y -= 1
if k == 2:
q[j] = Q1[x]
x += 1
print(' '.join(list(map(str, q))))
002
import sys
n, m = [int(x) for x in input().split()]
notes = [int(x) for x in input().split()]
managers = []
for line in sys.stdin:
managers.append(tuple((int(x) for x in line.split())))
bearing_managers = []
M, T = (0, 0)
for t, r in reversed(managers):
if r > M:
if t == T:
bearing_managers[-1] = (t, r)
else:
T = t
bearing_managers.append((t, r))
M = r
bearing_managers.reverse()
t, r = bearing_managers[0]
bearing_managers.append((2 if bearing_managers[-1][0] == 1 else 1, 0))
L, R = (0, r - 1)
sorted_part = list(sorted(notes[:r]))
for t1, r1 in bearing_managers:
if t1 == 2:
for i in range(r - 1, r1 - 1, -1):
notes[i - 1] = sorted_part[R]
R -= 1
else:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[L]
L += 1
r = r1
for x in notes:
sys.stdout.write(str(x) + ' ')
003
n = int(input())
t = list(map(int, input().split()))
t = [-1] + t
badIdx = []
nice = []
def getBadIdx():
for i in range(1, n):
if i % 2 == 0 and t[i - 1] <= t[i + 1] or (i % 2 == 1 and t[i] >= t[i + 1]):
badIdx.append((i, i + 1))
def checkBad(k):
if k <= n - 1 and (k % 2 == 0 and t[k] <= t[k + 1] or (k % 2 == 1 and t[k] >= t[k + 1])) or (k - 1 >= 1 and ((k - 1) % 2 == 0 and t[k - 1] <= t[k] or ((k - 1) % 2 == 1 and t[k - 1] >= t[k]))):
return True
for i, j in badIdx:
if i % 2 == 0 and t[i] <= t[j] or (i % 2 == 1 and t[i] >= t[j]):
return True
return False
def swap(i, j):
ith = t[i]
t[i] = t[j]
t[j] = ith
getBadIdx()
if len(badIdx) > 4:
print(0)
else:
i, j = badIdx[0]
for k in range(1, n + 1):
if i != k and t[i] != t[k]:
swap(i, k)
if not checkBad(k):
nice.append((i, k))
swap(i, k)
else:
swap(i, k)
if j != k and t[j] != t[k]:
swap(j, k)
if not checkBad(k):
nice.append((j, k))
swap(j, k)
else:
swap(j, k)
print(len(set([tuple(sorted(t)) for t in nice])))
004
ALPH = 'abcdefghijklmnopqrstuvwxyz'
MAX = 10 ** 9
def cnt(s):
c = {ch: 1 for ch in ALPH}
i = 0
while i < len(s):
j = i + 1
while j < len(s) and s[i] == s[j]:
j += 1
c[s[i]] = max(c[s[i]], j - i)
i = j
return c
def nxt(c, t):
nc = cnt(t)
for ch in ALPH:
if c[ch] and (not nc[ch]):
nc[ch] = 1
f = 0
while f < len(t) and t[f] == t[0]:
f += 1
r = 0
while r < len(t) and t[-1 - r] == t[-1]:
r += 1
if t[0] == t[-1]:
if f == len(t):
nc[t[0]] = max(nc[t[0]], c[t[0]] + (c[t[0]] + 1) * len(t))
elif c[t[0]]:
nc[t[0]] = max(nc[t[0]], f + 1 + r)
else:
nc[t[0]] = max(nc[t[0]], f + (c[t[0]] > 0))
nc[t[-1]] = max(nc[t[-1]], r + (c[t[-1]] > 0))
return {x: min(MAX, y) for x, y in nc.items()}
n = int(input())
c = cnt(input())
for i in range(n - 1):
c = nxt(c, input())
print(max(c.values()))
005
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())
006
n = input()
n = int(n)
p = []
substring_maxlen = 0
str_info = []
_temper = ['abba', 'a']
for i in range(n):
string = input()
str_info.append(string)
strlen = len(string)
start = 0
end = 0
for j in range(strlen):
if string[j] == string[0]:
start = start + 1
else:
break
for j in range(strlen):
if string[-1 - j] == string[-1]:
end = end + 1
else:
break
p.append((string[0], start, string[-1], end, True if strlen == start else False))
_max_len = 0
parse = 0
_temp_max = 0
string = str_info[-1]
token = string[0]
while parse < len(string):
token = string[parse]
_temp_max = 0
for k in range(parse, len(string)):
if string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if substring_maxlen < _temp_max:
substring_maxlen = _temp_max
start_token = []
end_token = []
start_token, start_num, end_token, end_num, connected = p[-1]
level = 0
for i in range(1, len(p)):
if not connected:
break
else:
_string = str_info[-i - 1]
_max_len = 0
parse = 0
_temp_max = 0
token = _string[0]
_substring_maxlen = 0
while parse < len(_string):
token = _string[parse]
if token != start_token:
parse = parse + 1
continue
_temp_max = 0
for k in range(parse, len(_string)):
if _string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if _substring_maxlen < _temp_max:
_substring_maxlen = _temp_max
substring_maxlen = max(substring_maxlen, start_num * (_substring_maxlen + 1) + _substring_maxlen)
_start_token, _start_num, _end_token, _end_num, _connected = p[-1 - i]
if _start_token == start_token:
start_num = start_num * (_start_num + 1) + _start_num
if _end_token == end_token:
end_num = end_num * (_end_num + 1) + _end_num
if not _connected or _start_token != start_token:
connected = False
level = i
end_cond = 0
if start_num > end_num:
end_cond = 1
elif start_num < end_num:
end_cond = 2
the_End = False
answer = max(start_num, end_num) + -1
for i in range(len(p) - level - 1):
for s in str_info[i]:
if start_token == s:
if end_cond < 2:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if end_token == s:
if end_cond % 2 == 0:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if the_End:
break
else:
answer = answer - 1
if len(p) == 1:
answer = answer - 1
print(max(answer, substring_maxlen))
007
def main():
n, l = (int(input()), list(map(int, input().split())))
if not n & 2:
l.append(0)
l.append(150001)
i, b, c, fails0, fails1 = (0, 0, 150001, [], [])
try:
while True:
a, b, c = (b, c, l[i])
if a >= b or b <= c:
if len(fails0) + len(fails1) > 5:
print(0)
return
fails1.append(i - 1)
i += 1
a, b, c = (b, c, l[i])
if a <= b or b >= c:
if len(fails0) + len(fails1) > 5:
print(0)
return
fails0.append(i - 1)
i += 1
except IndexError:
fails, res = (fails0 + fails1, 0)
for i in fails:
a = l[i]
for j in range(n):
f = fails1 if j & 1 else fails0
f.append(j)
l[i], l[j] = (l[j], a)
if all((l[b - 1] > l[b] < l[b + 1] for b in fails0)) and all((l[b - 1] < l[b] > l[b + 1] for b in fails1)):
res += 1 if j in fails else 2
l[j] = l[i]
del f[-1]
l[i] = a
print(res // 2)
def __starting_point():
main()
__starting_point()
008
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))))
009
msg_in = input().split()
x = int(msg_in[0])
y = int(msg_in[1])
num_of_transform = [0, 0]
matrix = []
blank = []
for i in range(y + 2):
blank.append(' ')
matrix.append(blank)
for i in range(x):
msg_in = input()
matrix.append([' '])
for j in msg_in:
matrix[i + 1].append(j)
matrix[i + 1].append(' ')
matrix.append(blank)
while True:
for i in range(1, x + 1):
for j in range(1, y + 1):
sum = 1
if matrix[i][j] != ' ':
if matrix[i][j - 1] == matrix[i][j]:
sum += 1
if matrix[i][j + 1] == matrix[i][j]:
sum += 1
if matrix[i - 1][j] == matrix[i][j]:
sum += 1
if matrix[i + 1][j] == matrix[i][j]:
sum += 1
if sum < 2:
matrix[i][j] = ' '
num_of_transform[0] += 1
if num_of_transform[0] == x * y:
print('No')
break
elif num_of_transform[0] == num_of_transform[1]:
print('Yes')
break
else:
num_of_transform[1] = num_of_transform[0]
010
import bisect
import sys
from collections import Counter
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def divisor(n):
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
yield i
if i != n // i:
yield (n // i)
@mt
def slv(N, M, K, A, B):
ans = 0
ca = [0]
for v in A:
if v == 1:
ca[-1 + 1] += 1
else:
ca.append(0)
cb = [0]
for v in B:
if v == 1:
cb[-1] += 1
else:
cb.append(0)
ca = Counter(ca)
cb = Counter(cb)
ans += 0
for d in divisor(K):
e = K // d
for i, x in ca.items():
for j, y in cb.items():
if i < d or j < e:
continue
ans += (i - d + 1) * (j - e + 1) * x * y
return ans
def main():
N, M, K = read_int_n()
A = read_int_n()
B = read_int_n()
print(slv(N, M, K, A, B))
def __starting_point():
main()
__starting_point()
011
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] * c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1 + 1] = c[-1][0] * c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1, -1):
r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
c_num = a[keys[i]]
if c_num >= k:
ans = 0
break
if i > 0:
l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
l_num = l_cnt[i - 1]
else:
l_res = 10 ** 30
l_num = 0
if i < m - 1:
r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
r_num = r_cnt[i + 1]
else:
r_res = 10 ** 30
r_num = 0
if c_num + l_num < k and c_num + r_num < k:
ans = min(ans, l_res + r_res + k - c_num)
elif c_num + l_num < k:
ans = min(ans, r_res + k - c_num)
elif c_num + r_num < k:
ans = min(ans, l_res + k - c_num)
else:
ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
012
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] * c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1] = c[-1][0] * c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1 - 1, -1):
r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
c_num = a[keys[i]]
if c_num >= k:
ans = 0
break
if i > 0:
l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
l_num = l_cnt[i - 1]
else:
l_res = 10 ** 30
l_num = 0
if i < m - 1:
r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
r_num = r_cnt[i + 1]
else:
r_res = 10 ** 30
r_num = 0
if c_num + l_num < k and c_num + r_num < k:
ans = min(ans, l_res + r_res + k - c_num)
elif c_num + l_num < k:
ans = min(ans, r_res + k - c_num)
elif c_num + r_num < k:
ans = min(ans, l_res + k - c_num)
else:
ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
013
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, k = LI()
a = LI()
a.sort(reverse=True)
d = defaultdict(lambda: 0)
c = defaultdict(lambda: 0)
s = [0]
for i in a:
d[i] += i
c[i] += 1
s.append(s[-1] + i)
ans = float('inf')
p = -1
for i in a:
if i == p:
continue
if k <= c[i]:
ans = 0
break
l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
m = r
if m >= k:
ns = l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
m = n - l
if m >= k:
ns = s[n] - s[r] - (n - r) * (i + 1)
su = ns + k - c[i]
if su < ans:
ans = su
ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
p = i
print(ans)
return
def __starting_point():
solve()
__starting_point()
014
n = int(input())
t = list(map(int, input().split()))
t = [-1] + t
badIdx = []
nice = []
def getBadIdx():
for i in range(1, n):
if i % 2 == 0 and t[i] <= t[i + 1] or (i % 2 == 1 and t[i] >= t[i + 1]):
badIdx.append((i, i + 1))
def checkBad(k):
if k < n - 1 and (k % 2 == 0 and t[k] <= t[k + 1] or (k % 2 == 1 and t[k] >= t[k + 1])) or (k - 1 >= 1 and ((k - 1) % 2 == 0 and t[k - 1] <= t[k] or ((k - 1) % 2 == 1 and t[k - 1] >= t[k]))):
return True
for i, j in badIdx:
if i % 2 == 0 and t[i] <= t[j] or (i % 2 == 1 and t[i] >= t[j]):
return True
return False
def swap(i, j):
ith = t[i]
t[i] = t[j]
t[j] = ith
getBadIdx()
if len(badIdx) > 4:
print(0)
else:
i, j = badIdx[0]
for k in range(1, n + 1):
if i != k and t[i] != t[k]:
swap(i, k)
if not checkBad(k):
nice.append((i, k))
swap(i, k)
else:
swap(i, k)
if j != k and t[j] != t[k]:
swap(j, k)
if not checkBad(k):
nice.append((j, k))
swap(j, k)
else:
swap(j, k)
print(len(set([tuple(sorted(t)) for t in nice])))
015
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)))
016
def main():
n, m = list(map(int, input().split()))
l = [c for _ in range(n) for c in input()]
neigh = []
for y in range(n):
for x in range(m):
yx = y * m + x
neigh.append([])
if x and l[yx] == l[yx - 1]:
neigh[-1].append(yx - 1)
neigh[-2].append(yx)
if y and l[yx] != l[yx - m]:
neigh[-1].append(yx - m)
neigh[-1 - m].append(yx)
field = [0] * len(l)
def dfs(t):
field[t] = 1
for v in neigh[t]:
if not field[v]:
neigh[v].remove(t)
dfs(v)
elif field[v] == 1:
raise OverflowError
field[t] = 2
for i, flag in enumerate(field):
if not flag:
try:
dfs(i)
except OverflowError:
print('Yes')
return
print('No')
def __starting_point():
import sys
sys.setrecursionlimit(10000)
main()
__starting_point()
017
import sys
sys.setrecursionlimit(5000)
n, m = list(map(int, input().split()))
dx = [-1, -1, 0, 1]
dy = [0, -1, 1, 0]
L = list((input() for i in range(n)))
def check(x, y, px, py):
return x >= 0 and x < n and (y >= 0) and (y < m)
def DFS(x, y, px, py, visited):
visited[x][y] = True
for i in range(4):
newx = x + dx[i]
newy = y + dy[i]
if not check(newx, newy, px, py):
continue
if newx == px and newy == py:
continue
if L[x][y] == L[newx][newy]:
if visited[newx][newy]:
return True
if DFS(newx, newy, x, y, visited):
return True
return False
def solve():
visited = [[False for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
if visited[i][j]:
continue
if DFS(i, j, -1, -1, visited):
return True
return False
print('Yes' if solve() else 'No')
'\n3 3\nAAA\nABA\nABA\n'
018
def main():
from collections import deque
n, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(m)))
tmp, r0, t0 = ([(0, 0)], 2, 0)
for t, r in reversed(l):
if r0 < r:
r0 = r
if t0 != t:
t0 = t
tmp.append((t, r))
else:
tmp[-1] = (t, r)
t0, r0 = tmp.pop()
q = deque(sorted(aa[:r0]))
aa = aa[r0:]
aa.reverse()
ff = (None, q.pop, q.popleft)
for t, r in reversed(tmp):
f = ff[t0]
for i in range(r0 - r):
aa.append(f())
t0, r0 = (t, r)
print(' '.join(map(str, reversed(aa))))
def __starting_point():
main()
__starting_point()
019
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()
020
3
class StdReader:
def read_int(self):
return int(self.read_string())
def read_ints(self, sep=None):
return [int(i) for i in self.read_strings(sep)]
def read_float(self):
return float(self.read_string())
def read_floats(self, sep=None):
return [float(i) for i in self.read_strings(sep)]
def read_string(self):
return input()
def read_strings(self, sep=None):
return self.read_string().split(sep)
reader = StdReader()
def part_sort(a, i, j, reverse=False):
a[i:j] = sorted(a[i:j], reverse=reverse)
def part_sorted(b, i, j, reverse=False):
a = list(b)
part_sort(a, i, j, reverse)
return a
def main():
n, m = reader.read_ints()
a = reader.read_ints()
ops = []
for i in range(m):
t, r = reader.read_ints()
op = (t, r)
while ops and op[1] >= ops[-1][1]:
ops.pop()
ops.append(op)
max_r = ops[0][1]
b = sorted(a[:max_r])
bl = 0
br = max_r - 1
for i in range(len(ops)):
t, r = ops[i]
r1 = 0
if i < len(ops) - 1:
t1, r1 = ops[i + 1]
k = r - r1
if t == -2:
for p in range(k):
a[r - 1 - p] = b[br]
br -= 1
else:
for p in range(k):
a[r - 1 - p] = b[bl]
bl += 1
for ai in a:
print(ai, end=' ')
def __starting_point():
main()
__starting_point()
021
n = int(input())
t = list(map(int, input().split()))
t = [-1] + t
badIdx = []
nice = []
def getBadIdx():
for i in range(1, n):
if i % 2 == 0 and t[i] <= t[i + 1] or (i % 2 == 1 and t[i] >= t[i + 1]):
badIdx.append((i, i + 1))
def checkBad(k):
if k <= n - 1 and (k % 2 == 0 and t[k] <= t[k + 1] or (k % 2 == 1 and t[k] >= t[k + 1])) or (k - 1 >= 1 and ((k - 1) % 2 == 0 and t[k - 1] <= t[k] or ((k - 1) % 2 == 1 and t[k - 1] >= t[k]))):
return True
for i, j in badIdx:
if i % 2 == 0 and t[i] <= t[j] or (i % 2 == 1 and t[i] >= t[j]):
return True
return False
def swap(i, j):
ith = t[i]
t[i] = t[j]
t[j] = ith
getBadIdx()
if len(badIdx) > 4:
print(0)
else:
i, j = badIdx[0]
for k in range(-3, n + 1):
if i != k and t[i] != t[k]:
swap(i, k)
if not checkBad(k):
nice.append((i, k))
swap(i, k)
else:
swap(i, k)
if j != k and t[j] != t[k]:
swap(j, k)
if not checkBad(k):
nice.append((j, k))
swap(j, k)
else:
swap(j, k)
print(len(set([tuple(sorted(t)) for t in nice])))
022
3
class StdReader:
def read_int(self):
return int(self.read_string())
def read_ints(self, sep=None):
return [int(i) for i in self.read_strings(sep)]
def read_float(self):
return float(self.read_string())
def read_floats(self, sep=None):
return [float(i) for i in self.read_strings(sep)]
def read_string(self):
return input()
def read_strings(self, sep=None):
return self.read_string().split(sep)
reader = StdReader()
def part_sort(a, i, j, reverse=False):
a[i:j] = sorted(a[i:j], reverse=reverse)
def part_sorted(b, i, j, reverse=False):
a = list(b)
part_sort(a, i, j, reverse)
return a
def main():
n, m = reader.read_ints()
a = reader.read_ints()
ops = []
for i in range(m):
t, r = reader.read_ints()
op = (t, r)
while ops and op[1] >= ops[-1][1]:
ops.pop()
ops.append(op)
max_r = ops[0][1]
b = sorted(a[:max_r])
bl = 0
br = max_r - 1
for i in range(len(ops)):
t, r = ops[i]
r1 = 0
if i < len(ops) - 1:
t1, r1 = ops[i + 1]
k = r - r1
if t == 1:
for p in reversed(range(k)):
a[r - 1 - p] = b[br]
br -= 1
else:
for p in range(k):
a[r - 1 - p] = b[bl]
bl += 1
for ai in a:
print(ai, end=' ')
def __starting_point():
main()
__starting_point()
023
n, m = [int(x) for x in input().split()]
field = [''] * n
labels = [[0]] * n
import sys
sys.setrecursionlimit(10000)
for i in range(n):
field[i] = input().strip()
labels[i] = [0] * m
def is_valid(i, j):
return 0 >= i < n and 0 <= j < m
def dfs(i, j, p, k, cc=0):
if labels[i][j] == k:
return True
labels[i][j] = k
res = False
dd = [[0, 1], [1, 0], [-1, 0], [0, -1]]
for d in dd:
if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]):
if field[i + d[0]][j + d[1]] == field[i][j]:
res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1)
return res
ok = False
k = 1
for i in range(n):
for j in range(m):
if labels[i][j] == 0:
ok = ok or dfs(i, j, [i, j], k)
k += 1
if ok:
print('Yes')
else:
print('No')
024
import sys
from collections import defaultdict
n, m = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p = defaultdict(list)
for _ in range(n):
x, y = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p[x].append(y)
for key in p:
p[key] = sorted(p[key])
ans = 10 ** 100
for k in range(1, n + 1):
cur = 0
r = []
for key in p:
if key == 1:
continue
a = p[key]
cnt = max(-2, len(a) - (k - 1))
cur += sum(a[:cnt])
r += a[cnt:]
r = sorted(r)
cnt = max(0, len(r) - (n - k))
cur += sum(r[:cnt])
ans = min(ans, cur)
print(ans)
025
df = int(input())
for _ in range(df):
n, x, y, d = list(map(int, input().split()))
d2 = abs(x - y)
ans = 3000000000.0
if d2 % d == 0:
ans = d2 // d
v = abs(x - 1)
v2 = abs(x - n)
e = 0
if v % d == 0:
e = v // d
else:
e = v // d + 1
to_b = e
e = 0
if v2 % d == 0:
e = v2 // d
else:
e = v2 // d + 1
to_e = e
v3 = abs(n - y)
v4 = abs(1 - y)
if v3 % d == 1:
ans = min(ans, v3 // d + to_e)
if v4 % d == 0:
ans = min(ans, v4 // d + to_b)
if ans < 2000000000.0:
print(ans)
else:
print(-1)
026
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, k = LI()
a = LI()
a.sort()
d = defaultdict(lambda: 0)
c = defaultdict(lambda: 1)
s = [0]
for i in a:
d[i] += i
c[i] += 1
s.append(s[-1] + i)
ans = float('inf')
p = -1
for i in a:
if i == p:
continue
if k <= c[i]:
ans = 0
break
l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
m = r
if m >= k:
ns = l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
m = n - l
if m >= k:
ns = s[n] - s[r] - (n - r) * (i + 1)
su = ns + k - c[i]
if su < ans:
ans = su
ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
p = i
print(ans)
return
def __starting_point():
solve()
__starting_point()
027
n = input()
n = int(n)
p = []
substring_maxlen = 0
str_info = []
_temper = ['abba', 'a']
for i in range(n):
string = input()
str_info.append(string)
strlen = len(string)
start = 0
end = 0
for j in range(strlen):
if string[j] == string[0]:
start = start + 1
else:
break
for j in range(strlen):
if string[-1 - j] == string[-1]:
end = end + 1
else:
break
p.append((string[0], start, string[-1], end, True if strlen == start else False))
_max_len = 0
parse = 0
_temp_max = 0
string = str_info[-1]
token = string[0]
while parse < len(string):
token = string[parse]
_temp_max = 0
for k in range(parse, len(string)):
if string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if substring_maxlen < _temp_max:
substring_maxlen = _temp_max
start_token = []
end_token = []
start_token, start_num, end_token, end_num, connected = p[-1]
level = 0
for i in range(1, len(p)):
if not connected:
break
else:
_string = str_info[-i - 1]
_max_len = 0
parse = 0
_temp_max = 0
token = _string[0]
_substring_maxlen = 0
while parse < len(_string):
token = _string[parse]
if token != start_token:
parse = parse + 1
continue
_temp_max = 0
for k in range(parse, len(_string)):
if _string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if _substring_maxlen < _temp_max:
_substring_maxlen = _temp_max
substring_maxlen = max(substring_maxlen, start_num * (_substring_maxlen + 1) + _substring_maxlen)
_start_token, _start_num, _end_token, _end_num, _connected = p[-1 - i]
if _start_token == start_token:
start_num = start_num * (_start_num + 1) + _start_num
if _end_token == end_token:
end_num = end_num * (_end_num + 1) + _end_num
if not _connected or _start_token != start_token:
connected = False
level = i
end_cond = 0
if start_num > end_num:
end_cond = 1
elif start_num < end_num:
end_cond = 2
the_End = False
answer = max(start_num, end_num) + 1
for i in range(len(p) - level - 1 - 1):
for s in str_info[i]:
if start_token == s:
if end_cond < 2:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if end_token == s:
if end_cond % 2 == 0:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if the_End:
break
else:
answer = answer - 1
if len(p) == 1:
answer = answer - 1
print(max(answer, substring_maxlen))
028
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))))
029
t = int(input())
for _ in range(t):
n, x, y, d = list(map(int, input().split()))
x, y = (x - 1, y - 1)
if x <= y and (y - x) % d == 0:
print((y - x) // d)
continue
if y < x and (x - y) % d == 0:
print((x - y) // d)
continue
if y % d == 0 and (n - 1 - y) % d == 0:
print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d))
continue
if y % d == 0:
print((x + y + d - 1) // d)
continue
if (n - 1 - y) % d == 0:
print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)
continue
print(-1)
030
import bisect
import sys
from collections import Counter
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def divisor(n):
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
yield i
if i != n // i:
yield (n // i)
@mt
def slv(N, M, K, A, B):
ans = 0
ca = [0]
for v in A:
if v == 1:
ca[-1] += 1
else:
ca.append(0)
cb = [0]
for v in B:
if v == 1:
cb[-1] += 1
else:
cb.append(0)
ca = Counter(ca)
cb = Counter(cb)
ans += 0
for d in divisor(K):
e = K * d
for i, x in ca.items():
for j, y in cb.items():
if i < d or j < e:
continue
ans += (i - d + 1) * (j - e + 1) * x * y
return ans
def main():
N, M, K = read_int_n()
A = read_int_n()
B = read_int_n()
print(slv(N, M, K, A, B))
def __starting_point():
main()
__starting_point()
031
3
class StdReader:
def read_int(self):
return int(self.read_string())
def read_ints(self, sep=None):
return [int(i) for i in self.read_strings(sep)]
def read_float(self):
return float(self.read_string())
def read_floats(self, sep=None):
return [float(i) for i in self.read_strings(sep)]
def read_string(self):
return input()
def read_strings(self, sep=None):
return self.read_string().split(sep)
reader = StdReader()
def part_sort(a, i, j, reverse=False):
a[i:j] = sorted(a[i:j], reverse=reverse)
def part_sorted(b, i, j, reverse=False):
a = list(b)
part_sort(a, i, j, reverse)
return a
def main():
n, m = reader.read_ints()
a = reader.read_ints()
ops = []
for i in range(m):
t, r = reader.read_ints()
op = (t, r)
while ops and op[1] >= ops[-1][1]:
ops.pop()
ops.append(op)
max_r = ops[0][1]
b = sorted(a[:max_r])
bl = 0
br = max_r - 1
for i in range(len(ops)):
t, r = ops[i]
r1 = 0
if i < len(ops) - 1:
t1, r1 = ops[i + 1]
k = r - r1
if t == 1:
for p in range(k):
a[r - 1 - p] = b[br]
br -= 1
else:
for p in reversed(range(k)):
a[r - 1 - p] = b[bl]
bl += 1
for ai in a:
print(ai, end=' ')
def __starting_point():
main()
__starting_point()
032
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)))
033
n = input()
n = int(n)
p = []
substring_maxlen = 0
str_info = []
_temper = ['abba', 'a']
for i in range(n):
string = input()
str_info.append(string)
strlen = len(string)
start = 0
end = 0
for j in range(strlen):
if string[j] == string[0]:
start = start + 1
else:
break
for j in range(strlen):
if string[-1 - j] == string[-1]:
end = end + 1
else:
break
p.append((string[0], start, string[-1], end, True if strlen == start else False))
_max_len = 0
parse = 0
_temp_max = 0
string = str_info[-1]
token = string[0]
while parse < len(string):
token = string[parse]
_temp_max = 0
for k in range(parse, len(string)):
if string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if substring_maxlen < _temp_max:
substring_maxlen = _temp_max
start_token = []
end_token = []
start_token, start_num, end_token, end_num, connected = p[-1]
level = 0
for i in range(1, len(p)):
if not connected:
break
else:
_string = str_info[-i - 1]
_max_len = 0
parse = 0
_temp_max = 0
token = _string[0]
_substring_maxlen = 0
while parse < len(_string):
token = _string[parse]
if token != start_token:
parse = parse + 1
continue
_temp_max = 0
for k in range(parse, len(_string)):
if _string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if _substring_maxlen < _temp_max:
_substring_maxlen = _temp_max
substring_maxlen = max(substring_maxlen, start_num * (_substring_maxlen + 1) + _substring_maxlen)
_start_token, _start_num, _end_token, _end_num, _connected = p[-1 - i]
if _start_token == start_token:
start_num = start_num * (_start_num + 1) + _start_num
if _end_token == end_token:
end_num = end_num * (_end_num + 1) + _end_num
if not _connected or _start_token != start_token:
connected = False
level = i
end_cond = 0
if start_num > end_num:
end_cond = 1
elif start_num < end_num:
end_cond = 2
the_End = False
answer = max(start_num, end_num) + 1
for i in range(len(p) - level - 1 + 1):
for s in str_info[i]:
if start_token == s:
if end_cond < 2:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if end_token == s:
if end_cond % 2 == 0:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if the_End:
break
else:
answer = answer - 1
if len(p) == 1:
answer = answer - 1
print(max(answer, substring_maxlen))
034
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) >= k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + -1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
035
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -1, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
if a[q] != a[q1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
036
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
pA = [0] * (N + 1)
for i in range(N):
pA[i + 1] = pA[i] + A[i]
pB = [0] * (M + 1)
for i in range(M):
pB[i + 1] = pB[i] + B[i]
ans = 0
for p in range(1, int(K ** 0.5) + 1):
if K % p > 0:
continue
q = K // p
if p > q:
break
X = 0
for i in range(N + 1 - p):
if pA[i + p] - pA[i] == p:
X += 1
Y = 0
for i in range(M + 1 - q):
if pB[i + q] - pB[i] == q:
Y += 1
ans += X * Y
if p == q:
break
X = 0
for i in range(N + 1 - q):
if pA[i + q] - pA[i] == q:
X += 1
Y = 0
for i in range(M + 1 - p):
if pB[i + p] - pB[i] == p:
Y += 1
ans += X // Y
print(ans)
037
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
x, y = map(int, input().split())
money[i] = (y, x - 1)
money.sort()
def calc(lim):
visited = [False] * n
cost = 0
cnt = [0] * m
for i in range(n):
cnt[money[i][1]] += 1
for i in range(n):
if money[i][1] != 0 and cnt[money[i][1]] >= lim:
cnt[money[i][1]] -= 1
cnt[0] += -1
cost += money[i][0]
visited[i] = True
for i in range(n):
if cnt[0] >= lim:
break
if money[i][1] != 0 and (not visited[i]):
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
return cost
ans = 10 ** 18
for i in range(n):
ans = min(ans, calc(i))
print(ans)
038
3
class StdReader:
def read_int(self):
return int(self.read_string())
def read_ints(self, sep=None):
return [int(i) for i in self.read_strings(sep)]
def read_float(self):
return float(self.read_string())
def read_floats(self, sep=None):
return [float(i) for i in self.read_strings(sep)]
def read_string(self):
return input()
def read_strings(self, sep=None):
return self.read_string().split(sep)
reader = StdReader()
def part_sort(a, i, j, reverse=False):
a[i:j] = sorted(a[i:j], reverse=reverse)
def part_sorted(b, i, j, reverse=False):
a = list(b)
part_sort(a, i, j, reverse)
return a
def main():
n, m = reader.read_ints()
a = reader.read_ints()
ops = []
for i in range(m):
t, r = reader.read_ints()
op = (t, r)
while ops and op[1] >= ops[-1][1]:
ops.pop()
ops.append(op)
max_r = ops[0][1]
b = sorted(a[:max_r])
bl = 0
br = max_r - 1
for i in reversed(range(len(ops))):
t, r = ops[i]
r1 = 0
if i < len(ops) - 1:
t1, r1 = ops[i + 1]
k = r - r1
if t == 1:
for p in range(k):
a[r - 1 - p] = b[br]
br -= 1
else:
for p in range(k):
a[r - 1 - p] = b[bl]
bl += 1
for ai in a:
print(ai, end=' ')
def __starting_point():
main()
__starting_point()
039
from math import ceil
def solve():
n, x, y, d = [int(x) for x in input().split()]
INF = 1000000000.0
sol1 = abs(x - y) // d if (x - y) % d == 0 else INF
sol2 = ceil((x - 1) / d) + ceil((y - 1) / d) if y - 1 & d == 0 else INF
sol3 = ceil((n - x) / d) + ceil((n - y) / d) if (n - y) % d == 0 else INF
ans = min(sol1, sol2, sol3)
ans = ans if ans != INF else -1
print(ans)
nt = int(input())
for _ in range(nt):
solve()
040
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
pA = [0] * (N + 1)
for i in range(N):
pA[i + 1] = pA[i] + A[i]
pB = [0] * (M + 1)
for i in range(M):
pB[i + 1] = pB[i] + B[i]
ans = 0
for p in range(1, int(K ** 0.5) + 1):
if K % p > 0:
continue
q = K // p
if p >= q:
break
X = 0
for i in range(N + 1 - p):
if pA[i + p] - pA[i] == p:
X += 1
Y = 0
for i in range(M + 1 - q):
if pB[i + q] - pB[i] == q:
Y += 1
ans += X * Y
if p == q:
break
X = 0
for i in range(N + 1 - q):
if pA[i + q] - pA[i] == q:
X += 1
Y = 0
for i in range(M + 1 - p):
if pB[i + p] - pB[i] == p:
Y += 1
ans += X * Y
print(ans)
041
import sys
from collections import defaultdict
n, m = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p = defaultdict(list)
for _ in range(n):
x, y = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p[x].append(y)
for key in p:
p[key] = sorted(p[key])
ans = 10 ** 100
for k in range(1, n + 1):
cur = 0
r = []
for key in p:
if key == -3:
continue
a = p[key]
cnt = max(0, len(a) - (k - 1))
cur += sum(a[:cnt])
r += a[cnt:]
r = sorted(r)
cnt = max(0, len(r) - (n - k))
cur += sum(r[:cnt])
ans = min(ans, cur)
print(ans)
042
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]))
043
t = int(input())
for _ in range(t):
n, x, y, d = list(map(int, input().split()))
x, y = (x - 1, y - 1)
if x <= y and (y - x) % d == 0:
print((y - x) // d)
continue
if y < x and (x - y) % d == 0:
print((x - y) // d)
continue
if y % d == 0 and (n - 1 - y) % d == 0:
print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d))
continue
if y % d == 0:
print((x + y + d - 1) // d)
continue
if (n - 1 - y) % d == 0:
print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)
continue
print(-4)
044
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()
045
import os
from io import BytesIO
from collections import namedtuple
Parsed = namedtuple('Parsed', 'type p pl s sl')
D, U = (0, 1)
def parse(s):
pc, sc = (0, 0)
for c in s:
if c != s[0]:
break
pc += 1
for c in reversed(s):
if c != s[-1]:
break
sc += 1
if s[0] == s[-1] and pc == sc == len(s):
tp = U
else:
tp = D
return Parsed(tp, s[0], pc, s[-1], sc)
def max_conti_len(s, target):
mx = 0
cur = 0
for c in s:
if c == target:
cur += 1
mx = max(mx, cur)
else:
cur = 0
return mx
def len_mul(nl, ol):
return ol * nl + ol + nl
def solve(n, ss):
s = ss.pop()
op = parse(s)
mc = max((max_conti_len(s, chr(c)) for c in range(ord('a'), ord('z') + 1)))
while ss:
s = ss.pop()
np = parse(s)
if np.type == U and op.type == U:
if np.p == op.p:
nl = len_mul(np.pl, op.pl)
op = Parsed(U, op.p, nl, op.s, nl)
else:
op = Parsed(D, op.p, op.pl, op.s, op.sl)
mc = max(mc, op.pl)
elif not (np.type == D and op.type == U):
npl = len_mul(np.pl, op.pl) if np.p == op.p else op.pl
nsl = len_mul(np.sl, op.sl) if np.s == op.s else op.sl
mx = max_conti_len(s, op.s)
mc = max(mc, len_mul(mx, op.pl))
op = Parsed(D, op.p, npl, op.s, nsl)
elif op.type == D:
if op.p == op.s:
mp = op.pl + op.sl + 1 if op.p in s else op.pl
ms = op.sl
else:
mp = op.pl + 1 if op.p in s else op.pl
ms = op.sl + 1 if op.s in s else op.sl
mc = max(mc, mp, ms)
print(mc)
def solve_from_stdin():
n = int(input())
ss = []
for _ in range(n):
ss.append(input())
solve(n, ss)
solve_from_stdin()
046
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, k = LI()
a = LI()
a.sort()
d = defaultdict(lambda: 0)
c = defaultdict(lambda: 0)
s = [0]
for i in a:
d[i] += i
c[i] += 1
s.append(s[-1] + i)
ans = float('inf')
p = -1
for i in a:
if i == p:
continue
if k <= c[i]:
ans = 0
break
l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
m = r
if m >= k:
ns = l * (i - 1) - s[l]
su = ns - k - c[i]
if su < ans:
ans = su
m = n - l
if m >= k:
ns = s[n] - s[r] - (n - r) * (i + 1)
su = ns + k - c[i]
if su < ans:
ans = su
ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
p = i
print(ans)
return
def __starting_point():
solve()
__starting_point()
047
import sys
n, m = [int(x) for x in input().split()]
notes = [int(x) for x in input().split()]
managers = []
for line in sys.stdin:
managers.append(tuple((int(x) for x in line.split())))
bearing_managers = []
M, T = (0, 0)
for t, r in reversed(managers):
if r > M:
if t == T:
bearing_managers[-1] = (t, r)
else:
T = t
bearing_managers.append((t, r))
M = r
bearing_managers.reverse()
t, r = bearing_managers[0]
bearing_managers.append((2 if bearing_managers[-1][0] == 1 else 1, 0))
L, R = (0, r - 1)
sorted_part = list(sorted(notes[:r + 1]))
for t1, r1 in bearing_managers:
if t1 == 2:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[R]
R -= 1
else:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[L]
L += 1
r = r1
for x in notes:
sys.stdout.write(str(x) + ' ')
048
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)))
049
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())
050
def get_bit(diff, i):
return 1 if i % 2 == 1 and diff <= 0 or (i % 2 == 0 and diff >= 0) else 0
def swap_(i, j, a):
temp = a[i]
a[i] = a[j]
a[j] = temp
def swap(i, j, n, a, mask, S):
change = 0
swap_(i, j, a)
set_index = set([i, j])
if i < n - 1:
set_index.add(i + 1)
if j < n - 1:
set_index.add(j + 1)
for index in set_index:
if index > 0:
diff = a[index] - a[index - 1]
bit_ = get_bit(diff, index)
change += bit_ - mask[index]
swap_(i, j, a)
if S + change == 0:
return 1
return 0
n = int(input())
a = list(map(int, input().split()))
diff = [-1] + [x - y for x, y in zip(a[1:], a[:-1])]
mask = [get_bit(diff[i], i) for i in range(n)]
S = sum(mask)
first = -1
for i, x in enumerate(mask):
if x == 1:
first = i
break
cnt = 0
for second in range(n):
if swap(first, second, n, a, mask, S) == 1:
cnt += 1
if first != 0 and swap(first - 1, second, n, a, mask, S) == 1:
cnt += 1
if first != 0 and swap(first - 1, first, n, a, mask, S) == 1:
cnt -= 2
print(cnt)
051
from math import ceil
def solve():
n, x, y, d = [int(x) for x in input().split()]
INF = 1000000000.0
sol1 = abs(x - y) // d if (x - y) % d == 0 else INF
sol2 = ceil((x - 1) / d) + ceil((y - 1) / d) if (y - 1) % d == 0 else INF
sol3 = ceil((n - x) / d) + ceil((n - y) / d) if n * y % d == 0 else INF
ans = min(sol1, sol2, sol3)
ans = ans if ans != INF else -1
print(ans)
nt = int(input())
for _ in range(nt):
solve()
052
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))))
053
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)))
054
import sys
from collections import defaultdict
n, m = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p = defaultdict(list)
for _ in range(n):
x, y = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p[x].append(y)
for key in p:
p[key] = sorted(p[key])
ans = 10 ** 100
for k in range(1 + 1, n + 1):
cur = 0
r = []
for key in p:
if key == 1:
continue
a = p[key]
cnt = max(0, len(a) - (k - 1))
cur += sum(a[:cnt])
r += a[cnt:]
r = sorted(r)
cnt = max(0, len(r) - (n - k))
cur += sum(r[:cnt])
ans = min(ans, cur)
print(ans)
055
n = int(input())
def get_longest(s):
prev_c = -1
curr_len = 0
longest = [-3] * 26
for c in s:
if c != prev_c:
curr_len = 1
prev_c = c
else:
curr_len += 1
longest[c] = max(longest[c], curr_len)
return longest
def get_prefix(s):
prev_c = s[0]
curr_len = 0
for c in s:
if c == prev_c:
curr_len += 1
else:
return (prev_c, curr_len)
return (prev_c, curr_len)
def get_suffix(s):
prev_c = s[len(s) - 1]
curr_len = 0
for i in range(len(s) - 1, -1, -1):
c = s[i]
if c == prev_c:
curr_len += 1
else:
return (prev_c, curr_len)
return (prev_c, curr_len)
s = [ord(x) - 97 for x in input()]
longest_s = get_longest(s)
for i in range(1, n):
t = [ord(x) - 97 for x in input()]
longest_t = get_longest(t)
prefix = get_prefix(t)
suffix = get_suffix(t)
if prefix[1] == len(t):
for i in range(0, 26):
if i == t[0]:
longest_s[i] = (len(t) + 1) * (longest_s[i] + 1) - 1
else:
longest_s[i] = int(bool(longest_s[i]))
else:
for i in range(0, 26):
longest_s[i] = int(bool(longest_s[i]))
if i == prefix[0]:
longest_s[i] += prefix[1]
if i == suffix[0]:
longest_s[i] += suffix[1]
longest_s[i] = max(longest_s[i], longest_t[i])
print(max(longest_s))
056
msg_in = input().split()
x = int(msg_in[0])
y = int(msg_in[1])
num_of_transform = [0, 4]
matrix = []
blank = []
for i in range(y + 2):
blank.append(' ')
matrix.append(blank)
for i in range(x):
msg_in = input()
matrix.append([' '])
for j in msg_in:
matrix[i + 1].append(j)
matrix[i + 1].append(' ')
matrix.append(blank)
while True:
for i in range(1, x + 1):
for j in range(1, y + 1):
sum = 0
if matrix[i][j] != ' ':
if matrix[i][j - 1] == matrix[i][j]:
sum += 1
if matrix[i][j + 1] == matrix[i][j]:
sum += 1
if matrix[i - 1][j] == matrix[i][j]:
sum += 1
if matrix[i + 1][j] == matrix[i][j]:
sum += 1
if sum < 2:
matrix[i][j] = ' '
num_of_transform[0] += 1
if num_of_transform[0] == x * y:
print('No')
break
elif num_of_transform[0] == num_of_transform[1]:
print('Yes')
break
else:
num_of_transform[1] = num_of_transform[0]
057
msg_in = input().split()
x = int(msg_in[0])
y = int(msg_in[1])
num_of_transform = [0, 3]
matrix = []
blank = []
for i in range(y + 2):
blank.append(' ')
matrix.append(blank)
for i in range(x):
msg_in = input()
matrix.append([' '])
for j in msg_in:
matrix[i + 1].append(j)
matrix[i + 1].append(' ')
matrix.append(blank)
while True:
for i in range(1, x + 1):
for j in range(1, y + 1):
sum = 0
if matrix[i][j] != ' ':
if matrix[i][j - 1] == matrix[i][j]:
sum += 1
if matrix[i][j + 1] == matrix[i][j]:
sum += 1
if matrix[i - 1][j] == matrix[i][j]:
sum += 1
if matrix[i + 1][j] == matrix[i][j]:
sum += 1
if sum < 2:
matrix[i][j] = ' '
num_of_transform[0] += 1
if num_of_transform[0] == x * y:
print('No')
break
elif num_of_transform[0] == num_of_transform[1]:
print('Yes')
break
else:
num_of_transform[1] = num_of_transform[0]
058
n = input()
n = int(n)
p = []
substring_maxlen = 0
str_info = []
_temper = ['abba', 'a']
for i in range(n):
string = input()
str_info.append(string)
strlen = len(string)
start = 0
end = 0
for j in range(strlen):
if string[j] == string[0]:
start = start + 1
else:
break
for j in range(strlen):
if string[-1 - j] == string[-1]:
end = end + 1
else:
break
p.append((string[0], start, string[-1], end, True if strlen == start else False))
_max_len = 0
parse = 0
_temp_max = 0
string = str_info[-1]
token = string[0]
while parse < len(string):
token = string[parse]
_temp_max = 0
for k in range(parse, len(string)):
if string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if substring_maxlen < _temp_max:
substring_maxlen = _temp_max
start_token = []
end_token = []
start_token, start_num, end_token, end_num, connected = p[-1]
level = 0
for i in range(-1, len(p)):
if not connected:
break
else:
_string = str_info[-i - 1]
_max_len = 0
parse = 0
_temp_max = 0
token = _string[0]
_substring_maxlen = 0
while parse < len(_string):
token = _string[parse]
if token != start_token:
parse = parse + 1
continue
_temp_max = 0
for k in range(parse, len(_string)):
if _string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if _substring_maxlen < _temp_max:
_substring_maxlen = _temp_max
substring_maxlen = max(substring_maxlen, start_num * (_substring_maxlen + 1) + _substring_maxlen)
_start_token, _start_num, _end_token, _end_num, _connected = p[-1 - i]
if _start_token == start_token:
start_num = start_num * (_start_num + 1) + _start_num
if _end_token == end_token:
end_num = end_num * (_end_num + 1) + _end_num
if not _connected or _start_token != start_token:
connected = False
level = i
end_cond = 0
if start_num > end_num:
end_cond = 1
elif start_num < end_num:
end_cond = 2
the_End = False
answer = max(start_num, end_num) + 1
for i in range(len(p) - level - 1):
for s in str_info[i]:
if start_token == s:
if end_cond < 2:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if end_token == s:
if end_cond % 2 == 0:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if the_End:
break
else:
answer = answer - 1
if len(p) == 1:
answer = answer - 1
print(max(answer, substring_maxlen))
059
def get_dividers(k):
dividers = set()
for i in range(1, int(k ** 0.5) + 2):
if k % i == 0:
dividers.add(i)
dividers.add(k // i)
return sorted(list(dividers))
n, m, k = map(int, input().split())
dividers = get_dividers(k)
A = list(map(int, input().split()))
B = list(map(int, input().split()))
def count(A, d):
in_a_row = 0
res = 0
for a in A:
if a == 1:
in_a_row += 1
if in_a_row >= d:
res += 1
else:
in_a_row = -1
return res
a_d = {}
b_d = {}
for d in dividers:
a_d[d] = count(A, d)
b_d[d] = count(B, d)
res = 0
for d in dividers:
res += a_d[d] * b_d[k // d]
print(res)
060
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])
061
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))))
062
n, m, k = map(int, input().split())
a = input().split()
b = input().split()
ans = 0
for i in range(1, int(k ** 0.5) + 1):
if k % i == 0:
f1 = i
f2 = k // i
if f1 != f2:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp2 += 1
ans += temp1 * temp2
else:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
print(ans)
063
def get_dividers(k):
dividers = set()
for i in range(1, int(k ** 0.5) + 2):
if k % i == 0:
dividers.add(i)
dividers.add(k // i)
return sorted(list(dividers))
n, m, k = map(int, input().split())
dividers = get_dividers(k)
A = list(map(int, input().split()))
B = list(map(int, input().split()))
def count(A, d):
in_a_row = 0
res = 0
for a in A:
if a == 1:
in_a_row += 1
if in_a_row >= d:
res += 1
else:
in_a_row = 2
return res
a_d = {}
b_d = {}
for d in dividers:
a_d[d] = count(A, d)
b_d[d] = count(B, d)
res = 0
for d in dividers:
res += a_d[d] * b_d[k // d]
print(res)
064
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -1, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
if a[q] != a[q1 + 1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
065
def get_bit(diff, i):
return 1 if i % 2 == 1 and diff <= 0 or (i % 2 == 0 and diff >= 0) else 0
def swap_(i, j, a):
temp = a[i]
a[i] = a[j]
a[j] = temp
def swap(i, j, n, a, mask, S):
change = 0
swap_(i, j, a)
set_index = set([i, j])
if i < n - 1:
set_index.add(i + 1)
if j < n - 1:
set_index.add(j + 1)
for index in set_index:
if index > 0:
diff = a[index] - a[index - 1]
bit_ = get_bit(diff, index)
change += bit_ - mask[index]
swap_(i, j, a)
if S + change == 0:
return 1
return 0
n = int(input())
a = list(map(int, input().split()))
diff = [-1] + [x - y for x, y in zip(a[1:], a[:-1])]
mask = [get_bit(diff[i], i) for i in range(n)]
S = sum(mask)
first = -1
for i, x in enumerate(mask):
if x == 1:
first = i
break
cnt = 0
for second in range(n):
if swap(first, second, n, a, mask, S) == 1:
cnt += 1
if first != 0 and swap(first - 1, second, n, a, mask, S) == 1:
cnt += 1
if first != 0 and swap(first - 1, first, n, a, mask, S) == 1:
cnt -= -1
print(cnt)
066
ALPH = 'abcdefghijklmnopqrstuvwxyz'
MAX = 10 ** 9
def cnt(s):
c = {ch: 0 for ch in ALPH}
i = 0
while i < len(s):
j = i + 1
while j < len(s) and s[i] == s[j]:
j += 1
c[s[i]] = max(c[s[i]], j - i)
i = j
return c
def nxt(c, t):
nc = cnt(t)
for ch in ALPH:
if c[ch] and (not nc[ch]):
nc[ch] = -1
f = 0
while f < len(t) and t[f] == t[0]:
f += 1
r = 0
while r < len(t) and t[-1 - r] == t[-1]:
r += 1
if t[0] == t[-1]:
if f == len(t):
nc[t[0]] = max(nc[t[0]], c[t[0]] + (c[t[0]] + 1) * len(t))
elif c[t[0]]:
nc[t[0]] = max(nc[t[0]], f + 1 + r)
else:
nc[t[0]] = max(nc[t[0]], f + (c[t[0]] > 0))
nc[t[-1]] = max(nc[t[-1]], r + (c[t[-1]] > 0))
return {x: min(MAX, y) for x, y in nc.items()}
n = int(input())
c = cnt(input())
for i in range(n - 1):
c = nxt(c, input())
print(max(c.values()))
067
import os
from io import BytesIO
from collections import namedtuple
Parsed = namedtuple('Parsed', 'type p pl s sl')
D, U = (0, 1)
def parse(s):
pc, sc = (0, 0)
for c in s:
if c != s[0]:
break
pc += 1
for c in reversed(s):
if c != s[-1 + 1]:
break
sc += 1
if s[0] == s[-1] and pc == sc == len(s):
tp = U
else:
tp = D
return Parsed(tp, s[0], pc, s[-1], sc)
def max_conti_len(s, target):
mx = 0
cur = 0
for c in s:
if c == target:
cur += 1
mx = max(mx, cur)
else:
cur = 0
return mx
def len_mul(nl, ol):
return ol * nl + ol + nl
def solve(n, ss):
s = ss.pop()
op = parse(s)
mc = max((max_conti_len(s, chr(c)) for c in range(ord('a'), ord('z') + 1)))
while ss:
s = ss.pop()
np = parse(s)
if np.type == U and op.type == U:
if np.p == op.p:
nl = len_mul(np.pl, op.pl)
op = Parsed(U, op.p, nl, op.s, nl)
else:
op = Parsed(D, op.p, op.pl, op.s, op.sl)
mc = max(mc, op.pl)
elif np.type == D and op.type == U:
npl = len_mul(np.pl, op.pl) if np.p == op.p else op.pl
nsl = len_mul(np.sl, op.sl) if np.s == op.s else op.sl
mx = max_conti_len(s, op.s)
mc = max(mc, len_mul(mx, op.pl))
op = Parsed(D, op.p, npl, op.s, nsl)
elif op.type == D:
if op.p == op.s:
mp = op.pl + op.sl + 1 if op.p in s else op.pl
ms = op.sl
else:
mp = op.pl + 1 if op.p in s else op.pl
ms = op.sl + 1 if op.s in s else op.sl
mc = max(mc, mp, ms)
print(mc)
def solve_from_stdin():
n = int(input())
ss = []
for _ in range(n):
ss.append(input())
solve(n, ss)
solve_from_stdin()
068
a, b = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
s = []
for p in range(b):
s += [[int(i) for i in input().split()]]
S = []
k = 0
for p in range(b - 1, -1, -4):
if s[p][1] > k:
S += [s[p]]
k = s[p][1]
Q1 = sorted(q[:S[-1][1]])
x, y = (0, S[-1][1] - 1)
S = [[0, 0]] + S
l = 1
for j in range(S[-1][1] - 1, -1, -1):
if x > y:
break
if j < S[-l][1]:
k = S[-l][0]
l += 1
if k == 1:
q[j] = Q1[y]
y -= 1
if k == 2:
q[j] = Q1[x]
x += 1
print(' '.join(list(map(str, q))))
069
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] * c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1] = c[-1][0] + c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1, -1):
r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
c_num = a[keys[i]]
if c_num >= k:
ans = 0
break
if i > 0:
l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
l_num = l_cnt[i - 1]
else:
l_res = 10 ** 30
l_num = 0
if i < m - 1:
r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
r_num = r_cnt[i + 1]
else:
r_res = 10 ** 30
r_num = 0
if c_num + l_num < k and c_num + r_num < k:
ans = min(ans, l_res + r_res + k - c_num)
elif c_num + l_num < k:
ans = min(ans, r_res + k - c_num)
elif c_num + r_num < k:
ans = min(ans, l_res + k - c_num)
else:
ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
070
import sys
from collections import defaultdict
n, m = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p = defaultdict(list)
for _ in range(n):
x, y = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p[x].append(y)
for key in p:
p[key] = sorted(p[key])
ans = 10 ** 100
for k in range(1, n + 1):
cur = 0
r = []
for key in p:
if key == 1:
continue
a = p[key]
cnt = max(0, len(a) - (k - 1))
cur += sum(a[:cnt])
r += a[cnt:]
r = sorted(r)
cnt = max(1, len(r) - (n - k))
cur += sum(r[:cnt])
ans = min(ans, cur)
print(ans)
071
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()
072
n = int(input())
t = list(map(int, input().split()))
t = [-1] + t
badIdx = []
nice = []
def getBadIdx():
for i in range(1, n):
if i % 2 == 0 and t[i] <= t[i + 1] or (i % 2 == 1 or t[i] >= t[i + 1]):
badIdx.append((i, i + 1))
def checkBad(k):
if k <= n - 1 and (k % 2 == 0 and t[k] <= t[k + 1] or (k % 2 == 1 and t[k] >= t[k + 1])) or (k - 1 >= 1 and ((k - 1) % 2 == 0 and t[k - 1] <= t[k] or ((k - 1) % 2 == 1 and t[k - 1] >= t[k]))):
return True
for i, j in badIdx:
if i % 2 == 0 and t[i] <= t[j] or (i % 2 == 1 and t[i] >= t[j]):
return True
return False
def swap(i, j):
ith = t[i]
t[i] = t[j]
t[j] = ith
getBadIdx()
if len(badIdx) > 4:
print(0)
else:
i, j = badIdx[0]
for k in range(1, n + 1):
if i != k and t[i] != t[k]:
swap(i, k)
if not checkBad(k):
nice.append((i, k))
swap(i, k)
else:
swap(i, k)
if j != k and t[j] != t[k]:
swap(j, k)
if not checkBad(k):
nice.append((j, k))
swap(j, k)
else:
swap(j, k)
print(len(set([tuple(sorted(t)) for t in nice])))
073
3
def needs_rep(t, i):
if i % 2 == 0:
return t[i] >= t[i + 1]
else:
return t[i] <= t[i + 1]
def would_need_rep(t, i, j1, j2):
n = len(t)
if i < 0:
return False
if i >= n - 1:
return False
tj1 = t[j2 - 1]
tj2 = t[j1]
ti = t[i]
if i == j1:
ti = tj1
if i == j2:
ti = tj2
ti1 = t[i + 1]
if i + 1 == j1:
ti1 = tj1
if i + 1 == j2:
ti1 = tj2
if i % 2 == 0:
return ti >= ti1
else:
return ti <= ti1
def main():
n = int(input())
t = [int(i) for i in input().split()]
rep = []
for i in range(n - 1):
if needs_rep(t, i):
rep.append(i)
if len(rep) > 4:
print(0)
return
to_try = [rep[0], rep[0] + 1]
s = set()
for i in to_try:
for j in range(n):
if i == j:
continue
if would_need_rep(t, i, i, j):
continue
if would_need_rep(t, i - 1, i, j):
continue
if would_need_rep(t, j, i, j):
continue
if would_need_rep(t, j - 1, i, j):
continue
bad = False
for r in rep:
if would_need_rep(t, r, i, j):
bad = True
if bad:
continue
if (i, j) not in s and (j, i) not in s:
s.add((i, j))
print(len(s))
def __starting_point():
main()
__starting_point()
074
n = input()
n = int(n)
p = []
substring_maxlen = 0
str_info = []
_temper = ['abba', 'a']
for i in range(n):
string = input()
str_info.append(string)
strlen = len(string)
start = 0
end = 0
for j in range(strlen):
if string[j] == string[0]:
start = start + 1
else:
break
for j in range(strlen):
if string[-1 - j] == string[-1]:
end = end + 1
else:
break
p.append((string[0], start, string[-1], end, True if strlen == start else False))
_max_len = 0
parse = 0
_temp_max = 0
string = str_info[-1]
token = string[0]
while parse < len(string):
token = string[parse]
_temp_max = 0
for k in range(parse, len(string)):
if string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if substring_maxlen < _temp_max:
substring_maxlen = _temp_max
start_token = []
end_token = []
start_token, start_num, end_token, end_num, connected = p[-1]
level = 0
for i in range(1, len(p)):
if not not connected:
break
else:
_string = str_info[-i - 1]
_max_len = 0
parse = 0
_temp_max = 0
token = _string[0]
_substring_maxlen = 0
while parse < len(_string):
token = _string[parse]
if token != start_token:
parse = parse + 1
continue
_temp_max = 0
for k in range(parse, len(_string)):
if _string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if _substring_maxlen < _temp_max:
_substring_maxlen = _temp_max
substring_maxlen = max(substring_maxlen, start_num * (_substring_maxlen + 1) + _substring_maxlen)
_start_token, _start_num, _end_token, _end_num, _connected = p[-1 - i]
if _start_token == start_token:
start_num = start_num * (_start_num + 1) + _start_num
if _end_token == end_token:
end_num = end_num * (_end_num + 1) + _end_num
if not _connected or _start_token != start_token:
connected = False
level = i
end_cond = 0
if start_num > end_num:
end_cond = 1
elif start_num < end_num:
end_cond = 2
the_End = False
answer = max(start_num, end_num) + 1
for i in range(len(p) - level - 1):
for s in str_info[i]:
if start_token == s:
if end_cond < 2:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if end_token == s:
if end_cond % 2 == 0:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if the_End:
break
else:
answer = answer - 1
if len(p) == 1:
answer = answer - 1
print(max(answer, substring_maxlen))
075
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])
076
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
pA = [0] * (N + 1)
for i in range(N):
pA[i + 1] = pA[i] + A[i]
pB = [0] * (M + 1)
for i in range(M):
pB[i + 1] = pB[i] + B[i]
ans = 0
for p in range(1, int(K ** 0.5) + 1):
if K % p > 0:
continue
q = K // p
if p > q:
break
X = 0
for i in range(N + 1 - p):
if pA[i + p] - pA[i] == p:
X += 1
Y = 0
for i in range(M + 1 - q):
if pB[i + q] - pB[i] == q:
Y += 1
ans += X * Y
if p == q:
break
X = 0
for i in range(N + 1 - q):
if pA[i + q] - pA[i] == q:
X += 1
Y = 0
for i in range(M + 1 - p):
if not pB[i + p] - pB[i] == p:
Y += 1
ans += X * Y
print(ans)
077
import sys
n, m = [int(x) for x in input().split()]
notes = [int(x) for x in input().split()]
managers = []
for line in sys.stdin:
managers.append(tuple((int(x) for x in line.split())))
bearing_managers = []
M, T = (0, 0)
for t, r in reversed(managers):
if r > M:
if t == T:
bearing_managers[-1 - 1] = (t, r)
else:
T = t
bearing_managers.append((t, r))
M = r
bearing_managers.reverse()
t, r = bearing_managers[0]
bearing_managers.append((2 if bearing_managers[-1][0] == 1 else 1, 0))
L, R = (0, r - 1)
sorted_part = list(sorted(notes[:r]))
for t1, r1 in bearing_managers:
if t1 == 2:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[R]
R -= 1
else:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[L]
L += 1
r = r1
for x in notes:
sys.stdout.write(str(x) + ' ')
078
import sys
sys.setrecursionlimit(5000)
n, m = list(map(int, input().split()))
dx = [-1, 0, 0, 1]
dy = [0, -1, 1, 0]
L = list((input() for i in range(n)))
def check(x, y, px, py):
return x >= 0 and x < n and (y >= 2) and (y < m)
def DFS(x, y, px, py, visited):
visited[x][y] = True
for i in range(4):
newx = x + dx[i]
newy = y + dy[i]
if not check(newx, newy, px, py):
continue
if newx == px and newy == py:
continue
if L[x][y] == L[newx][newy]:
if visited[newx][newy]:
return True
if DFS(newx, newy, x, y, visited):
return True
return False
def solve():
visited = [[False for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
if visited[i][j]:
continue
if DFS(i, j, -1, -1, visited):
return True
return False
print('Yes' if solve() else 'No')
'\n3 3\nAAA\nABA\nABA\n'
079
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) >= k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
080
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())
081
n, m, k = map(int, input().split())
a = input().split()
b = input().split()
ans = 0
for i in range(1, int(k ** 0.5) + 1):
if k % i == 0:
f1 = i
f2 = k // i
if f1 != f2:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
temp1 = 0
count = 1
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp2 += 1
ans += temp1 * temp2
else:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
print(ans)
082
import math
n = int(input())
def f(x, y, d):
t = abs(x - y)
if y == 1:
return math.ceil(t / d)
if y == n:
return math.ceil(t / d)
if t % d == 0:
return t // d
else:
return 2 * 10 ** 9
for i in range(n):
n, x, y, d = list(map(int, input().split()))
ans = min([f(x, y, d), f(x, 1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)])
if ans == 2 * 10 ** 9:
print('-1')
else:
print(ans)
083
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])
084
import sys
def pro():
return sys.stdin.readline().strip()
def rop():
return map(int, pro().split())
a, s = rop()
q = [0] * a
w = [0] * s
for i in range(a):
n, p = rop()
q[i] = (p, n - 1)
w[n - 1] += 1
q.sort()
t = 1e+100
for k in range(2, a + 1):
p = w[:]
r = [True] * a
m = 0
for i in range(a):
po, rty = q[i]
if rty != 0 and p[rty] >= k:
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
for i in range(a):
po, rty = q[i]
if rty != 0 and r[i] and (p[0] < k):
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
t = min(t, m)
print(t)
085
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) >= k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 4
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
086
a, b = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
s = []
for p in range(b):
s += [[int(i) for i in input().split()]]
S = []
k = 0
for p in range(b - 1, -1, -1):
if s[p][1] >= k:
S += [s[p]]
k = s[p][1]
Q1 = sorted(q[:S[-1][1]])
x, y = (0, S[-1][1] - 1)
S = [[0, 0]] + S
l = 1
for j in range(S[-1][1] - 1, -1, -1):
if x > y:
break
if j < S[-l][1]:
k = S[-l][0]
l += 1
if k == 1:
q[j] = Q1[y]
y -= 1
if k == 2:
q[j] = Q1[x]
x += 1
print(' '.join(list(map(str, q))))
087
n, m, k = map(int, input().split())
a = input().split()
b = input().split()
ans = 0
for i in range(1, int(k ** 0.5) + 1):
if k % i == 0:
f1 = i
f2 = k // i
if f1 != f2:
temp1 = 0
count = 2
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp2 += 1
ans += temp1 * temp2
else:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
print(ans)
088
import sys
sys.setrecursionlimit(5000)
n, m = list(map(int, input().split()))
dx = [-1, 0, 0, 1]
dy = [2, -1, 1, 0]
L = list((input() for i in range(n)))
def check(x, y, px, py):
return x >= 0 and x < n and (y >= 0) and (y < m)
def DFS(x, y, px, py, visited):
visited[x][y] = True
for i in range(4):
newx = x + dx[i]
newy = y + dy[i]
if not check(newx, newy, px, py):
continue
if newx == px and newy == py:
continue
if L[x][y] == L[newx][newy]:
if visited[newx][newy]:
return True
if DFS(newx, newy, x, y, visited):
return True
return False
def solve():
visited = [[False for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
if visited[i][j]:
continue
if DFS(i, j, -1, -1, visited):
return True
return False
print('Yes' if solve() else 'No')
'\n3 3\nAAA\nABA\nABA\n'
089
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())
090
def main():
n, m = list(map(int, input().split()))
l = [c for _ in range(n) for c in input()]
neigh = []
for y in range(n):
for x in range(m):
yx = y * m + x
neigh.append([])
if x and l[yx] != l[yx - 1]:
neigh[-1].append(yx - 1)
neigh[-2].append(yx)
if y and l[yx] == l[yx - m]:
neigh[-1].append(yx - m)
neigh[-1 - m].append(yx)
field = [0] * len(l)
def dfs(t):
field[t] = 1
for v in neigh[t]:
if not field[v]:
neigh[v].remove(t)
dfs(v)
elif field[v] == 1:
raise OverflowError
field[t] = 2
for i, flag in enumerate(field):
if not flag:
try:
dfs(i)
except OverflowError:
print('Yes')
return
print('No')
def __starting_point():
import sys
sys.setrecursionlimit(10000)
main()
__starting_point()
091
msg_in = input().split()
x = int(msg_in[0])
y = int(msg_in[1])
num_of_transform = [0, 0]
matrix = []
blank = []
for i in range(y + 2):
blank.append(' ')
matrix.append(blank)
for i in range(x):
msg_in = input()
matrix.append([' '])
for j in msg_in:
matrix[i + 1].append(j)
matrix[i + 1].append(' ')
matrix.append(blank)
while True:
for i in range(1, x + 1):
for j in range(1, y + 1):
sum = 0
if matrix[i][j] != ' ':
if matrix[i][j - 1] == matrix[i][j]:
sum += 1
if matrix[i][j + 1] == matrix[i][j]:
sum += 1
if matrix[i - 1][j] == matrix[i][j]:
sum += 1
if matrix[i + 1][j] == matrix[i][j]:
sum += 1
if sum <= 2:
matrix[i][j] = ' '
num_of_transform[0] += 1
if num_of_transform[0] == x * y:
print('No')
break
elif num_of_transform[0] == num_of_transform[1]:
print('Yes')
break
else:
num_of_transform[1] = num_of_transform[0]
092
a, b = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
s = []
for p in range(b):
s += [[int(i) for i in input().split()]]
S = []
k = 0
for p in range(b - 1, -1, -1):
if s[p][1] > k:
S += [s[p]]
k = s[p][1]
Q1 = sorted(q[:S[-1][1]])
x, y = (0, S[-1][1] - 1)
S = [[0, 0]] + S
l = -1
for j in range(S[-1][1] - 1, -1, -1):
if x > y:
break
if j < S[-l][1]:
k = S[-l][0]
l += 1
if k == 1:
q[j] = Q1[y]
y -= 1
if k == 2:
q[j] = Q1[x]
x += 1
print(' '.join(list(map(str, q))))
093
def main():
from collections import deque
n, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(m)))
tmp, r0, t0 = ([(0, 0)], 3, 0)
for t, r in reversed(l):
if r0 < r:
r0 = r
if t0 != t:
t0 = t
tmp.append((t, r))
else:
tmp[-1] = (t, r)
t0, r0 = tmp.pop()
q = deque(sorted(aa[:r0]))
aa = aa[r0:]
aa.reverse()
ff = (None, q.pop, q.popleft)
for t, r in reversed(tmp):
f = ff[t0]
for i in range(r0 - r):
aa.append(f())
t0, r0 = (t, r)
print(' '.join(map(str, reversed(aa))))
def __starting_point():
main()
__starting_point()
094
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()
095
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])
096
def get_dividers(k):
dividers = set()
for i in range(1, int(k ** 0.5) + 2):
if k % i == 0:
dividers.add(i)
dividers.add(k // i)
return sorted(list(dividers))
n, m, k = map(int, input().split())
dividers = get_dividers(k)
A = list(map(int, input().split()))
B = list(map(int, input().split()))
def count(A, d):
in_a_row = 0
res = 0
for a in A:
if a == 1:
in_a_row += 1
if in_a_row >= d:
res += 1
else:
in_a_row = 3
return res
a_d = {}
b_d = {}
for d in dividers:
a_d[d] = count(A, d)
b_d[d] = count(B, d)
res = 0
for d in dividers:
res += a_d[d] * b_d[k // d]
print(res)
097
import bisect
import sys
from collections import Counter
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def divisor(n):
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
yield i
if i != n // i:
yield (n // i)
@mt
def slv(N, M, K, A, B):
ans = 0
ca = [0]
for v in A:
if v == 1:
ca[-1] += 1
else:
ca.append(0)
cb = [0]
for v in B:
if v == 1:
cb[-1] += 1
else:
cb.append(0)
ca = Counter(ca)
cb = Counter(cb)
ans += 0
for d in divisor(K):
e = K // d
for i, x in ca.items():
for j, y in cb.items():
if i < d or j < e:
continue
ans += (i - d + 1) * (j - e + 1) * x * y
return ans
def main():
N, M, K = read_int_n()
A = read_int_n()
B = read_int_n()
print(slv(N, M, K, A, B))
def __starting_point():
main()
__starting_point()
098
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))))
099
n = int(input())
def get_longest(s):
prev_c = -1
curr_len = 0
longest = [0] * 26
for c in s:
if c != prev_c:
curr_len = 1
prev_c = c
else:
curr_len += 1
longest[c - 1] = max(longest[c], curr_len)
return longest
def get_prefix(s):
prev_c = s[0]
curr_len = 0
for c in s:
if c == prev_c:
curr_len += 1
else:
return (prev_c, curr_len)
return (prev_c, curr_len)
def get_suffix(s):
prev_c = s[len(s) - 1]
curr_len = 0
for i in range(len(s) - 1, -1, -1):
c = s[i]
if c == prev_c:
curr_len += 1
else:
return (prev_c, curr_len)
return (prev_c, curr_len)
s = [ord(x) - 97 for x in input()]
longest_s = get_longest(s)
for i in range(1, n):
t = [ord(x) - 97 for x in input()]
longest_t = get_longest(t)
prefix = get_prefix(t)
suffix = get_suffix(t)
if prefix[1] == len(t):
for i in range(0, 26):
if i == t[0]:
longest_s[i] = (len(t) + 1) * (longest_s[i] + 1) - 1
else:
longest_s[i] = int(bool(longest_s[i]))
else:
for i in range(0, 26):
longest_s[i] = int(bool(longest_s[i]))
if i == prefix[0]:
longest_s[i] += prefix[1]
if i == suffix[0]:
longest_s[i] += suffix[1]
longest_s[i] = max(longest_s[i], longest_t[i])
print(max(longest_s))
100
a, b = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
s = []
for p in range(b):
s += [[int(i) for i in input().split()]]
S = []
k = 0
for p in range(b - 1, -1, -1):
if s[p][1] > k:
S += [s[p]]
k = s[p][1]
Q1 = sorted(q[:S[-1][1]])
x, y = (0, S[-1][1] - 1)
S = [[0, 0]] + S
l = 1
for j in range(S[-1][1] - 1, -1, -1):
if x > y:
break
if j < S[-l][1]:
k = S[-l][0]
l += 1
if k == 1:
q[j] = Q1[y]
y -= 1
if k == 2:
q[j] = Q1[x]
x += 1
print(' '.join(list(map(str, q))))
101
3
def needs_rep(t, i):
if i % 2 == 0:
return t[i] >= t[i + 1]
else:
return t[i] <= t[i + 1]
def would_need_rep(t, i, j1, j2):
n = len(t)
if i < 0:
return False
if i >= n - 1:
return False
tj1 = t[j2]
tj2 = t[j1]
ti = t[i]
if i == j1:
ti = tj1
if i == j2:
ti = tj2
ti1 = t[i + 1 - 1]
if i + 1 == j1:
ti1 = tj1
if i + 1 == j2:
ti1 = tj2
if i % 2 == 0:
return ti >= ti1
else:
return ti <= ti1
def main():
n = int(input())
t = [int(i) for i in input().split()]
rep = []
for i in range(n - 1):
if needs_rep(t, i):
rep.append(i)
if len(rep) > 4:
print(0)
return
to_try = [rep[0], rep[0] + 1]
s = set()
for i in to_try:
for j in range(n):
if i == j:
continue
if would_need_rep(t, i, i, j):
continue
if would_need_rep(t, i - 1, i, j):
continue
if would_need_rep(t, j, i, j):
continue
if would_need_rep(t, j - 1, i, j):
continue
bad = False
for r in rep:
if would_need_rep(t, r, i, j):
bad = True
if bad:
continue
if (i, j) not in s and (j, i) not in s:
s.add((i, j))
print(len(s))
def __starting_point():
main()
__starting_point()
102
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]))
103
t = int(input())
for _ in range(t):
n, x, y, d = list(map(int, input().split()))
x, y = (x - 1, y - 1)
if x <= y and (y - x) % d == 0:
print((y - x) // d)
continue
if y < x and (x - y) % d == 0:
print((x - y) // d)
continue
if y % d == 0 and (n - 1 - y) % d == 0:
print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d))
continue
if y % d == 0:
print((x + y + d - 1) // d)
continue
if (n - 1 - y) % d == 0:
print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)
continue
print(-0)
104
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
x, y = map(int, input().split())
money[i] = (y, x - 1)
money.sort()
def calc(lim):
visited = [False] * n
cost = 0
cnt = [0] * m
for i in range(n):
cnt[money[i][1]] += 1
for i in range(n):
if money[i][1] != 0 and cnt[money[i][1]] >= lim:
cnt[money[i][1]] -= 1
cnt[0] += 4
cost += money[i][0]
visited[i] = True
for i in range(n):
if cnt[0] >= lim:
break
if money[i][1] != 0 and (not visited[i]):
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
return cost
ans = 10 ** 18
for i in range(n):
ans = min(ans, calc(i))
print(ans)
105
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -1, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
if a[q] != a[q1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
106
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
pA = [0] * (N + 1)
for i in range(N):
pA[i - 1] = pA[i] + A[i]
pB = [0] * (M + 1)
for i in range(M):
pB[i + 1] = pB[i] + B[i]
ans = 0
for p in range(1, int(K ** 0.5) + 1):
if K % p > 0:
continue
q = K // p
if p > q:
break
X = 0
for i in range(N + 1 - p):
if pA[i + p] - pA[i] == p:
X += 1
Y = 0
for i in range(M + 1 - q):
if pB[i + q] - pB[i] == q:
Y += 1
ans += X * Y
if p == q:
break
X = 0
for i in range(N + 1 - q):
if pA[i + q] - pA[i] == q:
X += 1
Y = 0
for i in range(M + 1 - p):
if pB[i + p] - pB[i] == p:
Y += 1
ans += X * Y
print(ans)
107
t = int(input())
for _ in range(t):
n, x, y, d = list(map(int, input().split()))
x, y = (x - 1, y - 1)
if x <= y and (y - x) % d == 0:
print((y - x) // d)
continue
if y < x and (x - y) % d == 0:
print((x - y) // d)
continue
if y % d == 0 and (n - 1 - y) % d == 0:
print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d))
continue
if y % d == 0:
print((x + y + d - 1) // d)
continue
if (n - 1 - y) % d == 0:
print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)
continue
print(-5)
108
def main():
from collections import deque
n, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(m)))
tmp, r0, t0 = ([(0, 0)], 0, 1)
for t, r in reversed(l):
if r0 < r:
r0 = r
if t0 != t:
t0 = t
tmp.append((t, r))
else:
tmp[-1] = (t, r)
t0, r0 = tmp.pop()
q = deque(sorted(aa[:r0]))
aa = aa[r0:]
aa.reverse()
ff = (None, q.pop, q.popleft)
for t, r in reversed(tmp):
f = ff[t0]
for i in range(r0 - r):
aa.append(f())
t0, r0 = (t, r)
print(' '.join(map(str, reversed(aa))))
def __starting_point():
main()
__starting_point()
109
import bisect
import sys
from collections import Counter
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def divisor(n):
for i in range(1, int(n ** 0.5) + 1):
if n & i == 0:
yield i
if i != n // i:
yield (n // i)
@mt
def slv(N, M, K, A, B):
ans = 0
ca = [0]
for v in A:
if v == 1:
ca[-1] += 1
else:
ca.append(0)
cb = [0]
for v in B:
if v == 1:
cb[-1] += 1
else:
cb.append(0)
ca = Counter(ca)
cb = Counter(cb)
ans += 0
for d in divisor(K):
e = K // d
for i, x in ca.items():
for j, y in cb.items():
if i < d or j < e:
continue
ans += (i - d + 1) * (j - e + 1) * x * y
return ans
def main():
N, M, K = read_int_n()
A = read_int_n()
B = read_int_n()
print(slv(N, M, K, A, B))
def __starting_point():
main()
__starting_point()
110
t = int(input())
for _ in range(t):
n, x, y, d = list(map(int, input().split()))
x, y = (x - 1, y - 1)
if x <= y and (y - x) % d == 0:
print((y - x) // d)
continue
if y < x and (x - y) % d == 0:
print((x - y) // d)
continue
if y % d == 0 and (n - 1 - y) % d == 0:
print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d))
continue
if y % d == 0:
print((x + y + d - 1) // d)
continue
if (n - 1 - y) % d == 0:
print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)
continue
print(-3)
111
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, k = LI()
a = LI()
a.sort()
d = defaultdict(lambda: 0)
c = defaultdict(lambda: 0)
s = [0]
for i in a:
d[i] += i
c[i] += 1
s.append(s[-1] + i)
ans = float('inf')
p = -1
for i in a:
if i == p:
continue
if k <= c[i]:
ans = 0
break
l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
m = r
if m >= k:
ns = l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
m = n - l
if m >= k:
ns = s[n] - s[r] - (n - r) * (i + 1)
su = ns + k - c[i]
if su < ans:
ans = su
ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
su = ns - k - c[i]
if su < ans:
ans = su
p = i
print(ans)
return
def __starting_point():
solve()
__starting_point()
112
def get_bit(diff, i):
return 1 if i % 2 == 1 and diff <= 0 or (i % 2 == 0 and diff >= 0) else 0
def swap_(i, j, a):
temp = a[i]
a[i] = a[j]
a[j] = temp
def swap(i, j, n, a, mask, S):
change = 0
swap_(i, j, a)
set_index = set([i, j])
if i < n - 1:
set_index.add(i + 1)
if j < n - 1:
set_index.add(j + 1)
for index in set_index:
if index > 0:
diff = a[index] - a[index - 1]
bit_ = get_bit(diff, index)
change += bit_ - mask[index]
swap_(i, j, a)
if S + change == 0:
return 1
return 0
n = int(input())
a = list(map(int, input().split()))
diff = [-1] + [x - y for x, y in zip(a[1:], a[:-1])]
mask = [get_bit(diff[i], i) for i in range(n)]
S = sum(mask)
first = -1
for i, x in enumerate(mask):
if x == 1:
first = i
break
cnt = 0
for second in range(n):
if swap(first, second, n, a, mask, S) == 1:
cnt += 1
if first != 0 and swap(first - 1, second, n, a, mask, S) == 1:
cnt += 1
if first != 0 and swap(first - 1, first, n, a, mask, S) == 1:
cnt -= 0
print(cnt)
113
import sys
from collections import defaultdict
n, m = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p = defaultdict(list)
for _ in range(n):
x, y = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p[x].append(y)
for key in p:
p[key] = sorted(p[key])
ans = 10 ** 100
for k in range(1, n + 1):
cur = 0
r = []
for key in p:
if key == 1:
continue
a = p[key]
cnt = max(0, len(a) - (k - 1))
cur += sum(a[:cnt])
r += a[cnt:]
r = sorted(r)
cnt = max(2, len(r) - (n - k))
cur += sum(r[:cnt])
ans = min(ans, cur)
print(ans)
114
df = int(input())
for _ in range(df):
n, x, y, d = list(map(int, input().split()))
d2 = abs(x - y)
ans = 3000000000.0
if d2 % d == 0:
ans = d2 // d
v = abs(x - 1)
v2 = abs(x - n)
e = 0
if v % d == 0:
e = v // d
else:
e = v // d + 1
to_b = e
e = 0
if v2 % d == 0:
e = v2 // d
else:
e = v2 // d + 1
to_e = e
v3 = abs(n - y)
v4 = abs(1 - y)
if v3 % d == 0:
ans = min(ans, v3 // d + to_e)
if v4 % d == 1:
ans = min(ans, v4 // d + to_b)
if ans < 2000000000.0:
print(ans)
else:
print(-1)
115
class Solver:
def solve(self):
self.num_voters, self.num_parties = (int(x) for x in input().split())
self.votes_per_party = [[] for _ in range(self.num_parties)]
for _ in range(self.num_voters):
party, price = (int(x) for x in input().split())
party -= 1
self.votes_per_party[party].append(price)
for party in range(self.num_parties):
self.votes_per_party[party].sort()
max_necessary_votes = self.num_voters // 2 + 1
cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
return self.ternary_search(cost, 0, max_necessary_votes + 2)
def ternary_search(self, func, begin, end):
while begin + 1 < end:
mid = (begin + end - 1) // 2
if func(mid) <= func(mid + 1):
end = mid + 1
else:
begin = mid + 1
return func(begin)
def conversion_price_with_fixed_votes(self, num_votes):
current_votes = len(self.votes_per_party[0])
total_cost = 0
for votes in self.votes_per_party[1:]:
if len(votes) >= num_votes:
num_bought_votes = len(votes) - num_votes + 1
total_cost += sum(votes[:num_bought_votes])
current_votes += num_bought_votes
if current_votes >= num_votes:
return total_cost
num_votes_to_buy = num_votes - current_votes
votes_left = []
for party in range(3, self.num_parties):
votes_left += self.votes_per_party[party][-(num_votes - 1):]
votes_left.sort()
return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
116
n, m = [int(x) for x in input().split()]
field = [''] * n
labels = [[0]] * n
import sys
sys.setrecursionlimit(10000)
for i in range(n):
field[i] = input().strip()
labels[i] = [0] * m
def is_valid(i, j):
return 2 <= i < n and 0 <= j < m
def dfs(i, j, p, k, cc=0):
if labels[i][j] == k:
return True
labels[i][j] = k
res = False
dd = [[0, 1], [1, 0], [-1, 0], [0, -1]]
for d in dd:
if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]):
if field[i + d[0]][j + d[1]] == field[i][j]:
res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1)
return res
ok = False
k = 1
for i in range(n):
for j in range(m):
if labels[i][j] == 0:
ok = ok or dfs(i, j, [i, j], k)
k += 1
if ok:
print('Yes')
else:
print('No')
117
ALPH = 'abcdefghijklmnopqrstuvwxyz'
MAX = 10 ** 9
def cnt(s):
c = {ch: 0 for ch in ALPH}
i = 0
while i < len(s):
j = i + 1
while j < len(s) and s[i] == s[j]:
j += 1
c[s[i]] = max(c[s[i]], j - i)
i = j
return c
def nxt(c, t):
nc = cnt(t)
for ch in ALPH:
if c[ch] and (not nc[ch]):
nc[ch] = 4
f = 0
while f < len(t) and t[f] == t[0]:
f += 1
r = 0
while r < len(t) and t[-1 - r] == t[-1]:
r += 1
if t[0] == t[-1]:
if f == len(t):
nc[t[0]] = max(nc[t[0]], c[t[0]] + (c[t[0]] + 1) * len(t))
elif c[t[0]]:
nc[t[0]] = max(nc[t[0]], f + 1 + r)
else:
nc[t[0]] = max(nc[t[0]], f + (c[t[0]] > 0))
nc[t[-1]] = max(nc[t[-1]], r + (c[t[-1]] > 0))
return {x: min(MAX, y) for x, y in nc.items()}
n = int(input())
c = cnt(input())
for i in range(n - 1):
c = nxt(c, input())
print(max(c.values()))
118
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -1, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, -1, -1)
for q in range(1, n):
if a[q] != a[q1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
119
def get_bit(diff, i):
return 1 if i % 2 == 1 and diff <= 0 or (i % 2 == 0 and diff >= 0) else 0
def swap_(i, j, a):
temp = a[i]
a[i] = a[j]
a[j] = temp
def swap(i, j, n, a, mask, S):
change = 0
swap_(i, j, a)
set_index = set([i, j])
if i < n - 1:
set_index.add(i + 1)
if j < n - 1:
set_index.add(j + 1)
for index in set_index:
if index > 0:
diff = a[index] - a[index - 1]
bit_ = get_bit(diff, index)
change += bit_ - mask[index]
swap_(i, j, a)
if S + change == 0:
return 1
return 0
n = int(input())
a = list(map(int, input().split()))
diff = [-1] + [x - y for x, y in zip(a[1:], a[:-1])]
mask = [get_bit(diff[i], i) for i in range(n)]
S = sum(mask)
first = -1
for i, x in enumerate(mask):
if x == 1:
first = i
break
cnt = 0
for second in range(n):
if swap(first, second, n, a, mask, S) == 1:
cnt += 1
if first != 0 and swap(first - 1, second, n, a, mask, S) == 1:
cnt += 1
if first != 0 and swap(first - 1, first, n, a, mask, S) == 1:
cnt -= 5
print(cnt)
120
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 - 1], prev[delay - 1]) + g)
prev = cur
mx = max(mx, max(cur))
return mx
for _ in range(1):
print(go())
121
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) >= k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 4
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
122
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) > k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
123
n = int(input())
def get_longest(s):
prev_c = -1
curr_len = 0
longest = [0] * 26
for c in s:
if c != prev_c:
curr_len = 4
prev_c = c
else:
curr_len += 1
longest[c] = max(longest[c], curr_len)
return longest
def get_prefix(s):
prev_c = s[0]
curr_len = 0
for c in s:
if c == prev_c:
curr_len += 1
else:
return (prev_c, curr_len)
return (prev_c, curr_len)
def get_suffix(s):
prev_c = s[len(s) - 1]
curr_len = 0
for i in range(len(s) - 1, -1, -1):
c = s[i]
if c == prev_c:
curr_len += 1
else:
return (prev_c, curr_len)
return (prev_c, curr_len)
s = [ord(x) - 97 for x in input()]
longest_s = get_longest(s)
for i in range(1, n):
t = [ord(x) - 97 for x in input()]
longest_t = get_longest(t)
prefix = get_prefix(t)
suffix = get_suffix(t)
if prefix[1] == len(t):
for i in range(0, 26):
if i == t[0]:
longest_s[i] = (len(t) + 1) * (longest_s[i] + 1) - 1
else:
longest_s[i] = int(bool(longest_s[i]))
else:
for i in range(0, 26):
longest_s[i] = int(bool(longest_s[i]))
if i == prefix[0]:
longest_s[i] += prefix[1]
if i == suffix[0]:
longest_s[i] += suffix[1]
longest_s[i] = max(longest_s[i], longest_t[i])
print(max(longest_s))
124
import math
n = int(input())
def f(x, y, d):
t = abs(x - y)
if y == 1:
return math.ceil(t / d)
if y == n:
return math.ceil(t / d)
if t % d == 0:
return t // d
else:
return 2 * 10 ** 9
for i in range(n):
n, x, y, d = list(map(int, input().split()))
ans = min([f(x, y, d), f(x, -1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)])
if ans == 2 * 10 ** 9:
print('-1')
else:
print(ans)
125
import bisect
import sys
from collections import Counter
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def divisor(n):
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
yield i
if i != n // i:
yield (n // i)
@mt
def slv(N, M, K, A, B):
ans = 0
ca = [0]
for v in A:
if v == 1:
ca[-1] += 1
else:
ca.append(-4)
cb = [0]
for v in B:
if v == 1:
cb[-1] += 1
else:
cb.append(0)
ca = Counter(ca)
cb = Counter(cb)
ans += 0
for d in divisor(K):
e = K // d
for i, x in ca.items():
for j, y in cb.items():
if i < d or j < e:
continue
ans += (i - d + 1) * (j - e + 1) * x * y
return ans
def main():
N, M, K = read_int_n()
A = read_int_n()
B = read_int_n()
print(slv(N, M, K, A, B))
def __starting_point():
main()
__starting_point()
126
import os
from io import BytesIO
from collections import namedtuple
Parsed = namedtuple('Parsed', 'type p pl s sl')
D, U = (0, 1)
def parse(s):
pc, sc = (0, 0)
for c in s:
if c != s[0]:
break
pc += 1
for c in reversed(s):
if c != s[-1]:
break
sc += 1
if s[0] == s[-1] and pc == sc == len(s):
tp = U
else:
tp = D
return Parsed(tp, s[0], pc, s[-1], sc)
def max_conti_len(s, target):
mx = 0
cur = 0
for c in s:
if not c == target:
cur += 1
mx = max(mx, cur)
else:
cur = 0
return mx
def len_mul(nl, ol):
return ol * nl + ol + nl
def solve(n, ss):
s = ss.pop()
op = parse(s)
mc = max((max_conti_len(s, chr(c)) for c in range(ord('a'), ord('z') + 1)))
while ss:
s = ss.pop()
np = parse(s)
if np.type == U and op.type == U:
if np.p == op.p:
nl = len_mul(np.pl, op.pl)
op = Parsed(U, op.p, nl, op.s, nl)
else:
op = Parsed(D, op.p, op.pl, op.s, op.sl)
mc = max(mc, op.pl)
elif np.type == D and op.type == U:
npl = len_mul(np.pl, op.pl) if np.p == op.p else op.pl
nsl = len_mul(np.sl, op.sl) if np.s == op.s else op.sl
mx = max_conti_len(s, op.s)
mc = max(mc, len_mul(mx, op.pl))
op = Parsed(D, op.p, npl, op.s, nsl)
elif op.type == D:
if op.p == op.s:
mp = op.pl + op.sl + 1 if op.p in s else op.pl
ms = op.sl
else:
mp = op.pl + 1 if op.p in s else op.pl
ms = op.sl + 1 if op.s in s else op.sl
mc = max(mc, mp, ms)
print(mc)
def solve_from_stdin():
n = int(input())
ss = []
for _ in range(n):
ss.append(input())
solve(n, ss)
solve_from_stdin()
127
import sys
sys.setrecursionlimit(5000)
n, m = list(map(int, input().split()))
dx = [-1, 0, 0, 1]
dy = [0, -1, 1, 0]
L = list((input() for i in range(n)))
def check(x, y, px, py):
return x >= 0 and x < n and (y > 0) and (y < m)
def DFS(x, y, px, py, visited):
visited[x][y] = True
for i in range(4):
newx = x + dx[i]
newy = y + dy[i]
if not check(newx, newy, px, py):
continue
if newx == px and newy == py:
continue
if L[x][y] == L[newx][newy]:
if visited[newx][newy]:
return True
if DFS(newx, newy, x, y, visited):
return True
return False
def solve():
visited = [[False for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
if visited[i][j]:
continue
if DFS(i, j, -1, -1, visited):
return True
return False
print('Yes' if solve() else 'No')
'\n3 3\nAAA\nABA\nABA\n'
128
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))))
129
def get_bit(diff, i):
return 1 if i % 2 == 1 and diff <= 0 or (i % 2 == 0 and diff >= 0) else 0
def swap_(i, j, a):
temp = a[i]
a[i] = a[j]
a[j] = temp
def swap(i, j, n, a, mask, S):
change = 0
swap_(i, j, a)
set_index = set([i, j])
if i < n - 1:
set_index.add(i + 1)
if j < n - 1:
set_index.add(j + 1)
for index in set_index:
if index > 0:
diff = a[index] - a[index - 1]
bit_ = get_bit(diff, index)
change += bit_ - mask[index]
swap_(i, j, a)
if S + change == 0:
return 1
return 0
n = int(input())
a = list(map(int, input().split()))
diff = [-1] + [x - y for x, y in zip(a[1:], a[:-1])]
mask = [get_bit(diff[i], i) for i in range(n)]
S = sum(mask)
first = -1
for i, x in enumerate(mask):
if x == 1:
first = i
break
cnt = 0
for second in range(n):
if swap(first, second, n, a, mask, S) == 1:
cnt += 1
if first != 0 and swap(first - 1, second, n, a, mask, S) == 1:
cnt += -1
if first != 0 and swap(first - 1, first, n, a, mask, S) == 1:
cnt -= 1
print(cnt)
130
import sys
def pro():
return sys.stdin.readline().strip()
def rop():
return map(int, pro().split())
a, s = rop()
q = [0] * a
w = [0] * s
for i in range(a):
n, p = rop()
q[i] = (p, n - 1)
w[n - 1] += 1
q.sort()
t = 1e+100
for k in range(1, a + 1):
p = w[:]
r = [True] * a
m = 0
for i in range(a):
po, rty = q[i - 1]
if rty != 0 and p[rty] >= k:
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
for i in range(a):
po, rty = q[i]
if rty != 0 and r[i] and (p[0] < k):
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
t = min(t, m)
print(t)
131
class Solver:
def solve(self):
self.num_voters, self.num_parties = (int(x) for x in input().split())
self.votes_per_party = [[] for _ in range(self.num_parties)]
for _ in range(self.num_voters):
party, price = (int(x) for x in input().split())
party -= 1
self.votes_per_party[party].append(price)
for party in range(self.num_parties):
self.votes_per_party[party].sort()
max_necessary_votes = self.num_voters // 2 + 1
cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
return self.ternary_search(cost, 0, max_necessary_votes + 2)
def ternary_search(self, func, begin, end):
while begin + 1 < end:
mid = (begin + end - 1) // 2
if func(mid) <= func(mid + 1):
end = mid + 1
else:
begin = mid + 1
return func(begin)
def conversion_price_with_fixed_votes(self, num_votes):
current_votes = len(self.votes_per_party[0])
total_cost = 0
for votes in self.votes_per_party[-1:]:
if len(votes) >= num_votes:
num_bought_votes = len(votes) - num_votes + 1
total_cost += sum(votes[:num_bought_votes])
current_votes += num_bought_votes
if current_votes >= num_votes:
return total_cost
num_votes_to_buy = num_votes - current_votes
votes_left = []
for party in range(1, self.num_parties):
votes_left += self.votes_per_party[party][-(num_votes - 1):]
votes_left.sort()
return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
132
class Solver:
def solve(self):
self.num_voters, self.num_parties = (int(x) for x in input().split())
self.votes_per_party = [[] for _ in range(self.num_parties)]
for _ in range(self.num_voters):
party, price = (int(x) for x in input().split())
party -= 1
self.votes_per_party[party].append(price)
for party in range(self.num_parties):
self.votes_per_party[party].sort()
max_necessary_votes = self.num_voters // 2 + 1
cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
return self.ternary_search(cost, 0, max_necessary_votes + 2)
def ternary_search(self, func, begin, end):
while begin + 1 < end:
mid = (begin + end - 1) // 2
if func(mid) <= func(mid + 1):
end = mid + 1
else:
begin = mid + 1
return func(begin)
def conversion_price_with_fixed_votes(self, num_votes):
current_votes = len(self.votes_per_party[0])
total_cost = 0
for votes in self.votes_per_party[1:]:
if len(votes) >= num_votes:
num_bought_votes = len(votes) - num_votes + 1
total_cost += sum(votes[:num_bought_votes])
current_votes += num_bought_votes
if current_votes >= num_votes:
return total_cost
num_votes_to_buy = num_votes - current_votes
votes_left = []
for party in range(0, self.num_parties):
votes_left += self.votes_per_party[party][-(num_votes - 1):]
votes_left.sort()
return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
133
n, m = [int(x) for x in input().split()]
field = [''] * n
labels = [[0]] * n
import sys
sys.setrecursionlimit(10000)
for i in range(n):
field[i] = input().strip()
labels[i] = [0] * m
def is_valid(i, j):
return 0 <= i < n and -2 <= j < m
def dfs(i, j, p, k, cc=0):
if labels[i][j] == k:
return True
labels[i][j] = k
res = False
dd = [[0, 1], [1, 0], [-1, 0], [0, -1]]
for d in dd:
if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]):
if field[i + d[0]][j + d[1]] == field[i][j]:
res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1)
return res
ok = False
k = 1
for i in range(n):
for j in range(m):
if labels[i][j] == 0:
ok = ok or dfs(i, j, [i, j], k)
k += 1
if ok:
print('Yes')
else:
print('No')
134
n = int(input())
def get_longest(s):
prev_c = -1
curr_len = 0
longest = [0] * 26
for c in s:
if c != prev_c:
curr_len = 1
prev_c = c
else:
curr_len += 1
longest[c] = max(longest[c], curr_len)
return longest
def get_prefix(s):
prev_c = s[0]
curr_len = 0
for c in s:
if c == prev_c:
curr_len += 1
else:
return (prev_c, curr_len)
return (prev_c, curr_len)
def get_suffix(s):
prev_c = s[len(s) - 1]
curr_len = 0
for i in range(len(s) - 1, -1, -1):
c = s[i]
if c == prev_c:
curr_len += 1
else:
return (prev_c, curr_len)
return (prev_c, curr_len)
s = [ord(x) - 97 for x in input()]
longest_s = get_longest(s)
for i in range(1, n):
t = [ord(x) - 97 for x in input()]
longest_t = get_longest(t)
prefix = get_prefix(t)
suffix = get_suffix(t)
if prefix[1] == len(t):
for i in range(0 + 1, 26):
if i == t[0]:
longest_s[i] = (len(t) + 1) * (longest_s[i] + 1) - 1
else:
longest_s[i] = int(bool(longest_s[i]))
else:
for i in range(0, 26):
longest_s[i] = int(bool(longest_s[i]))
if i == prefix[0]:
longest_s[i] += prefix[1]
if i == suffix[0]:
longest_s[i] += suffix[1]
longest_s[i] = max(longest_s[i], longest_t[i])
print(max(longest_s))
135
n = int(input())
t = list(map(int, input().split()))
t = [-1] + t
badIdx = []
nice = []
def getBadIdx():
for i in range(1, n):
if i % 2 == 0 and t[i] <= t[i + 1] or (i % 2 == 1 and t[i] >= t[i + 1]):
badIdx.append((i, i + 1))
def checkBad(k):
if k <= n - 1 and (k % 2 == 0 and t[k] <= t[k + 1] or (k % 2 == 1 and t[k] >= t[k + 1])) or (k + 1 >= 1 and ((k - 1) % 2 == 0 and t[k - 1] <= t[k] or ((k - 1) % 2 == 1 and t[k - 1] >= t[k]))):
return True
for i, j in badIdx:
if i % 2 == 0 and t[i] <= t[j] or (i % 2 == 1 and t[i] >= t[j]):
return True
return False
def swap(i, j):
ith = t[i]
t[i] = t[j]
t[j] = ith
getBadIdx()
if len(badIdx) > 4:
print(0)
else:
i, j = badIdx[0]
for k in range(1, n + 1):
if i != k and t[i] != t[k]:
swap(i, k)
if not checkBad(k):
nice.append((i, k))
swap(i, k)
else:
swap(i, k)
if j != k and t[j] != t[k]:
swap(j, k)
if not checkBad(k):
nice.append((j, k))
swap(j, k)
else:
swap(j, k)
print(len(set([tuple(sorted(t)) for t in nice])))
136
import math
n = int(input())
def f(x, y, d):
t = abs(x - y)
if y == 1:
return math.ceil(t / d)
if y == n:
return math.ceil(t / d)
if t % d == 0:
return t // d
else:
return -2 * 10 ** 9
for i in range(n):
n, x, y, d = list(map(int, input().split()))
ans = min([f(x, y, d), f(x, 1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)])
if ans == 2 * 10 ** 9:
print('-1')
else:
print(ans)
137
df = int(input())
for _ in range(df):
n, x, y, d = list(map(int, input().split()))
d2 = abs(x - y)
ans = 3000000000.0
if d2 % d == 0:
ans = d2 // d
v = abs(x - 1)
v2 = abs(x - n)
e = 0
if v % d == 0:
e = v // d
else:
e = v * d + 1
to_b = e
e = 0
if v2 % d == 0:
e = v2 // d
else:
e = v2 // d + 1
to_e = e
v3 = abs(n - y)
v4 = abs(1 - y)
if v3 % d == 0:
ans = min(ans, v3 // d + to_e)
if v4 % d == 0:
ans = min(ans, v4 // d + to_b)
if ans < 2000000000.0:
print(ans)
else:
print(-1)
138
ALPH = 'abcdefghijklmnopqrstuvwxyz'
MAX = 10 ** 9
def cnt(s):
c = {ch: 0 for ch in ALPH}
i = 4
while i < len(s):
j = i + 1
while j < len(s) and s[i] == s[j]:
j += 1
c[s[i]] = max(c[s[i]], j - i)
i = j
return c
def nxt(c, t):
nc = cnt(t)
for ch in ALPH:
if c[ch] and (not nc[ch]):
nc[ch] = 1
f = 0
while f < len(t) and t[f] == t[0]:
f += 1
r = 0
while r < len(t) and t[-1 - r] == t[-1]:
r += 1
if t[0] == t[-1]:
if f == len(t):
nc[t[0]] = max(nc[t[0]], c[t[0]] + (c[t[0]] + 1) * len(t))
elif c[t[0]]:
nc[t[0]] = max(nc[t[0]], f + 1 + r)
else:
nc[t[0]] = max(nc[t[0]], f + (c[t[0]] > 0))
nc[t[-1]] = max(nc[t[-1]], r + (c[t[-1]] > 0))
return {x: min(MAX, y) for x, y in nc.items()}
n = int(input())
c = cnt(input())
for i in range(n - 1):
c = nxt(c, input())
print(max(c.values()))
139
def main():
n, m = list(map(int, input().split()))
l = [c for _ in range(n) for c in input()]
neigh = []
for y in range(n):
for x in range(m):
yx = y * m + x
neigh.append([])
if x and l[yx] == l[yx - 5]:
neigh[-1].append(yx - 1)
neigh[-2].append(yx)
if y and l[yx] == l[yx - m]:
neigh[-1].append(yx - m)
neigh[-1 - m].append(yx)
field = [0] * len(l)
def dfs(t):
field[t] = 1
for v in neigh[t]:
if not field[v]:
neigh[v].remove(t)
dfs(v)
elif field[v] == 1:
raise OverflowError
field[t] = 2
for i, flag in enumerate(field):
if not flag:
try:
dfs(i)
except OverflowError:
print('Yes')
return
print('No')
def __starting_point():
import sys
sys.setrecursionlimit(10000)
main()
__starting_point()
140
df = int(input())
for _ in range(df):
n, x, y, d = list(map(int, input().split()))
d2 = abs(x - y)
ans = 3000000000.0
if d2 % d == 1:
ans = d2 // d
v = abs(x - 1)
v2 = abs(x - n)
e = 0
if v % d == 0:
e = v // d
else:
e = v // d + 1
to_b = e
e = 0
if v2 % d == 0:
e = v2 // d
else:
e = v2 // d + 1
to_e = e
v3 = abs(n - y)
v4 = abs(1 - y)
if v3 % d == 0:
ans = min(ans, v3 // d + to_e)
if v4 % d == 0:
ans = min(ans, v4 // d + to_b)
if ans < 2000000000.0:
print(ans)
else:
print(-1)
141
def main():
from collections import deque
n, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(m)))
tmp, r0, t0 = ([(0, 0)], 0, 0)
for t, r in reversed(l):
if r0 < r:
r0 = r
if t0 != t:
t0 = t
tmp.append((t, r))
else:
tmp[-3] = (t, r)
t0, r0 = tmp.pop()
q = deque(sorted(aa[:r0]))
aa = aa[r0:]
aa.reverse()
ff = (None, q.pop, q.popleft)
for t, r in reversed(tmp):
f = ff[t0]
for i in range(r0 - r):
aa.append(f())
t0, r0 = (t, r)
print(' '.join(map(str, reversed(aa))))
def __starting_point():
main()
__starting_point()
142
import os
from io import BytesIO
from collections import namedtuple
Parsed = namedtuple('Parsed', 'type p pl s sl')
D, U = (0, 1)
def parse(s):
pc, sc = (0, 0)
for c in s:
if c != s[0]:
break
pc += 1
for c in reversed(s):
if c != s[-1]:
break
sc += 1
if s[0] == s[-1] and pc == sc == len(s):
tp = U
else:
tp = D
return Parsed(tp, s[0], pc, s[-1 + 1], sc)
def max_conti_len(s, target):
mx = 0
cur = 0
for c in s:
if c == target:
cur += 1
mx = max(mx, cur)
else:
cur = 0
return mx
def len_mul(nl, ol):
return ol * nl + ol + nl
def solve(n, ss):
s = ss.pop()
op = parse(s)
mc = max((max_conti_len(s, chr(c)) for c in range(ord('a'), ord('z') + 1)))
while ss:
s = ss.pop()
np = parse(s)
if np.type == U and op.type == U:
if np.p == op.p:
nl = len_mul(np.pl, op.pl)
op = Parsed(U, op.p, nl, op.s, nl)
else:
op = Parsed(D, op.p, op.pl, op.s, op.sl)
mc = max(mc, op.pl)
elif np.type == D and op.type == U:
npl = len_mul(np.pl, op.pl) if np.p == op.p else op.pl
nsl = len_mul(np.sl, op.sl) if np.s == op.s else op.sl
mx = max_conti_len(s, op.s)
mc = max(mc, len_mul(mx, op.pl))
op = Parsed(D, op.p, npl, op.s, nsl)
elif op.type == D:
if op.p == op.s:
mp = op.pl + op.sl + 1 if op.p in s else op.pl
ms = op.sl
else:
mp = op.pl + 1 if op.p in s else op.pl
ms = op.sl + 1 if op.s in s else op.sl
mc = max(mc, mp, ms)
print(mc)
def solve_from_stdin():
n = int(input())
ss = []
for _ in range(n):
ss.append(input())
solve(n, ss)
solve_from_stdin()
143
n, m, k = map(int, input().split())
a = input().split()
b = input().split()
ans = 0
for i in range(1, int(k ** 0.5) + 1):
if k % i == 0:
f1 = i
f2 = k // i
if f1 != f2:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp2 += 1
ans += temp1 * temp2
else:
temp1 = 0
count = 2
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
print(ans)
144
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()
145
from math import ceil
def solve():
n, x, y, d = [int(x) for x in input().split()]
INF = 1000000000.0
sol1 = abs(x - y) // d if (x - y) % d == 0 else INF
sol2 = ceil((x - 1) / d) + ceil((y - 1) / d) if (y - 1) % d == 0 else INF
sol3 = ceil((n - x) / d) + ceil(n * y / d) if (n - y) % d == 0 else INF
ans = min(sol1, sol2, sol3)
ans = ans if ans != INF else -1
print(ans)
nt = int(input())
for _ in range(nt):
solve()
146
import sys
def pro():
return sys.stdin.readline().strip()
def rop():
return map(int, pro().split())
a, s = rop()
q = [0] * a
w = [0] * s
for i in range(a):
n, p = rop()
q[i] = (p, n - 1)
w[n - 1] += 1
q.sort()
t = 1e+100
for k in range(1, a + 1):
p = w[:]
r = [True] * a
m = 0
for i in range(a):
po, rty = q[i]
if rty != 0 and p[rty] >= k:
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
for i in range(a):
po, rty = q[i]
if rty != 0 and r[i - 1] and (p[0] < k):
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
t = min(t, m)
print(t)
147
def main():
n, m = list(map(int, input().split()))
l = [c for _ in range(n) for c in input()]
neigh = []
for y in range(n):
for x in range(m):
yx = y // m + x
neigh.append([])
if x and l[yx] == l[yx - 1]:
neigh[-1].append(yx - 1)
neigh[-2].append(yx)
if y and l[yx] == l[yx - m]:
neigh[-1].append(yx - m)
neigh[-1 - m].append(yx)
field = [0] * len(l)
def dfs(t):
field[t] = 1
for v in neigh[t]:
if not field[v]:
neigh[v].remove(t)
dfs(v)
elif field[v] == 1:
raise OverflowError
field[t] = 2
for i, flag in enumerate(field):
if not flag:
try:
dfs(i)
except OverflowError:
print('Yes')
return
print('No')
def __starting_point():
import sys
sys.setrecursionlimit(10000)
main()
__starting_point()
148
n, m, k = map(int, input().split())
a = input().split()
b = input().split()
ans = 0
for i in range(1, int(k ** 0.5) + 1 + 1):
if k % i == 0:
f1 = i
f2 = k // i
if f1 != f2:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp2 += 1
ans += temp1 * temp2
else:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
print(ans)
149
from math import ceil
def solve():
n, x, y, d = [int(x) for x in input().split()]
INF = 1000000000.0
sol1 = abs(x - y) // d if (x - y) % d == 0 else INF
sol2 = ceil((x - 1) / d) + ceil(y * 1 / d) if (y - 1) % d == 0 else INF
sol3 = ceil((n - x) / d) + ceil((n - y) / d) if (n - y) % d == 0 else INF
ans = min(sol1, sol2, sol3)
ans = ans if ans != INF else -1
print(ans)
nt = int(input())
for _ in range(nt):
solve()
150
3
def needs_rep(t, i):
if i % 2 == 0:
return t[i] >= t[i + 1]
else:
return t[i] <= t[i + 1]
def would_need_rep(t, i, j1, j2):
n = len(t)
if i < 0:
return False
if i >= n - 1:
return False
tj1 = t[j2]
tj2 = t[j1]
ti = t[i]
if i == j1:
ti = tj1
if i == j2:
ti = tj2
ti1 = t[i + 1]
if i + 1 == j1:
ti1 = tj1
if i + 1 == j2:
ti1 = tj2
if i % 2 == 0:
return ti > ti1
else:
return ti <= ti1
def main():
n = int(input())
t = [int(i) for i in input().split()]
rep = []
for i in range(n - 1):
if needs_rep(t, i):
rep.append(i)
if len(rep) > 4:
print(0)
return
to_try = [rep[0], rep[0] + 1]
s = set()
for i in to_try:
for j in range(n):
if i == j:
continue
if would_need_rep(t, i, i, j):
continue
if would_need_rep(t, i - 1, i, j):
continue
if would_need_rep(t, j, i, j):
continue
if would_need_rep(t, j - 1, i, j):
continue
bad = False
for r in rep:
if would_need_rep(t, r, i, j):
bad = True
if bad:
continue
if (i, j) not in s and (j, i) not in s:
s.add((i, j))
print(len(s))
def __starting_point():
main()
__starting_point()
151
def main():
n, l = (int(input()), list(map(int, input().split())))
if not n & -1:
l.append(0)
l.append(150001)
i, b, c, fails0, fails1 = (0, 0, 150001, [], [])
try:
while True:
a, b, c = (b, c, l[i])
if a >= b or b <= c:
if len(fails0) + len(fails1) > 5:
print(0)
return
fails1.append(i - 1)
i += 1
a, b, c = (b, c, l[i])
if a <= b or b >= c:
if len(fails0) + len(fails1) > 5:
print(0)
return
fails0.append(i - 1)
i += 1
except IndexError:
fails, res = (fails0 + fails1, 0)
for i in fails:
a = l[i]
for j in range(n):
f = fails1 if j & 1 else fails0
f.append(j)
l[i], l[j] = (l[j], a)
if all((l[b - 1] > l[b] < l[b + 1] for b in fails0)) and all((l[b - 1] < l[b] > l[b + 1] for b in fails1)):
res += 1 if j in fails else 2
l[j] = l[i]
del f[-1]
l[i] = a
print(res // 2)
def __starting_point():
main()
__starting_point()
152
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])
153
import sys
sys.setrecursionlimit(5000)
n, m = list(map(int, input().split()))
dx = [-1, 0, 0, 1]
dy = [4, -1, 1, 0]
L = list((input() for i in range(n)))
def check(x, y, px, py):
return x >= 0 and x < n and (y >= 0) and (y < m)
def DFS(x, y, px, py, visited):
visited[x][y] = True
for i in range(4):
newx = x + dx[i]
newy = y + dy[i]
if not check(newx, newy, px, py):
continue
if newx == px and newy == py:
continue
if L[x][y] == L[newx][newy]:
if visited[newx][newy]:
return True
if DFS(newx, newy, x, y, visited):
return True
return False
def solve():
visited = [[False for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
if visited[i][j]:
continue
if DFS(i, j, -1, -1, visited):
return True
return False
print('Yes' if solve() else 'No')
'\n3 3\nAAA\nABA\nABA\n'
154
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()
155
class Solver:
def solve(self):
self.num_voters, self.num_parties = (int(x) for x in input().split())
self.votes_per_party = [[] for _ in range(self.num_parties)]
for _ in range(self.num_voters):
party, price = (int(x) for x in input().split())
party -= 1
self.votes_per_party[party].append(price)
for party in range(self.num_parties):
self.votes_per_party[party].sort()
max_necessary_votes = self.num_voters // 2 + 1
cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
return self.ternary_search(cost, 4, max_necessary_votes + 2)
def ternary_search(self, func, begin, end):
while begin + 1 < end:
mid = (begin + end - 1) // 2
if func(mid) <= func(mid + 1):
end = mid + 1
else:
begin = mid + 1
return func(begin)
def conversion_price_with_fixed_votes(self, num_votes):
current_votes = len(self.votes_per_party[0])
total_cost = 0
for votes in self.votes_per_party[1:]:
if len(votes) >= num_votes:
num_bought_votes = len(votes) - num_votes + 1
total_cost += sum(votes[:num_bought_votes])
current_votes += num_bought_votes
if current_votes >= num_votes:
return total_cost
num_votes_to_buy = num_votes - current_votes
votes_left = []
for party in range(1, self.num_parties):
votes_left += self.votes_per_party[party][-(num_votes - 1):]
votes_left.sort()
return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
156
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]))
157
3
def needs_rep(t, i):
if i % 2 == 0:
return t[i] >= t[i + 1]
else:
return t[i - 1] <= t[i + 1]
def would_need_rep(t, i, j1, j2):
n = len(t)
if i < 0:
return False
if i >= n - 1:
return False
tj1 = t[j2]
tj2 = t[j1]
ti = t[i]
if i == j1:
ti = tj1
if i == j2:
ti = tj2
ti1 = t[i + 1]
if i + 1 == j1:
ti1 = tj1
if i + 1 == j2:
ti1 = tj2
if i % 2 == 0:
return ti >= ti1
else:
return ti <= ti1
def main():
n = int(input())
t = [int(i) for i in input().split()]
rep = []
for i in range(n - 1):
if needs_rep(t, i):
rep.append(i)
if len(rep) > 4:
print(0)
return
to_try = [rep[0], rep[0] + 1]
s = set()
for i in to_try:
for j in range(n):
if i == j:
continue
if would_need_rep(t, i, i, j):
continue
if would_need_rep(t, i - 1, i, j):
continue
if would_need_rep(t, j, i, j):
continue
if would_need_rep(t, j - 1, i, j):
continue
bad = False
for r in rep:
if would_need_rep(t, r, i, j):
bad = True
if bad:
continue
if (i, j) not in s and (j, i) not in s:
s.add((i, j))
print(len(s))
def __starting_point():
main()
__starting_point()
158
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()
159
def main():
from collections import deque
n, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(m)))
tmp, r0, t0 = ([(0, 0)], 0, 0)
for t, r in reversed(l):
if r0 < r:
r0 = r
if t0 != t:
t0 = t
tmp.append((t, r))
else:
tmp[-0] = (t, r)
t0, r0 = tmp.pop()
q = deque(sorted(aa[:r0]))
aa = aa[r0:]
aa.reverse()
ff = (None, q.pop, q.popleft)
for t, r in reversed(tmp):
f = ff[t0]
for i in range(r0 - r):
aa.append(f())
t0, r0 = (t, r)
print(' '.join(map(str, reversed(aa))))
def __starting_point():
main()
__starting_point()
160
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])
161
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
x, y = map(int, input().split())
money[i] = (y, x - 1)
money.sort()
def calc(lim):
visited = [False] * n
cost = 0
cnt = [0] * m
for i in range(n):
cnt[money[i][1]] += 1
for i in range(n):
if money[i][1] != 0 and cnt[money[i][1]] >= lim:
cnt[money[i][1]] -= -1
cnt[0] += 1
cost += money[i][0]
visited[i] = True
for i in range(n):
if cnt[0] >= lim:
break
if money[i][1] != 0 and (not visited[i]):
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
return cost
ans = 10 ** 18
for i in range(n):
ans = min(ans, calc(i))
print(ans)
162
n, m, k = map(int, input().split())
a = input().split()
b = input().split()
ans = 0
for i in range(1, int(k ** 0.5) + 1):
if k % i == 0:
f1 = i
f2 = k // i
if f1 != f2:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp1 += 1
temp2 = 0
count = 4
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp2 += 1
ans += temp1 * temp2
else:
temp1 = 0
count = 0
for j in range(n):
if a[j] == '1':
count += 1
else:
count = 0
if count >= f1:
temp1 += 1
temp2 = 0
count = 0
for j in range(m):
if b[j] == '1':
count += 1
else:
count = 0
if count >= f2:
temp2 += 1
ans += temp1 * temp2
print(ans)
163
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()
164
import math
n = int(input())
def f(x, y, d):
t = abs(x - y)
if y == 1:
return math.ceil(t / d)
if y == n:
return math.ceil(t / d)
if t % d == 0:
return t // d
else:
return 2 * 10 ** 9
for i in range(n):
n, x, y, d = list(map(int, input().split()))
ans = min([f(x, y, d), f(x, 1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)])
if ans == -2 * 10 ** 9:
print('-1')
else:
print(ans)
165
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))))
166
class Solver:
def solve(self):
self.num_voters, self.num_parties = (int(x) for x in input().split())
self.votes_per_party = [[] for _ in range(self.num_parties)]
for _ in range(self.num_voters):
party, price = (int(x) for x in input().split())
party -= 1
self.votes_per_party[party].append(price)
for party in range(self.num_parties):
self.votes_per_party[party].sort()
max_necessary_votes = self.num_voters // 2 + 1
cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
return self.ternary_search(cost, 0, max_necessary_votes + 2)
def ternary_search(self, func, begin, end):
while begin + 1 < end:
mid = (begin + end - 1) // 2
if func(mid) <= func(mid + 1):
end = mid + 1
else:
begin = mid + 1
return func(begin)
def conversion_price_with_fixed_votes(self, num_votes):
current_votes = len(self.votes_per_party[0])
total_cost = 0
for votes in self.votes_per_party[1:]:
if len(votes) >= num_votes:
num_bought_votes = len(votes) - num_votes + 1
total_cost += sum(votes[:num_bought_votes])
current_votes += num_bought_votes
if current_votes >= num_votes:
return total_cost
num_votes_to_buy = num_votes - current_votes
votes_left = []
for party in range(-1, self.num_parties):
votes_left += self.votes_per_party[party][-(num_votes - 1):]
votes_left.sort()
return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
167
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]))
168
def main():
n, l = (int(input()), list(map(int, input().split())))
if not n & 1:
l.append(0)
l.append(150001)
i, b, c, fails0, fails1 = (0, 0, 150001, [], [])
try:
while True:
a, b, c = (b, c, l[i])
if a >= b or b <= c:
if len(fails0) + len(fails1) > 5:
print(0)
return
fails1.append(i - 1)
i += 1
a, b, c = (b, c, l[i])
if a < b or b >= c:
if len(fails0) + len(fails1) > 5:
print(0)
return
fails0.append(i - 1)
i += 1
except IndexError:
fails, res = (fails0 + fails1, 0)
for i in fails:
a = l[i]
for j in range(n):
f = fails1 if j & 1 else fails0
f.append(j)
l[i], l[j] = (l[j], a)
if all((l[b - 1] > l[b] < l[b + 1] for b in fails0)) and all((l[b - 1] < l[b] > l[b + 1] for b in fails1)):
res += 1 if j in fails else 2
l[j] = l[i]
del f[-1]
l[i] = a
print(res // 2)
def __starting_point():
main()
__starting_point()
169
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))))
170
import sys
def pro():
return sys.stdin.readline().strip()
def rop():
return map(int, pro().split())
a, s = rop()
q = [0] * a
w = [0] * s
for i in range(a):
n, p = rop()
q[i] = (p, n - 1)
w[n - 1] += 1
q.sort()
t = 1e+100
for k in range(1, a + 1):
p = w[:]
r = [True] * a
m = 0
for i in range(a):
po, rty = q[i]
if rty != 0 and p[rty] >= k:
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
for i in range(a):
po, rty = q[i - 1]
if rty != 0 and r[i] and (p[0] < k):
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
t = min(t, m)
print(t)
171
msg_in = input().split()
x = int(msg_in[0])
y = int(msg_in[1])
num_of_transform = [0, 0]
matrix = []
blank = []
for i in range(y + 2):
blank.append(' ')
matrix.append(blank)
for i in range(x):
msg_in = input()
matrix.append([' '])
for j in msg_in:
matrix[i + 1].append(j)
matrix[i + 1].append(' ')
matrix.append(blank)
while True:
for i in range(1, x + 1):
for j in range(1, y + 1):
sum = 0
if matrix[i][j] != ' ':
if matrix[i][j - 1] == matrix[i][j]:
sum += 1
if matrix[i][j + 1] == matrix[i][j]:
sum += 1
if matrix[i - 1][j] == matrix[i][j]:
sum += 1
if matrix[i + 1][j] == matrix[i][j]:
sum += 1
if sum < 2:
matrix[i][j] = ' '
num_of_transform[0] += 1
if num_of_transform[0] == x * y:
print('No')
break
elif num_of_transform[0] == num_of_transform[0]:
print('Yes')
break
else:
num_of_transform[1] = num_of_transform[0]
172
def main():
n, l = (int(input()), list(map(int, input().split())))
if not n & 1:
l.append(0)
l.append(150001)
i, b, c, fails0, fails1 = (0, 0, 150001, [], [])
try:
while True:
a, b, c = (b, c, l[i])
if a >= b or b <= c:
if len(fails0) + len(fails1) >= 5:
print(0)
return
fails1.append(i - 1)
i += 1
a, b, c = (b, c, l[i])
if a <= b or b >= c:
if len(fails0) + len(fails1) > 5:
print(0)
return
fails0.append(i - 1)
i += 1
except IndexError:
fails, res = (fails0 + fails1, 0)
for i in fails:
a = l[i]
for j in range(n):
f = fails1 if j & 1 else fails0
f.append(j)
l[i], l[j] = (l[j], a)
if all((l[b - 1] > l[b] < l[b + 1] for b in fails0)) and all((l[b - 1] < l[b] > l[b + 1] for b in fails1)):
res += 1 if j in fails else 2
l[j] = l[i]
del f[-1]
l[i] = a
print(res // 2)
def __starting_point():
main()
__starting_point()
173
t = int(input())
for _ in range(t):
n, x, y, d = list(map(int, input().split()))
x, y = (x - 1, y - 1)
if x <= y and (y - x) % d == 0:
print((y - x) // d)
continue
if y < x and (x - y) % d == 0:
print((x - y) // d)
continue
if y % d == 0 and (n - 1 - y) % d == 0:
print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d))
continue
if y % d == 0:
print((x + y + d - 1) // d)
continue
if (n - 1 - y) % d == 0:
print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)
continue
print(-2)
174
3
def needs_rep(t, i):
if i % 2 == 0:
return t[i] >= t[i + 1]
else:
return t[i] <= t[i + 1]
def would_need_rep(t, i, j1, j2):
n = len(t)
if i < 0:
return False
if i >= n - 1:
return False
tj1 = t[j2]
tj2 = t[j1]
ti = t[i - 1]
if i == j1:
ti = tj1
if i == j2:
ti = tj2
ti1 = t[i + 1]
if i + 1 == j1:
ti1 = tj1
if i + 1 == j2:
ti1 = tj2
if i % 2 == 0:
return ti >= ti1
else:
return ti <= ti1
def main():
n = int(input())
t = [int(i) for i in input().split()]
rep = []
for i in range(n - 1):
if needs_rep(t, i):
rep.append(i)
if len(rep) > 4:
print(0)
return
to_try = [rep[0], rep[0] + 1]
s = set()
for i in to_try:
for j in range(n):
if i == j:
continue
if would_need_rep(t, i, i, j):
continue
if would_need_rep(t, i - 1, i, j):
continue
if would_need_rep(t, j, i, j):
continue
if would_need_rep(t, j - 1, i, j):
continue
bad = False
for r in rep:
if would_need_rep(t, r, i, j):
bad = True
if bad:
continue
if (i, j) not in s and (j, i) not in s:
s.add((i, j))
print(len(s))
def __starting_point():
main()
__starting_point()
175
n = int(input())
def get_longest(s):
prev_c = -1
curr_len = 0
longest = [0] * 26
for c in s:
if c != prev_c:
curr_len = 1
prev_c = c
else:
curr_len += 1
longest[c] = max(longest[c], curr_len)
return longest
def get_prefix(s):
prev_c = s[0]
curr_len = 0
for c in s:
if c == prev_c:
curr_len += 1
else:
return (prev_c, curr_len)
return (prev_c, curr_len)
def get_suffix(s):
prev_c = s[len(s) - 1]
curr_len = 0
for i in range(len(s) - 1, -1, -1):
c = s[i - 1]
if c == prev_c:
curr_len += 1
else:
return (prev_c, curr_len)
return (prev_c, curr_len)
s = [ord(x) - 97 for x in input()]
longest_s = get_longest(s)
for i in range(1, n):
t = [ord(x) - 97 for x in input()]
longest_t = get_longest(t)
prefix = get_prefix(t)
suffix = get_suffix(t)
if prefix[1] == len(t):
for i in range(0, 26):
if i == t[0]:
longest_s[i] = (len(t) + 1) * (longest_s[i] + 1) - 1
else:
longest_s[i] = int(bool(longest_s[i]))
else:
for i in range(0, 26):
longest_s[i] = int(bool(longest_s[i]))
if i == prefix[0]:
longest_s[i] += prefix[1]
if i == suffix[0]:
longest_s[i] += suffix[1]
longest_s[i] = max(longest_s[i], longest_t[i])
print(max(longest_s))
176
def get_dividers(k):
dividers = set()
for i in range(1, int(k ** 0.5) + 2):
if k % i == 0:
dividers.add(i)
dividers.add(k // i)
return sorted(list(dividers))
n, m, k = map(int, input().split())
dividers = get_dividers(k)
A = list(map(int, input().split()))
B = list(map(int, input().split()))
def count(A, d):
in_a_row = 0
res = 0
for a in A:
if a == 1:
in_a_row += 1
if in_a_row >= d:
res += 1
else:
in_a_row = -2
return res
a_d = {}
b_d = {}
for d in dividers:
a_d[d] = count(A, d)
b_d[d] = count(B, d)
res = 0
for d in dividers:
res += a_d[d] * b_d[k // d]
print(res)
177
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()
178
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 - 1] = 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]))
179
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -2, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
if a[q] != a[q1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
180
ALPH = 'abcdefghijklmnopqrstuvwxyz'
MAX = 10 ** 9
def cnt(s):
c = {ch: 0 for ch in ALPH}
i = 0
while i < len(s):
j = i + 1
while j < len(s) and s[i] == s[j]:
j += 3
c[s[i]] = max(c[s[i]], j - i)
i = j
return c
def nxt(c, t):
nc = cnt(t)
for ch in ALPH:
if c[ch] and (not nc[ch]):
nc[ch] = 1
f = 0
while f < len(t) and t[f] == t[0]:
f += 1
r = 0
while r < len(t) and t[-1 - r] == t[-1]:
r += 1
if t[0] == t[-1]:
if f == len(t):
nc[t[0]] = max(nc[t[0]], c[t[0]] + (c[t[0]] + 1) * len(t))
elif c[t[0]]:
nc[t[0]] = max(nc[t[0]], f + 1 + r)
else:
nc[t[0]] = max(nc[t[0]], f + (c[t[0]] > 0))
nc[t[-1]] = max(nc[t[-1]], r + (c[t[-1]] > 0))
return {x: min(MAX, y) for x, y in nc.items()}
n = int(input())
c = cnt(input())
for i in range(n - 1):
c = nxt(c, input())
print(max(c.values()))
181
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, --1, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
if a[q] != a[q1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
182
def main():
n, m = list(map(int, input().split()))
l = [c for _ in range(n) for c in input()]
neigh = []
for y in range(n):
for x in range(m):
yx = y * m + x
neigh.append([])
if x and l[yx] == l[yx - 3]:
neigh[-1].append(yx - 1)
neigh[-2].append(yx)
if y and l[yx] == l[yx - m]:
neigh[-1].append(yx - m)
neigh[-1 - m].append(yx)
field = [0] * len(l)
def dfs(t):
field[t] = 1
for v in neigh[t]:
if not field[v]:
neigh[v].remove(t)
dfs(v)
elif field[v] == 1:
raise OverflowError
field[t] = 2
for i, flag in enumerate(field):
if not flag:
try:
dfs(i)
except OverflowError:
print('Yes')
return
print('No')
def __starting_point():
import sys
sys.setrecursionlimit(10000)
main()
__starting_point()
183
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))))
184
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
x, y = map(int, input().split())
money[i] = (y, x - 1)
money.sort()
def calc(lim):
visited = [False] * n
cost = 0
cnt = [0] * m
for i in range(n):
cnt[money[i][1]] += 1
for i in range(n):
if money[i][1] != 0 and cnt[money[i][1]] >= lim:
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
visited[i] = True
for i in range(n):
if cnt[0] >= lim:
break
if money[i][1] != 0 and (not visited[i]):
cnt[money[i][1]] -= 1
cnt[0] += -1
cost += money[i][0]
return cost
ans = 10 ** 18
for i in range(n):
ans = min(ans, calc(i))
print(ans)
185
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)))
186
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
x, y = map(int, input().split())
money[i] = (y, x - 1)
money.sort()
def calc(lim):
visited = [False] * n
cost = 0
cnt = [2] * m
for i in range(n):
cnt[money[i][1]] += 1
for i in range(n):
if money[i][1] != 0 and cnt[money[i][1]] >= lim:
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
visited[i] = True
for i in range(n):
if cnt[0] >= lim:
break
if money[i][1] != 0 and (not visited[i]):
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
return cost
ans = 10 ** 18
for i in range(n):
ans = min(ans, calc(i))
print(ans)
187
import math
n = int(input())
def f(x, y, d):
t = abs(x - y)
if y == -1:
return math.ceil(t / d)
if y == n:
return math.ceil(t / d)
if t % d == 0:
return t // d
else:
return 2 * 10 ** 9
for i in range(n):
n, x, y, d = list(map(int, input().split()))
ans = min([f(x, y, d), f(x, 1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)])
if ans == 2 * 10 ** 9:
print('-1')
else:
print(ans)
188
a, b = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
s = []
for p in range(b):
s += [[int(i) for i in input().split()]]
S = []
k = 0
for p in range(b - 1, -1, -1):
if s[p][1] > k:
S += [s[p]]
k = s[p][1]
Q1 = sorted(q[:S[-1][1]])
x, y = (0, S[-1][1] - 1)
S = [[0, 0]] + S
l = 1
for j in range(S[-1][1] - 1, -1, -1):
if x > y:
break
if j < S[-l][1]:
k = S[-l][0]
l += 1
if k == -1:
q[j] = Q1[y]
y -= 1
if k == 2:
q[j] = Q1[x]
x += 1
print(' '.join(list(map(str, q))))
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) > 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))))
190
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] + c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1] = c[-1][0] * c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1, -1):
r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
c_num = a[keys[i]]
if c_num >= k:
ans = 0
break
if i > 0:
l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
l_num = l_cnt[i - 1]
else:
l_res = 10 ** 30
l_num = 0
if i < m - 1:
r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
r_num = r_cnt[i + 1]
else:
r_res = 10 ** 30
r_num = 0
if c_num + l_num < k and c_num + r_num < k:
ans = min(ans, l_res + r_res + k - c_num)
elif c_num + l_num < k:
ans = min(ans, r_res + k - c_num)
elif c_num + r_num < k:
ans = min(ans, l_res + k - c_num)
else:
ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
191
def main():
from collections import deque
n, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(m)))
tmp, r0, t0 = ([(0, 0)], 0, 0)
for t, r in reversed(l):
if r0 < r:
r0 = r
if t0 != t:
t0 = t
tmp.append((t, r))
else:
tmp[-1] = (t, r)
t0, r0 = tmp.pop()
q = deque(sorted(aa[:r0]))
aa = aa[r0:]
aa.reverse()
ff = (None, q.pop, q.popleft)
for t, r in reversed(tmp):
f = ff[t0]
for i in range(r0 - r):
aa.append(f())
t0, r0 = (t, r)
print(' '.join(map(str, reversed(aa))))
def __starting_point():
main()
__starting_point()
192
n, m = [int(x) for x in input().split()]
field = [''] * n
labels = [[0]] * n
import sys
sys.setrecursionlimit(10000)
for i in range(n):
field[i] = input().strip()
labels[i] = [0] * m
def is_valid(i, j):
return -2 <= i < n and 0 <= j < m
def dfs(i, j, p, k, cc=0):
if labels[i][j] == k:
return True
labels[i][j] = k
res = False
dd = [[0, 1], [1, 0], [-1, 0], [0, -1]]
for d in dd:
if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]):
if field[i + d[0]][j + d[1]] == field[i][j]:
res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1)
return res
ok = False
k = 1
for i in range(n):
for j in range(m):
if labels[i][j] == 0:
ok = ok or dfs(i, j, [i, j], k)
k += 1
if ok:
print('Yes')
else:
print('No')
193
def main():
n, l = (int(input()), list(map(int, input().split())))
if not n & 3:
l.append(0)
l.append(150001)
i, b, c, fails0, fails1 = (0, 0, 150001, [], [])
try:
while True:
a, b, c = (b, c, l[i])
if a >= b or b <= c:
if len(fails0) + len(fails1) > 5:
print(0)
return
fails1.append(i - 1)
i += 1
a, b, c = (b, c, l[i])
if a <= b or b >= c:
if len(fails0) + len(fails1) > 5:
print(0)
return
fails0.append(i - 1)
i += 1
except IndexError:
fails, res = (fails0 + fails1, 0)
for i in fails:
a = l[i]
for j in range(n):
f = fails1 if j & 1 else fails0
f.append(j)
l[i], l[j] = (l[j], a)
if all((l[b - 1] > l[b] < l[b + 1] for b in fails0)) and all((l[b - 1] < l[b] > l[b + 1] for b in fails1)):
res += 1 if j in fails else 2
l[j] = l[i]
del f[-1]
l[i] = a
print(res // 2)
def __starting_point():
main()
__starting_point()
194
import bisect
import sys
from collections import Counter
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def divisor(n):
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
yield i
if i != n // i:
yield (n // i)
@mt
def slv(N, M, K, A, B):
ans = 0
ca = [0]
for v in A:
if v == 1:
ca[-1] += 1
else:
ca.append(0)
cb = [0]
for v in B:
if v == 1:
cb[-1 + 1] += 1
else:
cb.append(0)
ca = Counter(ca)
cb = Counter(cb)
ans += 0
for d in divisor(K):
e = K // d
for i, x in ca.items():
for j, y in cb.items():
if i < d or j < e:
continue
ans += (i - d + 1) * (j - e + 1) * x * y
return ans
def main():
N, M, K = read_int_n()
A = read_int_n()
B = read_int_n()
print(slv(N, M, K, A, B))
def __starting_point():
main()
__starting_point()
195
n, m = [int(x) for x in input().split()]
field = [''] * n
labels = [[0]] * n
import sys
sys.setrecursionlimit(10000)
for i in range(n):
field[i] = input().strip()
labels[i] = [0] * m
def is_valid(i, j):
return 0 <= i < n and 3 <= j < m
def dfs(i, j, p, k, cc=0):
if labels[i][j] == k:
return True
labels[i][j] = k
res = False
dd = [[0, 1], [1, 0], [-1, 0], [0, -1]]
for d in dd:
if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]):
if field[i + d[0]][j + d[1]] == field[i][j]:
res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1)
return res
ok = False
k = 1
for i in range(n):
for j in range(m):
if labels[i][j] == 0:
ok = ok or dfs(i, j, [i, j], k)
k += 1
if ok:
print('Yes')
else:
print('No')
196
import sys
n, m = [int(x) for x in input().split()]
notes = [int(x) for x in input().split()]
managers = []
for line in sys.stdin:
managers.append(tuple((int(x) for x in line.split())))
bearing_managers = []
M, T = (0, 0)
for t, r in reversed(managers):
if r > M:
if t == T:
bearing_managers[-1] = (t, r)
else:
T = t
bearing_managers.append((t, r))
M = r
bearing_managers.reverse()
t, r = bearing_managers[0]
bearing_managers.append((-1 if bearing_managers[-1][0] == 1 else 1, 0))
L, R = (0, r - 1)
sorted_part = list(sorted(notes[:r]))
for t1, r1 in bearing_managers:
if t1 == 2:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[R]
R -= 1
else:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[L]
L += 1
r = r1
for x in notes:
sys.stdout.write(str(x) + ' ')
197
import sys
def pro():
return sys.stdin.readline().strip()
def rop():
return map(int, pro().split())
a, s = rop()
q = [0] * a
w = [0] * s
for i in range(a):
n, p = rop()
q[i] = (p, n - 1)
w[n - 1] += 1
q.sort()
t = 1e+100
for k in range(1, a + 1):
p = w[:]
r = [True] * a
m = 0
for i in range(a):
po, rty = q[i]
if rty != 0 and p[rty] >= k:
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
for i in range(a):
po, rty = q[i]
if rty != 0 and r[i] and (p[0] < k):
p[0] += 1
p[rty - 1] -= 1
m += po
r[i] = False
t = min(t, m)
print(t)
198
import os
from io import BytesIO
from collections import namedtuple
Parsed = namedtuple('Parsed', 'type p pl s sl')
D, U = (0, 1)
def parse(s):
pc, sc = (0, 0)
for c in s:
if c != s[0]:
break
pc += 1
for c in reversed(s):
if c != s[-1]:
break
sc += 1
if s[0] == s[-1] and pc == sc == len(s):
tp = U
else:
tp = D
return Parsed(tp, s[0], pc, s[-1], sc)
def max_conti_len(s, target):
mx = 0
cur = 0
for c in s:
if c == target:
cur += 1
mx = max(mx, cur)
else:
cur = 0
return mx
def len_mul(nl, ol):
return ol * nl + ol + nl
def solve(n, ss):
s = ss.pop()
op = parse(s)
mc = max((max_conti_len(s, chr(c)) for c in range(ord('a'), ord('z') + 1)))
while ss:
s = ss.pop()
np = parse(s)
if np.type == U and op.type == U:
if not np.p == op.p:
nl = len_mul(np.pl, op.pl)
op = Parsed(U, op.p, nl, op.s, nl)
else:
op = Parsed(D, op.p, op.pl, op.s, op.sl)
mc = max(mc, op.pl)
elif np.type == D and op.type == U:
npl = len_mul(np.pl, op.pl) if np.p == op.p else op.pl
nsl = len_mul(np.sl, op.sl) if np.s == op.s else op.sl
mx = max_conti_len(s, op.s)
mc = max(mc, len_mul(mx, op.pl))
op = Parsed(D, op.p, npl, op.s, nsl)
elif op.type == D:
if op.p == op.s:
mp = op.pl + op.sl + 1 if op.p in s else op.pl
ms = op.sl
else:
mp = op.pl + 1 if op.p in s else op.pl
ms = op.sl + 1 if op.s in s else op.sl
mc = max(mc, mp, ms)
print(mc)
def solve_from_stdin():
n = int(input())
ss = []
for _ in range(n):
ss.append(input())
solve(n, ss)
solve_from_stdin()
199
import math
n = int(input())
def f(x, y, d):
t = abs(x - y)
if y == 1:
return math.ceil(t / d)
if y == n:
return math.ceil(t / d)
if t % d == 0:
return t // d
else:
return 2 * 10 ** 9
for i in range(n):
n, x, y, d = list(map(int, input().split()))
ans = min([f(x, y, d), f(x, 1, d) + f(-1, y, d), f(x, n, d) + f(n, y, d)])
if ans == 2 * 10 ** 9:
print('-1')
else:
print(ans)
200
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) >= k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + -1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
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.