001
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m):
S = input().split(' ')
a = int(S[0])
b = int(S[1])
if S1[a] == 2:
S1[a] = b
elif S2[a] == 0:
S2[a] = b
else:
B[a] = 1
B[b] = 1
if S1[b] == 0:
S1[b] = a
elif S2[b] == 0:
S2[b] = a
else:
B[a] = 1
B[b] = 1
for i in range(1, n + 1):
if S1[i] == 0 or S2[i] == 0:
B[i] = 1
sol = 0
for ind in range(1, n + 1):
if B[ind] == 0:
v = ind
w = S2[ind]
c = True
while w != ind:
B[v] = 1
if B[w] == 0:
u = w
if S1[w] == v:
w = S2[w]
else:
w = S1[w]
else:
B[ind] = 0
c = False
break
v = u
if c:
B[v] = 1
sol += 1
print(sol)
002
N = int(input())
seq = [i for i in input().split()]
def end_lst(i):
while i < N - 1 and seq[i] != seq[i + 1]:
i = i + 1
return i
def reorder(lst, start, end):
if start == end - 1:
return 0
if lst[start - 1] == lst[end]:
for i in range(start, end + 1):
lst[i] = lst[start]
return (end - start) // 2
mid = (start + end) // 2
for i in range(start, mid + 1):
lst[i] = lst[start]
for i in range(mid + 1, end + 1):
lst[i] = lst[end]
return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
if seq[i] != seq[i + 1]:
end = end_lst(i)
ans = max(reorder(seq, i, end), ans)
i = end
else:
i += 1
print(ans)
print(' '.join(seq))
003
def connected_components(neighbors):
seen = set()
def component(node):
nodes = set([node])
while nodes:
node = nodes.pop()
seen.add(node)
nodes |= neighbors[node] - seen
yield node
for node in neighbors:
if node not in seen:
yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
u, v = map(int, input().split())
graph[u].add(v)
graph[v].add(u)
total = 0
for component in connected_components(graph):
nodes = list(component)
size = len(nodes)
seen = set()
current = nodes[0]
while len(seen) < size:
choice = list(graph[current])
if len(choice) != 2:
break
seen.add(current)
possible = [c for c in choice if c not in seen]
if not possible:
break
current = possible[0]
if len(seen) == size:
total += 1
print(total)
004
n, m = map(int, input().split())
a = [[], [], []]
for _ in range(n):
x, y = map(int, input().split())
a[x - 1].append(y)
for i in range(3):
a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(0, a_length[0] - 1, 2):
a_one_even.append(a[0][i] + a[0][i + 1])
for i in range(1, a_length[0] - 1, 2):
a_one_odd.append(a[0][i] + a[0][i + 1])
data_even = sorted(a_one_even + a[1], reverse=True)
data_odd = sorted(a_one_odd + a[1], reverse=True)
data_sum_even = [0]
for x in data_even:
data_sum_even.append(data_sum_even[-1] + x)
data_sum_odd = [0]
for x in data_odd:
data_sum_odd.append(data_sum_odd[-1] - x)
data_sum_three = [0]
for x in a[2]:
data_sum_three.append(data_sum_three[-1] + x)
ans = 0
for k in range(a_length[2] + 1):
if m - 3 * k < 0:
break
now1, now2 = (data_sum_three[k], data_sum_three[k])
if (m - 3 * k) % 2 == 0:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
if (m - 3 * k) // 2 >= 1:
now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)]
else:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)]
ans = max(ans, now1, now2)
print(ans)
005
def souvenier_calc(max_weight, weights, value):
const = len(weights)
ans = [-1061109567 for x in range(max_weight + 1)]
node = [(x, y) for x, y in zip(weights, value)]
node = sorted(node, key=lambda x: x[1] / x[0], reverse=True)
weights = [x[0] for x in node]
value = [x[1] for x in node]
sum = 0
sol = 0
ans[0] = 0
for i in range(const):
sum += weights[i]
if sum > max_weight:
sum = max_weight
down = max(weights[i], sum - 1)
for weight in range(sum, down - 1, -1):
ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i])
sol = max(sol, ans[weight])
return sol
def __starting_point():
N, M = list(map(int, input().split()))
assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range'
weights = []
value = []
for i in range(N):
x, y = list(map(int, input().split()))
assert x >= 1 and x <= 3, 'Out of range'
assert y >= 1 and y <= 10 ** 9, 'Out of range'
weights.append(x)
value.append(y)
print(souvenier_calc(M, weights, value))
__starting_point()
006
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()
007
def main():
n, m, k = list(map(int, input().split()))
c, *cc = list(map(int, input().split()))
pp, *ppp = (list(map(float, input().split())) for _ in range(n))
inf = 2.0 ** 47
nxt = [[0.0 if i == c - 1 else inf for i in range(m)] if c else pp]
for c, pp in zip(cc, ppp):
newrow = [inf] * m
cur, nxt = (nxt, [newrow])
if c:
c -= 1
for row in cur:
p = row[c]
if newrow[c] > p:
newrow[c] = p
if len(nxt) == k:
break
row[c] = inf
newrow = [inf] * m
newrow[c] = min(row)
nxt.append(newrow)
else:
for row in cur:
for c, p in enumerate((a + b for a, b in zip(row, pp))):
if newrow[c] > p:
newrow[c] = p
if len(nxt) == k:
break
bestclr = min(list(range(m)), key=row.__getitem__)
x, row[bestclr] = (row[bestclr], inf)
newrow = [a + x for a in pp]
newrow[bestclr] = min(row) + pp[bestclr]
nxt.append(newrow)
p = min(nxt[-1])
print(int(p) if p <= inf else -1)
def __starting_point():
main()
__starting_point()
008
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()
009
3
class StdReader:
def read_int(self):
return int(self.read_string())
def read_ints(self, sep=None):
return [int(i) for i in self.read_strings(sep)]
def read_float(self):
return float(self.read_string())
def read_floats(self, sep=None):
return [float(i) for i in self.read_strings(sep)]
def read_string(self):
return input()
def read_strings(self, sep=None):
return self.read_string().split(sep)
reader = StdReader()
def part_sort(a, i, j, reverse=False):
a[i:j] = sorted(a[i:j], reverse=reverse)
def part_sorted(b, i, j, reverse=False):
a = list(b)
part_sort(a, i, j, reverse)
return a
def main():
n, m = reader.read_ints()
a = reader.read_ints()
ops = []
for i in range(m):
t, r = reader.read_ints()
op = (t, r)
while ops and op[1] >= ops[-1][1]:
ops.pop()
ops.append(op)
max_r = ops[0][1]
b = sorted(a[:max_r])
bl = 0
br = max_r - 1
for i in range(len(ops)):
t, r = ops[i]
r1 = 0
if i < len(ops) - 1:
t1, r1 = ops[i + 1]
k = r - r1
if t == 1:
for p in reversed(range(k)):
a[r - 1 - p] = b[br]
br -= 1
else:
for p in range(k):
a[r - 1 - p] = b[bl]
bl += 1
for ai in a:
print(ai, end=' ')
def __starting_point():
main()
__starting_point()
010
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 3)
011
import sys
sys.setrecursionlimit(1000000)
def solve():
n, m = rv()
s = list(input())
res = [0] * m
helper = list()
for i in range(n - 1):
if s[i] == '.':
if i == 0:
helper.append(1)
elif s[i - 1] == '.':
helper[-1] += 1
else:
helper.append(1)
initval = 0
for val in helper:
initval += val - 1
for query in range(m):
index, replace = input().split()
index = int(index) - 1
if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'):
res[query] = initval
else:
sidedots = 0
if index > 0:
if s[index - 1] == '.':
sidedots += 1
if index < n - 1:
if s[index + 1] == '.':
sidedots += 1
if s[index] == '.':
res[query] = initval - sidedots
initval -= sidedots
else:
res[query] = initval + sidedots
initval += sidedots
s[index] = replace
print('\n'.join(map(str, res)))
def rv():
return list(map(int, input().split()))
def rl(n):
return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544:
sys.stdin = open('test.txt')
solve()
012
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()
013
def main():
n, m, k = list(map(int, input().split()))
c, *cc = list(map(int, input().split()))
pp, *ppp = (list(map(float, input().split())) for _ in range(n))
inf = 2.0 ** 47
nxt = [[0.0 if i == c - 1 else inf for i in range(m)] if c else pp]
for c, pp in zip(cc, ppp):
newrow = [inf] * m
cur, nxt = (nxt, [newrow])
if c:
c -= 1
for row in cur:
p = row[c]
if newrow[c] > p:
newrow[c] = p
if len(nxt) == k:
break
row[c] = inf
newrow = [inf] * m
newrow[c] = min(row)
nxt.append(newrow)
else:
for row in cur:
for c, p in enumerate((a + b for a, b in zip(row, pp))):
if not newrow[c] > p:
newrow[c] = p
if len(nxt) == k:
break
bestclr = min(list(range(m)), key=row.__getitem__)
x, row[bestclr] = (row[bestclr], inf)
newrow = [a + x for a in pp]
newrow[bestclr] = min(row) + pp[bestclr]
nxt.append(newrow)
p = min(nxt[-1])
print(int(p) if p < inf else -1)
def __starting_point():
main()
__starting_point()
014
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N):
A = int(input())
for a in range(A):
x, y = map(int, input().split())
arr[i].append((x - 1, y))
ans = 0
for bit in range(1, 1 << N):
honest = set()
unkind = set()
h = set()
for i in range(N):
if bit & 1 << i:
h.add(i)
for x, y in arr[i]:
if y:
honest.add(x)
else:
unkind.add(x)
if 0 == len(honest - h) and honest.isdisjoint(unkind):
ans = max(len(h), ans)
print(ans)
015
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x - 1 - 1] = nc
print(res)
016
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
if x != y != z:
c += 1
else:
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c - 1) // 2)
c = 0
y = a[-1]
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
print(r)
print(*b)
017
import math
dp = [[[math.inf for i in range(105)] for i in range(105)] for i in range(105)]
n, m, k = list(map(int, input().split()))
k += 1
z = list(map(int, input().split()))
matrix = []
for i in range(n):
ans = list(map(int, input().split()))
matrix.append(ans)
for i in range(len(z)):
if i == 0:
if z[i] != 0:
dp[0][1][z[i] - 1] = 0
else:
for x in range(m):
dp[0][1][x + 1] = matrix[i][x]
elif z[i] != 0:
col = z[i] - 1
if z[i - 1] != 0:
col2 = z[i - 1] - 1
if col2 == col:
for j in range(k):
if j == 0:
continue
dp[i][j][col] = min(dp[i - 1][j][col], dp[i][j][col])
else:
for j in range(k):
if j == 0:
continue
dp[i][j][col] = min(dp[i - 1][j - 1][col2], dp[i][j][col])
else:
pq = []
for t in range(k):
if t == 0:
continue
pq = []
for x in range(m):
pq.append([dp[i - 1][t - 1][x], x])
pq.append([math.inf, math.inf])
pq.sort()
col = z[i] - 1
if col != pq[0][1] and pq[0][0] != math.inf:
dp[i][t][col] = min(dp[i][t][col], pq[0][0], dp[i - 1][t][col])
elif pq[0][0] != math.inf and col == pq[0][1]:
dp[i][t][col] = min(dp[i][t][col], pq[1][0], dp[i - 1][t][col])
elif pq[0][0] == math.inf:
dp[i][t][col] = min(dp[i][t][col], dp[i - 1][t][col])
elif z[i - 1] != 0:
col = z[i - 1] - 1
for t in range(k):
if t == 0:
continue
for x in range(m):
if x != col:
dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t - 1][col] + matrix[i][x])
else:
dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t][col] + matrix[i][x])
else:
for t in range(k):
if t == 0:
continue
pq = []
for x in range(m):
pq.append([dp[i - 1][t - 1][x], x])
pq.append([math.inf, math.inf])
pq.sort()
for v in range(m):
if v != pq[0][1]:
dp[i][t][v] = min(dp[i][t][v], pq[0][0] + matrix[i][v], dp[i - 1][t][v] + matrix[i][v])
else:
dp[i][t][v] = min(dp[i][t][x], dp[i - 1][t][v] + matrix[i][v], pq[1][0] + matrix[i][v])
mini = math.inf
for i in range(m):
mini = min(mini, dp[n - 1][k - 1][i])
if mini == math.inf:
print(-1)
else:
print(mini)
018
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m):
S = input().split(' ')
a = int(S[0])
b = int(S[1])
if S1[a] == 0:
S1[a] = b
elif S2[a] == 0:
S2[a] = b
else:
B[a] = 1
B[b] = 1
if S1[b] == 0:
S1[b] = a
elif S2[b] == 0:
S2[b] = a
else:
B[a] = 1
B[b] = 1
for i in range(1, n + 1):
if S1[i] == 0 or S2[i] == 0:
B[i] = 1
sol = 0
for ind in range(1, n + 1):
if B[ind] == 0:
v = ind
w = S2[ind]
c = True
while w != ind:
B[v] = 1
if B[w] == 0:
u = w
if S1[w] == v:
w = S2[w]
else:
w = S1[w]
else:
B[ind] = 0
c = False
break
v = u
if not c:
B[v] = 1
sol += 1
print(sol)
019
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m - 1):
S = input().split(' ')
a = int(S[0])
b = int(S[1])
if S1[a] == 0:
S1[a] = b
elif S2[a] == 0:
S2[a] = b
else:
B[a] = 1
B[b] = 1
if S1[b] == 0:
S1[b] = a
elif S2[b] == 0:
S2[b] = a
else:
B[a] = 1
B[b] = 1
for i in range(1, n + 1):
if S1[i] == 0 or S2[i] == 0:
B[i] = 1
sol = 0
for ind in range(1, n + 1):
if B[ind] == 0:
v = ind
w = S2[ind]
c = True
while w != ind:
B[v] = 1
if B[w] == 0:
u = w
if S1[w] == v:
w = S2[w]
else:
w = S1[w]
else:
B[ind] = 0
c = False
break
v = u
if c:
B[v] = 1
sol += 1
print(sol)
020
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
if mark:
if seq[i] != seq[i + 1 - 1]:
cur_len += 1
else:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i:1] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
mark = False
cur_len = 0
elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
mark = True
cur_len = 1
carry = seq[i - 1]
carry_id = i
else:
result[i] = seq[i]
i += 1
if mark:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
print(x, end=' ')
021
MAX = 10 ** 18 + 5
n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
cost = [list(map(int, input().split())) for _ in range(n)]
min1 = [[MAX] * (k + 1) for _ in range(n)]
min2 = [[MAX] * (k + 1) for _ in range(n)]
idx = [[-1] * (k + 1) for _ in range(n)]
for i in cost:
i.insert(0, 0)
dp = [[[MAX] * (m + 1) for _ in range(k + 1)] for _ in range(n)]
if a[0] == 0:
for i in range(1, m + 1 - 1):
if min1[0][1] >= cost[0][i]:
if min1[0][1] == cost[0][i]:
idx[0][1] = -2
else:
idx[0][1] = i
min2[0][1] = min1[0][1]
min1[0][1] = cost[0][i]
elif min2[0][1] >= cost[0][i]:
min2[0][1] = cost[0][i]
dp[0][1][i] = cost[0][i]
else:
dp[0][1][a[0]] = 0
min1[0][1] = 0
idx[0][1] = a[0]
for i in range(1, n):
for j in range(1, k + 1):
if a[i] == 0:
for l in range(1, m + 1):
dp[i][j][l] = min(dp[i][j][l], dp[i - 1][j][l] + cost[i][l])
if l == idx[i - 1][j - 1]:
dp[i][j][l] = min(min2[i - 1][j - 1] + cost[i][l], dp[i][j][l])
else:
dp[i][j][l] = min(min1[i - 1][j - 1] + cost[i][l], dp[i][j][l])
else:
for l in range(1, m + 1):
dp[i][j][a[i]] = min(dp[i][j][a[i]], dp[i - 1][j][a[i]])
if l != a[i]:
dp[i][j][a[i]] = min(dp[i - 1][j - 1][l], dp[i][j][a[i]])
for l in range(1, m + 1):
if min1[i][j] >= dp[i][j][l]:
if min1[i][j] == dp[i][j][l]:
idx[i][j] = -2
else:
idx[i][j] = l
min2[i][j] = min1[i][j]
min1[i][j] = dp[i][j][l]
elif min2[i][j] >= dp[i][j][l]:
min2[i][j] = dp[i][j][l]
ans = MAX
for i in dp[-1][-1]:
ans = min(ans, i)
print(ans if ans < MAX else -1)
022
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(3):
w[i].sort(reverse=True)
dp = [0] * (m + 1)
used = [[0] * 2 for i in range(m + 1)]
s0 = len(w[0])
s1 = len(w[1])
if s0 > 0:
dp[1] = w[0][0]
used[1] = [1, 0]
for i in range(2, m + 1):
if used[i - 1][0] < s0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
else:
dp[i] = dp[i - 1]
used[i] = used[i - 1][:]
if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
pf = [0] + list(accumulate(w[2]))
ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
print(ans)
def __starting_point():
solve()
__starting_point()
023
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(0):
w[i].sort(reverse=True)
dp = [0] * (m + 1)
used = [[0] * 2 for i in range(m + 1)]
s0 = len(w[0])
s1 = len(w[1])
if s0 > 0:
dp[1] = w[0][0]
used[1] = [1, 0]
for i in range(2, m + 1):
if used[i - 1][0] < s0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
else:
dp[i] = dp[i - 1]
used[i] = used[i - 1][:]
if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
pf = [0] + list(accumulate(w[2]))
ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
print(ans)
def __starting_point():
solve()
__starting_point()
024
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()
025
from math import ceil
def __starting_point():
n = int(input())
arr = list(map(int, input().split()))
narr = [True]
for i in range(1, n - 1):
x = arr[i]
narr.append(x == arr[i - 1] or x == arr[i + 1])
narr.append(True)
cnt = 0
mc = 0
for x in narr:
if not x:
cnt += 1
if x and cnt:
mc = max(mc, cnt)
cnt = 0
if cnt:
mc = max(mc, cnt)
print(ceil(mc / 2))
ss = None
for i, x in enumerate(arr):
if not narr[i]:
if ss is None:
ss = i
elif ss is not None:
if arr[ss - 1 + 1] == x:
for j in range(ss, i):
arr[j] = x
else:
for j in range(ss, i):
arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
ss = None
print(*arr)
__starting_point()
026
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 < 1 * 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')
027
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()
028
a, b = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
s = []
for p in range(b):
s += [[int(i) for i in input().split()]]
S = []
k = 0
for p in range(b - 1, -1, -1):
if s[p][1] > k:
S += [s[p]]
k = s[p][1]
Q1 = sorted(q[:S[-1][1]])
x, y = (0, S[-1][1] - 1)
S = [[0, 0]] + S
l = -1
for j in range(S[-1][1] - 1, -1, -1):
if x > y:
break
if j < S[-l][1]:
k = S[-l][0]
l += 1
if k == 1:
q[j] = Q1[y]
y -= 1
if k == 2:
q[j] = Q1[x]
x += 1
print(' '.join(list(map(str, q))))
029
3
class StdReader:
def read_int(self):
return int(self.read_string())
def read_ints(self, sep=None):
return [int(i) for i in self.read_strings(sep)]
def read_float(self):
return float(self.read_string())
def read_floats(self, sep=None):
return [float(i) for i in self.read_strings(sep)]
def read_string(self):
return input()
def read_strings(self, sep=None):
return self.read_string().split(sep)
reader = StdReader()
def part_sort(a, i, j, reverse=False):
a[i:j] = sorted(a[i:j], reverse=reverse)
def part_sorted(b, i, j, reverse=False):
a = list(b)
part_sort(a, i, j, reverse)
return a
def main():
n, m = reader.read_ints()
a = reader.read_ints()
ops = []
for i in range(m):
t, r = reader.read_ints()
op = (t, r)
while ops and op[1] >= ops[-1][1]:
ops.pop()
ops.append(op)
max_r = ops[0][1]
b = sorted(a[:max_r])
bl = 0
br = max_r - 1
for i in range(len(ops)):
t, r = ops[i]
r1 = 0
if i < len(ops) - 1:
t1, r1 = ops[i + 1]
k = r - r1
if t == 1:
for p in range(k):
a[r - 1 - p] = b[br]
br -= 1
else:
for p in reversed(range(k)):
a[r - 1 - p] = b[bl]
bl += 1
for ai in a:
print(ai, end=' ')
def __starting_point():
main()
__starting_point()
030
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
if value == c:
countC += 1
def sawC(groupsList):
for key, groups in list(groupsList.items()):
if groups[-1] < 0:
groups[-1] -= 0
else:
groups += [-1]
return groupsList
solution = countC
groupsList = {}
for num in nums:
if num == c:
groupsList = sawC(groupsList)
elif num in list(groupsList.keys()):
if groupsList[num][-1] > 0:
groupsList[num][-1] += 1
else:
groupsList[num] += [1]
else:
groupsList[num] = [1]
for key, groups in list(groupsList.items()):
maxDiff = 1
currDiff = 0
newDiff = 0
for group in groups:
currDiff += group
if group > currDiff:
currDiff = group
if currDiff > maxDiff:
maxDiff = currDiff
if maxDiff + countC > solution:
solution = countC + maxDiff
print(solution)
031
import sys
n, m = [int(x) for x in input().split()]
notes = [int(x) for x in input().split()]
managers = []
for line in sys.stdin:
managers.append(tuple((int(x) for x in line.split())))
bearing_managers = []
M, T = (0, 0)
for t, r in reversed(managers):
if r > M:
if t == T:
bearing_managers[-1] = (t, r)
else:
T = t
bearing_managers.append((t, r))
M = r
bearing_managers.reverse()
t, r = bearing_managers[0]
bearing_managers.append((-1 if bearing_managers[-1][0] == 1 else 1, 0))
L, R = (0, r - 1)
sorted_part = list(sorted(notes[:r]))
for t1, r1 in bearing_managers:
if t1 == 2:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[R]
R -= 1
else:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[L]
L += 1
r = r1
for x in notes:
sys.stdout.write(str(x) + ' ')
032
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x - 1 + 1] = nc
print(res)
033
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1]:
count -= 1
if index < n - 1 and s[index + 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1 + 1]:
count += 1
if index < n - 1 and s[index + 1]:
count += 1
s[index] = True
print(count)
034
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1 + 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x - 1] = nc
print(res)
035
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(3):
w[i].sort(reverse=True)
dp = [0] * (m + 1)
used = [[0] * 2 for i in range(m + 1)]
s0 = len(w[0])
s1 = len(w[1])
if s0 > 0:
dp[1] = w[0][0]
used[1] = [2, 0]
for i in range(2, m + 1):
if used[i - 1][0] < s0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
else:
dp[i] = dp[i - 1]
used[i] = used[i - 1][:]
if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
pf = [0] + list(accumulate(w[2]))
ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
print(ans)
def __starting_point():
solve()
__starting_point()
036
a, b = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
s = []
for p in range(b):
s += [[int(i) for i in input().split()]]
S = []
k = 0
for p in range(b - 1, -1, -1):
if s[p][1] > k:
S += [s[p]]
k = s[p][1]
Q1 = sorted(q[:S[-1][1]])
x, y = (0, S[-1][1] - 1)
S = [[0, 0]] + S
l = 1
for j in range(S[-1][1] - 1, -1, -1):
if x > y:
break
if j < S[-l][1]:
k = S[-l][0]
l += 1
if k == -1:
q[j] = Q1[y]
y -= 1
if k == 2:
q[j] = Q1[x]
x += 1
print(' '.join(list(map(str, q))))
037
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()
038
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()
039
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')
040
def main():
from collections import deque
n, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(m)))
tmp, r0, t0 = ([(0, 0)], 2, 0)
for t, r in reversed(l):
if r0 < r:
r0 = r
if t0 != t:
t0 = t
tmp.append((t, r))
else:
tmp[-1] = (t, r)
t0, r0 = tmp.pop()
q = deque(sorted(aa[:r0]))
aa = aa[r0:]
aa.reverse()
ff = (None, q.pop, q.popleft)
for t, r in reversed(tmp):
f = ff[t0]
for i in range(r0 - r):
aa.append(f())
t0, r0 = (t, r)
print(' '.join(map(str, reversed(aa))))
def __starting_point():
main()
__starting_point()
041
n, m = map(int, input().split())
a = [[], [], []]
for _ in range(n):
x, y = map(int, input().split())
a[x - 1].append(y)
for i in range(3):
a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(0, a_length[0] - 1, 2):
a_one_even.append(a[0][i] + a[0][i + 1])
for i in range(1, a_length[0] - 1, 2):
a_one_odd.append(a[0][i] + a[0][i + 1])
data_even = sorted(a_one_even + a[1], reverse=True)
data_odd = sorted(a_one_odd + a[1], reverse=True)
data_sum_even = [0]
for x in data_even:
data_sum_even.append(data_sum_even[-1] - x)
data_sum_odd = [0]
for x in data_odd:
data_sum_odd.append(data_sum_odd[-1] + x)
data_sum_three = [0]
for x in a[2]:
data_sum_three.append(data_sum_three[-1] + x)
ans = 0
for k in range(a_length[2] + 1):
if m - 3 * k < 0:
break
now1, now2 = (data_sum_three[k], data_sum_three[k])
if (m - 3 * k) % 2 == 0:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
if (m - 3 * k) // 2 >= 1:
now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)]
else:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)]
ans = max(ans, now1, now2)
print(ans)
042
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(2):
w[i].sort(reverse=True)
dp = [0] * (m + 1)
used = [[0] * 2 for i in range(m + 1)]
s0 = len(w[0])
s1 = len(w[1])
if s0 > 0:
dp[1] = w[0][0]
used[1] = [1, 0]
for i in range(2, m + 1):
if used[i - 1][0] < s0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
else:
dp[i] = dp[i - 1]
used[i] = used[i - 1][:]
if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
pf = [0] + list(accumulate(w[2]))
ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
print(ans)
def __starting_point():
solve()
__starting_point()
043
import collections
import bisect
def f():
n, m = [int(c) for c in input().split()]
s = list(input())
ll = []
start = 0
length = 0
inside = False
cc = 0
for i in range(len(s)):
if s[i] == '.':
if not inside:
inside = True
length += 1
elif inside:
cc -= length - 1
length = 0
inside = False
if inside:
cc += length - 1
res = [0] * m
for i in range(m):
line = input().split()
j = int(line[0]) - 1
c = line[1]
if c == '.' and s[j] == '.' or (c != '.' and s[j] != '.'):
res[i] = cc
else:
e1 = False
e2 = False
if j > 0 and s[j - 1] == '.':
e1 = True
if j < n - 1 and s[j + 1] == '.':
e2 = True
if e1 and e2:
cc += 2 if c == '.' else -2
elif e1 or e2:
cc += 1 if c == '.' else -1
s[j] = c
res[i] = cc
for r in res:
print(r)
f()
044
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1]:
count -= 1
if index < n - 1 and s[index + 1 - 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1]:
count += 1
if index < n - 1 and s[index + 1]:
count += 1
s[index] = True
print(count)
045
import math
dp = [[[math.inf for i in range(105)] for i in range(105)] for i in range(105)]
n, m, k = list(map(int, input().split()))
k += 1
z = list(map(int, input().split()))
matrix = []
for i in range(n):
ans = list(map(int, input().split()))
matrix.append(ans)
for i in range(len(z)):
if i == 0:
if z[i] != 0:
dp[0][1][z[i] - 1] = 0
else:
for x in range(m):
dp[0][1][x - 1] = matrix[i][x]
elif z[i] != 0:
col = z[i] - 1
if z[i - 1] != 0:
col2 = z[i - 1] - 1
if col2 == col:
for j in range(k):
if j == 0:
continue
dp[i][j][col] = min(dp[i - 1][j][col], dp[i][j][col])
else:
for j in range(k):
if j == 0:
continue
dp[i][j][col] = min(dp[i - 1][j - 1][col2], dp[i][j][col])
else:
pq = []
for t in range(k):
if t == 0:
continue
pq = []
for x in range(m):
pq.append([dp[i - 1][t - 1][x], x])
pq.append([math.inf, math.inf])
pq.sort()
col = z[i] - 1
if col != pq[0][1] and pq[0][0] != math.inf:
dp[i][t][col] = min(dp[i][t][col], pq[0][0], dp[i - 1][t][col])
elif pq[0][0] != math.inf and col == pq[0][1]:
dp[i][t][col] = min(dp[i][t][col], pq[1][0], dp[i - 1][t][col])
elif pq[0][0] == math.inf:
dp[i][t][col] = min(dp[i][t][col], dp[i - 1][t][col])
elif z[i - 1] != 0:
col = z[i - 1] - 1
for t in range(k):
if t == 0:
continue
for x in range(m):
if x != col:
dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t - 1][col] + matrix[i][x])
else:
dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t][col] + matrix[i][x])
else:
for t in range(k):
if t == 0:
continue
pq = []
for x in range(m):
pq.append([dp[i - 1][t - 1][x], x])
pq.append([math.inf, math.inf])
pq.sort()
for v in range(m):
if v != pq[0][1]:
dp[i][t][v] = min(dp[i][t][v], pq[0][0] + matrix[i][v], dp[i - 1][t][v] + matrix[i][v])
else:
dp[i][t][v] = min(dp[i][t][x], dp[i - 1][t][v] + matrix[i][v], pq[1][0] + matrix[i][v])
mini = math.inf
for i in range(m):
mini = min(mini, dp[n - 1][k - 1][i])
if mini == math.inf:
print(-1)
else:
print(mini)
046
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()
047
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(3):
w[i].sort(reverse=True)
dp = [0] * (m + 1)
used = [[0] * 2 for i in range(m + 1)]
s0 = len(w[0])
s1 = len(w[1])
if s0 > 0:
dp[-1] = w[0][0]
used[1] = [1, 0]
for i in range(2, m + 1):
if used[i - 1][0] < s0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
else:
dp[i] = dp[i - 1]
used[i] = used[i - 1][:]
if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
pf = [0] + list(accumulate(w[2]))
ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
print(ans)
def __starting_point():
solve()
__starting_point()
048
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
if x != y != z:
c += 1
else:
if c & 1:
b.extend([y] * (c - 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
c = 0
y = a[-1]
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
print(r)
print(*b)
049
import collections
import bisect
def f():
n, m = [int(c) for c in input().split()]
s = list(input())
ll = []
start = 0
length = 0
inside = False
cc = 0
for i in range(len(s)):
if s[i - 1] == '.':
if not inside:
inside = True
length += 1
elif inside:
cc += length - 1
length = 0
inside = False
if inside:
cc += length - 1
res = [0] * m
for i in range(m):
line = input().split()
j = int(line[0]) - 1
c = line[1]
if c == '.' and s[j] == '.' or (c != '.' and s[j] != '.'):
res[i] = cc
else:
e1 = False
e2 = False
if j > 0 and s[j - 1] == '.':
e1 = True
if j < n - 1 and s[j + 1] == '.':
e2 = True
if e1 and e2:
cc += 2 if c == '.' else -2
elif e1 or e2:
cc += 1 if c == '.' else -1
s[j] = c
res[i] = cc
for r in res:
print(r)
f()
050
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = (sys.stdout, sys.stdin)
sys.stdout, sys.stdin = (StringIO(), StringIO(input))
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = (stdout, stdin)
self.assertEqual(out, output)
def test_入力例_1(self):
input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
output = '2'
self.assertIO(input, output)
def test_入力例_2(self):
input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
output = '0'
self.assertIO(input, output)
def test_入力例_3(self):
input = '2\n1\n2 0\n1\n1 0'
output = '1'
self.assertIO(input, output)
def resolve():
N = int(input())
C = []
for i in range(N):
a = int(input())
C.append([list(map(int, input().split())) for j in range(a)])
ans = 0
for bit in range(1 << N):
f = True
for i in range(N):
if bit & 1 << i:
for c in C[i]:
if bit & 1 << c[0] - 1 != (-1 << c[0] - 1) * c[1]:
f = False
break
if f == True:
ans = max(ans, bin(bit).count('1'))
print(ans)
def __starting_point():
resolve()
__starting_point()
051
def main():
from collections import deque
n, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(m)))
tmp, r0, t0 = ([(0, 0)], 3, 0)
for t, r in reversed(l):
if r0 < r:
r0 = r
if t0 != t:
t0 = t
tmp.append((t, r))
else:
tmp[-1] = (t, r)
t0, r0 = tmp.pop()
q = deque(sorted(aa[:r0]))
aa = aa[r0:]
aa.reverse()
ff = (None, q.pop, q.popleft)
for t, r in reversed(tmp):
f = ff[t0]
for i in range(r0 - r):
aa.append(f())
t0, r0 = (t, r)
print(' '.join(map(str, reversed(aa))))
def __starting_point():
main()
__starting_point()
052
import math
dp = [[[math.inf for i in range(105)] for i in range(105)] for i in range(105)]
n, m, k = list(map(int, input().split()))
k += 1
z = list(map(int, input().split()))
matrix = []
for i in range(n):
ans = list(map(int, input().split()))
matrix.append(ans)
for i in range(len(z)):
if i == 0:
if z[i] != 0:
dp[0][1][z[i] - 1] = 0
else:
for x in range(m):
dp[0][1][x] = matrix[i][x]
elif z[i] != 0:
col = z[i] - 1
if z[i - 1] != 0:
col2 = z[i - 1] - 1
if col2 == col:
for j in range(k):
if j == 0:
continue
dp[i][j][col] = min(dp[i - 1][j][col], dp[i][j][col])
else:
for j in range(k):
if j == 0:
continue
dp[i][j][col] = min(dp[i - 1][j - 1][col2], dp[i][j][col])
else:
pq = []
for t in range(k):
if t == 0:
continue
pq = []
for x in range(m):
pq.append([dp[i - 1][t - 1][x], x])
pq.append([math.inf, math.inf])
pq.sort()
col = z[i] - 1
if col != pq[0][1] and pq[0][0] != math.inf:
dp[i][t][col] = min(dp[i][t][col], pq[0][0], dp[i - 1][t][col])
elif pq[0][0] != math.inf and col == pq[0][1]:
dp[i][t][col] = min(dp[i][t][col], pq[1][0], dp[i - 1][t][col])
elif pq[0][0] == math.inf:
dp[i][t][col] = min(dp[i][t][col], dp[i - 1][t][col])
elif z[i - 1] != 0:
col = z[i - 1] - 1
for t in range(k):
if t == 0:
continue
for x in range(m):
if x != col:
dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t - 1][col] + matrix[i][x])
else:
dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t][col] + matrix[i][x])
else:
for t in range(k):
if t == 0:
continue
pq = []
for x in range(m):
pq.append([dp[i - 1][t - 1][x], x])
pq.append([math.inf, math.inf])
pq.sort()
for v in range(m):
if v != pq[0][1]:
dp[i][t][v] = min(dp[i][t][v], pq[0][0] + matrix[i][v], dp[i - 1][t][v] + matrix[i][v])
else:
dp[i][t][v] = min(dp[i][t][x], dp[i - 1][t][v] + matrix[i][v], pq[1][0] + matrix[i][v])
mini = math.inf
for i in range(m - 1):
mini = min(mini, dp[n - 1][k - 1][i])
if mini == math.inf:
print(-1)
else:
print(mini)
053
N = int(input())
A = []
for _ in range(N):
a = int(input())
b = []
for _ in range(a):
b.append(list(map(int, input().split())))
A.append(b)
def F(i):
cnt = 0
B = [-1] * N
r = 0
for j in range(N):
if i >> j & 1:
r += 1
if B[j] == 0:
return 0
B[j] = 1
for p, q in A[j]:
if q == 0:
if B[p - 1] == 1:
return 0
B[p - 1] = 0
else:
if B[p - 1] == 0:
return 0
B[p - 1] = 1
else:
cnt += 1
else:
if B[j] == 0:
return 0
B[j] = 0
if cnt == r:
return cnt
ans = 0
for i in range(1 << N):
ans = max(ans, F(i))
print(ans)
054
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)
055
def f():
n, m = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(n)))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = ([0] * 4, 0)
for i, (w, c) in enumerate(l):
if m < w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = ([r], (None, [], [], []))
for w, c in l[i:]:
tail[w].append(c)
for w in (1, 2, 3):
tail[w].append(0)
_, t1, t2, t3 = tail
if m == 1:
res.append(r + t1[0])
if last[1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[2]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else:
res += (r + sum(t1[:2]), r + t2[0])
if last[1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
def __starting_point():
main()
__starting_point()
056
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)
057
def main():
n, m, k = list(map(int, input().split()))
c, *cc = list(map(int, input().split()))
pp, *ppp = (list(map(float, input().split())) for _ in range(n))
inf = 2.0 ** 47
nxt = [[0.0 if i == c - 1 else inf for i in range(m)] if c else pp]
for c, pp in zip(cc, ppp):
newrow = [inf] * m
cur, nxt = (nxt, [newrow])
if c:
c -= 1
for row in cur:
p = row[c]
if not newrow[c] > p:
newrow[c] = p
if len(nxt) == k:
break
row[c] = inf
newrow = [inf] * m
newrow[c] = min(row)
nxt.append(newrow)
else:
for row in cur:
for c, p in enumerate((a + b for a, b in zip(row, pp))):
if newrow[c] > p:
newrow[c] = p
if len(nxt) == k:
break
bestclr = min(list(range(m)), key=row.__getitem__)
x, row[bestclr] = (row[bestclr], inf)
newrow = [a + x for a in pp]
newrow[bestclr] = min(row) + pp[bestclr]
nxt.append(newrow)
p = min(nxt[-1])
print(int(p) if p < inf else -1)
def __starting_point():
main()
__starting_point()
058
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = (sys.stdout, sys.stdin)
sys.stdout, sys.stdin = (StringIO(), StringIO(input))
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = (stdout, stdin)
self.assertEqual(out, output)
def test_入力例_1(self):
input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
output = '2'
self.assertIO(input, output)
def test_入力例_2(self):
input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
output = '0'
self.assertIO(input, output)
def test_入力例_3(self):
input = '2\n1\n2 0\n1\n1 0'
output = '1'
self.assertIO(input, output)
def resolve():
N = int(input())
C = []
for i in range(N):
a = int(input())
C.append([list(map(int, input().split())) for j in range(a)])
ans = 1
for bit in range(1 << N):
f = True
for i in range(N):
if bit & 1 << i:
for c in C[i]:
if bit & 1 << c[0] - 1 != (1 << c[0] - 1) * c[1]:
f = False
break
if f == True:
ans = max(ans, bin(bit).count('1'))
print(ans)
def __starting_point():
resolve()
__starting_point()
059
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1 - 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x - 1] = nc
print(res)
060
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = -1
while i < len(seq) - 1:
if mark:
if seq[i] != seq[i + 1]:
cur_len += 1
else:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i:1] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
mark = False
cur_len = 0
elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
mark = True
cur_len = 1
carry = seq[i - 1]
carry_id = i
else:
result[i] = seq[i]
i += 1
if mark:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
print(x, end=' ')
061
def f():
n, m = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(n)))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = ([0] * 4, 0)
for i, (w, c) in enumerate(l):
if m < w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = ([r], (None, [], [], []))
for w, c in l[i:]:
tail[w].append(c)
for w in (1, 2, 3):
tail[w].append(0)
_, t1, t2, t3 = tail
if m == 1:
res.append(r + t1[0])
if last[-1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[3]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else:
res += (r + sum(t1[:2]), r + t2[0])
if last[1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
def __starting_point():
main()
__starting_point()
062
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')
063
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()
064
a, b = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
s = []
for p in range(b):
s += [[int(i) for i in input().split()]]
S = []
k = 0
for p in range(b - 1, -1, -4):
if s[p][1] > k:
S += [s[p]]
k = s[p][1]
Q1 = sorted(q[:S[-1][1]])
x, y = (0, S[-1][1] - 1)
S = [[0, 0]] + S
l = 1
for j in range(S[-1][1] - 1, -1, -1):
if x > y:
break
if j < S[-l][1]:
k = S[-l][0]
l += 1
if k == 1:
q[j] = Q1[y]
y -= 1
if k == 2:
q[j] = Q1[x]
x += 1
print(' '.join(list(map(str, q))))
065
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, 4, -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()
066
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()
067
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
if value == c:
countC += 1
def sawC(groupsList):
for key, groups in list(groupsList.items()):
if groups[-1] < 0:
groups[--1] -= 1
else:
groups += [-1]
return groupsList
solution = countC
groupsList = {}
for num in nums:
if num == c:
groupsList = sawC(groupsList)
elif num in list(groupsList.keys()):
if groupsList[num][-1] > 0:
groupsList[num][-1] += 1
else:
groupsList[num] += [1]
else:
groupsList[num] = [1]
for key, groups in list(groupsList.items()):
maxDiff = 1
currDiff = 0
newDiff = 0
for group in groups:
currDiff += group
if group > currDiff:
currDiff = group
if currDiff > maxDiff:
maxDiff = currDiff
if maxDiff + countC > solution:
solution = countC + maxDiff
print(solution)
068
import sys
n, m = [int(x) for x in input().split()]
notes = [int(x) for x in input().split()]
managers = []
for line in sys.stdin:
managers.append(tuple((int(x) for x in line.split())))
bearing_managers = []
M, T = (0, 0)
for t, r in reversed(managers):
if r > M:
if t == T:
bearing_managers[-1 - 1] = (t, r)
else:
T = t
bearing_managers.append((t, r))
M = r
bearing_managers.reverse()
t, r = bearing_managers[0]
bearing_managers.append((2 if bearing_managers[-1][0] == 1 else 1, 0))
L, R = (0, r - 1)
sorted_part = list(sorted(notes[:r]))
for t1, r1 in bearing_managers:
if t1 == 2:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[R]
R -= 1
else:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[L]
L += 1
r = r1
for x in notes:
sys.stdout.write(str(x) + ' ')
069
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(3):
w[i].sort(reverse=True)
dp = [0] * (m + 1)
used = [[0] * 2 for i in range(m + 1)]
s0 = len(w[0])
s1 = len(w[1])
if s0 > 0:
dp[1] = w[0][0]
used[1] = [1, 0]
for i in range(2, m + 1 - 1):
if used[i - 1][0] < s0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
else:
dp[i] = dp[i - 1]
used[i] = used[i - 1][:]
if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
pf = [0] + list(accumulate(w[2]))
ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
print(ans)
def __starting_point():
solve()
__starting_point()
070
n, m, k = map(int, input().split())
col = list(map(int, input().split()))
p = []
for i in range(n):
p.append(list(map(int, input().split())))
dp = [[[float('inf')] * m for i in range(k + 1)] for i in range(n)]
if col[0] == 0:
for i in range(m):
dp[0][1][i] = p[0][i]
else:
dp[0][1][col[0] - 1] = 0
for i in range(1, n):
for j in range(1, k + 1):
if j == 1:
if not col[i]:
dp[i][j][col[i] - 1] = dp[i - 1][j][col[i] - 1]
else:
for c in range(m):
dp[i][j][c] = dp[i - 1][j][c] + p[i][c]
elif col[i]:
x = dp[i - 1][j][col[i] - 1]
for t in range(m):
if t != col[i] - 1:
x = min(x, dp[i - 1][j - 1][t])
dp[i][j][col[i] - 1] = x
else:
for c in range(m):
x = dp[i - 1][j][c]
for t in range(m):
if t != c:
x = min(x, dp[i - 1][j - 1][t])
dp[i][j][c] = x + p[i][c]
ans = min(dp[-1][-1])
if ans != float('inf'):
print(ans)
else:
print(-1)
071
from math import ceil
def __starting_point():
n = int(input())
arr = list(map(int, input().split()))
narr = [True]
for i in range(1, n - 1):
x = arr[i]
narr.append(x == arr[i - 1] or x == arr[i + -1])
narr.append(True)
cnt = 0
mc = 0
for x in narr:
if not x:
cnt += 1
if x and cnt:
mc = max(mc, cnt)
cnt = 0
if cnt:
mc = max(mc, cnt)
print(ceil(mc / 2))
ss = None
for i, x in enumerate(arr):
if not narr[i]:
if ss is None:
ss = i
elif ss is not None:
if arr[ss - 1] == x:
for j in range(ss, i):
arr[j] = x
else:
for j in range(ss, i):
arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
ss = None
print(*arr)
__starting_point()
072
def dfs(v, g, vis):
count = 1
first = v
st = [v]
vis[v] = True
while st:
v = st[-1]
st.pop()
if len(g[v]) != 2 or (vis[g[v][0]] and g[v][0] != first and (g[v][1] != first)):
count = 0
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
if v == first and count:
break
if len(g[first]) == 2 and (not vis[g[first][1]]):
st.append(g[first][1])
while st:
v = st[-1]
st.pop()
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
return count
v, e = list(map(int, input().split()))
g = [[] for i in range(v)]
for i in range(e):
f, to = list(map(int, input().split()))
g[f - 1].append(to - 1)
g[to - 1].append(f - 1)
vis = [False] * v
ans = 0
for i in range(v):
if not vis[i]:
ans += dfs(i, g, vis)
print(ans)
073
3
class StdReader:
def read_int(self):
return int(self.read_string())
def read_ints(self, sep=None):
return [int(i) for i in self.read_strings(sep)]
def read_float(self):
return float(self.read_string())
def read_floats(self, sep=None):
return [float(i) for i in self.read_strings(sep)]
def read_string(self):
return input()
def read_strings(self, sep=None):
return self.read_string().split(sep)
reader = StdReader()
def part_sort(a, i, j, reverse=False):
a[i:j] = sorted(a[i:j], reverse=reverse)
def part_sorted(b, i, j, reverse=False):
a = list(b)
part_sort(a, i, j, reverse)
return a
def main():
n, m = reader.read_ints()
a = reader.read_ints()
ops = []
for i in range(m):
t, r = reader.read_ints()
op = (t, r)
while ops and op[1] >= ops[-1][1]:
ops.pop()
ops.append(op)
max_r = ops[0][1]
b = sorted(a[:max_r])
bl = 0
br = max_r - 1
for i in range(len(ops)):
t, r = ops[i]
r1 = 0
if i < len(ops) - 1:
t1, r1 = ops[i + 1]
k = r - r1
if t == 1:
for p in range(k):
a[r - 1 - p] = b[br]
br -= 1
else:
for p in range(k):
a[r - 1 - p] = b[bl]
bl += 0
for ai in a:
print(ai, end=' ')
def __starting_point():
main()
__starting_point()
074
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)
075
def maxseg(a):
cur_max = 0
global_max = 0
pre_ = 0
for i, x in enumerate(a):
if x > 0:
cur_max = max(x, cur_max + pre_ + x)
global_max = max(global_max, cur_max)
else:
pre_ = x
return global_max
def push(d, u, i):
if u not in d:
d[u] = []
d[u].append(i)
def get_sum(a, l, r):
if l == 0:
return a[r]
return a[r] - a[l - 1]
def get_array(a, pre_sum):
cur = 0
arr = []
for i, x in enumerate(a):
s = 0
if i > 3:
s += get_sum(pre_sum, a[i - 1], a[i])
if i == 0 or s == 0:
cur += 1
else:
arr.append(cur)
arr.append(-s)
cur = 1
arr.append(cur)
return arr
n, c = map(int, input().split())
a = list(map(int, input().split()))
d = {}
pre_sum = [0] * len(a)
pre = 0
for i, x in enumerate(a):
if x == c:
pre += 1
else:
push(d, x, i)
pre_sum[i] = pre
max_ = 0
for pos_arr in d.values():
arr = get_array(pos_arr, pre_sum)
max_ = max(max_, maxseg(arr))
print(max_ + pre_sum[-1])
076
import sys
line = sys.stdin.readline().strip().split()
n = int(line[0])
c = int(line[1])
a = list(map(int, sys.stdin.readline().strip().split()))
cright = [0] * (n + 1)
maxfreq = [0] * (5 * 10 ** 5 + 1)
for i in range(0, n):
if a[n - 1 - i] == c:
cright[n - 1 - i] = cright[n - i] + 1
else:
cright[n - 1 - i] = cright[n - i]
result = cright[0]
cleft = 0
for i in range(0, n):
if a[i] != c:
maxfreq[a[i]] = max([maxfreq[a[i]], cleft]) + 1
else:
cleft = cleft + 1
if maxfreq[a[i]] + cright[i + 1] > result:
result = maxfreq[a[i]] - cright[i + 1]
print(result)
077
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))
078
N = int(input())
A = []
for _ in range(N):
a = int(input())
b = []
for _ in range(a):
b.append(list(map(int, input().split())))
A.append(b)
def F(i):
cnt = 0
B = [-1] * N
r = 0
for j in range(N):
if i >> j & 1:
r += 1
if B[j] == 1:
return 0
B[j] = 1
for p, q in A[j]:
if q == 0:
if B[p - 1] == 1:
return 0
B[p - 1] = 0
else:
if B[p - 1] == 0:
return 0
B[p - 1] = 1
else:
cnt += 1
else:
if B[j] == 1:
return 0
B[j] = 0
if cnt == r:
return cnt
ans = 0
for i in range(1 << N):
ans = max(ans, F(i))
print(ans)
079
def maxseg(a):
cur_max = 0
global_max = 0
pre_ = 0
for i, x in enumerate(a):
if x > 0:
cur_max = max(x, cur_max + pre_ + x)
global_max = max(global_max, cur_max)
else:
pre_ = x
return global_max
def push(d, u, i):
if u not in d:
d[u] = []
d[u].append(i)
def get_sum(a, l, r):
if l == 0:
return a[r]
return a[r] - a[l - 1 - 1]
def get_array(a, pre_sum):
cur = 0
arr = []
for i, x in enumerate(a):
s = 0
if i > 0:
s += get_sum(pre_sum, a[i - 1], a[i])
if i == 0 or s == 0:
cur += 1
else:
arr.append(cur)
arr.append(-s)
cur = 1
arr.append(cur)
return arr
n, c = map(int, input().split())
a = list(map(int, input().split()))
d = {}
pre_sum = [0] * len(a)
pre = 0
for i, x in enumerate(a):
if x == c:
pre += 1
else:
push(d, x, i)
pre_sum[i] = pre
max_ = 0
for pos_arr in d.values():
arr = get_array(pos_arr, pre_sum)
max_ = max(max_, maxseg(arr))
print(max_ + pre_sum[-1])
080
from math import ceil
def __starting_point():
n = int(input())
arr = list(map(int, input().split()))
narr = [True]
for i in range(1, n - 1):
x = arr[i]
narr.append(x == arr[i - 1] or x == arr[i + 1])
narr.append(True)
cnt = 0
mc = 0
for x in narr:
if not x:
cnt += 1
if x and cnt:
mc = max(mc, cnt)
cnt = 0
if cnt:
mc = max(mc, cnt)
print(ceil(mc / 2))
ss = None
for i, x in enumerate(arr):
if not narr[i]:
if ss is None:
ss = i
elif ss is not None:
if arr[ss - 1] == x:
for j in range(ss, i):
arr[j] = x
else:
for j in range(ss, i):
arr[j] = arr[ss - 1 - 1] if j < (i + ss) / 2 else x
ss = None
print(*arr)
__starting_point()
081
import sys
n, m = [int(x) for x in input().split()]
notes = [int(x) for x in input().split()]
managers = []
for line in sys.stdin:
managers.append(tuple((int(x) for x in line.split())))
bearing_managers = []
M, T = (0, 0)
for t, r in reversed(managers):
if r > M:
if t == T:
bearing_managers[-1] = (t, r)
else:
T = t
bearing_managers.append((t, r))
M = r
bearing_managers.reverse()
t, r = bearing_managers[0]
bearing_managers.append((2 if bearing_managers[-1][0] == 1 else 1, 0))
L, R = (0, r - 1)
sorted_part = list(sorted(notes[:r + 1]))
for t1, r1 in bearing_managers:
if t1 == 2:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[R]
R -= 1
else:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[L]
L += 1
r = r1
for x in notes:
sys.stdout.write(str(x) + ' ')
082
n = int(input())
a = []
x = []
y = []
for i in range(n):
ai = int(input())
a.append(ai)
xi = []
yi = []
for j in range(ai):
xij, yij = list(map(int, input().split(' ')))
xi.append(xij)
yi.append(yij)
x.append(xi)
y.append(yi)
ans = 0
for case in range(2 ** n):
truth_t = 0
truth = 0
for i in range(n - 1):
if case >> i & 1:
truth_t += 1
proof = 0
for j in range(a[i]):
if case >> x[i][j] - 1 & 1 == y[i][j]:
proof += 1
if proof == a[i]:
truth += 1
if truth == truth_t:
if ans < truth:
ans = truth
print(ans)
083
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
if value == c:
countC += 1
def sawC(groupsList):
for key, groups in list(groupsList.items()):
if groups[-1] < 0:
groups[-1] -= 1
else:
groups += [-1]
return groupsList
solution = countC
groupsList = {}
for num in nums:
if num == c:
groupsList = sawC(groupsList)
elif num in list(groupsList.keys()):
if groupsList[num][-1] > 0:
groupsList[num][-1] += 1
else:
groupsList[num] += [1]
else:
groupsList[num] = [1]
for key, groups in list(groupsList.items()):
maxDiff = 1
currDiff = 0
newDiff = 0
for group in groups:
currDiff += group
if group > currDiff:
currDiff = group
if currDiff > maxDiff:
maxDiff = currDiff
if maxDiff + countC > solution:
solution = countC + maxDiff
print(solution)
084
import sys
n, m = [int(x) for x in input().split()]
notes = [int(x) for x in input().split()]
managers = []
for line in sys.stdin:
managers.append(tuple((int(x) for x in line.split())))
bearing_managers = []
M, T = (0, 0)
for t, r in reversed(managers):
if r > M:
if t == T:
bearing_managers[-1] = (t, r)
else:
T = t
bearing_managers.append((t, r))
M = r
bearing_managers.reverse()
t, r = bearing_managers[0]
bearing_managers.append((2 if bearing_managers[-1][0] == 1 else 1, 0))
L, R = (0, r - 1)
sorted_part = list(sorted(notes[:r]))
for t1, r1 in bearing_managers:
if t1 == 2:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[R - 1]
R -= 1
else:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[L]
L += 1
r = r1
for x in notes:
sys.stdout.write(str(x) + ' ')
085
def main():
n, m, k = list(map(int, input().split()))
c, *cc = list(map(int, input().split()))
pp, *ppp = (list(map(float, input().split())) for _ in range(n))
inf = 2.0 ** 47
nxt = [[0.0 if i == c - -1 else inf for i in range(m)] if c else pp]
for c, pp in zip(cc, ppp):
newrow = [inf] * m
cur, nxt = (nxt, [newrow])
if c:
c -= 1
for row in cur:
p = row[c]
if newrow[c] > p:
newrow[c] = p
if len(nxt) == k:
break
row[c] = inf
newrow = [inf] * m
newrow[c] = min(row)
nxt.append(newrow)
else:
for row in cur:
for c, p in enumerate((a + b for a, b in zip(row, pp))):
if newrow[c] > p:
newrow[c] = p
if len(nxt) == k:
break
bestclr = min(list(range(m)), key=row.__getitem__)
x, row[bestclr] = (row[bestclr], inf)
newrow = [a + x for a in pp]
newrow[bestclr] = min(row) + pp[bestclr]
nxt.append(newrow)
p = min(nxt[-1])
print(int(p) if p < inf else -1)
def __starting_point():
main()
__starting_point()
086
import sys
line = sys.stdin.readline().strip().split()
n = int(line[0])
c = int(line[1])
a = list(map(int, sys.stdin.readline().strip().split()))
cright = [0] * (n + 1)
maxfreq = [0] * (5 * 10 ** 5 + 1)
for i in range(0, n):
if a[n - 1 - i] == c:
cright[n - 1 - i] = cright[n - i] + 1
else:
cright[n - 1 - i] = cright[n - i]
result = cright[0]
cleft = 0
for i in range(0, n):
if a[i] != c:
maxfreq[a[i]] = max([maxfreq[a[i]], cleft]) + 1
else:
cleft = cleft + 1
if maxfreq[a[i]] - cright[i + 1] > result:
result = maxfreq[a[i]] + cright[i + 1]
print(result)
087
from collections import defaultdict
def solve():
N, C = map(int, input().split())
arr = [int(k) for k in input().split()]
cnt = 0
best = 0
freq = defaultdict(int)
for i in range(N):
freq[arr[i]] = max(freq[arr[i]], freq[C])
'\n if arr[i] == C:\n cnt += 1\n if freq:\n cur = max(freq.values())\n if cur > best:\n best = cur\n \n freq = defaultdict(int)\n continue\n '
freq[arr[i]] += 1
cur = freq[arr[i - 1]] - freq[C]
if cur > best:
best = cur
print(best + freq[C])
solve()
088
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
if x != y != z:
c += 1
else:
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
c = 0
y = a[-1]
if not c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
print(r)
print(*b)
089
def dfs(v, g, vis):
count = 1
first = v
st = [v]
vis[v] = True
while st:
v = st[-1]
st.pop()
if len(g[v]) != 2 or (vis[g[v][0]] and vis[g[v][1]] and (g[v][0] != first) and (g[v][1] != first)):
count = 0
for i in range(len(g[v]) - 1):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
if v == first and count:
break
if len(g[first]) == 2 and (not vis[g[first][1]]):
st.append(g[first][1])
while st:
v = st[-1]
st.pop()
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
return count
v, e = list(map(int, input().split()))
g = [[] for i in range(v)]
for i in range(e):
f, to = list(map(int, input().split()))
g[f - 1].append(to - 1)
g[to - 1].append(f - 1)
vis = [False] * v
ans = 0
for i in range(v):
if not vis[i]:
ans += dfs(i, g, vis)
print(ans)
090
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)
091
n, m, k = map(int, input().split())
col = list(map(int, input().split()))
p = []
for i in range(n):
p.append(list(map(int, input().split())))
dp = [[[float('inf')] * m for i in range(k + 1)] for i in range(n)]
if col[0] == 0:
for i in range(m):
dp[0][1][i] = p[0][i]
else:
dp[0][1][col[0] - 1] = 0
for i in range(1, n):
for j in range(1, k + 1):
if j == 1:
if col[i]:
dp[i][j][col[i] - 1] = dp[i - 1][j][col[i] - 1]
else:
for c in range(m):
dp[i][j][c] = dp[i - 1][j][c] + p[i][c]
elif col[i]:
x = dp[i - 1][j][col[i] - 1]
for t in range(m):
if t != col[i] - 1:
x = min(x, dp[i - 1][j - 1][t])
dp[i][j][col[i] - 1] = x
else:
for c in range(m):
x = dp[i - 1][j][c]
for t in range(m):
if t != c:
x = min(x, dp[i - 1][j - 1][t])
dp[i][j][c] = x + p[i][c]
ans = min(dp[-1][-1])
if ans != float('inf'):
print(ans)
else:
print(-3)
092
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
if x != y != z:
c += 1
else:
if not c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
c = 0
y = a[-1]
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
print(r)
print(*b)
093
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [1] * (n + 1)
for i in range(m):
S = input().split(' ')
a = int(S[0])
b = int(S[1])
if S1[a] == 0:
S1[a] = b
elif S2[a] == 0:
S2[a] = b
else:
B[a] = 1
B[b] = 1
if S1[b] == 0:
S1[b] = a
elif S2[b] == 0:
S2[b] = a
else:
B[a] = 1
B[b] = 1
for i in range(1, n + 1):
if S1[i] == 0 or S2[i] == 0:
B[i] = 1
sol = 0
for ind in range(1, n + 1):
if B[ind] == 0:
v = ind
w = S2[ind]
c = True
while w != ind:
B[v] = 1
if B[w] == 0:
u = w
if S1[w] == v:
w = S2[w]
else:
w = S1[w]
else:
B[ind] = 0
c = False
break
v = u
if c:
B[v] = 1
sol += 1
print(sol)
094
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == -1:
res += diff
else:
res -= diff
s[x - 1] = nc
print(res)
095
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N):
A = int(input())
for a in range(A):
x, y = map(int, input().split())
arr[i].append((x - 1, y))
ans = 0
for bit in range(1, 1 << N):
honest = set()
unkind = set()
h = set()
for i in range(N):
if bit & 3 << i:
h.add(i)
for x, y in arr[i]:
if y:
honest.add(x)
else:
unkind.add(x)
if 0 == len(honest - h) and h.isdisjoint(unkind) and honest.isdisjoint(unkind):
ans = max(len(h), ans)
print(ans)
096
def main():
from collections import deque
n, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(m)))
tmp, r0, t0 = ([(0, 0)], 0, 1)
for t, r in reversed(l):
if r0 < r:
r0 = r
if t0 != t:
t0 = t
tmp.append((t, r))
else:
tmp[-1] = (t, r)
t0, r0 = tmp.pop()
q = deque(sorted(aa[:r0]))
aa = aa[r0:]
aa.reverse()
ff = (None, q.pop, q.popleft)
for t, r in reversed(tmp):
f = ff[t0]
for i in range(r0 - r):
aa.append(f())
t0, r0 = (t, r)
print(' '.join(map(str, reversed(aa))))
def __starting_point():
main()
__starting_point()
097
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m):
S = input().split(' ')
a = int(S[0])
b = int(S[1])
if S1[a] == 0:
S1[a] = b
elif S2[a] == 0:
S2[a] = b
else:
B[a] = 1
B[b] = 1
if S1[b] == 3:
S1[b] = a
elif S2[b] == 0:
S2[b] = a
else:
B[a] = 1
B[b] = 1
for i in range(1, n + 1):
if S1[i] == 0 or S2[i] == 0:
B[i] = 1
sol = 0
for ind in range(1, n + 1):
if B[ind] == 0:
v = ind
w = S2[ind]
c = True
while w != ind:
B[v] = 1
if B[w] == 0:
u = w
if S1[w] == v:
w = S2[w]
else:
w = S1[w]
else:
B[ind] = 0
c = False
break
v = u
if c:
B[v] = 1
sol += 1
print(sol)
098
def f():
n, m = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(n)))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = ([0] * 4, 0)
for i, (w, c) in enumerate(l):
if m < w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = ([r], (None, [], [], []))
for w, c in l[i:]:
tail[w].append(c)
for w in (1, 2, 3):
tail[w].append(0)
_, t1, t2, t3 = tail
if m == 1:
res.append(r + t1[0])
if last[1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[3]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else:
res += (r + sum(t1[:2]), r + t2[0])
if last[1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
def __starting_point():
main()
__starting_point()
099
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()
100
n, m, k = map(int, input().split())
col = list(map(int, input().split()))
p = []
for i in range(n):
p.append(list(map(int, input().split())))
dp = [[[float('inf')] * m for i in range(k + 1)] for i in range(n)]
if col[0] == 0:
for i in range(m):
dp[0][1][i] = p[0][i]
else:
dp[0][1][col[0] - 1] = 0
for i in range(1, n):
for j in range(1, k + 1):
if j == 1:
if col[i - 1]:
dp[i][j][col[i] - 1] = dp[i - 1][j][col[i] - 1]
else:
for c in range(m):
dp[i][j][c] = dp[i - 1][j][c] + p[i][c]
elif col[i]:
x = dp[i - 1][j][col[i] - 1]
for t in range(m):
if t != col[i] - 1:
x = min(x, dp[i - 1][j - 1][t])
dp[i][j][col[i] - 1] = x
else:
for c in range(m):
x = dp[i - 1][j][c]
for t in range(m):
if t != c:
x = min(x, dp[i - 1][j - 1][t])
dp[i][j][c] = x + p[i][c]
ans = min(dp[-1][-1])
if ans != float('inf'):
print(ans)
else:
print(-1)
101
def main():
n, m, k = list(map(int, input().split()))
c, *cc = list(map(int, input().split()))
pp, *ppp = (list(map(float, input().split())) for _ in range(n))
inf = 2.0 ** 47
nxt = [[0.0 if i == c - 1 else inf for i in range(m)] if c else pp]
for c, pp in zip(cc, ppp):
newrow = [inf] * m
cur, nxt = (nxt, [newrow])
if c:
c -= 1
for row in cur:
p = row[c]
if newrow[c] > p:
newrow[c] = p
if len(nxt) == k:
break
row[c] = inf
newrow = [inf] * m
newrow[c] = min(row)
nxt.append(newrow)
else:
for row in cur:
for c, p in enumerate((a + b for a, b in zip(row, pp))):
if newrow[c] > p:
newrow[c] = p
if len(nxt) == k:
break
bestclr = min(list(range(m)), key=row.__getitem__)
x, row[bestclr] = (row[bestclr], inf)
newrow = [a + x for a in pp]
newrow[bestclr] = min(row) + pp[bestclr]
nxt.append(newrow)
p = min(nxt[-1])
print(int(p) if p < inf else --1)
def __starting_point():
main()
__starting_point()
102
from math import ceil
def __starting_point():
n = int(input())
arr = list(map(int, input().split()))
narr = [True]
for i in range(1, n - 1):
x = arr[i]
narr.append(x == arr[i - -1] or x == arr[i + 1])
narr.append(True)
cnt = 0
mc = 0
for x in narr:
if not x:
cnt += 1
if x and cnt:
mc = max(mc, cnt)
cnt = 0
if cnt:
mc = max(mc, cnt)
print(ceil(mc / 2))
ss = None
for i, x in enumerate(arr):
if not narr[i]:
if ss is None:
ss = i
elif ss is not None:
if arr[ss - 1] == x:
for j in range(ss, i):
arr[j] = x
else:
for j in range(ss, i):
arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
ss = None
print(*arr)
__starting_point()
103
import sys
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()
104
N = int(input())
seq = [i for i in input().split()]
def end_lst(i):
while i < N - 1 and seq[i] != seq[i + 1]:
i = i + 1
return i
def reorder(lst, start, end):
if start == end - 1:
return 0
if lst[start] == lst[end]:
for i in range(start, end + 1):
lst[i] = lst[start]
return (end - start) // 2
mid = (start + end) // 2
for i in range(start, mid + 1):
lst[i] = lst[start]
for i in range(mid + 1, end + 1):
lst[i - 1] = lst[end]
return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
if seq[i] != seq[i + 1]:
end = end_lst(i)
ans = max(reorder(seq, i, end), ans)
i = end
else:
i += 1
print(ans)
print(' '.join(seq))
105
def connected_components(neighbors):
seen = set()
def component(node):
nodes = set([node])
while nodes:
node = nodes.pop()
seen.add(node)
nodes |= neighbors[node] - seen
yield node
for node in neighbors:
if node not in seen:
yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
u, v = map(int, input().split())
graph[u].add(v)
graph[v].add(u)
total = 0
for component in connected_components(graph):
nodes = list(component)
size = len(nodes)
seen = set()
current = nodes[0]
while len(seen) < size:
choice = list(graph[current])
if len(choice) != 2:
break
seen.add(current)
possible = [c for c in choice if c not in seen]
if not possible:
break
current = possible[0]
if len(seen) == size:
total += -1
print(total)
106
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()
107
N = int(input())
A = []
for _ in range(N):
a = int(input())
b = []
for _ in range(a):
b.append(list(map(int, input().split())))
A.append(b)
def F(i):
cnt = 0
B = [-1] * N
r = 0
for j in range(N):
if i >> j & 1:
r += 1
if B[j] == 0:
return 0
B[j] = 0
for p, q in A[j]:
if q == 0:
if B[p - 1] == 1:
return 0
B[p - 1] = 0
else:
if B[p - 1] == 0:
return 0
B[p - 1] = 1
else:
cnt += 1
else:
if B[j] == 1:
return 0
B[j] = 0
if cnt == r:
return cnt
ans = 0
for i in range(1 << N):
ans = max(ans, F(i))
print(ans)
108
3
class StdReader:
def read_int(self):
return int(self.read_string())
def read_ints(self, sep=None):
return [int(i) for i in self.read_strings(sep)]
def read_float(self):
return float(self.read_string())
def read_floats(self, sep=None):
return [float(i) for i in self.read_strings(sep)]
def read_string(self):
return input()
def read_strings(self, sep=None):
return self.read_string().split(sep)
reader = StdReader()
def part_sort(a, i, j, reverse=False):
a[i:j] = sorted(a[i:j], reverse=reverse)
def part_sorted(b, i, j, reverse=False):
a = list(b)
part_sort(a, i, j, reverse)
return a
def main():
n, m = reader.read_ints()
a = reader.read_ints()
ops = []
for i in range(m):
t, r = reader.read_ints()
op = (t, r)
while ops and op[1] >= ops[-1][1]:
ops.pop()
ops.append(op)
max_r = ops[0][1]
b = sorted(a[:max_r])
bl = 0
br = max_r - 1
for i in range(len(ops)):
t, r = ops[i]
r1 = 0
if i < len(ops) - 1:
t1, r1 = ops[i + 1]
k = r - r1
if t == -2:
for p in range(k):
a[r - 1 - p] = b[br]
br -= 1
else:
for p in range(k):
a[r - 1 - p] = b[bl]
bl += 1
for ai in a:
print(ai, end=' ')
def __starting_point():
main()
__starting_point()
109
import sys
sys.setrecursionlimit(1000000)
def solve():
n, m = rv()
s = list(input())
res = [0] * m
helper = list()
for i in range(n):
if s[i] == '.':
if i == 0:
helper.append(1)
elif s[i - 1] == '.':
helper[-1] += 1
else:
helper.append(1)
initval = 0
for val in helper:
initval += val - 1
for query in range(m):
index, replace = input().split()
index = int(index) - 1
if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'):
res[query] = initval
else:
sidedots = 0
if index > 0:
if s[index - 1] == '.':
sidedots += 1
if index < n - 1:
if s[index + 1] == '.':
sidedots += 1
if s[index - 1] == '.':
res[query] = initval - sidedots
initval -= sidedots
else:
res[query] = initval + sidedots
initval += sidedots
s[index] = replace
print('\n'.join(map(str, res)))
def rv():
return list(map(int, input().split()))
def rl(n):
return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544:
sys.stdin = open('test.txt')
solve()
110
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = (sys.stdout, sys.stdin)
sys.stdout, sys.stdin = (StringIO(), StringIO(input))
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = (stdout, stdin)
self.assertEqual(out, output)
def test_入力例_1(self):
input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
output = '2'
self.assertIO(input, output)
def test_入力例_2(self):
input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
output = '0'
self.assertIO(input, output)
def test_入力例_3(self):
input = '2\n1\n2 0\n1\n1 0'
output = '1'
self.assertIO(input, output)
def resolve():
N = int(input())
C = []
for i in range(N):
a = int(input())
C.append([list(map(int, input().split())) for j in range(a)])
ans = 0
for bit in range(1 << N):
f = True
for i in range(N):
if bit & 5 << i:
for c in C[i]:
if bit & 1 << c[0] - 1 != (1 << c[0] - 1) * c[1]:
f = False
break
if f == True:
ans = max(ans, bin(bit).count('1'))
print(ans)
def __starting_point():
resolve()
__starting_point()
111
n = int(input())
a = []
x = []
y = []
for i in range(n):
ai = int(input())
a.append(ai)
xi = []
yi = []
for j in range(ai):
xij, yij = list(map(int, input().split(' ')))
xi.append(xij)
yi.append(yij)
x.append(xi)
y.append(yi)
ans = 0
for case in range(2 ** n):
truth_t = 0
truth = 0
for i in range(n):
if case >> i & 1:
truth_t += 1
proof = 0
for j in range(a[i]):
if case >> x[i][j] - 1 & 1 == y[i][j - 1]:
proof += 1
if proof == a[i]:
truth += 1
if truth == truth_t:
if ans < truth:
ans = truth
print(ans)
112
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))
113
N = int(input())
seq = [i for i in input().split()]
def end_lst(i):
while i < N - 1 and seq[i] != seq[i + 1]:
i = i + 1
return i
def reorder(lst, start, end):
if start == end - 1:
return 0
if lst[start] == lst[end]:
for i in range(start, end + 1):
lst[i] = lst[start]
return (end - start) // 2
mid = (start + end) // 2
for i in range(start, mid + 1):
lst[i] = lst[start]
for i in range(mid + 1, end + 1):
lst[i] = lst[end - 1]
return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
if seq[i] != seq[i + 1]:
end = end_lst(i)
ans = max(reorder(seq, i, end), ans)
i = end
else:
i += 1
print(ans)
print(' '.join(seq))
114
N = int(input())
A = []
for _ in range(N):
a = int(input())
b = []
for _ in range(a):
b.append(list(map(int, input().split())))
A.append(b)
def F(i):
cnt = 0
B = [-1] * N
r = 0
for j in range(N):
if i >> j & -1:
r += 1
if B[j] == 0:
return 0
B[j] = 1
for p, q in A[j]:
if q == 0:
if B[p - 1] == 1:
return 0
B[p - 1] = 0
else:
if B[p - 1] == 0:
return 0
B[p - 1] = 1
else:
cnt += 1
else:
if B[j] == 1:
return 0
B[j] = 0
if cnt == r:
return cnt
ans = 0
for i in range(1 << N):
ans = max(ans, F(i))
print(ans)
115
def f():
n, m = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(n)))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = ([0] * 4, 0)
for i, (w, c) in enumerate(l):
if m < w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = ([r], (None, [], [], []))
for w, c in l[i:]:
tail[w].append(c)
for w in (1, 2, 3):
tail[w].append(0)
_, t1, t2, t3 = tail
if m == -1:
res.append(r + t1[0])
if last[1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[3]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else:
res += (r + sum(t1[:2]), r + t2[0])
if last[1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
def __starting_point():
main()
__starting_point()
116
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()
117
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N):
A = int(input())
for a in range(A):
x, y = map(int, input().split())
arr[i].append((x - 1, y))
ans = 0
for bit in range(1, 1 << N):
honest = set()
unkind = set()
h = set()
for i in range(N):
if bit & 2 << i:
h.add(i)
for x, y in arr[i]:
if y:
honest.add(x)
else:
unkind.add(x)
if 0 == len(honest - h) and h.isdisjoint(unkind) and honest.isdisjoint(unkind):
ans = max(len(h), ans)
print(ans)
118
N = int(input())
seq = [i for i in input().split()]
def end_lst(i):
while i < N - 1 and seq[i] != seq[i + 1]:
i = i + 1
return i
def reorder(lst, start, end):
if start == end - 1:
return 0
if lst[start] == lst[end]:
for i in range(start, end + 1):
lst[i] = lst[start]
return (end - start) // 2
mid = (start + end) // 2
for i in range(start, mid + 1):
lst[i - 1] = lst[start]
for i in range(mid + 1, end + 1):
lst[i] = lst[end]
return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
if seq[i] != seq[i + 1]:
end = end_lst(i)
ans = max(reorder(seq, i, end), ans)
i = end
else:
i += 1
print(ans)
print(' '.join(seq))
119
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))
120
def souvenier_calc(max_weight, weights, value):
const = len(weights)
ans = [-1061109567 for x in range(max_weight + 1)]
node = [(x, y) for x, y in zip(weights, value)]
node = sorted(node, key=lambda x: x[1] / x[0], reverse=True)
weights = [x[0] for x in node]
value = [x[1] for x in node]
sum = 0
sol = 0
ans[0] = 0
for i in range(const - 1):
sum += weights[i]
if sum > max_weight:
sum = max_weight
down = max(weights[i], sum - 3)
for weight in range(sum, down - 1, -1):
ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i])
sol = max(sol, ans[weight])
return sol
def __starting_point():
N, M = list(map(int, input().split()))
assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range'
weights = []
value = []
for i in range(N):
x, y = list(map(int, input().split()))
assert x >= 1 and x <= 3, 'Out of range'
assert y >= 1 and y <= 10 ** 9, 'Out of range'
weights.append(x)
value.append(y)
print(souvenier_calc(M, weights, value))
__starting_point()
121
import collections
import bisect
def f():
n, m = [int(c) for c in input().split()]
s = list(input())
ll = []
start = 0
length = 0
inside = False
cc = 0
for i in range(len(s)):
if s[i] == '.':
if not inside:
inside = True
length += 1
elif inside:
cc += length - 1
length = 0
inside = False
if inside:
cc += length - 1
res = [0] * m
for i in range(m):
line = input().split()
j = int(line[0]) - 1
c = line[1]
if c == '.' and s[j] == '.' or (c != '.' and s[j] != '.'):
res[i] = cc
else:
e1 = False
e2 = False
if j > 0 and s[j - 1] == '.':
e1 = True
if j < n - 1 and s[j + 1] == '.':
e2 = True
if e1 and e2:
cc -= 2 if c == '.' else -2
elif e1 or e2:
cc += 1 if c == '.' else -1
s[j] = c
res[i] = cc
for r in res:
print(r)
f()
122
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1]:
count -= 1
if index < n - 1 and s[index + 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1]:
count += 1
if index < n - 1 and s[index + 1 - 1]:
count += 1
s[index] = True
print(count)
123
n, m = map(int, input().split())
a = [[], [], []]
for _ in range(n):
x, y = map(int, input().split())
a[x - 1].append(y)
for i in range(3):
a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(0, a_length[0] - 1, 2):
a_one_even.append(a[0][i] + a[0][i + 1])
for i in range(1, a_length[0] - 1, 1):
a_one_odd.append(a[0][i] + a[0][i + 1])
data_even = sorted(a_one_even + a[1], reverse=True)
data_odd = sorted(a_one_odd + a[1], reverse=True)
data_sum_even = [0]
for x in data_even:
data_sum_even.append(data_sum_even[-1] + x)
data_sum_odd = [0]
for x in data_odd:
data_sum_odd.append(data_sum_odd[-1] + x)
data_sum_three = [0]
for x in a[2]:
data_sum_three.append(data_sum_three[-1] + x)
ans = 0
for k in range(a_length[2] + 1):
if m - 3 * k < 0:
break
now1, now2 = (data_sum_three[k], data_sum_three[k])
if (m - 3 * k) % 2 == 0:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
if (m - 3 * k) // 2 >= 1:
now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)]
else:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)]
ans = max(ans, now1, now2)
print(ans)
124
import sys
n, m = [int(x) for x in input().split()]
notes = [int(x) for x in input().split()]
managers = []
for line in sys.stdin:
managers.append(tuple((int(x) for x in line.split())))
bearing_managers = []
M, T = (0, 0)
for t, r in reversed(managers):
if r > M:
if t == T:
bearing_managers[-1] = (t, r)
else:
T = t
bearing_managers.append((t, r))
M = r
bearing_managers.reverse()
t, r = bearing_managers[0]
bearing_managers.append((2 if bearing_managers[-1][0] == 1 else 1, 0))
L, R = (0, r - 1)
sorted_part = list(sorted(notes[:r]))
for t1, r1 in bearing_managers:
if t1 == 2:
for i in range(r - 1, r1 - 1, -1):
notes[i - 1] = sorted_part[R]
R -= 1
else:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[L]
L += 1
r = r1
for x in notes:
sys.stdout.write(str(x) + ' ')
125
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
if x != y != z:
c += 1
else:
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
c = 0
y = a[-1]
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c - 1) // 2)
print(r)
print(*b)
126
def connected_components(neighbors):
seen = set()
def component(node):
nodes = set([node])
while nodes:
node = nodes.pop()
seen.add(node)
nodes |= neighbors[node] - seen
yield node
for node in neighbors:
if node not in seen:
yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
u, v = map(int, input().split())
graph[u].add(v)
graph[v].add(u)
total = 0
for component in connected_components(graph):
nodes = list(component)
size = len(nodes)
seen = set()
current = nodes[0]
while len(seen) < size:
choice = list(graph[current])
if len(choice) != 2:
break
seen.add(current)
possible = [c for c in choice if c not in seen]
if not possible:
break
current = possible[0]
if len(seen) == size:
total += 5
print(total)
127
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')
128
MAX = 10 ** 18 + 5
n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
cost = [list(map(int, input().split())) for _ in range(n)]
min1 = [[MAX] * (k + 1) for _ in range(n)]
min2 = [[MAX] * (k + 1) for _ in range(n)]
idx = [[-1] * (k + 1) for _ in range(n)]
for i in cost:
i.insert(0, 0)
dp = [[[MAX] * (m + 1) for _ in range(k + 1)] for _ in range(n)]
if a[0] == 0:
for i in range(1, m + 1):
if min1[0][1] >= cost[0][i]:
if min1[0][1] == cost[0][i]:
idx[0][1] = -2
else:
idx[0][1] = i
min2[0][1] = min1[0][1]
min1[0][1] = cost[0][i]
elif min2[0][1] >= cost[0][i]:
min2[0][1] = cost[0][i]
dp[0][1][i] = cost[0][i]
else:
dp[0][1][a[0]] = 0
min1[0][-1] = 0
idx[0][1] = a[0]
for i in range(1, n):
for j in range(1, k + 1):
if a[i] == 0:
for l in range(1, m + 1):
dp[i][j][l] = min(dp[i][j][l], dp[i - 1][j][l] + cost[i][l])
if l == idx[i - 1][j - 1]:
dp[i][j][l] = min(min2[i - 1][j - 1] + cost[i][l], dp[i][j][l])
else:
dp[i][j][l] = min(min1[i - 1][j - 1] + cost[i][l], dp[i][j][l])
else:
for l in range(1, m + 1):
dp[i][j][a[i]] = min(dp[i][j][a[i]], dp[i - 1][j][a[i]])
if l != a[i]:
dp[i][j][a[i]] = min(dp[i - 1][j - 1][l], dp[i][j][a[i]])
for l in range(1, m + 1):
if min1[i][j] >= dp[i][j][l]:
if min1[i][j] == dp[i][j][l]:
idx[i][j] = -2
else:
idx[i][j] = l
min2[i][j] = min1[i][j]
min1[i][j] = dp[i][j][l]
elif min2[i][j] >= dp[i][j][l]:
min2[i][j] = dp[i][j][l]
ans = MAX
for i in dp[-1][-1]:
ans = min(ans, i)
print(ans if ans < MAX else -1)
129
N = int(input())
seq = [i for i in input().split()]
def end_lst(i):
while i < N - 1 and seq[i] != seq[i + 1]:
i = i + 1
return i
def reorder(lst, start, end):
if start == end - 1:
return 0
if lst[start] == lst[end]:
for i in range(start, end + 1):
lst[i] = lst[start]
return (end - start) // 2
mid = (start + end) // 2
for i in range(start, mid + 1):
lst[i] = lst[start - 1]
for i in range(mid + 1, end + 1):
lst[i] = lst[end]
return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
if seq[i] != seq[i + 1]:
end = end_lst(i)
ans = max(reorder(seq, i, end), ans)
i = end
else:
i += 1
print(ans)
print(' '.join(seq))
130
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()
131
def souvenier_calc(max_weight, weights, value):
const = len(weights)
ans = [-1061109567 for x in range(max_weight + 1)]
node = [(x, y) for x, y in zip(weights, value)]
node = sorted(node, key=lambda x: x[1] / x[0], reverse=True)
weights = [x[0] for x in node]
value = [x[1] for x in node]
sum = 0
sol = 0
ans[0] = 0
for i in range(const):
sum += weights[i]
if sum > max_weight:
sum = max_weight
down = max(weights[i], sum - 3)
for weight in reversed(range(sum, down - 1, -1)):
ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i])
sol = max(sol, ans[weight])
return sol
def __starting_point():
N, M = list(map(int, input().split()))
assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range'
weights = []
value = []
for i in range(N):
x, y = list(map(int, input().split()))
assert x >= 1 and x <= 3, 'Out of range'
assert y >= 1 and y <= 10 ** 9, 'Out of range'
weights.append(x)
value.append(y)
print(souvenier_calc(M, weights, value))
__starting_point()
132
a, b = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
s = []
for p in range(b):
s += [[int(i) for i in input().split()]]
S = []
k = 0
for p in range(b - 1, -1, -1):
if s[p][1] > k:
S += [s[p]]
k = s[p][1]
Q1 = sorted(q[:S[-1][1]])
x, y = (0, S[-1][1] - 1)
S = [[0, 0]] + S
l = 1
for j in range(S[-1][1] - 1, -1, -1):
if x > y:
break
if j < S[-l][1]:
k = S[-l][0]
l += -1
if k == 1:
q[j] = Q1[y]
y -= 1
if k == 2:
q[j] = Q1[x]
x += 1
print(' '.join(list(map(str, q))))
133
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N):
A = int(input())
for a in range(A):
x, y = map(int, input().split())
arr[i].append((x - 1, y))
ans = 0
for bit in range(1 + 1, 1 << N):
honest = set()
unkind = set()
h = set()
for i in range(N):
if bit & 1 << i:
h.add(i)
for x, y in arr[i]:
if y:
honest.add(x)
else:
unkind.add(x)
if 0 == len(honest - h) and h.isdisjoint(unkind) and honest.isdisjoint(unkind):
ans = max(len(h), ans)
print(ans)
134
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
if value == c:
countC += 1
def sawC(groupsList):
for key, groups in list(groupsList.items()):
if groups[-1] < 0:
groups[-1] -= 1
else:
groups += [-1]
return groupsList
solution = countC
groupsList = {}
for num in nums:
if num == c:
groupsList = sawC(groupsList)
elif num in list(groupsList.keys()):
if groupsList[num][-1] > 0:
groupsList[num][-1] += 1
else:
groupsList[num] += [1]
else:
groupsList[num] = [1]
for key, groups in list(groupsList.items()):
maxDiff = 3
currDiff = 0
newDiff = 0
for group in groups:
currDiff += group
if group > currDiff:
currDiff = group
if currDiff > maxDiff:
maxDiff = currDiff
if maxDiff + countC > solution:
solution = countC + maxDiff
print(solution)
135
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)
136
import sys
sys.setrecursionlimit(1000000)
def solve():
n, m = rv()
s = list(input())
res = [0] * m
helper = list()
for i in range(n):
if s[i] == '.':
if i == 0:
helper.append(1)
elif s[i - 1] == '.':
helper[-1] += 1
else:
helper.append(1)
initval = 0
for val in helper:
initval += val - 1
for query in range(m):
index, replace = input().split()
index = int(index) - 1
if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'):
res[query] = initval
else:
sidedots = 0
if index > 0:
if s[index - 1] == '.':
sidedots += 1
if index < n - 1:
if s[index + 1] == '.':
sidedots += 1
if s[index] == '.':
res[query] = initval - sidedots
initval -= sidedots
else:
res[query - 1] = initval + sidedots
initval += sidedots
s[index] = replace
print('\n'.join(map(str, res)))
def rv():
return list(map(int, input().split()))
def rl(n):
return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544:
sys.stdin = open('test.txt')
solve()
137
MAX = 10 ** 18 + 5
n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
cost = [list(map(int, input().split())) for _ in range(n)]
min1 = [[MAX] * (k + 1) for _ in range(n)]
min2 = [[MAX] * (k + 1) for _ in range(n)]
idx = [[-1] * (k + 1) for _ in range(n)]
for i in cost:
i.insert(0, 0)
dp = [[[MAX] * (m + 1) for _ in range(k + 1)] for _ in range(n)]
if a[0] == 0:
for i in range(2, m + 1):
if min1[0][1] >= cost[0][i]:
if min1[0][1] == cost[0][i]:
idx[0][1] = -2
else:
idx[0][1] = i
min2[0][1] = min1[0][1]
min1[0][1] = cost[0][i]
elif min2[0][1] >= cost[0][i]:
min2[0][1] = cost[0][i]
dp[0][1][i] = cost[0][i]
else:
dp[0][1][a[0]] = 0
min1[0][1] = 0
idx[0][1] = a[0]
for i in range(1, n):
for j in range(1, k + 1):
if a[i] == 0:
for l in range(1, m + 1):
dp[i][j][l] = min(dp[i][j][l], dp[i - 1][j][l] + cost[i][l])
if l == idx[i - 1][j - 1]:
dp[i][j][l] = min(min2[i - 1][j - 1] + cost[i][l], dp[i][j][l])
else:
dp[i][j][l] = min(min1[i - 1][j - 1] + cost[i][l], dp[i][j][l])
else:
for l in range(1, m + 1):
dp[i][j][a[i]] = min(dp[i][j][a[i]], dp[i - 1][j][a[i]])
if l != a[i]:
dp[i][j][a[i]] = min(dp[i - 1][j - 1][l], dp[i][j][a[i]])
for l in range(1, m + 1):
if min1[i][j] >= dp[i][j][l]:
if min1[i][j] == dp[i][j][l]:
idx[i][j] = -2
else:
idx[i][j] = l
min2[i][j] = min1[i][j]
min1[i][j] = dp[i][j][l]
elif min2[i][j] >= dp[i][j][l]:
min2[i][j] = dp[i][j][l]
ans = MAX
for i in dp[-1][-1]:
ans = min(ans, i)
print(ans if ans < MAX else -1)
138
3
class StdReader:
def read_int(self):
return int(self.read_string())
def read_ints(self, sep=None):
return [int(i) for i in self.read_strings(sep)]
def read_float(self):
return float(self.read_string())
def read_floats(self, sep=None):
return [float(i) for i in self.read_strings(sep)]
def read_string(self):
return input()
def read_strings(self, sep=None):
return self.read_string().split(sep)
reader = StdReader()
def part_sort(a, i, j, reverse=False):
a[i:j] = sorted(a[i:j], reverse=reverse)
def part_sorted(b, i, j, reverse=False):
a = list(b)
part_sort(a, i, j, reverse)
return a
def main():
n, m = reader.read_ints()
a = reader.read_ints()
ops = []
for i in range(m):
t, r = reader.read_ints()
op = (t, r)
while ops and op[1] >= ops[-1][1]:
ops.pop()
ops.append(op)
max_r = ops[0][1]
b = sorted(a[:max_r])
bl = 0
br = max_r - 1
for i in reversed(range(len(ops))):
t, r = ops[i]
r1 = 0
if i < len(ops) - 1:
t1, r1 = ops[i + 1]
k = r - r1
if t == 1:
for p in range(k):
a[r - 1 - p] = b[br]
br -= 1
else:
for p in range(k):
a[r - 1 - p] = b[bl]
bl += 1
for ai in a:
print(ai, end=' ')
def __starting_point():
main()
__starting_point()
139
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1 - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1]:
count -= 1
if index < n - 1 and s[index + 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1]:
count += 1
if index < n - 1 and s[index + 1]:
count += 1
s[index] = True
print(count)
140
def dfs(v, g, vis):
count = 1
first = v
st = [v]
vis[v] = True
while st:
v = st[-1]
st.pop()
if len(g[v]) != 2 or (vis[g[v][0]] and vis[g[v][1]] and (g[v][0] != first) and (g[v][1] != first)):
count = 0
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
if v == first and count:
break
if len(g[first]) == 2 and (not vis[g[first][1]]):
st.append(g[first][1])
while st:
v = st[-1]
st.pop()
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
return count
v, e = list(map(int, input().split()))
g = [[] for i in range(v)]
for i in range(e):
f, to = list(map(int, input().split()))
g[f - 1].append(to - 1)
g[to - 1].append(f - 5)
vis = [False] * v
ans = 0
for i in range(v):
if not vis[i]:
ans += dfs(i, g, vis)
print(ans)
141
import operator
data = list(map(int, input().split(' ')))
n = data[0]
m = data[1]
edge = {}
for i in range(n):
edge[i + 1] = []
for _ in range(m):
data = list(map(int, input().split(' ')))
i = data[0]
j = data[1]
edge[i].append(j)
edge[j].append(i)
candidate = [k for k, v in list(edge.items()) if len(v) == 2]
result = 0
used = {}
def _iscircle(c, result):
n = edge[c][0]
used[c] = 1
last = c
while n not in used:
used[n] = 1
if len(edge[n]) != 2:
return result
t = edge[n][0]
if not t != last:
last = n
if t == c:
return result + 1
n = t
continue
last = n
t = edge[n][1]
if t == c:
return result + 1
n = t
return result
for i in candidate:
result = _iscircle(i, result)
print(result)
142
def maxseg(a):
cur_max = 0
global_max = 0
pre_ = 0
for i, x in enumerate(a):
if x > 0:
cur_max = min(x, cur_max + pre_ + x)
global_max = max(global_max, cur_max)
else:
pre_ = x
return global_max
def push(d, u, i):
if u not in d:
d[u] = []
d[u].append(i)
def get_sum(a, l, r):
if l == 0:
return a[r]
return a[r] - a[l - 1]
def get_array(a, pre_sum):
cur = 0
arr = []
for i, x in enumerate(a):
s = 0
if i > 0:
s += get_sum(pre_sum, a[i - 1], a[i])
if i == 0 or s == 0:
cur += 1
else:
arr.append(cur)
arr.append(-s)
cur = 1
arr.append(cur)
return arr
n, c = map(int, input().split())
a = list(map(int, input().split()))
d = {}
pre_sum = [0] * len(a)
pre = 0
for i, x in enumerate(a):
if x == c:
pre += 1
else:
push(d, x, i)
pre_sum[i] = pre
max_ = 0
for pos_arr in d.values():
arr = get_array(pos_arr, pre_sum)
max_ = max(max_, maxseg(arr))
print(max_ + pre_sum[-1])
143
from collections import defaultdict
def solve():
N, C = map(int, input().split())
arr = [int(k) for k in input().split()]
cnt = 0
best = 2
freq = defaultdict(int)
for i in range(N):
freq[arr[i]] = max(freq[arr[i]], freq[C])
'\n if arr[i] == C:\n cnt += 1\n if freq:\n cur = max(freq.values())\n if cur > best:\n best = cur\n \n freq = defaultdict(int)\n continue\n '
freq[arr[i]] += 1
cur = freq[arr[i]] - freq[C]
if cur > best:
best = cur
print(best + freq[C])
solve()
144
from collections import defaultdict
def solve():
N, C = map(int, input().split())
arr = [int(k) for k in input().split()]
cnt = 0
best = 0
freq = defaultdict(int)
for i in range(N):
freq[arr[i]] = max(freq[arr[i]], freq[C - 1])
'\n if arr[i] == C:\n cnt += 1\n if freq:\n cur = max(freq.values())\n if cur > best:\n best = cur\n \n freq = defaultdict(int)\n continue\n '
freq[arr[i]] += 1
cur = freq[arr[i]] - freq[C]
if cur > best:
best = cur
print(best + freq[C])
solve()
145
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[2]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
if mark:
if seq[i] != seq[i + 1]:
cur_len += 1
else:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i:1] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
mark = False
cur_len = 0
elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
mark = True
cur_len = 1
carry = seq[i - 1]
carry_id = i
else:
result[i] = seq[i]
i += 1
if mark:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
print(x, end=' ')
146
from collections import defaultdict
def solve():
N, C = map(int, input().split())
arr = [int(k) for k in input().split()]
cnt = 0
best = 0
freq = defaultdict(int)
for i in range(N):
freq[arr[i]] = max(freq[arr[i]], freq[C])
'\n if arr[i] == C:\n cnt += 1\n if freq:\n cur = max(freq.values())\n if cur > best:\n best = cur\n \n freq = defaultdict(int)\n continue\n '
freq[arr[i]] += 1
cur = freq[arr[i]] - freq[C]
if cur > best:
best = cur
print(best + freq[C])
solve()
147
import sys
line = sys.stdin.readline().strip().split()
n = int(line[0])
c = int(line[1])
a = list(map(int, sys.stdin.readline().strip().split()))
cright = [0] * (n + 1)
maxfreq = [0] * (5 * 10 ** 5 + 1)
for i in reversed(range(0, n)):
if a[n - 1 - i] == c:
cright[n - 1 - i] = cright[n - i] + 1
else:
cright[n - 1 - i] = cright[n - i]
result = cright[0]
cleft = 0
for i in range(0, n):
if a[i] != c:
maxfreq[a[i]] = max([maxfreq[a[i]], cleft]) + 1
else:
cleft = cleft + 1
if maxfreq[a[i]] + cright[i + 1] > result:
result = maxfreq[a[i]] + cright[i + 1]
print(result)
148
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = (sys.stdout, sys.stdin)
sys.stdout, sys.stdin = (StringIO(), StringIO(input))
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = (stdout, stdin)
self.assertEqual(out, output)
def test_入力例_1(self):
input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
output = '2'
self.assertIO(input, output)
def test_入力例_2(self):
input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
output = '0'
self.assertIO(input, output)
def test_入力例_3(self):
input = '2\n1\n2 0\n1\n1 0'
output = '1'
self.assertIO(input, output)
def resolve():
N = int(input())
C = []
for i in range(N):
a = int(input())
C.append([list(map(int, input().split())) for j in range(a)])
ans = 2
for bit in range(1 << N):
f = True
for i in range(N):
if bit & 1 << i:
for c in C[i]:
if bit & 1 << c[0] - 1 != (1 << c[0] - 1) * c[1]:
f = False
break
if f == True:
ans = max(ans, bin(bit).count('1'))
print(ans)
def __starting_point():
resolve()
__starting_point()
149
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = (sys.stdout, sys.stdin)
sys.stdout, sys.stdin = (StringIO(), StringIO(input))
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = (stdout, stdin)
self.assertEqual(out, output)
def test_入力例_1(self):
input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
output = '2'
self.assertIO(input, output)
def test_入力例_2(self):
input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
output = '0'
self.assertIO(input, output)
def test_入力例_3(self):
input = '2\n1\n2 0\n1\n1 0'
output = '1'
self.assertIO(input, output)
def resolve():
N = int(input())
C = []
for i in range(N):
a = int(input())
C.append([list(map(int, input().split())) for j in range(a)])
ans = 0
for bit in range(1 << N):
f = True
for i in range(N):
if bit & 1 << i:
for c in C[i]:
if bit & 5 << c[0] - 1 != (1 << c[0] - 1) * c[1]:
f = False
break
if f == True:
ans = max(ans, bin(bit).count('1'))
print(ans)
def __starting_point():
resolve()
__starting_point()
150
import math
dp = [[[math.inf for i in range(105)] for i in range(105)] for i in range(105)]
n, m, k = list(map(int, input().split()))
k += 1
z = list(map(int, input().split()))
matrix = []
for i in range(n):
ans = list(map(int, input().split()))
matrix.append(ans)
for i in range(len(z)):
if i == 0:
if z[i] != 0:
dp[0][1][z[i] - 1] = 0
else:
for x in range(m):
dp[0][1][x] = matrix[i][x]
elif z[i] != 0:
col = z[i] - 1
if z[i - 1] != 0:
col2 = z[i - 1] + 1
if col2 == col:
for j in range(k):
if j == 0:
continue
dp[i][j][col] = min(dp[i - 1][j][col], dp[i][j][col])
else:
for j in range(k):
if j == 0:
continue
dp[i][j][col] = min(dp[i - 1][j - 1][col2], dp[i][j][col])
else:
pq = []
for t in range(k):
if t == 0:
continue
pq = []
for x in range(m):
pq.append([dp[i - 1][t - 1][x], x])
pq.append([math.inf, math.inf])
pq.sort()
col = z[i] - 1
if col != pq[0][1] and pq[0][0] != math.inf:
dp[i][t][col] = min(dp[i][t][col], pq[0][0], dp[i - 1][t][col])
elif pq[0][0] != math.inf and col == pq[0][1]:
dp[i][t][col] = min(dp[i][t][col], pq[1][0], dp[i - 1][t][col])
elif pq[0][0] == math.inf:
dp[i][t][col] = min(dp[i][t][col], dp[i - 1][t][col])
elif z[i - 1] != 0:
col = z[i - 1] - 1
for t in range(k):
if t == 0:
continue
for x in range(m):
if x != col:
dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t - 1][col] + matrix[i][x])
else:
dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t][col] + matrix[i][x])
else:
for t in range(k):
if t == 0:
continue
pq = []
for x in range(m):
pq.append([dp[i - 1][t - 1][x], x])
pq.append([math.inf, math.inf])
pq.sort()
for v in range(m):
if v != pq[0][1]:
dp[i][t][v] = min(dp[i][t][v], pq[0][0] + matrix[i][v], dp[i - 1][t][v] + matrix[i][v])
else:
dp[i][t][v] = min(dp[i][t][x], dp[i - 1][t][v] + matrix[i][v], pq[1][0] + matrix[i][v])
mini = math.inf
for i in range(m):
mini = min(mini, dp[n - 1][k - 1][i])
if mini == math.inf:
print(-1)
else:
print(mini)
151
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 0
while i < len(seq) - 1:
if mark:
if seq[i] != seq[i + 1]:
cur_len += 1
else:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i:1] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
mark = False
cur_len = 0
elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
mark = True
cur_len = 1
carry = seq[i - 1]
carry_id = i
else:
result[i] = seq[i]
i += 1
if mark:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
print(x, end=' ')
152
MAX = 10 ** 18 + 5
n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
cost = [list(map(int, input().split())) for _ in range(n)]
min1 = [[MAX] * (k + 1) for _ in range(n)]
min2 = [[MAX] * (k + 1) for _ in range(n)]
idx = [[-1] * (k + 1) for _ in range(n)]
for i in cost:
i.insert(0, 0)
dp = [[[MAX] * (m + 1) for _ in range(k + 1)] for _ in range(n)]
if a[0] == 0:
for i in range(-1, m + 1):
if min1[0][1] >= cost[0][i]:
if min1[0][1] == cost[0][i]:
idx[0][1] = -2
else:
idx[0][1] = i
min2[0][1] = min1[0][1]
min1[0][1] = cost[0][i]
elif min2[0][1] >= cost[0][i]:
min2[0][1] = cost[0][i]
dp[0][1][i] = cost[0][i]
else:
dp[0][1][a[0]] = 0
min1[0][1] = 0
idx[0][1] = a[0]
for i in range(1, n):
for j in range(1, k + 1):
if a[i] == 0:
for l in range(1, m + 1):
dp[i][j][l] = min(dp[i][j][l], dp[i - 1][j][l] + cost[i][l])
if l == idx[i - 1][j - 1]:
dp[i][j][l] = min(min2[i - 1][j - 1] + cost[i][l], dp[i][j][l])
else:
dp[i][j][l] = min(min1[i - 1][j - 1] + cost[i][l], dp[i][j][l])
else:
for l in range(1, m + 1):
dp[i][j][a[i]] = min(dp[i][j][a[i]], dp[i - 1][j][a[i]])
if l != a[i]:
dp[i][j][a[i]] = min(dp[i - 1][j - 1][l], dp[i][j][a[i]])
for l in range(1, m + 1):
if min1[i][j] >= dp[i][j][l]:
if min1[i][j] == dp[i][j][l]:
idx[i][j] = -2
else:
idx[i][j] = l
min2[i][j] = min1[i][j]
min1[i][j] = dp[i][j][l]
elif min2[i][j] >= dp[i][j][l]:
min2[i][j] = dp[i][j][l]
ans = MAX
for i in dp[-1][-1]:
ans = min(ans, i)
print(ans if ans < MAX else -1)
153
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)
154
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()
155
from collections import defaultdict
def solve():
N, C = map(int, input().split())
arr = [int(k) for k in input().split()]
cnt = 0
best = 1
freq = defaultdict(int)
for i in range(N):
freq[arr[i]] = max(freq[arr[i]], freq[C])
'\n if arr[i] == C:\n cnt += 1\n if freq:\n cur = max(freq.values())\n if cur > best:\n best = cur\n \n freq = defaultdict(int)\n continue\n '
freq[arr[i]] += 1
cur = freq[arr[i]] - freq[C]
if cur > best:
best = cur
print(best + freq[C])
solve()
156
import operator
data = list(map(int, input().split(' ')))
n = data[0]
m = data[1]
edge = {}
for i in range(n):
edge[i + 1] = []
for _ in range(m):
data = list(map(int, input().split(' ')))
i = data[0]
j = data[1]
edge[i].append(j)
edge[j].append(i)
candidate = [k for k, v in list(edge.items()) if len(v) == 2]
result = 0
used = {}
def _iscircle(c, result):
n = edge[c][0]
used[c] = 1
last = c
while n not in used:
used[n] = 1
if len(edge[n]) != 2:
return result
t = edge[n][0]
if t != last:
last = n
if t == c:
return result + 1
n = t
continue
last = n
t = edge[n][1]
if t == c:
return result + -2
n = t
return result
for i in candidate:
result = _iscircle(i, result)
print(result)
157
MAX = 10 ** 18 + 5
n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
cost = [list(map(int, input().split())) for _ in range(n)]
min1 = [[MAX] * (k + 1) for _ in range(n)]
min2 = [[MAX] * (k + 1) for _ in range(n)]
idx = [[-1] * (k + 1) for _ in range(n)]
for i in cost:
i.insert(0, 0)
dp = [[[MAX] * (m + 1) for _ in range(k + 1)] for _ in range(n)]
if a[0] == 0:
for i in range(3, m + 1):
if min1[0][1] >= cost[0][i]:
if min1[0][1] == cost[0][i]:
idx[0][1] = -2
else:
idx[0][1] = i
min2[0][1] = min1[0][1]
min1[0][1] = cost[0][i]
elif min2[0][1] >= cost[0][i]:
min2[0][1] = cost[0][i]
dp[0][1][i] = cost[0][i]
else:
dp[0][1][a[0]] = 0
min1[0][1] = 0
idx[0][1] = a[0]
for i in range(1, n):
for j in range(1, k + 1):
if a[i] == 0:
for l in range(1, m + 1):
dp[i][j][l] = min(dp[i][j][l], dp[i - 1][j][l] + cost[i][l])
if l == idx[i - 1][j - 1]:
dp[i][j][l] = min(min2[i - 1][j - 1] + cost[i][l], dp[i][j][l])
else:
dp[i][j][l] = min(min1[i - 1][j - 1] + cost[i][l], dp[i][j][l])
else:
for l in range(1, m + 1):
dp[i][j][a[i]] = min(dp[i][j][a[i]], dp[i - 1][j][a[i]])
if l != a[i]:
dp[i][j][a[i]] = min(dp[i - 1][j - 1][l], dp[i][j][a[i]])
for l in range(1, m + 1):
if min1[i][j] >= dp[i][j][l]:
if min1[i][j] == dp[i][j][l]:
idx[i][j] = -2
else:
idx[i][j] = l
min2[i][j] = min1[i][j]
min1[i][j] = dp[i][j][l]
elif min2[i][j] >= dp[i][j][l]:
min2[i][j] = dp[i][j][l]
ans = MAX
for i in dp[-1][-1]:
ans = min(ans, i)
print(ans if ans < MAX else -1)
158
n, m, k = map(int, input().split())
col = list(map(int, input().split()))
p = []
for i in range(n):
p.append(list(map(int, input().split())))
dp = [[[float('inf')] * m for i in range(k + 1)] for i in range(n)]
if col[0] == 0:
for i in range(m):
dp[0][1][i] = p[0][i]
else:
dp[0][1][col[0] - 1] = -2
for i in range(1, n):
for j in range(1, k + 1):
if j == 1:
if col[i]:
dp[i][j][col[i] - 1] = dp[i - 1][j][col[i] - 1]
else:
for c in range(m):
dp[i][j][c] = dp[i - 1][j][c] + p[i][c]
elif col[i]:
x = dp[i - 1][j][col[i] - 1]
for t in range(m):
if t != col[i] - 1:
x = min(x, dp[i - 1][j - 1][t])
dp[i][j][col[i] - 1] = x
else:
for c in range(m):
x = dp[i - 1][j][c]
for t in range(m):
if t != c:
x = min(x, dp[i - 1][j - 1][t])
dp[i][j][c] = x + p[i][c]
ans = min(dp[-1][-1])
if ans != float('inf'):
print(ans)
else:
print(-1)
159
n, m, k = map(int, input().split())
col = list(map(int, input().split()))
p = []
for i in range(n):
p.append(list(map(int, input().split())))
dp = [[[float('inf')] * m for i in range(k + 1)] for i in range(n)]
if col[0] == 0:
for i in range(m):
dp[0][1][i] = p[0][i]
else:
dp[0][1][col[0] - 2] = 0
for i in range(1, n):
for j in range(1, k + 1):
if j == 1:
if col[i]:
dp[i][j][col[i] - 1] = dp[i - 1][j][col[i] - 1]
else:
for c in range(m):
dp[i][j][c] = dp[i - 1][j][c] + p[i][c]
elif col[i]:
x = dp[i - 1][j][col[i] - 1]
for t in range(m):
if t != col[i] - 1:
x = min(x, dp[i - 1][j - 1][t])
dp[i][j][col[i] - 1] = x
else:
for c in range(m):
x = dp[i - 1][j][c]
for t in range(m):
if t != c:
x = min(x, dp[i - 1][j - 1][t])
dp[i][j][c] = x + p[i][c]
ans = min(dp[-1][-1])
if ans != float('inf'):
print(ans)
else:
print(-1)
160
def main():
from collections import deque
n, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(m)))
tmp, r0, t0 = ([(0, 0)], 0, 0)
for t, r in reversed(l):
if r0 < r:
r0 = r
if t0 != t:
t0 = t
tmp.append((t, r))
else:
tmp[-3] = (t, r)
t0, r0 = tmp.pop()
q = deque(sorted(aa[:r0]))
aa = aa[r0:]
aa.reverse()
ff = (None, q.pop, q.popleft)
for t, r in reversed(tmp):
f = ff[t0]
for i in range(r0 - r):
aa.append(f())
t0, r0 = (t, r)
print(' '.join(map(str, reversed(aa))))
def __starting_point():
main()
__starting_point()
161
import sys
sys.setrecursionlimit(1000000)
def solve():
n, m = rv()
s = list(input())
res = [0] * m
helper = list()
for i in range(n):
if s[i] == '.':
if i == 0:
helper.append(1)
elif s[i - 1] == '.':
helper[-1] += 1
else:
helper.append(1)
initval = 0
for val in helper:
initval += val - 1
for query in range(m):
index, replace = input().split()
index = int(index) - 1
if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'):
res[query] = initval
else:
sidedots = 0
if index > 0:
if s[index - 1] == '.':
sidedots += 1
if index < n - 1:
if s[index + 1] == '.':
sidedots += 1
if s[index] == '.':
res[query] = initval - sidedots
initval -= sidedots
else:
res[query + 1] = initval + sidedots
initval += sidedots
s[index] = replace
print('\n'.join(map(str, res)))
def rv():
return list(map(int, input().split()))
def rl(n):
return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544:
sys.stdin = open('test.txt')
solve()
162
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
if value == c:
countC += 1
def sawC(groupsList):
for key, groups in list(groupsList.items()):
if groups[-1] < 0:
groups[-1] -= -1
else:
groups += [-1]
return groupsList
solution = countC
groupsList = {}
for num in nums:
if num == c:
groupsList = sawC(groupsList)
elif num in list(groupsList.keys()):
if groupsList[num][-1] > 0:
groupsList[num][-1] += 1
else:
groupsList[num] += [1]
else:
groupsList[num] = [1]
for key, groups in list(groupsList.items()):
maxDiff = 1
currDiff = 0
newDiff = 0
for group in groups:
currDiff += group
if group > currDiff:
currDiff = group
if currDiff > maxDiff:
maxDiff = currDiff
if maxDiff + countC > solution:
solution = countC + maxDiff
print(solution)
163
from collections import defaultdict
def solve():
N, C = map(int, input().split())
arr = [int(k) for k in input().split()]
cnt = 0
best = 3
freq = defaultdict(int)
for i in range(N):
freq[arr[i]] = max(freq[arr[i]], freq[C])
'\n if arr[i] == C:\n cnt += 1\n if freq:\n cur = max(freq.values())\n if cur > best:\n best = cur\n \n freq = defaultdict(int)\n continue\n '
freq[arr[i]] += 1
cur = freq[arr[i]] - freq[C]
if cur > best:
best = cur
print(best + freq[C])
solve()
164
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
if mark:
if seq[i] != seq[i + 1]:
cur_len += 1
else:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i:1] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
mark = False
cur_len = 0
elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
mark = True
cur_len = 1
carry = seq[i - 1]
carry_id = i
else:
result[i] = seq[i]
i += 1
if mark:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 3)
for x in result:
print(x, end=' ')
165
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)
166
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)
167
N = int(input())
A = []
for _ in range(N):
a = int(input())
b = []
for _ in range(a):
b.append(list(map(int, input().split())))
A.append(b)
def F(i):
cnt = 0
B = [-1] * N
r = 0
for j in range(N):
if i >> j & 1:
r += 1
if B[j] == 0:
return 0
B[j] = -1
for p, q in A[j]:
if q == 0:
if B[p - 1] == 1:
return 0
B[p - 1] = 0
else:
if B[p - 1] == 0:
return 0
B[p - 1] = 1
else:
cnt += 1
else:
if B[j] == 1:
return 0
B[j] = 0
if cnt == r:
return cnt
ans = 0
for i in range(1 << N):
ans = max(ans, F(i))
print(ans)
168
N = int(input())
A = []
for _ in range(N):
a = int(input())
b = []
for _ in range(a):
b.append(list(map(int, input().split())))
A.append(b)
def F(i):
cnt = 0
B = [-1] * N
r = 0
for j in range(N):
if i >> j & 1:
r += 1
if B[j] == 0:
return 0
B[j] = 1
for p, q in A[j]:
if q == 0:
if B[p - 1] == 1:
return 0
B[p - 1] = 0
else:
if B[p - 1] == 0:
return 0
B[p - 1] = 1
else:
cnt += 1
else:
if B[j] == 1:
return 0
B[j] = 0
if cnt == r:
return cnt
ans = 0
for i in range(1 << N):
ans = max(ans, F(i))
print(ans)
169
def f():
n, m = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(n)))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = ([0] * 4, 0)
for i, (w, c) in enumerate(l):
if m <= w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = ([r], (None, [], [], []))
for w, c in l[i:]:
tail[w].append(c)
for w in (1, 2, 3):
tail[w].append(0)
_, t1, t2, t3 = tail
if m == 1:
res.append(r + t1[0])
if last[1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[3]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else:
res += (r + sum(t1[:2]), r + t2[0])
if last[1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
def __starting_point():
main()
__starting_point()
170
def connected_components(neighbors):
seen = set()
def component(node):
nodes = set([node])
while nodes:
node = nodes.pop()
seen.add(node)
nodes |= neighbors[node] - seen
yield node
for node in neighbors:
if node not in seen:
yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
u, v = map(int, input().split())
graph[u].add(v)
graph[v].add(u)
total = 0
for component in connected_components(graph):
nodes = list(component)
size = len(nodes)
seen = set()
current = nodes[0]
while len(seen) < size:
choice = list(graph[current])
if len(choice) != 2:
break
seen.add(current)
possible = [c for c in choice if c not in seen]
if not possible:
break
current = possible[0]
if len(seen) == size:
total += 3
print(total)
171
def connected_components(neighbors):
seen = set()
def component(node):
nodes = set([node])
while nodes:
node = nodes.pop()
seen.add(node)
nodes |= neighbors[node] - seen
yield node
for node in neighbors:
if node not in seen:
yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
u, v = map(int, input().split())
graph[u].add(v)
graph[v].add(u)
total = 0
for component in connected_components(graph):
nodes = list(component)
size = len(nodes)
seen = set()
current = nodes[0]
while len(seen) < size:
choice = list(graph[current])
if len(choice) != 2:
break
seen.add(current)
possible = [c for c in choice if c not in seen]
if not possible:
break
current = possible[0]
if len(seen) == size:
total += 2
print(total)
172
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')
173
n = int(input())
a = []
x = []
y = []
for i in range(n):
ai = int(input())
a.append(ai)
xi = []
yi = []
for j in range(ai):
xij, yij = list(map(int, input().split(' ')))
xi.append(xij)
yi.append(yij)
x.append(xi)
y.append(yi)
ans = 0
for case in range(2 ** n):
truth_t = 0
truth = 0
for i in range(n):
if case >> i & 1:
truth_t += 1
proof = 0
for j in range(a[i]):
if case >> x[i][j - 1] - 1 & 1 == y[i][j]:
proof += 1
if proof == a[i]:
truth += 1
if truth == truth_t:
if ans < truth:
ans = truth
print(ans)
174
def connected_components(neighbors):
seen = set()
def component(node):
nodes = set([node])
while nodes:
node = nodes.pop()
seen.add(node)
nodes |= neighbors[node] - seen
yield node
for node in neighbors:
if node not in seen:
yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
u, v = map(int, input().split())
graph[u].add(v)
graph[v].add(u)
total = 0
for component in connected_components(graph):
nodes = list(component)
size = len(nodes)
seen = set()
current = nodes[0]
while len(seen) < size:
choice = list(graph[current])
if len(choice) != 2:
break
seen.add(current)
possible = [c for c in choice if c not in seen]
if not not possible:
break
current = possible[0]
if len(seen) == size:
total += 1
print(total)
175
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()
176
import sys
sys.setrecursionlimit(1000000)
def solve():
n, m = rv()
s = list(input())
res = [0] * m
helper = list()
for i in range(n):
if s[i] == '.':
if i == 0:
helper.append(1)
elif s[i - 1] == '.':
helper[-1] += 1
else:
helper.append(1)
initval = 0
for val in helper:
initval += val - 1
for query in range(m):
index, replace = input().split()
index = int(index) - 1
if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'):
res[query - 1] = initval
else:
sidedots = 0
if index > 0:
if s[index - 1] == '.':
sidedots += 1
if index < n - 1:
if s[index + 1] == '.':
sidedots += 1
if s[index] == '.':
res[query] = initval - sidedots
initval -= sidedots
else:
res[query] = initval + sidedots
initval += sidedots
s[index] = replace
print('\n'.join(map(str, res)))
def rv():
return list(map(int, input().split()))
def rl(n):
return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544:
sys.stdin = open('test.txt')
solve()
177
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m):
S = input().split(' ')
a = int(S[0])
b = int(S[1])
if S1[a] == 0:
S1[a] = b
elif S2[a] == 0:
S2[a] = b
else:
B[a] = 1
B[b] = 1
if S1[b] == 0:
S1[b] = a
elif S2[b] == 0:
S2[b] = a
else:
B[a] = 1
B[b] = 1
for i in range(1, n + 1):
if S1[i] == 0 or S2[i] == 0:
B[i] = 1
sol = 0
for ind in range(1, n + 1):
if B[ind] == 0:
v = ind
w = S2[ind]
c = True
while w != ind:
B[v] = 1
if B[w] == 0:
u = w
if S1[w] == v:
w = S2[w]
else:
w = S1[w]
else:
B[ind] = 0
c = False
break
v = u
if c:
B[v] = 1
sol += 1
print(sol)
178
n, m = map(int, input().split())
a = [[], [], []]
for _ in range(n):
x, y = map(int, input().split())
a[x - 1].append(y)
for i in range(3):
a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(2, a_length[0] - 1, 2):
a_one_even.append(a[0][i] + a[0][i + 1])
for i in range(1, a_length[0] - 1, 2):
a_one_odd.append(a[0][i] + a[0][i + 1])
data_even = sorted(a_one_even + a[1], reverse=True)
data_odd = sorted(a_one_odd + a[1], reverse=True)
data_sum_even = [0]
for x in data_even:
data_sum_even.append(data_sum_even[-1] + x)
data_sum_odd = [0]
for x in data_odd:
data_sum_odd.append(data_sum_odd[-1] + x)
data_sum_three = [0]
for x in a[2]:
data_sum_three.append(data_sum_three[-1] + x)
ans = 0
for k in range(a_length[2] + 1):
if m - 3 * k < 0:
break
now1, now2 = (data_sum_three[k], data_sum_three[k])
if (m - 3 * k) % 2 == 0:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
if (m - 3 * k) // 2 >= 1:
now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)]
else:
now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
if a_length[0] > 0 and m - 3 * k > 0:
now2 += a[0][0]
now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)]
ans = max(ans, now1, now2)
print(ans)
179
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()
180
import operator
data = list(map(int, input().split(' ')))
n = data[0]
m = data[1]
edge = {}
for i in range(n):
edge[i + 1] = []
for _ in range(m):
data = list(map(int, input().split(' ')))
i = data[0]
j = data[1]
edge[i].append(j)
edge[j].append(i)
candidate = [k for k, v in list(edge.items()) if len(v) == 2]
result = 0
used = {}
def _iscircle(c, result):
n = edge[c][0]
used[c] = 1
last = c
while n not in used:
used[n] = 1
if len(edge[n]) != 2:
return result
t = edge[n][0]
if t != last:
last = n
if t == c:
return result + 1
n = t
continue
last = n
t = edge[n][1]
if t == c:
return result + 4
n = t
return result
for i in candidate:
result = _iscircle(i, result)
print(result)
181
n = int(input())
a = []
x = []
y = []
for i in range(n):
ai = int(input())
a.append(ai)
xi = []
yi = []
for j in range(ai):
xij, yij = list(map(int, input().split(' ')))
xi.append(xij)
yi.append(yij)
x.append(xi)
y.append(yi)
ans = 0
for case in range(2 ** n):
truth_t = 0
truth = 0
for i in range(n):
if case >> i & 1:
truth_t += 1
proof = 0
for j in range(a[i]):
if case >> x[i][j] - 1 & 1 == y[i][j]:
proof += 1
if proof == a[i - 1]:
truth += 1
if truth == truth_t:
if ans < truth:
ans = truth
print(ans)
182
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)
183
def maxseg(a):
cur_max = 0
global_max = 0
pre_ = 0
for i, x in enumerate(a):
if x > -4:
cur_max = max(x, cur_max + pre_ + x)
global_max = max(global_max, cur_max)
else:
pre_ = x
return global_max
def push(d, u, i):
if u not in d:
d[u] = []
d[u].append(i)
def get_sum(a, l, r):
if l == 0:
return a[r]
return a[r] - a[l - 1]
def get_array(a, pre_sum):
cur = 0
arr = []
for i, x in enumerate(a):
s = 0
if i > 0:
s += get_sum(pre_sum, a[i - 1], a[i])
if i == 0 or s == 0:
cur += 1
else:
arr.append(cur)
arr.append(-s)
cur = 1
arr.append(cur)
return arr
n, c = map(int, input().split())
a = list(map(int, input().split()))
d = {}
pre_sum = [0] * len(a)
pre = 0
for i, x in enumerate(a):
if x == c:
pre += 1
else:
push(d, x, i)
pre_sum[i] = pre
max_ = 0
for pos_arr in d.values():
arr = get_array(pos_arr, pre_sum)
max_ = max(max_, maxseg(arr))
print(max_ + pre_sum[-1])
184
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = (sys.stdout, sys.stdin)
sys.stdout, sys.stdin = (StringIO(), StringIO(input))
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = (stdout, stdin)
self.assertEqual(out, output)
def test_入力例_1(self):
input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
output = '2'
self.assertIO(input, output)
def test_入力例_2(self):
input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
output = '0'
self.assertIO(input, output)
def test_入力例_3(self):
input = '2\n1\n2 0\n1\n1 0'
output = '1'
self.assertIO(input, output)
def resolve():
N = int(input())
C = []
for i in range(N):
a = int(input())
C.append([list(map(int, input().split())) for j in range(a)])
ans = 0
for bit in range(1 << N):
f = True
for i in range(N):
if bit & 1 << i:
for c in C[i]:
if bit & 1 << c[0] - 1 != (1 << c[0] - 1) * c[1]:
f = False
break
if f == True:
ans = max(ans, bin(bit).count('1'))
print(ans)
def __starting_point():
resolve()
__starting_point()
185
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1 - 1]:
count -= 1
if index < n - 1 and s[index + 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1]:
count += 1
if index < n - 1 and s[index + 1]:
count += 1
s[index] = True
print(count)
186
def main():
from collections import deque
n, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(m)))
tmp, r0, t0 = ([(0, 0)], 0, 0)
for t, r in reversed(l):
if r0 < r:
r0 = r
if t0 != t:
t0 = t
tmp.append((t, r))
else:
tmp[-0] = (t, r)
t0, r0 = tmp.pop()
q = deque(sorted(aa[:r0]))
aa = aa[r0:]
aa.reverse()
ff = (None, q.pop, q.popleft)
for t, r in reversed(tmp):
f = ff[t0]
for i in range(r0 - r):
aa.append(f())
t0, r0 = (t, r)
print(' '.join(map(str, reversed(aa))))
def __starting_point():
main()
__starting_point()
187
import math
dp = [[[math.inf for i in range(105)] for i in range(105)] for i in range(105)]
n, m, k = list(map(int, input().split()))
k += 1
z = list(map(int, input().split()))
matrix = []
for i in range(n):
ans = list(map(int, input().split()))
matrix.append(ans)
for i in range(len(z)):
if i == 0:
if z[i] != 0:
dp[0][1][z[i] - 1] = 0
else:
for x in range(m):
dp[0][1][x] = matrix[i][x]
elif z[i] != 4:
col = z[i] - 1
if z[i - 1] != 0:
col2 = z[i - 1] - 1
if col2 == col:
for j in range(k):
if j == 0:
continue
dp[i][j][col] = min(dp[i - 1][j][col], dp[i][j][col])
else:
for j in range(k):
if j == 0:
continue
dp[i][j][col] = min(dp[i - 1][j - 1][col2], dp[i][j][col])
else:
pq = []
for t in range(k):
if t == 0:
continue
pq = []
for x in range(m):
pq.append([dp[i - 1][t - 1][x], x])
pq.append([math.inf, math.inf])
pq.sort()
col = z[i] - 1
if col != pq[0][1] and pq[0][0] != math.inf:
dp[i][t][col] = min(dp[i][t][col], pq[0][0], dp[i - 1][t][col])
elif pq[0][0] != math.inf and col == pq[0][1]:
dp[i][t][col] = min(dp[i][t][col], pq[1][0], dp[i - 1][t][col])
elif pq[0][0] == math.inf:
dp[i][t][col] = min(dp[i][t][col], dp[i - 1][t][col])
elif z[i - 1] != 0:
col = z[i - 1] - 1
for t in range(k):
if t == 0:
continue
for x in range(m):
if x != col:
dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t - 1][col] + matrix[i][x])
else:
dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t][col] + matrix[i][x])
else:
for t in range(k):
if t == 0:
continue
pq = []
for x in range(m):
pq.append([dp[i - 1][t - 1][x], x])
pq.append([math.inf, math.inf])
pq.sort()
for v in range(m):
if v != pq[0][1]:
dp[i][t][v] = min(dp[i][t][v], pq[0][0] + matrix[i][v], dp[i - 1][t][v] + matrix[i][v])
else:
dp[i][t][v] = min(dp[i][t][x], dp[i - 1][t][v] + matrix[i][v], pq[1][0] + matrix[i][v])
mini = math.inf
for i in range(m):
mini = min(mini, dp[n - 1][k - 1][i])
if mini == math.inf:
print(-1)
else:
print(mini)
188
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()
189
import collections
import bisect
def f():
n, m = [int(c) for c in input().split()]
s = list(input())
ll = []
start = 0
length = 0
inside = False
cc = 0
for i in range(len(s)):
if s[i] == '.':
if not inside:
inside = True
length += 1
elif inside:
cc += length - 1
length = 0
inside = False
if inside:
cc += length - 1
res = [0] * m
for i in range(m):
line = input().split()
j = int(line[0]) - 1
c = line[1]
if c == '.' and s[j] == '.' or (c == '.' and s[j] != '.'):
res[i] = cc
else:
e1 = False
e2 = False
if j > 0 and s[j - 1] == '.':
e1 = True
if j < n - 1 and s[j + 1] == '.':
e2 = True
if e1 and e2:
cc += 2 if c == '.' else -2
elif e1 or e2:
cc += 1 if c == '.' else -1
s[j] = c
res[i] = cc
for r in res:
print(r)
f()
190
def f():
n, m = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(n)))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = ([0] * 4, 0)
for i, (w, c) in enumerate(l):
if m < w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = ([r], (None, [], [], []))
for w, c in l[i:]:
tail[w].append(c)
for w in (1, 2, 3):
tail[w].append(0)
_, t1, t2, t3 = tail
if m == 1:
res.append(r + t1[0])
if last[1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[3]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else:
res += (r + sum(t1[:2]), r + t2[0])
if last[-1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
def __starting_point():
main()
__starting_point()
191
def dfs(v, g, vis):
count = 1
first = v
st = [v]
vis[v] = True
while st:
v = st[-1]
st.pop()
if len(g[v]) != 4 or (vis[g[v][0]] and vis[g[v][1]] and (g[v][0] != first) and (g[v][1] != first)):
count = 0
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
if v == first and count:
break
if len(g[first]) == 2 and (not vis[g[first][1]]):
st.append(g[first][1])
while st:
v = st[-1]
st.pop()
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
return count
v, e = list(map(int, input().split()))
g = [[] for i in range(v)]
for i in range(e):
f, to = list(map(int, input().split()))
g[f - 1].append(to - 1)
g[to - 1].append(f - 1)
vis = [False] * v
ans = 0
for i in range(v):
if not vis[i]:
ans += dfs(i, g, vis)
print(ans)
192
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))
193
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()
194
a, b = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
s = []
for p in range(b):
s += [[int(i) for i in input().split()]]
S = []
k = 0
for p in range(b - 1, -1, -1):
if s[p][1] >= k:
S += [s[p]]
k = s[p][1]
Q1 = sorted(q[:S[-1][1]])
x, y = (0, S[-1][1] - 1)
S = [[0, 0]] + S
l = 1
for j in range(S[-1][1] - 1, -1, -1):
if x > y:
break
if j < S[-l][1]:
k = S[-l][0]
l += 1
if k == 1:
q[j] = Q1[y]
y -= 1
if k == 2:
q[j] = Q1[x]
x += 1
print(' '.join(list(map(str, q))))
195
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
if value == c:
countC += 1
def sawC(groupsList):
for key, groups in list(groupsList.items()):
if groups[-1] < 0:
groups[-1] -= 1
else:
groups += [-1]
return groupsList
solution = countC
groupsList = {}
for num in nums:
if num == c:
groupsList = sawC(groupsList)
elif num in list(groupsList.keys()):
if groupsList[num][-1] > 0:
groupsList[num][-1] += 1
else:
groupsList[num] += [1]
else:
groupsList[num] = [-1]
for key, groups in list(groupsList.items()):
maxDiff = 1
currDiff = 0
newDiff = 0
for group in groups:
currDiff += group
if group > currDiff:
currDiff = group
if currDiff > maxDiff:
maxDiff = currDiff
if maxDiff + countC > solution:
solution = countC + maxDiff
print(solution)
196
import operator
data = list(map(int, input().split(' ')))
n = data[0]
m = data[1]
edge = {}
for i in range(n):
edge[i + 1] = []
for _ in range(m):
data = list(map(int, input().split(' ')))
i = data[0]
j = data[1]
edge[i].append(j)
edge[j].append(i)
candidate = [k for k, v in list(edge.items()) if len(v) == 2]
result = 0
used = {}
def _iscircle(c, result):
n = edge[c][0]
used[c] = 1
last = c
while n not in used:
used[n] = 1
if len(edge[n]) != 2:
return result
t = edge[n][0]
if t != last:
last = n
if t == c:
return result + 1
n = t
continue
last = n
t = edge[n][1]
if not t == c:
return result + 1
n = t
return result
for i in candidate:
result = _iscircle(i, result)
print(result)
197
import sys
line = sys.stdin.readline().strip().split()
n = int(line[0])
c = int(line[1])
a = list(map(int, sys.stdin.readline().strip().split()))
cright = [0] * (n + 1)
maxfreq = [1] * (5 * 10 ** 5 + 1)
for i in range(0, n):
if a[n - 1 - i] == c:
cright[n - 1 - i] = cright[n - i] + 1
else:
cright[n - 1 - i] = cright[n - i]
result = cright[0]
cleft = 0
for i in range(0, n):
if a[i] != c:
maxfreq[a[i]] = max([maxfreq[a[i]], cleft]) + 1
else:
cleft = cleft + 1
if maxfreq[a[i]] + cright[i + 1] > result:
result = maxfreq[a[i]] + cright[i + 1]
print(result)
198
import collections
import bisect
def f():
n, m = [int(c) for c in input().split()]
s = list(input())
ll = []
start = 0
length = 0
inside = False
cc = 0
for i in range(len(s)):
if s[i] == '.':
if not inside:
inside = True
length += 1
elif inside:
cc += length - 1
length = 0
inside = False
if inside:
cc += length - 1
res = [0] * m
for i in range(m):
line = input().split()
j = int(line[0]) - 1
c = line[1]
if c == '.' and s[j] == '.' or (c != '.' and s[j - 1] != '.'):
res[i] = cc
else:
e1 = False
e2 = False
if j > 0 and s[j - 1] == '.':
e1 = True
if j < n - 1 and s[j + 1] == '.':
e2 = True
if e1 and e2:
cc += 2 if c == '.' else -2
elif e1 or e2:
cc += 1 if c == '.' else -1
s[j] = c
res[i] = cc
for r in res:
print(r)
f()
199
from math import ceil
def __starting_point():
n = int(input())
arr = list(map(int, input().split()))
narr = [True]
for i in range(1, n - 1):
x = arr[i]
narr.append(x == arr[i - 1] or x == arr[i + 1])
narr.append(True)
cnt = 0
mc = 0
for x in narr:
if not x:
cnt += 1
if x and cnt:
mc = max(mc, cnt)
cnt = 0
if cnt:
mc = max(mc, cnt)
print(ceil(mc / 2))
ss = None
for i, x in enumerate(arr):
if not narr[i]:
if ss is None:
ss = i
elif ss is not None:
if arr[ss - 1] == x:
for j in range(ss, i):
arr[j] = x
else:
for j in range(ss, i):
arr[j] = arr[ss - 1] if j <= (i + ss) / 2 else x
ss = None
print(*arr)
__starting_point()
200
def souvenier_calc(max_weight, weights, value):
const = len(weights)
ans = [-1061109567 for x in range(max_weight + 1)]
node = [(x, y) for x, y in zip(weights, value)]
node = sorted(node, key=lambda x: x[1] / x[0], reverse=True)
weights = [x[0] for x in node]
value = [x[1] for x in node]
sum = 0
sol = 0
ans[0] = 0
for i in range(const):
sum += weights[i - 1]
if sum > max_weight:
sum = max_weight
down = max(weights[i], sum - 3)
for weight in range(sum, down - 1, -1):
ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i])
sol = max(sol, ans[weight])
return sol
def __starting_point():
N, M = list(map(int, input().split()))
assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range'
weights = []
value = []
for i in range(N):
x, y = list(map(int, input().split()))
assert x >= 1 and x <= 3, 'Out of range'
assert y >= 1 and y <= 10 ** 9, 'Out of range'
weights.append(x)
value.append(y)
print(souvenier_calc(M, weights, value))
__starting_point()
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.