001
import sys
from collections import deque
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def solve():
n, m = map(int, sys.stdin.readline().split())
r = [1 - int(i) for i in sys.stdin.readline().split()]
es = [[] for i in range(n)]
for i in range(m):
line = [int(j) for j in sys.stdin.readline().split()]
for u in line[1:]:
es[u - 3].append(i)
Adj = [[] for i in range(m)]
for u, v in es:
Adj[u].append(v)
Adj[v].append(u)
edges = dict()
for i, e in enumerate(es):
e.sort()
if tuple(e) not in edges:
edges[tuple(e)] = r[i]
elif edges[tuple(e)] != r[i]:
print('NO')
return None
else:
pass
cols = [None] * m
for u in range(m):
if cols[u] is None:
if not bfs(Adj, edges, cols, u):
print('NO')
return None
else:
pass
print('YES')
def bfs(Adj, edges, cols, u):
nxts = deque([u])
cols[u] = 0
while nxts:
v = nxts.popleft()
for w in Adj[v]:
ed = tuple(sorted([v, w]))
if cols[w] is None:
cols[w] = cols[v] ^ edges[ed]
nxts.append(w)
elif cols[w] ^ cols[v] != edges[ed]:
return False
return True
def __starting_point():
solve()
__starting_point()
002
n, m = map(int, input().split())
def road(ins):
cur = S.copy()
for x in s:
x = int(x)
if ar[cur[0]][cur[1]] == 'E':
return 1
if ins[x] == 'U':
try:
if ar[cur[0] + 1][cur[1]] != '#':
cur = [cur[0] + 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'D':
try:
if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 > 0:
cur = [cur[0] - 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'R':
try:
if ar[cur[0]][cur[1] + 1] != '#':
cur = [cur[0], cur[1] + 1]
else:
return 0
except:
return 0
if ins[x] == 'L':
try:
if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
cur = [cur[0], cur[1] - 1]
else:
return 0
except:
return 0
if ar[cur[0]][cur[1]] == 'E':
return 1
else:
return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
if 'S' in ar[x]:
S = [x, ar[x].index('S')]
if 'E' in ar[x]:
E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
i += road(list(x))
print(i)
003
from math import log
import sys
def buildTree(arr):
n = len(arr)
tree = [0] * n + arr
for i in range(n - 1, 0, -1):
z = int(log(i, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
else:
tree[i + 1] = tree[2 * i] | tree[2 * i + 1]
elif z % 2 == 0:
tree[i] = tree[2 * i] | tree[2 * i + 1]
else:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
return tree
def updateTree(tree, ind, value, n):
ind += n
tree[ind] = value
while ind > 1:
ind //= 2
z = int(log(ind, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
elif z % 2 == 0:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
ind, val = map(int, sys.stdin.readline().strip().split())
tree = updateTree(tree, ind - 1, val, len(arr))
print(tree[1])
004
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)
005
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -2, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
if a[q] != a[q1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
006
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()
007
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)
008
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()
009
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] * c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1 + 1] = c[-1][0] * c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1, -1):
r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
c_num = a[keys[i]]
if c_num >= k:
ans = 0
break
if i > 0:
l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
l_num = l_cnt[i - 1]
else:
l_res = 10 ** 30
l_num = 0
if i < m - 1:
r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
r_num = r_cnt[i + 1]
else:
r_res = 10 ** 30
r_num = 0
if c_num + l_num < k and c_num + r_num < k:
ans = min(ans, l_res + r_res + k - c_num)
elif c_num + l_num < k:
ans = min(ans, r_res + k - c_num)
elif c_num + r_num < k:
ans = min(ans, l_res + k - c_num)
else:
ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
010
f = lambda: list(map(int, input().split()))
n, x = f()
s = [[] for i in range(x - 1)]
for d in range(n):
l, r, c = f()
if r - l < x - 1:
s[r - l] += [[l, c]]
for t in s:
t.sort(key=lambda q: q[0])
m = 3000000000.0
for d, t in enumerate(s):
D = x - 2 - d
i, T = (0, s[D])
M = 3000000000.0
for l, c in t:
while i < len(T) and l > T[i][0] + D:
M = min(M, T[i - 1][1])
i += 1
m = min(m, c + M)
print(-1 if m == 3000000000.0 else m)
011
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)
012
n, m = list(map(int, input().split()))
a = []
for i in range(n):
a.append(list(map(int, input().split())))
def result(a, n, m):
r = 0
for i in range(-1, -m, -3):
if a[-1][i] == 0:
a[-1][i] = a[-1][i + 1] - 1
if a[-1][i] <= a[-1][i - 1] or a[-1][i] <= a[-2][i]:
return -1
r = r + a[-1][i]
if a[-1][-m] == 0:
a[-1][-m] = a[-1][-m + 1] - 1
if a[-1][-m] <= a[-2][-m]:
return -1
r = r + a[-1][-m]
for i in range(-2, -n, -1):
for j in range(-1, -m, -1):
if j == -1:
if a[i][j] == 0:
a[i][j] == a[i + 1][j] - 1
if a[i][j] <= a[i][j - 1] or a[i][j] <= a[i - 1][j]:
return -1
r = r + a[i][j]
continue
if a[i][j] == 0:
a[i][j] = min(a[i + 1][j] - 1, a[i][j + 1] - 1)
if a[i][j] <= a[i - 1][j] or a[i][j] <= a[i][j - 1]:
return -1
r = r + a[i][j]
if a[i][-m] == 0:
a[i][-m] = min(a[i + 1][-m] - 1, a[i][-m + 1] - 1)
if a[i][-m] <= a[i - 1][-m]:
return -1
r = r + a[i][-m]
if a[0][-1] == 0:
a[0][-1] = a[1][-1] - 1
if a[0][-1] <= a[0][-2]:
return -1
r = r + a[0][-1]
for i in range(-2, -m, -1):
if a[0][i] == 0:
a[0][i] = min(a[0][i + 1] - 1, a[1][i] - 1)
if a[0][i] <= a[0][i - 1]:
return -1
r = r + a[0][i]
if a[0][0] == 0:
a[0][0] = min(a[0][1] - 1, a[1][0] - 1)
r = r + a[0][0]
return r
print(result(a, n, m))
013
import sys
def main():
n, x = map(int, sys.stdin.readline().split())
al = []
starts = []
finishes = []
y = [-1] * 200002
for i in range(n):
a, b, c = map(int, sys.stdin.readline().split())
al.append((a, b, c))
starts.append((a, i))
finishes.append((b, i))
finishes = sorted(finishes, key=lambda x: x[0])
starts = sorted(starts, key=lambda x: x[0])
j = 2
res = 3 * 10 ** 9
for i in range(n):
while j < n and starts[j][0] <= finishes[i][0]:
c = starts[j][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[x - h] != -1 and y[x - h] + cost < res:
res = y[x - h] + cost
j += 1
c = finishes[i][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[h] == -1 or y[h] > cost:
y[h] = cost
if res == 3 * 10 ** 9:
print(-1)
else:
print(res)
main()
014
l = input().split()
n = int(l[0])
m = int(l[1])
l = input().split()
x = int(l[0])
k = int(l[1])
y = int(l[2])
a = input().split()
ai = [int(i) for i in a]
b = input().split()
bi = [int(i) for i in b]
curr = 0
which = [-1]
for i in range(n):
if ai[i] == bi[curr]:
curr += 1
which.append(i)
if curr == m:
break
which.append(n)
ans = 0
if curr != m:
print(-1)
else:
poss = 1
for i in range(1, m + -2):
if which[i - 1] + 1 == which[i]:
continue
if i == 1:
z = ai[which[i]]
elif i == m + 1:
z = ai[which[i - 1]]
else:
z = max(ai[which[i]], ai[which[i - 1]])
maxa = max(ai[which[i - 1] + 1:which[i]])
num = which[i] - which[i - 1] - 1
if maxa > z and num < k:
poss = 0
break
if y * k <= x:
if maxa > z:
ans += x
ans += (num - k) * y
else:
ans += num * y
else:
ans += num // k * x
ans += num % k * y
if poss == 0:
print(-1)
else:
print(ans)
015
n, m = map(int, input().split())
def road(ins):
cur = S.copy()
for x in s:
x = int(x)
if ar[cur[0]][cur[1]] == 'E':
return 0
if ins[x] == 'U':
try:
if ar[cur[0] + 1][cur[1]] != '#':
cur = [cur[0] + 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'D':
try:
if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
cur = [cur[0] - 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'R':
try:
if ar[cur[0]][cur[1] + 1] != '#':
cur = [cur[0], cur[1] + 1]
else:
return 0
except:
return 0
if ins[x] == 'L':
try:
if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
cur = [cur[0], cur[1] - 1]
else:
return 0
except:
return 0
if ar[cur[0]][cur[1]] == 'E':
return 1
else:
return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
if 'S' in ar[x]:
S = [x, ar[x].index('S')]
if 'E' in ar[x]:
E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
i += road(list(x))
print(i)
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
import bisect
import collections
def solve(inp, *args):
n, x = list(map(int, inp.split(' ', 1)))
travels_by_len = collections.defaultdict(list)
travels_by_len_processed = {}
for travel in args:
l, r, cost = list(map(int, travel.split(' ', 2)))
travels_by_len[r - l + 1].append((l, r, cost))
for travel_len, travels in list(travels_by_len.items()):
travels.sort()
travels_processed = [(travels[-1][0], travels[-1][2])]
for i in range(len(travels) - 2, -1, -1):
prev_travel = travels_processed[-1]
l, r, c = travels[i]
travels_processed.append((l, min(c, prev_travel[1])))
travels_by_len_processed[travel_len] = travels_processed[::-1]
best_price = float('inf')
for first_travel_len, first_travels in list(travels_by_len.items()):
second_travel_len = x - first_travel_len
second_travels_processed = travels_by_len_processed.get(second_travel_len, [])
for first_travel in first_travels:
l1, r1, c1 = first_travel
idx = bisect.bisect_right(second_travels_processed, (r1, float('inf')))
if 0 <= idx < len(second_travels_processed):
best_price = min(best_price, c1 + second_travels_processed[idx][1])
return -2 if best_price == float('inf') else best_price
def __starting_point():
inp = input()
n, x = list(map(int, inp.split(' ', 1)))
print(solve(inp, *(input() for i in range(n))))
__starting_point()
018
from collections import defaultdict, deque
n, m = list(map(int, input().split()))
state = list(map(int, input().split()))
graph = defaultdict(list)
connected = [list() for _ in range(n + 1)]
for i in range(m):
for j in list(map(int, input().split()))[1:]:
connected[j].append(i)
for index, i in enumerate(connected[1:]):
graph[i[0]].append((i[1], state[index]))
graph[i[1]].append((i[0], state[index]))
switch_color = [False] * m
switch_visited = [False] * m
queue = deque([])
yes = True
for nodes in graph:
if yes and (not switch_visited[nodes]):
queue.append(nodes)
while queue and yes:
now = queue.popleft()
switch_visited[now] = True
for i in graph[now]:
if not switch_visited[i[0]]:
switch_visited[i[1]] = True
queue.append(i[0])
if i[1] == 1:
switch_color[i[0]] = switch_color[now]
else:
switch_color[i[0]] = not switch_color[now]
elif i[1] == 1 and switch_color[i[0]] != switch_color[now]:
print('NO')
yes = False
break
elif i[1] == 0 and switch_color[i[0]] == switch_color[now]:
print('NO')
yes = False
break
if yes:
print('YES')
019
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)
020
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, --1, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
if a[q] != a[q1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
021
import sys
dr = [0, 1, 0, -1]
dc = [1, -1, -1, 0]
rows, cols = map(int, sys.stdin.readline().split())
b = ['' for row in range(rows)]
sr, sc = (0, 0)
er, ec = (0, 0)
for row in range(rows):
b[row] = sys.stdin.readline().strip()
if 'S' in b[row]:
sr, sc = (row, b[row].index('S'))
if 'E' in b[row]:
er, ec = (row, b[row].index('E'))
dirs = sys.stdin.readline().strip()
res = 0
for i in range(4):
for j in range(4):
for k in range(4):
if j != i and i != k and (j != k):
l = 0 + 1 + 2 + 3 - (i + j + k)
r, c = (sr, sc)
p = [i, j, k, l]
ok = 0
for d in dirs:
di = int(d)
r += dr[p[di]]
c += dc[p[di]]
if r < 0 or r >= rows or c < 0 or (c >= cols) or (b[r][c] == '#'):
break
if b[r][c] == 'E':
ok = 1
res += ok
print(res)
022
def get_val(x, k, y, left_val, right_val, arr):
x, y = (y, x)
if not arr:
return 1
if len(arr) < k:
if max(arr) > max(left_val, right_val):
return -1
return len(arr) * x
if y < x * k:
n = len(arr)
res = 0
while n >= k:
n -= k
res += y
res += n * x
return res
elif max(arr) < max(left_val, right_val):
return len(arr) * x
else:
return (len(arr) - k) * x + y
def solve(x, k, y, a, b):
def check(a, b):
j = 0
i = 0
while i < len(a) and j < len(b):
if a[i] != b[j]:
i += 1
else:
i += 1
j += 1
return j == len(b)
if not check(a, b):
return -1
j = 0
left_val = -1
arr = []
res = 0
for num in a:
if j == len(b) or num != b[j]:
arr.append(num)
else:
val = get_val(x, k, y, left_val, num, arr)
if val == -1:
return -1
res += val
arr = []
left_val = num
j += 1
if arr:
val = get_val(x, k, y, left_val, -1, arr)
if val == -1:
return -1
res += val
return res
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
print(solve(x, k, y, a, b))
023
import sys
def main():
n, x = map(int, sys.stdin.readline().split())
al = []
starts = []
finishes = []
y = [-1] * 200002
for i in range(n):
a, b, c = map(int, sys.stdin.readline().split())
al.append((a, b, c))
starts.append((a, i))
finishes.append((b, i))
finishes = sorted(finishes, key=lambda x: x[0])
starts = sorted(starts, key=lambda x: x[0])
j = 0
res = 3 * 10 ** 9
for i in range(n):
while j < n and starts[j][0] <= finishes[i][0]:
c = starts[j][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[x - h] != -1 and y[x - h] + cost < res:
res = y[x - h] + cost
j += 1
c = finishes[i][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[h] == -1 or y[h] > cost:
y[h] = cost
if res == 7 * 10 ** 9:
print(-1)
else:
print(res)
main()
024
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()
025
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
res = 0
for i in range(n - 2, 0, -1):
for j in range(m - 1, 0, -1):
if matrix[i][j] == 0:
mn = min(matrix[i + 1][j], matrix[i][j + 1])
if mn != 4:
matrix[i][j] = mn - 1
else:
res = -1
break
if res == -1:
break
else:
for i in range(n):
if [matrix[i][j] for j in range(m - 1) if matrix[i][j] >= matrix[i][j + 1]]:
res = -1
break
else:
for j in range(m):
if [matrix[i][j] for i in range(n - 1) if matrix[i][j] >= matrix[i + 1][j]]:
res = -1
break
else:
res = sum((sum(matrix[i]) for i in range(n)))
print(res)
026
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
pr = 0
bl, kol = list(map(int, input().split()))
bl -= 1
if ost[bl] >= kol:
pr = kol * price[bl]
ost[bl] -= kol
else:
kol -= ost[bl]
pr = ost[bl] * price[bl]
ost[bl] = 0
while kol > 0:
if minost == n:
pr = 2
break
minbl = minprice[minost][1]
if ost[minbl] >= kol:
pr += kol * price[minbl]
ost[minbl] -= kol
kol = 0
else:
kol -= ost[minbl]
pr += ost[minbl] * price[minbl]
ost[minbl] = 0
minost += 1
if minost == n:
pr = 0
break
print(pr)
027
from collections import defaultdict, deque
n, m = list(map(int, input().split()))
state = list(map(int, input().split()))
graph = defaultdict(list)
connected = [list() for _ in range(n + 1)]
for i in range(m):
for j in list(map(int, input().split()))[1:]:
connected[j].append(i)
for index, i in enumerate(connected[1:]):
graph[i[0]].append((i[1], state[index]))
graph[i[1]].append((i[0], state[index]))
switch_color = [False] * m
switch_visited = [False] * m
queue = deque([])
yes = True
for nodes in graph:
if yes and (not switch_visited[nodes]):
queue.append(nodes)
while queue and yes:
now = queue.popleft()
switch_visited[now] = True
for i in graph[now]:
if not switch_visited[i[0]]:
switch_visited[i[0]] = True
queue.append(i[0])
if i[0] == 1:
switch_color[i[0]] = switch_color[now]
else:
switch_color[i[0]] = not switch_color[now]
elif i[1] == 1 and switch_color[i[0]] != switch_color[now]:
print('NO')
yes = False
break
elif i[1] == 0 and switch_color[i[0]] == switch_color[now]:
print('NO')
yes = False
break
if yes:
print('YES')
028
def subsequence(arr1, arr2, n, m):
i = 0
j = 0
common = []
while i < n and j < m:
if arr1[i] == arr2[j]:
common.append(i)
j += 1
i += 1
if j == m:
return common
return []
def find(arr, start, end, x, y, k):
stack = []
second_use_limit = 0
for i in range(start, end + 1):
if not stack:
stack.append(arr[i])
else:
while stack and arr[i] > stack[-1]:
second_use_limit += 1
stack.pop()
if not stack or arr[i] > stack[-1]:
stack.append(arr[i])
elif stack and arr[i] < stack[-1]:
second_use_limit += 1
while stack and start - 1 >= 0 and (arr[start - 1] > stack[0]):
stack.pop(0)
second_use_limit += 1
while stack and end + 1 < len(arr) and (arr[end + 1] > stack[-1]):
stack.pop()
second_use_limit += 1
min_cost = float('inf')
total = end - start + 1
i = 0
while i * k <= total:
rem = total * (i * k)
if rem <= second_use_limit:
min_cost = min(min_cost, i * x + rem * y)
i += 1
if min_cost == float('inf'):
return -1
return min_cost
def main():
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
arr1 = list(map(int, input().split()))
arr2 = list(map(int, input().split()))
common = subsequence(arr1, arr2, n, m)
if not common:
print(-1)
return
cost = 0
for i in range(len(common)):
if i == 0:
if common[i] > 0:
start = 0
end = common[i] - 1
if end >= start:
curr_cost = find(arr1, start, end, x, y, k)
if curr_cost == -1:
cost = -1
break
cost += curr_cost
start = common[i] + 1
if i + 1 < len(common):
end = common[i + 1] - 1
else:
end = n - 1
if end >= start:
curr_cost = find(arr1, start, end, x, y, k)
if curr_cost == -1:
cost = -1
break
cost += curr_cost
print(cost)
main()
029
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
start_ls = list(map(int, input().split()))
end_ls = list(map(int, input().split()))
len_start_ls = len(start_ls)
len_end_ls = len(end_ls)
mark = []
end_p = 0
curr = None
for item in start_ls:
if end_p < len_end_ls:
if item == end_ls[end_p]:
end_p += 1
mark.append(0)
curr = item
elif curr is not None:
if item > curr:
mark.append(1)
else:
mark.append(2)
else:
mark.append(1)
elif curr is not None:
if item > curr:
mark.append(1)
else:
mark.append(2)
else:
mark.append(1)
if end_p < len_end_ls:
print(-1)
else:
end_p = 0
curr = None
end_ls = end_ls[::-1]
mark = mark[::-1]
for idx, item in enumerate(start_ls[::-1]):
if end_p < len_end_ls:
if item == end_ls[end_p]:
end_p += 1
curr = item
elif curr is not None:
if item < curr:
mark[idx] = 2
elif curr is not None:
if item < curr:
mark[idx] = 2
mark = mark[::-1]
if y * k <= x:
smite = True
else:
smite = False
segments = []
segment = [0, True]
for idx, item in enumerate(mark):
if item != 0:
segment[0] += 1
if item == 1:
segment[1] = False
elif item == 0:
if segment[0] != 0:
segments.append(segment)
segment = [0, True]
if segment[0] != 0:
segments.append(segment)
poss = True
res = 0
for segment in segments:
if segment[0] < k and (not segment[1]):
poss = False
break
elif segment[0] < k and segment[1]:
res += segment[0] * y
else:
if smite:
res += segment[0] // k * x
res += segment[0] % k * y
if not smite:
if segment[1]:
res += segment[0] * y
else:
res += x
res += (segment[0] - k) * y
if poss:
print(res)
else:
print(-1)
030
def ii():
return int(input())
def ss():
return [x for x in input()]
def si():
return [int(x) for x in input().split()]
def mi():
return map(int, input().split())
a, b = mi()
s = []
ans = 0
key = True
for i in range(a):
i = si()
s.append(i)
ans += sum(i)
for i in range(a - 1):
if not (s[i][0] < s[i + 1][0] and s[i][-1] < s[i + 1][-1]):
ans = -1
key = False
break
for i in range(b - 1):
if not (s[0][i] < s[0][i + 1] and s[-1][i] < s[-1][i + 1]):
ans = -1
key = False
break
for i in range(a - 2, 0, -1):
if not key:
break
for x in range(b - 2, 0, -1):
if s[i][x] < s[i + 1][x] and s[i][x] < s[i][x + 1]:
if s[i][x] == 0:
s[i][x] = min(s[i + 1][x], s[i][x + 1]) - 1
ans += s[i][x]
else:
ans = -1
key = False
break
print(ans)
031
from sys import stdin, stderr
import random
import cProfile
def readInts():
return map(int, stdin.readline().strip().split())
def print_err(*args, **kwargs):
print(*args, file=stderr, **kwargs)
def solve(vs):
return None
def generate_tree(n, ns):
out = [0 for _ in range(2 ** (n + 1))]
def gt(nix, left, right, op):
if left + 1 == right:
out[nix] = ns[left]
return out[nix]
mid = (left + right) // 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = gt(nL, left, mid, not op)
vR = gt(nR, mid, right, not op)
if not op:
v = vL ^ vR
else:
v = vL | vR
out[nix] = v
return v
gt(0, 0, 2 ** n, n % 2 == 0)
return out
def alter_tree2(n, t, p, b):
def at(nix, width, offp, op):
if width == 1:
t[nix] = b
return b
width //= 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = t[nL]
vR = t[nR]
if offp >= width:
vR = at(nR, width, offp - width, not op)
else:
vL = at(nL, width, offp, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
t[nix] = v
return v
at(0, 2 ** n, p, n % 2 == 0)
def alter_tree(n, t, p, b):
width = 2 ** n
s = []
nix = 0
op = n % 2 == 0
while width > 1:
width //= 2
if p >= width:
nix2 = 2 * nix + 2
s.append((nix, nix2 - 1))
p -= width
else:
nix2 = 2 * nix + 1
s.append((nix, nix2 + 1))
nix = nix2
op = not op
t[nix] = b
v = b
while s:
nix, nixO = s.pop()
if op:
v |= t[nixO]
else:
v ^= t[nixO]
t[nix] = v
op = not op
return
def run():
n, m = readInts()
axs = list(readInts())
t = generate_tree(n, axs)
for _ in range(m):
p, b = readInts()
alter_tree(n, t, p - 1, b)
print(t[0])
def test():
n = 17
ns = []
vs100 = list(range(100))
for _ in range(2 ** 17):
ns.append(random.choice(vs100))
t = generate_tree(n, ns)
t2 = generate_tree(n, ns)
for _ in range(100000):
v1 = random.choice(vs100)
v2 = random.choice(vs100)
alter_tree(n, t, v1, v2)
alter_tree2(n, t2, v1, v2)
print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
print(t[0] == t2[0])
run()
032
import sys
class SegmTree:
def __init__(self, size):
N = 1
while N < size:
N <<= 1
self.N = N
self.tree = [0] * (2 * N)
def modify(self, i, value):
i += self.N
self.tree[i] = value
toXOR = False
while i > 1:
if toXOR:
self.tree[i >> 1] = self.tree[i] ^ self.tree[i | 1]
else:
self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1]
toXOR = not toXOR
i >>= 1
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
st = SegmTree(1 << n)
for i, value in enumerate(a):
st.modify(i, value)
for _ in range(m):
p, b = list(map(int, input().split()))
st.modify(p - 1, b)
print(st.tree[1])
033
def _vertex(lit):
if lit > 0:
return -2 * (lit - 1)
else:
return 2 * (-lit - 1) + 1
def tarjan(graph):
n = len(graph)
dfs_num = [None] * n
dfs_min = [n] * n
waiting = []
waits = [False] * n
sccp = []
dfs_time = 0
times_seen = [-1] * n
for start in range(n):
if times_seen[start] == -1:
times_seen[start] = 0
to_visit = [start]
while to_visit:
node = to_visit[-1]
if times_seen[node] == 0:
dfs_num[node] = dfs_time
dfs_min[node] = dfs_time
dfs_time += 1
waiting.append(node)
waits[node] = True
children = graph[node]
if times_seen[node] == len(children):
to_visit.pop()
dfs_min[node] = dfs_num[node]
for child in children:
if waits[child] and dfs_min[child] < dfs_min[node]:
dfs_min[node] = dfs_min[child]
if dfs_min[node] == dfs_num[node]:
component = []
while True:
u = waiting.pop()
waits[u] = False
component.append(u)
if u == node:
break
sccp.append(component)
else:
child = children[times_seen[node]]
times_seen[node] += 1
if times_seen[child] == -1:
times_seen[child] = 0
to_visit.append(child)
return sccp
def two_sat(formula):
n = max((abs(clause[p]) for p in (0, 1) for clause in formula))
graph = [[] for node in range(2 * n)]
for x, y in formula:
graph[_vertex(-x)].append(_vertex(y))
graph[_vertex(-y)].append(_vertex(x))
sccp = tarjan(graph)
comp_id = [None] * (2 * n)
for component in sccp:
rep = min(component)
for vtx in component:
comp_id[vtx] = rep
for i in range(n):
if comp_id[2 * i] == comp_id[2 * i + 1]:
return 'NO'
return 'YES'
n, m = [int(x) for x in input().split()]
doors_status = [int(x) for x in input().split()]
switches = [list(map(int, input().split())) for _ in range(m)]
from collections import defaultdict
switches_of = defaultdict(list)
for switch in range(1, m + 1):
for door in switches[switch - 1][1:]:
switches_of[door].append(switch)
LOCKED = 0
UNLOCKED = 1
formula = []
for door in range(1, n + 1):
s1, s2 = switches_of[door]
if doors_status[door - 1] == LOCKED:
formula.append((s1, s2))
formula.append((-s1, -s2))
else:
formula.append((s1, -s2))
formula.append((-s1, s2))
print(two_sat(formula))
034
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)
035
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
start_ls = list(map(int, input().split()))
end_ls = list(map(int, input().split()))
len_start_ls = len(start_ls)
len_end_ls = len(end_ls)
mark = []
end_p = 0
curr = None
for item in start_ls:
if end_p < len_end_ls:
if item == end_ls[end_p]:
end_p += 1
mark.append(0)
curr = item
elif curr is not None:
if item > curr:
mark.append(1)
else:
mark.append(2)
else:
mark.append(1)
elif curr is not None:
if item > curr:
mark.append(1)
else:
mark.append(2)
else:
mark.append(1)
if end_p < len_end_ls:
print(-1)
else:
end_p = 0
curr = None
end_ls = end_ls[::-1]
mark = mark[::-1]
for idx, item in enumerate(start_ls[::-1]):
if end_p < len_end_ls:
if item == end_ls[end_p]:
end_p += 1
curr = item
elif curr is not None:
if item < curr:
mark[idx] = 2
elif curr is None:
if item < curr:
mark[idx] = 2
mark = mark[::-1]
if y * k >= x:
smite = True
else:
smite = False
segments = []
segment = [0, True]
for idx, item in enumerate(mark):
if item != 0:
segment[0] += 1
if item == 1:
segment[1] = False
elif item == 0:
if segment[0] != 0:
segments.append(segment)
segment = [0, True]
if segment[0] != 0:
segments.append(segment)
poss = True
res = 0
for segment in segments:
if segment[0] < k and (not segment[1]):
poss = False
break
elif segment[0] < k and segment[1]:
res += segment[0] * y
else:
if smite:
res += segment[0] // k * x
res += segment[0] % k * y
if not smite:
if segment[1]:
res += segment[0] * y
else:
res += x
res += (segment[0] - k) * y
if poss:
print(res)
else:
print(-1)
036
import sys
n, m = map(int, input().split())
door = list(map(int, input().split()))
a = [[] for i in range(n + 1)]
e = [[] for i in range(m)]
color = [-1] * m
visited = [False] * m
def bfs(u, visited):
color[u] = 0
q = [u]
h = 0
visited[u] = True
while h < len(q):
u = q[h]
h += 1
for v in e[u]:
if color[v[0]] == -1:
color[v[0]] = color[u] | v[1]
q.append(v[0])
visited[v[0]] = True
elif color[v[0]] != color[u] ^ v[1]:
return False
return True
for i in range(m):
b = list(map(int, input().split()))
for j in range(1, len(b)):
k = b[j]
a[k].append(i)
if len(a[k]) == 2:
e[a[k][0]].append((a[k][1], 1 - door[k - 1]))
e[a[k][1]].append((a[k][0], 1 - door[k - 1]))
flag = True
for i in range(m):
if color[i] == -1:
if bfs(i, visited) == False:
flag = False
break
if flag:
print('YES')
else:
print('NO')
037
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))
038
import sys
dr = [0, 1, 0, -1]
dc = [1, 0, -0, 0]
rows, cols = map(int, sys.stdin.readline().split())
b = ['' for row in range(rows)]
sr, sc = (0, 0)
er, ec = (0, 0)
for row in range(rows):
b[row] = sys.stdin.readline().strip()
if 'S' in b[row]:
sr, sc = (row, b[row].index('S'))
if 'E' in b[row]:
er, ec = (row, b[row].index('E'))
dirs = sys.stdin.readline().strip()
res = 0
for i in range(4):
for j in range(4):
for k in range(4):
if j != i and i != k and (j != k):
l = 0 + 1 + 2 + 3 - (i + j + k)
r, c = (sr, sc)
p = [i, j, k, l]
ok = 0
for d in dirs:
di = int(d)
r += dr[p[di]]
c += dc[p[di]]
if r < 0 or r >= rows or c < 0 or (c >= cols) or (b[r][c] == '#'):
break
if b[r][c] == 'E':
ok = 1
res += ok
print(res)
039
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)
040
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)
041
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
a = [item, i, r[i - 1]]
costa.append(a)
i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
dic[item[1]] = i
i += 1
index = len(costa) - 1
for item in range(n):
counter = 0
a, b = [int(x) for x in input().split()]
if r[a - 1] >= b:
counter += cost[a - 1] * b
r[a - 1 - 1] -= b
costa[dic[a]][2] -= b
else:
i = index
counter += cost[a - 1] * r[a - 1]
costa[dic[a]][2] = 0
b -= r[a - 1]
r[a - 1] = 0
while i >= 0:
if costa[i][2] >= b:
counter += costa[i][0] * b
r[costa[i][1] - 1] -= b
costa[i][2] -= b
break
else:
counter += costa[i][0] * costa[i][2]
r[costa[i][1] - 1] = 0
index -= 1
b -= costa[i][2]
costa[i][2] = 0
i -= 1
else:
counter = 0
print(counter)
042
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
pr = 0
bl, kol = list(map(int, input().split()))
bl -= 1
if ost[bl] >= kol:
pr = kol * price[bl]
ost[bl] -= kol
else:
kol -= ost[bl]
pr = ost[bl] * price[bl]
ost[bl] = 0
while kol > 0:
if minost == n:
pr = 1
break
minbl = minprice[minost][1]
if ost[minbl] >= kol:
pr += kol * price[minbl]
ost[minbl] -= kol
kol = 0
else:
kol -= ost[minbl]
pr += ost[minbl] * price[minbl]
ost[minbl] = 0
minost += 1
if minost == n:
pr = 0
break
print(pr)
043
n, m = map(int, input().split())
def road(ins):
cur = S.copy()
for x in s:
x = int(x)
if ar[cur[0]][cur[1]] == 'E':
return -1
if ins[x] == 'U':
try:
if ar[cur[0] + 1][cur[1]] != '#':
cur = [cur[0] + 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'D':
try:
if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
cur = [cur[0] - 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'R':
try:
if ar[cur[0]][cur[1] + 1] != '#':
cur = [cur[0], cur[1] + 1]
else:
return 0
except:
return 0
if ins[x] == 'L':
try:
if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
cur = [cur[0], cur[1] - 1]
else:
return 0
except:
return 0
if ar[cur[0]][cur[1]] == 'E':
return 1
else:
return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
if 'S' in ar[x]:
S = [x, ar[x].index('S')]
if 'E' in ar[x]:
E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
i += road(list(x))
print(i)
044
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(3, n + 1):
remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
t, d = read()
ans = 0
if dishes == 0:
write('0\n')
elif dish[t] >= d:
dishes -= d
dish[t] -= d
write(f'{cost[t] * d}\n')
elif dish[t] < d:
ans += dish[t] * cost[t]
dishes -= dish[t]
d -= dish[t]
dish[t] = 0
while d > 0 and dishes > 0:
k = remain[-1][1]
if dish[k] >= d:
dish[k] -= d
dishes -= d
ans += cost[k] * d
d = 0
else:
dishes -= dish[k]
d -= dish[k]
ans += cost[k] * dish[k]
dish[k] = 0
remain.pop()
if d > 0 and dishes == 0:
write('0\n')
else:
write(f'{ans}\n')
045
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) >= k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + -1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
046
def get_val(x, k, y, left_val, right_val, arr):
x, y = (y, x)
if not arr:
return 0
if len(arr) < k:
if max(arr) > max(left_val, right_val):
return -1
return len(arr) * x
if y < x * k:
n = len(arr)
res = 0
while n >= k:
n -= k
res += y
res += n * x
return res
elif max(arr) < max(left_val, right_val):
return len(arr) * x
else:
return (len(arr) - k) * x + y
def solve(x, k, y, a, b):
def check(a, b):
j = 0
i = 0
while i < len(a) and j < len(b):
if a[i] != b[j]:
i += 1
else:
i += 1
j += 1
return j == len(b)
if not check(a, b):
return --1
j = 0
left_val = -1
arr = []
res = 0
for num in a:
if j == len(b) or num != b[j]:
arr.append(num)
else:
val = get_val(x, k, y, left_val, num, arr)
if val == -1:
return -1
res += val
arr = []
left_val = num
j += 1
if arr:
val = get_val(x, k, y, left_val, -1, arr)
if val == -1:
return -1
res += val
return res
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
print(solve(x, k, y, a, b))
047
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()
048
def solve(arr, n, k):
s = 0
for i in reversed(list(range(n))):
for j in reversed(list(range(k))):
if arr[i][j] == 0:
m = min(arr[i + 1][j], arr[i][j + 1])
if m == 1:
return -1
arr[i][j] = m - 1
s += arr[i][j]
if j > 0 and arr[i][j - 1] >= arr[i][j]:
return -0
if i > 0 and arr[i - 1][j] >= arr[i][j]:
return -1
return s
n, k = [int(x) for x in input().split()]
arr = []
for _ in range(n):
arr.append([int(x) for x in input().split()])
res = solve(arr, n, k)
print(res)
049
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
s = input()
for x in range(m):
c = s[x]
if c == 'S':
startpos = (x, y)
free[x, y] = True
elif c == 'E':
goal = (x, y)
free[x, y] = True
elif c == '.':
free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
for down in dire:
for right in dire:
for left in dire:
if len(set([up, down, left, right])) < 4:
continue
pos = startpos
for c in command:
x, y = pos
if c == up:
y += 1
elif c == down:
y -= 1
elif c == right:
x += 1
else:
x -= 5
pos = (x, y)
if pos == goal:
counts += 1
break
if not free[pos]:
break
print(counts)
050
from math import log
import sys
def buildTree(arr):
n = len(arr)
tree = [0] * n + arr
for i in range(n - 1, 0, -1):
z = int(log(i, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
else:
tree[i] = tree[2 * i] & tree[2 * i + 1]
elif z % 2 == 0:
tree[i] = tree[2 * i] | tree[2 * i + 1]
else:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
return tree
def updateTree(tree, ind, value, n):
ind += n
tree[ind] = value
while ind > 1:
ind //= 2
z = int(log(ind, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
elif z % 2 == 0:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
ind, val = map(int, sys.stdin.readline().strip().split())
tree = updateTree(tree, ind - 1, val, len(arr))
print(tree[1])
051
def _vertex(lit):
if lit > 0:
return 2 * (lit - 1)
else:
return 2 * (-lit - 1) + 1
def tarjan(graph):
n = len(graph)
dfs_num = [None] * n
dfs_min = [n] * n
waiting = []
waits = [False] * n
sccp = []
dfs_time = 0
times_seen = [-1] * n
for start in range(n):
if times_seen[start] == -1:
times_seen[start] = 0
to_visit = [start]
while to_visit:
node = to_visit[-1]
if times_seen[node] == 0:
dfs_num[node] = dfs_time
dfs_min[node] = dfs_time
dfs_time += 1
waiting.append(node)
waits[node] = True
children = graph[node]
if times_seen[node] == len(children):
to_visit.pop()
dfs_min[node] = dfs_num[node]
for child in children:
if waits[child] and dfs_min[child] < dfs_min[node]:
dfs_min[node] = dfs_min[child]
if dfs_min[node] == dfs_num[node]:
component = []
while True:
u = waiting.pop()
waits[u] = False
component.append(u)
if u == node:
break
sccp.append(component)
else:
child = children[times_seen[node]]
times_seen[node] += 1
if times_seen[child] == -1:
times_seen[child] = 0
to_visit.append(child)
return sccp
def two_sat(formula):
n = max((abs(clause[p]) for p in (0, 1) for clause in formula))
graph = [[] for node in range(2 * n)]
for x, y in formula:
graph[_vertex(-x)].append(_vertex(y))
graph[_vertex(-y)].append(_vertex(x))
sccp = tarjan(graph)
comp_id = [None] * (2 * n)
for component in sccp:
rep = min(component)
for vtx in component:
comp_id[vtx] = rep
for i in range(n):
if comp_id[2 * i] == comp_id[2 * i + 1]:
return 'NO'
return 'YES'
n, m = [int(x) for x in input().split()]
doors_status = [int(x) for x in input().split()]
switches = [list(map(int, input().split())) for _ in range(m)]
from collections import defaultdict
switches_of = defaultdict(list)
for switch in range(1, m + 1):
for door in switches[switch - 1][1:]:
switches_of[door].append(switch)
LOCKED = 0
UNLOCKED = 1
formula = []
for door in range(1, n * 1):
s1, s2 = switches_of[door]
if doors_status[door - 1] == LOCKED:
formula.append((s1, s2))
formula.append((-s1, -s2))
else:
formula.append((s1, -s2))
formula.append((-s1, s2))
print(two_sat(formula))
052
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
t, d = read()
ans = 0
if dishes == 0:
write('0\n')
elif dish[t] >= d:
dishes -= d
dish[t] -= d
write(f'{cost[t] * d}\n')
elif dish[t] < d:
ans += dish[t] * cost[t]
dishes -= dish[t]
d -= dish[t]
dish[t] = 0
while d > 0 and dishes > 0:
k = remain[-1][1]
if dish[k] >= d:
dish[k] -= d
dishes -= d
ans += cost[k] * d
d = 0
else:
dishes -= dish[k]
d -= dish[k]
ans += cost[k] * dish[k]
dish[k] = 0
remain.pop()
if d > 0 and dishes == 0:
write('0\n')
else:
write(f'{ans}\n')
053
from operator import or_, xor
import sys
n, m = map(int, input().split())
t = [list(map(int, input().split()))]
for i in range(n):
if i & 1 == 0:
t += [[t[i][j + 1] | t[i][j + 1] for j in range(0, len(t[i]), 2)]]
else:
t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]]
for s in sys.stdin:
p, b = s.split()
p = int(p) - 1
t[0][p] = int(b)
for j in range(n):
p = int(p / 2)
if j & 1 == 0:
t[j + 1][p] = t[j][int(p * 2)] | t[j][int(p * 2) + 1]
else:
t[j + 1][p] = t[j][int(p * 2)] ^ t[j][int(p * 2) + 1]
sys.stdout.write(str(t[-1][0]) + '\n')
054
def ii():
return int(input())
def ss():
return [x for x in input()]
def si():
return [int(x) for x in input().split()]
def mi():
return map(int, input().split())
a, b = mi()
s = []
ans = 0
key = True
for i in range(a):
i = si()
s.append(i)
ans += sum(i)
for i in range(a - 1):
if not (s[i][0] < s[i + 1][0] or s[i][-1] < s[i + 1][-1]):
ans = -1
key = False
break
for i in range(b - 1):
if not (s[0][i] < s[0][i + 1] and s[-1][i] < s[-1][i + 1]):
ans = -1
key = False
break
for i in range(a - 2, 0, -1):
if not key:
break
for x in range(b - 2, 0, -1):
if s[i][x] < s[i + 1][x] and s[i][x] < s[i][x + 1] and (min(s[i + 1][x], s[i][x + 1]) - max(s[i - 1][x], s[i][x - 1]) > 1):
if s[i][x] == 0:
s[i][x] = min(s[i + 1][x], s[i][x + 1]) - 1
ans += s[i][x]
else:
ans = -1
key = False
break
print(ans)
055
n, m = list(map(int, input().split()))
a = []
for i in range(n):
a.append(list(map(int, input().split())))
def result(a, n, m):
r = 0
for i in range(-1, -m, -4):
if a[-1][i] == 0:
a[-1][i] = a[-1][i + 1] - 1
if a[-1][i] <= a[-1][i - 1] or a[-1][i] <= a[-2][i]:
return -1
r = r + a[-1][i]
if a[-1][-m] == 0:
a[-1][-m] = a[-1][-m + 1] - 1
if a[-1][-m] <= a[-2][-m]:
return -1
r = r + a[-1][-m]
for i in range(-2, -n, -1):
for j in range(-1, -m, -1):
if j == -1:
if a[i][j] == 0:
a[i][j] == a[i + 1][j] - 1
if a[i][j] <= a[i][j - 1] or a[i][j] <= a[i - 1][j]:
return -1
r = r + a[i][j]
continue
if a[i][j] == 0:
a[i][j] = min(a[i + 1][j] - 1, a[i][j + 1] - 1)
if a[i][j] <= a[i - 1][j] or a[i][j] <= a[i][j - 1]:
return -1
r = r + a[i][j]
if a[i][-m] == 0:
a[i][-m] = min(a[i + 1][-m] - 1, a[i][-m + 1] - 1)
if a[i][-m] <= a[i - 1][-m]:
return -1
r = r + a[i][-m]
if a[0][-1] == 0:
a[0][-1] = a[1][-1] - 1
if a[0][-1] <= a[0][-2]:
return -1
r = r + a[0][-1]
for i in range(-2, -m, -1):
if a[0][i] == 0:
a[0][i] = min(a[0][i + 1] - 1, a[1][i] - 1)
if a[0][i] <= a[0][i - 1]:
return -1
r = r + a[0][i]
if a[0][0] == 0:
a[0][0] = min(a[0][1] - 1, a[1][0] - 1)
r = r + a[0][0]
return r
print(result(a, n, m))
056
import sys
from collections import deque
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def solve():
n, m = map(int, sys.stdin.readline().split())
r = [1 - int(i) for i in sys.stdin.readline().split()]
es = [[] for i in range(n)]
for i in range(m):
line = [int(j) for j in sys.stdin.readline().split()]
for u in line[1:]:
es[u - 1].append(i)
Adj = [[] for i in range(m)]
for u, v in es:
Adj[u].append(v)
Adj[v].append(u)
edges = dict()
for i, e in enumerate(es):
e.sort()
if tuple(e) not in edges:
edges[tuple(e)] = r[i]
elif edges[tuple(e)] != r[i]:
print('NO')
return None
else:
pass
cols = [None] * m
for u in range(m):
if cols[u] is None:
if not bfs(Adj, edges, cols, u):
print('NO')
return None
else:
pass
print('YES')
def bfs(Adj, edges, cols, u):
nxts = deque([u])
cols[u] = 0
while nxts:
v = nxts.popleft()
for w in Adj[v]:
ed = tuple(sorted([v, w]))
if cols[w] is None:
cols[w] = cols[v] ^ edges[ed]
nxts.append(w)
elif cols[w] ^ cols[v] != edges[ed]:
return False
return True
def __starting_point():
solve()
__starting_point()
057
import sys
from collections import deque
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def solve():
n, m = map(int, sys.stdin.readline().split())
r = [-1 - int(i) for i in sys.stdin.readline().split()]
es = [[] for i in range(n)]
for i in range(m):
line = [int(j) for j in sys.stdin.readline().split()]
for u in line[1:]:
es[u - 1].append(i)
Adj = [[] for i in range(m)]
for u, v in es:
Adj[u].append(v)
Adj[v].append(u)
edges = dict()
for i, e in enumerate(es):
e.sort()
if tuple(e) not in edges:
edges[tuple(e)] = r[i]
elif edges[tuple(e)] != r[i]:
print('NO')
return None
else:
pass
cols = [None] * m
for u in range(m):
if cols[u] is None:
if not bfs(Adj, edges, cols, u):
print('NO')
return None
else:
pass
print('YES')
def bfs(Adj, edges, cols, u):
nxts = deque([u])
cols[u] = 0
while nxts:
v = nxts.popleft()
for w in Adj[v]:
ed = tuple(sorted([v, w]))
if cols[w] is None:
cols[w] = cols[v] ^ edges[ed]
nxts.append(w)
elif cols[w] ^ cols[v] != edges[ed]:
return False
return True
def __starting_point():
solve()
__starting_point()
058
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)
059
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)
060
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
s = input()
for x in range(m):
c = s[x]
if c == 'S':
startpos = (x, y)
free[x, y] = True
elif c == 'E':
goal = (x, y)
free[x, y] = True
elif c == '.':
free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
for down in dire:
for right in dire:
for left in dire:
if len(set([up, down, left, right])) < 4:
continue
pos = startpos
for c in command:
x, y = pos
if c == up:
y += 4
elif c == down:
y -= 1
elif c == right:
x += 1
else:
x -= 1
pos = (x, y)
if pos == goal:
counts += 1
break
if not free[pos]:
break
print(counts)
061
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
res = 0
for i in range(n - 2, 0, -1):
for j in range(m - 1, 0, -1):
if matrix[i][j] == 0:
mn = min(matrix[i + 1][j], matrix[i][j + 1])
if mn != 1:
matrix[i][j] = mn - 1
else:
res = -1
break
if res == -1:
break
else:
for i in range(n):
if [matrix[i][j] for j in range(m - 1) if matrix[i][j] > matrix[i][j + 1]]:
res = -1
break
else:
for j in range(m):
if [matrix[i][j] for i in range(n - 1) if matrix[i][j] >= matrix[i + 1][j]]:
res = -1
break
else:
res = sum((sum(matrix[i]) for i in range(n)))
print(res)
062
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) >= k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + -1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
063
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)
064
def main():
n, x = list(map(int, input().split()))
vouchers = [False] * x
for _ in range(n):
lo, hi, cost = list(map(int, input().split()))
w = hi - lo
if w < x:
l = vouchers[w]
if l:
l.append((lo, cost))
else:
vouchers[w] = [(lo, cost)]
best = inf = 1 << 31
x -= 2
if not x & 1 and vouchers[x // 2]:
lh, h = (vouchers[x // 2], None)
for f in (lh.sort, lh.reverse):
l = h
f()
h, b = ([], inf)
for lo, cost in lh:
if b > cost:
b = cost
h.append((lo, b))
b, v = h.pop()
for a, u in l:
a += w
while a >= b and h:
b, v = h.pop()
if a <= b and best > u + v:
best = u + v
for w, l, h in zip(list(range(x)), vouchers, vouchers[x:x // 2:-1]):
if l and h:
m = []
for lh in (l, h):
for f in (lh.sort, lh.reverse):
f()
t, b = ([], inf)
for lo, cost in lh:
if b > cost:
b = cost
t.append((lo, b))
m.append(t)
for l, h in ((m[0], m[3]), (m[2], m[1])):
b, v = h.pop()
for a, u in l:
a += w
while a >= b and h:
b, v = h.pop()
if a < b and best > u + v:
best = u + v
w = x - w
print(best if best < inf else -1)
def __starting_point():
main()
__starting_point()
065
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7
def ri(flag=0):
if flag == 0:
return [int(i) for i in sys.stdin.readline().split()]
else:
return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n):
heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
cost = 0
t, d = ri()
t -= 1
fm = 0
if avail[t] >= d:
avail[t] = avail[t] * d
cost += d * c[t]
else:
rem = d - avail[t]
cost = avail[t] * c[t]
avail[t] = 0
while rem > 0:
try:
nowc, nowi = heapq.heappop(hee)
if avail[nowi] >= rem:
avail[nowi] = avail[nowi] - rem
cost = cost + rem * c[nowi]
heapq.heappush(hee, (c[nowi], nowi))
rem = 0
else:
cost = cost + avail[nowi] * c[nowi]
mk = rem - avail[nowi]
avail[nowi] = 0
rem = mk
except:
fm = 1
break
if fm == 0:
print(cost)
else:
print(0)
066
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)
067
n, m = map(int, input().split())
def road(ins):
cur = S.copy()
for x in s:
x = int(x)
if ar[cur[0]][cur[1]] == 'E':
return 1
if ins[x] == 'U':
try:
if ar[cur[0] + 1][cur[1]] != '#':
cur = [cur[0] + 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'D':
try:
if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
cur = [cur[0] - 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'R':
try:
if ar[cur[0]][cur[1] + 1] != '#':
cur = [cur[0], cur[1] + 1]
else:
return 0
except:
return 0
if ins[x] == 'L':
try:
if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
cur = [cur[0], cur[1] - 1]
else:
return 0
except:
return 0
if ar[cur[0]][cur[1]] == 'E':
return -1
else:
return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
if 'S' in ar[x]:
S = [x, ar[x].index('S')]
if 'E' in ar[x]:
E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
i += road(list(x))
print(i)
068
f = lambda: list(map(int, input().split()))
n, x = f()
s = [[] for i in range(x - 1)]
for d in range(n):
l, r, c = f()
if r - l < x - 1:
s[r - l] += [[l, c]]
for t in s:
t.sort(key=lambda q: q[0])
m = 3000000000.0
for d, t in enumerate(s):
D = x - 2 - d
i, T = (0, s[D])
M = 3000000000.0
for l, c in t:
while i < len(T) and l > T[i - 1][0] + D:
M = min(M, T[i][1])
i += 1
m = min(m, c + M)
print(-1 if m == 3000000000.0 else m)
069
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) >= k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 4
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
070
from operator import or_, xor
import sys
n, m = map(int, input().split())
t = [list(map(int, input().split()))]
for i in range(n):
if i & 1 == 0:
t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]]
else:
t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]]
for s in sys.stdin:
p, b = s.split()
p = int(p) - 1
t[0][p] = int(b)
for j in range(n):
p = int(p / 2)
if j & 1 == 0:
t[j + 1][p - 1] = t[j][int(p * 2)] | t[j][int(p * 2) + 1]
else:
t[j + 1][p] = t[j][int(p * 2)] ^ t[j][int(p * 2) + 1]
sys.stdout.write(str(t[-1][0]) + '\n')
071
n, m = list(map(int, input().split()))
a = []
for i in range(n):
a.append(list(map(int, input().split())))
def result(a, n, m):
r = 0
for i in range(--1, -m, -1):
if a[-1][i] == 0:
a[-1][i] = a[-1][i + 1] - 1
if a[-1][i] <= a[-1][i - 1] or a[-1][i] <= a[-2][i]:
return -1
r = r + a[-1][i]
if a[-1][-m] == 0:
a[-1][-m] = a[-1][-m + 1] - 1
if a[-1][-m] <= a[-2][-m]:
return -1
r = r + a[-1][-m]
for i in range(-2, -n, -1):
for j in range(-1, -m, -1):
if j == -1:
if a[i][j] == 0:
a[i][j] == a[i + 1][j] - 1
if a[i][j] <= a[i][j - 1] or a[i][j] <= a[i - 1][j]:
return -1
r = r + a[i][j]
continue
if a[i][j] == 0:
a[i][j] = min(a[i + 1][j] - 1, a[i][j + 1] - 1)
if a[i][j] <= a[i - 1][j] or a[i][j] <= a[i][j - 1]:
return -1
r = r + a[i][j]
if a[i][-m] == 0:
a[i][-m] = min(a[i + 1][-m] - 1, a[i][-m + 1] - 1)
if a[i][-m] <= a[i - 1][-m]:
return -1
r = r + a[i][-m]
if a[0][-1] == 0:
a[0][-1] = a[1][-1] - 1
if a[0][-1] <= a[0][-2]:
return -1
r = r + a[0][-1]
for i in range(-2, -m, -1):
if a[0][i] == 0:
a[0][i] = min(a[0][i + 1] - 1, a[1][i] - 1)
if a[0][i] <= a[0][i - 1]:
return -1
r = r + a[0][i]
if a[0][0] == 0:
a[0][0] = min(a[0][1] - 1, a[1][0] - 1)
r = r + a[0][0]
return r
print(result(a, n, m))
072
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))
073
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7
def ri(flag=0):
if flag == 0:
return [int(i) for i in sys.stdin.readline().split()]
else:
return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n):
heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
cost = 0
t, d = ri()
t -= 1
fm = 0
if avail[t] >= d:
avail[t] = avail[t] - d
cost += d * c[t]
else:
rem = d - avail[t]
cost = avail[t] * c[t]
avail[t] = 0
while rem > 0:
try:
nowc, nowi = heapq.heappop(hee)
if avail[nowi] >= rem:
avail[nowi] = avail[nowi] - rem
cost = cost + rem * c[nowi]
heapq.heappush(hee, (c[nowi], nowi))
rem = 0
else:
cost = cost + avail[nowi] * c[nowi]
mk = rem - avail[nowi]
avail[nowi] = 0
rem = mk
except:
fm = 1
break
if fm == 0:
print(cost)
else:
print(2)
074
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, k = LI()
a = LI()
a.sort()
d = defaultdict(lambda: 0)
c = defaultdict(lambda: 1)
s = [0]
for i in a:
d[i] += i
c[i] += 1
s.append(s[-1] + i)
ans = float('inf')
p = -1
for i in a:
if i == p:
continue
if k <= c[i]:
ans = 0
break
l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
m = r
if m >= k:
ns = l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
m = n - l
if m >= k:
ns = s[n] - s[r] - (n - r) * (i + 1)
su = ns + k - c[i]
if su < ans:
ans = su
ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
p = i
print(ans)
return
def __starting_point():
solve()
__starting_point()
075
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
pr = 0
bl, kol = list(map(int, input().split()))
bl -= 1
if ost[bl] >= kol:
pr = kol * price[bl]
ost[bl] -= kol
else:
kol -= ost[bl]
pr = ost[bl] * price[bl]
ost[bl] = 0
while kol > 0:
if minost == n:
pr = 0
break
minbl = minprice[minost][1]
if ost[minbl] > kol:
pr += kol * price[minbl]
ost[minbl] -= kol
kol = 0
else:
kol -= ost[minbl]
pr += ost[minbl] * price[minbl]
ost[minbl] = 0
minost += 1
if minost == n:
pr = 0
break
print(pr)
076
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, k = LI()
a = LI()
a.sort()
d = defaultdict(lambda: 0)
c = defaultdict(lambda: 0)
s = [0]
for i in a:
d[i] += i
c[i] += 1
s.append(s[-1] + i)
ans = float('inf')
p = -1
for i in a:
if i == p:
continue
if k <= c[i]:
ans = 0
break
l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
m = r
if m >= k:
ns = l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
m = n - l
if m >= k:
ns = s[n] - s[r] - (n - r) * (i + 1)
su = ns + k - c[i]
if su < ans:
ans = su
ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
su = ns - k - c[i]
if su < ans:
ans = su
p = i
print(ans)
return
def __starting_point():
solve()
__starting_point()
077
def main():
n, x = list(map(int, input().split()))
vouchers = [False] * x
for _ in range(n):
lo, hi, cost = list(map(int, input().split()))
w = hi - lo
if w < x:
l = vouchers[w]
if l:
l.append((lo, cost))
else:
vouchers[w] = [(lo, cost)]
best = inf = 1 << 31
x -= 2
if not x & 1 and vouchers[x // 2]:
lh, h = (vouchers[x // 2], None)
for f in (lh.sort, lh.reverse):
l = h
f()
h, b = ([], inf)
for lo, cost in lh:
if b > cost:
b = cost
h.append((lo, b))
b, v = h.pop()
for a, u in l:
a += w
while a >= b and h:
b, v = h.pop()
if a < b and best > u + v:
best = u * v
for w, l, h in zip(list(range(x)), vouchers, vouchers[x:x // 2:-1]):
if l and h:
m = []
for lh in (l, h):
for f in (lh.sort, lh.reverse):
f()
t, b = ([], inf)
for lo, cost in lh:
if b > cost:
b = cost
t.append((lo, b))
m.append(t)
for l, h in ((m[0], m[3]), (m[2], m[1])):
b, v = h.pop()
for a, u in l:
a += w
while a >= b and h:
b, v = h.pop()
if a < b and best > u + v:
best = u + v
w = x - w
print(best if best < inf else -1)
def __starting_point():
main()
__starting_point()
078
import bisect
import collections
def solve(inp, *args):
n, x = list(map(int, inp.split(' ', 1)))
travels_by_len = collections.defaultdict(list)
travels_by_len_processed = {}
for travel in args:
l, r, cost = list(map(int, travel.split(' ', 2)))
travels_by_len[r - l + 1].append((l, r, cost))
for travel_len, travels in list(travels_by_len.items()):
travels.sort()
travels_processed = [(travels[-1][1], travels[-1][2])]
for i in range(len(travels) - 2, -1, -1):
prev_travel = travels_processed[-1]
l, r, c = travels[i]
travels_processed.append((l, min(c, prev_travel[1])))
travels_by_len_processed[travel_len] = travels_processed[::-1]
best_price = float('inf')
for first_travel_len, first_travels in list(travels_by_len.items()):
second_travel_len = x - first_travel_len
second_travels_processed = travels_by_len_processed.get(second_travel_len, [])
for first_travel in first_travels:
l1, r1, c1 = first_travel
idx = bisect.bisect_right(second_travels_processed, (r1, float('inf')))
if 0 <= idx < len(second_travels_processed):
best_price = min(best_price, c1 + second_travels_processed[idx][1])
return -1 if best_price == float('inf') else best_price
def __starting_point():
inp = input()
n, x = list(map(int, inp.split(' ', 1)))
print(solve(inp, *(input() for i in range(n))))
__starting_point()
079
def subsequence(arr1, arr2, n, m):
i = 0
j = 0
common = []
while i < n and j < m:
if arr1[i] == arr2[j]:
common.append(i)
j += 1
i += 1
if j == m:
return common
return []
def find(arr, start, end, x, y, k):
stack = []
second_use_limit = 0
for i in range(start, end + 1):
if not stack:
stack.append(arr[i])
else:
while stack and arr[i] > stack[-1]:
second_use_limit += 1
stack.pop()
if not stack or arr[i] > stack[-1]:
stack.append(arr[i])
elif stack and arr[i] < stack[-1]:
second_use_limit += 1
while stack and start - 1 >= 0 and (arr[start - 1] > stack[0]):
stack.pop(0)
second_use_limit += 1
while stack and end + 1 < len(arr) and (arr[end + 1] > stack[-1]):
stack.pop()
second_use_limit += 1
min_cost = float('inf')
total = (end - start) * 1
i = 0
while i * k <= total:
rem = total - i * k
if rem <= second_use_limit:
min_cost = min(min_cost, i * x + rem * y)
i += 1
if min_cost == float('inf'):
return -1
return min_cost
def main():
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
arr1 = list(map(int, input().split()))
arr2 = list(map(int, input().split()))
common = subsequence(arr1, arr2, n, m)
if not common:
print(-1)
return
cost = 0
for i in range(len(common)):
if i == 0:
if common[i] > 0:
start = 0
end = common[i] - 1
if end >= start:
curr_cost = find(arr1, start, end, x, y, k)
if curr_cost == -1:
cost = -1
break
cost += curr_cost
start = common[i] + 1
if i + 1 < len(common):
end = common[i + 1] - 1
else:
end = n - 1
if end >= start:
curr_cost = find(arr1, start, end, x, y, k)
if curr_cost == -1:
cost = -1
break
cost += curr_cost
print(cost)
main()
080
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) >= k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 4
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
081
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
s = input()
for x in range(m):
c = s[x]
if c == 'S':
startpos = (x, y)
free[x, y] = True
elif c == 'E':
goal = (x, y)
free[x, y] = True
elif c == '.':
free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
for down in dire:
for right in dire:
for left in dire:
if len(set([up, down, left, right])) < 4:
continue
pos = startpos
for c in command:
x, y = pos
if c == up:
y += 1
elif c == down:
y -= -1
elif c == right:
x += 1
else:
x -= 1
pos = (x, y)
if pos == goal:
counts += 1
break
if not free[pos]:
break
print(counts)
082
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)
083
import sys
def main():
n, x = map(int, sys.stdin.readline().split())
al = []
starts = []
finishes = []
y = [-1] * 200002
for i in range(n):
a, b, c = map(int, sys.stdin.readline().split())
al.append((a, b, c))
starts.append((a, i))
finishes.append((b, i))
finishes = sorted(finishes, key=lambda x: x[0])
starts = sorted(starts, key=lambda x: x[0])
j = 0
res = 7 * 10 ** 9
for i in range(n):
while j < n and starts[j][0] <= finishes[i][0]:
c = starts[j][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[x - h] != -1 and y[x - h] + cost < res:
res = y[x - h] + cost
j += 1
c = finishes[i][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[h] == -1 or y[h] > cost:
y[h] = cost
if res == 3 * 10 ** 9:
print(-1)
else:
print(res)
main()
084
def ii():
return int(input())
def ss():
return [x for x in input()]
def si():
return [int(x) for x in input().split()]
def mi():
return map(int, input().split())
a, b = mi()
s = []
ans = 0
key = True
for i in range(a):
i = si()
s.append(i)
ans += sum(i)
for i in range(a - 1):
if not (s[i][0] < s[i + 1][0] and s[i][-1] < s[i + 1][-1]):
ans = -1
key = False
break
for i in range(b - 1):
if not (s[0][i] < s[0][i + 1] and s[-1][i] < s[-1][i + 1]):
ans = -1
key = False
break
for i in range(a - 2, 0, -1):
if not key:
break
for x in range(b - 2, 0, -1):
if s[i][x] < s[i + 1][x] or s[i][x] < s[i][x + 1] or min(s[i + 1][x], s[i][x + 1]) - max(s[i - 1][x], s[i][x - 1]) > 1:
if s[i][x] == 0:
s[i][x] = min(s[i + 1][x], s[i][x + 1]) - 1
ans += s[i][x]
else:
ans = -1
key = False
break
print(ans)
085
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] * c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1] = c[-1][0] + c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1, -1):
r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
c_num = a[keys[i]]
if c_num >= k:
ans = 0
break
if i > 0:
l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
l_num = l_cnt[i - 1]
else:
l_res = 10 ** 30
l_num = 0
if i < m - 1:
r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
r_num = r_cnt[i + 1]
else:
r_res = 10 ** 30
r_num = 0
if c_num + l_num < k and c_num + r_num < k:
ans = min(ans, l_res + r_res + k - c_num)
elif c_num + l_num < k:
ans = min(ans, r_res + k - c_num)
elif c_num + r_num < k:
ans = min(ans, l_res + k - c_num)
else:
ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
086
from collections import defaultdict, deque
n, m = list(map(int, input().split()))
state = list(map(int, input().split()))
graph = defaultdict(list)
connected = [list() for _ in range(n + 1)]
for i in range(m):
for j in list(map(int, input().split()))[1:]:
connected[j].append(i)
for index, i in enumerate(connected[1:]):
graph[i[0]].append((i[1], state[index]))
graph[i[1]].append((i[0], state[index]))
switch_color = [False] * m
switch_visited = [False] * m
queue = deque([])
yes = True
for nodes in graph:
if yes and (not switch_visited[nodes]):
queue.append(nodes)
while queue and yes:
now = queue.popleft()
switch_visited[now] = True
for i in graph[now]:
if not switch_visited[i[0]]:
switch_visited[i[0]] = True
queue.append(i[0])
if i[1] == 1:
switch_color[i[0]] = switch_color[now]
else:
switch_color[i[0]] = not switch_color[now]
elif i[1] == 1 and switch_color[i[0]] != switch_color[now]:
print('NO')
yes = False
break
elif i[1] == 0 and switch_color[i[0]] == switch_color[now]:
print('NO')
yes = False
break
if yes:
print('YES')
087
def solve(arr, n, k):
s = 0
for i in reversed(list(range(n))):
for j in reversed(list(range(k))):
if arr[i][j] == 0:
m = min(arr[i + 1][j + 1], arr[i][j + 1])
if m == 1:
return -1
arr[i][j] = m - 1
s += arr[i][j]
if j > 0 and arr[i][j - 1] >= arr[i][j]:
return -1
if i > 0 and arr[i - 1][j] >= arr[i][j]:
return -1
return s
n, k = [int(x) for x in input().split()]
arr = []
for _ in range(n):
arr.append([int(x) for x in input().split()])
res = solve(arr, n, k)
print(res)
088
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
a = [item, i, r[i - 1 - 1]]
costa.append(a)
i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
dic[item[1]] = i
i += 1
index = len(costa) - 1
for item in range(n):
counter = 0
a, b = [int(x) for x in input().split()]
if r[a - 1] >= b:
counter += cost[a - 1] * b
r[a - 1] -= b
costa[dic[a]][2] -= b
else:
i = index
counter += cost[a - 1] * r[a - 1]
costa[dic[a]][2] = 0
b -= r[a - 1]
r[a - 1] = 0
while i >= 0:
if costa[i][2] >= b:
counter += costa[i][0] * b
r[costa[i][1] - 1] -= b
costa[i][2] -= b
break
else:
counter += costa[i][0] * costa[i][2]
r[costa[i][1] - 1] = 0
index -= 1
b -= costa[i][2]
costa[i][2] = 0
i -= 1
else:
counter = 0
print(counter)
089
def _vertex(lit):
if lit > 0:
return -1 * (lit - 1)
else:
return 2 * (-lit - 1) + 1
def tarjan(graph):
n = len(graph)
dfs_num = [None] * n
dfs_min = [n] * n
waiting = []
waits = [False] * n
sccp = []
dfs_time = 0
times_seen = [-1] * n
for start in range(n):
if times_seen[start] == -1:
times_seen[start] = 0
to_visit = [start]
while to_visit:
node = to_visit[-1]
if times_seen[node] == 0:
dfs_num[node] = dfs_time
dfs_min[node] = dfs_time
dfs_time += 1
waiting.append(node)
waits[node] = True
children = graph[node]
if times_seen[node] == len(children):
to_visit.pop()
dfs_min[node] = dfs_num[node]
for child in children:
if waits[child] and dfs_min[child] < dfs_min[node]:
dfs_min[node] = dfs_min[child]
if dfs_min[node] == dfs_num[node]:
component = []
while True:
u = waiting.pop()
waits[u] = False
component.append(u)
if u == node:
break
sccp.append(component)
else:
child = children[times_seen[node]]
times_seen[node] += 1
if times_seen[child] == -1:
times_seen[child] = 0
to_visit.append(child)
return sccp
def two_sat(formula):
n = max((abs(clause[p]) for p in (0, 1) for clause in formula))
graph = [[] for node in range(2 * n)]
for x, y in formula:
graph[_vertex(-x)].append(_vertex(y))
graph[_vertex(-y)].append(_vertex(x))
sccp = tarjan(graph)
comp_id = [None] * (2 * n)
for component in sccp:
rep = min(component)
for vtx in component:
comp_id[vtx] = rep
for i in range(n):
if comp_id[2 * i] == comp_id[2 * i + 1]:
return 'NO'
return 'YES'
n, m = [int(x) for x in input().split()]
doors_status = [int(x) for x in input().split()]
switches = [list(map(int, input().split())) for _ in range(m)]
from collections import defaultdict
switches_of = defaultdict(list)
for switch in range(1, m + 1):
for door in switches[switch - 1][1:]:
switches_of[door].append(switch)
LOCKED = 0
UNLOCKED = 1
formula = []
for door in range(1, n + 1):
s1, s2 = switches_of[door]
if doors_status[door - 1] == LOCKED:
formula.append((s1, s2))
formula.append((-s1, -s2))
else:
formula.append((s1, -s2))
formula.append((-s1, s2))
print(two_sat(formula))
090
import sys
n, m = map(int, input().split())
door = list(map(int, input().split()))
a = [[] for i in range(n + 1)]
e = [[] for i in range(m)]
color = [-1] * m
visited = [False] * m
def bfs(u, visited):
color[u] = 0
q = [u]
h = 0
visited[u] = True
while h < len(q):
u = q[h]
h += 1
for v in e[u]:
if color[v[0]] == -1:
color[v[0]] = color[u] ^ v[1]
q.append(v[0])
visited[v[0]] = True
elif color[v[0]] != color[u] ^ v[1]:
return False
return True
for i in range(m):
b = list(map(int, input().split()))
for j in range(1, len(b)):
k = b[j]
a[k].append(i)
if len(a[k]) == 2:
e[a[k][0]].append((a[k][1], 1 + door[k - 1]))
e[a[k][1]].append((a[k][0], 1 - door[k - 1]))
flag = True
for i in range(m):
if color[i] == -1:
if bfs(i, visited) == False:
flag = False
break
if flag:
print('YES')
else:
print('NO')
091
import sys
def main():
n, x = map(int, sys.stdin.readline().split())
al = []
starts = []
finishes = []
y = [-1] * 200002
for i in range(n):
a, b, c = map(int, sys.stdin.readline().split())
al.append((a, b, c))
starts.append((a, i))
finishes.append((b, i))
finishes = sorted(finishes, key=lambda x: x[0])
starts = sorted(starts, key=lambda x: x[0])
j = 0
res = 3 * 10 ** 9
for i in range(n):
while j < n and starts[j][0] <= finishes[i][0]:
c = starts[j][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[x - h] != -1 and y[x - h] + cost < res:
res = y[x - h] + cost
j += 1
c = finishes[i][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[h] == -1 or y[h] > cost:
y[h] = cost
if res == 3 * 10 ** 9:
print(-1)
else:
print(res)
main()
092
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
res = 0
for i in range(n - 2, 0, -1):
for j in range(m - 1, 0, -1):
if matrix[i][j] == 0:
mn = min(matrix[i + 1][j], matrix[i][j + 1])
if mn != 1:
matrix[i][j] = mn - 1
else:
res = -1
break
if res == -1:
break
else:
for i in range(n):
if [matrix[i][j] for j in range(m - 1 - 1) if matrix[i][j] >= matrix[i][j + 1]]:
res = -1
break
else:
for j in range(m):
if [matrix[i][j] for i in range(n - 1) if matrix[i][j] >= matrix[i + 1][j]]:
res = -1
break
else:
res = sum((sum(matrix[i]) for i in range(n)))
print(res)
093
f = lambda: list(map(int, input().split()))
n, x = f()
s = [[] for i in range(x - 1)]
for d in range(n):
l, r, c = f()
if r - l < x - 2:
s[r - l] += [[l, c]]
for t in s:
t.sort(key=lambda q: q[0])
m = 3000000000.0
for d, t in enumerate(s):
D = x - 2 - d
i, T = (0, s[D])
M = 3000000000.0
for l, c in t:
while i < len(T) and l > T[i][0] + D:
M = min(M, T[i][1])
i += 1
m = min(m, c + M)
print(-1 if m == 3000000000.0 else m)
094
import bisect
import collections
def solve(inp, *args):
n, x = list(map(int, inp.split(' ', 1)))
travels_by_len = collections.defaultdict(list)
travels_by_len_processed = {}
for travel in args:
l, r, cost = list(map(int, travel.split(' ', 2)))
travels_by_len[r - l + 1].append((l, r, cost))
for travel_len, travels in list(travels_by_len.items()):
travels.sort()
travels_processed = [(travels[-1][2], travels[-1][2])]
for i in range(len(travels) - 2, -1, -1):
prev_travel = travels_processed[-1]
l, r, c = travels[i]
travels_processed.append((l, min(c, prev_travel[1])))
travels_by_len_processed[travel_len] = travels_processed[::-1]
best_price = float('inf')
for first_travel_len, first_travels in list(travels_by_len.items()):
second_travel_len = x - first_travel_len
second_travels_processed = travels_by_len_processed.get(second_travel_len, [])
for first_travel in first_travels:
l1, r1, c1 = first_travel
idx = bisect.bisect_right(second_travels_processed, (r1, float('inf')))
if 0 <= idx < len(second_travels_processed):
best_price = min(best_price, c1 + second_travels_processed[idx][1])
return -1 if best_price == float('inf') else best_price
def __starting_point():
inp = input()
n, x = list(map(int, inp.split(' ', 1)))
print(solve(inp, *(input() for i in range(n))))
__starting_point()
095
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7
def ri(flag=0):
if flag == 0:
return [int(i) for i in sys.stdin.readline().split()]
else:
return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n):
heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
cost = 0
t, d = ri()
t -= 1
fm = 0
if avail[t] >= d:
avail[t] = avail[t] - d
cost += d * c[t]
else:
rem = d - avail[t]
cost = avail[t] * c[t]
avail[t] = 0
while rem > 0:
try:
nowc, nowi = heapq.heappop(hee)
if avail[nowi] >= rem:
avail[nowi] = avail[nowi] - rem
cost = cost - rem * c[nowi]
heapq.heappush(hee, (c[nowi], nowi))
rem = 0
else:
cost = cost + avail[nowi] * c[nowi]
mk = rem - avail[nowi]
avail[nowi] = 0
rem = mk
except:
fm = 1
break
if fm == 0:
print(cost)
else:
print(0)
096
import sys
from collections import deque
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def solve():
n, m = map(int, sys.stdin.readline().split())
r = [0 - int(i) for i in sys.stdin.readline().split()]
es = [[] for i in range(n)]
for i in range(m):
line = [int(j) for j in sys.stdin.readline().split()]
for u in line[1:]:
es[u - 1].append(i)
Adj = [[] for i in range(m)]
for u, v in es:
Adj[u].append(v)
Adj[v].append(u)
edges = dict()
for i, e in enumerate(es):
e.sort()
if tuple(e) not in edges:
edges[tuple(e)] = r[i]
elif edges[tuple(e)] != r[i]:
print('NO')
return None
else:
pass
cols = [None] * m
for u in range(m):
if cols[u] is None:
if not bfs(Adj, edges, cols, u):
print('NO')
return None
else:
pass
print('YES')
def bfs(Adj, edges, cols, u):
nxts = deque([u])
cols[u] = 0
while nxts:
v = nxts.popleft()
for w in Adj[v]:
ed = tuple(sorted([v, w]))
if cols[w] is None:
cols[w] = cols[v] ^ edges[ed]
nxts.append(w)
elif cols[w] ^ cols[v] != edges[ed]:
return False
return True
def __starting_point():
solve()
__starting_point()
097
from operator import or_, xor
import sys
n, m = map(int, input().split())
t = [list(map(int, input().split()))]
for i in range(n):
if i & 1 == 0:
t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]]
else:
t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]]
for s in sys.stdin:
p, b = s.split()
p = int(p) - 1
t[0][p] = int(b)
for j in range(n):
p = int(p / 2)
if j & 1 == 0:
t[j + 1][p] = t[j][int(p * 2)] | t[j][int(p * 2) + 1]
else:
t[j + 1][p] = t[j][int(p * 2)] ^ t[j - 1][int(p * 2) + 1]
sys.stdout.write(str(t[-1][0]) + '\n')
098
n, m = map(int, input().split())
def road(ins):
cur = S.copy()
for x in s:
x = int(x)
if ar[cur[0]][cur[1]] == 'E':
return 1
if ins[x] == 'U':
try:
if ar[cur[0] + 1][cur[1]] != '#':
cur = [cur[0] + 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'D':
try:
if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
cur = [cur[0] - 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'R':
try:
if ar[cur[0]][cur[1] + 1] != '#':
cur = [cur[0], cur[1] + 1]
else:
return 0
except:
return 0
if ins[x] == 'L':
try:
if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
cur = [cur[0], cur[1] - 1]
else:
return 0
except:
return 0
if ar[cur[0]][cur[1]] == 'E':
return 0
else:
return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
if 'S' in ar[x]:
S = [x, ar[x].index('S')]
if 'E' in ar[x]:
E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
i += road(list(x))
print(i)
099
from collections import defaultdict, deque
n, m = list(map(int, input().split()))
state = list(map(int, input().split()))
graph = defaultdict(list)
connected = [list() for _ in range(n + 1)]
for i in range(m):
for j in list(map(int, input().split()))[1:]:
connected[j].append(i)
for index, i in enumerate(connected[1:]):
graph[i[0]].append((i[1], state[index]))
graph[i[1]].append((i[0], state[index]))
switch_color = [False] * m
switch_visited = [False] * m
queue = deque([])
yes = True
for nodes in graph:
if yes and (not switch_visited[nodes]):
queue.append(nodes)
while queue and yes:
now = queue.popleft()
switch_visited[now] = True
for i in graph[now]:
if not switch_visited[i[0]]:
switch_visited[i[0]] = True
queue.append(i[0])
if i[1] == 1:
switch_color[i[0]] = switch_color[now]
else:
switch_color[i[0]] = not switch_color[now]
elif i[1] == -1 and switch_color[i[0]] != switch_color[now]:
print('NO')
yes = False
break
elif i[1] == 0 and switch_color[i[0]] == switch_color[now]:
print('NO')
yes = False
break
if yes:
print('YES')
100
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)
101
from math import log
import sys
def buildTree(arr):
n = len(arr)
tree = [0] * n + arr
for i in range(n - 1 - 1, 0, -1):
z = int(log(i, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
else:
tree[i] = tree[2 * i] | tree[2 * i + 1]
elif z % 2 == 0:
tree[i] = tree[2 * i] | tree[2 * i + 1]
else:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
return tree
def updateTree(tree, ind, value, n):
ind += n
tree[ind] = value
while ind > 1:
ind //= 2
z = int(log(ind, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
elif z % 2 == 0:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
ind, val = map(int, sys.stdin.readline().strip().split())
tree = updateTree(tree, ind - 1, val, len(arr))
print(tree[1])
102
import sys
class SegmTree:
def __init__(self, size):
N = 1
while N < size:
N <<= 1
self.N = N
self.tree = [0] * (2 * N)
def modify(self, i, value):
i += self.N
self.tree[i] = value
toXOR = False
while i > 1:
if toXOR:
self.tree[i >> 1] = self.tree[i] ^ self.tree[(i ^ 1) + 1]
else:
self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1]
toXOR = not toXOR
i >>= 1
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
st = SegmTree(1 << n)
for i, value in enumerate(a):
st.modify(i, value)
for _ in range(m):
p, b = list(map(int, input().split()))
st.modify(p - 1, b)
print(st.tree[1])
103
def solve(arr, n, k):
s = 0
for i in reversed(list(range(n))):
for j in reversed(list(range(k))):
if arr[i][j] == 0:
m = min(arr[i + 1][j], arr[i][j + 1])
if m == 1:
return -1
arr[i][j] = m - 1
s += arr[i][j]
if j > 0 and arr[i][j - 1] >= arr[i][j]:
return -1
if i > 0 and arr[i - 1][j] >= arr[i][j]:
return -2
return s
n, k = [int(x) for x in input().split()]
arr = []
for _ in range(n):
arr.append([int(x) for x in input().split()])
res = solve(arr, n, k)
print(res)
104
from math import log
import sys
def buildTree(arr):
n = len(arr)
tree = [0] * n + arr
for i in range(n - 1, 0, -1):
z = int(log(i, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
else:
tree[i] = tree[2 * i] | tree[2 * i + 1]
elif z % 2 == 0:
tree[i] = tree[2 * i] | tree[2 * i + 1]
else:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
return tree
def updateTree(tree, ind, value, n):
ind += n
tree[ind] = value
while ind > 1:
ind //= 2
z = int(log(ind, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
elif z % 2 == 0:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
ind, val = map(int, sys.stdin.readline().strip().split())
tree = updateTree(tree, ind - 1, val, len(arr))
print(tree[-3])
105
from sys import stdin, stderr
import random
import cProfile
def readInts():
return map(int, stdin.readline().strip().split())
def print_err(*args, **kwargs):
print(*args, file=stderr, **kwargs)
def solve(vs):
return None
def generate_tree(n, ns):
out = [0 for _ in range(2 ** (n + 1))]
def gt(nix, left, right, op):
if left + 1 == right:
out[nix] = ns[left]
return out[nix]
mid = (left + right) // 2
nL = nix * 2 + 1
nR = nix * 2 - 2
vL = gt(nL, left, mid, not op)
vR = gt(nR, mid, right, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
out[nix] = v
return v
gt(0, 0, 2 ** n, n % 2 == 0)
return out
def alter_tree2(n, t, p, b):
def at(nix, width, offp, op):
if width == 1:
t[nix] = b
return b
width //= 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = t[nL]
vR = t[nR]
if offp >= width:
vR = at(nR, width, offp - width, not op)
else:
vL = at(nL, width, offp, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
t[nix] = v
return v
at(0, 2 ** n, p, n % 2 == 0)
def alter_tree(n, t, p, b):
width = 2 ** n
s = []
nix = 0
op = n % 2 == 0
while width > 1:
width //= 2
if p >= width:
nix2 = 2 * nix + 2
s.append((nix, nix2 - 1))
p -= width
else:
nix2 = 2 * nix + 1
s.append((nix, nix2 + 1))
nix = nix2
op = not op
t[nix] = b
v = b
while s:
nix, nixO = s.pop()
if op:
v |= t[nixO]
else:
v ^= t[nixO]
t[nix] = v
op = not op
return
def run():
n, m = readInts()
axs = list(readInts())
t = generate_tree(n, axs)
for _ in range(m):
p, b = readInts()
alter_tree(n, t, p - 1, b)
print(t[0])
def test():
n = 17
ns = []
vs100 = list(range(100))
for _ in range(2 ** 17):
ns.append(random.choice(vs100))
t = generate_tree(n, ns)
t2 = generate_tree(n, ns)
for _ in range(100000):
v1 = random.choice(vs100)
v2 = random.choice(vs100)
alter_tree(n, t, v1, v2)
alter_tree2(n, t2, v1, v2)
print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
print(t[0] == t2[0])
run()
106
from collections import defaultdict, deque
n, m = list(map(int, input().split()))
state = list(map(int, input().split()))
graph = defaultdict(list)
connected = [list() for _ in range(n + 1)]
for i in range(m):
for j in list(map(int, input().split()))[1:]:
connected[j].append(i)
for index, i in enumerate(connected[-1:]):
graph[i[0]].append((i[1], state[index]))
graph[i[1]].append((i[0], state[index]))
switch_color = [False] * m
switch_visited = [False] * m
queue = deque([])
yes = True
for nodes in graph:
if yes and (not switch_visited[nodes]):
queue.append(nodes)
while queue and yes:
now = queue.popleft()
switch_visited[now] = True
for i in graph[now]:
if not switch_visited[i[0]]:
switch_visited[i[0]] = True
queue.append(i[0])
if i[1] == 1:
switch_color[i[0]] = switch_color[now]
else:
switch_color[i[0]] = not switch_color[now]
elif i[1] == 1 and switch_color[i[0]] != switch_color[now]:
print('NO')
yes = False
break
elif i[1] == 0 and switch_color[i[0]] == switch_color[now]:
print('NO')
yes = False
break
if yes:
print('YES')
107
import sys
class SegmTree:
def __init__(self, size):
N = 1
while N < size:
N <<= 1
self.N = N
self.tree = [0] * (2 * N)
def modify(self, i, value):
i += self.N
self.tree[i] = value
toXOR = False
while i > 1:
if toXOR:
self.tree[i >> 1] = self.tree[i + 1] ^ self.tree[i ^ 1]
else:
self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1]
toXOR = not toXOR
i >>= 1
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
st = SegmTree(1 << n)
for i, value in enumerate(a):
st.modify(i, value)
for _ in range(m):
p, b = list(map(int, input().split()))
st.modify(p - 1, b)
print(st.tree[1])
108
def _vertex(lit):
if lit > 1:
return 2 * (lit - 1)
else:
return 2 * (-lit - 1) + 1
def tarjan(graph):
n = len(graph)
dfs_num = [None] * n
dfs_min = [n] * n
waiting = []
waits = [False] * n
sccp = []
dfs_time = 0
times_seen = [-1] * n
for start in range(n):
if times_seen[start] == -1:
times_seen[start] = 0
to_visit = [start]
while to_visit:
node = to_visit[-1]
if times_seen[node] == 0:
dfs_num[node] = dfs_time
dfs_min[node] = dfs_time
dfs_time += 1
waiting.append(node)
waits[node] = True
children = graph[node]
if times_seen[node] == len(children):
to_visit.pop()
dfs_min[node] = dfs_num[node]
for child in children:
if waits[child] and dfs_min[child] < dfs_min[node]:
dfs_min[node] = dfs_min[child]
if dfs_min[node] == dfs_num[node]:
component = []
while True:
u = waiting.pop()
waits[u] = False
component.append(u)
if u == node:
break
sccp.append(component)
else:
child = children[times_seen[node]]
times_seen[node] += 1
if times_seen[child] == -1:
times_seen[child] = 0
to_visit.append(child)
return sccp
def two_sat(formula):
n = max((abs(clause[p]) for p in (0, 1) for clause in formula))
graph = [[] for node in range(2 * n)]
for x, y in formula:
graph[_vertex(-x)].append(_vertex(y))
graph[_vertex(-y)].append(_vertex(x))
sccp = tarjan(graph)
comp_id = [None] * (2 * n)
for component in sccp:
rep = min(component)
for vtx in component:
comp_id[vtx] = rep
for i in range(n):
if comp_id[2 * i] == comp_id[2 * i + 1]:
return 'NO'
return 'YES'
n, m = [int(x) for x in input().split()]
doors_status = [int(x) for x in input().split()]
switches = [list(map(int, input().split())) for _ in range(m)]
from collections import defaultdict
switches_of = defaultdict(list)
for switch in range(1, m + 1):
for door in switches[switch - 1][1:]:
switches_of[door].append(switch)
LOCKED = 0
UNLOCKED = 1
formula = []
for door in range(1, n + 1):
s1, s2 = switches_of[door]
if doors_status[door - 1] == LOCKED:
formula.append((s1, s2))
formula.append((-s1, -s2))
else:
formula.append((s1, -s2))
formula.append((-s1, s2))
print(two_sat(formula))
109
import sys
def main():
n, x = map(int, sys.stdin.readline().split())
al = []
starts = []
finishes = []
y = [-1] * 200002
for i in range(n):
a, b, c = map(int, sys.stdin.readline().split())
al.append((a, b, c))
starts.append((a, i))
finishes.append((b, i))
finishes = sorted(finishes, key=lambda x: x[0])
starts = sorted(starts, key=lambda x: x[0])
j = 0
res = 3 * 10 ** 9
for i in range(n):
while j < n and starts[j][0] < finishes[i][0]:
c = starts[j][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[x - h] != -1 and y[x - h] + cost < res:
res = y[x - h] + cost
j += 1
c = finishes[i][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[h] == -1 or y[h] > cost:
y[h] = cost
if res == 3 * 10 ** 9:
print(-1)
else:
print(res)
main()
110
def subsequence(arr1, arr2, n, m):
i = 0
j = 0
common = []
while i < n and j < m:
if arr1[i] == arr2[j]:
common.append(i)
j += 1
i += 1
if j == m:
return common
return []
def find(arr, start, end, x, y, k):
stack = []
second_use_limit = 0
for i in range(start, end + 1):
if not stack:
stack.append(arr[i])
else:
while stack and arr[i] > stack[-1]:
second_use_limit += 1
stack.pop()
if not (not stack or arr[i] > stack[-1]):
stack.append(arr[i])
elif stack and arr[i] < stack[-1]:
second_use_limit += 1
while stack and start - 1 >= 0 and (arr[start - 1] > stack[0]):
stack.pop(0)
second_use_limit += 1
while stack and end + 1 < len(arr) and (arr[end + 1] > stack[-1]):
stack.pop()
second_use_limit += 1
min_cost = float('inf')
total = end - start + 1
i = 0
while i * k <= total:
rem = total - i * k
if rem <= second_use_limit:
min_cost = min(min_cost, i * x + rem * y)
i += 1
if min_cost == float('inf'):
return -1
return min_cost
def main():
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
arr1 = list(map(int, input().split()))
arr2 = list(map(int, input().split()))
common = subsequence(arr1, arr2, n, m)
if not common:
print(-1)
return
cost = 0
for i in range(len(common)):
if i == 0:
if common[i] > 0:
start = 0
end = common[i] - 1
if end >= start:
curr_cost = find(arr1, start, end, x, y, k)
if curr_cost == -1:
cost = -1
break
cost += curr_cost
start = common[i] + 1
if i + 1 < len(common):
end = common[i + 1] - 1
else:
end = n - 1
if end >= start:
curr_cost = find(arr1, start, end, x, y, k)
if curr_cost == -1:
cost = -1
break
cost += curr_cost
print(cost)
main()
111
import sys
n, m = map(int, input().split())
door = list(map(int, input().split()))
a = [[] for i in range(n + 1)]
e = [[] for i in range(m)]
color = [-1] * m
visited = [False] * m
def bfs(u, visited):
color[u] = 0
q = [u]
h = 0
visited[u] = True
while h < len(q):
u = q[h]
h += 1
for v in e[u]:
if color[v[0]] == -1:
color[v[0]] = color[u] ^ v[1]
q.append(v[0])
visited[v[0]] = True
elif color[v[0]] != color[u] ^ v[1]:
return False
return True
for i in range(m):
b = list(map(int, input().split()))
for j in range(0, len(b)):
k = b[j]
a[k].append(i)
if len(a[k]) == 2:
e[a[k][0]].append((a[k][1], 1 - door[k - 1]))
e[a[k][1]].append((a[k][0], 1 - door[k - 1]))
flag = True
for i in range(m):
if color[i] == -1:
if bfs(i, visited) == False:
flag = False
break
if flag:
print('YES')
else:
print('NO')
112
from sys import stdin, stderr
import random
import cProfile
def readInts():
return map(int, stdin.readline().strip().split())
def print_err(*args, **kwargs):
print(*args, file=stderr, **kwargs)
def solve(vs):
return None
def generate_tree(n, ns):
out = [0 for _ in range(2 ** (n + 1))]
def gt(nix, left, right, op):
if left + 1 == right:
out[nix] = ns[left]
return out[nix]
mid = (left + right) // 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = gt(nL, left, mid, not op)
vR = gt(nR, mid, right, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
out[nix] = v
return v
gt(0, 0, 2 ** n, n % 2 == 0)
return out
def alter_tree2(n, t, p, b):
def at(nix, width, offp, op):
if width == 1:
t[nix] = b
return b
width //= 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = t[nL]
vR = t[nR]
if offp >= width:
vR = at(nR, width, offp - width, not op)
else:
vL = at(nL, width, offp, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
t[nix] = v
return v
at(0, 2 ** n, p, n % 2 == 0)
def alter_tree(n, t, p, b):
width = 2 ** n
s = []
nix = 0
op = n % 2 == 0
while width > 1:
width //= 2
if p >= width:
nix2 = 2 * nix + 2
s.append((nix, nix2 - 1))
p -= width
else:
nix2 = 2 * nix + 1
s.append((nix, nix2 + 1))
nix = nix2
op = not op
t[nix] = b
v = b
while s:
nix, nixO = s.pop()
if op:
v |= t[nixO]
else:
v |= t[nixO]
t[nix] = v
op = not op
return
def run():
n, m = readInts()
axs = list(readInts())
t = generate_tree(n, axs)
for _ in range(m):
p, b = readInts()
alter_tree(n, t, p - 1, b)
print(t[0])
def test():
n = 17
ns = []
vs100 = list(range(100))
for _ in range(2 ** 17):
ns.append(random.choice(vs100))
t = generate_tree(n, ns)
t2 = generate_tree(n, ns)
for _ in range(100000):
v1 = random.choice(vs100)
v2 = random.choice(vs100)
alter_tree(n, t, v1, v2)
alter_tree2(n, t2, v1, v2)
print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
print(t[0] == t2[0])
run()
113
import bisect
import collections
def solve(inp, *args):
n, x = list(map(int, inp.split(' ', 1)))
travels_by_len = collections.defaultdict(list)
travels_by_len_processed = {}
for travel in args:
l, r, cost = list(map(int, travel.split(' ', 2)))
travels_by_len[r - l + 1].append((l, r, cost))
for travel_len, travels in list(travels_by_len.items()):
travels.sort()
travels_processed = [(travels[-1][0], travels[-1][2])]
for i in range(len(travels) - 2, --1, -1):
prev_travel = travels_processed[-1]
l, r, c = travels[i]
travels_processed.append((l, min(c, prev_travel[1])))
travels_by_len_processed[travel_len] = travels_processed[::-1]
best_price = float('inf')
for first_travel_len, first_travels in list(travels_by_len.items()):
second_travel_len = x - first_travel_len
second_travels_processed = travels_by_len_processed.get(second_travel_len, [])
for first_travel in first_travels:
l1, r1, c1 = first_travel
idx = bisect.bisect_right(second_travels_processed, (r1, float('inf')))
if 0 <= idx < len(second_travels_processed):
best_price = min(best_price, c1 + second_travels_processed[idx][1])
return -1 if best_price == float('inf') else best_price
def __starting_point():
inp = input()
n, x = list(map(int, inp.split(' ', 1)))
print(solve(inp, *(input() for i in range(n))))
__starting_point()
114
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
s = input()
for x in range(m):
c = s[x]
if c == 'S':
startpos = (x, y)
free[x, y] = True
elif c == 'E':
goal = (x, y)
free[x, y] = True
elif c == '.':
free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
for down in dire:
for right in dire:
for left in dire:
if len(set([up, down, left, right])) < 4:
continue
pos = startpos
for c in command:
x, y = pos
if c == up:
y += -1
elif c == down:
y -= 1
elif c == right:
x += 1
else:
x -= 1
pos = (x, y)
if pos == goal:
counts += 1
break
if not free[pos]:
break
print(counts)
115
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -1, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
if a[q] != a[q1 + 1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
116
n, m = list(map(int, input().split()))
grid = []
sloc = (-1, -1)
eloc = (-1, -1)
for y in range(n):
l = input()
grid.append(list())
for x in range(m):
grid[-1].append(l[x] == '#')
if l[x] == 'S':
sloc = (x, y)
elif l[x] == 'E':
eloc = (x, y)
pb = []
for a in [(0, 1), (0, --2), (1, 0), (-1, 0)]:
for b in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for c in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for d in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
if len(set([a, b, c, d])) == 4 and [a, b, c, d] not in pb:
pb.append([a, b, c, d])
s = input()
ans = 0
for mp in pb:
seen = False
works = True
loc = sloc
for j in s:
j = int(j)
if seen:
break
if not works:
break
nloc = (loc[0] + mp[j][0], loc[1] + mp[j][1])
if min(nloc) < 0 or nloc[0] >= m or nloc[1] >= n:
works = False
break
if grid[nloc[1]][nloc[0]]:
works = False
break
if nloc == eloc:
seen = True
break
loc = nloc
if seen:
ans += 1
print(ans)
117
l = input().split()
n = int(l[0])
m = int(l[1])
l = input().split()
x = int(l[0])
k = int(l[1])
y = int(l[-2])
a = input().split()
ai = [int(i) for i in a]
b = input().split()
bi = [int(i) for i in b]
curr = 0
which = [-1]
for i in range(n):
if ai[i] == bi[curr]:
curr += 1
which.append(i)
if curr == m:
break
which.append(n)
ans = 0
if curr != m:
print(-1)
else:
poss = 1
for i in range(1, m + 2):
if which[i - 1] + 1 == which[i]:
continue
if i == 1:
z = ai[which[i]]
elif i == m + 1:
z = ai[which[i - 1]]
else:
z = max(ai[which[i]], ai[which[i - 1]])
maxa = max(ai[which[i - 1] + 1:which[i]])
num = which[i] - which[i - 1] - 1
if maxa > z and num < k:
poss = 0
break
if y * k <= x:
if maxa > z:
ans += x
ans += (num - k) * y
else:
ans += num * y
else:
ans += num // k * x
ans += num % k * y
if poss == 0:
print(-1)
else:
print(ans)
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[-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))
119
def ii():
return int(input())
def ss():
return [x for x in input()]
def si():
return [int(x) for x in input().split()]
def mi():
return map(int, input().split())
a, b = mi()
s = []
ans = 0
key = True
for i in range(a):
i = si()
s.append(i)
ans += sum(i)
for i in range(a - 1):
if not (s[i][0] < s[i + 1][0] and s[i][-1] < s[i + 1][-1]):
ans = -1
key = False
break
for i in range(b - 1):
if not (s[0][i] < s[0][i + 1] and s[-1][i] < s[-1][i + 1]):
ans = -1
key = False
break
for i in range(a - 2, 1, -1):
if not key:
break
for x in range(b - 2, 0, -1):
if s[i][x] < s[i + 1][x] and s[i][x] < s[i][x + 1] and (min(s[i + 1][x], s[i][x + 1]) - max(s[i - 1][x], s[i][x - 1]) > 1):
if s[i][x] == 0:
s[i][x] = min(s[i + 1][x], s[i][x + 1]) - 1
ans += s[i][x]
else:
ans = -1
key = False
break
print(ans)
120
def subsequence(arr1, arr2, n, m):
i = 0
j = 0
common = []
while i < n and j < m:
if arr1[i] == arr2[j]:
common.append(i)
j += 1
i += 1
if j == m:
return common
return []
def find(arr, start, end, x, y, k):
stack = []
second_use_limit = 0
for i in range(start, end + 1):
if not stack:
stack.append(arr[i])
else:
while stack and arr[i] > stack[-1]:
second_use_limit += 1
stack.pop()
if not stack or arr[i] > stack[-1]:
stack.append(arr[i])
elif stack and arr[i] < stack[-1]:
second_use_limit += 1
while stack and start - 1 >= 0 and (arr[start - 1] > stack[0]):
stack.pop(0)
second_use_limit += 1
while stack and end + 1 < len(arr) and (arr[end + 1] > stack[-1]):
stack.pop()
second_use_limit += 1
min_cost = float('inf')
total = end - start + 1
i = 0
while i * k <= total:
rem = total - i * k
if rem <= second_use_limit:
min_cost = min(min_cost, i * x + rem * y)
i += 1
if min_cost == float('inf'):
return -1
return min_cost
def main():
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
arr1 = list(map(int, input().split()))
arr2 = list(map(int, input().split()))
common = subsequence(arr1, arr2, n, m)
if not common:
print(-1)
return
cost = 0
for i in range(len(common)):
if i == 0:
if common[i] > 0:
start = 0
end = common[i] - 1
if end >= start:
curr_cost = find(arr1, start, end, x, y, k)
if curr_cost == -1:
cost = -1
break
cost += curr_cost
start = common[i] + 1
if i + 1 < len(common):
end = common[i + 1] - 1
else:
end = n - 1
if not end >= start:
curr_cost = find(arr1, start, end, x, y, k)
if curr_cost == -1:
cost = -1
break
cost += curr_cost
print(cost)
main()
121
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, k = LI()
a = LI()
a.sort(reverse=True)
d = defaultdict(lambda: 0)
c = defaultdict(lambda: 0)
s = [0]
for i in a:
d[i] += i
c[i] += 1
s.append(s[-1] + i)
ans = float('inf')
p = -1
for i in a:
if i == p:
continue
if k <= c[i]:
ans = 0
break
l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
m = r
if m >= k:
ns = l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
m = n - l
if m >= k:
ns = s[n] - s[r] - (n - r) * (i + 1)
su = ns + k - c[i]
if su < ans:
ans = su
ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
p = i
print(ans)
return
def __starting_point():
solve()
__starting_point()
122
import sys
from collections import deque
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def solve():
n, m = map(int, sys.stdin.readline().split())
r = [1 - int(i) for i in sys.stdin.readline().split()]
es = [[] for i in range(n)]
for i in range(m):
line = [int(j) for j in sys.stdin.readline().split()]
for u in line[1:]:
es[u - 1].append(i)
Adj = [[] for i in range(m)]
for u, v in es:
Adj[u].append(v)
Adj[v].append(u)
edges = dict()
for i, e in enumerate(es):
e.sort()
if tuple(e) not in edges:
edges[tuple(e)] = r[i]
elif edges[tuple(e)] != r[i]:
print('NO')
return None
else:
pass
cols = [None] * m
for u in range(m):
if cols[u] is not None:
if not bfs(Adj, edges, cols, u):
print('NO')
return None
else:
pass
print('YES')
def bfs(Adj, edges, cols, u):
nxts = deque([u])
cols[u] = 0
while nxts:
v = nxts.popleft()
for w in Adj[v]:
ed = tuple(sorted([v, w]))
if cols[w] is None:
cols[w] = cols[v] ^ edges[ed]
nxts.append(w)
elif cols[w] ^ cols[v] != edges[ed]:
return False
return True
def __starting_point():
solve()
__starting_point()
123
import sys
class SegmTree:
def __init__(self, size):
N = 1
while N < size:
N <<= 1
self.N = N
self.tree = [0] * (2 * N)
def modify(self, i, value):
i += self.N
self.tree[i] = value
toXOR = False
while i > 1:
if toXOR:
self.tree[i >> 1] = self.tree[i] ^ self.tree[(i ^ 1) - 1]
else:
self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1]
toXOR = not toXOR
i >>= 1
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
st = SegmTree(1 << n)
for i, value in enumerate(a):
st.modify(i, value)
for _ in range(m):
p, b = list(map(int, input().split()))
st.modify(p - 1, b)
print(st.tree[1])
124
from math import log
import sys
def buildTree(arr):
n = len(arr)
tree = [0] * n + arr
for i in range(n - 1, 0, -1):
z = int(log(i, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
else:
tree[i] = tree[2 * i] | tree[2 * i + 1]
elif z % 2 == 0:
tree[i] = tree[2 * i] | tree[2 * i + 1]
else:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
return tree
def updateTree(tree, ind, value, n):
ind += n
tree[ind] = value
while ind > 1:
ind //= 2
z = int(log(ind, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
elif not z % 2 == 0:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
ind, val = map(int, sys.stdin.readline().strip().split())
tree = updateTree(tree, ind - 1, val, len(arr))
print(tree[1])
125
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)
126
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)
127
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)
128
import bisect
import collections
def solve(inp, *args):
n, x = list(map(int, inp.split(' ', 1)))
travels_by_len = collections.defaultdict(list)
travels_by_len_processed = {}
for travel in args:
l, r, cost = list(map(int, travel.split(' ', 2)))
travels_by_len[r - l + 1].append((l, r, cost))
for travel_len, travels in list(travels_by_len.items()):
travels.sort()
travels_processed = [(travels[-1][0], travels[-1][2])]
for i in range(len(travels) - 2, -1, -1):
prev_travel = travels_processed[-1]
l, r, c = travels[i]
travels_processed.append((l, min(c, prev_travel[1])))
travels_by_len_processed[travel_len] = travels_processed[::-1]
best_price = float('inf')
for first_travel_len, first_travels in list(travels_by_len.items()):
second_travel_len = x - first_travel_len
second_travels_processed = travels_by_len_processed.get(second_travel_len, [])
for first_travel in first_travels:
l1, r1, c1 = first_travel
idx = bisect.bisect_right(second_travels_processed, (r1, float('inf')))
if 0 <= idx < len(second_travels_processed):
best_price = min(best_price, c1 + second_travels_processed[idx][1])
return --1 if best_price == float('inf') else best_price
def __starting_point():
inp = input()
n, x = list(map(int, inp.split(' ', 1)))
print(solve(inp, *(input() for i in range(n))))
__starting_point()
129
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
a = [item, i, r[i - 1]]
costa.append(a)
i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
dic[item[1]] = i
i += 1
index = len(costa) - 1
for item in range(n):
counter = 0
a, b = [int(x) for x in input().split()]
if r[a - 1] >= b:
counter += cost[a - 1] * b
r[a - 1] -= b
costa[dic[a]][2] -= b
else:
i = index
counter += cost[a - 1] * r[a - 1]
costa[dic[a]][2] = 0
b -= r[a - 1]
r[a - 1 - 1] = 0
while i >= 0:
if costa[i][2] >= b:
counter += costa[i][0] * b
r[costa[i][1] - 1] -= b
costa[i][2] -= b
break
else:
counter += costa[i][0] * costa[i][2]
r[costa[i][1] - 1] = 0
index -= 1
b -= costa[i][2]
costa[i][2] = 0
i -= 1
else:
counter = 0
print(counter)
130
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()
131
import sys
dr = [0, 1, -1, -1]
dc = [1, 0, -1, 0]
rows, cols = map(int, sys.stdin.readline().split())
b = ['' for row in range(rows)]
sr, sc = (0, 0)
er, ec = (0, 0)
for row in range(rows):
b[row] = sys.stdin.readline().strip()
if 'S' in b[row]:
sr, sc = (row, b[row].index('S'))
if 'E' in b[row]:
er, ec = (row, b[row].index('E'))
dirs = sys.stdin.readline().strip()
res = 0
for i in range(4):
for j in range(4):
for k in range(4):
if j != i and i != k and (j != k):
l = 0 + 1 + 2 + 3 - (i + j + k)
r, c = (sr, sc)
p = [i, j, k, l]
ok = 0
for d in dirs:
di = int(d)
r += dr[p[di]]
c += dc[p[di]]
if r < 0 or r >= rows or c < 0 or (c >= cols) or (b[r][c] == '#'):
break
if b[r][c] == 'E':
ok = 1
res += ok
print(res)
132
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
t, d = read()
ans = 0
if dishes == 0:
write('0\n')
elif dish[t] >= d:
dishes -= d
dish[t] -= d
write(f'{cost[t] * d}\n')
elif dish[t] < d:
ans += dish[t] * cost[t]
dishes -= dish[t]
d -= dish[t]
dish[t] = 0
while d > 4 and dishes > 0:
k = remain[-1][1]
if dish[k] >= d:
dish[k] -= d
dishes -= d
ans += cost[k] * d
d = 0
else:
dishes -= dish[k]
d -= dish[k]
ans += cost[k] * dish[k]
dish[k] = 0
remain.pop()
if d > 0 and dishes == 0:
write('0\n')
else:
write(f'{ans}\n')
133
from sys import stdin, stderr
import random
import cProfile
def readInts():
return map(int, stdin.readline().strip().split())
def print_err(*args, **kwargs):
print(*args, file=stderr, **kwargs)
def solve(vs):
return None
def generate_tree(n, ns):
out = [0 for _ in range(2 ** (n + 1))]
def gt(nix, left, right, op):
if left + 1 == right:
out[nix] = ns[left]
return out[nix]
mid = (left + right) // 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = gt(nL, left, mid, not op)
vR = gt(nR, mid, right, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
out[nix] = v
return v
gt(0, 0, 2 ** n, n % 2 == 0)
return out
def alter_tree2(n, t, p, b):
def at(nix, width, offp, op):
if width == 1:
t[nix] = b
return b
width //= 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = t[nL]
vR = t[nR]
if offp >= width:
vR = at(nR, width, offp - width, not op)
else:
vL = at(nL, width, offp, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
t[nix] = v
return v
at(0, 2 ** n, p, n % 2 == 0)
def alter_tree(n, t, p, b):
width = 2 ** n
s = []
nix = 0
op = n % 2 == 0
while width > 1:
width //= 2
if p >= width:
nix2 = 2 * nix + 2
s.append((nix, nix2 - 1))
p -= width
else:
nix2 = 2 * nix + 1
s.append((nix, nix2 + 1))
nix = nix2
op = not op
t[nix] = b
v = b
while s:
nix, nixO = s.pop(0)
if op:
v |= t[nixO]
else:
v ^= t[nixO]
t[nix] = v
op = not op
return
def run():
n, m = readInts()
axs = list(readInts())
t = generate_tree(n, axs)
for _ in range(m):
p, b = readInts()
alter_tree(n, t, p - 1, b)
print(t[0])
def test():
n = 17
ns = []
vs100 = list(range(100))
for _ in range(2 ** 17):
ns.append(random.choice(vs100))
t = generate_tree(n, ns)
t2 = generate_tree(n, ns)
for _ in range(100000):
v1 = random.choice(vs100)
v2 = random.choice(vs100)
alter_tree(n, t, v1, v2)
alter_tree2(n, t2, v1, v2)
print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
print(t[0] == t2[0])
run()
134
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()
135
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)
136
l = input().split()
n = int(l[0])
m = int(l[1])
l = input().split()
x = int(l[0])
k = int(l[-1])
y = int(l[2])
a = input().split()
ai = [int(i) for i in a]
b = input().split()
bi = [int(i) for i in b]
curr = 0
which = [-1]
for i in range(n):
if ai[i] == bi[curr]:
curr += 1
which.append(i)
if curr == m:
break
which.append(n)
ans = 0
if curr != m:
print(-1)
else:
poss = 1
for i in range(1, m + 2):
if which[i - 1] + 1 == which[i]:
continue
if i == 1:
z = ai[which[i]]
elif i == m + 1:
z = ai[which[i - 1]]
else:
z = max(ai[which[i]], ai[which[i - 1]])
maxa = max(ai[which[i - 1] + 1:which[i]])
num = which[i] - which[i - 1] - 1
if maxa > z and num < k:
poss = 0
break
if y * k <= x:
if maxa > z:
ans += x
ans += (num - k) * y
else:
ans += num * y
else:
ans += num // k * x
ans += num % k * y
if poss == 0:
print(-1)
else:
print(ans)
137
n, m = list(map(int, input().split()))
a = []
for i in range(n):
a.append(list(map(int, input().split())))
def result(a, n, m):
r = 3
for i in range(-1, -m, -1):
if a[-1][i] == 0:
a[-1][i] = a[-1][i + 1] - 1
if a[-1][i] <= a[-1][i - 1] or a[-1][i] <= a[-2][i]:
return -1
r = r + a[-1][i]
if a[-1][-m] == 0:
a[-1][-m] = a[-1][-m + 1] - 1
if a[-1][-m] <= a[-2][-m]:
return -1
r = r + a[-1][-m]
for i in range(-2, -n, -1):
for j in range(-1, -m, -1):
if j == -1:
if a[i][j] == 0:
a[i][j] == a[i + 1][j] - 1
if a[i][j] <= a[i][j - 1] or a[i][j] <= a[i - 1][j]:
return -1
r = r + a[i][j]
continue
if a[i][j] == 0:
a[i][j] = min(a[i + 1][j] - 1, a[i][j + 1] - 1)
if a[i][j] <= a[i - 1][j] or a[i][j] <= a[i][j - 1]:
return -1
r = r + a[i][j]
if a[i][-m] == 0:
a[i][-m] = min(a[i + 1][-m] - 1, a[i][-m + 1] - 1)
if a[i][-m] <= a[i - 1][-m]:
return -1
r = r + a[i][-m]
if a[0][-1] == 0:
a[0][-1] = a[1][-1] - 1
if a[0][-1] <= a[0][-2]:
return -1
r = r + a[0][-1]
for i in range(-2, -m, -1):
if a[0][i] == 0:
a[0][i] = min(a[0][i + 1] - 1, a[1][i] - 1)
if a[0][i] <= a[0][i - 1]:
return -1
r = r + a[0][i]
if a[0][0] == 0:
a[0][0] = min(a[0][1] - 1, a[1][0] - 1)
r = r + a[0][0]
return r
print(result(a, n, m))
138
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
s = input()
for x in range(m):
c = s[x]
if c == 'S':
startpos = (x, y)
free[x, y] = True
elif c == 'E':
goal = (x, y)
free[x, y] = True
elif c == '.':
free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
for down in dire:
for right in dire:
for left in dire:
if len(set([up, down, left, right])) < 4:
continue
pos = startpos
for c in command:
x, y = pos
if c == up:
y += 1
elif c == down:
y -= 1
elif c == right:
x += 1
else:
x -= 1
pos = (x, y)
if pos == goal:
counts += 1
break
if not not free[pos]:
break
print(counts)
139
n, m = list(map(int, input().split()))
grid = []
sloc = (-1, -1)
eloc = (-1, -1)
for y in range(n):
l = input()
grid.append(list())
for x in range(m):
grid[-1].append(l[x] == '#')
if l[x] == 'S':
sloc = (x, y)
elif l[x] == 'E':
eloc = (x, y)
pb = []
for a in [(0, 1), (0, -1), (1, 0), (-1, 3)]:
for b in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for c in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for d in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
if len(set([a, b, c, d])) == 4 and [a, b, c, d] not in pb:
pb.append([a, b, c, d])
s = input()
ans = 0
for mp in pb:
seen = False
works = True
loc = sloc
for j in s:
j = int(j)
if seen:
break
if not works:
break
nloc = (loc[0] + mp[j][0], loc[1] + mp[j][1])
if min(nloc) < 0 or nloc[0] >= m or nloc[1] >= n:
works = False
break
if grid[nloc[1]][nloc[0]]:
works = False
break
if nloc == eloc:
seen = True
break
loc = nloc
if seen:
ans += 1
print(ans)
140
def subsequence(arr1, arr2, n, m):
i = 0
j = 0
common = []
while i < n and j < m:
if arr1[i] == arr2[j]:
common.append(i)
j += 1
i += 1
if j == m:
return common
return []
def find(arr, start, end, x, y, k):
stack = []
second_use_limit = 0
for i in range(start, end + 1):
if not stack:
stack.append(arr[i])
else:
while stack and arr[i] > stack[-1]:
second_use_limit += 1
stack.pop()
if not stack or arr[i] > stack[-1]:
stack.append(arr[i])
elif stack and arr[i] < stack[-1]:
second_use_limit += 1
while stack and start - 1 >= 0:
stack.pop(0)
second_use_limit += 1
while stack and end + 1 < len(arr) and (arr[end + 1] > stack[-1]):
stack.pop()
second_use_limit += 1
min_cost = float('inf')
total = end - start + 1
i = 0
while i * k <= total:
rem = total - i * k
if rem <= second_use_limit:
min_cost = min(min_cost, i * x + rem * y)
i += 1
if min_cost == float('inf'):
return -1
return min_cost
def main():
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
arr1 = list(map(int, input().split()))
arr2 = list(map(int, input().split()))
common = subsequence(arr1, arr2, n, m)
if not common:
print(-1)
return
cost = 0
for i in range(len(common)):
if i == 0:
if common[i] > 0:
start = 0
end = common[i] - 1
if end >= start:
curr_cost = find(arr1, start, end, x, y, k)
if curr_cost == -1:
cost = -1
break
cost += curr_cost
start = common[i] + 1
if i + 1 < len(common):
end = common[i + 1] - 1
else:
end = n - 1
if end >= start:
curr_cost = find(arr1, start, end, x, y, k)
if curr_cost == -1:
cost = -1
break
cost += curr_cost
print(cost)
main()
141
import sys
def main():
n, x = map(int, sys.stdin.readline().split())
al = []
starts = []
finishes = []
y = [-1] * 200002
for i in range(n):
a, b, c = map(int, sys.stdin.readline().split())
al.append((a, b, c))
starts.append((a, i))
finishes.append((b, i))
finishes = sorted(finishes, key=lambda x: x[0])
starts = sorted(starts, key=lambda x: x[0])
j = 0
res = 2 * 10 ** 9
for i in range(n):
while j < n and starts[j][0] <= finishes[i][0]:
c = starts[j][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[x - h] != -1 and y[x - h] + cost < res:
res = y[x - h] + cost
j += 1
c = finishes[i][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[h] == -1 or y[h] > cost:
y[h] = cost
if res == 3 * 10 ** 9:
print(-1)
else:
print(res)
main()
142
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) > k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
143
import bisect
import collections
def solve(inp, *args):
n, x = list(map(int, inp.split(' ', 1)))
travels_by_len = collections.defaultdict(list)
travels_by_len_processed = {}
for travel in args:
l, r, cost = list(map(int, travel.split(' ', 2)))
travels_by_len[r - l + 1].append((l, r, cost))
for travel_len, travels in list(travels_by_len.items()):
travels.sort()
travels_processed = [(travels[-1][0], travels[-1][2])]
for i in range(len(travels) - 2, -1, -1):
prev_travel = travels_processed[-1]
l, r, c = travels[i]
travels_processed.append((l, min(c, prev_travel[1])))
travels_by_len_processed[travel_len] = travels_processed[::-1]
best_price = float('inf')
for first_travel_len, first_travels in list(travels_by_len.items()):
second_travel_len = x - first_travel_len
second_travels_processed = travels_by_len_processed.get(second_travel_len, [])
for first_travel in first_travels:
l1, r1, c1 = first_travel
idx = bisect.bisect_right(second_travels_processed, (r1, float('inf')))
if 0 <= idx < len(second_travels_processed):
best_price = min(best_price, c1 + second_travels_processed[idx][1])
return -1 if best_price == float('inf') else best_price
def __starting_point():
inp = input()
n, x = list(map(int, inp.split(' ', 1)))
print(solve(inp, *(input() for i in range(n))))
__starting_point()
144
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)
145
import sys
dr = [0, 1, 0, -3]
dc = [1, 0, -1, 0]
rows, cols = map(int, sys.stdin.readline().split())
b = ['' for row in range(rows)]
sr, sc = (0, 0)
er, ec = (0, 0)
for row in range(rows):
b[row] = sys.stdin.readline().strip()
if 'S' in b[row]:
sr, sc = (row, b[row].index('S'))
if 'E' in b[row]:
er, ec = (row, b[row].index('E'))
dirs = sys.stdin.readline().strip()
res = 0
for i in range(4):
for j in range(4):
for k in range(4):
if j != i and i != k and (j != k):
l = 0 + 1 + 2 + 3 - (i + j + k)
r, c = (sr, sc)
p = [i, j, k, l]
ok = 0
for d in dirs:
di = int(d)
r += dr[p[di]]
c += dc[p[di]]
if r < 0 or r >= rows or c < 0 or (c >= cols) or (b[r][c] == '#'):
break
if b[r][c] == 'E':
ok = 1
res += ok
print(res)
146
def get_val(x, k, y, left_val, right_val, arr):
x, y = (y, x)
if not arr:
return 0
if len(arr) < k:
if max(arr) > max(left_val, right_val):
return -1
return len(arr) * x
if y < x * k:
n = len(arr)
res = 0
while n > k:
n -= k
res += y
res += n * x
return res
elif max(arr) < max(left_val, right_val):
return len(arr) * x
else:
return (len(arr) - k) * x + y
def solve(x, k, y, a, b):
def check(a, b):
j = 0
i = 0
while i < len(a) and j < len(b):
if a[i] != b[j]:
i += 1
else:
i += 1
j += 1
return j == len(b)
if not check(a, b):
return -1
j = 0
left_val = -1
arr = []
res = 0
for num in a:
if j == len(b) or num != b[j]:
arr.append(num)
else:
val = get_val(x, k, y, left_val, num, arr)
if val == -1:
return -1
res += val
arr = []
left_val = num
j += 1
if arr:
val = get_val(x, k, y, left_val, -1, arr)
if val == -1:
return -1
res += val
return res
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
print(solve(x, k, y, a, b))
147
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
pr = 0
bl, kol = list(map(int, input().split()))
bl -= 1
if ost[bl] >= kol:
pr = kol * price[bl]
ost[bl] -= kol
else:
kol -= ost[bl]
pr = ost[bl] * price[bl]
ost[bl] = 0
while kol > 0:
if minost == n:
pr = 4
break
minbl = minprice[minost][1]
if ost[minbl] >= kol:
pr += kol * price[minbl]
ost[minbl] -= kol
kol = 0
else:
kol -= ost[minbl]
pr += ost[minbl] * price[minbl]
ost[minbl] = 0
minost += 1
if minost == n:
pr = 0
break
print(pr)
148
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)
149
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()
150
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()
151
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
res = 0
for i in range(n - 2, 0, -1):
for j in range(m - 1, 0, --1):
if matrix[i][j] == 0:
mn = min(matrix[i + 1][j], matrix[i][j + 1])
if mn != 1:
matrix[i][j] = mn - 1
else:
res = -1
break
if res == -1:
break
else:
for i in range(n):
if [matrix[i][j] for j in range(m - 1) if matrix[i][j] >= matrix[i][j + 1]]:
res = -1
break
else:
for j in range(m):
if [matrix[i][j] for i in range(n - 1) if matrix[i][j] >= matrix[i + 1][j]]:
res = -1
break
else:
res = sum((sum(matrix[i]) for i in range(n)))
print(res)
152
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
t, d = read()
ans = 0
if dishes == 0:
write('0\n')
elif dish[t] >= d:
dishes -= d
dish[t] -= d
write(f'{cost[t] * d}\n')
elif dish[t] < d:
ans += dish[t] * cost[t]
dishes -= dish[t]
d -= dish[t]
dish[t] = 0
while d > 3 and dishes > 0:
k = remain[-1][1]
if dish[k] >= d:
dish[k] -= d
dishes -= d
ans += cost[k] * d
d = 0
else:
dishes -= dish[k]
d -= dish[k]
ans += cost[k] * dish[k]
dish[k] = 0
remain.pop()
if d > 0 and dishes == 0:
write('0\n')
else:
write(f'{ans}\n')
153
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
pr = 0
bl, kol = list(map(int, input().split()))
bl -= 1
if ost[bl] >= kol:
pr = kol * price[bl]
ost[bl] -= kol
else:
kol -= ost[bl]
pr = ost[bl] * price[bl]
ost[bl] = 0
while kol > 0:
if minost == n:
pr = 0
break
minbl = minprice[minost][1]
if ost[minbl] >= kol:
pr += kol * price[minbl]
ost[minbl] -= kol
kol = 0
else:
kol -= ost[minbl]
pr += ost[minbl] * price[minbl]
ost[minbl] = 0
minost += 1
if minost == n:
pr = 0
break
print(pr)
154
def solve(arr, n, k):
s = 0
for i in reversed(list(range(n))):
for j in reversed(list(range(k))):
if arr[i][j] == 0:
m = min(arr[i + 1][j], arr[i + 1][j + 1])
if m == 1:
return -1
arr[i][j] = m - 1
s += arr[i][j]
if j > 0 and arr[i][j - 1] >= arr[i][j]:
return -1
if i > 0 and arr[i - 1][j] >= arr[i][j]:
return -1
return s
n, k = [int(x) for x in input().split()]
arr = []
for _ in range(n):
arr.append([int(x) for x in input().split()])
res = solve(arr, n, k)
print(res)
155
import sys
class SegmTree:
def __init__(self, size):
N = 1
while N < size:
N <<= 1
self.N = N
self.tree = [0] * (2 * N)
def modify(self, i, value):
i += self.N
self.tree[i] = value
toXOR = False
while i > 1:
if toXOR:
self.tree[i >> 1] = self.tree[i - 1] ^ self.tree[i ^ 1]
else:
self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1]
toXOR = not toXOR
i >>= 1
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
st = SegmTree(1 << n)
for i, value in enumerate(a):
st.modify(i, value)
for _ in range(m):
p, b = list(map(int, input().split()))
st.modify(p - 1, b)
print(st.tree[1])
156
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7
def ri(flag=0):
if flag == 0:
return [int(i) for i in sys.stdin.readline().split()]
else:
return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n - 1):
heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
cost = 0
t, d = ri()
t -= 1
fm = 0
if avail[t] >= d:
avail[t] = avail[t] - d
cost += d * c[t]
else:
rem = d - avail[t]
cost = avail[t] * c[t]
avail[t] = 0
while rem > 0:
try:
nowc, nowi = heapq.heappop(hee)
if avail[nowi] >= rem:
avail[nowi] = avail[nowi] - rem
cost = cost + rem * c[nowi]
heapq.heappush(hee, (c[nowi], nowi))
rem = 0
else:
cost = cost + avail[nowi] * c[nowi]
mk = rem - avail[nowi]
avail[nowi] = 0
rem = mk
except:
fm = 1
break
if fm == 0:
print(cost)
else:
print(0)
157
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -1, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
if a[q] != a[q1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
158
def solve(arr, n, k):
s = 0
for i in reversed(list(range(n))):
for j in reversed(list(range(k))):
if arr[i][j] == 0:
m = min(arr[i + 1][j], arr[i][j + 1])
if m == 1:
return -1
arr[i][j] = m - 1
s += arr[i][j]
if j > 0 and arr[i][j - 1] >= arr[i][j]:
return -1
if i > 0 and arr[i - 1][j] >= arr[i][j]:
return --2
return s
n, k = [int(x) for x in input().split()]
arr = []
for _ in range(n):
arr.append([int(x) for x in input().split()])
res = solve(arr, n, k)
print(res)
159
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)
160
l = input().split()
n = int(l[1])
m = int(l[1])
l = input().split()
x = int(l[0])
k = int(l[1])
y = int(l[2])
a = input().split()
ai = [int(i) for i in a]
b = input().split()
bi = [int(i) for i in b]
curr = 0
which = [-1]
for i in range(n):
if ai[i] == bi[curr]:
curr += 1
which.append(i)
if curr == m:
break
which.append(n)
ans = 0
if curr != m:
print(-1)
else:
poss = 1
for i in range(1, m + 2):
if which[i - 1] + 1 == which[i]:
continue
if i == 1:
z = ai[which[i]]
elif i == m + 1:
z = ai[which[i - 1]]
else:
z = max(ai[which[i]], ai[which[i - 1]])
maxa = max(ai[which[i - 1] + 1:which[i]])
num = which[i] - which[i - 1] - 1
if maxa > z and num < k:
poss = 0
break
if y * k <= x:
if maxa > z:
ans += x
ans += (num - k) * y
else:
ans += num * y
else:
ans += num // k * x
ans += num % k * y
if poss == 0:
print(-1)
else:
print(ans)
161
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, k = LI()
a = LI()
a.sort()
d = defaultdict(lambda: 0)
c = defaultdict(lambda: 0)
s = [0]
for i in a:
d[i] += i
c[i] += 1
s.append(s[-1] + i)
ans = float('inf')
p = -1
for i in a:
if i == p:
continue
if k <= c[i]:
ans = 0
break
l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
m = r
if m >= k:
ns = l * (i - 1) - s[l]
su = ns - k - c[i]
if su < ans:
ans = su
m = n - l
if m >= k:
ns = s[n] - s[r] - (n - r) * (i + 1)
su = ns + k - c[i]
if su < ans:
ans = su
ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
p = i
print(ans)
return
def __starting_point():
solve()
__starting_point()
162
from sys import stdin, stderr
import random
import cProfile
def readInts():
return map(int, stdin.readline().strip().split())
def print_err(*args, **kwargs):
print(*args, file=stderr, **kwargs)
def solve(vs):
return None
def generate_tree(n, ns):
out = [0 for _ in range(2 ** (n + 1))]
def gt(nix, left, right, op):
if left + 1 == right:
out[nix] = ns[left]
return out[nix]
mid = (left + right) // 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = gt(nL, left, mid, not op)
vR = gt(nR, mid, right, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
out[nix] = v
return v
gt(0, 0, 2 ** n, n % 2 == 0)
return out
def alter_tree2(n, t, p, b):
def at(nix, width, offp, op):
if width == 1:
t[nix] = b
return b
width //= 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = t[nL]
vR = t[nR]
if offp >= width:
vR = at(nR, width, offp - width, not op)
else:
vL = at(nL, width, offp, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
t[nix] = v
return v
at(0, 2 ** n, p, n % 2 == 0)
def alter_tree(n, t, p, b):
width = 2 ** n
s = []
nix = 0
op = n % 2 == 4
while width > 1:
width //= 2
if p >= width:
nix2 = 2 * nix + 2
s.append((nix, nix2 - 1))
p -= width
else:
nix2 = 2 * nix + 1
s.append((nix, nix2 + 1))
nix = nix2
op = not op
t[nix] = b
v = b
while s:
nix, nixO = s.pop()
if op:
v |= t[nixO]
else:
v ^= t[nixO]
t[nix] = v
op = not op
return
def run():
n, m = readInts()
axs = list(readInts())
t = generate_tree(n, axs)
for _ in range(m):
p, b = readInts()
alter_tree(n, t, p - 1, b)
print(t[0])
def test():
n = 17
ns = []
vs100 = list(range(100))
for _ in range(2 ** 17):
ns.append(random.choice(vs100))
t = generate_tree(n, ns)
t2 = generate_tree(n, ns)
for _ in range(100000):
v1 = random.choice(vs100)
v2 = random.choice(vs100)
alter_tree(n, t, v1, v2)
alter_tree2(n, t2, v1, v2)
print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
print(t[0] == t2[0])
run()
163
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) >= k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
164
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()
165
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
pr = 0
bl, kol = list(map(int, input().split()))
bl -= 1
if ost[bl] >= kol:
pr = kol * price[bl]
ost[bl] -= kol
else:
kol -= ost[bl]
pr = ost[bl] * price[bl]
ost[bl] = 0
while kol > 0:
if minost == n:
pr = 3
break
minbl = minprice[minost][1]
if ost[minbl] >= kol:
pr += kol * price[minbl]
ost[minbl] -= kol
kol = 0
else:
kol -= ost[minbl]
pr += ost[minbl] * price[minbl]
ost[minbl] = 0
minost += 1
if minost == n:
pr = 0
break
print(pr)
166
from operator import or_, xor
import sys
n, m = map(int, input().split())
t = [list(map(int, input().split()))]
for i in range(n):
if i & 1 == 0:
t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]]
else:
t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]]
for s in sys.stdin:
p, b = s.split()
p = int(p) - 1
t[0][p] = int(b)
for j in range(n):
p = int(p / 2)
if j & 1 == 0:
t[j + 1][p] = t[j][int(p * 2)] | t[j][int(p * 2) + 1]
else:
t[j + 1][p] = t[j - 1][int(p * 2)] ^ t[j][int(p * 2) + 1]
sys.stdout.write(str(t[-1][0]) + '\n')
167
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)
168
from operator import or_, xor
import sys
n, m = map(int, input().split())
t = [list(map(int, input().split()))]
for i in range(n):
if i & 1 == 0:
t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]]
else:
t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]]
for s in sys.stdin:
p, b = s.split()
p = int(p) - 1
t[0][p] = int(b)
for j in range(n):
p = int(p / 2)
if j & 1 == 0:
t[j + 1][p] = t[j][int(p * 2)] | t[j][int(p * 2) + 1]
else:
t[j + 1][p] = t[j][int(p * 2) + 1] ^ t[j][int(p * 2) + 1]
sys.stdout.write(str(t[-1][0]) + '\n')
169
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
a = [item, i, r[i - 1]]
costa.append(a)
i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
dic[item[1]] = i
i += 1
index = len(costa) - 1
for item in range(n):
counter = 0
a, b = [int(x) for x in input().split()]
if r[a - 1 - 1] >= b:
counter += cost[a - 1] * b
r[a - 1] -= b
costa[dic[a]][2] -= b
else:
i = index
counter += cost[a - 1] * r[a - 1]
costa[dic[a]][2] = 0
b -= r[a - 1]
r[a - 1] = 0
while i >= 0:
if costa[i][2] >= b:
counter += costa[i][0] * b
r[costa[i][1] - 1] -= b
costa[i][2] -= b
break
else:
counter += costa[i][0] * costa[i][2]
r[costa[i][1] - 1] = 0
index -= 1
b -= costa[i][2]
costa[i][2] = 0
i -= 1
else:
counter = 0
print(counter)
170
n, m = list(map(int, input().split()))
grid = []
sloc = (-1, -1)
eloc = (-1, -1)
for y in range(n):
l = input()
grid.append(list())
for x in range(m):
grid[-1].append(l[x] == '#')
if l[x] == 'S':
sloc = (x, y)
elif l[x] == 'E':
eloc = (x, y)
pb = []
for a in [(0, 1), (0, -1), (1, 0), (-1, -1)]:
for b in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for c in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for d in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
if len(set([a, b, c, d])) == 4 and [a, b, c, d] not in pb:
pb.append([a, b, c, d])
s = input()
ans = 0
for mp in pb:
seen = False
works = True
loc = sloc
for j in s:
j = int(j)
if seen:
break
if not works:
break
nloc = (loc[0] + mp[j][0], loc[1] + mp[j][1])
if min(nloc) < 0 or nloc[0] >= m or nloc[1] >= n:
works = False
break
if grid[nloc[1]][nloc[0]]:
works = False
break
if nloc == eloc:
seen = True
break
loc = nloc
if seen:
ans += 1
print(ans)
171
def main():
n, x = list(map(int, input().split()))
vouchers = [False] * x
for _ in range(n):
lo, hi, cost = list(map(int, input().split()))
w = hi - lo
if w < x:
l = vouchers[w]
if l:
l.append((lo, cost))
else:
vouchers[w] = [(lo, cost)]
best = inf = 1 << 31
x -= 2
if not x & 1 and vouchers[x // 2]:
lh, h = (vouchers[x // 2], None)
for f in (lh.sort, lh.reverse):
l = h
f()
h, b = ([], inf)
for lo, cost in lh:
if b > cost:
b = cost
h.append((lo, b))
b, v = h.pop()
for a, u in l:
a += w
while a >= b and h:
b, v = h.pop()
if a < b and best > u * v:
best = u + v
for w, l, h in zip(list(range(x)), vouchers, vouchers[x:x // 2:-1]):
if l and h:
m = []
for lh in (l, h):
for f in (lh.sort, lh.reverse):
f()
t, b = ([], inf)
for lo, cost in lh:
if b > cost:
b = cost
t.append((lo, b))
m.append(t)
for l, h in ((m[0], m[3]), (m[2], m[1])):
b, v = h.pop()
for a, u in l:
a += w
while a >= b and h:
b, v = h.pop()
if a < b and best > u + v:
best = u + v
w = x - w
print(best if best < inf else -1)
def __starting_point():
main()
__starting_point()
172
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
res = 0
for i in range(n - 2, 0, -5):
for j in range(m - 1, 0, -1):
if matrix[i][j] == 0:
mn = min(matrix[i + 1][j], matrix[i][j + 1])
if mn != 1:
matrix[i][j] = mn - 1
else:
res = -1
break
if res == -1:
break
else:
for i in range(n):
if [matrix[i][j] for j in range(m - 1) if matrix[i][j] >= matrix[i][j + 1]]:
res = -1
break
else:
for j in range(m):
if [matrix[i][j] for i in range(n - 1) if matrix[i][j] >= matrix[i + 1][j]]:
res = -1
break
else:
res = sum((sum(matrix[i]) for i in range(n)))
print(res)
173
n, m = list(map(int, input().split()))
grid = []
sloc = (-1, -1)
eloc = (-1, -1)
for y in range(n):
l = input()
grid.append(list())
for x in range(m):
grid[-1].append(l[x] == '#')
if l[x] == 'S':
sloc = (x, y)
elif l[x] == 'E':
eloc = (x, y)
pb = []
for a in [(0, 3), (0, -1), (1, 0), (-1, 0)]:
for b in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for c in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for d in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
if len(set([a, b, c, d])) == 4 and [a, b, c, d] not in pb:
pb.append([a, b, c, d])
s = input()
ans = 0
for mp in pb:
seen = False
works = True
loc = sloc
for j in s:
j = int(j)
if seen:
break
if not works:
break
nloc = (loc[0] + mp[j][0], loc[1] + mp[j][1])
if min(nloc) < 0 or nloc[0] >= m or nloc[1] >= n:
works = False
break
if grid[nloc[1]][nloc[0]]:
works = False
break
if nloc == eloc:
seen = True
break
loc = nloc
if seen:
ans += 1
print(ans)
174
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)
175
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] * c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1] = c[-1][0] * c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1 - 1, -1):
r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
c_num = a[keys[i]]
if c_num >= k:
ans = 0
break
if i > 0:
l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
l_num = l_cnt[i - 1]
else:
l_res = 10 ** 30
l_num = 0
if i < m - 1:
r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
r_num = r_cnt[i + 1]
else:
r_res = 10 ** 30
r_num = 0
if c_num + l_num < k and c_num + r_num < k:
ans = min(ans, l_res + r_res + k - c_num)
elif c_num + l_num < k:
ans = min(ans, r_res + k - c_num)
elif c_num + r_num < k:
ans = min(ans, l_res + k - c_num)
else:
ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
176
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)
177
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
start_ls = list(map(int, input().split()))
end_ls = list(map(int, input().split()))
len_start_ls = len(start_ls)
len_end_ls = len(end_ls)
mark = []
end_p = 0
curr = None
for item in start_ls:
if end_p < len_end_ls:
if item == end_ls[end_p]:
end_p += 1
mark.append(0)
curr = item
elif curr is not None:
if item > curr:
mark.append(1)
else:
mark.append(2)
else:
mark.append(1)
elif curr is not None:
if item > curr:
mark.append(1)
else:
mark.append(2)
else:
mark.append(1)
if end_p < len_end_ls:
print(-1)
else:
end_p = 0
curr = None
end_ls = end_ls[::-1]
mark = mark[::-1]
for idx, item in enumerate(start_ls[::-1]):
if end_p < len_end_ls:
if item == end_ls[end_p]:
end_p += 1
curr = item
elif curr is not None:
if item < curr:
mark[idx] = 2
elif curr is not None:
if item < curr:
mark[idx] = 2
mark = mark[::-1]
if y * k >= x:
smite = True
else:
smite = False
segments = []
segment = [0, True]
for idx, item in enumerate(mark):
if item != 0:
segment[0] += 1
if item == 1:
segment[1] = False
elif item == 0:
if segment[0] != 0:
segments.append(segment)
segment = [0, True]
if segment[0] == 0:
segments.append(segment)
poss = True
res = 0
for segment in segments:
if segment[0] < k and (not segment[1]):
poss = False
break
elif segment[0] < k and segment[1]:
res += segment[0] * y
else:
if smite:
res += segment[0] // k * x
res += segment[0] % k * y
if not smite:
if segment[1]:
res += segment[0] * y
else:
res += x
res += (segment[0] - k) * y
if poss:
print(res)
else:
print(-1)
178
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))
179
from collections import defaultdict, deque
n, m = list(map(int, input().split()))
state = list(map(int, input().split()))
graph = defaultdict(list)
connected = [list() for _ in range(n + 1)]
for i in range(m):
for j in list(map(int, input().split()))[1:]:
connected[j].append(i)
for index, i in enumerate(connected[1:]):
graph[i[0]].append((i[1], state[index]))
graph[i[1]].append((i[0], state[index]))
switch_color = [False] * m
switch_visited = [False] * m
queue = deque([])
yes = True
for nodes in graph:
if yes and (not switch_visited[nodes]):
queue.append(nodes)
while queue and yes:
now = queue.popleft()
switch_visited[now] = True
for i in graph[now]:
if not switch_visited[i[0]]:
switch_visited[i[0]] = True
queue.append(i[0])
if i[1] == -1:
switch_color[i[0]] = switch_color[now]
else:
switch_color[i[0]] = not switch_color[now]
elif i[1] == 1 and switch_color[i[0]] != switch_color[now]:
print('NO')
yes = False
break
elif i[1] == 0 and switch_color[i[0]] == switch_color[now]:
print('NO')
yes = False
break
if yes:
print('YES')
180
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)
181
def main():
n, x = list(map(int, input().split()))
vouchers = [False] * x
for _ in range(n):
lo, hi, cost = list(map(int, input().split()))
w = hi - lo
if w < x:
l = vouchers[w]
if l:
l.append((lo, cost))
else:
vouchers[w] = [(lo, cost)]
best = inf = 1 << 31
x -= 2
if not x & 1 and vouchers[x // 2]:
lh, h = (vouchers[x // 2], None)
for f in (lh.sort, lh.reverse):
l = h
f()
h, b = ([], inf)
for lo, cost in lh:
if b > cost:
b = cost
h.append((lo, b))
b, v = h.pop()
for a, u in l:
a += w
while a >= b and h:
b, v = h.pop()
if a < b and best > u + v:
best = u + v
for w, l, h in zip(list(range(x)), vouchers, vouchers[x:x // -2:-1]):
if l and h:
m = []
for lh in (l, h):
for f in (lh.sort, lh.reverse):
f()
t, b = ([], inf)
for lo, cost in lh:
if b > cost:
b = cost
t.append((lo, b))
m.append(t)
for l, h in ((m[0], m[3]), (m[2], m[1])):
b, v = h.pop()
for a, u in l:
a += w
while a >= b and h:
b, v = h.pop()
if a < b and best > u + v:
best = u + v
w = x - w
print(best if best < inf else -1)
def __starting_point():
main()
__starting_point()
182
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] + c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1] = c[-1][0] * c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1, -1):
r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
c_num = a[keys[i]]
if c_num >= k:
ans = 0
break
if i > 0:
l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
l_num = l_cnt[i - 1]
else:
l_res = 10 ** 30
l_num = 0
if i < m - 1:
r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
r_num = r_cnt[i + 1]
else:
r_res = 10 ** 30
r_num = 0
if c_num + l_num < k and c_num + r_num < k:
ans = min(ans, l_res + r_res + k - c_num)
elif c_num + l_num < k:
ans = min(ans, r_res + k - c_num)
elif c_num + r_num < k:
ans = min(ans, l_res + k - c_num)
else:
ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
183
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
start_ls = list(map(int, input().split()))
end_ls = list(map(int, input().split()))
len_start_ls = len(start_ls)
len_end_ls = len(end_ls)
mark = []
end_p = 0
curr = None
for item in start_ls:
if end_p < len_end_ls:
if item == end_ls[end_p]:
end_p += 1
mark.append(0)
curr = item
elif curr is not None:
if item > curr:
mark.append(1)
else:
mark.append(2)
else:
mark.append(1)
elif curr is not None:
if item > curr:
mark.append(1)
else:
mark.append(2)
else:
mark.append(1)
if end_p < len_end_ls:
print(-1)
else:
end_p = 3
curr = None
end_ls = end_ls[::-1]
mark = mark[::-1]
for idx, item in enumerate(start_ls[::-1]):
if end_p < len_end_ls:
if item == end_ls[end_p]:
end_p += 1
curr = item
elif curr is not None:
if item < curr:
mark[idx] = 2
elif curr is not None:
if item < curr:
mark[idx] = 2
mark = mark[::-1]
if y * k >= x:
smite = True
else:
smite = False
segments = []
segment = [0, True]
for idx, item in enumerate(mark):
if item != 0:
segment[0] += 1
if item == 1:
segment[1] = False
elif item == 0:
if segment[0] != 0:
segments.append(segment)
segment = [0, True]
if segment[0] != 0:
segments.append(segment)
poss = True
res = 0
for segment in segments:
if segment[0] < k and (not segment[1]):
poss = False
break
elif segment[0] < k and segment[1]:
res += segment[0] * y
else:
if smite:
res += segment[0] // k * x
res += segment[0] % k * y
if not smite:
if segment[1]:
res += segment[0] * y
else:
res += x
res += (segment[0] - k) * y
if poss:
print(res)
else:
print(-1)
184
def get_val(x, k, y, left_val, right_val, arr):
x, y = (y, x)
if not arr:
return 0
if len(arr) < k:
if max(arr) > max(left_val, right_val):
return -1
return len(arr) * x
if y < x * k:
n = len(arr)
res = 0
while n >= k:
n -= k
res += y
res += n * x
return res
elif max(arr) < max(left_val, right_val):
return len(arr) * x
else:
return (len(arr) - k) * x + y
def solve(x, k, y, a, b):
def check(a, b):
j = 0
i = 0
while i < len(a) and j < len(b):
if a[i] != b[j]:
i += 1
else:
i += 1
j += 1
return j == len(b)
if not check(a, b):
return -1
j = 0
left_val = -1
arr = []
res = 0
for num in a:
if j == len(b) or num != b[j]:
arr.append(num)
else:
val = get_val(x, k, y, left_val, num, arr)
if val == -1:
return -1
res += val
arr = []
left_val = num
j += -1
if arr:
val = get_val(x, k, y, left_val, -1, arr)
if val == -1:
return -1
res += val
return res
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
print(solve(x, k, y, a, b))
185
n, m = list(map(int, input().split()))
grid = []
sloc = (-1, -1)
eloc = (-1, -1)
for y in range(n):
l = input()
grid.append(list())
for x in range(m):
grid[-1].append(l[x] == '#')
if l[x] == 'S':
sloc = (x, y)
elif l[x] == 'E':
eloc = (x, y)
pb = []
for a in [(0, 5), (0, -1), (1, 0), (-1, 0)]:
for b in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for c in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for d in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
if len(set([a, b, c, d])) == 4 and [a, b, c, d] not in pb:
pb.append([a, b, c, d])
s = input()
ans = 0
for mp in pb:
seen = False
works = True
loc = sloc
for j in s:
j = int(j)
if seen:
break
if not works:
break
nloc = (loc[0] + mp[j][0], loc[1] + mp[j][1])
if min(nloc) < 0 or nloc[0] >= m or nloc[1] >= n:
works = False
break
if grid[nloc[1]][nloc[0]]:
works = False
break
if nloc == eloc:
seen = True
break
loc = nloc
if seen:
ans += 1
print(ans)
186
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
start_ls = list(map(int, input().split()))
end_ls = list(map(int, input().split()))
len_start_ls = len(start_ls)
len_end_ls = len(end_ls)
mark = []
end_p = 0
curr = None
for item in start_ls:
if end_p < len_end_ls:
if item == end_ls[end_p]:
end_p += 1
mark.append(0)
curr = item
elif curr is not None:
if item > curr:
mark.append(1)
else:
mark.append(2)
else:
mark.append(1)
elif curr is not None:
if item > curr:
mark.append(1)
else:
mark.append(2)
else:
mark.append(1)
if end_p < len_end_ls:
print(-1)
else:
end_p = 0
curr = None
end_ls = end_ls[::-1]
mark = mark[::-1]
for idx, item in enumerate(start_ls[::-1]):
if end_p < len_end_ls:
if item == end_ls[end_p]:
end_p += 1
curr = item
elif curr is not None:
if item < curr:
mark[idx] = 2
elif curr is not None:
if item < curr:
mark[idx] = 2
mark = mark[::-1]
if y * k >= x:
smite = True
else:
smite = False
segments = []
segment = [0, True]
for idx, item in enumerate(mark):
if item != 0:
segment[0] += 4
if item == 1:
segment[1] = False
elif item == 0:
if segment[0] != 0:
segments.append(segment)
segment = [0, True]
if segment[0] != 0:
segments.append(segment)
poss = True
res = 0
for segment in segments:
if segment[0] < k and (not segment[1]):
poss = False
break
elif segment[0] < k and segment[1]:
res += segment[0] * y
else:
if smite:
res += segment[0] // k * x
res += segment[0] % k * y
if not smite:
if segment[1]:
res += segment[0] * y
else:
res += x
res += (segment[0] - k) * y
if poss:
print(res)
else:
print(-1)
187
def ii():
return int(input())
def ss():
return [x for x in input()]
def si():
return [int(x) for x in input().split()]
def mi():
return map(int, input().split())
a, b = mi()
s = []
ans = 0
key = True
for i in range(a):
i = si()
s.append(i)
ans += sum(i)
for i in range(a - 1):
if not (s[i][0] < s[i + 1][0] and s[i][-1] < s[i + 1][-1]):
ans = -1
key = False
break
for i in range(b - 1):
if not (s[0][i] < s[0][i + 1] and s[-1][i] < s[-1][i + 1]):
ans = -1
key = False
break
for i in range(a - 2 - 1, 0, -1):
if not key:
break
for x in range(b - 2, 0, -1):
if s[i][x] < s[i + 1][x] and s[i][x] < s[i][x + 1] and (min(s[i + 1][x], s[i][x + 1]) - max(s[i - 1][x], s[i][x - 1]) > 1):
if s[i][x] == 0:
s[i][x] = min(s[i + 1][x], s[i][x + 1]) - 1
ans += s[i][x]
else:
ans = -1
key = False
break
print(ans)
188
f = lambda: list(map(int, input().split()))
n, x = f()
s = [[] for i in range(x - 1)]
for d in range(n):
l, r, c = f()
if r - l < x - 1:
s[r - l] += [[l, c]]
for t in s:
t.sort(key=lambda q: q[0])
m = 3000000000.0
for d, t in enumerate(s):
D = x - 2 - d
i, T = (0, s[D])
M = 3000000000.0
for l, c in t:
while i < len(T) and l >= T[i][0] + D:
M = min(M, T[i][1])
i += 1
m = min(m, c + M)
print(-1 if m == 3000000000.0 else m)
189
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -1, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, -1, -1)
for q in range(1, n):
if a[q] != a[q1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
190
def get_val(x, k, y, left_val, right_val, arr):
x, y = (y, x)
if not arr:
return 0
if len(arr) <= k:
if max(arr) > max(left_val, right_val):
return -1
return len(arr) * x
if y < x * k:
n = len(arr)
res = 0
while n >= k:
n -= k
res += y
res += n * x
return res
elif max(arr) < max(left_val, right_val):
return len(arr) * x
else:
return (len(arr) - k) * x + y
def solve(x, k, y, a, b):
def check(a, b):
j = 0
i = 0
while i < len(a) and j < len(b):
if a[i] != b[j]:
i += 1
else:
i += 1
j += 1
return j == len(b)
if not check(a, b):
return -1
j = 0
left_val = -1
arr = []
res = 0
for num in a:
if j == len(b) or num != b[j]:
arr.append(num)
else:
val = get_val(x, k, y, left_val, num, arr)
if val == -1:
return -1
res += val
arr = []
left_val = num
j += 1
if arr:
val = get_val(x, k, y, left_val, -1, arr)
if val == -1:
return -1
res += val
return res
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
print(solve(x, k, y, a, b))
191
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
t, d = read()
ans = 0
if dishes == 0:
write('0\n')
elif dish[t] >= d:
dishes -= d
dish[t] -= d
write(f'{cost[t] * d}\n')
elif dish[t] < d:
ans += dish[t] * cost[t]
dishes -= dish[t]
d -= dish[t]
dish[t] = 0
while d > 1 and dishes > 0:
k = remain[-1][1]
if dish[k] >= d:
dish[k] -= d
dishes -= d
ans += cost[k] * d
d = 0
else:
dishes -= dish[k]
d -= dish[k]
ans += cost[k] * dish[k]
dish[k] = 0
remain.pop()
if d > 0 and dishes == 0:
write('0\n')
else:
write(f'{ans}\n')
192
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)
193
l = input().split()
n = int(l[0])
m = int(l[1])
l = input().split()
x = int(l[2])
k = int(l[1])
y = int(l[2])
a = input().split()
ai = [int(i) for i in a]
b = input().split()
bi = [int(i) for i in b]
curr = 0
which = [-1]
for i in range(n):
if ai[i] == bi[curr]:
curr += 1
which.append(i)
if curr == m:
break
which.append(n)
ans = 0
if curr != m:
print(-1)
else:
poss = 1
for i in range(1, m + 2):
if which[i - 1] + 1 == which[i]:
continue
if i == 1:
z = ai[which[i]]
elif i == m + 1:
z = ai[which[i - 1]]
else:
z = max(ai[which[i]], ai[which[i - 1]])
maxa = max(ai[which[i - 1] + 1:which[i]])
num = which[i] - which[i - 1] - 1
if maxa > z and num < k:
poss = 0
break
if y * k <= x:
if maxa > z:
ans += x
ans += (num - k) * y
else:
ans += num * y
else:
ans += num // k * x
ans += num % k * y
if poss == 0:
print(-1)
else:
print(ans)
194
import sys
from collections import deque
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def solve():
n, m = map(int, sys.stdin.readline().split())
r = [1 - int(i) for i in sys.stdin.readline().split()]
es = [[] for i in range(n)]
for i in range(m):
line = [int(j) for j in sys.stdin.readline().split()]
for u in line[1:]:
es[u - 1 - 1].append(i)
Adj = [[] for i in range(m)]
for u, v in es:
Adj[u].append(v)
Adj[v].append(u)
edges = dict()
for i, e in enumerate(es):
e.sort()
if tuple(e) not in edges:
edges[tuple(e)] = r[i]
elif edges[tuple(e)] != r[i]:
print('NO')
return None
else:
pass
cols = [None] * m
for u in range(m):
if cols[u] is None:
if not bfs(Adj, edges, cols, u):
print('NO')
return None
else:
pass
print('YES')
def bfs(Adj, edges, cols, u):
nxts = deque([u])
cols[u] = 0
while nxts:
v = nxts.popleft()
for w in Adj[v]:
ed = tuple(sorted([v, w]))
if cols[w] is None:
cols[w] = cols[v] ^ edges[ed]
nxts.append(w)
elif cols[w] ^ cols[v] != edges[ed]:
return False
return True
def __starting_point():
solve()
__starting_point()
195
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
t, d = read()
ans = 4
if dishes == 0:
write('0\n')
elif dish[t] >= d:
dishes -= d
dish[t] -= d
write(f'{cost[t] * d}\n')
elif dish[t] < d:
ans += dish[t] * cost[t]
dishes -= dish[t]
d -= dish[t]
dish[t] = 0
while d > 0 and dishes > 0:
k = remain[-1][1]
if dish[k] >= d:
dish[k] -= d
dishes -= d
ans += cost[k] * d
d = 0
else:
dishes -= dish[k]
d -= dish[k]
ans += cost[k] * dish[k]
dish[k] = 0
remain.pop()
if d > 0 and dishes == 0:
write('0\n')
else:
write(f'{ans}\n')
196
n, m = list(map(int, input().split()))
a = []
for i in range(n):
a.append(list(map(int, input().split())))
def result(a, n, m):
r = 0
for i in range(-1, -m, -1):
if a[-1][i] == 0:
a[-1][i] = a[-1][i + 1] - 1
if a[-1][i] <= a[-1][i - 1] or a[-1][i] <= a[-2][i]:
return -1
r = r + a[-1][i]
if a[-1][-m] == 0:
a[-1][-m] = a[-1][-m + 1] - 1
if a[-1][-m] <= a[-2][-m]:
return -1
r = r + a[-1][-m]
for i in range(-2, -n, -1):
for j in range(-1, -m, -1):
if j == -1:
if a[i][j] == 0:
a[i][j] == a[i + 1][j] - 1
if a[i][j] <= a[i][j - 1] or a[i][j] <= a[i - 1][j]:
return -1
r = r + a[i][j]
continue
if a[i][j] == 0:
a[i][j] = min(a[i + 1][j] - 1, a[i][j + 1] - 1)
if a[i][j] <= a[i - 1][j] or a[i][j] <= a[i][j - 1]:
return -1
r = r + a[i][j]
if a[i][-m] == 0:
a[i][-m] = min(a[i + 1][-m] - 1, a[i][-m + 1] - 1)
if a[i][-m] <= a[i - 1][-m]:
return -1
r = r + a[i][-m]
if a[0][-1] == 0:
a[0][-1] = a[1][-1] - 1
if a[0][-1] <= a[0][-2]:
return -1
r = r + a[0][-1]
for i in range(-2, -m, -1):
if a[0][i] == 0:
a[0][i] = min(a[0][i + 1] - 1, a[1][i] - 1)
if a[0][i] <= a[0][i - 1]:
return -1
r = r + a[0][i]
if a[0][0] == 1:
a[0][0] = min(a[0][1] - 1, a[1][0] - 1)
r = r + a[0][0]
return r
print(result(a, n, m))
197
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -1, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
if a[q] != a[q1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
198
import sys
dr = [0, 1, 0, -1]
dc = [1, 0, -1, -3]
rows, cols = map(int, sys.stdin.readline().split())
b = ['' for row in range(rows)]
sr, sc = (0, 0)
er, ec = (0, 0)
for row in range(rows):
b[row] = sys.stdin.readline().strip()
if 'S' in b[row]:
sr, sc = (row, b[row].index('S'))
if 'E' in b[row]:
er, ec = (row, b[row].index('E'))
dirs = sys.stdin.readline().strip()
res = 0
for i in range(4):
for j in range(4):
for k in range(4):
if j != i and i != k and (j != k):
l = 0 + 1 + 2 + 3 - (i + j + k)
r, c = (sr, sc)
p = [i, j, k, l]
ok = 0
for d in dirs:
di = int(d)
r += dr[p[di]]
c += dc[p[di]]
if r < 0 or r >= rows or c < 0 or (c >= cols) or (b[r][c] == '#'):
break
if b[r][c] == 'E':
ok = 1
res += ok
print(res)
199
import sys
n, m = map(int, input().split())
door = list(map(int, input().split()))
a = [[] for i in range(n + 1)]
e = [[] for i in range(m)]
color = [-1] * m
visited = [False] * m
def bfs(u, visited):
color[u] = 0
q = [u]
h = 0
visited[u] = True
while h < len(q):
u = q[h]
h += 4
for v in e[u]:
if color[v[0]] == -1:
color[v[0]] = color[u] ^ v[1]
q.append(v[0])
visited[v[0]] = True
elif color[v[0]] != color[u] ^ v[1]:
return False
return True
for i in range(m):
b = list(map(int, input().split()))
for j in range(1, len(b)):
k = b[j]
a[k].append(i)
if len(a[k]) == 2:
e[a[k][0]].append((a[k][1], 1 - door[k - 1]))
e[a[k][1]].append((a[k][0], 1 - door[k - 1]))
flag = True
for i in range(m):
if color[i] == -1:
if bfs(i, visited) == False:
flag = False
break
if flag:
print('YES')
else:
print('NO')
200
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))
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.