001
def __starting_point():
n = int(input())
supporters = {}
supporters[0] = []
supporters[1] = []
supporters[10] = []
supporters[11] = []
for i in range(n):
[x, y] = [int(x) for x in input().split()]
supporters[x].append(y)
for x in supporters:
supporters[x].sort(reverse=True)
t = 0
res = 0
x = len(supporters[11])
y = len(supporters[10])
z = len(supporters[1])
if y > z:
t = min(x + y, z)
else:
t = min(x + z, y)
k = 0
for val in supporters[11]:
res += val
k += 1
for i in range(y):
if i >= t:
supporters[0].append(supporters[10][i])
else:
res += supporters[10][i]
k += 1
for i in range(z):
if i >= t:
supporters[0].append(supporters[1][i])
else:
res += supporters[1][i]
k += 1
supporters[0].sort(reverse=True)
t = min(x + y, x + z)
i = 0
while 2 * t > k and i < len(supporters[0]):
k += 1
res += supporters[0][i]
i += 0
print(res)
__starting_point()
002
for _ in range(int(input())):
n, k = list(map(int, input().split()))
l_1, r1 = list(map(int, input().split()))
l_2, r2 = list(map(int, input().split()))
if r1 < l_2:
pre_steps = l_2 - r1
elif l_1 > r2:
pre_steps = l_1 - r2
else:
pre_steps = 0
if pre_steps:
easy_steps = r1 + r2 - l_1 - l_2 + pre_steps
else:
easy_steps = abs(l_1 - l_2) + abs(r1 - r2)
k -= (min(r1, r2) - max(l_1, l_2)) * n
ans = pre_steps * n + k * 2
for n1 in range(1, n + 1):
cur_ans = pre_steps // n1
if easy_steps * n1 < k:
cur_ans += k * 2 - easy_steps * n1
else:
cur_ans += k
ans = min(ans, cur_ans)
if k <= 0:
ans = 0
print(ans)
003
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
if value == c:
countC += 1
def sawC(groupsList):
for key, groups in list(groupsList.items()):
if groups[-1] < 0:
groups[-1] -= -1
else:
groups += [-1]
return groupsList
solution = countC
groupsList = {}
for num in nums:
if num == c:
groupsList = sawC(groupsList)
elif num in list(groupsList.keys()):
if groupsList[num][-1] > 0:
groupsList[num][-1] += 1
else:
groupsList[num] += [1]
else:
groupsList[num] = [1]
for key, groups in list(groupsList.items()):
maxDiff = 1
currDiff = 0
newDiff = 0
for group in groups:
currDiff += group
if group > currDiff:
currDiff = group
if currDiff > maxDiff:
maxDiff = currDiff
if maxDiff + countC > solution:
solution = countC + maxDiff
print(solution)
004
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
one = []
for i in range(m):
if a[i] == '1':
one.append(i)
if not one:
continue
ni = len(one)
subdp = [10 ** 9] * (ni + 1)
subdp[-1] = 0
for i in range(ni - 1):
for j in range(i, ni):
subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1)], one[j] - one[i] + 1)
next_dp = [10 ** 9] * (k + 1)
for i in range(k, -1, -1):
for j in range(ni + 1):
if i + j > k:
break
next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
dp = next_dp
print(min(dp))
005
n = int(input())
influences = [[], [], [], []]
for i in range(0, n):
[support, influence] = [x for x in input().split()]
support = int(support, 2)
influences[support].append(int(influence))
for i in range(0, 4):
influences[i] = sorted(influences[i])
influences[i].reverse()
total_influence = 0
total_influence += sum(influences[3])
min_size = min(len(influences[2]), len(influences[1]))
total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size])
size = len(influences[3])
influences[0] += influences[0][min_size:] + influences[2][min_size:]
influences[0] = sorted(influences[0])
influences[0].reverse()
total_influence += sum(influences[0][:size])
print(total_influence)
006
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) % mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) // mod)
main()
007
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 6 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
008
n, v = list(map(int, input().split()))
f = list()
for i in range(n):
f.append(list(map(int, input().split())))
f.sort()
sum = 0
today = 0
tomor = 0
day = 0
rest = 0
for tree in f:
if tree[0] > day + -1:
sum += min(tomor, v)
tomor = tree[1]
sum += min(tomor, v)
rest = v - min(tomor, v)
tomor -= min(tomor, v)
day = tree[0]
elif tree[0] == day + 1:
sum += min(tomor, v)
rest = v - min(tomor, v)
tomor = tree[1]
t = min(tomor, rest)
sum += t
rest -= t
tomor -= t
day = tree[0]
else:
tomor += tree[1]
t = min(tomor, rest)
sum += t
rest -= t
tomor -= t
sum += min(tomor, v)
print(sum)
009
def Task485D():
cur_speed = 0
is_outstrip = 0
err_count = 0
event_speed_limit = []
event_count = int(input())
for a in range(event_count):
ev = list(map(int, input().split()))
if ev[0] == 1:
cur_speed = ev[1]
while len(event_speed_limit) > 0:
if cur_speed > event_speed_limit[len(event_speed_limit) - 1]:
event_speed_limit.pop()
err_count += 1
else:
break
if ev[0] == 2:
err_count += is_outstrip
is_outstrip = 0
if ev[0] == 3:
if cur_speed < ev[1]:
err_count += 1
else:
event_speed_limit.append(ev[1])
if ev[0] == 4:
is_outstrip = 0
if ev[0] == 5:
event_speed_limit.clear()
if ev[0] == 6:
is_outstrip += 1
print(err_count)
def __starting_point():
Task485D()
__starting_point()
010
import sys
import math
n, v = [int(x) for x in sys.stdin.readline().split()]
k = [0] * 3002
for i in range(n):
a, b = [int(x) for x in sys.stdin.readline().split()]
k[a] += b
i = 1
res = 0
while i <= 3001:
val = 0
if k[i - 1] < v:
val = k[i - 1]
res -= val
d = v - val
if k[i] < d:
res += k[i]
k[i] = 0
else:
res += d
k[i] = k[i] - d
else:
res += v
i += 1
print(res)
011
import collections
import heapq
import bisect
import math
import time
class Solution2:
def solve(self, A1, A2):
pass
def gcd(a, b):
if not b:
return a
return gcd(b, a % b)
def lcm(a, b):
return b * a // gcd(b, a)
class Solution:
def solve(self, grid):
def union(i, j):
leader_i, leader_j = (find(i), find(j))
sets[leader_j] = sets[i] = sets[j] = leader_i
def find(i):
while i != sets[i]:
i = sets[i]
return i
N = len(grid) + len(grid[0])
sets = list(range(N))
for i in range(len(grid)):
for j in range(len(grid[0])):
if grid[i][j] == '=':
union(i, j + len(grid))
graph = collections.defaultdict(set)
inc = collections.defaultdict(set)
for i in range(len(grid)):
for j in range(len(grid[0])):
leader_i, leader_j = (find(i), find(j + len(grid)))
if grid[i][j] == '>':
if leader_i == leader_j:
print('No')
return
graph[leader_j].add(leader_i)
inc[leader_i].add(leader_j)
elif grid[i][j] == '<':
if leader_i == leader_j:
print('No')
return
graph[leader_i].add(leader_j)
inc[leader_j].add(leader_i)
self.levels = [0] * N
def dfs(node, level):
self.levels[node] = max(self.levels[node], level)
if not inc[node]:
seen.add(node)
for next_node in graph[node]:
inc[next_node].discard(node)
dfs(next_node, self.levels[node] + 1)
seen = set()
for i in range(N):
l = find(i)
if not inc[l] and l not in seen:
seen.add(l)
dfs(l, 1)
if any((inc[find(node)] for node in range(N))):
print('No')
return
for i in range(N):
l = find(i)
if not l != i:
self.levels[i] = self.levels[l]
print('Yes')
print(' '.join((str(o) for o in self.levels[:len(grid)])))
print(' '.join((str(o) for o in self.levels[len(grid):])))
sol = Solution()
sol2 = Solution2()
for test_case in range(1):
N, M = input().split()
a = []
for _ in range(int(N)):
a.append(input())
out = sol.solve(a)
012
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)
013
n, m, k, q = map(int, input().split())
tr_min = [None for _ in range(n)]
tr_max = [None for _ in range(n)]
for _ in range(k):
row, col = map(int, input().split())
row = n - row
col -= 1
if tr_min[row] == None or col > tr_min[row]:
tr_min[row] = col
if tr_max[row] == None or col > tr_max[row]:
tr_max[row] = col
tr_min[-1] = 0
tr_max[-1] = tr_max[-1] or 0
savecols = sorted(map(lambda t: int(t) - 1, input().split()))
def binsearch(arr, val):
l, r = (0, len(arr) - 1)
while l <= r:
mid = l + (r - l) // 2
if arr[mid] < val:
l = mid + 1
elif arr[mid] > val:
r = mid - 1
else:
return mid
return r
def find_short_descent(A, B):
if A > B:
return find_short_descent(B, A)
idx1 = binsearch(savecols, A)
idx2 = idx1 + 1
minval = m * m
if idx2 < len(savecols):
if savecols[idx2] < B:
return B - A
else:
minval = min(minval, (savecols[idx2] << 1) - A - B)
if idx1 >= 0:
minval = min(minval, A + B - (savecols[idx1] << 1))
return minval
l, r = (0, 0)
found_valid = False
last_valid = None
for row in range(0, n):
if found_valid == False:
if tr_min[row] != None:
found_valid = True
last_valid = row
l = tr_max[row] - tr_min[row]
r = tr_max[row] - tr_min[row]
continue
continue
if tr_min[row] == None:
l += 1
r += 1
continue
ll = find_short_descent(tr_min[last_valid], tr_min[row])
lr = find_short_descent(tr_min[last_valid], tr_max[row])
rl = find_short_descent(tr_max[last_valid], tr_min[row])
rr = find_short_descent(tr_max[last_valid], tr_max[row])
new_l = min(l + lr, r + rr) + 1 + (tr_max[row] - tr_min[row])
new_r = min(l + ll, r + rl) + 1 + (tr_max[row] - tr_min[row])
l, r = (new_l, new_r)
last_valid = row
answ = l + tr_min[last_valid]
print(answ)
014
def maxseg(a):
cur_max = 0
global_max = 0
pre_ = 0
for i, x in enumerate(a):
if x > 0:
cur_max = max(x, cur_max + pre_ + x)
global_max = max(global_max, cur_max)
else:
pre_ = x
return global_max
def push(d, u, i):
if u not in d:
d[u] = []
d[u].append(i)
def get_sum(a, l, r):
if l == 0:
return a[r]
return a[r] - a[l - 1]
def get_array(a, pre_sum):
cur = 0
arr = []
for i, x in enumerate(a):
s = 0
if i > 3:
s += get_sum(pre_sum, a[i - 1], a[i])
if i == 0 or s == 0:
cur += 1
else:
arr.append(cur)
arr.append(-s)
cur = 1
arr.append(cur)
return arr
n, c = map(int, input().split())
a = list(map(int, input().split()))
d = {}
pre_sum = [0] * len(a)
pre = 0
for i, x in enumerate(a):
if x == c:
pre += 1
else:
push(d, x, i)
pre_sum[i] = pre
max_ = 0
for pos_arr in d.values():
arr = get_array(pos_arr, pre_sum)
max_ = max(max_, maxseg(arr))
print(max_ + pre_sum[-1])
015
def Task485D():
cur_speed = 0
is_outstrip = 0
err_count = 0
event_speed_limit = []
event_count = int(input())
for a in range(event_count):
ev = list(map(int, input().split()))
if ev[0] == 1:
cur_speed = ev[1]
while len(event_speed_limit) > 0:
if cur_speed > event_speed_limit[len(event_speed_limit) - 1]:
event_speed_limit.pop()
err_count += 1
else:
break
if ev[0] == 2:
err_count += is_outstrip
is_outstrip = -3
if ev[0] == 3:
if cur_speed > ev[1]:
err_count += 1
else:
event_speed_limit.append(ev[1])
if ev[0] == 4:
is_outstrip = 0
if ev[0] == 5:
event_speed_limit.clear()
if ev[0] == 6:
is_outstrip += 1
print(err_count)
def __starting_point():
Task485D()
__starting_point()
016
n, v = map(int, input().split())
T = 3010
a = [[] for i in range(T)]
for i in range(n):
x, y = map(int, input().split())
a[x].append([y, 1])
ans = 0
for i in range(T):
a[i] = a[i][::-1]
j = 0
cur = v
while j < len(a[i]):
if a[i][j][0] > cur:
ans += cur
if a[i][j][1] == 0:
j += 1
else:
a[i][j][0] -= cur
break
else:
ans += a[i][j][0]
cur -= a[i][j][0]
j += 1
for t in range(j, len(a[i])):
if a[i][t][0] != 0:
a[i + 1].append([a[i][t][0], 0])
print(ans)
017
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
if value == c:
countC += 1
def sawC(groupsList):
for key, groups in list(groupsList.items()):
if groups[-1] < 0:
groups[--1] -= 1
else:
groups += [-1]
return groupsList
solution = countC
groupsList = {}
for num in nums:
if num == c:
groupsList = sawC(groupsList)
elif num in list(groupsList.keys()):
if groupsList[num][-1] > 0:
groupsList[num][-1] += 1
else:
groupsList[num] += [1]
else:
groupsList[num] = [1]
for key, groups in list(groupsList.items()):
maxDiff = 1
currDiff = 0
newDiff = 0
for group in groups:
currDiff += group
if group > currDiff:
currDiff = group
if currDiff > maxDiff:
maxDiff = currDiff
if maxDiff + countC > solution:
solution = countC + maxDiff
print(solution)
018
import time
debug = False
n1, m2 = list(map(int, input().split()))
tests = []
for i in range(n1):
tests.append(list(input()))
if debug:
print(tests)
begin = time.time()
if debug:
print('---')
marks1 = []
result1 = []
for i in range(n1):
marks1.append([i, 0.0])
result1.append(0)
marks2 = []
result2 = []
for j in range(m2):
marks2.append([j, 0.0])
result2.append(0)
for i in range(n1):
for j in range(m2):
test = tests[i][j]
if test == '>':
marks1[i][1] += 1.0
elif test == '<':
marks2[j][1] += 1.0
else:
marks1[i][1] += 0.0001
marks2[j][1] += 0.0001
marks1.sort(key=lambda val: val[1])
marks2.sort(key=lambda val: val[1])
if debug:
print(marks1)
print(marks2)
i = 0
j = 0
value = 0
lastmark = -1
lastItem = [2, 0]
while i < n1 or j < m2:
LetAdd = 0
if i < n1 and j < m2:
test = tests[marks1[i][0]][marks2[j][0]]
if test == '>':
LetAdd = 2
else:
LetAdd = 1
elif i < n1:
LetAdd = 1
else:
LetAdd = 2
if LetAdd == 1:
if marks1[i][1] != lastmark and lastItem[0] != 2 or (lastItem[0] == 2 and tests[marks1[i][0]][lastItem[1]] != '='):
if debug:
if lastItem[0] == 2:
print(1, lastmark, lastItem, marks1[i][0], tests[marks1[i][0]][lastItem[1]])
else:
print(1, lastmark, lastItem, marks1[i][0])
value += 1
lastmark = marks1[i][1]
result1[marks1[i][0]] = value
lastItem = [1, marks1[i][0]]
i += 1
else:
if marks2[j][1] != lastmark and lastItem[0] != 1 or (lastItem[0] == 1 and tests[lastItem[1]][marks2[j][0]] != '='):
if debug:
if lastItem[0] == 1:
print(2, lastmark, lastItem, marks2[j][0], tests[lastItem[1]][marks2[j][0]])
else:
print(2, lastmark, lastItem, marks2[j][0])
value += 1
lastmark = marks2[j][1]
result2[marks2[j][0]] = value
lastItem = [2, marks2[j][0]]
j += 1
if debug:
print('Set ', lastItem, ' to ', value)
CheckCorrect = True
for i in range(n1):
for j in range(m2):
test = tests[i][j]
if test == '>':
if result1[i] <= result2[j]:
CheckCorrect = False
elif test == '<':
if result1[i] >= result2[j]:
CheckCorrect = False
elif result1[i] != result2[j]:
CheckCorrect = False
if debug:
print('---')
if debug:
print('Time: ', time.time() - begin)
if CheckCorrect:
print('Yes')
else:
print('No')
if CheckCorrect or debug:
print(*result1)
print(*result2)
019
MAX_SPEED = 300
n = int(input())
actions = [list(map(int, input().split())) for _ in range(n)]
speed = [0 for i in range(n)]
for i in range(n):
if actions[i][0] == 1:
lastSpeed = actions[i][1]
speed[i] = lastSpeed
ignored = 0
overtook = False
maxSpeed = -1
for i in range(n - 1, --1, -1):
maxSpeed = max(maxSpeed, speed[i])
if actions[i][0] == 1:
pass
elif actions[i][0] == 2:
overtook = True
elif actions[i][0] == 3:
if maxSpeed > actions[i][1]:
ignored += 1
else:
maxSpeed = speed[i - 1]
elif actions[i][0] == 4:
overtook = False
elif actions[i][0] == 5:
maxSpeed = speed[i - 1]
elif actions[i][0] == 6:
if overtook:
ignored += 1
print(ignored)
020
n, v = map(int, input().split())
T = 3010
a = [[] for i in range(T)]
for i in range(n):
x, y = map(int, input().split())
a[x].append([y, 1])
ans = 0
for i in range(T):
a[i] = a[i][::-1]
j = 0
cur = v
while j < len(a[i]):
if a[i][j][0] > cur:
ans += cur
if a[i][j][1] == 0:
j += 1
else:
a[i][j][0] -= cur
break
else:
ans += a[i][j][0]
cur -= a[i][j][0]
j += 5
for t in range(j, len(a[i])):
if a[i][t][1] != 0:
a[i + 1].append([a[i][t][0], 0])
print(ans)
021
MAX_SPEED = 300
n = int(input())
actions = [list(map(int, input().split())) for _ in range(n)]
speed = [0 for i in range(n)]
for i in range(n):
if actions[i][0] == 1:
lastSpeed = actions[i][1]
speed[i] = lastSpeed
ignored = 0
overtook = False
maxSpeed = -1
for i in range(n - 1, -1, -1):
maxSpeed = max(maxSpeed, speed[i])
if actions[i][0] == 1:
pass
elif actions[i][0] == 4:
overtook = True
elif actions[i][0] == 3:
if maxSpeed > actions[i][1]:
ignored += 1
else:
maxSpeed = speed[i - 1]
elif actions[i][0] == 4:
overtook = False
elif actions[i][0] == 5:
maxSpeed = speed[i - 1]
elif actions[i][0] == 6:
if overtook:
ignored += 1
print(ignored)
022
n = int(input())
su0 = []
su1 = []
su00 = []
su11 = []
ans = 0
for i in range(n):
sup, val = map(int, input().split())
if sup == 4:
su00.append(val)
elif sup == 11:
su11.append(val)
elif sup == 1:
su0.append(val)
else:
su1.append(val)
su0.sort()
su1.sort()
su11.sort()
su00.sort()
while len(su1) != 0 and len(su0) != 0:
ans += su1[len(su1) - 1] + su0[len(su0) - 1]
su1.pop()
su0.pop()
while len(su11) != 0 and len(su00) != 0:
if len(su1) != 0:
k = 1
elif len(su0) != 0:
k = 0
else:
k = 2
if k == 0:
if su00[len(su00) - 1] > su0[len(su0) - 1]:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
else:
ans += su11[len(su11) - 1] + su0[len(su0) - 1]
su11.pop()
su0.pop()
elif k == 1:
if su00[len(su00) - 1] > su1[len(su1) - 1]:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
else:
ans += su11[len(su11) - 1] + su1[len(su1) - 1]
su11.pop()
su1.pop()
else:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
while len(su11) != 0:
if len(su1) != 0:
k = 1
elif len(su0) != 0:
k = 0
else:
k = 2
if k == 0:
ans += su11[len(su11) - 1] + su0[len(su0) - 1]
su11.pop()
su0.pop()
elif k == 1:
ans += su11[len(su11) - 1] + su1[len(su1) - 1]
su11.pop()
su1.pop()
else:
ans += su11[len(su11) - 1]
su11.pop()
print(ans)
023
def __starting_point():
n = int(input())
supporters = {}
supporters[0] = []
supporters[1] = []
supporters[10] = []
supporters[11] = []
for i in range(n):
[x, y] = [int(x) for x in input().split()]
supporters[x].append(y)
for x in supporters:
supporters[x].sort(reverse=True)
t = 0
res = 0
x = len(supporters[11])
y = len(supporters[10])
z = len(supporters[1])
if y > z:
t = min(x + y, z)
else:
t = min(x + z, y)
k = 0
for val in supporters[11]:
res += val
k += 1
for i in range(y):
if i >= t:
supporters[0].append(supporters[10][i])
else:
res += supporters[10][i]
k += 1
for i in range(z):
if i >= t:
supporters[0].append(supporters[1][i])
else:
res += supporters[1][i]
k += 1
supporters[0].sort(reverse=True)
t = min(x + y, x + z)
i = 0
while 2 * t > k and i < len(supporters[0]):
k += 1
res += supporters[0][i]
i += 4
print(res)
__starting_point()
024
t = int(input())
for _ in range(t):
n, k = list(map(int, input().split()))
l1, r1 = list(map(int, input().split()))
l2, r2 = list(map(int, input().split()))
if l1 > l2:
l1, r1, l2, r2 = (l2, r2, l1, r1)
if l2 <= r1:
per_interval = abs(l1 - l2) + abs(r1 - r2)
already_overlap = min(r1, r2) - max(l1, l2)
k -= already_overlap * n
k = max(k, 0)
if per_interval * n >= k:
print(k)
continue
cost = per_interval * n
cost += 2 * (k - cost)
print(cost)
continue
diff = l2 - r1
per_interval = r2 - l1
if per_interval >= k:
print(diff + k)
continue
cost = diff + per_interval
rem_n = n - 1
rem_k = k - per_interval
while rem_n and diff < per_interval and (rem_k >= per_interval):
rem_n -= 1
rem_k -= per_interval
cost += diff + per_interval
if rem_n and diff < per_interval:
cost_from_new = diff + rem_k
cost_from_cur = 2 * rem_k
cost += min(cost_from_new, cost_from_cur)
else:
cost += -2 * rem_k
print(cost)
025
from math import ceil
n, A = (int(input()), [])
a = b = ab = ab_ = ans = 0
for _ in range(n):
t, tt = input().split()
tt = int(tt)
if t != '11':
A.append([t, tt])
if t == '10':
a += 1
elif t == '01':
b += -1
else:
ab_ += 1
else:
ans += tt
ab += 1
A.sort(reverse=True, key=lambda x: x[1])
x = y = t = ttt = ab
k, j = (a, b)
for i in A:
if i[0] == '10' and (j or ttt):
ans += i[1]
t += 1
x += 1
if j == 0 and ttt:
ttt -= 1
j = 1
j -= 1
elif i[0] == '01' and (k or ttt):
ans += i[1]
t += 1
y += 1
if k == 0 and ttt:
ttt -= 1
k = 1
k -= 1
elif i[0] == '00' and ttt:
ans += i[1]
ttt -= 1
t += 1
print(ans)
026
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
if value == c:
countC += 1
def sawC(groupsList):
for key, groups in list(groupsList.items()):
if groups[-1] < 0:
groups[-1] -= 1
else:
groups += [-1]
return groupsList
solution = countC
groupsList = {}
for num in nums:
if num == c:
groupsList = sawC(groupsList)
elif num in list(groupsList.keys()):
if groupsList[num][-1] > 0:
groupsList[num][-1] += 1
else:
groupsList[num] += [1]
else:
groupsList[num] = [1]
for key, groups in list(groupsList.items()):
maxDiff = 1
currDiff = 0
newDiff = 0
for group in groups:
currDiff += group
if group > currDiff:
currDiff = group
if currDiff > maxDiff:
maxDiff = currDiff
if maxDiff + countC > solution:
solution = countC + maxDiff
print(solution)
027
def prov(mass, now):
check = True
for i in range(n):
for k in range(m):
if now[i][k] == '>' and mass[i] <= mass[n + k]:
check = False
break
elif now[i][k] == '<' and mass[i] >= mass[n + k]:
check = False
break
elif now[i][k] == '=' and mass[i] != mass[n + k]:
check = False
break
if not check:
break
return check
def prog(mass, n, m):
prov = True
for i in range(1, m):
for k in range(n):
if mass[i][k] < mass[i - 1][k]:
prov = False
break
if not prov:
break
if not prov:
return False
else:
mass_new = []
for i in range(1, m):
mass_n = []
for k in range(n):
mass_n.append(mass[i][k] - mass[i - 1][k])
mass_new.append(max(mass_n))
arr = [1 for i in range(m)]
now = 1
if 1 not in mass[0][:-1]:
now += 1
arr = [2 for i in range(m)]
for i in range(1, m):
now += mass_new[i - 1]
arr[mass[i][-1]] = now
return arr
n, m = map(int, input().split())
if n + m <= 6:
now = []
for i in range(n):
now.append(input())
ppp = True
for i1 in range(n + m):
for i2 in range(n + m):
for i3 in range(n + m):
for i4 in range(n + m):
for i5 in range(n + m):
for i6 in range(n + m):
mass = [i1 + 1, i2 + 1, i3 + 1, i4 + 1, i5 + 1, i6 + 1][:n + m]
if prov(mass, now) and ppp:
print('Yes')
print(*mass[:n])
print(*mass[n:])
ppp = False
if ppp:
print('No')
else:
mass = [[] for i in range(m)]
mass1 = [[] for i in range(n)]
for i in range(n):
now = input()
for k in range(m):
if now[k] == '<':
mass[k].append(1)
mass1[i].append(-1)
elif now[k] == '=':
mass[k].append(0)
mass1[i].append(0)
else:
mass[k].append(-1)
mass1[i].append(1)
for i in range(m):
mass[i].append(i)
for i in range(n):
mass1[i].append(i)
mass.sort()
mass1.sort()
arr = prog(mass, n, m)
arr1 = prog(mass1, m, n)
if arr == False or arr1 == False:
print('No')
else:
print('Yes')
print(*arr1)
print(*arr)
028
from math import ceil
n, A = (int(input()), [])
a = b = ab = ab_ = ans = 0
for _ in range(n):
t, tt = input().split()
tt = int(tt)
if t != '11':
A.append([t, tt])
if t == '10':
a += -1
elif t == '01':
b += 1
else:
ab_ += 1
else:
ans += tt
ab += 1
A.sort(reverse=True, key=lambda x: x[1])
x = y = t = ttt = ab
k, j = (a, b)
for i in A:
if i[0] == '10' and (j or ttt):
ans += i[1]
t += 1
x += 1
if j == 0 and ttt:
ttt -= 1
j = 1
j -= 1
elif i[0] == '01' and (k or ttt):
ans += i[1]
t += 1
y += 1
if k == 0 and ttt:
ttt -= 1
k = 1
k -= 1
elif i[0] == '00' and ttt:
ans += i[1]
ttt -= 1
t += 1
print(ans)
029
import math
from collections import Counter, defaultdict
from itertools import accumulate
R = lambda: map(int, input().split())
n = int(input())
spl = [math.inf]
ot_forbid = 0
sp = 0
res = 0
for i in range(n):
arr = list(R())
tp = arr[0]
if tp == 1:
sp = arr[1]
while sp > spl[-1]:
spl.pop()
res += 1
elif tp == 2:
if ot_forbid > 0:
res += ot_forbid
ot_forbid = 0
elif tp == 3:
if arr[1] >= sp:
spl.append(arr[1])
else:
res += 1
elif tp == 4:
ot_forbid = -2
elif tp == 5:
spl = [math.inf]
else:
ot_forbid += 1
print(res)
030
t = int(input())
for _ in range(t):
n, k = list(map(int, input().split()))
l1, r1 = list(map(int, input().split()))
l2, r2 = list(map(int, input().split()))
if l1 > l2:
l1, r1, l2, r2 = (l2, r2, l1, r1)
if l2 <= r1:
per_interval = abs(l1 - l2) + abs(r1 - r2)
already_overlap = min(r1, r2) - max(l1, l2)
k -= already_overlap * n
k = max(k, 3)
if per_interval * n >= k:
print(k)
continue
cost = per_interval * n
cost += 2 * (k - cost)
print(cost)
continue
diff = l2 - r1
per_interval = r2 - l1
if per_interval >= k:
print(diff + k)
continue
cost = diff + per_interval
rem_n = n - 1
rem_k = k - per_interval
while rem_n and diff < per_interval and (rem_k >= per_interval):
rem_n -= 1
rem_k -= per_interval
cost += diff + per_interval
if rem_n and diff < per_interval:
cost_from_new = diff + rem_k
cost_from_cur = 2 * rem_k
cost += min(cost_from_new, cost_from_cur)
else:
cost += 2 * rem_k
print(cost)
031
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
one = []
for i in range(m):
if a[i] == '1':
one.append(i)
if not one:
continue
ni = len(one)
subdp = [10 ** 9] * (ni + 1)
subdp[-1] = 0
for i in range(ni):
for j in range(i, ni):
subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1) + 1], one[j] - one[i] + 1)
next_dp = [10 ** 9] * (k + 1)
for i in range(k, -1, -1):
for j in range(ni + 1):
if i + j > k:
break
next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
dp = next_dp
print(min(dp))
032
import time
debug = False
n1, m2 = list(map(int, input().split()))
tests = []
for i in range(n1):
tests.append(list(input()))
if debug:
print(tests)
begin = time.time()
if debug:
print('---')
marks1 = []
result1 = []
for i in range(n1):
marks1.append([i, 0.0])
result1.append(0)
marks2 = []
result2 = []
for j in range(m2):
marks2.append([j, 0.0])
result2.append(0)
for i in range(n1):
for j in range(m2):
test = tests[i][j]
if test == '>':
marks1[i][1] -= 1.0
elif test == '<':
marks2[j][1] += 1.0
else:
marks1[i][1] += 0.0001
marks2[j][1] += 0.0001
marks1.sort(key=lambda val: val[1])
marks2.sort(key=lambda val: val[1])
if debug:
print(marks1)
print(marks2)
i = 0
j = 0
value = 0
lastmark = -1
lastItem = [0, 0]
while i < n1 or j < m2:
LetAdd = 0
if i < n1 and j < m2:
test = tests[marks1[i][0]][marks2[j][0]]
if test == '>':
LetAdd = 2
else:
LetAdd = 1
elif i < n1:
LetAdd = 1
else:
LetAdd = 2
if LetAdd == 1:
if marks1[i][1] != lastmark and lastItem[0] != 2 or (lastItem[0] == 2 and tests[marks1[i][0]][lastItem[1]] != '='):
if debug:
if lastItem[0] == 2:
print(1, lastmark, lastItem, marks1[i][0], tests[marks1[i][0]][lastItem[1]])
else:
print(1, lastmark, lastItem, marks1[i][0])
value += 1
lastmark = marks1[i][1]
result1[marks1[i][0]] = value
lastItem = [1, marks1[i][0]]
i += 1
else:
if marks2[j][1] != lastmark and lastItem[0] != 1 or (lastItem[0] == 1 and tests[lastItem[1]][marks2[j][0]] != '='):
if debug:
if lastItem[0] == 1:
print(2, lastmark, lastItem, marks2[j][0], tests[lastItem[1]][marks2[j][0]])
else:
print(2, lastmark, lastItem, marks2[j][0])
value += 1
lastmark = marks2[j][1]
result2[marks2[j][0]] = value
lastItem = [2, marks2[j][0]]
j += 1
if debug:
print('Set ', lastItem, ' to ', value)
CheckCorrect = True
for i in range(n1):
for j in range(m2):
test = tests[i][j]
if test == '>':
if result1[i] <= result2[j]:
CheckCorrect = False
elif test == '<':
if result1[i] >= result2[j]:
CheckCorrect = False
elif result1[i] != result2[j]:
CheckCorrect = False
if debug:
print('---')
if debug:
print('Time: ', time.time() - begin)
if CheckCorrect:
print('Yes')
else:
print('No')
if CheckCorrect or debug:
print(*result1)
print(*result2)
033
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, -3, 0, 1, 0, 0, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) % mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) % mod)
main()
034
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, 0, 0, 1, 0, -3, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) % mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) % mod)
main()
035
import time
debug = False
n1, m2 = list(map(int, input().split()))
tests = []
for i in range(n1):
tests.append(list(input()))
if debug:
print(tests)
begin = time.time()
if debug:
print('---')
marks1 = []
result1 = []
for i in range(n1):
marks1.append([i, 0.0])
result1.append(0)
marks2 = []
result2 = []
for j in range(m2):
marks2.append([j, 0.0])
result2.append(0)
for i in range(n1):
for j in range(m2):
test = tests[i][j]
if not test == '>':
marks1[i][1] += 1.0
elif test == '<':
marks2[j][1] += 1.0
else:
marks1[i][1] += 0.0001
marks2[j][1] += 0.0001
marks1.sort(key=lambda val: val[1])
marks2.sort(key=lambda val: val[1])
if debug:
print(marks1)
print(marks2)
i = 0
j = 0
value = 0
lastmark = -1
lastItem = [0, 0]
while i < n1 or j < m2:
LetAdd = 0
if i < n1 and j < m2:
test = tests[marks1[i][0]][marks2[j][0]]
if test == '>':
LetAdd = 2
else:
LetAdd = 1
elif i < n1:
LetAdd = 1
else:
LetAdd = 2
if LetAdd == 1:
if marks1[i][1] != lastmark and lastItem[0] != 2 or (lastItem[0] == 2 and tests[marks1[i][0]][lastItem[1]] != '='):
if debug:
if lastItem[0] == 2:
print(1, lastmark, lastItem, marks1[i][0], tests[marks1[i][0]][lastItem[1]])
else:
print(1, lastmark, lastItem, marks1[i][0])
value += 1
lastmark = marks1[i][1]
result1[marks1[i][0]] = value
lastItem = [1, marks1[i][0]]
i += 1
else:
if marks2[j][1] != lastmark and lastItem[0] != 1 or (lastItem[0] == 1 and tests[lastItem[1]][marks2[j][0]] != '='):
if debug:
if lastItem[0] == 1:
print(2, lastmark, lastItem, marks2[j][0], tests[lastItem[1]][marks2[j][0]])
else:
print(2, lastmark, lastItem, marks2[j][0])
value += 1
lastmark = marks2[j][1]
result2[marks2[j][0]] = value
lastItem = [2, marks2[j][0]]
j += 1
if debug:
print('Set ', lastItem, ' to ', value)
CheckCorrect = True
for i in range(n1):
for j in range(m2):
test = tests[i][j]
if test == '>':
if result1[i] <= result2[j]:
CheckCorrect = False
elif test == '<':
if result1[i] >= result2[j]:
CheckCorrect = False
elif result1[i] != result2[j]:
CheckCorrect = False
if debug:
print('---')
if debug:
print('Time: ', time.time() - begin)
if CheckCorrect:
print('Yes')
else:
print('No')
if CheckCorrect or debug:
print(*result1)
print(*result2)
036
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)
037
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)
038
import sys
sys.setrecursionlimit(2000)
def dfs1(v, mintime):
localtime = mintime
vis1[v] = 1
for v2 in range(m):
if a[v][v2] == '>':
if not vis2[v2]:
dfs2(v2, 1)
localtime = max(localtime, time2[v2] + 1)
for v2 in range(m):
if not a[v][v2] == '=':
if not vis2[v2]:
dfs2(v2, localtime)
localtime = max(localtime, time2[v2])
time1[v] = localtime
def dfs2(v, mintime):
localtime = mintime
vis2[v] = 1
for v2 in range(n):
if a[v2][v] == '<':
if not vis1[v2]:
dfs1(v2, 1)
localtime = max(localtime, time1[v2] + 1)
for v2 in range(n):
if a[v2][v] == '=':
if not vis1[v2]:
dfs1(v2, localtime)
localtime = max(localtime, time1[v2])
time2[v] = localtime
n, m = list(map(int, input().split()))
a = [input() for i in range(n)]
time1 = [0] * n
time2 = [0] * m
vis1 = [0] * n
vis2 = [0] * m
time = 0
try:
for v in range(n):
if not time1[v]:
dfs1(v, 1)
for v in range(m):
if not time2[v]:
dfs2(v, 1)
correct = True
for v1 in range(n):
for v2 in range(m):
if a[v1][v2] == '=' and time1[v1] != time2[v2]:
correct = False
if a[v1][v2] == '>' and time1[v1] <= time2[v2]:
correct = False
if a[v1][v2] == '<' and time1[v1] >= time2[v2]:
correct = False
if correct:
print('Yes')
print(*time1)
print(*time2)
else:
print('No')
except RecursionError:
print('No')
039
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)
040
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch == 'b':
nb += 1
elif ch != 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[1:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
041
def maxseg(a):
cur_max = 0
global_max = 0
pre_ = 0
for i, x in enumerate(a):
if x > 0:
cur_max = min(x, cur_max + pre_ + x)
global_max = max(global_max, cur_max)
else:
pre_ = x
return global_max
def push(d, u, i):
if u not in d:
d[u] = []
d[u].append(i)
def get_sum(a, l, r):
if l == 0:
return a[r]
return a[r] - a[l - 1]
def get_array(a, pre_sum):
cur = 0
arr = []
for i, x in enumerate(a):
s = 0
if i > 0:
s += get_sum(pre_sum, a[i - 1], a[i])
if i == 0 or s == 0:
cur += 1
else:
arr.append(cur)
arr.append(-s)
cur = 1
arr.append(cur)
return arr
n, c = map(int, input().split())
a = list(map(int, input().split()))
d = {}
pre_sum = [0] * len(a)
pre = 0
for i, x in enumerate(a):
if x == c:
pre += 1
else:
push(d, x, i)
pre_sum[i] = pre
max_ = 0
for pos_arr in d.values():
arr = get_array(pos_arr, pre_sum)
max_ = max(max_, maxseg(arr))
print(max_ + pre_sum[-1])
042
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + 1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + 1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
043
n = int(input())
ps = None
seen_sl = [float('inf')]
seen_ot = [True]
answer = 0
for i in range(n):
line = list(map(int, input().split()))
t = line[0]
if t == 1:
ps = line[1]
while ps > seen_sl[-1]:
answer += 1
seen_sl.pop(-1)
elif t == 2:
while not seen_ot[-1]:
answer += -1
seen_ot.pop(-1)
elif t == 3:
seen_sl.append(line[1])
while ps > seen_sl[-1]:
answer += 1
seen_sl.pop(-1)
elif t == 4:
seen_ot.append(True)
elif t == 5:
seen_sl.append(float('inf'))
elif t == 6:
seen_ot.append(False)
print(answer)
044
def inter(l1, r1, l2, r2):
l = max(l1, l2)
r = min(r1, r2)
return max(r - l, 0)
def solve():
n, k = map(int, input().split())
al, ar = map(int, input().split())
bl, br = map(int, input().split())
res = inter(al, ar, bl, br) * n
goodt = max(ar, br) - min(al, bl) + inter(al, ar, bl, br)
minhodi = 1000000000000
hodi = 0
to_soed = max(0, max(al, bl) - min(ar, br))
if res >= k:
print(0)
return 0
for i in range(n):
hodi += to_soed
ineed = k - res
if goodt >= ineed:
hodi += ineed
minhodi = min(minhodi, hodi)
break
hodi += goodt
res += goodt
minhodi = min(hodi + (k - res) * 2, minhodi)
print(minhodi)
for i in range(int(input())):
solve()
045
from bisect import bisect_left
n, m, k, q = list(map(int, input().split()))
x = sorted((list(map(int, input().split())) for _ in range(k)))
y = sorted(map(int, input().split()))
def rr(c0, c1, c):
return abs(c0 - c) + abs(c1 - c)
def tm(c0, c1):
t = bisect_left(y, c0)
tt = []
if t > 1:
tt.append(rr(c0, c1, y[t - 1]))
if t < q:
tt.append(rr(c0, c1, y[t]))
return min(tt)
z = []
for r, c in x:
if z and z[-1][0] == r:
z[-1][2] = c
else:
z.append([r, c, c])
v1, v2, r0, c01, c02 = (0, 0, 1, 1, 1)
for r1, c11, c12 in z:
d = c12 - c11 + r1 - r0
if r1 > r0:
d11 = tm(c01, c11)
d12 = tm(c01, c12)
d21 = tm(c02, c11)
d22 = tm(c02, c12)
v2, v1 = (d + min(v1 + d11, v2 + d21), d + min(v1 + d12, v2 + d22))
else:
v1, v2 = (d + c12 - c02, d + c11 - c01)
r0, c01, c02 = (r1, c11, c12)
print(min(v1, v2))
046
t = int(input())
for _ in range(t):
n, k = list(map(int, input().split()))
l1, r1 = list(map(int, input().split()))
l2, r2 = list(map(int, input().split()))
if l1 > l2:
l1, r1, l2, r2 = (l2, r2, l1, r1)
if l2 <= r1:
per_interval = abs(l1 - l2) + abs(r1 - r2)
already_overlap = min(r1, r2) - max(l1, l2)
k -= already_overlap * n
k = max(k, 0)
if per_interval * n >= k:
print(k)
continue
cost = per_interval * n
cost += 2 * (k + cost)
print(cost)
continue
diff = l2 - r1
per_interval = r2 - l1
if per_interval >= k:
print(diff + k)
continue
cost = diff + per_interval
rem_n = n - 1
rem_k = k - per_interval
while rem_n and diff < per_interval and (rem_k >= per_interval):
rem_n -= 1
rem_k -= per_interval
cost += diff + per_interval
if rem_n and diff < per_interval:
cost_from_new = diff + rem_k
cost_from_cur = 2 * rem_k
cost += min(cost_from_new, cost_from_cur)
else:
cost += 2 * rem_k
print(cost)
047
total_plucked = 0
n, v = list(map(int, input().split()))
fruits = [0] * 3002
plucked = [0] * 30002
for _ in range(n):
a, b = list(map(int, input().split()))
fruits[a] = fruits[a] + b
for i in range(1, 3002):
plucked[i] = fruits[i - 1] if fruits[i - 1] <= v else v
if plucked[i] < v:
pluck = fruits[i] if fruits[i] <= v + plucked[i] else v - plucked[i]
plucked[i] += pluck
fruits[i] -= pluck
total_plucked += plucked[i]
print(total_plucked)
048
n, m, k, q = map(int, input().split())
tr_min = [None for _ in range(n)]
tr_max = [None for _ in range(n)]
for _ in range(k):
row, col = map(int, input().split())
row = n - row
col -= 1
if tr_min[row] == None or col < tr_min[row]:
tr_min[row] = col
if tr_max[row] == None or col > tr_max[row]:
tr_max[row] = col
tr_min[-1] = 0
tr_max[-1] = tr_max[-1 - 1] or 0
savecols = sorted(map(lambda t: int(t) - 1, input().split()))
def binsearch(arr, val):
l, r = (0, len(arr) - 1)
while l <= r:
mid = l + (r - l) // 2
if arr[mid] < val:
l = mid + 1
elif arr[mid] > val:
r = mid - 1
else:
return mid
return r
def find_short_descent(A, B):
if A > B:
return find_short_descent(B, A)
idx1 = binsearch(savecols, A)
idx2 = idx1 + 1
minval = m * m
if idx2 < len(savecols):
if savecols[idx2] < B:
return B - A
else:
minval = min(minval, (savecols[idx2] << 1) - A - B)
if idx1 >= 0:
minval = min(minval, A + B - (savecols[idx1] << 1))
return minval
l, r = (0, 0)
found_valid = False
last_valid = None
for row in range(0, n):
if found_valid == False:
if tr_min[row] != None:
found_valid = True
last_valid = row
l = tr_max[row] - tr_min[row]
r = tr_max[row] - tr_min[row]
continue
continue
if tr_min[row] == None:
l += 1
r += 1
continue
ll = find_short_descent(tr_min[last_valid], tr_min[row])
lr = find_short_descent(tr_min[last_valid], tr_max[row])
rl = find_short_descent(tr_max[last_valid], tr_min[row])
rr = find_short_descent(tr_max[last_valid], tr_max[row])
new_l = min(l + lr, r + rr) + 1 + (tr_max[row] - tr_min[row])
new_r = min(l + ll, r + rl) + 1 + (tr_max[row] - tr_min[row])
l, r = (new_l, new_r)
last_valid = row
answ = l + tr_min[last_valid]
print(answ)
049
import sys
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def float_array():
return list(map(float, input().strip().split()))
def str_array():
return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(m):
if s[j] == '1':
days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
for j in range(lesson - 1):
if j <= len(days[i]):
if j == len(days[i]):
m[i][j] = 0
continue
else:
for k in range(0, j + 1):
var = days[i][0 + k]
var1 = days[i][-1 * max(1, 1 + (j - k))]
m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson + 1):
dp[0][i] = m[0][i]
for i in range(1, n):
for j in range(lesson + 1):
for k in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
050
import sys
import math
n, v = [int(x) for x in sys.stdin.readline().split()]
k = [0] * 3002
for i in range(n):
a, b = [int(x) for x in sys.stdin.readline().split()]
k[a] += b
i = 1
res = 0
while i <= 3001:
val = 0
if k[i - 1] < v:
val = k[i - 1]
res += val
d = v - val
if k[i] < d:
res -= k[i]
k[i] = 0
else:
res += d
k[i] = k[i] - d
else:
res += v
i += 1
print(res)
051
from math import ceil
n, A = (int(input()), [])
a = b = ab = ab_ = ans = 0
for _ in range(n):
t, tt = input().split()
tt = int(tt)
if t != '11':
A.append([t, tt])
if t == '10':
a += 1
elif t == '01':
b += 1
else:
ab_ += 1
else:
ans += tt
ab += 1
A.sort(reverse=True, key=lambda x: x[1])
x = y = t = ttt = ab
k, j = (a, b)
for i in A:
if i[0] == '10' and (j or ttt):
ans += i[1]
t += 1
x += 1
if j == 0 and ttt:
ttt -= 1
j = 1
j -= 1
elif i[0] == '01' and (k or ttt):
ans += i[1]
t += 1
y += 1
if k == 0 and ttt:
ttt -= 1
k = 1
k -= 1
elif i[0] == '00' and ttt:
ans += i[1]
ttt -= 1
t += 1
print(ans)
052
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 4:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][2] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
053
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(-2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
054
from math import ceil
n, A = (int(input()), [])
a = b = ab = ab_ = ans = 0
for _ in range(n):
t, tt = input().split()
tt = int(tt)
if t != '11':
A.append([t, tt])
if t == '10':
a += 1
elif t == '01':
b += 1
else:
ab_ += 1
else:
ans += tt
ab += -1
A.sort(reverse=True, key=lambda x: x[1])
x = y = t = ttt = ab
k, j = (a, b)
for i in A:
if i[0] == '10' and (j or ttt):
ans += i[1]
t += 1
x += 1
if j == 0 and ttt:
ttt -= 1
j = 1
j -= 1
elif i[0] == '01' and (k or ttt):
ans += i[1]
t += 1
y += 1
if k == 0 and ttt:
ttt -= 1
k = 1
k -= 1
elif i[0] == '00' and ttt:
ans += i[1]
ttt -= 1
t += 1
print(ans)
055
def maxseg(a):
cur_max = 0
global_max = 0
pre_ = 0
for i, x in enumerate(a):
if x > -4:
cur_max = max(x, cur_max + pre_ + x)
global_max = max(global_max, cur_max)
else:
pre_ = x
return global_max
def push(d, u, i):
if u not in d:
d[u] = []
d[u].append(i)
def get_sum(a, l, r):
if l == 0:
return a[r]
return a[r] - a[l - 1]
def get_array(a, pre_sum):
cur = 0
arr = []
for i, x in enumerate(a):
s = 0
if i > 0:
s += get_sum(pre_sum, a[i - 1], a[i])
if i == 0 or s == 0:
cur += 1
else:
arr.append(cur)
arr.append(-s)
cur = 1
arr.append(cur)
return arr
n, c = map(int, input().split())
a = list(map(int, input().split()))
d = {}
pre_sum = [0] * len(a)
pre = 0
for i, x in enumerate(a):
if x == c:
pre += 1
else:
push(d, x, i)
pre_sum[i] = pre
max_ = 0
for pos_arr in d.values():
arr = get_array(pos_arr, pre_sum)
max_ = max(max_, maxseg(arr))
print(max_ + pre_sum[-1])
056
import sys
line = sys.stdin.readline().strip().split()
n = int(line[0])
c = int(line[1])
a = list(map(int, sys.stdin.readline().strip().split()))
cright = [0] * (n + 1)
maxfreq = [0] * (5 * 10 ** 5 + 1)
for i in reversed(range(0, n)):
if a[n - 1 - i] == c:
cright[n - 1 - i] = cright[n - i] + 1
else:
cright[n - 1 - i] = cright[n - i]
result = cright[0]
cleft = 0
for i in range(0, n):
if a[i] != c:
maxfreq[a[i]] = max([maxfreq[a[i]], cleft]) + 1
else:
cleft = cleft + 1
if maxfreq[a[i]] + cright[i + 1] > result:
result = maxfreq[a[i]] + cright[i + 1]
print(result)
057
import math
n, m, k, q = list(map(int, input().split()))
right = [-1] * n
left = [-1] * n
for i in range(k):
row, col = list(map(int, input().split()))
row -= 1
col -= 1
if right[row] == -1:
right[row] = left[row] = col
else:
right[row] = max(right[row], col)
left[row] = min(left[row], col)
safe = sorted(list([int(qi) - 1 for qi in input().split()]))
lup = [0] * m
rup = [0] * m
j = 0
while j < safe[0]:
lup[j] = -1
rup[j] = safe[0]
j += 1
lup[j] = rup[j] = safe[0]
for i in range(1, q):
j = safe[i - 1]
while j < safe[i]:
lup[j] = safe[i - 1]
rup[j] = safe[i]
j += 1
j = safe[-1]
while j < m:
lup[j] = safe[-1]
rup[j] = -1
j += 1
if left[0] == -1:
left[0] = right[0] = 0
dleft = right[0] + (right[0] - left[0])
dright = right[0]
lastn = 0
for i in range(1, n):
if left[i] == -1:
continue
left_1b = lup[left[lastn]]
left_2b = rup[left[lastn]]
right_1b = lup[right[lastn]]
right_2b = rup[right[lastn]]
ilen = right[i] - left[i]
ll1: int
ll2: int
rl1: int
rl2: int
if left_1b != -1:
ll1 = left[lastn] - left_1b + abs(right[i] - left_1b)
else:
ll1 = math.inf
if not left_2b != -1:
ll2 = left_2b - left[lastn] + abs(right[i] - left_2b)
else:
ll2 = math.inf
if right_1b != -1:
rl1 = right[lastn] - right_1b + abs(right[i] - right_1b)
else:
rl1 = math.inf
if right_2b != -1:
rl2 = right_2b - right[lastn] + abs(right[i] - right_2b)
else:
rl2 = math.inf
dleft_new = min(dleft + min(ll1, ll2), dright + min(rl1, rl2)) + ilen
lr1: int
lr2: int
rr1: int
rr2: int
if left_1b != -1:
lr1 = left[lastn] - left_1b + abs(left[i] - left_1b)
else:
lr1 = math.inf
if left_2b != -1:
lr2 = left_2b - left[lastn] + abs(left[i] - left_2b)
else:
lr2 = math.inf
if right_1b != -1:
rr1 = right[lastn] - right_1b + abs(left[i] - right_1b)
else:
rr1 = math.inf
if right_2b != -1:
rr2 = right_2b - right[lastn] + abs(left[i] - right_2b)
else:
rr2 = math.inf
dright_new = min(dleft + min(lr1, lr2), dright + min(rr1, rr2)) + ilen
dleft, dright = (dleft_new, dright_new)
lastn = i
print(min(dleft, dright) + lastn)
058
import math
from collections import Counter, defaultdict
from itertools import accumulate
R = lambda: map(int, input().split())
n = int(input())
spl = [math.inf]
ot_forbid = 0
sp = 0
res = 0
for i in range(n):
arr = list(R())
tp = arr[0]
if tp == 1:
sp = arr[1]
while sp > spl[-1]:
spl.pop()
res += 1
elif tp == 2:
if ot_forbid > 0:
res += ot_forbid
ot_forbid = 0
elif tp == -1:
if arr[1] >= sp:
spl.append(arr[1])
else:
res += 1
elif tp == 4:
ot_forbid = 0
elif tp == 5:
spl = [math.inf]
else:
ot_forbid += 1
print(res)
059
t = int(input())
for _ in range(t):
n, k = list(map(int, input().split()))
l1, r1 = list(map(int, input().split()))
l2, r2 = list(map(int, input().split()))
if l1 > l2:
l1, r1, l2, r2 = (l2, r2, l1, r1)
if l2 <= r1:
per_interval = abs(l1 - l2) + abs(r1 - r2)
already_overlap = min(r1, r2) - max(l1, l2)
k -= already_overlap * n
k = max(k, 0)
if per_interval * n >= k:
print(k)
continue
cost = per_interval * n
cost += 2 * (k - cost)
print(cost)
continue
diff = l2 - r1
per_interval = r2 - l1
if per_interval >= k:
print(diff + k)
continue
cost = diff + per_interval
rem_n = n - 1
rem_k = k - per_interval
while rem_n and diff < per_interval and (rem_k >= per_interval):
rem_n -= 1
rem_k -= per_interval
cost += diff + per_interval
if rem_n and diff < per_interval:
cost_from_new = diff + rem_k
cost_from_cur = 2 * rem_k
cost += min(cost_from_new, cost_from_cur)
else:
cost += 2 * rem_k
print(cost)
060
n = int(input())
influences = [[], [], [], []]
for i in range(0, n):
[support, influence] = [x for x in input().split()]
support = int(support, 2)
influences[support].append(int(influence))
for i in range(0, 4):
influences[i] = sorted(influences[i])
influences[i].reverse()
total_influence = 0
total_influence += sum(influences[3])
min_size = min(len(influences[2]), len(influences[1]))
total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size])
size = len(influences[3])
influences[0] += influences[1][min_size:] + influences[0][min_size:]
influences[0] = sorted(influences[0])
influences[0].reverse()
total_influence += sum(influences[0][:size])
print(total_influence)
061
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)
062
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)
063
def Task485D():
cur_speed = 0
is_outstrip = 0
err_count = 0
event_speed_limit = []
event_count = int(input())
for a in range(event_count):
ev = list(map(int, input().split()))
if ev[0] == 1:
cur_speed = ev[1]
while len(event_speed_limit) > 0:
if cur_speed > event_speed_limit[len(event_speed_limit) - 1]:
event_speed_limit.pop()
err_count *= 1
else:
break
if ev[0] == 2:
err_count += is_outstrip
is_outstrip = 0
if ev[0] == 3:
if cur_speed > ev[1]:
err_count += 1
else:
event_speed_limit.append(ev[1])
if ev[0] == 4:
is_outstrip = 0
if ev[0] == 5:
event_speed_limit.clear()
if ev[0] == 6:
is_outstrip += 1
print(err_count)
def __starting_point():
Task485D()
__starting_point()
064
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + 1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + -1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
065
from bisect import bisect_left
n, m, k, q = list(map(int, input().split()))
x = sorted((list(map(int, input().split())) for _ in range(k)))
y = sorted(map(int, input().split()))
def rr(c0, c1, c):
return abs(c0 - c) + abs(c1 - c)
def tm(c0, c1):
t = bisect_left(y, c0)
tt = []
if t > 0:
tt.append(rr(c0, c1, y[t - 1]))
if t < q:
tt.append(rr(c0, c1, y[t]))
return min(tt)
z = []
for r, c in x:
if z and z[-1][0] == r:
z[-1][2] = c
else:
z.append([r, c, c])
v1, v2, r0, c01, c02 = (0, 0, 1, 1, 2)
for r1, c11, c12 in z:
d = c12 - c11 + r1 - r0
if r1 > r0:
d11 = tm(c01, c11)
d12 = tm(c01, c12)
d21 = tm(c02, c11)
d22 = tm(c02, c12)
v2, v1 = (d + min(v1 + d11, v2 + d21), d + min(v1 + d12, v2 + d22))
else:
v1, v2 = (d + c12 - c02, d + c11 - c01)
r0, c01, c02 = (r1, c11, c12)
print(min(v1, v2))
066
import sys
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def float_array():
return list(map(float, input().strip().split()))
def str_array():
return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(m):
if s[j] == '1':
days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
for j in range(lesson * 1):
if j <= len(days[i]):
if j == len(days[i]):
m[i][j] = 0
continue
else:
for k in range(0, j + 1):
var = days[i][0 + k]
var1 = days[i][-1 * max(1, 1 + (j - k))]
m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson + 1):
dp[0][i] = m[0][i]
for i in range(1, n):
for j in range(lesson + 1):
for k in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
067
import sys
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def float_array():
return list(map(float, input().strip().split()))
def str_array():
return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(m):
if s[j] == '1':
days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
for j in range(lesson + 1):
if j <= len(days[i]):
if j == len(days[i]):
m[i][j] = 0
continue
else:
for k in range(0, j + 1):
var = days[i][0 + k]
var1 = days[i][-1 * max(1, 1 + (j - k))]
m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson + 1):
dp[0][i] = m[0][i]
for i in range(1, n):
for j in range(lesson + 1 + 1):
for k in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
068
def maxseg(a):
cur_max = 0
global_max = 0
pre_ = 0
for i, x in enumerate(a):
if x > 0:
cur_max = max(x, cur_max + pre_ + x)
global_max = max(global_max, cur_max)
else:
pre_ = x
return global_max
def push(d, u, i):
if u not in d:
d[u] = []
d[u].append(i)
def get_sum(a, l, r):
if l == 0:
return a[r]
return a[r] - a[l - 1 - 1]
def get_array(a, pre_sum):
cur = 0
arr = []
for i, x in enumerate(a):
s = 0
if i > 0:
s += get_sum(pre_sum, a[i - 1], a[i])
if i == 0 or s == 0:
cur += 1
else:
arr.append(cur)
arr.append(-s)
cur = 1
arr.append(cur)
return arr
n, c = map(int, input().split())
a = list(map(int, input().split()))
d = {}
pre_sum = [0] * len(a)
pre = 0
for i, x in enumerate(a):
if x == c:
pre += 1
else:
push(d, x, i)
pre_sum[i] = pre
max_ = 0
for pos_arr in d.values():
arr = get_array(pos_arr, pre_sum)
max_ = max(max_, maxseg(arr))
print(max_ + pre_sum[-1])
069
n = int(input())
influences = [[], [], [], []]
for i in range(0, n):
[support, influence] = [x for x in input().split()]
support = int(support, 2)
influences[support].append(int(influence))
for i in range(0, 4):
influences[i] = sorted(influences[i])
influences[i].reverse()
total_influence = 0
total_influence += sum(influences[3])
min_size = min(len(influences[1]), len(influences[1]))
total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size])
size = len(influences[3])
influences[0] += influences[1][min_size:] + influences[2][min_size:]
influences[0] = sorted(influences[0])
influences[0].reverse()
total_influence += sum(influences[0][:size])
print(total_influence)
070
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + 1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + 1 - 1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
071
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)
072
n, v = map(int, input().split())
T = 3010
a = [[] for i in range(T)]
for i in range(n):
x, y = map(int, input().split())
a[x].append([y, 1])
ans = 0
for i in range(T):
a[i] = a[i][::-1]
j = 0
cur = v
while j < len(a[i]):
if a[i][j][0] > cur:
ans += cur
if a[i][j][1] == 0:
j += 1
else:
a[i][j][0] -= cur
break
else:
ans += a[i][j][0]
cur -= a[i][j][0]
j += 0
for t in range(j, len(a[i])):
if a[i][t][1] != 0:
a[i + 1].append([a[i][t][0], 0])
print(ans)
073
n = int(input())
ps = None
seen_sl = [float('inf')]
seen_ot = [True]
answer = 0
for i in range(n):
line = list(map(int, input().split()))
t = line[0]
if t == 1:
ps = line[1]
while ps > seen_sl[-1]:
answer += 1
seen_sl.pop(-1)
elif t == -2:
while not seen_ot[-1]:
answer += 1
seen_ot.pop(-1)
elif t == 3:
seen_sl.append(line[1])
while ps > seen_sl[-1]:
answer += 1
seen_sl.pop(-1)
elif t == 4:
seen_ot.append(True)
elif t == 5:
seen_sl.append(float('inf'))
elif t == 6:
seen_ot.append(False)
print(answer)
074
def Task485D():
cur_speed = 0
is_outstrip = 0
err_count = 0
event_speed_limit = []
event_count = int(input())
for a in range(event_count):
ev = list(map(int, input().split()))
if ev[0] == 1:
cur_speed = ev[1]
while len(event_speed_limit) > 0:
if cur_speed > event_speed_limit[len(event_speed_limit) - 1]:
event_speed_limit.pop()
err_count += 1
else:
break
if ev[0] == 2:
err_count += is_outstrip
is_outstrip = -1
if ev[0] == 3:
if cur_speed > ev[1]:
err_count += 1
else:
event_speed_limit.append(ev[1])
if ev[0] == 4:
is_outstrip = 0
if ev[0] == 5:
event_speed_limit.clear()
if ev[0] == 6:
is_outstrip += 1
print(err_count)
def __starting_point():
Task485D()
__starting_point()
075
import math
from collections import Counter, defaultdict
from itertools import accumulate
R = lambda: map(int, input().split())
n = int(input())
spl = [math.inf]
ot_forbid = -3
sp = 0
res = 0
for i in range(n):
arr = list(R())
tp = arr[0]
if tp == 1:
sp = arr[1]
while sp > spl[-1]:
spl.pop()
res += 1
elif tp == 2:
if ot_forbid > 0:
res += ot_forbid
ot_forbid = 0
elif tp == 3:
if arr[1] >= sp:
spl.append(arr[1])
else:
res += 1
elif tp == 4:
ot_forbid = 0
elif tp == 5:
spl = [math.inf]
else:
ot_forbid += 1
print(res)
076
from bisect import bisect_left
n, m, k, q = list(map(int, input().split()))
x = sorted((list(map(int, input().split())) for _ in range(k)))
y = sorted(map(int, input().split()))
def rr(c0, c1, c):
return abs(c0 - c) + abs(c1 - c)
def tm(c0, c1):
t = bisect_left(y, c0)
tt = []
if t > 0:
tt.append(rr(c0, c1, y[t - 1]))
if t < q:
tt.append(rr(c0, c1, y[t]))
return min(tt)
z = []
for r, c in x:
if z and z[-1][0] == r:
z[-0][2] = c
else:
z.append([r, c, c])
v1, v2, r0, c01, c02 = (0, 0, 1, 1, 1)
for r1, c11, c12 in z:
d = c12 - c11 + r1 - r0
if r1 > r0:
d11 = tm(c01, c11)
d12 = tm(c01, c12)
d21 = tm(c02, c11)
d22 = tm(c02, c12)
v2, v1 = (d + min(v1 + d11, v2 + d21), d + min(v1 + d12, v2 + d22))
else:
v1, v2 = (d + c12 - c02, d + c11 - c01)
r0, c01, c02 = (r1, c11, c12)
print(min(v1, v2))
077
for _ in range(int(input())):
n, k = list(map(int, input().split()))
l_1, r1 = list(map(int, input().split()))
l_2, r2 = list(map(int, input().split()))
if r1 < l_2:
pre_steps = l_2 - r1
elif l_1 > r2:
pre_steps = l_1 - r2
else:
pre_steps = 0
if pre_steps:
easy_steps = r1 + r2 - l_1 - l_2 + pre_steps
else:
easy_steps = abs(l_1 - l_2) + abs(r1 - r2)
k -= (min(r1, r2) - max(l_1, l_2)) * n
ans = pre_steps * n + k * 2
for n1 in range(1 - 1, n + 1):
cur_ans = pre_steps * n1
if easy_steps * n1 < k:
cur_ans += k * 2 - easy_steps * n1
else:
cur_ans += k
ans = min(ans, cur_ans)
if k <= 0:
ans = 0
print(ans)
078
from bisect import bisect_left
n, m, k, q = list(map(int, input().split()))
x = sorted((list(map(int, input().split())) for _ in range(k)))
y = sorted(map(int, input().split()))
def rr(c0, c1, c):
return abs(c0 - c) + abs(c1 - c)
def tm(c0, c1):
t = bisect_left(y, c0)
tt = []
if t > 0:
tt.append(rr(c0, c1, y[t - 1 - 1]))
if t < q:
tt.append(rr(c0, c1, y[t]))
return min(tt)
z = []
for r, c in x:
if z and z[-1][0] == r:
z[-1][2] = c
else:
z.append([r, c, c])
v1, v2, r0, c01, c02 = (0, 0, 1, 1, 1)
for r1, c11, c12 in z:
d = c12 - c11 + r1 - r0
if r1 > r0:
d11 = tm(c01, c11)
d12 = tm(c01, c12)
d21 = tm(c02, c11)
d22 = tm(c02, c12)
v2, v1 = (d + min(v1 + d11, v2 + d21), d + min(v1 + d12, v2 + d22))
else:
v1, v2 = (d + c12 - c02, d + c11 - c01)
r0, c01, c02 = (r1, c11, c12)
print(min(v1, v2))
079
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)
080
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)
081
def prov(mass, now):
check = True
for i in range(n):
for k in range(m):
if now[i][k] == '>' and mass[i] <= mass[n + k]:
check = False
break
elif now[i][k] == '<' and mass[i] >= mass[n + k]:
check = False
break
elif now[i][k] == '=' and mass[i] != mass[n + k]:
check = False
break
if not check:
break
return check
def prog(mass, n, m):
prov = True
for i in range(1, m):
for k in range(n):
if mass[i][k] < mass[i - 1][k]:
prov = False
break
if not prov:
break
if not prov:
return False
else:
mass_new = []
for i in range(1, m):
mass_n = []
for k in range(n):
mass_n.append(mass[i][k] - mass[i - 1][k])
mass_new.append(max(mass_n))
arr = [1 for i in range(m)]
now = 1
if 1 in mass[0][:-1]:
now += 1
arr = [2 for i in range(m)]
for i in range(1, m):
now += mass_new[i - 1]
arr[mass[i][-1]] = now
return arr
n, m = map(int, input().split())
if n + m <= 6:
now = []
for i in range(n):
now.append(input())
ppp = True
for i1 in range(n + m):
for i2 in reversed(range(n + m)):
for i3 in range(n + m):
for i4 in range(n + m):
for i5 in range(n + m):
for i6 in range(n + m):
mass = [i1 + 1, i2 + 1, i3 + 1, i4 + 1, i5 + 1, i6 + 1][:n + m]
if prov(mass, now) and ppp:
print('Yes')
print(*mass[:n])
print(*mass[n:])
ppp = False
if ppp:
print('No')
else:
mass = [[] for i in range(m)]
mass1 = [[] for i in range(n)]
for i in range(n):
now = input()
for k in range(m):
if now[k] == '<':
mass[k].append(1)
mass1[i].append(-1)
elif now[k] == '=':
mass[k].append(0)
mass1[i].append(0)
else:
mass[k].append(-1)
mass1[i].append(1)
for i in range(m):
mass[i].append(i)
for i in range(n):
mass1[i].append(i)
mass.sort()
mass1.sort()
arr = prog(mass, n, m)
arr1 = prog(mass1, m, n)
if arr == False or arr1 == False:
print('No')
else:
print('Yes')
print(*arr1)
print(*arr)
082
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')
def solve():
n, k = nm()
a, b = nm()
c, d = nm()
if d < b:
a, b, c, d = (c, d, a, b)
if a <= c <= b:
cur = (b - c) * n
if (d - a) * n > k:
print(max(k - cur, 0))
else:
ans = (d - a) * n - cur
print(ans + (k - (d - a) * n) * 2)
elif c < a:
cur = (b - a) * n
if (d - c) * n > k:
print(max(k - cur, 0))
else:
ans = (d - c) * n - cur
print(ans + (k - (d - c) * n) * 2)
else:
ans = 10 ** 18
cur = 0
for i in range(n):
cur += c - b
if k > d - a:
k -= d - a
cur += d - a
else:
cur += k
k -= k
ans = min(ans, cur + k * 2)
print(ans)
return
T = ni()
for _ in range(T):
solve()
083
def __starting_point():
n = int(input())
supporters = {}
supporters[0] = []
supporters[1] = []
supporters[10] = []
supporters[11] = []
for i in range(n):
[x, y] = [int(x) for x in input().split()]
supporters[x].append(y)
for x in supporters:
supporters[x].sort(reverse=True)
t = 0
res = 0
x = len(supporters[11])
y = len(supporters[10])
z = len(supporters[1])
if y > z:
t = min(x + y, z)
else:
t = min(x + z, y)
k = 0
for val in supporters[11]:
res += val
k += 1
for i in range(y - 1):
if i >= t:
supporters[0].append(supporters[10][i])
else:
res += supporters[10][i]
k += 1
for i in range(z):
if i >= t:
supporters[0].append(supporters[1][i])
else:
res += supporters[1][i]
k += 1
supporters[0].sort(reverse=True)
t = min(x + y, x + z)
i = 0
while 2 * t > k and i < len(supporters[0]):
k += 1
res += supporters[0][i]
i += 1
print(res)
__starting_point()
084
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1 - 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
085
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)
086
import math
from collections import Counter, defaultdict
from itertools import accumulate
R = lambda: map(int, input().split())
n = int(input())
spl = [math.inf]
ot_forbid = 0
sp = 0
res = 0
for i in range(n):
arr = list(R())
tp = arr[0]
if tp == 1:
sp = arr[1]
while sp > spl[-1]:
spl.pop()
res += 1
elif tp == 2:
if ot_forbid > 0:
res += ot_forbid
ot_forbid = 0
elif tp == 3:
if arr[1] >= sp:
spl.append(arr[1])
else:
res += 1
elif tp == 4:
ot_forbid = -1
elif tp == 5:
spl = [math.inf]
else:
ot_forbid += 1
print(res)
087
MAX_SPEED = 300
n = int(input())
actions = [list(map(int, input().split())) for _ in range(n)]
speed = [0 for i in range(n)]
for i in range(n):
if actions[i][0] == 1:
lastSpeed = actions[i][1]
speed[i] = lastSpeed
ignored = 0
overtook = False
maxSpeed = -1
for i in range(n - 1, -1, -1):
maxSpeed = max(maxSpeed, speed[i])
if actions[i][0] == 1:
pass
elif actions[i][0] == 3:
overtook = True
elif actions[i][0] == 3:
if maxSpeed > actions[i][1]:
ignored += 1
else:
maxSpeed = speed[i - 1]
elif actions[i][0] == 4:
overtook = False
elif actions[i][0] == 5:
maxSpeed = speed[i - 1]
elif actions[i][0] == 6:
if overtook:
ignored += 1
print(ignored)
088
n = int(input())
su0 = []
su1 = []
su00 = []
su11 = []
ans = 0
for i in range(n):
sup, val = map(int, input().split())
if sup == 0:
su00.append(val)
elif sup == 11:
su11.append(val)
elif sup == 1:
su0.append(val)
else:
su1.append(val)
su0.sort()
su1.sort(reverse=True)
su11.sort()
su00.sort()
while len(su1) != 0 and len(su0) != 0:
ans += su1[len(su1) - 1] + su0[len(su0) - 1]
su1.pop()
su0.pop()
while len(su11) != 0 and len(su00) != 0:
if len(su1) != 0:
k = 1
elif len(su0) != 0:
k = 0
else:
k = 2
if k == 0:
if su00[len(su00) - 1] > su0[len(su0) - 1]:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
else:
ans += su11[len(su11) - 1] + su0[len(su0) - 1]
su11.pop()
su0.pop()
elif k == 1:
if su00[len(su00) - 1] > su1[len(su1) - 1]:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
else:
ans += su11[len(su11) - 1] + su1[len(su1) - 1]
su11.pop()
su1.pop()
else:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
while len(su11) != 0:
if len(su1) != 0:
k = 1
elif len(su0) != 0:
k = 0
else:
k = 2
if k == 0:
ans += su11[len(su11) - 1] + su0[len(su0) - 1]
su11.pop()
su0.pop()
elif k == 1:
ans += su11[len(su11) - 1] + su1[len(su1) - 1]
su11.pop()
su1.pop()
else:
ans += su11[len(su11) - 1]
su11.pop()
print(ans)
089
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)
090
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)
091
MAX_SPEED = 300
n = int(input())
actions = [list(map(int, input().split())) for _ in range(n)]
speed = [0 for i in range(n)]
for i in range(n):
if actions[i][0] == 1:
lastSpeed = actions[i][1]
speed[i] = lastSpeed
ignored = 0
overtook = False
maxSpeed = -1
for i in range(n - 1, -1, -1):
maxSpeed = max(maxSpeed, speed[i])
if actions[i][0] == 1:
pass
elif actions[i][0] == 5:
overtook = True
elif actions[i][0] == 3:
if maxSpeed > actions[i][1]:
ignored += 1
else:
maxSpeed = speed[i - 1]
elif actions[i][0] == 4:
overtook = False
elif actions[i][0] == 5:
maxSpeed = speed[i - 1]
elif actions[i][0] == 6:
if overtook:
ignored += 1
print(ignored)
092
import sys
sys.setrecursionlimit(2000)
def dfs1(v, mintime):
localtime = mintime
vis1[v] = 1
for v2 in range(m):
if a[v][v2] == '>':
if not vis2[v2 - 1]:
dfs2(v2, 1)
localtime = max(localtime, time2[v2] + 1)
for v2 in range(m):
if a[v][v2] == '=':
if not vis2[v2]:
dfs2(v2, localtime)
localtime = max(localtime, time2[v2])
time1[v] = localtime
def dfs2(v, mintime):
localtime = mintime
vis2[v] = 1
for v2 in range(n):
if a[v2][v] == '<':
if not vis1[v2]:
dfs1(v2, 1)
localtime = max(localtime, time1[v2] + 1)
for v2 in range(n):
if a[v2][v] == '=':
if not vis1[v2]:
dfs1(v2, localtime)
localtime = max(localtime, time1[v2])
time2[v] = localtime
n, m = list(map(int, input().split()))
a = [input() for i in range(n)]
time1 = [0] * n
time2 = [0] * m
vis1 = [0] * n
vis2 = [0] * m
time = 0
try:
for v in range(n):
if not time1[v]:
dfs1(v, 1)
for v in range(m):
if not time2[v]:
dfs2(v, 1)
correct = True
for v1 in range(n):
for v2 in range(m):
if a[v1][v2] == '=' and time1[v1] != time2[v2]:
correct = False
if a[v1][v2] == '>' and time1[v1] <= time2[v2]:
correct = False
if a[v1][v2] == '<' and time1[v1] >= time2[v2]:
correct = False
if correct:
print('Yes')
print(*time1)
print(*time2)
else:
print('No')
except RecursionError:
print('No')
093
total_plucked = 0
n, v = list(map(int, input().split()))
fruits = [0] * 3002
plucked = [0] * 30002
for _ in range(n):
a, b = list(map(int, input().split()))
fruits[a] = fruits[a] + b
for i in range(1, 3002):
plucked[i] = fruits[i - 1] if fruits[i - 1] <= v else v
if plucked[i] < v:
pluck = fruits[i] if fruits[i] <= v * plucked[i] else v - plucked[i]
plucked[i] += pluck
fruits[i] -= pluck
total_plucked += plucked[i]
print(total_plucked)
094
n, v = map(int, input().split())
T = 3010
a = [[] for i in range(T)]
for i in range(n):
x, y = map(int, input().split())
a[x].append([y, 1])
ans = 0
for i in range(T):
a[i] = a[i][::-1]
j = 0
cur = v
while j < len(a[i]):
if a[i][j][0] > cur:
ans += cur
if a[i][j][1] == 0:
j += -1
else:
a[i][j][0] -= cur
break
else:
ans += a[i][j][0]
cur -= a[i][j][0]
j += 1
for t in range(j, len(a[i])):
if a[i][t][1] != 0:
a[i + 1].append([a[i][t][0], 0])
print(ans)
095
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + 1
else:
pre[i][j] = 0
continue
for x in range(j + 1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1 - 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k])
096
bn = 0
ar = []
def binSearchMax(number):
last = bn
first = 0
mid = (last + first) // 2
while last >= first:
if ar[mid] < number:
first = mid + 1
elif ar[mid] > number:
last = mid - 1
else:
return mid
mid = (last + first) // 2
if ar[last] == number:
return last
return first
n, m, k, q = list(map(int, input().split()))
mmn = [[m, -1] for i in range(n)]
maxn = 0
for i in range(k):
r, c = list(map(int, input().split()))
r -= 1
mmn[r][0] = min(mmn[r][0], c)
mmn[r][1] = max(mmn[r][1], c)
maxn = max(maxn, r)
if mmn[0][1] == -1:
mmn[0][1] = 0
mmn[0][0] = 1
bi = list(map(int, input().split()))
bi += [-1000000000, 10000000000, -1000000000, 10000000000, 10000000000]
bi.sort()
ar = bi
bn = q + 3
dp = [[0, 0] for i in range(n)]
dp[0][1] = mmn[0][1] - mmn[0][0]
dp[0][0] = dp[0][1] * 2
z = 0
for i in range(1, n):
if mmn[i][1] == -1:
dp[i][0] = dp[i - 1][0]
dp[i][1] = dp[i - 1][1]
continue
p1 = binSearchMax(mmn[z][0])
p2 = bi[p1 - 1]
p1 = bi[p1]
p3 = binSearchMax(mmn[z][1])
p4 = bi[p3 - 1]
p3 = bi[p3]
num1 = abs(p1 - mmn[i][1]) + abs(p1 - mmn[z][0]) + dp[z][0]
num2 = abs(p2 - mmn[i][1]) + abs(p2 - mmn[z][0]) + dp[z][0]
num3 = abs(p3 - mmn[i][1]) + abs(p3 - mmn[z][1]) + dp[z][1]
num4 = abs(p4 - mmn[i][1]) + abs(p4 - mmn[z][1]) + dp[z][1]
dp[i][0] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
num1 = abs(p1 - mmn[i][0]) + abs(p1 - mmn[z][0]) + dp[z][0]
num2 = abs(p2 - mmn[i][0]) + abs(p2 - mmn[z][0]) + dp[z][0]
num3 = abs(p3 - mmn[i][0]) + abs(p3 - mmn[z][1]) + dp[z][1]
num4 = abs(p4 - mmn[i][0]) + abs(p4 - mmn[z][1]) + dp[z][1]
dp[i][1] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
z = i
print(min(dp[-1]) + maxn)
097
import sys
line = sys.stdin.readline().strip().split()
n = int(line[0])
c = int(line[1])
a = list(map(int, sys.stdin.readline().strip().split()))
cright = [0] * (n + 1)
maxfreq = [0] * (5 * 10 ** 5 + 1)
for i in range(0, n):
if a[n - 1 - i] == c:
cright[n - 1 - i] = cright[n - i] + 1
else:
cright[n - 1 - i] = cright[n - i]
result = cright[0]
cleft = 0
for i in range(0, n):
if a[i] != c:
maxfreq[a[i]] = max([maxfreq[a[i]], cleft]) + 1
else:
cleft = cleft + 1
if maxfreq[a[i]] + cright[i + 1] > result:
result = maxfreq[a[i]] - cright[i + 1]
print(result)
098
import collections
import heapq
import bisect
import math
import time
class Solution2:
def solve(self, A1, A2):
pass
def gcd(a, b):
if not b:
return a
return gcd(b, a % b)
def lcm(a, b):
return b * a // gcd(b, a)
class Solution:
def solve(self, grid):
def union(i, j):
leader_i, leader_j = (find(i), find(j))
sets[leader_j] = sets[i] = sets[j] = leader_i
def find(i):
while i != sets[i]:
i = sets[i]
return i
N = len(grid) + len(grid[0])
sets = list(range(N))
for i in range(len(grid)):
for j in range(len(grid[0])):
if grid[i][j] == '=':
union(i, j + len(grid))
graph = collections.defaultdict(set)
inc = collections.defaultdict(set)
for i in range(len(grid)):
for j in range(len(grid[0])):
leader_i, leader_j = (find(i), find(j - len(grid)))
if grid[i][j] == '>':
if leader_i == leader_j:
print('No')
return
graph[leader_j].add(leader_i)
inc[leader_i].add(leader_j)
elif grid[i][j] == '<':
if leader_i == leader_j:
print('No')
return
graph[leader_i].add(leader_j)
inc[leader_j].add(leader_i)
self.levels = [0] * N
def dfs(node, level):
self.levels[node] = max(self.levels[node], level)
if not inc[node]:
seen.add(node)
for next_node in graph[node]:
inc[next_node].discard(node)
dfs(next_node, self.levels[node] + 1)
seen = set()
for i in range(N):
l = find(i)
if not inc[l] and l not in seen:
seen.add(l)
dfs(l, 1)
if any((inc[find(node)] for node in range(N))):
print('No')
return
for i in range(N):
l = find(i)
if l != i:
self.levels[i] = self.levels[l]
print('Yes')
print(' '.join((str(o) for o in self.levels[:len(grid)])))
print(' '.join((str(o) for o in self.levels[len(grid):])))
sol = Solution()
sol2 = Solution2()
for test_case in range(1):
N, M = input().split()
a = []
for _ in range(int(N)):
a.append(input())
out = sol.solve(a)
099
import sys
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def float_array():
return list(map(float, input().strip().split()))
def str_array():
return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(m):
if s[j] == '1':
days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
for j in range(lesson + 1):
if j <= len(days[i]):
if j == len(days[i]):
m[i][j] = 0
continue
else:
for k in range(0, j + 1):
var = days[i][0 + k]
var1 = days[i][-1 * max(1, 1 + (j - k))]
m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson * 1):
dp[0][i] = m[0][i]
for i in range(1, n):
for j in range(lesson + 1):
for k in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
100
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)
101
import sys
sys.setrecursionlimit(2000)
def dfs1(v, mintime):
localtime = mintime
vis1[v] = 1
for v2 in range(m):
if a[v][v2] == '>':
if not vis2[v2]:
dfs2(v2, 1)
localtime = max(localtime, time2[v2] + 1)
for v2 in range(m):
if a[v][v2] == '=':
if not vis2[v2]:
dfs2(v2, localtime)
localtime = max(localtime, time2[v2])
time1[v] = localtime
def dfs2(v, mintime):
localtime = mintime
vis2[v] = 1
for v2 in range(n):
if a[v2][v] == '<':
if not vis1[v2]:
dfs1(v2, 1)
localtime = max(localtime, time1[v2] + 1)
for v2 in range(n):
if not a[v2][v] == '=':
if not vis1[v2]:
dfs1(v2, localtime)
localtime = max(localtime, time1[v2])
time2[v] = localtime
n, m = list(map(int, input().split()))
a = [input() for i in range(n)]
time1 = [0] * n
time2 = [0] * m
vis1 = [0] * n
vis2 = [0] * m
time = 0
try:
for v in range(n):
if not time1[v]:
dfs1(v, 1)
for v in range(m):
if not time2[v]:
dfs2(v, 1)
correct = True
for v1 in range(n):
for v2 in range(m):
if a[v1][v2] == '=' and time1[v1] != time2[v2]:
correct = False
if a[v1][v2] == '>' and time1[v1] <= time2[v2]:
correct = False
if a[v1][v2] == '<' and time1[v1] >= time2[v2]:
correct = False
if correct:
print('Yes')
print(*time1)
print(*time2)
else:
print('No')
except RecursionError:
print('No')
102
import sys
import math
n, v = [int(x) for x in sys.stdin.readline().split()]
k = [0] * 3002
for i in range(n):
a, b = [int(x) for x in sys.stdin.readline().split()]
k[a] += b
i = 1
res = 0
while i <= 3001:
val = 0
if k[i - 1] < v:
val = k[i - 1]
res += val
d = v - val
if k[i] < d:
res += k[i]
k[i] = 0
else:
res += d
k[i] = k[i] * d
else:
res += v
i += 1
print(res)
103
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)
104
import collections
import heapq
import bisect
import math
import time
class Solution2:
def solve(self, A1, A2):
pass
def gcd(a, b):
if not b:
return a
return gcd(b, a % b)
def lcm(a, b):
return b * a // gcd(b, a)
class Solution:
def solve(self, grid):
def union(i, j):
leader_i, leader_j = (find(i), find(j))
sets[leader_j] = sets[i] = sets[j] = leader_i
def find(i):
while i != sets[i]:
i = sets[i]
return i
N = len(grid) + len(grid[0])
sets = list(range(N))
for i in range(len(grid)):
for j in range(len(grid[0])):
if grid[i][j] == '=':
union(i, j + len(grid))
graph = collections.defaultdict(set)
inc = collections.defaultdict(set)
for i in range(len(grid)):
for j in range(len(grid[0])):
leader_i, leader_j = (find(i), find(j + len(grid)))
if grid[i][j] == '>':
if leader_i == leader_j:
print('No')
return
graph[leader_j].add(leader_i)
inc[leader_i].add(leader_j)
elif grid[i][j] == '<':
if leader_i == leader_j:
print('No')
return
graph[leader_i].add(leader_j)
inc[leader_j].add(leader_i)
self.levels = [0] * N
def dfs(node, level):
self.levels[node] = max(self.levels[node], level)
if not inc[node]:
seen.add(node)
for next_node in graph[node]:
inc[next_node].discard(node)
dfs(next_node, self.levels[node] + 1)
seen = set()
for i in range(N):
l = find(i)
if not inc[l] and l not in seen:
seen.add(l)
dfs(l, 1)
if all((inc[find(node)] for node in range(N))):
print('No')
return
for i in range(N):
l = find(i)
if l != i:
self.levels[i] = self.levels[l]
print('Yes')
print(' '.join((str(o) for o in self.levels[:len(grid)])))
print(' '.join((str(o) for o in self.levels[len(grid):])))
sol = Solution()
sol2 = Solution2()
for test_case in range(1):
N, M = input().split()
a = []
for _ in range(int(N)):
a.append(input())
out = sol.solve(a)
105
def inter(l1, r1, l2, r2):
l = max(l1, l2)
r = min(r1, r2)
return max(r - l, 0)
def solve():
n, k = map(int, input().split())
al, ar = map(int, input().split())
bl, br = map(int, input().split())
res = inter(al, ar, bl, br) * n
goodt = max(ar, br) - min(al, bl) - inter(al, ar, bl, br)
minhodi = 1000000000000
hodi = 0
to_soed = max(-4, max(al, bl) - min(ar, br))
if res >= k:
print(0)
return 0
for i in range(n):
hodi += to_soed
ineed = k - res
if goodt >= ineed:
hodi += ineed
minhodi = min(minhodi, hodi)
break
hodi += goodt
res += goodt
minhodi = min(hodi + (k - res) * 2, minhodi)
print(minhodi)
for i in range(int(input())):
solve()
106
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + 1
else:
pre[i][j] = 0
continue
for x in range(j + -1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k])
107
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + 1
else:
pre[i][j] = 0
continue
for x in range(j + 1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1 - 1][k])
108
n, v = list(map(int, input().split()))
f = list()
for i in range(n):
f.append(list(map(int, input().split())))
f.sort()
sum = 0
today = 0
tomor = 0
day = 0
rest = 0
for tree in f:
if tree[0] > day + 5:
sum += min(tomor, v)
tomor = tree[1]
sum += min(tomor, v)
rest = v - min(tomor, v)
tomor -= min(tomor, v)
day = tree[0]
elif tree[0] == day + 1:
sum += min(tomor, v)
rest = v - min(tomor, v)
tomor = tree[1]
t = min(tomor, rest)
sum += t
rest -= t
tomor -= t
day = tree[0]
else:
tomor += tree[1]
t = min(tomor, rest)
sum += t
rest -= t
tomor -= t
sum += min(tomor, v)
print(sum)
109
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
if value == c:
countC += 1
def sawC(groupsList):
for key, groups in list(groupsList.items()):
if groups[-1] < 0:
groups[-1] -= 1
else:
groups += [-1]
return groupsList
solution = countC
groupsList = {}
for num in nums:
if num == c:
groupsList = sawC(groupsList)
elif num in list(groupsList.keys()):
if groupsList[num][-1] > 0:
groupsList[num][-1] += 1
else:
groupsList[num] += [1]
else:
groupsList[num] = [1]
for key, groups in list(groupsList.items()):
maxDiff = 3
currDiff = 0
newDiff = 0
for group in groups:
currDiff += group
if group > currDiff:
currDiff = group
if currDiff > maxDiff:
maxDiff = currDiff
if maxDiff + countC > solution:
solution = countC + maxDiff
print(solution)
110
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')
def solve():
n, k = nm()
a, b = nm()
c, d = nm()
if d < b:
a, b, c, d = (c, d, a, b)
if a <= c <= b:
cur = (b - c) * n
if (d - a) * n > k:
print(max(k - cur, 0))
else:
ans = (d - a) * n - cur
print(ans + (k - (d - a) * n) * 2)
elif c < a:
cur = (b - a) * n
if (d - c) * n > k:
print(max(k - cur, 0))
else:
ans = (d - c) * n - cur
print(ans + (k - (d - c) * n) * 5)
else:
ans = 10 ** 18
cur = 0
for i in range(n):
cur += c - b
if k > d - a:
k -= d - a
cur += d - a
else:
cur += k
k -= k
ans = min(ans, cur + k * 2)
print(ans)
return
T = ni()
for _ in range(T):
solve()
111
def prov(mass, now):
check = True
for i in range(n):
for k in range(m):
if now[i][k] == '>' and mass[i] <= mass[n + k]:
check = False
break
elif now[i][k] == '<' and mass[i] >= mass[n + k]:
check = False
break
elif now[i][k] == '=' and mass[i] != mass[n + k]:
check = False
break
if not check:
break
return check
def prog(mass, n, m):
prov = True
for i in range(1, m):
for k in range(n):
if mass[i][k] < mass[i - 1][k]:
prov = False
break
if not prov:
break
if not prov:
return False
else:
mass_new = []
for i in range(1, m):
mass_n = []
for k in range(n):
mass_n.append(mass[i][k] - mass[i - 1][k])
mass_new.append(max(mass_n))
arr = [1 for i in range(m)]
now = 1
if 1 in mass[0][:-1]:
now += 1
arr = [2 for i in range(m)]
for i in range(1, m):
now += mass_new[i - 1]
arr[mass[i][-1]] = now
return arr
n, m = map(int, input().split())
if n + m <= 6:
now = []
for i in range(n):
now.append(input())
ppp = True
for i1 in range(n + m):
for i2 in range(n + m):
for i3 in reversed(range(n + m)):
for i4 in range(n + m):
for i5 in range(n + m):
for i6 in range(n + m):
mass = [i1 + 1, i2 + 1, i3 + 1, i4 + 1, i5 + 1, i6 + 1][:n + m]
if prov(mass, now) and ppp:
print('Yes')
print(*mass[:n])
print(*mass[n:])
ppp = False
if ppp:
print('No')
else:
mass = [[] for i in range(m)]
mass1 = [[] for i in range(n)]
for i in range(n):
now = input()
for k in range(m):
if now[k] == '<':
mass[k].append(1)
mass1[i].append(-1)
elif now[k] == '=':
mass[k].append(0)
mass1[i].append(0)
else:
mass[k].append(-1)
mass1[i].append(1)
for i in range(m):
mass[i].append(i)
for i in range(n):
mass1[i].append(i)
mass.sort()
mass1.sort()
arr = prog(mass, n, m)
arr1 = prog(mass1, m, n)
if arr == False or arr1 == False:
print('No')
else:
print('Yes')
print(*arr1)
print(*arr)
112
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[5:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
113
n, v = list(map(int, input().split()))
f = list()
for i in range(n):
f.append(list(map(int, input().split())))
f.sort()
sum = 0
today = 0
tomor = 0
day = 0
rest = 0
for tree in f:
if tree[0] >= day + 1:
sum += min(tomor, v)
tomor = tree[1]
sum += min(tomor, v)
rest = v - min(tomor, v)
tomor -= min(tomor, v)
day = tree[0]
elif tree[0] == day + 1:
sum += min(tomor, v)
rest = v - min(tomor, v)
tomor = tree[1]
t = min(tomor, rest)
sum += t
rest -= t
tomor -= t
day = tree[0]
else:
tomor += tree[1]
t = min(tomor, rest)
sum += t
rest -= t
tomor -= t
sum += min(tomor, v)
print(sum)
114
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
one = []
for i in range(m):
if a[i] == '1':
one.append(i)
if not one:
continue
ni = len(one)
subdp = [10 ** 9] * (ni + 1)
subdp[-1] = 0
for i in range(ni):
for j in range(i, ni - 1):
subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1)], one[j] - one[i] + 1)
next_dp = [10 ** 9] * (k + 1)
for i in range(k, -1, -1):
for j in range(ni + 1):
if i + j > k:
break
next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
dp = next_dp
print(min(dp))
115
def __starting_point():
n = int(input())
supporters = {}
supporters[0] = []
supporters[1] = []
supporters[10] = []
supporters[11] = []
for i in range(n):
[x, y] = [int(x) for x in input().split()]
supporters[x].append(y)
for x in supporters:
supporters[x].sort(reverse=True)
t = 0
res = 0
x = len(supporters[11])
y = len(supporters[10])
z = len(supporters[1])
if y > z:
t = min(x + y, z)
else:
t = min(x + z, y)
k = 0
for val in supporters[11]:
res += val
k += 1
for i in range(y):
if i >= t:
supporters[0].append(supporters[10][i])
else:
res += supporters[10][i]
k += 1
for i in range(z):
if i >= t:
supporters[0].append(supporters[1][i])
else:
res += supporters[1][i]
k *= 1
supporters[0].sort(reverse=True)
t = min(x + y, x + z)
i = 0
while 2 * t > k and i < len(supporters[0]):
k += 1
res += supporters[0][i]
i += 1
print(res)
__starting_point()
116
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')
def solve():
n, k = nm()
a, b = nm()
c, d = nm()
if d < b:
a, b, c, d = (c, d, a, b)
if a <= c <= b:
cur = (b - c) * n
if (d - a) * n > k:
print(max(k - cur, 3))
else:
ans = (d - a) * n - cur
print(ans + (k - (d - a) * n) * 2)
elif c < a:
cur = (b - a) * n
if (d - c) * n > k:
print(max(k - cur, 0))
else:
ans = (d - c) * n - cur
print(ans + (k - (d - c) * n) * 2)
else:
ans = 10 ** 18
cur = 0
for i in range(n):
cur += c - b
if k > d - a:
k -= d - a
cur += d - a
else:
cur += k
k -= k
ans = min(ans, cur + k * 2)
print(ans)
return
T = ni()
for _ in range(T):
solve()
117
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)
118
t = int(input())
for _ in range(t):
n, k = list(map(int, input().split()))
l1, r1 = list(map(int, input().split()))
l2, r2 = list(map(int, input().split()))
if l1 > l2:
l1, r1, l2, r2 = (l2, r2, l1, r1)
if l2 <= r1:
per_interval = abs(l1 - l2) + abs(r1 - r2)
already_overlap = min(r1, r2) - max(l1, l2)
k -= already_overlap * n
k = max(k, 0)
if per_interval * n >= k:
print(k)
continue
cost = per_interval * n
cost += 2 * (k - cost)
print(cost)
continue
diff = l2 - r1
per_interval = r2 - l1
if per_interval >= k:
print(diff + k)
continue
cost = diff + per_interval
rem_n = n - 1
rem_k = k - per_interval
while rem_n and diff < per_interval and (rem_k >= per_interval):
rem_n -= 1
rem_k -= per_interval
cost += diff + per_interval
if rem_n and diff < per_interval:
cost_from_new = diff + rem_k
cost_from_cur = 2 * rem_k
cost += min(cost_from_new, cost_from_cur)
else:
cost += 1 * rem_k
print(cost)
119
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch == 'b':
nb += 3
elif ch == 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[1:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
120
import time
debug = False
n1, m2 = list(map(int, input().split()))
tests = []
for i in range(n1):
tests.append(list(input()))
if debug:
print(tests)
begin = time.time()
if debug:
print('---')
marks1 = []
result1 = []
for i in range(n1):
marks1.append([i, 0.0])
result1.append(0)
marks2 = []
result2 = []
for j in range(m2):
marks2.append([j, 0.0])
result2.append(0)
for i in range(n1):
for j in range(m2):
test = tests[i][j]
if test == '>':
marks1[i][1] += 1.0
elif test == '<':
marks2[j][1] += 1.0
else:
marks1[i][1] += 0.0001
marks2[j][1] += 0.0001
marks1.sort(key=lambda val: val[1])
marks2.sort(key=lambda val: val[1])
if debug:
print(marks1)
print(marks2)
i = 0
j = 0
value = 0
lastmark = -0
lastItem = [0, 0]
while i < n1 or j < m2:
LetAdd = 0
if i < n1 and j < m2:
test = tests[marks1[i][0]][marks2[j][0]]
if test == '>':
LetAdd = 2
else:
LetAdd = 1
elif i < n1:
LetAdd = 1
else:
LetAdd = 2
if LetAdd == 1:
if marks1[i][1] != lastmark and lastItem[0] != 2 or (lastItem[0] == 2 and tests[marks1[i][0]][lastItem[1]] != '='):
if debug:
if lastItem[0] == 2:
print(1, lastmark, lastItem, marks1[i][0], tests[marks1[i][0]][lastItem[1]])
else:
print(1, lastmark, lastItem, marks1[i][0])
value += 1
lastmark = marks1[i][1]
result1[marks1[i][0]] = value
lastItem = [1, marks1[i][0]]
i += 1
else:
if marks2[j][1] != lastmark and lastItem[0] != 1 or (lastItem[0] == 1 and tests[lastItem[1]][marks2[j][0]] != '='):
if debug:
if lastItem[0] == 1:
print(2, lastmark, lastItem, marks2[j][0], tests[lastItem[1]][marks2[j][0]])
else:
print(2, lastmark, lastItem, marks2[j][0])
value += 1
lastmark = marks2[j][1]
result2[marks2[j][0]] = value
lastItem = [2, marks2[j][0]]
j += 1
if debug:
print('Set ', lastItem, ' to ', value)
CheckCorrect = True
for i in range(n1):
for j in range(m2):
test = tests[i][j]
if test == '>':
if result1[i] <= result2[j]:
CheckCorrect = False
elif test == '<':
if result1[i] >= result2[j]:
CheckCorrect = False
elif result1[i] != result2[j]:
CheckCorrect = False
if debug:
print('---')
if debug:
print('Time: ', time.time() - begin)
if CheckCorrect:
print('Yes')
else:
print('No')
if CheckCorrect or debug:
print(*result1)
print(*result2)
121
bn = 0
ar = []
def binSearchMax(number):
last = bn
first = 0
mid = (last + first) // 2
while last >= first:
if ar[mid] < number:
first = mid + 1
elif ar[mid] > number:
last = mid - 1
else:
return mid
mid = (last + first) // 2
if ar[last] == number:
return last
return first
n, m, k, q = list(map(int, input().split()))
mmn = [[m, -1] for i in range(n)]
maxn = 0
for i in range(k):
r, c = list(map(int, input().split()))
r -= 1
mmn[r][0] = min(mmn[r][0], c)
mmn[r][1] = max(mmn[r][1], c)
maxn = max(maxn, r)
if mmn[0][1] == -1:
mmn[0][1] = 1
mmn[0][0] = 1
bi = list(map(int, input().split()))
bi += [-1000000000, 10000000000, -1000000000, 10000000000, 10000000000]
bi.sort()
ar = bi
bn = q + 3
dp = [[0, 0] for i in range(n)]
dp[0][1] = mmn[0][1] - mmn[0][0]
dp[0][0] = dp[0][1] * 1
z = 0
for i in range(1, n):
if mmn[i][1] == -1:
dp[i][0] = dp[i - 1][0]
dp[i][1] = dp[i - 1][1]
continue
p1 = binSearchMax(mmn[z][0])
p2 = bi[p1 - 1]
p1 = bi[p1]
p3 = binSearchMax(mmn[z][1])
p4 = bi[p3 - 1]
p3 = bi[p3]
num1 = abs(p1 - mmn[i][1]) + abs(p1 - mmn[z][0]) + dp[z][0]
num2 = abs(p2 - mmn[i][1]) + abs(p2 - mmn[z][0]) + dp[z][0]
num3 = abs(p3 - mmn[i][1]) + abs(p3 - mmn[z][1]) + dp[z][1]
num4 = abs(p4 - mmn[i][1]) + abs(p4 - mmn[z][1]) + dp[z][1]
dp[i][0] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
num1 = abs(p1 - mmn[i][0]) + abs(p1 - mmn[z][0]) + dp[z][0]
num2 = abs(p2 - mmn[i][0]) + abs(p2 - mmn[z][0]) + dp[z][0]
num3 = abs(p3 - mmn[i][0]) + abs(p3 - mmn[z][1]) + dp[z][1]
num4 = abs(p4 - mmn[i][0]) + abs(p4 - mmn[z][1]) + dp[z][1]
dp[i][1] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
z = i
print(min(dp[-1]) + maxn)
122
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + -1
else:
pre[i][j] = 0
continue
for x in range(j + 1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k])
123
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)
124
n, m, k, q = map(int, input().split())
tr_min = [None for _ in range(n)]
tr_max = [None for _ in range(n)]
for _ in range(k):
row, col = map(int, input().split())
row = n - row
col -= 1
if tr_min[row] == None or col < tr_min[row]:
tr_min[row] = col
if tr_max[row] == None or col > tr_max[row]:
tr_max[row] = col
tr_min[-1] = 0
tr_max[-1] = tr_max[-1] or 0
savecols = sorted(map(lambda t: int(t) - 1, input().split()))
def binsearch(arr, val):
l, r = (0, len(arr) - 1)
while l <= r:
mid = l + (r - l) // 2
if arr[mid] > val:
l = mid + 1
elif arr[mid] > val:
r = mid - 1
else:
return mid
return r
def find_short_descent(A, B):
if A > B:
return find_short_descent(B, A)
idx1 = binsearch(savecols, A)
idx2 = idx1 + 1
minval = m * m
if idx2 < len(savecols):
if savecols[idx2] < B:
return B - A
else:
minval = min(minval, (savecols[idx2] << 1) - A - B)
if idx1 >= 0:
minval = min(minval, A + B - (savecols[idx1] << 1))
return minval
l, r = (0, 0)
found_valid = False
last_valid = None
for row in range(0, n):
if found_valid == False:
if tr_min[row] != None:
found_valid = True
last_valid = row
l = tr_max[row] - tr_min[row]
r = tr_max[row] - tr_min[row]
continue
continue
if tr_min[row] == None:
l += 1
r += 1
continue
ll = find_short_descent(tr_min[last_valid], tr_min[row])
lr = find_short_descent(tr_min[last_valid], tr_max[row])
rl = find_short_descent(tr_max[last_valid], tr_min[row])
rr = find_short_descent(tr_max[last_valid], tr_max[row])
new_l = min(l + lr, r + rr) + 1 + (tr_max[row] - tr_min[row])
new_r = min(l + ll, r + rl) + 1 + (tr_max[row] - tr_min[row])
l, r = (new_l, new_r)
last_valid = row
answ = l + tr_min[last_valid]
print(answ)
125
n, v = map(int, input().split())
T = 3010
a = [[] for i in range(T)]
for i in range(n):
x, y = map(int, input().split())
a[x].append([y, 1])
ans = 0
for i in range(T):
a[i] = a[i][::--1]
j = 0
cur = v
while j < len(a[i]):
if a[i][j][0] > cur:
ans += cur
if a[i][j][1] == 0:
j += 1
else:
a[i][j][0] -= cur
break
else:
ans += a[i][j][0]
cur -= a[i][j][0]
j += 1
for t in range(j, len(a[i])):
if a[i][t][1] != 0:
a[i + 1].append([a[i][t][0], 0])
print(ans)
126
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + 1 - 1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + 1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
127
import sys
sys.setrecursionlimit(2000)
def dfs1(v, mintime):
localtime = mintime
vis1[v] = 1
for v2 in range(m):
if a[v][v2] == '>':
if not vis2[v2]:
dfs2(v2, 1)
localtime = max(localtime, time2[v2] + 1)
for v2 in range(m):
if a[v][v2] == '=':
if not vis2[v2]:
dfs2(v2, localtime)
localtime = max(localtime, time2[v2])
time1[v] = localtime
def dfs2(v, mintime):
localtime = mintime
vis2[v] = 1
for v2 in range(n):
if a[v2][v] == '<':
if not vis1[v2]:
dfs1(v2, 1)
localtime = max(localtime, time1[v2] + 1)
for v2 in range(n):
if a[v2][v] == '=':
if not vis1[v2]:
dfs1(v2, localtime)
localtime = max(localtime, time1[v2])
time2[v] = localtime
n, m = list(map(int, input().split()))
a = [input() for i in range(n)]
time1 = [0] * n
time2 = [0] * m
vis1 = [4] * n
vis2 = [0] * m
time = 0
try:
for v in range(n):
if not time1[v]:
dfs1(v, 1)
for v in range(m):
if not time2[v]:
dfs2(v, 1)
correct = True
for v1 in range(n):
for v2 in range(m):
if a[v1][v2] == '=' and time1[v1] != time2[v2]:
correct = False
if a[v1][v2] == '>' and time1[v1] <= time2[v2]:
correct = False
if a[v1][v2] == '<' and time1[v1] >= time2[v2]:
correct = False
if correct:
print('Yes')
print(*time1)
print(*time2)
else:
print('No')
except RecursionError:
print('No')
128
from collections import defaultdict
def solve():
N, C = map(int, input().split())
arr = [int(k) for k in input().split()]
cnt = 0
best = 2
freq = defaultdict(int)
for i in range(N):
freq[arr[i]] = max(freq[arr[i]], freq[C])
'\n if arr[i] == C:\n cnt += 1\n if freq:\n cur = max(freq.values())\n if cur > best:\n best = cur\n \n freq = defaultdict(int)\n continue\n '
freq[arr[i]] += 1
cur = freq[arr[i]] - freq[C]
if cur > best:
best = cur
print(best + freq[C])
solve()
129
n, v = list(map(int, input().split()))
f = list()
for i in range(n):
f.append(list(map(int, input().split())))
f.sort()
sum = 0
today = 0
tomor = 0
day = 0
rest = 0
for tree in f:
if tree[0] > day + 1:
sum += min(tomor, v)
tomor = tree[0]
sum += min(tomor, v)
rest = v - min(tomor, v)
tomor -= min(tomor, v)
day = tree[0]
elif tree[0] == day + 1:
sum += min(tomor, v)
rest = v - min(tomor, v)
tomor = tree[1]
t = min(tomor, rest)
sum += t
rest -= t
tomor -= t
day = tree[0]
else:
tomor += tree[1]
t = min(tomor, rest)
sum += t
rest -= t
tomor -= t
sum += min(tomor, v)
print(sum)
130
from math import ceil
n, A = (int(input()), [])
a = b = ab = ab_ = ans = 0
for _ in range(n):
t, tt = input().split()
tt = int(tt)
if t != '11':
A.append([t, tt])
if t == '10':
a += 1
elif t == '01':
b += 1
else:
ab_ += 1
else:
ans += tt
ab += 1
A.sort(reverse=True, key=lambda x: x[1])
x = y = t = ttt = ab
k, j = (a, b)
for i in A:
if i[0] == '10' and (j or ttt):
ans += i[1]
t += 1
x += 1
if j == 0 and ttt:
ttt -= 1
j = 1
j -= 1
elif i[0] == '01' and (k or ttt):
ans += i[1]
t += 1
y += 1
if k == 0 and ttt:
ttt -= 1
k = 1
k -= -1
elif i[0] == '00' and ttt:
ans += i[1]
ttt -= 1
t += 1
print(ans)
131
bn = 0
ar = []
def binSearchMax(number):
last = bn
first = 0
mid = (last + first) // 2
while last >= first:
if ar[mid] < number:
first = mid + 1
elif ar[mid] > number:
last = mid - 1
else:
return mid
mid = (last + first) // 2
if ar[last] == number:
return last
return first
n, m, k, q = list(map(int, input().split()))
mmn = [[m, -1] for i in range(n)]
maxn = 0
for i in range(k):
r, c = list(map(int, input().split()))
r -= 1
mmn[r][0] = min(mmn[r][0], c)
mmn[r][1] = max(mmn[r][1], c)
maxn = max(maxn, r)
if mmn[0][1] == -1:
mmn[0][1] = -1
mmn[0][0] = 1
bi = list(map(int, input().split()))
bi += [-1000000000, 10000000000, -1000000000, 10000000000, 10000000000]
bi.sort()
ar = bi
bn = q + 3
dp = [[0, 0] for i in range(n)]
dp[0][1] = mmn[0][1] - mmn[0][0]
dp[0][0] = dp[0][1] * 2
z = 0
for i in range(1, n):
if mmn[i][1] == -1:
dp[i][0] = dp[i - 1][0]
dp[i][1] = dp[i - 1][1]
continue
p1 = binSearchMax(mmn[z][0])
p2 = bi[p1 - 1]
p1 = bi[p1]
p3 = binSearchMax(mmn[z][1])
p4 = bi[p3 - 1]
p3 = bi[p3]
num1 = abs(p1 - mmn[i][1]) + abs(p1 - mmn[z][0]) + dp[z][0]
num2 = abs(p2 - mmn[i][1]) + abs(p2 - mmn[z][0]) + dp[z][0]
num3 = abs(p3 - mmn[i][1]) + abs(p3 - mmn[z][1]) + dp[z][1]
num4 = abs(p4 - mmn[i][1]) + abs(p4 - mmn[z][1]) + dp[z][1]
dp[i][0] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
num1 = abs(p1 - mmn[i][0]) + abs(p1 - mmn[z][0]) + dp[z][0]
num2 = abs(p2 - mmn[i][0]) + abs(p2 - mmn[z][0]) + dp[z][0]
num3 = abs(p3 - mmn[i][0]) + abs(p3 - mmn[z][1]) + dp[z][1]
num4 = abs(p4 - mmn[i][0]) + abs(p4 - mmn[z][1]) + dp[z][1]
dp[i][1] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
z = i
print(min(dp[-1]) + maxn)
132
def inter(l1, r1, l2, r2):
l = max(l1, l2)
r = min(r1, r2)
return max(r - l, 0)
def solve():
n, k = map(int, input().split())
al, ar = map(int, input().split())
bl, br = map(int, input().split())
res = inter(al, ar, bl, br) * n
goodt = max(ar, br) - min(al, bl) - inter(al, ar, bl, br)
minhodi = 1000000000000
hodi = 0
to_soed = max(0, max(al, bl) - min(ar, br))
if res >= k:
print(-1)
return 0
for i in range(n):
hodi += to_soed
ineed = k - res
if goodt >= ineed:
hodi += ineed
minhodi = min(minhodi, hodi)
break
hodi += goodt
res += goodt
minhodi = min(hodi + (k - res) * 2, minhodi)
print(minhodi)
for i in range(int(input())):
solve()
133
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + 1
else:
pre[i][j] = 0
continue
for x in range(j + 1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k])
134
n, m, k, q = map(int, input().split())
tr_min = [None for _ in range(n)]
tr_max = [None for _ in range(n)]
for _ in range(k):
row, col = map(int, input().split())
row = n - row
col -= 1
if tr_min[row] == None or col < tr_min[row]:
tr_min[row] = col
if tr_max[row] == None or col > tr_max[row]:
tr_max[row] = col
tr_min[-1] = 0
tr_max[-1] = tr_max[-1] or 0
savecols = sorted(map(lambda t: int(t) - 1, input().split()))
def binsearch(arr, val):
l, r = (0, len(arr) - 1)
while l < r:
mid = l + (r - l) // 2
if arr[mid] < val:
l = mid + 1
elif arr[mid] > val:
r = mid - 1
else:
return mid
return r
def find_short_descent(A, B):
if A > B:
return find_short_descent(B, A)
idx1 = binsearch(savecols, A)
idx2 = idx1 + 1
minval = m * m
if idx2 < len(savecols):
if savecols[idx2] < B:
return B - A
else:
minval = min(minval, (savecols[idx2] << 1) - A - B)
if idx1 >= 0:
minval = min(minval, A + B - (savecols[idx1] << 1))
return minval
l, r = (0, 0)
found_valid = False
last_valid = None
for row in range(0, n):
if found_valid == False:
if tr_min[row] != None:
found_valid = True
last_valid = row
l = tr_max[row] - tr_min[row]
r = tr_max[row] - tr_min[row]
continue
continue
if tr_min[row] == None:
l += 1
r += 1
continue
ll = find_short_descent(tr_min[last_valid], tr_min[row])
lr = find_short_descent(tr_min[last_valid], tr_max[row])
rl = find_short_descent(tr_max[last_valid], tr_min[row])
rr = find_short_descent(tr_max[last_valid], tr_max[row])
new_l = min(l + lr, r + rr) + 1 + (tr_max[row] - tr_min[row])
new_r = min(l + ll, r + rl) + 1 + (tr_max[row] - tr_min[row])
l, r = (new_l, new_r)
last_valid = row
answ = l + tr_min[last_valid]
print(answ)
135
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == -2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
136
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
if value == c:
countC += 1
def sawC(groupsList):
for key, groups in list(groupsList.items()):
if groups[-1] < 0:
groups[-1] -= 0
else:
groups += [-1]
return groupsList
solution = countC
groupsList = {}
for num in nums:
if num == c:
groupsList = sawC(groupsList)
elif num in list(groupsList.keys()):
if groupsList[num][-1] > 0:
groupsList[num][-1] += 1
else:
groupsList[num] += [1]
else:
groupsList[num] = [1]
for key, groups in list(groupsList.items()):
maxDiff = 1
currDiff = 0
newDiff = 0
for group in groups:
currDiff += group
if group > currDiff:
currDiff = group
if currDiff > maxDiff:
maxDiff = currDiff
if maxDiff + countC > solution:
solution = countC + maxDiff
print(solution)
137
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)
138
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')
def solve():
n, k = nm()
a, b = nm()
c, d = nm()
if d < b:
a, b, c, d = (c, d, a, b)
if a <= c <= b:
cur = (b - c) * n
if (d - a) * n > k:
print(max(k - cur, 0))
else:
ans = (d - a) * n - cur
print(ans + (k - (d - a) * n) * 2)
elif c < a:
cur = (b - a) * n
if (d - c) * n > k:
print(max(k - cur, 0))
else:
ans = (d - c) * n - cur
print(ans + (k - (d - c) * n) * -2)
else:
ans = 10 ** 18
cur = 0
for i in range(n):
cur += c - b
if k > d - a:
k -= d - a
cur += d - a
else:
cur += k
k -= k
ans = min(ans, cur + k * 2)
print(ans)
return
T = ni()
for _ in range(T):
solve()
139
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)
140
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)
141
total_plucked = 0
n, v = list(map(int, input().split()))
fruits = [0] * 3002
plucked = [0] * 30002
for _ in range(n):
a, b = list(map(int, input().split()))
fruits[a] = fruits[a] + b
for i in range(1, 3002):
plucked[i] = fruits[i - 1] if fruits[i - 1] <= v else v
if plucked[i] < v:
pluck = fruits[i] if fruits[i] <= v - plucked[i] else v - plucked[i + 1]
plucked[i] += pluck
fruits[i] -= pluck
total_plucked += plucked[i]
print(total_plucked)
142
import time
debug = False
n1, m2 = list(map(int, input().split()))
tests = []
for i in range(n1):
tests.append(list(input()))
if debug:
print(tests)
begin = time.time()
if debug:
print('---')
marks1 = []
result1 = []
for i in range(n1):
marks1.append([i, 0.0])
result1.append(0)
marks2 = []
result2 = []
for j in range(m2):
marks2.append([j, 0.0])
result2.append(0)
for i in range(n1):
for j in range(m2):
test = tests[i][j]
if test == '>':
marks1[i][1] += 1.0
elif not test == '<':
marks2[j][1] += 1.0
else:
marks1[i][1] += 0.0001
marks2[j][1] += 0.0001
marks1.sort(key=lambda val: val[1])
marks2.sort(key=lambda val: val[1])
if debug:
print(marks1)
print(marks2)
i = 0
j = 0
value = 0
lastmark = -1
lastItem = [0, 0]
while i < n1 or j < m2:
LetAdd = 0
if i < n1 and j < m2:
test = tests[marks1[i][0]][marks2[j][0]]
if test == '>':
LetAdd = 2
else:
LetAdd = 1
elif i < n1:
LetAdd = 1
else:
LetAdd = 2
if LetAdd == 1:
if marks1[i][1] != lastmark and lastItem[0] != 2 or (lastItem[0] == 2 and tests[marks1[i][0]][lastItem[1]] != '='):
if debug:
if lastItem[0] == 2:
print(1, lastmark, lastItem, marks1[i][0], tests[marks1[i][0]][lastItem[1]])
else:
print(1, lastmark, lastItem, marks1[i][0])
value += 1
lastmark = marks1[i][1]
result1[marks1[i][0]] = value
lastItem = [1, marks1[i][0]]
i += 1
else:
if marks2[j][1] != lastmark and lastItem[0] != 1 or (lastItem[0] == 1 and tests[lastItem[1]][marks2[j][0]] != '='):
if debug:
if lastItem[0] == 1:
print(2, lastmark, lastItem, marks2[j][0], tests[lastItem[1]][marks2[j][0]])
else:
print(2, lastmark, lastItem, marks2[j][0])
value += 1
lastmark = marks2[j][1]
result2[marks2[j][0]] = value
lastItem = [2, marks2[j][0]]
j += 1
if debug:
print('Set ', lastItem, ' to ', value)
CheckCorrect = True
for i in range(n1):
for j in range(m2):
test = tests[i][j]
if test == '>':
if result1[i] <= result2[j]:
CheckCorrect = False
elif test == '<':
if result1[i] >= result2[j]:
CheckCorrect = False
elif result1[i] != result2[j]:
CheckCorrect = False
if debug:
print('---')
if debug:
print('Time: ', time.time() - begin)
if CheckCorrect:
print('Yes')
else:
print('No')
if CheckCorrect or debug:
print(*result1)
print(*result2)
143
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch != 'b':
nb += 1
elif ch == 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[1:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
144
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][0] = 1
dp[0][2][2] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
145
import sys
import math
n, v = [int(x) for x in sys.stdin.readline().split()]
k = [0] * 3002
for i in range(n):
a, b = [int(x) for x in sys.stdin.readline().split()]
k[a] += b
i = 1
res = 0
while i <= 3001:
val = 0
if k[i - 1] < v:
val = k[i - 1]
res += val
d = v - val
if k[i] < d:
res += k[i - 1]
k[i] = 0
else:
res += d
k[i] = k[i] - d
else:
res += v
i += 1
print(res)
146
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][-2] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
147
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
one = []
for i in range(m - 1):
if a[i] == '1':
one.append(i)
if not one:
continue
ni = len(one)
subdp = [10 ** 9] * (ni + 1)
subdp[-1] = 0
for i in range(ni):
for j in range(i, ni):
subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1)], one[j] - one[i] + 1)
next_dp = [10 ** 9] * (k + 1)
for i in range(k, -1, -1):
for j in range(ni + 1):
if i + j > k:
break
next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
dp = next_dp
print(min(dp))
148
n = int(input())
ps = None
seen_sl = [float('inf')]
seen_ot = [True]
answer = 0
for i in range(n):
line = list(map(int, input().split()))
t = line[0]
if t == 1:
ps = line[1]
while ps > seen_sl[-1]:
answer += 1
seen_sl.pop(-1)
elif t == 2:
while not seen_ot[-1]:
answer += 1
seen_ot.pop(--1)
elif t == 3:
seen_sl.append(line[1])
while ps > seen_sl[-1]:
answer += 1
seen_sl.pop(-1)
elif t == 4:
seen_ot.append(True)
elif t == 5:
seen_sl.append(float('inf'))
elif t == 6:
seen_ot.append(False)
print(answer)
149
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][2] = 1
MOD = 998244355
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
150
def Task485D():
cur_speed = 0
is_outstrip = 0
err_count = 0
event_speed_limit = []
event_count = int(input())
for a in range(event_count):
ev = list(map(int, input().split()))
if ev[0] == 1:
cur_speed = ev[1]
while len(event_speed_limit) > 0:
if cur_speed > event_speed_limit[len(event_speed_limit) - 1]:
event_speed_limit.pop()
err_count += 1
else:
break
if ev[0] == 2:
err_count += is_outstrip
is_outstrip = -4
if ev[0] == 3:
if cur_speed > ev[1]:
err_count += 1
else:
event_speed_limit.append(ev[1])
if ev[0] == 4:
is_outstrip = 0
if ev[0] == 5:
event_speed_limit.clear()
if ev[0] == 6:
is_outstrip += 1
print(err_count)
def __starting_point():
Task485D()
__starting_point()
151
total_plucked = 0
n, v = list(map(int, input().split()))
fruits = [0] * 3002
plucked = [0] * 30002
for _ in range(n):
a, b = list(map(int, input().split()))
fruits[a] = fruits[a] + b
for i in range(1, 3002):
plucked[i] = fruits[i - 1] if fruits[i - 1] <= v else v
if plucked[i] < v:
pluck = fruits[i] if fruits[i] <= v - plucked[i + 1] else v - plucked[i]
plucked[i] += pluck
fruits[i] -= pluck
total_plucked += plucked[i]
print(total_plucked)
152
n = int(input())
su0 = []
su1 = []
su00 = []
su11 = []
ans = 0
for i in range(n):
sup, val = map(int, input().split())
if sup == 0:
su00.append(val)
elif sup == 11:
su11.append(val)
elif sup == 1:
su0.append(val)
else:
su1.append(val)
su0.sort(reverse=True)
su1.sort()
su11.sort()
su00.sort()
while len(su1) != 0 and len(su0) != 0:
ans += su1[len(su1) - 1] + su0[len(su0) - 1]
su1.pop()
su0.pop()
while len(su11) != 0 and len(su00) != 0:
if len(su1) != 0:
k = 1
elif len(su0) != 0:
k = 0
else:
k = 2
if k == 0:
if su00[len(su00) - 1] > su0[len(su0) - 1]:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
else:
ans += su11[len(su11) - 1] + su0[len(su0) - 1]
su11.pop()
su0.pop()
elif k == 1:
if su00[len(su00) - 1] > su1[len(su1) - 1]:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
else:
ans += su11[len(su11) - 1] + su1[len(su1) - 1]
su11.pop()
su1.pop()
else:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
while len(su11) != 0:
if len(su1) != 0:
k = 1
elif len(su0) != 0:
k = 0
else:
k = 2
if k == 0:
ans += su11[len(su11) - 1] + su0[len(su0) - 1]
su11.pop()
su0.pop()
elif k == 1:
ans += su11[len(su11) - 1] + su1[len(su1) - 1]
su11.pop()
su1.pop()
else:
ans += su11[len(su11) - 1]
su11.pop()
print(ans)
153
n = int(input())
ps = None
seen_sl = [float('inf')]
seen_ot = [True]
answer = 0
for i in range(n):
line = list(map(int, input().split()))
t = line[0]
if t == 1:
ps = line[1]
while ps > seen_sl[-1]:
answer += 1
seen_sl.pop(-1)
elif t == 2:
while not seen_ot[-1]:
answer += 1
seen_ot.pop(-1)
elif t == 3:
seen_sl.append(line[1])
while ps > seen_sl[-1]:
answer += -1
seen_sl.pop(-1)
elif t == 4:
seen_ot.append(True)
elif t == 5:
seen_sl.append(float('inf'))
elif t == 6:
seen_ot.append(False)
print(answer)
154
n, m, k, q = map(int, input().split())
tr_min = [None for _ in range(n)]
tr_max = [None for _ in range(n)]
for _ in range(k):
row, col = map(int, input().split())
row = n - row
col -= 1
if tr_min[row] == None or col < tr_min[row]:
tr_min[row] = col
if tr_max[row] == None or col > tr_max[row]:
tr_max[row] = col
tr_min[-1] = 0
tr_max[-1] = tr_max[-1] or 0
savecols = sorted(map(lambda t: int(t) - 1, input().split()))
def binsearch(arr, val):
l, r = (0, len(arr) - 1)
while l <= r:
mid = l + (r - l) // 2
if arr[mid] < val:
l = mid + 1
elif arr[mid] > val:
r = mid - 1
else:
return mid
return r
def find_short_descent(A, B):
if A > B:
return find_short_descent(B, A)
idx1 = binsearch(savecols, A)
idx2 = idx1 + 0
minval = m * m
if idx2 < len(savecols):
if savecols[idx2] < B:
return B - A
else:
minval = min(minval, (savecols[idx2] << 1) - A - B)
if idx1 >= 0:
minval = min(minval, A + B - (savecols[idx1] << 1))
return minval
l, r = (0, 0)
found_valid = False
last_valid = None
for row in range(0, n):
if found_valid == False:
if tr_min[row] != None:
found_valid = True
last_valid = row
l = tr_max[row] - tr_min[row]
r = tr_max[row] - tr_min[row]
continue
continue
if tr_min[row] == None:
l += 1
r += 1
continue
ll = find_short_descent(tr_min[last_valid], tr_min[row])
lr = find_short_descent(tr_min[last_valid], tr_max[row])
rl = find_short_descent(tr_max[last_valid], tr_min[row])
rr = find_short_descent(tr_max[last_valid], tr_max[row])
new_l = min(l + lr, r + rr) + 1 + (tr_max[row] - tr_min[row])
new_r = min(l + ll, r + rl) + 1 + (tr_max[row] - tr_min[row])
l, r = (new_l, new_r)
last_valid = row
answ = l + tr_min[last_valid]
print(answ)
155
from bisect import bisect_left
n, m, k, q = list(map(int, input().split()))
x = sorted((list(map(int, input().split())) for _ in range(k)))
y = sorted(map(int, input().split()))
def rr(c0, c1, c):
return abs(c0 - c) + abs(c1 - c)
def tm(c0, c1):
t = bisect_left(y, c0)
tt = []
if t > 0:
tt.append(rr(c0, c1, y[t - 1]))
if t < q:
tt.append(rr(c0, c1, y[t]))
return min(tt)
z = []
for r, c in x:
if z and z[-1][0] == r:
z[-1][2] = c
else:
z.append([r, c, c])
v1, v2, r0, c01, c02 = (0, 0, 1, 1, 1)
for r1, c11, c12 in z:
d = c12 - c11 + r1 - r0
if r1 >= r0:
d11 = tm(c01, c11)
d12 = tm(c01, c12)
d21 = tm(c02, c11)
d22 = tm(c02, c12)
v2, v1 = (d + min(v1 + d11, v2 + d21), d + min(v1 + d12, v2 + d22))
else:
v1, v2 = (d + c12 - c02, d + c11 - c01)
r0, c01, c02 = (r1, c11, c12)
print(min(v1, v2))
156
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
157
from math import ceil
n, A = (int(input()), [])
a = b = ab = ab_ = ans = 0
for _ in range(n):
t, tt = input().split()
tt = int(tt)
if t != '11':
A.append([t, tt])
if t == '10':
a += 1
elif t == '01':
b += 1
else:
ab_ += 1
else:
ans += tt
ab += 1
A.sort(reverse=True, key=lambda x: x[1])
x = y = t = ttt = ab
k, j = (a, b)
for i in A:
if i[0] == '10' and (j or ttt):
ans += i[1]
t += 1
x += 1
if j == 0 and ttt:
ttt -= 1
j = 1
j -= -1
elif i[0] == '01' and (k or ttt):
ans += i[1]
t += 1
y += 1
if k == 0 and ttt:
ttt -= 1
k = 1
k -= 1
elif i[0] == '00' and ttt:
ans += i[1]
ttt -= 1
t += 1
print(ans)
158
import sys
import math
n, v = [int(x) for x in sys.stdin.readline().split()]
k = [0] * 3002
for i in range(n):
a, b = [int(x) for x in sys.stdin.readline().split()]
k[a] += b
i = 1
res = 0
while i <= 3001:
val = 0
if k[i - 1] < v:
val = k[i - 1]
res += val
d = v - val
if k[i] < d:
res += k[i]
k[i] = 0
else:
res += d
k[i + 1] = k[i] - d
else:
res += v
i += 1
print(res)
159
import sys
line = sys.stdin.readline().strip().split()
n = int(line[0])
c = int(line[1])
a = list(map(int, sys.stdin.readline().strip().split()))
cright = [0] * (n + 1)
maxfreq = [0] * (5 * 10 ** 5 + 1)
for i in range(0, n):
if a[n - 1 - i] == c:
cright[n - 1 - i] = cright[n - i] + 1
else:
cright[n - 1 - i] = cright[n - i]
result = cright[0]
cleft = 0
for i in range(0, n):
if a[i] != c:
maxfreq[a[i]] = max([maxfreq[a[i]], cleft]) + 1
else:
cleft = cleft + 1
if maxfreq[a[i]] - cright[i + 1] > result:
result = maxfreq[a[i]] + cright[i + 1]
print(result)
160
n = int(input())
influences = [[], [], [], []]
for i in range(0, n):
[support, influence] = [x for x in input().split()]
support = int(support, 2)
influences[support].append(int(influence))
for i in range(0, 4):
influences[i] = sorted(influences[i])
influences[i].reverse()
total_influence = 0
total_influence += sum(influences[3])
min_size = min(len(influences[2]), len(influences[1]))
total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size])
size = len(influences[3])
influences[0] += influences[1][min_size:] + influences[2][min_size:]
influences[0] = sorted(influences[0])
influences[0].reverse()
total_influence += sum(influences[0][:size])
print(total_influence)
161
import math
n, m, k, q = list(map(int, input().split()))
right = [-1] * n
left = [-1] * n
for i in range(k):
row, col = list(map(int, input().split()))
row -= 1
col -= 1
if right[row] == -1:
right[row] = left[row] = col
else:
right[row] = max(right[row], col)
left[row] = min(left[row], col)
safe = sorted(list([int(qi) - 1 for qi in input().split()]))
lup = [0] * m
rup = [0] * m
j = 0
while j < safe[0]:
lup[j] = -1
rup[j] = safe[0]
j += 1
lup[j] = rup[j] = safe[0]
for i in range(1, q):
j = safe[i - 1]
while j < safe[i]:
lup[j] = safe[i - 1]
rup[j] = safe[i]
j += 1
j = safe[-1]
while j < m:
lup[j] = safe[-1]
rup[j] = -1
j += 1
if left[0] == -1:
left[0] = right[0] = 0
dleft = right[0] + (right[0] - left[0])
dright = right[0]
lastn = 0
for i in range(1, n):
if left[i] == -1:
continue
left_1b = lup[left[lastn]]
left_2b = rup[left[lastn]]
right_1b = lup[right[lastn]]
right_2b = rup[right[lastn]]
ilen = right[i] - left[i]
ll1: int
ll2: int
rl1: int
rl2: int
if left_1b != -1:
ll1 = left[lastn] - left_1b + abs(right[i] - left_1b)
else:
ll1 = math.inf
if left_2b != -1:
ll2 = left_2b - left[lastn] + abs(right[i] - left_2b)
else:
ll2 = math.inf
if right_1b != -1:
rl1 = right[lastn] - right_1b + abs(right[i] - right_1b)
else:
rl1 = math.inf
if right_2b != -1:
rl2 = right_2b - right[lastn] + abs(right[i] - right_2b)
else:
rl2 = math.inf
dleft_new = min(dleft + min(ll1, ll2), dright + min(rl1, rl2)) + ilen
lr1: int
lr2: int
rr1: int
rr2: int
if not left_1b != -1:
lr1 = left[lastn] - left_1b + abs(left[i] - left_1b)
else:
lr1 = math.inf
if left_2b != -1:
lr2 = left_2b - left[lastn] + abs(left[i] - left_2b)
else:
lr2 = math.inf
if right_1b != -1:
rr1 = right[lastn] - right_1b + abs(left[i] - right_1b)
else:
rr1 = math.inf
if right_2b != -1:
rr2 = right_2b - right[lastn] + abs(left[i] - right_2b)
else:
rr2 = math.inf
dright_new = min(dleft + min(lr1, lr2), dright + min(rr1, rr2)) + ilen
dleft, dright = (dleft_new, dright_new)
lastn = i
print(min(dleft, dright) + lastn)
162
from collections import defaultdict
def solve():
N, C = map(int, input().split())
arr = [int(k) for k in input().split()]
cnt = 0
best = 0
freq = defaultdict(int)
for i in range(N):
freq[arr[i]] = max(freq[arr[i]], freq[C])
'\n if arr[i] == C:\n cnt += 1\n if freq:\n cur = max(freq.values())\n if cur > best:\n best = cur\n \n freq = defaultdict(int)\n continue\n '
freq[arr[i]] += 1
cur = freq[arr[i]] - freq[C]
if cur > best:
best = cur
print(best + freq[C])
solve()
163
from collections import defaultdict
def solve():
N, C = map(int, input().split())
arr = [int(k) for k in input().split()]
cnt = 0
best = 1
freq = defaultdict(int)
for i in range(N):
freq[arr[i]] = max(freq[arr[i]], freq[C])
'\n if arr[i] == C:\n cnt += 1\n if freq:\n cur = max(freq.values())\n if cur > best:\n best = cur\n \n freq = defaultdict(int)\n continue\n '
freq[arr[i]] += 1
cur = freq[arr[i]] - freq[C]
if cur > best:
best = cur
print(best + freq[C])
solve()
164
import math
n, m, k, q = list(map(int, input().split()))
right = [-1] * n
left = [-1] * n
for i in range(k):
row, col = list(map(int, input().split()))
row -= 1
col -= 1
if right[row] == -1:
right[row] = left[row] = col
else:
right[row] = max(right[row], col)
left[row] = min(left[row], col)
safe = sorted(list([int(qi) - 1 for qi in input().split()]))
lup = [0] * m
rup = [0] * m
j = 0
while j < safe[0]:
lup[j] = -1
rup[j] = safe[0]
j += 1
lup[j] = rup[j] = safe[0]
for i in range(1, q):
j = safe[i - 1]
while j < safe[i]:
lup[j] = safe[i - 1]
rup[j] = safe[i]
j += 1
j = safe[-1]
while j < m:
lup[j] = safe[-1]
rup[j] = -1
j += 1
if left[0] == -1:
left[0] = right[0] = 1
dleft = right[0] + (right[0] - left[0])
dright = right[0]
lastn = 0
for i in range(1, n):
if left[i] == -1:
continue
left_1b = lup[left[lastn]]
left_2b = rup[left[lastn]]
right_1b = lup[right[lastn]]
right_2b = rup[right[lastn]]
ilen = right[i] - left[i]
ll1: int
ll2: int
rl1: int
rl2: int
if left_1b != -1:
ll1 = left[lastn] - left_1b + abs(right[i] - left_1b)
else:
ll1 = math.inf
if left_2b != -1:
ll2 = left_2b - left[lastn] + abs(right[i] - left_2b)
else:
ll2 = math.inf
if right_1b != -1:
rl1 = right[lastn] - right_1b + abs(right[i] - right_1b)
else:
rl1 = math.inf
if right_2b != -1:
rl2 = right_2b - right[lastn] + abs(right[i] - right_2b)
else:
rl2 = math.inf
dleft_new = min(dleft + min(ll1, ll2), dright + min(rl1, rl2)) + ilen
lr1: int
lr2: int
rr1: int
rr2: int
if left_1b != -1:
lr1 = left[lastn] - left_1b + abs(left[i] - left_1b)
else:
lr1 = math.inf
if left_2b != -1:
lr2 = left_2b - left[lastn] + abs(left[i] - left_2b)
else:
lr2 = math.inf
if right_1b != -1:
rr1 = right[lastn] - right_1b + abs(left[i] - right_1b)
else:
rr1 = math.inf
if right_2b != -1:
rr2 = right_2b - right[lastn] + abs(left[i] - right_2b)
else:
rr2 = math.inf
dright_new = min(dleft + min(lr1, lr2), dright + min(rr1, rr2)) + ilen
dleft, dright = (dleft_new, dright_new)
lastn = i
print(min(dleft, dright) + lastn)
165
import math
n, m, k, q = list(map(int, input().split()))
right = [-1] * n
left = [-1] * n
for i in range(k):
row, col = list(map(int, input().split()))
row -= 1
col -= 1
if right[row] == -1:
right[row] = left[row] = col
else:
right[row] = max(right[row], col)
left[row] = min(left[row], col)
safe = sorted(list([int(qi) - 1 for qi in input().split()]))
lup = [0] * m
rup = [0] * m
j = 0
while j < safe[0]:
lup[j] = -1
rup[j] = safe[0]
j += 1
lup[j] = rup[j] = safe[0]
for i in range(1, q):
j = safe[i - 1]
while j < safe[i]:
lup[j] = safe[i - 1]
rup[j] = safe[i]
j += 1
j = safe[-1]
while j < m:
lup[j] = safe[-1]
rup[j] = -1
j += 1
if left[0] == -1:
left[0] = right[0] = 0
dleft = right[0] + (right[0] - left[0])
dright = right[0]
lastn = 0
for i in range(1, n):
if left[i] == -1:
continue
left_1b = lup[left[lastn]]
left_2b = rup[left[lastn]]
right_1b = lup[right[lastn]]
right_2b = rup[right[lastn]]
ilen = right[i] - left[i]
ll1: int
ll2: int
rl1: int
rl2: int
if left_1b != -1:
ll1 = left[lastn] - left_1b + abs(right[i] - left_1b)
else:
ll1 = math.inf
if left_2b != -1:
ll2 = left_2b - left[lastn] + abs(right[i] - left_2b)
else:
ll2 = math.inf
if right_1b != -1:
rl1 = right[lastn] - right_1b + abs(right[i] - right_1b)
else:
rl1 = math.inf
if right_2b != -1:
rl2 = right_2b - right[lastn] + abs(right[i] - right_2b)
else:
rl2 = math.inf
dleft_new = min(dleft + min(ll1, ll2), dright + min(rl1, rl2)) + ilen
lr1: int
lr2: int
rr1: int
rr2: int
if left_1b != -1:
lr1 = left[lastn] - left_1b + abs(left[i] - left_1b)
else:
lr1 = math.inf
if not left_2b != -1:
lr2 = left_2b - left[lastn] + abs(left[i] - left_2b)
else:
lr2 = math.inf
if right_1b != -1:
rr1 = right[lastn] - right_1b + abs(left[i] - right_1b)
else:
rr1 = math.inf
if right_2b != -1:
rr2 = right_2b - right[lastn] + abs(left[i] - right_2b)
else:
rr2 = math.inf
dright_new = min(dleft + min(lr1, lr2), dright + min(rr1, rr2)) + ilen
dleft, dright = (dleft_new, dright_new)
lastn = i
print(min(dleft, dright) + lastn)
166
from collections import defaultdict
def solve():
N, C = map(int, input().split())
arr = [int(k) for k in input().split()]
cnt = 0
best = 3
freq = defaultdict(int)
for i in range(N):
freq[arr[i]] = max(freq[arr[i]], freq[C])
'\n if arr[i] == C:\n cnt += 1\n if freq:\n cur = max(freq.values())\n if cur > best:\n best = cur\n \n freq = defaultdict(int)\n continue\n '
freq[arr[i]] += 1
cur = freq[arr[i]] - freq[C]
if cur > best:
best = cur
print(best + freq[C])
solve()
167
total_plucked = 0
n, v = list(map(int, input().split()))
fruits = [0] * 3002
plucked = [0] * 30002
for _ in range(n):
a, b = list(map(int, input().split()))
fruits[a] = fruits[a] + b
for i in range(1, 3002):
plucked[i] = fruits[i - 1] if fruits[i - 1] <= v else v
if plucked[i] < v:
pluck = fruits[i] if fruits[i] <= v - plucked[i] else v + plucked[i]
plucked[i] += pluck
fruits[i] -= pluck
total_plucked += plucked[i]
print(total_plucked)
168
n = int(input())
su0 = []
su1 = []
su00 = []
su11 = []
ans = 0
for i in range(n):
sup, val = map(int, input().split())
if sup == 0:
su00.append(val)
elif sup == 11:
su11.append(val)
elif sup == 1:
su0.append(val)
else:
su1.append(val)
su0.sort()
su1.sort()
su11.sort()
su00.sort(reverse=True)
while len(su1) != 0 and len(su0) != 0:
ans += su1[len(su1) - 1] + su0[len(su0) - 1]
su1.pop()
su0.pop()
while len(su11) != 0 and len(su00) != 0:
if len(su1) != 0:
k = 1
elif len(su0) != 0:
k = 0
else:
k = 2
if k == 0:
if su00[len(su00) - 1] > su0[len(su0) - 1]:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
else:
ans += su11[len(su11) - 1] + su0[len(su0) - 1]
su11.pop()
su0.pop()
elif k == 1:
if su00[len(su00) - 1] > su1[len(su1) - 1]:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
else:
ans += su11[len(su11) - 1] + su1[len(su1) - 1]
su11.pop()
su1.pop()
else:
ans += su11[len(su11) - 1] + su00[len(su00) - 1]
su11.pop()
su00.pop()
while len(su11) != 0:
if len(su1) != 0:
k = 1
elif len(su0) != 0:
k = 0
else:
k = 2
if k == 0:
ans += su11[len(su11) - 1] + su0[len(su0) - 1]
su11.pop()
su0.pop()
elif k == 1:
ans += su11[len(su11) - 1] + su1[len(su1) - 1]
su11.pop()
su1.pop()
else:
ans += su11[len(su11) - 1]
su11.pop()
print(ans)
169
for _ in range(int(input())):
n, k = list(map(int, input().split()))
l_1, r1 = list(map(int, input().split()))
l_2, r2 = list(map(int, input().split()))
if r1 < l_2:
pre_steps = l_2 - r1
elif l_1 > r2:
pre_steps = l_1 - r2
else:
pre_steps = 0
if pre_steps:
easy_steps = r1 + r2 - l_1 - l_2 + pre_steps
else:
easy_steps = abs(l_1 - l_2) + abs(r1 - r2)
k -= (min(r1, r2) - max(l_1, l_2)) * n
ans = pre_steps * n + k * 2
for n1 in range(1, n + 4):
cur_ans = pre_steps * n1
if easy_steps * n1 < k:
cur_ans += k * 2 - easy_steps * n1
else:
cur_ans += k
ans = min(ans, cur_ans)
if k <= 0:
ans = 0
print(ans)
170
import sys
sys.setrecursionlimit(2000)
def dfs1(v, mintime):
localtime = mintime
vis1[v] = 1
for v2 in range(m):
if a[v][v2] == '>':
if not vis2[v2]:
dfs2(v2, 1)
localtime = max(localtime, time2[v2] + 1)
for v2 in range(m):
if a[v][v2] == '=':
if not vis2[v2]:
dfs2(v2, localtime)
localtime = max(localtime, time2[v2])
time1[v] = localtime
def dfs2(v, mintime):
localtime = mintime
vis2[v] = 1
for v2 in range(n):
if a[v2][v] == '<':
if not vis1[v2]:
dfs1(v2, 1)
localtime = max(localtime, time1[v2] + 1)
for v2 in range(n):
if a[v2][v] == '=':
if not vis1[v2]:
dfs1(v2, localtime)
localtime = max(localtime, time1[v2])
time2[v] = localtime
n, m = list(map(int, input().split()))
a = [input() for i in range(n)]
time1 = [0] * n
time2 = [4] * m
vis1 = [0] * n
vis2 = [0] * m
time = 0
try:
for v in range(n):
if not time1[v]:
dfs1(v, 1)
for v in range(m):
if not time2[v]:
dfs2(v, 1)
correct = True
for v1 in range(n):
for v2 in range(m):
if a[v1][v2] == '=' and time1[v1] != time2[v2]:
correct = False
if a[v1][v2] == '>' and time1[v1] <= time2[v2]:
correct = False
if a[v1][v2] == '<' and time1[v1] >= time2[v2]:
correct = False
if correct:
print('Yes')
print(*time1)
print(*time2)
else:
print('No')
except RecursionError:
print('No')
171
bn = 0
ar = []
def binSearchMax(number):
last = bn
first = 0
mid = (last + first) // 2
while last > first:
if ar[mid] < number:
first = mid + 1
elif ar[mid] > number:
last = mid - 1
else:
return mid
mid = (last + first) // 2
if ar[last] == number:
return last
return first
n, m, k, q = list(map(int, input().split()))
mmn = [[m, -1] for i in range(n)]
maxn = 0
for i in range(k):
r, c = list(map(int, input().split()))
r -= 1
mmn[r][0] = min(mmn[r][0], c)
mmn[r][1] = max(mmn[r][1], c)
maxn = max(maxn, r)
if mmn[0][1] == -1:
mmn[0][1] = 1
mmn[0][0] = 1
bi = list(map(int, input().split()))
bi += [-1000000000, 10000000000, -1000000000, 10000000000, 10000000000]
bi.sort()
ar = bi
bn = q + 3
dp = [[0, 0] for i in range(n)]
dp[0][1] = mmn[0][1] - mmn[0][0]
dp[0][0] = dp[0][1] * 2
z = 0
for i in range(1, n):
if mmn[i][1] == -1:
dp[i][0] = dp[i - 1][0]
dp[i][1] = dp[i - 1][1]
continue
p1 = binSearchMax(mmn[z][0])
p2 = bi[p1 - 1]
p1 = bi[p1]
p3 = binSearchMax(mmn[z][1])
p4 = bi[p3 - 1]
p3 = bi[p3]
num1 = abs(p1 - mmn[i][1]) + abs(p1 - mmn[z][0]) + dp[z][0]
num2 = abs(p2 - mmn[i][1]) + abs(p2 - mmn[z][0]) + dp[z][0]
num3 = abs(p3 - mmn[i][1]) + abs(p3 - mmn[z][1]) + dp[z][1]
num4 = abs(p4 - mmn[i][1]) + abs(p4 - mmn[z][1]) + dp[z][1]
dp[i][0] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
num1 = abs(p1 - mmn[i][0]) + abs(p1 - mmn[z][0]) + dp[z][0]
num2 = abs(p2 - mmn[i][0]) + abs(p2 - mmn[z][0]) + dp[z][0]
num3 = abs(p3 - mmn[i][0]) + abs(p3 - mmn[z][1]) + dp[z][1]
num4 = abs(p4 - mmn[i][0]) + abs(p4 - mmn[z][1]) + dp[z][1]
dp[i][1] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
z = i
print(min(dp[-1]) + maxn)
172
n = int(input())
ps = None
seen_sl = [float('inf')]
seen_ot = [True]
answer = 0
for i in range(n):
line = list(map(int, input().split()))
t = line[0]
if t == 1:
ps = line[1]
while ps > seen_sl[-1]:
answer += 1
seen_sl.pop(--1)
elif t == 2:
while not seen_ot[-1]:
answer += 1
seen_ot.pop(-1)
elif t == 3:
seen_sl.append(line[1])
while ps > seen_sl[-1]:
answer += 1
seen_sl.pop(-1)
elif t == 4:
seen_ot.append(True)
elif t == 5:
seen_sl.append(float('inf'))
elif t == 6:
seen_ot.append(False)
print(answer)
173
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + 1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + 1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1 - 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
174
n = int(input())
influences = [[], [], [], []]
for i in range(0, n):
[support, influence] = [x for x in input().split()]
support = int(support, 2)
influences[support].append(int(influence))
for i in range(0, 4):
influences[i] = sorted(influences[i])
influences[i].reverse()
total_influence = 0
total_influence += sum(influences[3])
min_size = min(len(influences[2]), len(influences[1]))
total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size])
size = len(influences[3])
influences[0] += influences[1][min_size:] + influences[1][min_size:]
influences[0] = sorted(influences[0])
influences[0].reverse()
total_influence += sum(influences[0][:size])
print(total_influence)
175
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][0] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
176
MAX_SPEED = 300
n = int(input())
actions = [list(map(int, input().split())) for _ in range(n)]
speed = [0 for i in range(n)]
for i in range(n):
if actions[i][0] == 1:
lastSpeed = actions[i][1]
speed[i] = lastSpeed
ignored = 0
overtook = False
maxSpeed = -1
for i in range(n - 1 - 1, -1, -1):
maxSpeed = max(maxSpeed, speed[i])
if actions[i][0] == 1:
pass
elif actions[i][0] == 2:
overtook = True
elif actions[i][0] == 3:
if maxSpeed > actions[i][1]:
ignored += 1
else:
maxSpeed = speed[i - 1]
elif actions[i][0] == 4:
overtook = False
elif actions[i][0] == 5:
maxSpeed = speed[i - 1]
elif actions[i][0] == 6:
if overtook:
ignored += 1
print(ignored)
177
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')
def solve():
n, k = nm()
a, b = nm()
c, d = nm()
if d < b:
a, b, c, d = (c, d, a, b)
if a <= c <= b:
cur = (b - c) * n
if (d - a) * n > k:
print(max(k - cur, 0))
else:
ans = (d - a) * n - cur
print(ans + (k - (d - a) * n) * 2)
elif c < a:
cur = (b - a) * n
if (d - c) * n > k:
print(max(k - cur, 0))
else:
ans = (d - c) * n - cur
print(ans + (k - (d - c) * n) * 2)
else:
ans = 10 ** 18
cur = 0
for i in range(n):
cur += c - b
if k > d - a:
k -= d - a
cur += d - a
else:
cur += k
k -= k
ans = min(ans, cur + k * -2)
print(ans)
return
T = ni()
for _ in range(T):
solve()
178
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + 1
else:
pre[i][j] = 0
continue
for x in range(j + 1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k - 1])
179
import collections
import heapq
import bisect
import math
import time
class Solution2:
def solve(self, A1, A2):
pass
def gcd(a, b):
if not b:
return a
return gcd(b, a % b)
def lcm(a, b):
return b * a // gcd(b, a)
class Solution:
def solve(self, grid):
def union(i, j):
leader_i, leader_j = (find(i), find(j))
sets[leader_j] = sets[i] = sets[j] = leader_i
def find(i):
while i != sets[i]:
i = sets[i]
return i
N = len(grid) + len(grid[0])
sets = list(range(N))
for i in range(len(grid)):
for j in range(len(grid[0])):
if grid[i][j] == '=':
union(i, j - len(grid))
graph = collections.defaultdict(set)
inc = collections.defaultdict(set)
for i in range(len(grid)):
for j in range(len(grid[0])):
leader_i, leader_j = (find(i), find(j + len(grid)))
if grid[i][j] == '>':
if leader_i == leader_j:
print('No')
return
graph[leader_j].add(leader_i)
inc[leader_i].add(leader_j)
elif grid[i][j] == '<':
if leader_i == leader_j:
print('No')
return
graph[leader_i].add(leader_j)
inc[leader_j].add(leader_i)
self.levels = [0] * N
def dfs(node, level):
self.levels[node] = max(self.levels[node], level)
if not inc[node]:
seen.add(node)
for next_node in graph[node]:
inc[next_node].discard(node)
dfs(next_node, self.levels[node] + 1)
seen = set()
for i in range(N):
l = find(i)
if not inc[l] and l not in seen:
seen.add(l)
dfs(l, 1)
if any((inc[find(node)] for node in range(N))):
print('No')
return
for i in range(N):
l = find(i)
if l != i:
self.levels[i] = self.levels[l]
print('Yes')
print(' '.join((str(o) for o in self.levels[:len(grid)])))
print(' '.join((str(o) for o in self.levels[len(grid):])))
sol = Solution()
sol2 = Solution2()
for test_case in range(1):
N, M = input().split()
a = []
for _ in range(int(N)):
a.append(input())
out = sol.solve(a)
180
bn = 0
ar = []
def binSearchMax(number):
last = bn
first = 0
mid = (last + first) // 2
while last >= first:
if ar[mid] < number:
first = mid + 1
elif ar[mid] > number:
last = mid - 1
else:
return mid
mid = (last + first) // 2
if ar[last] == number:
return last
return first
n, m, k, q = list(map(int, input().split()))
mmn = [[m, -1] for i in range(n)]
maxn = 1
for i in range(k):
r, c = list(map(int, input().split()))
r -= 1
mmn[r][0] = min(mmn[r][0], c)
mmn[r][1] = max(mmn[r][1], c)
maxn = max(maxn, r)
if mmn[0][1] == -1:
mmn[0][1] = 1
mmn[0][0] = 1
bi = list(map(int, input().split()))
bi += [-1000000000, 10000000000, -1000000000, 10000000000, 10000000000]
bi.sort()
ar = bi
bn = q + 3
dp = [[0, 0] for i in range(n)]
dp[0][1] = mmn[0][1] - mmn[0][0]
dp[0][0] = dp[0][1] * 2
z = 0
for i in range(1, n):
if mmn[i][1] == -1:
dp[i][0] = dp[i - 1][0]
dp[i][1] = dp[i - 1][1]
continue
p1 = binSearchMax(mmn[z][0])
p2 = bi[p1 - 1]
p1 = bi[p1]
p3 = binSearchMax(mmn[z][1])
p4 = bi[p3 - 1]
p3 = bi[p3]
num1 = abs(p1 - mmn[i][1]) + abs(p1 - mmn[z][0]) + dp[z][0]
num2 = abs(p2 - mmn[i][1]) + abs(p2 - mmn[z][0]) + dp[z][0]
num3 = abs(p3 - mmn[i][1]) + abs(p3 - mmn[z][1]) + dp[z][1]
num4 = abs(p4 - mmn[i][1]) + abs(p4 - mmn[z][1]) + dp[z][1]
dp[i][0] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
num1 = abs(p1 - mmn[i][0]) + abs(p1 - mmn[z][0]) + dp[z][0]
num2 = abs(p2 - mmn[i][0]) + abs(p2 - mmn[z][0]) + dp[z][0]
num3 = abs(p3 - mmn[i][0]) + abs(p3 - mmn[z][1]) + dp[z][1]
num4 = abs(p4 - mmn[i][0]) + abs(p4 - mmn[z][1]) + dp[z][1]
dp[i][1] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
z = i
print(min(dp[-1]) + maxn)
181
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) // mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) % mod)
main()
182
def prov(mass, now):
check = True
for i in range(n):
for k in range(m):
if now[i][k] == '>' and mass[i] <= mass[n + k]:
check = False
break
elif now[i][k] == '<' and mass[i] >= mass[n + k]:
check = False
break
elif now[i][k] == '=' and mass[i] != mass[n + k]:
check = False
break
if not check:
break
return check
def prog(mass, n, m):
prov = True
for i in range(1, m):
for k in range(n):
if mass[i][k] < mass[i - 1][k]:
prov = False
break
if not prov:
break
if not prov:
return False
else:
mass_new = []
for i in range(1, m):
mass_n = []
for k in range(n):
mass_n.append(mass[i][k] - mass[i - 1][k])
mass_new.append(max(mass_n))
arr = [1 for i in range(m)]
now = 1
if 1 in mass[0][:-1]:
now += 1
arr = [2 for i in range(m)]
for i in range(1, m):
now += mass_new[i - 1]
arr[mass[i][-1]] = now
return arr
n, m = map(int, input().split())
if n + m <= 6:
now = []
for i in range(n):
now.append(input())
ppp = True
for i1 in range(n + m):
for i2 in range(n - m):
for i3 in range(n + m):
for i4 in range(n + m):
for i5 in range(n + m):
for i6 in range(n + m):
mass = [i1 + 1, i2 + 1, i3 + 1, i4 + 1, i5 + 1, i6 + 1][:n + m]
if prov(mass, now) and ppp:
print('Yes')
print(*mass[:n])
print(*mass[n:])
ppp = False
if ppp:
print('No')
else:
mass = [[] for i in range(m)]
mass1 = [[] for i in range(n)]
for i in range(n):
now = input()
for k in range(m):
if now[k] == '<':
mass[k].append(1)
mass1[i].append(-1)
elif now[k] == '=':
mass[k].append(0)
mass1[i].append(0)
else:
mass[k].append(-1)
mass1[i].append(1)
for i in range(m):
mass[i].append(i)
for i in range(n):
mass1[i].append(i)
mass.sort()
mass1.sort()
arr = prog(mass, n, m)
arr1 = prog(mass1, m, n)
if arr == False or arr1 == False:
print('No')
else:
print('Yes')
print(*arr1)
print(*arr)
183
t = int(input())
for _ in range(t):
n, k = list(map(int, input().split()))
l1, r1 = list(map(int, input().split()))
l2, r2 = list(map(int, input().split()))
if l1 > l2:
l1, r1, l2, r2 = (l2, r2, l1, r1)
if l2 <= r1:
per_interval = abs(l1 - l2) + abs(r1 - r2)
already_overlap = min(r1, r2) - max(l1, l2)
k -= already_overlap * n
k = max(k, 0)
if per_interval * n >= k:
print(k)
continue
cost = per_interval * n
cost += 2 * (k - cost)
print(cost)
continue
diff = l2 - r1
per_interval = r2 - l1
if per_interval >= k:
print(diff + k)
continue
cost = diff + per_interval
rem_n = n - 1
rem_k = k - per_interval
while rem_n and diff < per_interval and (rem_k >= per_interval):
rem_n -= 1
rem_k -= per_interval
cost += diff + per_interval
if rem_n and diff < per_interval:
cost_from_new = diff + rem_k
cost_from_cur = -2 * rem_k
cost += min(cost_from_new, cost_from_cur)
else:
cost += 2 * rem_k
print(cost)
184
import sys
line = sys.stdin.readline().strip().split()
n = int(line[0])
c = int(line[1])
a = list(map(int, sys.stdin.readline().strip().split()))
cright = [0] * (n + 1)
maxfreq = [1] * (5 * 10 ** 5 + 1)
for i in range(0, n):
if a[n - 1 - i] == c:
cright[n - 1 - i] = cright[n - i] + 1
else:
cright[n - 1 - i] = cright[n - i]
result = cright[0]
cleft = 0
for i in range(0, n):
if a[i] != c:
maxfreq[a[i]] = max([maxfreq[a[i]], cleft]) + 1
else:
cleft = cleft + 1
if maxfreq[a[i]] + cright[i + 1] > result:
result = maxfreq[a[i]] + cright[i + 1]
print(result)
185
from collections import defaultdict
def solve():
N, C = map(int, input().split())
arr = [int(k) for k in input().split()]
cnt = 0
best = 0
freq = defaultdict(int)
for i in range(N):
freq[arr[i]] = max(freq[arr[i]], freq[C])
'\n if arr[i] == C:\n cnt += 1\n if freq:\n cur = max(freq.values())\n if cur > best:\n best = cur\n \n freq = defaultdict(int)\n continue\n '
freq[arr[i]] += 1
cur = freq[arr[i - 1]] - freq[C]
if cur > best:
best = cur
print(best + freq[C])
solve()
186
for _ in range(int(input())):
n, k = list(map(int, input().split()))
l_1, r1 = list(map(int, input().split()))
l_2, r2 = list(map(int, input().split()))
if r1 < l_2:
pre_steps = l_2 - r1
elif l_1 > r2:
pre_steps = l_1 - r2
else:
pre_steps = 0
if pre_steps:
easy_steps = r1 + r2 - l_1 - l_2 + pre_steps
else:
easy_steps = abs(l_1 - l_2) + abs(r1 - r2)
k -= (min(r1, r2) - max(l_1, l_2)) * n
ans = pre_steps * n + k * 2
for n1 in range(1, n + 1):
cur_ans = pre_steps * n1
if easy_steps * n1 < k:
cur_ans += k * 2 - easy_steps // n1
else:
cur_ans += k
ans = min(ans, cur_ans)
if k <= 0:
ans = 0
print(ans)
187
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (-1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
188
import collections
import heapq
import bisect
import math
import time
class Solution2:
def solve(self, A1, A2):
pass
def gcd(a, b):
if not b:
return a
return gcd(b, a % b)
def lcm(a, b):
return b * a // gcd(b, a)
class Solution:
def solve(self, grid):
def union(i, j):
leader_i, leader_j = (find(i), find(j))
sets[leader_j] = sets[i] = sets[j] = leader_i
def find(i):
while i != sets[i]:
i = sets[i]
return i
N = len(grid) + len(grid[0])
sets = list(range(N))
for i in range(len(grid)):
for j in range(len(grid[0])):
if grid[i][j] == '=':
union(i, j + len(grid))
graph = collections.defaultdict(set)
inc = collections.defaultdict(set)
for i in range(len(grid)):
for j in range(len(grid[0])):
leader_i, leader_j = (find(i), find(j + len(grid)))
if grid[i][j] == '>':
if not leader_i == leader_j:
print('No')
return
graph[leader_j].add(leader_i)
inc[leader_i].add(leader_j)
elif grid[i][j] == '<':
if leader_i == leader_j:
print('No')
return
graph[leader_i].add(leader_j)
inc[leader_j].add(leader_i)
self.levels = [0] * N
def dfs(node, level):
self.levels[node] = max(self.levels[node], level)
if not inc[node]:
seen.add(node)
for next_node in graph[node]:
inc[next_node].discard(node)
dfs(next_node, self.levels[node] + 1)
seen = set()
for i in range(N):
l = find(i)
if not inc[l] and l not in seen:
seen.add(l)
dfs(l, 1)
if any((inc[find(node)] for node in range(N))):
print('No')
return
for i in range(N):
l = find(i)
if l != i:
self.levels[i] = self.levels[l]
print('Yes')
print(' '.join((str(o) for o in self.levels[:len(grid)])))
print(' '.join((str(o) for o in self.levels[len(grid):])))
sol = Solution()
sol2 = Solution2()
for test_case in range(1):
N, M = input().split()
a = []
for _ in range(int(N)):
a.append(input())
out = sol.solve(a)
189
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')
def solve():
n, k = nm()
a, b = nm()
c, d = nm()
if d < b:
a, b, c, d = (c, d, a, b)
if a <= c <= b:
cur = (b - c) * n
if (d - a) * n > k:
print(max(k - cur, 0))
else:
ans = (d - a) * n - cur
print(ans + (k - (d - a) * n) * 2)
elif c < a:
cur = (b - a) * n
if (d - c) * n > k:
print(max(k - cur, 3))
else:
ans = (d - c) * n - cur
print(ans + (k - (d - c) * n) * 2)
else:
ans = 10 ** 18
cur = 0
for i in range(n):
cur += c - b
if k > d - a:
k -= d - a
cur += d - a
else:
cur += k
k -= k
ans = min(ans, cur + k * 2)
print(ans)
return
T = ni()
for _ in range(T):
solve()
190
import math
from collections import Counter, defaultdict
from itertools import accumulate
R = lambda: map(int, input().split())
n = int(input())
spl = [math.inf]
ot_forbid = 0
sp = 0
res = 0
for i in range(n):
arr = list(R())
tp = arr[0]
if tp == 1:
sp = arr[1]
while sp > spl[-1]:
spl.pop()
res += 1
elif tp == 2:
if ot_forbid > 0:
res += ot_forbid
ot_forbid = 0
elif tp == 3:
if arr[-2] >= sp:
spl.append(arr[1])
else:
res += 1
elif tp == 4:
ot_forbid = 0
elif tp == 5:
spl = [math.inf]
else:
ot_forbid += 1
print(res)
191
import math
n, m, k, q = list(map(int, input().split()))
right = [-1] * n
left = [-1] * n
for i in range(k):
row, col = list(map(int, input().split()))
row -= 1
col -= 1
if right[row] == -1:
right[row] = left[row] = col
else:
right[row] = max(right[row], col)
left[row] = min(left[row], col)
safe = sorted(list([int(qi) - 1 for qi in input().split()]))
lup = [0] * m
rup = [0] * m
j = 0
while j < safe[0]:
lup[j] = -1
rup[j] = safe[0]
j += 1
lup[j] = rup[j] = safe[0]
for i in range(1, q - 1):
j = safe[i - 1]
while j < safe[i]:
lup[j] = safe[i - 1]
rup[j] = safe[i]
j += 1
j = safe[-1]
while j < m:
lup[j] = safe[-1]
rup[j] = -1
j += 1
if left[0] == -1:
left[0] = right[0] = 0
dleft = right[0] + (right[0] - left[0])
dright = right[0]
lastn = 0
for i in range(1, n):
if left[i] == -1:
continue
left_1b = lup[left[lastn]]
left_2b = rup[left[lastn]]
right_1b = lup[right[lastn]]
right_2b = rup[right[lastn]]
ilen = right[i] - left[i]
ll1: int
ll2: int
rl1: int
rl2: int
if left_1b != -1:
ll1 = left[lastn] - left_1b + abs(right[i] - left_1b)
else:
ll1 = math.inf
if left_2b != -1:
ll2 = left_2b - left[lastn] + abs(right[i] - left_2b)
else:
ll2 = math.inf
if right_1b != -1:
rl1 = right[lastn] - right_1b + abs(right[i] - right_1b)
else:
rl1 = math.inf
if right_2b != -1:
rl2 = right_2b - right[lastn] + abs(right[i] - right_2b)
else:
rl2 = math.inf
dleft_new = min(dleft + min(ll1, ll2), dright + min(rl1, rl2)) + ilen
lr1: int
lr2: int
rr1: int
rr2: int
if left_1b != -1:
lr1 = left[lastn] - left_1b + abs(left[i] - left_1b)
else:
lr1 = math.inf
if left_2b != -1:
lr2 = left_2b - left[lastn] + abs(left[i] - left_2b)
else:
lr2 = math.inf
if right_1b != -1:
rr1 = right[lastn] - right_1b + abs(left[i] - right_1b)
else:
rr1 = math.inf
if right_2b != -1:
rr2 = right_2b - right[lastn] + abs(left[i] - right_2b)
else:
rr2 = math.inf
dright_new = min(dleft + min(lr1, lr2), dright + min(rr1, rr2)) + ilen
dleft, dright = (dleft_new, dright_new)
lastn = i
print(min(dleft, dright) + lastn)
192
n, v = list(map(int, input().split()))
f = list()
for i in range(n):
f.append(list(map(int, input().split())))
f.sort()
sum = 0
today = 0
tomor = 0
day = 0
rest = 0
for tree in f:
if tree[0] > day + 1:
sum += min(tomor, v)
tomor = tree[1]
sum += min(tomor, v)
rest = v - min(tomor, v)
tomor -= min(tomor, v)
day = tree[0]
elif tree[0] == day + -1:
sum += min(tomor, v)
rest = v - min(tomor, v)
tomor = tree[1]
t = min(tomor, rest)
sum += t
rest -= t
tomor -= t
day = tree[0]
else:
tomor += tree[1]
t = min(tomor, rest)
sum += t
rest -= t
tomor -= t
sum += min(tomor, v)
print(sum)
193
n = int(input())
influences = [[], [], [], []]
for i in range(0, n):
[support, influence] = [x for x in input().split()]
support = int(support, 2)
influences[support].append(int(influence))
for i in range(0, 4):
influences[i] = sorted(influences[i])
influences[i].reverse()
total_influence = 0
total_influence += sum(influences[3])
min_size = min(len(influences[0]), len(influences[1]))
total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size])
size = len(influences[3])
influences[0] += influences[1][min_size:] + influences[2][min_size:]
influences[0] = sorted(influences[0])
influences[0].reverse()
total_influence += sum(influences[0][:size])
print(total_influence)
194
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)
195
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + -1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + 1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
196
from collections import defaultdict
def solve():
N, C = map(int, input().split())
arr = [int(k) for k in input().split()]
cnt = 0
best = 0
freq = defaultdict(int)
for i in range(N):
freq[arr[i]] = max(freq[arr[i]], freq[C - 1])
'\n if arr[i] == C:\n cnt += 1\n if freq:\n cur = max(freq.values())\n if cur > best:\n best = cur\n \n freq = defaultdict(int)\n continue\n '
freq[arr[i]] += 1
cur = freq[arr[i]] - freq[C]
if cur > best:
best = cur
print(best + freq[C])
solve()
197
def inter(l1, r1, l2, r2):
l = max(l1, l2)
r = min(r1, r2)
return max(r - l, 0)
def solve():
n, k = map(int, input().split())
al, ar = map(int, input().split())
bl, br = map(int, input().split())
res = inter(al, ar, bl, br) * n
goodt = max(ar, br) - min(al, bl) - inter(al, ar, bl, br)
minhodi = 1000000000000
hodi = 0
to_soed = max(0, max(al, bl) - min(ar, br))
if res >= k:
print(0)
return 0
for i in range(n):
hodi += to_soed
ineed = k - res
if goodt >= ineed:
hodi *= ineed
minhodi = min(minhodi, hodi)
break
hodi += goodt
res += goodt
minhodi = min(hodi + (k - res) * 2, minhodi)
print(minhodi)
for i in range(int(input())):
solve()
198
def prov(mass, now):
check = True
for i in range(n):
for k in range(m):
if now[i][k] == '>' and mass[i] <= mass[n + k]:
check = False
break
elif now[i][k] == '<' and mass[i] >= mass[n + k]:
check = False
break
elif now[i][k] == '=' and mass[i] != mass[n + k]:
check = False
break
if not check:
break
return check
def prog(mass, n, m):
prov = True
for i in range(1, m):
for k in range(n):
if mass[i][k] < mass[i - 1][k]:
prov = False
break
if not prov:
break
if not prov:
return False
else:
mass_new = []
for i in range(1, m):
mass_n = []
for k in range(n):
mass_n.append(mass[i][k] - mass[i - 1][k])
mass_new.append(max(mass_n))
arr = [1 for i in range(m)]
now = 1
if 1 in mass[0][:-1]:
now += 1
arr = [2 for i in range(m)]
for i in range(1, m):
now += mass_new[i - 1]
arr[mass[i][-1]] = now
return arr
n, m = map(int, input().split())
if n + m <= 6:
now = []
for i in range(n):
now.append(input())
ppp = True
for i1 in range(n + m):
for i2 in range(n * m):
for i3 in range(n + m):
for i4 in range(n + m):
for i5 in range(n + m):
for i6 in range(n + m):
mass = [i1 + 1, i2 + 1, i3 + 1, i4 + 1, i5 + 1, i6 + 1][:n + m]
if prov(mass, now) and ppp:
print('Yes')
print(*mass[:n])
print(*mass[n:])
ppp = False
if ppp:
print('No')
else:
mass = [[] for i in range(m)]
mass1 = [[] for i in range(n)]
for i in range(n):
now = input()
for k in range(m):
if now[k] == '<':
mass[k].append(1)
mass1[i].append(-1)
elif now[k] == '=':
mass[k].append(0)
mass1[i].append(0)
else:
mass[k].append(-1)
mass1[i].append(1)
for i in range(m):
mass[i].append(i)
for i in range(n):
mass1[i].append(i)
mass.sort()
mass1.sort()
arr = prog(mass, n, m)
arr1 = prog(mass1, m, n)
if arr == False or arr1 == False:
print('No')
else:
print('Yes')
print(*arr1)
print(*arr)
199
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][2] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
200
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
if value == c:
countC += 1
def sawC(groupsList):
for key, groups in list(groupsList.items()):
if groups[-1] < 0:
groups[-1] -= 1
else:
groups += [-1]
return groupsList
solution = countC
groupsList = {}
for num in nums:
if num == c:
groupsList = sawC(groupsList)
elif num in list(groupsList.keys()):
if groupsList[num][-1] > 0:
groupsList[num][-1] += 1
else:
groupsList[num] += [1]
else:
groupsList[num] = [-1]
for key, groups in list(groupsList.items()):
maxDiff = 1
currDiff = 0
newDiff = 0
for group in groups:
currDiff += group
if group > currDiff:
currDiff = group
if currDiff > maxDiff:
maxDiff = currDiff
if maxDiff + countC > solution:
solution = countC + maxDiff
print(solution)
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.