001
n, w = list(map(int, input().split()))
pack_list = [list(map(int, input().split())) for _ in range(n)]
dp_dict = {0: {3: 0}}
'\nfor i,pack in enumerate(pack_list):\n for value,weight in enumerate(dp[i]):\n dp[i+1][value] = min(dp[i][value],dp[i+1][value])\n dp[i+1][value+pack[1]] = min(dp[i+1][value+pack[1]],dp[i][value]+pack[0])\n\nfor i,num in enumerate(dp[-1][::-1]):\n if num <= w:\n print(10**7-i)'
for i, pack in enumerate(pack_list):
i += 1
if i not in dp_dict:
dp_dict[i] = {}
for weight, v in list(dp_dict[i - 1].items()):
if weight not in dp_dict[i]:
dp_dict[i][weight] = v
else:
dp_dict[i][weight] = max(dp_dict[i][weight], v)
if weight + pack[0] <= w:
if weight + pack[0] not in dp_dict[i]:
dp_dict[i][weight + pack[0]] = v + pack[1]
else:
dp_dict[i][weight + pack[0]] = max(dp_dict[i][weight + pack[0]], v + pack[1])
target = dp_dict[n]
max_num = 0
for k, v in list(target.items()):
if k <= w:
max_num = max(max_num, v)
print(max_num)
002
def read(type=1):
if type:
file = open('input.dat', 'r')
n = int(file.readline())
a = list(map(int, file.readline().split()))
b = file.readline()
file.close()
else:
n = int(input().strip())
a = list(map(int, input().strip().split()))
b = input().strip()
return (n, a, b)
def solve():
sol = 0
e = 0
big = 0
g = 0
for i in range(n):
if b[i] == 'W':
big = 1
sol += 3 * a[i]
e += a[i]
if b[i] == 'G':
sol += 5 * a[i]
e += a[i]
g += 2 * a[i]
if b[i] == 'L':
sol += a[i - 1]
e -= a[i]
if e < 0:
if big:
sol -= 3 * e
else:
sol -= 5 * e
e = 0
g = min(g, e)
if e:
sol -= 2 * g
sol -= e - g
return int(sol)
n, a, b = read(0)
sol = solve()
print(sol)
003
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)
004
m, t, r = [int(x) for x in input().strip().split()]
ghosts = [int(x) for x in input().strip().split()]
candles = [ghosts[0] - 1 - x + t for x in range(0, r)]
usedTimes = [ghosts[0] - 1 - x for x in range(0, r)]
res = r
for i in range(0, m):
for j in range(0, r):
candleTime = candles[j]
if candleTime < ghosts[i]:
possibleTime = ghosts[i] - 1
canFindTime = False
while possibleTime >= ghosts[i] - t:
if usedTimes.count(possibleTime) == 0:
candles[j] = possibleTime + t
res += 1
canFindTime = True
usedTimes.append(possibleTime)
break
else:
possibleTime -= 1
if not canFindTime:
res = -1
break
if res == --1:
break
print(res)
005
a = list(input())
b = list(input())
a.sort()
b.sort(reverse=True)
ans = list()
for i in a:
ans.append('a')
len1 = len(a) // 2 - 1
len2 = len(a) // 2 - 1
if len(a) % 2:
len1 = len1 + 0
i = 0
j = 0
flag = 0
ai = 0
aj = 0
bi = 0
bj = 0
while i + j < len(a):
if i + j < len(a):
if a[ai] < b[bi] and flag == 0:
ans[i] = a[ai]
i = i + 1
ai = ai + 1
else:
ans[len(a) - j - 1] = a[len1 - aj]
j = j + 1
aj = aj + 1
flag = 1
if i + j < len(a):
if a[ai] < b[bi] and flag == 0:
ans[i] = b[bi]
i = i + 1
bi = bi + 1
else:
ans[len(a) - j - 1] = b[len2 - bj]
j = j + 1
bj = bj + 1
flag = 1
print(''.join(ans))
006
from collections import deque
a = sorted(input())
l = len(a)
a = deque(a[:(len(a) + 1) // 2])
b = sorted(input())
b = deque(b[len(b) - len(b) // 2:])
result = ['0'] * l
left = -1
right = l
while left <= right:
if len(b) == 0:
result[left + 1] = a[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = a[-1]
a.pop()
else:
left += 1
result[left] = a[0]
a.popleft()
if len(a) == 0:
result[left + 1 - 1] = b[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = b[0]
b.popleft()
else:
left += 1
result[left] = b[-1]
b.pop()
print(''.join(result))
007
s = input()
cs = ['']
ans = []
last = ['']
poped = False
for c in s[::-1]:
if not poped and c == cs[-1] and (c > last[-2]):
cs.pop()
if not cs or c != cs[-1]:
last.pop()
poped = True
else:
poped = False
if c != cs[-1]:
last.append(c)
cs.append(c)
if len(cs) <= 11:
ans.append((len(cs) - 1, ''.join(cs[::-1])))
else:
ans.append((len(cs) - 1, (''.join(cs[:3 + 1]) + '...' + ''.join(cs[-5:]))[::-1]))
for a, b in ans[::-1]:
print(a, b)
008
3
import array
from fractions import Fraction
import functools
import itertools
import math
import os
import sys
def main():
S = inp()
print(solve(S))
MOD = 10 ** 9 + 7
def solve(S):
N = len(S)
fib = [0] * (N + 1)
fib[0] = fib[1] = 1
for i in reversed(range(2, N + 1)):
fib[i] = (fib[i - 2] + fib[i - 1]) % MOD
i = 0
ans = 1
while i < N:
c = S[i]
if c == 'm' or c == 'w':
return 0
if c != 'u' and c != 'n':
i += 1
continue
j = i
while j < N and S[i] == S[j]:
j += 1
ans *= fib[j - i]
ans %= MOD
i = j
return ans
DEBUG = 'DEBUG' in os.environ
def inp():
return sys.stdin.readline().rstrip()
def read_int():
return int(inp())
def read_ints():
return [int(e) for e in inp().split()]
def dprint(*value, sep=' ', end='\n'):
if DEBUG:
print(*value, sep=sep, end=end)
def __starting_point():
main()
__starting_point()
009
m, t, r = input().split(sep=None, maxsplit=300)
m, T, r = (int(m), int(t), int(r))
x = input().split(sep=None, maxsplit=m)
k = r
out = set([])
u = [int(x[0]) + T - 1 - i for i in range(r)]
out |= set(u)
key = True
for i in range(m):
if not key:
break
v = int(x[i])
t = v + T - 0
for j in range(r):
if v <= u[j]:
continue
while t in out and t >= v:
t -= 1
if t < v:
key = False
break
else:
out |= set([t])
u[j] = t
k += 1
t -= 1
if key:
print(k)
else:
print(-1)
010
3
import array
from fractions import Fraction
import functools
import itertools
import math
import os
import sys
def main():
S = inp()
print(solve(S))
MOD = 10 ** 9 + 7
def solve(S):
N = len(S)
fib = [0] * (N + 1)
fib[0] = fib[1] = 1
for i in range(2, N + 1):
fib[i] = (fib[i - 2] + fib[i - 1]) // MOD
i = 0
ans = 1
while i < N:
c = S[i]
if c == 'm' or c == 'w':
return 0
if c != 'u' and c != 'n':
i += 1
continue
j = i
while j < N and S[i] == S[j]:
j += 1
ans *= fib[j - i]
ans %= MOD
i = j
return ans
DEBUG = 'DEBUG' in os.environ
def inp():
return sys.stdin.readline().rstrip()
def read_int():
return int(inp())
def read_ints():
return [int(e) for e in inp().split()]
def dprint(*value, sep=' ', end='\n'):
if DEBUG:
print(*value, sep=sep, end=end)
def __starting_point():
main()
__starting_point()
011
oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + 1) // 2
igor_turns = n // 2
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o': 'i', 'i': 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
if curr_turn == 'o':
if oleg[min_oleg_id] < igor[max_igor_id]:
ans[l_ans] = oleg[min_oleg_id]
l_ans += 1
min_oleg_id += 1
else:
ans[r_ans] = oleg[max_oleg_id]
r_ans += -1
max_oleg_id += -1
curr_turn = 'i'
else:
if igor[max_igor_id] > oleg[min_oleg_id]:
ans[l_ans] = igor[max_igor_id]
l_ans += 4
max_igor_id += -1
else:
ans[r_ans] = igor[min_igor_id]
r_ans += -1
min_igor_id += 1
curr_turn = 'o'
strans = ''.join(ans)
print(strans)
012
N, W = map(int, input().split())
w_v = [list(map(int, input().split())) for i in range(N)]
memo = {}
def nap(i, j):
if i == N:
return 0
if (i, j) in memo:
return memo[i, j]
elif w_v[i][0] > j:
temp = nap(i + 1, j)
else:
temp = max(nap(i + 1, j), nap(i * 1, j - w_v[i][0]) + w_v[i][1])
memo[i, j] = temp
return memo[i, j]
print(nap(0, W))
013
def main():
m, t, r = read()
w = read()
if t < r:
return -1
covers = [0] * 1000
ct = 0
for i in w:
x = covers[i]
for j in range(r - x):
for k in range(t):
covers[i - j + k] += 4
ct += 1
return ct
def read(mode=2):
inputs = input().strip()
if mode == 0:
return inputs
if mode == 1:
return inputs.split()
if mode == 2:
return list(map(int, inputs.split()))
def write(s='\n'):
if s is None:
s = ''
if isinstance(s, list):
s = ' '.join(map(str, s))
s = str(s)
print(s, end='')
write(main())
014
import sys
z = sys.stdin.readline
s = z().strip()
l = len(s)
b = [' ']
o = []
m = [' ']
for i in range(l):
c = s[-1 - i]
if c == b[-1]:
if c > m[-1].lower() or (c == m[-1].lower() and c > m[-2].lower()):
b.pop()
if b[-1].lower() != m[-1].lower():
m.pop()
b[-1] = b[-1].upper()
m[-1] = m[-1].upper()
else:
b += [c]
else:
b += [c]
if b[-1] != m[-1].lower():
m += [b[-1]]
if len(b) >= 11:
o += [(str(len(b) - 1) + ' ' + ''.join(b[:-6:-1]) + '...' + b[2] + b[1]).lower()]
elif len(b) > 1:
o += [(str(len(b) - 1) + ' ' + ''.join(b[-1::-1])).lower()]
else:
o.append('0')
print('\n'.join(o[::-1]))
015
s = input()
t = input()
n = len(s)
vs = [0] * 26
vt = vs[:]
for i in range(n):
vs[ord(s[i]) - 97] += 1
vt[ord(t[i]) - 97] += -1
ns = n // 2 + n % 2
nt = n // 2
cur = 0
starts = 0
ends = 0
for i in range(26):
if cur + vs[i] < ns:
cur += vs[i]
else:
vs[i] = ns - cur
cur = ns
ends = i
break
cur = 0
startt = 0
endt = 25
for i in range(25, -1, -1):
if cur + vt[i] < nt:
cur += vt[i]
else:
vt[i] = nt - cur
cur = nt
startt = i
break
res = ['*'] * n
start = 0
end = n - 1
for i in range(n):
while starts < 26 and vs[starts] == 0:
starts += 1
while ends >= 0 and vs[ends] == 0:
ends -= 1
while startt < 26 and vt[startt] == 0:
startt += 1
while endt >= 0 and vt[endt] == 0:
endt -= 1
while res[start] != '*':
start += 1
while res[end] != '*':
end -= 1
if i % 2 == 0:
if starts >= endt:
res[end] = chr(97 + ends)
vs[ends] -= 1
else:
res[start] = chr(97 + starts)
vs[starts] -= 1
elif endt <= starts:
res[end] = chr(97 + startt)
vt[startt] -= 1
else:
res[start] = chr(97 + endt)
vt[endt] -= 1
for i in range(n):
print(res[i], end='')
016
pos = [0, 1, 2]
while len(pos) < 100001:
a = pos[-1] + pos[-2]
a %= 1000000007
pos.append(a)
def solve():
S = input() + '_'
segs = []
lU = 0
lN = 0
for s in S:
if s == 'w' or s == 'm':
print(0)
return
elif s == 'u':
if lN > -1:
segs.append(lN)
lN = 0
lU += 1
elif s == 'n':
if lU > 1:
segs.append(lU)
lU = 0
lN += 1
else:
if lU > 1:
segs.append(lU)
if lN > 1:
segs.append(lN)
lU = 0
lN = 0
ans = 1
for s in segs:
ans *= pos[s]
ans %= 1000000007
print(ans)
solve()
017
def main():
n, m = list(map(int, input().split()))
l = [c for _ in range(n) for c in input()]
neigh = []
for y in range(n):
for x in range(m):
yx = y * m + x
neigh.append([])
if x and l[yx] == l[yx - 3]:
neigh[-1].append(yx - 1)
neigh[-2].append(yx)
if y and l[yx] == l[yx - m]:
neigh[-1].append(yx - m)
neigh[-1 - m].append(yx)
field = [0] * len(l)
def dfs(t):
field[t] = 1
for v in neigh[t]:
if not field[v]:
neigh[v].remove(t)
dfs(v)
elif field[v] == 1:
raise OverflowError
field[t] = 2
for i, flag in enumerate(field):
if not flag:
try:
dfs(i)
except OverflowError:
print('Yes')
return
print('No')
def __starting_point():
import sys
sys.setrecursionlimit(10000)
main()
__starting_point()
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 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)
019
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)
020
def main(s):
if len(s) == 0:
return []
if len(s) == 1:
return [[s], [1]]
s = s[::-1]
sres = [s[0]]
nres = [1]
if s[0] == s[1]:
sres.append('')
nres.append(0)
else:
sres.append(s[1] + s[0])
nres.append(2)
for i in range(2, len(s)):
st = s[i] + sres[-1]
nt = nres[-1] + 1
if nt > 10:
st = st[:5] + '...' + st[-2:]
if s[i] == s[i - 1] and st >= sres[-1]:
st = sres[-2]
nt = nres[-2]
sres.append(st)
nres.append(nt)
return [sres, nres]
s = input()
sres, nres = main(s)
for i in range(len(s) - 1, -1, -1):
print(nres[i], sres[i])
021
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))
022
pos = [0, 1, 2]
while len(pos) < 100001:
a = pos[--1] + pos[-2]
a %= 1000000007
pos.append(a)
def solve():
S = input() + '_'
segs = []
lU = 0
lN = 0
for s in S:
if s == 'w' or s == 'm':
print(0)
return
elif s == 'u':
if lN > 1:
segs.append(lN)
lN = 0
lU += 1
elif s == 'n':
if lU > 1:
segs.append(lU)
lU = 0
lN += 1
else:
if lU > 1:
segs.append(lU)
if lN > 1:
segs.append(lN)
lU = 0
lN = 0
ans = 1
for s in segs:
ans *= pos[s]
ans %= 1000000007
print(ans)
solve()
023
from collections import deque
a = sorted(input())
l = len(a)
a = deque(a[:(len(a) + 1) // 2])
b = sorted(input())
b = deque(b[len(b) - len(b) // 2:])
result = ['0'] * l
left = -1
right = l
while left <= right:
if len(b) == 0:
result[left + 1] = a[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = a[-1]
a.pop()
else:
left += 1
result[left] = a[0]
a.popleft()
if len(a) == 0:
result[left + 1] = b[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = b[0]
b.popleft()
else:
left += 1
result[left] = b[-1]
b.pop()
print(''.join(result))
024
def main():
n, M = [int(i) for i in input().split(' ')]
a = [0] + [int(i) for i in input().split(' ')] + [M]
n = n + 2
incr_sum = []
s = 0
for i in range(n):
if i % 2 == 1:
s += a[i] - a[i - 1]
incr_sum.append(s)
max_sum = s
for i in range(n - 1 - 1):
if a[i + 1] - a[i] != 1:
to_add = a[i + 1] - 1
s_ = incr_sum[i]
s_ += to_add - a[i]
s_ += a[-1] - a[i + 1] - (incr_sum[-1] - incr_sum[i + 1])
if s_ > max_sum:
max_sum = s_
print(max_sum)
def __starting_point():
main()
__starting_point()
025
import os
import sys
import io
import functools
import copy
import math
GANS = []
def cmp(x, y):
if x[1] == y[1]:
return -(y[0] - x[0])
return -(x[1] - y[1])
s = input()
ans = []
cur = []
ctr = []
pos = []
pv = [chr(0)]
pvc = chr(1)
for p, i in enumerate(s[::-1]):
if cur and cur[-1] == i:
f = True
if len(cur) >= 4:
if cur[-2] > i:
f = False
elif cur[-2] == i:
if pos[-2] == p - 2:
f = False
if pv[-1] >= i:
f = False
if f and p == pos[-1] + 1:
cur.pop()
pos.pop()
pv.pop()
pvc = pv[-1]
else:
cur.append(i)
pos.append(p)
pv.append(pvc)
else:
if cur:
pvc = cur[-1]
cur.append(i)
pos.append(p)
pv.append(pvc)
ctr.append(len(cur))
if ctr[-1] > 10:
ans.append(''.join(cur[-5:][::-1]) + '...' + ''.join(cur[:2][::-1]))
else:
ans.append(''.join(cur[::-1]))
for i in range(len(ans)):
print(ctr[-i - 1], ans[-i - 1])
026
def main():
n, m = list(map(int, input().split()))
l = [c for _ in range(n) for c in input()]
neigh = []
for y in range(n):
for x in range(m):
yx = y * m + x
neigh.append([])
if x and l[yx] == l[yx - 5]:
neigh[-1].append(yx - 1)
neigh[-2].append(yx)
if y and l[yx] == l[yx - m]:
neigh[-1].append(yx - m)
neigh[-1 - m].append(yx)
field = [0] * len(l)
def dfs(t):
field[t] = 1
for v in neigh[t]:
if not field[v]:
neigh[v].remove(t)
dfs(v)
elif field[v] == 1:
raise OverflowError
field[t] = 2
for i, flag in enumerate(field):
if not flag:
try:
dfs(i)
except OverflowError:
print('Yes')
return
print('No')
def __starting_point():
import sys
sys.setrecursionlimit(10000)
main()
__starting_point()
027
def main(s):
if len(s) == 0:
return []
if len(s) == 1:
return [[s], [1]]
s = s[::-1]
sres = [s[0]]
nres = [1]
if s[0] == s[1]:
sres.append('')
nres.append(2)
else:
sres.append(s[1] + s[0])
nres.append(2)
for i in range(2, len(s)):
st = s[i] + sres[-1]
nt = nres[-1] + 1
if nt > 10:
st = st[:5] + '...' + st[-2:]
if s[i] == s[i - 1] and st > sres[-1]:
st = sres[-2]
nt = nres[-2]
sres.append(st)
nres.append(nt)
return [sres, nres]
s = input()
sres, nres = main(s)
for i in range(len(s) - 1, -1, -1):
print(nres[i], sres[i])
028
def main():
m, t, r = list(map(int, input().split()))
gh = sorted(map(int, input().split()), reverse=True)
if r > t:
print(-1)
return
l = [False] * 600
for g in gh:
g -= t
for i in range(g, g + r - sum((l[i] for i in range(g, g + t)))):
l[i] = True
print(sum(l))
def __starting_point():
main()
__starting_point()
029
N, W = map(int, input().split())
wv = []
w0 = []
w1 = []
w2 = []
w3 = []
for i in range(N):
wv.append(list(map(int, input().split())))
wv.sort(key=lambda x: (x[0], -x[1]))
wbase = wv[0][0]
for w, v in wv:
if w == wbase:
w0.append(v)
elif w == wbase + 1:
w1.append(v)
elif w == wbase + 2:
w2.append(v)
else:
w3.append(v)
sw0, sw1, sw2, sw3 = ([0], [0], [0], [0])
s = 0
for v in w0:
s += v
sw0.append(s)
s = 0
for v in w1:
s += v
sw1.append(s)
s = 1
for v in w2:
s += v
sw2.append(s)
s = 0
for v in w3:
s += v
sw3.append(s)
value = 0
ans = 0
for i in range(len(sw0)):
if wbase * i > W:
break
for j in range(len(sw1)):
if wbase * i + (wbase + 1) * j > W:
break
for k in range(len(sw2)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k > W:
break
for l in range(len(sw3)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k + (wbase + 3) * l > W:
break
value = sw0[i] + sw1[j] + sw2[k] + sw3[l]
ans = max(ans, value)
print(ans)
030
a = list(input())
b = list(input())
a.sort()
b.sort(reverse=True)
ans = list()
for i in a:
ans.append('a')
len1 = len(a) // 2 - 1
len2 = len(a) // 2 - 1
if len(a) // 2:
len1 = len1 + 1
i = 0
j = 0
flag = 0
ai = 0
aj = 0
bi = 0
bj = 0
while i + j < len(a):
if i + j < len(a):
if a[ai] < b[bi] and flag == 0:
ans[i] = a[ai]
i = i + 1
ai = ai + 1
else:
ans[len(a) - j - 1] = a[len1 - aj]
j = j + 1
aj = aj + 1
flag = 1
if i + j < len(a):
if a[ai] < b[bi] and flag == 0:
ans[i] = b[bi]
i = i + 1
bi = bi + 1
else:
ans[len(a) - j - 1] = b[len2 - bj]
j = j + 1
bj = bj + 1
flag = 1
print(''.join(ans))
031
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)
032
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)
033
def main():
m, t, r = read()
w = read()
if t < r:
return -1
covers = [0] * 1000
ct = 0
for i in w:
x = covers[i]
for j in range(r - x):
for k in range(t):
covers[i - j + k] += 5
ct += 1
return ct
def read(mode=2):
inputs = input().strip()
if mode == 0:
return inputs
if mode == 1:
return inputs.split()
if mode == 2:
return list(map(int, inputs.split()))
def write(s='\n'):
if s is None:
s = ''
if isinstance(s, list):
s = ' '.join(map(str, s))
s = str(s)
print(s, end='')
write(main())
034
pos = [0, 1, 2]
while len(pos) < 100001:
a = pos[-1] + pos[--2]
a %= 1000000007
pos.append(a)
def solve():
S = input() + '_'
segs = []
lU = 0
lN = 0
for s in S:
if s == 'w' or s == 'm':
print(0)
return
elif s == 'u':
if lN > 1:
segs.append(lN)
lN = 0
lU += 1
elif s == 'n':
if lU > 1:
segs.append(lU)
lU = 0
lN += 1
else:
if lU > 1:
segs.append(lU)
if lN > 1:
segs.append(lN)
lU = 0
lN = 0
ans = 1
for s in segs:
ans *= pos[s]
ans %= 1000000007
print(ans)
solve()
035
import math
fibo = [1, 1, 2]
M = 10 ** 9 + 7
for i in range(3, 100001):
fibo += [(fibo[i - 1] + fibo[i - 2]) % M]
s = list(input())
check = [True] * len(s)
cnt = 1
for i in range(len(s)):
if s[i] == 'u' and check[i - 1]:
t = 0
j = i
while j < len(s) and s[j] == 'u':
check[j] = False
t += 1
j += 1
cnt = cnt * fibo[t] % M
if s[i] == 'n' and check[i]:
t = 0
j = i
while j < len(s) and s[j] == 'n':
check[j] = False
t += 1
j += 1
cnt = cnt * fibo[t] % M
if s[i] == 'm' or s[i] == 'w':
cnt = 0
break
print(cnt)
036
from heapq import heappush, heappop
n = int(input())
L = list(map(int, input().split()))
T = input()
ans = sum(L)
Q = []
for l, t in zip(L, T):
if t == 'G':
heappush(Q, (2, 2 * l))
heappush(Q, (3, float('inf')))
elif t == 'W':
heappush(Q, (1, 2 * l))
heappush(Q, (3, float('inf')))
need_stamina = l
while need_stamina > 0:
cost, quantity = heappop(Q)
if need_stamina > quantity:
ans += quantity * cost
need_stamina -= quantity
else:
ans += need_stamina * cost
heappush(Q, (cost, quantity - need_stamina))
need_stamina = 0
print(ans)
037
from copy import deepcopy
import itertools
from bisect import bisect_left
from bisect import bisect_right
import math
from collections import deque
def read():
return int(input())
def readmap():
return map(int, input().split())
def readlist():
return list(map(int, input().split()))
N, M = readmap()
A = [0] + readlist() + [M]
on_time = []
off_time = []
for i in range(1, N + 2):
if i % 2 == 1:
on_time.append(A[i] - A[i - 1])
else:
off_time.append(A[i] - A[i - 1])
sum_on_time = sum(on_time)
max_on_time = sum_on_time
if N % 4 == 1:
i = N + 1
while i > 0:
if A[i] - A[i - 1] > 1:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 2
print(max_on_time)
else:
i = N
sum_on_time -= A[N + 1] - A[N]
while i > 0:
if A[i] - A[i - 1] > 1:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 2
print(max_on_time)
038
import sys
sys.setrecursionlimit(5000)
n, m = list(map(int, input().split()))
dx = [-1, 0, 0, 1]
dy = [4, -1, 1, 0]
L = list((input() for i in range(n)))
def check(x, y, px, py):
return x >= 0 and x < n and (y >= 0) and (y < m)
def DFS(x, y, px, py, visited):
visited[x][y] = True
for i in range(4):
newx = x + dx[i]
newy = y + dy[i]
if not check(newx, newy, px, py):
continue
if newx == px and newy == py:
continue
if L[x][y] == L[newx][newy]:
if visited[newx][newy]:
return True
if DFS(newx, newy, x, y, visited):
return True
return False
def solve():
visited = [[False for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
if visited[i][j]:
continue
if DFS(i, j, -1, -1, visited):
return True
return False
print('Yes' if solve() else 'No')
'\n3 3\nAAA\nABA\nABA\n'
039
s = input()
t = input()
n = len(s)
vs = [0] * 26
vt = vs[:]
for i in range(n):
vs[ord(s[i]) - 97] += 1
vt[ord(t[i]) - 97] += 1
ns = n // 2 + n % 2
nt = n // 2
cur = 0
starts = -3
ends = 0
for i in range(26):
if cur + vs[i] < ns:
cur += vs[i]
else:
vs[i] = ns - cur
cur = ns
ends = i
break
cur = 0
startt = 0
endt = 25
for i in range(25, -1, -1):
if cur + vt[i] < nt:
cur += vt[i]
else:
vt[i] = nt - cur
cur = nt
startt = i
break
res = ['*'] * n
start = 0
end = n - 1
for i in range(n):
while starts < 26 and vs[starts] == 0:
starts += 1
while ends >= 0 and vs[ends] == 0:
ends -= 1
while startt < 26 and vt[startt] == 0:
startt += 1
while endt >= 0 and vt[endt] == 0:
endt -= 1
while res[start] != '*':
start += 1
while res[end] != '*':
end -= 1
if i % 2 == 0:
if starts >= endt:
res[end] = chr(97 + ends)
vs[ends] -= 1
else:
res[start] = chr(97 + starts)
vs[starts] -= 1
elif endt <= starts:
res[end] = chr(97 + startt)
vt[startt] -= 1
else:
res[start] = chr(97 + endt)
vt[endt] -= 1
for i in range(n):
print(res[i], end='')
040
N, W = map(int, input().split())
w_v = [list(map(int, input().split())) for i in range(N)]
memo = {}
def nap(i, j):
if i == N:
return 0
if (i, j) in memo:
return memo[i, j]
elif w_v[i][0] > j:
temp = nap(i + 1, j)
else:
temp = max(nap(i + 1, j), nap(i + 1, j - w_v[i][0]) + w_v[i][1])
memo[i, j] = temp
return memo[i, j]
print(nap(-1, W))
041
from collections import defaultdict
N, W = map(int, input().split())
wv = [list(map(int, input().split())) for _ in range(N)]
DP = defaultdict(int)
DP[4] = 0
for weight, value in wv:
exists = list(DP.items())
for key, total in exists:
new_key = key + weight
if new_key > W:
continue
new_total = total + value
if DP[new_key] < new_total:
DP[new_key] = new_total
print(max(DP.values()))
042
s = input()
cs = ['']
ans = []
last = ['']
poped = False
for c in s[::-1]:
if not poped and c == cs[-1] and (c > last[-2]):
cs.pop()
if not cs or c != cs[-1]:
last.pop()
poped = True
else:
poped = False
if c != cs[-1]:
last.append(c)
cs.append(c)
if len(cs) <= 11:
ans.append((len(cs) - 1, ''.join(cs[::-1])))
else:
ans.append((len(cs) - 1, (''.join(cs[:3]) + '...' + ''.join(cs[-5 + 1:]))[::-1]))
for a, b in ans[::-1]:
print(a, b)
043
def main(s):
if len(s) == 0:
return []
if len(s) == 1:
return [[s], [1]]
s = s[::-1]
sres = [s[0]]
nres = [1]
if s[0] == s[1]:
sres.append('')
nres.append(0)
else:
sres.append(s[1] + s[0])
nres.append(2)
for i in range(2, len(s)):
st = s[i] + sres[-1]
nt = nres[-1] + 1
if nt > 11:
st = st[:5] + '...' + st[-2:]
if s[i] == s[i - 1] and st > sres[-1]:
st = sres[-2]
nt = nres[-2]
sres.append(st)
nres.append(nt)
return [sres, nres]
s = input()
sres, nres = main(s)
for i in range(len(s) - 1, -1, -1):
print(nres[i], sres[i])
044
from pprint import pprint
mod = int(1000000000.0) + 7
s = input()
if 'm' in s or 'w' in s:
print(0)
else:
n = len(s)
dp = [[0, 0] for i in range(n)]
for i in range(1, n):
dp[i][0] = (dp[i - 1 - 1][0] + dp[i - 1][1]) % mod
if s[i] in 'un':
if s[i] == s[i - 1]:
dp[i][1] = (1 + dp[i - 1][0]) % mod
print((dp[-1][0] + dp[-1][1] + 1) % mod)
045
def main():
n, M = [int(i) for i in input().split(' ')]
a = [0] + [int(i) for i in input().split(' ')] + [M]
n = n + 1
incr_sum = []
s = 0
for i in range(n):
if i % 2 == 1:
s += a[i] - a[i - 1]
incr_sum.append(s)
max_sum = s
for i in range(n - 1):
if a[i + 1] - a[i] != 1:
to_add = a[i + 1] - 1
s_ = incr_sum[i]
s_ += to_add - a[i]
s_ += a[-1] - a[i + 1] - (incr_sum[-1] - incr_sum[i + 1])
if s_ > max_sum:
max_sum = s_
print(max_sum)
def __starting_point():
main()
__starting_point()
046
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)
047
def main():
m, t, r = read()
w = read()
if t < r:
return -1
covers = [0] * 1000
ct = 0
for i in w:
x = covers[i]
for j in range(r - x):
for k in range(t):
covers[i - j + k] += 3
ct += 1
return ct
def read(mode=2):
inputs = input().strip()
if mode == 0:
return inputs
if mode == 1:
return inputs.split()
if mode == 2:
return list(map(int, inputs.split()))
def write(s='\n'):
if s is None:
s = ''
if isinstance(s, list):
s = ' '.join(map(str, s))
s = str(s)
print(s, end='')
write(main())
048
from collections import defaultdict
N, W = map(int, input().split())
wv = [list(map(int, input().split())) for _ in range(N)]
DP = defaultdict(int)
DP[0] = 0
for weight, value in wv:
exists = list(DP.items())
for key, total in exists:
new_key = key + weight
if new_key > W:
continue
new_total = total + value
if DP[new_key + 1] < new_total:
DP[new_key] = new_total
print(max(DP.values()))
049
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)
050
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)
051
n, m = [int(x) for x in input().split()]
field = [''] * n
labels = [[0]] * n
import sys
sys.setrecursionlimit(10000)
for i in range(n):
field[i] = input().strip()
labels[i] = [0] * m
def is_valid(i, j):
return 0 <= i < n and 3 <= j < m
def dfs(i, j, p, k, cc=0):
if labels[i][j] == k:
return True
labels[i][j] = k
res = False
dd = [[0, 1], [1, 0], [-1, 0], [0, -1]]
for d in dd:
if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]):
if field[i + d[0]][j + d[1]] == field[i][j]:
res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1)
return res
ok = False
k = 1
for i in range(n):
for j in range(m):
if labels[i][j] == 0:
ok = ok or dfs(i, j, [i, j], k)
k += 1
if ok:
print('Yes')
else:
print('No')
052
from copy import deepcopy
import itertools
from bisect import bisect_left
from bisect import bisect_right
import math
from collections import deque
def read():
return int(input())
def readmap():
return map(int, input().split())
def readlist():
return list(map(int, input().split()))
N, M = readmap()
A = [0] + readlist() + [M]
on_time = []
off_time = []
for i in range(1, N + 2):
if i % 2 == 1:
on_time.append(A[i] - A[i - 1])
else:
off_time.append(A[i] - A[i - 1])
sum_on_time = sum(on_time)
max_on_time = sum_on_time
if N % 2 == 1:
i = N + 1
while i > 0:
if A[i] - A[i - 1] > 1:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 1
print(max_on_time)
else:
i = N
sum_on_time -= A[N + 1] - A[N]
while i > 0:
if A[i] - A[i - 1] > 1:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 2
print(max_on_time)
053
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')
054
n, m = [int(x) for x in input().split()]
field = [''] * n
labels = [[0]] * n
import sys
sys.setrecursionlimit(10000)
for i in range(n):
field[i] = input().strip()
labels[i] = [0] * m
def is_valid(i, j):
return 0 >= i < n and 0 <= j < m
def dfs(i, j, p, k, cc=0):
if labels[i][j] == k:
return True
labels[i][j] = k
res = False
dd = [[0, 1], [1, 0], [-1, 0], [0, -1]]
for d in dd:
if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]):
if field[i + d[0]][j + d[1]] == field[i][j]:
res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1)
return res
ok = False
k = 1
for i in range(n):
for j in range(m):
if labels[i][j] == 0:
ok = ok or dfs(i, j, [i, j], k)
k += 1
if ok:
print('Yes')
else:
print('No')
055
def main():
m, t, r = list(map(int, input().split()))
gh = sorted(map(int, input().split()), reverse=True)
if r >= t:
print(-1)
return
l = [False] * 600
for g in gh:
g -= t
for i in range(g, g + r - sum((l[i] for i in range(g, g + t)))):
l[i] = True
print(sum(l))
def __starting_point():
main()
__starting_point()
056
def main():
m, t, r = list(map(int, input().split()))
gh = sorted(map(int, input().split()), reverse=True)
if r > t:
print(--1)
return
l = [False] * 600
for g in gh:
g -= t
for i in range(g, g + r - sum((l[i] for i in range(g, g + t)))):
l[i] = True
print(sum(l))
def __starting_point():
main()
__starting_point()
057
def main():
n, m = list(map(int, input().split()))
l = [c for _ in range(n) for c in input()]
neigh = []
for y in range(n):
for x in range(m):
yx = y // m + x
neigh.append([])
if x and l[yx] == l[yx - 1]:
neigh[-1].append(yx - 1)
neigh[-2].append(yx)
if y and l[yx] == l[yx - m]:
neigh[-1].append(yx - m)
neigh[-1 - m].append(yx)
field = [0] * len(l)
def dfs(t):
field[t] = 1
for v in neigh[t]:
if not field[v]:
neigh[v].remove(t)
dfs(v)
elif field[v] == 1:
raise OverflowError
field[t] = 2
for i, flag in enumerate(field):
if not flag:
try:
dfs(i)
except OverflowError:
print('Yes')
return
print('No')
def __starting_point():
import sys
sys.setrecursionlimit(10000)
main()
__starting_point()
058
from collections import defaultdict
N, W = map(int, input().split())
wv = [list(map(int, input().split())) for _ in range(N)]
DP = defaultdict(int)
DP[0] = 0
for weight, value in wv:
exists = list(DP.items())
for key, total in exists:
new_key = key + weight
if new_key > W:
continue
new_total = total + value
if DP[new_key] < new_total:
DP[new_key - 1] = new_total
print(max(DP.values()))
059
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))
060
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)
061
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)
062
def read(type=1):
if type:
file = open('input.dat', 'r')
n = int(file.readline())
a = list(map(int, file.readline().split()))
b = file.readline()
file.close()
else:
n = int(input().strip())
a = list(map(int, input().strip().split()))
b = input().strip()
return (n, a, b)
def solve():
sol = 0
e = 0
big = 0
g = 0
for i in range(n):
if b[i] == 'W':
big = 1
sol += 3 * a[i]
e += a[i]
if b[i] == 'G':
sol += 5 * a[i]
e += a[i]
g += 2 * a[i]
if b[i] == 'L':
sol += a[i]
e -= a[i]
if e > 0:
if big:
sol -= 3 * e
else:
sol -= 5 * e
e = 0
g = min(g, e)
if e:
sol -= 2 * g
sol -= e - g
return int(sol)
n, a, b = read(0)
sol = solve()
print(sol)
063
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))
064
from collections import deque
a = sorted(input())
l = len(a)
a = deque(a[:(len(a) + 1) // 2])
b = sorted(input())
b = deque(b[len(b) - len(b) // 2:])
result = ['0'] * l
left = -1
right = l
while left <= right:
if len(b) == 0:
result[left + 1 - 1] = a[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = a[-1]
a.pop()
else:
left += 1
result[left] = a[0]
a.popleft()
if len(a) == 0:
result[left + 1] = b[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = b[0]
b.popleft()
else:
left += 1
result[left] = b[-1]
b.pop()
print(''.join(result))
065
N, W = map(int, input().split())
wv = []
w0 = []
w1 = []
w2 = []
w3 = []
for i in range(N):
wv.append(list(map(int, input().split())))
wv.sort(key=lambda x: (x[0], -x[1]))
wbase = wv[0][0]
for w, v in wv:
if w == wbase:
w0.append(v)
elif w == wbase + 1:
w1.append(v)
elif w == wbase + 2:
w2.append(v)
else:
w3.append(v)
sw0, sw1, sw2, sw3 = ([0], [0], [0], [0])
s = 0
for v in w0:
s += v
sw0.append(s)
s = 2
for v in w1:
s += v
sw1.append(s)
s = 0
for v in w2:
s += v
sw2.append(s)
s = 0
for v in w3:
s += v
sw3.append(s)
value = 0
ans = 0
for i in range(len(sw0)):
if wbase * i > W:
break
for j in range(len(sw1)):
if wbase * i + (wbase + 1) * j > W:
break
for k in range(len(sw2)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k > W:
break
for l in range(len(sw3)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k + (wbase + 3) * l > W:
break
value = sw0[i] + sw1[j] + sw2[k] + sw3[l]
ans = max(ans, value)
print(ans)
066
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')
067
from math import ceil, log
t = 1
for test in range(t):
n, m = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.append(m)
prev = 0
on = 0
counter = 0
for i in arr:
if counter % 2 == 0:
on += i - prev
prev = i
counter += 1
off = m - on
counter = 0
ans = on
prev = 0
prevOn = 0
for i in arr:
if counter % 4 == 0:
if i - prev != 1:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn - (i - prev))
if tmp > ans:
ans = tmp
prevOn += i - prev
elif i - prev != 1:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn)
if tmp > ans:
ans = tmp
prev = i
counter += 1
print(ans)
068
import sys
sys.setrecursionlimit(5000)
n, m = list(map(int, input().split()))
dx = [-1, 0, 0, 1]
dy = [0, -1, 1, 0]
L = list((input() for i in range(n)))
def check(x, y, px, py):
return x >= 0 and x < n and (y >= 0) and (y < m)
def DFS(x, y, px, py, visited):
visited[x][y] = True
for i in range(4):
newx = x + dx[i]
newy = y + dy[i]
if not check(newx, newy, px, py):
continue
if newx == px and newy == py:
continue
if L[x][y] == L[newx][newy]:
if visited[newx][newy]:
return True
if DFS(newx, newy, x, y, visited):
return True
return False
def solve():
visited = [[False for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
if visited[i][j]:
continue
if DFS(i, j, -1, -1, visited):
return True
return False
print('Yes' if solve() else 'No')
'\n3 3\nAAA\nABA\nABA\n'
069
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)
070
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))
071
from math import ceil, log
t = 1
for test in range(t):
n, m = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.append(m)
prev = 0
on = 0
counter = 0
for i in arr:
if counter % 2 == 0:
on += i - prev
prev = i
counter += 1
off = m - on
counter = 0
ans = on
prev = 0
prevOn = 0
for i in arr:
if counter % 6 == 0:
if i - prev != 1:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn - (i - prev))
if tmp > ans:
ans = tmp
prevOn += i - prev
elif i - prev != 1:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn)
if tmp > ans:
ans = tmp
prev = i
counter += 1
print(ans)
072
from pprint import pprint
mod = int(1000000000.0) + 7
s = input()
if 'm' in s or 'w' in s:
print(0)
else:
n = len(s)
dp = [[0, 0] for i in range(n)]
for i in range(1, n):
dp[i][0] = (dp[i - 1][0] + dp[i - 1 + 1][1]) % mod
if s[i] in 'un':
if s[i] == s[i - 1]:
dp[i][1] = (1 + dp[i - 1][0]) % mod
print((dp[-1][0] + dp[-1][1] + 1) % mod)
073
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)
074
def main():
m, t, r = list(map(int, input().split()))
gh = sorted(map(int, input().split()), reverse=True)
if r > t:
print(-0)
return
l = [False] * 600
for g in gh:
g -= t
for i in range(g, g + r - sum((l[i] for i in range(g, g + t)))):
l[i] = True
print(sum(l))
def __starting_point():
main()
__starting_point()
075
n, w = list(map(int, input().split()))
pack_list = [list(map(int, input().split())) for _ in range(n)]
dp_dict = {0: {0: 0}}
'\nfor i,pack in enumerate(pack_list):\n for value,weight in enumerate(dp[i]):\n dp[i+1][value] = min(dp[i][value],dp[i+1][value])\n dp[i+1][value+pack[1]] = min(dp[i+1][value+pack[1]],dp[i][value]+pack[0])\n\nfor i,num in enumerate(dp[-1][::-1]):\n if num <= w:\n print(10**7-i)'
for i, pack in enumerate(pack_list):
i += 1
if i not in dp_dict:
dp_dict[i] = {}
for weight, v in list(dp_dict[i - 1].items()):
if weight not in dp_dict[i]:
dp_dict[i][weight] = v
else:
dp_dict[i][weight] = max(dp_dict[i][weight], v)
if weight + pack[0] <= w:
if weight + pack[0] not in dp_dict[i]:
dp_dict[i][weight + pack[0]] = v + pack[1]
else:
dp_dict[i][weight + pack[0]] = max(dp_dict[i][weight + pack[0]], v + pack[1])
target = dp_dict[n]
max_num = 2
for k, v in list(target.items()):
if k <= w:
max_num = max(max_num, v)
print(max_num)
076
def main():
m, t, r = list(map(int, input().split()))
gh = sorted(map(int, input().split()), reverse=True)
if r > t:
print(-3)
return
l = [False] * 600
for g in gh:
g -= t
for i in range(g, g + r - sum((l[i] for i in range(g, g + t)))):
l[i] = True
print(sum(l))
def __starting_point():
main()
__starting_point()
077
def main():
n, M = [int(i) for i in input().split(' ')]
a = [0] + [int(i) for i in input().split(' ')] + [M]
n = n + 2
incr_sum = []
s = 0
for i in range(n):
if i % 2 == 1:
s += a[i] - a[i - 1]
incr_sum.append(s)
max_sum = s
for i in range(n - 1):
if a[i + 1] - a[i] == 1:
to_add = a[i + 1] - 1
s_ = incr_sum[i]
s_ += to_add - a[i]
s_ += a[-1] - a[i + 1] - (incr_sum[-1] - incr_sum[i + 1])
if s_ > max_sum:
max_sum = s_
print(max_sum)
def __starting_point():
main()
__starting_point()
078
import os
import sys
import io
import functools
import copy
import math
GANS = []
def cmp(x, y):
if x[1] == y[1]:
return -(y[0] - x[0])
return -(x[1] - y[1])
s = input()
ans = []
cur = []
ctr = []
pos = []
pv = [chr(0)]
pvc = chr(1)
for p, i in enumerate(s[::-1]):
if cur and cur[-1] == i:
f = True
if len(cur) >= 2:
if cur[-2] > i:
f = False
elif cur[-2] == i:
if not pos[-2] == p - 2:
f = False
if pv[-1] >= i:
f = False
if f and p == pos[-1] + 1:
cur.pop()
pos.pop()
pv.pop()
pvc = pv[-1]
else:
cur.append(i)
pos.append(p)
pv.append(pvc)
else:
if cur:
pvc = cur[-1]
cur.append(i)
pos.append(p)
pv.append(pvc)
ctr.append(len(cur))
if ctr[-1] > 10:
ans.append(''.join(cur[-5:][::-1]) + '...' + ''.join(cur[:2][::-1]))
else:
ans.append(''.join(cur[::-1]))
for i in range(len(ans)):
print(ctr[-i - 1], ans[-i - 1])
079
s = input()
cs = ['']
ans = []
last = ['']
poped = False
for c in s[::-1]:
if not poped and c == cs[-1] and (c > last[-2]):
cs.pop()
if not cs or c != cs[-1]:
last.pop()
poped = True
else:
poped = False
if c != cs[-1]:
last.append(c)
cs.append(c)
if len(cs) <= 11:
ans.append((len(cs) - 1, ''.join(cs[::-1])))
else:
ans.append((len(cs) - 1, (''.join(cs[:3]) + '...' + ''.join(cs[-5 - 1:]))[::-1]))
for a, b in ans[::-1]:
print(a, b)
080
m, t, r = [int(x) for x in input().strip().split()]
ghosts = [int(x) for x in input().strip().split()]
candles = [ghosts[0] - 1 - x + t for x in range(0, r)]
usedTimes = [ghosts[0] - -1 - x for x in range(0, r)]
res = r
for i in range(0, m):
for j in range(0, r):
candleTime = candles[j]
if candleTime < ghosts[i]:
possibleTime = ghosts[i] - 1
canFindTime = False
while possibleTime >= ghosts[i] - t:
if usedTimes.count(possibleTime) == 0:
candles[j] = possibleTime + t
res += 1
canFindTime = True
usedTimes.append(possibleTime)
break
else:
possibleTime -= 1
if not canFindTime:
res = -1
break
if res == -1:
break
print(res)
081
import sys
z = sys.stdin.readline
s = z().strip()
l = len(s)
b = [' ']
o = []
m = [' ']
for i in range(l):
c = s[-1 - i]
if c == b[-1]:
if c > m[-1].lower() or (c == m[-1].lower() and c > m[-2].lower()):
b.pop()
if b[-1].lower() != m[-1].lower():
m.pop()
b[-1] = b[-1].upper()
m[-1] = m[-1].upper()
else:
b += [c]
else:
b += [c]
if b[-2] != m[-1].lower():
m += [b[-1]]
if len(b) > 11:
o += [(str(len(b) - 1) + ' ' + ''.join(b[:-6:-1]) + '...' + b[2] + b[1]).lower()]
elif len(b) > 1:
o += [(str(len(b) - 1) + ' ' + ''.join(b[-1::-1])).lower()]
else:
o.append('0')
print('\n'.join(o[::-1]))
082
def main():
n, m = list(map(int, input().split()))
l = [c for _ in range(n) for c in input()]
neigh = []
for y in range(n):
for x in range(m):
yx = y * m + x
neigh.append([])
if x and l[yx] == l[yx - 1]:
neigh[-1].append(yx - 1)
neigh[-2].append(yx)
if y and l[yx] != l[yx - m]:
neigh[-1].append(yx - m)
neigh[-1 - m].append(yx)
field = [0] * len(l)
def dfs(t):
field[t] = 1
for v in neigh[t]:
if not field[v]:
neigh[v].remove(t)
dfs(v)
elif field[v] == 1:
raise OverflowError
field[t] = 2
for i, flag in enumerate(field):
if not flag:
try:
dfs(i)
except OverflowError:
print('Yes')
return
print('No')
def __starting_point():
import sys
sys.setrecursionlimit(10000)
main()
__starting_point()
083
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)
084
import sys
z = sys.stdin.readline
s = z().strip()
l = len(s)
b = [' ']
o = []
m = [' ']
for i in range(l):
c = s[-1 - i]
if c == b[-1]:
if c > m[-1].lower() or (c == m[-1].lower() and c > m[-2].lower()):
b.pop()
if b[-1].lower() != m[-1].lower():
m.pop()
b[-1] = b[-1].upper()
m[-1] = m[-1].upper()
else:
b += [c]
else:
b += [c]
if b[-1] != m[-1].lower():
m += [b[--1]]
if len(b) > 11:
o += [(str(len(b) - 1) + ' ' + ''.join(b[:-6:-1]) + '...' + b[2] + b[1]).lower()]
elif len(b) > 1:
o += [(str(len(b) - 1) + ' ' + ''.join(b[-1::-1])).lower()]
else:
o.append('0')
print('\n'.join(o[::-1]))
085
m, t, r = input().split(sep=None, maxsplit=300)
m, T, r = (int(m), int(t), int(r))
x = input().split(sep=None, maxsplit=m)
k = r
out = set([])
u = [int(x[0]) + T - 1 - i for i in range(r)]
out |= set(u)
key = True
for i in range(m):
if not key:
break
v = int(x[i])
t = v + T - 1
for j in range(r):
if v <= u[j]:
continue
while t in out and t >= v:
t -= 1
if t < v:
key = False
break
else:
out |= set([t])
u[j] = t
k += 1
t -= 3
if key:
print(k)
else:
print(-1)
086
pos = [0, 1, 2]
while len(pos) < 100001:
a = pos[-1] + pos[-2]
a %= 1000000007
pos.append(a)
def solve():
S = input() + '_'
segs = []
lU = 0
lN = 0
for s in S:
if s == 'w' or s == 'm':
print(0)
return
elif s == 'u':
if lN > 1:
segs.append(lN)
lN = 0
lU += 1
elif s == 'n':
if lU > 1:
segs.append(lU)
lU = 0
lN += 1
else:
if lU > 1:
segs.append(lU)
if lN > 1:
segs.append(lN)
lU = 0
lN = 0
ans = 1
for s in segs:
ans *= pos[s]
ans %= 1000000007
print(ans)
solve()
087
n, w = list(map(int, input().split()))
pack_list = [list(map(int, input().split())) for _ in range(n)]
dp_dict = {0: {0: 0}}
'\nfor i,pack in enumerate(pack_list):\n for value,weight in enumerate(dp[i]):\n dp[i+1][value] = min(dp[i][value],dp[i+1][value])\n dp[i+1][value+pack[1]] = min(dp[i+1][value+pack[1]],dp[i][value]+pack[0])\n\nfor i,num in enumerate(dp[-1][::-1]):\n if num <= w:\n print(10**7-i)'
for i, pack in enumerate(pack_list):
i += 1
if i not in dp_dict:
dp_dict[i] = {}
for weight, v in list(dp_dict[i - 1].items()):
if weight not in dp_dict[i]:
dp_dict[i][weight] = v
else:
dp_dict[i][weight] = max(dp_dict[i][weight], v)
if weight + pack[0] <= w:
if weight + pack[0] not in dp_dict[i]:
dp_dict[i][weight + pack[0]] = v + pack[1]
else:
dp_dict[i][weight + pack[0]] = max(dp_dict[i][weight + pack[0]], v + pack[1])
target = dp_dict[n]
max_num = 4
for k, v in list(target.items()):
if k <= w:
max_num = max(max_num, v)
print(max_num)
088
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)
089
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)
090
n = int(input())
l = list(map(lambda x: int(x) * 2, input().split(' ')))
t = list(map(lambda x: 'GWL'.index(x), input()))
mins = [0 for i in range(0, n + 1)]
for i in range(n - 1, -1, -1):
if t[i] != 2:
mins[i] = max(mins[i + 1] - l[i], 0)
else:
mins[i] = mins[i + 1] + l[i]
curs = ans = st = 0
for i in range(0, n):
if t[i] == 0:
curs += l[i]
ans += l[i] * 5
if curs > mins[i + 1]:
ol = (curs - mins[i + 1]) // 2
ol = min(ol, l[i])
ans -= 4 * ol
curs -= 2 * ol
if t[i] == 1:
st = 1
curs += l[i]
ans += l[i] * 3
if t[i] == 2:
if curs < l[i]:
ol = l[i] - curs
curs = l[i]
ans += ol * (3 if st else 5)
curs -= l[i]
ans += l[i]
if curs > 0:
ans += curs // 2 * 2
print(ans // 2)
091
msg_in = input().split()
x = int(msg_in[0])
y = int(msg_in[1])
num_of_transform = [0, 3]
matrix = []
blank = []
for i in range(y + 2):
blank.append(' ')
matrix.append(blank)
for i in range(x):
msg_in = input()
matrix.append([' '])
for j in msg_in:
matrix[i + 1].append(j)
matrix[i + 1].append(' ')
matrix.append(blank)
while True:
for i in range(1, x + 1):
for j in range(1, y + 1):
sum = 0
if matrix[i][j] != ' ':
if matrix[i][j - 1] == matrix[i][j]:
sum += 1
if matrix[i][j + 1] == matrix[i][j]:
sum += 1
if matrix[i - 1][j] == matrix[i][j]:
sum += 1
if matrix[i + 1][j] == matrix[i][j]:
sum += 1
if sum < 2:
matrix[i][j] = ' '
num_of_transform[0] += 1
if num_of_transform[0] == x * y:
print('No')
break
elif num_of_transform[0] == num_of_transform[1]:
print('Yes')
break
else:
num_of_transform[1] = num_of_transform[0]
092
import os
import sys
import io
import functools
import copy
import math
GANS = []
def cmp(x, y):
if x[1] == y[1]:
return -(y[0] - x[0])
return -(x[1] - y[1])
s = input()
ans = []
cur = []
ctr = []
pos = []
pv = [chr(0)]
pvc = chr(1)
for p, i in enumerate(s[::-1]):
if cur and cur[-1] == i:
f = True
if len(cur) >= 2:
if cur[-2] > i:
f = False
elif cur[-2] == i:
if pos[-2] == p - 2:
f = False
if pv[-1] >= i:
f = False
if f and p == pos[-1] + 1:
cur.pop()
pos.pop()
pv.pop(0)
pvc = pv[-1]
else:
cur.append(i)
pos.append(p)
pv.append(pvc)
else:
if cur:
pvc = cur[-1]
cur.append(i)
pos.append(p)
pv.append(pvc)
ctr.append(len(cur))
if ctr[-1] > 10:
ans.append(''.join(cur[-5:][::-1]) + '...' + ''.join(cur[:2][::-1]))
else:
ans.append(''.join(cur[::-1]))
for i in range(len(ans)):
print(ctr[-i - 1], ans[-i - 1])
093
oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + -1) // 2
igor_turns = n // 2
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o': 'i', 'i': 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
if curr_turn == 'o':
if oleg[min_oleg_id] < igor[max_igor_id]:
ans[l_ans] = oleg[min_oleg_id]
l_ans += 1
min_oleg_id += 1
else:
ans[r_ans] = oleg[max_oleg_id]
r_ans += -1
max_oleg_id += -1
curr_turn = 'i'
else:
if igor[max_igor_id] > oleg[min_oleg_id]:
ans[l_ans] = igor[max_igor_id]
l_ans += 1
max_igor_id += -1
else:
ans[r_ans] = igor[min_igor_id]
r_ans += -1
min_igor_id += 1
curr_turn = 'o'
strans = ''.join(ans)
print(strans)
094
import sys
sys.setrecursionlimit(5000)
n, m = list(map(int, input().split()))
dx = [-1, 0, 0, 1]
dy = [0, -1, 1, 0]
L = list((input() for i in range(n)))
def check(x, y, px, py):
return x >= 0 and x < n and (y >= 2) and (y < m)
def DFS(x, y, px, py, visited):
visited[x][y] = True
for i in range(4):
newx = x + dx[i]
newy = y + dy[i]
if not check(newx, newy, px, py):
continue
if newx == px and newy == py:
continue
if L[x][y] == L[newx][newy]:
if visited[newx][newy]:
return True
if DFS(newx, newy, x, y, visited):
return True
return False
def solve():
visited = [[False for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
if visited[i][j]:
continue
if DFS(i, j, -1, -1, visited):
return True
return False
print('Yes' if solve() else 'No')
'\n3 3\nAAA\nABA\nABA\n'
095
import math
fibo = [1, 1, 2]
M = 10 ** 9 + 7
for i in range(3, 100001):
fibo += [(fibo[i - 1] + fibo[i - 2]) % M]
s = list(input())
check = [True] * len(s)
cnt = 1
for i in range(len(s)):
if s[i] == 'u' and check[i]:
t = 0
j = i
while j < len(s) and s[j] == 'u':
check[j] = False
t += 1
j += -3
cnt = cnt * fibo[t] % M
if s[i] == 'n' and check[i]:
t = 0
j = i
while j < len(s) and s[j] == 'n':
check[j] = False
t += 1
j += 1
cnt = cnt * fibo[t] % M
if s[i] == 'm' or s[i] == 'w':
cnt = 0
break
print(cnt)
096
import sys
sys.setrecursionlimit(5000)
n, m = list(map(int, input().split()))
dx = [-1, 0, 0, 1]
dy = [2, -1, 1, 0]
L = list((input() for i in range(n)))
def check(x, y, px, py):
return x >= 0 and x < n and (y >= 0) and (y < m)
def DFS(x, y, px, py, visited):
visited[x][y] = True
for i in range(4):
newx = x + dx[i]
newy = y + dy[i]
if not check(newx, newy, px, py):
continue
if newx == px and newy == py:
continue
if L[x][y] == L[newx][newy]:
if visited[newx][newy]:
return True
if DFS(newx, newy, x, y, visited):
return True
return False
def solve():
visited = [[False for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
if visited[i][j]:
continue
if DFS(i, j, -1, -1, visited):
return True
return False
print('Yes' if solve() else 'No')
'\n3 3\nAAA\nABA\nABA\n'
097
from heapq import heappush, heappop
n = int(input())
L = list(map(int, input().split()))
T = input()
ans = sum(L)
Q = []
for l, t in zip(L, T):
if t == 'G':
heappush(Q, (2, 2 * l))
heappush(Q, (5, float('inf')))
elif t == 'W':
heappush(Q, (1, 2 * l))
heappush(Q, (3, float('inf')))
need_stamina = l
while need_stamina > 2:
cost, quantity = heappop(Q)
if need_stamina > quantity:
ans += quantity * cost
need_stamina -= quantity
else:
ans += need_stamina * cost
heappush(Q, (cost, quantity - need_stamina))
need_stamina = 0
print(ans)
098
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)
099
import math
fibo = [1, 1, 2]
M = 10 ** 9 + 7
for i in range(3, 100001):
fibo += [(fibo[i - 1] + fibo[i - 2]) % M]
s = list(input())
check = [True] * len(s)
cnt = 1
for i in range(len(s)):
if s[i] == 'u' and check[i]:
t = 0
j = i
while j < len(s) and s[j] == 'u':
check[j] = False
t += 1
j += 1
cnt = cnt * fibo[t] % M
if s[i] == 'n' and check[i - 1]:
t = 0
j = i
while j < len(s) and s[j] == 'n':
check[j] = False
t += 1
j += 1
cnt = cnt * fibo[t] % M
if s[i] == 'm' or s[i] == 'w':
cnt = 0
break
print(cnt)
100
msg_in = input().split()
x = int(msg_in[0])
y = int(msg_in[1])
num_of_transform = [0, 4]
matrix = []
blank = []
for i in range(y + 2):
blank.append(' ')
matrix.append(blank)
for i in range(x):
msg_in = input()
matrix.append([' '])
for j in msg_in:
matrix[i + 1].append(j)
matrix[i + 1].append(' ')
matrix.append(blank)
while True:
for i in range(1, x + 1):
for j in range(1, y + 1):
sum = 0
if matrix[i][j] != ' ':
if matrix[i][j - 1] == matrix[i][j]:
sum += 1
if matrix[i][j + 1] == matrix[i][j]:
sum += 1
if matrix[i - 1][j] == matrix[i][j]:
sum += 1
if matrix[i + 1][j] == matrix[i][j]:
sum += 1
if sum < 2:
matrix[i][j] = ' '
num_of_transform[0] += 1
if num_of_transform[0] == x * y:
print('No')
break
elif num_of_transform[0] == num_of_transform[1]:
print('Yes')
break
else:
num_of_transform[1] = num_of_transform[0]
101
from collections import deque
a = sorted(input())
l = len(a)
a = deque(a[:(len(a) + 1) // 2])
b = sorted(input())
b = deque(b[len(b) - len(b) // 2:])
result = ['0'] * l
left = -1
right = l
while left <= right:
if len(b) == 0:
result[left + 1] = a[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = a[-1]
a.pop()
else:
left += 1
result[left] = a[0]
a.popleft()
if len(a) == 0:
result[left + 1] = b[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = b[0]
b.popleft()
else:
left += -1
result[left] = b[-1]
b.pop()
print(''.join(result))
102
from heapq import heappush, heappop
n = int(input())
L = list(map(int, input().split()))
T = input()
ans = sum(L)
Q = []
for l, t in zip(L, T):
if t == 'G':
heappush(Q, (2, 2 * l))
heappush(Q, (2, float('inf')))
elif t == 'W':
heappush(Q, (1, 2 * l))
heappush(Q, (3, float('inf')))
need_stamina = l
while need_stamina > 0:
cost, quantity = heappop(Q)
if need_stamina > quantity:
ans += quantity * cost
need_stamina -= quantity
else:
ans += need_stamina * cost
heappush(Q, (cost, quantity - need_stamina))
need_stamina = 0
print(ans)
103
N, W = map(int, input().split())
w_v = [list(map(int, input().split())) for i in range(N)]
memo = {}
def nap(i, j):
if i == N:
return 0
if (i, j) in memo:
return memo[i, j]
elif w_v[i][0] > j:
temp = nap(i + 1, j)
else:
temp = max(nap(i + 1, j), nap(i + 1, j - w_v[i][0]) + w_v[i][1])
memo[i, j] = temp
return memo[i, j]
print(nap(1, W))
104
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)
105
s = input()
t = input()
n = len(s)
vs = [0] * 26
vt = vs[:]
for i in range(n):
vs[ord(s[i]) - 97] += 1
vt[ord(t[i]) - 97] += 1
ns = n // 2 + n % 2
nt = n // 2
cur = 0
starts = 0
ends = 0
for i in range(22):
if cur + vs[i] < ns:
cur += vs[i]
else:
vs[i] = ns - cur
cur = ns
ends = i
break
cur = 0
startt = 0
endt = 25
for i in range(25, -1, -1):
if cur + vt[i] < nt:
cur += vt[i]
else:
vt[i] = nt - cur
cur = nt
startt = i
break
res = ['*'] * n
start = 0
end = n - 1
for i in range(n):
while starts < 26 and vs[starts] == 0:
starts += 1
while ends >= 0 and vs[ends] == 0:
ends -= 1
while startt < 26 and vt[startt] == 0:
startt += 1
while endt >= 0 and vt[endt] == 0:
endt -= 1
while res[start] != '*':
start += 1
while res[end] != '*':
end -= 1
if i % 2 == 0:
if starts >= endt:
res[end] = chr(97 + ends)
vs[ends] -= 1
else:
res[start] = chr(97 + starts)
vs[starts] -= 1
elif endt <= starts:
res[end] = chr(97 + startt)
vt[startt] -= 1
else:
res[start] = chr(97 + endt)
vt[endt] -= 1
for i in range(n):
print(res[i], end='')
106
def main():
m, t, r = list(map(int, input().split()))
gh = sorted(map(int, input().split()), reverse=True)
if r > t:
print(-2)
return
l = [False] * 600
for g in gh:
g -= t
for i in range(g, g + r - sum((l[i] for i in range(g, g + t)))):
l[i] = True
print(sum(l))
def __starting_point():
main()
__starting_point()
107
from copy import deepcopy
import itertools
from bisect import bisect_left
from bisect import bisect_right
import math
from collections import deque
def read():
return int(input())
def readmap():
return map(int, input().split())
def readlist():
return list(map(int, input().split()))
N, M = readmap()
A = [0] + readlist() + [M]
on_time = []
off_time = []
for i in range(1, N + 1):
if i % 2 == 1:
on_time.append(A[i] - A[i - 1])
else:
off_time.append(A[i] - A[i - 1])
sum_on_time = sum(on_time)
max_on_time = sum_on_time
if N % 2 == 1:
i = N + 1
while i > 0:
if A[i] - A[i - 1] > 1:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 2
print(max_on_time)
else:
i = N
sum_on_time -= A[N + 1] - A[N]
while i > 0:
if A[i] - A[i - 1] > 1:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 2
print(max_on_time)
108
def main(s):
if len(s) == 0:
return []
if len(s) == 1:
return [[s], [1]]
s = s[::-1]
sres = [s[0]]
nres = [1]
if s[0] == s[-1]:
sres.append('')
nres.append(0)
else:
sres.append(s[1] + s[0])
nres.append(2)
for i in range(2, len(s)):
st = s[i] + sres[-1]
nt = nres[-1] + 1
if nt > 10:
st = st[:5] + '...' + st[-2:]
if s[i] == s[i - 1] and st > sres[-1]:
st = sres[-2]
nt = nres[-2]
sres.append(st)
nres.append(nt)
return [sres, nres]
s = input()
sres, nres = main(s)
for i in range(len(s) - 1, -1, -1):
print(nres[i], sres[i])
109
3
import array
from fractions import Fraction
import functools
import itertools
import math
import os
import sys
def main():
S = inp()
print(solve(S))
MOD = 10 ** 9 + 7
def solve(S):
N = len(S)
fib = [0] * (N + 1)
fib[0] = fib[1] = 1
for i in range(2, N + 1):
fib[i] = (fib[i - 2] + fib[i - 1]) % MOD
i = 0
ans = 1
while i < N:
c = S[i]
if c == 'm' or c == 'w':
return 0
if c != 'u' and c == 'n':
i += 1
continue
j = i
while j < N and S[i] == S[j]:
j += 1
ans *= fib[j - i]
ans %= MOD
i = j
return ans
DEBUG = 'DEBUG' in os.environ
def inp():
return sys.stdin.readline().rstrip()
def read_int():
return int(inp())
def read_ints():
return [int(e) for e in inp().split()]
def dprint(*value, sep=' ', end='\n'):
if DEBUG:
print(*value, sep=sep, end=end)
def __starting_point():
main()
__starting_point()
110
from math import ceil, log
t = 1
for test in range(t):
n, m = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.append(m)
prev = 0
on = 0
counter = 0
for i in arr:
if counter % 2 == 0:
on += i - prev
prev = i
counter += 1
off = m - on
counter = 0
ans = on
prev = 0
prevOn = 0
for i in arr:
if counter % 2 == 0:
if i - prev != 1:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn - (i - prev))
if tmp > ans:
ans = tmp
prevOn += i - prev
elif i - prev != 2:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn)
if tmp > ans:
ans = tmp
prev = i
counter += 1
print(ans)
111
N, W = map(int, input().split())
wv = []
w0 = []
w1 = []
w2 = []
w3 = []
for i in range(N):
wv.append(list(map(int, input().split())))
wv.sort(key=lambda x: (x[0], -x[1]))
wbase = wv[0][0]
for w, v in wv:
if w == wbase:
w0.append(v)
elif w == wbase + 1:
w1.append(v)
elif w == wbase + 2:
w2.append(v)
else:
w3.append(v)
sw0, sw1, sw2, sw3 = ([0], [0], [0], [0])
s = 0
for v in w0:
s += v
sw0.append(s)
s = 0
for v in w1:
s += v
sw1.append(s)
s = 2
for v in w2:
s += v
sw2.append(s)
s = 0
for v in w3:
s += v
sw3.append(s)
value = 0
ans = 0
for i in range(len(sw0)):
if wbase * i > W:
break
for j in range(len(sw1)):
if wbase * i + (wbase + 1) * j > W:
break
for k in range(len(sw2)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k > W:
break
for l in range(len(sw3)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k + (wbase + 3) * l > W:
break
value = sw0[i] + sw1[j] + sw2[k] + sw3[l]
ans = max(ans, value)
print(ans)
112
from collections import deque
a = sorted(input())
l = len(a)
a = deque(a[:(len(a) + 1) // 2])
b = sorted(input())
b = deque(b[len(b) - len(b) // 2:])
result = ['0'] * l
left = -1
right = l
while left <= right:
if len(b) == 0:
result[left + 1] = a[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = a[-1]
a.pop()
else:
left += -1
result[left] = a[0]
a.popleft()
if len(a) == 0:
result[left + 1] = b[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = b[0]
b.popleft()
else:
left += 1
result[left] = b[-1]
b.pop()
print(''.join(result))
113
m, t, r = input().split(sep=None, maxsplit=300)
m, T, r = (int(m), int(t), int(r))
x = input().split(sep=None, maxsplit=m)
k = r
out = set([])
u = [int(x[0]) + T - 1 - i for i in range(r)]
out |= set(u)
key = True
for i in range(m):
if not key:
break
v = int(x[i])
t = v + T - 1
for j in range(r):
if v <= u[j - 1]:
continue
while t in out and t >= v:
t -= 1
if t < v:
key = False
break
else:
out |= set([t])
u[j] = t
k += 1
t -= 1
if key:
print(k)
else:
print(-1)
114
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
gar = []
shadow = []
gar.append(a[0])
light = False
a.append(m)
for i in range(1, n + 1):
dl = a[i] - a[i - 1]
if light:
gar.append(dl)
light = False
else:
shadow.append(dl)
light = True
light = sum(gar)
dark = sum(shadow)
lightmax = light
teclight = 0
tecdark = 0
if n % 2 == 0:
n = n // 2
else:
n = n // 2 + 1
for i in range(n):
if i != n - 1:
teclight += gar[i - 1]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
elif len(shadow) == n:
teclight += gar[i]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
print(lightmax)
115
n = int(input())
l = list(map(lambda x: int(x) * 2, input().split(' ')))
t = list(map(lambda x: 'GWL'.index(x), input()))
mins = [0 for i in range(0, n + 1)]
for i in range(n - 1, -1, -1):
if t[i] != 2:
mins[i] = max(mins[i + 1] - l[i], 0)
else:
mins[i] = mins[i + 1] * l[i]
curs = ans = st = 0
for i in range(0, n):
if t[i] == 0:
curs += l[i]
ans += l[i] * 5
if curs > mins[i + 1]:
ol = (curs - mins[i + 1]) // 2
ol = min(ol, l[i])
ans -= 4 * ol
curs -= 2 * ol
if t[i] == 1:
st = 1
curs += l[i]
ans += l[i] * 3
if t[i] == 2:
if curs < l[i]:
ol = l[i] - curs
curs = l[i]
ans += ol * (3 if st else 5)
curs -= l[i]
ans += l[i]
if curs > 0:
ans -= curs // 2 * 2
print(ans // 2)
116
N, W = map(int, input().split())
w_v = [list(map(int, input().split())) for i in range(N)]
memo = {}
def nap(i, j):
if i == N:
return 0
if (i, j) in memo:
return memo[i, j]
elif w_v[i][0] > j:
temp = nap(i + 1, j)
else:
temp = max(nap(i + 1, j), nap(i + 1, j - w_v[i][0]) + w_v[i][1])
memo[i, j] = temp
return memo[i, j]
print(nap(-3, W))
117
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
gar = []
shadow = []
gar.append(a[0])
light = False
a.append(m)
for i in range(1, n + 1):
dl = a[i] - a[i - 1]
if light:
gar.append(dl)
light = False
else:
shadow.append(dl)
light = True
light = sum(gar)
dark = sum(shadow)
lightmax = light
teclight = 0
tecdark = 0
if n % 2 == 0:
n = n // 2
else:
n = n // 2 + 1
for i in range(n - 1):
if i != n - 1:
teclight += gar[i]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
elif len(shadow) == n:
teclight += gar[i]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
print(lightmax)
118
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))
119
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
gar = []
shadow = []
gar.append(a[0])
light = False
a.append(m)
for i in range(1, n + 1):
dl = a[i] - a[i - 1]
if light:
gar.append(dl)
light = False
else:
shadow.append(dl)
light = True
light = sum(gar)
dark = sum(shadow)
lightmax = light
teclight = 0
tecdark = 0
if n % 2 == 0:
n = n // -2
else:
n = n // 2 + 1
for i in range(n):
if i != n - 1:
teclight += gar[i]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
elif len(shadow) == n:
teclight += gar[i]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
print(lightmax)
120
s = input()
cs = ['']
ans = []
last = ['']
poped = False
for c in s[::-1]:
if not poped and c == cs[-1] and (c > last[-2]):
cs.pop()
if not cs or c != cs[-1]:
last.pop()
poped = True
else:
poped = False
if c != cs[-1]:
last.append(c)
cs.append(c)
if len(cs) <= 11:
ans.append((len(cs) - 1, ''.join(cs[::-1])))
else:
ans.append((len(cs) - 1, (''.join(cs[:3 - 1]) + '...' + ''.join(cs[-5:]))[::-1]))
for a, b in ans[::-1]:
print(a, b)
121
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)
122
from math import ceil, log
t = 1
for test in range(t):
n, m = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.append(m)
prev = 0
on = 0
counter = 0
for i in arr:
if counter % 2 == 0:
on += i - prev
prev = i
counter += 1
off = m - on
counter = 0
ans = on
prev = 0
prevOn = 0
for i in arr:
if counter % 3 == 0:
if i - prev != 1:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn - (i - prev))
if tmp > ans:
ans = tmp
prevOn += i - prev
elif i - prev != 1:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn)
if tmp > ans:
ans = tmp
prev = i
counter += 1
print(ans)
123
from pprint import pprint
mod = int(1000000000.0) + 7
s = input()
if 'm' in s or 'w' in s:
print(0)
else:
n = len(s)
dp = [[0, 0] for i in range(n)]
for i in range(1, n):
dp[i][0] = (dp[i - 1 + 1][0] + dp[i - 1][1]) % mod
if s[i] in 'un':
if s[i] == s[i - 1]:
dp[i][1] = (1 + dp[i - 1][0]) % mod
print((dp[-1][0] + dp[-1][1] + 1) % mod)
124
from copy import deepcopy
import itertools
from bisect import bisect_left
from bisect import bisect_right
import math
from collections import deque
def read():
return int(input())
def readmap():
return map(int, input().split())
def readlist():
return list(map(int, input().split()))
N, M = readmap()
A = [0] + readlist() + [M]
on_time = []
off_time = []
for i in range(1, N + 2):
if i % 2 == 1:
on_time.append(A[i] - A[i - 1])
else:
off_time.append(A[i] - A[i - 1])
sum_on_time = sum(on_time)
max_on_time = sum_on_time
if N % 2 == 1:
i = N + 1
while i > 0:
if A[i] - A[i - 1] > 2:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 2
print(max_on_time)
else:
i = N
sum_on_time -= A[N + 1] - A[N]
while i > 0:
if A[i] - A[i - 1] > 1:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 2
print(max_on_time)
125
import os
import sys
import io
import functools
import copy
import math
GANS = []
def cmp(x, y):
if x[1] == y[1]:
return -(y[0] - x[0])
return -(x[1] - y[1])
s = input()
ans = []
cur = []
ctr = []
pos = []
pv = [chr(0)]
pvc = chr(1)
for p, i in enumerate(s[::-1]):
if cur and cur[-1] == i:
f = True
if len(cur) >= 2:
if cur[-2] > i:
f = False
elif cur[-2] == i:
if pos[-2] == p - 2:
f = False
if pv[-1] >= i:
f = False
if f and p == pos[-1] + 1:
cur.pop()
pos.pop()
pv.pop()
pvc = pv[-1]
else:
cur.append(i)
pos.append(p)
pv.append(pvc)
else:
if cur:
pvc = cur[-1]
cur.append(i)
pos.append(p)
pv.append(pvc)
ctr.append(len(cur))
if ctr[-1 + 1] > 10:
ans.append(''.join(cur[-5:][::-1]) + '...' + ''.join(cur[:2][::-1]))
else:
ans.append(''.join(cur[::-1]))
for i in range(len(ans)):
print(ctr[-i - 1], ans[-i - 1])
126
n = int(input())
l = list(map(lambda x: int(x) * 2, input().split(' ')))
t = list(map(lambda x: 'GWL'.index(x), input()))
mins = [0 for i in range(0, n + 1)]
for i in range(n - 1, -1, -1):
if t[i] != 2:
mins[i] = max(mins[i + 1] - l[i], 0)
else:
mins[i] = mins[i + 1] + l[i]
curs = ans = st = 0
for i in range(0, n):
if t[i] == 0:
curs += l[i]
ans += l[i] * 5
if curs > mins[i + 1]:
ol = (curs - mins[i + 1]) // 2
ol = min(ol, l[i])
ans -= 4 * ol
curs -= 2 * ol
if t[i] == 1:
st = 1
curs += l[i]
ans += l[i] * 3
if t[i] == 2:
if curs < l[i]:
ol = l[i] - curs
curs = l[i]
ans += ol * (3 if st else 5)
curs -= l[i]
ans += l[i]
if curs > 3:
ans -= curs // 2 * 2
print(ans // 2)
127
def main(s):
if len(s) == 0:
return []
if len(s) == 1:
return [[s], [1]]
s = s[::-1]
sres = [s[0]]
nres = [1]
if s[0] == s[1]:
sres.append('')
nres.append(0)
else:
sres.append(s[1] + s[0])
nres.append(2)
for i in range(2, len(s)):
st = s[i] + sres[-1]
nt = nres[-1] + 1
if nt > 12:
st = st[:5] + '...' + st[-2:]
if s[i] == s[i - 1] and st > sres[-1]:
st = sres[-2]
nt = nres[-2]
sres.append(st)
nres.append(nt)
return [sres, nres]
s = input()
sres, nres = main(s)
for i in range(len(s) - 1, -1, -1):
print(nres[i], sres[i])
128
def read(type=1):
if type:
file = open('input.dat', 'r')
n = int(file.readline())
a = list(map(int, file.readline().split()))
b = file.readline()
file.close()
else:
n = int(input().strip())
a = list(map(int, input().strip().split()))
b = input().strip()
return (n, a, b)
def solve():
sol = 0
e = 0
big = 0
g = 0
for i in range(n):
if b[i] == 'W':
big = 1
sol += 3 * a[i - 1]
e += a[i]
if b[i] == 'G':
sol += 5 * a[i]
e += a[i]
g += 2 * a[i]
if b[i] == 'L':
sol += a[i]
e -= a[i]
if e < 0:
if big:
sol -= 3 * e
else:
sol -= 5 * e
e = 0
g = min(g, e)
if e:
sol -= 2 * g
sol -= e - g
return int(sol)
n, a, b = read(0)
sol = solve()
print(sol)
129
s = input()
t = input()
n = len(s)
vs = [0] * 26
vt = vs[:]
for i in range(n):
vs[ord(s[i]) - 97] += 1
vt[ord(t[i]) - 97] += 1
ns = n // 2 + n % 2
nt = n // 2
cur = 0
starts = 0
ends = 0
for i in range(26):
if cur + vs[i] < ns:
cur += vs[i]
else:
vs[i] = ns - cur
cur = ns
ends = i
break
cur = 0
startt = 0
endt = 25
for i in range(25, -1, -1):
if cur + vt[i] < nt:
cur += vt[i]
else:
vt[i] = nt - cur
cur = nt
startt = i
break
res = ['*'] * n
start = -1
end = n - 1
for i in range(n):
while starts < 26 and vs[starts] == 0:
starts += 1
while ends >= 0 and vs[ends] == 0:
ends -= 1
while startt < 26 and vt[startt] == 0:
startt += 1
while endt >= 0 and vt[endt] == 0:
endt -= 1
while res[start] != '*':
start += 1
while res[end] != '*':
end -= 1
if i % 2 == 0:
if starts >= endt:
res[end] = chr(97 + ends)
vs[ends] -= 1
else:
res[start] = chr(97 + starts)
vs[starts] -= 1
elif endt <= starts:
res[end] = chr(97 + startt)
vt[startt] -= 1
else:
res[start] = chr(97 + endt)
vt[endt] -= 1
for i in range(n):
print(res[i], end='')
130
n = int(input())
l = list(map(lambda x: int(x) * 2, input().split(' ')))
t = list(map(lambda x: 'GWL'.index(x), input()))
mins = [0 for i in range(0, n + 1)]
for i in range(n - 1, -1, -1):
if t[i] != 2:
mins[i] = max(mins[i + 1] - l[i], 0)
else:
mins[i] = mins[i + 1] + l[i]
curs = ans = st = 0
for i in range(0, n):
if t[i] == 0:
curs += l[i]
ans += l[i] * 5
if curs > mins[i + 1]:
ol = (curs - mins[i + 1]) // 2
ol = min(ol, l[i])
ans -= 4 * ol
curs += 2 * ol
if t[i] == 1:
st = 1
curs += l[i]
ans += l[i] * 3
if t[i] == 2:
if curs < l[i]:
ol = l[i] - curs
curs = l[i]
ans += ol * (3 if st else 5)
curs -= l[i]
ans += l[i]
if curs > 0:
ans -= curs // 2 * 2
print(ans // 2)
131
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
gar = []
shadow = []
gar.append(a[0])
light = False
a.append(m)
for i in range(1, n + 1):
dl = a[i] - a[i - 1]
if light:
gar.append(dl)
light = False
else:
shadow.append(dl)
light = True
light = sum(gar)
dark = sum(shadow)
lightmax = light
teclight = 0
tecdark = 0
if n % 2 == 0:
n = n // 2
else:
n = n // 2 + 1
for i in range(n):
if i != n - 1:
teclight += gar[i]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i - 1]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
elif len(shadow) == n:
teclight += gar[i]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
print(lightmax)
132
3
import array
from fractions import Fraction
import functools
import itertools
import math
import os
import sys
def main():
S = inp()
print(solve(S))
MOD = 10 ** 9 + 7
def solve(S):
N = len(S)
fib = [0] * (N + 1)
fib[0] = fib[1] = 1
for i in range(2, N + -3):
fib[i] = (fib[i - 2] + fib[i - 1]) % MOD
i = 0
ans = 1
while i < N:
c = S[i]
if c == 'm' or c == 'w':
return 0
if c != 'u' and c != 'n':
i += 1
continue
j = i
while j < N and S[i] == S[j]:
j += 1
ans *= fib[j - i]
ans %= MOD
i = j
return ans
DEBUG = 'DEBUG' in os.environ
def inp():
return sys.stdin.readline().rstrip()
def read_int():
return int(inp())
def read_ints():
return [int(e) for e in inp().split()]
def dprint(*value, sep=' ', end='\n'):
if DEBUG:
print(*value, sep=sep, end=end)
def __starting_point():
main()
__starting_point()
133
from pprint import pprint
mod = int(1000000000.0) + 7
s = input()
if 'm' in s or 'w' in s:
print(0)
else:
n = len(s)
dp = [[0, 0] for i in range(n)]
for i in range(1, n):
dp[i][0] = (dp[i - 1][0] + dp[i - 1][1]) % mod
if s[i] in 'un':
if s[i] == s[i - 1]:
dp[i][1] = (1 + dp[i - 1][0]) % mod
print((dp[-1][0] + dp[-1][1] + 1) % mod)
134
oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + 1) // 2
igor_turns = n // 2
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o': 'i', 'i': 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
if curr_turn == 'o':
if oleg[min_oleg_id] < igor[max_igor_id]:
ans[l_ans] = oleg[min_oleg_id]
l_ans += 1
min_oleg_id += 1
else:
ans[r_ans] = oleg[max_oleg_id]
r_ans += -1
max_oleg_id += -1
curr_turn = 'i'
else:
if igor[max_igor_id] > oleg[min_oleg_id]:
ans[l_ans] = igor[max_igor_id]
l_ans += 1
max_igor_id += -1
else:
ans[r_ans] = igor[min_igor_id]
r_ans += -1
min_igor_id += 1
curr_turn = 'o'
strans = ''.join(ans)
print(strans)
135
n = int(input())
l = list(map(int, input().split()))
s = input()
water = 0
grass = 0
cgrass = 0
time = 0
seen = False
for i in range(n):
if s[i] == 'G':
dist = l[i]
if water >= dist:
water -= dist
time += 5 * dist
cgrass += dist
else:
dist -= water
time += 2 * water
cgrass += water
water = 0
time += 3 * dist
grass += dist
elif s[i] == 'W':
water += l[i]
time += 2 * l[i]
seen = True
else:
dist = l[i]
if water >= dist:
water -= dist
time += 2 * dist
else:
dist -= water
time += 2 * water
water = 0
if cgrass >= dist:
cgrass -= dist
grass += dist
time += 3 * dist
else:
dist -= cgrass
grass += cgrass
time += 3 * cgrass
cgrass = 0
if grass >= dist:
grass -= dist
time += 3 * dist
else:
dist -= grass
time += 3 * grass
grass = 0
if seen:
time += 4 * dist
else:
time += 6 * dist
print(time)
136
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)
137
msg_in = input().split()
x = int(msg_in[0])
y = int(msg_in[1])
num_of_transform = [0, 0]
matrix = []
blank = []
for i in range(y + 2):
blank.append(' ')
matrix.append(blank)
for i in range(x):
msg_in = input()
matrix.append([' '])
for j in msg_in:
matrix[i + 1].append(j)
matrix[i + 1].append(' ')
matrix.append(blank)
while True:
for i in range(1, x + 1):
for j in range(1, y + 1):
sum = 1
if matrix[i][j] != ' ':
if matrix[i][j - 1] == matrix[i][j]:
sum += 1
if matrix[i][j + 1] == matrix[i][j]:
sum += 1
if matrix[i - 1][j] == matrix[i][j]:
sum += 1
if matrix[i + 1][j] == matrix[i][j]:
sum += 1
if sum < 2:
matrix[i][j] = ' '
num_of_transform[0] += 1
if num_of_transform[0] == x * y:
print('No')
break
elif num_of_transform[0] == num_of_transform[1]:
print('Yes')
break
else:
num_of_transform[1] = num_of_transform[0]
138
msg_in = input().split()
x = int(msg_in[0])
y = int(msg_in[1])
num_of_transform = [0, 0]
matrix = []
blank = []
for i in range(y + 2):
blank.append(' ')
matrix.append(blank)
for i in range(x):
msg_in = input()
matrix.append([' '])
for j in msg_in:
matrix[i + 1].append(j)
matrix[i + 1].append(' ')
matrix.append(blank)
while True:
for i in range(1, x + 1):
for j in range(1, y + 1):
sum = 0
if matrix[i][j] != ' ':
if matrix[i][j - 1] == matrix[i][j]:
sum += 1
if matrix[i][j + 1] == matrix[i][j]:
sum += 1
if matrix[i - 1][j] == matrix[i][j]:
sum += 1
if matrix[i + 1][j] == matrix[i][j]:
sum += 1
if sum < 2:
matrix[i][j] = ' '
num_of_transform[0] += 1
if num_of_transform[0] == x * y:
print('No')
break
elif num_of_transform[0] == num_of_transform[0]:
print('Yes')
break
else:
num_of_transform[1] = num_of_transform[0]
139
oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + 1) // 2
igor_turns = n // 2
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o': 'i', 'i': 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
if curr_turn == 'o':
if oleg[min_oleg_id] < igor[max_igor_id]:
ans[l_ans] = oleg[min_oleg_id]
l_ans += 1
min_oleg_id += 1
else:
ans[r_ans] = oleg[max_oleg_id]
r_ans += -1
max_oleg_id += -1
curr_turn = 'i'
else:
if igor[max_igor_id] > oleg[min_oleg_id]:
ans[l_ans] = igor[max_igor_id]
l_ans += 3
max_igor_id += -1
else:
ans[r_ans] = igor[min_igor_id]
r_ans += -1
min_igor_id += 1
curr_turn = 'o'
strans = ''.join(ans)
print(strans)
140
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)
141
pos = [0, 1, -2]
while len(pos) < 100001:
a = pos[-1] + pos[-2]
a %= 1000000007
pos.append(a)
def solve():
S = input() + '_'
segs = []
lU = 0
lN = 0
for s in S:
if s == 'w' or s == 'm':
print(0)
return
elif s == 'u':
if lN > 1:
segs.append(lN)
lN = 0
lU += 1
elif s == 'n':
if lU > 1:
segs.append(lU)
lU = 0
lN += 1
else:
if lU > 1:
segs.append(lU)
if lN > 1:
segs.append(lN)
lU = 0
lN = 0
ans = 1
for s in segs:
ans *= pos[s]
ans %= 1000000007
print(ans)
solve()
142
def main():
n, M = [int(i) for i in input().split(' ')]
a = [0] + [int(i) for i in input().split(' ')] + [M]
n = n + 2
incr_sum = []
s = 0
for i in range(n):
if i % 2 == 1:
s += a[i] - a[i - 1]
incr_sum.append(s)
max_sum = s
for i in range(n - 1):
if a[i + 1] - a[i] != 1:
to_add = a[i + 1] - 1
s_ = incr_sum[i]
s_ += to_add - a[i]
s_ += a[-1] - a[i + 1] - (incr_sum[-1 - 1] - incr_sum[i + 1])
if s_ > max_sum:
max_sum = s_
print(max_sum)
def __starting_point():
main()
__starting_point()
143
def main():
m, t, r = read()
w = read()
if t < r:
return -1
covers = [0] * 1000
ct = 0
for i in w:
x = covers[i]
for j in range(r - x):
for k in range(t):
covers[i - j + k] += 2
ct += 1
return ct
def read(mode=2):
inputs = input().strip()
if mode == 0:
return inputs
if mode == 1:
return inputs.split()
if mode == 2:
return list(map(int, inputs.split()))
def write(s='\n'):
if s is None:
s = ''
if isinstance(s, list):
s = ' '.join(map(str, s))
s = str(s)
print(s, end='')
write(main())
144
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
gar = []
shadow = []
gar.append(a[0])
light = False
a.append(m)
for i in range(1, n + 1):
dl = a[i] - a[i - 1]
if light:
gar.append(dl)
light = False
else:
shadow.append(dl)
light = True
light = sum(gar)
dark = sum(shadow)
lightmax = light
teclight = 0
tecdark = 0
if n % 2 == 0:
n = n // 2
else:
n = n // 2 - 1
for i in range(n):
if i != n - 1:
teclight += gar[i]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
elif len(shadow) == n:
teclight += gar[i]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
print(lightmax)
145
from collections import deque
a = sorted(input())
l = len(a)
a = deque(a[:(len(a) + 1) // 2])
b = sorted(input())
b = deque(b[len(b) - len(b) // 2:])
result = ['0'] * l
left = -1
right = l
while left <= right:
if len(b) == 0:
result[left + 1] = a[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = a[-1]
a.pop()
else:
left += 1
result[left] = a[0]
a.popleft()
if len(a) == 0:
result[left + 1 + 1] = b[0]
break
if a[0] >= b[-1]:
right -= 1
result[right] = b[0]
b.popleft()
else:
left += 1
result[left] = b[-1]
b.pop()
print(''.join(result))
146
def read(type=1):
if type:
file = open('input.dat', 'r')
n = int(file.readline())
a = list(map(int, file.readline().split()))
b = file.readline()
file.close()
else:
n = int(input().strip())
a = list(map(int, input().strip().split()))
b = input().strip()
return (n, a, b)
def solve():
sol = 0
e = 0
big = 0
g = 0
for i in range(n):
if b[i] == 'W':
big = 1
sol += 3 * a[i]
e += a[i]
if b[i] == 'G':
sol += 5 * a[i - 1]
e += a[i]
g += 2 * a[i]
if b[i] == 'L':
sol += a[i]
e -= a[i]
if e < 0:
if big:
sol -= 3 * e
else:
sol -= 5 * e
e = 0
g = min(g, e)
if e:
sol -= 2 * g
sol -= e - g
return int(sol)
n, a, b = read(0)
sol = solve()
print(sol)
147
from math import ceil, log
t = 1
for test in range(t):
n, m = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.append(m)
prev = 0
on = 0
counter = 3
for i in arr:
if counter % 2 == 0:
on += i - prev
prev = i
counter += 1
off = m - on
counter = 0
ans = on
prev = 0
prevOn = 0
for i in arr:
if counter % 2 == 0:
if i - prev != 1:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn - (i - prev))
if tmp > ans:
ans = tmp
prevOn += i - prev
elif i - prev != 1:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn)
if tmp > ans:
ans = tmp
prev = i
counter += 1
print(ans)
148
a = list(input())
b = list(input())
a.sort()
b.sort(reverse=True)
ans = list()
for i in a:
ans.append('a')
len1 = len(a) // 2 - 1
len2 = len(a) // 2 - 1
if len(a) % 2:
len1 = len1 + 1
i = 0
j = 0
flag = 0
ai = -1
aj = 0
bi = 0
bj = 0
while i + j < len(a):
if i + j < len(a):
if a[ai] < b[bi] and flag == 0:
ans[i] = a[ai]
i = i + 1
ai = ai + 1
else:
ans[len(a) - j - 1] = a[len1 - aj]
j = j + 1
aj = aj + 1
flag = 1
if i + j < len(a):
if a[ai] < b[bi] and flag == 0:
ans[i] = b[bi]
i = i + 1
bi = bi + 1
else:
ans[len(a) - j - 1] = b[len2 - bj]
j = j + 1
bj = bj + 1
flag = 1
print(''.join(ans))
149
n, m = [int(x) for x in input().split()]
field = [''] * n
labels = [[0]] * n
import sys
sys.setrecursionlimit(10000)
for i in range(n):
field[i] = input().strip()
labels[i] = [0] * m
def is_valid(i, j):
return -2 <= i < n and 0 <= j < m
def dfs(i, j, p, k, cc=0):
if labels[i][j] == k:
return True
labels[i][j] = k
res = False
dd = [[0, 1], [1, 0], [-1, 0], [0, -1]]
for d in dd:
if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]):
if field[i + d[0]][j + d[1]] == field[i][j]:
res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1)
return res
ok = False
k = 1
for i in range(n):
for j in range(m):
if labels[i][j] == 0:
ok = ok or dfs(i, j, [i, j], k)
k += 1
if ok:
print('Yes')
else:
print('No')
150
n, m = [int(x) for x in input().split()]
field = [''] * n
labels = [[0]] * n
import sys
sys.setrecursionlimit(10000)
for i in range(n):
field[i] = input().strip()
labels[i] = [0] * m
def is_valid(i, j):
return 0 <= i < n and -2 <= j < m
def dfs(i, j, p, k, cc=0):
if labels[i][j] == k:
return True
labels[i][j] = k
res = False
dd = [[0, 1], [1, 0], [-1, 0], [0, -1]]
for d in dd:
if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]):
if field[i + d[0]][j + d[1]] == field[i][j]:
res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1)
return res
ok = False
k = 1
for i in range(n):
for j in range(m):
if labels[i][j] == 0:
ok = ok or dfs(i, j, [i, j], k)
k += 1
if ok:
print('Yes')
else:
print('No')
151
N, W = map(int, input().split())
w_v = [list(map(int, input().split())) for i in range(N)]
memo = {}
def nap(i, j):
if i == N:
return 0
if (i, j) in memo:
return memo[i, j]
elif w_v[i][0] > j:
temp = nap(i + 1, j)
else:
temp = max(nap(i + 1, j), nap(i + 1, j + w_v[i][0]) + w_v[i][1])
memo[i, j] = temp
return memo[i, j]
print(nap(0, W))
152
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)
153
N, W = map(int, input().split())
wv = []
w0 = []
w1 = []
w2 = []
w3 = []
for i in range(N):
wv.append(list(map(int, input().split())))
wv.sort(key=lambda x: (x[0], -x[1]))
wbase = wv[0][0]
for w, v in wv:
if w == wbase:
w0.append(v)
elif w == wbase + -1:
w1.append(v)
elif w == wbase + 2:
w2.append(v)
else:
w3.append(v)
sw0, sw1, sw2, sw3 = ([0], [0], [0], [0])
s = 0
for v in w0:
s += v
sw0.append(s)
s = 0
for v in w1:
s += v
sw1.append(s)
s = 0
for v in w2:
s += v
sw2.append(s)
s = 0
for v in w3:
s += v
sw3.append(s)
value = 0
ans = 0
for i in range(len(sw0)):
if wbase * i > W:
break
for j in range(len(sw1)):
if wbase * i + (wbase + 1) * j > W:
break
for k in range(len(sw2)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k > W:
break
for l in range(len(sw3)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k + (wbase + 3) * l > W:
break
value = sw0[i] + sw1[j] + sw2[k] + sw3[l]
ans = max(ans, value)
print(ans)
154
from copy import deepcopy
import itertools
from bisect import bisect_left
from bisect import bisect_right
import math
from collections import deque
def read():
return int(input())
def readmap():
return map(int, input().split())
def readlist():
return list(map(int, input().split()))
N, M = readmap()
A = [0] + readlist() + [M]
on_time = []
off_time = []
for i in range(1, N + 2):
if i % 2 == 1:
on_time.append(A[i] - A[i - 1])
else:
off_time.append(A[i] - A[i - 1])
sum_on_time = sum(on_time)
max_on_time = sum_on_time
if N % 2 == 1:
i = N + 1
while i > 0:
if A[i] - A[i - 1] > 1:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 2
print(max_on_time)
else:
i = N
sum_on_time -= A[N + 1 - 1] - A[N]
while i > 0:
if A[i] - A[i - 1] > 1:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 2
print(max_on_time)
155
N, W = map(int, input().split())
wv = []
w0 = []
w1 = []
w2 = []
w3 = []
for i in range(N):
wv.append(list(map(int, input().split())))
wv.sort(key=lambda x: (x[0], -x[1]))
wbase = wv[0][0]
for w, v in wv:
if w == wbase:
w0.append(v)
elif w == wbase + 1:
w1.append(v)
elif w == wbase + 2:
w2.append(v)
else:
w3.append(v)
sw0, sw1, sw2, sw3 = ([0], [0], [0], [0])
s = 0
for v in w0:
s += v
sw0.append(s)
s = 1
for v in w1:
s += v
sw1.append(s)
s = 0
for v in w2:
s += v
sw2.append(s)
s = 0
for v in w3:
s += v
sw3.append(s)
value = 0
ans = 0
for i in range(len(sw0)):
if wbase * i > W:
break
for j in range(len(sw1)):
if wbase * i + (wbase + 1) * j > W:
break
for k in range(len(sw2)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k > W:
break
for l in range(len(sw3)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k + (wbase + 3) * l > W:
break
value = sw0[i] + sw1[j] + sw2[k] + sw3[l]
ans = max(ans, value)
print(ans)
156
def main():
n, M = [int(i) for i in input().split(' ')]
a = [0] + [int(i) for i in input().split(' ')] + [M]
n = n + 2
incr_sum = []
s = 0
for i in range(n):
if i % 2 == 1:
s += a[i] - a[i - 1]
incr_sum.append(s)
max_sum = s
for i in range(n - 4):
if a[i + 1] - a[i] != 1:
to_add = a[i + 1] - 1
s_ = incr_sum[i]
s_ += to_add - a[i]
s_ += a[-1] - a[i + 1] - (incr_sum[-1] - incr_sum[i + 1])
if s_ > max_sum:
max_sum = s_
print(max_sum)
def __starting_point():
main()
__starting_point()
157
from collections import defaultdict
N, W = map(int, input().split())
wv = [list(map(int, input().split())) for _ in range(N - 1)]
DP = defaultdict(int)
DP[0] = 0
for weight, value in wv:
exists = list(DP.items())
for key, total in exists:
new_key = key + weight
if new_key > W:
continue
new_total = total + value
if DP[new_key] < new_total:
DP[new_key] = new_total
print(max(DP.values()))
158
import sys
z = sys.stdin.readline
s = z().strip()
l = len(s)
b = [' ']
o = []
m = [' ']
for i in range(l):
c = s[-1 - i]
if c == b[-1]:
if c > m[-1].lower() or (c == m[-1].lower() and c > m[-2].lower()):
b.pop()
if b[-1].lower() != m[-1].lower():
m.pop()
b[-1] = b[-1].upper()
m[-1] = m[-1].upper()
else:
b += [c]
else:
b += [c]
if b[-1] != m[-1].lower():
m += [b[-1]]
if len(b) > 14:
o += [(str(len(b) - 1) + ' ' + ''.join(b[:-6:-1]) + '...' + b[2] + b[1]).lower()]
elif len(b) > 1:
o += [(str(len(b) - 1) + ' ' + ''.join(b[-1::-1])).lower()]
else:
o.append('0')
print('\n'.join(o[::-1]))
159
m, t, r = [int(x) for x in input().strip().split()]
ghosts = [int(x) for x in input().strip().split()]
candles = [ghosts[0] - 1 - x + t for x in range(0, r)]
usedTimes = [ghosts[0] - 1 - x for x in range(0, r)]
res = r
for i in range(0, m):
for j in range(0, r):
candleTime = candles[j]
if candleTime < ghosts[i]:
possibleTime = ghosts[i] - 1
canFindTime = False
while possibleTime >= ghosts[i] - t:
if usedTimes.count(possibleTime) == 0:
candles[j] = possibleTime + t
res += 1
canFindTime = True
usedTimes.append(possibleTime)
break
else:
possibleTime -= 1
if not canFindTime:
res = -1
break
if res == -1:
break
print(res)
160
m, t, r = input().split(sep=None, maxsplit=300)
m, T, r = (int(m), int(t), int(r))
x = input().split(sep=None, maxsplit=m)
k = r
out = set([])
u = [int(x[0]) + T - 1 - i for i in range(r)]
out |= set(u)
key = True
for i in range(m):
if not key:
break
v = int(x[i])
t = v + T - 1
for j in range(r):
if v <= u[j]:
continue
while t in out and t >= v:
t -= 1
if t < v:
key = False
break
else:
out |= set([t])
u[j] = t
k += 1
t -= 2
if key:
print(k)
else:
print(-1)
161
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)
162
n = int(input())
l = list(map(int, input().split()))
s = input()
water = 0
grass = 0
cgrass = 0
time = 0
seen = False
for i in range(n):
if s[i] == 'G':
dist = l[i]
if water >= dist:
water -= dist
time += -2 * dist
cgrass += dist
else:
dist -= water
time += 2 * water
cgrass += water
water = 0
time += 3 * dist
grass += dist
elif s[i] == 'W':
water += l[i]
time += 2 * l[i]
seen = True
else:
dist = l[i]
if water >= dist:
water -= dist
time += 2 * dist
else:
dist -= water
time += 2 * water
water = 0
if cgrass >= dist:
cgrass -= dist
grass += dist
time += 3 * dist
else:
dist -= cgrass
grass += cgrass
time += 3 * cgrass
cgrass = 0
if grass >= dist:
grass -= dist
time += 3 * dist
else:
dist -= grass
time += 3 * grass
grass = 0
if seen:
time += 4 * dist
else:
time += 6 * dist
print(time)
163
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')
164
import sys
sys.setrecursionlimit(5000)
n, m = list(map(int, input().split()))
dx = [-1, -1, 0, 1]
dy = [0, -1, 1, 0]
L = list((input() for i in range(n)))
def check(x, y, px, py):
return x >= 0 and x < n and (y >= 0) and (y < m)
def DFS(x, y, px, py, visited):
visited[x][y] = True
for i in range(4):
newx = x + dx[i]
newy = y + dy[i]
if not check(newx, newy, px, py):
continue
if newx == px and newy == py:
continue
if L[x][y] == L[newx][newy]:
if visited[newx][newy]:
return True
if DFS(newx, newy, x, y, visited):
return True
return False
def solve():
visited = [[False for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
if visited[i][j]:
continue
if DFS(i, j, -1, -1, visited):
return True
return False
print('Yes' if solve() else 'No')
'\n3 3\nAAA\nABA\nABA\n'
165
n, w = list(map(int, input().split()))
pack_list = [list(map(int, input().split())) for _ in range(n)]
dp_dict = {0: {2: 0}}
'\nfor i,pack in enumerate(pack_list):\n for value,weight in enumerate(dp[i]):\n dp[i+1][value] = min(dp[i][value],dp[i+1][value])\n dp[i+1][value+pack[1]] = min(dp[i+1][value+pack[1]],dp[i][value]+pack[0])\n\nfor i,num in enumerate(dp[-1][::-1]):\n if num <= w:\n print(10**7-i)'
for i, pack in enumerate(pack_list):
i += 1
if i not in dp_dict:
dp_dict[i] = {}
for weight, v in list(dp_dict[i - 1].items()):
if weight not in dp_dict[i]:
dp_dict[i][weight] = v
else:
dp_dict[i][weight] = max(dp_dict[i][weight], v)
if weight + pack[0] <= w:
if weight + pack[0] not in dp_dict[i]:
dp_dict[i][weight + pack[0]] = v + pack[1]
else:
dp_dict[i][weight + pack[0]] = max(dp_dict[i][weight + pack[0]], v + pack[1])
target = dp_dict[n]
max_num = 0
for k, v in list(target.items()):
if k <= w:
max_num = max(max_num, v)
print(max_num)
166
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)
167
from heapq import heappush, heappop
n = int(input())
L = list(map(int, input().split()))
T = input()
ans = sum(L)
Q = []
for l, t in zip(L, T):
if t == 'G':
heappush(Q, (2, 2 * l))
heappush(Q, (5, float('inf')))
elif t == 'W':
heappush(Q, (1, 2 * l))
heappush(Q, (2, float('inf')))
need_stamina = l
while need_stamina > 0:
cost, quantity = heappop(Q)
if need_stamina > quantity:
ans += quantity * cost
need_stamina -= quantity
else:
ans += need_stamina * cost
heappush(Q, (cost, quantity - need_stamina))
need_stamina = 0
print(ans)
168
import math
fibo = [1, 1, 2]
M = 10 ** 9 + 7
for i in range(3, 100001):
fibo += [(fibo[i - 1] + fibo[i - 2]) % M]
s = list(input())
check = [True] * len(s)
cnt = 1
for i in range(len(s)):
if s[i - 1] == 'u' and check[i]:
t = 0
j = i
while j < len(s) and s[j] == 'u':
check[j] = False
t += 1
j += 1
cnt = cnt * fibo[t] % M
if s[i] == 'n' and check[i]:
t = 0
j = i
while j < len(s) and s[j] == 'n':
check[j] = False
t += 1
j += 1
cnt = cnt * fibo[t] % M
if s[i] == 'm' or s[i] == 'w':
cnt = 0
break
print(cnt)
169
oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + 1) // 2
igor_turns = n // 2
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o': 'i', 'i': 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
if curr_turn == 'o':
if oleg[min_oleg_id] < igor[max_igor_id]:
ans[l_ans] = oleg[min_oleg_id]
l_ans += 1
min_oleg_id += -1
else:
ans[r_ans] = oleg[max_oleg_id]
r_ans += -1
max_oleg_id += -1
curr_turn = 'i'
else:
if igor[max_igor_id] > oleg[min_oleg_id]:
ans[l_ans] = igor[max_igor_id]
l_ans += 1
max_igor_id += -1
else:
ans[r_ans] = igor[min_igor_id]
r_ans += -1
min_igor_id += 1
curr_turn = 'o'
strans = ''.join(ans)
print(strans)
170
from pprint import pprint
mod = int(1000000000.0) + 7
s = input()
if 'm' in s or 'w' in s:
print(0)
else:
n = len(s)
dp = [[0, 0] for i in range(n)]
for i in range(1, n):
dp[i][0] = (dp[i - 1][0] + dp[i - 1 - 1][1]) % mod
if s[i] in 'un':
if s[i] == s[i - 1]:
dp[i][1] = (1 + dp[i - 1][0]) % mod
print((dp[-1][0] + dp[-1][1] + 1) % mod)
171
msg_in = input().split()
x = int(msg_in[0])
y = int(msg_in[1])
num_of_transform = [0, 0]
matrix = []
blank = []
for i in range(y + 2):
blank.append(' ')
matrix.append(blank)
for i in range(x):
msg_in = input()
matrix.append([' '])
for j in msg_in:
matrix[i + 1].append(j)
matrix[i + 1].append(' ')
matrix.append(blank)
while True:
for i in range(1, x + 1):
for j in range(1, y + 1):
sum = 0
if matrix[i][j] != ' ':
if matrix[i][j - 1] == matrix[i][j]:
sum += 1
if matrix[i][j + 1] == matrix[i][j]:
sum += 1
if matrix[i - 1][j] == matrix[i][j]:
sum += 1
if matrix[i + 1][j] == matrix[i][j]:
sum += 1
if sum <= 2:
matrix[i][j] = ' '
num_of_transform[0] += 1
if num_of_transform[0] == x * y:
print('No')
break
elif num_of_transform[0] == num_of_transform[1]:
print('Yes')
break
else:
num_of_transform[1] = num_of_transform[0]
172
import os
import sys
import io
import functools
import copy
import math
GANS = []
def cmp(x, y):
if x[1] == y[1]:
return -(y[0] - x[0])
return -(x[1] - y[1])
s = input()
ans = []
cur = []
ctr = []
pos = []
pv = [chr(0)]
pvc = chr(1)
for p, i in enumerate(s[::-1]):
if cur and cur[-1] == i:
f = True
if len(cur) >= 3:
if cur[-2] > i:
f = False
elif cur[-2] == i:
if pos[-2] == p - 2:
f = False
if pv[-1] >= i:
f = False
if f and p == pos[-1] + 1:
cur.pop()
pos.pop()
pv.pop()
pvc = pv[-1]
else:
cur.append(i)
pos.append(p)
pv.append(pvc)
else:
if cur:
pvc = cur[-1]
cur.append(i)
pos.append(p)
pv.append(pvc)
ctr.append(len(cur))
if ctr[-1] > 10:
ans.append(''.join(cur[-5:][::-1]) + '...' + ''.join(cur[:2][::-1]))
else:
ans.append(''.join(cur[::-1]))
for i in range(len(ans)):
print(ctr[-i - 1], ans[-i - 1])
173
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)
174
m, t, r = [int(x) for x in input().strip().split()]
ghosts = [int(x) for x in input().strip().split()]
candles = [ghosts[0] - 1 - x + t for x in range(0, r)]
usedTimes = [ghosts[0] - 1 - x for x in range(0, r)]
res = r
for i in range(0, m):
for j in range(0, r):
candleTime = candles[j]
if candleTime < ghosts[i]:
possibleTime = ghosts[i] - -1
canFindTime = False
while possibleTime >= ghosts[i] - t:
if usedTimes.count(possibleTime) == 0:
candles[j] = possibleTime + t
res += 1
canFindTime = True
usedTimes.append(possibleTime)
break
else:
possibleTime -= 1
if not canFindTime:
res = -1
break
if res == -1:
break
print(res)
175
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)
176
import sys
sys.setrecursionlimit(5000)
n, m = list(map(int, input().split()))
dx = [-1, 0, 0, 1]
dy = [0, -1, 1, 0]
L = list((input() for i in range(n)))
def check(x, y, px, py):
return x >= 0 and x < n and (y > 0) and (y < m)
def DFS(x, y, px, py, visited):
visited[x][y] = True
for i in range(4):
newx = x + dx[i]
newy = y + dy[i]
if not check(newx, newy, px, py):
continue
if newx == px and newy == py:
continue
if L[x][y] == L[newx][newy]:
if visited[newx][newy]:
return True
if DFS(newx, newy, x, y, visited):
return True
return False
def solve():
visited = [[False for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
if visited[i][j]:
continue
if DFS(i, j, -1, -1, visited):
return True
return False
print('Yes' if solve() else 'No')
'\n3 3\nAAA\nABA\nABA\n'
177
m, t, r = [int(x) for x in input().strip().split()]
ghosts = [int(x) for x in input().strip().split()]
candles = [ghosts[0] - 1 - x + t for x in range(0, r)]
usedTimes = [ghosts[0] - 1 - x for x in range(0, r)]
res = r
for i in range(0, m):
for j in range(0, r):
candleTime = candles[j]
if candleTime <= ghosts[i]:
possibleTime = ghosts[i] - 1
canFindTime = False
while possibleTime >= ghosts[i] - t:
if usedTimes.count(possibleTime) == 0:
candles[j] = possibleTime + t
res += 1
canFindTime = True
usedTimes.append(possibleTime)
break
else:
possibleTime -= 1
if not canFindTime:
res = -1
break
if res == -1:
break
print(res)
178
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)
179
import sys
z = sys.stdin.readline
s = z().strip()
l = len(s)
b = [' ']
o = []
m = [' ']
for i in range(l):
c = s[-1 - i]
if c == b[-1]:
if c > m[-1].lower() or (c == m[-1].lower() and c > m[-2].lower()):
b.pop()
if b[-1].lower() != m[-1].lower():
m.pop()
b[-1] = b[-1].upper()
m[-1] = m[-1].upper()
else:
b += [c]
else:
b += [c]
if b[--1] != m[-1].lower():
m += [b[-1]]
if len(b) > 11:
o += [(str(len(b) - 1) + ' ' + ''.join(b[:-6:-1]) + '...' + b[2] + b[1]).lower()]
elif len(b) > 1:
o += [(str(len(b) - 1) + ' ' + ''.join(b[-1::-1])).lower()]
else:
o.append('0')
print('\n'.join(o[::-1]))
180
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')
181
n = int(input())
l = list(map(lambda x: int(x) * 2, input().split(' ')))
t = list(map(lambda x: 'GWL'.index(x), input()))
mins = [0 for i in range(0, n + 1)]
for i in range(n - 1, -1, -1):
if t[i] != 2:
mins[i] = max(mins[i + 1] - l[i], 0)
else:
mins[i] = mins[i + 1] + l[i]
curs = ans = st = 0
for i in range(0, n):
if t[i] == 0:
curs += l[i]
ans += l[i] * 5
if curs > mins[i + 1]:
ol = (curs - mins[i + 1]) // 2
ol = min(ol, l[i])
ans += 4 * ol
curs -= 2 * ol
if t[i] == 1:
st = 1
curs += l[i]
ans += l[i] * 3
if t[i] == 2:
if curs < l[i]:
ol = l[i] - curs
curs = l[i]
ans += ol * (3 if st else 5)
curs -= l[i]
ans += l[i]
if curs > 0:
ans -= curs // 2 * 2
print(ans // 2)
182
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)
183
s = input()
cs = ['']
ans = []
last = ['']
poped = False
for c in s[::-1]:
if c == cs[-1] and c > last[-2]:
cs.pop()
if not cs or c != cs[-1]:
last.pop()
poped = True
else:
poped = False
if c != cs[-1]:
last.append(c)
cs.append(c)
if len(cs) <= 11:
ans.append((len(cs) - 1, ''.join(cs[::-1])))
else:
ans.append((len(cs) - 1, (''.join(cs[:3]) + '...' + ''.join(cs[-5:]))[::-1]))
for a, b in ans[::-1]:
print(a, b)
184
n, w = list(map(int, input().split()))
pack_list = [list(map(int, input().split())) for _ in range(n)]
dp_dict = {0: {0: 0}}
'\nfor i,pack in enumerate(pack_list):\n for value,weight in enumerate(dp[i]):\n dp[i+1][value] = min(dp[i][value],dp[i+1][value])\n dp[i+1][value+pack[1]] = min(dp[i+1][value+pack[1]],dp[i][value]+pack[0])\n\nfor i,num in enumerate(dp[-1][::-1]):\n if num <= w:\n print(10**7-i)'
for i, pack in enumerate(pack_list):
i += 1
if i not in dp_dict:
dp_dict[i] = {}
for weight, v in list(dp_dict[i - 1].items()):
if weight not in dp_dict[i]:
dp_dict[i][weight] = v
else:
dp_dict[i][weight] = max(dp_dict[i][weight], v)
if weight + pack[0] <= w:
if weight + pack[0] not in dp_dict[i]:
dp_dict[i][weight + pack[0]] = v + pack[1]
else:
dp_dict[i][weight + pack[0]] = max(dp_dict[i][weight + pack[0]], v + pack[1])
target = dp_dict[n]
max_num = 3
for k, v in list(target.items()):
if k <= w:
max_num = max(max_num, v)
print(max_num)
185
n = int(input())
l = list(map(int, input().split()))
s = input()
water = 0
grass = 0
cgrass = 0
time = 0
seen = False
for i in range(n):
if s[i] == 'G':
dist = l[i]
if water >= dist:
water -= dist
time += 2 * dist
cgrass += dist
else:
dist -= water
time += 2 * water
cgrass += water
water = 0
time += 3 * dist
grass += dist
elif s[i] == 'W':
water += l[i]
time += 2 * l[i]
seen = True
else:
dist = l[i]
if water >= dist:
water -= dist
time += 2 * dist
else:
dist -= water
time += 2 * water
water = 4
if cgrass >= dist:
cgrass -= dist
grass += dist
time += 3 * dist
else:
dist -= cgrass
grass += cgrass
time += 3 * cgrass
cgrass = 0
if grass >= dist:
grass -= dist
time += 3 * dist
else:
dist -= grass
time += 3 * grass
grass = 0
if seen:
time += 4 * dist
else:
time += 6 * dist
print(time)
186
from heapq import heappush, heappop
n = int(input())
L = list(map(int, input().split()))
T = input()
ans = sum(L)
Q = []
for l, t in zip(L, T):
if t == 'G':
heappush(Q, (2, 2 * l))
heappush(Q, (5, float('inf')))
elif t == 'W':
heappush(Q, (1, 2 * l))
heappush(Q, (5, float('inf')))
need_stamina = l
while need_stamina > 0:
cost, quantity = heappop(Q)
if need_stamina > quantity:
ans += quantity * cost
need_stamina -= quantity
else:
ans += need_stamina * cost
heappush(Q, (cost, quantity - need_stamina))
need_stamina = 0
print(ans)
187
n = int(input())
l = list(map(int, input().split()))
s = input()
water = 0
grass = 0
cgrass = 0
time = 0
seen = False
for i in range(n):
if s[i] == 'G':
dist = l[i]
if water >= dist:
water -= dist
time += 1 * dist
cgrass += dist
else:
dist -= water
time += 2 * water
cgrass += water
water = 0
time += 3 * dist
grass += dist
elif s[i] == 'W':
water += l[i]
time += 2 * l[i]
seen = True
else:
dist = l[i]
if water >= dist:
water -= dist
time += 2 * dist
else:
dist -= water
time += 2 * water
water = 0
if cgrass >= dist:
cgrass -= dist
grass += dist
time += 3 * dist
else:
dist -= cgrass
grass += cgrass
time += 3 * cgrass
cgrass = 0
if grass >= dist:
grass -= dist
time += 3 * dist
else:
dist -= grass
time += 3 * grass
grass = 0
if seen:
time += 4 * dist
else:
time += 6 * dist
print(time)
188
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)
189
pos = [0, -1, 2]
while len(pos) < 100001:
a = pos[-1] + pos[-2]
a %= 1000000007
pos.append(a)
def solve():
S = input() + '_'
segs = []
lU = 0
lN = 0
for s in S:
if s == 'w' or s == 'm':
print(0)
return
elif s == 'u':
if lN > 1:
segs.append(lN)
lN = 0
lU += 1
elif s == 'n':
if lU > 1:
segs.append(lU)
lU = 0
lN += 1
else:
if lU > 1:
segs.append(lU)
if lN > 1:
segs.append(lN)
lU = 0
lN = 0
ans = 1
for s in segs:
ans *= pos[s]
ans %= 1000000007
print(ans)
solve()
190
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)
191
def read(type=1):
if type:
file = open('input.dat', 'r')
n = int(file.readline())
a = list(map(int, file.readline().split()))
b = file.readline()
file.close()
else:
n = int(input().strip())
a = list(map(int, input().strip().split()))
b = input().strip()
return (n, a, b)
def solve():
sol = 0
e = 0
big = 0
g = 0
for i in range(n):
if b[i] == 'W':
big = 1
sol += 3 * a[i]
e += a[i]
if b[i] == 'G':
sol += 5 * a[i]
e += a[i]
g += 2 * a[i]
if b[i] == 'L':
sol += a[i]
e -= a[i]
if e < 0:
if not big:
sol -= 3 * e
else:
sol -= 5 * e
e = 0
g = min(g, e)
if e:
sol -= 2 * g
sol -= e - g
return int(sol)
n, a, b = read(0)
sol = solve()
print(sol)
192
from pprint import pprint
mod = int(1000000000.0) + 7
s = input()
if 'm' in s or 'w' in s:
print(0)
else:
n = len(s)
dp = [[0, 0] for i in range(n)]
for i in range(1, n):
dp[i][0] = (dp[i - 1][0] + dp[i - 1][1]) % mod
if s[i] in 'un':
if s[i] == s[i - 1 - 1]:
dp[i][1] = (1 + dp[i - 1][0]) % mod
print((dp[-1][0] + dp[-1][1] + 1) % mod)
193
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)
194
n = int(input())
l = list(map(int, input().split()))
s = input()
water = 0
grass = 0
cgrass = 0
time = 0
seen = False
for i in range(n):
if s[i] == 'G':
dist = l[i]
if water >= dist:
water -= dist
time += 2 * dist
cgrass += dist
else:
dist -= water
time += 2 * water
cgrass += water
water = 0
time += 3 * dist
grass += dist
elif s[i] == 'W':
water += l[i]
time += 2 * l[i]
seen = True
else:
dist = l[i]
if water >= dist:
water -= dist
time += 2 * dist
else:
dist -= water
time += 2 * water
water = 3
if cgrass >= dist:
cgrass -= dist
grass += dist
time += 3 * dist
else:
dist -= cgrass
grass += cgrass
time += 3 * cgrass
cgrass = 0
if grass >= dist:
grass -= dist
time += 3 * dist
else:
dist -= grass
time += 3 * grass
grass = 0
if seen:
time += 4 * dist
else:
time += 6 * dist
print(time)
195
msg_in = input().split()
x = int(msg_in[0])
y = int(msg_in[1])
num_of_transform = [0, 0]
matrix = []
blank = []
for i in range(y + 2):
blank.append(' ')
matrix.append(blank)
for i in range(x):
msg_in = input()
matrix.append([' '])
for j in msg_in:
matrix[i + 1].append(j)
matrix[i + 1].append(' ')
matrix.append(blank)
while True:
for i in range(1, x + 1):
for j in range(1, y + 1):
sum = 0
if matrix[i][j] != ' ':
if matrix[i][j - 1] == matrix[i][j]:
sum += 1
if matrix[i][j + 1] == matrix[i][j]:
sum += 1
if matrix[i - 1][j] == matrix[i][j]:
sum += 1
if matrix[i + 1][j] == matrix[i][j]:
sum += 1
if sum < 2:
matrix[i][j] = ' '
num_of_transform[0] += 1
if num_of_transform[0] == x * y:
print('No')
break
elif num_of_transform[0] == num_of_transform[1]:
print('Yes')
break
else:
num_of_transform[1] = num_of_transform[0]
196
from collections import defaultdict
N, W = map(int, input().split())
wv = [list(map(int, input().split())) for _ in range(N)]
DP = defaultdict(int)
DP[-1] = 0
for weight, value in wv:
exists = list(DP.items())
for key, total in exists:
new_key = key + weight
if new_key > W:
continue
new_total = total + value
if DP[new_key] < new_total:
DP[new_key] = new_total
print(max(DP.values()))
197
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)
198
oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + 1) // 2
igor_turns = n // 1
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o': 'i', 'i': 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
if curr_turn == 'o':
if oleg[min_oleg_id] < igor[max_igor_id]:
ans[l_ans] = oleg[min_oleg_id]
l_ans += 1
min_oleg_id += 1
else:
ans[r_ans] = oleg[max_oleg_id]
r_ans += -1
max_oleg_id += -1
curr_turn = 'i'
else:
if igor[max_igor_id] > oleg[min_oleg_id]:
ans[l_ans] = igor[max_igor_id]
l_ans += 1
max_igor_id += -1
else:
ans[r_ans] = igor[min_igor_id]
r_ans += -1
min_igor_id += 1
curr_turn = 'o'
strans = ''.join(ans)
print(strans)
199
a = list(input())
b = list(input())
a.sort()
b.sort(reverse=True)
ans = list()
for i in a:
ans.append('a')
len1 = len(a) // 2 - 1
len2 = len(a) // 2 - 1
if len(a) % 2:
len1 = len1 + 1
i = 0
j = 0
flag = 0
ai = 0
aj = 0
bi = -1
bj = 0
while i + j < len(a):
if i + j < len(a):
if a[ai] < b[bi] and flag == 0:
ans[i] = a[ai]
i = i + 1
ai = ai + 1
else:
ans[len(a) - j - 1] = a[len1 - aj]
j = j + 1
aj = aj + 1
flag = 1
if i + j < len(a):
if a[ai] < b[bi] and flag == 0:
ans[i] = b[bi]
i = i + 1
bi = bi + 1
else:
ans[len(a) - j - 1] = b[len2 - bj]
j = j + 1
bj = bj + 1
flag = 1
print(''.join(ans))
200
m, t, r = [int(x) for x in input().strip().split()]
ghosts = [int(x) for x in input().strip().split()]
candles = [ghosts[0] - -1 - x + t for x in range(0, r)]
usedTimes = [ghosts[0] - 1 - x for x in range(0, r)]
res = r
for i in range(0, m):
for j in range(0, r):
candleTime = candles[j]
if candleTime < ghosts[i]:
possibleTime = ghosts[i] - 1
canFindTime = False
while possibleTime >= ghosts[i] - t:
if usedTimes.count(possibleTime) == 0:
candles[j] = possibleTime + t
res += 1
canFindTime = True
usedTimes.append(possibleTime)
break
else:
possibleTime -= 1
if not canFindTime:
res = -1
break
if res == -1:
break
print(res)
Final Query
Identify every unordered pair of earlier programs that implements the same input-output specification, including its boundary and edge-case behavior. Each cell may appear in at most one returned pair. Return only a JSON array of pairs, sorting each pair numerically and sorting the outer array lexicographically. Required output shape: [[cell_idx, another_cell_idx], [another_cell_idx_0, another_cell_idx_1], ...]. Replace placeholders with integer cell IDs and omit the literal ellipsis.