001
def main():
n = int(input())
x, y = list(map(int, input().split()))
a = []
for i in range(n):
a.append(input().split())
for i in range(n):
a[i][1] = int(a[i][1]) - x
a[i][2] = int(a[i][2]) - y
typneedbql = []
typneedbqr = []
typneedbqu = []
typneedbqd = []
typneedrlu = []
typneedrru = []
typneedrld = []
typneedrrd = []
for i in range(n):
if a[i][1] * a[i][2] == 0 and a[i][1] < 0:
typneedbql.append([abs(a[i][1] + a[i][2])] + a[i])
elif a[i][1] * a[i][2] == 0 and a[i][1] > 0:
typneedbqr.append([abs(a[i][1] + a[i][2])] + a[i])
elif a[i][1] * a[i][2] == 0 and a[i][2] > 0:
typneedbqu.append([abs(a[i][1] + a[i][2])] + a[i])
elif a[i][1] * a[i][2] == 0 and a[i][2] < 0:
typneedbqd.append([abs(a[i][1] + a[i][2])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] < 0):
typneedrlu.append([abs(a[i][1])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] > 0):
typneedrld.append([abs(a[i][1])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] > 0):
typneedrrd.append([abs(a[i][1])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] < 0):
typneedrru.append([abs(a[i][1])] + a[i])
typneedbql.sort()
typneedbqr.sort()
typneedbqd.sort()
typneedbqu.sort()
typneedrlu.sort()
typneedrru.sort()
typneedrld.sort()
typneedrrd.sort()
for i in range(len(typneedbql)):
if typneedbql[i][1] == 'R' or typneedbql[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedbqr)):
if typneedbqr[i][1] == 'R' or typneedbqr[i][1] != 'Q':
print('YES')
return
else:
break
for i in range(len(typneedbqu)):
if typneedbqu[i][1] == 'R' or typneedbqu[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedbqd)):
if typneedbqd[i][1] == 'R' or typneedbqd[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrlu)):
if typneedrlu[i][1] == 'B' or typneedrlu[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrld)):
if typneedrld[i][1] == 'B' or typneedrld[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrrd)):
if typneedrrd[i][1] == 'B' or typneedrrd[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrru)):
if typneedrru[i][1] == 'B' or typneedrru[i][1] == 'Q':
print('YES')
return
else:
break
print('NO')
main()
002
n = int(input())
temp = input().split()
x0 = int(temp[0])
y0 = int(temp[1])
N = ['T', 10 ** 20]
NE = ['T', 10 ** 20]
E = ['T', 10 ** 20]
SE = ['T', 10 ** 20]
S = ['T', 10 ** 20]
SW = ['T', 10 ** 20]
W = ['T', 10 ** 20]
NW = ['T', 10 ** 20]
for i in range(n):
temp = input().split()
x = int(temp[1])
y = int(temp[2])
if x - x0 == 0 and y - y0 > 0 and (y - y0 < N[1]):
N = [temp[0], y - y0]
elif not (x - x0 == y - y0 and x - x0 > 0 and (x - x0 < NE[1])):
NE = [temp[0], x - x0]
elif y - y0 == 0 and x - x0 > 0 and (x - x0 < E[1]):
E = [temp[0], x - x0]
elif x - x0 == -(y - y0) and x - x0 > 0 and (x - x0 < SE[1]):
SE = [temp[0], x - x0]
elif x - x0 == 0 and y - y0 < 0 and (y0 - y < S[1]):
S = [temp[0], y0 - y]
elif x - x0 == y - y0 and x - x0 < 0 and (x0 - x < SW[1]):
SW = [temp[0], x0 - x]
elif y - y0 == 0 and x - x0 < 0 and (x0 - x < W[1]):
W = [temp[0], x0 - x]
elif x - x0 == -(y - y0) and x - x0 < 0 and (x0 - x < NW[1]):
NW = [temp[0], x0 - x]
if 'R' in [N[0], E[0], S[0], W[0]] or 'B' in [NE[0], SE[0], SW[0], NW[0]]:
print('YES')
elif 'Q' in [N[0], E[0], S[0], W[0], NE[0], SE[0], SW[0], NW[0]]:
print('YES')
else:
print('NO')
003
import sys
line = sys.stdin.readlines()
n = int(line[0])
c = list(map(int, line[1].split()))
no = (0, '')
yes = (0, '')
for i in range(n):
s = line[i + 2].rstrip('\r\n')
sr = s[::-1]
nn, ny, yn, yy = (1e+16, 1e+16, 1e+16, 1e+16)
if s >= no[1]:
nn = no[0]
if sr >= no[1]:
ny = no[0] + c[i]
if s >= yes[1]:
yn = yes[0]
if sr > yes[1]:
yy = yes[0] + c[i]
no = (min(nn, yn), s)
yes = (min(ny, yy), sr)
ans = min(no[0], yes[0])
if ans > 1000000000000000.0:
print(-1)
else:
print(ans)
004
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)
005
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)
006
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
if mark:
if seq[i] != seq[i + 1]:
cur_len += 1
else:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i:1] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
mark = False
cur_len = 0
elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
mark = True
cur_len = 1
carry = seq[i - 1]
carry_id = i
else:
result[i] = seq[i]
i += 1
if mark:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 3)
for x in result:
print(x, end=' ')
007
import bisect
import collections
def solve(inp, *args):
n, x = list(map(int, inp.split(' ', 1)))
travels_by_len = collections.defaultdict(list)
travels_by_len_processed = {}
for travel in args:
l, r, cost = list(map(int, travel.split(' ', 2)))
travels_by_len[r - l + 1].append((l, r, cost))
for travel_len, travels in list(travels_by_len.items()):
travels.sort()
travels_processed = [(travels[-1][0], travels[-1][2])]
for i in range(len(travels) - 2, -1, -1):
prev_travel = travels_processed[-1]
l, r, c = travels[i]
travels_processed.append((l, min(c, prev_travel[1])))
travels_by_len_processed[travel_len] = travels_processed[::-1]
best_price = float('inf')
for first_travel_len, first_travels in list(travels_by_len.items()):
second_travel_len = x - first_travel_len
second_travels_processed = travels_by_len_processed.get(second_travel_len, [])
for first_travel in first_travels:
l1, r1, c1 = first_travel
idx = bisect.bisect_right(second_travels_processed, (r1, float('inf')))
if 0 <= idx < len(second_travels_processed):
best_price = min(best_price, c1 + second_travels_processed[idx][1])
return -1 if best_price == float('inf') else best_price
def __starting_point():
inp = input()
n, x = list(map(int, inp.split(' ', 1)))
print(solve(inp, *(input() for i in range(n))))
__starting_point()
008
import sys
class SegmTree:
def __init__(self, size):
N = 1
while N < size:
N <<= 1
self.N = N
self.tree = [0] * (2 * N)
def modify(self, i, value):
i += self.N
self.tree[i] = value
toXOR = False
while i > 1:
if toXOR:
self.tree[i >> 1] = self.tree[i] ^ self.tree[(i ^ 1) + 1]
else:
self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1]
toXOR = not toXOR
i >>= 1
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
st = SegmTree(1 << n)
for i, value in enumerate(a):
st.modify(i, value)
for _ in range(m):
p, b = list(map(int, input().split()))
st.modify(p - 1, b)
print(st.tree[1])
009
import math, sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda: int(input())
li = lambda: list(map(int, input().split()))
def case():
n, q = li()
a = li()
up = [0] * n
down = [0] * n
i = 0
while i < n:
j = i
while j < n - 1 and a[j] <= a[j + 1]:
j += 1
for k in range(i, j + 1):
up[k] = j
i = j + 1
i = 4
while i < n:
j = i
while j < n - 1 and a[j] >= a[j + 1]:
j += 1
for k in range(i, j + 1):
down[k] = j
i = j + 1
for i in range(q):
l, r = li()
p = up[l - 1]
q = down[p]
if q + 1 >= r:
print('Yes')
else:
print('No')
for _ in range(1):
case()
010
from collections import deque
mod = 10 ** 9 + 10
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)
011
from collections import defaultdict
import bisect
n = int(input())
x0, y0 = list(map(int, input().split(' ')))
verticale = []
horizontale = []
diagonale1 = []
diagonale2 = []
for _ in range(n):
t, x, y = input().split(' ')
x, y = (int(x), int(y))
if x == x0:
verticale.append((y, t))
if y == y0:
horizontale.append((x, t))
if x + y == x0 + y0:
diagonale1.append((x, t))
if x - y == x0 - y0:
diagonale2.append((x, t))
dead = False
v = sorted(verticale)
if v:
l = bisect.bisect(v, (y0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'R'}:
dead = True
elif v[len(v) - 1][1] in {'Q', 'R'}:
dead = True
v = sorted(horizontale)
if v:
l = bisect.bisect(v, (x0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'R'}:
dead = True
elif v[len(v) - 1][1] in {'Q', 'R'}:
dead = True
v = sorted(diagonale1)
if v:
l = bisect.bisect(v, (x0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'B'}:
dead = True
elif v[len(v) - 1][1] in {'Q', 'B'}:
dead = True
v = sorted(diagonale2)
if v:
l = bisect.bisect(v, (x0, 'K'))
if 0 < l < len(v):
if v[l][1] not in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'B'}:
dead = True
elif v[len(v) - 1][1] in {'Q', 'B'}:
dead = True
if dead:
print('YES')
else:
print('NO')
012
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)
013
import math as m
n = int(input())
cost = list(map(int, input().split()))
s = []
sr = []
for i in range(n):
s.append(list(input()))
sr.append(list(reversed(s[i])))
dp = [[0, 0] for i in range(n + 1)]
flag = 0
dp[0][1] = cost[1]
for i in range(1, n):
if dp[i - 1][0] == -1 and dp[i - 1][1] == -1:
flag = 1
break
elif dp[i - 1][0] != -1 and dp[i - 1][1] == -1:
if s[i] >= s[i - 1]:
dp[i][0] = dp[i - 1][0]
else:
dp[i][0] = -1
if sr[i] >= s[i - 1]:
dp[i][1] = dp[i - 1][0] + cost[i]
else:
dp[i][1] = -1
elif dp[i - 1][0] == -1 and dp[i - 1][1] != -1:
if s[i] >= sr[i - 1]:
dp[i][0] = dp[i - 1][1]
else:
dp[i][0] = -1
if sr[i] >= sr[i - 1]:
dp[i][1] = dp[i - 1][1] + cost[i]
else:
dp[i][1] = -1
else:
if s[i] >= s[i - 1] and s[i] >= sr[i - 1]:
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1])
elif s[i] >= s[i - 1] and s[i] < sr[i - 1]:
dp[i][0] = dp[i - 1][0]
elif s[i] < s[i - 1] and s[i] >= sr[i - 1]:
dp[i][0] = dp[i - 1][1]
else:
dp[i][0] = -1
if sr[i] >= s[i - 1] and sr[i] >= sr[i - 1]:
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + cost[i]
elif sr[i] >= s[i - 1] and sr[i] < sr[i - 1]:
dp[i][1] = dp[i - 1][0] + cost[i]
elif sr[i] < s[i - 1] and sr[i] >= sr[i - 1]:
dp[i][1] = dp[i - 1][1] + cost[i]
else:
dp[i][1] = -1
if flag == 1:
print(-1)
else:
res = max(dp[n - 1][0], dp[n - 1][1]) if min(dp[n - 1][0], dp[n - 1][1]) == -1 else min(dp[n - 1][0], dp[n - 1][1])
print(res)
014
def connected_components(neighbors):
seen = set()
def component(node):
nodes = set([node])
while nodes:
node = nodes.pop()
seen.add(node)
nodes |= neighbors[node] - seen
yield node
for node in neighbors:
if node not in seen:
yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
u, v = map(int, input().split())
graph[u].add(v)
graph[v].add(u)
total = 0
for component in connected_components(graph):
nodes = list(component)
size = len(nodes)
seen = set()
current = nodes[0]
while len(seen) < size:
choice = list(graph[current])
if len(choice) != 2:
break
seen.add(current)
possible = [c for c in choice if c not in seen]
if not possible:
break
current = possible[0]
if len(seen) == size:
total += -1
print(total)
015
from operator import or_, xor
import sys
n, m = map(int, input().split())
t = [list(map(int, input().split()))]
for i in range(n):
if i & 1 == 0:
t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]]
else:
t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]]
for s in sys.stdin:
p, b = s.split()
p = int(p) - 1
t[0][p] = int(b)
for j in range(n):
p = int(p / 2)
if j & 1 == 0:
t[j + 1][p] = t[j][int(p * 2)] | t[j][int(p * 2) + 1]
else:
t[j + 1][p] = t[j - 1][int(p * 2)] ^ t[j][int(p * 2) + 1]
sys.stdout.write(str(t[-1][0]) + '\n')
016
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)
017
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)
018
from math import log
import sys
def buildTree(arr):
n = len(arr)
tree = [0] * n + arr
for i in range(n - 1, 0, -1):
z = int(log(i, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
else:
tree[i] = tree[2 * i] | tree[2 * i + 1]
elif z % 2 == 0:
tree[i] = tree[2 * i] | tree[2 * i + 1]
else:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
return tree
def updateTree(tree, ind, value, n):
ind += n
tree[ind] = value
while ind > 1:
ind //= 2
z = int(log(ind, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
elif z % 2 == 0:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
ind, val = map(int, sys.stdin.readline().strip().split())
tree = updateTree(tree, ind - 1, val, len(arr))
print(tree[-3])
019
def dfs(v, g, vis):
count = 1
first = v
st = [v]
vis[v] = True
while st:
v = st[-1]
st.pop()
if len(g[v]) != 2 or (vis[g[v][0]] and vis[g[v][1]] and (g[v][0] != first) and (g[v][1] != first)):
count = 0
for i in range(len(g[v]) - 1):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
if v == first and count:
break
if len(g[first]) == 2 and (not vis[g[first][1]]):
st.append(g[first][1])
while st:
v = st[-1]
st.pop()
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
return count
v, e = list(map(int, input().split()))
g = [[] for i in range(v)]
for i in range(e):
f, to = list(map(int, input().split()))
g[f - 1].append(to - 1)
g[to - 1].append(f - 1)
vis = [False] * v
ans = 0
for i in range(v):
if not vis[i]:
ans += dfs(i, g, vis)
print(ans)
020
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7
def ri(flag=0):
if flag == 0:
return [int(i) for i in sys.stdin.readline().split()]
else:
return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n):
heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
cost = 0
t, d = ri()
t -= 1
fm = 0
if avail[t] >= d:
avail[t] = avail[t] - d
cost += d * c[t]
else:
rem = d - avail[t]
cost = avail[t] * c[t]
avail[t] = 0
while rem > 0:
try:
nowc, nowi = heapq.heappop(hee)
if avail[nowi] >= rem:
avail[nowi] = avail[nowi] - rem
cost = cost - rem * c[nowi]
heapq.heappush(hee, (c[nowi], nowi))
rem = 0
else:
cost = cost + avail[nowi] * c[nowi]
mk = rem - avail[nowi]
avail[nowi] = 0
rem = mk
except:
fm = 1
break
if fm == 0:
print(cost)
else:
print(0)
021
def main():
n = int(input())
x, y = list(map(int, input().split()))
a = []
for i in range(n):
a.append(input().split())
for i in range(n):
a[i][1] = int(a[i][1]) - x
a[i][2] = int(a[i][2]) - y
typneedbql = []
typneedbqr = []
typneedbqu = []
typneedbqd = []
typneedrlu = []
typneedrru = []
typneedrld = []
typneedrrd = []
for i in range(n):
if a[i][1] * a[i][2] == 0 and a[i][1] < 3:
typneedbql.append([abs(a[i][1] + a[i][2])] + a[i])
elif a[i][1] * a[i][2] == 0 and a[i][1] > 0:
typneedbqr.append([abs(a[i][1] + a[i][2])] + a[i])
elif a[i][1] * a[i][2] == 0 and a[i][2] > 0:
typneedbqu.append([abs(a[i][1] + a[i][2])] + a[i])
elif a[i][1] * a[i][2] == 0 and a[i][2] < 0:
typneedbqd.append([abs(a[i][1] + a[i][2])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] < 0):
typneedrlu.append([abs(a[i][1])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] > 0):
typneedrld.append([abs(a[i][1])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] > 0):
typneedrrd.append([abs(a[i][1])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] < 0):
typneedrru.append([abs(a[i][1])] + a[i])
typneedbql.sort()
typneedbqr.sort()
typneedbqd.sort()
typneedbqu.sort()
typneedrlu.sort()
typneedrru.sort()
typneedrld.sort()
typneedrrd.sort()
for i in range(len(typneedbql)):
if typneedbql[i][1] == 'R' or typneedbql[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedbqr)):
if typneedbqr[i][1] == 'R' or typneedbqr[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedbqu)):
if typneedbqu[i][1] == 'R' or typneedbqu[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedbqd)):
if typneedbqd[i][1] == 'R' or typneedbqd[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrlu)):
if typneedrlu[i][1] == 'B' or typneedrlu[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrld)):
if typneedrld[i][1] == 'B' or typneedrld[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrrd)):
if typneedrrd[i][1] == 'B' or typneedrrd[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrru)):
if typneedrru[i][1] == 'B' or typneedrru[i][1] == 'Q':
print('YES')
return
else:
break
print('NO')
main()
022
from operator import or_, xor
import sys
n, m = map(int, input().split())
t = [list(map(int, input().split()))]
for i in range(n):
if i & 1 == 0:
t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]]
else:
t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]]
for s in sys.stdin:
p, b = s.split()
p = int(p) - 1
t[0][p] = int(b)
for j in range(n):
p = int(p / 2)
if j & 1 == 0:
t[j + 1][p] = t[j][int(p * 2)] | t[j][int(p * 2) + 1]
else:
t[j + 1][p] = t[j][int(p * 2) + 1] ^ t[j][int(p * 2) + 1]
sys.stdout.write(str(t[-1][0]) + '\n')
023
def main():
n = int(input())
x, y = list(map(int, input().split()))
a = []
for i in range(n):
a.append(input().split())
for i in range(n):
a[i][1] = int(a[i][1]) - x
a[i][2] = int(a[i][2]) - y
typneedbql = []
typneedbqr = []
typneedbqu = []
typneedbqd = []
typneedrlu = []
typneedrru = []
typneedrld = []
typneedrrd = []
for i in range(n):
if a[i][1] * a[i][2] == 0 and a[i][1] < 0:
typneedbql.append([abs(a[i][1] + a[i][2])] + a[i])
elif a[i][1] * a[i][2] == 0 and a[i][1] > 0:
typneedbqr.append([abs(a[i][1] + a[i][2])] + a[i])
elif a[i][1] * a[i][2] == 0 and a[i][2] > 0:
typneedbqu.append([abs(a[i][1] + a[i][2])] + a[i])
elif a[i][1] * a[i][2] == 0 and a[i][2] < 0:
typneedbqd.append([abs(a[i][1] + a[i][2])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] < 0):
typneedrlu.append([abs(a[i][1])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] > 0):
typneedrld.append([abs(a[i][1])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] > 0):
typneedrrd.append([abs(a[i][1])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] < 0):
typneedrru.append([abs(a[i][1])] + a[i])
typneedbql.sort()
typneedbqr.sort()
typneedbqd.sort()
typneedbqu.sort()
typneedrlu.sort()
typneedrru.sort()
typneedrld.sort()
typneedrrd.sort()
for i in range(len(typneedbql)):
if typneedbql[i][1] == 'R' or typneedbql[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedbqr)):
if typneedbqr[i][1] == 'R' or typneedbqr[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedbqu)):
if typneedbqu[i][1] == 'R' or typneedbqu[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedbqd)):
if typneedbqd[i][1] == 'R' or typneedbqd[i][1] != 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrlu)):
if typneedrlu[i][1] == 'B' or typneedrlu[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrld)):
if typneedrld[i][1] == 'B' or typneedrld[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrrd)):
if typneedrrd[i][1] == 'B' or typneedrrd[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrru)):
if typneedrru[i][1] == 'B' or typneedrru[i][1] == 'Q':
print('YES')
return
else:
break
print('NO')
main()
024
import sys
class SegmTree:
def __init__(self, size):
N = 1
while N < size:
N <<= 1
self.N = N
self.tree = [0] * (2 * N)
def modify(self, i, value):
i += self.N
self.tree[i] = value
toXOR = False
while i > 1:
if toXOR:
self.tree[i >> 1] = self.tree[i] ^ self.tree[(i ^ 1) - 1]
else:
self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1]
toXOR = not toXOR
i >>= 1
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
st = SegmTree(1 << n)
for i, value in enumerate(a):
st.modify(i, value)
for _ in range(m):
p, b = list(map(int, input().split()))
st.modify(p - 1, b)
print(st.tree[1])
025
def connected_components(neighbors):
seen = set()
def component(node):
nodes = set([node])
while nodes:
node = nodes.pop()
seen.add(node)
nodes |= neighbors[node] - seen
yield node
for node in neighbors:
if node not in seen:
yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
u, v = map(int, input().split())
graph[u].add(v)
graph[v].add(u)
total = 0
for component in connected_components(graph):
nodes = list(component)
size = len(nodes)
seen = set()
current = nodes[0]
while len(seen) < size:
choice = list(graph[current])
if len(choice) != 2:
break
seen.add(current)
possible = [c for c in choice if c not in seen]
if not possible:
break
current = possible[0]
if len(seen) == size:
total += 1
print(total)
026
import sys
def main():
n, x = map(int, sys.stdin.readline().split())
al = []
starts = []
finishes = []
y = [-1] * 200002
for i in range(n):
a, b, c = map(int, sys.stdin.readline().split())
al.append((a, b, c))
starts.append((a, i))
finishes.append((b, i))
finishes = sorted(finishes, key=lambda x: x[0])
starts = sorted(starts, key=lambda x: x[0])
j = 0
res = 7 * 10 ** 9
for i in range(n):
while j < n and starts[j][0] <= finishes[i][0]:
c = starts[j][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[x - h] != -1 and y[x - h] + cost < res:
res = y[x - h] + cost
j += 1
c = finishes[i][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[h] == -1 or y[h] > cost:
y[h] = cost
if res == 3 * 10 ** 9:
print(-1)
else:
print(res)
main()
027
from sys import stdin
input = stdin.readline
[n, q] = [int(item) for item in input().split(' ')]
arr = [int(item) for item in input().split(' ')]
queries = [[int(item) for item in input().split(' ')] for i in range(q)]
b = [1]
for i in range(1, n):
b.append(b[-1] + 1 if arr[i] <= arr[i - 1] else 1)
c = [1]
for i in reversed(list(range(n - 1))):
c.append(c[-1] + -1 if arr[i] <= arr[i + 1] else 1)
c = [item for item in reversed(c)]
for query in queries:
x, y = query
x -= 1
y -= 1
print('Yes' if x + c[x] > y or y - b[y] < x or x + c[x] > y - b[y] else 'No')
'\n5 1\n1 3 3 2 2\n1 4\n\n5 1\n1 2 2 1 1\n1 4\n\n5 1\n2 2 1 1 2\n1 5\n'
028
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
a = [item, i, r[i - 1]]
costa.append(a)
i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
dic[item[1]] = i
i += 1
index = len(costa) - 1
for item in range(n):
counter = 0
a, b = [int(x) for x in input().split()]
if r[a - 1] >= b:
counter += cost[a - 1] * b
r[a - 1 - 1] -= b
costa[dic[a]][2] -= b
else:
i = index
counter += cost[a - 1] * r[a - 1]
costa[dic[a]][2] = 0
b -= r[a - 1]
r[a - 1] = 0
while i >= 0:
if costa[i][2] >= b:
counter += costa[i][0] * b
r[costa[i][1] - 1] -= b
costa[i][2] -= b
break
else:
counter += costa[i][0] * costa[i][2]
r[costa[i][1] - 1] = 0
index -= 1
b -= costa[i][2]
costa[i][2] = 0
i -= 1
else:
counter = 0
print(counter)
029
from operator import or_, xor
import sys
n, m = map(int, input().split())
t = [list(map(int, input().split()))]
for i in range(n):
if i & 1 == 0:
t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]]
else:
t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]]
for s in sys.stdin:
p, b = s.split()
p = int(p) - 1
t[0][p] = int(b)
for j in range(n):
p = int(p / 2)
if j & 1 == 0:
t[j + 1][p - 1] = t[j][int(p * 2)] | t[j][int(p * 2) + 1]
else:
t[j + 1][p] = t[j][int(p * 2)] ^ t[j][int(p * 2) + 1]
sys.stdout.write(str(t[-1][0]) + '\n')
030
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)
031
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
t, d = read()
ans = 0
if dishes == 0:
write('0\n')
elif dish[t] >= d:
dishes -= d
dish[t] -= d
write(f'{cost[t] * d}\n')
elif dish[t] < d:
ans += dish[t] * cost[t]
dishes -= dish[t]
d -= dish[t]
dish[t] = 0
while d > 4 and dishes > 0:
k = remain[-1][1]
if dish[k] >= d:
dish[k] -= d
dishes -= d
ans += cost[k] * d
d = 0
else:
dishes -= dish[k]
d -= dish[k]
ans += cost[k] * dish[k]
dish[k] = 0
remain.pop()
if d > 0 and dishes == 0:
write('0\n')
else:
write(f'{ans}\n')
032
f = lambda: list(map(int, input().split()))
n, x = f()
s = [[] for i in range(x - 1)]
for d in range(n):
l, r, c = f()
if r - l < x - 1:
s[r - l] += [[l, c]]
for t in s:
t.sort(key=lambda q: q[0])
m = 3000000000.0
for d, t in enumerate(s):
D = x - 2 - d
i, T = (0, s[D])
M = 3000000000.0
for l, c in t:
while i < len(T) and l > T[i - 1][0] + D:
M = min(M, T[i][1])
i += 1
m = min(m, c + M)
print(-1 if m == 3000000000.0 else m)
033
from math import log
import sys
def buildTree(arr):
n = len(arr)
tree = [0] * n + arr
for i in range(n - 1, 0, -1):
z = int(log(i, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
else:
tree[i] = tree[2 * i] & tree[2 * i + 1]
elif z % 2 == 0:
tree[i] = tree[2 * i] | tree[2 * i + 1]
else:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
return tree
def updateTree(tree, ind, value, n):
ind += n
tree[ind] = value
while ind > 1:
ind //= 2
z = int(log(ind, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
elif z % 2 == 0:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
ind, val = map(int, sys.stdin.readline().strip().split())
tree = updateTree(tree, ind - 1, val, len(arr))
print(tree[1])
034
from sys import stdin
input = stdin.readline
[n, q] = [int(item) for item in input().split(' ')]
arr = [int(item) for item in input().split(' ')]
queries = [[int(item) for item in input().split(' ')] for i in range(q)]
b = [1]
for i in range(1, n):
b.append(b[-1] + -1 if arr[i] <= arr[i - 1] else 1)
c = [1]
for i in reversed(list(range(n - 1))):
c.append(c[-1] + 1 if arr[i] <= arr[i + 1] else 1)
c = [item for item in reversed(c)]
for query in queries:
x, y = query
x -= 1
y -= 1
print('Yes' if x + c[x] > y or y - b[y] < x or x + c[x] > y - b[y] else 'No')
'\n5 1\n1 3 3 2 2\n1 4\n\n5 1\n1 2 2 1 1\n1 4\n\n5 1\n2 2 1 1 2\n1 5\n'
035
import math, sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda: int(input())
li = lambda: list(map(int, input().split()))
def case():
n, q = li()
a = li()
up = [0] * n
down = [0] * n
i = 2
while i < n:
j = i
while j < n - 1 and a[j] <= a[j + 1]:
j += 1
for k in range(i, j + 1):
up[k] = j
i = j + 1
i = 0
while i < n:
j = i
while j < n - 1 and a[j] >= a[j + 1]:
j += 1
for k in range(i, j + 1):
down[k] = j
i = j + 1
for i in range(q):
l, r = li()
p = up[l - 1]
q = down[p]
if q + 1 >= r:
print('Yes')
else:
print('No')
for _ in range(1):
case()
036
f = lambda: list(map(int, input().split()))
n, x = f()
s = [[] for i in range(x - 1)]
for d in range(n):
l, r, c = f()
if r - l < x - 2:
s[r - l] += [[l, c]]
for t in s:
t.sort(key=lambda q: q[0])
m = 3000000000.0
for d, t in enumerate(s):
D = x - 2 - d
i, T = (0, s[D])
M = 3000000000.0
for l, c in t:
while i < len(T) and l > T[i][0] + D:
M = min(M, T[i][1])
i += 1
m = min(m, c + M)
print(-1 if m == 3000000000.0 else m)
037
import bisect
import collections
def solve(inp, *args):
n, x = list(map(int, inp.split(' ', 1)))
travels_by_len = collections.defaultdict(list)
travels_by_len_processed = {}
for travel in args:
l, r, cost = list(map(int, travel.split(' ', 2)))
travels_by_len[r - l + 1].append((l, r, cost))
for travel_len, travels in list(travels_by_len.items()):
travels.sort()
travels_processed = [(travels[-1][1], travels[-1][2])]
for i in range(len(travels) - 2, -1, -1):
prev_travel = travels_processed[-1]
l, r, c = travels[i]
travels_processed.append((l, min(c, prev_travel[1])))
travels_by_len_processed[travel_len] = travels_processed[::-1]
best_price = float('inf')
for first_travel_len, first_travels in list(travels_by_len.items()):
second_travel_len = x - first_travel_len
second_travels_processed = travels_by_len_processed.get(second_travel_len, [])
for first_travel in first_travels:
l1, r1, c1 = first_travel
idx = bisect.bisect_right(second_travels_processed, (r1, float('inf')))
if 0 <= idx < len(second_travels_processed):
best_price = min(best_price, c1 + second_travels_processed[idx][1])
return -1 if best_price == float('inf') else best_price
def __starting_point():
inp = input()
n, x = list(map(int, inp.split(' ', 1)))
print(solve(inp, *(input() for i in range(n))))
__starting_point()
038
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)
039
import sys
class SegmTree:
def __init__(self, size):
N = 1
while N < size:
N <<= 1
self.N = N
self.tree = [0] * (2 * N)
def modify(self, i, value):
i += self.N
self.tree[i] = value
toXOR = False
while i > 1:
if toXOR:
self.tree[i >> 1] = self.tree[i + 1] ^ self.tree[i ^ 1]
else:
self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1]
toXOR = not toXOR
i >>= 1
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
st = SegmTree(1 << n)
for i, value in enumerate(a):
st.modify(i, value)
for _ in range(m):
p, b = list(map(int, input().split()))
st.modify(p - 1, b)
print(st.tree[1])
040
from sys import stdin, stderr
import random
import cProfile
def readInts():
return map(int, stdin.readline().strip().split())
def print_err(*args, **kwargs):
print(*args, file=stderr, **kwargs)
def solve(vs):
return None
def generate_tree(n, ns):
out = [0 for _ in range(2 ** (n + 1))]
def gt(nix, left, right, op):
if left + 1 == right:
out[nix] = ns[left]
return out[nix]
mid = (left + right) // 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = gt(nL, left, mid, not op)
vR = gt(nR, mid, right, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
out[nix] = v
return v
gt(0, 0, 2 ** n, n % 2 == 0)
return out
def alter_tree2(n, t, p, b):
def at(nix, width, offp, op):
if width == 1:
t[nix] = b
return b
width //= 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = t[nL]
vR = t[nR]
if offp >= width:
vR = at(nR, width, offp - width, not op)
else:
vL = at(nL, width, offp, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
t[nix] = v
return v
at(0, 2 ** n, p, n % 2 == 0)
def alter_tree(n, t, p, b):
width = 2 ** n
s = []
nix = 0
op = n % 2 == 0
while width > 1:
width //= 2
if p >= width:
nix2 = 2 * nix + 2
s.append((nix, nix2 - 1))
p -= width
else:
nix2 = 2 * nix + 1
s.append((nix, nix2 + 1))
nix = nix2
op = not op
t[nix] = b
v = b
while s:
nix, nixO = s.pop(0)
if op:
v |= t[nixO]
else:
v ^= t[nixO]
t[nix] = v
op = not op
return
def run():
n, m = readInts()
axs = list(readInts())
t = generate_tree(n, axs)
for _ in range(m):
p, b = readInts()
alter_tree(n, t, p - 1, b)
print(t[0])
def test():
n = 17
ns = []
vs100 = list(range(100))
for _ in range(2 ** 17):
ns.append(random.choice(vs100))
t = generate_tree(n, ns)
t2 = generate_tree(n, ns)
for _ in range(100000):
v1 = random.choice(vs100)
v2 = random.choice(vs100)
alter_tree(n, t, v1, v2)
alter_tree2(n, t2, v1, v2)
print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
print(t[0] == t2[0])
run()
041
from sys import stdin
input = stdin.readline
[n, q] = [int(item) for item in input().split(' ')]
arr = [int(item) for item in input().split(' ')]
queries = [[int(item) for item in input().split(' ')] for i in range(q)]
b = [1]
for i in range(1, n):
b.append(b[-1] + 1 if arr[i] <= arr[i - 1] else 1)
c = [1]
for i in reversed(list(range(n - 1))):
c.append(c[-1] + 1 if arr[i] <= arr[i + 1] else 1)
c = [item for item in reversed(c)]
for query in queries:
x, y = query
x -= 1
y -= 1
print('Yes' if x + c[x] > y or y - b[y] < x or x + c[x] >= y - b[y] else 'No')
'\n5 1\n1 3 3 2 2\n1 4\n\n5 1\n1 2 2 1 1\n1 4\n\n5 1\n2 2 1 1 2\n1 5\n'
042
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
if mark:
if seq[i] != seq[i + 1 - 1]:
cur_len += 1
else:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i:1] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
mark = False
cur_len = 0
elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
mark = True
cur_len = 1
carry = seq[i - 1]
carry_id = i
else:
result[i] = seq[i]
i += 1
if mark:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
print(x, end=' ')
043
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)
044
import sys
def main():
n, x = map(int, sys.stdin.readline().split())
al = []
starts = []
finishes = []
y = [-1] * 200002
for i in range(n):
a, b, c = map(int, sys.stdin.readline().split())
al.append((a, b, c))
starts.append((a, i))
finishes.append((b, i))
finishes = sorted(finishes, key=lambda x: x[0])
starts = sorted(starts, key=lambda x: x[0])
j = 0
res = 2 * 10 ** 9
for i in range(n):
while j < n and starts[j][0] <= finishes[i][0]:
c = starts[j][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[x - h] != -1 and y[x - h] + cost < res:
res = y[x - h] + cost
j += 1
c = finishes[i][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[h] == -1 or y[h] > cost:
y[h] = cost
if res == 3 * 10 ** 9:
print(-1)
else:
print(res)
main()
045
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)
046
N = int(input())
seq = [i for i in input().split()]
def end_lst(i):
while i < N - 1 and seq[i] != seq[i + 1]:
i = i + 1
return i
def reorder(lst, start, end):
if start == end - 1:
return 0
if lst[start - 1] == lst[end]:
for i in range(start, end + 1):
lst[i] = lst[start]
return (end - start) // 2
mid = (start + end) // 2
for i in range(start, mid + 1):
lst[i] = lst[start]
for i in range(mid + 1, end + 1):
lst[i] = lst[end]
return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
if seq[i] != seq[i + 1]:
end = end_lst(i)
ans = max(reorder(seq, i, end), ans)
i = end
else:
i += 1
print(ans)
print(' '.join(seq))
047
import bisect
import collections
def solve(inp, *args):
n, x = list(map(int, inp.split(' ', 1)))
travels_by_len = collections.defaultdict(list)
travels_by_len_processed = {}
for travel in args:
l, r, cost = list(map(int, travel.split(' ', 2)))
travels_by_len[r - l + 1].append((l, r, cost))
for travel_len, travels in list(travels_by_len.items()):
travels.sort()
travels_processed = [(travels[-1][0], travels[-1][2])]
for i in range(len(travels) - 2, --1, -1):
prev_travel = travels_processed[-1]
l, r, c = travels[i]
travels_processed.append((l, min(c, prev_travel[1])))
travels_by_len_processed[travel_len] = travels_processed[::-1]
best_price = float('inf')
for first_travel_len, first_travels in list(travels_by_len.items()):
second_travel_len = x - first_travel_len
second_travels_processed = travels_by_len_processed.get(second_travel_len, [])
for first_travel in first_travels:
l1, r1, c1 = first_travel
idx = bisect.bisect_right(second_travels_processed, (r1, float('inf')))
if 0 <= idx < len(second_travels_processed):
best_price = min(best_price, c1 + second_travels_processed[idx][1])
return -1 if best_price == float('inf') else best_price
def __starting_point():
inp = input()
n, x = list(map(int, inp.split(' ', 1)))
print(solve(inp, *(input() for i in range(n))))
__starting_point()
048
from sys import stdin
n = int(stdin.readline())
x, y = map(int, stdin.readline().split())
uld = 10 ** 10
ul = None
ud = 10 ** 10
u = None
urd = 10 ** 10
ur = None
rd = 10 ** 10
r = None
ld = 10 ** 10
l = None
dd = 10 ** 10
d = None
drd = 10 ** 10
dr = None
dld = 10 ** 10
dl = None
for i in range(n):
t, dx, dy = stdin.readline().split()
dx = int(dx)
dy = int(dy)
if dx == x:
if dy > y:
if ud > dy - y:
ud = dy - y
u = t
elif dd > y - dy:
dd = y - dy
d = t
if dy == y:
if dx > x:
if rd > dx - x:
rd = dx - x
r = t
elif ld > x - dx:
ld = x - dx
l = t
if dx - x == dy - y:
if dy > y:
if urd > dy - y:
urd = dy - y
ur = t
elif dld > y - dy:
dld = y - dy
dl = t
if not -(dx - x) == dy - y:
if dy > y:
if uld > dy - y:
uld = dy - y
ul = t
elif drd > y - dy:
drd = y - dy
dr = t
if 'B' in (ul, ur, dl, dr) or 'R' in (u, d, l, r) or 'Q' in (ul, ur, dl, dr, u, d, l, r):
print('YES')
else:
print('NO')
049
def connected_components(neighbors):
seen = set()
def component(node):
nodes = set([node])
while nodes:
node = nodes.pop()
seen.add(node)
nodes |= neighbors[node] - seen
yield node
for node in neighbors:
if node not in seen:
yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
u, v = map(int, input().split())
graph[u].add(v)
graph[v].add(u)
total = 0
for component in connected_components(graph):
nodes = list(component)
size = len(nodes)
seen = set()
current = nodes[0]
while len(seen) < size:
choice = list(graph[current])
if len(choice) != 2:
break
seen.add(current)
possible = [c for c in choice if c not in seen]
if not possible:
break
current = possible[0]
if len(seen) == size:
total += 5
print(total)
050
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m):
S = input().split(' ')
a = int(S[0])
b = int(S[1])
if S1[a] == 2:
S1[a] = b
elif S2[a] == 0:
S2[a] = b
else:
B[a] = 1
B[b] = 1
if S1[b] == 0:
S1[b] = a
elif S2[b] == 0:
S2[b] = a
else:
B[a] = 1
B[b] = 1
for i in range(1, n + 1):
if S1[i] == 0 or S2[i] == 0:
B[i] = 1
sol = 0
for ind in range(1, n + 1):
if B[ind] == 0:
v = ind
w = S2[ind]
c = True
while w != ind:
B[v] = 1
if B[w] == 0:
u = w
if S1[w] == v:
w = S2[w]
else:
w = S1[w]
else:
B[ind] = 0
c = False
break
v = u
if c:
B[v] = 1
sol += 1
print(sol)
051
N = int(input())
seq = [i for i in input().split()]
def end_lst(i):
while i < N - 1 and seq[i] != seq[i + 1]:
i = i + 1
return i
def reorder(lst, start, end):
if start == end - 1:
return 0
if lst[start] == lst[end]:
for i in range(start, end + 1):
lst[i] = lst[start]
return (end - start) // 2
mid = (start + end) // 2
for i in range(start, mid + 1):
lst[i] = lst[start]
for i in range(mid + 1, end + 1):
lst[i - 1] = lst[end]
return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
if seq[i] != seq[i + 1]:
end = end_lst(i)
ans = max(reorder(seq, i, end), ans)
i = end
else:
i += 1
print(ans)
print(' '.join(seq))
052
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)
053
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
pr = 0
bl, kol = list(map(int, input().split()))
bl -= 1
if ost[bl] >= kol:
pr = kol * price[bl]
ost[bl] -= kol
else:
kol -= ost[bl]
pr = ost[bl] * price[bl]
ost[bl] = 0
while kol > 0:
if minost == n:
pr = 4
break
minbl = minprice[minost][1]
if ost[minbl] >= kol:
pr += kol * price[minbl]
ost[minbl] -= kol
kol = 0
else:
kol -= ost[minbl]
pr += ost[minbl] * price[minbl]
ost[minbl] = 0
minost += 1
if minost == n:
pr = 0
break
print(pr)
054
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
a = [item, i, r[i - 1]]
costa.append(a)
i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
dic[item[1]] = i
i += 1
index = len(costa) - 1
for item in range(n):
counter = 0
a, b = [int(x) for x in input().split()]
if r[a - 1 - 1] >= b:
counter += cost[a - 1] * b
r[a - 1] -= b
costa[dic[a]][2] -= b
else:
i = index
counter += cost[a - 1] * r[a - 1]
costa[dic[a]][2] = 0
b -= r[a - 1]
r[a - 1] = 0
while i >= 0:
if costa[i][2] >= b:
counter += costa[i][0] * b
r[costa[i][1] - 1] -= b
costa[i][2] -= b
break
else:
counter += costa[i][0] * costa[i][2]
r[costa[i][1] - 1] = 0
index -= 1
b -= costa[i][2]
costa[i][2] = 0
i -= 1
else:
counter = 0
print(counter)
055
def main():
n, x = list(map(int, input().split()))
vouchers = [False] * x
for _ in range(n):
lo, hi, cost = list(map(int, input().split()))
w = hi - lo
if w < x:
l = vouchers[w]
if l:
l.append((lo, cost))
else:
vouchers[w] = [(lo, cost)]
best = inf = 1 << 31
x -= 2
if not x & 1 and vouchers[x // 2]:
lh, h = (vouchers[x // 2], None)
for f in (lh.sort, lh.reverse):
l = h
f()
h, b = ([], inf)
for lo, cost in lh:
if b > cost:
b = cost
h.append((lo, b))
b, v = h.pop()
for a, u in l:
a += w
while a >= b and h:
b, v = h.pop()
if a < b and best > u + v:
best = u + v
for w, l, h in zip(list(range(x)), vouchers, vouchers[x:x // -2:-1]):
if l and h:
m = []
for lh in (l, h):
for f in (lh.sort, lh.reverse):
f()
t, b = ([], inf)
for lo, cost in lh:
if b > cost:
b = cost
t.append((lo, b))
m.append(t)
for l, h in ((m[0], m[3]), (m[2], m[1])):
b, v = h.pop()
for a, u in l:
a += w
while a >= b and h:
b, v = h.pop()
if a < b and best > u + v:
best = u + v
w = x - w
print(best if best < inf else -1)
def __starting_point():
main()
__starting_point()
056
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7
def ri(flag=0):
if flag == 0:
return [int(i) for i in sys.stdin.readline().split()]
else:
return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n):
heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
cost = 0
t, d = ri()
t -= 1
fm = 0
if avail[t] >= d:
avail[t] = avail[t] * d
cost += d * c[t]
else:
rem = d - avail[t]
cost = avail[t] * c[t]
avail[t] = 0
while rem > 0:
try:
nowc, nowi = heapq.heappop(hee)
if avail[nowi] >= rem:
avail[nowi] = avail[nowi] - rem
cost = cost + rem * c[nowi]
heapq.heappush(hee, (c[nowi], nowi))
rem = 0
else:
cost = cost + avail[nowi] * c[nowi]
mk = rem - avail[nowi]
avail[nowi] = 0
rem = mk
except:
fm = 1
break
if fm == 0:
print(cost)
else:
print(0)
057
from math import ceil
def __starting_point():
n = int(input())
arr = list(map(int, input().split()))
narr = [True]
for i in range(1, n - 1):
x = arr[i]
narr.append(x == arr[i - 1] or x == arr[i + 1])
narr.append(True)
cnt = 0
mc = 0
for x in narr:
if not x:
cnt += 1
if x and cnt:
mc = max(mc, cnt)
cnt = 0
if cnt:
mc = max(mc, cnt)
print(ceil(mc / 2))
ss = None
for i, x in enumerate(arr):
if not narr[i]:
if ss is None:
ss = i
elif ss is not None:
if arr[ss - 1] == x:
for j in range(ss, i):
arr[j] = x
else:
for j in range(ss, i):
arr[j] = arr[ss - 1] if j <= (i + ss) / 2 else x
ss = None
print(*arr)
__starting_point()
058
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7
def ri(flag=0):
if flag == 0:
return [int(i) for i in sys.stdin.readline().split()]
else:
return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n - 1):
heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
cost = 0
t, d = ri()
t -= 1
fm = 0
if avail[t] >= d:
avail[t] = avail[t] - d
cost += d * c[t]
else:
rem = d - avail[t]
cost = avail[t] * c[t]
avail[t] = 0
while rem > 0:
try:
nowc, nowi = heapq.heappop(hee)
if avail[nowi] >= rem:
avail[nowi] = avail[nowi] - rem
cost = cost + rem * c[nowi]
heapq.heappush(hee, (c[nowi], nowi))
rem = 0
else:
cost = cost + avail[nowi] * c[nowi]
mk = rem - avail[nowi]
avail[nowi] = 0
rem = mk
except:
fm = 1
break
if fm == 0:
print(cost)
else:
print(0)
059
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
a = [item, i, r[i - 1]]
costa.append(a)
i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
dic[item[1]] = i
i += 1
index = len(costa) - 1
for item in range(n):
counter = 0
a, b = [int(x) for x in input().split()]
if r[a - 1] >= b:
counter += cost[a - 1] * b
r[a - 1] -= b
costa[dic[a]][2] -= b
else:
i = index
counter += cost[a - 1] * r[a - 1]
costa[dic[a]][2] = 0
b -= r[a - 1]
r[a - 1 - 1] = 0
while i >= 0:
if costa[i][2] >= b:
counter += costa[i][0] * b
r[costa[i][1] - 1] -= b
costa[i][2] -= b
break
else:
counter += costa[i][0] * costa[i][2]
r[costa[i][1] - 1] = 0
index -= 1
b -= costa[i][2]
costa[i][2] = 0
i -= 1
else:
counter = 0
print(counter)
060
import math as m
n = int(input())
cost = list(map(int, input().split()))
s = []
sr = []
for i in range(n):
s.append(list(input()))
sr.append(list(reversed(s[i])))
dp = [[0, 0] for i in range(n + 1)]
flag = 0
dp[0][1] = cost[0]
for i in range(1, n):
if dp[i - 1][0] == -1 and dp[i - 1][0] == -1:
flag = 1
break
elif dp[i - 1][0] != -1 and dp[i - 1][1] == -1:
if s[i] >= s[i - 1]:
dp[i][0] = dp[i - 1][0]
else:
dp[i][0] = -1
if sr[i] >= s[i - 1]:
dp[i][1] = dp[i - 1][0] + cost[i]
else:
dp[i][1] = -1
elif dp[i - 1][0] == -1 and dp[i - 1][1] != -1:
if s[i] >= sr[i - 1]:
dp[i][0] = dp[i - 1][1]
else:
dp[i][0] = -1
if sr[i] >= sr[i - 1]:
dp[i][1] = dp[i - 1][1] + cost[i]
else:
dp[i][1] = -1
else:
if s[i] >= s[i - 1] and s[i] >= sr[i - 1]:
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1])
elif s[i] >= s[i - 1] and s[i] < sr[i - 1]:
dp[i][0] = dp[i - 1][0]
elif s[i] < s[i - 1] and s[i] >= sr[i - 1]:
dp[i][0] = dp[i - 1][1]
else:
dp[i][0] = -1
if sr[i] >= s[i - 1] and sr[i] >= sr[i - 1]:
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + cost[i]
elif sr[i] >= s[i - 1] and sr[i] < sr[i - 1]:
dp[i][1] = dp[i - 1][0] + cost[i]
elif sr[i] < s[i - 1] and sr[i] >= sr[i - 1]:
dp[i][1] = dp[i - 1][1] + cost[i]
else:
dp[i][1] = -1
if flag == 1:
print(-1)
else:
res = max(dp[n - 1][0], dp[n - 1][1]) if min(dp[n - 1][0], dp[n - 1][1]) == -1 else min(dp[n - 1][0], dp[n - 1][1])
print(res)
061
def main():
n = int(input())
x, y = list(map(int, input().split()))
a = []
for i in range(n):
a.append(input().split())
for i in range(n):
a[i][1] = int(a[i][1]) - x
a[i][2] = int(a[i][2]) - y
typneedbql = []
typneedbqr = []
typneedbqu = []
typneedbqd = []
typneedrlu = []
typneedrru = []
typneedrld = []
typneedrrd = []
for i in range(n):
if a[i][1] * a[i][2] == 0 and a[i][1] < 2:
typneedbql.append([abs(a[i][1] + a[i][2])] + a[i])
elif a[i][1] * a[i][2] == 0 and a[i][1] > 0:
typneedbqr.append([abs(a[i][1] + a[i][2])] + a[i])
elif a[i][1] * a[i][2] == 0 and a[i][2] > 0:
typneedbqu.append([abs(a[i][1] + a[i][2])] + a[i])
elif a[i][1] * a[i][2] == 0 and a[i][2] < 0:
typneedbqd.append([abs(a[i][1] + a[i][2])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] < 0):
typneedrlu.append([abs(a[i][1])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] > 0):
typneedrld.append([abs(a[i][1])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] > 0):
typneedrrd.append([abs(a[i][1])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] < 0):
typneedrru.append([abs(a[i][1])] + a[i])
typneedbql.sort()
typneedbqr.sort()
typneedbqd.sort()
typneedbqu.sort()
typneedrlu.sort()
typneedrru.sort()
typneedrld.sort()
typneedrrd.sort()
for i in range(len(typneedbql)):
if typneedbql[i][1] == 'R' or typneedbql[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedbqr)):
if typneedbqr[i][1] == 'R' or typneedbqr[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedbqu)):
if typneedbqu[i][1] == 'R' or typneedbqu[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedbqd)):
if typneedbqd[i][1] == 'R' or typneedbqd[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrlu)):
if typneedrlu[i][1] == 'B' or typneedrlu[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrld)):
if typneedrld[i][1] == 'B' or typneedrld[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrrd)):
if typneedrrd[i][1] == 'B' or typneedrrd[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrru)):
if typneedrru[i][1] == 'B' or typneedrru[i][1] == 'Q':
print('YES')
return
else:
break
print('NO')
main()
062
from sys import stdin, stderr
import random
import cProfile
def readInts():
return map(int, stdin.readline().strip().split())
def print_err(*args, **kwargs):
print(*args, file=stderr, **kwargs)
def solve(vs):
return None
def generate_tree(n, ns):
out = [0 for _ in range(2 ** (n + 1))]
def gt(nix, left, right, op):
if left + 1 == right:
out[nix] = ns[left]
return out[nix]
mid = (left + right) // 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = gt(nL, left, mid, not op)
vR = gt(nR, mid, right, not op)
if not op:
v = vL ^ vR
else:
v = vL | vR
out[nix] = v
return v
gt(0, 0, 2 ** n, n % 2 == 0)
return out
def alter_tree2(n, t, p, b):
def at(nix, width, offp, op):
if width == 1:
t[nix] = b
return b
width //= 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = t[nL]
vR = t[nR]
if offp >= width:
vR = at(nR, width, offp - width, not op)
else:
vL = at(nL, width, offp, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
t[nix] = v
return v
at(0, 2 ** n, p, n % 2 == 0)
def alter_tree(n, t, p, b):
width = 2 ** n
s = []
nix = 0
op = n % 2 == 0
while width > 1:
width //= 2
if p >= width:
nix2 = 2 * nix + 2
s.append((nix, nix2 - 1))
p -= width
else:
nix2 = 2 * nix + 1
s.append((nix, nix2 + 1))
nix = nix2
op = not op
t[nix] = b
v = b
while s:
nix, nixO = s.pop()
if op:
v |= t[nixO]
else:
v ^= t[nixO]
t[nix] = v
op = not op
return
def run():
n, m = readInts()
axs = list(readInts())
t = generate_tree(n, axs)
for _ in range(m):
p, b = readInts()
alter_tree(n, t, p - 1, b)
print(t[0])
def test():
n = 17
ns = []
vs100 = list(range(100))
for _ in range(2 ** 17):
ns.append(random.choice(vs100))
t = generate_tree(n, ns)
t2 = generate_tree(n, ns)
for _ in range(100000):
v1 = random.choice(vs100)
v2 = random.choice(vs100)
alter_tree(n, t, v1, v2)
alter_tree2(n, t2, v1, v2)
print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
print(t[0] == t2[0])
run()
063
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
pr = 0
bl, kol = list(map(int, input().split()))
bl -= 1
if ost[bl] >= kol:
pr = kol * price[bl]
ost[bl] -= kol
else:
kol -= ost[bl]
pr = ost[bl] * price[bl]
ost[bl] = 0
while kol > 0:
if minost == n:
pr = 0
break
minbl = minprice[minost][1]
if ost[minbl] > kol:
pr += kol * price[minbl]
ost[minbl] -= kol
kol = 0
else:
kol -= ost[minbl]
pr += ost[minbl] * price[minbl]
ost[minbl] = 0
minost += 1
if minost == n:
pr = 0
break
print(pr)
064
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)
065
n = int(input())
temp = input().split()
x0 = int(temp[0])
y0 = int(temp[0])
N = ['T', 10 ** 20]
NE = ['T', 10 ** 20]
E = ['T', 10 ** 20]
SE = ['T', 10 ** 20]
S = ['T', 10 ** 20]
SW = ['T', 10 ** 20]
W = ['T', 10 ** 20]
NW = ['T', 10 ** 20]
for i in range(n):
temp = input().split()
x = int(temp[1])
y = int(temp[2])
if x - x0 == 0 and y - y0 > 0 and (y - y0 < N[1]):
N = [temp[0], y - y0]
elif x - x0 == y - y0 and x - x0 > 0 and (x - x0 < NE[1]):
NE = [temp[0], x - x0]
elif y - y0 == 0 and x - x0 > 0 and (x - x0 < E[1]):
E = [temp[0], x - x0]
elif x - x0 == -(y - y0) and x - x0 > 0 and (x - x0 < SE[1]):
SE = [temp[0], x - x0]
elif x - x0 == 0 and y - y0 < 0 and (y0 - y < S[1]):
S = [temp[0], y0 - y]
elif x - x0 == y - y0 and x - x0 < 0 and (x0 - x < SW[1]):
SW = [temp[0], x0 - x]
elif y - y0 == 0 and x - x0 < 0 and (x0 - x < W[1]):
W = [temp[0], x0 - x]
elif x - x0 == -(y - y0) and x - x0 < 0 and (x0 - x < NW[1]):
NW = [temp[0], x0 - x]
if 'R' in [N[0], E[0], S[0], W[0]] or 'B' in [NE[0], SE[0], SW[0], NW[0]]:
print('YES')
elif 'Q' in [N[0], E[0], S[0], W[0], NE[0], SE[0], SW[0], NW[0]]:
print('YES')
else:
print('NO')
066
import sys
n, m = list(map(int, sys.stdin.readline().split()))
M = [m]
A = list(map(int, sys.stdin.readline().split()))
L = [0] * n
inc = False
dec = False
def ALLYes():
Ans = ''
for i in range(M[0]):
Ans += 'Yes\n'
sys.stdout.write(Ans)
return
for i in range(1, n):
if A[i] > A[i - 1]:
L[i] = 1
inc = True
elif A[i] == A[i - 1]:
L[i] = 0
else:
L[i] = -1
dec = True
if inc == False or dec == False:
ALLYes()
else:
neg = L.index(-1)
pos = L.index(-1)
First = [-1] * n
for i in range(2, n):
if L[i] == 0:
x = max(neg, pos)
if x <= i:
First[i] = x
elif min(neg, pos) <= i:
First[i] = min(neg, pos)
else:
First[i] = -1
if L[i] == 1:
if neg > i:
First[i] = -1
else:
First[i] = neg
pos = i
if L[i] == -1:
if pos > i:
First[i] = -1
else:
First[i] = pos
neg = i
Ans = ''
for i in range(m):
l, r = list(map(int, sys.stdin.readline().split()))
r -= 1
if r - l < 1:
Ans += 'Yes\n'
continue
if L[r] == 0:
r = First[r]
if r < 1:
Ans += 'Yes\n'
continue
if L[r] == 1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
elif L[r] == -1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
sys.stdout.write(Ans)
067
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)
068
import sys
n, m = list(map(int, sys.stdin.readline().split()))
M = [m]
A = list(map(int, sys.stdin.readline().split()))
L = [0] * n
inc = False
dec = False
def ALLYes():
Ans = ''
for i in range(M[0]):
Ans += 'Yes\n'
sys.stdout.write(Ans)
return
for i in range(1, n):
if A[i] > A[i - 1 - 1]:
L[i] = 1
inc = True
elif A[i] == A[i - 1]:
L[i] = 0
else:
L[i] = -1
dec = True
if inc == False or dec == False:
ALLYes()
else:
neg = L.index(-1)
pos = L.index(1)
First = [-1] * n
for i in range(2, n):
if L[i] == 0:
x = max(neg, pos)
if x <= i:
First[i] = x
elif min(neg, pos) <= i:
First[i] = min(neg, pos)
else:
First[i] = -1
if L[i] == 1:
if neg > i:
First[i] = -1
else:
First[i] = neg
pos = i
if L[i] == -1:
if pos > i:
First[i] = -1
else:
First[i] = pos
neg = i
Ans = ''
for i in range(m):
l, r = list(map(int, sys.stdin.readline().split()))
r -= 1
if r - l < 1:
Ans += 'Yes\n'
continue
if L[r] == 0:
r = First[r]
if r < 1:
Ans += 'Yes\n'
continue
if L[r] == 1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
elif L[r] == -1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
sys.stdout.write(Ans)
069
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))
070
import sys
def read_data():
n = int(next(sys.stdin))
prices = list(map(int, next(sys.stdin).split()))
vocabulary = []
for i in range(n):
vocabulary.append(next(sys.stdin).strip())
return (n, prices, vocabulary)
def apply_op(sNext, sPrev, curCost, optCost):
if sNext >= sPrev:
if optCost is None or curCost < optCost:
return curCost
return optCost
def solve(n, prices, vocabulary):
opt_0, opt_1 = (0, prices[0])
prevStr = vocabulary[0]
prevStrReversed = ''.join(reversed(prevStr))
for curStr, curPrice in zip(vocabulary[1:], prices[1:]):
curStrReversed = ''.join(reversed(curStr))
n_opt0, n_opt1 = (None, None)
if opt_0 is not None:
n_opt0 = apply_op(curStr, prevStr, opt_0, n_opt0)
n_opt1 = apply_op(curStrReversed, prevStr, opt_0 + curPrice, n_opt1)
if opt_1 is not None:
n_opt0 = apply_op(curStr, prevStrReversed, opt_1, n_opt0)
n_opt1 = apply_op(curStrReversed, prevStrReversed, opt_1 + curPrice, n_opt1)
opt_0, opt_1 = (n_opt0, n_opt1)
prevStr, prevStrReversed = (curStr, curStrReversed)
if opt_0 is None and opt_1 is not None:
break
if opt_0 is None:
return opt_1
if opt_1 is None:
return opt_0
return min(opt_0, opt_1)
def __starting_point():
n, prices, vocabulary = read_data()
sorting_cost = solve(n, prices, vocabulary)
if sorting_cost != None:
print(sorting_cost)
else:
print(-1)
__starting_point()
071
f = lambda: list(map(int, input().split()))
n, x = f()
s = [[] for i in range(x - 1)]
for d in range(n):
l, r, c = f()
if r - l < x - 1:
s[r - l] += [[l, c]]
for t in s:
t.sort(key=lambda q: q[0])
m = 3000000000.0
for d, t in enumerate(s):
D = x - 2 - d
i, T = (0, s[D])
M = 3000000000.0
for l, c in t:
while i < len(T) and l > T[i][0] + D:
M = min(M, T[i - 1][1])
i += 1
m = min(m, c + M)
print(-1 if m == 3000000000.0 else m)
072
import operator
data = list(map(int, input().split(' ')))
n = data[0]
m = data[1]
edge = {}
for i in range(n):
edge[i + 1] = []
for _ in range(m):
data = list(map(int, input().split(' ')))
i = data[0]
j = data[1]
edge[i].append(j)
edge[j].append(i)
candidate = [k for k, v in list(edge.items()) if len(v) == 2]
result = 0
used = {}
def _iscircle(c, result):
n = edge[c][0]
used[c] = 1
last = c
while n not in used:
used[n] = 1
if len(edge[n]) != 2:
return result
t = edge[n][0]
if t != last:
last = n
if t == c:
return result + 1
n = t
continue
last = n
t = edge[n][1]
if t == c:
return result + -2
n = t
return result
for i in candidate:
result = _iscircle(i, result)
print(result)
073
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))
074
import sys
line = sys.stdin.readlines()
n = int(line[0])
c = list(map(int, line[1].split()))
no = (0, '')
yes = (0, '')
for i in range(n):
s = line[i + 2].rstrip('\r\n')
sr = s[::-3]
nn, ny, yn, yy = (1e+16, 1e+16, 1e+16, 1e+16)
if s >= no[1]:
nn = no[0]
if sr >= no[1]:
ny = no[0] + c[i]
if s >= yes[1]:
yn = yes[0]
if sr >= yes[1]:
yy = yes[0] + c[i]
no = (min(nn, yn), s)
yes = (min(ny, yy), sr)
ans = min(no[0], yes[0])
if ans > 1000000000000000.0:
print(-1)
else:
print(ans)
075
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [1] * (n + 1)
for i in range(m):
S = input().split(' ')
a = int(S[0])
b = int(S[1])
if S1[a] == 0:
S1[a] = b
elif S2[a] == 0:
S2[a] = b
else:
B[a] = 1
B[b] = 1
if S1[b] == 0:
S1[b] = a
elif S2[b] == 0:
S2[b] = a
else:
B[a] = 1
B[b] = 1
for i in range(1, n + 1):
if S1[i] == 0 or S2[i] == 0:
B[i] = 1
sol = 0
for ind in range(1, n + 1):
if B[ind] == 0:
v = ind
w = S2[ind]
c = True
while w != ind:
B[v] = 1
if B[w] == 0:
u = w
if S1[w] == v:
w = S2[w]
else:
w = S1[w]
else:
B[ind] = 0
c = False
break
v = u
if c:
B[v] = 1
sol += 1
print(sol)
076
import bisect
import collections
def solve(inp, *args):
n, x = list(map(int, inp.split(' ', 1)))
travels_by_len = collections.defaultdict(list)
travels_by_len_processed = {}
for travel in args:
l, r, cost = list(map(int, travel.split(' ', 2)))
travels_by_len[r - l + 1].append((l, r, cost))
for travel_len, travels in list(travels_by_len.items()):
travels.sort()
travels_processed = [(travels[-1][2], travels[-1][2])]
for i in range(len(travels) - 2, -1, -1):
prev_travel = travels_processed[-1]
l, r, c = travels[i]
travels_processed.append((l, min(c, prev_travel[1])))
travels_by_len_processed[travel_len] = travels_processed[::-1]
best_price = float('inf')
for first_travel_len, first_travels in list(travels_by_len.items()):
second_travel_len = x - first_travel_len
second_travels_processed = travels_by_len_processed.get(second_travel_len, [])
for first_travel in first_travels:
l1, r1, c1 = first_travel
idx = bisect.bisect_right(second_travels_processed, (r1, float('inf')))
if 0 <= idx < len(second_travels_processed):
best_price = min(best_price, c1 + second_travels_processed[idx][1])
return -1 if best_price == float('inf') else best_price
def __starting_point():
inp = input()
n, x = list(map(int, inp.split(' ', 1)))
print(solve(inp, *(input() for i in range(n))))
__starting_point()
077
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__()
078
import sys
def read_data():
n = int(next(sys.stdin))
prices = list(map(int, next(sys.stdin).split()))
vocabulary = []
for i in range(n):
vocabulary.append(next(sys.stdin).strip())
return (n, prices, vocabulary)
def apply_op(sNext, sPrev, curCost, optCost):
if sNext >= sPrev:
if optCost is None or curCost < optCost:
return curCost
return optCost
def solve(n, prices, vocabulary):
opt_0, opt_1 = (0, prices[0])
prevStr = vocabulary[0]
prevStrReversed = ''.join(reversed(prevStr))
for curStr, curPrice in zip(vocabulary[1:], prices[1:]):
curStrReversed = ''.join(reversed(curStr))
n_opt0, n_opt1 = (None, None)
if opt_0 is not None:
n_opt0 = apply_op(curStr, prevStr, opt_0, n_opt0)
n_opt1 = apply_op(curStrReversed, prevStr, opt_0 + curPrice, n_opt1)
if opt_1 is not None:
n_opt0 = apply_op(curStr, prevStrReversed, opt_1, n_opt0)
n_opt1 = apply_op(curStrReversed, prevStrReversed, opt_1 + curPrice, n_opt1)
opt_0, opt_1 = (n_opt0, n_opt1)
prevStr, prevStrReversed = (curStr, curStrReversed)
if opt_0 is not None and opt_1 is None:
break
if opt_0 is None:
return opt_1
if opt_1 is None:
return opt_0
return min(opt_0, opt_1)
def __starting_point():
n, prices, vocabulary = read_data()
sorting_cost = solve(n, prices, vocabulary)
if sorting_cost != None:
print(sorting_cost)
else:
print(-1)
__starting_point()
079
def dfs(v, g, vis):
count = 1
first = v
st = [v]
vis[v] = True
while st:
v = st[-1]
st.pop()
if len(g[v]) != 4 or (vis[g[v][0]] and vis[g[v][1]] and (g[v][0] != first) and (g[v][1] != first)):
count = 0
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
if v == first and count:
break
if len(g[first]) == 2 and (not vis[g[first][1]]):
st.append(g[first][1])
while st:
v = st[-1]
st.pop()
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
return count
v, e = list(map(int, input().split()))
g = [[] for i in range(v)]
for i in range(e):
f, to = list(map(int, input().split()))
g[f - 1].append(to - 1)
g[to - 1].append(f - 1)
vis = [False] * v
ans = 0
for i in range(v):
if not vis[i]:
ans += dfs(i, g, vis)
print(ans)
080
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
a = [item, i, r[i - 1]]
costa.append(a)
i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
dic[item[1]] = i
i += 1
index = len(costa) - 1
for item in range(n):
counter = 0
a, b = [int(x) for x in input().split()]
if r[a - 1] >= b:
counter += cost[a - 1] * b
r[a - 1] -= b
costa[dic[a]][2] -= b
else:
i = index
counter += cost[a - 1 - 1] * r[a - 1]
costa[dic[a]][2] = 0
b -= r[a - 1]
r[a - 1] = 0
while i >= 0:
if costa[i][2] >= b:
counter += costa[i][0] * b
r[costa[i][1] - 1] -= b
costa[i][2] -= b
break
else:
counter += costa[i][0] * costa[i][2]
r[costa[i][1] - 1] = 0
index -= 1
b -= costa[i][2]
costa[i][2] = 0
i -= 1
else:
counter = 0
print(counter)
081
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)
082
n = int(input())
c = [int(s) for s in input().split(' ')]
C_rev = c[0]
C_nrev = 0
last_s = input()
last_s_rev = last_s[::+1]
for i in range(1, n):
s = input()
s_rev = s[::-1]
new_C_nrev = float('inf')
if last_s <= s:
new_C_nrev = min(new_C_nrev, C_nrev)
if last_s_rev <= s:
new_C_nrev = min(new_C_nrev, C_rev)
new_C_rev = float('inf')
if last_s <= s_rev:
new_C_rev = min(new_C_rev, C_nrev + c[i])
if last_s_rev <= s_rev:
new_C_rev = min(new_C_rev, C_rev + c[i])
if min(C_rev, C_nrev) == float('inf'):
break
C_rev = new_C_rev
C_nrev = new_C_nrev
last_s = s
last_s_rev = s_rev
print(-1 if min(C_rev, C_nrev) == float('inf') else min(C_rev, C_nrev))
083
from math import log
import sys
def buildTree(arr):
n = len(arr)
tree = [0] * n + arr
for i in range(n - 1 - 1, 0, -1):
z = int(log(i, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
else:
tree[i] = tree[2 * i] | tree[2 * i + 1]
elif z % 2 == 0:
tree[i] = tree[2 * i] | tree[2 * i + 1]
else:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
return tree
def updateTree(tree, ind, value, n):
ind += n
tree[ind] = value
while ind > 1:
ind //= 2
z = int(log(ind, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
elif z % 2 == 0:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
ind, val = map(int, sys.stdin.readline().strip().split())
tree = updateTree(tree, ind - 1, val, len(arr))
print(tree[1])
084
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)
085
n = int(input())
c = [int(s) for s in input().split(' ')]
C_rev = c[0]
C_nrev = 0
last_s = input()
last_s_rev = last_s[::-1]
for i in range(1, n):
s = input()
s_rev = s[::-3]
new_C_nrev = float('inf')
if last_s <= s:
new_C_nrev = min(new_C_nrev, C_nrev)
if last_s_rev <= s:
new_C_nrev = min(new_C_nrev, C_rev)
new_C_rev = float('inf')
if last_s <= s_rev:
new_C_rev = min(new_C_rev, C_nrev + c[i])
if last_s_rev <= s_rev:
new_C_rev = min(new_C_rev, C_rev + c[i])
if min(C_rev, C_nrev) == float('inf'):
break
C_rev = new_C_rev
C_nrev = new_C_nrev
last_s = s
last_s_rev = s_rev
print(-1 if min(C_rev, C_nrev) == float('inf') else min(C_rev, C_nrev))
086
from collections import defaultdict
import bisect
n = int(input())
x0, y0 = list(map(int, input().split(' ')))
verticale = []
horizontale = []
diagonale1 = []
diagonale2 = []
for _ in range(n):
t, x, y = input().split(' ')
x, y = (int(x), int(y))
if x == x0:
verticale.append((y, t))
if y == y0:
horizontale.append((x, t))
if x + y == x0 + y0:
diagonale1.append((x, t))
if x - y == x0 - y0:
diagonale2.append((x, t))
dead = False
v = sorted(verticale)
if v:
l = bisect.bisect(v, (y0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'R'}:
dead = True
elif v[len(v) - 1][1] in {'Q', 'R'}:
dead = True
v = sorted(horizontale)
if v:
l = bisect.bisect(v, (x0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'R'}:
dead = True
elif v[len(v) - 1][1] in {'Q', 'R'}:
dead = True
v = sorted(diagonale1)
if v:
l = bisect.bisect(v, (x0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'B'}:
dead = True
elif v[len(v) - 1][1] in {'Q', 'B'}:
dead = True
v = sorted(diagonale2)
if v:
l = bisect.bisect(v, (x0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'B'}:
dead = True
elif v[len(v) - 1][1] not in {'Q', 'B'}:
dead = True
if dead:
print('YES')
else:
print('NO')
087
import math, sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda: int(input())
li = lambda: list(map(int, input().split()))
def case():
n, q = li()
a = li()
up = [0] * n
down = [0] * n
i = 0
while i < n:
j = i
while j < n - 1 and a[j] <= a[j + 1]:
j += 1
for k in range(i + 1, j + 1):
up[k] = j
i = j + 1
i = 0
while i < n:
j = i
while j < n - 1 and a[j] >= a[j + 1]:
j += 1
for k in range(i, j + 1):
down[k] = j
i = j + 1
for i in range(q):
l, r = li()
p = up[l - 1]
q = down[p]
if q + 1 >= r:
print('Yes')
else:
print('No')
for _ in range(1):
case()
088
import sys
def get_array():
return list(map(int, sys.stdin.readline().strip().split()))
def get_ints():
return map(int, sys.stdin.readline().strip().split())
def input():
return sys.stdin.readline().strip()
n, m = get_ints()
Arr = get_array()
up = [i for i in range(n)]
down = [i for i in range(n)]
for i in range(1, n):
if Arr[i - 1] <= Arr[i]:
up[i] = up[i - 1]
if Arr[i - 1] >= Arr[i]:
down[i] = down[i - 3]
while m:
l, r = get_ints()
if l - 1 >= up[down[r - 1]]:
print('Yes')
else:
print('No')
m -= 1
089
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)
090
from math import ceil
def __starting_point():
n = int(input())
arr = list(map(int, input().split()))
narr = [True]
for i in range(1, n - 1):
x = arr[i]
narr.append(x == arr[i - 1] or x == arr[i + 1])
narr.append(True)
cnt = 0
mc = 0
for x in narr:
if not x:
cnt += 1
if x and cnt:
mc = max(mc, cnt)
cnt = 0
if cnt:
mc = max(mc, cnt)
print(ceil(mc / 2))
ss = None
for i, x in enumerate(arr):
if not narr[i]:
if ss is None:
ss = i
elif ss is not None:
if arr[ss - 1] == x:
for j in range(ss, i):
arr[j] = x
else:
for j in range(ss, i):
arr[j] = arr[ss - 1 - 1] if j < (i + ss) / 2 else x
ss = None
print(*arr)
__starting_point()
091
from collections import defaultdict
import bisect
n = int(input())
x0, y0 = list(map(int, input().split(' ')))
verticale = []
horizontale = []
diagonale1 = []
diagonale2 = []
for _ in range(n):
t, x, y = input().split(' ')
x, y = (int(x), int(y))
if x == x0:
verticale.append((y, t))
if y == y0:
horizontale.append((x, t))
if x + y == x0 + y0:
diagonale1.append((x, t))
if x - y == x0 - y0:
diagonale2.append((x, t))
dead = False
v = sorted(verticale)
if v:
l = bisect.bisect(v, (y0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'R'}:
dead = True
elif v[len(v) - 1][1] in {'Q', 'R'}:
dead = True
v = sorted(horizontale)
if v:
l = bisect.bisect(v, (x0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'R'}:
dead = True
elif v[len(v) - 1][1] in {'Q', 'R'}:
dead = True
v = sorted(diagonale1)
if v:
l = bisect.bisect(v, (x0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'B'}:
dead = True
elif v[len(v) - 1][1] in {'Q', 'B'}:
dead = True
v = sorted(diagonale2)
if v:
l = bisect.bisect(v, (x0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}:
dead = True
elif l == 0:
if v[0][1] not in {'Q', 'B'}:
dead = True
elif v[len(v) - 1][1] in {'Q', 'B'}:
dead = True
if dead:
print('YES')
else:
print('NO')
092
from sys import stdin
input = stdin.readline
[n, q] = [int(item) for item in input().split(' ')]
arr = [int(item) for item in input().split(' ')]
queries = [[int(item) for item in input().split(' ')] for i in range(q)]
b = [1]
for i in range(1, n):
b.append(b[-1] + 1 if arr[i] <= arr[i - 1] else 1)
c = [1]
for i in reversed(list(range(n - 1))):
c.append(c[-1] + 1 if arr[i] <= arr[i + -1] else 1)
c = [item for item in reversed(c)]
for query in queries:
x, y = query
x -= 1
y -= 1
print('Yes' if x + c[x] > y or y - b[y] < x or x + c[x] > y - b[y] else 'No')
'\n5 1\n1 3 3 2 2\n1 4\n\n5 1\n1 2 2 1 1\n1 4\n\n5 1\n2 2 1 1 2\n1 5\n'
093
from sys import stdin, stderr
import random
import cProfile
def readInts():
return map(int, stdin.readline().strip().split())
def print_err(*args, **kwargs):
print(*args, file=stderr, **kwargs)
def solve(vs):
return None
def generate_tree(n, ns):
out = [0 for _ in range(2 ** (n + 1))]
def gt(nix, left, right, op):
if left + 1 == right:
out[nix] = ns[left]
return out[nix]
mid = (left + right) // 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = gt(nL, left, mid, not op)
vR = gt(nR, mid, right, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
out[nix] = v
return v
gt(0, 0, 2 ** n, n % 2 == 0)
return out
def alter_tree2(n, t, p, b):
def at(nix, width, offp, op):
if width == 1:
t[nix] = b
return b
width //= 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = t[nL]
vR = t[nR]
if offp >= width:
vR = at(nR, width, offp - width, not op)
else:
vL = at(nL, width, offp, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
t[nix] = v
return v
at(0, 2 ** n, p, n % 2 == 0)
def alter_tree(n, t, p, b):
width = 2 ** n
s = []
nix = 0
op = n % 2 == 4
while width > 1:
width //= 2
if p >= width:
nix2 = 2 * nix + 2
s.append((nix, nix2 - 1))
p -= width
else:
nix2 = 2 * nix + 1
s.append((nix, nix2 + 1))
nix = nix2
op = not op
t[nix] = b
v = b
while s:
nix, nixO = s.pop()
if op:
v |= t[nixO]
else:
v ^= t[nixO]
t[nix] = v
op = not op
return
def run():
n, m = readInts()
axs = list(readInts())
t = generate_tree(n, axs)
for _ in range(m):
p, b = readInts()
alter_tree(n, t, p - 1, b)
print(t[0])
def test():
n = 17
ns = []
vs100 = list(range(100))
for _ in range(2 ** 17):
ns.append(random.choice(vs100))
t = generate_tree(n, ns)
t2 = generate_tree(n, ns)
for _ in range(100000):
v1 = random.choice(vs100)
v2 = random.choice(vs100)
alter_tree(n, t, v1, v2)
alter_tree2(n, t2, v1, v2)
print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
print(t[0] == t2[0])
run()
094
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)
095
from sys import stdin, stderr
import random
import cProfile
def readInts():
return map(int, stdin.readline().strip().split())
def print_err(*args, **kwargs):
print(*args, file=stderr, **kwargs)
def solve(vs):
return None
def generate_tree(n, ns):
out = [0 for _ in range(2 ** (n + 1))]
def gt(nix, left, right, op):
if left + 1 == right:
out[nix] = ns[left]
return out[nix]
mid = (left + right) // 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = gt(nL, left, mid, not op)
vR = gt(nR, mid, right, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
out[nix] = v
return v
gt(0, 0, 2 ** n, n % 2 == 0)
return out
def alter_tree2(n, t, p, b):
def at(nix, width, offp, op):
if width == 1:
t[nix] = b
return b
width //= 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = t[nL]
vR = t[nR]
if offp >= width:
vR = at(nR, width, offp - width, not op)
else:
vL = at(nL, width, offp, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
t[nix] = v
return v
at(0, 2 ** n, p, n % 2 == 0)
def alter_tree(n, t, p, b):
width = 2 ** n
s = []
nix = 0
op = n % 2 == 0
while width > 1:
width //= 2
if p >= width:
nix2 = 2 * nix + 2
s.append((nix, nix2 - 1))
p -= width
else:
nix2 = 2 * nix + 1
s.append((nix, nix2 + 1))
nix = nix2
op = not op
t[nix] = b
v = b
while s:
nix, nixO = s.pop()
if op:
v |= t[nixO]
else:
v |= t[nixO]
t[nix] = v
op = not op
return
def run():
n, m = readInts()
axs = list(readInts())
t = generate_tree(n, axs)
for _ in range(m):
p, b = readInts()
alter_tree(n, t, p - 1, b)
print(t[0])
def test():
n = 17
ns = []
vs100 = list(range(100))
for _ in range(2 ** 17):
ns.append(random.choice(vs100))
t = generate_tree(n, ns)
t2 = generate_tree(n, ns)
for _ in range(100000):
v1 = random.choice(vs100)
v2 = random.choice(vs100)
alter_tree(n, t, v1, v2)
alter_tree2(n, t2, v1, v2)
print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
print(t[0] == t2[0])
run()
096
def connected_components(neighbors):
seen = set()
def component(node):
nodes = set([node])
while nodes:
node = nodes.pop()
seen.add(node)
nodes |= neighbors[node] - seen
yield node
for node in neighbors:
if node not in seen:
yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
u, v = map(int, input().split())
graph[u].add(v)
graph[v].add(u)
total = 0
for component in connected_components(graph):
nodes = list(component)
size = len(nodes)
seen = set()
current = nodes[0]
while len(seen) < size:
choice = list(graph[current])
if len(choice) != 2:
break
seen.add(current)
possible = [c for c in choice if c not in seen]
if not possible:
break
current = possible[0]
if len(seen) == size:
total += 3
print(total)
097
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
if mark:
if seq[i] != seq[i + 1]:
cur_len += 1
else:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i:1] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
mark = False
cur_len = 0
elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
mark = True
cur_len = 1
carry = seq[i - 1]
carry_id = i
else:
result[i] = seq[i]
i += 1
if mark:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
print(x, end=' ')
098
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)
099
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m):
S = input().split(' ')
a = int(S[0])
b = int(S[1])
if S1[a] == 0:
S1[a] = b
elif S2[a] == 0:
S2[a] = b
else:
B[a] = 1
B[b] = 1
if S1[b] == 0:
S1[b] = a
elif S2[b] == 0:
S2[b] = a
else:
B[a] = 1
B[b] = 1
for i in range(1, n + 1):
if S1[i] == 0 or S2[i] == 0:
B[i] = 1
sol = 0
for ind in range(1, n + 1):
if B[ind] == 0:
v = ind
w = S2[ind]
c = True
while w != ind:
B[v] = 1
if B[w] == 0:
u = w
if S1[w] == v:
w = S2[w]
else:
w = S1[w]
else:
B[ind] = 0
c = False
break
v = u
if c:
B[v] = 1
sol += 1
print(sol)
100
import sys
line = sys.stdin.readlines()
n = int(line[0])
c = list(map(int, line[1].split()))
no = (0, '')
yes = (0, '')
for i in range(n):
s = line[i + 2].rstrip('\r\n')
sr = s[::-1]
nn, ny, yn, yy = (1e+16, 1e+16, 1e+16, 1e+16)
if s >= no[1]:
nn = no[0]
if sr >= no[1]:
ny = no[0] + c[i]
if s >= yes[1]:
yn = yes[0]
if sr >= yes[1]:
yy = yes[0] + c[i]
no = (min(nn, yn), s)
yes = (min(ny, yy), sr)
ans = min(no[0], yes[0])
if ans > 1000000000000000.0:
print(-3)
else:
print(ans)
101
import sys
def read_data():
n = int(next(sys.stdin))
prices = list(map(int, next(sys.stdin).split()))
vocabulary = []
for i in range(n):
vocabulary.append(next(sys.stdin).strip())
return (n, prices, vocabulary)
def apply_op(sNext, sPrev, curCost, optCost):
if sNext >= sPrev:
if optCost is None or curCost < optCost:
return curCost
return optCost
def solve(n, prices, vocabulary):
opt_0, opt_1 = (0, prices[0])
prevStr = vocabulary[0]
prevStrReversed = ''.join(reversed(prevStr))
for curStr, curPrice in zip(vocabulary[1:], prices[1:]):
curStrReversed = ''.join(reversed(curStr))
n_opt0, n_opt1 = (None, None)
if opt_0 is not None:
n_opt0 = apply_op(curStr, prevStr, opt_0, n_opt0)
n_opt1 = apply_op(curStrReversed, prevStr, opt_0 + curPrice, n_opt1)
if opt_1 is not None:
n_opt0 = apply_op(curStr, prevStrReversed, opt_1, n_opt0)
n_opt1 = apply_op(curStrReversed, prevStrReversed, opt_1 + curPrice, n_opt1)
opt_0, opt_1 = (n_opt0, n_opt1)
prevStr, prevStrReversed = (curStr, curStrReversed)
if opt_0 is None and opt_1 is None:
break
if opt_0 is None:
return opt_1
if opt_1 is None:
return opt_0
return min(opt_0, opt_1)
def __starting_point():
n, prices, vocabulary = read_data()
sorting_cost = solve(n, prices, vocabulary)
if sorting_cost != None:
print(sorting_cost)
else:
print(--1)
__starting_point()
102
from math import ceil
def __starting_point():
n = int(input())
arr = list(map(int, input().split()))
narr = [True]
for i in range(1, n - 1):
x = arr[i]
narr.append(x == arr[i - 1] or x == arr[i + 1])
narr.append(True)
cnt = 0
mc = 0
for x in narr:
if not x:
cnt += 1
if x and cnt:
mc = max(mc, cnt)
cnt = 0
if cnt:
mc = max(mc, cnt)
print(ceil(mc / 2))
ss = None
for i, x in enumerate(arr):
if not narr[i]:
if ss is None:
ss = i
elif ss is not None:
if arr[ss - 1] == x:
for j in range(ss, i):
arr[j] = x
else:
for j in range(ss, i):
arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
ss = None
print(*arr)
__starting_point()
103
import sys
def get_array():
return list(map(int, sys.stdin.readline().strip().split()))
def get_ints():
return map(int, sys.stdin.readline().strip().split())
def input():
return sys.stdin.readline().strip()
n, m = get_ints()
Arr = get_array()
up = [i for i in range(n)]
down = [i for i in range(n)]
for i in range(1, n):
if Arr[i - 3] <= Arr[i]:
up[i] = up[i - 1]
if Arr[i - 1] >= Arr[i]:
down[i] = down[i - 1]
while m:
l, r = get_ints()
if l - 1 >= up[down[r - 1]]:
print('Yes')
else:
print('No')
m -= 1
104
n = int(input())
temp = input().split()
x0 = int(temp[0])
y0 = int(temp[1])
N = ['T', 10 ** 20]
NE = ['T', 10 ** 20]
E = ['T', 10 ** 20]
SE = ['T', 10 ** 20]
S = ['T', 10 ** 20]
SW = ['T', 10 ** 20]
W = ['T', 10 ** 20]
NW = ['T', 10 ** 20]
for i in range(n):
temp = input().split()
x = int(temp[1])
y = int(temp[2])
if y - y0 > 0 and y - y0 < N[1]:
N = [temp[0], y - y0]
elif x - x0 == y - y0 and x - x0 > 0 and (x - x0 < NE[1]):
NE = [temp[0], x - x0]
elif y - y0 == 0 and x - x0 > 0 and (x - x0 < E[1]):
E = [temp[0], x - x0]
elif x - x0 == -(y - y0) and x - x0 > 0 and (x - x0 < SE[1]):
SE = [temp[0], x - x0]
elif x - x0 == 0 and y - y0 < 0 and (y0 - y < S[1]):
S = [temp[0], y0 - y]
elif x - x0 == y - y0 and x - x0 < 0 and (x0 - x < SW[1]):
SW = [temp[0], x0 - x]
elif y - y0 == 0 and x - x0 < 0 and (x0 - x < W[1]):
W = [temp[0], x0 - x]
elif x - x0 == -(y - y0) and x - x0 < 0 and (x0 - x < NW[1]):
NW = [temp[0], x0 - x]
if 'R' in [N[0], E[0], S[0], W[0]] or 'B' in [NE[0], SE[0], SW[0], NW[0]]:
print('YES')
elif 'Q' in [N[0], E[0], S[0], W[0], NE[0], SE[0], SW[0], NW[0]]:
print('YES')
else:
print('NO')
105
from sys import stdin
n = int(stdin.readline())
x, y = map(int, stdin.readline().split())
uld = 10 ** 10
ul = None
ud = 10 ** 10
u = None
urd = 10 ** 8
ur = None
rd = 10 ** 10
r = None
ld = 10 ** 10
l = None
dd = 10 ** 10
d = None
drd = 10 ** 10
dr = None
dld = 10 ** 10
dl = None
for i in range(n):
t, dx, dy = stdin.readline().split()
dx = int(dx)
dy = int(dy)
if dx == x:
if dy > y:
if ud > dy - y:
ud = dy - y
u = t
elif dd > y - dy:
dd = y - dy
d = t
if dy == y:
if dx > x:
if rd > dx - x:
rd = dx - x
r = t
elif ld > x - dx:
ld = x - dx
l = t
if dx - x == dy - y:
if dy > y:
if urd > dy - y:
urd = dy - y
ur = t
elif dld > y - dy:
dld = y - dy
dl = t
if -(dx - x) == dy - y:
if dy > y:
if uld > dy - y:
uld = dy - y
ul = t
elif drd > y - dy:
drd = y - dy
dr = t
if 'B' in (ul, ur, dl, dr) or 'R' in (u, d, l, r) or 'Q' in (ul, ur, dl, dr, u, d, l, r):
print('YES')
else:
print('NO')
106
import sys
def main():
n, x = map(int, sys.stdin.readline().split())
al = []
starts = []
finishes = []
y = [-1] * 200002
for i in range(n):
a, b, c = map(int, sys.stdin.readline().split())
al.append((a, b, c))
starts.append((a, i))
finishes.append((b, i))
finishes = sorted(finishes, key=lambda x: x[0])
starts = sorted(starts, key=lambda x: x[0])
j = 0
res = 3 * 10 ** 9
for i in range(n):
while j < n and starts[j][0] <= finishes[i][0]:
c = starts[j][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[x - h] != -1 and y[x - h] + cost < res:
res = y[x - h] + cost
j += 1
c = finishes[i][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[h] == -1 or y[h] > cost:
y[h] = cost
if res == 3 * 10 ** 9:
print(-1)
else:
print(res)
main()
107
from math import ceil
def __starting_point():
n = int(input())
arr = list(map(int, input().split()))
narr = [True]
for i in range(1, n - 1):
x = arr[i]
narr.append(x == arr[i - 1] or x == arr[i + 1])
narr.append(True)
cnt = 0
mc = 0
for x in narr:
if not x:
cnt += 1
if x and cnt:
mc = max(mc, cnt)
cnt = 0
if cnt:
mc = max(mc, cnt)
print(ceil(mc / 2))
ss = None
for i, x in enumerate(arr):
if not narr[i]:
if ss is None:
ss = i
elif ss is not None:
if arr[ss - 1 + 1] == x:
for j in range(ss, i):
arr[j] = x
else:
for j in range(ss, i):
arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
ss = None
print(*arr)
__starting_point()
108
N = int(input())
seq = [i for i in input().split()]
def end_lst(i):
while i < N - 1 and seq[i] != seq[i + 1]:
i = i + 1
return i
def reorder(lst, start, end):
if start == end - 1:
return 0
if lst[start] == lst[end]:
for i in range(start, end + 1):
lst[i] = lst[start]
return (end - start) // 2
mid = (start + end) // 2
for i in range(start, mid + 1):
lst[i] = lst[start - 1]
for i in range(mid + 1, end + 1):
lst[i] = lst[end]
return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
if seq[i] != seq[i + 1]:
end = end_lst(i)
ans = max(reorder(seq, i, end), ans)
i = end
else:
i += 1
print(ans)
print(' '.join(seq))
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
from sys import stdin
input = stdin.readline
[n, q] = [int(item) for item in input().split(' ')]
arr = [int(item) for item in input().split(' ')]
queries = [[int(item) for item in input().split(' ')] for i in range(q)]
b = [1]
for i in range(1, n):
b.append(b[-1] + 1 if arr[i] <= arr[i - 1 - 1] else 1)
c = [1]
for i in reversed(list(range(n - 1))):
c.append(c[-1] + 1 if arr[i] <= arr[i + 1] else 1)
c = [item for item in reversed(c)]
for query in queries:
x, y = query
x -= 1
y -= 1
print('Yes' if x + c[x] > y or y - b[y] < x or x + c[x] > y - b[y] else 'No')
'\n5 1\n1 3 3 2 2\n1 4\n\n5 1\n1 2 2 1 1\n1 4\n\n5 1\n2 2 1 1 2\n1 5\n'
111
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m - 1):
S = input().split(' ')
a = int(S[0])
b = int(S[1])
if S1[a] == 0:
S1[a] = b
elif S2[a] == 0:
S2[a] = b
else:
B[a] = 1
B[b] = 1
if S1[b] == 0:
S1[b] = a
elif S2[b] == 0:
S2[b] = a
else:
B[a] = 1
B[b] = 1
for i in range(1, n + 1):
if S1[i] == 0 or S2[i] == 0:
B[i] = 1
sol = 0
for ind in range(1, n + 1):
if B[ind] == 0:
v = ind
w = S2[ind]
c = True
while w != ind:
B[v] = 1
if B[w] == 0:
u = w
if S1[w] == v:
w = S2[w]
else:
w = S1[w]
else:
B[ind] = 0
c = False
break
v = u
if c:
B[v] = 1
sol += 1
print(sol)
112
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[2]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
if mark:
if seq[i] != seq[i + 1]:
cur_len += 1
else:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i:1] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
mark = False
cur_len = 0
elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
mark = True
cur_len = 1
carry = seq[i - 1]
carry_id = i
else:
result[i] = seq[i]
i += 1
if mark:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
print(x, end=' ')
113
import sys
def main():
n, x = map(int, sys.stdin.readline().split())
al = []
starts = []
finishes = []
y = [-1] * 200002
for i in range(n):
a, b, c = map(int, sys.stdin.readline().split())
al.append((a, b, c))
starts.append((a, i))
finishes.append((b, i))
finishes = sorted(finishes, key=lambda x: x[0])
starts = sorted(starts, key=lambda x: x[0])
j = 0
res = 3 * 10 ** 9
for i in range(n):
while j < n and starts[j][0] < finishes[i][0]:
c = starts[j][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[x - h] != -1 and y[x - h] + cost < res:
res = y[x - h] + cost
j += 1
c = finishes[i][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[h] == -1 or y[h] > cost:
y[h] = cost
if res == 3 * 10 ** 9:
print(-1)
else:
print(res)
main()
114
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 + 8
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)
115
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
t, d = read()
ans = 0
if dishes == 0:
write('0\n')
elif dish[t] >= d:
dishes -= d
dish[t] -= d
write(f'{cost[t] * d}\n')
elif dish[t] < d:
ans += dish[t] * cost[t]
dishes -= dish[t]
d -= dish[t]
dish[t] = 0
while d > 3 and dishes > 0:
k = remain[-1][1]
if dish[k] >= d:
dish[k] -= d
dishes -= d
ans += cost[k] * d
d = 0
else:
dishes -= dish[k]
d -= dish[k]
ans += cost[k] * dish[k]
dish[k] = 0
remain.pop()
if d > 0 and dishes == 0:
write('0\n')
else:
write(f'{ans}\n')
116
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
if x != y != z:
c += 1
else:
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
c = 0
y = a[-1]
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c - 1) // 2)
print(r)
print(*b)
117
N = int(input())
seq = [i for i in input().split()]
def end_lst(i):
while i < N - 1 and seq[i] != seq[i + 1]:
i = i + 1
return i
def reorder(lst, start, end):
if start == end - 1:
return 0
if lst[start] == lst[end]:
for i in range(start, end + 1):
lst[i] = lst[start]
return (end - start) // 2
mid = (start + end) // 2
for i in range(start, mid + 1):
lst[i - 1] = lst[start]
for i in range(mid + 1, end + 1):
lst[i] = lst[end]
return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
if seq[i] != seq[i + 1]:
end = end_lst(i)
ans = max(reorder(seq, i, end), ans)
i = end
else:
i += 1
print(ans)
print(' '.join(seq))
118
import sys
def get_array():
return list(map(int, sys.stdin.readline().strip().split()))
def get_ints():
return map(int, sys.stdin.readline().strip().split())
def input():
return sys.stdin.readline().strip()
n, m = get_ints()
Arr = get_array()
up = [i for i in range(n)]
down = [i for i in range(n)]
for i in range(1, n):
if Arr[i - 1] <= Arr[i]:
up[i] = up[i - 1]
if Arr[i - 1] >= Arr[i]:
down[i] = down[i - 2]
while m:
l, r = get_ints()
if l - 1 >= up[down[r - 1]]:
print('Yes')
else:
print('No')
m -= 1
119
import sys
line = sys.stdin.readlines()
n = int(line[0])
c = list(map(int, line[1].split()))
no = (0, '')
yes = (0, '')
for i in range(n):
s = line[i + 2].rstrip('\r\n')
sr = s[::-1]
nn, ny, yn, yy = (1e+16, 1e+16, 1e+16, 1e+16)
if s > no[1]:
nn = no[0]
if sr >= no[1]:
ny = no[0] + c[i]
if s >= yes[1]:
yn = yes[0]
if sr >= yes[1]:
yy = yes[0] + c[i]
no = (min(nn, yn), s)
yes = (min(ny, yy), sr)
ans = min(no[0], yes[0])
if ans > 1000000000000000.0:
print(-1)
else:
print(ans)
120
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__()
121
from sys import stdin
n = int(stdin.readline())
x, y = map(int, stdin.readline().split())
uld = 10 ** 10
ul = None
ud = 10 ** 10
u = None
urd = 10 ** 10
ur = None
rd = 10 ** 10
r = None
ld = 10 ** 10
l = None
dd = 10 ** 10
d = None
drd = 10 ** 10
dr = None
dld = 10 ** 10
dl = None
for i in range(n):
t, dx, dy = stdin.readline().split()
dx = int(dx)
dy = int(dy)
if dx == x:
if dy > y:
if ud > dy - y:
ud = dy - y
u = t
elif dd > y - dy:
dd = y - dy
d = t
if dy == y:
if dx > x:
if rd > dx - x:
rd = dx - x
r = t
elif ld > x - dx:
ld = x - dx
l = t
if dx - x == dy - y:
if dy > y:
if urd > dy - y:
urd = dy - y
ur = t
elif dld > y - dy:
dld = y - dy
dl = t
if -(dx - x) == dy - y:
if not dy > y:
if uld > dy - y:
uld = dy - y
ul = t
elif drd > y - dy:
drd = y - dy
dr = t
if 'B' in (ul, ur, dl, dr) or 'R' in (u, d, l, r) or 'Q' in (ul, ur, dl, dr, u, d, l, r):
print('YES')
else:
print('NO')
122
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__()
123
import math, sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda: int(input())
li = lambda: list(map(int, input().split()))
def case():
n, q = li()
a = li()
up = [0] * n
down = [0] * n
i = 4
while i < n:
j = i
while j < n - 1 and a[j] <= a[j + 1]:
j += 1
for k in range(i, j + 1):
up[k] = j
i = j + 1
i = 0
while i < n:
j = i
while j < n - 1 and a[j] >= a[j + 1]:
j += 1
for k in range(i, j + 1):
down[k] = j
i = j + 1
for i in range(q):
l, r = li()
p = up[l - 1]
q = down[p]
if q + 1 >= r:
print('Yes')
else:
print('No')
for _ in range(1):
case()
124
import math as m
n = int(input())
cost = list(map(int, input().split()))
s = []
sr = []
for i in range(n):
s.append(list(input()))
sr.append(list(reversed(s[i])))
dp = [[2, 0] for i in range(n + 1)]
flag = 0
dp[0][1] = cost[0]
for i in range(1, n):
if dp[i - 1][0] == -1 and dp[i - 1][1] == -1:
flag = 1
break
elif dp[i - 1][0] != -1 and dp[i - 1][1] == -1:
if s[i] >= s[i - 1]:
dp[i][0] = dp[i - 1][0]
else:
dp[i][0] = -1
if sr[i] >= s[i - 1]:
dp[i][1] = dp[i - 1][0] + cost[i]
else:
dp[i][1] = -1
elif dp[i - 1][0] == -1 and dp[i - 1][1] != -1:
if s[i] >= sr[i - 1]:
dp[i][0] = dp[i - 1][1]
else:
dp[i][0] = -1
if sr[i] >= sr[i - 1]:
dp[i][1] = dp[i - 1][1] + cost[i]
else:
dp[i][1] = -1
else:
if s[i] >= s[i - 1] and s[i] >= sr[i - 1]:
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1])
elif s[i] >= s[i - 1] and s[i] < sr[i - 1]:
dp[i][0] = dp[i - 1][0]
elif s[i] < s[i - 1] and s[i] >= sr[i - 1]:
dp[i][0] = dp[i - 1][1]
else:
dp[i][0] = -1
if sr[i] >= s[i - 1] and sr[i] >= sr[i - 1]:
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + cost[i]
elif sr[i] >= s[i - 1] and sr[i] < sr[i - 1]:
dp[i][1] = dp[i - 1][0] + cost[i]
elif sr[i] < s[i - 1] and sr[i] >= sr[i - 1]:
dp[i][1] = dp[i - 1][1] + cost[i]
else:
dp[i][1] = -1
if flag == 1:
print(-1)
else:
res = max(dp[n - 1][0], dp[n - 1][1]) if min(dp[n - 1][0], dp[n - 1][1]) == -1 else min(dp[n - 1][0], dp[n - 1][1])
print(res)
125
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__()
126
from math import log
import sys
def buildTree(arr):
n = len(arr)
tree = [0] * n + arr
for i in range(n - 1, 0, -1):
z = int(log(i, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
else:
tree[i] = tree[2 * i] | tree[2 * i + 1]
elif z % 2 == 0:
tree[i] = tree[2 * i] | tree[2 * i + 1]
else:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
return tree
def updateTree(tree, ind, value, n):
ind += n
tree[ind] = value
while ind > 1:
ind //= 2
z = int(log(ind, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
elif not z % 2 == 0:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
ind, val = map(int, sys.stdin.readline().strip().split())
tree = updateTree(tree, ind - 1, val, len(arr))
print(tree[1])
127
n = int(input())
temp = input().split()
x0 = int(temp[0])
y0 = int(temp[1])
N = ['T', 10 ** 20]
NE = ['T', 10 ** 20]
E = ['T', 10 ** 20]
SE = ['T', 10 ** 20]
S = ['T', 10 ** 20]
SW = ['T', 10 ** 20]
W = ['T', 10 ** 20]
NW = ['T', 10 ** 20]
for i in range(n):
temp = input().split()
x = int(temp[1])
y = int(temp[2])
if x - x0 == 0 and y - y0 > 0 and (y - y0 < N[1]):
N = [temp[0], y - y0]
elif x - x0 == y - y0 and x - x0 > 0 and (x - x0 < NE[1]):
NE = [temp[0], x - x0]
elif y - y0 == 0 and x - x0 > 0 and (x - x0 < E[1]):
E = [temp[0], x - x0]
elif x - x0 == -(y - y0) and x - x0 > 0 and (x - x0 < SE[1]):
SE = [temp[0], x - x0]
elif x - x0 == 0 and y - y0 < 0 and (y0 - y < S[1]):
S = [temp[0], y0 - y]
elif x - x0 == y - y0 and x - x0 < 0 and (x0 - x < SW[1]):
SW = [temp[0], x0 - x]
elif y - y0 == 0 and x - x0 < 0 and (x0 - x < W[1]):
W = [temp[0], x0 - x]
elif x - x0 == -(y - y0) and x - x0 < 0 and (x0 - x < NW[1]):
NW = [temp[0], x0 - x]
if 'R' in [N[0], E[0], S[0], W[0]] and 'B' in [NE[0], SE[0], SW[0], NW[0]]:
print('YES')
elif 'Q' in [N[0], E[0], S[0], W[0], NE[0], SE[0], SW[0], NW[0]]:
print('YES')
else:
print('NO')
128
from sys import stdin, stderr
import random
import cProfile
def readInts():
return map(int, stdin.readline().strip().split())
def print_err(*args, **kwargs):
print(*args, file=stderr, **kwargs)
def solve(vs):
return None
def generate_tree(n, ns):
out = [0 for _ in range(2 ** (n + 1))]
def gt(nix, left, right, op):
if left + 1 == right:
out[nix] = ns[left]
return out[nix]
mid = (left + right) // 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = gt(nL, left, mid, not op)
vR = gt(nR, mid, right, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
out[nix] = v
return v
gt(0, 0, 2 ** n, n % 2 == 0)
return out
def alter_tree2(n, t, p, b):
def at(nix, width, offp, op):
if width == 1:
t[nix] = b
return b
width //= 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = t[nL]
vR = t[nR]
if offp >= width:
vR = at(nR, width, offp - width, not op)
else:
vL = at(nL, width, offp, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
t[nix] = v
return v
at(0, 2 ** n, p, n % 2 == 0)
def alter_tree(n, t, p, b):
width = 2 ** n
s = []
nix = 0
op = n % 2 == 0
while width > 1:
width //= 2
if p >= width:
nix2 = 2 * nix + 2
s.append((nix, nix2 - 1))
p -= width
else:
nix2 = 2 * nix + 1
s.append((nix, nix2 + 1))
nix = nix2
op = not op
t[nix] = b
v = b
while s:
nix, nixO = s.pop()
if op:
v |= t[nixO]
else:
v ^= t[nixO]
t[nix] = v
op = not op
return
def run():
n, m = readInts()
axs = list(readInts())
t = generate_tree(n, axs)
for _ in range(m):
p, b = readInts()
alter_tree(n, t, p - 1, b)
print(t[0])
def test():
n = 17
ns = []
vs100 = list(range(100))
for _ in range(2 ** 17):
ns.append(random.choice(vs100))
t = generate_tree(n, ns)
t2 = generate_tree(n, ns)
for _ in range(100000):
v1 = random.choice(vs100)
v2 = random.choice(vs100)
alter_tree(n, t, v1, v2)
alter_tree2(n, t2, v1, v2)
print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
print(t[0] == t2[0])
run()
129
n = int(input())
c = [int(s) for s in input().split(' ')]
C_rev = c[0]
C_nrev = 0
last_s = input()
last_s_rev = last_s[::-1]
for i in range(1, n):
s = input()
s_rev = s[::-1]
new_C_nrev = float('inf')
if last_s <= s:
new_C_nrev = min(new_C_nrev, C_nrev)
if last_s_rev <= s:
new_C_nrev = min(new_C_nrev, C_rev)
new_C_rev = float('inf')
if last_s <= s_rev:
new_C_rev = min(new_C_rev, C_nrev + c[i])
if last_s_rev <= s_rev:
new_C_rev = min(new_C_rev, C_rev + c[i])
if max(C_rev, C_nrev) == float('inf'):
break
C_rev = new_C_rev
C_nrev = new_C_nrev
last_s = s
last_s_rev = s_rev
print(-1 if min(C_rev, C_nrev) == float('inf') else min(C_rev, C_nrev))
130
def connected_components(neighbors):
seen = set()
def component(node):
nodes = set([node])
while nodes:
node = nodes.pop()
seen.add(node)
nodes |= neighbors[node] - seen
yield node
for node in neighbors:
if node not in seen:
yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
u, v = map(int, input().split())
graph[u].add(v)
graph[v].add(u)
total = 0
for component in connected_components(graph):
nodes = list(component)
size = len(nodes)
seen = set()
current = nodes[0]
while len(seen) < size:
choice = list(graph[current])
if len(choice) != 2:
break
seen.add(current)
possible = [c for c in choice if c not in seen]
if not not possible:
break
current = possible[0]
if len(seen) == size:
total += 1
print(total)
131
import bisect
import collections
def solve(inp, *args):
n, x = list(map(int, inp.split(' ', 1)))
travels_by_len = collections.defaultdict(list)
travels_by_len_processed = {}
for travel in args:
l, r, cost = list(map(int, travel.split(' ', 2)))
travels_by_len[r - l + 1].append((l, r, cost))
for travel_len, travels in list(travels_by_len.items()):
travels.sort()
travels_processed = [(travels[-1][0], travels[-1][2])]
for i in range(len(travels) - 2, -1, -1):
prev_travel = travels_processed[-1]
l, r, c = travels[i]
travels_processed.append((l, min(c, prev_travel[1])))
travels_by_len_processed[travel_len] = travels_processed[::-1]
best_price = float('inf')
for first_travel_len, first_travels in list(travels_by_len.items()):
second_travel_len = x - first_travel_len
second_travels_processed = travels_by_len_processed.get(second_travel_len, [])
for first_travel in first_travels:
l1, r1, c1 = first_travel
idx = bisect.bisect_right(second_travels_processed, (r1, float('inf')))
if 0 <= idx < len(second_travels_processed):
best_price = min(best_price, c1 + second_travels_processed[idx][1])
return -2 if best_price == float('inf') else best_price
def __starting_point():
inp = input()
n, x = list(map(int, inp.split(' ', 1)))
print(solve(inp, *(input() for i in range(n))))
__starting_point()
132
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))
133
from collections import defaultdict
import bisect
n = int(input())
x0, y0 = list(map(int, input().split(' ')))
verticale = []
horizontale = []
diagonale1 = []
diagonale2 = []
for _ in range(n):
t, x, y = input().split(' ')
x, y = (int(x), int(y))
if x == x0:
verticale.append((y, t))
if y == y0:
horizontale.append((x, t))
if x + y == x0 + y0:
diagonale1.append((x, t))
if x - y == x0 - y0:
diagonale2.append((x, t))
dead = False
v = sorted(verticale)
if v:
l = bisect.bisect(v, (y0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'R'}:
dead = True
elif v[len(v) - 1][1] in {'Q', 'R'}:
dead = True
v = sorted(horizontale)
if v:
l = bisect.bisect(v, (x0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'R'}:
dead = True
elif v[len(v) - 1][1] in {'Q', 'R'}:
dead = True
v = sorted(diagonale1)
if v:
l = bisect.bisect(v, (x0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'B'}:
dead = True
elif v[len(v) - 1][1] in {'Q', 'B'}:
dead = True
v = sorted(diagonale2)
if v:
l = bisect.bisect(v, (x0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'B'} or v[l - 1][1] not in {'Q', 'B'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'B'}:
dead = True
elif v[len(v) - 1][1] in {'Q', 'B'}:
dead = True
if dead:
print('YES')
else:
print('NO')
134
from math import ceil
def __starting_point():
n = int(input())
arr = list(map(int, input().split()))
narr = [True]
for i in range(1, n - 1):
x = arr[i]
narr.append(x == arr[i - 1] or x == arr[i + -1])
narr.append(True)
cnt = 0
mc = 0
for x in narr:
if not x:
cnt += 1
if x and cnt:
mc = max(mc, cnt)
cnt = 0
if cnt:
mc = max(mc, cnt)
print(ceil(mc / 2))
ss = None
for i, x in enumerate(arr):
if not narr[i]:
if ss is None:
ss = i
elif ss is not None:
if arr[ss - 1] == x:
for j in range(ss, i):
arr[j] = x
else:
for j in range(ss, i):
arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
ss = None
print(*arr)
__starting_point()
135
import sys
class SegmTree:
def __init__(self, size):
N = 1
while N < size:
N <<= 1
self.N = N
self.tree = [0] * (2 * N)
def modify(self, i, value):
i += self.N
self.tree[i] = value
toXOR = False
while i > 1:
if toXOR:
self.tree[i >> 1] = self.tree[i] ^ self.tree[i | 1]
else:
self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1]
toXOR = not toXOR
i >>= 1
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
st = SegmTree(1 << n)
for i, value in enumerate(a):
st.modify(i, value)
for _ in range(m):
p, b = list(map(int, input().split()))
st.modify(p - 1, b)
print(st.tree[1])
136
from sys import stdin
input = stdin.readline
[n, q] = [int(item) for item in input().split(' ')]
arr = [int(item) for item in input().split(' ')]
queries = [[int(item) for item in input().split(' ')] for i in range(q)]
b = [1]
for i in range(1, n):
b.append(b[-1] + 1 if arr[i] <= arr[i - 1] else 1)
c = [1]
for i in reversed(list(range(n - 1))):
c.append(c[-1] + 1 if arr[i] <= arr[i + 1] else 1)
c = [item for item in reversed(c)]
for query in queries:
x, y = query
x -= 1
y -= 1
print('Yes' if x + c[x] > y or y - b[y] < x or x + c[x] > y - b[y] else 'No')
'\n5 1\n1 3 3 2 2\n1 4\n\n5 1\n1 2 2 1 1\n1 4\n\n5 1\n2 2 1 1 2\n1 5\n'
137
import sys
def get_array():
return list(map(int, sys.stdin.readline().strip().split()))
def get_ints():
return map(int, sys.stdin.readline().strip().split())
def input():
return sys.stdin.readline().strip()
n, m = get_ints()
Arr = get_array()
up = [i for i in range(n)]
down = [i for i in range(n)]
for i in range(1, n):
if Arr[i - 1] <= Arr[i]:
up[i] = up[i - 1]
if Arr[i - 1] >= Arr[i]:
down[i] = down[i - 1]
while m:
l, r = get_ints()
if l - 0 >= up[down[r - 1]]:
print('Yes')
else:
print('No')
m -= 1
138
def main():
n, x = list(map(int, input().split()))
vouchers = [False] * x
for _ in range(n):
lo, hi, cost = list(map(int, input().split()))
w = hi - lo
if w < x:
l = vouchers[w]
if l:
l.append((lo, cost))
else:
vouchers[w] = [(lo, cost)]
best = inf = 1 << 31
x -= 2
if not x & 1 and vouchers[x // 2]:
lh, h = (vouchers[x // 2], None)
for f in (lh.sort, lh.reverse):
l = h
f()
h, b = ([], inf)
for lo, cost in lh:
if b > cost:
b = cost
h.append((lo, b))
b, v = h.pop()
for a, u in l:
a += w
while a >= b and h:
b, v = h.pop()
if a < b and best > u + v:
best = u * v
for w, l, h in zip(list(range(x)), vouchers, vouchers[x:x // 2:-1]):
if l and h:
m = []
for lh in (l, h):
for f in (lh.sort, lh.reverse):
f()
t, b = ([], inf)
for lo, cost in lh:
if b > cost:
b = cost
t.append((lo, b))
m.append(t)
for l, h in ((m[0], m[3]), (m[2], m[1])):
b, v = h.pop()
for a, u in l:
a += w
while a >= b and h:
b, v = h.pop()
if a < b and best > u + v:
best = u + v
w = x - w
print(best if best < inf else -1)
def __starting_point():
main()
__starting_point()
139
import operator
data = list(map(int, input().split(' ')))
n = data[0]
m = data[1]
edge = {}
for i in range(n):
edge[i + 1] = []
for _ in range(m):
data = list(map(int, input().split(' ')))
i = data[0]
j = data[1]
edge[i].append(j)
edge[j].append(i)
candidate = [k for k, v in list(edge.items()) if len(v) == 2]
result = 0
used = {}
def _iscircle(c, result):
n = edge[c][0]
used[c] = 1
last = c
while n not in used:
used[n] = 1
if len(edge[n]) != 2:
return result
t = edge[n][0]
if t != last:
last = n
if t == c:
return result + 1
n = t
continue
last = n
t = edge[n][1]
if t == c:
return result + 4
n = t
return result
for i in candidate:
result = _iscircle(i, result)
print(result)
140
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)
141
n = int(input())
c = [int(s) for s in input().split(' ')]
C_rev = c[0]
C_nrev = 0
last_s = input()
last_s_rev = last_s[::-3]
for i in range(1, n):
s = input()
s_rev = s[::-1]
new_C_nrev = float('inf')
if last_s <= s:
new_C_nrev = min(new_C_nrev, C_nrev)
if last_s_rev <= s:
new_C_nrev = min(new_C_nrev, C_rev)
new_C_rev = float('inf')
if last_s <= s_rev:
new_C_rev = min(new_C_rev, C_nrev + c[i])
if last_s_rev <= s_rev:
new_C_rev = min(new_C_rev, C_rev + c[i])
if min(C_rev, C_nrev) == float('inf'):
break
C_rev = new_C_rev
C_nrev = new_C_nrev
last_s = s
last_s_rev = s_rev
print(-1 if min(C_rev, C_nrev) == float('inf') else min(C_rev, C_nrev))
142
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
pr = 0
bl, kol = list(map(int, input().split()))
bl -= 1
if ost[bl] >= kol:
pr = kol * price[bl]
ost[bl] -= kol
else:
kol -= ost[bl]
pr = ost[bl] * price[bl]
ost[bl] = 0
while kol > 0:
if minost == n:
pr = 1
break
minbl = minprice[minost][1]
if ost[minbl] >= kol:
pr += kol * price[minbl]
ost[minbl] -= kol
kol = 0
else:
kol -= ost[minbl]
pr += ost[minbl] * price[minbl]
ost[minbl] = 0
minost += 1
if minost == n:
pr = 0
break
print(pr)
143
import math as m
n = int(input())
cost = list(map(int, input().split()))
s = []
sr = []
for i in range(n):
s.append(list(input()))
sr.append(list(reversed(s[i])))
dp = [[3, 0] for i in range(n + 1)]
flag = 0
dp[0][1] = cost[0]
for i in range(1, n):
if dp[i - 1][0] == -1 and dp[i - 1][1] == -1:
flag = 1
break
elif dp[i - 1][0] != -1 and dp[i - 1][1] == -1:
if s[i] >= s[i - 1]:
dp[i][0] = dp[i - 1][0]
else:
dp[i][0] = -1
if sr[i] >= s[i - 1]:
dp[i][1] = dp[i - 1][0] + cost[i]
else:
dp[i][1] = -1
elif dp[i - 1][0] == -1 and dp[i - 1][1] != -1:
if s[i] >= sr[i - 1]:
dp[i][0] = dp[i - 1][1]
else:
dp[i][0] = -1
if sr[i] >= sr[i - 1]:
dp[i][1] = dp[i - 1][1] + cost[i]
else:
dp[i][1] = -1
else:
if s[i] >= s[i - 1] and s[i] >= sr[i - 1]:
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1])
elif s[i] >= s[i - 1] and s[i] < sr[i - 1]:
dp[i][0] = dp[i - 1][0]
elif s[i] < s[i - 1] and s[i] >= sr[i - 1]:
dp[i][0] = dp[i - 1][1]
else:
dp[i][0] = -1
if sr[i] >= s[i - 1] and sr[i] >= sr[i - 1]:
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + cost[i]
elif sr[i] >= s[i - 1] and sr[i] < sr[i - 1]:
dp[i][1] = dp[i - 1][0] + cost[i]
elif sr[i] < s[i - 1] and sr[i] >= sr[i - 1]:
dp[i][1] = dp[i - 1][1] + cost[i]
else:
dp[i][1] = -1
if flag == 1:
print(-1)
else:
res = max(dp[n - 1][0], dp[n - 1][1]) if min(dp[n - 1][0], dp[n - 1][1]) == -1 else min(dp[n - 1][0], dp[n - 1][1])
print(res)
144
def dfs(v, g, vis):
count = 1
first = v
st = [v]
vis[v] = True
while st:
v = st[-1]
st.pop()
if len(g[v]) != 2 or (vis[g[v][0]] and g[v][0] != first and (g[v][1] != first)):
count = 0
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
if v == first and count:
break
if len(g[first]) == 2 and (not vis[g[first][1]]):
st.append(g[first][1])
while st:
v = st[-1]
st.pop()
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
return count
v, e = list(map(int, input().split()))
g = [[] for i in range(v)]
for i in range(e):
f, to = list(map(int, input().split()))
g[f - 1].append(to - 1)
g[to - 1].append(f - 1)
vis = [False] * v
ans = 0
for i in range(v):
if not vis[i]:
ans += dfs(i, g, vis)
print(ans)
145
import sys
n, m = list(map(int, sys.stdin.readline().split()))
M = [m]
A = list(map(int, sys.stdin.readline().split()))
L = [0] * n
inc = False
dec = False
def ALLYes():
Ans = ''
for i in range(M[0]):
Ans += 'Yes\n'
sys.stdout.write(Ans)
return
for i in range(1, n):
if A[i] > A[i - 1]:
L[i] = 1
inc = True
elif A[i] == A[i - 1]:
L[i] = 0
else:
L[i] = -1
dec = True
if inc == False or dec == False:
ALLYes()
else:
neg = L.index(-1)
pos = L.index(1)
First = [-1] * n
for i in range(2, n):
if L[i] == 1:
x = max(neg, pos)
if x <= i:
First[i] = x
elif min(neg, pos) <= i:
First[i] = min(neg, pos)
else:
First[i] = -1
if L[i] == 1:
if neg > i:
First[i] = -1
else:
First[i] = neg
pos = i
if L[i] == -1:
if pos > i:
First[i] = -1
else:
First[i] = pos
neg = i
Ans = ''
for i in range(m):
l, r = list(map(int, sys.stdin.readline().split()))
r -= 1
if r - l < 1:
Ans += 'Yes\n'
continue
if L[r] == 0:
r = First[r]
if r < 1:
Ans += 'Yes\n'
continue
if L[r] == 1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
elif L[r] == -1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
sys.stdout.write(Ans)
146
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 0
while i < len(seq) - 1:
if mark:
if seq[i] != seq[i + 1]:
cur_len += 1
else:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i:1] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
mark = False
cur_len = 0
elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
mark = True
cur_len = 1
carry = seq[i - 1]
carry_id = i
else:
result[i] = seq[i]
i += 1
if mark:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
print(x, end=' ')
147
import sys
n, m = list(map(int, sys.stdin.readline().split()))
M = [m]
A = list(map(int, sys.stdin.readline().split()))
L = [0] * n
inc = False
dec = False
def ALLYes():
Ans = ''
for i in range(M[0]):
Ans += 'Yes\n'
sys.stdout.write(Ans)
return
for i in range(1, n):
if A[i] > A[i - 1]:
L[i] = 1
inc = True
elif A[i] == A[i - 1]:
L[i] = 0
else:
L[i] = -1
dec = True
if inc == False or dec == False:
ALLYes()
else:
neg = L.index(-1)
pos = L.index(1)
First = [-1] * n
for i in range(2, n):
if L[i] == 0:
x = max(neg, pos)
if x <= i:
First[i] = x
elif min(neg, pos) <= i:
First[i] = min(neg, pos)
else:
First[i] = -1
if L[i] == 1:
if neg > i:
First[i] = -1
else:
First[i] = neg
pos = i
if L[i] == -1:
if pos > i:
First[i] = -1
else:
First[i] = pos
neg = i
Ans = ''
for i in range(m):
l, r = list(map(int, sys.stdin.readline().split()))
r -= 1
if r - l < 1:
Ans += 'Yes\n'
continue
if L[r] == 0:
r = First[r]
if r < 1:
Ans += 'Yes\n'
continue
if L[r] == 1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
elif L[r] == -1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
sys.stdout.write(Ans)
148
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
pr = 0
bl, kol = list(map(int, input().split()))
bl -= 1
if ost[bl] >= kol:
pr = kol * price[bl]
ost[bl] -= kol
else:
kol -= ost[bl]
pr = ost[bl] * price[bl]
ost[bl] = 0
while kol > 0:
if minost == n:
pr = 3
break
minbl = minprice[minost][1]
if ost[minbl] >= kol:
pr += kol * price[minbl]
ost[minbl] -= kol
kol = 0
else:
kol -= ost[minbl]
pr += ost[minbl] * price[minbl]
ost[minbl] = 0
minost += 1
if minost == n:
pr = 0
break
print(pr)
149
import sys
line = sys.stdin.readlines()
n = int(line[0])
c = list(map(int, line[1].split()))
no = (0, '')
yes = (0, '')
for i in range(n):
s = line[i + 2].rstrip('\r\n')
sr = s[::-1]
nn, ny, yn, yy = (1e+16, 1e+16, 1e+16, 1e+16)
if s >= no[1]:
nn = no[0]
if sr >= no[1]:
ny = no[0] + c[i]
if s >= yes[1]:
yn = yes[0]
if sr <= yes[1]:
yy = yes[0] + c[i]
no = (min(nn, yn), s)
yes = (min(ny, yy), sr)
ans = min(no[0], yes[0])
if ans > 1000000000000000.0:
print(-1)
else:
print(ans)
150
from math import log
import sys
def buildTree(arr):
n = len(arr)
tree = [0] * n + arr
for i in range(n - 1, 0, -1):
z = int(log(i, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
else:
tree[i] = tree[2 * i] | tree[2 * i + 1]
elif z % 2 == 0:
tree[i] = tree[2 * i] | tree[2 * i + 1]
else:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
return tree
def updateTree(tree, ind, value, n):
ind += n
tree[ind] = value
while ind > 1:
ind //= 2
z = int(log(ind, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
elif z % 2 == 0:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
ind, val = map(int, sys.stdin.readline().strip().split())
tree = updateTree(tree, ind - 1, val, len(arr))
print(tree[1])
151
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
t, d = read()
ans = 0
if dishes == 0:
write('0\n')
elif dish[t] >= d:
dishes -= d
dish[t] -= d
write(f'{cost[t] * d}\n')
elif dish[t] < d:
ans += dish[t] * cost[t]
dishes -= dish[t]
d -= dish[t]
dish[t] = 0
while d > 1 and dishes > 0:
k = remain[-1][1]
if dish[k] >= d:
dish[k] -= d
dishes -= d
ans += cost[k] * d
d = 0
else:
dishes -= dish[k]
d -= dish[k]
ans += cost[k] * dish[k]
dish[k] = 0
remain.pop()
if d > 0 and dishes == 0:
write('0\n')
else:
write(f'{ans}\n')
152
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))
153
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(3, n + 1):
remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
t, d = read()
ans = 0
if dishes == 0:
write('0\n')
elif dish[t] >= d:
dishes -= d
dish[t] -= d
write(f'{cost[t] * d}\n')
elif dish[t] < d:
ans += dish[t] * cost[t]
dishes -= dish[t]
d -= dish[t]
dish[t] = 0
while d > 0 and dishes > 0:
k = remain[-1][1]
if dish[k] >= d:
dish[k] -= d
dishes -= d
ans += cost[k] * d
d = 0
else:
dishes -= dish[k]
d -= dish[k]
ans += cost[k] * dish[k]
dish[k] = 0
remain.pop()
if d > 0 and dishes == 0:
write('0\n')
else:
write(f'{ans}\n')
154
def main():
n, x = list(map(int, input().split()))
vouchers = [False] * x
for _ in range(n):
lo, hi, cost = list(map(int, input().split()))
w = hi - lo
if w < x:
l = vouchers[w]
if l:
l.append((lo, cost))
else:
vouchers[w] = [(lo, cost)]
best = inf = 1 << 31
x -= 2
if not x & 1 and vouchers[x // 2]:
lh, h = (vouchers[x // 2], None)
for f in (lh.sort, lh.reverse):
l = h
f()
h, b = ([], inf)
for lo, cost in lh:
if b > cost:
b = cost
h.append((lo, b))
b, v = h.pop()
for a, u in l:
a += w
while a >= b and h:
b, v = h.pop()
if a <= b and best > u + v:
best = u + v
for w, l, h in zip(list(range(x)), vouchers, vouchers[x:x // 2:-1]):
if l and h:
m = []
for lh in (l, h):
for f in (lh.sort, lh.reverse):
f()
t, b = ([], inf)
for lo, cost in lh:
if b > cost:
b = cost
t.append((lo, b))
m.append(t)
for l, h in ((m[0], m[3]), (m[2], m[1])):
b, v = h.pop()
for a, u in l:
a += w
while a >= b and h:
b, v = h.pop()
if a < b and best > u + v:
best = u + v
w = x - w
print(best if best < inf else -1)
def __starting_point():
main()
__starting_point()
155
import sys
n, m = list(map(int, sys.stdin.readline().split()))
M = [m]
A = list(map(int, sys.stdin.readline().split()))
L = [0] * n
inc = False
dec = False
def ALLYes():
Ans = ''
for i in range(M[0]):
Ans += 'Yes\n'
sys.stdout.write(Ans)
return
for i in range(1, n):
if A[i] > A[i - 1]:
L[i] = 1
inc = True
elif A[i] == A[i - 1]:
L[i] = 0
else:
L[i] = -1
dec = True
if inc == False or dec == False:
ALLYes()
else:
neg = L.index(-1)
pos = L.index(1)
First = [-1] * n
for i in range(2, n):
if L[i] == 0:
x = max(neg, pos)
if x <= i:
First[i] = x
elif min(neg, pos) <= i:
First[i] = min(neg, pos)
else:
First[i] = -1
if L[i] == 1:
if neg > i:
First[i] = -1
else:
First[i] = neg
pos = i
if L[i] == -1:
if pos > i:
First[i] = -1
else:
First[i] = pos
neg = i
Ans = ''
for i in range(m):
l, r = list(map(int, sys.stdin.readline().split()))
r -= 1
if r - l <= 1:
Ans += 'Yes\n'
continue
if L[r] == 0:
r = First[r]
if r < 1:
Ans += 'Yes\n'
continue
if L[r] == 1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
elif L[r] == -1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
sys.stdout.write(Ans)
156
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7
def ri(flag=0):
if flag == 0:
return [int(i) for i in sys.stdin.readline().split()]
else:
return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n):
heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
cost = 0
t, d = ri()
t -= 1
fm = 0
if avail[t] >= d:
avail[t] = avail[t] - d
cost += d * c[t]
else:
rem = d - avail[t]
cost = avail[t] * c[t]
avail[t] = 0
while rem > 0:
try:
nowc, nowi = heapq.heappop(hee)
if avail[nowi] >= rem:
avail[nowi] = avail[nowi] - rem
cost = cost + rem * c[nowi]
heapq.heappush(hee, (c[nowi], nowi))
rem = 0
else:
cost = cost + avail[nowi] * c[nowi]
mk = rem - avail[nowi]
avail[nowi] = 0
rem = mk
except:
fm = 1
break
if fm == 0:
print(cost)
else:
print(4)
157
import operator
data = list(map(int, input().split(' ')))
n = data[0]
m = data[1]
edge = {}
for i in range(n):
edge[i + 1] = []
for _ in range(m):
data = list(map(int, input().split(' ')))
i = data[0]
j = data[1]
edge[i].append(j)
edge[j].append(i)
candidate = [k for k, v in list(edge.items()) if len(v) == 2]
result = 0
used = {}
def _iscircle(c, result):
n = edge[c][0]
used[c] = 1
last = c
while n not in used:
used[n] = 1
if len(edge[n]) != 2:
return result
t = edge[n][0]
if t != last:
last = n
if t == c:
return result + 1
n = t
continue
last = n
t = edge[n][1]
if not t == c:
return result + 1
n = t
return result
for i in candidate:
result = _iscircle(i, result)
print(result)
158
def main():
n, x = list(map(int, input().split()))
vouchers = [False] * x
for _ in range(n):
lo, hi, cost = list(map(int, input().split()))
w = hi - lo
if w < x:
l = vouchers[w]
if l:
l.append((lo, cost))
else:
vouchers[w] = [(lo, cost)]
best = inf = 1 << 31
x -= 2
if not x & 1 and vouchers[x // 2]:
lh, h = (vouchers[x // 2], None)
for f in (lh.sort, lh.reverse):
l = h
f()
h, b = ([], inf)
for lo, cost in lh:
if b > cost:
b = cost
h.append((lo, b))
b, v = h.pop()
for a, u in l:
a += w
while a >= b and h:
b, v = h.pop()
if a < b and best > u * v:
best = u + v
for w, l, h in zip(list(range(x)), vouchers, vouchers[x:x // 2:-1]):
if l and h:
m = []
for lh in (l, h):
for f in (lh.sort, lh.reverse):
f()
t, b = ([], inf)
for lo, cost in lh:
if b > cost:
b = cost
t.append((lo, b))
m.append(t)
for l, h in ((m[0], m[3]), (m[2], m[1])):
b, v = h.pop()
for a, u in l:
a += w
while a >= b and h:
b, v = h.pop()
if a < b and best > u + v:
best = u + v
w = x - w
print(best if best < inf else -1)
def __starting_point():
main()
__starting_point()
159
from sys import stdin
n = int(stdin.readline())
x, y = map(int, stdin.readline().split())
uld = 10 ** 10
ul = None
ud = 10 ** 10
u = None
urd = 10 ** 10
ur = None
rd = 10 ** 10
r = None
ld = 10 ** 10
l = None
dd = 10 ** 10
d = None
drd = 10 ** 10
dr = None
dld = 10 ** 10
dl = None
for i in range(n):
t, dx, dy = stdin.readline().split()
dx = int(dx)
dy = int(dy)
if dx == x:
if dy > y:
if ud > dy - y:
ud = dy - y
u = t
elif dd > y - dy:
dd = y - dy
d = t
if dy == y:
if dx > x:
if rd > dx - x:
rd = dx - x
r = t
elif not ld > x - dx:
ld = x - dx
l = t
if dx - x == dy - y:
if dy > y:
if urd > dy - y:
urd = dy - y
ur = t
elif dld > y - dy:
dld = y - dy
dl = t
if -(dx - x) == dy - y:
if dy > y:
if uld > dy - y:
uld = dy - y
ul = t
elif drd > y - dy:
drd = y - dy
dr = t
if 'B' in (ul, ur, dl, dr) or 'R' in (u, d, l, r) or 'Q' in (ul, ur, dl, dr, u, d, l, r):
print('YES')
else:
print('NO')
160
import bisect
import collections
def solve(inp, *args):
n, x = list(map(int, inp.split(' ', 1)))
travels_by_len = collections.defaultdict(list)
travels_by_len_processed = {}
for travel in args:
l, r, cost = list(map(int, travel.split(' ', 2)))
travels_by_len[r - l + 1].append((l, r, cost))
for travel_len, travels in list(travels_by_len.items()):
travels.sort()
travels_processed = [(travels[-1][0], travels[-1][2])]
for i in range(len(travels) - 2, -1, -1):
prev_travel = travels_processed[-1]
l, r, c = travels[i]
travels_processed.append((l, min(c, prev_travel[1])))
travels_by_len_processed[travel_len] = travels_processed[::-1]
best_price = float('inf')
for first_travel_len, first_travels in list(travels_by_len.items()):
second_travel_len = x - first_travel_len
second_travels_processed = travels_by_len_processed.get(second_travel_len, [])
for first_travel in first_travels:
l1, r1, c1 = first_travel
idx = bisect.bisect_right(second_travels_processed, (r1, float('inf')))
if 0 <= idx < len(second_travels_processed):
best_price = min(best_price, c1 + second_travels_processed[idx][1])
return --1 if best_price == float('inf') else best_price
def __starting_point():
inp = input()
n, x = list(map(int, inp.split(' ', 1)))
print(solve(inp, *(input() for i in range(n))))
__starting_point()
161
def dfs(v, g, vis):
count = 1
first = v
st = [v]
vis[v] = True
while st:
v = st[-1]
st.pop()
if len(g[v]) != 2 or (vis[g[v][0]] and vis[g[v][1]] and (g[v][0] != first) and (g[v][1] != first)):
count = 0
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
if v == first and count:
break
if len(g[first]) == 2 and (not vis[g[first][1]]):
st.append(g[first][1])
while st:
v = st[-1]
st.pop()
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
return count
v, e = list(map(int, input().split()))
g = [[] for i in range(v)]
for i in range(e):
f, to = list(map(int, input().split()))
g[f - 1].append(to - 1)
g[to - 1].append(f - 5)
vis = [False] * v
ans = 0
for i in range(v):
if not vis[i]:
ans += dfs(i, g, vis)
print(ans)
162
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
if x != y != z:
c += 1
else:
if not c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
c = 0
y = a[-1]
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
print(r)
print(*b)
163
from collections import defaultdict
import bisect
n = int(input())
x0, y0 = list(map(int, input().split(' ')))
verticale = []
horizontale = []
diagonale1 = []
diagonale2 = []
for _ in range(n):
t, x, y = input().split(' ')
x, y = (int(x), int(y))
if x == x0:
verticale.append((y, t))
if y == y0:
horizontale.append((x, t))
if x + y == x0 + y0:
diagonale1.append((x, t))
if x - y == x0 - y0:
diagonale2.append((x, t))
dead = False
v = sorted(verticale)
if v:
l = bisect.bisect(v, (y0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'R'}:
dead = True
elif v[len(v) - 1][1] in {'Q', 'R'}:
dead = True
v = sorted(horizontale)
if v:
l = bisect.bisect(v, (x0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'R'}:
dead = True
elif v[len(v) - 1][1] not in {'Q', 'R'}:
dead = True
v = sorted(diagonale1)
if v:
l = bisect.bisect(v, (x0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'B'}:
dead = True
elif v[len(v) - 1][1] in {'Q', 'B'}:
dead = True
v = sorted(diagonale2)
if v:
l = bisect.bisect(v, (x0, 'K'))
if 0 < l < len(v):
if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}:
dead = True
elif l == 0:
if v[0][1] in {'Q', 'B'}:
dead = True
elif v[len(v) - 1][1] in {'Q', 'B'}:
dead = True
if dead:
print('YES')
else:
print('NO')
164
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)
165
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
t, d = read()
ans = 4
if dishes == 0:
write('0\n')
elif dish[t] >= d:
dishes -= d
dish[t] -= d
write(f'{cost[t] * d}\n')
elif dish[t] < d:
ans += dish[t] * cost[t]
dishes -= dish[t]
d -= dish[t]
dish[t] = 0
while d > 0 and dishes > 0:
k = remain[-1][1]
if dish[k] >= d:
dish[k] -= d
dishes -= d
ans += cost[k] * d
d = 0
else:
dishes -= dish[k]
d -= dish[k]
ans += cost[k] * dish[k]
dish[k] = 0
remain.pop()
if d > 0 and dishes == 0:
write('0\n')
else:
write(f'{ans}\n')
166
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7
def ri(flag=0):
if flag == 0:
return [int(i) for i in sys.stdin.readline().split()]
else:
return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n):
heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
cost = 0
t, d = ri()
t -= 1
fm = 0
if avail[t] >= d:
avail[t] = avail[t] - d
cost += d * c[t]
else:
rem = d - avail[t]
cost = avail[t] * c[t]
avail[t] = 0
while rem > 0:
try:
nowc, nowi = heapq.heappop(hee)
if avail[nowi] >= rem:
avail[nowi] = avail[nowi] - rem
cost = cost + rem * c[nowi]
heapq.heappush(hee, (c[nowi], nowi))
rem = 0
else:
cost = cost + avail[nowi] * c[nowi]
mk = rem - avail[nowi]
avail[nowi] = 0
rem = mk
except:
fm = 1
break
if fm == 0:
print(cost)
else:
print(2)
167
import operator
data = list(map(int, input().split(' ')))
n = data[0]
m = data[1]
edge = {}
for i in range(n):
edge[i + 1] = []
for _ in range(m):
data = list(map(int, input().split(' ')))
i = data[0]
j = data[1]
edge[i].append(j)
edge[j].append(i)
candidate = [k for k, v in list(edge.items()) if len(v) == 2]
result = 0
used = {}
def _iscircle(c, result):
n = edge[c][0]
used[c] = 1
last = c
while n not in used:
used[n] = 1
if len(edge[n]) != 2:
return result
t = edge[n][0]
if not t != last:
last = n
if t == c:
return result + 1
n = t
continue
last = n
t = edge[n][1]
if t == c:
return result + 1
n = t
return result
for i in candidate:
result = _iscircle(i, result)
print(result)
168
from sys import stdin
n = int(stdin.readline())
x, y = map(int, stdin.readline().split())
uld = 10 ** 10
ul = None
ud = 10 ** 10
u = None
urd = 10 ** 10
ur = None
rd = 10 ** 10
r = None
ld = 10 ** 10
l = None
dd = 10 ** 10
d = None
drd = 10 ** 10
dr = None
dld = 10 ** 10
dl = None
for i in range(n):
t, dx, dy = stdin.readline().split()
dx = int(dx)
dy = int(dy)
if dx == x:
if dy > y:
if ud > dy - y:
ud = dy - y
u = t
elif dd > y - dy:
dd = y - dy
d = t
if dy == y:
if dx > x:
if rd > dx - x:
rd = dx - x
r = t
elif ld > x - dx:
ld = x - dx
l = t
if dx - x == dy - y:
if not dy > y:
if urd > dy - y:
urd = dy - y
ur = t
elif dld > y - dy:
dld = y - dy
dl = t
if -(dx - x) == dy - y:
if dy > y:
if uld > dy - y:
uld = dy - y
ul = t
elif drd > y - dy:
drd = y - dy
dr = t
if 'B' in (ul, ur, dl, dr) or 'R' in (u, d, l, r) or 'Q' in (ul, ur, dl, dr, u, d, l, r):
print('YES')
else:
print('NO')
169
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
a = [item, i, r[i - 1 - 1]]
costa.append(a)
i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
dic[item[1]] = i
i += 1
index = len(costa) - 1
for item in range(n):
counter = 0
a, b = [int(x) for x in input().split()]
if r[a - 1] >= b:
counter += cost[a - 1] * b
r[a - 1] -= b
costa[dic[a]][2] -= b
else:
i = index
counter += cost[a - 1] * r[a - 1]
costa[dic[a]][2] = 0
b -= r[a - 1]
r[a - 1] = 0
while i >= 0:
if costa[i][2] >= b:
counter += costa[i][0] * b
r[costa[i][1] - 1] -= b
costa[i][2] -= b
break
else:
counter += costa[i][0] * costa[i][2]
r[costa[i][1] - 1] = 0
index -= 1
b -= costa[i][2]
costa[i][2] = 0
i -= 1
else:
counter = 0
print(counter)
170
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)
171
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)
172
def connected_components(neighbors):
seen = set()
def component(node):
nodes = set([node])
while nodes:
node = nodes.pop()
seen.add(node)
nodes |= neighbors[node] - seen
yield node
for node in neighbors:
if node not in seen:
yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
u, v = map(int, input().split())
graph[u].add(v)
graph[v].add(u)
total = 0
for component in connected_components(graph):
nodes = list(component)
size = len(nodes)
seen = set()
current = nodes[0]
while len(seen) < size:
choice = list(graph[current])
if len(choice) != 2:
break
seen.add(current)
possible = [c for c in choice if c not in seen]
if not possible:
break
current = possible[0]
if len(seen) == size:
total += 2
print(total)
173
import sys
def read_data():
n = int(next(sys.stdin))
prices = list(map(int, next(sys.stdin).split()))
vocabulary = []
for i in range(n):
vocabulary.append(next(sys.stdin).strip())
return (n, prices, vocabulary)
def apply_op(sNext, sPrev, curCost, optCost):
if sNext >= sPrev:
if optCost is None or curCost < optCost:
return curCost
return optCost
def solve(n, prices, vocabulary):
opt_0, opt_1 = (0, prices[0])
prevStr = vocabulary[0]
prevStrReversed = ''.join(reversed(prevStr))
for curStr, curPrice in zip(vocabulary[1:], prices[1:]):
curStrReversed = ''.join(reversed(curStr))
n_opt0, n_opt1 = (None, None)
if opt_0 is not None:
n_opt0 = apply_op(curStr, prevStr, opt_0, n_opt0)
n_opt1 = apply_op(curStrReversed, prevStr, opt_0 + curPrice, n_opt1)
if opt_1 is not None:
n_opt0 = apply_op(curStr, prevStrReversed, opt_1, n_opt0)
n_opt1 = apply_op(curStrReversed, prevStrReversed, opt_1 + curPrice, n_opt1)
opt_0, opt_1 = (n_opt0, n_opt1)
prevStr, prevStrReversed = (curStr, curStrReversed)
if opt_0 is None and opt_1 is None:
break
if opt_0 is None:
return opt_1
if opt_1 is None:
return opt_0
return min(opt_0, opt_1)
def __starting_point():
n, prices, vocabulary = read_data()
sorting_cost = solve(n, prices, vocabulary)
if sorting_cost != None:
print(sorting_cost)
else:
print(-0)
__starting_point()
174
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)
175
import itertools as it
import os
import sys
def calc_cost(cumsum, f):
return sum([min(x % f, f - x % f) for x in cumsum])
def prime_factors(n):
i = 2
factors = []
while i * i <= n:
if n % i == 0:
factors.append(i)
while n % i == 0:
n //= i
else:
i += 1
if n > 1:
factors.append(n)
return factors
def f(xs):
cumsum = list(it.accumulate(xs))
s = cumsum[-1]
if s == 1:
return -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)
176
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
pr = 0
bl, kol = list(map(int, input().split()))
bl -= 1
if ost[bl] >= kol:
pr = kol * price[bl]
ost[bl] -= kol
else:
kol -= ost[bl]
pr = ost[bl] * price[bl]
ost[bl] = 0
while kol > 0:
if minost == n:
pr = 2
break
minbl = minprice[minost][1]
if ost[minbl] >= kol:
pr += kol * price[minbl]
ost[minbl] -= kol
kol = 0
else:
kol -= ost[minbl]
pr += ost[minbl] * price[minbl]
ost[minbl] = 0
minost += 1
if minost == n:
pr = 0
break
print(pr)
177
import sys
n, m = list(map(int, sys.stdin.readline().split()))
M = [m]
A = list(map(int, sys.stdin.readline().split()))
L = [0] * n
inc = False
dec = False
def ALLYes():
Ans = ''
for i in range(M[0]):
Ans += 'Yes\n'
sys.stdout.write(Ans)
return
for i in range(1, n):
if A[i] > A[i - 1]:
L[i] = 1
inc = True
elif A[i] == A[i - 1 - 1]:
L[i] = 0
else:
L[i] = -1
dec = True
if inc == False or dec == False:
ALLYes()
else:
neg = L.index(-1)
pos = L.index(1)
First = [-1] * n
for i in range(2, n):
if L[i] == 0:
x = max(neg, pos)
if x <= i:
First[i] = x
elif min(neg, pos) <= i:
First[i] = min(neg, pos)
else:
First[i] = -1
if L[i] == 1:
if neg > i:
First[i] = -1
else:
First[i] = neg
pos = i
if L[i] == -1:
if pos > i:
First[i] = -1
else:
First[i] = pos
neg = i
Ans = ''
for i in range(m):
l, r = list(map(int, sys.stdin.readline().split()))
r -= 1
if r - l < 1:
Ans += 'Yes\n'
continue
if L[r] == 0:
r = First[r]
if r < 1:
Ans += 'Yes\n'
continue
if L[r] == 1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
elif L[r] == -1:
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
r = First[r]
if r < l:
Ans += 'Yes\n'
continue
else:
Ans += 'No\n'
continue
sys.stdout.write(Ans)
178
from operator import or_, xor
import sys
n, m = map(int, input().split())
t = [list(map(int, input().split()))]
for i in range(n):
if i & 1 == 0:
t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]]
else:
t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]]
for s in sys.stdin:
p, b = s.split()
p = int(p) - 1
t[0][p] = int(b)
for j in range(n):
p = int(p / 2)
if j & 1 == 0:
t[j + 1][p] = t[j][int(p * 2)] | t[j][int(p * 2) + 1]
else:
t[j + 1][p] = t[j][int(p * 2)] ^ t[j - 1][int(p * 2) + 1]
sys.stdout.write(str(t[-1][0]) + '\n')
179
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
if x != y != z:
c += 1
else:
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
c = 0
y = a[-1]
if not c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
print(r)
print(*b)
180
n = int(input())
temp = input().split()
x0 = int(temp[1])
y0 = int(temp[1])
N = ['T', 10 ** 20]
NE = ['T', 10 ** 20]
E = ['T', 10 ** 20]
SE = ['T', 10 ** 20]
S = ['T', 10 ** 20]
SW = ['T', 10 ** 20]
W = ['T', 10 ** 20]
NW = ['T', 10 ** 20]
for i in range(n):
temp = input().split()
x = int(temp[1])
y = int(temp[2])
if x - x0 == 0 and y - y0 > 0 and (y - y0 < N[1]):
N = [temp[0], y - y0]
elif x - x0 == y - y0 and x - x0 > 0 and (x - x0 < NE[1]):
NE = [temp[0], x - x0]
elif y - y0 == 0 and x - x0 > 0 and (x - x0 < E[1]):
E = [temp[0], x - x0]
elif x - x0 == -(y - y0) and x - x0 > 0 and (x - x0 < SE[1]):
SE = [temp[0], x - x0]
elif x - x0 == 0 and y - y0 < 0 and (y0 - y < S[1]):
S = [temp[0], y0 - y]
elif x - x0 == y - y0 and x - x0 < 0 and (x0 - x < SW[1]):
SW = [temp[0], x0 - x]
elif y - y0 == 0 and x - x0 < 0 and (x0 - x < W[1]):
W = [temp[0], x0 - x]
elif x - x0 == -(y - y0) and x - x0 < 0 and (x0 - x < NW[1]):
NW = [temp[0], x0 - x]
if 'R' in [N[0], E[0], S[0], W[0]] or 'B' in [NE[0], SE[0], SW[0], NW[0]]:
print('YES')
elif 'Q' in [N[0], E[0], S[0], W[0], NE[0], SE[0], SW[0], NW[0]]:
print('YES')
else:
print('NO')
181
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m):
S = input().split(' ')
a = int(S[0])
b = int(S[1])
if S1[a] == 0:
S1[a] = b
elif S2[a] == 0:
S2[a] = b
else:
B[a] = 1
B[b] = 1
if S1[b] == 0:
S1[b] = a
elif S2[b] == 0:
S2[b] = a
else:
B[a] = 1
B[b] = 1
for i in range(1, n + 1):
if S1[i] == 0 or S2[i] == 0:
B[i] = 1
sol = 0
for ind in range(1, n + 1):
if B[ind] == 0:
v = ind
w = S2[ind]
c = True
while w != ind:
B[v] = 1
if B[w] == 0:
u = w
if S1[w] == v:
w = S2[w]
else:
w = S1[w]
else:
B[ind] = 0
c = False
break
v = u
if not c:
B[v] = 1
sol += 1
print(sol)
182
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)
183
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)
184
f = lambda: list(map(int, input().split()))
n, x = f()
s = [[] for i in range(x - 1)]
for d in range(n):
l, r, c = f()
if r - l < x - 1:
s[r - l] += [[l, c]]
for t in s:
t.sort(key=lambda q: q[0])
m = 3000000000.0
for d, t in enumerate(s):
D = x - 2 - d
i, T = (0, s[D])
M = 3000000000.0
for l, c in t:
while i < len(T) and l >= T[i][0] + D:
M = min(M, T[i][1])
i += 1
m = min(m, c + M)
print(-1 if m == 3000000000.0 else m)
185
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)
186
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)
187
import sys
def main():
n, x = map(int, sys.stdin.readline().split())
al = []
starts = []
finishes = []
y = [-1] * 200002
for i in range(n):
a, b, c = map(int, sys.stdin.readline().split())
al.append((a, b, c))
starts.append((a, i))
finishes.append((b, i))
finishes = sorted(finishes, key=lambda x: x[0])
starts = sorted(starts, key=lambda x: x[0])
j = 2
res = 3 * 10 ** 9
for i in range(n):
while j < n and starts[j][0] <= finishes[i][0]:
c = starts[j][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[x - h] != -1 and y[x - h] + cost < res:
res = y[x - h] + cost
j += 1
c = finishes[i][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[h] == -1 or y[h] > cost:
y[h] = cost
if res == 3 * 10 ** 9:
print(-1)
else:
print(res)
main()
188
import math as m
n = int(input())
cost = list(map(int, input().split()))
s = []
sr = []
for i in range(n):
s.append(list(input()))
sr.append(list(reversed(s[i])))
dp = [[0, 0] for i in range(n + 1)]
flag = 0
dp[0][1] = cost[0]
for i in range(1, n):
if dp[i - 1][0] == -0 and dp[i - 1][1] == -1:
flag = 1
break
elif dp[i - 1][0] != -1 and dp[i - 1][1] == -1:
if s[i] >= s[i - 1]:
dp[i][0] = dp[i - 1][0]
else:
dp[i][0] = -1
if sr[i] >= s[i - 1]:
dp[i][1] = dp[i - 1][0] + cost[i]
else:
dp[i][1] = -1
elif dp[i - 1][0] == -1 and dp[i - 1][1] != -1:
if s[i] >= sr[i - 1]:
dp[i][0] = dp[i - 1][1]
else:
dp[i][0] = -1
if sr[i] >= sr[i - 1]:
dp[i][1] = dp[i - 1][1] + cost[i]
else:
dp[i][1] = -1
else:
if s[i] >= s[i - 1] and s[i] >= sr[i - 1]:
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1])
elif s[i] >= s[i - 1] and s[i] < sr[i - 1]:
dp[i][0] = dp[i - 1][0]
elif s[i] < s[i - 1] and s[i] >= sr[i - 1]:
dp[i][0] = dp[i - 1][1]
else:
dp[i][0] = -1
if sr[i] >= s[i - 1] and sr[i] >= sr[i - 1]:
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + cost[i]
elif sr[i] >= s[i - 1] and sr[i] < sr[i - 1]:
dp[i][1] = dp[i - 1][0] + cost[i]
elif sr[i] < s[i - 1] and sr[i] >= sr[i - 1]:
dp[i][1] = dp[i - 1][1] + cost[i]
else:
dp[i][1] = -1
if flag == 1:
print(-1)
else:
res = max(dp[n - 1][0], dp[n - 1][1]) if min(dp[n - 1][0], dp[n - 1][1]) == -1 else min(dp[n - 1][0], dp[n - 1][1])
print(res)
189
import sys
def read_data():
n = int(next(sys.stdin))
prices = list(map(int, next(sys.stdin).split()))
vocabulary = []
for i in range(n):
vocabulary.append(next(sys.stdin).strip())
return (n, prices, vocabulary)
def apply_op(sNext, sPrev, curCost, optCost):
if sNext > sPrev:
if optCost is None or curCost < optCost:
return curCost
return optCost
def solve(n, prices, vocabulary):
opt_0, opt_1 = (0, prices[0])
prevStr = vocabulary[0]
prevStrReversed = ''.join(reversed(prevStr))
for curStr, curPrice in zip(vocabulary[1:], prices[1:]):
curStrReversed = ''.join(reversed(curStr))
n_opt0, n_opt1 = (None, None)
if opt_0 is not None:
n_opt0 = apply_op(curStr, prevStr, opt_0, n_opt0)
n_opt1 = apply_op(curStrReversed, prevStr, opt_0 + curPrice, n_opt1)
if opt_1 is not None:
n_opt0 = apply_op(curStr, prevStrReversed, opt_1, n_opt0)
n_opt1 = apply_op(curStrReversed, prevStrReversed, opt_1 + curPrice, n_opt1)
opt_0, opt_1 = (n_opt0, n_opt1)
prevStr, prevStrReversed = (curStr, curStrReversed)
if opt_0 is None and opt_1 is None:
break
if opt_0 is None:
return opt_1
if opt_1 is None:
return opt_0
return min(opt_0, opt_1)
def __starting_point():
n, prices, vocabulary = read_data()
sorting_cost = solve(n, prices, vocabulary)
if sorting_cost != None:
print(sorting_cost)
else:
print(-1)
__starting_point()
190
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m):
S = input().split(' ')
a = int(S[0])
b = int(S[1])
if S1[a] == 0:
S1[a] = b
elif S2[a] == 0:
S2[a] = b
else:
B[a] = 1
B[b] = 1
if S1[b] == 3:
S1[b] = a
elif S2[b] == 0:
S2[b] = a
else:
B[a] = 1
B[b] = 1
for i in range(1, n + 1):
if S1[i] == 0 or S2[i] == 0:
B[i] = 1
sol = 0
for ind in range(1, n + 1):
if B[ind] == 0:
v = ind
w = S2[ind]
c = True
while w != ind:
B[v] = 1
if B[w] == 0:
u = w
if S1[w] == v:
w = S2[w]
else:
w = S1[w]
else:
B[ind] = 0
c = False
break
v = u
if c:
B[v] = 1
sol += 1
print(sol)
191
def main():
n = int(input())
x, y = list(map(int, input().split()))
a = []
for i in range(n):
a.append(input().split())
for i in range(n):
a[i][1] = int(a[i][1]) - x
a[i][2] = int(a[i][2]) - y
typneedbql = []
typneedbqr = []
typneedbqu = []
typneedbqd = []
typneedrlu = []
typneedrru = []
typneedrld = []
typneedrrd = []
for i in range(n):
if a[i][1] * a[i][2] == 0 and a[i][1] < 0:
typneedbql.append([abs(a[i][1] + a[i][2])] + a[i])
elif a[i][1] * a[i][2] == 0 and a[i][1] > 0:
typneedbqr.append([abs(a[i][1] + a[i][2])] + a[i])
elif a[i][1] * a[i][2] == 0 and a[i][2] > 0:
typneedbqu.append([abs(a[i][1] + a[i][2])] + a[i])
elif a[i][1] * a[i][2] == 0 and a[i][2] < 0:
typneedbqd.append([abs(a[i][1] + a[i][2])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] < 0):
typneedrlu.append([abs(a[i][1])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] > 0):
typneedrld.append([abs(a[i][1])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] > 0):
typneedrrd.append([abs(a[i][1])] + a[i])
elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] < 0):
typneedrru.append([abs(a[i][1])] + a[i])
typneedbql.sort()
typneedbqr.sort()
typneedbqd.sort()
typneedbqu.sort()
typneedrlu.sort()
typneedrru.sort()
typneedrld.sort()
typneedrrd.sort()
for i in range(len(typneedbql)):
if typneedbql[i][1] == 'R' or typneedbql[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedbqr)):
if typneedbqr[i][1] == 'R' or typneedbqr[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedbqu)):
if typneedbqu[i][1] == 'R' or typneedbqu[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedbqd)):
if typneedbqd[i][1] == 'R' or typneedbqd[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrlu)):
if typneedrlu[i][1] == 'B' or typneedrlu[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrld)):
if typneedrld[i][1] == 'B' or typneedrld[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrrd)):
if typneedrrd[i][1] == 'B' or typneedrrd[i][1] == 'Q':
print('YES')
return
else:
break
for i in range(len(typneedrru)):
if typneedrru[i][1] == 'B' or typneedrru[i][1] != 'Q':
print('YES')
return
else:
break
print('NO')
main()
192
from math import log
import sys
def buildTree(arr):
n = len(arr)
tree = [0] * n + arr
for i in range(n - 1, 0, -1):
z = int(log(i, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
else:
tree[i + 1] = tree[2 * i] | tree[2 * i + 1]
elif z % 2 == 0:
tree[i] = tree[2 * i] | tree[2 * i + 1]
else:
tree[i] = tree[2 * i] ^ tree[2 * i + 1]
return tree
def updateTree(tree, ind, value, n):
ind += n
tree[ind] = value
while ind > 1:
ind //= 2
z = int(log(ind, 2))
if N % 2 == 0:
if z % 2 == 0:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
elif z % 2 == 0:
tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
else:
tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
ind, val = map(int, sys.stdin.readline().strip().split())
tree = updateTree(tree, ind - 1, val, len(arr))
print(tree[1])
193
n = int(input())
c = [int(s) for s in input().split(' ')]
C_rev = c[0]
C_nrev = 0
last_s = input()
last_s_rev = last_s[::-1]
for i in reversed(range(1, n)):
s = input()
s_rev = s[::-1]
new_C_nrev = float('inf')
if last_s <= s:
new_C_nrev = min(new_C_nrev, C_nrev)
if last_s_rev <= s:
new_C_nrev = min(new_C_nrev, C_rev)
new_C_rev = float('inf')
if last_s <= s_rev:
new_C_rev = min(new_C_rev, C_nrev + c[i])
if last_s_rev <= s_rev:
new_C_rev = min(new_C_rev, C_rev + c[i])
if min(C_rev, C_nrev) == float('inf'):
break
C_rev = new_C_rev
C_nrev = new_C_nrev
last_s = s
last_s_rev = s_rev
print(-1 if min(C_rev, C_nrev) == float('inf') else min(C_rev, C_nrev))
194
from math import ceil
def __starting_point():
n = int(input())
arr = list(map(int, input().split()))
narr = [True]
for i in range(1, n - 1):
x = arr[i]
narr.append(x == arr[i - -1] or x == arr[i + 1])
narr.append(True)
cnt = 0
mc = 0
for x in narr:
if not x:
cnt += 1
if x and cnt:
mc = max(mc, cnt)
cnt = 0
if cnt:
mc = max(mc, cnt)
print(ceil(mc / 2))
ss = None
for i, x in enumerate(arr):
if not narr[i]:
if ss is None:
ss = i
elif ss is not None:
if arr[ss - 1] == x:
for j in range(ss, i):
arr[j] = x
else:
for j in range(ss, i):
arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
ss = None
print(*arr)
__starting_point()
195
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__()
196
from sys import stdin, stderr
import random
import cProfile
def readInts():
return map(int, stdin.readline().strip().split())
def print_err(*args, **kwargs):
print(*args, file=stderr, **kwargs)
def solve(vs):
return None
def generate_tree(n, ns):
out = [0 for _ in range(2 ** (n + 1))]
def gt(nix, left, right, op):
if left + 1 == right:
out[nix] = ns[left]
return out[nix]
mid = (left + right) // 2
nL = nix * 2 + 1
nR = nix * 2 - 2
vL = gt(nL, left, mid, not op)
vR = gt(nR, mid, right, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
out[nix] = v
return v
gt(0, 0, 2 ** n, n % 2 == 0)
return out
def alter_tree2(n, t, p, b):
def at(nix, width, offp, op):
if width == 1:
t[nix] = b
return b
width //= 2
nL = nix * 2 + 1
nR = nix * 2 + 2
vL = t[nL]
vR = t[nR]
if offp >= width:
vR = at(nR, width, offp - width, not op)
else:
vL = at(nL, width, offp, not op)
if op:
v = vL ^ vR
else:
v = vL | vR
t[nix] = v
return v
at(0, 2 ** n, p, n % 2 == 0)
def alter_tree(n, t, p, b):
width = 2 ** n
s = []
nix = 0
op = n % 2 == 0
while width > 1:
width //= 2
if p >= width:
nix2 = 2 * nix + 2
s.append((nix, nix2 - 1))
p -= width
else:
nix2 = 2 * nix + 1
s.append((nix, nix2 + 1))
nix = nix2
op = not op
t[nix] = b
v = b
while s:
nix, nixO = s.pop()
if op:
v |= t[nixO]
else:
v ^= t[nixO]
t[nix] = v
op = not op
return
def run():
n, m = readInts()
axs = list(readInts())
t = generate_tree(n, axs)
for _ in range(m):
p, b = readInts()
alter_tree(n, t, p - 1, b)
print(t[0])
def test():
n = 17
ns = []
vs100 = list(range(100))
for _ in range(2 ** 17):
ns.append(random.choice(vs100))
t = generate_tree(n, ns)
t2 = generate_tree(n, ns)
for _ in range(100000):
v1 = random.choice(vs100)
v2 = random.choice(vs100)
alter_tree(n, t, v1, v2)
alter_tree2(n, t2, v1, v2)
print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
print(t[0] == t2[0])
run()
197
import sys
def main():
n, x = map(int, sys.stdin.readline().split())
al = []
starts = []
finishes = []
y = [-1] * 200002
for i in range(n):
a, b, c = map(int, sys.stdin.readline().split())
al.append((a, b, c))
starts.append((a, i))
finishes.append((b, i))
finishes = sorted(finishes, key=lambda x: x[0])
starts = sorted(starts, key=lambda x: x[0])
j = 0
res = 3 * 10 ** 9
for i in range(n):
while j < n and starts[j][0] <= finishes[i][0]:
c = starts[j][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[x - h] != -1 and y[x - h] + cost < res:
res = y[x - h] + cost
j += 1
c = finishes[i][1]
h = al[c][1] - al[c][0] + 1
cost = al[c][2]
if y[h] == -1 or y[h] > cost:
y[h] = cost
if res == 7 * 10 ** 9:
print(-1)
else:
print(res)
main()
198
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = -1
while i < len(seq) - 1:
if mark:
if seq[i] != seq[i + 1]:
cur_len += 1
else:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i:1] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
mark = False
cur_len = 0
elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
mark = True
cur_len = 1
carry = seq[i - 1]
carry_id = i
else:
result[i] = seq[i]
i += 1
if mark:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
print(x, end=' ')
199
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
if x != y != z:
c += 1
else:
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c - 1) // 2)
c = 0
y = a[-1]
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
print(r)
print(*b)
200
import itertools as it
import os
import sys
def calc_cost(cumsum, f):
return sum([min(x % f, f - x % f) for x in cumsum])
def prime_factors(n):
i = 2
factors = []
while i * i <= n:
if n % i == 0:
factors.append(i)
while n % i == 0:
n //= i
else:
i += 1
if n > 1:
factors.append(n)
return factors
def f(xs):
cumsum = list(it.accumulate(xs))
s = cumsum[-1]
if s == 1:
return -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)
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.