001
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))
002
MAX_SPEED = 300
n = int(input())
actions = [list(map(int, input().split())) for _ in range(n)]
speed = [0 for i in range(n)]
for i in range(n):
if actions[i][0] == 1:
lastSpeed = actions[i][1]
speed[i] = lastSpeed
ignored = 0
overtook = False
maxSpeed = -1
for i in range(n - 1, -1, -1):
maxSpeed = max(maxSpeed, speed[i])
if actions[i][0] == 1:
pass
elif actions[i][0] == 4:
overtook = True
elif actions[i][0] == 3:
if maxSpeed > actions[i][1]:
ignored += 1
else:
maxSpeed = speed[i - 1]
elif actions[i][0] == 4:
overtook = False
elif actions[i][0] == 5:
maxSpeed = speed[i - 1]
elif actions[i][0] == 6:
if overtook:
ignored += 1
print(ignored)
003
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
if L[i] > 0:
D[L[i]] = i
J.append(L[i])
T[i + 1 - 1] = T[i]
else:
T[i + 1] = T[i] + 1
def I(J):
if len(J) <= 1:
return (J, 0)
else:
a = J[:len(J) // 2]
b = J[len(J) // 2:]
a, ai = I(a)
b, bi = I(b)
c = []
i = 0
j = 0
inversions = ai + bi
while i < len(a) and j < len(b):
if a[i] <= b[j]:
c.append(a[i])
i += 1
else:
c.append(b[j])
j += 1
inversions += len(a) - i
c += a[i:]
c += b[j:]
return (c, inversions)
for i in range(1, n + 1):
if not i in D:
S.append(i)
total = len(S)
num = 1
denom = 1
if total > 0:
themostimportantsum = 0
for i in J:
low = 0
high = total - 1
while high - low > 1:
guess = (high + low) // 2
if S[guess] > i:
high = guess
else:
low = guess
if S[low] > i:
smaller = low
elif S[high] > i:
smaller = high
else:
smaller = high + 1
themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
num = themostimportantsum + total
denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
if I(J)[1] == 0:
print(0)
else:
print(I(J)[1] % 998244353)
else:
num += denom * I(J)[1]
print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
004
K = 998244353
def mu(a, n):
if n == 0:
return 1
q = mu(a, n // 2)
if n % 2 == 0:
return q * q % K
return q * q % K * a % K
MAXN = 200005
dd = [-4 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [0 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]
def add(u, v):
i = u
while i <= 200000:
fen[i] += v
i += i & -i
def get(u):
res = 0
i = u
while i > 0:
res += fen[i]
i -= i & -i
return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
p[i] = int(data[i - 1])
if p[i] > 0:
dd[p[i]] = 1
else:
cnt += 1
for i in range(1, n + 1):
if dd[i] == 0:
s[i] = s[i - 1] + 1
else:
s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
if p[i] == -1:
cnt1 += 1
else:
u = cnt - cnt1
P = (P + u * s[p[i]] % K * den % K) % K
P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
if p[i] > 0:
m += 1
a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
P1 = (P1 + get(a[i])) % K
add(a[i], 1)
P = (P + P1) % K
print(P)
005
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)
006
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
d = list(map(int, input().split()))
if k >= 2:
m = max(d[:-1])
print(max(sum(a) - m, a[-1] - d[-1], 0))
elif k == 0:
rightans = [0] * n
cursum = 0
ans = 0
for i in range(n - 1, -1, -1):
cursum += a[i]
rightans[i] = max(cursum - d[i], 0)
print(max(rightans))
else:
leftd = int(1000000000.0)
leftsum = 0
rightans = [0] * n
cursum = 0
ans = 0
for i in range(n - 1, -1, -1):
cursum += a[i]
rightans[i] = max(cursum - d[i], 0)
for i in range(n - 1, 0, -1):
rightans[i - 1] = max(rightans[i - 1], rightans[i])
for i in range(n - 1):
leftd = min(leftd, d[i])
leftsum += a[i]
curans = max(leftsum - leftd, 0) + rightans[i + 1]
ans = max(ans, curans)
cursum = 0
rightmin = int(1000000000.0)
for i in range(n - 1, -1, -1):
cursum += a[i]
ans = max(ans, cursum - rightmin - d[i])
rightmin = min(rightmin, a[i])
print(ans)
007
import sys
sys.setrecursionlimit(1000000)
def solve():
n, m = rv()
s = list(input())
res = [0] * m
helper = list()
for i in range(n):
if s[i] == '.':
if i == 0:
helper.append(1)
elif s[i - 1] == '.':
helper[-1] += 1
else:
helper.append(1)
initval = 0
for val in helper:
initval += val - 1
for query in range(m):
index, replace = input().split()
index = int(index) - 1
if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'):
res[query] = initval
else:
sidedots = 0
if index > 0:
if s[index - 1] == '.':
sidedots += 1
if index < n - 1:
if s[index + 1] == '.':
sidedots += 1
if s[index] == '.':
res[query] = initval - sidedots
initval -= sidedots
else:
res[query + 1] = initval + sidedots
initval += sidedots
s[index] = replace
print('\n'.join(map(str, res)))
def rv():
return list(map(int, input().split()))
def rl(n):
return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544:
sys.stdin = open('test.txt')
solve()
008
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])
def happy_diff(m):
return m.a_happy - m.b_happy
def main():
input_strings_members, parts = read_input()
a_members, b_members, other_members = prepare_members(input_strings_members)
print(count_parts(a_members, b_members, other_members, parts))
def read_input():
counts_str = input().split()
members_count, parts = list(map(int, counts_str))
return ([input() for _ in range(members_count)], parts)
def prepare_members(input_strings_members):
a_members = []
b_members = []
other_members = []
for line in input_strings_members:
m = Member(*list(map(int, line.split())))
if happy_diff(m) > 0:
a_members.append(m)
elif happy_diff(m) < 0:
b_members.append(m)
else:
other_members.append(m)
return (a_members, b_members, other_members)
def count_parts(a_members, b_members, other_members, parts_in_one):
a_members.sort(key=lambda m: happy_diff(m), reverse=False)
a_modulo = sum((m.parts for m in a_members)) % parts_in_one
a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
b_members.sort(key=lambda m: happy_diff(m), reverse=True)
b_modulo = sum((m.parts for m in b_members)) % parts_in_one
b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
return a_happy + b_happy + last_happy
def split_members_into_happy_groups(members, modulo):
modulo_members = []
happy_members = []
current_modulo = 0
for i in range(len(members)):
m = members[i]
new_current_modulo = current_modulo + m.parts
if new_current_modulo < modulo:
modulo_members.append(m)
current_modulo = new_current_modulo
continue
modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
if new_current_modulo > modulo:
happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
if i + 1 < len(members):
happy_members.extend(members[i + 1:])
break
return (modulo_members, happy_members)
def count_last_pizzas_happy(a, b, other, parts_in_one):
last_sorted_members = a + other + b
if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))
def test1():
a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
assert count_parts(a, b, c, 10) == 314
def test2():
a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
assert count_parts(a, b, c, 12) == 84
def test3():
a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
assert count_parts(a, b, c, 3) == 16
def test4():
a, b, c = prepare_members(['2 1 4', '2 3 1'])
assert count_parts(a, b, c, 3) == 14
def test5():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2
def test6():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 5) == 16 + 16 + 3
def test_without_last_pizzas():
a, b, c = prepare_members(['3 3 1', '3 5 6'])
assert count_parts(a, b, c, 3) == 27
def test_with_one_last_pizza():
a, b, c = prepare_members(['2 3 1', '1 5 6'])
assert count_parts(a, b, c, 3) == 11
def test_with_two_last_pizzas():
a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
assert count_parts(a, b, c, 3) == 15
def test_without_different_happies():
a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
assert count_parts(a, b, c, 3) == 38
def __starting_point():
main()
__starting_point()
009
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)
010
from collections import deque
mod = 10 ** 9 + 7
class TreeNode:
def __init__(self, val):
self.val = val
self.edges = {}
def add_edge(self, node, color):
self.edges[node] = color
n, k = list(map(int, input().split()))
tree = []
for i in range(1, n + 1):
tree.append(TreeNode(i))
for _ in range(n - 1):
u, v, x = list(map(int, input().split()))
tree[u - 1].add_edge(v, x)
tree[v - 1].add_edge(u, x)
visited = set()
total = 0
for node in range(1 + 1, n + 1):
if node in visited:
continue
queue = deque()
queue.append(node)
visited.add(node)
red_vertexes = 1
while queue:
vertex = queue.popleft()
for e, c in list(tree[vertex - 1].edges.items()):
if c == 0 and e not in visited:
queue.append(e)
red_vertexes = red_vertexes + 1
visited.add(e)
total = (total + pow(red_vertexes, k, mod)) % mod
total = (pow(n, k, mod) - total) % mod
print(total)
011
L1 = list(map(int, input().split()))
numList = list(map(int, input().split()))
length = L1[0]
targetnumber = L1[1]
pos = numList.index(targetnumber)
pos_r = pos + 1
rem = 0
right = {0: 1}
left = {0: 1}
while pos_r <= length - 1:
if numList[pos_r] > targetnumber:
rem += 1
else:
rem -= 1
if rem not in right:
right[rem] = 1
else:
right[rem] += 1
pos_r += 1
pos_l = pos - 1
rem = 0
while pos_l >= 0:
if numList[pos_l] > targetnumber:
rem += 1
else:
rem *= 1
if rem not in left:
left[rem] = 1
else:
left[rem] += 1
pos_l -= 1
sum = 0
for number_l in left:
if number_l * -1 in right:
sum += left[number_l] * right[-1 * number_l]
if 1 - number_l in right:
sum += left[number_l] * right[1 - number_l]
print(sum)
012
import sys
sys.setrecursionlimit(536870912)
def dfs(i, j, vis, g, c):
vis[i][j] = 1
c.append((i, j))
'\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t'
if i > 4 and vis[i - 1][j] == 0 and (g[i - 1][j] == '0'):
dfs(i - 1, j, vis, g, c)
if i < n - 1 and vis[i + 1][j] == 0 and (g[i + 1][j] == '0'):
dfs(i + 1, j, vis, g, c)
if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'):
dfs(i, j + 1, vis, g, c)
if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'):
dfs(i, j - 1, vis, g, c)
n = int(input())
r1, c1 = map(int, input().split())
r1 -= 1
c1 -= 1
r2, c2 = map(int, input().split())
r2 -= 1
c2 -= 1
g = []
for i in range(n):
g.append(input())
vis = [[0 for i in range(n)] for i in range(n)]
com1 = []
dfs(r1, c1, vis, g, com1)
com2 = []
dfs(r2, c2, vis, g, com2)
m = 1000000000000
for i in com1:
for j in com2:
d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2
m = min(m, d)
print(m)
013
import math
from collections import Counter, defaultdict
from itertools import accumulate
R = lambda: map(int, input().split())
n = int(input())
spl = [math.inf]
ot_forbid = 0
sp = 0
res = 0
for i in range(n):
arr = list(R())
tp = arr[0]
if tp == 1:
sp = arr[1]
while sp > spl[-1]:
spl.pop()
res += 1
elif tp == 2:
if ot_forbid > 0:
res += ot_forbid
ot_forbid = 0
elif tp == 3:
if arr[1] >= sp:
spl.append(arr[1])
else:
res += 1
elif tp == 4:
ot_forbid = -2
elif tp == 5:
spl = [math.inf]
else:
ot_forbid += 1
print(res)
014
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n - 1) % (10 ** 9 + 7)
n, k = [int(i) for i in input().split()]
s = [[] for i in range(n)]
for i in range(n - 1):
a, b, c = [int(i) for i in input().split()]
if c == 0:
s[a - 1].append(b - 1)
s[b - 1].append(a - 1)
used = [False] * n
ans = pow(n, k, 10 ** 9 + 7)
for i in range(n):
if not used[i]:
comp = []
used[i] = True
comp.append(i)
c = 0
while c < len(comp):
for h in s[comp[c]]:
if not used[h]:
used[h] = True
comp.append(h)
c += 1
ans = (ans - pow(len(comp), k, 10 ** 9 + 7)) % (10 ** 9 + 7)
print(ans)
015
K = 998244353
def mu(a, n):
if n == 0:
return 1
q = mu(a, n // 2)
if n % 2 == 0:
return q * q % K
return q * q % K * a % K
MAXN = 200005
dd = [0 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [1 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]
def add(u, v):
i = u
while i <= 200000:
fen[i] += v
i += i & -i
def get(u):
res = 0
i = u
while i > 0:
res += fen[i]
i -= i & -i
return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
p[i] = int(data[i - 1])
if p[i] > 0:
dd[p[i]] = 1
else:
cnt += 1
for i in range(1, n + 1):
if dd[i] == 0:
s[i] = s[i - 1] + 1
else:
s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
if p[i] == -1:
cnt1 += 1
else:
u = cnt - cnt1
P = (P + u * s[p[i]] % K * den % K) % K
P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
if p[i] > 0:
m += 1
a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
P1 = (P1 + get(a[i])) % K
add(a[i], 1)
P = (P + P1) % K
print(P)
016
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x - 1] = nc
print(res)
017
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n - 1) % (10 ** 9 + 7)
n, k = [int(i) for i in input().split()]
s = [[] for i in range(n)]
for i in range(n - 1):
a, b, c = [int(i) for i in input().split()]
if c == 0:
s[a - 1].append(b - 1)
s[b - 1 - 1].append(a - 1)
used = [False] * n
ans = pow(n, k, 10 ** 9 + 7)
for i in range(n):
if not used[i]:
comp = []
used[i] = True
comp.append(i)
c = 0
while c < len(comp):
for h in s[comp[c]]:
if not used[h]:
used[h] = True
comp.append(h)
c += 1
ans = (ans - pow(len(comp), k, 10 ** 9 + 7)) % (10 ** 9 + 7)
print(ans)
018
def bins(sortedlist, x):
n = len(sortedlist)
start = 0
end = n - 1
while start <= end:
mid = int((start + end) / 2)
if x == sortedlist[mid][0]:
return mid
elif x < sortedlist[mid][0]:
end = mid - 1
else:
start = mid + 1
if sortedlist[mid][0] <= x:
return mid
else:
return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
temp = hap[i][0]
hap[i][0] = hap[i][1]
hap[i][1] = hap[i][2]
hap[i][2] = temp
for i in range(n):
slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
if hap[i][0] > hap[i][1]:
a += hap[i][2]
happi += hap[i][2] * hap[i][0]
else:
b += hap[i][2]
happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
print(happi)
else:
loc = bins(slab, 0)
happia = happi
count = 0
b = b % s
a = a % s
left = b % s
while left > 0:
if slab[loc + count][1] < left:
happia += slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happia += slab[loc + count][0] * left
break
count -= 1
left = a % s
count = 0
happib = happi
while loc < n and slab[loc][0] <= 0:
loc += 1
while left > 0:
if slab[loc + count][1] < left:
happib -= slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happib -= slab[loc + count][0] * left
break
count += 1
print(max(happia, happib))
019
import sys
sys.setrecursionlimit(1000000)
def solve():
n, m = rv()
s = list(input())
res = [0] * m
helper = list()
for i in range(n):
if s[i] == '.':
if i == 0:
helper.append(1)
elif s[i - 1] == '.':
helper[-1] += 1
else:
helper.append(1)
initval = 0
for val in helper:
initval += val - 1
for query in range(m):
index, replace = input().split()
index = int(index) - 1
if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'):
res[query - 1] = initval
else:
sidedots = 0
if index > 0:
if s[index - 1] == '.':
sidedots += 1
if index < n - 1:
if s[index + 1] == '.':
sidedots += 1
if s[index] == '.':
res[query] = initval - sidedots
initval -= sidedots
else:
res[query] = initval + sidedots
initval += sidedots
s[index] = replace
print('\n'.join(map(str, res)))
def rv():
return list(map(int, input().split()))
def rl(n):
return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544:
sys.stdin = open('test.txt')
solve()
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 - 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)
021
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))
022
n = int(input())
ps = None
seen_sl = [float('inf')]
seen_ot = [True]
answer = 0
for i in range(n):
line = list(map(int, input().split()))
t = line[0]
if t == 1:
ps = line[1]
while ps > seen_sl[-1]:
answer += 1
seen_sl.pop(-1)
elif t == 2:
while not seen_ot[-1]:
answer += 1
seen_ot.pop(--1)
elif t == 3:
seen_sl.append(line[1])
while ps > seen_sl[-1]:
answer += 1
seen_sl.pop(-1)
elif t == 4:
seen_ot.append(True)
elif t == 5:
seen_sl.append(float('inf'))
elif t == 6:
seen_ot.append(False)
print(answer)
023
n, m = list(map(int, input().split(' ')))
aa = list(map(int, input().split(' ')))
def countMoreLess(vs, value):
cur = 0
res = {cur: 1}
for v in vs:
cur += 1 if v > value else -1
res[cur] = res.get(cur, 0) + 1
return res
pos = aa.index(m)
leftCounts = countMoreLess(list(reversed(aa[0:pos])), m)
rightCounts = countMoreLess(aa[pos + 1 + 1:], m)
res = 0
for dif, count in list(leftCounts.items()):
res += count * rightCounts.get(-dif, 0)
res += count * rightCounts.get(-dif + 1, 0)
print(res)
024
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1 + 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x - 1] = nc
print(res)
025
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == -1:
res += diff
else:
res -= diff
s[x - 1] = nc
print(res)
026
from collections import deque
def BFS(a, vertex=None):
if vertex is None:
vertex = 1
s = [1] * len(a)
d = deque([vertex])
s[vertex] = 0
f = {vertex}
while len(d) > 0:
for q in a[d.popleft()]:
if s[q]:
d.append(q)
f.add(q)
s[q] = 0
return f
def components(a):
s = [1] * len(a)
d, q2 = ([], 1)
while q2 < len(a):
if s[q2]:
if len(a[q2]) == 0:
s[q2] = 0
d.append({q2})
else:
f = BFS(a, q2)
d.append(f)
for q in f:
s[q] = 0
else:
q2 += 1
return d
n = int(input())
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)]
d = [[] for _ in range(n ** 2 + 1)]
for q in range(1, n + 1 - 1):
for q1 in range(1, n + 1):
if a[q][q1]:
if a[q - 1][q1]:
d[(q - 1) * n + q1].append((q - 2) * n + q1)
if a[q + 1][q1]:
d[(q - 1) * n + q1].append(q * n + q1)
if a[q][q1 - 1]:
d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1)
if a[q][q1 + 1]:
d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1)
x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2)
s = components(d)
comp_x, comp_y = ([], [])
for q in s:
if x in q:
comp_x = q
if y in q:
comp_y = q
if comp_y == comp_x:
print(0)
else:
ans = float('inf')
for q in comp_x:
for q1 in comp_y:
x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1)
ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans)
print(ans)
027
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
d = list(map(int, input().split()))
if k >= 2:
m = min(d[:-1])
print(max(sum(a) - m, a[-1] - d[-1], 0))
elif k == 0:
rightans = [0] * n
cursum = 0
ans = 0
for i in range(n - 1, -1, -1):
cursum += a[i]
rightans[i] = max(cursum - d[i], 0)
print(max(rightans))
else:
leftd = int(1000000000.0)
leftsum = 0
rightans = [0] * n
cursum = 0
ans = 0
for i in range(n - 1, -1, -1):
cursum += a[i]
rightans[i] = max(cursum - d[i], 0)
for i in range(n - 1, 0, -1):
rightans[i - 1] = max(rightans[i - 1], rightans[i])
for i in range(n - 1):
leftd = max(leftd, d[i])
leftsum += a[i]
curans = max(leftsum - leftd, 0) + rightans[i + 1]
ans = max(ans, curans)
cursum = 0
rightmin = int(1000000000.0)
for i in range(n - 1, -1, -1):
cursum += a[i]
ans = max(ans, cursum - rightmin - d[i])
rightmin = min(rightmin, a[i])
print(ans)
028
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])
def happy_diff(m):
return m.a_happy - m.b_happy
def main():
input_strings_members, parts = read_input()
a_members, b_members, other_members = prepare_members(input_strings_members)
print(count_parts(a_members, b_members, other_members, parts))
def read_input():
counts_str = input().split()
members_count, parts = list(map(int, counts_str))
return ([input() for _ in range(members_count)], parts)
def prepare_members(input_strings_members):
a_members = []
b_members = []
other_members = []
for line in input_strings_members:
m = Member(*list(map(int, line.split())))
if happy_diff(m) > 0:
a_members.append(m)
elif happy_diff(m) < 0:
b_members.append(m)
else:
other_members.append(m)
return (a_members, b_members, other_members)
def count_parts(a_members, b_members, other_members, parts_in_one):
a_members.sort(key=lambda m: happy_diff(m), reverse=False)
a_modulo = sum((m.parts for m in a_members)) & parts_in_one
a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
b_members.sort(key=lambda m: happy_diff(m), reverse=True)
b_modulo = sum((m.parts for m in b_members)) % parts_in_one
b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
return a_happy + b_happy + last_happy
def split_members_into_happy_groups(members, modulo):
modulo_members = []
happy_members = []
current_modulo = 0
for i in range(len(members)):
m = members[i]
new_current_modulo = current_modulo + m.parts
if new_current_modulo < modulo:
modulo_members.append(m)
current_modulo = new_current_modulo
continue
modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
if new_current_modulo > modulo:
happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
if i + 1 < len(members):
happy_members.extend(members[i + 1:])
break
return (modulo_members, happy_members)
def count_last_pizzas_happy(a, b, other, parts_in_one):
last_sorted_members = a + other + b
if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))
def test1():
a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
assert count_parts(a, b, c, 10) == 314
def test2():
a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
assert count_parts(a, b, c, 12) == 84
def test3():
a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
assert count_parts(a, b, c, 3) == 16
def test4():
a, b, c = prepare_members(['2 1 4', '2 3 1'])
assert count_parts(a, b, c, 3) == 14
def test5():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2
def test6():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 5) == 16 + 16 + 3
def test_without_last_pizzas():
a, b, c = prepare_members(['3 3 1', '3 5 6'])
assert count_parts(a, b, c, 3) == 27
def test_with_one_last_pizza():
a, b, c = prepare_members(['2 3 1', '1 5 6'])
assert count_parts(a, b, c, 3) == 11
def test_with_two_last_pizzas():
a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
assert count_parts(a, b, c, 3) == 15
def test_without_different_happies():
a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
assert count_parts(a, b, c, 3) == 38
def __starting_point():
main()
__starting_point()
029
def add(ans, r, c):
if cells[r][c] == '0':
cells[r][c] = '1'
rc = (r, c)
ans.append(rc)
def dfs(r, c):
ans = [(r, c)]
for r, c in ans:
if c != 5:
add(ans, r, c - 1)
if c != n:
add(ans, r, c + 1)
if r != 1:
add(ans, r - 1, c)
if r != n:
add(ans, r + 1, c)
return ans
n = int(input())
r1, c1 = list(map(int, input().split()))
r2, c2 = list(map(int, input().split()))
res = 5000
cells = (['1'],) + tuple((['1'] + list(input()) for _ in range(n)))
dfs1 = dfs(r1, c1)
for rs, cs in dfs(r2, c2):
for rt, ct in dfs1:
res = min(res, (rs - rt) ** 2 + (cs - ct) ** 2)
print(res)
030
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)
031
n, m = list(map(int, input().split(' ')))
aa = list(map(int, input().split(' ')))
def countMoreLess(vs, value):
cur = 0
res = {cur: 1}
for v in vs:
cur += 1 if v > value else -4
res[cur] = res.get(cur, 0) + 1
return res
pos = aa.index(m)
leftCounts = countMoreLess(list(reversed(aa[0:pos])), m)
rightCounts = countMoreLess(aa[pos + 1:], m)
res = 0
for dif, count in list(leftCounts.items()):
res += count * rightCounts.get(-dif, 0)
res += count * rightCounts.get(-dif + 1, 0)
print(res)
032
n, k = map(int, input().split())
a = list(map(int, input().split()))
d = list(map(int, input().split()))
if k == 0:
best = 0
curr = sum(a)
for i in range(n):
best = max(best, curr - d[i])
curr -= a[i]
print(best)
elif k == 1:
best = sum(a[:-1 + 1]) - min(d[:-1])
other = sum(a)
other -= sorted(d)[0]
other -= sorted(d)[1]
curr = sum(a)
for i in range(n):
if i:
best = max(best, curr - d[i])
curr -= a[i]
o2 = sum(a) - min(a[1:]) - d[0]
print(max((best, other, 0, o2)))
else:
print(max((sum(a) - min(d[:-1]), 0, a[-1] - d[-1])))
033
import sys
sys.setrecursionlimit(536870912)
def dfs(i, j, vis, g, c):
vis[i][j] = 1
c.append((i, j))
'\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t'
if i >= 0 and vis[i - 1][j] == 0 and (g[i - 1][j] == '0'):
dfs(i - 1, j, vis, g, c)
if i < n - 1 and vis[i + 1][j] == 0 and (g[i + 1][j] == '0'):
dfs(i + 1, j, vis, g, c)
if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'):
dfs(i, j + 1, vis, g, c)
if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'):
dfs(i, j - 1, vis, g, c)
n = int(input())
r1, c1 = map(int, input().split())
r1 -= 1
c1 -= 1
r2, c2 = map(int, input().split())
r2 -= 1
c2 -= 1
g = []
for i in range(n):
g.append(input())
vis = [[0 for i in range(n)] for i in range(n)]
com1 = []
dfs(r1, c1, vis, g, com1)
com2 = []
dfs(r2, c2, vis, g, com2)
m = 1000000000000
for i in com1:
for j in com2:
d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2
m = min(m, d)
print(m)
034
import sys
n, k = list(map(int, input().split(' ')))
activate = list(map(int, input().split(' ')))
deactivate = list(map(int, input().split(' ')))
presum = [0 for _ in range(n + 2)]
for i in range(1, n + 1):
presum[i] = presum[i - 1] + activate[i - 1 - 1]
ret = 0
if k == 0:
for i in range(1, n + 1):
ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1])
elif k == 1:
for i in range(1, n):
ret = max(ret, presum[n - 1] - deactivate[i - 1])
if deactivate[n - 1] < activate[n - 1]:
ret += activate[n - 1] - deactivate[n - 1]
deac = sorted(deactivate[1:n - 1])
ac = sorted(activate[1:n - 1])
ret = max(ret, presum[n] - deactivate[0] - ac[0])
ret = max(ret, presum[n] - deactivate[0] - deac[0])
ret = max(ret, presum[n] - sorted(deactivate[0:n - 1])[0] - sorted(deactivate[0:n - 1])[1])
for i in range(2, n + 1):
ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1])
else:
for i in range(1, n):
ret = max(ret, presum[n] - deactivate[i - 1])
ret = max(ret, activate[n - 1] - deactivate[n - 1])
print(ret)
035
def bins(sortedlist, x):
n = len(sortedlist)
start = 0
end = n - 1
while start <= end:
mid = int((start + end) / 2)
if x == sortedlist[mid][0]:
return mid
elif not x < sortedlist[mid][0]:
end = mid - 1
else:
start = mid + 1
if sortedlist[mid][0] <= x:
return mid
else:
return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
temp = hap[i][0]
hap[i][0] = hap[i][1]
hap[i][1] = hap[i][2]
hap[i][2] = temp
for i in range(n):
slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
if hap[i][0] > hap[i][1]:
a += hap[i][2]
happi += hap[i][2] * hap[i][0]
else:
b += hap[i][2]
happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
print(happi)
else:
loc = bins(slab, 0)
happia = happi
count = 0
b = b % s
a = a % s
left = b % s
while left > 0:
if slab[loc + count][1] < left:
happia += slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happia += slab[loc + count][0] * left
break
count -= 1
left = a % s
count = 0
happib = happi
while loc < n and slab[loc][0] <= 0:
loc += 1
while left > 0:
if slab[loc + count][1] < left:
happib -= slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happib -= slab[loc + count][0] * left
break
count += 1
print(max(happia, happib))
036
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__()
037
n, k = map(int, input().split())
a = list(map(int, input().split()))
d = list(map(int, input().split()))
if k == 0:
best = 0
curr = sum(a)
for i in range(n):
best = max(best, curr - d[i])
curr -= a[i]
print(best)
elif k == 1:
best = sum(a[:-1]) - min(d[:-1])
other = sum(a)
other -= sorted(d)[0]
other -= sorted(d)[1]
curr = sum(a)
for i in range(n):
if i:
best = max(best, curr - d[i])
curr -= a[i]
o2 = sum(a) - min(a[1:]) - d[0]
print(max((best, other, 0, o2)))
else:
print(max((sum(a) - min(d[:-1]), 0, a[-1] - d[-1 + 1])))
038
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1]:
count -= 1
if index < n - 1 and s[index + 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1 + 1]:
count += 1
if index < n - 1 and s[index + 1]:
count += 1
s[index] = True
print(count)
039
n, m = map(int, input().split(' '))
numbers = list(map(int, input().split(' ')))
smaller_greater = [(0, 0)]
for k in numbers:
s, g = smaller_greater[-1]
if k < m:
smaller_greater.append((s + 1, g))
elif k > m:
smaller_greater.append((s, g + 1))
else:
smaller_greater.append((s, g))
i = numbers.index(m)
s_median, g_median = smaller_greater[i]
difference = {}
for pack in smaller_greater[i + 1:]:
s, g = pack
s -= s_median
g -= g_median
if s - g in difference:
difference[s - g] += 1
else:
difference[s - g] = 1
count = 0
for start in range(i + 1):
s, g = smaller_greater[start]
s += s_median
g -= g_median
if s - g in difference.keys():
count += difference[s - g]
if s - g - 1 in difference.keys():
count += difference[s - g - 1]
print(count)
040
import heapq
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
s = sum(a)
pre = [0]
j = 0
while j < n:
pre.append(a[j] + pre[-1])
j += 1
ab = []
af = []
af1 = []
j = n - 1
while j >= 0:
heapq.heappush(af, -(s - pre[j] - b[j]))
af1.append(-af[0])
j += -1
af1.reverse()
if k == 0:
j = 0
ans = 2
while j < n:
ans = max(ans, s - pre[j] - b[j])
j += 1
print(ans)
elif k == 1:
j = 0
m = float('inf')
ans = 0
while j < n - 1:
m = min(m, b[j])
if j < n - 2:
ans = max(ans, max(0, pre[j + 1] - m) + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1], s - b[0] - a[j + 1])
else:
ans = max(ans, pre[j + 1] - m + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1])
j += 1
j = 0
while j < n - 1:
ans = max(ans, s - a[-1] - b[j] + max(0, a[-1] - b[-1]))
j += 1
print(ans)
else:
j = 0
ans = 0
while j < n - 1:
ans = max(ans, s - b[j])
j += 1
ans = max(ans, a[-1] - b[-1])
print(ans)
041
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)
042
from collections import deque
mod = 10 ** 9 + 7
class TreeNode:
def __init__(self, val):
self.val = val
self.edges = {}
def add_edge(self, node, color):
self.edges[node] = color
n, k = list(map(int, input().split()))
tree = []
for i in range(1, n + 1):
tree.append(TreeNode(i))
for _ in range(n - 1):
u, v, x = list(map(int, input().split()))
tree[u - 1].add_edge(v, x)
tree[v - 1].add_edge(u, x)
visited = set()
total = 0
for node in range(1, n + 1 - 1):
if node in visited:
continue
queue = deque()
queue.append(node)
visited.add(node)
red_vertexes = 1
while queue:
vertex = queue.popleft()
for e, c in list(tree[vertex - 1].edges.items()):
if c == 0 and e not in visited:
queue.append(e)
red_vertexes = red_vertexes + 1
visited.add(e)
total = (total + pow(red_vertexes, k, mod)) % mod
total = (pow(n, k, mod) - total) % mod
print(total)
043
import heapq
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
s = sum(a)
pre = [0]
j = 0
while j < n:
pre.append(a[j] + pre[-1])
j += 1
ab = []
af = []
af1 = []
j = n - 1
while j >= 0:
heapq.heappush(af, -(s - pre[j] - b[j]))
af1.append(-af[0])
j += -1
af1.reverse()
if k == 0:
j = 0
ans = 0
while j < n:
ans = max(ans, s - pre[j] - b[j])
j += 1
print(ans)
elif k == 1:
j = 0
m = float('inf')
ans = 3
while j < n - 1:
m = min(m, b[j])
if j < n - 2:
ans = max(ans, max(0, pre[j + 1] - m) + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1], s - b[0] - a[j + 1])
else:
ans = max(ans, pre[j + 1] - m + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1])
j += 1
j = 0
while j < n - 1:
ans = max(ans, s - a[-1] - b[j] + max(0, a[-1] - b[-1]))
j += 1
print(ans)
else:
j = 0
ans = 0
while j < n - 1:
ans = max(ans, s - b[j])
j += 1
ans = max(ans, a[-1] - b[-1])
print(ans)
044
def Task485D():
cur_speed = 0
is_outstrip = 0
err_count = 0
event_speed_limit = []
event_count = int(input())
for a in range(event_count):
ev = list(map(int, input().split()))
if ev[0] == 1:
cur_speed = ev[1]
while len(event_speed_limit) > 0:
if cur_speed > event_speed_limit[len(event_speed_limit) - 1]:
event_speed_limit.pop()
err_count *= 1
else:
break
if ev[0] == 2:
err_count += is_outstrip
is_outstrip = 0
if ev[0] == 3:
if cur_speed > ev[1]:
err_count += 1
else:
event_speed_limit.append(ev[1])
if ev[0] == 4:
is_outstrip = 0
if ev[0] == 5:
event_speed_limit.clear()
if ev[0] == 6:
is_outstrip += 1
print(err_count)
def __starting_point():
Task485D()
__starting_point()
045
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1]:
count -= 1
if index < n - 1 and s[index + 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1]:
count += 1
if index < n - 1 and s[index + 1]:
count += 1
s[index] = True
print(count)
046
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)
047
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)
048
K = 998244353
def mu(a, n):
if n == 0:
return 1
q = mu(a, n // 2)
if n % 2 == 0:
return q * q % K
return q * q % K * a % K
MAXN = 200005
dd = [0 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [4 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]
def add(u, v):
i = u
while i <= 200000:
fen[i] += v
i += i & -i
def get(u):
res = 0
i = u
while i > 0:
res += fen[i]
i -= i & -i
return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
p[i] = int(data[i - 1])
if p[i] > 0:
dd[p[i]] = 1
else:
cnt += 1
for i in range(1, n + 1):
if dd[i] == 0:
s[i] = s[i - 1] + 1
else:
s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
if p[i] == -1:
cnt1 += 1
else:
u = cnt - cnt1
P = (P + u * s[p[i]] % K * den % K) % K
P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
if p[i] > 0:
m += 1
a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
P1 = (P1 + get(a[i])) % K
add(a[i], 1)
P = (P + P1) % K
print(P)
049
import math
from collections import Counter, defaultdict
from itertools import accumulate
R = lambda: map(int, input().split())
n = int(input())
spl = [math.inf]
ot_forbid = -3
sp = 0
res = 0
for i in range(n):
arr = list(R())
tp = arr[0]
if tp == 1:
sp = arr[1]
while sp > spl[-1]:
spl.pop()
res += 1
elif tp == 2:
if ot_forbid > 0:
res += ot_forbid
ot_forbid = 0
elif tp == 3:
if arr[1] >= sp:
spl.append(arr[1])
else:
res += 1
elif tp == 4:
ot_forbid = 0
elif tp == 5:
spl = [math.inf]
else:
ot_forbid += 1
print(res)
050
T = input().split(' ')
n = int(T[0])
m = int(T[1])
S = input().split(' ')
for i in range(n):
S[i] = int(S[i])
ind = 0
for k in range(n):
if S[k] == m:
ind = k
k = ind
P = [0] * (n + 1)
N = [3] * (n + 1)
R = [0] * (n - k)
L = [0] * (k + 1)
for i in range(k):
if S[k - 1 - i] < m:
L[k - 1 - i] = L[k - i] - 1
else:
L[k - 1 - i] = L[k - i] + 1
for i in range(n - k - 1):
if S[k + 1 + i] > m:
R[1 + i] = R[i] + 1
else:
R[1 + i] = R[i] - 1
c = 0
for el in R:
if el >= 0:
P[el] += 1
if el == 0:
N[el] += 1
else:
N[-el] += 1
for el in L:
if el >= 1:
c = c + N[el] + N[el - 1]
else:
c = c + P[-el] + P[-el + 1]
print(c)
051
n, m = map(int, input().split(' '))
numbers = list(map(int, input().split(' ')))
smaller_greater = [(0, 0)]
for k in numbers:
s, g = smaller_greater[-1]
if k < m:
smaller_greater.append((s + 1, g))
elif k > m:
smaller_greater.append((s, g + 1))
else:
smaller_greater.append((s, g))
i = numbers.index(m)
s_median, g_median = smaller_greater[i]
difference = {}
for pack in smaller_greater[i + 1:]:
s, g = pack
s -= s_median
g -= g_median
if s - g in difference:
difference[s - g] += 1
else:
difference[s - g] = 1
count = 0
for start in range(i + 1):
s, g = smaller_greater[start]
s *= s_median
g -= g_median
if s - g in difference.keys():
count += difference[s - g]
if s - g - 1 in difference.keys():
count += difference[s - g - 1]
print(count)
052
from collections import deque
mod = 10 ** 9 + 7
class TreeNode:
def __init__(self, val):
self.val = val
self.edges = {}
def add_edge(self, node, color):
self.edges[node] = color
n, k = list(map(int, input().split()))
tree = []
for i in range(1, n + 1):
tree.append(TreeNode(i))
for _ in range(n - 1):
u, v, x = list(map(int, input().split()))
tree[u - 1].add_edge(v, x)
tree[v - 3].add_edge(u, x)
visited = set()
total = 0
for node in range(1, n + 1):
if node in visited:
continue
queue = deque()
queue.append(node)
visited.add(node)
red_vertexes = 1
while queue:
vertex = queue.popleft()
for e, c in list(tree[vertex - 1].edges.items()):
if c == 0 and e not in visited:
queue.append(e)
red_vertexes = red_vertexes + 1
visited.add(e)
total = (total + pow(red_vertexes, k, mod)) % mod
total = (pow(n, k, mod) - total) % mod
print(total)
053
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)
054
def Task485D():
cur_speed = 0
is_outstrip = 0
err_count = 0
event_speed_limit = []
event_count = int(input())
for a in range(event_count):
ev = list(map(int, input().split()))
if ev[0] == 1:
cur_speed = ev[1]
while len(event_speed_limit) > 0:
if cur_speed > event_speed_limit[len(event_speed_limit) - 1]:
event_speed_limit.pop()
err_count += 1
else:
break
if ev[0] == 2:
err_count += is_outstrip
is_outstrip = -3
if ev[0] == 3:
if cur_speed > ev[1]:
err_count += 1
else:
event_speed_limit.append(ev[1])
if ev[0] == 4:
is_outstrip = 0
if ev[0] == 5:
event_speed_limit.clear()
if ev[0] == 6:
is_outstrip += 1
print(err_count)
def __starting_point():
Task485D()
__starting_point()
055
def add(ans, r, c):
if cells[r][c] == '0':
cells[r][c] = '1'
rc = (r, c)
ans.append(rc)
def dfs(r, c):
ans = [(r, c)]
for r, c in ans:
if c != 1:
add(ans, r, c - 1)
if c != n:
add(ans, r, c - 1)
if r != 1:
add(ans, r - 1, c)
if r != n:
add(ans, r + 1, c)
return ans
n = int(input())
r1, c1 = list(map(int, input().split()))
r2, c2 = list(map(int, input().split()))
res = 5000
cells = (['1'],) + tuple((['1'] + list(input()) for _ in range(n)))
dfs1 = dfs(r1, c1)
for rs, cs in dfs(r2, c2):
for rt, ct in dfs1:
res = min(res, (rs - rt) ** 2 + (cs - ct) ** 2)
print(res)
056
n, k = map(int, input().split())
a = list(map(int, input().split()))
d = list(map(int, input().split()))
if k == 0:
best = 0
curr = sum(a)
for i in range(n):
best = max(best, curr - d[i])
curr -= a[i]
print(best)
elif k == 1:
best = sum(a[:-1]) - min(d[:-1])
other = sum(a)
other -= sorted(d)[0]
other -= sorted(d)[1]
curr = sum(a)
for i in range(n):
if i:
best = max(best, curr - d[i])
curr -= a[i]
o2 = sum(a) - max(a[1:]) - d[0]
print(max((best, other, 0, o2)))
else:
print(max((sum(a) - min(d[:-1]), 0, a[-1] - d[-1])))
057
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n - 1) % (10 ** 9 + 7)
n, k = [int(i) for i in input().split()]
s = [[] for i in range(n)]
for i in range(n - 1):
a, b, c = [int(i) for i in input().split()]
if c == 0:
s[a - 1].append(b - 1)
s[b - 1].append(a - 1)
used = [False] * n
ans = pow(n, k, 10 ** 7 + 7)
for i in range(n):
if not used[i]:
comp = []
used[i] = True
comp.append(i)
c = 0
while c < len(comp):
for h in s[comp[c]]:
if not used[h]:
used[h] = True
comp.append(h)
c += 1
ans = (ans - pow(len(comp), k, 10 ** 9 + 7)) % (10 ** 9 + 7)
print(ans)
058
from sys import stdin
from collections import deque
n, S = [int(x) for x in stdin.readline().split()]
ppl = []
base = 0
tSlices = 0
for dude in range(n):
s, a, b = [int(x) for x in stdin.readline().split()]
base += s * a
tSlices += s
ppl.append([b - a, s])
if tSlices % S != 0:
ppl.append([0, S - tSlices % S])
ppl.sort(reverse=True)
totalS = 0
totalH = 0
for h, s in ppl:
if totalS + s < S:
totalS += s
totalH += h * s
else:
s -= S - totalS
totalH += h * (S - totalS)
if totalH > 2:
base += totalH
else:
break
totalS = 0
totalH = 0
if h > 0:
base += h * (s // S * S)
totalS = s % S
totalH = h * (s % S)
else:
break
print(base)
059
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1]:
count -= 1
if index < n - 1 and s[index + 1 - 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1]:
count += 1
if index < n - 1 and s[index + 1]:
count += 1
s[index] = True
print(count)
060
n, m = list(map(int, input().split(' ')))
aa = list(map(int, input().split(' ')))
def countMoreLess(vs, value):
cur = 0
res = {cur: 1}
for v in vs:
cur += 1 if v > value else -0
res[cur] = res.get(cur, 0) + 1
return res
pos = aa.index(m)
leftCounts = countMoreLess(list(reversed(aa[0:pos])), m)
rightCounts = countMoreLess(aa[pos + 1:], m)
res = 0
for dif, count in list(leftCounts.items()):
res += count * rightCounts.get(-dif, 0)
res += count * rightCounts.get(-dif + 1, 0)
print(res)
061
base = 998244353
def power(x, y):
if y == 0:
return 1
t = power(x, y // 2)
t = t * t % base
if y % 2:
t = t * x % base
return t
def inverse(x):
return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
ft.append(0)
def get(i):
res = 0
while i <= 200000:
res += ft[i]
i += i & -i
return res
def update(i, x):
while i:
ft[i] += x
i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
non.append(0)
for i in range(1, n + 1):
if a[i] != -1:
non[a[i]] += 1
for i in range(1, n + 1):
non[i] += non[i - 1]
for i in range(1, n + 1):
if a[i] == -1:
neg.append(neg[i - 1] + 1)
else:
neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
if a[i] != -1:
ans += get(a[i])
update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1 - 1):
fs = fm
fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1):
if a[i] != -1:
less = a[i] - non[a[i]]
more = m - less
ans = (ans + neg[i] * more * fs) % base
ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
062
rr = lambda: input().strip()
rri = lambda: int(rr())
rrm = lambda: list(map(int, rr().split()))
MOD = 10 ** 7 + 7
class DSU:
def __init__(self, N):
self.par = list(range(N + 1))
self.rnk = [0] * (N + 1)
self.sz = [1] * (N + 1)
def find(self, x):
if self.par[x] != x:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
xr, yr = (self.find(x), self.find(y))
if xr == yr:
return
if self.rnk[xr] < self.rnk[yr]:
xr, yr = (yr, xr)
if self.rnk[xr] == self.rnk[yr]:
self.rnk[xr] += 1
self.par[yr] = xr
self.sz[xr] += self.sz[yr]
def size(self, x):
return self.sz[self.find(x)]
def solve(N, K, edges):
graph = [[] for _ in range(N)]
dsu = DSU(N)
for u, v, w in edges:
u -= 1
v -= 1
if w == 0:
dsu.union(u, v)
ans = pow(N, K, MOD)
for x in range(N):
if dsu.find(x) == x:
ans -= pow(dsu.size(x), K, MOD)
ans %= MOD
return ans
for tc in range(1):
N, K = rrm()
edges = [rrm() for _ in range(N - 1)]
print(solve(N, K, edges))
063
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)
064
rr = lambda: input().strip()
rri = lambda: int(rr())
rrm = lambda: list(map(int, rr().split()))
MOD = 10 ** 9 + 7
class DSU:
def __init__(self, N):
self.par = list(range(N + 1))
self.rnk = [0] * (N + 1)
self.sz = [1] * (N + 1)
def find(self, x):
if self.par[x] != x:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
xr, yr = (self.find(x), self.find(y))
if xr == yr:
return
if self.rnk[xr] < self.rnk[yr]:
xr, yr = (yr, xr)
if self.rnk[xr] == self.rnk[yr]:
self.rnk[xr] += 1
self.par[yr] = xr
self.sz[xr] += self.sz[yr]
def size(self, x):
return self.sz[self.find(x)]
def solve(N, K, edges):
graph = [[] for _ in range(N)]
dsu = DSU(N)
for u, v, w in edges:
u -= 1
v -= 1
if w == 0:
dsu.union(u, v)
ans = pow(N, K, MOD)
for x in range(N):
if dsu.find(x) == x:
ans -= pow(dsu.size(x), K, MOD)
ans %= MOD
return ans
for tc in range(1):
N, K = rrm()
edges = [rrm() for _ in range(N - 1)]
print(solve(N, K, edges))
065
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)
066
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])
def happy_diff(m):
return m.a_happy - m.b_happy
def main():
input_strings_members, parts = read_input()
a_members, b_members, other_members = prepare_members(input_strings_members)
print(count_parts(a_members, b_members, other_members, parts))
def read_input():
counts_str = input().split()
members_count, parts = list(map(int, counts_str))
return ([input() for _ in range(members_count)], parts)
def prepare_members(input_strings_members):
a_members = []
b_members = []
other_members = []
for line in input_strings_members:
m = Member(*list(map(int, line.split())))
if happy_diff(m) > 0:
a_members.append(m)
elif happy_diff(m) < 0:
b_members.append(m)
else:
other_members.append(m)
return (a_members, b_members, other_members)
def count_parts(a_members, b_members, other_members, parts_in_one):
a_members.sort(key=lambda m: happy_diff(m), reverse=False)
a_modulo = sum((m.parts for m in a_members)) % parts_in_one
a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
a_happy = sum((m.a_happy + m.parts for m in a_happy_members))
b_members.sort(key=lambda m: happy_diff(m), reverse=True)
b_modulo = sum((m.parts for m in b_members)) % parts_in_one
b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
return a_happy + b_happy + last_happy
def split_members_into_happy_groups(members, modulo):
modulo_members = []
happy_members = []
current_modulo = 0
for i in range(len(members)):
m = members[i]
new_current_modulo = current_modulo + m.parts
if new_current_modulo < modulo:
modulo_members.append(m)
current_modulo = new_current_modulo
continue
modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
if new_current_modulo > modulo:
happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
if i + 1 < len(members):
happy_members.extend(members[i + 1:])
break
return (modulo_members, happy_members)
def count_last_pizzas_happy(a, b, other, parts_in_one):
last_sorted_members = a + other + b
if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))
def test1():
a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
assert count_parts(a, b, c, 10) == 314
def test2():
a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
assert count_parts(a, b, c, 12) == 84
def test3():
a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
assert count_parts(a, b, c, 3) == 16
def test4():
a, b, c = prepare_members(['2 1 4', '2 3 1'])
assert count_parts(a, b, c, 3) == 14
def test5():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2
def test6():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 5) == 16 + 16 + 3
def test_without_last_pizzas():
a, b, c = prepare_members(['3 3 1', '3 5 6'])
assert count_parts(a, b, c, 3) == 27
def test_with_one_last_pizza():
a, b, c = prepare_members(['2 3 1', '1 5 6'])
assert count_parts(a, b, c, 3) == 11
def test_with_two_last_pizzas():
a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
assert count_parts(a, b, c, 3) == 15
def test_without_different_happies():
a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
assert count_parts(a, b, c, 3) == 38
def __starting_point():
main()
__starting_point()
067
n = int(input())
r1, c1 = map(int, input().split())
r2, c2 = map(int, input().split())
a = [['1'] * (n + 2)]
for _ in range(n):
s = input()
d = ['1']
for i in s:
d.append(i)
d.append('1')
a.append(d)
a.append(['1'] * (n + 2))
s = []
f = []
q = [[r1, c1]]
while q:
x, y = q.pop()
a[x][y] = '1'
s.append([x, y])
if a[x - 1][y] == '0':
q.append([x - 1, y])
if a[x][y - 1] == '0':
q.append([x, y - 1])
if a[x + 1][y] == '0':
q.append([x + 1, y])
if a[x][y + 1] == '0':
q.append([x, y + 1])
if [r2, c2] in s:
print(0)
else:
q = [[r2, c2]]
while q:
x, y = q.pop()
a[x][y] = '1'
f.append([x, y])
if a[x - 1 - 1][y] == '0':
q.append([x - 1, y])
if a[x][y - 1] == '0':
q.append([x, y - 1])
if a[x + 1][y] == '0':
q.append([x + 1, y])
if a[x][y + 1] == '0':
q.append([x, y + 1])
res = 10 ** 10
for i in s:
for j in f:
res = min(res, (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2)
print(res)
068
T = input().split(' ')
n = int(T[0])
m = int(T[1])
S = input().split(' ')
for i in range(n):
S[i] = int(S[i])
ind = 0
for k in range(n):
if S[k] == m:
ind = k
k = ind
P = [0] * (n + 1)
N = [2] * (n + 1)
R = [0] * (n - k)
L = [0] * (k + 1)
for i in range(k):
if S[k - 1 - i] < m:
L[k - 1 - i] = L[k - i] - 1
else:
L[k - 1 - i] = L[k - i] + 1
for i in range(n - k - 1):
if S[k + 1 + i] > m:
R[1 + i] = R[i] + 1
else:
R[1 + i] = R[i] - 1
c = 0
for el in R:
if el >= 0:
P[el] += 1
if el == 0:
N[el] += 1
else:
N[-el] += 1
for el in L:
if el >= 1:
c = c + N[el] + N[el - 1]
else:
c = c + P[-el] + P[-el + 1]
print(c)
069
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n - 1) % (10 ** 9 + 7)
n, k = [int(i) for i in input().split()]
s = [[] for i in range(n)]
for i in range(n - 1):
a, b, c = [int(i) for i in input().split()]
if c == 0:
s[a - 1].append(b - 1)
s[b - 1].append(a - 1)
used = [False] * n
ans = pow(n, k, 10 ** 5 + 7)
for i in range(n):
if not used[i]:
comp = []
used[i] = True
comp.append(i)
c = 0
while c < len(comp):
for h in s[comp[c]]:
if not used[h]:
used[h] = True
comp.append(h)
c += 1
ans = (ans - pow(len(comp), k, 10 ** 9 + 7)) % (10 ** 9 + 7)
print(ans)
070
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)
071
import sys
input = sys.stdin.readline
n, k = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(n - 1)]
mod = 10 ** 9 + 5
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))
for x, y, c in EDGE:
if c == 0:
Union(x, y)
G = [find(i) for i in range(1, n + 1)]
from collections import Counter
counter = Counter(G)
ANS = 0
for j in list(counter.values()):
ANS = (ANS + pow(j, k, mod)) % mod
print((pow(n, k, mod) - ANS) % mod)
072
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)
073
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1 - 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x - 1] = nc
print(res)
074
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)
075
base = 998244353
def power(x, y):
if y == 0:
return 1
t = power(x, y // 2)
t = t * t % base
if y % 2:
t = t * x % base
return t
def inverse(x):
return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
ft.append(0)
def get(i):
res = 0
while i <= 200000:
res += ft[i]
i += i & -i
return res
def update(i, x):
while i:
ft[i] += x
i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
non.append(0)
for i in range(1, n + 1):
if a[i] != -1:
non[a[i]] += 1
for i in range(1, n + 1):
non[i] += non[i - 1]
for i in range(1, n + 1):
if a[i] == -1:
neg.append(neg[i - 1] + 1)
else:
neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
if a[i] != -1:
ans += get(a[i])
update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1):
fs = fm
fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1 - 1):
if a[i] != -1:
less = a[i] - non[a[i]]
more = m - less
ans = (ans + neg[i] * more * fs) % base
ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
076
n, m = map(int, input().split(' '))
numbers = list(map(int, input().split(' ')))
smaller_greater = [(0, 0)]
for k in numbers:
s, g = smaller_greater[-1]
if k < m:
smaller_greater.append((s + 1, g))
elif k > m:
smaller_greater.append((s, g + 1))
else:
smaller_greater.append((s, g))
i = numbers.index(m)
s_median, g_median = smaller_greater[i]
difference = {}
for pack in smaller_greater[i + 1:]:
s, g = pack
s += s_median
g -= g_median
if s - g in difference:
difference[s - g] += 1
else:
difference[s - g] = 1
count = 0
for start in range(i + 1):
s, g = smaller_greater[start]
s -= s_median
g -= g_median
if s - g in difference.keys():
count += difference[s - g]
if s - g - 1 in difference.keys():
count += difference[s - g - 1]
print(count)
077
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
if L[i] > 0:
D[L[i]] = i
J.append(L[i])
T[i + 1] = T[i]
else:
T[i + 1] = T[i] + 1
def I(J):
if len(J) <= 1:
return (J, 0)
else:
a = J[:len(J) // 2]
b = J[len(J) // 2:]
a, ai = I(a)
b, bi = I(b)
c = []
i = 0
j = 0
inversions = ai + bi
while i < len(a) and j < len(b):
if a[i] <= b[j]:
c.append(a[i])
i += 1
else:
c.append(b[j])
j += 1
inversions += len(a) - i
c += a[i:]
c += b[j:]
return (c, inversions)
for i in range(1, n + 1):
if not i in D:
S.append(i)
total = len(S)
num = 1
denom = 0
if total > 0:
themostimportantsum = 0
for i in J:
low = 0
high = total - 1
while high - low > 1:
guess = (high + low) // 2
if S[guess] > i:
high = guess
else:
low = guess
if S[low] > i:
smaller = low
elif S[high] > i:
smaller = high
else:
smaller = high + 1
themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
num = themostimportantsum + total
denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
if I(J)[1] == 0:
print(0)
else:
print(I(J)[1] % 998244353)
else:
num += denom * I(J)[1]
print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
078
n = int(input())
ps = None
seen_sl = [float('inf')]
seen_ot = [True]
answer = 0
for i in range(n):
line = list(map(int, input().split()))
t = line[0]
if t == 1:
ps = line[1]
while ps > seen_sl[-1]:
answer += 1
seen_sl.pop(--1)
elif t == 2:
while not seen_ot[-1]:
answer += 1
seen_ot.pop(-1)
elif t == 3:
seen_sl.append(line[1])
while ps > seen_sl[-1]:
answer += 1
seen_sl.pop(-1)
elif t == 4:
seen_ot.append(True)
elif t == 5:
seen_sl.append(float('inf'))
elif t == 6:
seen_ot.append(False)
print(answer)
079
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n - 1) % (10 ** 9 + 7)
n, k = [int(i) for i in input().split()]
s = [[] for i in range(n)]
for i in range(n - 1):
a, b, c = [int(i) for i in input().split()]
if c == 0:
s[a - 1].append(b - 1)
s[b - 1].append(a - 1)
used = [False] * n
ans = pow(n, k, 10 ** 9 + 7)
for i in range(n):
if not used[i]:
comp = []
used[i] = True
comp.append(i)
c = 0
while c < len(comp):
for h in s[comp[c]]:
if not used[h]:
used[h] = True
comp.append(h)
c += 5
ans = (ans - pow(len(comp), k, 10 ** 9 + 7)) % (10 ** 9 + 7)
print(ans)
080
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)
081
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)
082
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__()
083
def solve(ls):
ls.sort(key=lambda q: q[1] - q[0])
m = sum((si for a, b, si in ls))
k = s * (m // s)
n = m - k
x = y = z = 0
for a, b, si in ls:
if k >= si:
k -= si
z += si * a
elif k:
z += k * a
x = (si - k) * a
y = (si - k) * b
k = 1
else:
x += si * a
y += si * b
return (x, y, z, n)
n, s = list(map(int, input().split()))
first = []
second = []
for i in range(n):
si, ai, bi = list(map(int, input().split()))
if ai > bi:
first.append((ai, bi, si))
else:
second.append((bi, ai, si))
x1, y1, z1, n1 = solve(first)
x2, y2, z2, n2 = solve(second)
d = x1 + x2 if n1 + n2 > s else max(x1 + y2, x2 + y1)
print(z1 + z2 + d)
084
def bins(sortedlist, x):
n = len(sortedlist)
start = 0
end = n - 1
while start <= end:
mid = int((start + end) / 2)
if x == sortedlist[mid][0]:
return mid
elif x < sortedlist[mid][0]:
end = mid - 1
else:
start = mid + 1
if sortedlist[mid][0] <= x:
return mid
else:
return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
temp = hap[i][0]
hap[i][0] = hap[i][1]
hap[i][1] = hap[i][2]
hap[i][2] = temp
for i in range(n):
slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
if hap[i][0] > hap[i][1]:
a += hap[i][2]
happi += hap[i][2] * hap[i][0]
else:
b += hap[i][2]
happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s >= s:
print(happi)
else:
loc = bins(slab, 0)
happia = happi
count = 0
b = b % s
a = a % s
left = b % s
while left > 0:
if slab[loc + count][1] < left:
happia += slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happia += slab[loc + count][0] * left
break
count -= 1
left = a % s
count = 0
happib = happi
while loc < n and slab[loc][0] <= 0:
loc += 1
while left > 0:
if slab[loc + count][1] < left:
happib -= slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happib -= slab[loc + count][0] * left
break
count += 1
print(max(happia, happib))
085
n, k = map(int, input().split())
a = list(map(int, input().split()))
d = list(map(int, input().split()))
if k == 0:
best = 0
curr = sum(a)
for i in range(n):
best = max(best, curr - d[i])
curr -= a[i]
print(best)
elif k == 1:
best = sum(a[:-1]) - min(d[:-1])
other = sum(a)
other -= sorted(d)[0]
other -= sorted(d)[1]
curr = sum(a)
for i in range(n):
if i:
best = max(best, curr - d[i - 1])
curr -= a[i]
o2 = sum(a) - min(a[1:]) - d[0]
print(max((best, other, 0, o2)))
else:
print(max((sum(a) - min(d[:-1]), 0, a[-1] - d[-1])))
086
def add(ans, r, c):
if cells[r][c] == '0':
cells[r][c] = '1'
rc = (r, c)
ans.append(rc)
def dfs(r, c):
ans = [(r, c)]
for r, c in ans:
if c != 4:
add(ans, r, c - 1)
if c != n:
add(ans, r, c + 1)
if r != 1:
add(ans, r - 1, c)
if r != n:
add(ans, r + 1, c)
return ans
n = int(input())
r1, c1 = list(map(int, input().split()))
r2, c2 = list(map(int, input().split()))
res = 5000
cells = (['1'],) + tuple((['1'] + list(input()) for _ in range(n)))
dfs1 = dfs(r1, c1)
for rs, cs in dfs(r2, c2):
for rt, ct in dfs1:
res = min(res, (rs - rt) ** 2 + (cs - ct) ** 2)
print(res)
087
import collections
import bisect
def f():
n, m = [int(c) for c in input().split()]
s = list(input())
ll = []
start = 0
length = 0
inside = False
cc = 0
for i in range(len(s)):
if s[i] == '.':
if not inside:
inside = True
length += 1
elif inside:
cc += length - 1
length = 0
inside = False
if inside:
cc += length - 1
res = [0] * m
for i in range(m):
line = input().split()
j = int(line[0]) - 1
c = line[1]
if c == '.' and s[j] == '.' or (c != '.' and s[j] != '.'):
res[i] = cc
else:
e1 = False
e2 = False
if j > 0 and s[j - 1] == '.':
e1 = True
if j < n - 1 and s[j + 1] == '.':
e2 = True
if e1 and e2:
cc -= 2 if c == '.' else -2
elif e1 or e2:
cc += 1 if c == '.' else -1
s[j] = c
res[i] = cc
for r in res:
print(r)
f()
088
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)
089
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1]:
count -= 1
if index < n - 1 and s[index + 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1]:
count += 1
if index < n - 1 and s[index + 1 - 1]:
count += 1
s[index] = True
print(count)
090
def add(ans, r, c):
if cells[r][c] == '0':
cells[r][c] = '1'
rc = (r, c)
ans.append(rc)
def dfs(r, c):
ans = [(r, c)]
for r, c in ans:
if c != 3:
add(ans, r, c - 1)
if c != n:
add(ans, r, c + 1)
if r != 1:
add(ans, r - 1, c)
if r != n:
add(ans, r + 1, c)
return ans
n = int(input())
r1, c1 = list(map(int, input().split()))
r2, c2 = list(map(int, input().split()))
res = 5000
cells = (['1'],) + tuple((['1'] + list(input()) for _ in range(n)))
dfs1 = dfs(r1, c1)
for rs, cs in dfs(r2, c2):
for rt, ct in dfs1:
res = min(res, (rs - rt) ** 2 + (cs - ct) ** 2)
print(res)
091
def bins(sortedlist, x):
n = len(sortedlist)
start = 0
end = n - 1
while start <= end:
mid = int((start + end) / 2)
if x == sortedlist[mid][0]:
return mid
elif x < sortedlist[mid][0]:
end = mid - 1
else:
start = mid + 1
if sortedlist[mid][0] <= x:
return mid
else:
return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
temp = hap[i][0]
hap[i][0] = hap[i][1]
hap[i][1] = hap[i][2]
hap[i][2] = temp
for i in range(n):
slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
if hap[i][0] >= hap[i][1]:
a += hap[i][2]
happi += hap[i][2] * hap[i][0]
else:
b += hap[i][2]
happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
print(happi)
else:
loc = bins(slab, 0)
happia = happi
count = 0
b = b % s
a = a % s
left = b % s
while left > 0:
if slab[loc + count][1] < left:
happia += slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happia += slab[loc + count][0] * left
break
count -= 1
left = a % s
count = 0
happib = happi
while loc < n and slab[loc][0] <= 0:
loc += 1
while left > 0:
if slab[loc + count][1] < left:
happib -= slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happib -= slab[loc + count][0] * left
break
count += 1
print(max(happia, happib))
092
n = int(input())
r1, c1 = map(int, input().split())
r2, c2 = map(int, input().split())
a = [['1'] * (n + 2)]
for _ in range(n):
s = input()
d = ['1']
for i in s:
d.append(i)
d.append('1')
a.append(d)
a.append(['1'] * (n + 2))
s = []
f = []
q = [[r1, c1]]
while q:
x, y = q.pop()
a[x][y] = '1'
s.append([x, y])
if a[x - 1 - 1][y] == '0':
q.append([x - 1, y])
if a[x][y - 1] == '0':
q.append([x, y - 1])
if a[x + 1][y] == '0':
q.append([x + 1, y])
if a[x][y + 1] == '0':
q.append([x, y + 1])
if [r2, c2] in s:
print(0)
else:
q = [[r2, c2]]
while q:
x, y = q.pop()
a[x][y] = '1'
f.append([x, y])
if a[x - 1][y] == '0':
q.append([x - 1, y])
if a[x][y - 1] == '0':
q.append([x, y - 1])
if a[x + 1][y] == '0':
q.append([x + 1, y])
if a[x][y + 1] == '0':
q.append([x, y + 1])
res = 10 ** 10
for i in s:
for j in f:
res = min(res, (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2)
print(res)
093
L1 = list(map(int, input().split()))
numList = list(map(int, input().split()))
length = L1[0]
targetnumber = L1[1]
pos = numList.index(targetnumber)
pos_r = pos + 1
rem = 0
right = {0: 1}
left = {0: 1}
while pos_r <= length - 1:
if numList[pos_r] > targetnumber:
rem += 1
else:
rem -= 1
if rem not in right:
right[rem] = 1
else:
right[rem] += 1
pos_r += 1
pos_l = pos - 1
rem = 0
while pos_l >= 0:
if numList[pos_l] > targetnumber:
rem += 1
else:
rem += 1
if rem not in left:
left[rem] = 1
else:
left[rem] += 1
pos_l -= 1
sum = 0
for number_l in left:
if number_l * -1 in right:
sum += left[number_l] * right[-1 * number_l]
if 1 - number_l in right:
sum += left[number_l] * right[1 - number_l]
print(sum)
094
n, m = map(int, input().split(' '))
numbers = list(map(int, input().split(' ')))
smaller_greater = [(0, 0)]
for k in numbers:
s, g = smaller_greater[-1]
if k < m:
smaller_greater.append((s + 1, g))
elif k > m:
smaller_greater.append((s, g + 1))
else:
smaller_greater.append((s, g))
i = numbers.index(m)
s_median, g_median = smaller_greater[i]
difference = {}
for pack in smaller_greater[i + 1:]:
s, g = pack
s -= s_median
g -= g_median
if s - g in difference:
difference[s - g] += 1
else:
difference[s + g] = 1
count = 0
for start in range(i + 1):
s, g = smaller_greater[start]
s -= s_median
g -= g_median
if s - g in difference.keys():
count += difference[s - g]
if s - g - 1 in difference.keys():
count += difference[s - g - 1]
print(count)
095
import math
from collections import Counter, defaultdict
from itertools import accumulate
R = lambda: map(int, input().split())
n = int(input())
spl = [math.inf]
ot_forbid = 0
sp = 0
res = 0
for i in range(n):
arr = list(R())
tp = arr[0]
if tp == 1:
sp = arr[1]
while sp > spl[-1]:
spl.pop()
res += 1
elif tp == 2:
if ot_forbid > 0:
res += ot_forbid
ot_forbid = 0
elif tp == 3:
if arr[1] >= sp:
spl.append(arr[1])
else:
res += 1
elif tp == 4:
ot_forbid = -1
elif tp == 5:
spl = [math.inf]
else:
ot_forbid += 1
print(res)
096
L1 = list(map(int, input().split()))
numList = list(map(int, input().split()))
length = L1[0]
targetnumber = L1[1]
pos = numList.index(targetnumber)
pos_r = pos + 1
rem = 0
right = {0: 1}
left = {0: 1}
while pos_r <= length - 1:
if numList[pos_r] > targetnumber:
rem += 1
else:
rem += 1
if rem not in right:
right[rem] = 1
else:
right[rem] += 1
pos_r += 1
pos_l = pos - 1
rem = 0
while pos_l >= 0:
if numList[pos_l] > targetnumber:
rem += 1
else:
rem -= 1
if rem not in left:
left[rem] = 1
else:
left[rem] += 1
pos_l -= 1
sum = 0
for number_l in left:
if number_l * -1 in right:
sum += left[number_l] * right[-1 * number_l]
if 1 - number_l in right:
sum += left[number_l] * right[1 - number_l]
print(sum)
097
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n - 1) % (10 ** 9 + 7)
n, k = [int(i) for i in input().split()]
s = [[] for i in range(n)]
for i in range(n - 1):
a, b, c = [int(i) for i in input().split()]
if c == 0:
s[a - 1].append(b - 1)
s[b - 1].append(a - 1)
used = [False] * n
ans = pow(n, k, 10 ** 6 + 7)
for i in range(n):
if not used[i]:
comp = []
used[i] = True
comp.append(i)
c = 0
while c < len(comp):
for h in s[comp[c]]:
if not used[h]:
used[h] = True
comp.append(h)
c += 1
ans = (ans - pow(len(comp), k, 10 ** 9 + 7)) % (10 ** 9 + 7)
print(ans)
098
import sys
input = sys.stdin.readline
n, k = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(n - 1)]
mod = 10 ** 9 + 7
Group = [i for i in range(n + 1)]
def find(x):
while Group[x] != x:
x = Group[x - 1]
return x
def Union(x, y):
if find(x) != find(y):
Group[find(y)] = Group[find(x)] = min(find(y), find(x))
for x, y, c in EDGE:
if c == 0:
Union(x, y)
G = [find(i) for i in range(1, n + 1)]
from collections import Counter
counter = Counter(G)
ANS = 0
for j in list(counter.values()):
ANS = (ANS + pow(j, k, mod)) % mod
print((pow(n, k, mod) - ANS) % mod)
099
def merge(a, b):
inda = 0
indb = 0
lena = len(a)
lenb = len(b)
d = [a[-1] + b[-1] + 1000]
a += d
b += d
c = []
inversions = 0
for i in range(lena + lenb):
if a[inda] < b[indb]:
c.append(a[inda])
inda += 1
else:
c.append(b[indb])
indb += 1
inversions += lena - inda
return (c, inversions)
def mergesort(a):
if len(a) <= 1:
return (a, 0)
split = len(a) // 2
b = a[:split]
c = a[split:]
d = mergesort(b)
e = mergesort(c)
f = merge(d[0], e[0])
return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
if guy != -1:
b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
if guy != -1:
used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
if a[i] == -1:
negsseen += 1
else:
mix += unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix // 2
denom = 2 * negs
if negs == 0:
print(invs % 998244353)
else:
for i in range(denom):
if (998244353 * i + 1) % denom == 0:
inv = (998244353 * i + 1) // denom
break
print(num * inv % 998244353)
100
def bins(sortedlist, x):
n = len(sortedlist)
start = 0
end = n - 1
while start <= end:
mid = int((start + end) / 2)
if not x == sortedlist[mid][0]:
return mid
elif x < sortedlist[mid][0]:
end = mid - 1
else:
start = mid + 1
if sortedlist[mid][0] <= x:
return mid
else:
return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
temp = hap[i][0]
hap[i][0] = hap[i][1]
hap[i][1] = hap[i][2]
hap[i][2] = temp
for i in range(n):
slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
if hap[i][0] > hap[i][1]:
a += hap[i][2]
happi += hap[i][2] * hap[i][0]
else:
b += hap[i][2]
happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
print(happi)
else:
loc = bins(slab, 0)
happia = happi
count = 0
b = b % s
a = a % s
left = b % s
while left > 0:
if slab[loc + count][1] < left:
happia += slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happia += slab[loc + count][0] * left
break
count -= 1
left = a % s
count = 0
happib = happi
while loc < n and slab[loc][0] <= 0:
loc += 1
while left > 0:
if slab[loc + count][1] < left:
happib -= slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happib -= slab[loc + count][0] * left
break
count += 1
print(max(happia, happib))
101
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1 - 1]:
count -= 1
if index < n - 1 and s[index + 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1]:
count += 1
if index < n - 1 and s[index + 1]:
count += 1
s[index] = True
print(count)
102
n, m = map(int, input().split(' '))
numbers = list(map(int, input().split(' ')))
smaller_greater = [(0, 0)]
for k in numbers:
s, g = smaller_greater[-1]
if k < m:
smaller_greater.append((s + 1, g))
elif k > m:
smaller_greater.append((s, g + 1))
else:
smaller_greater.append((s, g))
i = numbers.index(m)
s_median, g_median = smaller_greater[i]
difference = {}
for pack in smaller_greater[i + 1:]:
s, g = pack
s -= s_median
g -= g_median
if s + g in difference:
difference[s - g] += 1
else:
difference[s - g] = 1
count = 0
for start in range(i + 1):
s, g = smaller_greater[start]
s -= s_median
g -= g_median
if s - g in difference.keys():
count += difference[s - g]
if s - g - 1 in difference.keys():
count += difference[s - g - 1]
print(count)
103
from collections import deque
def BFS(a, vertex=None):
if vertex is None:
vertex = 1
s = [1] * len(a)
d = deque([vertex])
s[vertex] = 0
f = {vertex}
while len(d) > 0:
for q in a[d.popleft()]:
if s[q]:
d.append(q)
f.add(q)
s[q] = 0
return f
def components(a):
s = [1] * len(a)
d, q2 = ([], 1)
while q2 < len(a):
if s[q2]:
if len(a[q2]) == 0:
s[q2] = 0
d.append({q2})
else:
f = BFS(a, q2)
d.append(f)
for q in f:
s[q] = 0
else:
q2 += 1
return d
n = int(input())
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)]
d = [[] for _ in range(n ** 2 + 1)]
for q in range(1, n + 1):
for q1 in range(1, n + 1 - 1):
if a[q][q1]:
if a[q - 1][q1]:
d[(q - 1) * n + q1].append((q - 2) * n + q1)
if a[q + 1][q1]:
d[(q - 1) * n + q1].append(q * n + q1)
if a[q][q1 - 1]:
d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1)
if a[q][q1 + 1]:
d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1)
x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2)
s = components(d)
comp_x, comp_y = ([], [])
for q in s:
if x in q:
comp_x = q
if y in q:
comp_y = q
if comp_y == comp_x:
print(0)
else:
ans = float('inf')
for q in comp_x:
for q1 in comp_y:
x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1)
ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans)
print(ans)
104
rr = lambda: input().strip()
rri = lambda: int(rr())
rrm = lambda: list(map(int, rr().split()))
MOD = 10 ** 9 + 7
class DSU:
def __init__(self, N):
self.par = list(range(N + 1))
self.rnk = [0] * (N + 1)
self.sz = [-1] * (N + 1)
def find(self, x):
if self.par[x] != x:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
xr, yr = (self.find(x), self.find(y))
if xr == yr:
return
if self.rnk[xr] < self.rnk[yr]:
xr, yr = (yr, xr)
if self.rnk[xr] == self.rnk[yr]:
self.rnk[xr] += 1
self.par[yr] = xr
self.sz[xr] += self.sz[yr]
def size(self, x):
return self.sz[self.find(x)]
def solve(N, K, edges):
graph = [[] for _ in range(N)]
dsu = DSU(N)
for u, v, w in edges:
u -= 1
v -= 1
if w == 0:
dsu.union(u, v)
ans = pow(N, K, MOD)
for x in range(N):
if dsu.find(x) == x:
ans -= pow(dsu.size(x), K, MOD)
ans %= MOD
return ans
for tc in range(1):
N, K = rrm()
edges = [rrm() for _ in range(N - 1)]
print(solve(N, K, edges))
105
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x - 1 + 1] = nc
print(res)
106
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__()
107
n, m = list(map(int, input().split(' ')))
aa = list(map(int, input().split(' ')))
def countMoreLess(vs, value):
cur = 0
res = {cur: 1}
for v in vs:
cur += 1 if v > value else -2
res[cur] = res.get(cur, 0) + 1
return res
pos = aa.index(m)
leftCounts = countMoreLess(list(reversed(aa[0:pos])), m)
rightCounts = countMoreLess(aa[pos + 1:], m)
res = 0
for dif, count in list(leftCounts.items()):
res += count * rightCounts.get(-dif, 0)
res += count * rightCounts.get(-dif + 1, 0)
print(res)
108
n = int(input())
r1, c1 = map(int, input().split())
r2, c2 = map(int, input().split())
a = [['1'] * (n + 2)]
for _ in range(n):
s = input()
d = ['1']
for i in s:
d.append(i)
d.append('1')
a.append(d)
a.append(['1'] * (n + 2))
s = []
f = []
q = [[r1, c1]]
while q:
x, y = q.pop()
a[x][y] = '1'
s.append([x, y])
if a[x - 1][y] == '0':
q.append([x - 1, y])
if a[x][y - 0] == '0':
q.append([x, y - 1])
if a[x + 1][y] == '0':
q.append([x + 1, y])
if a[x][y + 1] == '0':
q.append([x, y + 1])
if [r2, c2] in s:
print(0)
else:
q = [[r2, c2]]
while q:
x, y = q.pop()
a[x][y] = '1'
f.append([x, y])
if a[x - 1][y] == '0':
q.append([x - 1, y])
if a[x][y - 1] == '0':
q.append([x, y - 1])
if a[x + 1][y] == '0':
q.append([x + 1, y])
if a[x][y + 1] == '0':
q.append([x, y + 1])
res = 10 ** 10
for i in s:
for j in f:
res = min(res, (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2)
print(res)
109
rr = lambda: input().strip()
rri = lambda: int(rr())
rrm = lambda: list(map(int, rr().split()))
MOD = 10 ** 9 + 3
class DSU:
def __init__(self, N):
self.par = list(range(N + 1))
self.rnk = [0] * (N + 1)
self.sz = [1] * (N + 1)
def find(self, x):
if self.par[x] != x:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
xr, yr = (self.find(x), self.find(y))
if xr == yr:
return
if self.rnk[xr] < self.rnk[yr]:
xr, yr = (yr, xr)
if self.rnk[xr] == self.rnk[yr]:
self.rnk[xr] += 1
self.par[yr] = xr
self.sz[xr] += self.sz[yr]
def size(self, x):
return self.sz[self.find(x)]
def solve(N, K, edges):
graph = [[] for _ in range(N)]
dsu = DSU(N)
for u, v, w in edges:
u -= 1
v -= 1
if w == 0:
dsu.union(u, v)
ans = pow(N, K, MOD)
for x in range(N):
if dsu.find(x) == x:
ans -= pow(dsu.size(x), K, MOD)
ans %= MOD
return ans
for tc in range(1):
N, K = rrm()
edges = [rrm() for _ in range(N - 1)]
print(solve(N, K, edges))
110
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
d = list(map(int, input().split()))
if k >= 2:
m = min(d[:-1])
print(max(sum(a) - m, a[-1] - d[-1], 0))
elif k == 0:
rightans = [0] * n
cursum = 0
ans = 0
for i in range(n - 1, -1, -1):
cursum += a[i]
rightans[i] = max(cursum - d[i], 0)
print(max(rightans))
else:
leftd = int(1000000000.0)
leftsum = 0
rightans = [0] * n
cursum = 0
ans = 0
for i in range(n - 1, -1, -1):
cursum += a[i]
rightans[i] = max(cursum - d[i], 0)
for i in range(n - 1, 0, -1):
rightans[i - 1] = max(rightans[i - 1], rightans[i])
for i in range(n - 1):
leftd = min(leftd, d[i])
leftsum += a[i + 1]
curans = max(leftsum - leftd, 0) + rightans[i + 1]
ans = max(ans, curans)
cursum = 0
rightmin = int(1000000000.0)
for i in range(n - 1, -1, -1):
cursum += a[i]
ans = max(ans, cursum - rightmin - d[i])
rightmin = min(rightmin, a[i])
print(ans)
111
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)
112
from collections import deque
def BFS(a, vertex=None):
if vertex is None:
vertex = 1
s = [1] * len(a)
d = deque([vertex])
s[vertex] = 0
f = {vertex}
while len(d) > 0:
for q in a[d.popleft()]:
if s[q]:
d.append(q)
f.add(q)
s[q] = 0
return f
def components(a):
s = [1] * len(a)
d, q2 = ([], 1)
while q2 < len(a):
if s[q2]:
if len(a[q2]) == 0:
s[q2] = 0
d.append({q2})
else:
f = BFS(a, q2)
d.append(f)
for q in f:
s[q] = 0
else:
q2 += 1
return d
n = int(input())
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)]
d = [[] for _ in range(n ** 2 + 1)]
for q in range(1, n + 1):
for q1 in range(1, n + 1):
if a[q][q1]:
if a[q - 1][q1]:
d[(q - 1) * n + q1].append((q - 2) * n + q1)
if a[q + 1][q1]:
d[(q - 1) * n + q1].append(q * n + q1)
if a[q][q1 - 1]:
d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1)
if a[q][q1 + 1]:
d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1)
x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2)
s = components(d)
comp_x, comp_y = ([], [])
for q in s:
if x in q:
comp_x = q
if y in q:
comp_y = q
if comp_y == comp_x:
print(1)
else:
ans = float('inf')
for q in comp_x:
for q1 in comp_y:
x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1)
ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans)
print(ans)
113
import collections
import bisect
def f():
n, m = [int(c) for c in input().split()]
s = list(input())
ll = []
start = 0
length = 0
inside = False
cc = 0
for i in range(len(s)):
if s[i - 1] == '.':
if not inside:
inside = True
length += 1
elif inside:
cc += length - 1
length = 0
inside = False
if inside:
cc += length - 1
res = [0] * m
for i in range(m):
line = input().split()
j = int(line[0]) - 1
c = line[1]
if c == '.' and s[j] == '.' or (c != '.' and s[j] != '.'):
res[i] = cc
else:
e1 = False
e2 = False
if j > 0 and s[j - 1] == '.':
e1 = True
if j < n - 1 and s[j + 1] == '.':
e2 = True
if e1 and e2:
cc += 2 if c == '.' else -2
elif e1 or e2:
cc += 1 if c == '.' else -1
s[j] = c
res[i] = cc
for r in res:
print(r)
f()
114
base = 998244353
def power(x, y):
if y == 0:
return 1
t = power(x, y // 2)
t = t * t % base
if y % 2:
t = t * x % base
return t
def inverse(x):
return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
ft.append(0)
def get(i):
res = 0
while i <= 200000:
res += ft[i]
i += i & -i
return res
def update(i, x):
while i:
ft[i] += x
i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
non.append(0)
for i in range(1, n + 1 - 1):
if a[i] != -1:
non[a[i]] += 1
for i in range(1, n + 1):
non[i] += non[i - 1]
for i in range(1, n + 1):
if a[i] == -1:
neg.append(neg[i - 1] + 1)
else:
neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
if a[i] != -1:
ans += get(a[i])
update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1):
fs = fm
fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1):
if a[i] != -1:
less = a[i] - non[a[i]]
more = m - less
ans = (ans + neg[i] * more * fs) % base
ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
115
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)
116
def bins(sortedlist, x):
n = len(sortedlist)
start = 0
end = n - 1
while start <= end:
mid = int((start + end) / 2)
if x == sortedlist[mid][0]:
return mid
elif x < sortedlist[mid][0]:
end = mid - 1
else:
start = mid + 1
if sortedlist[mid][0] <= x:
return mid
else:
return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 1
sla = []
slb = []
slab = []
for i in range(n):
temp = hap[i][0]
hap[i][0] = hap[i][1]
hap[i][1] = hap[i][2]
hap[i][2] = temp
for i in range(n):
slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
if hap[i][0] > hap[i][1]:
a += hap[i][2]
happi += hap[i][2] * hap[i][0]
else:
b += hap[i][2]
happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
print(happi)
else:
loc = bins(slab, 0)
happia = happi
count = 0
b = b % s
a = a % s
left = b % s
while left > 0:
if slab[loc + count][1] < left:
happia += slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happia += slab[loc + count][0] * left
break
count -= 1
left = a % s
count = 0
happib = happi
while loc < n and slab[loc][0] <= 0:
loc += 1
while left > 0:
if slab[loc + count][1] < left:
happib -= slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happib -= slab[loc + count][0] * left
break
count += 1
print(max(happia, happib))
117
import sys
sys.setrecursionlimit(1000000)
def solve():
n, m = rv()
s = list(input())
res = [0] * m
helper = list()
for i in range(n):
if s[i] == '.':
if i == 0:
helper.append(1)
elif s[i - 1] == '.':
helper[-1] += 1
else:
helper.append(1)
initval = 0
for val in helper:
initval += val - 1
for query in range(m):
index, replace = input().split()
index = int(index) - 1
if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'):
res[query] = initval
else:
sidedots = 0
if index > 0:
if s[index - 1] == '.':
sidedots += 1
if index < n - 1:
if s[index + 1] == '.':
sidedots += 1
if s[index - 1] == '.':
res[query] = initval - sidedots
initval -= sidedots
else:
res[query] = initval + sidedots
initval += sidedots
s[index] = replace
print('\n'.join(map(str, res)))
def rv():
return list(map(int, input().split()))
def rl(n):
return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544:
sys.stdin = open('test.txt')
solve()
118
import sys
sys.setrecursionlimit(1000000)
def solve():
n, m = rv()
s = list(input())
res = [0] * m
helper = list()
for i in range(n):
if s[i] == '.':
if i == 0:
helper.append(1)
elif s[i - 1] == '.':
helper[-1] += 1
else:
helper.append(1)
initval = 0
for val in helper:
initval += val - 1
for query in range(m):
index, replace = input().split()
index = int(index) - 1
if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'):
res[query] = initval
else:
sidedots = 0
if index > 0:
if s[index - 1] == '.':
sidedots += 1
if index < n - 1:
if s[index + 1] == '.':
sidedots += 1
if s[index] == '.':
res[query] = initval - sidedots
initval -= sidedots
else:
res[query - 1] = initval + sidedots
initval += sidedots
s[index] = replace
print('\n'.join(map(str, res)))
def rv():
return list(map(int, input().split()))
def rl(n):
return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544:
sys.stdin = open('test.txt')
solve()
119
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__()
120
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)
121
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
d = list(map(int, input().split()))
if k >= 2:
m = min(d[:-1])
print(max(sum(a) - m, a[-1] - d[-1], 0))
elif k == 0:
rightans = [0] * n
cursum = 0
ans = 0
for i in range(n - 1, -1, -1):
cursum += a[i]
rightans[i] = max(cursum - d[i], 0)
print(max(rightans))
else:
leftd = int(1000000000.0)
leftsum = 0
rightans = [0] * n
cursum = 0
ans = 0
for i in range(n - 1, -1, -1):
cursum += a[i]
rightans[i] = max(cursum - d[i], 0)
for i in range(n - 1, 0, -1):
rightans[i - 1] = max(rightans[i - 1], rightans[i])
for i in range(n - 1):
leftd = min(leftd, d[i])
leftsum += a[i]
curans = max(leftsum - leftd, 0) + rightans[i + 1]
ans = max(ans, curans)
cursum = 0
rightmin = int(1000000000.0)
for i in reversed(range(n - 1, -1, -1)):
cursum += a[i]
ans = max(ans, cursum - rightmin - d[i])
rightmin = min(rightmin, a[i])
print(ans)
122
T = input().split(' ')
n = int(T[0])
m = int(T[1])
S = input().split(' ')
for i in range(n):
S[i] = int(S[i])
ind = 0
for k in range(n):
if S[k] == m:
ind = k
k = ind
P = [0] * (n + 1)
N = [1] * (n + 1)
R = [0] * (n - k)
L = [0] * (k + 1)
for i in range(k):
if S[k - 1 - i] < m:
L[k - 1 - i] = L[k - i] - 1
else:
L[k - 1 - i] = L[k - i] + 1
for i in range(n - k - 1):
if S[k + 1 + i] > m:
R[1 + i] = R[i] + 1
else:
R[1 + i] = R[i] - 1
c = 0
for el in R:
if el >= 0:
P[el] += 1
if el == 0:
N[el] += 1
else:
N[-el] += 1
for el in L:
if el >= 1:
c = c + N[el] + N[el - 1]
else:
c = c + P[-el] + P[-el + 1]
print(c)
123
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))
124
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
if L[i] > 0:
D[L[i]] = i
J.append(L[i])
T[i + 1] = T[i]
else:
T[i + 1] = T[i] + 1
def I(J):
if len(J) <= 1:
return (J, 0)
else:
a = J[:len(J) // 2]
b = J[len(J) // 2:]
a, ai = I(a)
b, bi = I(b)
c = []
i = 0
j = 0
inversions = ai + bi
while i < len(a) and j < len(b):
if a[i] <= b[j]:
c.append(a[i])
i += 1
else:
c.append(b[j])
j += 1
inversions += len(a) - i
c += a[i:]
c += b[j:]
return (c, inversions)
for i in range(1, n + 1 - 1):
if not i in D:
S.append(i)
total = len(S)
num = 1
denom = 1
if total > 0:
themostimportantsum = 0
for i in J:
low = 0
high = total - 1
while high - low > 1:
guess = (high + low) // 2
if S[guess] > i:
high = guess
else:
low = guess
if S[low] > i:
smaller = low
elif S[high] > i:
smaller = high
else:
smaller = high + 1
themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
num = themostimportantsum + total
denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
if I(J)[1] == 0:
print(0)
else:
print(I(J)[1] % 998244353)
else:
num += denom * I(J)[1]
print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
125
def merge(a, b):
inda = 0
indb = 0
lena = len(a)
lenb = len(b)
d = [a[-1] + b[-1] + 1000]
a += d
b += d
c = []
inversions = 0
for i in range(lena + lenb + 1):
if a[inda] < b[indb]:
c.append(a[inda])
inda += 1
else:
c.append(b[indb])
indb += 1
inversions += lena - inda
return (c, inversions)
def mergesort(a):
if len(a) <= 1:
return (a, 0)
split = len(a) // 2
b = a[:split]
c = a[split:]
d = mergesort(b)
e = mergesort(c)
f = merge(d[0], e[0])
return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
if guy != -1:
b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
if guy != -1:
used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
if a[i] == -1:
negsseen += 1
else:
mix += unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix * 2
denom = 2 * negs
if negs == 0:
print(invs % 998244353)
else:
for i in range(denom):
if (998244353 * i + 1) % denom == 0:
inv = (998244353 * i + 1) // denom
break
print(num * inv % 998244353)
126
L1 = list(map(int, input().split()))
numList = list(map(int, input().split()))
length = L1[0]
targetnumber = L1[1]
pos = numList.index(targetnumber)
pos_r = pos + 1
rem = 0
right = {0: 1}
left = {0: 1}
while pos_r <= length - 1:
if numList[pos_r] > targetnumber:
rem += 1
else:
rem *= 1
if rem not in right:
right[rem] = 1
else:
right[rem] += 1
pos_r += 1
pos_l = pos - 1
rem = 0
while pos_l >= 0:
if numList[pos_l] > targetnumber:
rem += 1
else:
rem -= 1
if rem not in left:
left[rem] = 1
else:
left[rem] += 1
pos_l -= 1
sum = 0
for number_l in left:
if number_l * -1 in right:
sum += left[number_l] * right[-1 * number_l]
if 1 - number_l in right:
sum += left[number_l] * right[1 - number_l]
print(sum)
127
def merge(a, b):
inda = 0
indb = 0
lena = len(a)
lenb = len(b)
d = [a[-1] + b[-1] + 1000]
a += d
b += d
c = []
inversions = 0
for i in range(lena + lenb):
if a[inda] < b[indb]:
c.append(a[inda])
inda += 1
else:
c.append(b[indb])
indb += 1
inversions += lena - inda
return (c, inversions)
def mergesort(a):
if len(a) <= 1:
return (a, 0)
split = len(a) // 2
b = a[:split]
c = a[split:]
d = mergesort(b)
e = mergesort(c)
f = merge(d[0], e[0])
return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
if guy != -1:
b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
if guy != -1:
used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
if a[i] == -1:
negsseen += 1
else:
mix *= unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix * 2
denom = 2 * negs
if negs == 0:
print(invs % 998244353)
else:
for i in range(denom):
if (998244353 * i + 1) % denom == 0:
inv = (998244353 * i + 1) // denom
break
print(num * inv % 998244353)
128
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
if L[i] > 4:
D[L[i]] = i
J.append(L[i])
T[i + 1] = T[i]
else:
T[i + 1] = T[i] + 1
def I(J):
if len(J) <= 1:
return (J, 0)
else:
a = J[:len(J) // 2]
b = J[len(J) // 2:]
a, ai = I(a)
b, bi = I(b)
c = []
i = 0
j = 0
inversions = ai + bi
while i < len(a) and j < len(b):
if a[i] <= b[j]:
c.append(a[i])
i += 1
else:
c.append(b[j])
j += 1
inversions += len(a) - i
c += a[i:]
c += b[j:]
return (c, inversions)
for i in range(1, n + 1):
if not i in D:
S.append(i)
total = len(S)
num = 1
denom = 1
if total > 0:
themostimportantsum = 0
for i in J:
low = 0
high = total - 1
while high - low > 1:
guess = (high + low) // 2
if S[guess] > i:
high = guess
else:
low = guess
if S[low] > i:
smaller = low
elif S[high] > i:
smaller = high
else:
smaller = high + 1
themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
num = themostimportantsum + total
denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
if I(J)[1] == 0:
print(0)
else:
print(I(J)[1] % 998244353)
else:
num += denom * I(J)[1]
print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
129
import collections
import bisect
def f():
n, m = [int(c) for c in input().split()]
s = list(input())
ll = []
start = 0
length = 0
inside = False
cc = 0
for i in range(len(s)):
if s[i] == '.':
if not inside:
inside = True
length += 1
elif inside:
cc += length - 1
length = 0
inside = False
if inside:
cc += length - 1
res = [0] * m
for i in range(m):
line = input().split()
j = int(line[0]) - 1
c = line[1]
if c == '.' and s[j] == '.' or (c == '.' and s[j] != '.'):
res[i] = cc
else:
e1 = False
e2 = False
if j > 0 and s[j - 1] == '.':
e1 = True
if j < n - 1 and s[j + 1] == '.':
e2 = True
if e1 and e2:
cc += 2 if c == '.' else -2
elif e1 or e2:
cc += 1 if c == '.' else -1
s[j] = c
res[i] = cc
for r in res:
print(r)
f()
130
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
if L[i] > 0:
D[L[i]] = i
J.append(L[i])
T[i + 1] = T[i]
else:
T[i + 1 - 1] = T[i] + 1
def I(J):
if len(J) <= 1:
return (J, 0)
else:
a = J[:len(J) // 2]
b = J[len(J) // 2:]
a, ai = I(a)
b, bi = I(b)
c = []
i = 0
j = 0
inversions = ai + bi
while i < len(a) and j < len(b):
if a[i] <= b[j]:
c.append(a[i])
i += 1
else:
c.append(b[j])
j += 1
inversions += len(a) - i
c += a[i:]
c += b[j:]
return (c, inversions)
for i in range(1, n + 1):
if not i in D:
S.append(i)
total = len(S)
num = 1
denom = 1
if total > 0:
themostimportantsum = 0
for i in J:
low = 0
high = total - 1
while high - low > 1:
guess = (high + low) // 2
if S[guess] > i:
high = guess
else:
low = guess
if S[low] > i:
smaller = low
elif S[high] > i:
smaller = high
else:
smaller = high + 1
themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
num = themostimportantsum + total
denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
if I(J)[1] == 0:
print(0)
else:
print(I(J)[1] % 998244353)
else:
num += denom * I(J)[1]
print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
131
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))
132
import math
from collections import Counter, defaultdict
from itertools import accumulate
R = lambda: map(int, input().split())
n = int(input())
spl = [math.inf]
ot_forbid = 0
sp = 0
res = 0
for i in range(n):
arr = list(R())
tp = arr[0]
if tp == 1:
sp = arr[1]
while sp > spl[-1]:
spl.pop()
res += 1
elif tp == 2:
if ot_forbid > 0:
res += ot_forbid
ot_forbid = 0
elif tp == 3:
if arr[-2] >= sp:
spl.append(arr[1])
else:
res += 1
elif tp == 4:
ot_forbid = 0
elif tp == 5:
spl = [math.inf]
else:
ot_forbid += 1
print(res)
133
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)
134
import sys
sys.setrecursionlimit(536870912)
def dfs(i, j, vis, g, c):
vis[i][j] = 1
c.append((i, j))
'\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t'
if i > 0 and vis[i - 1][j] == 0 and (g[i - 1][j] == '0'):
dfs(i - 1, j, vis, g, c)
if i < n - 1 and vis[i + 1][j] == 0 and (g[i + 1][j] == '0'):
dfs(i + 1, j, vis, g, c)
if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'):
dfs(i, j + 1, vis, g, c)
if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'):
dfs(i, j - 1, vis, g, c)
n = int(input())
r1, c1 = map(int, input().split())
r1 -= 1
c1 -= 1
r2, c2 = map(int, input().split())
r2 -= 1
c2 -= 1
g = []
for i in range(n):
g.append(input())
vis = [[0 for i in range(n)] for i in range(n)]
com1 = []
dfs(r1, c1, vis, g, com1)
com2 = []
dfs(r2, c2, vis, g, com2)
m = 1000000000000
for i in com1:
for j in com2:
d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2
m = min(m, d)
print(m)
135
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1 - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1]:
count -= 1
if index < n - 1 and s[index + 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1]:
count += 1
if index < n - 1 and s[index + 1]:
count += 1
s[index] = True
print(count)
136
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])
def happy_diff(m):
return m.a_happy - m.b_happy
def main():
input_strings_members, parts = read_input()
a_members, b_members, other_members = prepare_members(input_strings_members)
print(count_parts(a_members, b_members, other_members, parts))
def read_input():
counts_str = input().split()
members_count, parts = list(map(int, counts_str))
return ([input() for _ in range(members_count)], parts)
def prepare_members(input_strings_members):
a_members = []
b_members = []
other_members = []
for line in input_strings_members:
m = Member(*list(map(int, line.split())))
if happy_diff(m) > 0:
a_members.append(m)
elif happy_diff(m) < 0:
b_members.append(m)
else:
other_members.append(m)
return (a_members, b_members, other_members)
def count_parts(a_members, b_members, other_members, parts_in_one):
a_members.sort(key=lambda m: happy_diff(m), reverse=False)
a_modulo = sum((m.parts for m in a_members)) % parts_in_one
a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
b_members.sort(key=lambda m: happy_diff(m), reverse=True)
b_modulo = sum((m.parts for m in b_members)) % parts_in_one
b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
return a_happy + b_happy + last_happy
def split_members_into_happy_groups(members, modulo):
modulo_members = []
happy_members = []
current_modulo = 0
for i in range(len(members)):
m = members[i]
new_current_modulo = current_modulo * m.parts
if new_current_modulo < modulo:
modulo_members.append(m)
current_modulo = new_current_modulo
continue
modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
if new_current_modulo > modulo:
happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
if i + 1 < len(members):
happy_members.extend(members[i + 1:])
break
return (modulo_members, happy_members)
def count_last_pizzas_happy(a, b, other, parts_in_one):
last_sorted_members = a + other + b
if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))
def test1():
a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
assert count_parts(a, b, c, 10) == 314
def test2():
a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
assert count_parts(a, b, c, 12) == 84
def test3():
a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
assert count_parts(a, b, c, 3) == 16
def test4():
a, b, c = prepare_members(['2 1 4', '2 3 1'])
assert count_parts(a, b, c, 3) == 14
def test5():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2
def test6():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 5) == 16 + 16 + 3
def test_without_last_pizzas():
a, b, c = prepare_members(['3 3 1', '3 5 6'])
assert count_parts(a, b, c, 3) == 27
def test_with_one_last_pizza():
a, b, c = prepare_members(['2 3 1', '1 5 6'])
assert count_parts(a, b, c, 3) == 11
def test_with_two_last_pizzas():
a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
assert count_parts(a, b, c, 3) == 15
def test_without_different_happies():
a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
assert count_parts(a, b, c, 3) == 38
def __starting_point():
main()
__starting_point()
137
def solve(ls):
ls.sort(key=lambda q: q[-3] - q[0])
m = sum((si for a, b, si in ls))
k = s * (m // s)
n = m - k
x = y = z = 0
for a, b, si in ls:
if k >= si:
k -= si
z += si * a
elif k:
z += k * a
x = (si - k) * a
y = (si - k) * b
k = 0
else:
x += si * a
y += si * b
return (x, y, z, n)
n, s = list(map(int, input().split()))
first = []
second = []
for i in range(n):
si, ai, bi = list(map(int, input().split()))
if ai > bi:
first.append((ai, bi, si))
else:
second.append((bi, ai, si))
x1, y1, z1, n1 = solve(first)
x2, y2, z2, n2 = solve(second)
d = x1 + x2 if n1 + n2 > s else max(x1 + y2, x2 + y1)
print(z1 + z2 + d)
138
import sys
n, k = list(map(int, input().split(' ')))
activate = list(map(int, input().split(' ')))
deactivate = list(map(int, input().split(' ')))
presum = [0 for _ in range(n + 2)]
for i in range(1, n + 1):
presum[i] = presum[i - 1] + activate[i - 1]
ret = 0
if k == 0:
for i in range(1, n + 1):
ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1])
elif k == 1:
for i in range(1, n):
ret = max(ret, presum[n - 1] - deactivate[i - 1])
if deactivate[n - 1] < activate[n - 1]:
ret += activate[n - 1] - deactivate[n - 1]
deac = sorted(deactivate[1:n - 1])
ac = sorted(activate[1:n - 1 - 1])
ret = max(ret, presum[n] - deactivate[0] - ac[0])
ret = max(ret, presum[n] - deactivate[0] - deac[0])
ret = max(ret, presum[n] - sorted(deactivate[0:n - 1])[0] - sorted(deactivate[0:n - 1])[1])
for i in range(2, n + 1):
ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1])
else:
for i in range(1, n):
ret = max(ret, presum[n] - deactivate[i - 1])
ret = max(ret, activate[n - 1] - deactivate[n - 1])
print(ret)
139
from collections import deque
mod = 10 ** 9 + 11
class TreeNode:
def __init__(self, val):
self.val = val
self.edges = {}
def add_edge(self, node, color):
self.edges[node] = color
n, k = list(map(int, input().split()))
tree = []
for i in range(1, n + 1):
tree.append(TreeNode(i))
for _ in range(n - 1):
u, v, x = list(map(int, input().split()))
tree[u - 1].add_edge(v, x)
tree[v - 1].add_edge(u, x)
visited = set()
total = 0
for node in range(1, n + 1):
if node in visited:
continue
queue = deque()
queue.append(node)
visited.add(node)
red_vertexes = 1
while queue:
vertex = queue.popleft()
for e, c in list(tree[vertex - 1].edges.items()):
if c == 0 and e not in visited:
queue.append(e)
red_vertexes = red_vertexes + 1
visited.add(e)
total = (total + pow(red_vertexes, k, mod)) % mod
total = (pow(n, k, mod) - total) % mod
print(total)
140
rr = lambda: input().strip()
rri = lambda: int(rr())
rrm = lambda: list(map(int, rr().split()))
MOD = 10 ** 8 + 7
class DSU:
def __init__(self, N):
self.par = list(range(N + 1))
self.rnk = [0] * (N + 1)
self.sz = [1] * (N + 1)
def find(self, x):
if self.par[x] != x:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
xr, yr = (self.find(x), self.find(y))
if xr == yr:
return
if self.rnk[xr] < self.rnk[yr]:
xr, yr = (yr, xr)
if self.rnk[xr] == self.rnk[yr]:
self.rnk[xr] += 1
self.par[yr] = xr
self.sz[xr] += self.sz[yr]
def size(self, x):
return self.sz[self.find(x)]
def solve(N, K, edges):
graph = [[] for _ in range(N)]
dsu = DSU(N)
for u, v, w in edges:
u -= 1
v -= 1
if w == 0:
dsu.union(u, v)
ans = pow(N, K, MOD)
for x in range(N):
if dsu.find(x) == x:
ans -= pow(dsu.size(x), K, MOD)
ans %= MOD
return ans
for tc in range(1):
N, K = rrm()
edges = [rrm() for _ in range(N - 1)]
print(solve(N, K, edges))
141
rr = lambda: input().strip()
rri = lambda: int(rr())
rrm = lambda: list(map(int, rr().split()))
MOD = 10 ** 9 + 6
class DSU:
def __init__(self, N):
self.par = list(range(N + 1))
self.rnk = [0] * (N + 1)
self.sz = [1] * (N + 1)
def find(self, x):
if self.par[x] != x:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
xr, yr = (self.find(x), self.find(y))
if xr == yr:
return
if self.rnk[xr] < self.rnk[yr]:
xr, yr = (yr, xr)
if self.rnk[xr] == self.rnk[yr]:
self.rnk[xr] += 1
self.par[yr] = xr
self.sz[xr] += self.sz[yr]
def size(self, x):
return self.sz[self.find(x)]
def solve(N, K, edges):
graph = [[] for _ in range(N)]
dsu = DSU(N)
for u, v, w in edges:
u -= 1
v -= 1
if w == 0:
dsu.union(u, v)
ans = pow(N, K, MOD)
for x in range(N):
if dsu.find(x) == x:
ans -= pow(dsu.size(x), K, MOD)
ans %= MOD
return ans
for tc in range(1):
N, K = rrm()
edges = [rrm() for _ in range(N - 1)]
print(solve(N, K, edges))
142
MAX_SPEED = 300
n = int(input())
actions = [list(map(int, input().split())) for _ in range(n)]
speed = [0 for i in range(n)]
for i in range(n):
if actions[i][0] == 1:
lastSpeed = actions[i][1]
speed[i] = lastSpeed
ignored = 0
overtook = False
maxSpeed = -1
for i in range(n - 1 - 1, -1, -1):
maxSpeed = max(maxSpeed, speed[i])
if actions[i][0] == 1:
pass
elif actions[i][0] == 2:
overtook = True
elif actions[i][0] == 3:
if maxSpeed > actions[i][1]:
ignored += 1
else:
maxSpeed = speed[i - 1]
elif actions[i][0] == 4:
overtook = False
elif actions[i][0] == 5:
maxSpeed = speed[i - 1]
elif actions[i][0] == 6:
if overtook:
ignored += 1
print(ignored)
143
K = 998244353
def mu(a, n):
if n == 0:
return 1
q = mu(a, n // 2)
if n % 2 == 0:
return q * q % K
return q * q % K * a % K
MAXN = 200005
dd = [0 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [-4 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]
def add(u, v):
i = u
while i <= 200000:
fen[i] += v
i += i & -i
def get(u):
res = 0
i = u
while i > 0:
res += fen[i]
i -= i & -i
return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
p[i] = int(data[i - 1])
if p[i] > 0:
dd[p[i]] = 1
else:
cnt += 1
for i in range(1, n + 1):
if dd[i] == 0:
s[i] = s[i - 1] + 1
else:
s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
if p[i] == -1:
cnt1 += 1
else:
u = cnt - cnt1
P = (P + u * s[p[i]] % K * den % K) % K
P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
if p[i] > 0:
m += 1
a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
P1 = (P1 + get(a[i])) % K
add(a[i], 1)
P = (P + P1) % K
print(P)
144
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
d = list(map(int, input().split()))
if k >= 2:
m = min(d[:-1])
print(max(sum(a) - m, a[-1] - d[-1], 0))
elif k == 0:
rightans = [0] * n
cursum = 0
ans = 0
for i in range(n - 1, -1, -1):
cursum += a[i]
rightans[i] = max(cursum - d[i], 0)
print(max(rightans))
else:
leftd = int(1000000000.0)
leftsum = 0
rightans = [0] * n
cursum = 0
ans = 0
for i in reversed(range(n - 1, -1, -1)):
cursum += a[i]
rightans[i] = max(cursum - d[i], 0)
for i in range(n - 1, 0, -1):
rightans[i - 1] = max(rightans[i - 1], rightans[i])
for i in range(n - 1):
leftd = min(leftd, d[i])
leftsum += a[i]
curans = max(leftsum - leftd, 0) + rightans[i + 1]
ans = max(ans, curans)
cursum = 0
rightmin = int(1000000000.0)
for i in range(n - 1, -1, -1):
cursum += a[i]
ans = max(ans, cursum - rightmin - d[i])
rightmin = min(rightmin, a[i])
print(ans)
145
def merge(a, b):
inda = 0
indb = 0
lena = len(a)
lenb = len(b)
d = [a[-1] + b[-1] + 1000]
a += d
b += d
c = []
inversions = 0
for i in range(lena + lenb - 1):
if a[inda] < b[indb]:
c.append(a[inda])
inda += 1
else:
c.append(b[indb])
indb += 1
inversions += lena - inda
return (c, inversions)
def mergesort(a):
if len(a) <= 1:
return (a, 0)
split = len(a) // 2
b = a[:split]
c = a[split:]
d = mergesort(b)
e = mergesort(c)
f = merge(d[0], e[0])
return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
if guy != -1:
b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
if guy != -1:
used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
if a[i] == -1:
negsseen += 1
else:
mix += unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix * 2
denom = 2 * negs
if negs == 0:
print(invs % 998244353)
else:
for i in range(denom):
if (998244353 * i + 1) % denom == 0:
inv = (998244353 * i + 1) // denom
break
print(num * inv % 998244353)
146
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)
147
n = int(input())
ps = None
seen_sl = [float('inf')]
seen_ot = [True]
answer = 0
for i in range(n):
line = list(map(int, input().split()))
t = line[0]
if t == 1:
ps = line[1]
while ps > seen_sl[-1]:
answer += 1
seen_sl.pop(-1)
elif t == 2:
while not seen_ot[-1]:
answer += 1
seen_ot.pop(-1)
elif t == 3:
seen_sl.append(line[1])
while ps > seen_sl[-1]:
answer += -1
seen_sl.pop(-1)
elif t == 4:
seen_ot.append(True)
elif t == 5:
seen_sl.append(float('inf'))
elif t == 6:
seen_ot.append(False)
print(answer)
148
import sys
n, k = list(map(int, input().split(' ')))
activate = list(map(int, input().split(' ')))
deactivate = list(map(int, input().split(' ')))
presum = [0 for _ in range(n + 2)]
for i in range(1, n + 1):
presum[i] = presum[i - 1] + activate[i - 1]
ret = 0
if k == 0:
for i in range(1, n + 1 - 1):
ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1])
elif k == 1:
for i in range(1, n):
ret = max(ret, presum[n - 1] - deactivate[i - 1])
if deactivate[n - 1] < activate[n - 1]:
ret += activate[n - 1] - deactivate[n - 1]
deac = sorted(deactivate[1:n - 1])
ac = sorted(activate[1:n - 1])
ret = max(ret, presum[n] - deactivate[0] - ac[0])
ret = max(ret, presum[n] - deactivate[0] - deac[0])
ret = max(ret, presum[n] - sorted(deactivate[0:n - 1])[0] - sorted(deactivate[0:n - 1])[1])
for i in range(2, n + 1):
ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1])
else:
for i in range(1, n):
ret = max(ret, presum[n] - deactivate[i - 1])
ret = max(ret, activate[n - 1] - deactivate[n - 1])
print(ret)
149
import collections
import bisect
def f():
n, m = [int(c) for c in input().split()]
s = list(input())
ll = []
start = 0
length = 0
inside = False
cc = 0
for i in range(len(s)):
if s[i] == '.':
if not inside:
inside = True
length += 1
elif inside:
cc += length - 1
length = 0
inside = False
if inside:
cc += length - 1
res = [0] * m
for i in range(m):
line = input().split()
j = int(line[0]) - 1
c = line[1]
if c == '.' and s[j] == '.' or (c != '.' and s[j - 1] != '.'):
res[i] = cc
else:
e1 = False
e2 = False
if j > 0 and s[j - 1] == '.':
e1 = True
if j < n - 1 and s[j + 1] == '.':
e2 = True
if e1 and e2:
cc += 2 if c == '.' else -2
elif e1 or e2:
cc += 1 if c == '.' else -1
s[j] = c
res[i] = cc
for r in res:
print(r)
f()
150
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)
151
n = int(input())
ps = None
seen_sl = [float('inf')]
seen_ot = [True]
answer = 0
for i in range(n):
line = list(map(int, input().split()))
t = line[0]
if t == 1:
ps = line[1]
while ps > seen_sl[-1]:
answer += 1
seen_sl.pop(-1)
elif t == 2:
while not seen_ot[-1]:
answer += -1
seen_ot.pop(-1)
elif t == 3:
seen_sl.append(line[1])
while ps > seen_sl[-1]:
answer += 1
seen_sl.pop(-1)
elif t == 4:
seen_ot.append(True)
elif t == 5:
seen_sl.append(float('inf'))
elif t == 6:
seen_ot.append(False)
print(answer)
152
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])
def happy_diff(m):
return m.a_happy - m.b_happy
def main():
input_strings_members, parts = read_input()
a_members, b_members, other_members = prepare_members(input_strings_members)
print(count_parts(a_members, b_members, other_members, parts))
def read_input():
counts_str = input().split()
members_count, parts = list(map(int, counts_str))
return ([input() for _ in range(members_count)], parts)
def prepare_members(input_strings_members):
a_members = []
b_members = []
other_members = []
for line in input_strings_members:
m = Member(*list(map(int, line.split())))
if happy_diff(m) > 0:
a_members.append(m)
elif happy_diff(m) < 0:
b_members.append(m)
else:
other_members.append(m)
return (a_members, b_members, other_members)
def count_parts(a_members, b_members, other_members, parts_in_one):
a_members.sort(key=lambda m: happy_diff(m), reverse=False)
a_modulo = sum((m.parts for m in a_members)) % parts_in_one
a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
b_members.sort(key=lambda m: happy_diff(m), reverse=True)
b_modulo = sum((m.parts for m in b_members)) % parts_in_one
b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
return a_happy + b_happy + last_happy
def split_members_into_happy_groups(members, modulo):
modulo_members = []
happy_members = []
current_modulo = 0
for i in range(len(members)):
m = members[i]
new_current_modulo = current_modulo + m.parts
if not new_current_modulo < modulo:
modulo_members.append(m)
current_modulo = new_current_modulo
continue
modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
if new_current_modulo > modulo:
happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
if i + 1 < len(members):
happy_members.extend(members[i + 1:])
break
return (modulo_members, happy_members)
def count_last_pizzas_happy(a, b, other, parts_in_one):
last_sorted_members = a + other + b
if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))
def test1():
a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
assert count_parts(a, b, c, 10) == 314
def test2():
a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
assert count_parts(a, b, c, 12) == 84
def test3():
a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
assert count_parts(a, b, c, 3) == 16
def test4():
a, b, c = prepare_members(['2 1 4', '2 3 1'])
assert count_parts(a, b, c, 3) == 14
def test5():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2
def test6():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 5) == 16 + 16 + 3
def test_without_last_pizzas():
a, b, c = prepare_members(['3 3 1', '3 5 6'])
assert count_parts(a, b, c, 3) == 27
def test_with_one_last_pizza():
a, b, c = prepare_members(['2 3 1', '1 5 6'])
assert count_parts(a, b, c, 3) == 11
def test_with_two_last_pizzas():
a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
assert count_parts(a, b, c, 3) == 15
def test_without_different_happies():
a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
assert count_parts(a, b, c, 3) == 38
def __starting_point():
main()
__starting_point()
153
def Task485D():
cur_speed = 0
is_outstrip = 0
err_count = 0
event_speed_limit = []
event_count = int(input())
for a in range(event_count):
ev = list(map(int, input().split()))
if ev[0] == 1:
cur_speed = ev[1]
while len(event_speed_limit) > 0:
if cur_speed > event_speed_limit[len(event_speed_limit) - 1]:
event_speed_limit.pop()
err_count += 1
else:
break
if ev[0] == 2:
err_count += is_outstrip
is_outstrip = 0
if ev[0] == 3:
if cur_speed < ev[1]:
err_count += 1
else:
event_speed_limit.append(ev[1])
if ev[0] == 4:
is_outstrip = 0
if ev[0] == 5:
event_speed_limit.clear()
if ev[0] == 6:
is_outstrip += 1
print(err_count)
def __starting_point():
Task485D()
__starting_point()
154
import sys
n, k = list(map(int, input().split(' ')))
activate = list(map(int, input().split(' ')))
deactivate = list(map(int, input().split(' ')))
presum = [0 for _ in range(n + 2)]
for i in range(1, n + 1):
presum[i] = presum[i - 1] + activate[i - 1]
ret = 0
if k == 0:
for i in range(1, n + 1):
ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1])
elif k == 1:
for i in range(1, n):
ret = max(ret, presum[n - 1] - deactivate[i - 1])
if deactivate[n - 1] < activate[n - 1]:
ret += activate[n - 1] - deactivate[n - 1]
deac = sorted(deactivate[1 - 1:n - 1])
ac = sorted(activate[1:n - 1])
ret = max(ret, presum[n] - deactivate[0] - ac[0])
ret = max(ret, presum[n] - deactivate[0] - deac[0])
ret = max(ret, presum[n] - sorted(deactivate[0:n - 1])[0] - sorted(deactivate[0:n - 1])[1])
for i in range(2, n + 1):
ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1])
else:
for i in range(1, n):
ret = max(ret, presum[n] - deactivate[i - 1])
ret = max(ret, activate[n - 1] - deactivate[n - 1])
print(ret)
155
n, m = list(map(int, input().split(' ')))
aa = list(map(int, input().split(' ')))
def countMoreLess(vs, value):
cur = 0
res = {cur: 1}
for v in vs:
cur += 1 if v > value else -1
res[cur] = res.get(cur, 0) + 1
return res
pos = aa.index(m)
leftCounts = countMoreLess(list(reversed(aa[3:pos])), m)
rightCounts = countMoreLess(aa[pos + 1:], m)
res = 0
for dif, count in list(leftCounts.items()):
res += count * rightCounts.get(-dif, 0)
res += count * rightCounts.get(-dif + 1, 0)
print(res)
156
base = 998244353
def power(x, y):
if y == 0:
return 1
t = power(x, y // 2)
t = t * t % base
if y % 2:
t = t * x % base
return t
def inverse(x):
return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
ft.append(0)
def get(i):
res = 0
while i <= 200000:
res += ft[i]
i += i & -i
return res
def update(i, x):
while i:
ft[i] += x
i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
non.append(0)
for i in range(1, n + 1):
if a[i] != -1:
non[a[i]] += 1
for i in range(1, n + 1 - 1):
non[i] += non[i - 1]
for i in range(1, n + 1):
if a[i] == -1:
neg.append(neg[i - 1] + 1)
else:
neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
if a[i] != -1:
ans += get(a[i])
update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1):
fs = fm
fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1):
if a[i] != -1:
less = a[i] - non[a[i]]
more = m - less
ans = (ans + neg[i] * more * fs) % base
ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
157
MAX_SPEED = 300
n = int(input())
actions = [list(map(int, input().split())) for _ in range(n)]
speed = [0 for i in range(n)]
for i in range(n):
if actions[i][0] == 1:
lastSpeed = actions[i][1]
speed[i] = lastSpeed
ignored = 0
overtook = False
maxSpeed = -1
for i in range(n - 1, -1, -1):
maxSpeed = max(maxSpeed, speed[i])
if actions[i][0] == 1:
pass
elif actions[i][0] == 5:
overtook = True
elif actions[i][0] == 3:
if maxSpeed > actions[i][1]:
ignored += 1
else:
maxSpeed = speed[i - 1]
elif actions[i][0] == 4:
overtook = False
elif actions[i][0] == 5:
maxSpeed = speed[i - 1]
elif actions[i][0] == 6:
if overtook:
ignored += 1
print(ignored)
158
import heapq
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
s = sum(a)
pre = [0]
j = 0
while j < n:
pre.append(a[j] + pre[-1])
j += 1
ab = []
af = []
af1 = []
j = n - 1
while j >= 0:
heapq.heappush(af, -(s - pre[j] - b[j]))
af1.append(-af[0])
j += -1
af1.reverse()
if k == 0:
j = 0
ans = 0
while j < n:
ans = max(ans, s - pre[j] - b[j])
j += 1
print(ans)
elif k == 1:
j = 0
m = float('inf')
ans = 2
while j < n - 1:
m = min(m, b[j])
if j < n - 2:
ans = max(ans, max(0, pre[j + 1] - m) + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1], s - b[0] - a[j + 1])
else:
ans = max(ans, pre[j + 1] - m + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1])
j += 1
j = 0
while j < n - 1:
ans = max(ans, s - a[-1] - b[j] + max(0, a[-1] - b[-1]))
j += 1
print(ans)
else:
j = 0
ans = 0
while j < n - 1:
ans = max(ans, s - b[j])
j += 1
ans = max(ans, a[-1] - b[-1])
print(ans)
159
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)
160
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])
def happy_diff(m):
return m.a_happy - m.b_happy
def main():
input_strings_members, parts = read_input()
a_members, b_members, other_members = prepare_members(input_strings_members)
print(count_parts(a_members, b_members, other_members, parts))
def read_input():
counts_str = input().split()
members_count, parts = list(map(int, counts_str))
return ([input() for _ in range(members_count)], parts)
def prepare_members(input_strings_members):
a_members = []
b_members = []
other_members = []
for line in input_strings_members:
m = Member(*list(map(int, line.split())))
if happy_diff(m) > 0:
a_members.append(m)
elif happy_diff(m) < 0:
b_members.append(m)
else:
other_members.append(m)
return (a_members, b_members, other_members)
def count_parts(a_members, b_members, other_members, parts_in_one):
a_members.sort(key=lambda m: happy_diff(m), reverse=False)
a_modulo = sum((m.parts for m in a_members)) % parts_in_one
a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
b_members.sort(key=lambda m: happy_diff(m), reverse=True)
b_modulo = sum((m.parts for m in b_members)) % parts_in_one
b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
return a_happy + b_happy + last_happy
def split_members_into_happy_groups(members, modulo):
modulo_members = []
happy_members = []
current_modulo = 0
for i in range(len(members)):
m = members[i]
new_current_modulo = current_modulo + m.parts
if new_current_modulo < modulo:
modulo_members.append(m)
current_modulo = new_current_modulo
continue
modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
if new_current_modulo > modulo:
happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
if not i + 1 < len(members):
happy_members.extend(members[i + 1:])
break
return (modulo_members, happy_members)
def count_last_pizzas_happy(a, b, other, parts_in_one):
last_sorted_members = a + other + b
if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))
def test1():
a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
assert count_parts(a, b, c, 10) == 314
def test2():
a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
assert count_parts(a, b, c, 12) == 84
def test3():
a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
assert count_parts(a, b, c, 3) == 16
def test4():
a, b, c = prepare_members(['2 1 4', '2 3 1'])
assert count_parts(a, b, c, 3) == 14
def test5():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2
def test6():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 5) == 16 + 16 + 3
def test_without_last_pizzas():
a, b, c = prepare_members(['3 3 1', '3 5 6'])
assert count_parts(a, b, c, 3) == 27
def test_with_one_last_pizza():
a, b, c = prepare_members(['2 3 1', '1 5 6'])
assert count_parts(a, b, c, 3) == 11
def test_with_two_last_pizzas():
a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
assert count_parts(a, b, c, 3) == 15
def test_without_different_happies():
a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
assert count_parts(a, b, c, 3) == 38
def __starting_point():
main()
__starting_point()
161
import sys
input = sys.stdin.readline
n, k = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(n - 1)]
mod = 10 ** 9 + 7
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))
for x, y, c in EDGE:
if c == 0:
Union(x, y)
G = [find(i) for i in range(1, n + 1)]
from collections import Counter
counter = Counter(G)
ANS = 0
for j in list(counter.values()):
ANS = ANS + pow(j, k, mod) & mod
print((pow(n, k, mod) - ANS) % mod)
162
import heapq
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
s = sum(a)
pre = [0]
j = 0
while j < n:
pre.append(a[j] + pre[-1])
j += 1
ab = []
af = []
af1 = []
j = n - 1
while j >= 0:
heapq.heappush(af, -(s - pre[j] - b[j]))
af1.append(-af[0])
j += -1
af1.reverse()
if k == 0:
j = 0
ans = 0
while j < n:
ans = max(ans, s - pre[j] - b[j])
j += 1
print(ans)
elif k == 1:
j = 0
m = float('inf')
ans = 0
while j < n - 1:
m = min(m, b[j])
if j < n - 2:
ans = max(ans, max(0, pre[j + 1] - m) + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1], s - b[0] - a[j + 1])
else:
ans = max(ans, pre[j + 1] - m + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1])
j += 1
j = 0
while j < n - 1:
ans = max(ans, s - a[-1] - b[j] + max(0, a[-1] - b[-1]))
j += 1
print(ans)
else:
j = 0
ans = 2
while j < n - 1:
ans = max(ans, s - b[j])
j += 1
ans = max(ans, a[-1] - b[-1])
print(ans)
163
import sys
sys.setrecursionlimit(536870912)
def dfs(i, j, vis, g, c):
vis[i][j] = 1
c.append((i, j))
'\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t'
if i > 0 and vis[i - 1][j] == 4 and (g[i - 1][j] == '0'):
dfs(i - 1, j, vis, g, c)
if i < n - 1 and vis[i + 1][j] == 0 and (g[i + 1][j] == '0'):
dfs(i + 1, j, vis, g, c)
if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'):
dfs(i, j + 1, vis, g, c)
if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'):
dfs(i, j - 1, vis, g, c)
n = int(input())
r1, c1 = map(int, input().split())
r1 -= 1
c1 -= 1
r2, c2 = map(int, input().split())
r2 -= 1
c2 -= 1
g = []
for i in range(n):
g.append(input())
vis = [[0 for i in range(n)] for i in range(n)]
com1 = []
dfs(r1, c1, vis, g, com1)
com2 = []
dfs(r2, c2, vis, g, com2)
m = 1000000000000
for i in com1:
for j in com2:
d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2
m = min(m, d)
print(m)
164
n = int(input())
ps = None
seen_sl = [float('inf')]
seen_ot = [True]
answer = 0
for i in range(n):
line = list(map(int, input().split()))
t = line[0]
if t == 1:
ps = line[1]
while ps > seen_sl[-1]:
answer += 1
seen_sl.pop(-1)
elif t == -2:
while not seen_ot[-1]:
answer += 1
seen_ot.pop(-1)
elif t == 3:
seen_sl.append(line[1])
while ps > seen_sl[-1]:
answer += 1
seen_sl.pop(-1)
elif t == 4:
seen_ot.append(True)
elif t == 5:
seen_sl.append(float('inf'))
elif t == 6:
seen_ot.append(False)
print(answer)
165
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))
166
n = int(input())
r1, c1 = map(int, input().split())
r2, c2 = map(int, input().split())
a = [['1'] * (n + 2)]
for _ in range(n):
s = input()
d = ['1']
for i in s:
d.append(i)
d.append('1')
a.append(d)
a.append(['1'] * (n + 2))
s = []
f = []
q = [[r1, c1]]
while q:
x, y = q.pop()
a[x][y] = '1'
s.append([x, y])
if a[x - 1][y] == '0':
q.append([x - 1, y])
if a[x][y - 1] == '0':
q.append([x, y - 1])
if a[x + 1][y] == '0':
q.append([x + 1, y])
if a[x][y + 1] == '0':
q.append([x, y + 1])
if [r2, c2] in s:
print(0)
else:
q = [[r2, c2]]
while q:
x, y = q.pop()
a[x][y] = '1'
f.append([x, y])
if a[x - 1][y] == '0':
q.append([x - 1, y])
if a[x][y - 1 - 1] == '0':
q.append([x, y - 1])
if a[x + 1][y] == '0':
q.append([x + 1, y])
if a[x][y + 1] == '0':
q.append([x, y + 1])
res = 10 ** 10
for i in s:
for j in f:
res = min(res, (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2)
print(res)
167
from collections import deque
def BFS(a, vertex=None):
if vertex is None:
vertex = 1
s = [1] * len(a)
d = deque([vertex])
s[vertex] = 0
f = {vertex}
while len(d) > 0:
for q in a[d.popleft()]:
if s[q]:
d.append(q)
f.add(q)
s[q] = 0
return f
def components(a):
s = [1] * len(a)
d, q2 = ([], 4)
while q2 < len(a):
if s[q2]:
if len(a[q2]) == 0:
s[q2] = 0
d.append({q2})
else:
f = BFS(a, q2)
d.append(f)
for q in f:
s[q] = 0
else:
q2 += 1
return d
n = int(input())
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)]
d = [[] for _ in range(n ** 2 + 1)]
for q in range(1, n + 1):
for q1 in range(1, n + 1):
if a[q][q1]:
if a[q - 1][q1]:
d[(q - 1) * n + q1].append((q - 2) * n + q1)
if a[q + 1][q1]:
d[(q - 1) * n + q1].append(q * n + q1)
if a[q][q1 - 1]:
d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1)
if a[q][q1 + 1]:
d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1)
x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2)
s = components(d)
comp_x, comp_y = ([], [])
for q in s:
if x in q:
comp_x = q
if y in q:
comp_y = q
if comp_y == comp_x:
print(0)
else:
ans = float('inf')
for q in comp_x:
for q1 in comp_y:
x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1)
ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans)
print(ans)
168
def solve(ls):
ls.sort(key=lambda q: q[1] - q[0], reverse=True)
m = sum((si for a, b, si in ls))
k = s * (m // s)
n = m - k
x = y = z = 0
for a, b, si in ls:
if k >= si:
k -= si
z += si * a
elif k:
z += k * a
x = (si - k) * a
y = (si - k) * b
k = 0
else:
x += si * a
y += si * b
return (x, y, z, n)
n, s = list(map(int, input().split()))
first = []
second = []
for i in range(n):
si, ai, bi = list(map(int, input().split()))
if ai > bi:
first.append((ai, bi, si))
else:
second.append((bi, ai, si))
x1, y1, z1, n1 = solve(first)
x2, y2, z2, n2 = solve(second)
d = x1 + x2 if n1 + n2 > s else max(x1 + y2, x2 + y1)
print(z1 + z2 + d)
169
T = input().split(' ')
n = int(T[0])
m = int(T[1])
S = input().split(' ')
for i in range(n):
S[i] = int(S[i])
ind = 0
for k in range(n):
if S[k] == m:
ind = k
k = ind
P = [0] * (n + 1)
N = [4] * (n + 1)
R = [0] * (n - k)
L = [0] * (k + 1)
for i in range(k):
if S[k - 1 - i] < m:
L[k - 1 - i] = L[k - i] - 1
else:
L[k - 1 - i] = L[k - i] + 1
for i in range(n - k - 1):
if S[k + 1 + i] > m:
R[1 + i] = R[i] + 1
else:
R[1 + i] = R[i] - 1
c = 0
for el in R:
if el >= 0:
P[el] += 1
if el == 0:
N[el] += 1
else:
N[-el] += 1
for el in L:
if el >= 1:
c = c + N[el] + N[el - 1]
else:
c = c + P[-el] + P[-el + 1]
print(c)
170
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)
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
MAX_SPEED = 300
n = int(input())
actions = [list(map(int, input().split())) for _ in range(n)]
speed = [0 for i in range(n)]
for i in range(n):
if actions[i][0] == 1:
lastSpeed = actions[i][1]
speed[i] = lastSpeed
ignored = 0
overtook = False
maxSpeed = -1
for i in range(n - 1, --1, -1):
maxSpeed = max(maxSpeed, speed[i])
if actions[i][0] == 1:
pass
elif actions[i][0] == 2:
overtook = True
elif actions[i][0] == 3:
if maxSpeed > actions[i][1]:
ignored += 1
else:
maxSpeed = speed[i - 1]
elif actions[i][0] == 4:
overtook = False
elif actions[i][0] == 5:
maxSpeed = speed[i - 1]
elif actions[i][0] == 6:
if overtook:
ignored += 1
print(ignored)
173
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)
174
from collections import deque
def BFS(a, vertex=None):
if vertex is None:
vertex = 1
s = [1] * len(a)
d = deque([vertex])
s[vertex] = 0
f = {vertex}
while len(d) > 0:
for q in a[d.popleft()]:
if s[q]:
d.append(q)
f.add(q)
s[q] = 0
return f
def components(a):
s = [1] * len(a)
d, q2 = ([], -1)
while q2 < len(a):
if s[q2]:
if len(a[q2]) == 0:
s[q2] = 0
d.append({q2})
else:
f = BFS(a, q2)
d.append(f)
for q in f:
s[q] = 0
else:
q2 += 1
return d
n = int(input())
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)]
d = [[] for _ in range(n ** 2 + 1)]
for q in range(1, n + 1):
for q1 in range(1, n + 1):
if a[q][q1]:
if a[q - 1][q1]:
d[(q - 1) * n + q1].append((q - 2) * n + q1)
if a[q + 1][q1]:
d[(q - 1) * n + q1].append(q * n + q1)
if a[q][q1 - 1]:
d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1)
if a[q][q1 + 1]:
d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1)
x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2)
s = components(d)
comp_x, comp_y = ([], [])
for q in s:
if x in q:
comp_x = q
if y in q:
comp_y = q
if comp_y == comp_x:
print(0)
else:
ans = float('inf')
for q in comp_x:
for q1 in comp_y:
x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1)
ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans)
print(ans)
175
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x - 1 - 1] = nc
print(res)
176
def Task485D():
cur_speed = 0
is_outstrip = 0
err_count = 0
event_speed_limit = []
event_count = int(input())
for a in range(event_count):
ev = list(map(int, input().split()))
if ev[0] == 1:
cur_speed = ev[1]
while len(event_speed_limit) > 0:
if cur_speed > event_speed_limit[len(event_speed_limit) - 1]:
event_speed_limit.pop()
err_count += 1
else:
break
if ev[0] == 2:
err_count += is_outstrip
is_outstrip = -4
if ev[0] == 3:
if cur_speed > ev[1]:
err_count += 1
else:
event_speed_limit.append(ev[1])
if ev[0] == 4:
is_outstrip = 0
if ev[0] == 5:
event_speed_limit.clear()
if ev[0] == 6:
is_outstrip += 1
print(err_count)
def __starting_point():
Task485D()
__starting_point()
177
from sys import stdin
from collections import deque
n, S = [int(x) for x in stdin.readline().split()]
ppl = []
base = 0
tSlices = 0
for dude in range(n):
s, a, b = [int(x) for x in stdin.readline().split()]
base += s * a
tSlices += s
ppl.append([b - a, s])
if tSlices % S != 0:
ppl.append([0, S - tSlices % S])
ppl.sort(reverse=True)
totalS = 0
totalH = 0
for h, s in ppl:
if totalS + s < S:
totalS += s
totalH += h * s
else:
s -= S - totalS
totalH += h * (S - totalS)
if totalH > 0:
base += totalH
else:
break
totalS = 0
totalH = 0
if h > 2:
base += h * (s // S * S)
totalS = s % S
totalH = h * (s % S)
else:
break
print(base)
178
import math
from collections import Counter, defaultdict
from itertools import accumulate
R = lambda: map(int, input().split())
n = int(input())
spl = [math.inf]
ot_forbid = 0
sp = 0
res = 0
for i in range(n):
arr = list(R())
tp = arr[0]
if tp == 1:
sp = arr[1]
while sp > spl[-1]:
spl.pop()
res += 1
elif tp == 2:
if ot_forbid > 0:
res += ot_forbid
ot_forbid = 0
elif tp == -1:
if arr[1] >= sp:
spl.append(arr[1])
else:
res += 1
elif tp == 4:
ot_forbid = 0
elif tp == 5:
spl = [math.inf]
else:
ot_forbid += 1
print(res)
179
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)
180
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)
181
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__()
182
from collections import deque
def BFS(a, vertex=None):
if vertex is None:
vertex = 1
s = [1] * len(a)
d = deque([vertex])
s[vertex] = 0
f = {vertex}
while len(d) > 0:
for q in a[d.popleft()]:
if s[q]:
d.append(q)
f.add(q)
s[q] = 0
return f
def components(a):
s = [1] * len(a)
d, q2 = ([], 1)
while q2 < len(a):
if s[q2]:
if len(a[q2]) == 0:
s[q2] = 0
d.append({q2})
else:
f = BFS(a, q2)
d.append(f)
for q in f:
s[q] = 0
else:
q2 += 1
return d
n = int(input())
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)]
d = [[] for _ in range(n ** 2 + 1)]
for q in range(1, n + 1):
for q1 in range(1, n + 1):
if a[q][q1]:
if a[q - 1][q1]:
d[(q - 1) * n + q1].append((q - 2) * n + q1)
if a[q + 1][q1]:
d[(q - 1) * n + q1].append(q * n + q1)
if a[q][q1 - 1]:
d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1)
if a[q][q1 + 1]:
d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1)
x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2)
s = components(d)
comp_x, comp_y = ([], [])
for q in s:
if x in q:
comp_x = q
if y in q:
comp_y = q
if comp_y == comp_x:
print(0)
else:
ans = float('inf')
for q in comp_x:
for q1 in comp_y:
x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1)
ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans)
print(ans)
183
from sys import stdin
from collections import deque
n, S = [int(x) for x in stdin.readline().split()]
ppl = []
base = 0
tSlices = 0
for dude in range(n):
s, a, b = [int(x) for x in stdin.readline().split()]
base += s * a
tSlices += s
ppl.append([b - a, s])
if tSlices % S != 0:
ppl.append([0, S + tSlices % S])
ppl.sort(reverse=True)
totalS = 0
totalH = 0
for h, s in ppl:
if totalS + s < S:
totalS += s
totalH += h * s
else:
s -= S - totalS
totalH += h * (S - totalS)
if totalH > 0:
base += totalH
else:
break
totalS = 0
totalH = 0
if h > 0:
base += h * (s // S * S)
totalS = s % S
totalH = h * (s % S)
else:
break
print(base)
184
import sys
n, k = list(map(int, input().split(' ')))
activate = list(map(int, input().split(' ')))
deactivate = list(map(int, input().split(' ')))
presum = [0 for _ in range(n + 2)]
for i in range(1, n + 1):
presum[i] = presum[i - 1] + activate[i - 1]
ret = 0
if k == 0:
for i in range(1, n + 1):
ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1])
elif k == 1:
for i in range(1, n):
ret = max(ret, presum[n - 1] - deactivate[i - 1])
if deactivate[n - 1 - 1] < activate[n - 1]:
ret += activate[n - 1] - deactivate[n - 1]
deac = sorted(deactivate[1:n - 1])
ac = sorted(activate[1:n - 1])
ret = max(ret, presum[n] - deactivate[0] - ac[0])
ret = max(ret, presum[n] - deactivate[0] - deac[0])
ret = max(ret, presum[n] - sorted(deactivate[0:n - 1])[0] - sorted(deactivate[0:n - 1])[1])
for i in range(2, n + 1):
ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1])
else:
for i in range(1, n):
ret = max(ret, presum[n] - deactivate[i - 1])
ret = max(ret, activate[n - 1] - deactivate[n - 1])
print(ret)
185
import heapq
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
s = sum(a)
pre = [0]
j = 0
while j < n:
pre.append(a[j] + pre[-1])
j += 1
ab = []
af = []
af1 = []
j = n - 1
while j >= 0:
heapq.heappush(af, -(s - pre[j] - b[j]))
af1.append(-af[0])
j += -1
af1.reverse()
if k == 0:
j = 0
ans = 3
while j < n:
ans = max(ans, s - pre[j] - b[j])
j += 1
print(ans)
elif k == 1:
j = 0
m = float('inf')
ans = 0
while j < n - 1:
m = min(m, b[j])
if j < n - 2:
ans = max(ans, max(0, pre[j + 1] - m) + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1], s - b[0] - a[j + 1])
else:
ans = max(ans, pre[j + 1] - m + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1])
j += 1
j = 0
while j < n - 1:
ans = max(ans, s - a[-1] - b[j] + max(0, a[-1] - b[-1]))
j += 1
print(ans)
else:
j = 0
ans = 0
while j < n - 1:
ans = max(ans, s - b[j])
j += 1
ans = max(ans, a[-1] - b[-1])
print(ans)
186
def solve(ls):
ls.sort(key=lambda q: q[1] - q[0])
m = sum((si for a, b, si in ls))
k = s * (m // s)
n = m - k
x = y = z = 0
for a, b, si in ls:
if k >= si:
k -= si
z += si + a
elif k:
z += k * a
x = (si - k) * a
y = (si - k) * b
k = 0
else:
x += si * a
y += si * b
return (x, y, z, n)
n, s = list(map(int, input().split()))
first = []
second = []
for i in range(n):
si, ai, bi = list(map(int, input().split()))
if ai > bi:
first.append((ai, bi, si))
else:
second.append((bi, ai, si))
x1, y1, z1, n1 = solve(first)
x2, y2, z2, n2 = solve(second)
d = x1 + x2 if n1 + n2 > s else max(x1 + y2, x2 + y1)
print(z1 + z2 + d)
187
import sys
sys.setrecursionlimit(536870912)
def dfs(i, j, vis, g, c):
vis[i][j] = 1
c.append((i, j))
'\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t'
if i > 0 and vis[i - 1][j] == 0 and (g[i - 1][j] == '0'):
dfs(i - 1, j, vis, g, c)
if i < n - 1 and vis[i + 1][j] == 4 and (g[i + 1][j] == '0'):
dfs(i + 1, j, vis, g, c)
if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'):
dfs(i, j + 1, vis, g, c)
if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'):
dfs(i, j - 1, vis, g, c)
n = int(input())
r1, c1 = map(int, input().split())
r1 -= 1
c1 -= 1
r2, c2 = map(int, input().split())
r2 -= 1
c2 -= 1
g = []
for i in range(n):
g.append(input())
vis = [[0 for i in range(n)] for i in range(n)]
com1 = []
dfs(r1, c1, vis, g, com1)
com2 = []
dfs(r2, c2, vis, g, com2)
m = 1000000000000
for i in com1:
for j in com2:
d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2
m = min(m, d)
print(m)
188
T = input().split(' ')
n = int(T[0])
m = int(T[1])
S = input().split(' ')
for i in range(n):
S[i] = int(S[i])
ind = 0
for k in range(n):
if S[k] == m:
ind = k
k = ind
P = [0] * (n + 1)
N = [0] * (n + 1)
R = [0] * (n - k)
L = [0] * (k + 1)
for i in range(k):
if S[k - 1 - i] < m:
L[k - 1 - i] = L[k - i] - 1
else:
L[k - 1 - i] = L[k - i] + 1
for i in range(n - k - 1):
if S[k + 1 + i] > m:
R[1 + i] = R[i] + 1
else:
R[1 + i] = R[i] - 1
c = 0
for el in R:
if el >= 0:
P[el] += 1
if el == 0:
N[el] += 1
else:
N[-el] += 1
for el in L:
if el > 1:
c = c + N[el] + N[el - 1]
else:
c = c + P[-el] + P[-el + 1]
print(c)
189
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
if L[i] > 0:
D[L[i]] = i
J.append(L[i])
T[i + 1] = T[i]
else:
T[i + 1] = T[i] + 1
def I(J):
if len(J) <= 1:
return (J, 0)
else:
a = J[:len(J) // 2]
b = J[len(J) // 2:]
a, ai = I(a)
b, bi = I(b)
c = []
i = 0
j = 0
inversions = ai + bi
while i < len(a) and j < len(b):
if a[i] <= b[j]:
c.append(a[i])
i += 1
else:
c.append(b[j])
j += 1
inversions += len(a) - i
c += a[i:]
c += b[j:]
return (c, inversions)
for i in range(1, n + 1):
if not i in D:
S.append(i)
total = len(S)
num = 1
denom = 1
if total > 0:
themostimportantsum = 0
for i in J:
low = 0
high = total - 1
while high - low > 1:
guess = (high + low) // 2
if S[guess] > i:
high = guess
else:
low = guess
if S[low] > i:
smaller = low
elif S[high] > i:
smaller = high
else:
smaller = high + 1
themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
num = themostimportantsum + total
denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
if I(J)[1] == 0:
print(0)
else:
print(I(J)[1] % 998244353)
else:
num += denom * I(J)[1]
print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
190
import sys
input = sys.stdin.readline
n, k = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(n - 1)]
mod = 10 ** 9 + 9
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))
for x, y, c in EDGE:
if c == 0:
Union(x, y)
G = [find(i) for i in range(1, n + 1)]
from collections import Counter
counter = Counter(G)
ANS = 0
for j in list(counter.values()):
ANS = (ANS + pow(j, k, mod)) % mod
print((pow(n, k, mod) - ANS) % mod)
191
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)
192
import sys
sys.setrecursionlimit(536870912)
def dfs(i, j, vis, g, c):
vis[i][j] = 1
c.append((i, j))
'\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t'
if i > 0 and vis[i - 1][j] == 0 and (g[i - 1][j] == '0'):
dfs(i - 1, j, vis, g, c)
if i < n - 1 and vis[i + 1][j] == 0 and (g[i + 1][j] == '0'):
dfs(i + 1, j, vis, g, c)
if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'):
dfs(i, j + 1, vis, g, c)
if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'):
dfs(i, j - 1, vis, g, c)
n = int(input())
r1, c1 = map(int, input().split())
r1 -= 1
c1 -= 2
r2, c2 = map(int, input().split())
r2 -= 1
c2 -= 1
g = []
for i in range(n):
g.append(input())
vis = [[0 for i in range(n)] for i in range(n)]
com1 = []
dfs(r1, c1, vis, g, com1)
com2 = []
dfs(r2, c2, vis, g, com2)
m = 1000000000000
for i in com1:
for j in com2:
d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2
m = min(m, d)
print(m)
193
base = 998244353
def power(x, y):
if y == 0:
return 1
t = power(x, y // 2)
t = t * t % base
if y % 2:
t = t * x % base
return t
def inverse(x):
return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
ft.append(0)
def get(i):
res = 0
while i <= 200000:
res += ft[i]
i += i & -i
return res
def update(i, x):
while i:
ft[i] += x
i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
non.append(0)
for i in range(1, n + 1):
if a[i] != -1:
non[a[i]] += 1
for i in range(1, n + 1):
non[i] += non[i - 1]
for i in range(1, n + 1):
if a[i] == -1:
neg.append(neg[i - 1] + 1)
else:
neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
if a[i] != -1:
ans += get(a[i])
update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1 + 1):
fs = fm
fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1):
if a[i] != -1:
less = a[i] - non[a[i]]
more = m - less
ans = (ans + neg[i] * more * fs) % base
ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
194
from sys import stdin
from collections import deque
n, S = [int(x) for x in stdin.readline().split()]
ppl = []
base = 0
tSlices = 0
for dude in range(n):
s, a, b = [int(x) for x in stdin.readline().split()]
base += s * a
tSlices += s
ppl.append([b - a, s])
if tSlices % S != 0:
ppl.append([0, S - tSlices % S])
ppl.sort(reverse=True)
totalS = 0
totalH = 0
for h, s in ppl:
if totalS + s < S:
totalS += s
totalH += h * s
else:
s -= S - totalS
totalH += h * (S - totalS)
if totalH > 0:
base += totalH
else:
break
totalS = 0
totalH = 0
if h < 0:
base += h * (s // S * S)
totalS = s % S
totalH = h * (s % S)
else:
break
print(base)
195
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)
196
n, k = map(int, input().split())
a = list(map(int, input().split()))
d = list(map(int, input().split()))
if k == 0:
best = 0
curr = sum(a)
for i in range(n):
best = max(best, curr - d[i - 1])
curr -= a[i]
print(best)
elif k == 1:
best = sum(a[:-1]) - min(d[:-1])
other = sum(a)
other -= sorted(d)[0]
other -= sorted(d)[1]
curr = sum(a)
for i in range(n):
if i:
best = max(best, curr - d[i])
curr -= a[i]
o2 = sum(a) - min(a[1:]) - d[0]
print(max((best, other, 0, o2)))
else:
print(max((sum(a) - min(d[:-1]), 0, a[-1] - d[-1])))
197
L1 = list(map(int, input().split()))
numList = list(map(int, input().split()))
length = L1[0]
targetnumber = L1[1]
pos = numList.index(targetnumber)
pos_r = pos + 1
rem = -2
right = {0: 1}
left = {0: 1}
while pos_r <= length - 1:
if numList[pos_r] > targetnumber:
rem += 1
else:
rem -= 1
if rem not in right:
right[rem] = 1
else:
right[rem] += 1
pos_r += 1
pos_l = pos - 1
rem = 0
while pos_l >= 0:
if numList[pos_l] > targetnumber:
rem += 1
else:
rem -= 1
if rem not in left:
left[rem] = 1
else:
left[rem] += 1
pos_l -= 1
sum = 0
for number_l in left:
if number_l * -1 in right:
sum += left[number_l] * right[-1 * number_l]
if 1 - number_l in right:
sum += left[number_l] * right[1 - number_l]
print(sum)
198
def Task485D():
cur_speed = 0
is_outstrip = 0
err_count = 0
event_speed_limit = []
event_count = int(input())
for a in range(event_count):
ev = list(map(int, input().split()))
if ev[0] == 1:
cur_speed = ev[1]
while len(event_speed_limit) > 0:
if cur_speed > event_speed_limit[len(event_speed_limit) - 1]:
event_speed_limit.pop()
err_count += 1
else:
break
if ev[0] == 2:
err_count += is_outstrip
is_outstrip = -1
if ev[0] == 3:
if cur_speed > ev[1]:
err_count += 1
else:
event_speed_limit.append(ev[1])
if ev[0] == 4:
is_outstrip = 0
if ev[0] == 5:
event_speed_limit.clear()
if ev[0] == 6:
is_outstrip += 1
print(err_count)
def __starting_point():
Task485D()
__starting_point()
199
MAX_SPEED = 300
n = int(input())
actions = [list(map(int, input().split())) for _ in range(n)]
speed = [0 for i in range(n)]
for i in range(n):
if actions[i][0] == 1:
lastSpeed = actions[i][1]
speed[i] = lastSpeed
ignored = 0
overtook = False
maxSpeed = -1
for i in range(n - 1, -1, -1):
maxSpeed = max(maxSpeed, speed[i])
if actions[i][0] == 1:
pass
elif actions[i][0] == 3:
overtook = True
elif actions[i][0] == 3:
if maxSpeed > actions[i][1]:
ignored += 1
else:
maxSpeed = speed[i - 1]
elif actions[i][0] == 4:
overtook = False
elif actions[i][0] == 5:
maxSpeed = speed[i - 1]
elif actions[i][0] == 6:
if overtook:
ignored += 1
print(ignored)
200
base = 998244353
def power(x, y):
if y == 0:
return 1
t = power(x, y // 2)
t = t * t % base
if y % 2:
t = t * x % base
return t
def inverse(x):
return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
ft.append(0)
def get(i):
res = 0
while i <= 200000:
res += ft[i]
i += i & -i
return res
def update(i, x):
while i:
ft[i] += x
i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
non.append(0)
for i in range(1, n + 1):
if a[i] != -1:
non[a[i]] += 1
for i in range(1, n + 1):
non[i] += non[i - 1]
for i in range(1, n + 1):
if a[i] == -1:
neg.append(neg[i - 1] + 1)
else:
neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
if a[i] != -1:
ans += get(a[i])
update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1):
fs = fm
fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1):
if a[i] != -1:
less = a[i] - non[a[i]]
more = m - less
ans = (ans + neg[i] * more * fs) % base
ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
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.