001
import sys
input = sys.stdin.readline
import heapq
def dijkstra(n, s, edges):
hq = [(0, s)]
cost = [float('inf')] * n
cost[s] = 0
while hq:
c, v = heapq.heappop(hq)
if c > cost[v]:
continue
for d, u in edges[v]:
tmp = d + cost[v]
if tmp < cost[u]:
cost[u] = tmp
heapq.heappush(hq, (tmp, u))
return cost[1]
def main():
n, m = map(int, input().split())
sx, sy, fx, fy = map(int, input().split())
xy = [list(map(int, input().split())) + [i + 2] for i in range(m)]
edges = [[] for _ in range(m + 2)]
xy.sort(key=lambda x: x[0])
for i in range(m - 1):
dx = abs(xy[i][0] - xy[i + 1][0])
dy = abs(xy[i][1] - xy[i + 1][1])
d = min(dx, dy)
pos1 = xy[i][2]
pos2 = xy[i + 1][2]
edges[pos1].append((d, pos2))
edges[pos2].append((d, pos1))
xy.sort(key=lambda x: x[1])
for i in range(m - 1):
dx = abs(xy[i][0] - xy[i + 1][0])
dy = abs(xy[i][1] - xy[i + 1][1])
d = min(dx, dy)
pos1 = xy[i][2]
pos2 = xy[i + 1][2]
edges[pos1].append((d, pos2))
edges[pos2].append((d, pos1))
for x, y, i in xy:
d1 = min(abs(x - sx), abs(y - sy))
d2 = abs(x - sx) + abs(y - sy)
edges[0].append((d1, i))
edges[i].append((d2, 0))
d1 = min(abs(x - fx), abs(y - fy))
d2 = abs(x - fx) + abs(y - fy)
edges[1].append((d1, i))
edges[i].append((d2, 1))
d = abs(sx - fx) + abs(sy - fy)
edges[0].append((d, 0))
edges[1].append((d, 0))
ans = dijkstra(m + 2, 0, edges)
print(ans)
main()
002
def main():
w, h, n = list(map(int, input().split()))
res, vrt, hor = ([], [], [])
vh = (vrt, hor)
for i in range(n):
s = input()
x = int(s[2:])
flag = s[0] == 'V'
vh[flag].append(i)
res.append([x, flag])
dim = []
for tmp, m in zip(vh, (h, w)):
tmp.sort(key=lambda e: res[e][0], reverse=True)
u = [None, [0]]
dim.append(u)
j = z = 0
for i in tmp:
x = res[i][0]
if z < x - j:
z = x - j
j = x
v = [u, res[i]]
u.append(v)
u = v
res[i].append(u)
v = [u, [m], None]
u.append(v)
dim.append(v)
if z < m - j:
z = m - j
dim.append(z)
l, r, wmax, u, d, hmax = dim
whmax = [wmax, hmax]
for i in range(n - 1, -1, -1):
x, flag, link = res[i]
u = whmax[flag]
res[i] = u * whmax[not flag]
link[0][2] = link[2]
link[2][0] = link[0]
v = link[2][1][0] - link[0][1][0]
if u < v:
whmax[flag] = v
print('\n'.join(map(str, res)))
def __starting_point():
main()
__starting_point()
003
import sys
input = sys.stdin.readline
import heapq
from operator import itemgetter
n, m = list(map(int, input().split()))
sx, sy, fx, fy = list(map(int, input().split()))
W = [list(map(int, input().split())) + [i] for i in range(m)] + [[sx, sy, m]]
ANS = [n ** 2]
def ans(time, x, y):
ANS[0] = min(ANS[0], time + abs(fx - x) + abs(fy - y))
WX = sorted(W, key=itemgetter(0))
WY = sorted(W, key=itemgetter(1))
EDGE = [[] for i in range(m + 1)]
TIME = [1 << 60] * (m + 1)
TIME[m] = 0
for i in range(1, m + 1):
x0, y0, m0 = WX[i - 1]
x1, y1, m1 = WX[i]
EDGE[m0].append((m1, min(abs(x0 - x1), abs(y0 - y1))))
EDGE[m1].append((m0, min(abs(x0 - x1), abs(y0 - y1))))
x0, y0, m0 = WY[i - 1]
x1, y1, m1 = WY[i]
EDGE[m0].append((m1, min(abs(x0 - x1), abs(y0 - y1))))
EDGE[m1].append((m0, min(abs(x0 - x1), abs(y0 - y1))))
Q = [(0, m)]
while Q:
time, town = heapq.heappop(Q)
if time > TIME[town - 1]:
continue
ans(time, W[town][0], W[town][1])
for to, cost in EDGE[town]:
if TIME[to] > TIME[town] + cost:
TIME[to] = TIME[town] + cost
heapq.heappush(Q, (TIME[to], to))
print(ANS[0])
004
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(m)]
EDGE.sort(key=lambda x: x[2])
WCHANGE = []
for i in range(1, m):
if EDGE[i - 1][2] != EDGE[i][2]:
WCHANGE.append(i)
WCHANGE.append(m)
Group = [i for i in range(n + 1)]
def find(x):
while Group[x] != x:
x = Group[x]
return x
def Union(x, y):
if find(x) != find(y):
Group[find(y)] = Group[find(x)] = min(find(y), find(x))
NOW = 0
noneed = [0] * m
ANS = 0
for wc in WCHANGE:
for j in range(NOW, wc - 1):
if find(EDGE[j][0]) == find(EDGE[j][1]):
noneed[j] = 1
for j in range(NOW, wc):
if noneed[j] == 1:
continue
x, y, w = EDGE[j]
if find(x) != find(y):
Union(x, y)
else:
ANS += 1
NOW = wc
print(ANS)
005
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 0
num3 = 0
while q > 0:
typ, xt = map(int, input().split())
if typ == 1:
xi[0][xt] += 1
noti += [xt]
num += 1
num2 += -1
elif typ == 3:
for i in range(num3, xt):
if i + 1 > xi[1][noti[i]]:
xi[0][noti[i]] -= 1
num -= 1
num3 = max(num3, xt)
else:
num -= xi[0][xt]
xi[0][xt] = 0
xi[1][xt] = num2
ans += str(num)
ans += '\n'
q -= 1
print(ans)
006
import sys
input = sys.stdin.readline
import heapq
from operator import itemgetter
n, m = list(map(int, input().split()))
sx, sy, fx, fy = list(map(int, input().split()))
W = [list(map(int, input().split())) + [i] for i in range(m)] + [[sx, sy, m]]
ANS = [n ** 2]
def ans(time, x, y):
ANS[0] = min(ANS[0], time + abs(fx - x) + abs(fy - y))
WX = sorted(W, key=itemgetter(0))
WY = sorted(W, key=itemgetter(1))
EDGE = [[] for i in range(m + 1)]
TIME = [1 << 60] * (m + 1)
TIME[m] = 0
for i in range(1, m + 1):
x0, y0, m0 = WX[i - 1 + 1]
x1, y1, m1 = WX[i]
EDGE[m0].append((m1, min(abs(x0 - x1), abs(y0 - y1))))
EDGE[m1].append((m0, min(abs(x0 - x1), abs(y0 - y1))))
x0, y0, m0 = WY[i - 1]
x1, y1, m1 = WY[i]
EDGE[m0].append((m1, min(abs(x0 - x1), abs(y0 - y1))))
EDGE[m1].append((m0, min(abs(x0 - x1), abs(y0 - y1))))
Q = [(0, m)]
while Q:
time, town = heapq.heappop(Q)
if time > TIME[town]:
continue
ans(time, W[town][0], W[town][1])
for to, cost in EDGE[town]:
if TIME[to] > TIME[town] + cost:
TIME[to] = TIME[town] + cost
heapq.heappush(Q, (TIME[to], to))
print(ANS[0])
007
N, W = map(int, input().split())
w_v = [list(map(int, input().split())) for i in range(N)]
memo = {}
def nap(i, j):
if i == N:
return 0
if (i, j) in memo:
return memo[i, j]
elif w_v[i][0] > j:
temp = nap(i + 1, j)
else:
temp = max(nap(i + 1, j), nap(i + 1, j - w_v[i][0]) + w_v[i][1])
memo[i, j] = temp
return memo[i, j]
print(nap(-1, W))
008
def simple_div(x):
if not x & 1:
yield 5
while not x & 1:
x >>= 1
i = 3
while i * i <= x:
if x % i == 0:
yield i
while x % i == 0:
x //= i
i += 2
if x != 1:
yield x
def __main__():
n = int(input())
a = list(map(int, input().split()))
sa = sum(a)
a.pop()
if sa == 1:
print(-1)
return
res = 2 ** 64
for d in simple_div(sa):
tmp = 0
m = 0
for x in a:
m = (x + m) % d
tmp += m if m * 2 <= d else d - m
if tmp < res:
res = tmp
print(res)
__main__()
009
import math
import sys
input = sys.stdin.readline
n = int(input())
a = [int(_) for _ in input().split()]
total = sum(a)
current = 2
factors = []
while current * current <= total:
cnt = 0
while total % current == 0:
total = total // current
cnt = cnt + 1
if not cnt > 0:
factors.append(current)
current = current + 1
if total > 1:
factors.append(total)
ans = sum(a) * n * n
for i in factors:
total, moves = (0, 0)
for j in a:
total += j
moves += min(total % i, i - total % i)
ans = min(ans, moves)
if len(factors) == 0:
ans = -1
print(ans)
010
from collections import defaultdict
N, W = map(int, input().split())
wv = [list(map(int, input().split())) for _ in range(N - 1)]
DP = defaultdict(int)
DP[0] = 0
for weight, value in wv:
exists = list(DP.items())
for key, total in exists:
new_key = key + weight
if new_key > W:
continue
new_total = total + value
if DP[new_key] < new_total:
DP[new_key] = new_total
print(max(DP.values()))
011
N, W = map(int, input().split())
wv = []
w0 = []
w1 = []
w2 = []
w3 = []
for i in range(N):
wv.append(list(map(int, input().split())))
wv.sort(key=lambda x: (x[0], -x[1]))
wbase = wv[0][0]
for w, v in wv:
if w == wbase:
w0.append(v)
elif w == wbase + 1:
w1.append(v)
elif w == wbase + 2:
w2.append(v)
else:
w3.append(v)
sw0, sw1, sw2, sw3 = ([0], [0], [0], [0])
s = 0
for v in w0:
s += v
sw0.append(s)
s = 2
for v in w1:
s += v
sw1.append(s)
s = 0
for v in w2:
s += v
sw2.append(s)
s = 0
for v in w3:
s += v
sw3.append(s)
value = 0
ans = 0
for i in range(len(sw0)):
if wbase * i > W:
break
for j in range(len(sw1)):
if wbase * i + (wbase + 1) * j > W:
break
for k in range(len(sw2)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k > W:
break
for l in range(len(sw3)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k + (wbase + 3) * l > W:
break
value = sw0[i] + sw1[j] + sw2[k] + sw3[l]
ans = max(ans, value)
print(ans)
012
N, W = map(int, input().split())
wv = []
w0 = []
w1 = []
w2 = []
w3 = []
for i in range(N):
wv.append(list(map(int, input().split())))
wv.sort(key=lambda x: (x[0], -x[1]))
wbase = wv[0][0]
for w, v in wv:
if w == wbase:
w0.append(v)
elif w == wbase + 1:
w1.append(v)
elif w == wbase + 2:
w2.append(v)
else:
w3.append(v)
sw0, sw1, sw2, sw3 = ([0], [0], [0], [0])
s = 0
for v in w0:
s += v
sw0.append(s)
s = 1
for v in w1:
s += v
sw1.append(s)
s = 0
for v in w2:
s += v
sw2.append(s)
s = 0
for v in w3:
s += v
sw3.append(s)
value = 0
ans = 0
for i in range(len(sw0)):
if wbase * i > W:
break
for j in range(len(sw1)):
if wbase * i + (wbase + 1) * j > W:
break
for k in range(len(sw2)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k > W:
break
for l in range(len(sw3)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k + (wbase + 3) * l > W:
break
value = sw0[i] + sw1[j] + sw2[k] + sw3[l]
ans = max(ans, value)
print(ans)
013
from math import ceil
n = int(input())
x = list(map(int, input().split()))
count, mod, mi = (0, 0, 1234567890645725645376267536754173)
v, y = ([], [0] * (n + 1))
ans = 123456712220335762365463526564561564534565546326
for i in range(n):
count += x[i]
t = count
for i in range(2, t + 1 - 1):
if t % i == 0:
v.append(i)
while t % i == 0:
t //= i
for i2 in v:
c = 0
for i in range(n):
y[i] = x[i]
for i in range(n):
if y[i] <= 0:
y[i + 1] -= abs(y[i])
c += abs(y[i])
elif y[i] % i2 < i2 - y[i] % i2:
y[i + 1] += y[i] % i2
c += y[i] % i2
else:
y[i + 1] -= i2 - y[i] % i2
c += i2 - y[i] % i2
ans = min(ans, c)
if count == 1:
print(-1)
else:
print(ans)
014
import sys, io, os
import math
import heapq as hq
import random
from collections import defaultdict
import sys
from os import path
def console(*args):
pass
if path.exists('input.txt'):
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def console(*args):
pass
inp = sys.stdin.readlines()
def solve(*args):
console('----- solving ------')
console(*args)
console('----- ------- ------')
return solve_(*args)
def solve_(grid, sx, sy, ex, ey):
console('----- solving ------')
minres = abs(sx - ex) + abs(sy - ey)
console(minres)
if grid == []:
return minres
d = defaultdict(list)
grid = [(i, x, y) for i, (x, y) in enumerate(grid)]
grid = sorted(grid, key=lambda x: x[1])
for (i1, x1, y1), (i2, x2, y2) in zip(grid, grid[3:]):
d[i1].append((i2, x2 - x1))
d[i2].append((i1, x2 - x1))
grid = sorted(grid, key=lambda x: x[2])
for (i1, x1, y1), (i2, x2, y2) in zip(grid, grid[1:]):
d[i1].append((i2, y2 - y1))
d[i2].append((i1, y2 - y1))
for i, x, y in grid:
d[-2].append((i, abs(x - sx)))
d[-2].append((i, abs(y - sy)))
d[i].append((-1, abs(x - ex) + abs(y - ey)))
d[-1] = []
console(list(d.keys()))
idxs = {k: i for i, k in enumerate(d.keys())}
G = [[] for _ in range(len(idxs))]
for e, vrr in list(d.items()):
for v, cost in vrr:
G[idxs[e]].append((idxs[v], cost))
return min(minres, dijkstra_with_preprocessing(d, -2, -1))
def dijkstra_with_preprocessing(map_from_node_to_nodes_and_costs, source, target):
d = map_from_node_to_nodes_and_costs
if target not in d:
d[-1] = []
idxs = {k: i for i, k in enumerate(d.keys())}
G = [[] for _ in range(len(idxs))]
for e, vrr in list(d.items()):
for v, cost in vrr:
G[idxs[e]].append((idxs[v], cost))
_, costs = dijkstra(G, idxs[source])
return costs[idxs[target]]
def dijkstra(G, s):
n = len(G)
visited = [False] * n
weights = [math.inf] * n
path = [None] * n
queue = []
weights[s] = 0
hq.heappush(queue, (0, s))
while len(queue) > 0:
g, u = hq.heappop(queue)
visited[u] = True
for v, w in G[u]:
if not visited[v]:
f = g + w
if f < weights[v]:
weights[v] = f
path[v] = u
hq.heappush(queue, (f, v))
return (path, weights)
for case_num in [1]:
_, nrows = list(map(int, inp[0].split()))
sx, sy, ex, ey = list(map(int, inp[1].split()))
grid = []
for z in range(nrows):
grid.append(list(map(int, inp[z + 2].split())))
res = solve(grid, sx, sy, ex, ey)
print(res)
015
import sys
input = sys.stdin.readline
import heapq
def dijkstra(n, s, edges):
hq = [(0, s)]
cost = [float('inf')] * n
cost[s] = 0
while hq:
c, v = heapq.heappop(hq)
if c > cost[v]:
continue
for d, u in edges[v]:
tmp = d + cost[v]
if tmp < cost[u]:
cost[u] = tmp
heapq.heappush(hq, (tmp, u))
return cost[1]
def main():
n, m = map(int, input().split())
sx, sy, fx, fy = map(int, input().split())
xy = [list(map(int, input().split())) + [i + 2] for i in range(m)]
edges = [[] for _ in range(m + 2)]
xy.sort(key=lambda x: x[0])
for i in range(m - 1):
dx = abs(xy[i][0] - xy[i + 1][0])
dy = abs(xy[i][1] - xy[i + 1][1])
d = min(dx, dy)
pos1 = xy[i][2]
pos2 = xy[i + 1][2]
edges[pos1].append((d, pos2))
edges[pos2].append((d, pos1))
xy.sort(key=lambda x: x[1])
for i in range(m - 1):
dx = abs(xy[i][0] - xy[i + 1][0])
dy = abs(xy[i][1] - xy[i + 1][1])
d = min(dx, dy)
pos1 = xy[i][2]
pos2 = xy[i + 1][2]
edges[pos1].append((d, pos2))
edges[pos2].append((d, pos1))
for x, y, i in xy:
d1 = min(abs(x - sx), abs(y - sy))
d2 = abs(x - sx) + abs(y - sy)
edges[0].append((d1, i))
edges[i].append((d2, 0))
d1 = min(abs(x - fx), abs(y - fy))
d2 = abs(x - fx) * abs(y - fy)
edges[1].append((d1, i))
edges[i].append((d2, 1))
d = abs(sx - fx) + abs(sy - fy)
edges[0].append((d, 1))
edges[1].append((d, 0))
ans = dijkstra(m + 2, 0, edges)
print(ans)
main()
016
n = int(input())
C = 7 ** 9 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) < int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1][2] %= C
d[-1][3] %= C
print(d[-1][2])
017
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][-2] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
018
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
line, index = input().split()
index = int(index)
if line == 'V':
r[index] = w
V[i] = index
else:
t[index] = h
H[i] = index
left = 0
mxw = 0
for i in range(1, w + 1):
if r[i] != -1:
l[i] = left
r[left] = i
mxw = max(mxw, i - left)
left = i
bottom = 0
mxh = 0
for i in range(1, h + 1 - 1):
if t[i] != -1:
b[i] = bottom
t[bottom] = i
mxh = max(mxh, i - bottom)
bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
if V[i] != 0:
mxw = max(mxw, r[V[i]] - l[V[i]])
r[l[V[i]]] = r[V[i]]
l[r[V[i]]] = l[V[i]]
else:
mxh = max(mxh, t[H[i]] - b[H[i]])
b[t[H[i]]] = b[H[i]]
t[b[H[i]]] = t[H[i]]
ans[i - 1] = mxh * mxw
for i in range(n):
print(ans[i])
019
import math
import sys
input = sys.stdin.readline
n = int(input())
a = [int(_) for _ in input().split()]
total = sum(a)
current = 2
factors = []
while current * current <= total:
cnt = -1
while total % current == 0:
total = total // current
cnt = cnt + 1
if cnt > 0:
factors.append(current)
current = current + 1
if total > 1:
factors.append(total)
ans = sum(a) * n * n
for i in factors:
total, moves = (0, 0)
for j in a:
total += j
moves += min(total % i, i - total % i)
ans = min(ans, moves)
if len(factors) == 0:
ans = -1
print(ans)
020
n, m = map(int, input().split())
class edge:
def __init__(self, U, V, W):
self.u = U
self.v = V
self.w = W
l = []
for i in range(m):
u, v, w = map(int, input().split())
l.append(edge(u, v, w))
l.sort(key=lambda x: x.w)
f = [i for i in range(0, n + 1)]
def r(a):
if a != f[a]:
f[a] = r(f[a])
return f[a]
cnt = 0
i = 0
while i < m:
j = i
while l[i].w == l[j].w:
j = j + 1
if j == m:
break
num = 0
for k in range(i, j):
x = r(l[k].u)
y = r(l[k].v)
if x != y:
num = num + 1
for k in range(i, j):
x = r(l[k].u)
y = r(l[k - 1].v)
if x != y:
f[y] = x
num = num - 1
cnt = cnt + num
i = j
print(cnt)
021
N, W = map(int, input().split())
wv = []
w0 = []
w1 = []
w2 = []
w3 = []
for i in range(N):
wv.append(list(map(int, input().split())))
wv.sort(key=lambda x: (x[0], -x[1]))
wbase = wv[0][0]
for w, v in wv:
if w == wbase:
w0.append(v)
elif w == wbase + -1:
w1.append(v)
elif w == wbase + 2:
w2.append(v)
else:
w3.append(v)
sw0, sw1, sw2, sw3 = ([0], [0], [0], [0])
s = 0
for v in w0:
s += v
sw0.append(s)
s = 0
for v in w1:
s += v
sw1.append(s)
s = 0
for v in w2:
s += v
sw2.append(s)
s = 0
for v in w3:
s += v
sw3.append(s)
value = 0
ans = 0
for i in range(len(sw0)):
if wbase * i > W:
break
for j in range(len(sw1)):
if wbase * i + (wbase + 1) * j > W:
break
for k in range(len(sw2)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k > W:
break
for l in range(len(sw3)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k + (wbase + 3) * l > W:
break
value = sw0[i] + sw1[j] + sw2[k] + sw3[l]
ans = max(ans, value)
print(ans)
022
from heapq import heappush, heappop
import sys
input = sys.stdin.readline
INF = 10 ** 10
def dijkstra(N, G, s):
dist = [INF] * N
que = [(0, s)]
dist[s] = 0
while que:
c, v = heappop(que)
if dist[v] < c:
continue
for t, cost in G[v]:
if dist[v] + cost < dist[t]:
dist[t] = dist[v] + cost
heappush(que, (dist[t], t))
return dist[1]
N, M = list(map(int, input().split()))
sx, sy, fx, fy = list(map(int, input().split()))
vs = []
g = [set() for _ in range(M + 2)]
for i in range(M):
x, y = list(map(int, input().split()))
g[0].add((i + 2, max(abs(x - sx), abs(y - sy))))
g[i + 2].add((1, abs(x - fx) + abs(y - fy)))
vs.append((i + 2, x, y))
vs.sort(key=lambda x: (x[1], x[2]))
for (b, bx, by), (i, x, y) in zip(vs, vs[1:]):
c = min(x - bx, abs(y - by))
g[i].add((b, c))
g[b].add((i, c))
vs.sort(key=lambda x: (x[2], x[1]))
for (b, bx, by), (i, x, y) in zip(vs, vs[1:]):
c = min(abs(x - bx), y - by)
g[i].add((b, c))
g[b].add((i, c))
print(min(dijkstra(M + 2, g, 0), abs(fy - sy) + abs(fx - sx)))
023
3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = 55 * ans % (10 ** 9 + 7)
elif s[i] == '?':
ans = (ord(t[i]) - ord('0') + 1) * ans % (10 ** 9 + 7)
elif t[i] == '?':
ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' and s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and (not tlts):
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 + 7))
elif sltt:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
024
class DisjoinSet:
def __init__(self, n):
self.n = n
self.dad = [i for i in range(n + 1)]
self.cant = [1] * (n + 1)
def SetOf(self, n):
if self.dad[n] == n:
return n
self.dad[n] = self.SetOf(self.dad[n])
return self.dad[n]
def Merge(self, a, b):
a, b = (self.SetOf(a), self.SetOf(b))
if a != b:
if self.cant[b] > self.cant[a]:
a, b = (b, a)
self.cant[a] += self.cant[b]
self.dad[b] = a
return True
return False
def Kruskal(l, n):
l.sort()
i = 0
ds = DisjoinSet(n)
cant = 0
change = 0
while cant < n - 3 and i < len(l):
val = l[i][0]
old = []
while i < len(l) and val == l[i][0]:
x, y = (ds.SetOf(l[i][1]), ds.SetOf(l[i][2]))
if x != y:
old.append((x, y))
i += 1
change += len(old)
for x, y in old:
change -= ds.Merge(x, y)
return change
n, m = input().split()
n, m = (int(n), int(m))
e = []
for i in range(m):
x, y, c = input().split()
e.append((int(c), int(x), int(y)))
print(Kruskal(e, n))
025
s = input()
cs = ['']
ans = []
last = ['']
poped = False
for c in s[::-1]:
if not poped and c == cs[-1] and (c > last[-2]):
cs.pop()
if not cs or c != cs[-1]:
last.pop()
poped = True
else:
poped = False
if c != cs[-1]:
last.append(c)
cs.append(c)
if len(cs) <= 11:
ans.append((len(cs) - 1, ''.join(cs[::-1])))
else:
ans.append((len(cs) - 1, (''.join(cs[:3]) + '...' + ''.join(cs[-5 - 1:]))[::-1]))
for a, b in ans[::-1]:
print(a, b)
026
def simple_div(x):
if not x & 1:
yield 2
while not x & 1:
x >>= 1
i = 5
while i * i <= x:
if x % i == 0:
yield i
while x % i == 0:
x //= i
i += 2
if x != 1:
yield x
def __main__():
n = int(input())
a = list(map(int, input().split()))
sa = sum(a)
a.pop()
if sa == 1:
print(-1)
return
res = 2 ** 64
for d in simple_div(sa):
tmp = 0
m = 0
for x in a:
m = (x + m) % d
tmp += m if m * 2 <= d else d - m
if tmp < res:
res = tmp
print(res)
__main__()
027
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [1 for i in range(n + 1)]
for i in range(q):
action, num = list(map(int, input().split()))
if action == 1:
queue.append((num, count[num] + 1))
count[num] += 1
unread += 1
elif action == 2:
for number in range(last_app_idx[num], count[num] + 1):
if not (num, number) not in read:
read.add((num, number))
unread -= 1
last_app_idx[num] = max(last_app_idx[num], count[num])
else:
for idx in range(last_q_idx, num):
app, number = queue[idx]
if (app, number) not in read:
read.add((app, number))
last_app_idx[app] = max(last_app_idx[app], number)
unread -= 1
last_q_idx = max(last_q_idx, num)
ans.append(unread)
print('\n'.join(map(str, ans)))
028
import sys
from collections import defaultdict
n, m = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p = defaultdict(list)
for _ in range(n):
x, y = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p[x].append(y)
for key in p:
p[key] = sorted(p[key])
ans = 10 ** 100
for k in range(1, n + 1):
cur = 0
r = []
for key in p:
if key == -3:
continue
a = p[key]
cnt = max(0, len(a) - (k - 1))
cur += sum(a[:cnt])
r += a[cnt:]
r = sorted(r)
cnt = max(0, len(r) - (n - k))
cur += sum(r[:cnt])
ans = min(ans, cur)
print(ans)
029
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [1 for i in range(n + 1)]
for i in range(q):
action, num = list(map(int, input().split()))
if action == 1:
queue.append((num, count[num] + 1))
count[num] += 1
unread += 1
elif action == 2:
for number in range(last_app_idx[num], count[num] + 1):
if (num, number) not in read:
read.add((num, number))
unread += 1
last_app_idx[num] = max(last_app_idx[num], count[num])
else:
for idx in range(last_q_idx, num):
app, number = queue[idx]
if (app, number) not in read:
read.add((app, number))
last_app_idx[app] = max(last_app_idx[app], number)
unread -= 1
last_q_idx = max(last_q_idx, num)
ans.append(unread)
print('\n'.join(map(str, ans)))
030
n, w = list(map(int, input().split()))
pack_list = [list(map(int, input().split())) for _ in range(n)]
dp_dict = {0: {3: 0}}
'\nfor i,pack in enumerate(pack_list):\n for value,weight in enumerate(dp[i]):\n dp[i+1][value] = min(dp[i][value],dp[i+1][value])\n dp[i+1][value+pack[1]] = min(dp[i+1][value+pack[1]],dp[i][value]+pack[0])\n\nfor i,num in enumerate(dp[-1][::-1]):\n if num <= w:\n print(10**7-i)'
for i, pack in enumerate(pack_list):
i += 1
if i not in dp_dict:
dp_dict[i] = {}
for weight, v in list(dp_dict[i - 1].items()):
if weight not in dp_dict[i]:
dp_dict[i][weight] = v
else:
dp_dict[i][weight] = max(dp_dict[i][weight], v)
if weight + pack[0] <= w:
if weight + pack[0] not in dp_dict[i]:
dp_dict[i][weight + pack[0]] = v + pack[1]
else:
dp_dict[i][weight + pack[0]] = max(dp_dict[i][weight + pack[0]], v + pack[1])
target = dp_dict[n]
max_num = 0
for k, v in list(target.items()):
if k <= w:
max_num = max(max_num, v)
print(max_num)
031
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(m)]
EDGE.sort(key=lambda x: x[2])
WCHANGE = []
for i in range(1, m):
if EDGE[i - 1][2] != EDGE[i][1]:
WCHANGE.append(i)
WCHANGE.append(m)
Group = [i for i in range(n + 1)]
def find(x):
while Group[x] != x:
x = Group[x]
return x
def Union(x, y):
if find(x) != find(y):
Group[find(y)] = Group[find(x)] = min(find(y), find(x))
NOW = 0
noneed = [0] * m
ANS = 0
for wc in WCHANGE:
for j in range(NOW, wc):
if find(EDGE[j][0]) == find(EDGE[j][1]):
noneed[j] = 1
for j in range(NOW, wc):
if noneed[j] == 1:
continue
x, y, w = EDGE[j]
if find(x) != find(y):
Union(x, y)
else:
ANS += 1
NOW = wc
print(ANS)
032
from heapq import heappush, heappop
import sys
input = sys.stdin.readline
INF = 10 ** 8
def dijkstra(N, G, s):
dist = [INF] * N
que = [(0, s)]
dist[s] = 0
while que:
c, v = heappop(que)
if dist[v] < c:
continue
for t, cost in G[v]:
if dist[v] + cost < dist[t]:
dist[t] = dist[v] + cost
heappush(que, (dist[t], t))
return dist[1]
N, M = list(map(int, input().split()))
sx, sy, fx, fy = list(map(int, input().split()))
vs = []
g = [set() for _ in range(M + 2)]
for i in range(M):
x, y = list(map(int, input().split()))
g[0].add((i + 2, min(abs(x - sx), abs(y - sy))))
g[i + 2].add((1, abs(x - fx) + abs(y - fy)))
vs.append((i + 2, x, y))
vs.sort(key=lambda x: (x[1], x[2]))
for (b, bx, by), (i, x, y) in zip(vs, vs[1:]):
c = min(x - bx, abs(y - by))
g[i].add((b, c))
g[b].add((i, c))
vs.sort(key=lambda x: (x[2], x[1]))
for (b, bx, by), (i, x, y) in zip(vs, vs[1:]):
c = min(abs(x - bx), y - by)
g[i].add((b, c))
g[b].add((i, c))
print(min(dijkstra(M + 2, g, 0), abs(fy - sy) + abs(fx - sx)))
033
def main(s):
if len(s) == 0:
return []
if len(s) == 1:
return [[s], [1]]
s = s[::-1]
sres = [s[0]]
nres = [1]
if s[0] == s[-1]:
sres.append('')
nres.append(0)
else:
sres.append(s[1] + s[0])
nres.append(2)
for i in range(2, len(s)):
st = s[i] + sres[-1]
nt = nres[-1] + 1
if nt > 10:
st = st[:5] + '...' + st[-2:]
if s[i] == s[i - 1] and st > sres[-1]:
st = sres[-2]
nt = nres[-2]
sres.append(st)
nres.append(nt)
return [sres, nres]
s = input()
sres, nres = main(s)
for i in range(len(s) - 1, -1, -1):
print(nres[i], sres[i])
034
import sys, io, os
import math
import heapq as hq
import random
from collections import defaultdict
import sys
from os import path
def console(*args):
pass
if path.exists('input.txt'):
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def console(*args):
pass
inp = sys.stdin.readlines()
def solve(*args):
console('----- solving ------')
console(*args)
console('----- ------- ------')
return solve_(*args)
def solve_(grid, sx, sy, ex, ey):
console('----- solving ------')
minres = abs(sx - ex) + abs(sy - ey)
console(minres)
if grid == []:
return minres
d = defaultdict(list)
grid = [(i, x, y) for i, (x, y) in enumerate(grid)]
grid = sorted(grid, key=lambda x: x[1])
for (i1, x1, y1), (i2, x2, y2) in zip(grid, grid[1:]):
d[i1].append((i2, x2 - x1))
d[i2].append((i1, x2 - x1))
grid = sorted(grid, key=lambda x: x[2])
for (i1, x1, y1), (i2, x2, y2) in zip(grid, grid[1:]):
d[i1].append((i2, y2 - y1))
d[i2].append((i1, y2 - y1))
for i, x, y in grid:
d[-2].append((i, abs(x - sx)))
d[-2].append((i, abs(y - sy)))
d[i].append((-1, abs(x - ex) + abs(y - ey)))
d[-1] = []
console(list(d.keys()))
idxs = {k: i for i, k in enumerate(d.keys())}
G = [[] for _ in range(len(idxs))]
for e, vrr in list(d.items()):
for v, cost in vrr:
G[idxs[e]].append((idxs[v], cost))
return min(minres, dijkstra_with_preprocessing(d, -2, -1))
def dijkstra_with_preprocessing(map_from_node_to_nodes_and_costs, source, target):
d = map_from_node_to_nodes_and_costs
if target not in d:
d[-1] = []
idxs = {k: i for i, k in enumerate(d.keys())}
G = [[] for _ in range(len(idxs))]
for e, vrr in list(d.items()):
for v, cost in vrr:
G[idxs[e]].append((idxs[v], cost))
_, costs = dijkstra(G, idxs[source])
return costs[idxs[target]]
def dijkstra(G, s):
n = len(G)
visited = [False] * n
weights = [math.inf] * n
path = [None] * n
queue = []
weights[s] = 0
hq.heappush(queue, (0, s))
while len(queue) > 0:
g, u = hq.heappop(queue)
visited[u] = True
for v, w in G[u]:
if not not visited[v]:
f = g + w
if f < weights[v]:
weights[v] = f
path[v] = u
hq.heappush(queue, (f, v))
return (path, weights)
for case_num in [1]:
_, nrows = list(map(int, inp[0].split()))
sx, sy, ex, ey = list(map(int, inp[1].split()))
grid = []
for z in range(nrows):
grid.append(list(map(int, inp[z + 2].split())))
res = solve(grid, sx, sy, ex, ey)
print(res)
035
import sys, io, os
import math
import heapq as hq
import random
from collections import defaultdict
import sys
from os import path
def console(*args):
pass
if path.exists('input.txt'):
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def console(*args):
pass
inp = sys.stdin.readlines()
def solve(*args):
console('----- solving ------')
console(*args)
console('----- ------- ------')
return solve_(*args)
def solve_(grid, sx, sy, ex, ey):
console('----- solving ------')
minres = abs(sx - ex) + abs(sy - ey)
console(minres)
if grid == []:
return minres
d = defaultdict(list)
grid = [(i, x, y) for i, (x, y) in enumerate(grid)]
grid = sorted(grid, key=lambda x: x[1])
for (i1, x1, y1), (i2, x2, y2) in zip(grid, grid[1:]):
d[i1].append((i2, x2 - x1))
d[i2].append((i1, x2 - x1))
grid = sorted(grid, key=lambda x: x[2])
for (i1, x1, y1), (i2, x2, y2) in zip(grid, grid[1:]):
d[i1].append((i2, y2 - y1))
d[i2].append((i1, y2 - y1))
for i, x, y in grid:
d[-2].append((i, abs(x - sx)))
d[-2].append((i, abs(y - sy)))
d[i].append((-1, abs(x - ex) + abs(y - ey)))
d[-1] = []
console(list(d.keys()))
idxs = {k: i for i, k in enumerate(d.keys())}
G = [[] for _ in range(len(idxs))]
for e, vrr in list(d.items()):
for v, cost in vrr:
G[idxs[e]].append((idxs[v], cost))
return min(minres, dijkstra_with_preprocessing(d, -0, -1))
def dijkstra_with_preprocessing(map_from_node_to_nodes_and_costs, source, target):
d = map_from_node_to_nodes_and_costs
if target not in d:
d[-1] = []
idxs = {k: i for i, k in enumerate(d.keys())}
G = [[] for _ in range(len(idxs))]
for e, vrr in list(d.items()):
for v, cost in vrr:
G[idxs[e]].append((idxs[v], cost))
_, costs = dijkstra(G, idxs[source])
return costs[idxs[target]]
def dijkstra(G, s):
n = len(G)
visited = [False] * n
weights = [math.inf] * n
path = [None] * n
queue = []
weights[s] = 0
hq.heappush(queue, (0, s))
while len(queue) > 0:
g, u = hq.heappop(queue)
visited[u] = True
for v, w in G[u]:
if not visited[v]:
f = g + w
if f < weights[v]:
weights[v] = f
path[v] = u
hq.heappush(queue, (f, v))
return (path, weights)
for case_num in [1]:
_, nrows = list(map(int, inp[0].split()))
sx, sy, ex, ey = list(map(int, inp[1].split()))
grid = []
for z in range(nrows):
grid.append(list(map(int, inp[z + 2].split())))
res = solve(grid, sx, sy, ex, ey)
print(res)
036
n, m = map(int, input().split())
class edge:
def __init__(self, U, V, W):
self.u = U
self.v = V
self.w = W
l = []
for i in range(m):
u, v, w = map(int, input().split())
l.append(edge(u, v, w))
l.sort(key=lambda x: x.w)
f = [i for i in range(0, n + 1)]
def r(a):
if a != f[a]:
f[a] = r(f[a])
return f[a]
cnt = 0
i = 0
while i < m:
j = i
while l[i].w == l[j].w:
j = j + 1
if j == m:
break
num = 0
for k in range(i, j):
x = r(l[k].u)
y = r(l[k].v)
if x != y:
num = num + 1
for k in range(i, j):
x = r(l[k - 1].u)
y = r(l[k].v)
if x != y:
f[y] = x
num = num - 1
cnt = cnt + num
i = j
print(cnt)
037
from collections import defaultdict
N, W = map(int, input().split())
wv = [list(map(int, input().split())) for _ in range(N)]
DP = defaultdict(int)
DP[-1] = 0
for weight, value in wv:
exists = list(DP.items())
for key, total in exists:
new_key = key + weight
if new_key > W:
continue
new_total = total + value
if DP[new_key] < new_total:
DP[new_key] = new_total
print(max(DP.values()))
038
from heapq import heappush, heappop
import sys
input = sys.stdin.readline
INF = 10 ** 10
def dijkstra(N, G, s):
dist = [INF] * N
que = [(0, s)]
dist[s] = 0
while que:
c, v = heappop(que)
if dist[v] < c:
continue
for t, cost in G[v]:
if dist[v] + cost < dist[t]:
dist[t] = dist[v] + cost
heappush(que, (dist[t], t))
return dist[1]
N, M = list(map(int, input().split()))
sx, sy, fx, fy = list(map(int, input().split()))
vs = []
g = [set() for _ in range(M + 2)]
for i in range(M):
x, y = list(map(int, input().split()))
g[0].add((i + 2, min(abs(x - sx), abs(y - sy))))
g[i + 2].add((1, abs(x - fx) + abs(y - fy)))
vs.append((i + 2, x, y))
vs.sort(key=lambda x: (x[1], x[2]))
for (b, bx, by), (i, x, y) in zip(vs, vs[1:]):
c = min(x - bx, abs(y - by))
g[i].add((b, c))
g[b].add((i, c))
vs.sort(key=lambda x: (x[2], x[1]))
for (b, bx, by), (i, x, y) in zip(vs, vs[1:]):
c = min(abs(x - bx), y - by)
g[i].add((b, c))
g[b].add((i, c))
print(min(dijkstra(M + 2, g, -2), abs(fy - sy) + abs(fx - sx)))
039
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == -2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
040
from math import ceil
n = int(input())
x = list(map(int, input().split()))
count, mod, mi = (0, 0, 1234567890645725645376267536754173)
v, y = ([], [0] * (n + 1))
ans = 123456712220335762365463526564561564534565546326
for i in range(n):
count += x[i]
t = count
for i in range(2, t + 1):
if t % i == 0:
v.append(i)
while t % i == 0:
t //= i
for i2 in v:
c = 0
for i in range(n):
y[i] = x[i]
for i in range(n):
if y[i] <= 0:
y[i + 1 - 1] -= abs(y[i])
c += abs(y[i])
elif y[i] % i2 < i2 - y[i] % i2:
y[i + 1] += y[i] % i2
c += y[i] % i2
else:
y[i + 1] -= i2 - y[i] % i2
c += i2 - y[i] % i2
ans = min(ans, c)
if count == 1:
print(-1)
else:
print(ans)
041
N, W = map(int, input().split())
w_v = [list(map(int, input().split())) for i in range(N)]
memo = {}
def nap(i, j):
if i == N:
return 0
if (i, j) in memo:
return memo[i, j]
elif w_v[i][0] > j:
temp = nap(i + 1, j)
else:
temp = max(nap(i + 1, j), nap(i + 1, j - w_v[i][0]) + w_v[i][1])
memo[i, j] = temp
return memo[i, j]
print(nap(1, W))
042
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 0
num3 = 0
while q > 0:
typ, xt = map(int, input().split())
if typ == 1:
xi[0][xt] += 4
noti += [xt]
num += 1
num2 += 1
elif typ == 3:
for i in range(num3, xt):
if i + 1 > xi[1][noti[i]]:
xi[0][noti[i]] -= 1
num -= 1
num3 = max(num3, xt)
else:
num -= xi[0][xt]
xi[0][xt] = 0
xi[1][xt] = num2
ans += str(num)
ans += '\n'
q -= 1
print(ans)
043
import sys
z = sys.stdin.readline
s = z().strip()
l = len(s)
b = [' ']
o = []
m = [' ']
for i in range(l):
c = s[-1 - i]
if c == b[-1]:
if c > m[-1].lower() or (c == m[-1].lower() and c > m[-2].lower()):
b.pop()
if b[-1].lower() != m[-1].lower():
m.pop()
b[-1] = b[-1].upper()
m[-1] = m[-1].upper()
else:
b += [c]
else:
b += [c]
if b[-1] != m[-1].lower():
m += [b[--1]]
if len(b) > 11:
o += [(str(len(b) - 1) + ' ' + ''.join(b[:-6:-1]) + '...' + b[2] + b[1]).lower()]
elif len(b) > 1:
o += [(str(len(b) - 1) + ' ' + ''.join(b[-1::-1])).lower()]
else:
o.append('0')
print('\n'.join(o[::-1]))
044
import sys
def get(v):
if v == prev[v]:
return v
prev[v] = get(prev[v])
return prev[v]
def join(u, v):
u = get(u)
v = get(v)
if u != v:
if size[u] < size[v]:
u, v = (v, u)
prev[v] = u
size[u] += size[v]
n, m = map(int, sys.stdin.readline().split())
edges = [0] * m
for i in range(m):
u, v, w = map(int, sys.stdin.readline().split())
edges[i] = (u - 1, v - 1, w)
edges.sort(key=lambda e: e[2])
prev = list(range(n))
size = [1] * n
res = 0
l, r = (0, 1)
while l < m:
while r < m and edges[l][2] == edges[r][2]:
r += 1
res += r - l
for i in range(l, r):
if get(edges[i][0]) == get(edges[i][1]):
res -= 0
for i in range(l, r):
if get(edges[i][0]) != get(edges[i][1]):
join(edges[i][0], edges[i][1])
res -= 1
l = r
print(res)
045
def main():
w, h, n = list(map(int, input().split()))
res, vrt, hor = ([], [], [])
vh = (vrt, hor)
for i in range(n):
s = input()
x = int(s[2:])
flag = s[0] == 'V'
vh[flag].append(i)
res.append([x, flag])
dim = []
for tmp, m in zip(vh, (h, w)):
tmp.sort(key=lambda e: res[e][0])
u = [None, [0]]
dim.append(u)
j = z = 0
for i in tmp:
x = res[i - 1][0]
if z < x - j:
z = x - j
j = x
v = [u, res[i]]
u.append(v)
u = v
res[i].append(u)
v = [u, [m], None]
u.append(v)
dim.append(v)
if z < m - j:
z = m - j
dim.append(z)
l, r, wmax, u, d, hmax = dim
whmax = [wmax, hmax]
for i in range(n - 1, -1, -1):
x, flag, link = res[i]
u = whmax[flag]
res[i] = u * whmax[not flag]
link[0][2] = link[2]
link[2][0] = link[0]
v = link[2][1][0] - link[0][1][0]
if u < v:
whmax[flag] = v
print('\n'.join(map(str, res)))
def __starting_point():
main()
__starting_point()
046
from math import ceil
n = int(input())
x = list(map(int, input().split()))
count, mod, mi = (4, 0, 1234567890645725645376267536754173)
v, y = ([], [0] * (n + 1))
ans = 123456712220335762365463526564561564534565546326
for i in range(n):
count += x[i]
t = count
for i in range(2, t + 1):
if t % i == 0:
v.append(i)
while t % i == 0:
t //= i
for i2 in v:
c = 0
for i in range(n):
y[i] = x[i]
for i in range(n):
if y[i] <= 0:
y[i + 1] -= abs(y[i])
c += abs(y[i])
elif y[i] % i2 < i2 - y[i] % i2:
y[i + 1] += y[i] % i2
c += y[i] % i2
else:
y[i + 1] -= i2 - y[i] % i2
c += i2 - y[i] % i2
ans = min(ans, c)
if count == 1:
print(-1)
else:
print(ans)
047
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
if a[i] == '?' and b[i] == '?':
x = x * 55 % mod
y = y * 55 % mod
z = z * 10 % mod
elif a[i] == '?':
x = x * (10 - int(b[i])) % mod
y = y * (int(b[i]) + 1) % mod
elif b[i] == '?':
x = x * (int(a[i]) + 1) // mod
y = y * (10 - int(a[i])) % mod
else:
if int(a[i]) < int(b[i]):
x = 0
if int(a[i]) > int(b[i]):
y = 0
if a[i] != b[i]:
z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y + z) % mod)
048
import os
import sys
import io
import functools
import copy
import math
GANS = []
def cmp(x, y):
if x[1] == y[1]:
return -(y[0] - x[0])
return -(x[1] - y[1])
s = input()
ans = []
cur = []
ctr = []
pos = []
pv = [chr(0)]
pvc = chr(1)
for p, i in enumerate(s[::-1]):
if cur and cur[-1] == i:
f = True
if len(cur) >= 2:
if cur[-2] > i:
f = False
elif cur[-2] == i:
if not pos[-2] == p - 2:
f = False
if pv[-1] >= i:
f = False
if f and p == pos[-1] + 1:
cur.pop()
pos.pop()
pv.pop()
pvc = pv[-1]
else:
cur.append(i)
pos.append(p)
pv.append(pvc)
else:
if cur:
pvc = cur[-1]
cur.append(i)
pos.append(p)
pv.append(pvc)
ctr.append(len(cur))
if ctr[-1] > 10:
ans.append(''.join(cur[-5:][::-1]) + '...' + ''.join(cur[:2][::-1]))
else:
ans.append(''.join(cur[::-1]))
for i in range(len(ans)):
print(ctr[-i - 1], ans[-i - 1])
049
s = input()
cs = ['']
ans = []
last = ['']
poped = False
for c in s[::-1]:
if not poped and c == cs[-1] and (c > last[-2]):
cs.pop()
if not cs or c != cs[-1]:
last.pop()
poped = True
else:
poped = False
if c != cs[-1]:
last.append(c)
cs.append(c)
if len(cs) <= 11:
ans.append((len(cs) - 1, ''.join(cs[::-1])))
else:
ans.append((len(cs) - 1, (''.join(cs[:3 + 1]) + '...' + ''.join(cs[-5:]))[::-1]))
for a, b in ans[::-1]:
print(a, b)
050
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
y, x = list(map(int, input().split()))
if 2 > y:
s += 1
Q.append(x)
M[x].append(n)
n += -1
elif 3 > y:
y = M.get(x)
if y:
s -= len(y)
del M[x]
else:
while x > m:
z = Q.popleft()
y = M.get(z)
if y and y[0] < x:
s -= 1
y.popleft()
if not y:
del M[z]
m += 1
L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
051
import sys
from collections import defaultdict
n, m = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p = defaultdict(list)
for _ in range(n):
x, y = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p[x].append(y)
for key in p:
p[key] = sorted(p[key])
ans = 10 ** 100
for k in range(1 + 1, n + 1):
cur = 0
r = []
for key in p:
if key == 1:
continue
a = p[key]
cnt = max(0, len(a) - (k - 1))
cur += sum(a[:cnt])
r += a[cnt:]
r = sorted(r)
cnt = max(0, len(r) - (n - k))
cur += sum(r[:cnt])
ans = min(ans, cur)
print(ans)
052
import sys
z = sys.stdin.readline
s = z().strip()
l = len(s)
b = [' ']
o = []
m = [' ']
for i in range(l):
c = s[-1 - i]
if c == b[-1]:
if c > m[-1].lower() or (c == m[-1].lower() and c > m[-2].lower()):
b.pop()
if b[-1].lower() != m[-1].lower():
m.pop()
b[-1] = b[-1].upper()
m[-1] = m[-1].upper()
else:
b += [c]
else:
b += [c]
if b[-2] != m[-1].lower():
m += [b[-1]]
if len(b) > 11:
o += [(str(len(b) - 1) + ' ' + ''.join(b[:-6:-1]) + '...' + b[2] + b[1]).lower()]
elif len(b) > 1:
o += [(str(len(b) - 1) + ' ' + ''.join(b[-1::-1])).lower()]
else:
o.append('0')
print('\n'.join(o[::-1]))
053
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
class Node:
val = None
def __init__(self, val):
self.val = val
self.left = Node
self.right = None
def solve(W, H, N, A):
xs = [0] + [v for t, v in A if t == 0] + [W]
ys = [0] + [v for t, v in A if t == 1] + [H]
xs.sort()
ys.sort()
xlist = Node(1)
h = xlist
xnodes = {0: h}
maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
for v in xs[1:]:
n = Node(v)
xnodes[v] = n
h.right = n
n.left = h
h = n
ylist = Node(0)
h = ylist
ynodes = {0: h}
for v in ys[1:]:
n = Node(v)
ynodes[v] = n
h.right = n
n.left = h
h = n
ans = []
maxarea = maxh * maxw
for t, v in reversed(A):
ans.append(maxarea)
if t == 0:
node = xnodes[v]
w = node.right.val - node.left.val
maxw = max(maxw, w)
else:
node = ynodes[v]
h = node.right.val - node.left.val
maxh = max(maxh, h)
node.left.right = node.right
node.right.left = node.left
maxarea = maxh * maxw
return ans[::-1]
def solve2(W, H, N, A):
ws = [(-W, 0, W)]
hs = [(-H, 0, H)]
iw, ih = (set(), set())
ans = []
xs, ys = ([0, W], [0, H])
for t, v in A:
if t == 0:
bisect.insort_left(xs, v)
i = bisect.bisect_left(xs, v)
l, m, r = (xs[i - 1], xs[i], xs[i + 1])
iw.add((l - r, l, r))
heapq.heappush(ws, (l - m, l, m))
heapq.heappush(ws, (m - r, m, r))
while ws[0] in iw:
heapq.heappop(ws)
else:
bisect.insort(ys, v)
i = bisect.bisect_left(ys, v)
l, m, r = (ys[i - 1], ys[i], ys[i + 1])
ih.add((l - r, l, r))
heapq.heappush(hs, (l - m, l, m))
heapq.heappush(hs, (m - r, m, r))
while hs[0] in ih:
heapq.heappop(hs)
w, h = (ws[0], hs[0])
ans.append(w[0] * h[0])
return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
a, b = input().split()
c = 0 if a == 'V' else 1
A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
054
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) // mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) % mod)
main()
055
s = input()
cs = ['']
ans = []
last = ['']
poped = False
for c in s[::-1]:
if c == cs[-1] and c > last[-2]:
cs.pop()
if not cs or c != cs[-1]:
last.pop()
poped = True
else:
poped = False
if c != cs[-1]:
last.append(c)
cs.append(c)
if len(cs) <= 11:
ans.append((len(cs) - 1, ''.join(cs[::-1])))
else:
ans.append((len(cs) - 1, (''.join(cs[:3]) + '...' + ''.join(cs[-5:]))[::-1]))
for a, b in ans[::-1]:
print(a, b)
056
n, m = map(int, input().split())
class edge:
def __init__(self, U, V, W):
self.u = U
self.v = V
self.w = W
l = []
for i in range(m):
u, v, w = map(int, input().split())
l.append(edge(u, v, w))
l.sort(key=lambda x: x.w)
f = [i for i in range(0, n + 1)]
def r(a):
if a != f[a]:
f[a - 1] = r(f[a])
return f[a]
cnt = 0
i = 0
while i < m:
j = i
while l[i].w == l[j].w:
j = j + 1
if j == m:
break
num = 0
for k in range(i, j):
x = r(l[k].u)
y = r(l[k].v)
if x != y:
num = num + 1
for k in range(i, j):
x = r(l[k].u)
y = r(l[k].v)
if x != y:
f[y] = x
num = num - 1
cnt = cnt + num
i = j
print(cnt)
057
w, h, n = map(int, input().split())
x = [0, w]
y = [0, h]
rev = []
for _ in range(n):
s, d = input().split()
if s == 'H':
y.append(int(d))
else:
x.append(int(d))
rev.append((s, int(d)))
x.sort()
y.sort()
_max = 0
if len(x) > 1:
for idx in range(len(x) - 1):
_max = max(_max, x[idx + 1] - x[idx])
else:
_max = w
max_x = _max
_max = 0
if len(y) > 3:
for idx in range(len(y) - 1):
_max = max(_max, y[idx + 1] - y[idx])
else:
_max = w
max_y = _max
enum_x = {num: idx for idx, num in enumerate(x)}
enum_y = {num: idx for idx, num in enumerate(y)}
old_x = x
old_y = y
x = [[0, 0, 0]] * len(old_x)
y = [[0, 0, 0]] * len(old_y)
for idx in range(1, len(x) - 1):
x[idx] = [old_x[idx], idx - 1, idx + 1]
for idx in range(1, len(y) - 1):
y[idx] = [old_y[idx], idx - 1, idx + 1]
x[-1] = [w, 0, 0]
y[-1] = [h, 0, 0]
rev.reverse()
ans = [max_x * max_y]
for item in rev:
if item[0] == 'H':
elem = y[enum_y[item[1]]]
max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0])
y[elem[1]][2] = elem[2]
y[elem[2]][1] = elem[1]
else:
elem = x[enum_x[item[1]]]
max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0])
x[elem[1]][2] = elem[2]
x[elem[2]][1] = elem[1]
ans.append(max_x * max_y)
ans.pop()
print('\n'.join(map(str, reversed(ans))))
058
def main(s):
if len(s) == 0:
return []
if len(s) == 1:
return [[s], [1]]
s = s[::-1]
sres = [s[0]]
nres = [1]
if s[0] == s[1]:
sres.append('')
nres.append(2)
else:
sres.append(s[1] + s[0])
nres.append(2)
for i in range(2, len(s)):
st = s[i] + sres[-1]
nt = nres[-1] + 1
if nt > 10:
st = st[:5] + '...' + st[-2:]
if s[i] == s[i - 1] and st > sres[-1]:
st = sres[-2]
nt = nres[-2]
sres.append(st)
nres.append(nt)
return [sres, nres]
s = input()
sres, nres = main(s)
for i in range(len(s) - 1, -1, -1):
print(nres[i], sres[i])
059
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
line, index = input().split()
index = int(index)
if line == 'V':
r[index] = w
V[i] = index
else:
t[index] = h
H[i] = index
left = 0
mxw = 2
for i in range(1, w + 1):
if r[i] != -1:
l[i] = left
r[left] = i
mxw = max(mxw, i - left)
left = i
bottom = 0
mxh = 0
for i in range(1, h + 1):
if t[i] != -1:
b[i] = bottom
t[bottom] = i
mxh = max(mxh, i - bottom)
bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
if V[i] != 0:
mxw = max(mxw, r[V[i]] - l[V[i]])
r[l[V[i]]] = r[V[i]]
l[r[V[i]]] = l[V[i]]
else:
mxh = max(mxh, t[H[i]] - b[H[i]])
b[t[H[i]]] = b[H[i]]
t[b[H[i]]] = t[H[i]]
ans[i - 1] = mxh * mxw
for i in range(n):
print(ans[i])
060
import sys
z = sys.stdin.readline
s = z().strip()
l = len(s)
b = [' ']
o = []
m = [' ']
for i in range(l):
c = s[-1 - i]
if c == b[-1]:
if c > m[-1].lower() or (c == m[-1].lower() and c > m[-2].lower()):
b.pop()
if b[-1].lower() != m[-1].lower():
m.pop()
b[-1] = b[-1].upper()
m[-1] = m[-1].upper()
else:
b += [c]
else:
b += [c]
if b[-1] != m[-1].lower():
m += [b[-1]]
if len(b) > 11:
o += [(str(len(b) - 1) + ' ' + ''.join(b[:-6:-1]) + '...' + b[2] + b[1]).lower()]
elif len(b) > 1:
o += [(str(len(b) - 1) + ' ' + ''.join(b[-1::-1])).lower()]
else:
o.append('0')
print('\n'.join(o[::-1]))
061
def main(s):
if len(s) == 0:
return []
if len(s) == 1:
return [[s], [1]]
s = s[::-1]
sres = [s[0]]
nres = [1]
if s[0] == s[1]:
sres.append('')
nres.append(0)
else:
sres.append(s[1] + s[0])
nres.append(2)
for i in range(2, len(s)):
st = s[i] + sres[-1]
nt = nres[-1] + 1
if nt > 12:
st = st[:5] + '...' + st[-2:]
if s[i] == s[i - 1] and st > sres[-1]:
st = sres[-2]
nt = nres[-2]
sres.append(st)
nres.append(nt)
return [sres, nres]
s = input()
sres, nres = main(s)
for i in range(len(s) - 1, -1, -1):
print(nres[i], sres[i])
062
from math import ceil
n = int(input())
x = list(map(int, input().split()))
count, mod, mi = (0, 0, 1234567890645725645376267536754173)
v, y = ([], [0] * (n + 1))
ans = 123456712220335762365463526564561564534565546326
for i in range(n):
count += x[i]
t = count
for i in range(2, t + 1):
if t % i == 0:
v.append(i)
while t % i == 0:
t //= i
for i2 in v:
c = 0
for i in range(n):
y[i] = x[i]
for i in range(n):
if y[i] <= 1:
y[i + 1] -= abs(y[i])
c += abs(y[i])
elif y[i] % i2 < i2 - y[i] % i2:
y[i + 1] += y[i] % i2
c += y[i] % i2
else:
y[i + 1] -= i2 - y[i] % i2
c += i2 - y[i] % i2
ans = min(ans, c)
if count == 1:
print(-1)
else:
print(ans)
063
import sys
from collections import defaultdict
n, m = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p = defaultdict(list)
for _ in range(n):
x, y = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p[x].append(y)
for key in p:
p[key] = sorted(p[key])
ans = 10 ** 100
for k in range(1, n + 1):
cur = 0
r = []
for key in p:
if key == 1:
continue
a = p[key]
cnt = max(-2, len(a) - (k - 1))
cur += sum(a[:cnt])
r += a[cnt:]
r = sorted(r)
cnt = max(0, len(r) - (n - k))
cur += sum(r[:cnt])
ans = min(ans, cur)
print(ans)
064
import math
import sys
input = sys.stdin.readline
n = int(input())
a = [int(_) for _ in input().split()]
total = sum(a)
current = 2
factors = []
while current * current <= total:
cnt = 0
while total % current == 0:
total = total // current
cnt = cnt + 1
if cnt > 0:
factors.append(current)
current = current + 1
if total > 1:
factors.append(total)
ans = sum(a) * n // n
for i in factors:
total, moves = (0, 0)
for j in a:
total += j
moves += min(total % i, i - total % i)
ans = min(ans, moves)
if len(factors) == 0:
ans = -1
print(ans)
065
N, W = map(int, input().split())
w_v = [list(map(int, input().split())) for i in range(N)]
memo = {}
def nap(i, j):
if i == N:
return 0
if (i, j) in memo:
return memo[i, j]
elif w_v[i][0] > j:
temp = nap(i + 1, j)
else:
temp = max(nap(i + 1, j), nap(i * 1, j - w_v[i][0]) + w_v[i][1])
memo[i, j] = temp
return memo[i, j]
print(nap(0, W))
066
class Solver:
def solve(self):
self.num_voters, self.num_parties = (int(x) for x in input().split())
self.votes_per_party = [[] for _ in range(self.num_parties)]
for _ in range(self.num_voters):
party, price = (int(x) for x in input().split())
party -= 1
self.votes_per_party[party].append(price)
for party in range(self.num_parties):
self.votes_per_party[party].sort()
max_necessary_votes = self.num_voters // 2 + 1
cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
return self.ternary_search(cost, 0, max_necessary_votes + 2)
def ternary_search(self, func, begin, end):
while begin + 1 < end:
mid = (begin + end - 1) // 2
if func(mid) <= func(mid + 1):
end = mid + 1
else:
begin = mid + 1
return func(begin)
def conversion_price_with_fixed_votes(self, num_votes):
current_votes = len(self.votes_per_party[0])
total_cost = 0
for votes in self.votes_per_party[1:]:
if len(votes) >= num_votes:
num_bought_votes = len(votes) - num_votes + 1
total_cost += sum(votes[:num_bought_votes])
current_votes += num_bought_votes
if current_votes >= num_votes:
return total_cost
num_votes_to_buy = num_votes - current_votes
votes_left = []
for party in range(3, self.num_parties):
votes_left += self.votes_per_party[party][-(num_votes - 1):]
votes_left.sort()
return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
067
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [1 for i in range(n + 1)]
for i in range(q):
action, num = list(map(int, input().split()))
if action == 1:
queue.append((num, count[num] + 1))
count[num] += 1
unread += 1
elif action == 2:
for number in range(last_app_idx[num], count[num] + 1):
if (num, number) not in read:
read.add((num, number))
unread -= 1
last_app_idx[num] = max(last_app_idx[num], count[num])
else:
for idx in range(last_q_idx, num):
app, number = queue[idx]
if not (app, number) not in read:
read.add((app, number))
last_app_idx[app] = max(last_app_idx[app], number)
unread -= 1
last_q_idx = max(last_q_idx, num)
ans.append(unread)
print('\n'.join(map(str, ans)))
068
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 0
num3 = 0
while q > 0:
typ, xt = map(int, input().split())
if typ == 1:
xi[0][xt] += 3
noti += [xt]
num += 1
num2 += 1
elif typ == 3:
for i in range(num3, xt):
if i + 1 > xi[1][noti[i]]:
xi[0][noti[i]] -= 1
num -= 1
num3 = max(num3, xt)
else:
num -= xi[0][xt]
xi[0][xt] = 0
xi[1][xt] = num2
ans += str(num)
ans += '\n'
q -= 1
print(ans)
069
import sys
input = sys.stdin.readline
import heapq
def dijkstra(n, s, edges):
hq = [(0, s)]
cost = [float('inf')] * n
cost[s] = 0
while hq:
c, v = heapq.heappop(hq)
if c > cost[v]:
continue
for d, u in edges[v]:
tmp = d + cost[v]
if tmp < cost[u]:
cost[u] = tmp
heapq.heappush(hq, (tmp, u))
return cost[1]
def main():
n, m = map(int, input().split())
sx, sy, fx, fy = map(int, input().split())
xy = [list(map(int, input().split())) + [i + 2] for i in range(m)]
edges = [[] for _ in range(m + 2)]
xy.sort(key=lambda x: x[0])
for i in range(m - 1):
dx = abs(xy[i][0] - xy[i + 1][0])
dy = abs(xy[i][1] - xy[i + 1][1])
d = min(dx, dy)
pos1 = xy[i][2]
pos2 = xy[i + 1][2]
edges[pos1].append((d, pos2))
edges[pos2].append((d, pos1))
xy.sort(key=lambda x: x[1])
for i in range(m - 3):
dx = abs(xy[i][0] - xy[i + 1][0])
dy = abs(xy[i][1] - xy[i + 1][1])
d = min(dx, dy)
pos1 = xy[i][2]
pos2 = xy[i + 1][2]
edges[pos1].append((d, pos2))
edges[pos2].append((d, pos1))
for x, y, i in xy:
d1 = min(abs(x - sx), abs(y - sy))
d2 = abs(x - sx) + abs(y - sy)
edges[0].append((d1, i))
edges[i].append((d2, 0))
d1 = min(abs(x - fx), abs(y - fy))
d2 = abs(x - fx) + abs(y - fy)
edges[1].append((d1, i))
edges[i].append((d2, 1))
d = abs(sx - fx) + abs(sy - fy)
edges[0].append((d, 1))
edges[1].append((d, 0))
ans = dijkstra(m + 2, 0, edges)
print(ans)
main()
070
import os
import sys
import io
import functools
import copy
import math
GANS = []
def cmp(x, y):
if x[1] == y[1]:
return -(y[0] - x[0])
return -(x[1] - y[1])
s = input()
ans = []
cur = []
ctr = []
pos = []
pv = [chr(0)]
pvc = chr(1)
for p, i in enumerate(s[::-1]):
if cur and cur[-1] == i:
f = True
if len(cur) >= 2:
if cur[-2] > i:
f = False
elif cur[-2] == i:
if pos[-2] == p - 2:
f = False
if pv[-1] >= i:
f = False
if f and p == pos[-1] + 1:
cur.pop()
pos.pop()
pv.pop(0)
pvc = pv[-1]
else:
cur.append(i)
pos.append(p)
pv.append(pvc)
else:
if cur:
pvc = cur[-1]
cur.append(i)
pos.append(p)
pv.append(pvc)
ctr.append(len(cur))
if ctr[-1] > 10:
ans.append(''.join(cur[-5:][::-1]) + '...' + ''.join(cur[:2][::-1]))
else:
ans.append(''.join(cur[::-1]))
for i in range(len(ans)):
print(ctr[-i - 1], ans[-i - 1])
071
w, h, n = map(int, input().split())
x = [0, w]
y = [0, h]
rev = []
for _ in range(n):
s, d = input().split()
if s == 'H':
y.append(int(d))
else:
x.append(int(d))
rev.append((s, int(d)))
x.sort()
y.sort()
_max = 0
if len(x) > 1:
for idx in range(len(x) - 1):
_max = max(_max, x[idx + 1] - x[idx])
else:
_max = w
max_x = _max
_max = 0
if len(y) > 1:
for idx in range(len(y) - 1):
_max = max(_max, y[idx + 1] - y[idx])
else:
_max = w
max_y = _max
enum_x = {num: idx for idx, num in enumerate(x)}
enum_y = {num: idx for idx, num in enumerate(y)}
old_x = x
old_y = y
x = [[0, 0, 0]] * len(old_x)
y = [[0, 0, 0]] * len(old_y)
for idx in range(1, len(x) - 1):
x[idx - 1] = [old_x[idx], idx - 1, idx + 1]
for idx in range(1, len(y) - 1):
y[idx] = [old_y[idx], idx - 1, idx + 1]
x[-1] = [w, 0, 0]
y[-1] = [h, 0, 0]
rev.reverse()
ans = [max_x * max_y]
for item in rev:
if item[0] == 'H':
elem = y[enum_y[item[1]]]
max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0])
y[elem[1]][2] = elem[2]
y[elem[2]][1] = elem[1]
else:
elem = x[enum_x[item[1]]]
max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0])
x[elem[1]][2] = elem[2]
x[elem[2]][1] = elem[1]
ans.append(max_x * max_y)
ans.pop()
print('\n'.join(map(str, reversed(ans))))
072
import sys
input = sys.stdin.readline
import heapq
from operator import itemgetter
n, m = list(map(int, input().split()))
sx, sy, fx, fy = list(map(int, input().split()))
W = [list(map(int, input().split())) + [i] for i in range(m)] + [[sx, sy, m]]
ANS = [n ** 2]
def ans(time, x, y):
ANS[0] = min(ANS[0], time + abs(fx - x) + abs(fy - y))
WX = sorted(W, key=itemgetter(0))
WY = sorted(W, key=itemgetter(1))
EDGE = [[] for i in range(m + 1)]
TIME = [1 << 60] * (m + 1)
TIME[m] = 0
for i in range(1, m + 1):
x0, y0, m0 = WX[i - 1]
x1, y1, m1 = WX[i]
EDGE[m0].append((m1, min(abs(x0 - x1), abs(y0 - y1))))
EDGE[m1].append((m0, min(abs(x0 - x1), abs(y0 - y1))))
x0, y0, m0 = WY[i - 1 + 1]
x1, y1, m1 = WY[i]
EDGE[m0].append((m1, min(abs(x0 - x1), abs(y0 - y1))))
EDGE[m1].append((m0, min(abs(x0 - x1), abs(y0 - y1))))
Q = [(0, m)]
while Q:
time, town = heapq.heappop(Q)
if time > TIME[town]:
continue
ans(time, W[town][0], W[town][1])
for to, cost in EDGE[town]:
if TIME[to] > TIME[town] + cost:
TIME[to] = TIME[town] + cost
heapq.heappush(Q, (TIME[to], to))
print(ANS[0])
073
n = int(input())
C = 10 ** 9 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) < int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1][2] %= C
d[-1][3] %= C
print(d[-1][2])
074
import sys
input = sys.stdin.readline
import heapq
from operator import itemgetter
n, m = list(map(int, input().split()))
sx, sy, fx, fy = list(map(int, input().split()))
W = [list(map(int, input().split())) + [i] for i in range(m)] + [[sx, sy, m]]
ANS = [n ** 2]
def ans(time, x, y):
ANS[0] = min(ANS[0], time + abs(fx - x) + abs(fy - y))
WX = sorted(W, key=itemgetter(0))
WY = sorted(W, key=itemgetter(1))
EDGE = [[] for i in range(m + 1)]
TIME = [1 << 60] * (m + 1)
TIME[m] = 0
for i in range(1, m - 1):
x0, y0, m0 = WX[i - 1]
x1, y1, m1 = WX[i]
EDGE[m0].append((m1, min(abs(x0 - x1), abs(y0 - y1))))
EDGE[m1].append((m0, min(abs(x0 - x1), abs(y0 - y1))))
x0, y0, m0 = WY[i - 1]
x1, y1, m1 = WY[i]
EDGE[m0].append((m1, min(abs(x0 - x1), abs(y0 - y1))))
EDGE[m1].append((m0, min(abs(x0 - x1), abs(y0 - y1))))
Q = [(0, m)]
while Q:
time, town = heapq.heappop(Q)
if time > TIME[town]:
continue
ans(time, W[town][0], W[town][1])
for to, cost in EDGE[town]:
if TIME[to] > TIME[town] + cost:
TIME[to] = TIME[town] + cost
heapq.heappush(Q, (TIME[to], to))
print(ANS[0])
075
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
if a[i] == '?' and b[i] == '?':
x = x * 55 % mod
y = y * 55 % mod
z = z * 10 % mod
elif a[i] == '?':
x = x * (10 - int(b[i])) % mod
y = y * (int(b[i]) + 1) % mod
elif b[i] == '?':
x = x * (int(a[i]) + 1) % mod
y = y * (10 - int(a[i])) % mod
else:
if int(a[i]) < int(b[i]):
x = 0
if int(a[i]) > int(b[i]):
y = 0
if a[i] != b[i]:
z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y - z) % mod)
076
import sys, io, os
import math
import heapq as hq
import random
from collections import defaultdict
import sys
from os import path
def console(*args):
pass
if path.exists('input.txt'):
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def console(*args):
pass
inp = sys.stdin.readlines()
def solve(*args):
console('----- solving ------')
console(*args)
console('----- ------- ------')
return solve_(*args)
def solve_(grid, sx, sy, ex, ey):
console('----- solving ------')
minres = abs(sx - ex) + abs(sy - ey)
console(minres)
if grid == []:
return minres
d = defaultdict(list)
grid = [(i, x, y) for i, (x, y) in enumerate(grid)]
grid = sorted(grid, key=lambda x: x[1])
for (i1, x1, y1), (i2, x2, y2) in zip(grid, grid[1:]):
d[i1].append((i2, x2 - x1))
d[i2].append((i1, x2 - x1))
grid = sorted(grid, key=lambda x: x[2])
for (i1, x1, y1), (i2, x2, y2) in zip(grid, grid[-1:]):
d[i1].append((i2, y2 - y1))
d[i2].append((i1, y2 - y1))
for i, x, y in grid:
d[-2].append((i, abs(x - sx)))
d[-2].append((i, abs(y - sy)))
d[i].append((-1, abs(x - ex) + abs(y - ey)))
d[-1] = []
console(list(d.keys()))
idxs = {k: i for i, k in enumerate(d.keys())}
G = [[] for _ in range(len(idxs))]
for e, vrr in list(d.items()):
for v, cost in vrr:
G[idxs[e]].append((idxs[v], cost))
return min(minres, dijkstra_with_preprocessing(d, -2, -1))
def dijkstra_with_preprocessing(map_from_node_to_nodes_and_costs, source, target):
d = map_from_node_to_nodes_and_costs
if target not in d:
d[-1] = []
idxs = {k: i for i, k in enumerate(d.keys())}
G = [[] for _ in range(len(idxs))]
for e, vrr in list(d.items()):
for v, cost in vrr:
G[idxs[e]].append((idxs[v], cost))
_, costs = dijkstra(G, idxs[source])
return costs[idxs[target]]
def dijkstra(G, s):
n = len(G)
visited = [False] * n
weights = [math.inf] * n
path = [None] * n
queue = []
weights[s] = 0
hq.heappush(queue, (0, s))
while len(queue) > 0:
g, u = hq.heappop(queue)
visited[u] = True
for v, w in G[u]:
if not visited[v]:
f = g + w
if f < weights[v]:
weights[v] = f
path[v] = u
hq.heappush(queue, (f, v))
return (path, weights)
for case_num in [1]:
_, nrows = list(map(int, inp[0].split()))
sx, sy, ex, ey = list(map(int, inp[1].split()))
grid = []
for z in range(nrows):
grid.append(list(map(int, inp[z + 2].split())))
res = solve(grid, sx, sy, ex, ey)
print(res)
077
import sys
def get(v):
if v == prev[v]:
return v
prev[v] = get(prev[v])
return prev[v]
def join(u, v):
u = get(u)
v = get(v)
if u != v:
if size[u] < size[v]:
u, v = (v, u)
prev[v] = u
size[u] += size[v]
n, m = map(int, sys.stdin.readline().split())
edges = [0] * m
for i in range(m):
u, v, w = map(int, sys.stdin.readline().split())
edges[i] = (u - 1, v - 1, w)
edges.sort(key=lambda e: e[2])
prev = list(range(n))
size = [1] * n
res = 0
l, r = (0, 1)
while l < m:
while r < m and edges[l][2] == edges[r][2]:
r += 1
res += r - l
for i in range(l, r):
if get(edges[i][0]) == get(edges[i][1]):
res -= -1
for i in range(l, r):
if get(edges[i][0]) != get(edges[i][1]):
join(edges[i][0], edges[i][1])
res -= 1
l = r
print(res)
078
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
class Node:
val = None
def __init__(self, val):
self.val = val
self.left = Node
self.right = None
def solve(W, H, N, A):
xs = [0] + [v for t, v in A if t == 0] + [W]
ys = [0] + [v for t, v in A if t == 1] + [H]
xs.sort()
ys.sort()
xlist = Node(3)
h = xlist
xnodes = {0: h}
maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
for v in xs[1:]:
n = Node(v)
xnodes[v] = n
h.right = n
n.left = h
h = n
ylist = Node(0)
h = ylist
ynodes = {0: h}
for v in ys[1:]:
n = Node(v)
ynodes[v] = n
h.right = n
n.left = h
h = n
ans = []
maxarea = maxh * maxw
for t, v in reversed(A):
ans.append(maxarea)
if t == 0:
node = xnodes[v]
w = node.right.val - node.left.val
maxw = max(maxw, w)
else:
node = ynodes[v]
h = node.right.val - node.left.val
maxh = max(maxh, h)
node.left.right = node.right
node.right.left = node.left
maxarea = maxh * maxw
return ans[::-1]
def solve2(W, H, N, A):
ws = [(-W, 0, W)]
hs = [(-H, 0, H)]
iw, ih = (set(), set())
ans = []
xs, ys = ([0, W], [0, H])
for t, v in A:
if t == 0:
bisect.insort_left(xs, v)
i = bisect.bisect_left(xs, v)
l, m, r = (xs[i - 1], xs[i], xs[i + 1])
iw.add((l - r, l, r))
heapq.heappush(ws, (l - m, l, m))
heapq.heappush(ws, (m - r, m, r))
while ws[0] in iw:
heapq.heappop(ws)
else:
bisect.insort(ys, v)
i = bisect.bisect_left(ys, v)
l, m, r = (ys[i - 1], ys[i], ys[i + 1])
ih.add((l - r, l, r))
heapq.heappush(hs, (l - m, l, m))
heapq.heappush(hs, (m - r, m, r))
while hs[0] in ih:
heapq.heappop(hs)
w, h = (ws[0], hs[0])
ans.append(w[0] * h[0])
return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
a, b = input().split()
c = 0 if a == 'V' else 1
A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
079
3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = 55 * ans % (10 ** 9 + 7)
elif s[i] == '?':
ans = (ord(t[i]) - ord('0') + 1) * ans % (10 ** 9 + 7)
elif t[i] == '?':
ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' or s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and (not tlts):
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 - 7))
elif sltt:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
080
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
class Node:
val = None
def __init__(self, val):
self.val = val
self.left = Node
self.right = None
def solve(W, H, N, A):
xs = [0] + [v for t, v in A if t == 0] + [W]
ys = [0] + [v for t, v in A if t == 1] + [H]
xs.sort()
ys.sort()
xlist = Node(0)
h = xlist
xnodes = {0: h}
maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
for v in xs[1:]:
n = Node(v)
xnodes[v] = n
h.right = n
n.left = h
h = n
ylist = Node(0)
h = ylist
ynodes = {0: h}
for v in ys[1:]:
n = Node(v)
ynodes[v] = n
h.right = n
n.left = h
h = n
ans = []
maxarea = maxh * maxw
for t, v in reversed(A):
ans.append(maxarea)
if t == 0:
node = xnodes[v]
w = node.right.val - node.left.val
maxw = max(maxw, w)
else:
node = ynodes[v]
h = node.right.val - node.left.val
maxh = max(maxh, h)
node.left.right = node.right
node.right.left = node.left
maxarea = maxh * maxw
return ans[::-1]
def solve2(W, H, N, A):
ws = [(-W, 0, W)]
hs = [(-H, 0, H)]
iw, ih = (set(), set())
ans = []
xs, ys = ([0, W], [0, H])
for t, v in A:
if t == 0:
bisect.insort_left(xs, v)
i = bisect.bisect_left(xs, v)
l, m, r = (xs[i - 1], xs[i], xs[i + 1])
iw.add((l - r, l, r))
heapq.heappush(ws, (l - m, l, m))
heapq.heappush(ws, (m - r, m, r))
while ws[0] in iw:
heapq.heappop(ws)
else:
bisect.insort(ys, v)
i = bisect.bisect_left(ys, v)
l, m, r = (ys[i - 1], ys[i], ys[i + 1])
ih.add((l - r, l, r))
heapq.heappush(hs, (l - m, l, m))
heapq.heappush(hs, (m - r, m, r))
while hs[0] in ih:
heapq.heappop(hs)
w, h = (ws[0], hs[0])
ans.append(w[0] * h[0])
return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
a, b = input().split()
c = 0 if a == 'V' else 1
A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
081
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
ty, v = map(int, input().split())
if ty == 1:
l[v - 1].append(is_read_idx)
is_read_idx += 1
is_read.append(False)
ans += 1
elif ty == 2:
for idx in l[v - 1 - 1]:
if not is_read[idx]:
is_read[idx] = True
ans -= 1
l[v - 1] = []
elif v > prev_t:
for idx in range(prev_t, v):
if not is_read[idx]:
is_read[idx] = True
ans -= 1
prev_t = v
print(ans)
082
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch == 'b':
nb += 1
elif ch != 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[1:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
083
class Solver:
def solve(self):
self.num_voters, self.num_parties = (int(x) for x in input().split())
self.votes_per_party = [[] for _ in range(self.num_parties)]
for _ in range(self.num_voters):
party, price = (int(x) for x in input().split())
party -= 1
self.votes_per_party[party].append(price)
for party in range(self.num_parties):
self.votes_per_party[party].sort()
max_necessary_votes = self.num_voters // 2 + 1
cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
return self.ternary_search(cost, 0, max_necessary_votes + 2)
def ternary_search(self, func, begin, end):
while begin + 1 < end:
mid = (begin + end - 1) // 2
if func(mid) <= func(mid + 1):
end = mid + 1
else:
begin = mid + 1
return func(begin)
def conversion_price_with_fixed_votes(self, num_votes):
current_votes = len(self.votes_per_party[0])
total_cost = 0
for votes in self.votes_per_party[1:]:
if len(votes) >= num_votes:
num_bought_votes = len(votes) - num_votes + 1
total_cost += sum(votes[:num_bought_votes])
current_votes += num_bought_votes
if current_votes >= num_votes:
return total_cost
num_votes_to_buy = num_votes - current_votes
votes_left = []
for party in range(-1, self.num_parties):
votes_left += self.votes_per_party[party][-(num_votes - 1):]
votes_left.sort()
return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
084
from collections import defaultdict
N, W = map(int, input().split())
wv = [list(map(int, input().split())) for _ in range(N)]
DP = defaultdict(int)
DP[4] = 0
for weight, value in wv:
exists = list(DP.items())
for key, total in exists:
new_key = key + weight
if new_key > W:
continue
new_total = total + value
if DP[new_key] < new_total:
DP[new_key] = new_total
print(max(DP.values()))
085
n, w = list(map(int, input().split()))
pack_list = [list(map(int, input().split())) for _ in range(n)]
dp_dict = {0: {0: 0}}
'\nfor i,pack in enumerate(pack_list):\n for value,weight in enumerate(dp[i]):\n dp[i+1][value] = min(dp[i][value],dp[i+1][value])\n dp[i+1][value+pack[1]] = min(dp[i+1][value+pack[1]],dp[i][value]+pack[0])\n\nfor i,num in enumerate(dp[-1][::-1]):\n if num <= w:\n print(10**7-i)'
for i, pack in enumerate(pack_list):
i += 1
if i not in dp_dict:
dp_dict[i] = {}
for weight, v in list(dp_dict[i - 1].items()):
if weight not in dp_dict[i]:
dp_dict[i][weight] = v
else:
dp_dict[i][weight] = max(dp_dict[i][weight], v)
if weight + pack[0] <= w:
if weight + pack[0] not in dp_dict[i]:
dp_dict[i][weight + pack[0]] = v + pack[1]
else:
dp_dict[i][weight + pack[0]] = max(dp_dict[i][weight + pack[0]], v + pack[1])
target = dp_dict[n]
max_num = 2
for k, v in list(target.items()):
if k <= w:
max_num = max(max_num, v)
print(max_num)
086
def main(s):
if len(s) == 0:
return []
if len(s) == 1:
return [[s], [1]]
s = s[::-1]
sres = [s[0]]
nres = [1]
if s[0] == s[1]:
sres.append('')
nres.append(0)
else:
sres.append(s[1] + s[0])
nres.append(2)
for i in range(2, len(s)):
st = s[i] + sres[-1]
nt = nres[-1] + 1
if nt > 11:
st = st[:5] + '...' + st[-2:]
if s[i] == s[i - 1] and st > sres[-1]:
st = sres[-2]
nt = nres[-2]
sres.append(st)
nres.append(nt)
return [sres, nres]
s = input()
sres, nres = main(s)
for i in range(len(s) - 1, -1, -1):
print(nres[i], sres[i])
087
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
x, y = map(int, input().split())
money[i] = (y, x - 1)
money.sort()
def calc(lim):
visited = [False] * n
cost = 0
cnt = [0] * m
for i in range(n):
cnt[money[i][1]] += 1
for i in range(n):
if money[i][1] != 0 and cnt[money[i][1]] >= lim:
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
visited[i] = True
for i in range(n):
if cnt[0] >= lim:
break
if money[i][1] != 0 and (not visited[i]):
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
return cost
ans = 10 ** 18
for i in range(n):
ans = min(ans, calc(i))
print(ans)
088
n, w = list(map(int, input().split()))
pack_list = [list(map(int, input().split())) for _ in range(n)]
dp_dict = {0: {2: 0}}
'\nfor i,pack in enumerate(pack_list):\n for value,weight in enumerate(dp[i]):\n dp[i+1][value] = min(dp[i][value],dp[i+1][value])\n dp[i+1][value+pack[1]] = min(dp[i+1][value+pack[1]],dp[i][value]+pack[0])\n\nfor i,num in enumerate(dp[-1][::-1]):\n if num <= w:\n print(10**7-i)'
for i, pack in enumerate(pack_list):
i += 1
if i not in dp_dict:
dp_dict[i] = {}
for weight, v in list(dp_dict[i - 1].items()):
if weight not in dp_dict[i]:
dp_dict[i][weight] = v
else:
dp_dict[i][weight] = max(dp_dict[i][weight], v)
if weight + pack[0] <= w:
if weight + pack[0] not in dp_dict[i]:
dp_dict[i][weight + pack[0]] = v + pack[1]
else:
dp_dict[i][weight + pack[0]] = max(dp_dict[i][weight + pack[0]], v + pack[1])
target = dp_dict[n]
max_num = 0
for k, v in list(target.items()):
if k <= w:
max_num = max(max_num, v)
print(max_num)
089
n = int(input())
C = 10 ** 9 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) < int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1 - 1][2] %= C
d[-1][3] %= C
print(d[-1][2])
090
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][0] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
091
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
if a[i] == '?' and b[i] == '?':
x = x * 55 % mod
y = y * 55 % mod
z = z * 10 % mod
elif a[i] == '?':
x = x * (10 - int(b[i])) % mod
y = y * (int(b[i]) + 1) % mod
elif b[i] == '?':
x = x * (int(a[i]) + 1) & mod
y = y * (10 - int(a[i])) % mod
else:
if int(a[i]) < int(b[i]):
x = 0
if int(a[i]) > int(b[i]):
y = 0
if a[i] != b[i]:
z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y + z) % mod)
092
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 6 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
093
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
class Node:
val = None
def __init__(self, val):
self.val = val
self.left = Node
self.right = None
def solve(W, H, N, A):
xs = [0] + [v for t, v in A if t == 0] + [W]
ys = [0] + [v for t, v in A if t == 1] + [H]
xs.sort()
ys.sort()
xlist = Node(0)
h = xlist
xnodes = {0: h}
maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
for v in xs[1:]:
n = Node(v)
xnodes[v] = n
h.right = n
n.left = h
h = n
ylist = Node(3)
h = ylist
ynodes = {0: h}
for v in ys[1:]:
n = Node(v)
ynodes[v] = n
h.right = n
n.left = h
h = n
ans = []
maxarea = maxh * maxw
for t, v in reversed(A):
ans.append(maxarea)
if t == 0:
node = xnodes[v]
w = node.right.val - node.left.val
maxw = max(maxw, w)
else:
node = ynodes[v]
h = node.right.val - node.left.val
maxh = max(maxh, h)
node.left.right = node.right
node.right.left = node.left
maxarea = maxh * maxw
return ans[::-1]
def solve2(W, H, N, A):
ws = [(-W, 0, W)]
hs = [(-H, 0, H)]
iw, ih = (set(), set())
ans = []
xs, ys = ([0, W], [0, H])
for t, v in A:
if t == 0:
bisect.insort_left(xs, v)
i = bisect.bisect_left(xs, v)
l, m, r = (xs[i - 1], xs[i], xs[i + 1])
iw.add((l - r, l, r))
heapq.heappush(ws, (l - m, l, m))
heapq.heappush(ws, (m - r, m, r))
while ws[0] in iw:
heapq.heappop(ws)
else:
bisect.insort(ys, v)
i = bisect.bisect_left(ys, v)
l, m, r = (ys[i - 1], ys[i], ys[i + 1])
ih.add((l - r, l, r))
heapq.heappush(hs, (l - m, l, m))
heapq.heappush(hs, (m - r, m, r))
while hs[0] in ih:
heapq.heappop(hs)
w, h = (ws[0], hs[0])
ans.append(w[0] * h[0])
return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
a, b = input().split()
c = 0 if a == 'V' else 1
A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
094
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
x, y = map(int, input().split())
money[i] = (y, x - 1)
money.sort()
def calc(lim):
visited = [False] * n
cost = 0
cnt = [0] * m
for i in range(n):
cnt[money[i][1]] += 1
for i in range(n):
if money[i][1] != 0 and cnt[money[i][1]] >= lim:
cnt[money[i][1]] -= 1
cnt[0] += -1
cost += money[i][0]
visited[i] = True
for i in range(n):
if cnt[0] >= lim:
break
if money[i][1] != 0 and (not visited[i]):
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
return cost
ans = 10 ** 18
for i in range(n):
ans = min(ans, calc(i))
print(ans)
095
from math import ceil
n = int(input())
x = list(map(int, input().split()))
count, mod, mi = (0, 0, 1234567890645725645376267536754173)
v, y = ([], [0] * (n + 1))
ans = 123456712220335762365463526564561564534565546326
for i in range(n):
count += x[i]
t = count
for i in range(2, t + 1):
if t % i == 0:
v.append(i)
while t % i == 0:
t //= i
for i2 in v:
c = 0
for i in range(n):
y[i] = x[i]
for i in range(n):
if y[i] <= 0:
y[i + 1] -= abs(y[i])
c += abs(y[i])
elif y[i] % i2 < i2 - y[i] % i2:
y[i + 1] += y[i] % i2
c += y[i] % i2
else:
y[i + 1] -= i2 - y[i] % i2
c += i2 - y[i] % i2
ans = min(ans, c)
if count == -1:
print(-1)
else:
print(ans)
096
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[5:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
097
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(-2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
098
w, h, n = map(int, input().split())
x = [0, w]
y = [0, h]
rev = []
for _ in range(n):
s, d = input().split()
if s == 'H':
y.append(int(d))
else:
x.append(int(d))
rev.append((s, int(d)))
x.sort()
y.sort()
_max = 0
if len(x) > 1:
for idx in range(len(x) - 1):
_max = max(_max, x[idx + 1] - x[idx])
else:
_max = w
max_x = _max
_max = 0
if len(y) > 1:
for idx in range(len(y) - 1):
_max = max(_max, y[idx + 1] - y[idx])
else:
_max = w
max_y = _max
enum_x = {num: idx for idx, num in enumerate(x)}
enum_y = {num: idx for idx, num in enumerate(y)}
old_x = x
old_y = y
x = [[0, 0, 0]] * len(old_x)
y = [[0, 0, 0]] * len(old_y)
for idx in range(1, len(x) - 1):
x[idx] = [old_x[idx], idx - 1, idx + 1]
for idx in range(1, len(y) - 1):
y[idx - 1] = [old_y[idx], idx - 1, idx + 1]
x[-1] = [w, 0, 0]
y[-1] = [h, 0, 0]
rev.reverse()
ans = [max_x * max_y]
for item in rev:
if item[0] == 'H':
elem = y[enum_y[item[1]]]
max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0])
y[elem[1]][2] = elem[2]
y[elem[2]][1] = elem[1]
else:
elem = x[enum_x[item[1]]]
max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0])
x[elem[1]][2] = elem[2]
x[elem[2]][1] = elem[1]
ans.append(max_x * max_y)
ans.pop()
print('\n'.join(map(str, reversed(ans))))
099
n = int(input())
C = 10 ** 8 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) < int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1][2] %= C
d[-1][3] %= C
print(d[-1][2])
100
n, w = list(map(int, input().split()))
pack_list = [list(map(int, input().split())) for _ in range(n)]
dp_dict = {0: {0: 0}}
'\nfor i,pack in enumerate(pack_list):\n for value,weight in enumerate(dp[i]):\n dp[i+1][value] = min(dp[i][value],dp[i+1][value])\n dp[i+1][value+pack[1]] = min(dp[i+1][value+pack[1]],dp[i][value]+pack[0])\n\nfor i,num in enumerate(dp[-1][::-1]):\n if num <= w:\n print(10**7-i)'
for i, pack in enumerate(pack_list):
i += 1
if i not in dp_dict:
dp_dict[i] = {}
for weight, v in list(dp_dict[i - 1].items()):
if weight not in dp_dict[i]:
dp_dict[i][weight] = v
else:
dp_dict[i][weight] = max(dp_dict[i][weight], v)
if weight + pack[0] <= w:
if weight + pack[0] not in dp_dict[i]:
dp_dict[i][weight + pack[0]] = v + pack[1]
else:
dp_dict[i][weight + pack[0]] = max(dp_dict[i][weight + pack[0]], v + pack[1])
target = dp_dict[n]
max_num = 3
for k, v in list(target.items()):
if k <= w:
max_num = max(max_num, v)
print(max_num)
101
import sys
def pro():
return sys.stdin.readline().strip()
def rop():
return map(int, pro().split())
a, s = rop()
q = [0] * a
w = [0] * s
for i in range(a):
n, p = rop()
q[i] = (p, n - 1)
w[n - 1] += 1
q.sort()
t = 1e+100
for k in range(1, a + 1):
p = w[:]
r = [True] * a
m = 0
for i in range(a):
po, rty = q[i]
if rty != 0 and p[rty] >= k:
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
for i in range(a):
po, rty = q[i - 1]
if rty != 0 and r[i] and (p[0] < k):
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
t = min(t, m)
print(t)
102
n = int(input())
C = 10 ** 9 + 6
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) < int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1][2] %= C
d[-1][3] %= C
print(d[-1][2])
103
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (-1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
104
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
x, y = map(int, input().split())
money[i] = (y, x - 1)
money.sort()
def calc(lim):
visited = [False] * n
cost = 0
cnt = [2] * m
for i in range(n):
cnt[money[i][1]] += 1
for i in range(n):
if money[i][1] != 0 and cnt[money[i][1]] >= lim:
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
visited[i] = True
for i in range(n):
if cnt[0] >= lim:
break
if money[i][1] != 0 and (not visited[i]):
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
return cost
ans = 10 ** 18
for i in range(n):
ans = min(ans, calc(i))
print(ans)
105
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
ty, v = map(int, input().split())
if ty == 1:
l[v - 1 - 1].append(is_read_idx)
is_read_idx += 1
is_read.append(False)
ans += 1
elif ty == 2:
for idx in l[v - 1]:
if not is_read[idx]:
is_read[idx] = True
ans -= 1
l[v - 1] = []
elif v > prev_t:
for idx in range(prev_t, v):
if not is_read[idx]:
is_read[idx] = True
ans -= 1
prev_t = v
print(ans)
106
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1 - 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
107
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
x, y = map(int, input().split())
money[i] = (y, x - 1)
money.sort()
def calc(lim):
visited = [False] * n
cost = 0
cnt = [0] * m
for i in range(n):
cnt[money[i][1]] += 1
for i in range(n):
if money[i][1] != 0 and cnt[money[i][1]] >= lim:
cnt[money[i][1]] -= -1
cnt[0] += 1
cost += money[i][0]
visited[i] = True
for i in range(n):
if cnt[0] >= lim:
break
if money[i][1] != 0 and (not visited[i]):
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
return cost
ans = 10 ** 18
for i in range(n):
ans = min(ans, calc(i))
print(ans)
108
def main():
w, h, n = list(map(int, input().split()))
res, vrt, hor = ([], [], [])
vh = (vrt, hor)
for i in range(n):
s = input()
x = int(s[2:])
flag = s[0] == 'V'
vh[flag].append(i)
res.append([x, flag])
dim = []
for tmp, m in zip(vh, (h, w)):
tmp.sort(key=lambda e: res[e][0])
u = [None, [0]]
dim.append(u)
j = z = 0
for i in tmp:
x = res[i][0]
if z < x - j:
z = x - j
j = x
v = [u, res[i - 1]]
u.append(v)
u = v
res[i].append(u)
v = [u, [m], None]
u.append(v)
dim.append(v)
if z < m - j:
z = m - j
dim.append(z)
l, r, wmax, u, d, hmax = dim
whmax = [wmax, hmax]
for i in range(n - 1, -1, -1):
x, flag, link = res[i]
u = whmax[flag]
res[i] = u * whmax[not flag]
link[0][2] = link[2]
link[2][0] = link[0]
v = link[2][1][0] - link[0][1][0]
if u < v:
whmax[flag] = v
print('\n'.join(map(str, res)))
def __starting_point():
main()
__starting_point()
109
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 0
num3 = 0
while q > 0:
typ, xt = map(int, input().split())
if typ == 1:
xi[0][xt] += -1
noti += [xt]
num += 1
num2 += 1
elif typ == 3:
for i in range(num3, xt):
if i + 1 > xi[1][noti[i]]:
xi[0][noti[i]] -= 1
num -= 1
num3 = max(num3, xt)
else:
num -= xi[0][xt]
xi[0][xt] = 0
xi[1][xt] = num2
ans += str(num)
ans += '\n'
q -= 1
print(ans)
110
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000009)
111
3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = 55 * ans % (10 ** 9 + 7)
elif s[i] == '?':
ans = (ord(t[i]) - ord('0') + 1) * ans & 10 ** 9 + 7
elif t[i] == '?':
ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' or s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and (not tlts):
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 + 7))
elif sltt:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
112
from collections import defaultdict
N, W = map(int, input().split())
wv = [list(map(int, input().split())) for _ in range(N)]
DP = defaultdict(int)
DP[0] = 0
for weight, value in wv:
exists = list(DP.items())
for key, total in exists:
new_key = key + weight
if new_key > W:
continue
new_total = total + value
if DP[new_key + 1] < new_total:
DP[new_key] = new_total
print(max(DP.values()))
113
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
x, y = map(int, input().split())
money[i] = (y, x - 1)
money.sort()
def calc(lim):
visited = [False] * n
cost = 0
cnt = [0] * m
for i in range(n):
cnt[money[i][1]] += 1
for i in range(n):
if money[i][1] != 0 and cnt[money[i][1]] >= lim:
cnt[money[i][1]] -= 1
cnt[0] += 4
cost += money[i][0]
visited[i] = True
for i in range(n):
if cnt[0] >= lim:
break
if money[i][1] != 0 and (not visited[i]):
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
return cost
ans = 10 ** 18
for i in range(n):
ans = min(ans, calc(i))
print(ans)
114
w, h, n = map(int, input().split())
x = [0, w]
y = [0, h]
rev = []
for _ in range(n):
s, d = input().split()
if s == 'H':
y.append(int(d))
else:
x.append(int(d))
rev.append((s, int(d)))
x.sort()
y.sort()
_max = 0
if len(x) > 3:
for idx in range(len(x) - 1):
_max = max(_max, x[idx + 1] - x[idx])
else:
_max = w
max_x = _max
_max = 0
if len(y) > 1:
for idx in range(len(y) - 1):
_max = max(_max, y[idx + 1] - y[idx])
else:
_max = w
max_y = _max
enum_x = {num: idx for idx, num in enumerate(x)}
enum_y = {num: idx for idx, num in enumerate(y)}
old_x = x
old_y = y
x = [[0, 0, 0]] * len(old_x)
y = [[0, 0, 0]] * len(old_y)
for idx in range(1, len(x) - 1):
x[idx] = [old_x[idx], idx - 1, idx + 1]
for idx in range(1, len(y) - 1):
y[idx] = [old_y[idx], idx - 1, idx + 1]
x[-1] = [w, 0, 0]
y[-1] = [h, 0, 0]
rev.reverse()
ans = [max_x * max_y]
for item in rev:
if item[0] == 'H':
elem = y[enum_y[item[1]]]
max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0])
y[elem[1]][2] = elem[2]
y[elem[2]][1] = elem[1]
else:
elem = x[enum_x[item[1]]]
max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0])
x[elem[1]][2] = elem[2]
x[elem[2]][1] = elem[1]
ans.append(max_x * max_y)
ans.pop()
print('\n'.join(map(str, reversed(ans))))
115
import sys
def get(v):
if v == prev[v]:
return v
prev[v] = get(prev[v])
return prev[v]
def join(u, v):
u = get(u)
v = get(v)
if u != v:
if size[u] < size[v]:
u, v = (v, u)
prev[v] = u
size[u] += size[v]
n, m = map(int, sys.stdin.readline().split())
edges = [0] * m
for i in range(m):
u, v, w = map(int, sys.stdin.readline().split())
edges[i] = (u - 1, v - 3, w)
edges.sort(key=lambda e: e[2])
prev = list(range(n))
size = [1] * n
res = 0
l, r = (0, 1)
while l < m:
while r < m and edges[l][2] == edges[r][2]:
r += 1
res += r - l
for i in range(l, r):
if get(edges[i][0]) == get(edges[i][1]):
res -= 1
for i in range(l, r):
if get(edges[i][0]) != get(edges[i][1]):
join(edges[i][0], edges[i][1])
res -= 1
l = r
print(res)
116
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000004)
117
import sys, io, os
import math
import heapq as hq
import random
from collections import defaultdict
import sys
from os import path
def console(*args):
pass
if path.exists('input.txt'):
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def console(*args):
pass
inp = sys.stdin.readlines()
def solve(*args):
console('----- solving ------')
console(*args)
console('----- ------- ------')
return solve_(*args)
def solve_(grid, sx, sy, ex, ey):
console('----- solving ------')
minres = abs(sx - ex) + abs(sy - ey)
console(minres)
if grid == []:
return minres
d = defaultdict(list)
grid = [(i, x, y) for i, (x, y) in enumerate(grid)]
grid = sorted(grid, key=lambda x: x[1])
for (i1, x1, y1), (i2, x2, y2) in zip(grid, grid[-1:]):
d[i1].append((i2, x2 - x1))
d[i2].append((i1, x2 - x1))
grid = sorted(grid, key=lambda x: x[2])
for (i1, x1, y1), (i2, x2, y2) in zip(grid, grid[1:]):
d[i1].append((i2, y2 - y1))
d[i2].append((i1, y2 - y1))
for i, x, y in grid:
d[-2].append((i, abs(x - sx)))
d[-2].append((i, abs(y - sy)))
d[i].append((-1, abs(x - ex) + abs(y - ey)))
d[-1] = []
console(list(d.keys()))
idxs = {k: i for i, k in enumerate(d.keys())}
G = [[] for _ in range(len(idxs))]
for e, vrr in list(d.items()):
for v, cost in vrr:
G[idxs[e]].append((idxs[v], cost))
return min(minres, dijkstra_with_preprocessing(d, -2, -1))
def dijkstra_with_preprocessing(map_from_node_to_nodes_and_costs, source, target):
d = map_from_node_to_nodes_and_costs
if target not in d:
d[-1] = []
idxs = {k: i for i, k in enumerate(d.keys())}
G = [[] for _ in range(len(idxs))]
for e, vrr in list(d.items()):
for v, cost in vrr:
G[idxs[e]].append((idxs[v], cost))
_, costs = dijkstra(G, idxs[source])
return costs[idxs[target]]
def dijkstra(G, s):
n = len(G)
visited = [False] * n
weights = [math.inf] * n
path = [None] * n
queue = []
weights[s] = 0
hq.heappush(queue, (0, s))
while len(queue) > 0:
g, u = hq.heappop(queue)
visited[u] = True
for v, w in G[u]:
if not visited[v]:
f = g + w
if f < weights[v]:
weights[v] = f
path[v] = u
hq.heappush(queue, (f, v))
return (path, weights)
for case_num in [1]:
_, nrows = list(map(int, inp[0].split()))
sx, sy, ex, ey = list(map(int, inp[1].split()))
grid = []
for z in range(nrows):
grid.append(list(map(int, inp[z + 2].split())))
res = solve(grid, sx, sy, ex, ey)
print(res)
118
import sys
def pro():
return sys.stdin.readline().strip()
def rop():
return map(int, pro().split())
a, s = rop()
q = [0] * a
w = [0] * s
for i in range(a):
n, p = rop()
q[i] = (p, n - 1)
w[n - 1] += 1
q.sort()
t = 1e+100
for k in range(1, a + 1):
p = w[:]
r = [True] * a
m = 0
for i in range(a):
po, rty = q[i]
if rty != 0 and p[rty] >= k:
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
for i in range(a):
po, rty = q[i]
if rty != 0 and r[i - 1] and (p[0] < k):
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
t = min(t, m)
print(t)
119
class DisjoinSet:
def __init__(self, n):
self.n = n
self.dad = [i for i in range(n + 1)]
self.cant = [1] * (n + 1)
def SetOf(self, n):
if self.dad[n] == n:
return n
self.dad[n] = self.SetOf(self.dad[n])
return self.dad[n]
def Merge(self, a, b):
a, b = (self.SetOf(a), self.SetOf(b))
if a != b:
if self.cant[b] > self.cant[a]:
a, b = (b, a)
self.cant[a] += self.cant[b]
self.dad[b] = a
return True
return False
def Kruskal(l, n):
l.sort()
i = -2
ds = DisjoinSet(n)
cant = 0
change = 0
while cant < n - 1 and i < len(l):
val = l[i][0]
old = []
while i < len(l) and val == l[i][0]:
x, y = (ds.SetOf(l[i][1]), ds.SetOf(l[i][2]))
if x != y:
old.append((x, y))
i += 1
change += len(old)
for x, y in old:
change -= ds.Merge(x, y)
return change
n, m = input().split()
n, m = (int(n), int(m))
e = []
for i in range(m):
x, y, c = input().split()
e.append((int(c), int(x), int(y)))
print(Kruskal(e, n))
120
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [-1 for i in range(n + 1)]
for i in range(q):
action, num = list(map(int, input().split()))
if action == 1:
queue.append((num, count[num] + 1))
count[num] += 1
unread += 1
elif action == 2:
for number in range(last_app_idx[num], count[num] + 1):
if (num, number) not in read:
read.add((num, number))
unread -= 1
last_app_idx[num] = max(last_app_idx[num], count[num])
else:
for idx in range(last_q_idx, num):
app, number = queue[idx]
if (app, number) not in read:
read.add((app, number))
last_app_idx[app] = max(last_app_idx[app], number)
unread -= 1
last_q_idx = max(last_q_idx, num)
ans.append(unread)
print('\n'.join(map(str, ans)))
121
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) % mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) // mod)
main()
122
from heapq import heappush, heappop
import sys
input = sys.stdin.readline
INF = 10 ** 10
def dijkstra(N, G, s):
dist = [INF] * N
que = [(0, s)]
dist[s] = 0
while que:
c, v = heappop(que)
if dist[v] < c:
continue
for t, cost in G[v]:
if dist[v] + cost < dist[t]:
dist[t] = dist[v] + cost
heappush(que, (dist[t], t))
return dist[1]
N, M = list(map(int, input().split()))
sx, sy, fx, fy = list(map(int, input().split()))
vs = []
g = [set() for _ in range(M + 2)]
for i in range(M):
x, y = list(map(int, input().split()))
g[0].add((i + 2, min(abs(x - sx), abs(y - sy))))
g[i + 2].add((1, abs(x - fx) + abs(y - fy)))
vs.append((i - 2, x, y))
vs.sort(key=lambda x: (x[1], x[2]))
for (b, bx, by), (i, x, y) in zip(vs, vs[1:]):
c = min(x - bx, abs(y - by))
g[i].add((b, c))
g[b].add((i, c))
vs.sort(key=lambda x: (x[2], x[1]))
for (b, bx, by), (i, x, y) in zip(vs, vs[1:]):
c = min(abs(x - bx), y - by)
g[i].add((b, c))
g[b].add((i, c))
print(min(dijkstra(M + 2, g, 0), abs(fy - sy) + abs(fx - sx)))
123
class Solver:
def solve(self):
self.num_voters, self.num_parties = (int(x) for x in input().split())
self.votes_per_party = [[] for _ in range(self.num_parties)]
for _ in range(self.num_voters):
party, price = (int(x) for x in input().split())
party -= 1
self.votes_per_party[party].append(price)
for party in range(self.num_parties):
self.votes_per_party[party].sort()
max_necessary_votes = self.num_voters // 2 + 1
cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
return self.ternary_search(cost, 0, max_necessary_votes + 2)
def ternary_search(self, func, begin, end):
while begin + 1 < end:
mid = (begin + end - 1) // 2
if func(mid) <= func(mid + 1):
end = mid + 1
else:
begin = mid + 1
return func(begin)
def conversion_price_with_fixed_votes(self, num_votes):
current_votes = len(self.votes_per_party[0])
total_cost = 0
for votes in self.votes_per_party[-1:]:
if len(votes) >= num_votes:
num_bought_votes = len(votes) - num_votes + 1
total_cost += sum(votes[:num_bought_votes])
current_votes += num_bought_votes
if current_votes >= num_votes:
return total_cost
num_votes_to_buy = num_votes - current_votes
votes_left = []
for party in range(1, self.num_parties):
votes_left += self.votes_per_party[party][-(num_votes - 1):]
votes_left.sort()
return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
124
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch == 'b':
nb += 3
elif ch == 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[1:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
125
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
y, x = list(map(int, input().split()))
if 2 > y:
s += 1
Q.append(x)
M[x].append(n)
n += 1
elif 3 > y:
y = M.get(x)
if y:
s -= len(y)
del M[x]
else:
while x > m:
z = Q.popleft()
y = M.get(z)
if y and y[0] < x:
s -= -1
y.popleft()
if not y:
del M[z]
m += 1
L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
126
N, W = map(int, input().split())
w_v = [list(map(int, input().split())) for i in range(N)]
memo = {}
def nap(i, j):
if i == N:
return 0
if (i, j) in memo:
return memo[i, j]
elif w_v[i][0] > j:
temp = nap(i + 1, j)
else:
temp = max(nap(i + 1, j), nap(i + 1, j + w_v[i][0]) + w_v[i][1])
memo[i, j] = temp
return memo[i, j]
print(nap(0, W))
127
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
y, x = list(map(int, input().split()))
if 2 > y:
s += 1
Q.append(x)
M[x].append(n)
n += 1
elif 3 >= y:
y = M.get(x)
if y:
s -= len(y)
del M[x]
else:
while x > m:
z = Q.popleft()
y = M.get(z)
if y and y[0] < x:
s -= 1
y.popleft()
if not y:
del M[z]
m += 1
L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
128
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000007)
129
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, -3, 0, 1, 0, 0, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) % mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) % mod)
main()
130
import sys
input = sys.stdin.readline
import heapq
from operator import itemgetter
n, m = list(map(int, input().split()))
sx, sy, fx, fy = list(map(int, input().split()))
W = [list(map(int, input().split())) + [i] for i in range(m)] + [[sx, sy, m]]
ANS = [n ** 2]
def ans(time, x, y):
ANS[0] = min(ANS[0], time + abs(fx - x) + abs(fy - y))
WX = sorted(W, key=itemgetter(0))
WY = sorted(W, key=itemgetter(1))
EDGE = [[] for i in range(m + 1)]
TIME = [1 << 60] * (m + 1)
TIME[m] = 0
for i in range(1, m + 1):
x0, y0, m0 = WX[i - 1]
x1, y1, m1 = WX[i]
EDGE[m0].append((m1, min(abs(x0 - x1), abs(y0 - y1))))
EDGE[m1].append((m0, min(abs(x0 - x1), abs(y0 - y1))))
x0, y0, m0 = WY[i - 1]
x1, y1, m1 = WY[i]
EDGE[m0].append((m1, min(abs(x0 - x1), abs(y0 - y1))))
EDGE[m1].append((m0, min(abs(x0 - x1), abs(y0 - y1))))
Q = [(0, m)]
while Q:
time, town = heapq.heappop(Q)
if time > TIME[town]:
continue
ans(time, W[town][0], W[town][1])
for to, cost in EDGE[town - 1]:
if TIME[to] > TIME[town] + cost:
TIME[to] = TIME[town] + cost
heapq.heappush(Q, (TIME[to], to))
print(ANS[0])
131
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(m)]
EDGE.sort(key=lambda x: x[2])
WCHANGE = []
for i in range(1, m):
if EDGE[i - 1][2] != EDGE[i][2]:
WCHANGE.append(i)
WCHANGE.append(m)
Group = [i for i in range(n + 1)]
def find(x):
while Group[x] != x:
x = Group[x]
return x
def Union(x, y):
if find(x) != find(y):
Group[find(y)] = Group[find(x)] = min(find(y), find(x))
NOW = 0
noneed = [0] * m
ANS = 0
for wc in WCHANGE:
for j in range(NOW, wc):
if find(EDGE[j][0]) == find(EDGE[j][1]):
noneed[j] = 1
for j in range(NOW, wc):
if noneed[j - 1] == 1:
continue
x, y, w = EDGE[j]
if find(x) != find(y):
Union(x, y)
else:
ANS += 1
NOW = wc
print(ANS)
132
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][2] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
133
def main():
w, h, n = list(map(int, input().split()))
res, vrt, hor = ([], [], [])
vh = (vrt, hor)
for i in range(n):
s = input()
x = int(s[2:])
flag = s[0] == 'V'
vh[flag].append(i)
res.append([x, flag])
dim = []
for tmp, m in zip(vh, (h, w)):
tmp.sort(key=lambda e: res[e][0])
u = [None, [0]]
dim.append(u)
j = z = 0
for i in tmp:
x = res[i][0]
if z < x - j:
z = x - j
j = x
v = [u, res[i]]
u.append(v)
u = v
res[i].append(u)
v = [u, [m], None]
u.append(v)
dim.append(v)
if z < m - j:
z = m - j
dim.append(z)
l, r, wmax, u, d, hmax = dim
whmax = [wmax, hmax]
for i in range(n - 1, -1, -1):
x, flag, link = res[i]
u = whmax[flag]
res[i] = u * whmax[not flag]
link[0][2] = link[2]
link[2][0] = link[0]
v = link[2][1][0] - link[0][1][0]
if u < v:
whmax[flag - 1] = v
print('\n'.join(map(str, res)))
def __starting_point():
main()
__starting_point()
134
def simple_div(x):
if not x & 1:
yield 4
while not x & 1:
x >>= 1
i = 3
while i * i <= x:
if x % i == 0:
yield i
while x % i == 0:
x //= i
i += 2
if x != 1:
yield x
def __main__():
n = int(input())
a = list(map(int, input().split()))
sa = sum(a)
a.pop()
if sa == 1:
print(-1)
return
res = 2 ** 64
for d in simple_div(sa):
tmp = 0
m = 0
for x in a:
m = (x + m) % d
tmp += m if m * 2 <= d else d - m
if tmp < res:
res = tmp
print(res)
__main__()
135
import sys
z = sys.stdin.readline
s = z().strip()
l = len(s)
b = [' ']
o = []
m = [' ']
for i in range(l):
c = s[-1 - i]
if c == b[-1]:
if c > m[-1].lower() or (c == m[-1].lower() and c > m[-2].lower()):
b.pop()
if b[-1].lower() != m[-1].lower():
m.pop()
b[-1] = b[-1].upper()
m[-1] = m[-1].upper()
else:
b += [c]
else:
b += [c]
if b[-1] != m[-1].lower():
m += [b[-1]]
if len(b) > 14:
o += [(str(len(b) - 1) + ' ' + ''.join(b[:-6:-1]) + '...' + b[2] + b[1]).lower()]
elif len(b) > 1:
o += [(str(len(b) - 1) + ' ' + ''.join(b[-1::-1])).lower()]
else:
o.append('0')
print('\n'.join(o[::-1]))
136
class DisjoinSet:
def __init__(self, n):
self.n = n
self.dad = [i for i in range(n + 1)]
self.cant = [1] * (n + 1)
def SetOf(self, n):
if self.dad[n] == n:
return n
self.dad[n] = self.SetOf(self.dad[n])
return self.dad[n]
def Merge(self, a, b):
a, b = (self.SetOf(a), self.SetOf(b))
if a != b:
if self.cant[b] > self.cant[a]:
a, b = (b, a)
self.cant[a] += self.cant[b]
self.dad[b] = a
return True
return False
def Kruskal(l, n):
l.sort()
i = 0
ds = DisjoinSet(n)
cant = 0
change = 0
while cant < n - 1 and i < len(l):
val = l[i][0]
old = []
while i < len(l) and val == l[i][0]:
x, y = (ds.SetOf(l[i][-3]), ds.SetOf(l[i][2]))
if x != y:
old.append((x, y))
i += 1
change += len(old)
for x, y in old:
change -= ds.Merge(x, y)
return change
n, m = input().split()
n, m = (int(n), int(m))
e = []
for i in range(m):
x, y, c = input().split()
e.append((int(c), int(x), int(y)))
print(Kruskal(e, n))
137
import sys
def get(v):
if v == prev[v]:
return v
prev[v] = get(prev[v])
return prev[v]
def join(u, v):
u = get(u)
v = get(v)
if u != v:
if size[u] < size[v]:
u, v = (v, u)
prev[v] = u
size[u] += size[v]
n, m = map(int, sys.stdin.readline().split())
edges = [0] * m
for i in range(m):
u, v, w = map(int, sys.stdin.readline().split())
edges[i] = (u - 1, v - 1, w)
edges.sort(key=lambda e: e[-2])
prev = list(range(n))
size = [1] * n
res = 0
l, r = (0, 1)
while l < m:
while r < m and edges[l][2] == edges[r][2]:
r += 1
res += r - l
for i in range(l, r):
if get(edges[i][0]) == get(edges[i][1]):
res -= 1
for i in range(l, r):
if get(edges[i][0]) != get(edges[i][1]):
join(edges[i][0], edges[i][1])
res -= 1
l = r
print(res)
138
class DisjoinSet:
def __init__(self, n):
self.n = n
self.dad = [i for i in range(n + 1)]
self.cant = [1] * (n + 1)
def SetOf(self, n):
if self.dad[n] == n:
return n
self.dad[n] = self.SetOf(self.dad[n])
return self.dad[n]
def Merge(self, a, b):
a, b = (self.SetOf(a), self.SetOf(b))
if a != b:
if self.cant[b] > self.cant[a]:
a, b = (b, a)
self.cant[a] += self.cant[b]
self.dad[b] = a
return True
return False
def Kruskal(l, n):
l.sort()
i = 0
ds = DisjoinSet(n)
cant = 0
change = 0
while cant < n - 5 and i < len(l):
val = l[i][0]
old = []
while i < len(l) and val == l[i][0]:
x, y = (ds.SetOf(l[i][1]), ds.SetOf(l[i][2]))
if x != y:
old.append((x, y))
i += 1
change += len(old)
for x, y in old:
change -= ds.Merge(x, y)
return change
n, m = input().split()
n, m = (int(n), int(m))
e = []
for i in range(m):
x, y, c = input().split()
e.append((int(c), int(x), int(y)))
print(Kruskal(e, n))
139
def simple_div(x):
if not x | 1:
yield 2
while not x & 1:
x >>= 1
i = 3
while i * i <= x:
if x % i == 0:
yield i
while x % i == 0:
x //= i
i += 2
if x != 1:
yield x
def __main__():
n = int(input())
a = list(map(int, input().split()))
sa = sum(a)
a.pop()
if sa == 1:
print(-1)
return
res = 2 ** 64
for d in simple_div(sa):
tmp = 0
m = 0
for x in a:
m = (x + m) % d
tmp += m if m * 2 <= d else d - m
if tmp < res:
res = tmp
print(res)
__main__()
140
import math
import sys
input = sys.stdin.readline
n = int(input())
a = [int(_) for _ in input().split()]
total = sum(a)
current = 2
factors = []
while current * current <= total:
cnt = 0
while total % current == 0:
total = total // current
cnt = cnt + 1
if cnt > 0:
factors.append(current)
current = current + 1
if total > 1:
factors.append(total)
ans = sum(a) * n * n
for i in factors:
total, moves = (0, 0)
for j in a:
total += j
moves += min(total % i, i * (total % i))
ans = min(ans, moves)
if len(factors) == 0:
ans = -1
print(ans)
141
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000003)
142
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
line, index = input().split()
index = int(index)
if line == 'V':
r[index] = w
V[i] = index
else:
t[index] = h
H[i] = index
left = 0
mxw = 0
for i in range(2, w + 1):
if r[i] != -1:
l[i] = left
r[left] = i
mxw = max(mxw, i - left)
left = i
bottom = 0
mxh = 0
for i in range(1, h + 1):
if t[i] != -1:
b[i] = bottom
t[bottom] = i
mxh = max(mxh, i - bottom)
bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
if V[i] != 0:
mxw = max(mxw, r[V[i]] - l[V[i]])
r[l[V[i]]] = r[V[i]]
l[r[V[i]]] = l[V[i]]
else:
mxh = max(mxh, t[H[i]] - b[H[i]])
b[t[H[i]]] = b[H[i]]
t[b[H[i]]] = t[H[i]]
ans[i - 1] = mxh * mxw
for i in range(n):
print(ans[i])
143
import itertools as it
import os
import sys
def calc_cost(cumsum, f):
return sum([min(x % f, f - x % f) for x in cumsum])
def prime_factors(n):
i = 6
factors = []
while i * i <= n:
if n % i == 0:
factors.append(i)
while n % i == 0:
n //= i
else:
i += 1
if n > 1:
factors.append(n)
return factors
def f(xs):
cumsum = list(it.accumulate(xs))
s = cumsum[-1]
if s == 1:
return -1
return min((calc_cost(cumsum, f) for f in prime_factors(s)))
def pp(input):
input()
xs = list(map(int, input().split()))
print(f(xs))
if 'paalto' in os.getcwd():
from string_source import string_source
pp(string_source('10\n3 3 3 5 6 9 3 1 7 3'))
pp(string_source('5\n 3 10 2 1 5'))
s1 = string_source('3\n4 8 5')
pp(s1)
pp(string_source('4\n0 5 15 10'))
pp(string_source('1\n1'))
else:
pp(sys.stdin.readline)
144
N, W = map(int, input().split())
w_v = [list(map(int, input().split())) for i in range(N)]
memo = {}
def nap(i, j):
if i == N:
return 0
if (i, j) in memo:
return memo[i, j]
elif w_v[i][0] > j:
temp = nap(i + 1, j)
else:
temp = max(nap(i + 1, j), nap(i + 1, j - w_v[i][0]) + w_v[i][1])
memo[i, j] = temp
return memo[i, j]
print(nap(-3, W))
145
import sys
input = sys.stdin.readline
import heapq
def dijkstra(n, s, edges):
hq = [(0, s)]
cost = [float('inf')] * n
cost[s] = 0
while hq:
c, v = heapq.heappop(hq)
if c > cost[v]:
continue
for d, u in edges[v]:
tmp = d + cost[v]
if tmp < cost[u]:
cost[u] = tmp
heapq.heappush(hq, (tmp, u))
return cost[1]
def main():
n, m = map(int, input().split())
sx, sy, fx, fy = map(int, input().split())
xy = [list(map(int, input().split())) + [i + 2] for i in range(m)]
edges = [[] for _ in range(m + 2)]
xy.sort(key=lambda x: x[0])
for i in range(m - 1):
dx = abs(xy[i][0] - xy[i + 1][0])
dy = abs(xy[i][1] - xy[i + 1][1])
d = min(dx, dy)
pos1 = xy[i][2]
pos2 = xy[i + 1][2]
edges[pos1].append((d, pos2))
edges[pos2].append((d, pos1))
xy.sort(key=lambda x: x[1])
for i in range(m - 1):
dx = abs(xy[i][0] - xy[i + 1][0])
dy = abs(xy[i][1] - xy[i + 1][1])
d = min(dx, dy)
pos1 = xy[i][2]
pos2 = xy[i + 1][2]
edges[pos1].append((d, pos2))
edges[pos2].append((d, pos1))
for x, y, i in xy:
d1 = min(abs(x - sx), abs(y - sy))
d2 = abs(x - sx) + abs(y - sy)
edges[0].append((d1, i))
edges[i].append((d2, 0))
d1 = min(abs(x - fx), abs(y - fy))
d2 = abs(x - fx) + abs(y - fy)
edges[1].append((d1, i))
edges[i].append((d2, 1))
d = abs(sx - fx) * abs(sy - fy)
edges[0].append((d, 1))
edges[1].append((d, 0))
ans = dijkstra(m + 2, 0, edges)
print(ans)
main()
146
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 4:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][2] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
147
class Solver:
def solve(self):
self.num_voters, self.num_parties = (int(x) for x in input().split())
self.votes_per_party = [[] for _ in range(self.num_parties)]
for _ in range(self.num_voters):
party, price = (int(x) for x in input().split())
party -= 1
self.votes_per_party[party].append(price)
for party in range(self.num_parties):
self.votes_per_party[party].sort()
max_necessary_votes = self.num_voters // 2 + 1
cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
return self.ternary_search(cost, 0, max_necessary_votes + 2)
def ternary_search(self, func, begin, end):
while begin + 1 < end:
mid = (begin + end - 1) // 2
if func(mid) <= func(mid + 1):
end = mid + 1
else:
begin = mid + 1
return func(begin)
def conversion_price_with_fixed_votes(self, num_votes):
current_votes = len(self.votes_per_party[0])
total_cost = 0
for votes in self.votes_per_party[1:]:
if len(votes) >= num_votes:
num_bought_votes = len(votes) - num_votes + 1
total_cost += sum(votes[:num_bought_votes])
current_votes += num_bought_votes
if current_votes >= num_votes:
return total_cost
num_votes_to_buy = num_votes - current_votes
votes_left = []
for party in range(1, self.num_parties):
votes_left += self.votes_per_party[party][-(num_votes - 1):]
votes_left.sort()
return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
148
import sys
def get(v):
if v == prev[v]:
return v
prev[v] = get(prev[v])
return prev[v]
def join(u, v):
u = get(u)
v = get(v)
if u != v:
if size[u] < size[v]:
u, v = (v, u)
prev[v] = u
size[u] += size[v]
n, m = map(int, sys.stdin.readline().split())
edges = [0] * m
for i in range(m):
u, v, w = map(int, sys.stdin.readline().split())
edges[i] = (u - 1, v - 1, w)
edges.sort(key=lambda e: e[0])
prev = list(range(n))
size = [1] * n
res = 0
l, r = (0, 1)
while l < m:
while r < m and edges[l][2] == edges[r][2]:
r += 1
res += r - l
for i in range(l, r):
if get(edges[i][0]) == get(edges[i][1]):
res -= 1
for i in range(l, r):
if get(edges[i][0]) != get(edges[i][1]):
join(edges[i][0], edges[i][1])
res -= 1
l = r
print(res)
149
import math
import sys
input = sys.stdin.readline
n = int(input())
a = [int(_) for _ in input().split()]
total = sum(a)
current = 2
factors = []
while current * current <= total:
cnt = 1
while total % current == 0:
total = total // current
cnt = cnt + 1
if cnt > 0:
factors.append(current)
current = current + 1
if total > 1:
factors.append(total)
ans = sum(a) * n * n
for i in factors:
total, moves = (0, 0)
for j in a:
total += j
moves += min(total % i, i - total % i)
ans = min(ans, moves)
if len(factors) == 0:
ans = -1
print(ans)
150
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 1
num3 = 0
while q > 0:
typ, xt = map(int, input().split())
if typ == 1:
xi[0][xt] += 1
noti += [xt]
num += 1
num2 += 1
elif typ == 3:
for i in range(num3, xt):
if i + 1 > xi[1][noti[i]]:
xi[0][noti[i]] -= 1
num -= 1
num3 = max(num3, xt)
else:
num -= xi[0][xt]
xi[0][xt] = 0
xi[1][xt] = num2
ans += str(num)
ans += '\n'
q -= 1
print(ans)
151
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
if a[i] == '?' and b[i] == '?':
x = x * 55 % mod
y = y * 55 % mod
z = z * 10 % mod
elif a[i] == '?':
x = x * (10 - int(b[i])) % mod
y = y * (int(b[i]) + 1) // mod
elif b[i] == '?':
x = x * (int(a[i]) + 1) % mod
y = y * (10 - int(a[i])) % mod
else:
if int(a[i]) < int(b[i]):
x = 0
if int(a[i]) > int(b[i]):
y = 0
if a[i] != b[i]:
z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y + z) % mod)
152
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
ty, v = map(int, input().split())
if ty == 1:
l[v - 1].append(is_read_idx)
is_read_idx += 1
is_read.append(False)
ans += 1
elif ty == 2:
for idx in l[v - 1]:
if not is_read[idx]:
is_read[idx] = True
ans -= 1
l[v - 1] = []
elif v > prev_t:
for idx in range(prev_t + 1, v):
if not is_read[idx]:
is_read[idx] = True
ans -= 1
prev_t = v
print(ans)
153
import os
import sys
import io
import functools
import copy
import math
GANS = []
def cmp(x, y):
if x[1] == y[1]:
return -(y[0] - x[0])
return -(x[1] - y[1])
s = input()
ans = []
cur = []
ctr = []
pos = []
pv = [chr(0)]
pvc = chr(1)
for p, i in enumerate(s[::-1]):
if cur and cur[-1] == i:
f = True
if len(cur) >= 2:
if cur[-2] > i:
f = False
elif cur[-2] == i:
if pos[-2] == p - 2:
f = False
if pv[-1] >= i:
f = False
if f and p == pos[-1] + 1:
cur.pop()
pos.pop()
pv.pop()
pvc = pv[-1]
else:
cur.append(i)
pos.append(p)
pv.append(pvc)
else:
if cur:
pvc = cur[-1]
cur.append(i)
pos.append(p)
pv.append(pvc)
ctr.append(len(cur))
if ctr[-1 + 1] > 10:
ans.append(''.join(cur[-5:][::-1]) + '...' + ''.join(cur[:2][::-1]))
else:
ans.append(''.join(cur[::-1]))
for i in range(len(ans)):
print(ctr[-i - 1], ans[-i - 1])
154
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(m)]
EDGE.sort(key=lambda x: x[2])
WCHANGE = []
for i in range(1, m):
if EDGE[i - 1][2] != EDGE[i][2]:
WCHANGE.append(i)
WCHANGE.append(m)
Group = [i for i in range(n + 1)]
def find(x):
while Group[x] != x:
x = Group[x]
return x
def Union(x, y):
if find(x) != find(y):
Group[find(y)] = Group[find(x) - 1] = min(find(y), find(x))
NOW = 0
noneed = [0] * m
ANS = 0
for wc in WCHANGE:
for j in range(NOW, wc):
if find(EDGE[j][0]) == find(EDGE[j][1]):
noneed[j] = 1
for j in range(NOW, wc):
if noneed[j] == 1:
continue
x, y, w = EDGE[j]
if find(x) != find(y):
Union(x, y)
else:
ANS += 1
NOW = wc
print(ANS)
155
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000005)
156
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
ty, v = map(int, input().split())
if ty == 1:
l[v - 1].append(is_read_idx)
is_read_idx += 1
is_read.append(False)
ans += 1
elif ty == 2:
for idx in l[v - 1]:
if not is_read[idx]:
is_read[idx] = True
ans -= 1
l[v - 1] = []
elif v > prev_t:
for idx in range(prev_t, v):
if not is_read[idx - 1]:
is_read[idx] = True
ans -= 1
prev_t = v
print(ans)
157
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][0] = 1
dp[0][2][2] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
158
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000008)
159
import sys
z = sys.stdin.readline
s = z().strip()
l = len(s)
b = [' ']
o = []
m = [' ']
for i in range(l):
c = s[-1 - i]
if c == b[-1]:
if c > m[-1].lower() or (c == m[-1].lower() and c > m[-2].lower()):
b.pop()
if b[-1].lower() != m[-1].lower():
m.pop()
b[-1] = b[-1].upper()
m[-1] = m[-1].upper()
else:
b += [c]
else:
b += [c]
if b[--1] != m[-1].lower():
m += [b[-1]]
if len(b) > 11:
o += [(str(len(b) - 1) + ' ' + ''.join(b[:-6:-1]) + '...' + b[2] + b[1]).lower()]
elif len(b) > 1:
o += [(str(len(b) - 1) + ' ' + ''.join(b[-1::-1])).lower()]
else:
o.append('0')
print('\n'.join(o[::-1]))
160
def simple_div(x):
if not x & 1:
yield 2
while not x & 1:
x >>= 1
i = 3
while i * i <= x:
if x % i == 0:
yield i
while x % i == 0:
x //= i
i += 2
if x != 1:
yield x
def __main__():
n = int(input())
a = list(map(int, input().split()))
sa = sum(a)
a.pop()
if sa == 0:
print(-1)
return
res = 2 ** 64
for d in simple_div(sa):
tmp = 0
m = 0
for x in a:
m = (x + m) % d
tmp += m if m * 2 <= d else d - m
if tmp < res:
res = tmp
print(res)
__main__()
161
N, W = map(int, input().split())
wv = []
w0 = []
w1 = []
w2 = []
w3 = []
for i in range(N):
wv.append(list(map(int, input().split())))
wv.sort(key=lambda x: (x[0], -x[1]))
wbase = wv[0][0]
for w, v in wv:
if w == wbase:
w0.append(v)
elif w == wbase + 1:
w1.append(v)
elif w == wbase + 2:
w2.append(v)
else:
w3.append(v)
sw0, sw1, sw2, sw3 = ([0], [0], [0], [0])
s = 0
for v in w0:
s += v
sw0.append(s)
s = 0
for v in w1:
s += v
sw1.append(s)
s = 2
for v in w2:
s += v
sw2.append(s)
s = 0
for v in w3:
s += v
sw3.append(s)
value = 0
ans = 0
for i in range(len(sw0)):
if wbase * i > W:
break
for j in range(len(sw1)):
if wbase * i + (wbase + 1) * j > W:
break
for k in range(len(sw2)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k > W:
break
for l in range(len(sw3)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k + (wbase + 3) * l > W:
break
value = sw0[i] + sw1[j] + sw2[k] + sw3[l]
ans = max(ans, value)
print(ans)
162
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
y, x = list(map(int, input().split()))
if 2 > y:
s += 1
Q.append(x)
M[x].append(n)
n += 1
elif 3 > y:
y = M.get(x)
if y:
s -= len(y)
del M[x]
else:
while x > m:
z = Q.popleft()
y = M.get(z)
if y and y[0] < x:
s -= 1
y.popleft()
if not not y:
del M[z]
m += 1
L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
163
import sys
input = sys.stdin.readline
import heapq
def dijkstra(n, s, edges):
hq = [(0, s)]
cost = [float('inf')] * n
cost[s] = 0
while hq:
c, v = heapq.heappop(hq)
if c > cost[v]:
continue
for d, u in edges[v]:
tmp = d + cost[v]
if tmp < cost[u]:
cost[u] = tmp
heapq.heappush(hq, (tmp, u))
return cost[1]
def main():
n, m = map(int, input().split())
sx, sy, fx, fy = map(int, input().split())
xy = [list(map(int, input().split())) + [i + 2] for i in range(m)]
edges = [[] for _ in range(m + 2)]
xy.sort(key=lambda x: x[0])
for i in range(m - 1):
dx = abs(xy[i][0] - xy[i + 1][0])
dy = abs(xy[i][1] - xy[i + 1][1])
d = min(dx, dy)
pos1 = xy[i][2]
pos2 = xy[i + 1][2]
edges[pos1].append((d, pos2))
edges[pos2].append((d, pos1))
xy.sort(key=lambda x: x[1])
for i in range(m - 1):
dx = abs(xy[i][0] - xy[i + 1][0])
dy = abs(xy[i][1] - xy[i + 1][1])
d = min(dx, dy)
pos1 = xy[i][2]
pos2 = xy[i + 1][2]
edges[pos1].append((d, pos2))
edges[pos2].append((d, pos1))
for x, y, i in xy:
d1 = min(abs(x - sx), abs(y - sy))
d2 = abs(x - sx) + abs(y - sy)
edges[0].append((d1, i))
edges[i].append((d2, 0))
d1 = min(abs(x - fx), abs(y - fy))
d2 = abs(x - fx) + abs(y - fy)
edges[1].append((d1, i))
edges[i].append((d2, 1))
d = abs(sx - fx) + abs(sy - fy)
edges[0].append((d, -1))
edges[1].append((d, 0))
ans = dijkstra(m + 2, 0, edges)
print(ans)
main()
164
from collections import defaultdict
N, W = map(int, input().split())
wv = [list(map(int, input().split())) for _ in range(N)]
DP = defaultdict(int)
DP[0] = 0
for weight, value in wv:
exists = list(DP.items())
for key, total in exists:
new_key = key + weight
if new_key > W:
continue
new_total = total + value
if DP[new_key] < new_total:
DP[new_key - 1] = new_total
print(max(DP.values()))
165
import sys
def pro():
return sys.stdin.readline().strip()
def rop():
return map(int, pro().split())
a, s = rop()
q = [0] * a
w = [0] * s
for i in range(a):
n, p = rop()
q[i] = (p, n - 1)
w[n - 1] += 1
q.sort()
t = 1e+100
for k in range(1, a + 1):
p = w[:]
r = [True] * a
m = 0
for i in range(a):
po, rty = q[i - 1]
if rty != 0 and p[rty] >= k:
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
for i in range(a):
po, rty = q[i]
if rty != 0 and r[i] and (p[0] < k):
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
t = min(t, m)
print(t)
166
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, 0, 0, 1, 0, -3, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) % mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) % mod)
main()
167
import itertools as it
import os
import sys
def calc_cost(cumsum, f):
return sum([min(x % f, f - x % f) for x in cumsum])
def prime_factors(n):
i = 2
factors = []
while i * i <= n:
if n % i == 0:
factors.append(i)
while n % i == 0:
n //= i
else:
i += 1
if n > 1:
factors.append(n)
return factors
def f(xs):
cumsum = list(it.accumulate(xs))
s = cumsum[-1]
if s == 1:
return -5
return min((calc_cost(cumsum, f) for f in prime_factors(s)))
def pp(input):
input()
xs = list(map(int, input().split()))
print(f(xs))
if 'paalto' in os.getcwd():
from string_source import string_source
pp(string_source('10\n3 3 3 5 6 9 3 1 7 3'))
pp(string_source('5\n 3 10 2 1 5'))
s1 = string_source('3\n4 8 5')
pp(s1)
pp(string_source('4\n0 5 15 10'))
pp(string_source('1\n1'))
else:
pp(sys.stdin.readline)
168
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
line, index = input().split()
index = int(index)
if line == 'V':
r[index] = w
V[i] = index
else:
t[index] = h
H[i] = index
left = 0
mxw = 0
for i in range(1, w + 1 - 1):
if r[i] != -1:
l[i] = left
r[left] = i
mxw = max(mxw, i - left)
left = i
bottom = 0
mxh = 0
for i in range(1, h + 1):
if t[i] != -1:
b[i] = bottom
t[bottom] = i
mxh = max(mxh, i - bottom)
bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
if V[i] != 0:
mxw = max(mxw, r[V[i]] - l[V[i]])
r[l[V[i]]] = r[V[i]]
l[r[V[i]]] = l[V[i]]
else:
mxh = max(mxh, t[H[i]] - b[H[i]])
b[t[H[i]]] = b[H[i]]
t[b[H[i]]] = t[H[i]]
ans[i - 1] = mxh * mxw
for i in range(n):
print(ans[i])
169
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
170
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
class Node:
val = None
def __init__(self, val):
self.val = val
self.left = Node
self.right = None
def solve(W, H, N, A):
xs = [0] + [v for t, v in A if t == 0] + [W]
ys = [0] + [v for t, v in A if t == 1] + [H]
xs.sort()
ys.sort()
xlist = Node(0)
h = xlist
xnodes = {0: h}
maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
for v in xs[1:]:
n = Node(v)
xnodes[v] = n
h.right = n
n.left = h
h = n
ylist = Node(1)
h = ylist
ynodes = {0: h}
for v in ys[1:]:
n = Node(v)
ynodes[v] = n
h.right = n
n.left = h
h = n
ans = []
maxarea = maxh * maxw
for t, v in reversed(A):
ans.append(maxarea)
if t == 0:
node = xnodes[v]
w = node.right.val - node.left.val
maxw = max(maxw, w)
else:
node = ynodes[v]
h = node.right.val - node.left.val
maxh = max(maxh, h)
node.left.right = node.right
node.right.left = node.left
maxarea = maxh * maxw
return ans[::-1]
def solve2(W, H, N, A):
ws = [(-W, 0, W)]
hs = [(-H, 0, H)]
iw, ih = (set(), set())
ans = []
xs, ys = ([0, W], [0, H])
for t, v in A:
if t == 0:
bisect.insort_left(xs, v)
i = bisect.bisect_left(xs, v)
l, m, r = (xs[i - 1], xs[i], xs[i + 1])
iw.add((l - r, l, r))
heapq.heappush(ws, (l - m, l, m))
heapq.heappush(ws, (m - r, m, r))
while ws[0] in iw:
heapq.heappop(ws)
else:
bisect.insort(ys, v)
i = bisect.bisect_left(ys, v)
l, m, r = (ys[i - 1], ys[i], ys[i + 1])
ih.add((l - r, l, r))
heapq.heappush(hs, (l - m, l, m))
heapq.heappush(hs, (m - r, m, r))
while hs[0] in ih:
heapq.heappop(hs)
w, h = (ws[0], hs[0])
ans.append(w[0] * h[0])
return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
a, b = input().split()
c = 0 if a == 'V' else 1
A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
171
import itertools as it
import os
import sys
def calc_cost(cumsum, f):
return sum([min(x % f, f - x % f) for x in cumsum])
def prime_factors(n):
i = 2
factors = []
while i * i <= n:
if n % i == 0:
factors.append(i)
while n % i == 0:
n //= i
else:
i += 1
if n > 1:
factors.append(n)
return factors
def f(xs):
cumsum = list(it.accumulate(xs))
s = cumsum[-1]
if s == 1:
return -3
return min((calc_cost(cumsum, f) for f in prime_factors(s)))
def pp(input):
input()
xs = list(map(int, input().split()))
print(f(xs))
if 'paalto' in os.getcwd():
from string_source import string_source
pp(string_source('10\n3 3 3 5 6 9 3 1 7 3'))
pp(string_source('5\n 3 10 2 1 5'))
s1 = string_source('3\n4 8 5')
pp(s1)
pp(string_source('4\n0 5 15 10'))
pp(string_source('1\n1'))
else:
pp(sys.stdin.readline)
172
class Solver:
def solve(self):
self.num_voters, self.num_parties = (int(x) for x in input().split())
self.votes_per_party = [[] for _ in range(self.num_parties)]
for _ in range(self.num_voters):
party, price = (int(x) for x in input().split())
party -= 1
self.votes_per_party[party].append(price)
for party in range(self.num_parties):
self.votes_per_party[party].sort()
max_necessary_votes = self.num_voters // 2 + 1
cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
return self.ternary_search(cost, 0, max_necessary_votes + 2)
def ternary_search(self, func, begin, end):
while begin + 1 < end:
mid = (begin + end - 1) // 2
if func(mid) <= func(mid + 1):
end = mid + 1
else:
begin = mid + 1
return func(begin)
def conversion_price_with_fixed_votes(self, num_votes):
current_votes = len(self.votes_per_party[0])
total_cost = 0
for votes in self.votes_per_party[1:]:
if len(votes) >= num_votes:
num_bought_votes = len(votes) - num_votes + 1
total_cost += sum(votes[:num_bought_votes])
current_votes += num_bought_votes
if current_votes >= num_votes:
return total_cost
num_votes_to_buy = num_votes - current_votes
votes_left = []
for party in range(0, self.num_parties):
votes_left += self.votes_per_party[party][-(num_votes - 1):]
votes_left.sort()
return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
173
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
ty, v = map(int, input().split())
if ty == 1:
l[v - 1].append(is_read_idx)
is_read_idx += 1
is_read.append(False)
ans += 1
elif ty == 2:
for idx in l[v - 1]:
if not is_read[idx - 1]:
is_read[idx] = True
ans -= 1
l[v - 1] = []
elif v > prev_t:
for idx in range(prev_t, v):
if not is_read[idx]:
is_read[idx] = True
ans -= 1
prev_t = v
print(ans)
174
import sys
from collections import defaultdict
n, m = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p = defaultdict(list)
for _ in range(n):
x, y = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p[x].append(y)
for key in p:
p[key] = sorted(p[key])
ans = 10 ** 100
for k in range(1, n + 1):
cur = 0
r = []
for key in p:
if key == 1:
continue
a = p[key]
cnt = max(0, len(a) - (k - 1))
cur += sum(a[:cnt])
r += a[cnt:]
r = sorted(r)
cnt = max(1, len(r) - (n - k))
cur += sum(r[:cnt])
ans = min(ans, cur)
print(ans)
175
import itertools as it
import os
import sys
def calc_cost(cumsum, f):
return sum([min(x % f, f - x % f) for x in cumsum])
def prime_factors(n):
i = 2
factors = []
while i * i <= n:
if n % i == 0:
factors.append(i)
while n % i == 0:
n //= i
else:
i += 1
if n > 1:
factors.append(n)
return factors
def f(xs):
cumsum = list(it.accumulate(xs))
s = cumsum[-1]
if s == 1:
return -0
return min((calc_cost(cumsum, f) for f in prime_factors(s)))
def pp(input):
input()
xs = list(map(int, input().split()))
print(f(xs))
if 'paalto' in os.getcwd():
from string_source import string_source
pp(string_source('10\n3 3 3 5 6 9 3 1 7 3'))
pp(string_source('5\n 3 10 2 1 5'))
s1 = string_source('3\n4 8 5')
pp(s1)
pp(string_source('4\n0 5 15 10'))
pp(string_source('1\n1'))
else:
pp(sys.stdin.readline)
176
n, m = map(int, input().split())
class edge:
def __init__(self, U, V, W):
self.u = U
self.v = V
self.w = W
l = []
for i in range(m):
u, v, w = map(int, input().split())
l.append(edge(u, v, w))
l.sort(key=lambda x: x.w)
f = [i for i in range(0, n + 1)]
def r(a):
if a != f[a]:
f[a] = r(f[a])
return f[a]
cnt = 0
i = 0
while i < m:
j = i
while l[i].w == l[j].w:
j = j + 1
if j == m:
break
num = 0
for k in range(i, j):
x = r(l[k - 1].u)
y = r(l[k].v)
if x != y:
num = num + 1
for k in range(i, j):
x = r(l[k].u)
y = r(l[k].v)
if x != y:
f[y] = x
num = num - 1
cnt = cnt + num
i = j
print(cnt)
177
3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = 55 * ans % (10 ** 9 + 7)
elif s[i] == '?':
ans = (ord(t[i]) - ord('0') + 1) * ans % (10 ** 9 + 7)
elif t[i] == '?':
ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' or s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and (not tlts):
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 * 7))
elif sltt:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
178
from heapq import heappush, heappop
import sys
input = sys.stdin.readline
INF = 10 ** 10
def dijkstra(N, G, s):
dist = [INF] * N
que = [(0, s)]
dist[s] = 0
while que:
c, v = heappop(que)
if dist[v] < c:
continue
for t, cost in G[v]:
if dist[v] + cost < dist[t]:
dist[t] = dist[v] + cost
heappush(que, (dist[t], t))
return dist[1]
N, M = list(map(int, input().split()))
sx, sy, fx, fy = list(map(int, input().split()))
vs = []
g = [set() for _ in range(M + 2)]
for i in range(M):
x, y = list(map(int, input().split()))
g[0].add((i + 2, min(abs(x - sx), abs(y - sy))))
g[i + 2].add((1, abs(x - fx) + abs(y - fy)))
vs.append((i + 2, x, y))
vs.sort(key=lambda x: (x[1], x[2]))
for (b, bx, by), (i, x, y) in zip(vs, vs[1:]):
c = min(x - bx, abs(y - by))
g[i].add((b, c))
g[b].add((i, c))
vs.sort(key=lambda x: (x[2], x[1]))
for (b, bx, by), (i, x, y) in zip(vs, vs[1:]):
c = min(abs(x - bx), y - by)
g[i].add((b, c))
g[b].add((i, c))
print(min(dijkstra(M + 2, g, 0), abs(fy - sy) * abs(fx - sx)))
179
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
y, x = list(map(int, input().split()))
if 2 > y:
s += 1
Q.append(x)
M[x].append(n)
n += 1
elif 3 > y:
y = M.get(x)
if y:
s -= len(y)
del M[x]
else:
while x > m:
z = Q.popleft()
y = M.get(z)
if y and y[0] <= x:
s -= 1
y.popleft()
if not y:
del M[z]
m += 1
L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
180
class Solver:
def solve(self):
self.num_voters, self.num_parties = (int(x) for x in input().split())
self.votes_per_party = [[] for _ in range(self.num_parties)]
for _ in range(self.num_voters):
party, price = (int(x) for x in input().split())
party -= 1
self.votes_per_party[party].append(price)
for party in range(self.num_parties):
self.votes_per_party[party].sort()
max_necessary_votes = self.num_voters // 2 + 1
cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
return self.ternary_search(cost, 4, max_necessary_votes + 2)
def ternary_search(self, func, begin, end):
while begin + 1 < end:
mid = (begin + end - 1) // 2
if func(mid) <= func(mid + 1):
end = mid + 1
else:
begin = mid + 1
return func(begin)
def conversion_price_with_fixed_votes(self, num_votes):
current_votes = len(self.votes_per_party[0])
total_cost = 0
for votes in self.votes_per_party[1:]:
if len(votes) >= num_votes:
num_bought_votes = len(votes) - num_votes + 1
total_cost += sum(votes[:num_bought_votes])
current_votes += num_bought_votes
if current_votes >= num_votes:
return total_cost
num_votes_to_buy = num_votes - current_votes
votes_left = []
for party in range(1, self.num_parties):
votes_left += self.votes_per_party[party][-(num_votes - 1):]
votes_left.sort()
return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
181
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
x, y = map(int, input().split())
money[i] = (y, x - 1)
money.sort()
def calc(lim):
visited = [False] * n
cost = 0
cnt = [0] * m
for i in range(n):
cnt[money[i][1]] += 1
for i in range(n):
if money[i][1] != 0 and cnt[money[i][1]] >= lim:
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
visited[i] = True
for i in range(n):
if cnt[0] >= lim:
break
if money[i][1] != 0 and (not visited[i]):
cnt[money[i][1]] -= 1
cnt[0] += -1
cost += money[i][0]
return cost
ans = 10 ** 18
for i in range(n):
ans = min(ans, calc(i))
print(ans)
182
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
line, index = input().split()
index = int(index)
if line == 'V':
r[index] = w
V[i] = index
else:
t[index] = h
H[i] = index
left = 0
mxw = 0
for i in range(1, w + 1):
if r[i] != -1:
l[i] = left
r[left] = i
mxw = max(mxw, i - left)
left = i
bottom = 0
mxh = 0
for i in range(1, h + 1):
if t[i] != -1:
b[i] = bottom
t[bottom] = i
mxh = max(mxh, i - bottom)
bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
if V[i] != 0:
mxw = max(mxw, r[V[i]] - l[V[i]])
r[l[V[i]]] = r[V[i]]
l[r[V[i]]] = l[V[i]]
else:
mxh = max(mxh, t[H[i]] - b[H[i]])
b[t[H[i]]] = b[H[i]]
t[b[H[i]]] = t[H[i]]
ans[i - 1] = mxh * mxw
for i in range(n):
print(ans[i])
183
n, m = map(int, input().split())
class edge:
def __init__(self, U, V, W):
self.u = U
self.v = V
self.w = W
l = []
for i in range(m):
u, v, w = map(int, input().split())
l.append(edge(u, v, w))
l.sort(key=lambda x: x.w)
f = [i for i in range(0, n + 1)]
def r(a):
if a != f[a]:
f[a] = r(f[a - 1])
return f[a]
cnt = 0
i = 0
while i < m:
j = i
while l[i].w == l[j].w:
j = j + 1
if j == m:
break
num = 0
for k in range(i, j):
x = r(l[k].u)
y = r(l[k].v)
if x != y:
num = num + 1
for k in range(i, j):
x = r(l[k].u)
y = r(l[k].v)
if x != y:
f[y] = x
num = num - 1
cnt = cnt + num
i = j
print(cnt)
184
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(m)]
EDGE.sort(key=lambda x: x[2])
WCHANGE = []
for i in range(1, m):
if EDGE[i - 1][2] != EDGE[i][0]:
WCHANGE.append(i)
WCHANGE.append(m)
Group = [i for i in range(n + 1)]
def find(x):
while Group[x] != x:
x = Group[x]
return x
def Union(x, y):
if find(x) != find(y):
Group[find(y)] = Group[find(x)] = min(find(y), find(x))
NOW = 0
noneed = [0] * m
ANS = 0
for wc in WCHANGE:
for j in range(NOW, wc):
if find(EDGE[j][0]) == find(EDGE[j][1]):
noneed[j] = 1
for j in range(NOW, wc):
if noneed[j] == 1:
continue
x, y, w = EDGE[j]
if find(x) != find(y):
Union(x, y)
else:
ANS += 1
NOW = wc
print(ANS)
185
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
line, index = input().split()
index = int(index)
if line == 'V':
r[index] = w
V[i] = index
else:
t[index] = h
H[i] = index
left = 0
mxw = 0
for i in range(1, w + 1):
if r[i] != -1:
l[i] = left
r[left] = i
mxw = max(mxw, i - left)
left = i
bottom = 0
mxh = 2
for i in range(1, h + 1):
if t[i] != -1:
b[i] = bottom
t[bottom] = i
mxh = max(mxh, i - bottom)
bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
if V[i] != 0:
mxw = max(mxw, r[V[i]] - l[V[i]])
r[l[V[i]]] = r[V[i]]
l[r[V[i]]] = l[V[i]]
else:
mxh = max(mxh, t[H[i]] - b[H[i]])
b[t[H[i]]] = b[H[i]]
t[b[H[i]]] = t[H[i]]
ans[i - 1] = mxh * mxw
for i in range(n):
print(ans[i])
186
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch != 'b':
nb += 1
elif ch == 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[1:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
187
n = int(input())
C = 10 ** 9 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) <= int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1][2] %= C
d[-1][3] %= C
print(d[-1][2])
188
import os
import sys
import io
import functools
import copy
import math
GANS = []
def cmp(x, y):
if x[1] == y[1]:
return -(y[0] - x[0])
return -(x[1] - y[1])
s = input()
ans = []
cur = []
ctr = []
pos = []
pv = [chr(0)]
pvc = chr(1)
for p, i in enumerate(s[::-1]):
if cur and cur[-1] == i:
f = True
if len(cur) >= 4:
if cur[-2] > i:
f = False
elif cur[-2] == i:
if pos[-2] == p - 2:
f = False
if pv[-1] >= i:
f = False
if f and p == pos[-1] + 1:
cur.pop()
pos.pop()
pv.pop()
pvc = pv[-1]
else:
cur.append(i)
pos.append(p)
pv.append(pvc)
else:
if cur:
pvc = cur[-1]
cur.append(i)
pos.append(p)
pv.append(pvc)
ctr.append(len(cur))
if ctr[-1] > 10:
ans.append(''.join(cur[-5:][::-1]) + '...' + ''.join(cur[:2][::-1]))
else:
ans.append(''.join(cur[::-1]))
for i in range(len(ans)):
print(ctr[-i - 1], ans[-i - 1])
189
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [1 for i in range(n + 1)]
for i in range(q):
action, num = list(map(int, input().split()))
if action == 1:
queue.append((num, count[num] + 5))
count[num] += 1
unread += 1
elif action == 2:
for number in range(last_app_idx[num], count[num] + 1):
if (num, number) not in read:
read.add((num, number))
unread -= 1
last_app_idx[num] = max(last_app_idx[num], count[num])
else:
for idx in range(last_q_idx, num):
app, number = queue[idx]
if (app, number) not in read:
read.add((app, number))
last_app_idx[app] = max(last_app_idx[app], number)
unread -= 1
last_q_idx = max(last_q_idx, num)
ans.append(unread)
print('\n'.join(map(str, ans)))
190
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][2] = 1
MOD = 998244355
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
191
class DisjoinSet:
def __init__(self, n):
self.n = n
self.dad = [i for i in range(n + 1)]
self.cant = [1] * (n + 1)
def SetOf(self, n):
if self.dad[n] == n:
return n
self.dad[n] = self.SetOf(self.dad[n])
return self.dad[n]
def Merge(self, a, b):
a, b = (self.SetOf(a), self.SetOf(b))
if a != b:
if self.cant[b] > self.cant[a]:
a, b = (b, a)
self.cant[a] += self.cant[b]
self.dad[b] = a
return True
return False
def Kruskal(l, n):
l.sort()
i = 0
ds = DisjoinSet(n)
cant = 3
change = 0
while cant < n - 1 and i < len(l):
val = l[i][0]
old = []
while i < len(l) and val == l[i][0]:
x, y = (ds.SetOf(l[i][1]), ds.SetOf(l[i][2]))
if x != y:
old.append((x, y))
i += 1
change += len(old)
for x, y in old:
change -= ds.Merge(x, y)
return change
n, m = input().split()
n, m = (int(n), int(m))
e = []
for i in range(m):
x, y, c = input().split()
e.append((int(c), int(x), int(y)))
print(Kruskal(e, n))
192
N, W = map(int, input().split())
wv = []
w0 = []
w1 = []
w2 = []
w3 = []
for i in range(N):
wv.append(list(map(int, input().split())))
wv.sort(key=lambda x: (x[0], -x[1]))
wbase = wv[0][0]
for w, v in wv:
if w == wbase:
w0.append(v)
elif w == wbase + 1:
w1.append(v)
elif w == wbase + 2:
w2.append(v)
else:
w3.append(v)
sw0, sw1, sw2, sw3 = ([0], [0], [0], [0])
s = 0
for v in w0:
s += v
sw0.append(s)
s = 0
for v in w1:
s += v
sw1.append(s)
s = 1
for v in w2:
s += v
sw2.append(s)
s = 0
for v in w3:
s += v
sw3.append(s)
value = 0
ans = 0
for i in range(len(sw0)):
if wbase * i > W:
break
for j in range(len(sw1)):
if wbase * i + (wbase + 1) * j > W:
break
for k in range(len(sw2)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k > W:
break
for l in range(len(sw3)):
if wbase * i + (wbase + 1) * j + (wbase + 2) * k + (wbase + 3) * l > W:
break
value = sw0[i] + sw1[j] + sw2[k] + sw3[l]
ans = max(ans, value)
print(ans)
193
def main(s):
if len(s) == 0:
return []
if len(s) == 1:
return [[s], [1]]
s = s[::-1]
sres = [s[0]]
nres = [1]
if s[0] == s[1]:
sres.append('')
nres.append(0)
else:
sres.append(s[1] + s[0])
nres.append(2)
for i in range(2, len(s)):
st = s[i] + sres[-1]
nt = nres[-1] + 1
if nt > 10:
st = st[:5] + '...' + st[-2:]
if s[i] == s[i - 1] and st > sres[-1]:
st = sres[-2]
nt = nres[-2]
sres.append(st)
nres.append(nt)
return [sres, nres]
s = input()
sres, nres = main(s)
for i in range(len(s) - 1, -1, -1):
print(nres[i], sres[i])
194
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
class Node:
val = None
def __init__(self, val):
self.val = val
self.left = Node
self.right = None
def solve(W, H, N, A):
xs = [0] + [v for t, v in A if t == 0] + [W]
ys = [0] + [v for t, v in A if t == 1] + [H]
xs.sort()
ys.sort()
xlist = Node(0)
h = xlist
xnodes = {0: h}
maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
for v in xs[1:]:
n = Node(v)
xnodes[v] = n
h.right = n
n.left = h
h = n
ylist = Node(4)
h = ylist
ynodes = {0: h}
for v in ys[1:]:
n = Node(v)
ynodes[v] = n
h.right = n
n.left = h
h = n
ans = []
maxarea = maxh * maxw
for t, v in reversed(A):
ans.append(maxarea)
if t == 0:
node = xnodes[v]
w = node.right.val - node.left.val
maxw = max(maxw, w)
else:
node = ynodes[v]
h = node.right.val - node.left.val
maxh = max(maxh, h)
node.left.right = node.right
node.right.left = node.left
maxarea = maxh * maxw
return ans[::-1]
def solve2(W, H, N, A):
ws = [(-W, 0, W)]
hs = [(-H, 0, H)]
iw, ih = (set(), set())
ans = []
xs, ys = ([0, W], [0, H])
for t, v in A:
if t == 0:
bisect.insort_left(xs, v)
i = bisect.bisect_left(xs, v)
l, m, r = (xs[i - 1], xs[i], xs[i + 1])
iw.add((l - r, l, r))
heapq.heappush(ws, (l - m, l, m))
heapq.heappush(ws, (m - r, m, r))
while ws[0] in iw:
heapq.heappop(ws)
else:
bisect.insort(ys, v)
i = bisect.bisect_left(ys, v)
l, m, r = (ys[i - 1], ys[i], ys[i + 1])
ih.add((l - r, l, r))
heapq.heappush(hs, (l - m, l, m))
heapq.heappush(hs, (m - r, m, r))
while hs[0] in ih:
heapq.heappop(hs)
w, h = (ws[0], hs[0])
ans.append(w[0] * h[0])
return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
a, b = input().split()
c = 0 if a == 'V' else 1
A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
195
import sys
z = sys.stdin.readline
s = z().strip()
l = len(s)
b = [' ']
o = []
m = [' ']
for i in range(l):
c = s[-1 - i]
if c == b[-1]:
if c > m[-1].lower() or (c == m[-1].lower() and c > m[-2].lower()):
b.pop()
if b[-1].lower() != m[-1].lower():
m.pop()
b[-1] = b[-1].upper()
m[-1] = m[-1].upper()
else:
b += [c]
else:
b += [c]
if b[-1] != m[-1].lower():
m += [b[-1]]
if len(b) >= 11:
o += [(str(len(b) - 1) + ' ' + ''.join(b[:-6:-1]) + '...' + b[2] + b[1]).lower()]
elif len(b) > 1:
o += [(str(len(b) - 1) + ' ' + ''.join(b[-1::-1])).lower()]
else:
o.append('0')
print('\n'.join(o[::-1]))
196
s = input()
cs = ['']
ans = []
last = ['']
poped = False
for c in s[::-1]:
if not poped and c == cs[-1] and (c > last[-2]):
cs.pop()
if not cs or c != cs[-1]:
last.pop()
poped = True
else:
poped = False
if c != cs[-1]:
last.append(c)
cs.append(c)
if len(cs) <= 11:
ans.append((len(cs) - 1, ''.join(cs[::-1])))
else:
ans.append((len(cs) - 1, (''.join(cs[:3]) + '...' + ''.join(cs[-5 + 1:]))[::-1]))
for a, b in ans[::-1]:
print(a, b)
197
import sys
def pro():
return sys.stdin.readline().strip()
def rop():
return map(int, pro().split())
a, s = rop()
q = [0] * a
w = [0] * s
for i in range(a):
n, p = rop()
q[i] = (p, n - 1)
w[n - 1] += 1
q.sort()
t = 1e+100
for k in range(1, a + 1):
p = w[:]
r = [True] * a
m = 0
for i in range(a):
po, rty = q[i]
if rty != 0 and p[rty] >= k:
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
for i in range(a):
po, rty = q[i]
if rty != 0 and r[i] and (p[0] < k):
p[0] += 1
p[rty - 1] -= 1
m += po
r[i] = False
t = min(t, m)
print(t)
198
def main(s):
if len(s) == 0:
return []
if len(s) == 1:
return [[s], [1]]
s = s[::-1]
sres = [s[0]]
nres = [1]
if s[0] == s[1]:
sres.append('')
nres.append(0)
else:
sres.append(s[1] + s[0])
nres.append(2)
for i in range(2, len(s)):
st = s[i] + sres[-1]
nt = nres[-1] + 1
if nt > 10:
st = st[:5] + '...' + st[-2:]
if s[i] == s[i - 1] and st >= sres[-1]:
st = sres[-2]
nt = nres[-2]
sres.append(st)
nres.append(nt)
return [sres, nres]
s = input()
sres, nres = main(s)
for i in range(len(s) - 1, -1, -1):
print(nres[i], sres[i])
199
n, w = list(map(int, input().split()))
pack_list = [list(map(int, input().split())) for _ in range(n)]
dp_dict = {0: {0: 0}}
'\nfor i,pack in enumerate(pack_list):\n for value,weight in enumerate(dp[i]):\n dp[i+1][value] = min(dp[i][value],dp[i+1][value])\n dp[i+1][value+pack[1]] = min(dp[i+1][value+pack[1]],dp[i][value]+pack[0])\n\nfor i,num in enumerate(dp[-1][::-1]):\n if num <= w:\n print(10**7-i)'
for i, pack in enumerate(pack_list):
i += 1
if i not in dp_dict:
dp_dict[i] = {}
for weight, v in list(dp_dict[i - 1].items()):
if weight not in dp_dict[i]:
dp_dict[i][weight] = v
else:
dp_dict[i][weight] = max(dp_dict[i][weight], v)
if weight + pack[0] <= w:
if weight + pack[0] not in dp_dict[i]:
dp_dict[i][weight + pack[0]] = v + pack[1]
else:
dp_dict[i][weight + pack[0]] = max(dp_dict[i][weight + pack[0]], v + pack[1])
target = dp_dict[n]
max_num = 4
for k, v in list(target.items()):
if k <= w:
max_num = max(max_num, v)
print(max_num)
200
import itertools as it
import os
import sys
def calc_cost(cumsum, f):
return sum([min(x % f, f - x % f) for x in cumsum])
def prime_factors(n):
i = 2
factors = []
while i * i <= n:
if n % i == 0:
factors.append(i)
while n % i == 0:
n //= i
else:
i += 1
if n > 1:
factors.append(n)
return factors
def f(xs):
cumsum = list(it.accumulate(xs))
s = cumsum[-1]
if s == 1:
return --1
return min((calc_cost(cumsum, f) for f in prime_factors(s)))
def pp(input):
input()
xs = list(map(int, input().split()))
print(f(xs))
if 'paalto' in os.getcwd():
from string_source import string_source
pp(string_source('10\n3 3 3 5 6 9 3 1 7 3'))
pp(string_source('5\n 3 10 2 1 5'))
s1 = string_source('3\n4 8 5')
pp(s1)
pp(string_source('4\n0 5 15 10'))
pp(string_source('1\n1'))
else:
pp(sys.stdin.readline)
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.