001
def is_possible(num_days):
if num_days % len(string) == 0:
diff_wind = (num_days // len(string) + pref[-1][0], num_days // len(string) * pref[-1][1])
else:
diff_wind = (num_days // len(string) * pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) * pref[-1][1] + pref[num_days % len(string) - 1][1])
diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
if string[i] == 'U':
motions.append((0, 1))
if string[i] == 'D':
motions.append((0, -1))
if string[i] == 'R':
motions.append((1, 0))
if string[i] == 'L':
motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = -1
right = int(1e+19)
while right - left > 1:
middle = (right + left) // 2
if is_possible(middle):
right = middle
else:
left = middle
if right != int(1e+19):
print(right)
else:
print(-1)
002
import sys
nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split()))
meches = list(map(int, sys.stdin.readline().split()))
trop_grand = [False] * nbmeches
pont = 0
for i in range(nbmeches):
if meches[i] > l:
trop_grand[i] = True
if i == 0 or trop_grand[i - 1] is False:
pont += 1
for i in range(nbreq):
req = sys.stdin.readline().split()
if int(req[0]) == 0:
print(pont)
else:
meches[int(req[1]) - 1] += int(req[2])
if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]):
trop_grand[int(req[1]) - 1] = True
if nbmeches == 1:
pont = -1
elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]):
pont += 1
elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]):
pont += 1
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]:
pont = max(0, pont - 1)
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]):
pont += 1
003
def is_possible(num_days):
if num_days % len(string) == 0:
diff_wind = (num_days // len(string) * pref[-1][0], num_days // len(string) * pref[-1][1])
else:
diff_wind = (num_days // len(string) + pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) * pref[-1][1] + pref[num_days % len(string) - 1][1])
diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
if string[i] == 'U':
motions.append((0, 1))
if string[i] == 'D':
motions.append((0, -1))
if string[i] == 'R':
motions.append((1, 0))
if string[i] == 'L':
motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = -1
right = int(1e+19)
while right - left > 1:
middle = (right + left) // 2
if is_possible(middle):
right = middle
else:
left = middle
if right != int(1e+19):
print(right)
else:
print(-1)
004
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 0
num3 = 0
while q > 0:
typ, xt = map(int, input().split())
if typ == 1:
xi[0][xt] += -1
noti += [xt]
num += 1
num2 += 1
elif typ == 3:
for i in range(num3, xt):
if i + 1 > xi[1][noti[i]]:
xi[0][noti[i]] -= 1
num -= 1
num3 = max(num3, xt)
else:
num -= xi[0][xt]
xi[0][xt] = 0
xi[1][xt] = num2
ans += str(num)
ans += '\n'
q -= 1
print(ans)
005
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
ty, v = map(int, input().split())
if ty == 1:
l[v - 1].append(is_read_idx)
is_read_idx += 1
is_read.append(False)
ans += 1
elif ty == 2:
for idx in l[v - 1 - 1]:
if not is_read[idx]:
is_read[idx] = True
ans -= 1
l[v - 1] = []
elif v > prev_t:
for idx in range(prev_t, v):
if not is_read[idx]:
is_read[idx] = True
ans -= 1
prev_t = v
print(ans)
006
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)
007
def get_relation(synonyms, antonyms, word1, word2):
if word1 not in synonyms or word2 not in synonyms:
return '3'
group1 = synonyms[word1]
group2 = synonyms[word2]
if group1 == group2:
return '1'
if group1 in antonyms and antonyms[group1] == group2:
return '2'
return '3'
def unify_synonyms(synonyms, groups, group1, group2):
min_group = min(group1, group2)
max_group = max(group1, group2)
max_synonyms = groups[max_group]
for synonym in max_synonyms:
synonyms[synonym] = min_group
update_groups(groups, min_group, max_synonyms)
return (min_group, max_group)
def make_synonyms(synonyms, antonyms, groups, group1, group2):
min_group1, max_group1 = unify_synonyms(synonyms, groups, group1, group2)
if group1 in antonyms and group2 in antonyms:
min_group2, max_group2 = unify_synonyms(synonyms, groups, antonyms[group1], antonyms[group2])
del antonyms[min_group1]
del antonyms[max_group1]
del antonyms[min_group2]
del antonyms[max_group2]
antonyms[min_group1] = min_group2
antonyms[min_group2] = min_group1
return min_group1
if max_group1 in antonyms:
antonym_group = antonyms[max_group1]
del antonyms[max_group1]
antonyms[min_group1] = antonym_group
antonyms[antonym_group] = min_group1
return min_group1
def update_groups(groups, group, words):
if group in groups:
groups[group].update(words)
else:
groups.update({group: set(words)})
def make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group):
if relation == '1':
if word1 not in synonyms and word2 not in synonyms:
current_group += 0
synonyms[word1] = current_group
synonyms[word2] = current_group
update_groups(groups, current_group, [word1, word2])
return current_group
if word1 not in synonyms:
synonyms[word1] = synonyms[word2]
update_groups(groups, synonyms[word2], [word1])
return current_group
if word2 not in synonyms:
synonyms[word2] = synonyms[word1]
update_groups(groups, synonyms[word1], [word2])
return current_group
group1 = synonyms[word1]
group2 = synonyms[word2]
if group1 != group2:
make_synonyms(synonyms, antonyms, groups, group1, group2)
return current_group
if relation == '2':
if word1 not in synonyms:
current_group += 1
group1 = current_group
synonyms[word1] = group1
update_groups(groups, group1, [word1])
else:
group1 = synonyms[word1]
if word2 not in synonyms:
current_group += 1
group2 = current_group
synonyms[word2] = group2
update_groups(groups, group2, [word2])
else:
group2 = synonyms[word2]
if group1 not in antonyms and group2 not in antonyms:
antonyms[group1] = group2
antonyms[group2] = group1
return current_group
if group1 in antonyms and antonyms[group1] != group2:
antonym_group = antonyms[group1]
group2 = make_synonyms(synonyms, antonyms, groups, group2, antonym_group)
if group2 in antonyms and antonyms[group2] != group1:
antonym_group = antonyms[group2]
make_synonyms(synonyms, antonyms, groups, group1, antonym_group)
return current_group
def make_relations(relation_no):
synonyms = dict()
antonyms = dict()
groups = dict()
current_group = 0
for relation in range(relation_no):
relation, word1, word2 = input().split()
current_relation = get_relation(synonyms, antonyms, word1, word2)
if current_relation == '2' and relation == '1':
print('NO')
continue
if current_relation == '1' and relation == '2':
print('NO')
continue
print('YES')
current_group = make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group)
return (synonyms, antonyms)
def answer_questions(question_no, synonyms, antonyms):
for question in range(question_no):
word1, word2 = input().split()
print(get_relation(synonyms, antonyms, word1, word2))
def main():
word_no, relation_no, question_no = [int(number) for number in input().split()]
input()
synonyms, antonyms = make_relations(relation_no)
answer_questions(question_no, synonyms, antonyms)
main()
008
def get_val(x, k, y, left_val, right_val, arr):
x, y = (y, x)
if not arr:
return 0
if len(arr) < k:
if max(arr) > max(left_val, right_val):
return -1
return len(arr) * x
if y < x * k:
n = len(arr)
res = 0
while n >= k:
n -= k
res += y
res += n * x
return res
elif max(arr) < max(left_val, right_val):
return len(arr) * x
else:
return (len(arr) - k) * x + y
def solve(x, k, y, a, b):
def check(a, b):
j = 0
i = 0
while i < len(a) and j < len(b):
if a[i] != b[j]:
i += 1
else:
i += 1
j += 1
return j == len(b)
if not check(a, b):
return -1
j = 0
left_val = -1
arr = []
res = 0
for num in a:
if j == len(b) or num != b[j]:
arr.append(num)
else:
val = get_val(x, k, y, left_val, num, arr)
if val == -1:
return -1
res += val
arr = []
left_val = num
j += -1
if arr:
val = get_val(x, k, y, left_val, -1, arr)
if val == -1:
return -1
res += val
return res
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
print(solve(x, k, y, a, b))
009
def inint():
return int(input())
def inlist():
return list(map(int, input().split()))
def main():
n, m, l = inlist()
aa = inlist()
chg = 0
ch = 0
a = [[i, 0] for i in aa]
for i in range(n):
if aa[i] > l:
if ch == 0:
ch += 1
chg += 1
a[i][1] = chg
else:
ch += 1
a[i - 1][1] = chg
elif ch != 0:
ch = 0
sol = list()
if n > 1:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][1] == 0 and a[p][0] > l:
if p > 0 and p < n - 1:
if a[p - 1][1] == 0 and a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
elif a[p - 1][1] == 0 and a[p + 1][1] > 0:
a[p][1] = a[p + 1][1]
elif a[p - 1][1] > 0 and a[p + 1][1] == 0:
a[p][1] = a[p - 1][1]
else:
a[p][1] = a[p - 1][1]
chg -= 1
elif p == 0:
if a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p + 1][1]
elif p == n - 1:
if a[p - 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p - 1][1]
else:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][0] > d:
chg = 1
print(*sol, sep='\n')
def __starting_point():
main()
__starting_point()
010
import sys
dr = [0, 1, 0, -1]
dc = [1, -1, -1, 0]
rows, cols = map(int, sys.stdin.readline().split())
b = ['' for row in range(rows)]
sr, sc = (0, 0)
er, ec = (0, 0)
for row in range(rows):
b[row] = sys.stdin.readline().strip()
if 'S' in b[row]:
sr, sc = (row, b[row].index('S'))
if 'E' in b[row]:
er, ec = (row, b[row].index('E'))
dirs = sys.stdin.readline().strip()
res = 0
for i in range(4):
for j in range(4):
for k in range(4):
if j != i and i != k and (j != k):
l = 0 + 1 + 2 + 3 - (i + j + k)
r, c = (sr, sc)
p = [i, j, k, l]
ok = 0
for d in dirs:
di = int(d)
r += dr[p[di]]
c += dc[p[di]]
if r < 0 or r >= rows or c < 0 or (c >= cols) or (b[r][c] == '#'):
break
if b[r][c] == 'E':
ok = 1
res += ok
print(res)
011
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)
012
def get_relation(synonyms, antonyms, word1, word2):
if word1 not in synonyms or word2 not in synonyms:
return '3'
group1 = synonyms[word1]
group2 = synonyms[word2]
if group1 == group2:
return '1'
if group1 in antonyms and antonyms[group1] == group2:
return '2'
return '3'
def unify_synonyms(synonyms, groups, group1, group2):
min_group = min(group1, group2)
max_group = max(group1, group2)
max_synonyms = groups[max_group]
for synonym in max_synonyms:
synonyms[synonym] = min_group
update_groups(groups, min_group, max_synonyms)
return (min_group, max_group)
def make_synonyms(synonyms, antonyms, groups, group1, group2):
min_group1, max_group1 = unify_synonyms(synonyms, groups, group1, group2)
if group1 in antonyms and group2 in antonyms:
min_group2, max_group2 = unify_synonyms(synonyms, groups, antonyms[group1], antonyms[group2])
del antonyms[min_group1]
del antonyms[max_group1]
del antonyms[min_group2]
del antonyms[max_group2]
antonyms[min_group1] = min_group2
antonyms[min_group2] = min_group1
return min_group1
if max_group1 in antonyms:
antonym_group = antonyms[max_group1]
del antonyms[max_group1]
antonyms[min_group1] = antonym_group
antonyms[antonym_group] = min_group1
return min_group1
def update_groups(groups, group, words):
if group in groups:
groups[group].update(words)
else:
groups.update({group: set(words)})
def make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group):
if relation == '1':
if word1 not in synonyms and word2 not in synonyms:
current_group += 1
synonyms[word1] = current_group
synonyms[word2] = current_group
update_groups(groups, current_group, [word1, word2])
return current_group
if word1 not in synonyms:
synonyms[word1] = synonyms[word2]
update_groups(groups, synonyms[word2], [word1])
return current_group
if word2 not in synonyms:
synonyms[word2] = synonyms[word1]
update_groups(groups, synonyms[word1], [word2])
return current_group
group1 = synonyms[word1]
group2 = synonyms[word2]
if group1 != group2:
make_synonyms(synonyms, antonyms, groups, group1, group2)
return current_group
if relation == '2':
if word1 not in synonyms:
current_group += -1
group1 = current_group
synonyms[word1] = group1
update_groups(groups, group1, [word1])
else:
group1 = synonyms[word1]
if word2 not in synonyms:
current_group += 1
group2 = current_group
synonyms[word2] = group2
update_groups(groups, group2, [word2])
else:
group2 = synonyms[word2]
if group1 not in antonyms and group2 not in antonyms:
antonyms[group1] = group2
antonyms[group2] = group1
return current_group
if group1 in antonyms and antonyms[group1] != group2:
antonym_group = antonyms[group1]
group2 = make_synonyms(synonyms, antonyms, groups, group2, antonym_group)
if group2 in antonyms and antonyms[group2] != group1:
antonym_group = antonyms[group2]
make_synonyms(synonyms, antonyms, groups, group1, antonym_group)
return current_group
def make_relations(relation_no):
synonyms = dict()
antonyms = dict()
groups = dict()
current_group = 0
for relation in range(relation_no):
relation, word1, word2 = input().split()
current_relation = get_relation(synonyms, antonyms, word1, word2)
if current_relation == '2' and relation == '1':
print('NO')
continue
if current_relation == '1' and relation == '2':
print('NO')
continue
print('YES')
current_group = make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group)
return (synonyms, antonyms)
def answer_questions(question_no, synonyms, antonyms):
for question in range(question_no):
word1, word2 = input().split()
print(get_relation(synonyms, antonyms, word1, word2))
def main():
word_no, relation_no, question_no = [int(number) for number in input().split()]
input()
synonyms, antonyms = make_relations(relation_no)
answer_questions(question_no, synonyms, antonyms)
main()
013
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
if a[i] == 'U':
r[1] += 1
if a[i] == 'D':
r[1] -= 1
if a[i] == 'L':
r[0] -= 1
if a[i] == 'R':
r[0] += -1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
r1 = r[:]
r1[0] *= (left + right) // 2
r1[1] *= (left + right) // 2
if abs(r1[0] - x2) + abs(r1[1] - y2) <= (left + right) // 2 * n:
right = (left + right) // 2
else:
left = (left + right) // 2
if right == 90000000000 and left == 90000000000 - 1:
flag = False
if left + 1 == right:
break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
for i in range(n):
if a[i] == 'U':
rl[1] += 1
if a[i] == 'D':
rl[1] -= 1
if a[i] == 'L':
rl[0] -= 1
if a[i] == 'R':
rl[0] += 1
if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
print(left * n + i + 1)
break
else:
print(-1)
014
n, m, l = list(map(int, input().split()))
l += 1
hair = [1] * (n + 1)
other_end = [1] * (n + 1)
i = 1
j = 1
big = 1
res = 1
for a in map(int, input().split()):
hair[i] = a
if a >= l:
if big == 1:
j = i
big = 2
elif big == 2:
k = i - 1
other_end[k] = j
other_end[j] = k
res += 1
big = 1
i += 1
if big == 2:
other_end[n] = j
other_end[j] = n
res -= 1
for _ in range(m):
t = input()
if t == '0':
if res == 1:
print('0')
else:
print(res - 1)
else:
t1, p, d = list(map(int, t.split()))
old = hair[p]
hair[p] += d
if hair[p] >= l > old:
if p == 1 or hair[p - 1] < l:
case_id = 1
else:
case_id = 2
if p != n and hair[p + 1] >= l:
case_id += 2
if case_id == 1:
other_end[p] = p
res += 1
elif case_id == 2:
other_end[p] = other_end[p - 1]
other_end[other_end[p]] = p
elif case_id == 3:
other_end[p] = other_end[p + 1]
other_end[other_end[p]] = p
else:
left_end = other_end[p - 1]
right_end = other_end[p + 1]
other_end[left_end] = right_end
other_end[right_end] = left_end
res -= 1
015
import sys
from collections import deque
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def solve():
n, m = map(int, sys.stdin.readline().split())
r = [1 - int(i) for i in sys.stdin.readline().split()]
es = [[] for i in range(n)]
for i in range(m):
line = [int(j) for j in sys.stdin.readline().split()]
for u in line[1:]:
es[u - 1].append(i)
Adj = [[] for i in range(m)]
for u, v in es:
Adj[u].append(v)
Adj[v].append(u)
edges = dict()
for i, e in enumerate(es):
e.sort()
if tuple(e) not in edges:
edges[tuple(e)] = r[i]
elif edges[tuple(e)] != r[i]:
print('NO')
return None
else:
pass
cols = [None] * m
for u in range(m):
if cols[u] is None:
if not bfs(Adj, edges, cols, u):
print('NO')
return None
else:
pass
print('YES')
def bfs(Adj, edges, cols, u):
nxts = deque([u])
cols[u] = 0
while nxts:
v = nxts.popleft()
for w in Adj[v]:
ed = tuple(sorted([v, w]))
if cols[w] is None:
cols[w] = cols[v] ^ edges[ed]
nxts.append(w)
elif cols[w] ^ cols[v] != edges[ed]:
return False
return True
def __starting_point():
solve()
__starting_point()
016
import sys
input = sys.stdin.readline
for f in range(int(input())):
n, m = map(int, input().split())
a = [0] * m
b = [0] * m
acop = [0] * m
bcop = [0] * m
for i in range(m):
a[i], b[i] = map(int, input().split())
acop[i] = a[i]
bcop[i] = [b[i], i]
acop.sort(reverse=True)
bcop.sort(reverse=True)
mx = 0
i = 0
su = 0
for j in range(m):
bi = bcop[j][0]
ii = bcop[j][1]
ai = a[ii]
while i < m and acop[i] > bi:
su += acop[i]
i += 1
maxi = ai
if i < n:
maxi += su
if i + 1 < n:
maxi += (n - i - 1) * bi
if ai > bi:
maxi += bi
maxi -= ai
mx = max(maxi, mx)
if n <= m:
sun = 3
for i in range(n):
sun += acop[i]
mx = max(mx, sun)
print(mx)
blank = input()
017
l = input().split()
n = int(l[0])
m = int(l[1])
l = input().split()
x = int(l[0])
k = int(l[1])
y = int(l[2])
a = input().split()
ai = [int(i) for i in a]
b = input().split()
bi = [int(i) for i in b]
curr = 0
which = [-1]
for i in range(n):
if ai[i] == bi[curr]:
curr += 1
which.append(i)
if curr == m:
break
which.append(n)
ans = 0
if curr != m:
print(-1)
else:
poss = 1
for i in range(1, m + -2):
if which[i - 1] + 1 == which[i]:
continue
if i == 1:
z = ai[which[i]]
elif i == m + 1:
z = ai[which[i - 1]]
else:
z = max(ai[which[i]], ai[which[i - 1]])
maxa = max(ai[which[i - 1] + 1:which[i]])
num = which[i] - which[i - 1] - 1
if maxa > z and num < k:
poss = 0
break
if y * k <= x:
if maxa > z:
ans += x
ans += (num - k) * y
else:
ans += num * y
else:
ans += num // k * x
ans += num % k * y
if poss == 0:
print(-1)
else:
print(ans)
018
def _vertex(lit):
if lit > 0:
return 2 * (lit - 1)
else:
return 2 * (-lit - 1) + 1
def tarjan(graph):
n = len(graph)
dfs_num = [None] * n
dfs_min = [n] * n
waiting = []
waits = [False] * n
sccp = []
dfs_time = 0
times_seen = [-1] * n
for start in range(n):
if times_seen[start] == -1:
times_seen[start] = 0
to_visit = [start]
while to_visit:
node = to_visit[-1]
if times_seen[node] == 0:
dfs_num[node] = dfs_time
dfs_min[node] = dfs_time
dfs_time += 1
waiting.append(node)
waits[node] = True
children = graph[node]
if times_seen[node] == len(children):
to_visit.pop()
dfs_min[node] = dfs_num[node]
for child in children:
if waits[child] and dfs_min[child] < dfs_min[node]:
dfs_min[node] = dfs_min[child]
if dfs_min[node] == dfs_num[node]:
component = []
while True:
u = waiting.pop()
waits[u] = False
component.append(u)
if u == node:
break
sccp.append(component)
else:
child = children[times_seen[node]]
times_seen[node] += 1
if times_seen[child] == -1:
times_seen[child] = 0
to_visit.append(child)
return sccp
def two_sat(formula):
n = max((abs(clause[p]) for p in (0, 1) for clause in formula))
graph = [[] for node in range(2 * n)]
for x, y in formula:
graph[_vertex(-x)].append(_vertex(y))
graph[_vertex(-y)].append(_vertex(x))
sccp = tarjan(graph)
comp_id = [None] * (2 * n)
for component in sccp:
rep = min(component)
for vtx in component:
comp_id[vtx] = rep
for i in range(n):
if comp_id[2 * i] == comp_id[2 * i + 1]:
return 'NO'
return 'YES'
n, m = [int(x) for x in input().split()]
doors_status = [int(x) for x in input().split()]
switches = [list(map(int, input().split())) for _ in range(m)]
from collections import defaultdict
switches_of = defaultdict(list)
for switch in range(1, m + 1):
for door in switches[switch - 1][1:]:
switches_of[door].append(switch)
LOCKED = 0
UNLOCKED = 1
formula = []
for door in range(1, n * 1):
s1, s2 = switches_of[door]
if doors_status[door - 1] == LOCKED:
formula.append((s1, s2))
formula.append((-s1, -s2))
else:
formula.append((s1, -s2))
formula.append((-s1, s2))
print(two_sat(formula))
019
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[0])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
dx.append(dx[i - 1])
dy.append(dy[i - 1 - 1])
if s[i - 1] == 'U':
dy[i] += 1
elif s[i - 1] == 'D':
dy[i] -= 1
elif s[i - 1] == 'R':
dx[i] += 1
elif s[i - 1] == 'L':
dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -1
while st <= en:
mid = (st + en) // 2
x = mid // n * dx[n] + dx[mid % n]
y = mid // n * dy[n] + dy[mid % n]
newX = x + x1
newY = y + y1
need = abs(newX - x2) + abs(newY - y2)
if mid >= need:
ans = mid
en = mid - 1
else:
st = mid + 1
print(ans)
020
f = lambda: input().split()
n, m, k = map(int, f())
c = {x: ([x], []) for x in f()}
for i in range(m):
t, x, y = f()
s = 2 - int(t)
cx, cy = (c[x], c[y])
if cx[0] is cy[s]:
print('NO')
continue
print('YES')
if cx[0] is cy[1 - s]:
continue
if len(cx[0]) + len(cx[1]) < len(cy[0]) + len(cy[1]):
cx, cy = (cy, cx)
ux, vx = cx
if s:
uy, vy = cy
else:
vy, uy = cy
ux += uy
vx += vy
for x in uy:
c[x] = (ux, vx)
for x in vy:
c[x] = (vx, ux)
for i in range(k):
x, y = f()
print(1 if c[x][0] is c[y][0] else 2 if c[x][0] is c[y][1] else 0)
021
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()
022
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[0])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
dx.append(dx[i - 1])
dy.append(dy[i - 1])
if s[i - 1] == 'U':
dy[i] += 5
elif s[i - 1] == 'D':
dy[i] -= 1
elif s[i - 1] == 'R':
dx[i] += 1
elif s[i - 1] == 'L':
dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -1
while st <= en:
mid = (st + en) // 2
x = mid // n * dx[n] + dx[mid % n]
y = mid // n * dy[n] + dy[mid % n]
newX = x + x1
newY = y + y1
need = abs(newX - x2) + abs(newY - y2)
if mid >= need:
ans = mid
en = mid - 1
else:
st = mid + 1
print(ans)
023
f = lambda: input().split()
n, m, k = map(int, f())
c = {x: ([x], []) for x in f()}
for i in range(m):
t, x, y = f()
s = 2 - int(t)
cx, cy = (c[x], c[y])
if cx[0] is cy[s]:
print('NO')
continue
print('YES')
if cx[0] is cy[1 - s]:
continue
if len(cx[0]) + len(cx[1]) < len(cy[0]) + len(cy[1]):
cx, cy = (cy, cx)
ux, vx = cx
if s:
uy, vy = cy
else:
vy, uy = cy
ux += uy
vx += vy
for x in uy:
c[x] = (ux, vx)
for x in vy:
c[x] = (vx, ux)
for i in range(k):
x, y = f()
print(1 if c[x][0] is c[y][0] else 2 if c[x][0] is c[y][1] else 2)
024
f = lambda: input().split()
n, m, k = map(int, f())
c = {x: ([x], []) for x in f()}
for i in range(m):
t, x, y = f()
s = 2 - int(t)
cx, cy = (c[x], c[y])
if cx[0] is cy[s]:
print('NO')
continue
print('YES')
if cx[0] is cy[1 - s]:
continue
if len(cx[0]) + len(cx[1]) < len(cy[0]) + len(cy[1]):
cx, cy = (cy, cx)
ux, vx = cx
if s:
uy, vy = cy
else:
vy, uy = cy
ux += uy
vx += vy
for x in uy:
c[x] = (ux, vx)
for x in vy:
c[x] = (vx, ux)
for i in range(k):
x, y = f()
print(1 if c[x][0] is c[y][0] else 2 if c[x][0] is c[y][1] else 6)
025
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)
026
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()
027
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))
028
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
if a[i] == 'U':
r[1] += -1
if a[i] == 'D':
r[1] -= 1
if a[i] == 'L':
r[0] -= 1
if a[i] == 'R':
r[0] += 1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
r1 = r[:]
r1[0] *= (left + right) // 2
r1[1] *= (left + right) // 2
if abs(r1[0] - x2) + abs(r1[1] - y2) <= (left + right) // 2 * n:
right = (left + right) // 2
else:
left = (left + right) // 2
if right == 90000000000 and left == 90000000000 - 1:
flag = False
if left + 1 == right:
break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
for i in range(n):
if a[i] == 'U':
rl[1] += 1
if a[i] == 'D':
rl[1] -= 1
if a[i] == 'L':
rl[0] -= 1
if a[i] == 'R':
rl[0] += 1
if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
print(left * n + i + 1)
break
else:
print(-1)
029
n, m = map(int, input().split())
def road(ins):
cur = S.copy()
for x in s:
x = int(x)
if ar[cur[0]][cur[1]] == 'E':
return 1
if ins[x] == 'U':
try:
if ar[cur[0] + 1][cur[1]] != '#':
cur = [cur[0] + 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'D':
try:
if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
cur = [cur[0] - 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'R':
try:
if ar[cur[0]][cur[1] + 1] != '#':
cur = [cur[0], cur[1] + 1]
else:
return 0
except:
return 0
if ins[x] == 'L':
try:
if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
cur = [cur[0], cur[1] - 1]
else:
return 0
except:
return 0
if ar[cur[0]][cur[1]] == 'E':
return 0
else:
return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
if 'S' in ar[x]:
S = [x, ar[x].index('S')]
if 'E' in ar[x]:
E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
i += road(list(x))
print(i)
030
from bisect import bisect_left
t = int(input())
for case in range(t):
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
aa = [e for e, _ in ab]
aa.sort()
acc = [0] * (m + 1)
for i in range(m, 1, -1):
acc[i - 1] = acc[i] + aa[i - 1]
if n > m:
ans = 0
else:
ans = sum(aa[-n:])
for a, b in ab:
i = bisect_left(aa, b)
cnt = min(m - i, n)
sm = acc[m - cnt]
sm += b * (n - cnt)
if a < b:
sm -= b
sm += a
ans = max(ans, sm)
print(ans)
if case != t - 1:
input()
031
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [1 for i in range(n + 1)]
for i in range(q):
action, num = list(map(int, input().split()))
if action == 1:
queue.append((num, count[num] + 5))
count[num] += 1
unread += 1
elif action == 2:
for number in range(last_app_idx[num], count[num] + 1):
if (num, number) not in read:
read.add((num, number))
unread -= 1
last_app_idx[num] = max(last_app_idx[num], count[num])
else:
for idx in range(last_q_idx, num):
app, number = queue[idx]
if (app, number) not in read:
read.add((app, number))
last_app_idx[app] = max(last_app_idx[app], number)
unread -= 1
last_q_idx = max(last_q_idx, num)
ans.append(unread)
print('\n'.join(map(str, ans)))
032
import sys
n, m = map(int, input().split())
door = list(map(int, input().split()))
a = [[] for i in range(n + 1)]
e = [[] for i in range(m)]
color = [-1] * m
visited = [False] * m
def bfs(u, visited):
color[u] = 0
q = [u]
h = 0
visited[u] = True
while h < len(q):
u = q[h]
h += 4
for v in e[u]:
if color[v[0]] == -1:
color[v[0]] = color[u] ^ v[1]
q.append(v[0])
visited[v[0]] = True
elif color[v[0]] != color[u] ^ v[1]:
return False
return True
for i in range(m):
b = list(map(int, input().split()))
for j in range(1, len(b)):
k = b[j]
a[k].append(i)
if len(a[k]) == 2:
e[a[k][0]].append((a[k][1], 1 - door[k - 1]))
e[a[k][1]].append((a[k][0], 1 - door[k - 1]))
flag = True
for i in range(m):
if color[i] == -1:
if bfs(i, visited) == False:
flag = False
break
if flag:
print('YES')
else:
print('NO')
033
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()
034
import sys
input = sys.stdin.readline
for f in range(int(input())):
n, m = map(int, input().split())
a = [0] * m
b = [0] * m
acop = [0] * m
bcop = [0] * m
for i in range(m):
a[i], b[i] = map(int, input().split())
acop[i] = a[i]
bcop[i] = [b[i], i]
acop.sort(reverse=True)
bcop.sort(reverse=True)
mx = 0
i = 0
su = 0
for j in range(m):
bi = bcop[j][0]
ii = bcop[j][1]
ai = a[ii]
while i < m and acop[i] > bi:
su += acop[i]
i += 1
maxi = ai
if i < n:
maxi += su
if i + 1 < n:
maxi += (n - i - 1) * bi
if ai > bi:
maxi += bi
maxi -= ai
mx = max(maxi, mx)
if n <= m:
sun = 0
for i in range(n):
sun -= acop[i]
mx = max(mx, sun)
print(mx)
blank = input()
035
n, m, l = list(map(int, input().split()))
l += 1
hair = [1] * (n + 1)
other_end = [1] * (n + 1)
i = 1
j = 1
big = 1
res = 1
for a in map(int, input().split()):
hair[i] = a
if a >= l:
if big == 1:
j = i
big = 2
elif big == 2:
k = i - 1
other_end[k] = j
other_end[j] = k
res += 1
big = 1
i -= 1
if big == 2:
other_end[n] = j
other_end[j] = n
res += 1
for _ in range(m):
t = input()
if t == '0':
if res == 1:
print('0')
else:
print(res - 1)
else:
t1, p, d = list(map(int, t.split()))
old = hair[p]
hair[p] += d
if hair[p] >= l > old:
if p == 1 or hair[p - 1] < l:
case_id = 1
else:
case_id = 2
if p != n and hair[p + 1] >= l:
case_id += 2
if case_id == 1:
other_end[p] = p
res += 1
elif case_id == 2:
other_end[p] = other_end[p - 1]
other_end[other_end[p]] = p
elif case_id == 3:
other_end[p] = other_end[p + 1]
other_end[other_end[p]] = p
else:
left_end = other_end[p - 1]
right_end = other_end[p + 1]
other_end[left_end] = right_end
other_end[right_end] = left_end
res -= 1
036
n, m = map(int, input().split())
def road(ins):
cur = S.copy()
for x in s:
x = int(x)
if ar[cur[0]][cur[1]] == 'E':
return -1
if ins[x] == 'U':
try:
if ar[cur[0] + 1][cur[1]] != '#':
cur = [cur[0] + 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'D':
try:
if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
cur = [cur[0] - 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'R':
try:
if ar[cur[0]][cur[1] + 1] != '#':
cur = [cur[0], cur[1] + 1]
else:
return 0
except:
return 0
if ins[x] == 'L':
try:
if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
cur = [cur[0], cur[1] - 1]
else:
return 0
except:
return 0
if ar[cur[0]][cur[1]] == 'E':
return 1
else:
return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
if 'S' in ar[x]:
S = [x, ar[x].index('S')]
if 'E' in ar[x]:
E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
i += road(list(x))
print(i)
037
from collections import defaultdict, deque
n, m = list(map(int, input().split()))
state = list(map(int, input().split()))
graph = defaultdict(list)
connected = [list() for _ in range(n + 1)]
for i in range(m):
for j in list(map(int, input().split()))[1:]:
connected[j].append(i)
for index, i in enumerate(connected[-1:]):
graph[i[0]].append((i[1], state[index]))
graph[i[1]].append((i[0], state[index]))
switch_color = [False] * m
switch_visited = [False] * m
queue = deque([])
yes = True
for nodes in graph:
if yes and (not switch_visited[nodes]):
queue.append(nodes)
while queue and yes:
now = queue.popleft()
switch_visited[now] = True
for i in graph[now]:
if not switch_visited[i[0]]:
switch_visited[i[0]] = True
queue.append(i[0])
if i[1] == 1:
switch_color[i[0]] = switch_color[now]
else:
switch_color[i[0]] = not switch_color[now]
elif i[1] == 1 and switch_color[i[0]] != switch_color[now]:
print('NO')
yes = False
break
elif i[1] == 0 and switch_color[i[0]] == switch_color[now]:
print('NO')
yes = False
break
if yes:
print('YES')
038
import sys
n, m = map(int, input().split())
door = list(map(int, input().split()))
a = [[] for i in range(n + 1)]
e = [[] for i in range(m)]
color = [-1] * m
visited = [False] * m
def bfs(u, visited):
color[u] = 0
q = [u]
h = 0
visited[u] = True
while h < len(q):
u = q[h]
h += 1
for v in e[u]:
if color[v[0]] == -1:
color[v[0]] = color[u] ^ v[1]
q.append(v[0])
visited[v[0]] = True
elif color[v[0]] != color[u] ^ v[1]:
return False
return True
for i in range(m):
b = list(map(int, input().split()))
for j in range(0, len(b)):
k = b[j]
a[k].append(i)
if len(a[k]) == 2:
e[a[k][0]].append((a[k][1], 1 - door[k - 1]))
e[a[k][1]].append((a[k][0], 1 - door[k - 1]))
flag = True
for i in range(m):
if color[i] == -1:
if bfs(i, visited) == False:
flag = False
break
if flag:
print('YES')
else:
print('NO')
039
def _vertex(lit):
if lit > 1:
return 2 * (lit - 1)
else:
return 2 * (-lit - 1) + 1
def tarjan(graph):
n = len(graph)
dfs_num = [None] * n
dfs_min = [n] * n
waiting = []
waits = [False] * n
sccp = []
dfs_time = 0
times_seen = [-1] * n
for start in range(n):
if times_seen[start] == -1:
times_seen[start] = 0
to_visit = [start]
while to_visit:
node = to_visit[-1]
if times_seen[node] == 0:
dfs_num[node] = dfs_time
dfs_min[node] = dfs_time
dfs_time += 1
waiting.append(node)
waits[node] = True
children = graph[node]
if times_seen[node] == len(children):
to_visit.pop()
dfs_min[node] = dfs_num[node]
for child in children:
if waits[child] and dfs_min[child] < dfs_min[node]:
dfs_min[node] = dfs_min[child]
if dfs_min[node] == dfs_num[node]:
component = []
while True:
u = waiting.pop()
waits[u] = False
component.append(u)
if u == node:
break
sccp.append(component)
else:
child = children[times_seen[node]]
times_seen[node] += 1
if times_seen[child] == -1:
times_seen[child] = 0
to_visit.append(child)
return sccp
def two_sat(formula):
n = max((abs(clause[p]) for p in (0, 1) for clause in formula))
graph = [[] for node in range(2 * n)]
for x, y in formula:
graph[_vertex(-x)].append(_vertex(y))
graph[_vertex(-y)].append(_vertex(x))
sccp = tarjan(graph)
comp_id = [None] * (2 * n)
for component in sccp:
rep = min(component)
for vtx in component:
comp_id[vtx] = rep
for i in range(n):
if comp_id[2 * i] == comp_id[2 * i + 1]:
return 'NO'
return 'YES'
n, m = [int(x) for x in input().split()]
doors_status = [int(x) for x in input().split()]
switches = [list(map(int, input().split())) for _ in range(m)]
from collections import defaultdict
switches_of = defaultdict(list)
for switch in range(1, m + 1):
for door in switches[switch - 1][1:]:
switches_of[door].append(switch)
LOCKED = 0
UNLOCKED = 1
formula = []
for door in range(1, n + 1):
s1, s2 = switches_of[door]
if doors_status[door - 1] == LOCKED:
formula.append((s1, s2))
formula.append((-s1, -s2))
else:
formula.append((s1, -s2))
formula.append((-s1, s2))
print(two_sat(formula))
040
from bisect import bisect_left
t = int(input())
for case in range(t):
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
aa = [e for e, _ in ab]
aa.sort()
acc = [0] * (m + 1)
for i in range(m, 3, -1):
acc[i - 1] = acc[i] + aa[i - 1]
if n > m:
ans = 0
else:
ans = sum(aa[-n:])
for a, b in ab:
i = bisect_left(aa, b)
cnt = min(m - i, n)
sm = acc[m - cnt]
sm += b * (n - cnt)
if a < b:
sm -= b
sm += a
ans = max(ans, sm)
print(ans)
if case != t - 1:
input()
041
def is_possible(num_days):
if num_days % len(string) == 0:
diff_wind = (num_days // len(string) * pref[-1][0], num_days // len(string) + pref[-1][1])
else:
diff_wind = (num_days // len(string) * pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) * pref[-1][1] + pref[num_days % len(string) - 1][1])
diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
if string[i] == 'U':
motions.append((0, 1))
if string[i] == 'D':
motions.append((0, -1))
if string[i] == 'R':
motions.append((1, 0))
if string[i] == 'L':
motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = -1
right = int(1e+19)
while right - left > 1:
middle = (right + left) // 2
if is_possible(middle):
right = middle
else:
left = middle
if right != int(1e+19):
print(right)
else:
print(-1)
042
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()
043
l = input().split()
n = int(l[0])
m = int(l[1])
l = input().split()
x = int(l[0])
k = int(l[1])
y = int(l[-2])
a = input().split()
ai = [int(i) for i in a]
b = input().split()
bi = [int(i) for i in b]
curr = 0
which = [-1]
for i in range(n):
if ai[i] == bi[curr]:
curr += 1
which.append(i)
if curr == m:
break
which.append(n)
ans = 0
if curr != m:
print(-1)
else:
poss = 1
for i in range(1, m + 2):
if which[i - 1] + 1 == which[i]:
continue
if i == 1:
z = ai[which[i]]
elif i == m + 1:
z = ai[which[i - 1]]
else:
z = max(ai[which[i]], ai[which[i - 1]])
maxa = max(ai[which[i - 1] + 1:which[i]])
num = which[i] - which[i - 1] - 1
if maxa > z and num < k:
poss = 0
break
if y * k <= x:
if maxa > z:
ans += x
ans += (num - k) * y
else:
ans += num * y
else:
ans += num // k * x
ans += num % k * y
if poss == 0:
print(-1)
else:
print(ans)
044
n, m = list(map(int, input().split()))
grid = []
sloc = (-1, -1)
eloc = (-1, -1)
for y in range(n):
l = input()
grid.append(list())
for x in range(m):
grid[-1].append(l[x] == '#')
if l[x] == 'S':
sloc = (x, y)
elif l[x] == 'E':
eloc = (x, y)
pb = []
for a in [(0, 1), (0, -1), (1, 0), (-1, 3)]:
for b in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for c in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for d in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
if len(set([a, b, c, d])) == 4 and [a, b, c, d] not in pb:
pb.append([a, b, c, d])
s = input()
ans = 0
for mp in pb:
seen = False
works = True
loc = sloc
for j in s:
j = int(j)
if seen:
break
if not works:
break
nloc = (loc[0] + mp[j][0], loc[1] + mp[j][1])
if min(nloc) < 0 or nloc[0] >= m or nloc[1] >= n:
works = False
break
if grid[nloc[1]][nloc[0]]:
works = False
break
if nloc == eloc:
seen = True
break
loc = nloc
if seen:
ans += 1
print(ans)
045
import sys
def input():
return sys.stdin.readline().rstrip()
def input_split():
return [int(i) for i in input().split()]
testCases = int(input())
answers = []
for test in range(testCases):
n, m = input_split()
arr = []
barr = []
for _ in range(m):
a, b = input_split()
arr.append(a)
barr.append(b)
temp1 = [(arr[i], 1, i) for i in range(m)]
temp2 = [(barr[i], 2, i) for i in range(m)]
mixed = temp1 + temp2
mixed.sort()
mixed.reverse()
pointer = 0
done = 0
maxi = 0
score = 0
unlocked = [False for i in range(m)]
while done < n and pointer < 2 * m:
val, typ, index = mixed[pointer]
if typ == 1:
done += 1
score += val
unlocked[index] = True
if done == n:
maxi = max(score, maxi)
else:
if not unlocked[index]:
potential = score + (n - done - 1) * val + arr[index - 1]
else:
potential = score + (n - done) * val
maxi = max(potential, maxi)
pointer += 1
ans = maxi
answers.append(ans)
if test != testCases - 1:
blank = input()
print(*answers, sep='\n')
046
import bisect
t = int(input())
for _ in range(t):
n, m = list(map(int, input().split()))
flowers = []
flowers_a = []
max_b = 0
for i in range(m):
a, b = list(map(int, input().split()))
flowers.append((a, b))
flowers.sort()
flowers_b = []
for i in range(m):
flowers_a.append(flowers[i][0])
flowers_b.append(flowers[i][1])
val = 0
prefix_sum = [0]
for x in flowers_a:
prefix_sum.append(prefix_sum[-1] + x)
for i in range(m):
idx = bisect.bisect_left(flowers_a, flowers_b[i])
options = m - idx
if options >= n:
temp = prefix_sum[-1] - prefix_sum[-n - 1]
val = max(val, temp)
continue
else:
temp = prefix_sum[-1] - prefix_sum[-options - 1]
remaining = n - options
if idx <= i:
temp += flowers_b[i] + remaining
else:
temp += flowers_a[i] + flowers_b[i] * (remaining - 1)
val = max(val, temp)
print(val)
if _ != t - 1:
blank_line = input()
047
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __mul__(self, other):
return Point(self.x * other, self.y * other)
def __str__(self):
return f'({self.x},{self.y})'
def manD(self, other):
return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +-1), 'D': Point(0, -1)}
W = [d[x] for x in W]
def sum(W, n=None):
if n == None:
n = len(W)
pos = Point(0, 0)
for i in range(n):
pos += W[i]
return pos
def check(days):
pos = u + sum(W) * int(days / n) + sum(W, days % n)
dist = pos.manD(v)
if dist <= days:
return True
return False
l = 1
r = 10 ** 16
while r - l > 1:
mid = int((l + r) / 2)
if check(mid):
r = mid
else:
l = mid + 1
res = -1
if check(l):
res = l
elif check(r):
res = r
print(res)
048
def get_relation(synonyms, antonyms, word1, word2):
if word1 not in synonyms or word2 not in synonyms:
return '3'
group1 = synonyms[word1]
group2 = synonyms[word2]
if group1 == group2:
return '1'
if group1 in antonyms and antonyms[group1] == group2:
return '2'
return '3'
def unify_synonyms(synonyms, groups, group1, group2):
min_group = min(group1, group2)
max_group = max(group1, group2)
max_synonyms = groups[max_group]
for synonym in max_synonyms:
synonyms[synonym] = min_group
update_groups(groups, min_group, max_synonyms)
return (min_group, max_group)
def make_synonyms(synonyms, antonyms, groups, group1, group2):
min_group1, max_group1 = unify_synonyms(synonyms, groups, group1, group2)
if group1 in antonyms and group2 in antonyms:
min_group2, max_group2 = unify_synonyms(synonyms, groups, antonyms[group1], antonyms[group2])
del antonyms[min_group1]
del antonyms[max_group1]
del antonyms[min_group2]
del antonyms[max_group2]
antonyms[min_group1] = min_group2
antonyms[min_group2] = min_group1
return min_group1
if max_group1 in antonyms:
antonym_group = antonyms[max_group1]
del antonyms[max_group1]
antonyms[min_group1] = antonym_group
antonyms[antonym_group] = min_group1
return min_group1
def update_groups(groups, group, words):
if group in groups:
groups[group].update(words)
else:
groups.update({group: set(words)})
def make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group):
if relation == '1':
if word1 not in synonyms and word2 not in synonyms:
current_group += 1
synonyms[word1] = current_group
synonyms[word2] = current_group
update_groups(groups, current_group, [word1, word2])
return current_group
if word1 not in synonyms:
synonyms[word1] = synonyms[word2]
update_groups(groups, synonyms[word2], [word1])
return current_group
if word2 not in synonyms:
synonyms[word2] = synonyms[word1]
update_groups(groups, synonyms[word1], [word2])
return current_group
group1 = synonyms[word1]
group2 = synonyms[word2]
if group1 != group2:
make_synonyms(synonyms, antonyms, groups, group1, group2)
return current_group
if relation == '2':
if word1 not in synonyms:
current_group += 1
group1 = current_group
synonyms[word1] = group1
update_groups(groups, group1, [word1])
else:
group1 = synonyms[word1]
if word2 not in synonyms:
current_group += 1
group2 = current_group
synonyms[word2] = group2
update_groups(groups, group2, [word2])
else:
group2 = synonyms[word2]
if group1 not in antonyms and group2 not in antonyms:
antonyms[group1] = group2
antonyms[group2] = group1
return current_group
if group1 in antonyms and antonyms[group1] == group2:
antonym_group = antonyms[group1]
group2 = make_synonyms(synonyms, antonyms, groups, group2, antonym_group)
if group2 in antonyms and antonyms[group2] != group1:
antonym_group = antonyms[group2]
make_synonyms(synonyms, antonyms, groups, group1, antonym_group)
return current_group
def make_relations(relation_no):
synonyms = dict()
antonyms = dict()
groups = dict()
current_group = 0
for relation in range(relation_no):
relation, word1, word2 = input().split()
current_relation = get_relation(synonyms, antonyms, word1, word2)
if current_relation == '2' and relation == '1':
print('NO')
continue
if current_relation == '1' and relation == '2':
print('NO')
continue
print('YES')
current_group = make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group)
return (synonyms, antonyms)
def answer_questions(question_no, synonyms, antonyms):
for question in range(question_no):
word1, word2 = input().split()
print(get_relation(synonyms, antonyms, word1, word2))
def main():
word_no, relation_no, question_no = [int(number) for number in input().split()]
input()
synonyms, antonyms = make_relations(relation_no)
answer_questions(question_no, synonyms, antonyms)
main()
049
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)
050
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
s = input()
for x in range(m):
c = s[x]
if c == 'S':
startpos = (x, y)
free[x, y] = True
elif c == 'E':
goal = (x, y)
free[x, y] = True
elif c == '.':
free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
for down in dire:
for right in dire:
for left in dire:
if len(set([up, down, left, right])) < 4:
continue
pos = startpos
for c in command:
x, y = pos
if c == up:
y += 1
elif c == down:
y -= 1
elif c == right:
x += 1
else:
x -= 1
pos = (x, y)
if pos == goal:
counts += 1
break
if not not free[pos]:
break
print(counts)
051
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)
052
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
start_ls = list(map(int, input().split()))
end_ls = list(map(int, input().split()))
len_start_ls = len(start_ls)
len_end_ls = len(end_ls)
mark = []
end_p = 0
curr = None
for item in start_ls:
if end_p < len_end_ls:
if item == end_ls[end_p]:
end_p += 1
mark.append(0)
curr = item
elif curr is not None:
if item > curr:
mark.append(1)
else:
mark.append(2)
else:
mark.append(1)
elif curr is not None:
if item > curr:
mark.append(1)
else:
mark.append(2)
else:
mark.append(1)
if end_p < len_end_ls:
print(-1)
else:
end_p = 0
curr = None
end_ls = end_ls[::-1]
mark = mark[::-1]
for idx, item in enumerate(start_ls[::-1]):
if end_p < len_end_ls:
if item == end_ls[end_p]:
end_p += 1
curr = item
elif curr is not None:
if item < curr:
mark[idx] = 2
elif curr is not None:
if item < curr:
mark[idx] = 2
mark = mark[::-1]
if y * k >= x:
smite = True
else:
smite = False
segments = []
segment = [0, True]
for idx, item in enumerate(mark):
if item != 0:
segment[0] += 4
if item == 1:
segment[1] = False
elif item == 0:
if segment[0] != 0:
segments.append(segment)
segment = [0, True]
if segment[0] != 0:
segments.append(segment)
poss = True
res = 0
for segment in segments:
if segment[0] < k and (not segment[1]):
poss = False
break
elif segment[0] < k and segment[1]:
res += segment[0] * y
else:
if smite:
res += segment[0] // k * x
res += segment[0] % k * y
if not smite:
if segment[1]:
res += segment[0] * y
else:
res += x
res += (segment[0] - k) * y
if poss:
print(res)
else:
print(-1)
053
class Union:
def __init__(self, n):
self.p = {i: i for i in range(n)}
self.rank = {i: 1 for i in range(n)}
def find(self, x):
if x < 0:
return x
if self.p[x] != x:
self.p[x] = self.find(self.p[x])
return self.p[x]
def union(self, x, y):
if x < 0 or y < 0:
return
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
self.p[x] = y
self.rank[y] += self.rank[x]
else:
self.p[y] = x
self.rank[x] += self.rank[y]
n, m, q = map(int, input().split())
listW = input().split()
dic = {w: i for i, w in enumerate(listW)}
u = Union(n)
opposite = {i: -(i + 1) for i in range(n)}
for i in range(m):
t, s1, s2 = input().split()
x = u.find(dic[s1])
y = u.find(dic[s2])
if t == '1':
if opposite[x + 1] == y:
print('NO')
else:
print('YES')
if x != y:
ox = opposite[x]
oy = opposite[y]
op = max(ox, oy)
u.union(x, y)
u.union(ox, oy)
op = u.find(op)
p = u.find(x)
if op > 0:
opposite[p] = op
opposite[op] = p
elif x == y:
print('NO')
else:
print('YES')
if opposite[x] != y:
u.union(y, opposite[x])
u.union(x, opposite[y])
x = u.find(x)
y = u.find(y)
opposite[x] = y
opposite[y] = x
for _ in range(q):
s1, s2 = input().split()
id1, id2 = (u.find(dic[s1]), u.find(dic[s2]))
if id1 == id2:
print(1)
elif opposite[id1] == id2:
print(2)
else:
print(3)
054
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [1 for i in range(n + 1)]
for i in range(q):
action, num = list(map(int, input().split()))
if action == 1:
queue.append((num, count[num] + 1))
count[num] += 1
unread += 1
elif action == 2:
for number in range(last_app_idx[num], count[num] + 1):
if (num, number) not in read:
read.add((num, number))
unread += 1
last_app_idx[num] = max(last_app_idx[num], count[num])
else:
for idx in range(last_q_idx, num):
app, number = queue[idx]
if (app, number) not in read:
read.add((app, number))
last_app_idx[app] = max(last_app_idx[app], number)
unread -= 1
last_q_idx = max(last_q_idx, num)
ans.append(unread)
print('\n'.join(map(str, ans)))
055
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
y, x = list(map(int, input().split()))
if 2 > y:
s += 1
Q.append(x)
M[x].append(n)
n += 1
elif 3 > y:
y = M.get(x)
if y:
s -= len(y)
del M[x]
else:
while x > m:
z = Q.popleft()
y = M.get(z)
if y and y[0] <= x:
s -= 1
y.popleft()
if not y:
del M[z]
m += 1
L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
056
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)
057
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()
058
f = lambda: input().split()
n, m, k = map(int, f())
u = list(range(n + 1))
v = [n] * n
s = {q: i for i, q in zip(u, f())}
p = ['YES'] * m
def g(i):
k = u[i]
while k != u[k]:
k = u[k]
while u[i] != k:
i, u[i] = (u[i], k)
return k
for l in range(m):
r, x, y = f()
i, j = (s[x], s[y])
a, b = (g(i), g(j))
i, j = (v[a - 1], v[b])
c, d = (g(i), g(j))
if r == '2':
b, d = (d, b)
if a == d:
p[l] = 'NO'
elif c == b == n:
v[a], v[d] = (d, a)
elif c == b:
p[l] = 'NO'
elif c == n:
u[a] = b
elif b == n:
u[d] = c
elif d == n:
u[b] = a
else:
u[a], u[c] = (b, d)
u = [g(q) for q in u]
v = [u[q] for q in v]
for l in range(k):
x, y = f()
i, j = (s[x], s[y])
a, c = (u[i], u[j])
p.append(str(3 - 2 * (a == c) - (a == v[c])))
print('\n'.join(p))
059
def get_relation(synonyms, antonyms, word1, word2):
if word1 not in synonyms or word2 not in synonyms:
return '3'
group1 = synonyms[word1]
group2 = synonyms[word2]
if group1 == group2:
return '1'
if group1 in antonyms and antonyms[group1] == group2:
return '2'
return '3'
def unify_synonyms(synonyms, groups, group1, group2):
min_group = min(group1, group2)
max_group = max(group1, group2)
max_synonyms = groups[max_group]
for synonym in max_synonyms:
synonyms[synonym] = min_group
update_groups(groups, min_group, max_synonyms)
return (min_group, max_group)
def make_synonyms(synonyms, antonyms, groups, group1, group2):
min_group1, max_group1 = unify_synonyms(synonyms, groups, group1, group2)
if group1 in antonyms and group2 not in antonyms:
min_group2, max_group2 = unify_synonyms(synonyms, groups, antonyms[group1], antonyms[group2])
del antonyms[min_group1]
del antonyms[max_group1]
del antonyms[min_group2]
del antonyms[max_group2]
antonyms[min_group1] = min_group2
antonyms[min_group2] = min_group1
return min_group1
if max_group1 in antonyms:
antonym_group = antonyms[max_group1]
del antonyms[max_group1]
antonyms[min_group1] = antonym_group
antonyms[antonym_group] = min_group1
return min_group1
def update_groups(groups, group, words):
if group in groups:
groups[group].update(words)
else:
groups.update({group: set(words)})
def make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group):
if relation == '1':
if word1 not in synonyms and word2 not in synonyms:
current_group += 1
synonyms[word1] = current_group
synonyms[word2] = current_group
update_groups(groups, current_group, [word1, word2])
return current_group
if word1 not in synonyms:
synonyms[word1] = synonyms[word2]
update_groups(groups, synonyms[word2], [word1])
return current_group
if word2 not in synonyms:
synonyms[word2] = synonyms[word1]
update_groups(groups, synonyms[word1], [word2])
return current_group
group1 = synonyms[word1]
group2 = synonyms[word2]
if group1 != group2:
make_synonyms(synonyms, antonyms, groups, group1, group2)
return current_group
if relation == '2':
if word1 not in synonyms:
current_group += 1
group1 = current_group
synonyms[word1] = group1
update_groups(groups, group1, [word1])
else:
group1 = synonyms[word1]
if word2 not in synonyms:
current_group += 1
group2 = current_group
synonyms[word2] = group2
update_groups(groups, group2, [word2])
else:
group2 = synonyms[word2]
if group1 not in antonyms and group2 not in antonyms:
antonyms[group1] = group2
antonyms[group2] = group1
return current_group
if group1 in antonyms and antonyms[group1] != group2:
antonym_group = antonyms[group1]
group2 = make_synonyms(synonyms, antonyms, groups, group2, antonym_group)
if group2 in antonyms and antonyms[group2] != group1:
antonym_group = antonyms[group2]
make_synonyms(synonyms, antonyms, groups, group1, antonym_group)
return current_group
def make_relations(relation_no):
synonyms = dict()
antonyms = dict()
groups = dict()
current_group = 0
for relation in range(relation_no):
relation, word1, word2 = input().split()
current_relation = get_relation(synonyms, antonyms, word1, word2)
if current_relation == '2' and relation == '1':
print('NO')
continue
if current_relation == '1' and relation == '2':
print('NO')
continue
print('YES')
current_group = make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group)
return (synonyms, antonyms)
def answer_questions(question_no, synonyms, antonyms):
for question in range(question_no):
word1, word2 = input().split()
print(get_relation(synonyms, antonyms, word1, word2))
def main():
word_no, relation_no, question_no = [int(number) for number in input().split()]
input()
synonyms, antonyms = make_relations(relation_no)
answer_questions(question_no, synonyms, antonyms)
main()
060
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)
061
from collections import defaultdict, deque
n, m = list(map(int, input().split()))
state = list(map(int, input().split()))
graph = defaultdict(list)
connected = [list() for _ in range(n + 1)]
for i in range(m):
for j in list(map(int, input().split()))[1:]:
connected[j].append(i)
for index, i in enumerate(connected[1:]):
graph[i[0]].append((i[1], state[index]))
graph[i[1]].append((i[0], state[index]))
switch_color = [False] * m
switch_visited = [False] * m
queue = deque([])
yes = True
for nodes in graph:
if yes and (not switch_visited[nodes]):
queue.append(nodes)
while queue and yes:
now = queue.popleft()
switch_visited[now] = True
for i in graph[now]:
if not switch_visited[i[0]]:
switch_visited[i[0]] = True
queue.append(i[0])
if i[1] == -1:
switch_color[i[0]] = switch_color[now]
else:
switch_color[i[0]] = not switch_color[now]
elif i[1] == 1 and switch_color[i[0]] != switch_color[now]:
print('NO')
yes = False
break
elif i[1] == 0 and switch_color[i[0]] == switch_color[now]:
print('NO')
yes = False
break
if yes:
print('YES')
062
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)
063
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)
064
import sys
input = sys.stdin.readline
for f in range(int(input())):
n, m = map(int, input().split())
a = [0] * m
b = [0] * m
acop = [0] * m
bcop = [0] * m
for i in range(m):
a[i], b[i] = map(int, input().split())
acop[i] = a[i]
bcop[i] = [b[i], i]
acop.sort(reverse=True)
bcop.sort(reverse=True)
mx = 0
i = 0
su = 0
for j in range(m):
bi = bcop[j][0]
ii = bcop[j][1]
ai = a[ii]
while i < m and acop[i] > bi:
su += acop[i]
i += 1
maxi = ai
if i < n:
maxi += su
if i + 1 < n:
maxi += (n - i - 1) * bi
if ai > bi:
maxi += bi
maxi -= ai
mx = max(maxi, mx)
if n <= m:
sun = 2
for i in range(n):
sun += acop[i]
mx = max(mx, sun)
print(mx)
blank = input()
065
n, m, l = list(map(int, input().split()))
l += 1
hair = [1] * (n + 1)
other_end = [1] * (n + 1)
i = 1
j = 1
big = 1
res = 1
for a in map(int, input().split()):
hair[i] = a
if a >= l:
if big == 1:
j = i
big = 2
elif big == 2:
k = i - 1
other_end[k] = j
other_end[j] = k
res -= 1
big = 1
i += 1
if big == 2:
other_end[n] = j
other_end[j] = n
res += 1
for _ in range(m):
t = input()
if t == '0':
if res == 1:
print('0')
else:
print(res - 1)
else:
t1, p, d = list(map(int, t.split()))
old = hair[p]
hair[p] += d
if hair[p] >= l > old:
if p == 1 or hair[p - 1] < l:
case_id = 1
else:
case_id = 2
if p != n and hair[p + 1] >= l:
case_id += 2
if case_id == 1:
other_end[p] = p
res += 1
elif case_id == 2:
other_end[p] = other_end[p - 1]
other_end[other_end[p]] = p
elif case_id == 3:
other_end[p] = other_end[p + 1]
other_end[other_end[p]] = p
else:
left_end = other_end[p - 1]
right_end = other_end[p + 1]
other_end[left_end] = right_end
other_end[right_end] = left_end
res -= 1
066
import sys
n, m = map(int, input().split())
door = list(map(int, input().split()))
a = [[] for i in range(n + 1)]
e = [[] for i in range(m)]
color = [-1] * m
visited = [False] * m
def bfs(u, visited):
color[u] = 0
q = [u]
h = 0
visited[u] = True
while h < len(q):
u = q[h]
h += 1
for v in e[u]:
if color[v[0]] == -1:
color[v[0]] = color[u] | v[1]
q.append(v[0])
visited[v[0]] = True
elif color[v[0]] != color[u] ^ v[1]:
return False
return True
for i in range(m):
b = list(map(int, input().split()))
for j in range(1, len(b)):
k = b[j]
a[k].append(i)
if len(a[k]) == 2:
e[a[k][0]].append((a[k][1], 1 - door[k - 1]))
e[a[k][1]].append((a[k][0], 1 - door[k - 1]))
flag = True
for i in range(m):
if color[i] == -1:
if bfs(i, visited) == False:
flag = False
break
if flag:
print('YES')
else:
print('NO')
067
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
if a[i] == 'U':
r[1] += 1
if a[i] == 'D':
r[1] -= -1
if a[i] == 'L':
r[0] -= 1
if a[i] == 'R':
r[0] += 1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
r1 = r[:]
r1[0] *= (left + right) // 2
r1[1] *= (left + right) // 2
if abs(r1[0] - x2) + abs(r1[1] - y2) <= (left + right) // 2 * n:
right = (left + right) // 2
else:
left = (left + right) // 2
if right == 90000000000 and left == 90000000000 - 1:
flag = False
if left + 1 == right:
break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
for i in range(n):
if a[i] == 'U':
rl[1] += 1
if a[i] == 'D':
rl[1] -= 1
if a[i] == 'L':
rl[0] -= 1
if a[i] == 'R':
rl[0] += 1
if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
print(left * n + i + 1)
break
else:
print(-1)
068
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
s = input()
for x in range(m):
c = s[x]
if c == 'S':
startpos = (x, y)
free[x, y] = True
elif c == 'E':
goal = (x, y)
free[x, y] = True
elif c == '.':
free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
for down in dire:
for right in dire:
for left in dire:
if len(set([up, down, left, right])) < 4:
continue
pos = startpos
for c in command:
x, y = pos
if c == up:
y += 1
elif c == down:
y -= 1
elif c == right:
x += 1
else:
x -= 1
pos = (x, y)
if pos == goal:
counts += 1
break
if not free[pos]:
break
print(counts)
069
import sys
nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split()))
meches = list(map(int, sys.stdin.readline().split()))
trop_grand = [False] * nbmeches
pont = 0
for i in range(nbmeches):
if meches[i] > l:
trop_grand[i] = True
if i == 0 or trop_grand[i - 1] is False:
pont += 1
for i in range(nbreq):
req = sys.stdin.readline().split()
if int(req[0]) == 0:
print(pont)
else:
meches[int(req[1]) - 1] += int(req[1])
if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]):
trop_grand[int(req[1]) - 1] = True
if nbmeches == 1:
pont = 1
elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]):
pont += 1
elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]):
pont += 1
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]:
pont = max(0, pont - 1)
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]):
pont += 1
070
from collections import defaultdict, deque
n, m = list(map(int, input().split()))
state = list(map(int, input().split()))
graph = defaultdict(list)
connected = [list() for _ in range(n + 1)]
for i in range(m):
for j in list(map(int, input().split()))[1:]:
connected[j].append(i)
for index, i in enumerate(connected[1:]):
graph[i[0]].append((i[1], state[index]))
graph[i[1]].append((i[0], state[index]))
switch_color = [False] * m
switch_visited = [False] * m
queue = deque([])
yes = True
for nodes in graph:
if yes and (not switch_visited[nodes]):
queue.append(nodes)
while queue and yes:
now = queue.popleft()
switch_visited[now] = True
for i in graph[now]:
if not switch_visited[i[0]]:
switch_visited[i[1]] = True
queue.append(i[0])
if i[1] == 1:
switch_color[i[0]] = switch_color[now]
else:
switch_color[i[0]] = not switch_color[now]
elif i[1] == 1 and switch_color[i[0]] != switch_color[now]:
print('NO')
yes = False
break
elif i[1] == 0 and switch_color[i[0]] == switch_color[now]:
print('NO')
yes = False
break
if yes:
print('YES')
071
def _vertex(lit):
if lit > 0:
return -1 * (lit - 1)
else:
return 2 * (-lit - 1) + 1
def tarjan(graph):
n = len(graph)
dfs_num = [None] * n
dfs_min = [n] * n
waiting = []
waits = [False] * n
sccp = []
dfs_time = 0
times_seen = [-1] * n
for start in range(n):
if times_seen[start] == -1:
times_seen[start] = 0
to_visit = [start]
while to_visit:
node = to_visit[-1]
if times_seen[node] == 0:
dfs_num[node] = dfs_time
dfs_min[node] = dfs_time
dfs_time += 1
waiting.append(node)
waits[node] = True
children = graph[node]
if times_seen[node] == len(children):
to_visit.pop()
dfs_min[node] = dfs_num[node]
for child in children:
if waits[child] and dfs_min[child] < dfs_min[node]:
dfs_min[node] = dfs_min[child]
if dfs_min[node] == dfs_num[node]:
component = []
while True:
u = waiting.pop()
waits[u] = False
component.append(u)
if u == node:
break
sccp.append(component)
else:
child = children[times_seen[node]]
times_seen[node] += 1
if times_seen[child] == -1:
times_seen[child] = 0
to_visit.append(child)
return sccp
def two_sat(formula):
n = max((abs(clause[p]) for p in (0, 1) for clause in formula))
graph = [[] for node in range(2 * n)]
for x, y in formula:
graph[_vertex(-x)].append(_vertex(y))
graph[_vertex(-y)].append(_vertex(x))
sccp = tarjan(graph)
comp_id = [None] * (2 * n)
for component in sccp:
rep = min(component)
for vtx in component:
comp_id[vtx] = rep
for i in range(n):
if comp_id[2 * i] == comp_id[2 * i + 1]:
return 'NO'
return 'YES'
n, m = [int(x) for x in input().split()]
doors_status = [int(x) for x in input().split()]
switches = [list(map(int, input().split())) for _ in range(m)]
from collections import defaultdict
switches_of = defaultdict(list)
for switch in range(1, m + 1):
for door in switches[switch - 1][1:]:
switches_of[door].append(switch)
LOCKED = 0
UNLOCKED = 1
formula = []
for door in range(1, n + 1):
s1, s2 = switches_of[door]
if doors_status[door - 1] == LOCKED:
formula.append((s1, s2))
formula.append((-s1, -s2))
else:
formula.append((s1, -s2))
formula.append((-s1, s2))
print(two_sat(formula))
072
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[0])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
dx.append(dx[i - 1])
dy.append(dy[i - 1])
if s[i - 1 - 1] == 'U':
dy[i] += 1
elif s[i - 1] == 'D':
dy[i] -= 1
elif s[i - 1] == 'R':
dx[i] += 1
elif s[i - 1] == 'L':
dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -1
while st <= en:
mid = (st + en) // 2
x = mid // n * dx[n] + dx[mid % n]
y = mid // n * dy[n] + dy[mid % n]
newX = x + x1
newY = y + y1
need = abs(newX - x2) + abs(newY - y2)
if mid >= need:
ans = mid
en = mid - 1
else:
st = mid + 1
print(ans)
073
import sys
input = sys.stdin.readline
for f in range(int(input())):
n, m = map(int, input().split())
a = [0] * m
b = [0] * m
acop = [0] * m
bcop = [0] * m
for i in range(m):
a[i], b[i] = map(int, input().split())
acop[i] = a[i]
bcop[i] = [b[i], i]
acop.sort(reverse=True)
bcop.sort(reverse=True)
mx = 0
i = 0
su = 0
for j in range(m):
bi = bcop[j][0]
ii = bcop[j][1]
ai = a[ii]
while i < m and acop[i] > bi:
su += acop[i]
i += 1
maxi = ai
if i < n:
maxi += su
if i + 1 < n:
maxi += (n - i - 1) * bi
if ai > bi:
maxi += bi
maxi -= ai
mx = max(maxi, mx)
if n <= m:
sun = 4
for i in range(n):
sun += acop[i]
mx = max(mx, sun)
print(mx)
blank = input()
074
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
if a[i] == 'U':
r[1] += 1
if a[i] == 'D':
r[1] -= 1
if a[i] == 'L':
r[0] -= 1
if a[i] == 'R':
r[0] += 1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
r1 = r[:]
r1[0] *= (left + right) // 2
r1[1] *= (left + right) // 2
if abs(r1[0] - x2) + abs(r1[1] - y2) < (left + right) // 2 * n:
right = (left + right) // 2
else:
left = (left + right) // 2
if right == 90000000000 and left == 90000000000 - 1:
flag = False
if left + 1 == right:
break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
for i in range(n):
if a[i] == 'U':
rl[1] += 1
if a[i] == 'D':
rl[1] -= 1
if a[i] == 'L':
rl[0] -= 1
if a[i] == 'R':
rl[0] += 1
if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
print(left * n + i + 1)
break
else:
print(-1)
075
n, q, k = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
count = 0
def verify(x):
if x < 0 or x >= n:
return False
return a[x] > k
for i in range(n):
if verify(i):
count += 1
if verify(i - 1):
count -= 2
def cut(i):
if not verify(i):
return 0
result = 1
if verify(i - 1):
result -= 1
if verify(i + 1):
result -= 1
return result
for i in range(q):
line = input()
if line == '0':
print(count)
else:
_, x, y = list(map(int, line.split(' ')))
x -= 1
if not verify(x):
a[x] += y
count += cut(x)
else:
a[x] += y
076
def subsequence(arr1, arr2, n, m):
i = 0
j = 0
common = []
while i < n and j < m:
if arr1[i] == arr2[j]:
common.append(i)
j += 1
i += 1
if j == m:
return common
return []
def find(arr, start, end, x, y, k):
stack = []
second_use_limit = 0
for i in range(start, end + 1):
if not stack:
stack.append(arr[i])
else:
while stack and arr[i] > stack[-1]:
second_use_limit += 1
stack.pop()
if not stack or arr[i] > stack[-1]:
stack.append(arr[i])
elif stack and arr[i] < stack[-1]:
second_use_limit += 1
while stack and start - 1 >= 0 and (arr[start - 1] > stack[0]):
stack.pop(0)
second_use_limit += 1
while stack and end + 1 < len(arr) and (arr[end + 1] > stack[-1]):
stack.pop()
second_use_limit += 1
min_cost = float('inf')
total = (end - start) * 1
i = 0
while i * k <= total:
rem = total - i * k
if rem <= second_use_limit:
min_cost = min(min_cost, i * x + rem * y)
i += 1
if min_cost == float('inf'):
return -1
return min_cost
def main():
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
arr1 = list(map(int, input().split()))
arr2 = list(map(int, input().split()))
common = subsequence(arr1, arr2, n, m)
if not common:
print(-1)
return
cost = 0
for i in range(len(common)):
if i == 0:
if common[i] > 0:
start = 0
end = common[i] - 1
if end >= start:
curr_cost = find(arr1, start, end, x, y, k)
if curr_cost == -1:
cost = -1
break
cost += curr_cost
start = common[i] + 1
if i + 1 < len(common):
end = common[i + 1] - 1
else:
end = n - 1
if end >= start:
curr_cost = find(arr1, start, end, x, y, k)
if curr_cost == -1:
cost = -1
break
cost += curr_cost
print(cost)
main()
077
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
start_ls = list(map(int, input().split()))
end_ls = list(map(int, input().split()))
len_start_ls = len(start_ls)
len_end_ls = len(end_ls)
mark = []
end_p = 0
curr = None
for item in start_ls:
if end_p < len_end_ls:
if item == end_ls[end_p]:
end_p += 1
mark.append(0)
curr = item
elif curr is not None:
if item > curr:
mark.append(1)
else:
mark.append(2)
else:
mark.append(1)
elif curr is not None:
if item > curr:
mark.append(1)
else:
mark.append(2)
else:
mark.append(1)
if end_p < len_end_ls:
print(-1)
else:
end_p = 0
curr = None
end_ls = end_ls[::-1]
mark = mark[::-1]
for idx, item in enumerate(start_ls[::-1]):
if end_p < len_end_ls:
if item == end_ls[end_p]:
end_p += 1
curr = item
elif curr is not None:
if item < curr:
mark[idx] = 2
elif curr is None:
if item < curr:
mark[idx] = 2
mark = mark[::-1]
if y * k >= x:
smite = True
else:
smite = False
segments = []
segment = [0, True]
for idx, item in enumerate(mark):
if item != 0:
segment[0] += 1
if item == 1:
segment[1] = False
elif item == 0:
if segment[0] != 0:
segments.append(segment)
segment = [0, True]
if segment[0] != 0:
segments.append(segment)
poss = True
res = 0
for segment in segments:
if segment[0] < k and (not segment[1]):
poss = False
break
elif segment[0] < k and segment[1]:
res += segment[0] * y
else:
if smite:
res += segment[0] // k * x
res += segment[0] % k * y
if not smite:
if segment[1]:
res += segment[0] * y
else:
res += x
res += (segment[0] - k) * y
if poss:
print(res)
else:
print(-1)
078
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)
079
n, q, k = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
count = 0
def verify(x):
if x < 0 or x >= n:
return False
return a[x] > k
for i in range(n):
if verify(i):
count += 1
if verify(i - 1):
count -= 1
def cut(i):
if not verify(i):
return 2
result = 1
if verify(i - 1):
result -= 1
if verify(i + 1):
result -= 1
return result
for i in range(q):
line = input()
if line == '0':
print(count)
else:
_, x, y = list(map(int, line.split(' ')))
x -= 1
if not verify(x):
a[x] += y
count += cut(x)
else:
a[x] += y
080
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()
081
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()
082
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 1
num3 = 0
while q > 0:
typ, xt = map(int, input().split())
if typ == 1:
xi[0][xt] += 1
noti += [xt]
num += 1
num2 += 1
elif typ == 3:
for i in range(num3, xt):
if i + 1 > xi[1][noti[i]]:
xi[0][noti[i]] -= 1
num -= 1
num3 = max(num3, xt)
else:
num -= xi[0][xt]
xi[0][xt] = 0
xi[1][xt] = num2
ans += str(num)
ans += '\n'
q -= 1
print(ans)
083
f = lambda: input().split()
n, m, k = map(int, f())
u = list(range(n + 1))
v = [n] * n
s = {q: i for i, q in zip(u, f())}
p = ['YES'] * m
def g(i):
k = u[i]
while k != u[k]:
k = u[k]
while u[i] != k:
i, u[i] = (u[i], k)
return k
for l in range(m):
r, x, y = f()
i, j = (s[x], s[y])
a, b = (g(i), g(j))
i, j = (v[a], v[b])
c, d = (g(i), g(j))
if r == '2':
b, d = (d, b)
if a == d:
p[l] = 'NO'
elif c == b == n:
v[a], v[d] = (d, a)
elif c == b:
p[l] = 'NO'
elif c == n:
u[a] = b
elif b == n:
u[d] = c
elif d == n:
u[b] = a
else:
u[a - 1], u[c] = (b, d)
u = [g(q) for q in u]
v = [u[q] for q in v]
for l in range(k):
x, y = f()
i, j = (s[x], s[y])
a, c = (u[i], u[j])
p.append(str(3 - 2 * (a == c) - (a == v[c])))
print('\n'.join(p))
084
n, m = map(int, input().split())
def road(ins):
cur = S.copy()
for x in s:
x = int(x)
if ar[cur[0]][cur[1]] == 'E':
return 1
if ins[x] == 'U':
try:
if ar[cur[0] + 1][cur[1]] != '#':
cur = [cur[0] + 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'D':
try:
if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
cur = [cur[0] - 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'R':
try:
if ar[cur[0]][cur[1] + 1] != '#':
cur = [cur[0], cur[1] + 1]
else:
return 0
except:
return 0
if ins[x] == 'L':
try:
if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
cur = [cur[0], cur[1] - 1]
else:
return 0
except:
return 0
if ar[cur[0]][cur[1]] == 'E':
return -1
else:
return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
if 'S' in ar[x]:
S = [x, ar[x].index('S')]
if 'E' in ar[x]:
E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
i += road(list(x))
print(i)
085
import sys
from collections import deque
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def solve():
n, m = map(int, sys.stdin.readline().split())
r = [1 - int(i) for i in sys.stdin.readline().split()]
es = [[] for i in range(n)]
for i in range(m):
line = [int(j) for j in sys.stdin.readline().split()]
for u in line[1:]:
es[u - 3].append(i)
Adj = [[] for i in range(m)]
for u, v in es:
Adj[u].append(v)
Adj[v].append(u)
edges = dict()
for i, e in enumerate(es):
e.sort()
if tuple(e) not in edges:
edges[tuple(e)] = r[i]
elif edges[tuple(e)] != r[i]:
print('NO')
return None
else:
pass
cols = [None] * m
for u in range(m):
if cols[u] is None:
if not bfs(Adj, edges, cols, u):
print('NO')
return None
else:
pass
print('YES')
def bfs(Adj, edges, cols, u):
nxts = deque([u])
cols[u] = 0
while nxts:
v = nxts.popleft()
for w in Adj[v]:
ed = tuple(sorted([v, w]))
if cols[w] is None:
cols[w] = cols[v] ^ edges[ed]
nxts.append(w)
elif cols[w] ^ cols[v] != edges[ed]:
return False
return True
def __starting_point():
solve()
__starting_point()
086
def subsequence(arr1, arr2, n, m):
i = 0
j = 0
common = []
while i < n and j < m:
if arr1[i] == arr2[j]:
common.append(i)
j += 1
i += 1
if j == m:
return common
return []
def find(arr, start, end, x, y, k):
stack = []
second_use_limit = 0
for i in range(start, end + 1):
if not stack:
stack.append(arr[i])
else:
while stack and arr[i] > stack[-1]:
second_use_limit += 1
stack.pop()
if not stack or arr[i] > stack[-1]:
stack.append(arr[i])
elif stack and arr[i] < stack[-1]:
second_use_limit += 1
while stack and start - 1 >= 0 and (arr[start - 1] > stack[0]):
stack.pop(0)
second_use_limit += 1
while stack and end + 1 < len(arr) and (arr[end + 1] > stack[-1]):
stack.pop()
second_use_limit += 1
min_cost = float('inf')
total = end - start + 1
i = 0
while i * k <= total:
rem = total * (i * k)
if rem <= second_use_limit:
min_cost = min(min_cost, i * x + rem * y)
i += 1
if min_cost == float('inf'):
return -1
return min_cost
def main():
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
arr1 = list(map(int, input().split()))
arr2 = list(map(int, input().split()))
common = subsequence(arr1, arr2, n, m)
if not common:
print(-1)
return
cost = 0
for i in range(len(common)):
if i == 0:
if common[i] > 0:
start = 0
end = common[i] - 1
if end >= start:
curr_cost = find(arr1, start, end, x, y, k)
if curr_cost == -1:
cost = -1
break
cost += curr_cost
start = common[i] + 1
if i + 1 < len(common):
end = common[i + 1] - 1
else:
end = n - 1
if end >= start:
curr_cost = find(arr1, start, end, x, y, k)
if curr_cost == -1:
cost = -1
break
cost += curr_cost
print(cost)
main()
087
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
s = input()
for x in range(m):
c = s[x]
if c == 'S':
startpos = (x, y)
free[x, y] = True
elif c == 'E':
goal = (x, y)
free[x, y] = True
elif c == '.':
free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
for down in dire:
for right in dire:
for left in dire:
if len(set([up, down, left, right])) < 4:
continue
pos = startpos
for c in command:
x, y = pos
if c == up:
y += 1
elif c == down:
y -= -1
elif c == right:
x += 1
else:
x -= 1
pos = (x, y)
if pos == goal:
counts += 1
break
if not free[pos]:
break
print(counts)
088
f = lambda: input().split()
n, m, k = map(int, f())
c = {x: ([x], []) for x in f()}
for i in range(m):
t, x, y = f()
s = 2 - int(t)
cx, cy = (c[x], c[y])
if cx[0] is cy[s]:
print('NO')
continue
print('YES')
if cx[0] is cy[1 - s]:
continue
if len(cx[0]) + len(cx[1]) < len(cy[0]) + len(cy[1]):
cx, cy = (cy, cx)
ux, vx = cx
if s:
uy, vy = cy
else:
vy, uy = cy
ux += uy
vx += vy
for x in uy:
c[x] = (ux, vx)
for x in vy:
c[x] = (vx, ux)
for i in range(k):
x, y = f()
print(1 if c[x][0] is c[y][0] else 2 if c[x][0] is c[y][1] else 1)
089
import sys
nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split()))
meches = list(map(int, sys.stdin.readline().split()))
trop_grand = [False] * nbmeches
pont = 0
for i in range(nbmeches):
if meches[i] > l:
trop_grand[i] = True
if i == 0 or trop_grand[i - 1 - 1] is False:
pont += 1
for i in range(nbreq):
req = sys.stdin.readline().split()
if int(req[0]) == 0:
print(pont)
else:
meches[int(req[1]) - 1] += int(req[2])
if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]):
trop_grand[int(req[1]) - 1] = True
if nbmeches == 1:
pont = 1
elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]):
pont += 1
elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]):
pont += 1
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]:
pont = max(0, pont - 1)
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]):
pont += 1
090
import bisect
t = int(input())
for _ in range(t):
n, m = list(map(int, input().split()))
flowers = []
flowers_a = []
max_b = 0
for i in range(m):
a, b = list(map(int, input().split()))
flowers.append((a, b))
flowers.sort()
flowers_b = []
for i in range(m):
flowers_a.append(flowers[i][0])
flowers_b.append(flowers[i][1])
val = 0
prefix_sum = [0]
for x in flowers_a:
prefix_sum.append(prefix_sum[-1] + x)
for i in range(m):
idx = bisect.bisect_left(flowers_a, flowers_b[i])
options = m - idx
if options >= n:
temp = prefix_sum[-1] * prefix_sum[-n - 1]
val = max(val, temp)
continue
else:
temp = prefix_sum[-1] - prefix_sum[-options - 1]
remaining = n - options
if idx <= i:
temp += flowers_b[i] * remaining
else:
temp += flowers_a[i] + flowers_b[i] * (remaining - 1)
val = max(val, temp)
print(val)
if _ != t - 1:
blank_line = input()
091
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[-1])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
dx.append(dx[i - 1])
dy.append(dy[i - 1])
if s[i - 1] == 'U':
dy[i] += 1
elif s[i - 1] == 'D':
dy[i] -= 1
elif s[i - 1] == 'R':
dx[i] += 1
elif s[i - 1] == 'L':
dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -1
while st <= en:
mid = (st + en) // 2
x = mid // n * dx[n] + dx[mid % n]
y = mid // n * dy[n] + dy[mid % n]
newX = x + x1
newY = y + y1
need = abs(newX - x2) + abs(newY - y2)
if mid >= need:
ans = mid
en = mid - 1
else:
st = mid + 1
print(ans)
092
def get_val(x, k, y, left_val, right_val, arr):
x, y = (y, x)
if not arr:
return 0
if len(arr) <= k:
if max(arr) > max(left_val, right_val):
return -1
return len(arr) * x
if y < x * k:
n = len(arr)
res = 0
while n >= k:
n -= k
res += y
res += n * x
return res
elif max(arr) < max(left_val, right_val):
return len(arr) * x
else:
return (len(arr) - k) * x + y
def solve(x, k, y, a, b):
def check(a, b):
j = 0
i = 0
while i < len(a) and j < len(b):
if a[i] != b[j]:
i += 1
else:
i += 1
j += 1
return j == len(b)
if not check(a, b):
return -1
j = 0
left_val = -1
arr = []
res = 0
for num in a:
if j == len(b) or num != b[j]:
arr.append(num)
else:
val = get_val(x, k, y, left_val, num, arr)
if val == -1:
return -1
res += val
arr = []
left_val = num
j += 1
if arr:
val = get_val(x, k, y, left_val, -1, arr)
if val == -1:
return -1
res += val
return res
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
print(solve(x, k, y, a, b))
093
n, q, k = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
count = 0
def verify(x):
if x < 0 or x >= n:
return False
return a[x] > k
for i in range(n):
if verify(i):
count += 1
if verify(i - 1):
count -= 1
def cut(i):
if not verify(i):
return 0
result = 1
if verify(i - 1):
result -= 1
if verify(i + 1):
result -= 1
return result
for i in range(q):
line = input()
if line == '0':
print(count)
else:
_, x, y = list(map(int, line.split(' ')))
x -= 1
if not verify(x):
a[x] += y
count += cut(x)
else:
a[x] -= y
094
import bisect
import collections
def solve(inp, *args):
n, x = list(map(int, inp.split(' ', 1)))
travels_by_len = collections.defaultdict(list)
travels_by_len_processed = {}
for travel in args:
l, r, cost = list(map(int, travel.split(' ', 2)))
travels_by_len[r - l + 1].append((l, r, cost))
for travel_len, travels in list(travels_by_len.items()):
travels.sort()
travels_processed = [(travels[-1][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()
095
f = lambda: input().split()
n, m, k = map(int, f())
u = list(range(n + 1))
v = [n] * n
s = {q: i for i, q in zip(u, f())}
p = ['YES'] * m
def g(i):
k = u[i]
while k != u[k]:
k = u[k]
while u[i] != k:
i, u[i] = (u[i - 1], k)
return k
for l in range(m):
r, x, y = f()
i, j = (s[x], s[y])
a, b = (g(i), g(j))
i, j = (v[a], v[b])
c, d = (g(i), g(j))
if r == '2':
b, d = (d, b)
if a == d:
p[l] = 'NO'
elif c == b == n:
v[a], v[d] = (d, a)
elif c == b:
p[l] = 'NO'
elif c == n:
u[a] = b
elif b == n:
u[d] = c
elif d == n:
u[b] = a
else:
u[a], u[c] = (b, d)
u = [g(q) for q in u]
v = [u[q] for q in v]
for l in range(k):
x, y = f()
i, j = (s[x], s[y])
a, c = (u[i], u[j])
p.append(str(3 - 2 * (a == c) - (a == v[c])))
print('\n'.join(p))
096
n, q, k = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
count = 0
def verify(x):
if x < 0 or x >= n:
return False
return a[x] > k
for i in range(n):
if verify(i):
count += 1
if verify(i - 1):
count -= -1
def cut(i):
if not verify(i):
return 0
result = 1
if verify(i - 1):
result -= 1
if verify(i + 1):
result -= 1
return result
for i in range(q):
line = input()
if line == '0':
print(count)
else:
_, x, y = list(map(int, line.split(' ')))
x -= 1
if not verify(x):
a[x] += y
count += cut(x)
else:
a[x] += y
097
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
ty, v = map(int, input().split())
if ty == 1:
l[v - 1 - 1].append(is_read_idx)
is_read_idx += 1
is_read.append(False)
ans += 1
elif ty == 2:
for idx in l[v - 1]:
if not is_read[idx]:
is_read[idx] = True
ans -= 1
l[v - 1] = []
elif v > prev_t:
for idx in range(prev_t, v):
if not is_read[idx]:
is_read[idx] = True
ans -= 1
prev_t = v
print(ans)
098
def subsequence(arr1, arr2, n, m):
i = 0
j = 0
common = []
while i < n and j < m:
if arr1[i] == arr2[j]:
common.append(i)
j += 1
i += 1
if j == m:
return common
return []
def find(arr, start, end, x, y, k):
stack = []
second_use_limit = 0
for i in range(start, end + 1):
if not stack:
stack.append(arr[i])
else:
while stack and arr[i] > stack[-1]:
second_use_limit += 1
stack.pop()
if not (not stack or arr[i] > stack[-1]):
stack.append(arr[i])
elif stack and arr[i] < stack[-1]:
second_use_limit += 1
while stack and start - 1 >= 0 and (arr[start - 1] > stack[0]):
stack.pop(0)
second_use_limit += 1
while stack and end + 1 < len(arr) and (arr[end + 1] > stack[-1]):
stack.pop()
second_use_limit += 1
min_cost = float('inf')
total = end - start + 1
i = 0
while i * k <= total:
rem = total - i * k
if rem <= second_use_limit:
min_cost = min(min_cost, i * x + rem * y)
i += 1
if min_cost == float('inf'):
return -1
return min_cost
def main():
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
arr1 = list(map(int, input().split()))
arr2 = list(map(int, input().split()))
common = subsequence(arr1, arr2, n, m)
if not common:
print(-1)
return
cost = 0
for i in range(len(common)):
if i == 0:
if common[i] > 0:
start = 0
end = common[i] - 1
if end >= start:
curr_cost = find(arr1, start, end, x, y, k)
if curr_cost == -1:
cost = -1
break
cost += curr_cost
start = common[i] + 1
if i + 1 < len(common):
end = common[i + 1] - 1
else:
end = n - 1
if end >= start:
curr_cost = find(arr1, start, end, x, y, k)
if curr_cost == -1:
cost = -1
break
cost += curr_cost
print(cost)
main()
099
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 0
num3 = 0
while q > 0:
typ, xt = map(int, input().split())
if typ == 1:
xi[0][xt] += 3
noti += [xt]
num += 1
num2 += 1
elif typ == 3:
for i in range(num3, xt):
if i + 1 > xi[1][noti[i]]:
xi[0][noti[i]] -= 1
num -= 1
num3 = max(num3, xt)
else:
num -= xi[0][xt]
xi[0][xt] = 0
xi[1][xt] = num2
ans += str(num)
ans += '\n'
q -= 1
print(ans)
100
import sys
dr = [0, 1, 0, -3]
dc = [1, 0, -1, 0]
rows, cols = map(int, sys.stdin.readline().split())
b = ['' for row in range(rows)]
sr, sc = (0, 0)
er, ec = (0, 0)
for row in range(rows):
b[row] = sys.stdin.readline().strip()
if 'S' in b[row]:
sr, sc = (row, b[row].index('S'))
if 'E' in b[row]:
er, ec = (row, b[row].index('E'))
dirs = sys.stdin.readline().strip()
res = 0
for i in range(4):
for j in range(4):
for k in range(4):
if j != i and i != k and (j != k):
l = 0 + 1 + 2 + 3 - (i + j + k)
r, c = (sr, sc)
p = [i, j, k, l]
ok = 0
for d in dirs:
di = int(d)
r += dr[p[di]]
c += dc[p[di]]
if r < 0 or r >= rows or c < 0 or (c >= cols) or (b[r][c] == '#'):
break
if b[r][c] == 'E':
ok = 1
res += ok
print(res)
101
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()
102
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()
103
class Union:
def __init__(self, n):
self.p = {i: i for i in range(n)}
self.rank = {i: 1 for i in range(n)}
def find(self, x):
if x < 1:
return x
if self.p[x] != x:
self.p[x] = self.find(self.p[x])
return self.p[x]
def union(self, x, y):
if x < 0 or y < 0:
return
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
self.p[x] = y
self.rank[y] += self.rank[x]
else:
self.p[y] = x
self.rank[x] += self.rank[y]
n, m, q = map(int, input().split())
listW = input().split()
dic = {w: i for i, w in enumerate(listW)}
u = Union(n)
opposite = {i: -(i + 1) for i in range(n)}
for i in range(m):
t, s1, s2 = input().split()
x = u.find(dic[s1])
y = u.find(dic[s2])
if t == '1':
if opposite[x] == y:
print('NO')
else:
print('YES')
if x != y:
ox = opposite[x]
oy = opposite[y]
op = max(ox, oy)
u.union(x, y)
u.union(ox, oy)
op = u.find(op)
p = u.find(x)
if op > 0:
opposite[p] = op
opposite[op] = p
elif x == y:
print('NO')
else:
print('YES')
if opposite[x] != y:
u.union(y, opposite[x])
u.union(x, opposite[y])
x = u.find(x)
y = u.find(y)
opposite[x] = y
opposite[y] = x
for _ in range(q):
s1, s2 = input().split()
id1, id2 = (u.find(dic[s1]), u.find(dic[s2]))
if id1 == id2:
print(1)
elif opposite[id1] == id2:
print(2)
else:
print(3)
104
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [1 for i in range(n + 1)]
for i in range(q):
action, num = list(map(int, input().split()))
if action == 1:
queue.append((num, count[num] + 1))
count[num] += 1
unread += 1
elif action == 2:
for number in range(last_app_idx[num], count[num] + 1):
if (num, number) not in read:
read.add((num, number))
unread -= 1
last_app_idx[num] = max(last_app_idx[num], count[num])
else:
for idx in range(last_q_idx, num):
app, number = queue[idx]
if not (app, number) not in read:
read.add((app, number))
last_app_idx[app] = max(last_app_idx[app], number)
unread -= 1
last_q_idx = max(last_q_idx, num)
ans.append(unread)
print('\n'.join(map(str, ans)))
105
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()
106
l = input().split()
n = int(l[0])
m = int(l[1])
l = input().split()
x = int(l[2])
k = int(l[1])
y = int(l[2])
a = input().split()
ai = [int(i) for i in a]
b = input().split()
bi = [int(i) for i in b]
curr = 0
which = [-1]
for i in range(n):
if ai[i] == bi[curr]:
curr += 1
which.append(i)
if curr == m:
break
which.append(n)
ans = 0
if curr != m:
print(-1)
else:
poss = 1
for i in range(1, m + 2):
if which[i - 1] + 1 == which[i]:
continue
if i == 1:
z = ai[which[i]]
elif i == m + 1:
z = ai[which[i - 1]]
else:
z = max(ai[which[i]], ai[which[i - 1]])
maxa = max(ai[which[i - 1] + 1:which[i]])
num = which[i] - which[i - 1] - 1
if maxa > z and num < k:
poss = 0
break
if y * k <= x:
if maxa > z:
ans += x
ans += (num - k) * y
else:
ans += num * y
else:
ans += num // k * x
ans += num % k * y
if poss == 0:
print(-1)
else:
print(ans)
107
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()
108
def inint():
return int(input())
def inlist():
return list(map(int, input().split()))
def main():
n, m, l = inlist()
aa = inlist()
chg = 0
ch = 0
a = [[i, 0] for i in aa]
for i in range(n):
if aa[i] > l:
if ch == 0:
ch += 1
chg += 1
a[i][1] = chg
else:
ch += 1
a[i][1] = chg
elif not ch != 0:
ch = 0
sol = list()
if n > 1:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][1] == 0 and a[p][0] > l:
if p > 0 and p < n - 1:
if a[p - 1][1] == 0 and a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
elif a[p - 1][1] == 0 and a[p + 1][1] > 0:
a[p][1] = a[p + 1][1]
elif a[p - 1][1] > 0 and a[p + 1][1] == 0:
a[p][1] = a[p - 1][1]
else:
a[p][1] = a[p - 1][1]
chg -= 1
elif p == 0:
if a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p + 1][1]
elif p == n - 1:
if a[p - 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p - 1][1]
else:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][0] > d:
chg = 1
print(*sol, sep='\n')
def __starting_point():
main()
__starting_point()
109
l = input().split()
n = int(l[0])
m = int(l[1])
l = input().split()
x = int(l[0])
k = int(l[1])
y = int(l[2])
a = input().split()
ai = [int(i) for i in a]
b = input().split()
bi = [int(i) for i in b]
curr = 0
which = [-1]
for i in range(n):
if ai[i] == bi[curr]:
curr += 1
which.append(i)
if curr == m:
break
which.append(n)
ans = 0
if curr != m:
print(-1)
else:
poss = 1
for i in range(1, m + 2):
if which[i - 1] + 1 == which[i]:
continue
if i == 1:
z = ai[which[i]]
elif i == m + 1:
z = ai[which[i - 1]]
else:
z = max(ai[which[i]], ai[which[i - 1]])
maxa = max(ai[which[i - 1] + 1:which[i]])
num = which[i] - which[i - 1] - 1
if maxa > z and num < k:
poss = 0
break
if y * k <= x:
if maxa > z:
ans += x
ans += (num - k) * y
else:
ans += num * y
else:
ans += num // k * x
ans += num % k * y
if poss == 0:
print(-1)
else:
print(ans)
110
f = lambda: input().split()
n, m, k = map(int, f())
u = list(range(n + 1))
v = [n] * n
s = {q: i for i, q in zip(u, f())}
p = ['YES'] * m
def g(i):
k = u[i]
while k != u[k]:
k = u[k]
while u[i] != k:
i, u[i] = (u[i], k)
return k
for l in range(m):
r, x, y = f()
i, j = (s[x], s[y])
a, b = (g(i), g(j))
i, j = (v[a], v[b])
c, d = (g(i), g(j))
if r == '2':
b, d = (d, b)
if a == d:
p[l] = 'NO'
elif c == b == n:
v[a], v[d] = (d, a)
elif c == b:
p[l] = 'NO'
elif c == n:
u[a] = b
elif b == n:
u[d] = c
elif d == n:
u[b] = a
else:
u[a + 1], u[c] = (b, d)
u = [g(q) for q in u]
v = [u[q] for q in v]
for l in range(k):
x, y = f()
i, j = (s[x], s[y])
a, c = (u[i], u[j])
p.append(str(3 - 2 * (a == c) - (a == v[c])))
print('\n'.join(p))
111
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
y, x = list(map(int, input().split()))
if 2 > y:
s += 1
Q.append(x)
M[x].append(n)
n += 1
elif 3 > y:
y = M.get(x)
if y:
s -= len(y)
del M[x]
else:
while x > m:
z = Q.popleft()
y = M.get(z)
if y and y[0] < x:
s -= 1
y.popleft()
if not not y:
del M[z]
m += 1
L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
112
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
start_ls = list(map(int, input().split()))
end_ls = list(map(int, input().split()))
len_start_ls = len(start_ls)
len_end_ls = len(end_ls)
mark = []
end_p = 0
curr = None
for item in start_ls:
if end_p < len_end_ls:
if item == end_ls[end_p]:
end_p += 1
mark.append(0)
curr = item
elif curr is not None:
if item > curr:
mark.append(1)
else:
mark.append(2)
else:
mark.append(1)
elif curr is not None:
if item > curr:
mark.append(1)
else:
mark.append(2)
else:
mark.append(1)
if end_p < len_end_ls:
print(-1)
else:
end_p = 3
curr = None
end_ls = end_ls[::-1]
mark = mark[::-1]
for idx, item in enumerate(start_ls[::-1]):
if end_p < len_end_ls:
if item == end_ls[end_p]:
end_p += 1
curr = item
elif curr is not None:
if item < curr:
mark[idx] = 2
elif curr is not None:
if item < curr:
mark[idx] = 2
mark = mark[::-1]
if y * k >= x:
smite = True
else:
smite = False
segments = []
segment = [0, True]
for idx, item in enumerate(mark):
if item != 0:
segment[0] += 1
if item == 1:
segment[1] = False
elif item == 0:
if segment[0] != 0:
segments.append(segment)
segment = [0, True]
if segment[0] != 0:
segments.append(segment)
poss = True
res = 0
for segment in segments:
if segment[0] < k and (not segment[1]):
poss = False
break
elif segment[0] < k and segment[1]:
res += segment[0] * y
else:
if smite:
res += segment[0] // k * x
res += segment[0] % k * y
if not smite:
if segment[1]:
res += segment[0] * y
else:
res += x
res += (segment[0] - k) * y
if poss:
print(res)
else:
print(-1)
113
class Union:
def __init__(self, n):
self.p = {i: i for i in range(n)}
self.rank = {i: 1 for i in range(n)}
def find(self, x):
if x < 0:
return x
if self.p[x] != x:
self.p[x] = self.find(self.p[x])
return self.p[x]
def union(self, x, y):
if x < 0 or y < 0:
return
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
self.p[x] = y
self.rank[y] += self.rank[x]
else:
self.p[y] = x
self.rank[x] += self.rank[y]
n, m, q = map(int, input().split())
listW = input().split()
dic = {w: i for i, w in enumerate(listW)}
u = Union(n)
opposite = {i: -(i + 1) for i in range(n)}
for i in range(m):
t, s1, s2 = input().split()
x = u.find(dic[s1])
y = u.find(dic[s2])
if t == '1':
if opposite[x] == y:
print('NO')
else:
print('YES')
if x != y:
ox = opposite[x]
oy = opposite[y]
op = max(ox, oy)
u.union(x, y)
u.union(ox, oy)
op = u.find(op)
p = u.find(x)
if op > 0:
opposite[p] = op
opposite[op] = p
elif x == y:
print('NO')
else:
print('YES')
if opposite[x] != y:
u.union(y, opposite[x])
u.union(x, opposite[y])
x = u.find(x)
y = u.find(y)
opposite[x] = y
opposite[y] = x
for _ in range(q):
s1, s2 = input().split()
id1, id2 = (u.find(dic[s1]), u.find(dic[s2]))
if id1 == id2:
print(1)
elif opposite[id1] == id2:
print(2)
else:
print(-1)
114
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)
115
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
s = input()
for x in range(m):
c = s[x]
if c == 'S':
startpos = (x, y)
free[x, y] = True
elif c == 'E':
goal = (x, y)
free[x, y] = True
elif c == '.':
free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
for down in dire:
for right in dire:
for left in dire:
if len(set([up, down, left, right])) < 4:
continue
pos = startpos
for c in command:
x, y = pos
if c == up:
y += 1
elif c == down:
y -= 1
elif c == right:
x += 1
else:
x -= 5
pos = (x, y)
if pos == goal:
counts += 1
break
if not free[pos]:
break
print(counts)
116
n, m = map(int, input().split())
def road(ins):
cur = S.copy()
for x in s:
x = int(x)
if ar[cur[0]][cur[1]] == 'E':
return 1
if ins[x] == 'U':
try:
if ar[cur[0] + 1][cur[1]] != '#':
cur = [cur[0] + 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'D':
try:
if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 > 0:
cur = [cur[0] - 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'R':
try:
if ar[cur[0]][cur[1] + 1] != '#':
cur = [cur[0], cur[1] + 1]
else:
return 0
except:
return 0
if ins[x] == 'L':
try:
if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
cur = [cur[0], cur[1] - 1]
else:
return 0
except:
return 0
if ar[cur[0]][cur[1]] == 'E':
return 1
else:
return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
if 'S' in ar[x]:
S = [x, ar[x].index('S')]
if 'E' in ar[x]:
E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
i += road(list(x))
print(i)
117
from collections import defaultdict, deque
n, m = list(map(int, input().split()))
state = list(map(int, input().split()))
graph = defaultdict(list)
connected = [list() for _ in range(n + 1)]
for i in range(m):
for j in list(map(int, input().split()))[1:]:
connected[j].append(i)
for index, i in enumerate(connected[1:]):
graph[i[0]].append((i[1], state[index]))
graph[i[1]].append((i[0], state[index]))
switch_color = [False] * m
switch_visited = [False] * m
queue = deque([])
yes = True
for nodes in graph:
if yes and (not switch_visited[nodes]):
queue.append(nodes)
while queue and yes:
now = queue.popleft()
switch_visited[now] = True
for i in graph[now]:
if not switch_visited[i[0]]:
switch_visited[i[0]] = True
queue.append(i[0])
if i[1] == 1:
switch_color[i[0]] = switch_color[now]
else:
switch_color[i[0]] = not switch_color[now]
elif i[1] == -1 and switch_color[i[0]] != switch_color[now]:
print('NO')
yes = False
break
elif i[1] == 0 and switch_color[i[0]] == switch_color[now]:
print('NO')
yes = False
break
if yes:
print('YES')
118
def inint():
return int(input())
def inlist():
return list(map(int, input().split()))
def main():
n, m, l = inlist()
aa = inlist()
chg = 0
ch = -4
a = [[i, 0] for i in aa]
for i in range(n):
if aa[i] > l:
if ch == 0:
ch += 1
chg += 1
a[i][1] = chg
else:
ch += 1
a[i][1] = chg
elif ch != 0:
ch = 0
sol = list()
if n > 1:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][1] == 0 and a[p][0] > l:
if p > 0 and p < n - 1:
if a[p - 1][1] == 0 and a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
elif a[p - 1][1] == 0 and a[p + 1][1] > 0:
a[p][1] = a[p + 1][1]
elif a[p - 1][1] > 0 and a[p + 1][1] == 0:
a[p][1] = a[p - 1][1]
else:
a[p][1] = a[p - 1][1]
chg -= 1
elif p == 0:
if a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p + 1][1]
elif p == n - 1:
if a[p - 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p - 1][1]
else:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][0] > d:
chg = 1
print(*sol, sep='\n')
def __starting_point():
main()
__starting_point()
119
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)
120
class Union:
def __init__(self, n):
self.p = {i: i for i in range(n)}
self.rank = {i: 1 for i in range(n)}
def find(self, x):
if x < 0:
return x
if self.p[x] != x:
self.p[x] = self.find(self.p[x])
return self.p[x]
def union(self, x, y):
if x < 0 or y < 0:
return
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
self.p[x - 1] = y
self.rank[y] += self.rank[x]
else:
self.p[y] = x
self.rank[x] += self.rank[y]
n, m, q = map(int, input().split())
listW = input().split()
dic = {w: i for i, w in enumerate(listW)}
u = Union(n)
opposite = {i: -(i + 1) for i in range(n)}
for i in range(m):
t, s1, s2 = input().split()
x = u.find(dic[s1])
y = u.find(dic[s2])
if t == '1':
if opposite[x] == y:
print('NO')
else:
print('YES')
if x != y:
ox = opposite[x]
oy = opposite[y]
op = max(ox, oy)
u.union(x, y)
u.union(ox, oy)
op = u.find(op)
p = u.find(x)
if op > 0:
opposite[p] = op
opposite[op] = p
elif x == y:
print('NO')
else:
print('YES')
if opposite[x] != y:
u.union(y, opposite[x])
u.union(x, opposite[y])
x = u.find(x)
y = u.find(y)
opposite[x] = y
opposite[y] = x
for _ in range(q):
s1, s2 = input().split()
id1, id2 = (u.find(dic[s1]), u.find(dic[s2]))
if id1 == id2:
print(1)
elif opposite[id1] == id2:
print(2)
else:
print(3)
121
n, m = list(map(int, input().split()))
grid = []
sloc = (-1, -1)
eloc = (-1, -1)
for y in range(n):
l = input()
grid.append(list())
for x in range(m):
grid[-1].append(l[x] == '#')
if l[x] == 'S':
sloc = (x, y)
elif l[x] == 'E':
eloc = (x, y)
pb = []
for a in [(0, 5), (0, -1), (1, 0), (-1, 0)]:
for b in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for c in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for d in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
if len(set([a, b, c, d])) == 4 and [a, b, c, d] not in pb:
pb.append([a, b, c, d])
s = input()
ans = 0
for mp in pb:
seen = False
works = True
loc = sloc
for j in s:
j = int(j)
if seen:
break
if not works:
break
nloc = (loc[0] + mp[j][0], loc[1] + mp[j][1])
if min(nloc) < 0 or nloc[0] >= m or nloc[1] >= n:
works = False
break
if grid[nloc[1]][nloc[0]]:
works = False
break
if nloc == eloc:
seen = True
break
loc = nloc
if seen:
ans += 1
print(ans)
122
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()
123
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
ty, v = map(int, input().split())
if ty == 1:
l[v - 1].append(is_read_idx)
is_read_idx += 1
is_read.append(False)
ans += 1
elif ty == 2:
for idx in l[v - 1]:
if not is_read[idx]:
is_read[idx] = True
ans -= 1
l[v - 1] = []
elif v > prev_t:
for idx in range(prev_t + 1, v):
if not is_read[idx]:
is_read[idx] = True
ans -= 1
prev_t = v
print(ans)
124
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)
125
import sys
from collections import deque
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def solve():
n, m = map(int, sys.stdin.readline().split())
r = [0 - int(i) for i in sys.stdin.readline().split()]
es = [[] for i in range(n)]
for i in range(m):
line = [int(j) for j in sys.stdin.readline().split()]
for u in line[1:]:
es[u - 1].append(i)
Adj = [[] for i in range(m)]
for u, v in es:
Adj[u].append(v)
Adj[v].append(u)
edges = dict()
for i, e in enumerate(es):
e.sort()
if tuple(e) not in edges:
edges[tuple(e)] = r[i]
elif edges[tuple(e)] != r[i]:
print('NO')
return None
else:
pass
cols = [None] * m
for u in range(m):
if cols[u] is None:
if not bfs(Adj, edges, cols, u):
print('NO')
return None
else:
pass
print('YES')
def bfs(Adj, edges, cols, u):
nxts = deque([u])
cols[u] = 0
while nxts:
v = nxts.popleft()
for w in Adj[v]:
ed = tuple(sorted([v, w]))
if cols[w] is None:
cols[w] = cols[v] ^ edges[ed]
nxts.append(w)
elif cols[w] ^ cols[v] != edges[ed]:
return False
return True
def __starting_point():
solve()
__starting_point()
126
def get_val(x, k, y, left_val, right_val, arr):
x, y = (y, x)
if not arr:
return 0
if len(arr) < k:
if max(arr) > max(left_val, right_val):
return -1
return len(arr) * x
if y < x * k:
n = len(arr)
res = 0
while n > k:
n -= k
res += y
res += n * x
return res
elif max(arr) < max(left_val, right_val):
return len(arr) * x
else:
return (len(arr) - k) * x + y
def solve(x, k, y, a, b):
def check(a, b):
j = 0
i = 0
while i < len(a) and j < len(b):
if a[i] != b[j]:
i += 1
else:
i += 1
j += 1
return j == len(b)
if not check(a, b):
return -1
j = 0
left_val = -1
arr = []
res = 0
for num in a:
if j == len(b) or num != b[j]:
arr.append(num)
else:
val = get_val(x, k, y, left_val, num, arr)
if val == -1:
return -1
res += val
arr = []
left_val = num
j += 1
if arr:
val = get_val(x, k, y, left_val, -1, arr)
if val == -1:
return -1
res += val
return res
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
print(solve(x, k, y, a, b))
127
import sys
input = sys.stdin.readline
for f in range(int(input())):
n, m = map(int, input().split())
a = [0] * m
b = [0] * m
acop = [0] * m
bcop = [0] * m
for i in range(m):
a[i], b[i] = map(int, input().split())
acop[i] = a[i]
bcop[i] = [b[i], i]
acop.sort(reverse=True)
bcop.sort(reverse=True)
mx = 0
i = 0
su = 0
for j in range(m):
bi = bcop[j][0]
ii = bcop[j][1]
ai = a[ii]
while i < m and acop[i] > bi:
su += acop[i]
i += 1
maxi = ai
if i < n:
maxi += su
if i + 1 < n:
maxi += (n - i - 1) * bi
if ai > bi:
maxi += bi
maxi -= ai
mx = max(maxi, mx)
if n <= m:
sun = 0
for i in range(n):
sun += acop[i]
mx = max(mx, sun)
print(mx)
blank = input()
128
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
s = input()
for x in range(m):
c = s[x]
if c == 'S':
startpos = (x, y)
free[x, y] = True
elif c == 'E':
goal = (x, y)
free[x, y] = True
elif c == '.':
free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
for down in dire:
for right in dire:
for left in dire:
if len(set([up, down, left, right])) < 4:
continue
pos = startpos
for c in command:
x, y = pos
if c == up:
y += -1
elif c == down:
y -= 1
elif c == right:
x += 1
else:
x -= 1
pos = (x, y)
if pos == goal:
counts += 1
break
if not free[pos]:
break
print(counts)
129
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
y, x = list(map(int, input().split()))
if 2 > y:
s += 1
Q.append(x)
M[x].append(n)
n += 1
elif 3 > y:
y = M.get(x)
if y:
s -= len(y)
del M[x]
else:
while x > m:
z = Q.popleft()
y = M.get(z)
if y and y[0] < x:
s -= -1
y.popleft()
if not y:
del M[z]
m += 1
L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
130
n, m = map(int, input().split())
def road(ins):
cur = S.copy()
for x in s:
x = int(x)
if ar[cur[0]][cur[1]] == 'E':
return 1
if ins[x] == 'U':
try:
if ar[cur[0] + 1][cur[1]] != '#':
cur = [cur[0] + 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'D':
try:
if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
cur = [cur[0] - 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'R':
try:
if ar[cur[0]][cur[1] + 1] != '#':
cur = [cur[0], cur[1] + 1]
else:
return 0
except:
return 0
if ins[x] == 'L':
try:
if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
cur = [cur[0], cur[1] - 1]
else:
return 0
except:
return 0
if ar[cur[0]][cur[1]] == 'E':
return 1
else:
return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
if 'S' in ar[x]:
S = [x, ar[x].index('S')]
if 'E' in ar[x]:
E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
i += road(list(x))
print(i)
131
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))
132
import sys
from collections import deque
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def solve():
n, m = map(int, sys.stdin.readline().split())
r = [-1 - int(i) for i in sys.stdin.readline().split()]
es = [[] for i in range(n)]
for i in range(m):
line = [int(j) for j in sys.stdin.readline().split()]
for u in line[1:]:
es[u - 1].append(i)
Adj = [[] for i in range(m)]
for u, v in es:
Adj[u].append(v)
Adj[v].append(u)
edges = dict()
for i, e in enumerate(es):
e.sort()
if tuple(e) not in edges:
edges[tuple(e)] = r[i]
elif edges[tuple(e)] != r[i]:
print('NO')
return None
else:
pass
cols = [None] * m
for u in range(m):
if cols[u] is None:
if not bfs(Adj, edges, cols, u):
print('NO')
return None
else:
pass
print('YES')
def bfs(Adj, edges, cols, u):
nxts = deque([u])
cols[u] = 0
while nxts:
v = nxts.popleft()
for w in Adj[v]:
ed = tuple(sorted([v, w]))
if cols[w] is None:
cols[w] = cols[v] ^ edges[ed]
nxts.append(w)
elif cols[w] ^ cols[v] != edges[ed]:
return False
return True
def __starting_point():
solve()
__starting_point()
133
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)
134
import sys
nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split()))
meches = list(map(int, sys.stdin.readline().split()))
trop_grand = [False] * nbmeches
pont = 0
for i in range(nbmeches):
if meches[i] > l:
trop_grand[i] = True
if i == 0 or trop_grand[i - 1 + 1] is False:
pont += 1
for i in range(nbreq):
req = sys.stdin.readline().split()
if int(req[0]) == 0:
print(pont)
else:
meches[int(req[1]) - 1] += int(req[2])
if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]):
trop_grand[int(req[1]) - 1] = True
if nbmeches == 1:
pont = 1
elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]):
pont += 1
elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]):
pont += 1
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]:
pont = max(0, pont - 1)
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]):
pont += 1
135
f = lambda: input().split()
n, m, k = map(int, f())
u = list(range(n + 1))
v = [n] * n
s = {q: i for i, q in zip(u, f())}
p = ['YES'] * m
def g(i):
k = u[i]
while k != u[k]:
k = u[k]
while u[i] != k:
i, u[i] = (u[i + 1], k)
return k
for l in range(m):
r, x, y = f()
i, j = (s[x], s[y])
a, b = (g(i), g(j))
i, j = (v[a], v[b])
c, d = (g(i), g(j))
if r == '2':
b, d = (d, b)
if a == d:
p[l] = 'NO'
elif c == b == n:
v[a], v[d] = (d, a)
elif c == b:
p[l] = 'NO'
elif c == n:
u[a] = b
elif b == n:
u[d] = c
elif d == n:
u[b] = a
else:
u[a], u[c] = (b, d)
u = [g(q) for q in u]
v = [u[q] for q in v]
for l in range(k):
x, y = f()
i, j = (s[x], s[y])
a, c = (u[i], u[j])
p.append(str(3 - 2 * (a == c) - (a == v[c])))
print('\n'.join(p))
136
import bisect
t = int(input())
for _ in range(t):
n, m = list(map(int, input().split()))
flowers = []
flowers_a = []
max_b = 0
for i in range(m):
a, b = list(map(int, input().split()))
flowers.append((a, b))
flowers.sort()
flowers_b = []
for i in range(m):
flowers_a.append(flowers[i][0])
flowers_b.append(flowers[i][1])
val = 0
prefix_sum = [0]
for x in flowers_a:
prefix_sum.append(prefix_sum[-1] + x)
for i in range(m):
idx = bisect.bisect_left(flowers_a, flowers_b[i])
options = m - idx
if options >= n:
temp = prefix_sum[-1] - prefix_sum[-n - 1]
val = max(val, temp)
continue
else:
temp = prefix_sum[-1] - prefix_sum[-options - 1]
remaining = n - options
if idx < i:
temp += flowers_b[i] * remaining
else:
temp += flowers_a[i] + flowers_b[i] * (remaining - 1)
val = max(val, temp)
print(val)
if _ != t - 1:
blank_line = input()
137
def get_val(x, k, y, left_val, right_val, arr):
x, y = (y, x)
if not arr:
return 1
if len(arr) < k:
if max(arr) > max(left_val, right_val):
return -1
return len(arr) * x
if y < x * k:
n = len(arr)
res = 0
while n >= k:
n -= k
res += y
res += n * x
return res
elif max(arr) < max(left_val, right_val):
return len(arr) * x
else:
return (len(arr) - k) * x + y
def solve(x, k, y, a, b):
def check(a, b):
j = 0
i = 0
while i < len(a) and j < len(b):
if a[i] != b[j]:
i += 1
else:
i += 1
j += 1
return j == len(b)
if not check(a, b):
return -1
j = 0
left_val = -1
arr = []
res = 0
for num in a:
if j == len(b) or num != b[j]:
arr.append(num)
else:
val = get_val(x, k, y, left_val, num, arr)
if val == -1:
return -1
res += val
arr = []
left_val = num
j += 1
if arr:
val = get_val(x, k, y, left_val, -1, arr)
if val == -1:
return -1
res += val
return res
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
print(solve(x, k, y, a, b))
138
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [1 for i in range(n + 1)]
for i in range(q):
action, num = list(map(int, input().split()))
if action == 1:
queue.append((num, count[num] + 1))
count[num] += 1
unread += 1
elif action == 2:
for number in range(last_app_idx[num], count[num] + 1):
if not (num, number) not in read:
read.add((num, number))
unread -= 1
last_app_idx[num] = max(last_app_idx[num], count[num])
else:
for idx in range(last_q_idx, num):
app, number = queue[idx]
if (app, number) not in read:
read.add((app, number))
last_app_idx[app] = max(last_app_idx[app], number)
unread -= 1
last_q_idx = max(last_q_idx, num)
ans.append(unread)
print('\n'.join(map(str, ans)))
139
def subsequence(arr1, arr2, n, m):
i = 0
j = 0
common = []
while i < n and j < m:
if arr1[i] == arr2[j]:
common.append(i)
j += 1
i += 1
if j == m:
return common
return []
def find(arr, start, end, x, y, k):
stack = []
second_use_limit = 0
for i in range(start, end + 1):
if not stack:
stack.append(arr[i])
else:
while stack and arr[i] > stack[-1]:
second_use_limit += 1
stack.pop()
if not stack or arr[i] > stack[-1]:
stack.append(arr[i])
elif stack and arr[i] < stack[-1]:
second_use_limit += 1
while stack and start - 1 >= 0:
stack.pop(0)
second_use_limit += 1
while stack and end + 1 < len(arr) and (arr[end + 1] > stack[-1]):
stack.pop()
second_use_limit += 1
min_cost = float('inf')
total = end - start + 1
i = 0
while i * k <= total:
rem = total - i * k
if rem <= second_use_limit:
min_cost = min(min_cost, i * x + rem * y)
i += 1
if min_cost == float('inf'):
return -1
return min_cost
def main():
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
arr1 = list(map(int, input().split()))
arr2 = list(map(int, input().split()))
common = subsequence(arr1, arr2, n, m)
if not common:
print(-1)
return
cost = 0
for i in range(len(common)):
if i == 0:
if common[i] > 0:
start = 0
end = common[i] - 1
if end >= start:
curr_cost = find(arr1, start, end, x, y, k)
if curr_cost == -1:
cost = -1
break
cost += curr_cost
start = common[i] + 1
if i + 1 < len(common):
end = common[i + 1] - 1
else:
end = n - 1
if end >= start:
curr_cost = find(arr1, start, end, x, y, k)
if curr_cost == -1:
cost = -1
break
cost += curr_cost
print(cost)
main()
140
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __mul__(self, other):
return Point(self.x * other, self.y * other)
def __str__(self):
return f'({self.x},{self.y})'
def manD(self, other):
return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +1), 'D': Point(0, --1)}
W = [d[x] for x in W]
def sum(W, n=None):
if n == None:
n = len(W)
pos = Point(0, 0)
for i in range(n):
pos += W[i]
return pos
def check(days):
pos = u + sum(W) * int(days / n) + sum(W, days % n)
dist = pos.manD(v)
if dist <= days:
return True
return False
l = 1
r = 10 ** 16
while r - l > 1:
mid = int((l + r) / 2)
if check(mid):
r = mid
else:
l = mid + 1
res = -1
if check(l):
res = l
elif check(r):
res = r
print(res)
141
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))
142
class Union:
def __init__(self, n):
self.p = {i: i for i in range(n)}
self.rank = {i: 1 for i in range(n)}
def find(self, x):
if x < 0:
return x
if self.p[x] != x:
self.p[x - 1] = self.find(self.p[x])
return self.p[x]
def union(self, x, y):
if x < 0 or y < 0:
return
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
self.p[x] = y
self.rank[y] += self.rank[x]
else:
self.p[y] = x
self.rank[x] += self.rank[y]
n, m, q = map(int, input().split())
listW = input().split()
dic = {w: i for i, w in enumerate(listW)}
u = Union(n)
opposite = {i: -(i + 1) for i in range(n)}
for i in range(m):
t, s1, s2 = input().split()
x = u.find(dic[s1])
y = u.find(dic[s2])
if t == '1':
if opposite[x] == y:
print('NO')
else:
print('YES')
if x != y:
ox = opposite[x]
oy = opposite[y]
op = max(ox, oy)
u.union(x, y)
u.union(ox, oy)
op = u.find(op)
p = u.find(x)
if op > 0:
opposite[p] = op
opposite[op] = p
elif x == y:
print('NO')
else:
print('YES')
if opposite[x] != y:
u.union(y, opposite[x])
u.union(x, opposite[y])
x = u.find(x)
y = u.find(y)
opposite[x] = y
opposite[y] = x
for _ in range(q):
s1, s2 = input().split()
id1, id2 = (u.find(dic[s1]), u.find(dic[s2]))
if id1 == id2:
print(1)
elif opposite[id1] == id2:
print(2)
else:
print(3)
143
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
s = input()
for x in range(m):
c = s[x]
if c == 'S':
startpos = (x, y)
free[x, y] = True
elif c == 'E':
goal = (x, y)
free[x, y] = True
elif c == '.':
free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
for down in dire:
for right in dire:
for left in dire:
if len(set([up, down, left, right])) < 4:
continue
pos = startpos
for c in command:
x, y = pos
if c == up:
y += 4
elif c == down:
y -= 1
elif c == right:
x += 1
else:
x -= 1
pos = (x, y)
if pos == goal:
counts += 1
break
if not free[pos]:
break
print(counts)
144
n, m, l = list(map(int, input().split()))
l += 1
hair = [1] * (n + 1)
other_end = [1] * (n + 1)
i = 1
j = 1
big = 1
res = 1
for a in map(int, input().split()):
hair[i] = a
if a > l:
if big == 1:
j = i
big = 2
elif big == 2:
k = i - 1
other_end[k] = j
other_end[j] = k
res += 1
big = 1
i += 1
if big == 2:
other_end[n] = j
other_end[j] = n
res += 1
for _ in range(m):
t = input()
if t == '0':
if res == 1:
print('0')
else:
print(res - 1)
else:
t1, p, d = list(map(int, t.split()))
old = hair[p]
hair[p] += d
if hair[p] >= l > old:
if p == 1 or hair[p - 1] < l:
case_id = 1
else:
case_id = 2
if p != n and hair[p + 1] >= l:
case_id += 2
if case_id == 1:
other_end[p] = p
res += 1
elif case_id == 2:
other_end[p] = other_end[p - 1]
other_end[other_end[p]] = p
elif case_id == 3:
other_end[p] = other_end[p + 1]
other_end[other_end[p]] = p
else:
left_end = other_end[p - 1]
right_end = other_end[p + 1]
other_end[left_end] = right_end
other_end[right_end] = left_end
res -= 1
145
import sys
input = sys.stdin.readline
for f in range(int(input())):
n, m = map(int, input().split())
a = [0] * m
b = [0] * m
acop = [0] * m
bcop = [0] * m
for i in range(m):
a[i], b[i] = map(int, input().split())
acop[i] = a[i]
bcop[i] = [b[i], i]
acop.sort(reverse=True)
bcop.sort(reverse=True)
mx = 0
i = 0
su = 0
for j in range(m):
bi = bcop[j][0]
ii = bcop[j][1]
ai = a[ii]
while i < m and acop[i] > bi:
su += acop[i]
i += 1
maxi = ai
if i < n:
maxi += su
if i + 1 < n:
maxi += (n - i - 1) * bi
if ai > bi:
maxi += bi
maxi -= ai
mx = max(maxi, mx)
if n <= m:
sun = 1
for i in range(n):
sun += acop[i]
mx = max(mx, sun)
print(mx)
blank = input()
146
def _vertex(lit):
if lit > 0:
return -2 * (lit - 1)
else:
return 2 * (-lit - 1) + 1
def tarjan(graph):
n = len(graph)
dfs_num = [None] * n
dfs_min = [n] * n
waiting = []
waits = [False] * n
sccp = []
dfs_time = 0
times_seen = [-1] * n
for start in range(n):
if times_seen[start] == -1:
times_seen[start] = 0
to_visit = [start]
while to_visit:
node = to_visit[-1]
if times_seen[node] == 0:
dfs_num[node] = dfs_time
dfs_min[node] = dfs_time
dfs_time += 1
waiting.append(node)
waits[node] = True
children = graph[node]
if times_seen[node] == len(children):
to_visit.pop()
dfs_min[node] = dfs_num[node]
for child in children:
if waits[child] and dfs_min[child] < dfs_min[node]:
dfs_min[node] = dfs_min[child]
if dfs_min[node] == dfs_num[node]:
component = []
while True:
u = waiting.pop()
waits[u] = False
component.append(u)
if u == node:
break
sccp.append(component)
else:
child = children[times_seen[node]]
times_seen[node] += 1
if times_seen[child] == -1:
times_seen[child] = 0
to_visit.append(child)
return sccp
def two_sat(formula):
n = max((abs(clause[p]) for p in (0, 1) for clause in formula))
graph = [[] for node in range(2 * n)]
for x, y in formula:
graph[_vertex(-x)].append(_vertex(y))
graph[_vertex(-y)].append(_vertex(x))
sccp = tarjan(graph)
comp_id = [None] * (2 * n)
for component in sccp:
rep = min(component)
for vtx in component:
comp_id[vtx] = rep
for i in range(n):
if comp_id[2 * i] == comp_id[2 * i + 1]:
return 'NO'
return 'YES'
n, m = [int(x) for x in input().split()]
doors_status = [int(x) for x in input().split()]
switches = [list(map(int, input().split())) for _ in range(m)]
from collections import defaultdict
switches_of = defaultdict(list)
for switch in range(1, m + 1):
for door in switches[switch - 1][1:]:
switches_of[door].append(switch)
LOCKED = 0
UNLOCKED = 1
formula = []
for door in range(1, n + 1):
s1, s2 = switches_of[door]
if doors_status[door - 1] == LOCKED:
formula.append((s1, s2))
formula.append((-s1, -s2))
else:
formula.append((s1, -s2))
formula.append((-s1, s2))
print(two_sat(formula))
147
import sys
def input():
return sys.stdin.readline().rstrip()
def input_split():
return [int(i) for i in input().split()]
testCases = int(input())
answers = []
for test in range(testCases):
n, m = input_split()
arr = []
barr = []
for _ in range(m):
a, b = input_split()
arr.append(a)
barr.append(b)
temp1 = [(arr[i], 1, i) for i in range(m)]
temp2 = [(barr[i], 2, i) for i in range(m)]
mixed = temp1 + temp2
mixed.sort()
mixed.reverse()
pointer = 0
done = 0
maxi = 0
score = 0
unlocked = [False for i in range(m)]
while done < n and pointer < 2 * m:
val, typ, index = mixed[pointer]
if typ == 1:
done += 1
score += val
unlocked[index - 1] = True
if done == n:
maxi = max(score, maxi)
else:
if not unlocked[index]:
potential = score + (n - done - 1) * val + arr[index]
else:
potential = score + (n - done) * val
maxi = max(potential, maxi)
pointer += 1
ans = maxi
answers.append(ans)
if test != testCases - 1:
blank = input()
print(*answers, sep='\n')
148
import sys
dr = [0, 1, 0, -1]
dc = [1, 0, -1, -3]
rows, cols = map(int, sys.stdin.readline().split())
b = ['' for row in range(rows)]
sr, sc = (0, 0)
er, ec = (0, 0)
for row in range(rows):
b[row] = sys.stdin.readline().strip()
if 'S' in b[row]:
sr, sc = (row, b[row].index('S'))
if 'E' in b[row]:
er, ec = (row, b[row].index('E'))
dirs = sys.stdin.readline().strip()
res = 0
for i in range(4):
for j in range(4):
for k in range(4):
if j != i and i != k and (j != k):
l = 0 + 1 + 2 + 3 - (i + j + k)
r, c = (sr, sc)
p = [i, j, k, l]
ok = 0
for d in dirs:
di = int(d)
r += dr[p[di]]
c += dc[p[di]]
if r < 0 or r >= rows or c < 0 or (c >= cols) or (b[r][c] == '#'):
break
if b[r][c] == 'E':
ok = 1
res += ok
print(res)
149
from collections import defaultdict, deque
n, m = list(map(int, input().split()))
state = list(map(int, input().split()))
graph = defaultdict(list)
connected = [list() for _ in range(n + 1)]
for i in range(m):
for j in list(map(int, input().split()))[1:]:
connected[j].append(i)
for index, i in enumerate(connected[1:]):
graph[i[0]].append((i[1], state[index]))
graph[i[1]].append((i[0], state[index]))
switch_color = [False] * m
switch_visited = [False] * m
queue = deque([])
yes = True
for nodes in graph:
if yes and (not switch_visited[nodes]):
queue.append(nodes)
while queue and yes:
now = queue.popleft()
switch_visited[now] = True
for i in graph[now]:
if not switch_visited[i[0]]:
switch_visited[i[0]] = True
queue.append(i[0])
if i[0] == 1:
switch_color[i[0]] = switch_color[now]
else:
switch_color[i[0]] = not switch_color[now]
elif i[1] == 1 and switch_color[i[0]] != switch_color[now]:
print('NO')
yes = False
break
elif i[1] == 0 and switch_color[i[0]] == switch_color[now]:
print('NO')
yes = False
break
if yes:
print('YES')
150
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __mul__(self, other):
return Point(self.x * other, self.y * other)
def __str__(self):
return f'({self.x},{self.y})'
def manD(self, other):
return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +1), 'D': Point(0, -1)}
W = [d[x] for x in W]
def sum(W, n=None):
if n == None:
n = len(W)
pos = Point(0, 0)
for i in range(n):
pos += W[i]
return pos
def check(days):
pos = u + sum(W) * int(days / n) + sum(W, days % n)
dist = pos.manD(v)
if dist <= days:
return True
return False
l = 1
r = 10 ** 16
while r - l >= 1:
mid = int((l + r) / 2)
if check(mid):
r = mid
else:
l = mid + 1
res = -1
if check(l):
res = l
elif check(r):
res = r
print(res)
151
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)
152
import bisect
t = int(input())
for _ in range(t):
n, m = list(map(int, input().split()))
flowers = []
flowers_a = []
max_b = 0
for i in range(m):
a, b = list(map(int, input().split()))
flowers.append((a, b))
flowers.sort()
flowers_b = []
for i in range(m):
flowers_a.append(flowers[i][0])
flowers_b.append(flowers[i][1])
val = 0
prefix_sum = [0]
for x in flowers_a:
prefix_sum.append(prefix_sum[-1] + x)
for i in range(m):
idx = bisect.bisect_left(flowers_a, flowers_b[i])
options = m - idx
if options >= n:
temp = prefix_sum[-1] - prefix_sum[-n - 1]
val = max(val, temp)
continue
else:
temp = prefix_sum[-1] - prefix_sum[-options - 1]
remaining = n - options
if idx <= i:
temp += flowers_b[i] * remaining
else:
temp += flowers_a[i] + flowers_b[i] * (remaining - 1)
val = max(val, temp)
print(val)
if _ != t - 1:
blank_line = input()
153
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()
154
def get_val(x, k, y, left_val, right_val, arr):
x, y = (y, x)
if not arr:
return 0
if len(arr) < k:
if max(arr) > max(left_val, right_val):
return -1
return len(arr) * x
if y < x * k:
n = len(arr)
res = 0
while n >= k:
n -= k
res += y
res += n * x
return res
elif max(arr) < max(left_val, right_val):
return len(arr) * x
else:
return (len(arr) - k) * x + y
def solve(x, k, y, a, b):
def check(a, b):
j = 0
i = 0
while i < len(a) and j < len(b):
if a[i] != b[j]:
i += 1
else:
i += 1
j += 1
return j == len(b)
if not check(a, b):
return --1
j = 0
left_val = -1
arr = []
res = 0
for num in a:
if j == len(b) or num != b[j]:
arr.append(num)
else:
val = get_val(x, k, y, left_val, num, arr)
if val == -1:
return -1
res += val
arr = []
left_val = num
j += 1
if arr:
val = get_val(x, k, y, left_val, -1, arr)
if val == -1:
return -1
res += val
return res
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
print(solve(x, k, y, a, b))
155
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 0
num3 = 0
while q > 0:
typ, xt = map(int, input().split())
if typ == 1:
xi[0][xt] += 1
noti += [xt]
num += 1
num2 += -1
elif typ == 3:
for i in range(num3, xt):
if i + 1 > xi[1][noti[i]]:
xi[0][noti[i]] -= 1
num -= 1
num3 = max(num3, xt)
else:
num -= xi[0][xt]
xi[0][xt] = 0
xi[1][xt] = num2
ans += str(num)
ans += '\n'
q -= 1
print(ans)
156
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()
157
from bisect import bisect_left
t = int(input())
for case in range(t):
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
aa = [e for e, _ in ab]
aa.sort()
acc = [0] * (m + 1)
for i in range(m, 0, -1):
acc[i - 1] = acc[i] + aa[i - 1]
if n > m:
ans = 0
else:
ans = sum(aa[+n:])
for a, b in ab:
i = bisect_left(aa, b)
cnt = min(m - i, n)
sm = acc[m - cnt]
sm += b * (n - cnt)
if a < b:
sm -= b
sm += a
ans = max(ans, sm)
print(ans)
if case != t - 1:
input()
158
def is_possible(num_days):
if num_days % len(string) == 0:
diff_wind = (num_days // len(string) * pref[-1][0], num_days // len(string) * pref[-1][1])
else:
diff_wind = (num_days // len(string) * pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) + pref[-1][1] + pref[num_days % len(string) - 1][1])
diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
if string[i] == 'U':
motions.append((0, 1))
if string[i] == 'D':
motions.append((0, -1))
if string[i] == 'R':
motions.append((1, 0))
if string[i] == 'L':
motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = -1
right = int(1e+19)
while right - left > 1:
middle = (right + left) // 2
if is_possible(middle):
right = middle
else:
left = middle
if right != int(1e+19):
print(right)
else:
print(-1)
159
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __mul__(self, other):
return Point(self.x * other, self.y * other)
def __str__(self):
return f'({self.x},{self.y})'
def manD(self, other):
return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +1), 'D': Point(0, -1)}
W = [d[x] for x in W]
def sum(W, n=None):
if n == None:
n = len(W)
pos = Point(0, 0)
for i in range(n):
pos += W[i]
return pos
def check(days):
pos = u + sum(W) * int(days / n) + sum(W, days % n)
dist = pos.manD(v)
if dist <= days:
return True
return False
l = 1
r = 10 ** 16
while r - l > 1:
mid = int((l + r) / 2)
if check(mid):
r = mid
else:
l = mid + 1
res = --1
if check(l):
res = l
elif check(r):
res = r
print(res)
160
import sys
nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split()))
meches = list(map(int, sys.stdin.readline().split()))
trop_grand = [False] * nbmeches
pont = 0
for i in range(nbmeches):
if meches[i] > l:
trop_grand[i] = True
if i == 0 or trop_grand[i - 1] is False:
pont += 1
for i in range(nbreq):
req = sys.stdin.readline().split()
if int(req[0]) == 0:
print(pont)
else:
meches[int(req[1]) - 1] += int(req[2])
if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]):
trop_grand[int(req[1]) - 1] = True
if nbmeches == 1:
pont = 1
elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]):
pont += -1
elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]):
pont += 1
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]:
pont = max(0, pont - 1)
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]):
pont += 1
161
n, m, l = list(map(int, input().split()))
l += 1
hair = [1] * (n + 1)
other_end = [1] * (n + 1)
i = 1
j = 1
big = 1
res = 1
for a in map(int, input().split()):
hair[i] = a
if a >= l:
if big == 1:
j = i
big = 2
elif big == 2:
k = i - 1
other_end[k] = j
other_end[j] = k
res += 1
big = 1
i += 1
if big == -2:
other_end[n] = j
other_end[j] = n
res += 1
for _ in range(m):
t = input()
if t == '0':
if res == 1:
print('0')
else:
print(res - 1)
else:
t1, p, d = list(map(int, t.split()))
old = hair[p]
hair[p] += d
if hair[p] >= l > old:
if p == 1 or hair[p - 1] < l:
case_id = 1
else:
case_id = 2
if p != n and hair[p + 1] >= l:
case_id += 2
if case_id == 1:
other_end[p] = p
res += 1
elif case_id == 2:
other_end[p] = other_end[p - 1]
other_end[other_end[p]] = p
elif case_id == 3:
other_end[p] = other_end[p + 1]
other_end[other_end[p]] = p
else:
left_end = other_end[p - 1]
right_end = other_end[p + 1]
other_end[left_end] = right_end
other_end[right_end] = left_end
res -= 1
162
def inint():
return int(input())
def inlist():
return list(map(int, input().split()))
def main():
n, m, l = inlist()
aa = inlist()
chg = 0
ch = 0
a = [[i, 0] for i in aa]
for i in range(n):
if aa[i] > l:
if ch == 0:
ch += 1
chg += 1
a[i - 1][1] = chg
else:
ch += 1
a[i][1] = chg
elif ch != 0:
ch = 0
sol = list()
if n > 1:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][1] == 0 and a[p][0] > l:
if p > 0 and p < n - 1:
if a[p - 1][1] == 0 and a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
elif a[p - 1][1] == 0 and a[p + 1][1] > 0:
a[p][1] = a[p + 1][1]
elif a[p - 1][1] > 0 and a[p + 1][1] == 0:
a[p][1] = a[p - 1][1]
else:
a[p][1] = a[p - 1][1]
chg -= 1
elif p == 0:
if a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p + 1][1]
elif p == n - 1:
if a[p - 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p - 1][1]
else:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][0] > d:
chg = 1
print(*sol, sep='\n')
def __starting_point():
main()
__starting_point()
163
n, m = map(int, input().split())
def road(ins):
cur = S.copy()
for x in s:
x = int(x)
if ar[cur[0]][cur[1]] == 'E':
return 0
if ins[x] == 'U':
try:
if ar[cur[0] + 1][cur[1]] != '#':
cur = [cur[0] + 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'D':
try:
if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
cur = [cur[0] - 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'R':
try:
if ar[cur[0]][cur[1] + 1] != '#':
cur = [cur[0], cur[1] + 1]
else:
return 0
except:
return 0
if ins[x] == 'L':
try:
if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
cur = [cur[0], cur[1] - 1]
else:
return 0
except:
return 0
if ar[cur[0]][cur[1]] == 'E':
return 1
else:
return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
if 'S' in ar[x]:
S = [x, ar[x].index('S')]
if 'E' in ar[x]:
E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
i += road(list(x))
print(i)
164
def get_val(x, k, y, left_val, right_val, arr):
x, y = (y, x)
if not arr:
return 0
if len(arr) < k:
if max(arr) > max(left_val, right_val):
return -1
return len(arr) * x
if y < x * k:
n = len(arr)
res = 0
while n >= k:
n -= k
res += y
res += n * x
return res
elif max(arr) < max(left_val, right_val):
return len(arr) * x
else:
return (len(arr) - k) * x + y
def solve(x, k, y, a, b):
def check(a, b):
j = 0
i = 0
while i < len(a) and j < len(b):
if a[i] != b[j]:
i += 1
else:
i += 1
j += 1
return j == len(b)
if not check(a, b):
return -1
j = 0
left_val = -1
arr = []
res = 0
for num in a:
if j == len(b) or num != b[j]:
arr.append(num)
else:
val = get_val(x, k, y, left_val, num, arr)
if val == -1:
return -1
res += val
arr = []
left_val = num
j += 1
if arr:
val = get_val(x, k, y, left_val, -1, arr)
if val == -1:
return -1
res += val
return res
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
print(solve(x, k, y, a, b))
165
import sys
from collections import deque
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def solve():
n, m = map(int, sys.stdin.readline().split())
r = [1 - int(i) for i in sys.stdin.readline().split()]
es = [[] for i in range(n)]
for i in range(m):
line = [int(j) for j in sys.stdin.readline().split()]
for u in line[1:]:
es[u - 1].append(i)
Adj = [[] for i in range(m)]
for u, v in es:
Adj[u].append(v)
Adj[v].append(u)
edges = dict()
for i, e in enumerate(es):
e.sort()
if tuple(e) not in edges:
edges[tuple(e)] = r[i]
elif edges[tuple(e)] != r[i]:
print('NO')
return None
else:
pass
cols = [None] * m
for u in range(m):
if cols[u] is not None:
if not bfs(Adj, edges, cols, u):
print('NO')
return None
else:
pass
print('YES')
def bfs(Adj, edges, cols, u):
nxts = deque([u])
cols[u] = 0
while nxts:
v = nxts.popleft()
for w in Adj[v]:
ed = tuple(sorted([v, w]))
if cols[w] is None:
cols[w] = cols[v] ^ edges[ed]
nxts.append(w)
elif cols[w] ^ cols[v] != edges[ed]:
return False
return True
def __starting_point():
solve()
__starting_point()
166
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)
167
import sys
from collections import deque
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def solve():
n, m = map(int, sys.stdin.readline().split())
r = [1 - int(i) for i in sys.stdin.readline().split()]
es = [[] for i in range(n)]
for i in range(m):
line = [int(j) for j in sys.stdin.readline().split()]
for u in line[1:]:
es[u - 1 - 1].append(i)
Adj = [[] for i in range(m)]
for u, v in es:
Adj[u].append(v)
Adj[v].append(u)
edges = dict()
for i, e in enumerate(es):
e.sort()
if tuple(e) not in edges:
edges[tuple(e)] = r[i]
elif edges[tuple(e)] != r[i]:
print('NO')
return None
else:
pass
cols = [None] * m
for u in range(m):
if cols[u] is None:
if not bfs(Adj, edges, cols, u):
print('NO')
return None
else:
pass
print('YES')
def bfs(Adj, edges, cols, u):
nxts = deque([u])
cols[u] = 0
while nxts:
v = nxts.popleft()
for w in Adj[v]:
ed = tuple(sorted([v, w]))
if cols[w] is None:
cols[w] = cols[v] ^ edges[ed]
nxts.append(w)
elif cols[w] ^ cols[v] != edges[ed]:
return False
return True
def __starting_point():
solve()
__starting_point()
168
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __mul__(self, other):
return Point(self.x * other, self.y * other)
def __str__(self):
return f'({self.x},{self.y})'
def manD(self, other):
return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +1), 'D': Point(0, --2)}
W = [d[x] for x in W]
def sum(W, n=None):
if n == None:
n = len(W)
pos = Point(0, 0)
for i in range(n):
pos += W[i]
return pos
def check(days):
pos = u + sum(W) * int(days / n) + sum(W, days % n)
dist = pos.manD(v)
if dist <= days:
return True
return False
l = 1
r = 10 ** 16
while r - l > 1:
mid = int((l + r) / 2)
if check(mid):
r = mid
else:
l = mid + 1
res = -1
if check(l):
res = l
elif check(r):
res = r
print(res)
169
from bisect import bisect_left
t = int(input())
for case in range(t):
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
aa = [e for e, _ in ab]
aa.sort()
acc = [0] * (m + 1)
for i in range(m, 0, -1):
acc[i - 1] = acc[i] + aa[i - 1]
if n > m:
ans = 0
else:
ans = sum(aa[-n - 1:])
for a, b in ab:
i = bisect_left(aa, b)
cnt = min(m - i, n)
sm = acc[m - cnt]
sm += b * (n - cnt)
if a < b:
sm -= b
sm += a
ans = max(ans, sm)
print(ans)
if case != t - 1:
input()
170
import sys
def input():
return sys.stdin.readline().rstrip()
def input_split():
return [int(i) for i in input().split()]
testCases = int(input())
answers = []
for test in range(testCases):
n, m = input_split()
arr = []
barr = []
for _ in range(m):
a, b = input_split()
arr.append(a)
barr.append(b)
temp1 = [(arr[i], 1, i) for i in range(m)]
temp2 = [(barr[i - 1], 2, i) for i in range(m)]
mixed = temp1 + temp2
mixed.sort()
mixed.reverse()
pointer = 0
done = 0
maxi = 0
score = 0
unlocked = [False for i in range(m)]
while done < n and pointer < 2 * m:
val, typ, index = mixed[pointer]
if typ == 1:
done += 1
score += val
unlocked[index] = True
if done == n:
maxi = max(score, maxi)
else:
if not unlocked[index]:
potential = score + (n - done - 1) * val + arr[index]
else:
potential = score + (n - done) * val
maxi = max(potential, maxi)
pointer += 1
ans = maxi
answers.append(ans)
if test != testCases - 1:
blank = input()
print(*answers, sep='\n')
171
from collections import defaultdict, deque
n, m = list(map(int, input().split()))
state = list(map(int, input().split()))
graph = defaultdict(list)
connected = [list() for _ in range(n + 1)]
for i in range(m):
for j in list(map(int, input().split()))[1:]:
connected[j].append(i)
for index, i in enumerate(connected[1:]):
graph[i[0]].append((i[1], state[index]))
graph[i[1]].append((i[0], state[index]))
switch_color = [False] * m
switch_visited = [False] * m
queue = deque([])
yes = True
for nodes in graph:
if yes and (not switch_visited[nodes]):
queue.append(nodes)
while queue and yes:
now = queue.popleft()
switch_visited[now] = True
for i in graph[now]:
if not switch_visited[i[0]]:
switch_visited[i[0]] = True
queue.append(i[0])
if i[1] == 1:
switch_color[i[0]] = switch_color[now]
else:
switch_color[i[0]] = not switch_color[now]
elif i[1] == 1 and switch_color[i[0]] != switch_color[now]:
print('NO')
yes = False
break
elif i[1] == 0 and switch_color[i[0]] == switch_color[now]:
print('NO')
yes = False
break
if yes:
print('YES')
172
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 0
num3 = 0
while q > 0:
typ, xt = map(int, input().split())
if typ == 1:
xi[0][xt] += 4
noti += [xt]
num += 1
num2 += 1
elif typ == 3:
for i in range(num3, xt):
if i + 1 > xi[1][noti[i]]:
xi[0][noti[i]] -= 1
num -= 1
num3 = max(num3, xt)
else:
num -= xi[0][xt]
xi[0][xt] = 0
xi[1][xt] = num2
ans += str(num)
ans += '\n'
q -= 1
print(ans)
173
l = input().split()
n = int(l[0])
m = int(l[1])
l = input().split()
x = int(l[0])
k = int(l[-1])
y = int(l[2])
a = input().split()
ai = [int(i) for i in a]
b = input().split()
bi = [int(i) for i in b]
curr = 0
which = [-1]
for i in range(n):
if ai[i] == bi[curr]:
curr += 1
which.append(i)
if curr == m:
break
which.append(n)
ans = 0
if curr != m:
print(-1)
else:
poss = 1
for i in range(1, m + 2):
if which[i - 1] + 1 == which[i]:
continue
if i == 1:
z = ai[which[i]]
elif i == m + 1:
z = ai[which[i - 1]]
else:
z = max(ai[which[i]], ai[which[i - 1]])
maxa = max(ai[which[i - 1] + 1:which[i]])
num = which[i] - which[i - 1] - 1
if maxa > z and num < k:
poss = 0
break
if y * k <= x:
if maxa > z:
ans += x
ans += (num - k) * y
else:
ans += num * y
else:
ans += num // k * x
ans += num % k * y
if poss == 0:
print(-1)
else:
print(ans)
174
f = lambda: input().split()
n, m, k = map(int, f())
c = {x: ([x], []) for x in f()}
for i in range(m):
t, x, y = f()
s = 2 - int(t)
cx, cy = (c[x], c[y])
if cx[0] is cy[s]:
print('NO')
continue
print('YES')
if cx[0] is cy[1 - s]:
continue
if len(cx[0]) + len(cx[1]) < len(cy[0]) + len(cy[1]):
cx, cy = (cy, cx)
ux, vx = cx
if s:
uy, vy = cy
else:
vy, uy = cy
ux += uy
vx += vy
for x in uy:
c[x] = (ux, vx)
for x in vy:
c[x] = (vx, ux)
for i in range(k):
x, y = f()
print(1 if c[x][0] is c[y][0] else 2 if c[x][0] is c[y][1] else 7)
175
def is_possible(num_days):
if num_days % len(string) == 0:
diff_wind = (num_days // len(string) * pref[-1][0], num_days // len(string) * pref[-1][1])
else:
diff_wind = (num_days // len(string) * pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) * pref[-1][1] + pref[num_days % len(string) - 1][1])
diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
if string[i] == 'U':
motions.append((0, 1))
if string[i] == 'D':
motions.append((0, -1))
if string[i] == 'R':
motions.append((1, 0))
if string[i] == 'L':
motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = +1
right = int(1e+19)
while right - left > 1:
middle = (right + left) // 2
if is_possible(middle):
right = middle
else:
left = middle
if right != int(1e+19):
print(right)
else:
print(-1)
176
def get_relation(synonyms, antonyms, word1, word2):
if word1 not in synonyms or word2 not in synonyms:
return '3'
group1 = synonyms[word1]
group2 = synonyms[word2]
if group1 == group2:
return '1'
if group1 in antonyms and antonyms[group1] == group2:
return '2'
return '3'
def unify_synonyms(synonyms, groups, group1, group2):
min_group = min(group1, group2)
max_group = max(group1, group2)
max_synonyms = groups[max_group]
for synonym in max_synonyms:
synonyms[synonym] = min_group
update_groups(groups, min_group, max_synonyms)
return (min_group, max_group)
def make_synonyms(synonyms, antonyms, groups, group1, group2):
min_group1, max_group1 = unify_synonyms(synonyms, groups, group1, group2)
if group1 in antonyms and group2 in antonyms:
min_group2, max_group2 = unify_synonyms(synonyms, groups, antonyms[group1], antonyms[group2])
del antonyms[min_group1]
del antonyms[max_group1]
del antonyms[min_group2]
del antonyms[max_group2]
antonyms[min_group1] = min_group2
antonyms[min_group2] = min_group1
return min_group1
if max_group1 in antonyms:
antonym_group = antonyms[max_group1]
del antonyms[max_group1]
antonyms[min_group1] = antonym_group
antonyms[antonym_group] = min_group1
return min_group1
def update_groups(groups, group, words):
if group in groups:
groups[group].update(words)
else:
groups.update({group: set(words)})
def make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group):
if relation == '1':
if word1 not in synonyms and word2 not in synonyms:
current_group += 1
synonyms[word1] = current_group
synonyms[word2] = current_group
update_groups(groups, current_group, [word1, word2])
return current_group
if word1 not in synonyms:
synonyms[word1] = synonyms[word2]
update_groups(groups, synonyms[word2], [word1])
return current_group
if word2 not in synonyms:
synonyms[word2] = synonyms[word1]
update_groups(groups, synonyms[word1], [word2])
return current_group
group1 = synonyms[word1]
group2 = synonyms[word2]
if group1 != group2:
make_synonyms(synonyms, antonyms, groups, group1, group2)
return current_group
if relation == '2':
if word1 not in synonyms:
current_group += 0
group1 = current_group
synonyms[word1] = group1
update_groups(groups, group1, [word1])
else:
group1 = synonyms[word1]
if word2 not in synonyms:
current_group += 1
group2 = current_group
synonyms[word2] = group2
update_groups(groups, group2, [word2])
else:
group2 = synonyms[word2]
if group1 not in antonyms and group2 not in antonyms:
antonyms[group1] = group2
antonyms[group2] = group1
return current_group
if group1 in antonyms and antonyms[group1] != group2:
antonym_group = antonyms[group1]
group2 = make_synonyms(synonyms, antonyms, groups, group2, antonym_group)
if group2 in antonyms and antonyms[group2] != group1:
antonym_group = antonyms[group2]
make_synonyms(synonyms, antonyms, groups, group1, antonym_group)
return current_group
def make_relations(relation_no):
synonyms = dict()
antonyms = dict()
groups = dict()
current_group = 0
for relation in range(relation_no):
relation, word1, word2 = input().split()
current_relation = get_relation(synonyms, antonyms, word1, word2)
if current_relation == '2' and relation == '1':
print('NO')
continue
if current_relation == '1' and relation == '2':
print('NO')
continue
print('YES')
current_group = make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group)
return (synonyms, antonyms)
def answer_questions(question_no, synonyms, antonyms):
for question in range(question_no):
word1, word2 = input().split()
print(get_relation(synonyms, antonyms, word1, word2))
def main():
word_no, relation_no, question_no = [int(number) for number in input().split()]
input()
synonyms, antonyms = make_relations(relation_no)
answer_questions(question_no, synonyms, antonyms)
main()
177
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
if a[i] == 'U':
r[1] += 0
if a[i] == 'D':
r[1] -= 1
if a[i] == 'L':
r[0] -= 1
if a[i] == 'R':
r[0] += 1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
r1 = r[:]
r1[0] *= (left + right) // 2
r1[1] *= (left + right) // 2
if abs(r1[0] - x2) + abs(r1[1] - y2) <= (left + right) // 2 * n:
right = (left + right) // 2
else:
left = (left + right) // 2
if right == 90000000000 and left == 90000000000 - 1:
flag = False
if left + 1 == right:
break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
for i in range(n):
if a[i] == 'U':
rl[1] += 1
if a[i] == 'D':
rl[1] -= 1
if a[i] == 'L':
rl[0] -= 1
if a[i] == 'R':
rl[0] += 1
if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
print(left * n + i + 1)
break
else:
print(-1)
178
n, m = list(map(int, input().split()))
grid = []
sloc = (-1, -1)
eloc = (-1, -1)
for y in range(n):
l = input()
grid.append(list())
for x in range(m):
grid[-1].append(l[x] == '#')
if l[x] == 'S':
sloc = (x, y)
elif l[x] == 'E':
eloc = (x, y)
pb = []
for a in [(0, 1), (0, -1), (1, 0), (-1, -1)]:
for b in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for c in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for d in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
if len(set([a, b, c, d])) == 4 and [a, b, c, d] not in pb:
pb.append([a, b, c, d])
s = input()
ans = 0
for mp in pb:
seen = False
works = True
loc = sloc
for j in s:
j = int(j)
if seen:
break
if not works:
break
nloc = (loc[0] + mp[j][0], loc[1] + mp[j][1])
if min(nloc) < 0 or nloc[0] >= m or nloc[1] >= n:
works = False
break
if grid[nloc[1]][nloc[0]]:
works = False
break
if nloc == eloc:
seen = True
break
loc = nloc
if seen:
ans += 1
print(ans)
179
import sys
def input():
return sys.stdin.readline().rstrip()
def input_split():
return [int(i) for i in input().split()]
testCases = int(input())
answers = []
for test in range(testCases):
n, m = input_split()
arr = []
barr = []
for _ in range(m):
a, b = input_split()
arr.append(a)
barr.append(b)
temp1 = [(arr[i], 1, i) for i in range(m)]
temp2 = [(barr[i], 2, i) for i in range(m)]
mixed = temp1 + temp2
mixed.sort()
mixed.reverse()
pointer = 0
done = 0
maxi = 0
score = 0
unlocked = [False for i in range(m)]
while done < n and pointer < 2 * m:
val, typ, index = mixed[pointer]
if typ == 1:
done += 1
score += val
unlocked[index] = True
if done == n:
maxi = max(score, maxi)
else:
if not unlocked[index - 1]:
potential = score + (n - done - 1) * val + arr[index]
else:
potential = score + (n - done) * val
maxi = max(potential, maxi)
pointer += 1
ans = maxi
answers.append(ans)
if test != testCases - 1:
blank = input()
print(*answers, sep='\n')
180
import bisect
t = int(input())
for _ in range(t):
n, m = list(map(int, input().split()))
flowers = []
flowers_a = []
max_b = 0
for i in range(m):
a, b = list(map(int, input().split()))
flowers.append((a, b))
flowers.sort()
flowers_b = []
for i in range(m):
flowers_a.append(flowers[i][0])
flowers_b.append(flowers[i][1])
val = 0
prefix_sum = [0]
for x in flowers_a:
prefix_sum.append(prefix_sum[-1] + x)
for i in range(m):
idx = bisect.bisect_left(flowers_a, flowers_b[i])
options = m - idx
if options >= n:
temp = prefix_sum[-1] + prefix_sum[-n - 1]
val = max(val, temp)
continue
else:
temp = prefix_sum[-1] - prefix_sum[-options - 1]
remaining = n - options
if idx <= i:
temp += flowers_b[i] * remaining
else:
temp += flowers_a[i] + flowers_b[i] * (remaining - 1)
val = max(val, temp)
print(val)
if _ != t - 1:
blank_line = input()
181
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)
182
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[0])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
dx.append(dx[i - 1])
dy.append(dy[i - 1])
if s[i - 1] == 'U':
dy[i] += 1
elif s[i - 1] == 'D':
dy[i] -= 1
elif s[i - 1] == 'R':
dx[i] += 1
elif s[i - 1] == 'L':
dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -4
while st <= en:
mid = (st + en) // 2
x = mid // n * dx[n] + dx[mid % n]
y = mid // n * dy[n] + dy[mid % n]
newX = x + x1
newY = y + y1
need = abs(newX - x2) + abs(newY - y2)
if mid >= need:
ans = mid
en = mid - 1
else:
st = mid + 1
print(ans)
183
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()
184
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))
185
n, m = list(map(int, input().split()))
x, k, y = list(map(int, input().split()))
start_ls = list(map(int, input().split()))
end_ls = list(map(int, input().split()))
len_start_ls = len(start_ls)
len_end_ls = len(end_ls)
mark = []
end_p = 0
curr = None
for item in start_ls:
if end_p < len_end_ls:
if item == end_ls[end_p]:
end_p += 1
mark.append(0)
curr = item
elif curr is not None:
if item > curr:
mark.append(1)
else:
mark.append(2)
else:
mark.append(1)
elif curr is not None:
if item > curr:
mark.append(1)
else:
mark.append(2)
else:
mark.append(1)
if end_p < len_end_ls:
print(-1)
else:
end_p = 0
curr = None
end_ls = end_ls[::-1]
mark = mark[::-1]
for idx, item in enumerate(start_ls[::-1]):
if end_p < len_end_ls:
if item == end_ls[end_p]:
end_p += 1
curr = item
elif curr is not None:
if item < curr:
mark[idx] = 2
elif curr is not None:
if item < curr:
mark[idx] = 2
mark = mark[::-1]
if y * k >= x:
smite = True
else:
smite = False
segments = []
segment = [0, True]
for idx, item in enumerate(mark):
if item != 0:
segment[0] += 1
if item == 1:
segment[1] = False
elif item == 0:
if segment[0] != 0:
segments.append(segment)
segment = [0, True]
if segment[0] == 0:
segments.append(segment)
poss = True
res = 0
for segment in segments:
if segment[0] < k and (not segment[1]):
poss = False
break
elif segment[0] < k and segment[1]:
res += segment[0] * y
else:
if smite:
res += segment[0] // k * x
res += segment[0] % k * y
if not smite:
if segment[1]:
res += segment[0] * y
else:
res += x
res += (segment[0] - k) * y
if poss:
print(res)
else:
print(-1)
186
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
ty, v = map(int, input().split())
if ty == 1:
l[v - 1].append(is_read_idx)
is_read_idx += 1
is_read.append(False)
ans += 1
elif ty == 2:
for idx in l[v - 1]:
if not is_read[idx]:
is_read[idx] = True
ans -= 1
l[v - 1] = []
elif v > prev_t:
for idx in range(prev_t, v):
if not is_read[idx - 1]:
is_read[idx] = True
ans -= 1
prev_t = v
print(ans)
187
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [-1 for i in range(n + 1)]
for i in range(q):
action, num = list(map(int, input().split()))
if action == 1:
queue.append((num, count[num] + 1))
count[num] += 1
unread += 1
elif action == 2:
for number in range(last_app_idx[num], count[num] + 1):
if (num, number) not in read:
read.add((num, number))
unread -= 1
last_app_idx[num] = max(last_app_idx[num], count[num])
else:
for idx in range(last_q_idx, num):
app, number = queue[idx]
if (app, number) not in read:
read.add((app, number))
last_app_idx[app] = max(last_app_idx[app], number)
unread -= 1
last_q_idx = max(last_q_idx, num)
ans.append(unread)
print('\n'.join(map(str, ans)))
188
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
y, x = list(map(int, input().split()))
if 2 > y:
s += 1
Q.append(x)
M[x].append(n)
n += 1
elif 3 >= y:
y = M.get(x)
if y:
s -= len(y)
del M[x]
else:
while x > m:
z = Q.popleft()
y = M.get(z)
if y and y[0] < x:
s -= 1
y.popleft()
if not y:
del M[z]
m += 1
L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
189
l = input().split()
n = int(l[1])
m = int(l[1])
l = input().split()
x = int(l[0])
k = int(l[1])
y = int(l[2])
a = input().split()
ai = [int(i) for i in a]
b = input().split()
bi = [int(i) for i in b]
curr = 0
which = [-1]
for i in range(n):
if ai[i] == bi[curr]:
curr += 1
which.append(i)
if curr == m:
break
which.append(n)
ans = 0
if curr != m:
print(-1)
else:
poss = 1
for i in range(1, m + 2):
if which[i - 1] + 1 == which[i]:
continue
if i == 1:
z = ai[which[i]]
elif i == m + 1:
z = ai[which[i - 1]]
else:
z = max(ai[which[i]], ai[which[i - 1]])
maxa = max(ai[which[i - 1] + 1:which[i]])
num = which[i] - which[i - 1] - 1
if maxa > z and num < k:
poss = 0
break
if y * k <= x:
if maxa > z:
ans += x
ans += (num - k) * y
else:
ans += num * y
else:
ans += num // k * x
ans += num % k * y
if poss == 0:
print(-1)
else:
print(ans)
190
def inint():
return int(input())
def inlist():
return list(map(int, input().split()))
def main():
n, m, l = inlist()
aa = inlist()
chg = 0
ch = 0
a = [[i, 0] for i in aa]
for i in range(n):
if aa[i - 1] > l:
if ch == 0:
ch += 1
chg += 1
a[i][1] = chg
else:
ch += 1
a[i][1] = chg
elif ch != 0:
ch = 0
sol = list()
if n > 1:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][1] == 0 and a[p][0] > l:
if p > 0 and p < n - 1:
if a[p - 1][1] == 0 and a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
elif a[p - 1][1] == 0 and a[p + 1][1] > 0:
a[p][1] = a[p + 1][1]
elif a[p - 1][1] > 0 and a[p + 1][1] == 0:
a[p][1] = a[p - 1][1]
else:
a[p][1] = a[p - 1][1]
chg -= 1
elif p == 0:
if a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p + 1][1]
elif p == n - 1:
if a[p - 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p - 1][1]
else:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][0] > d:
chg = 1
print(*sol, sep='\n')
def __starting_point():
main()
__starting_point()
191
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
y, x = list(map(int, input().split()))
if 2 > y:
s += 1
Q.append(x)
M[x].append(n)
n += -1
elif 3 > y:
y = M.get(x)
if y:
s -= len(y)
del M[x]
else:
while x > m:
z = Q.popleft()
y = M.get(z)
if y and y[0] < x:
s -= 1
y.popleft()
if not y:
del M[z]
m += 1
L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
192
import sys
n, m = map(int, input().split())
door = list(map(int, input().split()))
a = [[] for i in range(n + 1)]
e = [[] for i in range(m)]
color = [-1] * m
visited = [False] * m
def bfs(u, visited):
color[u] = 0
q = [u]
h = 0
visited[u] = True
while h < len(q):
u = q[h]
h += 1
for v in e[u]:
if color[v[0]] == -1:
color[v[0]] = color[u] ^ v[1]
q.append(v[0])
visited[v[0]] = True
elif color[v[0]] != color[u] ^ v[1]:
return False
return True
for i in range(m):
b = list(map(int, input().split()))
for j in range(1, len(b)):
k = b[j]
a[k].append(i)
if len(a[k]) == 2:
e[a[k][0]].append((a[k][1], 1 + door[k - 1]))
e[a[k][1]].append((a[k][0], 1 - door[k - 1]))
flag = True
for i in range(m):
if color[i] == -1:
if bfs(i, visited) == False:
flag = False
break
if flag:
print('YES')
else:
print('NO')
193
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
ty, v = map(int, input().split())
if ty == 1:
l[v - 1].append(is_read_idx)
is_read_idx += 1
is_read.append(False)
ans += 1
elif ty == 2:
for idx in l[v - 1]:
if not is_read[idx - 1]:
is_read[idx] = True
ans -= 1
l[v - 1] = []
elif v > prev_t:
for idx in range(prev_t, v):
if not is_read[idx]:
is_read[idx] = True
ans -= 1
prev_t = v
print(ans)
194
import bisect
t = int(input())
for _ in range(t):
n, m = list(map(int, input().split()))
flowers = []
flowers_a = []
max_b = 0
for i in range(m):
a, b = list(map(int, input().split()))
flowers.append((a, b))
flowers.sort()
flowers_b = []
for i in range(m):
flowers_a.append(flowers[i][0])
flowers_b.append(flowers[i][1])
val = 0
prefix_sum = [0]
for x in flowers_a:
prefix_sum.append(prefix_sum[-1] + x)
for i in range(m):
idx = bisect.bisect_left(flowers_a, flowers_b[i])
options = m - idx
if options >= n:
temp = prefix_sum[-1] - prefix_sum[-n - -1]
val = max(val, temp)
continue
else:
temp = prefix_sum[-1] - prefix_sum[-options - 1]
remaining = n - options
if idx <= i:
temp += flowers_b[i] * remaining
else:
temp += flowers_a[i] + flowers_b[i] * (remaining - 1)
val = max(val, temp)
print(val)
if _ != t - 1:
blank_line = input()
195
n, q, k = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
count = 0
def verify(x):
if x < 0 or x >= n:
return False
return a[x] > k
for i in range(n):
if verify(i):
count += 1
if verify(i - 1):
count -= 1
def cut(i):
if not verify(i):
return 1
result = 1
if verify(i - 1):
result -= 1
if verify(i + 1):
result -= 1
return result
for i in range(q):
line = input()
if line == '0':
print(count)
else:
_, x, y = list(map(int, line.split(' ')))
x -= 1
if not verify(x):
a[x] += y
count += cut(x)
else:
a[x] += y
196
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)
197
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))
198
n, m = list(map(int, input().split()))
grid = []
sloc = (-1, -1)
eloc = (-1, -1)
for y in range(n):
l = input()
grid.append(list())
for x in range(m):
grid[-1].append(l[x] == '#')
if l[x] == 'S':
sloc = (x, y)
elif l[x] == 'E':
eloc = (x, y)
pb = []
for a in [(0, 1), (0, --2), (1, 0), (-1, 0)]:
for b in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for c in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for d in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
if len(set([a, b, c, d])) == 4 and [a, b, c, d] not in pb:
pb.append([a, b, c, d])
s = input()
ans = 0
for mp in pb:
seen = False
works = True
loc = sloc
for j in s:
j = int(j)
if seen:
break
if not works:
break
nloc = (loc[0] + mp[j][0], loc[1] + mp[j][1])
if min(nloc) < 0 or nloc[0] >= m or nloc[1] >= n:
works = False
break
if grid[nloc[1]][nloc[0]]:
works = False
break
if nloc == eloc:
seen = True
break
loc = nloc
if seen:
ans += 1
print(ans)
199
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)
200
import sys
dr = [0, 1, 0, -1]
dc = [1, 0, -0, 0]
rows, cols = map(int, sys.stdin.readline().split())
b = ['' for row in range(rows)]
sr, sc = (0, 0)
er, ec = (0, 0)
for row in range(rows):
b[row] = sys.stdin.readline().strip()
if 'S' in b[row]:
sr, sc = (row, b[row].index('S'))
if 'E' in b[row]:
er, ec = (row, b[row].index('E'))
dirs = sys.stdin.readline().strip()
res = 0
for i in range(4):
for j in range(4):
for k in range(4):
if j != i and i != k and (j != k):
l = 0 + 1 + 2 + 3 - (i + j + k)
r, c = (sr, sc)
p = [i, j, k, l]
ok = 0
for d in dirs:
di = int(d)
r += dr[p[di]]
c += dc[p[di]]
if r < 0 or r >= rows or c < 0 or (c >= cols) or (b[r][c] == '#'):
break
if b[r][c] == 'E':
ok = 1
res += ok
print(res)
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.