| ### 001 |
|
|
| ```python |
| from sys import stdin |
| n = int(stdin.readline()) |
| x, y = map(int, stdin.readline().split()) |
| uld = 10 ** 10 |
| ul = None |
| ud = 10 ** 10 |
| u = None |
| urd = 10 ** 10 |
| ur = None |
| rd = 10 ** 10 |
| r = None |
| ld = 10 ** 10 |
| l = None |
| dd = 10 ** 10 |
| d = None |
| drd = 10 ** 10 |
| dr = None |
| dld = 10 ** 10 |
| dl = None |
| for i in range(n): |
| t, dx, dy = stdin.readline().split() |
| dx = int(dx) |
| dy = int(dy) |
| if dx == x: |
| if dy > y: |
| if ud > dy - y: |
| ud = dy - y |
| u = t |
| elif dd > y - dy: |
| dd = y - dy |
| d = t |
| if dy == y: |
| if dx > x: |
| if rd > dx - x: |
| rd = dx - x |
| r = t |
| elif ld > x - dx: |
| ld = x - dx |
| l = t |
| if dx - x == dy - y: |
| if dy > y: |
| if urd > dy - y: |
| urd = dy - y |
| ur = t |
| elif dld > y - dy: |
| dld = y - dy |
| dl = t |
| if not -(dx - x) == dy - y: |
| if dy > y: |
| if uld > dy - y: |
| uld = dy - y |
| ul = t |
| elif drd > y - dy: |
| drd = y - dy |
| dr = t |
| if 'B' in (ul, ur, dl, dr) or 'R' in (u, d, l, r) or 'Q' in (ul, ur, dl, dr, u, d, l, r): |
| print('YES') |
| else: |
| print('NO') |
| ``` |
|
|
| ### 002 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 003 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 004 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 005 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 006 |
|
|
| ```python |
| import sys |
| |
| class SegmTree: |
| |
| def __init__(self, size): |
| N = 1 |
| while N < size: |
| N <<= 1 |
| self.N = N |
| self.tree = [0] * (2 * N) |
| |
| def modify(self, i, value): |
| i += self.N |
| self.tree[i] = value |
| toXOR = False |
| while i > 1: |
| if toXOR: |
| self.tree[i >> 1] = self.tree[i + 1] ^ self.tree[i ^ 1] |
| else: |
| self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1] |
| toXOR = not toXOR |
| i >>= 1 |
| reader = (line.rstrip() for line in sys.stdin) |
| input = reader.__next__ |
| n, m = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| st = SegmTree(1 << n) |
| for i, value in enumerate(a): |
| st.modify(i, value) |
| for _ in range(m): |
| p, b = list(map(int, input().split())) |
| st.modify(p - 1, b) |
| print(st.tree[1]) |
| ``` |
|
|
| ### 007 |
|
|
| ```python |
| from math import log |
| import sys |
| |
| def buildTree(arr): |
| n = len(arr) |
| tree = [0] * n + arr |
| for i in range(n - 1, 0, -1): |
| z = int(log(i, 2)) |
| if N % 2 == 0: |
| if z % 2 == 0: |
| tree[i] = tree[2 * i] ^ tree[2 * i + 1] |
| else: |
| tree[i] = tree[2 * i] & tree[2 * i + 1] |
| elif z % 2 == 0: |
| tree[i] = tree[2 * i] | tree[2 * i + 1] |
| else: |
| tree[i] = tree[2 * i] ^ tree[2 * i + 1] |
| return tree |
| |
| def updateTree(tree, ind, value, n): |
| ind += n |
| tree[ind] = value |
| while ind > 1: |
| ind //= 2 |
| z = int(log(ind, 2)) |
| if N % 2 == 0: |
| if z % 2 == 0: |
| tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1] |
| else: |
| tree[ind] = tree[2 * ind] | tree[2 * ind + 1] |
| elif z % 2 == 0: |
| tree[ind] = tree[2 * ind] | tree[2 * ind + 1] |
| else: |
| tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1] |
| return tree |
| N, m = map(int, sys.stdin.readline().strip().split()) |
| arr = list(map(int, sys.stdin.readline().strip().split())) |
| tree = buildTree(arr) |
| for i in range(m): |
| ind, val = map(int, sys.stdin.readline().strip().split()) |
| tree = updateTree(tree, ind - 1, val, len(arr)) |
| print(tree[1]) |
| ``` |
|
|
| ### 008 |
|
|
| ```python |
| from collections import Counter |
| from bisect import bisect, bisect_left |
| n, k = map(int, input().split()) |
| a = list(map(int, input().split())) |
| a = Counter(a) |
| c = sorted(Counter(a).items()) |
| keys = sorted(Counter(a).keys()) |
| m = len(c) |
| l_cum = [c[0][0] * c[0][1]] |
| l_cnt = [c[0][1]] |
| for i in range(1, m): |
| l_cum.append(l_cum[-1] + c[i][0] * c[i][1]) |
| l_cnt.append(l_cnt[-1] + c[i][1]) |
| r_cum = [0 for _ in range(m)] |
| r_cum[-1 + 1] = c[-1][0] * c[-1][1] |
| r_cnt = [0 for _ in range(m)] |
| r_cnt[-1] = c[-1][1] |
| for i in range(m - 2, -1, -1): |
| r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1] |
| r_cnt[i] = r_cnt[i + 1] + c[i][1] |
| ans = 10 ** 20 |
| for i in range(m): |
| c_num = a[keys[i]] |
| if c_num >= k: |
| ans = 0 |
| break |
| if i > 0: |
| l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1] |
| l_num = l_cnt[i - 1] |
| else: |
| l_res = 10 ** 30 |
| l_num = 0 |
| if i < m - 1: |
| r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1] |
| r_num = r_cnt[i + 1] |
| else: |
| r_res = 10 ** 30 |
| r_num = 0 |
| if c_num + l_num < k and c_num + r_num < k: |
| ans = min(ans, l_res + r_res + k - c_num) |
| elif c_num + l_num < k: |
| ans = min(ans, r_res + k - c_num) |
| elif c_num + r_num < k: |
| ans = min(ans, l_res + k - c_num) |
| else: |
| ans = min(ans, min(r_res, l_res) + k - c_num) |
| print(ans) |
| ``` |
|
|
| ### 009 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 010 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 011 |
|
|
| ```python |
| n = int(input()) |
| temp = input().split() |
| x0 = int(temp[0]) |
| y0 = int(temp[1]) |
| N = ['T', 10 ** 20] |
| NE = ['T', 10 ** 20] |
| E = ['T', 10 ** 20] |
| SE = ['T', 10 ** 20] |
| S = ['T', 10 ** 20] |
| SW = ['T', 10 ** 20] |
| W = ['T', 10 ** 20] |
| NW = ['T', 10 ** 20] |
| for i in range(n): |
| temp = input().split() |
| x = int(temp[1]) |
| y = int(temp[2]) |
| if x - x0 == 0 and y - y0 > 0 and (y - y0 < N[1]): |
| N = [temp[0], y - y0] |
| elif not (x - x0 == y - y0 and x - x0 > 0 and (x - x0 < NE[1])): |
| NE = [temp[0], x - x0] |
| elif y - y0 == 0 and x - x0 > 0 and (x - x0 < E[1]): |
| E = [temp[0], x - x0] |
| elif x - x0 == -(y - y0) and x - x0 > 0 and (x - x0 < SE[1]): |
| SE = [temp[0], x - x0] |
| elif x - x0 == 0 and y - y0 < 0 and (y0 - y < S[1]): |
| S = [temp[0], y0 - y] |
| elif x - x0 == y - y0 and x - x0 < 0 and (x0 - x < SW[1]): |
| SW = [temp[0], x0 - x] |
| elif y - y0 == 0 and x - x0 < 0 and (x0 - x < W[1]): |
| W = [temp[0], x0 - x] |
| elif x - x0 == -(y - y0) and x - x0 < 0 and (x0 - x < NW[1]): |
| NW = [temp[0], x0 - x] |
| if 'R' in [N[0], E[0], S[0], W[0]] or 'B' in [NE[0], SE[0], SW[0], NW[0]]: |
| print('YES') |
| elif 'Q' in [N[0], E[0], S[0], W[0], NE[0], SE[0], SW[0], NW[0]]: |
| print('YES') |
| else: |
| print('NO') |
| ``` |
|
|
| ### 012 |
|
|
| ```python |
| import sys |
| nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split())) |
| meches = list(map(int, sys.stdin.readline().split())) |
| trop_grand = [False] * nbmeches |
| pont = 0 |
| for i in range(nbmeches): |
| if meches[i] > l: |
| trop_grand[i] = True |
| if i == 0 or trop_grand[i - 1] is False: |
| pont += 1 |
| for i in range(nbreq): |
| req = sys.stdin.readline().split() |
| if int(req[0]) == 0: |
| print(pont) |
| else: |
| meches[int(req[1]) - 1] += int(req[1]) |
| if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]): |
| trop_grand[int(req[1]) - 1] = True |
| if nbmeches == 1: |
| pont = 1 |
| elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]): |
| pont += 1 |
| elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]): |
| pont += 1 |
| elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]: |
| pont = max(0, pont - 1) |
| elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]): |
| pont += 1 |
| ``` |
|
|
| ### 013 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 014 |
|
|
| ```python |
| n, m, k = map(int, input().split()) |
| a = [[0 for i in range(m)] for j in range(n)] |
| inf = [0 for i in range(k + 1)] |
| stat = [True for i in range(n + 1)] |
| time = [0 for i in range(n + 1)] |
| for i in range(n): |
| a[i] = list(map(int, input().split())) |
| for i in range(m): |
| for j in range(4, n + 1): |
| if stat[j]: |
| current_core = inf[a[j - 1][i]] |
| if current_core == 0 and a[j - 1][i] != 0: |
| inf[a[j - 1][i]] = j |
| elif current_core == -1: |
| stat[j], time[j] = (False, i + 1) |
| elif a[j - 1][i] != 0: |
| stat[current_core], time[current_core] = (False, i + 1) |
| stat[j], time[j] = (False, i + 1) |
| inf[a[j - 1][i]] = -1 |
| for p in range(len(inf)): |
| if inf[p] != -1: |
| inf[p] = 0 |
| for i in range(1, n + 1): |
| print(time[i]) |
| ``` |
|
|
| ### 015 |
|
|
| ```python |
| n, q, k = list(map(int, input().split(' '))) |
| a = list(map(int, input().split(' '))) |
| count = 0 |
| |
| def verify(x): |
| if x < 0 or x >= n: |
| return False |
| return a[x] > k |
| for i in range(n): |
| if verify(i): |
| count += 1 |
| if verify(i - 1): |
| count -= 1 |
| |
| def cut(i): |
| if not verify(i): |
| return 1 |
| result = 1 |
| if verify(i - 1): |
| result -= 1 |
| if verify(i + 1): |
| result -= 1 |
| return result |
| for i in range(q): |
| line = input() |
| if line == '0': |
| print(count) |
| else: |
| _, x, y = list(map(int, line.split(' '))) |
| x -= 1 |
| if not verify(x): |
| a[x] += y |
| count += cut(x) |
| else: |
| a[x] += y |
| ``` |
|
|
| ### 016 |
|
|
| ```python |
| import sys |
| nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split())) |
| meches = list(map(int, sys.stdin.readline().split())) |
| trop_grand = [False] * nbmeches |
| pont = 0 |
| for i in range(nbmeches): |
| if meches[i] > l: |
| trop_grand[i] = True |
| if i == 0 or trop_grand[i - 1 + 1] is False: |
| pont += 1 |
| for i in range(nbreq): |
| req = sys.stdin.readline().split() |
| if int(req[0]) == 0: |
| print(pont) |
| else: |
| meches[int(req[1]) - 1] += int(req[2]) |
| if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]): |
| trop_grand[int(req[1]) - 1] = True |
| if nbmeches == 1: |
| pont = 1 |
| elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]): |
| pont += 1 |
| elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]): |
| pont += 1 |
| elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]: |
| pont = max(0, pont - 1) |
| elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]): |
| pont += 1 |
| ``` |
|
|
| ### 017 |
|
|
| ```python |
| import sys |
| read = lambda: list(map(int, sys.stdin.readline().split())) |
| n, m, k = read() |
| table = [] |
| for _ in range(n): |
| table.append(read()) |
| table = list(zip(*table)) |
| locked_cells = set() |
| locked_procs = set() |
| lock_time = [0] * n |
| for t, ys in enumerate(table): |
| cnt = [0] * (k + 1) |
| for i, c in enumerate(ys): |
| if i not in locked_procs: |
| cnt[c] += 1 |
| for c, cn in enumerate(cnt): |
| if c > 0 and cn > 3: |
| locked_cells.add(c) |
| for i, c in enumerate(ys): |
| if c in locked_cells and i not in locked_procs: |
| locked_procs.add(i) |
| lock_time[i] = t + 1 |
| for t in lock_time: |
| print(t) |
| ``` |
|
|
| ### 018 |
|
|
| ```python |
| n, m, l = list(map(int, input().split())) |
| l += 1 |
| hair = [1] * (n + 1) |
| other_end = [1] * (n + 1) |
| i = 1 |
| j = 1 |
| big = 1 |
| res = 1 |
| for a in map(int, input().split()): |
| hair[i] = a |
| if a >= l: |
| if big == 1: |
| j = i |
| big = 2 |
| elif big == 2: |
| k = i - 1 |
| other_end[k] = j |
| other_end[j] = k |
| res += 1 |
| big = 1 |
| i += 1 |
| if big == 2: |
| other_end[n] = j |
| other_end[j] = n |
| res -= 1 |
| for _ in range(m): |
| t = input() |
| if t == '0': |
| if res == 1: |
| print('0') |
| else: |
| print(res - 1) |
| else: |
| t1, p, d = list(map(int, t.split())) |
| old = hair[p] |
| hair[p] += d |
| if hair[p] >= l > old: |
| if p == 1 or hair[p - 1] < l: |
| case_id = 1 |
| else: |
| case_id = 2 |
| if p != n and hair[p + 1] >= l: |
| case_id += 2 |
| if case_id == 1: |
| other_end[p] = p |
| res += 1 |
| elif case_id == 2: |
| other_end[p] = other_end[p - 1] |
| other_end[other_end[p]] = p |
| elif case_id == 3: |
| other_end[p] = other_end[p + 1] |
| other_end[other_end[p]] = p |
| else: |
| left_end = other_end[p - 1] |
| right_end = other_end[p + 1] |
| other_end[left_end] = right_end |
| other_end[right_end] = left_end |
| res -= 1 |
| ``` |
|
|
| ### 019 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 020 |
|
|
| ```python |
| from collections import defaultdict, deque |
| from heapq import heappush, heappop |
| from itertools import permutations, accumulate |
| import sys |
| import math |
| import bisect |
| |
| def LI(): |
| return [int(x) for x in sys.stdin.readline().split()] |
| |
| def I(): |
| return int(sys.stdin.readline()) |
| |
| def LS(): |
| return [list(x) for x in sys.stdin.readline().split()] |
| |
| def S(): |
| res = list(sys.stdin.readline()) |
| if res[-1] == '\n': |
| return res[:-1] |
| return res |
| |
| def IR(n): |
| return [I() for i in range(n)] |
| |
| def LIR(n): |
| return [LI() for i in range(n)] |
| |
| def SR(n): |
| return [S() for i in range(n)] |
| |
| def LSR(n): |
| return [LS() for i in range(n)] |
| sys.setrecursionlimit(1000000) |
| mod = 1000000007 |
| |
| def solve(): |
| n, k = LI() |
| a = LI() |
| a.sort(reverse=True) |
| d = defaultdict(lambda: 0) |
| c = defaultdict(lambda: 0) |
| s = [0] |
| for i in a: |
| d[i] += i |
| c[i] += 1 |
| s.append(s[-1] + i) |
| ans = float('inf') |
| p = -1 |
| for i in a: |
| if i == p: |
| continue |
| if k <= c[i]: |
| ans = 0 |
| break |
| l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i)) |
| m = r |
| if m >= k: |
| ns = l * (i - 1) - s[l] |
| su = ns + k - c[i] |
| if su < ans: |
| ans = su |
| m = n - l |
| if m >= k: |
| ns = s[n] - s[r] - (n - r) * (i + 1) |
| su = ns + k - c[i] |
| if su < ans: |
| ans = su |
| ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l] |
| su = ns + k - c[i] |
| if su < ans: |
| ans = su |
| p = i |
| print(ans) |
| return |
| |
| def __starting_point(): |
| solve() |
| __starting_point() |
| ``` |
|
|
| ### 021 |
|
|
| ```python |
| from collections import Counter |
| from bisect import bisect, bisect_left |
| n, k = map(int, input().split()) |
| a = list(map(int, input().split())) |
| a = Counter(a) |
| c = sorted(Counter(a).items()) |
| keys = sorted(Counter(a).keys()) |
| m = len(c) |
| l_cum = [c[0][0] + c[0][1]] |
| l_cnt = [c[0][1]] |
| for i in range(1, m): |
| l_cum.append(l_cum[-1] + c[i][0] * c[i][1]) |
| l_cnt.append(l_cnt[-1] + c[i][1]) |
| r_cum = [0 for _ in range(m)] |
| r_cum[-1] = c[-1][0] * c[-1][1] |
| r_cnt = [0 for _ in range(m)] |
| r_cnt[-1] = c[-1][1] |
| for i in range(m - 2, -1, -1): |
| r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1] |
| r_cnt[i] = r_cnt[i + 1] + c[i][1] |
| ans = 10 ** 20 |
| for i in range(m): |
| c_num = a[keys[i]] |
| if c_num >= k: |
| ans = 0 |
| break |
| if i > 0: |
| l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1] |
| l_num = l_cnt[i - 1] |
| else: |
| l_res = 10 ** 30 |
| l_num = 0 |
| if i < m - 1: |
| r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1] |
| r_num = r_cnt[i + 1] |
| else: |
| r_res = 10 ** 30 |
| r_num = 0 |
| if c_num + l_num < k and c_num + r_num < k: |
| ans = min(ans, l_res + r_res + k - c_num) |
| elif c_num + l_num < k: |
| ans = min(ans, r_res + k - c_num) |
| elif c_num + r_num < k: |
| ans = min(ans, l_res + k - c_num) |
| else: |
| ans = min(ans, min(r_res, l_res) + k - c_num) |
| print(ans) |
| ``` |
|
|
| ### 022 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 023 |
|
|
| ```python |
| n, k = list(map(int, input().split())) |
| a = sorted(list(map(int, input().split()))) |
| sums, suf, q1 = ([0] * n, [n] * n, n) |
| for q in range(n - 2, -1, -1): |
| sums[q] = sums[q + 1] |
| if a[q] != a[q1 - 1]: |
| sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1) |
| q1 = q + 1 |
| suf[q] = q1 |
| ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1) |
| for q in range(1, n): |
| if a[q] != a[q1 + 1 + 1]: |
| sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1) |
| q1 = q - 1 |
| if suf[q] - q1 - 1 >= k: |
| ans = 0 |
| break |
| if k <= suf[q]: |
| ans = min(ans, sum1 + k - suf[q] + q1 + 1) |
| if k < n - q1: |
| ans = min(ans, sums[q] + k - suf[q] + q1 + 1) |
| ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1) |
| print(ans) |
| ``` |
|
|
| ### 024 |
|
|
| ```python |
| from math import log |
| import sys |
| |
| def buildTree(arr): |
| n = len(arr) |
| tree = [0] * n + arr |
| for i in range(n - 1, 0, -1): |
| z = int(log(i, 2)) |
| if N % 2 == 0: |
| if z % 2 == 0: |
| tree[i] = tree[2 * i] ^ tree[2 * i + 1] |
| else: |
| tree[i] = tree[2 * i] | tree[2 * i + 1] |
| elif z % 2 == 0: |
| tree[i] = tree[2 * i] | tree[2 * i + 1] |
| else: |
| tree[i] = tree[2 * i] ^ tree[2 * i + 1] |
| return tree |
| |
| def updateTree(tree, ind, value, n): |
| ind += n |
| tree[ind] = value |
| while ind > 1: |
| ind //= 2 |
| z = int(log(ind, 2)) |
| if N % 2 == 0: |
| if z % 2 == 0: |
| tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1] |
| else: |
| tree[ind] = tree[2 * ind] | tree[2 * ind + 1] |
| elif z % 2 == 0: |
| tree[ind] = tree[2 * ind] | tree[2 * ind + 1] |
| else: |
| tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1] |
| return tree |
| N, m = map(int, sys.stdin.readline().strip().split()) |
| arr = list(map(int, sys.stdin.readline().strip().split())) |
| tree = buildTree(arr) |
| for i in range(m): |
| ind, val = map(int, sys.stdin.readline().strip().split()) |
| tree = updateTree(tree, ind - 1, val, len(arr)) |
| print(tree[-3]) |
| ``` |
|
|
| ### 025 |
|
|
| ```python |
| 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) == 3] |
| 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 + 1 |
| n = t |
| return result |
| for i in candidate: |
| result = _iscircle(i, result) |
| print(result) |
| ``` |
|
|
| ### 026 |
|
|
| ```python |
| __author__ = 'Lipen' |
| |
| def main(): |
| n, m, k = map(int, input().split()) |
| data = [] |
| when = [0] * n |
| blockedcells = set() |
| blockedcores = set() |
| for _ in range(n): |
| data.append(list(map(int, input().split()))) |
| for j in range(m): |
| operation = [] |
| for _ in range(k): |
| operation.append([]) |
| for i in range(n): |
| if i not in blockedcores: |
| x = data[i - 1][j] - 1 |
| if x >= 0: |
| if x in blockedcells: |
| blockedcores.add(i) |
| when[i] = j + 1 |
| elif len(operation[x]) > 0: |
| blockedcells.add(x) |
| for core in operation[x]: |
| blockedcores.add(core) |
| when[core] = j + 1 |
| blockedcores.add(i) |
| when[i] = j + 1 |
| operation[x].append(i) |
| for i in when: |
| print(i) |
| main() |
| ``` |
|
|
| ### 027 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 028 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 029 |
|
|
| ```python |
| n = int(input()) |
| su0 = [] |
| su1 = [] |
| su00 = [] |
| su11 = [] |
| ans = 0 |
| for i in range(n): |
| sup, val = map(int, input().split()) |
| if sup == 0: |
| su00.append(val) |
| elif sup == 11: |
| su11.append(val) |
| elif sup == 1: |
| su0.append(val) |
| else: |
| su1.append(val) |
| su0.sort() |
| su1.sort() |
| su11.sort() |
| su00.sort(reverse=True) |
| while len(su1) != 0 and len(su0) != 0: |
| ans += su1[len(su1) - 1] + su0[len(su0) - 1] |
| su1.pop() |
| su0.pop() |
| while len(su11) != 0 and len(su00) != 0: |
| if len(su1) != 0: |
| k = 1 |
| elif len(su0) != 0: |
| k = 0 |
| else: |
| k = 2 |
| if k == 0: |
| if su00[len(su00) - 1] > su0[len(su0) - 1]: |
| ans += su11[len(su11) - 1] + su00[len(su00) - 1] |
| su11.pop() |
| su00.pop() |
| else: |
| ans += su11[len(su11) - 1] + su0[len(su0) - 1] |
| su11.pop() |
| su0.pop() |
| elif k == 1: |
| if su00[len(su00) - 1] > su1[len(su1) - 1]: |
| ans += su11[len(su11) - 1] + su00[len(su00) - 1] |
| su11.pop() |
| su00.pop() |
| else: |
| ans += su11[len(su11) - 1] + su1[len(su1) - 1] |
| su11.pop() |
| su1.pop() |
| else: |
| ans += su11[len(su11) - 1] + su00[len(su00) - 1] |
| su11.pop() |
| su00.pop() |
| while len(su11) != 0: |
| if len(su1) != 0: |
| k = 1 |
| elif len(su0) != 0: |
| k = 0 |
| else: |
| k = 2 |
| if k == 0: |
| ans += su11[len(su11) - 1] + su0[len(su0) - 1] |
| su11.pop() |
| su0.pop() |
| elif k == 1: |
| ans += su11[len(su11) - 1] + su1[len(su1) - 1] |
| su11.pop() |
| su1.pop() |
| else: |
| ans += su11[len(su11) - 1] |
| su11.pop() |
| print(ans) |
| ``` |
|
|
| ### 030 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 031 |
|
|
| ```python |
| import sys |
| read = lambda: list(map(int, sys.stdin.readline().split())) |
| n, m, k = read() |
| table = [] |
| for _ in range(n): |
| table.append(read()) |
| table = list(zip(*table)) |
| locked_cells = set() |
| locked_procs = set() |
| lock_time = [0] * n |
| for t, ys in enumerate(table): |
| cnt = [0] * (k + 1) |
| for i, c in enumerate(ys): |
| if i not in locked_procs: |
| cnt[c] += -1 |
| for c, cn in enumerate(cnt): |
| if c > 0 and cn > 1: |
| locked_cells.add(c) |
| for i, c in enumerate(ys): |
| if c in locked_cells and i not in locked_procs: |
| locked_procs.add(i) |
| lock_time[i] = t + 1 |
| for t in lock_time: |
| print(t) |
| ``` |
|
|
| ### 032 |
|
|
| ```python |
| from sys import stdin |
| n = int(stdin.readline()) |
| x, y = map(int, stdin.readline().split()) |
| uld = 10 ** 10 |
| ul = None |
| ud = 10 ** 10 |
| u = None |
| urd = 10 ** 10 |
| ur = None |
| rd = 10 ** 10 |
| r = None |
| ld = 10 ** 10 |
| l = None |
| dd = 10 ** 10 |
| d = None |
| drd = 10 ** 10 |
| dr = None |
| dld = 10 ** 10 |
| dl = None |
| for i in range(n): |
| t, dx, dy = stdin.readline().split() |
| dx = int(dx) |
| dy = int(dy) |
| if dx == x: |
| if dy > y: |
| if ud > dy - y: |
| ud = dy - y |
| u = t |
| elif dd > y - dy: |
| dd = y - dy |
| d = t |
| if dy == y: |
| if dx > x: |
| if rd > dx - x: |
| rd = dx - x |
| r = t |
| elif ld > x - dx: |
| ld = x - dx |
| l = t |
| if dx - x == dy - y: |
| if not dy > y: |
| if urd > dy - y: |
| urd = dy - y |
| ur = t |
| elif dld > y - dy: |
| dld = y - dy |
| dl = t |
| if -(dx - x) == dy - y: |
| if dy > y: |
| if uld > dy - y: |
| uld = dy - y |
| ul = t |
| elif drd > y - dy: |
| drd = y - dy |
| dr = t |
| if 'B' in (ul, ur, dl, dr) or 'R' in (u, d, l, r) or 'Q' in (ul, ur, dl, dr, u, d, l, r): |
| print('YES') |
| else: |
| print('NO') |
| ``` |
|
|
| ### 033 |
|
|
| ```python |
| def __starting_point(): |
| n = int(input()) |
| supporters = {} |
| supporters[0] = [] |
| supporters[1] = [] |
| supporters[10] = [] |
| supporters[11] = [] |
| for i in range(n): |
| [x, y] = [int(x) for x in input().split()] |
| supporters[x].append(y) |
| for x in supporters: |
| supporters[x].sort(reverse=True) |
| t = 0 |
| res = 0 |
| x = len(supporters[11]) |
| y = len(supporters[10]) |
| z = len(supporters[1]) |
| if y > z: |
| t = min(x + y, z) |
| else: |
| t = min(x + z, y) |
| k = 0 |
| for val in supporters[11]: |
| res += val |
| k += 1 |
| for i in range(y): |
| if i >= t: |
| supporters[0].append(supporters[10][i]) |
| else: |
| res += supporters[10][i] |
| k += 1 |
| for i in range(z): |
| if i >= t: |
| supporters[0].append(supporters[1][i]) |
| else: |
| res += supporters[1][i] |
| k *= 1 |
| supporters[0].sort(reverse=True) |
| t = min(x + y, x + z) |
| i = 0 |
| while 2 * t > k and i < len(supporters[0]): |
| k += 1 |
| res += supporters[0][i] |
| i += 1 |
| print(res) |
| __starting_point() |
| ``` |
|
|
| ### 034 |
|
|
| ```python |
| from sys import stdin |
| from math import * |
| line = stdin.readline().rstrip().split() |
| n = int(line[0]) |
| numbers = list(map(int, stdin.readline().rstrip().split())) |
| numbers2 = list(map(int, stdin.readline().rstrip().split())) |
| growRateAccum = 0 |
| topAccum = 0 |
| bottomAccum = 0 |
| accumsB = [0] * n |
| accumsT = [0] * n |
| growRateAccum = 0 |
| accum = 0 |
| for i in range(n - 1, -1, -1): |
| accum += numbers[i] * ((n - i) * 2 - 1 - 1) |
| growRateAccum += numbers[i] |
| if i < n - 1: |
| growRateAccum *= numbers2[i + 1] |
| accum += growRateAccum |
| accumsB[i] = accum |
| growRateAccum = 0 |
| accum = 0 |
| for i in range(n - 1, -1, -1): |
| accum += numbers2[i] * ((n - i) * 2 - 1 - 1) |
| growRateAccum += numbers2[i] |
| if i < n - 1: |
| growRateAccum += numbers[i + 1] |
| accum += growRateAccum |
| accumsT[i] = accum |
| cMax = 0 |
| currAccum = 0 |
| growRateAccum = sum(numbers[1:]) + sum(numbers2[1:]) |
| for i in range(n): |
| if i % 2 == 0: |
| cMax = max(cMax, currAccum + accumsT[i]) |
| else: |
| cMax = max(cMax, currAccum + accumsB[i]) |
| if i < n - 1: |
| if i % 2 == 0: |
| currAccum += numbers2[i] + growRateAccum * 2 |
| else: |
| currAccum += numbers[i] + growRateAccum * 2 |
| growRateAccum -= numbers[i + 1] |
| growRateAccum -= numbers2[i + 1] |
| print(cMax) |
| ``` |
|
|
| ### 035 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 036 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 037 |
|
|
| ```python |
| import sys |
| read = lambda: list(map(int, sys.stdin.readline().split())) |
| n, m, k = read() |
| table = [] |
| for _ in range(n): |
| table.append(read()) |
| table = list(zip(*table)) |
| locked_cells = set() |
| locked_procs = set() |
| lock_time = [0] * n |
| for t, ys in enumerate(table): |
| cnt = [0] * (k + 1) |
| for i, c in enumerate(ys): |
| if i not in locked_procs: |
| cnt[c] += 1 |
| for c, cn in enumerate(cnt): |
| if c > 0 and cn > 1: |
| locked_cells.add(c) |
| for i, c in enumerate(ys): |
| if c in locked_cells and i not in locked_procs: |
| locked_procs.add(i) |
| lock_time[i] = t + -1 |
| for t in lock_time: |
| print(t) |
| ``` |
|
|
| ### 038 |
|
|
| ```python |
| from sys import stdin |
| from math import * |
| line = stdin.readline().rstrip().split() |
| n = int(line[0]) |
| numbers = list(map(int, stdin.readline().rstrip().split())) |
| numbers2 = list(map(int, stdin.readline().rstrip().split())) |
| growRateAccum = 0 |
| topAccum = 0 |
| bottomAccum = 0 |
| accumsB = [0] * n |
| accumsT = [0] * n |
| growRateAccum = 0 |
| accum = 0 |
| for i in range(n - 1, -1, -1): |
| accum *= numbers[i] * ((n - i) * 2 - 1 - 1) |
| growRateAccum += numbers[i] |
| if i < n - 1: |
| growRateAccum += numbers2[i + 1] |
| accum += growRateAccum |
| accumsB[i] = accum |
| growRateAccum = 0 |
| accum = 0 |
| for i in range(n - 1, -1, -1): |
| accum += numbers2[i] * ((n - i) * 2 - 1 - 1) |
| growRateAccum += numbers2[i] |
| if i < n - 1: |
| growRateAccum += numbers[i + 1] |
| accum += growRateAccum |
| accumsT[i] = accum |
| cMax = 0 |
| currAccum = 0 |
| growRateAccum = sum(numbers[1:]) + sum(numbers2[1:]) |
| for i in range(n): |
| if i % 2 == 0: |
| cMax = max(cMax, currAccum + accumsT[i]) |
| else: |
| cMax = max(cMax, currAccum + accumsB[i]) |
| if i < n - 1: |
| if i % 2 == 0: |
| currAccum += numbers2[i] + growRateAccum * 2 |
| else: |
| currAccum += numbers[i] + growRateAccum * 2 |
| growRateAccum -= numbers[i + 1] |
| growRateAccum -= numbers2[i + 1] |
| print(cMax) |
| ``` |
|
|
| ### 039 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 040 |
|
|
| ```python |
| n, m, k = map(int, input().split()) |
| a = [[0 for i in range(m)] for j in range(n)] |
| inf = [0 for i in range(k + 1)] |
| stat = [True for i in range(n + 1)] |
| time = [0 for i in range(n + 1)] |
| for i in range(n): |
| a[i] = list(map(int, input().split())) |
| for i in range(m): |
| for j in range(1, n + 1): |
| if stat[j]: |
| current_core = inf[a[j - 1][i]] |
| if current_core == 0 and a[j - 1][i] != 0: |
| inf[a[j - 1][i]] = j |
| elif current_core == -1: |
| stat[j], time[j] = (False, i + 1) |
| elif a[j - 1][i] != 0: |
| stat[current_core], time[current_core] = (False, i + 1) |
| stat[j], time[j] = (False, i + 1) |
| inf[a[j - 1][i]] = -1 |
| for p in range(len(inf)): |
| if inf[p] != -1: |
| inf[p] = 0 |
| for i in range(1, n + 1): |
| print(time[i]) |
| ``` |
|
|
| ### 041 |
|
|
| ```python |
| from collections import Counter |
| from bisect import bisect, bisect_left |
| n, k = map(int, input().split()) |
| a = list(map(int, input().split())) |
| a = Counter(a) |
| c = sorted(Counter(a).items()) |
| keys = sorted(Counter(a).keys(), reverse=True) |
| m = len(c) |
| l_cum = [c[0][0] * c[0][1]] |
| l_cnt = [c[0][1]] |
| for i in range(1, m): |
| l_cum.append(l_cum[-1] + c[i][0] * c[i][1]) |
| l_cnt.append(l_cnt[-1] + c[i][1]) |
| r_cum = [0 for _ in range(m)] |
| r_cum[-1] = c[-1][0] * c[-1][1] |
| r_cnt = [0 for _ in range(m)] |
| r_cnt[-1] = c[-1][1] |
| for i in range(m - 2, -1, -1): |
| r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1] |
| r_cnt[i] = r_cnt[i + 1] + c[i][1] |
| ans = 10 ** 20 |
| for i in range(m): |
| c_num = a[keys[i]] |
| if c_num >= k: |
| ans = 0 |
| break |
| if i > 0: |
| l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1] |
| l_num = l_cnt[i - 1] |
| else: |
| l_res = 10 ** 30 |
| l_num = 0 |
| if i < m - 1: |
| r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1] |
| r_num = r_cnt[i + 1] |
| else: |
| r_res = 10 ** 30 |
| r_num = 0 |
| if c_num + l_num < k and c_num + r_num < k: |
| ans = min(ans, l_res + r_res + k - c_num) |
| elif c_num + l_num < k: |
| ans = min(ans, r_res + k - c_num) |
| elif c_num + r_num < k: |
| ans = min(ans, l_res + k - c_num) |
| else: |
| ans = min(ans, min(r_res, l_res) + k - c_num) |
| print(ans) |
| ``` |
|
|
| ### 042 |
|
|
| ```python |
| n = int(input()) |
| a = list(map(int, input().split())) |
| b = list(map(int, input().split())) |
| curl_ud_weights = [0] * n |
| curl_du_weights = [0] * n |
| sums = [0] * n |
| sums[n - 1] = a[n - 1] + b[n - 1] |
| curl_ud_weights[n - 1] = b[n - 1] |
| curl_du_weights[n - 1] = a[n - 1] |
| for i in range(n - 2, -1, -1): |
| sums[i] = sums[i + 1] + (a[i] + b[i]) |
| remain = n * 2 - i * 2 - 1 |
| curl_ud_weights[i] = sums[i + 1] + curl_ud_weights[i + 1] + remain * b[i] |
| curl_du_weights[i + 1] = sums[i + 1] + curl_du_weights[i + 1] + remain * a[i] |
| snake_weight = 0 |
| max_weight = 0 |
| current_weight = -1 |
| for t in range(0, 2 * n, 2): |
| remain = t % 4 |
| if remain == 0: |
| current_weight = sums[t // 2] * t + curl_ud_weights[t // 2] + snake_weight |
| snake_weight += a[t // 2] * t + b[t // 2] * (t + 1) |
| elif remain == 2: |
| current_weight = sums[t // 2] * t + curl_du_weights[t // 2] + snake_weight |
| snake_weight += b[t // 2] * t + a[t // 2] * (t + 1) |
| if current_weight > max_weight: |
| max_weight = current_weight |
| print(max_weight) |
| '\n3\n0 1 0\n0 0 0\n' |
| ``` |
|
|
| ### 043 |
|
|
| ```python |
| from collections import Counter |
| import sys |
| from itertools import accumulate |
| |
| def go(): |
| n, k = list(map(int, input().split())) |
| a = sorted(map(int, input().split())) |
| c = Counter(a) |
| if max(c.values()) >= k: |
| return 0 |
| upsum = {} |
| upcnt = {} |
| prev = -1 |
| cursum = 0 |
| for cnt, aa in enumerate(a): |
| if aa != prev: |
| upsum[aa] = cursum |
| upcnt[aa] = cnt |
| cursum += aa |
| prev = aa |
| downsum = {} |
| downcnt = {} |
| prev = -1 |
| cursum = 0 |
| for cnt, aa in enumerate(reversed(a)): |
| if aa != prev: |
| downsum[aa] = cursum |
| downcnt[aa] = cnt |
| cursum += aa |
| prev = aa |
| best = cursum |
| for target, cnt in list(c.items()): |
| need = k - cnt |
| if upcnt[target] >= need: |
| best = min(best, (target - 1) * upcnt[target] - upsum[target] + need) |
| if downcnt[target] >= need: |
| best = min(best, downsum[target] - (target + -1) * downcnt[target] + need) |
| best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need) |
| return best |
| t = 1 |
| for _ in range(t): |
| print(go()) |
| ``` |
|
|
| ### 044 |
|
|
| ```python |
| def __starting_point(): |
| n = int(input()) |
| supporters = {} |
| supporters[0] = [] |
| supporters[1] = [] |
| supporters[10] = [] |
| supporters[11] = [] |
| for i in range(n): |
| [x, y] = [int(x) for x in input().split()] |
| supporters[x].append(y) |
| for x in supporters: |
| supporters[x].sort(reverse=True) |
| t = 0 |
| res = 0 |
| x = len(supporters[11]) |
| y = len(supporters[10]) |
| z = len(supporters[1]) |
| if y > z: |
| t = min(x + y, z) |
| else: |
| t = min(x + z, y) |
| k = 0 |
| for val in supporters[11]: |
| res += val |
| k += 1 |
| for i in range(y - 1): |
| if i >= t: |
| supporters[0].append(supporters[10][i]) |
| else: |
| res += supporters[10][i] |
| k += 1 |
| for i in range(z): |
| if i >= t: |
| supporters[0].append(supporters[1][i]) |
| else: |
| res += supporters[1][i] |
| k += 1 |
| supporters[0].sort(reverse=True) |
| t = min(x + y, x + z) |
| i = 0 |
| while 2 * t > k and i < len(supporters[0]): |
| k += 1 |
| res += supporters[0][i] |
| i += 1 |
| print(res) |
| __starting_point() |
| ``` |
|
|
| ### 045 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 046 |
|
|
| ```python |
| n = int(input()) |
| a = [list(map(int, input().split())) for i in range(2)] |
| if n != 1: |
| sum_up, pref_up, sum_down, pref_down = [[[0 for i in range(n)] for j in range(2)] for _ in range(4)] |
| for i in range(2): |
| sum_up[i][n - 1 - 1] = a[i][n - 1] |
| pref_up[i][n - 1] = a[i][n - 1] |
| pref_down[i][n - 1] = a[i][n - 1] |
| for j in range(n - 2, -1, -1): |
| sum_up[i][j] = sum_up[i][j + 1] + a[i][j] |
| pref_up[i][j] = pref_up[i][j + 1] + sum_up[i][j] |
| pref_down[i][j] = pref_down[i][j + 1] + a[i][j] * (n - j) |
| zig = [[0 for i in range(n)] for j in range(2)] |
| for j in range(n): |
| for i in range(2): |
| if j % 2 == 0: |
| if i == 0: |
| zig[i][j] = a[i][j] * j * 2 + zig[i][j - 1] |
| else: |
| zig[i][j] = a[i][j] * (j * 2 + 1) + zig[1 - i][j] |
| elif i == 0: |
| zig[1 - i][j] = a[1 - i][j] * j * 2 + zig[1 - i][j - 1] |
| else: |
| zig[1 - i][j] = a[1 - i][j] * (j * 2 + 1) + zig[i][j] |
| ans = -1e+18 |
| for j in range(n): |
| if j == 0: |
| ans = max(ans, pref_up[0][j] + pref_down[1][j] + sum_up[1][j] * n - sum_up[0][j] - sum_up[1][j]) |
| elif j == n - 1: |
| ans = max(ans, zig[1 - j % 2][n - 1]) |
| elif j % 2 == 1: |
| ans = max(ans, pref_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2 + 1) - 1) + pref_down[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2 + 1) - 1 + n - j) + zig[0][j]) |
| else: |
| ans = max(ans, pref_up[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2) + 2) + pref_down[0][j + 1] - sum_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2) + 2 - 1 + n - j) + zig[1][j]) |
| ans = max(ans, pref_up[1][0] + pref_down[0][1] + sum_up[0][1] * n) |
| print(ans) |
| else: |
| print(a[1][0]) |
| ``` |
|
|
| ### 047 |
|
|
| ```python |
| from sys import stdin, stderr |
| import random |
| import cProfile |
| |
| def readInts(): |
| return map(int, stdin.readline().strip().split()) |
| |
| def print_err(*args, **kwargs): |
| print(*args, file=stderr, **kwargs) |
| |
| def solve(vs): |
| return None |
| |
| def generate_tree(n, ns): |
| out = [0 for _ in range(2 ** (n + 1))] |
| |
| def gt(nix, left, right, op): |
| if left + 1 == right: |
| out[nix] = ns[left] |
| return out[nix] |
| mid = (left + right) // 2 |
| nL = nix * 2 + 1 |
| nR = nix * 2 + 2 |
| vL = gt(nL, left, mid, not op) |
| vR = gt(nR, mid, right, not op) |
| if op: |
| v = vL ^ vR |
| else: |
| v = vL | vR |
| out[nix] = v |
| return v |
| gt(0, 0, 2 ** n, n % 2 == 0) |
| return out |
| |
| def alter_tree2(n, t, p, b): |
| |
| def at(nix, width, offp, op): |
| if width == 1: |
| t[nix] = b |
| return b |
| width //= 2 |
| nL = nix * 2 + 1 |
| nR = nix * 2 + 2 |
| vL = t[nL] |
| vR = t[nR] |
| if offp >= width: |
| vR = at(nR, width, offp - width, not op) |
| else: |
| vL = at(nL, width, offp, not op) |
| if op: |
| v = vL ^ vR |
| else: |
| v = vL | vR |
| t[nix] = v |
| return v |
| at(0, 2 ** n, p, n % 2 == 0) |
| |
| def alter_tree(n, t, p, b): |
| width = 2 ** n |
| s = [] |
| nix = 0 |
| op = n % 2 == 0 |
| while width > 1: |
| width //= 2 |
| if p >= width: |
| nix2 = 2 * nix + 2 |
| s.append((nix, nix2 - 1)) |
| p -= width |
| else: |
| nix2 = 2 * nix + 1 |
| s.append((nix, nix2 + 1)) |
| nix = nix2 |
| op = not op |
| t[nix] = b |
| v = b |
| while s: |
| nix, nixO = s.pop() |
| if op: |
| v |= t[nixO] |
| else: |
| v ^= t[nixO] |
| t[nix] = v |
| op = not op |
| return |
| |
| def run(): |
| n, m = readInts() |
| axs = list(readInts()) |
| t = generate_tree(n, axs) |
| for _ in range(m): |
| p, b = readInts() |
| alter_tree(n, t, p - 1, b) |
| print(t[0]) |
| |
| def test(): |
| n = 17 |
| ns = [] |
| vs100 = list(range(100)) |
| for _ in range(2 ** 17): |
| ns.append(random.choice(vs100)) |
| t = generate_tree(n, ns) |
| t2 = generate_tree(n, ns) |
| for _ in range(100000): |
| v1 = random.choice(vs100) |
| v2 = random.choice(vs100) |
| alter_tree(n, t, v1, v2) |
| alter_tree2(n, t2, v1, v2) |
| print(all(map(lambda x: x[0] == x[1], zip(t, t2)))) |
| print(t[0] == t2[0]) |
| run() |
| ``` |
|
|
| ### 048 |
|
|
| ```python |
| from sys import stdin |
| n = int(stdin.readline()) |
| x, y = map(int, stdin.readline().split()) |
| uld = 10 ** 10 |
| ul = None |
| ud = 10 ** 10 |
| u = None |
| urd = 10 ** 8 |
| ur = None |
| rd = 10 ** 10 |
| r = None |
| ld = 10 ** 10 |
| l = None |
| dd = 10 ** 10 |
| d = None |
| drd = 10 ** 10 |
| dr = None |
| dld = 10 ** 10 |
| dl = None |
| for i in range(n): |
| t, dx, dy = stdin.readline().split() |
| dx = int(dx) |
| dy = int(dy) |
| if dx == x: |
| if dy > y: |
| if ud > dy - y: |
| ud = dy - y |
| u = t |
| elif dd > y - dy: |
| dd = y - dy |
| d = t |
| if dy == y: |
| if dx > x: |
| if rd > dx - x: |
| rd = dx - x |
| r = t |
| elif ld > x - dx: |
| ld = x - dx |
| l = t |
| if dx - x == dy - y: |
| if dy > y: |
| if urd > dy - y: |
| urd = dy - y |
| ur = t |
| elif dld > y - dy: |
| dld = y - dy |
| dl = t |
| if -(dx - x) == dy - y: |
| if dy > y: |
| if uld > dy - y: |
| uld = dy - y |
| ul = t |
| elif drd > y - dy: |
| drd = y - dy |
| dr = t |
| if 'B' in (ul, ur, dl, dr) or 'R' in (u, d, l, r) or 'Q' in (ul, ur, dl, dr, u, d, l, r): |
| print('YES') |
| else: |
| print('NO') |
| ``` |
|
|
| ### 049 |
|
|
| ```python |
| n = int(input()) |
| temp = input().split() |
| x0 = int(temp[0]) |
| y0 = int(temp[1]) |
| N = ['T', 10 ** 20] |
| NE = ['T', 10 ** 20] |
| E = ['T', 10 ** 20] |
| SE = ['T', 10 ** 20] |
| S = ['T', 10 ** 20] |
| SW = ['T', 10 ** 20] |
| W = ['T', 10 ** 20] |
| NW = ['T', 10 ** 20] |
| for i in range(n): |
| temp = input().split() |
| x = int(temp[1]) |
| y = int(temp[2]) |
| if y - y0 > 0 and y - y0 < N[1]: |
| N = [temp[0], y - y0] |
| elif x - x0 == y - y0 and x - x0 > 0 and (x - x0 < NE[1]): |
| NE = [temp[0], x - x0] |
| elif y - y0 == 0 and x - x0 > 0 and (x - x0 < E[1]): |
| E = [temp[0], x - x0] |
| elif x - x0 == -(y - y0) and x - x0 > 0 and (x - x0 < SE[1]): |
| SE = [temp[0], x - x0] |
| elif x - x0 == 0 and y - y0 < 0 and (y0 - y < S[1]): |
| S = [temp[0], y0 - y] |
| elif x - x0 == y - y0 and x - x0 < 0 and (x0 - x < SW[1]): |
| SW = [temp[0], x0 - x] |
| elif y - y0 == 0 and x - x0 < 0 and (x0 - x < W[1]): |
| W = [temp[0], x0 - x] |
| elif x - x0 == -(y - y0) and x - x0 < 0 and (x0 - x < NW[1]): |
| NW = [temp[0], x0 - x] |
| if 'R' in [N[0], E[0], S[0], W[0]] or 'B' in [NE[0], SE[0], SW[0], NW[0]]: |
| print('YES') |
| elif 'Q' in [N[0], E[0], S[0], W[0], NE[0], SE[0], SW[0], NW[0]]: |
| print('YES') |
| else: |
| print('NO') |
| ``` |
|
|
| ### 050 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 051 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 052 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 053 |
|
|
| ```python |
| n, q, k = list(map(int, input().split(' '))) |
| a = list(map(int, input().split(' '))) |
| count = 0 |
| |
| def verify(x): |
| if x < 0 or x >= n: |
| return False |
| return a[x] > k |
| for i in range(n): |
| if verify(i): |
| count += 1 |
| if verify(i - 1): |
| count -= 1 |
| |
| def cut(i): |
| if not verify(i): |
| return 0 |
| result = 1 |
| if verify(i - 1): |
| result -= 1 |
| if verify(i + 1): |
| result -= 1 |
| return result |
| for i in range(q): |
| line = input() |
| if line == '0': |
| print(count) |
| else: |
| _, x, y = list(map(int, line.split(' '))) |
| x -= 1 |
| if not verify(x): |
| a[x] += y |
| count += cut(x) |
| else: |
| a[x] -= y |
| ``` |
|
|
| ### 054 |
|
|
| ```python |
| def adds(memtoproc, mem, proc): |
| if mem in memtoproc: |
| memtoproc[mem].append(proc) |
| else: |
| memtoproc[mem] = [proc] |
| |
| def corr(arr, n, m): |
| brokemems = set() |
| stopprocs = [0] * n |
| for c in range(m): |
| memtoproc = dict() |
| usemems = set() |
| locmems = set() |
| for d in range(n): |
| if not arr[d][c] or stopprocs[d]: |
| continue |
| adds(memtoproc, arr[d][c], d) |
| if arr[d][c] in usemems: |
| locmems.add(arr[d][c]) |
| usemems.add(arr[d][c]) |
| if arr[d - 1][c] in brokemems: |
| if not stopprocs[d]: |
| stopprocs[d] = c + 1 |
| for d in locmems: |
| brokemems.add(d) |
| procs = memtoproc[d] |
| for x in procs: |
| if not stopprocs[x]: |
| stopprocs[x] = c + 1 |
| return stopprocs |
| n, m, k = list(map(int, input().split(' '))) |
| arr = [] |
| for c in range(n): |
| arr.append(tuple(map(int, input().split(' ')))) |
| procs = corr(arr, n, m) |
| for c in procs: |
| print(c) |
| ``` |
|
|
| ### 055 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 056 |
|
|
| ```python |
| __author__ = 'Lipen' |
| |
| def main(): |
| n, m, k = map(int, input().split()) |
| data = [] |
| when = [0] * n |
| blockedcells = set() |
| blockedcores = set() |
| for _ in range(n): |
| data.append(list(map(int, input().split()))) |
| for j in range(m): |
| operation = [] |
| for _ in range(k): |
| operation.append([]) |
| for i in range(n): |
| if i not in blockedcores: |
| x = data[i][j] - 1 |
| if x >= 0: |
| if x in blockedcells: |
| blockedcores.add(i) |
| when[i] = j + 1 |
| elif len(operation[x]) > 0: |
| blockedcells.add(x) |
| for core in operation[x]: |
| blockedcores.add(core) |
| when[core] = j + 1 |
| blockedcores.add(i) |
| when[i] = j + 1 |
| operation[x - 1].append(i) |
| for i in when: |
| print(i) |
| main() |
| ``` |
|
|
| ### 057 |
|
|
| ```python |
| from sys import stdin |
| n = int(stdin.readline()) |
| x, y = map(int, stdin.readline().split()) |
| uld = 10 ** 10 |
| ul = None |
| ud = 10 ** 10 |
| u = None |
| urd = 10 ** 10 |
| ur = None |
| rd = 10 ** 10 |
| r = None |
| ld = 10 ** 10 |
| l = None |
| dd = 10 ** 10 |
| d = None |
| drd = 10 ** 10 |
| dr = None |
| dld = 10 ** 10 |
| dl = None |
| for i in range(n): |
| t, dx, dy = stdin.readline().split() |
| dx = int(dx) |
| dy = int(dy) |
| if dx == x: |
| if dy > y: |
| if ud > dy - y: |
| ud = dy - y |
| u = t |
| elif dd > y - dy: |
| dd = y - dy |
| d = t |
| if dy == y: |
| if dx > x: |
| if rd > dx - x: |
| rd = dx - x |
| r = t |
| elif not ld > x - dx: |
| ld = x - dx |
| l = t |
| if dx - x == dy - y: |
| if dy > y: |
| if urd > dy - y: |
| urd = dy - y |
| ur = t |
| elif dld > y - dy: |
| dld = y - dy |
| dl = t |
| if -(dx - x) == dy - y: |
| if dy > y: |
| if uld > dy - y: |
| uld = dy - y |
| ul = t |
| elif drd > y - dy: |
| drd = y - dy |
| dr = t |
| if 'B' in (ul, ur, dl, dr) or 'R' in (u, d, l, r) or 'Q' in (ul, ur, dl, dr, u, d, l, r): |
| print('YES') |
| else: |
| print('NO') |
| ``` |
|
|
| ### 058 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 059 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 060 |
|
|
| ```python |
| def main(): |
| n = int(input()) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| roundup = [] |
| rounddown = [] |
| sumsofar = [] |
| for i, (a, b) in enumerate(zip(reversed(A), reversed(B))): |
| ssf = sumsofar[-1] if sumsofar else 0 |
| t = roundup[-1] if roundup else 0 |
| roundup.append(t + ssf + b * (-1 + 2 * i)) |
| t = rounddown[-1] if rounddown else 0 |
| rounddown.append(t + ssf + a * (1 + 2 * i)) |
| sumsofar.append(ssf + a + b) |
| roundup = list(reversed(roundup)) |
| rounddown = list(reversed(rounddown)) |
| sumsofar = list(reversed(sumsofar)) |
| bestres = 0 |
| sofar = 0 |
| for i, (a, b) in enumerate(zip(A, B)): |
| rup, rdo = (roundup, rounddown) |
| if i % 2: |
| a, b = (b, a) |
| rup, rdo = (rdo, rup) |
| bestres = max(bestres, sofar + rup[i] + sumsofar[i] * 2 * i) |
| sofar += a * 2 * i |
| sofar += b * (2 * i + 1) |
| bestres = max(bestres, sofar) |
| print(bestres) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 061 |
|
|
| ```python |
| n = int(input()) |
| su0 = [] |
| su1 = [] |
| su00 = [] |
| su11 = [] |
| ans = 0 |
| for i in range(n): |
| sup, val = map(int, input().split()) |
| if sup == 4: |
| su00.append(val) |
| elif sup == 11: |
| su11.append(val) |
| elif sup == 1: |
| su0.append(val) |
| else: |
| su1.append(val) |
| su0.sort() |
| su1.sort() |
| su11.sort() |
| su00.sort() |
| while len(su1) != 0 and len(su0) != 0: |
| ans += su1[len(su1) - 1] + su0[len(su0) - 1] |
| su1.pop() |
| su0.pop() |
| while len(su11) != 0 and len(su00) != 0: |
| if len(su1) != 0: |
| k = 1 |
| elif len(su0) != 0: |
| k = 0 |
| else: |
| k = 2 |
| if k == 0: |
| if su00[len(su00) - 1] > su0[len(su0) - 1]: |
| ans += su11[len(su11) - 1] + su00[len(su00) - 1] |
| su11.pop() |
| su00.pop() |
| else: |
| ans += su11[len(su11) - 1] + su0[len(su0) - 1] |
| su11.pop() |
| su0.pop() |
| elif k == 1: |
| if su00[len(su00) - 1] > su1[len(su1) - 1]: |
| ans += su11[len(su11) - 1] + su00[len(su00) - 1] |
| su11.pop() |
| su00.pop() |
| else: |
| ans += su11[len(su11) - 1] + su1[len(su1) - 1] |
| su11.pop() |
| su1.pop() |
| else: |
| ans += su11[len(su11) - 1] + su00[len(su00) - 1] |
| su11.pop() |
| su00.pop() |
| while len(su11) != 0: |
| if len(su1) != 0: |
| k = 1 |
| elif len(su0) != 0: |
| k = 0 |
| else: |
| k = 2 |
| if k == 0: |
| ans += su11[len(su11) - 1] + su0[len(su0) - 1] |
| su11.pop() |
| su0.pop() |
| elif k == 1: |
| ans += su11[len(su11) - 1] + su1[len(su1) - 1] |
| su11.pop() |
| su1.pop() |
| else: |
| ans += su11[len(su11) - 1] |
| su11.pop() |
| print(ans) |
| ``` |
|
|
| ### 062 |
|
|
| ```python |
| from sys import stdin |
| from math import * |
| line = stdin.readline().rstrip().split() |
| n = int(line[0]) |
| numbers = list(map(int, stdin.readline().rstrip().split())) |
| numbers2 = list(map(int, stdin.readline().rstrip().split())) |
| growRateAccum = 0 |
| topAccum = 0 |
| bottomAccum = 0 |
| accumsB = [0] * n |
| accumsT = [0] * n |
| growRateAccum = 0 |
| accum = 0 |
| for i in reversed(range(n - 1, -1, -1)): |
| accum += numbers[i] * ((n - i) * 2 - 1 - 1) |
| growRateAccum += numbers[i] |
| if i < n - 1: |
| growRateAccum += numbers2[i + 1] |
| accum += growRateAccum |
| accumsB[i] = accum |
| growRateAccum = 0 |
| accum = 0 |
| for i in range(n - 1, -1, -1): |
| accum += numbers2[i] * ((n - i) * 2 - 1 - 1) |
| growRateAccum += numbers2[i] |
| if i < n - 1: |
| growRateAccum += numbers[i + 1] |
| accum += growRateAccum |
| accumsT[i] = accum |
| cMax = 0 |
| currAccum = 0 |
| growRateAccum = sum(numbers[1:]) + sum(numbers2[1:]) |
| for i in range(n): |
| if i % 2 == 0: |
| cMax = max(cMax, currAccum + accumsT[i]) |
| else: |
| cMax = max(cMax, currAccum + accumsB[i]) |
| if i < n - 1: |
| if i % 2 == 0: |
| currAccum += numbers2[i] + growRateAccum * 2 |
| else: |
| currAccum += numbers[i] + growRateAccum * 2 |
| growRateAccum -= numbers[i + 1] |
| growRateAccum -= numbers2[i + 1] |
| print(cMax) |
| ``` |
|
|
| ### 063 |
|
|
| ```python |
| from operator import or_, xor |
| import sys |
| n, m = map(int, input().split()) |
| t = [list(map(int, input().split()))] |
| for i in range(n): |
| if i & 1 == 0: |
| t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]] |
| else: |
| t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]] |
| for s in sys.stdin: |
| p, b = s.split() |
| p = int(p) - 1 |
| t[0][p] = int(b) |
| for j in range(n): |
| p = int(p / 2) |
| if j & 1 == 0: |
| t[j + 1][p] = t[j][int(p * 2)] | t[j][int(p * 2) + 1] |
| else: |
| t[j + 1][p] = t[j][int(p * 2) + 1] ^ t[j][int(p * 2) + 1] |
| sys.stdout.write(str(t[-1][0]) + '\n') |
| ``` |
|
|
| ### 064 |
|
|
| ```python |
| def main(): |
| n = int(input()) |
| x, y = list(map(int, input().split())) |
| a = [] |
| for i in range(n): |
| a.append(input().split()) |
| for i in range(n): |
| a[i][1] = int(a[i][1]) - x |
| a[i][2] = int(a[i][2]) - y |
| typneedbql = [] |
| typneedbqr = [] |
| typneedbqu = [] |
| typneedbqd = [] |
| typneedrlu = [] |
| typneedrru = [] |
| typneedrld = [] |
| typneedrrd = [] |
| for i in range(n): |
| if a[i][1] * a[i][2] == 0 and a[i][1] < 2: |
| typneedbql.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif a[i][1] * a[i][2] == 0 and a[i][1] > 0: |
| typneedbqr.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif a[i][1] * a[i][2] == 0 and a[i][2] > 0: |
| typneedbqu.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif a[i][1] * a[i][2] == 0 and a[i][2] < 0: |
| typneedbqd.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] < 0): |
| typneedrlu.append([abs(a[i][1])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] > 0): |
| typneedrld.append([abs(a[i][1])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] > 0): |
| typneedrrd.append([abs(a[i][1])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] < 0): |
| typneedrru.append([abs(a[i][1])] + a[i]) |
| typneedbql.sort() |
| typneedbqr.sort() |
| typneedbqd.sort() |
| typneedbqu.sort() |
| typneedrlu.sort() |
| typneedrru.sort() |
| typneedrld.sort() |
| typneedrrd.sort() |
| for i in range(len(typneedbql)): |
| if typneedbql[i][1] == 'R' or typneedbql[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedbqr)): |
| if typneedbqr[i][1] == 'R' or typneedbqr[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedbqu)): |
| if typneedbqu[i][1] == 'R' or typneedbqu[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedbqd)): |
| if typneedbqd[i][1] == 'R' or typneedbqd[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrlu)): |
| if typneedrlu[i][1] == 'B' or typneedrlu[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrld)): |
| if typneedrld[i][1] == 'B' or typneedrld[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrrd)): |
| if typneedrrd[i][1] == 'B' or typneedrrd[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrru)): |
| if typneedrru[i][1] == 'B' or typneedrru[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| print('NO') |
| main() |
| ``` |
|
|
| ### 065 |
|
|
| ```python |
| n = int(input()) |
| a = [list(map(int, input().split())) for i in range(2)] |
| if n != 1: |
| sum_up, pref_up, sum_down, pref_down = [[[0 for i in range(n)] for j in range(2)] for _ in range(4)] |
| for i in range(2): |
| sum_up[i][n - 1] = a[i][n - 1] |
| pref_up[i][n - 1] = a[i][n - 1] |
| pref_down[i][n - 1] = a[i][n - 1 - 1] |
| for j in range(n - 2, -1, -1): |
| sum_up[i][j] = sum_up[i][j + 1] + a[i][j] |
| pref_up[i][j] = pref_up[i][j + 1] + sum_up[i][j] |
| pref_down[i][j] = pref_down[i][j + 1] + a[i][j] * (n - j) |
| zig = [[0 for i in range(n)] for j in range(2)] |
| for j in range(n): |
| for i in range(2): |
| if j % 2 == 0: |
| if i == 0: |
| zig[i][j] = a[i][j] * j * 2 + zig[i][j - 1] |
| else: |
| zig[i][j] = a[i][j] * (j * 2 + 1) + zig[1 - i][j] |
| elif i == 0: |
| zig[1 - i][j] = a[1 - i][j] * j * 2 + zig[1 - i][j - 1] |
| else: |
| zig[1 - i][j] = a[1 - i][j] * (j * 2 + 1) + zig[i][j] |
| ans = -1e+18 |
| for j in range(n): |
| if j == 0: |
| ans = max(ans, pref_up[0][j] + pref_down[1][j] + sum_up[1][j] * n - sum_up[0][j] - sum_up[1][j]) |
| elif j == n - 1: |
| ans = max(ans, zig[1 - j % 2][n - 1]) |
| elif j % 2 == 1: |
| ans = max(ans, pref_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2 + 1) - 1) + pref_down[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2 + 1) - 1 + n - j) + zig[0][j]) |
| else: |
| ans = max(ans, pref_up[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2) + 2) + pref_down[0][j + 1] - sum_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2) + 2 - 1 + n - j) + zig[1][j]) |
| ans = max(ans, pref_up[1][0] + pref_down[0][1] + sum_up[0][1] * n) |
| print(ans) |
| else: |
| print(a[1][0]) |
| ``` |
|
|
| ### 066 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 067 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 068 |
|
|
| ```python |
| from collections import defaultdict |
| import bisect |
| n = int(input()) |
| x0, y0 = list(map(int, input().split(' '))) |
| verticale = [] |
| horizontale = [] |
| diagonale1 = [] |
| diagonale2 = [] |
| for _ in range(n): |
| t, x, y = input().split(' ') |
| x, y = (int(x), int(y)) |
| if x == x0: |
| verticale.append((y, t)) |
| if y == y0: |
| horizontale.append((x, t)) |
| if x + y == x0 + y0: |
| diagonale1.append((x, t)) |
| if x - y == x0 - y0: |
| diagonale2.append((x, t)) |
| dead = False |
| v = sorted(verticale) |
| if v: |
| l = bisect.bisect(v, (y0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'R'}: |
| dead = True |
| elif v[len(v) - 1][1] in {'Q', 'R'}: |
| dead = True |
| v = sorted(horizontale) |
| if v: |
| l = bisect.bisect(v, (x0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'R'}: |
| dead = True |
| elif v[len(v) - 1][1] in {'Q', 'R'}: |
| dead = True |
| v = sorted(diagonale1) |
| if v: |
| l = bisect.bisect(v, (x0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'B'}: |
| dead = True |
| elif v[len(v) - 1][1] in {'Q', 'B'}: |
| dead = True |
| v = sorted(diagonale2) |
| if v: |
| l = bisect.bisect(v, (x0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'B'}: |
| dead = True |
| elif v[len(v) - 1][1] not in {'Q', 'B'}: |
| dead = True |
| if dead: |
| print('YES') |
| else: |
| print('NO') |
| ``` |
|
|
| ### 069 |
|
|
| ```python |
| from sys import stdin |
| from math import * |
| line = stdin.readline().rstrip().split() |
| n = int(line[0]) |
| numbers = list(map(int, stdin.readline().rstrip().split())) |
| numbers2 = list(map(int, stdin.readline().rstrip().split())) |
| growRateAccum = 0 |
| topAccum = 0 |
| bottomAccum = 0 |
| accumsB = [0] * n |
| accumsT = [0] * n |
| growRateAccum = 0 |
| accum = 0 |
| for i in range(n - 1, -1, -1): |
| accum += numbers[i] * ((n - i) * 2 - 1 - 1) |
| growRateAccum *= numbers[i] |
| if i < n - 1: |
| growRateAccum += numbers2[i + 1] |
| accum += growRateAccum |
| accumsB[i] = accum |
| growRateAccum = 0 |
| accum = 0 |
| for i in range(n - 1, -1, -1): |
| accum += numbers2[i] * ((n - i) * 2 - 1 - 1) |
| growRateAccum += numbers2[i] |
| if i < n - 1: |
| growRateAccum += numbers[i + 1] |
| accum += growRateAccum |
| accumsT[i] = accum |
| cMax = 0 |
| currAccum = 0 |
| growRateAccum = sum(numbers[1:]) + sum(numbers2[1:]) |
| for i in range(n): |
| if i % 2 == 0: |
| cMax = max(cMax, currAccum + accumsT[i]) |
| else: |
| cMax = max(cMax, currAccum + accumsB[i]) |
| if i < n - 1: |
| if i % 2 == 0: |
| currAccum += numbers2[i] + growRateAccum * 2 |
| else: |
| currAccum += numbers[i] + growRateAccum * 2 |
| growRateAccum -= numbers[i + 1] |
| growRateAccum -= numbers2[i + 1] |
| print(cMax) |
| ``` |
|
|
| ### 070 |
|
|
| ```python |
| n = int(input()) |
| temp = input().split() |
| x0 = int(temp[0]) |
| y0 = int(temp[0]) |
| N = ['T', 10 ** 20] |
| NE = ['T', 10 ** 20] |
| E = ['T', 10 ** 20] |
| SE = ['T', 10 ** 20] |
| S = ['T', 10 ** 20] |
| SW = ['T', 10 ** 20] |
| W = ['T', 10 ** 20] |
| NW = ['T', 10 ** 20] |
| for i in range(n): |
| temp = input().split() |
| x = int(temp[1]) |
| y = int(temp[2]) |
| if x - x0 == 0 and y - y0 > 0 and (y - y0 < N[1]): |
| N = [temp[0], y - y0] |
| elif x - x0 == y - y0 and x - x0 > 0 and (x - x0 < NE[1]): |
| NE = [temp[0], x - x0] |
| elif y - y0 == 0 and x - x0 > 0 and (x - x0 < E[1]): |
| E = [temp[0], x - x0] |
| elif x - x0 == -(y - y0) and x - x0 > 0 and (x - x0 < SE[1]): |
| SE = [temp[0], x - x0] |
| elif x - x0 == 0 and y - y0 < 0 and (y0 - y < S[1]): |
| S = [temp[0], y0 - y] |
| elif x - x0 == y - y0 and x - x0 < 0 and (x0 - x < SW[1]): |
| SW = [temp[0], x0 - x] |
| elif y - y0 == 0 and x - x0 < 0 and (x0 - x < W[1]): |
| W = [temp[0], x0 - x] |
| elif x - x0 == -(y - y0) and x - x0 < 0 and (x0 - x < NW[1]): |
| NW = [temp[0], x0 - x] |
| if 'R' in [N[0], E[0], S[0], W[0]] or 'B' in [NE[0], SE[0], SW[0], NW[0]]: |
| print('YES') |
| elif 'Q' in [N[0], E[0], S[0], W[0], NE[0], SE[0], SW[0], NW[0]]: |
| print('YES') |
| else: |
| print('NO') |
| ``` |
|
|
| ### 071 |
|
|
| ```python |
| n, k = list(map(int, input().split())) |
| a = sorted(list(map(int, input().split()))) |
| sums, suf, q1 = ([0] * n, [n] * n, n) |
| for q in range(n - 2, -1, -1): |
| sums[q] = sums[q + 1] |
| if a[q] != a[q1 - 1 - 1]: |
| sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1) |
| q1 = q + 1 |
| suf[q] = q1 |
| ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1) |
| for q in range(1, n): |
| if a[q] != a[q1 + 1]: |
| sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1) |
| q1 = q - 1 |
| if suf[q] - q1 - 1 >= k: |
| ans = 0 |
| break |
| if k <= suf[q]: |
| ans = min(ans, sum1 + k - suf[q] + q1 + 1) |
| if k < n - q1: |
| ans = min(ans, sums[q] + k - suf[q] + q1 + 1) |
| ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1) |
| print(ans) |
| ``` |
|
|
| ### 072 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 073 |
|
|
| ```python |
| from collections import Counter |
| import sys |
| from itertools import accumulate |
| |
| def go(): |
| n, k = list(map(int, input().split())) |
| a = sorted(map(int, input().split())) |
| c = Counter(a) |
| if max(c.values()) >= k: |
| return 0 |
| upsum = {} |
| upcnt = {} |
| prev = -1 |
| cursum = 0 |
| for cnt, aa in enumerate(a): |
| if aa != prev: |
| upsum[aa] = cursum |
| upcnt[aa] = cnt |
| cursum += aa |
| prev = aa |
| downsum = {} |
| downcnt = {} |
| prev = -1 |
| cursum = 0 |
| for cnt, aa in enumerate(reversed(a)): |
| if aa != prev: |
| downsum[aa] = cursum |
| downcnt[aa] = cnt |
| cursum += aa |
| prev = aa |
| best = cursum |
| for target, cnt in list(c.items()): |
| need = k - cnt |
| if upcnt[target] >= need: |
| best = min(best, (target - 1) * upcnt[target] - upsum[target] + need) |
| if downcnt[target] >= need: |
| best = min(best, downsum[target] - (target + 1) * downcnt[target] + need) |
| best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + -1) * downcnt[target] + need) |
| return best |
| t = 1 |
| for _ in range(t): |
| print(go()) |
| ``` |
|
|
| ### 074 |
|
|
| ```python |
| from collections import defaultdict |
| import bisect |
| n = int(input()) |
| x0, y0 = list(map(int, input().split(' '))) |
| verticale = [] |
| horizontale = [] |
| diagonale1 = [] |
| diagonale2 = [] |
| for _ in range(n): |
| t, x, y = input().split(' ') |
| x, y = (int(x), int(y)) |
| if x == x0: |
| verticale.append((y, t)) |
| if y == y0: |
| horizontale.append((x, t)) |
| if x + y == x0 + y0: |
| diagonale1.append((x, t)) |
| if x - y == x0 - y0: |
| diagonale2.append((x, t)) |
| dead = False |
| v = sorted(verticale) |
| if v: |
| l = bisect.bisect(v, (y0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'R'}: |
| dead = True |
| elif v[len(v) - 1][1] in {'Q', 'R'}: |
| dead = True |
| v = sorted(horizontale) |
| if v: |
| l = bisect.bisect(v, (x0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'R'}: |
| dead = True |
| elif v[len(v) - 1][1] in {'Q', 'R'}: |
| dead = True |
| v = sorted(diagonale1) |
| if v: |
| l = bisect.bisect(v, (x0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'B'}: |
| dead = True |
| elif v[len(v) - 1][1] in {'Q', 'B'}: |
| dead = True |
| v = sorted(diagonale2) |
| if v: |
| l = bisect.bisect(v, (x0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] not in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'B'}: |
| dead = True |
| elif v[len(v) - 1][1] in {'Q', 'B'}: |
| dead = True |
| if dead: |
| print('YES') |
| else: |
| print('NO') |
| ``` |
|
|
| ### 075 |
|
|
| ```python |
| n, m, l = list(map(int, input().split())) |
| l += 1 |
| hair = [1] * (n + 1) |
| other_end = [1] * (n + 1) |
| i = 1 |
| j = 1 |
| big = 1 |
| res = 1 |
| for a in map(int, input().split()): |
| hair[i] = a |
| if a >= l: |
| if big == 1: |
| j = i |
| big = 2 |
| elif big == 2: |
| k = i - 1 |
| other_end[k] = j |
| other_end[j] = k |
| res -= 1 |
| big = 1 |
| i += 1 |
| if big == 2: |
| other_end[n] = j |
| other_end[j] = n |
| res += 1 |
| for _ in range(m): |
| t = input() |
| if t == '0': |
| if res == 1: |
| print('0') |
| else: |
| print(res - 1) |
| else: |
| t1, p, d = list(map(int, t.split())) |
| old = hair[p] |
| hair[p] += d |
| if hair[p] >= l > old: |
| if p == 1 or hair[p - 1] < l: |
| case_id = 1 |
| else: |
| case_id = 2 |
| if p != n and hair[p + 1] >= l: |
| case_id += 2 |
| if case_id == 1: |
| other_end[p] = p |
| res += 1 |
| elif case_id == 2: |
| other_end[p] = other_end[p - 1] |
| other_end[other_end[p]] = p |
| elif case_id == 3: |
| other_end[p] = other_end[p + 1] |
| other_end[other_end[p]] = p |
| else: |
| left_end = other_end[p - 1] |
| right_end = other_end[p + 1] |
| other_end[left_end] = right_end |
| other_end[right_end] = left_end |
| res -= 1 |
| ``` |
|
|
| ### 076 |
|
|
| ```python |
| from sys import stdin, stderr |
| import random |
| import cProfile |
| |
| def readInts(): |
| return map(int, stdin.readline().strip().split()) |
| |
| def print_err(*args, **kwargs): |
| print(*args, file=stderr, **kwargs) |
| |
| def solve(vs): |
| return None |
| |
| def generate_tree(n, ns): |
| out = [0 for _ in range(2 ** (n + 1))] |
| |
| def gt(nix, left, right, op): |
| if left + 1 == right: |
| out[nix] = ns[left] |
| return out[nix] |
| mid = (left + right) // 2 |
| nL = nix * 2 + 1 |
| nR = nix * 2 - 2 |
| vL = gt(nL, left, mid, not op) |
| vR = gt(nR, mid, right, not op) |
| if op: |
| v = vL ^ vR |
| else: |
| v = vL | vR |
| out[nix] = v |
| return v |
| gt(0, 0, 2 ** n, n % 2 == 0) |
| return out |
| |
| def alter_tree2(n, t, p, b): |
| |
| def at(nix, width, offp, op): |
| if width == 1: |
| t[nix] = b |
| return b |
| width //= 2 |
| nL = nix * 2 + 1 |
| nR = nix * 2 + 2 |
| vL = t[nL] |
| vR = t[nR] |
| if offp >= width: |
| vR = at(nR, width, offp - width, not op) |
| else: |
| vL = at(nL, width, offp, not op) |
| if op: |
| v = vL ^ vR |
| else: |
| v = vL | vR |
| t[nix] = v |
| return v |
| at(0, 2 ** n, p, n % 2 == 0) |
| |
| def alter_tree(n, t, p, b): |
| width = 2 ** n |
| s = [] |
| nix = 0 |
| op = n % 2 == 0 |
| while width > 1: |
| width //= 2 |
| if p >= width: |
| nix2 = 2 * nix + 2 |
| s.append((nix, nix2 - 1)) |
| p -= width |
| else: |
| nix2 = 2 * nix + 1 |
| s.append((nix, nix2 + 1)) |
| nix = nix2 |
| op = not op |
| t[nix] = b |
| v = b |
| while s: |
| nix, nixO = s.pop() |
| if op: |
| v |= t[nixO] |
| else: |
| v ^= t[nixO] |
| t[nix] = v |
| op = not op |
| return |
| |
| def run(): |
| n, m = readInts() |
| axs = list(readInts()) |
| t = generate_tree(n, axs) |
| for _ in range(m): |
| p, b = readInts() |
| alter_tree(n, t, p - 1, b) |
| print(t[0]) |
| |
| def test(): |
| n = 17 |
| ns = [] |
| vs100 = list(range(100)) |
| for _ in range(2 ** 17): |
| ns.append(random.choice(vs100)) |
| t = generate_tree(n, ns) |
| t2 = generate_tree(n, ns) |
| for _ in range(100000): |
| v1 = random.choice(vs100) |
| v2 = random.choice(vs100) |
| alter_tree(n, t, v1, v2) |
| alter_tree2(n, t2, v1, v2) |
| print(all(map(lambda x: x[0] == x[1], zip(t, t2)))) |
| print(t[0] == t2[0]) |
| run() |
| ``` |
|
|
| ### 077 |
|
|
| ```python |
| from operator import or_, xor |
| import sys |
| n, m = map(int, input().split()) |
| t = [list(map(int, input().split()))] |
| for i in range(n): |
| if i & 1 == 0: |
| t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]] |
| else: |
| t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]] |
| for s in sys.stdin: |
| p, b = s.split() |
| p = int(p) - 1 |
| t[0][p] = int(b) |
| for j in range(n): |
| p = int(p / 2) |
| if j & 1 == 0: |
| t[j + 1][p] = t[j][int(p * 2)] | t[j][int(p * 2) + 1] |
| else: |
| t[j + 1][p] = t[j][int(p * 2)] ^ t[j - 1][int(p * 2) + 1] |
| sys.stdout.write(str(t[-1][0]) + '\n') |
| ``` |
|
|
| ### 078 |
|
|
| ```python |
| n, m, l = list(map(int, input().split())) |
| l += 1 |
| hair = [1] * (n + 1) |
| other_end = [1] * (n + 1) |
| i = 1 |
| j = 1 |
| big = 1 |
| res = 1 |
| for a in map(int, input().split()): |
| hair[i] = a |
| if a >= l: |
| if big == 1: |
| j = i |
| big = 2 |
| elif big == 2: |
| k = i - 1 |
| other_end[k] = j |
| other_end[j] = k |
| res += 1 |
| big = 1 |
| i -= 1 |
| if big == 2: |
| other_end[n] = j |
| other_end[j] = n |
| res += 1 |
| for _ in range(m): |
| t = input() |
| if t == '0': |
| if res == 1: |
| print('0') |
| else: |
| print(res - 1) |
| else: |
| t1, p, d = list(map(int, t.split())) |
| old = hair[p] |
| hair[p] += d |
| if hair[p] >= l > old: |
| if p == 1 or hair[p - 1] < l: |
| case_id = 1 |
| else: |
| case_id = 2 |
| if p != n and hair[p + 1] >= l: |
| case_id += 2 |
| if case_id == 1: |
| other_end[p] = p |
| res += 1 |
| elif case_id == 2: |
| other_end[p] = other_end[p - 1] |
| other_end[other_end[p]] = p |
| elif case_id == 3: |
| other_end[p] = other_end[p + 1] |
| other_end[other_end[p]] = p |
| else: |
| left_end = other_end[p - 1] |
| right_end = other_end[p + 1] |
| other_end[left_end] = right_end |
| other_end[right_end] = left_end |
| res -= 1 |
| ``` |
|
|
| ### 079 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 080 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 081 |
|
|
| ```python |
| from collections import Counter |
| import sys |
| from itertools import accumulate |
| |
| def go(): |
| n, k = list(map(int, input().split())) |
| a = sorted(map(int, input().split())) |
| c = Counter(a) |
| if max(c.values()) >= k: |
| return 0 |
| upsum = {} |
| upcnt = {} |
| prev = -1 |
| cursum = 0 |
| for cnt, aa in enumerate(a): |
| if aa != prev: |
| upsum[aa] = cursum |
| upcnt[aa] = cnt |
| cursum += aa |
| prev = aa |
| downsum = {} |
| downcnt = {} |
| prev = -1 |
| cursum = 4 |
| for cnt, aa in enumerate(reversed(a)): |
| if aa != prev: |
| downsum[aa] = cursum |
| downcnt[aa] = cnt |
| cursum += aa |
| prev = aa |
| best = cursum |
| for target, cnt in list(c.items()): |
| need = k - cnt |
| if upcnt[target] >= need: |
| best = min(best, (target - 1) * upcnt[target] - upsum[target] + need) |
| if downcnt[target] >= need: |
| best = min(best, downsum[target] - (target + 1) * downcnt[target] + need) |
| best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need) |
| return best |
| t = 1 |
| for _ in range(t): |
| print(go()) |
| ``` |
|
|
| ### 082 |
|
|
| ```python |
| def dfs(v, g, vis): |
| count = -3 |
| 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 - 1) |
| vis = [False] * v |
| ans = 0 |
| for i in range(v): |
| if not vis[i]: |
| ans += dfs(i, g, vis) |
| print(ans) |
| ``` |
|
|
| ### 083 |
|
|
| ```python |
| from collections import defaultdict |
| import bisect |
| n = int(input()) |
| x0, y0 = list(map(int, input().split(' '))) |
| verticale = [] |
| horizontale = [] |
| diagonale1 = [] |
| diagonale2 = [] |
| for _ in range(n): |
| t, x, y = input().split(' ') |
| x, y = (int(x), int(y)) |
| if x == x0: |
| verticale.append((y, t)) |
| if y == y0: |
| horizontale.append((x, t)) |
| if x + y == x0 + y0: |
| diagonale1.append((x, t)) |
| if x - y == x0 - y0: |
| diagonale2.append((x, t)) |
| dead = False |
| v = sorted(verticale) |
| if v: |
| l = bisect.bisect(v, (y0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'R'}: |
| dead = True |
| elif v[len(v) - 1][1] in {'Q', 'R'}: |
| dead = True |
| v = sorted(horizontale) |
| if v: |
| l = bisect.bisect(v, (x0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'R'}: |
| dead = True |
| elif v[len(v) - 1][1] not in {'Q', 'R'}: |
| dead = True |
| v = sorted(diagonale1) |
| if v: |
| l = bisect.bisect(v, (x0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'B'}: |
| dead = True |
| elif v[len(v) - 1][1] in {'Q', 'B'}: |
| dead = True |
| v = sorted(diagonale2) |
| if v: |
| l = bisect.bisect(v, (x0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'B'}: |
| dead = True |
| elif v[len(v) - 1][1] in {'Q', 'B'}: |
| dead = True |
| if dead: |
| print('YES') |
| else: |
| print('NO') |
| ``` |
|
|
| ### 084 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 085 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 086 |
|
|
| ```python |
| n = int(input()) |
| a = list(map(int, input().split())) |
| b = list(map(int, input().split())) |
| curl_ud_weights = [0] * n |
| curl_du_weights = [0] * n |
| sums = [0] * n |
| sums[n - 1] = a[n - 1] + b[n - 1] |
| curl_ud_weights[n - 1] = b[n - 1] |
| curl_du_weights[n - 1] = a[n - 1] |
| for i in range(n - 2, -1, -1): |
| sums[i] = sums[i + 1] + (a[i] + b[i]) |
| remain = n * 2 - i * 2 - 1 |
| curl_ud_weights[i] = sums[i + 1] + curl_ud_weights[i + 1] + remain * b[i] |
| curl_du_weights[i - 1] = sums[i + 1] + curl_du_weights[i + 1] + remain * a[i] |
| snake_weight = 0 |
| max_weight = 0 |
| current_weight = -1 |
| for t in range(0, 2 * n, 2): |
| remain = t % 4 |
| if remain == 0: |
| current_weight = sums[t // 2] * t + curl_ud_weights[t // 2] + snake_weight |
| snake_weight += a[t // 2] * t + b[t // 2] * (t + 1) |
| elif remain == 2: |
| current_weight = sums[t // 2] * t + curl_du_weights[t // 2] + snake_weight |
| snake_weight += b[t // 2] * t + a[t // 2] * (t + 1) |
| if current_weight > max_weight: |
| max_weight = current_weight |
| print(max_weight) |
| '\n3\n0 1 0\n0 0 0\n' |
| ``` |
|
|
| ### 087 |
|
|
| ```python |
| from collections import defaultdict, deque |
| from heapq import heappush, heappop |
| from itertools import permutations, accumulate |
| import sys |
| import math |
| import bisect |
| |
| def LI(): |
| return [int(x) for x in sys.stdin.readline().split()] |
| |
| def I(): |
| return int(sys.stdin.readline()) |
| |
| def LS(): |
| return [list(x) for x in sys.stdin.readline().split()] |
| |
| def S(): |
| res = list(sys.stdin.readline()) |
| if res[-1] == '\n': |
| return res[:-1] |
| return res |
| |
| def IR(n): |
| return [I() for i in range(n)] |
| |
| def LIR(n): |
| return [LI() for i in range(n)] |
| |
| def SR(n): |
| return [S() for i in range(n)] |
| |
| def LSR(n): |
| return [LS() for i in range(n)] |
| sys.setrecursionlimit(1000000) |
| mod = 1000000007 |
| |
| def solve(): |
| n, k = LI() |
| a = LI() |
| a.sort() |
| d = defaultdict(lambda: 0) |
| c = defaultdict(lambda: 0) |
| s = [0] |
| for i in a: |
| d[i] += i |
| c[i] += 1 |
| s.append(s[-1] + i) |
| ans = float('inf') |
| p = -1 |
| for i in a: |
| if i == p: |
| continue |
| if k <= c[i]: |
| ans = 0 |
| break |
| l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i)) |
| m = r |
| if m >= k: |
| ns = l * (i - 1) - s[l] |
| su = ns + k - c[i] |
| if su < ans: |
| ans = su |
| m = n - l |
| if m >= k: |
| ns = s[n] - s[r] - (n - r) * (i + 1) |
| su = ns + k - c[i] |
| if su < ans: |
| ans = su |
| ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l] |
| su = ns - k - c[i] |
| if su < ans: |
| ans = su |
| p = i |
| print(ans) |
| return |
| |
| def __starting_point(): |
| solve() |
| __starting_point() |
| ``` |
|
|
| ### 088 |
|
|
| ```python |
| def adds(memtoproc, mem, proc): |
| if mem in memtoproc: |
| memtoproc[mem].append(proc) |
| else: |
| memtoproc[mem] = [proc] |
| |
| def corr(arr, n, m): |
| brokemems = set() |
| stopprocs = [0] * n |
| for c in range(m): |
| memtoproc = dict() |
| usemems = set() |
| locmems = set() |
| for d in range(n): |
| if not arr[d][c] or stopprocs[d]: |
| continue |
| adds(memtoproc, arr[d][c], d) |
| if arr[d][c] in usemems: |
| locmems.add(arr[d][c]) |
| usemems.add(arr[d][c]) |
| if arr[d][c] in brokemems: |
| if not stopprocs[d]: |
| stopprocs[d] = c * 1 |
| for d in locmems: |
| brokemems.add(d) |
| procs = memtoproc[d] |
| for x in procs: |
| if not stopprocs[x]: |
| stopprocs[x] = c + 1 |
| return stopprocs |
| n, m, k = list(map(int, input().split(' '))) |
| arr = [] |
| for c in range(n): |
| arr.append(tuple(map(int, input().split(' ')))) |
| procs = corr(arr, n, m) |
| for c in procs: |
| print(c) |
| ``` |
|
|
| ### 089 |
|
|
| ```python |
| n = int(input()) |
| a = list(map(int, input().split())) |
| b = list(map(int, input().split())) |
| curl_ud_weights = [0] * n |
| curl_du_weights = [0] * n |
| sums = [0] * n |
| sums[n - 1] = a[n - 1] + b[n - 1] |
| curl_ud_weights[n - 1] = b[n - 1] |
| curl_du_weights[n - 1] = a[n - 1] |
| for i in range(n - 2, -1, -1): |
| sums[i] = sums[i + 1] + (a[i] + b[i]) |
| remain = n * 2 - i * 2 - 1 |
| curl_ud_weights[i + 1] = sums[i + 1] + curl_ud_weights[i + 1] + remain * b[i] |
| curl_du_weights[i] = sums[i + 1] + curl_du_weights[i + 1] + remain * a[i] |
| snake_weight = 0 |
| max_weight = 0 |
| current_weight = -1 |
| for t in range(0, 2 * n, 2): |
| remain = t % 4 |
| if remain == 0: |
| current_weight = sums[t // 2] * t + curl_ud_weights[t // 2] + snake_weight |
| snake_weight += a[t // 2] * t + b[t // 2] * (t + 1) |
| elif remain == 2: |
| current_weight = sums[t // 2] * t + curl_du_weights[t // 2] + snake_weight |
| snake_weight += b[t // 2] * t + a[t // 2] * (t + 1) |
| if current_weight > max_weight: |
| max_weight = current_weight |
| print(max_weight) |
| '\n3\n0 1 0\n0 0 0\n' |
| ``` |
|
|
| ### 090 |
|
|
| ```python |
| def main(): |
| n = int(input()) |
| x, y = list(map(int, input().split())) |
| a = [] |
| for i in range(n): |
| a.append(input().split()) |
| for i in range(n): |
| a[i][1] = int(a[i][1]) - x |
| a[i][2] = int(a[i][2]) - y |
| typneedbql = [] |
| typneedbqr = [] |
| typneedbqu = [] |
| typneedbqd = [] |
| typneedrlu = [] |
| typneedrru = [] |
| typneedrld = [] |
| typneedrrd = [] |
| for i in range(n): |
| if a[i][1] * a[i][2] == 0 and a[i][1] < 0: |
| typneedbql.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif a[i][1] * a[i][2] == 0 and a[i][1] > 0: |
| typneedbqr.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif a[i][1] * a[i][2] == 0 and a[i][2] > 0: |
| typneedbqu.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif a[i][1] * a[i][2] == 0 and a[i][2] < 0: |
| typneedbqd.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] < 0): |
| typneedrlu.append([abs(a[i][1])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] > 0): |
| typneedrld.append([abs(a[i][1])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] > 0): |
| typneedrrd.append([abs(a[i][1])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] < 0): |
| typneedrru.append([abs(a[i][1])] + a[i]) |
| typneedbql.sort() |
| typneedbqr.sort() |
| typneedbqd.sort() |
| typneedbqu.sort() |
| typneedrlu.sort() |
| typneedrru.sort() |
| typneedrld.sort() |
| typneedrrd.sort() |
| for i in range(len(typneedbql)): |
| if typneedbql[i][1] == 'R' or typneedbql[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedbqr)): |
| if typneedbqr[i][1] == 'R' or typneedbqr[i][1] != 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedbqu)): |
| if typneedbqu[i][1] == 'R' or typneedbqu[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedbqd)): |
| if typneedbqd[i][1] == 'R' or typneedbqd[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrlu)): |
| if typneedrlu[i][1] == 'B' or typneedrlu[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrld)): |
| if typneedrld[i][1] == 'B' or typneedrld[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrrd)): |
| if typneedrrd[i][1] == 'B' or typneedrrd[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrru)): |
| if typneedrru[i][1] == 'B' or typneedrru[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| print('NO') |
| main() |
| ``` |
|
|
| ### 091 |
|
|
| ```python |
| n = int(input()) |
| influences = [[], [], [], []] |
| for i in range(0, n): |
| [support, influence] = [x for x in input().split()] |
| support = int(support, 2) |
| influences[support].append(int(influence)) |
| for i in range(0, 4): |
| influences[i] = sorted(influences[i]) |
| influences[i].reverse() |
| total_influence = 0 |
| total_influence += sum(influences[3]) |
| min_size = min(len(influences[1]), len(influences[1])) |
| total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size]) |
| size = len(influences[3]) |
| influences[0] += influences[1][min_size:] + influences[2][min_size:] |
| influences[0] = sorted(influences[0]) |
| influences[0].reverse() |
| total_influence += sum(influences[0][:size]) |
| print(total_influence) |
| ``` |
|
|
| ### 092 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 093 |
|
|
| ```python |
| from sys import stdin, stderr |
| import random |
| import cProfile |
| |
| def readInts(): |
| return map(int, stdin.readline().strip().split()) |
| |
| def print_err(*args, **kwargs): |
| print(*args, file=stderr, **kwargs) |
| |
| def solve(vs): |
| return None |
| |
| def generate_tree(n, ns): |
| out = [0 for _ in range(2 ** (n + 1))] |
| |
| def gt(nix, left, right, op): |
| if left + 1 == right: |
| out[nix] = ns[left] |
| return out[nix] |
| mid = (left + right) // 2 |
| nL = nix * 2 + 1 |
| nR = nix * 2 + 2 |
| vL = gt(nL, left, mid, not op) |
| vR = gt(nR, mid, right, not op) |
| if not op: |
| v = vL ^ vR |
| else: |
| v = vL | vR |
| out[nix] = v |
| return v |
| gt(0, 0, 2 ** n, n % 2 == 0) |
| return out |
| |
| def alter_tree2(n, t, p, b): |
| |
| def at(nix, width, offp, op): |
| if width == 1: |
| t[nix] = b |
| return b |
| width //= 2 |
| nL = nix * 2 + 1 |
| nR = nix * 2 + 2 |
| vL = t[nL] |
| vR = t[nR] |
| if offp >= width: |
| vR = at(nR, width, offp - width, not op) |
| else: |
| vL = at(nL, width, offp, not op) |
| if op: |
| v = vL ^ vR |
| else: |
| v = vL | vR |
| t[nix] = v |
| return v |
| at(0, 2 ** n, p, n % 2 == 0) |
| |
| def alter_tree(n, t, p, b): |
| width = 2 ** n |
| s = [] |
| nix = 0 |
| op = n % 2 == 0 |
| while width > 1: |
| width //= 2 |
| if p >= width: |
| nix2 = 2 * nix + 2 |
| s.append((nix, nix2 - 1)) |
| p -= width |
| else: |
| nix2 = 2 * nix + 1 |
| s.append((nix, nix2 + 1)) |
| nix = nix2 |
| op = not op |
| t[nix] = b |
| v = b |
| while s: |
| nix, nixO = s.pop() |
| if op: |
| v |= t[nixO] |
| else: |
| v ^= t[nixO] |
| t[nix] = v |
| op = not op |
| return |
| |
| def run(): |
| n, m = readInts() |
| axs = list(readInts()) |
| t = generate_tree(n, axs) |
| for _ in range(m): |
| p, b = readInts() |
| alter_tree(n, t, p - 1, b) |
| print(t[0]) |
| |
| def test(): |
| n = 17 |
| ns = [] |
| vs100 = list(range(100)) |
| for _ in range(2 ** 17): |
| ns.append(random.choice(vs100)) |
| t = generate_tree(n, ns) |
| t2 = generate_tree(n, ns) |
| for _ in range(100000): |
| v1 = random.choice(vs100) |
| v2 = random.choice(vs100) |
| alter_tree(n, t, v1, v2) |
| alter_tree2(n, t2, v1, v2) |
| print(all(map(lambda x: x[0] == x[1], zip(t, t2)))) |
| print(t[0] == t2[0]) |
| run() |
| ``` |
|
|
| ### 094 |
|
|
| ```python |
| __author__ = 'Lipen' |
| |
| def main(): |
| n, m, k = map(int, input().split()) |
| data = [] |
| when = [0] * n |
| blockedcells = set() |
| blockedcores = set() |
| for _ in range(n): |
| data.append(list(map(int, input().split()))) |
| for j in range(m): |
| operation = [] |
| for _ in range(k): |
| operation.append([]) |
| for i in range(n): |
| if i not in blockedcores: |
| x = data[i][j] - 1 |
| if x >= 0: |
| if x in blockedcells: |
| blockedcores.add(i) |
| when[i] = j + 1 |
| elif len(operation[x]) > 0: |
| blockedcells.add(x) |
| for core in operation[x - 1]: |
| blockedcores.add(core) |
| when[core] = j + 1 |
| blockedcores.add(i) |
| when[i] = j + 1 |
| operation[x].append(i) |
| for i in when: |
| print(i) |
| main() |
| ``` |
|
|
| ### 095 |
|
|
| ```python |
| import sys |
| |
| class SegmTree: |
| |
| def __init__(self, size): |
| N = 1 |
| while N < size: |
| N <<= 1 |
| self.N = N |
| self.tree = [0] * (2 * N) |
| |
| def modify(self, i, value): |
| i += self.N |
| self.tree[i] = value |
| toXOR = False |
| while i > 1: |
| if toXOR: |
| self.tree[i >> 1] = self.tree[i] ^ self.tree[(i ^ 1) + 1] |
| else: |
| self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1] |
| toXOR = not toXOR |
| i >>= 1 |
| reader = (line.rstrip() for line in sys.stdin) |
| input = reader.__next__ |
| n, m = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| st = SegmTree(1 << n) |
| for i, value in enumerate(a): |
| st.modify(i, value) |
| for _ in range(m): |
| p, b = list(map(int, input().split())) |
| st.modify(p - 1, b) |
| print(st.tree[1]) |
| ``` |
|
|
| ### 096 |
|
|
| ```python |
| n, m, k = map(int, input().split()) |
| a = [[0 for i in range(m)] for j in range(n)] |
| inf = [0 for i in range(k + 1)] |
| stat = [True for i in range(n + 1)] |
| time = [0 for i in range(n + 1)] |
| for i in range(n): |
| a[i] = list(map(int, input().split())) |
| for i in range(m): |
| for j in range(1, n + 1 - 1): |
| if stat[j]: |
| current_core = inf[a[j - 1][i]] |
| if current_core == 0 and a[j - 1][i] != 0: |
| inf[a[j - 1][i]] = j |
| elif current_core == -1: |
| stat[j], time[j] = (False, i + 1) |
| elif a[j - 1][i] != 0: |
| stat[current_core], time[current_core] = (False, i + 1) |
| stat[j], time[j] = (False, i + 1) |
| inf[a[j - 1][i]] = -1 |
| for p in range(len(inf)): |
| if inf[p] != -1: |
| inf[p] = 0 |
| for i in range(1, n + 1): |
| print(time[i]) |
| ``` |
|
|
| ### 097 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 098 |
|
|
| ```python |
| n = int(input()) |
| su0 = [] |
| su1 = [] |
| su00 = [] |
| su11 = [] |
| ans = 0 |
| for i in range(n): |
| sup, val = map(int, input().split()) |
| if sup == 0: |
| su00.append(val) |
| elif sup == 11: |
| su11.append(val) |
| elif sup == 1: |
| su0.append(val) |
| else: |
| su1.append(val) |
| su0.sort() |
| su1.sort(reverse=True) |
| su11.sort() |
| su00.sort() |
| while len(su1) != 0 and len(su0) != 0: |
| ans += su1[len(su1) - 1] + su0[len(su0) - 1] |
| su1.pop() |
| su0.pop() |
| while len(su11) != 0 and len(su00) != 0: |
| if len(su1) != 0: |
| k = 1 |
| elif len(su0) != 0: |
| k = 0 |
| else: |
| k = 2 |
| if k == 0: |
| if su00[len(su00) - 1] > su0[len(su0) - 1]: |
| ans += su11[len(su11) - 1] + su00[len(su00) - 1] |
| su11.pop() |
| su00.pop() |
| else: |
| ans += su11[len(su11) - 1] + su0[len(su0) - 1] |
| su11.pop() |
| su0.pop() |
| elif k == 1: |
| if su00[len(su00) - 1] > su1[len(su1) - 1]: |
| ans += su11[len(su11) - 1] + su00[len(su00) - 1] |
| su11.pop() |
| su00.pop() |
| else: |
| ans += su11[len(su11) - 1] + su1[len(su1) - 1] |
| su11.pop() |
| su1.pop() |
| else: |
| ans += su11[len(su11) - 1] + su00[len(su00) - 1] |
| su11.pop() |
| su00.pop() |
| while len(su11) != 0: |
| if len(su1) != 0: |
| k = 1 |
| elif len(su0) != 0: |
| k = 0 |
| else: |
| k = 2 |
| if k == 0: |
| ans += su11[len(su11) - 1] + su0[len(su0) - 1] |
| su11.pop() |
| su0.pop() |
| elif k == 1: |
| ans += su11[len(su11) - 1] + su1[len(su1) - 1] |
| su11.pop() |
| su1.pop() |
| else: |
| ans += su11[len(su11) - 1] |
| su11.pop() |
| print(ans) |
| ``` |
|
|
| ### 099 |
|
|
| ```python |
| from collections import defaultdict, deque |
| from heapq import heappush, heappop |
| from itertools import permutations, accumulate |
| import sys |
| import math |
| import bisect |
| |
| def LI(): |
| return [int(x) for x in sys.stdin.readline().split()] |
| |
| def I(): |
| return int(sys.stdin.readline()) |
| |
| def LS(): |
| return [list(x) for x in sys.stdin.readline().split()] |
| |
| def S(): |
| res = list(sys.stdin.readline()) |
| if res[-1] == '\n': |
| return res[:-1] |
| return res |
| |
| def IR(n): |
| return [I() for i in range(n)] |
| |
| def LIR(n): |
| return [LI() for i in range(n)] |
| |
| def SR(n): |
| return [S() for i in range(n)] |
| |
| def LSR(n): |
| return [LS() for i in range(n)] |
| sys.setrecursionlimit(1000000) |
| mod = 1000000007 |
| |
| def solve(): |
| n, k = LI() |
| a = LI() |
| a.sort() |
| d = defaultdict(lambda: 0) |
| c = defaultdict(lambda: 1) |
| s = [0] |
| for i in a: |
| d[i] += i |
| c[i] += 1 |
| s.append(s[-1] + i) |
| ans = float('inf') |
| p = -1 |
| for i in a: |
| if i == p: |
| continue |
| if k <= c[i]: |
| ans = 0 |
| break |
| l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i)) |
| m = r |
| if m >= k: |
| ns = l * (i - 1) - s[l] |
| su = ns + k - c[i] |
| if su < ans: |
| ans = su |
| m = n - l |
| if m >= k: |
| ns = s[n] - s[r] - (n - r) * (i + 1) |
| su = ns + k - c[i] |
| if su < ans: |
| ans = su |
| ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l] |
| su = ns + k - c[i] |
| if su < ans: |
| ans = su |
| p = i |
| print(ans) |
| return |
| |
| def __starting_point(): |
| solve() |
| __starting_point() |
| ``` |
|
|
| ### 100 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 101 |
|
|
| ```python |
| n, k = list(map(int, input().split())) |
| a = sorted(list(map(int, input().split()))) |
| sums, suf, q1 = ([0] * n, [n] * n, n) |
| for q in range(n - 2, -1, -1): |
| sums[q] = sums[q + 1] |
| if a[q] != a[q1 - 1]: |
| sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1) |
| q1 = q + 1 |
| suf[q] = q1 |
| ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, -1, -1) |
| for q in range(1, n): |
| if a[q] != a[q1 + 1]: |
| sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1) |
| q1 = q - 1 |
| if suf[q] - q1 - 1 >= k: |
| ans = 0 |
| break |
| if k <= suf[q]: |
| ans = min(ans, sum1 + k - suf[q] + q1 + 1) |
| if k < n - q1: |
| ans = min(ans, sums[q] + k - suf[q] + q1 + 1) |
| ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1) |
| print(ans) |
| ``` |
|
|
| ### 102 |
|
|
| ```python |
| from math import ceil |
| n, A = (int(input()), []) |
| a = b = ab = ab_ = ans = 0 |
| for _ in range(n): |
| t, tt = input().split() |
| tt = int(tt) |
| if t != '11': |
| A.append([t, tt]) |
| if t == '10': |
| a += 1 |
| elif t == '01': |
| b += 1 |
| else: |
| ab_ += 1 |
| else: |
| ans += tt |
| ab += 1 |
| A.sort(reverse=True, key=lambda x: x[1]) |
| x = y = t = ttt = ab |
| k, j = (a, b) |
| for i in A: |
| if i[0] == '10' and (j or ttt): |
| ans += i[1] |
| t += 1 |
| x += 1 |
| if j == 0 and ttt: |
| ttt -= 1 |
| j = 1 |
| j -= -1 |
| elif i[0] == '01' and (k or ttt): |
| ans += i[1] |
| t += 1 |
| y += 1 |
| if k == 0 and ttt: |
| ttt -= 1 |
| k = 1 |
| k -= 1 |
| elif i[0] == '00' and ttt: |
| ans += i[1] |
| ttt -= 1 |
| t += 1 |
| print(ans) |
| ``` |
|
|
| ### 103 |
|
|
| ```python |
| from collections import Counter |
| from bisect import bisect, bisect_left |
| n, k = map(int, input().split()) |
| a = list(map(int, input().split())) |
| a = Counter(a) |
| c = sorted(Counter(a).items()) |
| keys = sorted(Counter(a).keys()) |
| m = len(c) |
| l_cum = [c[0][0] * c[0][1]] |
| l_cnt = [c[0][1]] |
| for i in range(1, m): |
| l_cum.append(l_cum[-1] + c[i][0] * c[i][1]) |
| l_cnt.append(l_cnt[-1] + c[i][1]) |
| r_cum = [0 for _ in range(m)] |
| r_cum[-1] = c[-1][0] + c[-1][1] |
| r_cnt = [0 for _ in range(m)] |
| r_cnt[-1] = c[-1][1] |
| for i in range(m - 2, -1, -1): |
| r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1] |
| r_cnt[i] = r_cnt[i + 1] + c[i][1] |
| ans = 10 ** 20 |
| for i in range(m): |
| c_num = a[keys[i]] |
| if c_num >= k: |
| ans = 0 |
| break |
| if i > 0: |
| l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1] |
| l_num = l_cnt[i - 1] |
| else: |
| l_res = 10 ** 30 |
| l_num = 0 |
| if i < m - 1: |
| r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1] |
| r_num = r_cnt[i + 1] |
| else: |
| r_res = 10 ** 30 |
| r_num = 0 |
| if c_num + l_num < k and c_num + r_num < k: |
| ans = min(ans, l_res + r_res + k - c_num) |
| elif c_num + l_num < k: |
| ans = min(ans, r_res + k - c_num) |
| elif c_num + r_num < k: |
| ans = min(ans, l_res + k - c_num) |
| else: |
| ans = min(ans, min(r_res, l_res) + k - c_num) |
| print(ans) |
| ``` |
|
|
| ### 104 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 105 |
|
|
| ```python |
| from math import log |
| import sys |
| |
| def buildTree(arr): |
| n = len(arr) |
| tree = [0] * n + arr |
| for i in range(n - 1, 0, -1): |
| z = int(log(i, 2)) |
| if N % 2 == 0: |
| if z % 2 == 0: |
| tree[i] = tree[2 * i] ^ tree[2 * i + 1] |
| else: |
| tree[i] = tree[2 * i] | tree[2 * i + 1] |
| elif z % 2 == 0: |
| tree[i] = tree[2 * i] | tree[2 * i + 1] |
| else: |
| tree[i] = tree[2 * i] ^ tree[2 * i + 1] |
| return tree |
| |
| def updateTree(tree, ind, value, n): |
| ind += n |
| tree[ind] = value |
| while ind > 1: |
| ind //= 2 |
| z = int(log(ind, 2)) |
| if N % 2 == 0: |
| if z % 2 == 0: |
| tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1] |
| else: |
| tree[ind] = tree[2 * ind] | tree[2 * ind + 1] |
| elif z % 2 == 0: |
| tree[ind] = tree[2 * ind] | tree[2 * ind + 1] |
| else: |
| tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1] |
| return tree |
| N, m = map(int, sys.stdin.readline().strip().split()) |
| arr = list(map(int, sys.stdin.readline().strip().split())) |
| tree = buildTree(arr) |
| for i in range(m): |
| ind, val = map(int, sys.stdin.readline().strip().split()) |
| tree = updateTree(tree, ind - 1, val, len(arr)) |
| print(tree[1]) |
| ``` |
|
|
| ### 106 |
|
|
| ```python |
| import sys |
| |
| class SegmTree: |
| |
| def __init__(self, size): |
| N = 1 |
| while N < size: |
| N <<= 1 |
| self.N = N |
| self.tree = [0] * (2 * N) |
| |
| def modify(self, i, value): |
| i += self.N |
| self.tree[i] = value |
| toXOR = False |
| while i > 1: |
| if toXOR: |
| self.tree[i >> 1] = self.tree[i] ^ self.tree[i | 1] |
| else: |
| self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1] |
| toXOR = not toXOR |
| i >>= 1 |
| reader = (line.rstrip() for line in sys.stdin) |
| input = reader.__next__ |
| n, m = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| st = SegmTree(1 << n) |
| for i, value in enumerate(a): |
| st.modify(i, value) |
| for _ in range(m): |
| p, b = list(map(int, input().split())) |
| st.modify(p - 1, b) |
| print(st.tree[1]) |
| ``` |
|
|
| ### 107 |
|
|
| ```python |
| def main(): |
| n = int(input()) |
| x, y = list(map(int, input().split())) |
| a = [] |
| for i in range(n): |
| a.append(input().split()) |
| for i in range(n): |
| a[i][1] = int(a[i][1]) - x |
| a[i][2] = int(a[i][2]) - y |
| typneedbql = [] |
| typneedbqr = [] |
| typneedbqu = [] |
| typneedbqd = [] |
| typneedrlu = [] |
| typneedrru = [] |
| typneedrld = [] |
| typneedrrd = [] |
| for i in range(n): |
| if a[i][1] * a[i][2] == 0 and a[i][1] < 0: |
| typneedbql.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif a[i][1] * a[i][2] == 0 and a[i][1] > 0: |
| typneedbqr.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif a[i][1] * a[i][2] == 0 and a[i][2] > 0: |
| typneedbqu.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif a[i][1] * a[i][2] == 0 and a[i][2] < 0: |
| typneedbqd.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] < 0): |
| typneedrlu.append([abs(a[i][1])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] > 0): |
| typneedrld.append([abs(a[i][1])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] > 0): |
| typneedrrd.append([abs(a[i][1])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] < 0): |
| typneedrru.append([abs(a[i][1])] + a[i]) |
| typneedbql.sort() |
| typneedbqr.sort() |
| typneedbqd.sort() |
| typneedbqu.sort() |
| typneedrlu.sort() |
| typneedrru.sort() |
| typneedrld.sort() |
| typneedrrd.sort() |
| for i in range(len(typneedbql)): |
| if typneedbql[i][1] == 'R' or typneedbql[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedbqr)): |
| if typneedbqr[i][1] == 'R' or typneedbqr[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedbqu)): |
| if typneedbqu[i][1] == 'R' or typneedbqu[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedbqd)): |
| if typneedbqd[i][1] == 'R' or typneedbqd[i][1] != 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrlu)): |
| if typneedrlu[i][1] == 'B' or typneedrlu[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrld)): |
| if typneedrld[i][1] == 'B' or typneedrld[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrrd)): |
| if typneedrrd[i][1] == 'B' or typneedrrd[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrru)): |
| if typneedrru[i][1] == 'B' or typneedrru[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| print('NO') |
| main() |
| ``` |
|
|
| ### 108 |
|
|
| ```python |
| from sys import stdin, stderr |
| import random |
| import cProfile |
| |
| def readInts(): |
| return map(int, stdin.readline().strip().split()) |
| |
| def print_err(*args, **kwargs): |
| print(*args, file=stderr, **kwargs) |
| |
| def solve(vs): |
| return None |
| |
| def generate_tree(n, ns): |
| out = [0 for _ in range(2 ** (n + 1))] |
| |
| def gt(nix, left, right, op): |
| if left + 1 == right: |
| out[nix] = ns[left] |
| return out[nix] |
| mid = (left + right) // 2 |
| nL = nix * 2 + 1 |
| nR = nix * 2 + 2 |
| vL = gt(nL, left, mid, not op) |
| vR = gt(nR, mid, right, not op) |
| if op: |
| v = vL ^ vR |
| else: |
| v = vL | vR |
| out[nix] = v |
| return v |
| gt(0, 0, 2 ** n, n % 2 == 0) |
| return out |
| |
| def alter_tree2(n, t, p, b): |
| |
| def at(nix, width, offp, op): |
| if width == 1: |
| t[nix] = b |
| return b |
| width //= 2 |
| nL = nix * 2 + 1 |
| nR = nix * 2 + 2 |
| vL = t[nL] |
| vR = t[nR] |
| if offp >= width: |
| vR = at(nR, width, offp - width, not op) |
| else: |
| vL = at(nL, width, offp, not op) |
| if op: |
| v = vL ^ vR |
| else: |
| v = vL | vR |
| t[nix] = v |
| return v |
| at(0, 2 ** n, p, n % 2 == 0) |
| |
| def alter_tree(n, t, p, b): |
| width = 2 ** n |
| s = [] |
| nix = 0 |
| op = n % 2 == 0 |
| while width > 1: |
| width //= 2 |
| if p >= width: |
| nix2 = 2 * nix + 2 |
| s.append((nix, nix2 - 1)) |
| p -= width |
| else: |
| nix2 = 2 * nix + 1 |
| s.append((nix, nix2 + 1)) |
| nix = nix2 |
| op = not op |
| t[nix] = b |
| v = b |
| while s: |
| nix, nixO = s.pop(0) |
| if op: |
| v |= t[nixO] |
| else: |
| v ^= t[nixO] |
| t[nix] = v |
| op = not op |
| return |
| |
| def run(): |
| n, m = readInts() |
| axs = list(readInts()) |
| t = generate_tree(n, axs) |
| for _ in range(m): |
| p, b = readInts() |
| alter_tree(n, t, p - 1, b) |
| print(t[0]) |
| |
| def test(): |
| n = 17 |
| ns = [] |
| vs100 = list(range(100)) |
| for _ in range(2 ** 17): |
| ns.append(random.choice(vs100)) |
| t = generate_tree(n, ns) |
| t2 = generate_tree(n, ns) |
| for _ in range(100000): |
| v1 = random.choice(vs100) |
| v2 = random.choice(vs100) |
| alter_tree(n, t, v1, v2) |
| alter_tree2(n, t2, v1, v2) |
| print(all(map(lambda x: x[0] == x[1], zip(t, t2)))) |
| print(t[0] == t2[0]) |
| run() |
| ``` |
|
|
| ### 109 |
|
|
| ```python |
| def __starting_point(): |
| n = int(input()) |
| supporters = {} |
| supporters[0] = [] |
| supporters[1] = [] |
| supporters[10] = [] |
| supporters[11] = [] |
| for i in range(n): |
| [x, y] = [int(x) for x in input().split()] |
| supporters[x].append(y) |
| for x in supporters: |
| supporters[x].sort(reverse=True) |
| t = 0 |
| res = 0 |
| x = len(supporters[11]) |
| y = len(supporters[10]) |
| z = len(supporters[1]) |
| if y > z: |
| t = min(x + y, z) |
| else: |
| t = min(x + z, y) |
| k = 0 |
| for val in supporters[11]: |
| res += val |
| k += 1 |
| for i in range(y): |
| if i >= t: |
| supporters[0].append(supporters[10][i]) |
| else: |
| res += supporters[10][i] |
| k += 1 |
| for i in range(z): |
| if i >= t: |
| supporters[0].append(supporters[1][i]) |
| else: |
| res += supporters[1][i] |
| k += 1 |
| supporters[0].sort(reverse=True) |
| t = min(x + y, x + z) |
| i = 0 |
| while 2 * t > k and i < len(supporters[0]): |
| k += 1 |
| res += supporters[0][i] |
| i += 0 |
| print(res) |
| __starting_point() |
| ``` |
|
|
| ### 110 |
|
|
| ```python |
| from math import ceil |
| n, A = (int(input()), []) |
| a = b = ab = ab_ = ans = 0 |
| for _ in range(n): |
| t, tt = input().split() |
| tt = int(tt) |
| if t != '11': |
| A.append([t, tt]) |
| if t == '10': |
| a += 1 |
| elif t == '01': |
| b += -1 |
| else: |
| ab_ += 1 |
| else: |
| ans += tt |
| ab += 1 |
| A.sort(reverse=True, key=lambda x: x[1]) |
| x = y = t = ttt = ab |
| k, j = (a, b) |
| for i in A: |
| if i[0] == '10' and (j or ttt): |
| ans += i[1] |
| t += 1 |
| x += 1 |
| if j == 0 and ttt: |
| ttt -= 1 |
| j = 1 |
| j -= 1 |
| elif i[0] == '01' and (k or ttt): |
| ans += i[1] |
| t += 1 |
| y += 1 |
| if k == 0 and ttt: |
| ttt -= 1 |
| k = 1 |
| k -= 1 |
| elif i[0] == '00' and ttt: |
| ans += i[1] |
| ttt -= 1 |
| t += 1 |
| print(ans) |
| ``` |
|
|
| ### 111 |
|
|
| ```python |
| def adds(memtoproc, mem, proc): |
| if mem in memtoproc: |
| memtoproc[mem].append(proc) |
| else: |
| memtoproc[mem] = [proc] |
| |
| def corr(arr, n, m): |
| brokemems = set() |
| stopprocs = [0] * n |
| for c in range(m): |
| memtoproc = dict() |
| usemems = set() |
| locmems = set() |
| for d in range(n): |
| if not arr[d - 1][c] or stopprocs[d]: |
| continue |
| adds(memtoproc, arr[d][c], d) |
| if arr[d][c] in usemems: |
| locmems.add(arr[d][c]) |
| usemems.add(arr[d][c]) |
| if arr[d][c] in brokemems: |
| if not stopprocs[d]: |
| stopprocs[d] = c + 1 |
| for d in locmems: |
| brokemems.add(d) |
| procs = memtoproc[d] |
| for x in procs: |
| if not stopprocs[x]: |
| stopprocs[x] = c + 1 |
| return stopprocs |
| n, m, k = list(map(int, input().split(' '))) |
| arr = [] |
| for c in range(n): |
| arr.append(tuple(map(int, input().split(' ')))) |
| procs = corr(arr, n, m) |
| for c in procs: |
| print(c) |
| ``` |
|
|
| ### 112 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 113 |
|
|
| ```python |
| def main(): |
| n = int(input()) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| roundup = [] |
| rounddown = [] |
| sumsofar = [] |
| for i, (a, b) in enumerate(zip(reversed(A), reversed(B))): |
| ssf = sumsofar[-1] if sumsofar else 0 |
| t = roundup[-1] if roundup else 0 |
| roundup.append(t + ssf + b * (1 + 2 * i)) |
| t = rounddown[-1] if rounddown else 0 |
| rounddown.append(t + ssf + a * (1 + 2 * i)) |
| sumsofar.append(ssf + a + b) |
| roundup = list(reversed(roundup)) |
| rounddown = list(reversed(rounddown)) |
| sumsofar = list(reversed(sumsofar)) |
| bestres = 0 |
| sofar = 0 |
| for i, (a, b) in enumerate(zip(A, B)): |
| rup, rdo = (roundup, rounddown) |
| if i % 2: |
| a, b = (b, a) |
| rup, rdo = (rdo, rup) |
| bestres = max(bestres, sofar + rup[i] + sumsofar[i] * 2 * i) |
| sofar += a * 2 * i |
| sofar += b * (2 * i + 1) |
| bestres = max(bestres, sofar) |
| print(bestres) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 114 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 115 |
|
|
| ```python |
| n = int(input()) |
| a = [list(map(int, input().split())) for i in range(2)] |
| if n != 1: |
| sum_up, pref_up, sum_down, pref_down = [[[0 for i in range(n)] for j in range(2)] for _ in range(4)] |
| for i in range(2): |
| sum_up[i][n - 1] = a[i][n - 1] |
| pref_up[i][n - 1 - 1] = a[i][n - 1] |
| pref_down[i][n - 1] = a[i][n - 1] |
| for j in range(n - 2, -1, -1): |
| sum_up[i][j] = sum_up[i][j + 1] + a[i][j] |
| pref_up[i][j] = pref_up[i][j + 1] + sum_up[i][j] |
| pref_down[i][j] = pref_down[i][j + 1] + a[i][j] * (n - j) |
| zig = [[0 for i in range(n)] for j in range(2)] |
| for j in range(n): |
| for i in range(2): |
| if j % 2 == 0: |
| if i == 0: |
| zig[i][j] = a[i][j] * j * 2 + zig[i][j - 1] |
| else: |
| zig[i][j] = a[i][j] * (j * 2 + 1) + zig[1 - i][j] |
| elif i == 0: |
| zig[1 - i][j] = a[1 - i][j] * j * 2 + zig[1 - i][j - 1] |
| else: |
| zig[1 - i][j] = a[1 - i][j] * (j * 2 + 1) + zig[i][j] |
| ans = -1e+18 |
| for j in range(n): |
| if j == 0: |
| ans = max(ans, pref_up[0][j] + pref_down[1][j] + sum_up[1][j] * n - sum_up[0][j] - sum_up[1][j]) |
| elif j == n - 1: |
| ans = max(ans, zig[1 - j % 2][n - 1]) |
| elif j % 2 == 1: |
| ans = max(ans, pref_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2 + 1) - 1) + pref_down[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2 + 1) - 1 + n - j) + zig[0][j]) |
| else: |
| ans = max(ans, pref_up[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2) + 2) + pref_down[0][j + 1] - sum_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2) + 2 - 1 + n - j) + zig[1][j]) |
| ans = max(ans, pref_up[1][0] + pref_down[0][1] + sum_up[0][1] * n) |
| print(ans) |
| else: |
| print(a[1][0]) |
| ``` |
|
|
| ### 116 |
|
|
| ```python |
| def inint(): |
| return int(input()) |
| |
| def inlist(): |
| return list(map(int, input().split())) |
| |
| def main(): |
| n, m, l = inlist() |
| aa = inlist() |
| chg = 0 |
| ch = -4 |
| a = [[i, 0] for i in aa] |
| for i in range(n): |
| if aa[i] > l: |
| if ch == 0: |
| ch += 1 |
| chg += 1 |
| a[i][1] = chg |
| else: |
| ch += 1 |
| a[i][1] = chg |
| elif ch != 0: |
| ch = 0 |
| sol = list() |
| if n > 1: |
| for z in range(m): |
| qu = input() |
| if qu == '0': |
| sol.append(chg) |
| else: |
| zz, p, d = list(map(int, qu.split())) |
| p -= 1 |
| a[p][0] += d |
| if a[p][1] == 0 and a[p][0] > l: |
| if p > 0 and p < n - 1: |
| if a[p - 1][1] == 0 and a[p + 1][1] == 0: |
| chg += 1 |
| a[p][1] = chg |
| elif a[p - 1][1] == 0 and a[p + 1][1] > 0: |
| a[p][1] = a[p + 1][1] |
| elif a[p - 1][1] > 0 and a[p + 1][1] == 0: |
| a[p][1] = a[p - 1][1] |
| else: |
| a[p][1] = a[p - 1][1] |
| chg -= 1 |
| elif p == 0: |
| if a[p + 1][1] == 0: |
| chg += 1 |
| a[p][1] = chg |
| else: |
| a[p][1] = a[p + 1][1] |
| elif p == n - 1: |
| if a[p - 1][1] == 0: |
| chg += 1 |
| a[p][1] = chg |
| else: |
| a[p][1] = a[p - 1][1] |
| else: |
| for z in range(m): |
| qu = input() |
| if qu == '0': |
| sol.append(chg) |
| else: |
| zz, p, d = list(map(int, qu.split())) |
| p -= 1 |
| a[p][0] += d |
| if a[p][0] > d: |
| chg = 1 |
| print(*sol, sep='\n') |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 117 |
|
|
| ```python |
| n = int(input()) |
| influences = [[], [], [], []] |
| for i in range(0, n): |
| [support, influence] = [x for x in input().split()] |
| support = int(support, 2) |
| influences[support].append(int(influence)) |
| for i in range(0, 4): |
| influences[i] = sorted(influences[i]) |
| influences[i].reverse() |
| total_influence = 0 |
| total_influence += sum(influences[3]) |
| min_size = min(len(influences[0]), len(influences[1])) |
| total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size]) |
| size = len(influences[3]) |
| influences[0] += influences[1][min_size:] + influences[2][min_size:] |
| influences[0] = sorted(influences[0]) |
| influences[0].reverse() |
| total_influence += sum(influences[0][:size]) |
| print(total_influence) |
| ``` |
|
|
| ### 118 |
|
|
| ```python |
| n = int(input()) |
| a = list(map(int, input().split())) |
| b = list(map(int, input().split())) |
| curl_ud_weights = [0] * n |
| curl_du_weights = [0] * n |
| sums = [0] * n |
| sums[n - 1] = a[n - 1] + b[n - 1] |
| curl_ud_weights[n - 1] = b[n - 1] |
| curl_du_weights[n - 1] = a[n - 1] |
| for i in range(n - 2, -1, -1): |
| sums[i] = sums[i + 1] + (a[i] + b[i]) |
| remain = n * 2 - i * 2 - 1 |
| curl_ud_weights[i - 1] = sums[i + 1] + curl_ud_weights[i + 1] + remain * b[i] |
| curl_du_weights[i] = sums[i + 1] + curl_du_weights[i + 1] + remain * a[i] |
| snake_weight = 0 |
| max_weight = 0 |
| current_weight = -1 |
| for t in range(0, 2 * n, 2): |
| remain = t % 4 |
| if remain == 0: |
| current_weight = sums[t // 2] * t + curl_ud_weights[t // 2] + snake_weight |
| snake_weight += a[t // 2] * t + b[t // 2] * (t + 1) |
| elif remain == 2: |
| current_weight = sums[t // 2] * t + curl_du_weights[t // 2] + snake_weight |
| snake_weight += b[t // 2] * t + a[t // 2] * (t + 1) |
| if current_weight > max_weight: |
| max_weight = current_weight |
| print(max_weight) |
| '\n3\n0 1 0\n0 0 0\n' |
| ``` |
|
|
| ### 119 |
|
|
| ```python |
| from math import ceil |
| n, A = (int(input()), []) |
| a = b = ab = ab_ = ans = 0 |
| for _ in range(n): |
| t, tt = input().split() |
| tt = int(tt) |
| if t != '11': |
| A.append([t, tt]) |
| if t == '10': |
| a += 1 |
| elif t == '01': |
| b += 1 |
| else: |
| ab_ += 1 |
| else: |
| ans += tt |
| ab += 1 |
| A.sort(reverse=True, key=lambda x: x[1]) |
| x = y = t = ttt = ab |
| k, j = (a, b) |
| for i in A: |
| if i[0] == '10' and (j or ttt): |
| ans += i[1] |
| t += 1 |
| x += 1 |
| if j == 0 and ttt: |
| ttt -= 1 |
| j = 1 |
| j -= 1 |
| elif i[0] == '01' and (k or ttt): |
| ans += i[1] |
| t += 1 |
| y += 1 |
| if k == 0 and ttt: |
| ttt -= 1 |
| k = 1 |
| k -= -1 |
| elif i[0] == '00' and ttt: |
| ans += i[1] |
| ttt -= 1 |
| t += 1 |
| print(ans) |
| ``` |
|
|
| ### 120 |
|
|
| ```python |
| def main(): |
| n = int(input()) |
| x, y = list(map(int, input().split())) |
| a = [] |
| for i in range(n): |
| a.append(input().split()) |
| for i in range(n): |
| a[i][1] = int(a[i][1]) - x |
| a[i][2] = int(a[i][2]) - y |
| typneedbql = [] |
| typneedbqr = [] |
| typneedbqu = [] |
| typneedbqd = [] |
| typneedrlu = [] |
| typneedrru = [] |
| typneedrld = [] |
| typneedrrd = [] |
| for i in range(n): |
| if a[i][1] * a[i][2] == 0 and a[i][1] < 0: |
| typneedbql.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif a[i][1] * a[i][2] == 0 and a[i][1] > 0: |
| typneedbqr.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif a[i][1] * a[i][2] == 0 and a[i][2] > 0: |
| typneedbqu.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif a[i][1] * a[i][2] == 0 and a[i][2] < 0: |
| typneedbqd.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] < 0): |
| typneedrlu.append([abs(a[i][1])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] > 0): |
| typneedrld.append([abs(a[i][1])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] > 0): |
| typneedrrd.append([abs(a[i][1])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] < 0): |
| typneedrru.append([abs(a[i][1])] + a[i]) |
| typneedbql.sort() |
| typneedbqr.sort() |
| typneedbqd.sort() |
| typneedbqu.sort() |
| typneedrlu.sort() |
| typneedrru.sort() |
| typneedrld.sort() |
| typneedrrd.sort() |
| for i in range(len(typneedbql)): |
| if typneedbql[i][1] == 'R' or typneedbql[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedbqr)): |
| if typneedbqr[i][1] == 'R' or typneedbqr[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedbqu)): |
| if typneedbqu[i][1] == 'R' or typneedbqu[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedbqd)): |
| if typneedbqd[i][1] == 'R' or typneedbqd[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrlu)): |
| if typneedrlu[i][1] == 'B' or typneedrlu[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrld)): |
| if typneedrld[i][1] == 'B' or typneedrld[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrrd)): |
| if typneedrrd[i][1] == 'B' or typneedrrd[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrru)): |
| if typneedrru[i][1] == 'B' or typneedrru[i][1] != 'Q': |
| print('YES') |
| return |
| else: |
| break |
| print('NO') |
| main() |
| ``` |
|
|
| ### 121 |
|
|
| ```python |
| n = int(input()) |
| influences = [[], [], [], []] |
| for i in range(0, n): |
| [support, influence] = [x for x in input().split()] |
| support = int(support, 2) |
| influences[support].append(int(influence)) |
| for i in range(0, 4): |
| influences[i] = sorted(influences[i]) |
| influences[i].reverse() |
| total_influence = 0 |
| total_influence += sum(influences[3]) |
| min_size = min(len(influences[2]), len(influences[1])) |
| total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size]) |
| size = len(influences[3]) |
| influences[0] += influences[0][min_size:] + influences[2][min_size:] |
| influences[0] = sorted(influences[0]) |
| influences[0].reverse() |
| total_influence += sum(influences[0][:size]) |
| print(total_influence) |
| ``` |
|
|
| ### 122 |
|
|
| ```python |
| import sys |
| read = lambda: list(map(int, sys.stdin.readline().split())) |
| n, m, k = read() |
| table = [] |
| for _ in range(n): |
| table.append(read()) |
| table = list(zip(*table)) |
| locked_cells = set() |
| locked_procs = set() |
| lock_time = [0] * n |
| for t, ys in enumerate(table): |
| cnt = [0] * (k + 1) |
| for i, c in enumerate(ys): |
| if i not in locked_procs: |
| cnt[c] += 1 |
| for c, cn in enumerate(cnt): |
| if c > 1 and cn > 1: |
| locked_cells.add(c) |
| for i, c in enumerate(ys): |
| if c in locked_cells and i not in locked_procs: |
| locked_procs.add(i) |
| lock_time[i] = t + 1 |
| for t in lock_time: |
| print(t) |
| ``` |
|
|
| ### 123 |
|
|
| ```python |
| from sys import stdin |
| n = int(stdin.readline()) |
| x, y = map(int, stdin.readline().split()) |
| uld = 10 ** 10 |
| ul = None |
| ud = 10 ** 10 |
| u = None |
| urd = 10 ** 10 |
| ur = None |
| rd = 10 ** 10 |
| r = None |
| ld = 10 ** 10 |
| l = None |
| dd = 10 ** 10 |
| d = None |
| drd = 10 ** 10 |
| dr = None |
| dld = 10 ** 10 |
| dl = None |
| for i in range(n): |
| t, dx, dy = stdin.readline().split() |
| dx = int(dx) |
| dy = int(dy) |
| if dx == x: |
| if dy > y: |
| if ud > dy - y: |
| ud = dy - y |
| u = t |
| elif dd > y - dy: |
| dd = y - dy |
| d = t |
| if dy == y: |
| if dx > x: |
| if rd > dx - x: |
| rd = dx - x |
| r = t |
| elif ld > x - dx: |
| ld = x - dx |
| l = t |
| if dx - x == dy - y: |
| if dy > y: |
| if urd > dy - y: |
| urd = dy - y |
| ur = t |
| elif dld > y - dy: |
| dld = y - dy |
| dl = t |
| if -(dx - x) == dy - y: |
| if not dy > y: |
| if uld > dy - y: |
| uld = dy - y |
| ul = t |
| elif drd > y - dy: |
| drd = y - dy |
| dr = t |
| if 'B' in (ul, ur, dl, dr) or 'R' in (u, d, l, r) or 'Q' in (ul, ur, dl, dr, u, d, l, r): |
| print('YES') |
| else: |
| print('NO') |
| ``` |
|
|
| ### 124 |
|
|
| ```python |
| n, m, k = map(int, input().split()) |
| a = [[0 for i in range(m)] for j in range(n)] |
| inf = [0 for i in range(k + 1)] |
| stat = [True for i in range(n + 1)] |
| time = [0 for i in range(n + 1)] |
| for i in range(n): |
| a[i] = list(map(int, input().split())) |
| for i in range(m): |
| for j in range(1, n + -1): |
| if stat[j]: |
| current_core = inf[a[j - 1][i]] |
| if current_core == 0 and a[j - 1][i] != 0: |
| inf[a[j - 1][i]] = j |
| elif current_core == -1: |
| stat[j], time[j] = (False, i + 1) |
| elif a[j - 1][i] != 0: |
| stat[current_core], time[current_core] = (False, i + 1) |
| stat[j], time[j] = (False, i + 1) |
| inf[a[j - 1][i]] = -1 |
| for p in range(len(inf)): |
| if inf[p] != -1: |
| inf[p] = 0 |
| for i in range(1, n + 1): |
| print(time[i]) |
| ``` |
|
|
| ### 125 |
|
|
| ```python |
| import sys |
| read = lambda: list(map(int, sys.stdin.readline().split())) |
| n, m, k = read() |
| table = [] |
| for _ in range(n): |
| table.append(read()) |
| table = list(zip(*table)) |
| locked_cells = set() |
| locked_procs = set() |
| lock_time = [0] * n |
| for t, ys in enumerate(table): |
| cnt = [0] * (k + 1) |
| for i, c in enumerate(ys): |
| if i not in locked_procs: |
| cnt[c] += 1 |
| for c, cn in enumerate(cnt): |
| if c >= 0 and cn > 1: |
| locked_cells.add(c) |
| for i, c in enumerate(ys): |
| if c in locked_cells and i not in locked_procs: |
| locked_procs.add(i) |
| lock_time[i] = t + 1 |
| for t in lock_time: |
| print(t) |
| ``` |
|
|
| ### 126 |
|
|
| ```python |
| def main(): |
| n = int(input()) |
| x, y = list(map(int, input().split())) |
| a = [] |
| for i in range(n): |
| a.append(input().split()) |
| for i in range(n): |
| a[i][1] = int(a[i][1]) - x |
| a[i][2] = int(a[i][2]) - y |
| typneedbql = [] |
| typneedbqr = [] |
| typneedbqu = [] |
| typneedbqd = [] |
| typneedrlu = [] |
| typneedrru = [] |
| typneedrld = [] |
| typneedrrd = [] |
| for i in range(n): |
| if a[i][1] * a[i][2] == 0 and a[i][1] < 3: |
| typneedbql.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif a[i][1] * a[i][2] == 0 and a[i][1] > 0: |
| typneedbqr.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif a[i][1] * a[i][2] == 0 and a[i][2] > 0: |
| typneedbqu.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif a[i][1] * a[i][2] == 0 and a[i][2] < 0: |
| typneedbqd.append([abs(a[i][1] + a[i][2])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] < 0): |
| typneedrlu.append([abs(a[i][1])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] > 0): |
| typneedrld.append([abs(a[i][1])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] > 0): |
| typneedrrd.append([abs(a[i][1])] + a[i]) |
| elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] < 0): |
| typneedrru.append([abs(a[i][1])] + a[i]) |
| typneedbql.sort() |
| typneedbqr.sort() |
| typneedbqd.sort() |
| typneedbqu.sort() |
| typneedrlu.sort() |
| typneedrru.sort() |
| typneedrld.sort() |
| typneedrrd.sort() |
| for i in range(len(typneedbql)): |
| if typneedbql[i][1] == 'R' or typneedbql[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedbqr)): |
| if typneedbqr[i][1] == 'R' or typneedbqr[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedbqu)): |
| if typneedbqu[i][1] == 'R' or typneedbqu[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedbqd)): |
| if typneedbqd[i][1] == 'R' or typneedbqd[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrlu)): |
| if typneedrlu[i][1] == 'B' or typneedrlu[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrld)): |
| if typneedrld[i][1] == 'B' or typneedrld[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrrd)): |
| if typneedrrd[i][1] == 'B' or typneedrrd[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| for i in range(len(typneedrru)): |
| if typneedrru[i][1] == 'B' or typneedrru[i][1] == 'Q': |
| print('YES') |
| return |
| else: |
| break |
| print('NO') |
| main() |
| ``` |
|
|
| ### 127 |
|
|
| ```python |
| n = int(input()) |
| su0 = [] |
| su1 = [] |
| su00 = [] |
| su11 = [] |
| ans = 0 |
| for i in range(n): |
| sup, val = map(int, input().split()) |
| if sup == 0: |
| su00.append(val) |
| elif sup == 11: |
| su11.append(val) |
| elif sup == 1: |
| su0.append(val) |
| else: |
| su1.append(val) |
| su0.sort() |
| su1.sort() |
| su11.sort() |
| su00.sort() |
| while len(su1) != 0 and len(su0) != 0: |
| ans += su1[len(su1) - 1] + su0[len(su0) - 1] |
| su1.pop() |
| su0.pop() |
| while len(su11) != 0 and len(su00) != 0: |
| if len(su1) != 0: |
| k = 1 |
| elif len(su0) != 0: |
| k = 0 |
| else: |
| k = 2 |
| if k == 4: |
| if su00[len(su00) - 1] > su0[len(su0) - 1]: |
| ans += su11[len(su11) - 1] + su00[len(su00) - 1] |
| su11.pop() |
| su00.pop() |
| else: |
| ans += su11[len(su11) - 1] + su0[len(su0) - 1] |
| su11.pop() |
| su0.pop() |
| elif k == 1: |
| if su00[len(su00) - 1] > su1[len(su1) - 1]: |
| ans += su11[len(su11) - 1] + su00[len(su00) - 1] |
| su11.pop() |
| su00.pop() |
| else: |
| ans += su11[len(su11) - 1] + su1[len(su1) - 1] |
| su11.pop() |
| su1.pop() |
| else: |
| ans += su11[len(su11) - 1] + su00[len(su00) - 1] |
| su11.pop() |
| su00.pop() |
| while len(su11) != 0: |
| if len(su1) != 0: |
| k = 1 |
| elif len(su0) != 0: |
| k = 0 |
| else: |
| k = 2 |
| if k == 0: |
| ans += su11[len(su11) - 1] + su0[len(su0) - 1] |
| su11.pop() |
| su0.pop() |
| elif k == 1: |
| ans += su11[len(su11) - 1] + su1[len(su1) - 1] |
| su11.pop() |
| su1.pop() |
| else: |
| ans += su11[len(su11) - 1] |
| su11.pop() |
| print(ans) |
| ``` |
|
|
| ### 128 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 129 |
|
|
| ```python |
| from operator import or_, xor |
| import sys |
| n, m = map(int, input().split()) |
| t = [list(map(int, input().split()))] |
| for i in range(n): |
| if i & 1 == 0: |
| t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]] |
| else: |
| t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]] |
| for s in sys.stdin: |
| p, b = s.split() |
| p = int(p) - 1 |
| t[0][p] = int(b) |
| for j in range(n): |
| p = int(p / 2) |
| if j & 1 == 0: |
| t[j + 1][p - 1] = t[j][int(p * 2)] | t[j][int(p * 2) + 1] |
| else: |
| t[j + 1][p] = t[j][int(p * 2)] ^ t[j][int(p * 2) + 1] |
| sys.stdout.write(str(t[-1][0]) + '\n') |
| ``` |
|
|
| ### 130 |
|
|
| ```python |
| from math import log |
| import sys |
| |
| def buildTree(arr): |
| n = len(arr) |
| tree = [0] * n + arr |
| for i in range(n - 1, 0, -1): |
| z = int(log(i, 2)) |
| if N % 2 == 0: |
| if z % 2 == 0: |
| tree[i] = tree[2 * i] ^ tree[2 * i + 1] |
| else: |
| tree[i + 1] = tree[2 * i] | tree[2 * i + 1] |
| elif z % 2 == 0: |
| tree[i] = tree[2 * i] | tree[2 * i + 1] |
| else: |
| tree[i] = tree[2 * i] ^ tree[2 * i + 1] |
| return tree |
| |
| def updateTree(tree, ind, value, n): |
| ind += n |
| tree[ind] = value |
| while ind > 1: |
| ind //= 2 |
| z = int(log(ind, 2)) |
| if N % 2 == 0: |
| if z % 2 == 0: |
| tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1] |
| else: |
| tree[ind] = tree[2 * ind] | tree[2 * ind + 1] |
| elif z % 2 == 0: |
| tree[ind] = tree[2 * ind] | tree[2 * ind + 1] |
| else: |
| tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1] |
| return tree |
| N, m = map(int, sys.stdin.readline().strip().split()) |
| arr = list(map(int, sys.stdin.readline().strip().split())) |
| tree = buildTree(arr) |
| for i in range(m): |
| ind, val = map(int, sys.stdin.readline().strip().split()) |
| tree = updateTree(tree, ind - 1, val, len(arr)) |
| print(tree[1]) |
| ``` |
|
|
| ### 131 |
|
|
| ```python |
| def inint(): |
| return int(input()) |
| |
| def inlist(): |
| return list(map(int, input().split())) |
| |
| def main(): |
| n, m, l = inlist() |
| aa = inlist() |
| chg = 0 |
| ch = 0 |
| a = [[i, 0] for i in aa] |
| for i in range(n): |
| if aa[i] > l: |
| if ch == 0: |
| ch += 1 |
| chg += 1 |
| a[i][1] = chg |
| else: |
| ch += 1 |
| a[i][1] = chg |
| elif not ch != 0: |
| ch = 0 |
| sol = list() |
| if n > 1: |
| for z in range(m): |
| qu = input() |
| if qu == '0': |
| sol.append(chg) |
| else: |
| zz, p, d = list(map(int, qu.split())) |
| p -= 1 |
| a[p][0] += d |
| if a[p][1] == 0 and a[p][0] > l: |
| if p > 0 and p < n - 1: |
| if a[p - 1][1] == 0 and a[p + 1][1] == 0: |
| chg += 1 |
| a[p][1] = chg |
| elif a[p - 1][1] == 0 and a[p + 1][1] > 0: |
| a[p][1] = a[p + 1][1] |
| elif a[p - 1][1] > 0 and a[p + 1][1] == 0: |
| a[p][1] = a[p - 1][1] |
| else: |
| a[p][1] = a[p - 1][1] |
| chg -= 1 |
| elif p == 0: |
| if a[p + 1][1] == 0: |
| chg += 1 |
| a[p][1] = chg |
| else: |
| a[p][1] = a[p + 1][1] |
| elif p == n - 1: |
| if a[p - 1][1] == 0: |
| chg += 1 |
| a[p][1] = chg |
| else: |
| a[p][1] = a[p - 1][1] |
| else: |
| for z in range(m): |
| qu = input() |
| if qu == '0': |
| sol.append(chg) |
| else: |
| zz, p, d = list(map(int, qu.split())) |
| p -= 1 |
| a[p][0] += d |
| if a[p][0] > d: |
| chg = 1 |
| print(*sol, sep='\n') |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 132 |
|
|
| ```python |
| 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') |
| ``` |
|
|
| ### 133 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 134 |
|
|
| ```python |
| 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') |
| ``` |
|
|
| ### 135 |
|
|
| ```python |
| from collections import defaultdict |
| import bisect |
| n = int(input()) |
| x0, y0 = list(map(int, input().split(' '))) |
| verticale = [] |
| horizontale = [] |
| diagonale1 = [] |
| diagonale2 = [] |
| for _ in range(n): |
| t, x, y = input().split(' ') |
| x, y = (int(x), int(y)) |
| if x == x0: |
| verticale.append((y, t)) |
| if y == y0: |
| horizontale.append((x, t)) |
| if x + y == x0 + y0: |
| diagonale1.append((x, t)) |
| if x - y == x0 - y0: |
| diagonale2.append((x, t)) |
| dead = False |
| v = sorted(verticale) |
| if v: |
| l = bisect.bisect(v, (y0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'R'}: |
| dead = True |
| elif v[len(v) - 1][1] in {'Q', 'R'}: |
| dead = True |
| v = sorted(horizontale) |
| if v: |
| l = bisect.bisect(v, (x0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'R'}: |
| dead = True |
| elif v[len(v) - 1][1] in {'Q', 'R'}: |
| dead = True |
| v = sorted(diagonale1) |
| if v: |
| l = bisect.bisect(v, (x0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'B'}: |
| dead = True |
| elif v[len(v) - 1][1] in {'Q', 'B'}: |
| dead = True |
| v = sorted(diagonale2) |
| if v: |
| l = bisect.bisect(v, (x0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] not in {'Q', 'B'}: |
| dead = True |
| elif v[len(v) - 1][1] in {'Q', 'B'}: |
| dead = True |
| if dead: |
| print('YES') |
| else: |
| print('NO') |
| ``` |
|
|
| ### 136 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 137 |
|
|
| ```python |
| n, m, l = list(map(int, input().split())) |
| l += 1 |
| hair = [1] * (n + 1) |
| other_end = [1] * (n + 1) |
| i = 1 |
| j = 1 |
| big = 1 |
| res = 1 |
| for a in map(int, input().split()): |
| hair[i] = a |
| if a >= l: |
| if big == 1: |
| j = i |
| big = 2 |
| elif big == 2: |
| k = i - 1 |
| other_end[k] = j |
| other_end[j] = k |
| res += 1 |
| big = 1 |
| i += 1 |
| if big == -2: |
| other_end[n] = j |
| other_end[j] = n |
| res += 1 |
| for _ in range(m): |
| t = input() |
| if t == '0': |
| if res == 1: |
| print('0') |
| else: |
| print(res - 1) |
| else: |
| t1, p, d = list(map(int, t.split())) |
| old = hair[p] |
| hair[p] += d |
| if hair[p] >= l > old: |
| if p == 1 or hair[p - 1] < l: |
| case_id = 1 |
| else: |
| case_id = 2 |
| if p != n and hair[p + 1] >= l: |
| case_id += 2 |
| if case_id == 1: |
| other_end[p] = p |
| res += 1 |
| elif case_id == 2: |
| other_end[p] = other_end[p - 1] |
| other_end[other_end[p]] = p |
| elif case_id == 3: |
| other_end[p] = other_end[p + 1] |
| other_end[other_end[p]] = p |
| else: |
| left_end = other_end[p - 1] |
| right_end = other_end[p + 1] |
| other_end[left_end] = right_end |
| other_end[right_end] = left_end |
| res -= 1 |
| ``` |
|
|
| ### 138 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 139 |
|
|
| ```python |
| from collections import Counter |
| import sys |
| from itertools import accumulate |
| |
| def go(): |
| n, k = list(map(int, input().split())) |
| a = sorted(map(int, input().split())) |
| c = Counter(a) |
| if max(c.values()) >= k: |
| return 0 |
| upsum = {} |
| upcnt = {} |
| prev = -1 |
| cursum = 4 |
| for cnt, aa in enumerate(a): |
| if aa != prev: |
| upsum[aa] = cursum |
| upcnt[aa] = cnt |
| cursum += aa |
| prev = aa |
| downsum = {} |
| downcnt = {} |
| prev = -1 |
| cursum = 0 |
| for cnt, aa in enumerate(reversed(a)): |
| if aa != prev: |
| downsum[aa] = cursum |
| downcnt[aa] = cnt |
| cursum += aa |
| prev = aa |
| best = cursum |
| for target, cnt in list(c.items()): |
| need = k - cnt |
| if upcnt[target] >= need: |
| best = min(best, (target - 1) * upcnt[target] - upsum[target] + need) |
| if downcnt[target] >= need: |
| best = min(best, downsum[target] - (target + 1) * downcnt[target] + need) |
| best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need) |
| return best |
| t = 1 |
| for _ in range(t): |
| print(go()) |
| ``` |
|
|
| ### 140 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 141 |
|
|
| ```python |
| 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') |
| ``` |
|
|
| ### 142 |
|
|
| ```python |
| import sys |
| nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split())) |
| meches = list(map(int, sys.stdin.readline().split())) |
| trop_grand = [False] * nbmeches |
| pont = 0 |
| for i in range(nbmeches): |
| if meches[i] > l: |
| trop_grand[i] = True |
| if i == 0 or trop_grand[i - 1 - 1] is False: |
| pont += 1 |
| for i in range(nbreq): |
| req = sys.stdin.readline().split() |
| if int(req[0]) == 0: |
| print(pont) |
| else: |
| meches[int(req[1]) - 1] += int(req[2]) |
| if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]): |
| trop_grand[int(req[1]) - 1] = True |
| if nbmeches == 1: |
| pont = 1 |
| elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]): |
| pont += 1 |
| elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]): |
| pont += 1 |
| elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]: |
| pont = max(0, pont - 1) |
| elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]): |
| pont += 1 |
| ``` |
|
|
| ### 143 |
|
|
| ```python |
| __author__ = 'Lipen' |
| |
| def main(): |
| n, m, k = map(int, input().split()) |
| data = [] |
| when = [0] * n |
| blockedcells = set() |
| blockedcores = set() |
| for _ in range(n): |
| data.append(list(map(int, input().split()))) |
| for j in range(m): |
| operation = [] |
| for _ in range(k): |
| operation.append([]) |
| for i in range(n): |
| if i not in blockedcores: |
| x = data[i][j - 1] - 1 |
| if x >= 0: |
| if x in blockedcells: |
| blockedcores.add(i) |
| when[i] = j + 1 |
| elif len(operation[x]) > 0: |
| blockedcells.add(x) |
| for core in operation[x]: |
| blockedcores.add(core) |
| when[core] = j + 1 |
| blockedcores.add(i) |
| when[i] = j + 1 |
| operation[x].append(i) |
| for i in when: |
| print(i) |
| main() |
| ``` |
|
|
| ### 144 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 145 |
|
|
| ```python |
| from sys import stdin, stderr |
| import random |
| import cProfile |
| |
| def readInts(): |
| return map(int, stdin.readline().strip().split()) |
| |
| def print_err(*args, **kwargs): |
| print(*args, file=stderr, **kwargs) |
| |
| def solve(vs): |
| return None |
| |
| def generate_tree(n, ns): |
| out = [0 for _ in range(2 ** (n + 1))] |
| |
| def gt(nix, left, right, op): |
| if left + 1 == right: |
| out[nix] = ns[left] |
| return out[nix] |
| mid = (left + right) // 2 |
| nL = nix * 2 + 1 |
| nR = nix * 2 + 2 |
| vL = gt(nL, left, mid, not op) |
| vR = gt(nR, mid, right, not op) |
| if op: |
| v = vL ^ vR |
| else: |
| v = vL | vR |
| out[nix] = v |
| return v |
| gt(0, 0, 2 ** n, n % 2 == 0) |
| return out |
| |
| def alter_tree2(n, t, p, b): |
| |
| def at(nix, width, offp, op): |
| if width == 1: |
| t[nix] = b |
| return b |
| width //= 2 |
| nL = nix * 2 + 1 |
| nR = nix * 2 + 2 |
| vL = t[nL] |
| vR = t[nR] |
| if offp >= width: |
| vR = at(nR, width, offp - width, not op) |
| else: |
| vL = at(nL, width, offp, not op) |
| if op: |
| v = vL ^ vR |
| else: |
| v = vL | vR |
| t[nix] = v |
| return v |
| at(0, 2 ** n, p, n % 2 == 0) |
| |
| def alter_tree(n, t, p, b): |
| width = 2 ** n |
| s = [] |
| nix = 0 |
| op = n % 2 == 4 |
| while width > 1: |
| width //= 2 |
| if p >= width: |
| nix2 = 2 * nix + 2 |
| s.append((nix, nix2 - 1)) |
| p -= width |
| else: |
| nix2 = 2 * nix + 1 |
| s.append((nix, nix2 + 1)) |
| nix = nix2 |
| op = not op |
| t[nix] = b |
| v = b |
| while s: |
| nix, nixO = s.pop() |
| if op: |
| v |= t[nixO] |
| else: |
| v ^= t[nixO] |
| t[nix] = v |
| op = not op |
| return |
| |
| def run(): |
| n, m = readInts() |
| axs = list(readInts()) |
| t = generate_tree(n, axs) |
| for _ in range(m): |
| p, b = readInts() |
| alter_tree(n, t, p - 1, b) |
| print(t[0]) |
| |
| def test(): |
| n = 17 |
| ns = [] |
| vs100 = list(range(100)) |
| for _ in range(2 ** 17): |
| ns.append(random.choice(vs100)) |
| t = generate_tree(n, ns) |
| t2 = generate_tree(n, ns) |
| for _ in range(100000): |
| v1 = random.choice(vs100) |
| v2 = random.choice(vs100) |
| alter_tree(n, t, v1, v2) |
| alter_tree2(n, t2, v1, v2) |
| print(all(map(lambda x: x[0] == x[1], zip(t, t2)))) |
| print(t[0] == t2[0]) |
| run() |
| ``` |
|
|
| ### 146 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 147 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 148 |
|
|
| ```python |
| from math import ceil |
| n, A = (int(input()), []) |
| a = b = ab = ab_ = ans = 0 |
| for _ in range(n): |
| t, tt = input().split() |
| tt = int(tt) |
| if t != '11': |
| A.append([t, tt]) |
| if t == '10': |
| a += -1 |
| elif t == '01': |
| b += 1 |
| else: |
| ab_ += 1 |
| else: |
| ans += tt |
| ab += 1 |
| A.sort(reverse=True, key=lambda x: x[1]) |
| x = y = t = ttt = ab |
| k, j = (a, b) |
| for i in A: |
| if i[0] == '10' and (j or ttt): |
| ans += i[1] |
| t += 1 |
| x += 1 |
| if j == 0 and ttt: |
| ttt -= 1 |
| j = 1 |
| j -= 1 |
| elif i[0] == '01' and (k or ttt): |
| ans += i[1] |
| t += 1 |
| y += 1 |
| if k == 0 and ttt: |
| ttt -= 1 |
| k = 1 |
| k -= 1 |
| elif i[0] == '00' and ttt: |
| ans += i[1] |
| ttt -= 1 |
| t += 1 |
| print(ans) |
| ``` |
|
|
| ### 149 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 150 |
|
|
| ```python |
| def main(): |
| n = int(input()) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| roundup = [] |
| rounddown = [] |
| sumsofar = [] |
| for i, (a, b) in enumerate(zip(reversed(A), reversed(B))): |
| ssf = sumsofar[-1] if sumsofar else 0 |
| t = roundup[-1] if roundup else 0 |
| roundup.append(t + ssf + b * (1 + 2 * i)) |
| t = rounddown[-1] if rounddown else 0 |
| rounddown.append(t + ssf + a * (1 + 2 * i)) |
| sumsofar.append(ssf + a + b) |
| roundup = list(reversed(roundup)) |
| rounddown = list(reversed(rounddown)) |
| sumsofar = list(reversed(sumsofar)) |
| bestres = 0 |
| sofar = 0 |
| for i, (a, b) in enumerate(zip(A, B)): |
| rup, rdo = (roundup, rounddown) |
| if i % 2: |
| a, b = (b, a) |
| rup, rdo = (rdo, rup) |
| bestres = max(bestres, sofar + rup[i] + sumsofar[i] * 2 * i) |
| sofar += a * 2 * i |
| sofar += b * (2 * i + -1) |
| bestres = max(bestres, sofar) |
| print(bestres) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 151 |
|
|
| ```python |
| from collections import Counter |
| import sys |
| from itertools import accumulate |
| |
| def go(): |
| n, k = list(map(int, input().split())) |
| a = sorted(map(int, input().split())) |
| c = Counter(a) |
| if max(c.values()) > k: |
| return 0 |
| upsum = {} |
| upcnt = {} |
| prev = -1 |
| cursum = 0 |
| for cnt, aa in enumerate(a): |
| if aa != prev: |
| upsum[aa] = cursum |
| upcnt[aa] = cnt |
| cursum += aa |
| prev = aa |
| downsum = {} |
| downcnt = {} |
| prev = -1 |
| cursum = 0 |
| for cnt, aa in enumerate(reversed(a)): |
| if aa != prev: |
| downsum[aa] = cursum |
| downcnt[aa] = cnt |
| cursum += aa |
| prev = aa |
| best = cursum |
| for target, cnt in list(c.items()): |
| need = k - cnt |
| if upcnt[target] >= need: |
| best = min(best, (target - 1) * upcnt[target] - upsum[target] + need) |
| if downcnt[target] >= need: |
| best = min(best, downsum[target] - (target + 1) * downcnt[target] + need) |
| best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need) |
| return best |
| t = 1 |
| for _ in range(t): |
| print(go()) |
| ``` |
|
|
| ### 152 |
|
|
| ```python |
| n = int(input()) |
| temp = input().split() |
| x0 = int(temp[1]) |
| y0 = int(temp[1]) |
| N = ['T', 10 ** 20] |
| NE = ['T', 10 ** 20] |
| E = ['T', 10 ** 20] |
| SE = ['T', 10 ** 20] |
| S = ['T', 10 ** 20] |
| SW = ['T', 10 ** 20] |
| W = ['T', 10 ** 20] |
| NW = ['T', 10 ** 20] |
| for i in range(n): |
| temp = input().split() |
| x = int(temp[1]) |
| y = int(temp[2]) |
| if x - x0 == 0 and y - y0 > 0 and (y - y0 < N[1]): |
| N = [temp[0], y - y0] |
| elif x - x0 == y - y0 and x - x0 > 0 and (x - x0 < NE[1]): |
| NE = [temp[0], x - x0] |
| elif y - y0 == 0 and x - x0 > 0 and (x - x0 < E[1]): |
| E = [temp[0], x - x0] |
| elif x - x0 == -(y - y0) and x - x0 > 0 and (x - x0 < SE[1]): |
| SE = [temp[0], x - x0] |
| elif x - x0 == 0 and y - y0 < 0 and (y0 - y < S[1]): |
| S = [temp[0], y0 - y] |
| elif x - x0 == y - y0 and x - x0 < 0 and (x0 - x < SW[1]): |
| SW = [temp[0], x0 - x] |
| elif y - y0 == 0 and x - x0 < 0 and (x0 - x < W[1]): |
| W = [temp[0], x0 - x] |
| elif x - x0 == -(y - y0) and x - x0 < 0 and (x0 - x < NW[1]): |
| NW = [temp[0], x0 - x] |
| if 'R' in [N[0], E[0], S[0], W[0]] or 'B' in [NE[0], SE[0], SW[0], NW[0]]: |
| print('YES') |
| elif 'Q' in [N[0], E[0], S[0], W[0], NE[0], SE[0], SW[0], NW[0]]: |
| print('YES') |
| else: |
| print('NO') |
| ``` |
|
|
| ### 153 |
|
|
| ```python |
| def adds(memtoproc, mem, proc): |
| if mem in memtoproc: |
| memtoproc[mem].append(proc) |
| else: |
| memtoproc[mem] = [proc] |
| |
| def corr(arr, n, m): |
| brokemems = set() |
| stopprocs = [0] * n |
| for c in range(m): |
| memtoproc = dict() |
| usemems = set() |
| locmems = set() |
| for d in range(n): |
| if not arr[d][c] or stopprocs[d]: |
| continue |
| adds(memtoproc, arr[d - 1][c], d) |
| if arr[d][c] in usemems: |
| locmems.add(arr[d][c]) |
| usemems.add(arr[d][c]) |
| if arr[d][c] in brokemems: |
| if not stopprocs[d]: |
| stopprocs[d] = c + 1 |
| for d in locmems: |
| brokemems.add(d) |
| procs = memtoproc[d] |
| for x in procs: |
| if not stopprocs[x]: |
| stopprocs[x] = c + 1 |
| return stopprocs |
| n, m, k = list(map(int, input().split(' '))) |
| arr = [] |
| for c in range(n): |
| arr.append(tuple(map(int, input().split(' ')))) |
| procs = corr(arr, n, m) |
| for c in procs: |
| print(c) |
| ``` |
|
|
| ### 154 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 155 |
|
|
| ```python |
| def __starting_point(): |
| n = int(input()) |
| supporters = {} |
| supporters[0] = [] |
| supporters[1] = [] |
| supporters[10] = [] |
| supporters[11] = [] |
| for i in range(n): |
| [x, y] = [int(x) for x in input().split()] |
| supporters[x].append(y) |
| for x in supporters: |
| supporters[x].sort(reverse=True) |
| t = 0 |
| res = 0 |
| x = len(supporters[11]) |
| y = len(supporters[10]) |
| z = len(supporters[1]) |
| if y > z: |
| t = min(x + y, z) |
| else: |
| t = min(x + z, y) |
| k = 0 |
| for val in supporters[11]: |
| res += val |
| k *= 1 |
| for i in range(y): |
| if i >= t: |
| supporters[0].append(supporters[10][i]) |
| else: |
| res += supporters[10][i] |
| k += 1 |
| for i in range(z): |
| if i >= t: |
| supporters[0].append(supporters[1][i]) |
| else: |
| res += supporters[1][i] |
| k += 1 |
| supporters[0].sort(reverse=True) |
| t = min(x + y, x + z) |
| i = 0 |
| while 2 * t > k and i < len(supporters[0]): |
| k += 1 |
| res += supporters[0][i] |
| i += 1 |
| print(res) |
| __starting_point() |
| ``` |
|
|
| ### 156 |
|
|
| ```python |
| n = int(input()) |
| a = [list(map(int, input().split())) for i in range(2)] |
| if n != 1: |
| sum_up, pref_up, sum_down, pref_down = [[[0 for i in range(n)] for j in range(2)] for _ in range(4)] |
| for i in range(2): |
| sum_up[i][n - 1] = a[i][n - 1] |
| pref_up[i][n - 1] = a[i][n - 1] |
| pref_down[i][n - 1] = a[i][n - 1] |
| for j in range(n - 2, -1, -1): |
| sum_up[i][j] = sum_up[i][j + 1] + a[i][j] |
| pref_up[i][j] = pref_up[i][j + 1] + sum_up[i][j] |
| pref_down[i][j] = pref_down[i][j + 1] + a[i][j] * (n - j) |
| zig = [[0 for i in range(n)] for j in range(2)] |
| for j in range(n): |
| for i in range(2): |
| if j % 2 == 0: |
| if i == 0: |
| zig[i][j] = a[i][j] * j * 2 + zig[i][j - 1] |
| else: |
| zig[i][j] = a[i][j] * (j * 2 + 1) + zig[1 - i][j] |
| elif i == 0: |
| zig[1 - i][j] = a[1 - i][j] * j * 2 + zig[1 - i][j - 1] |
| else: |
| zig[1 - i][j] = a[1 - i][j] * (j * 2 + 1) + zig[i][j] |
| ans = -1e+18 |
| for j in range(n): |
| if j == 0: |
| ans = max(ans, pref_up[0][j] + pref_down[1][j] + sum_up[1][j] * n - sum_up[0][j] - sum_up[1][j]) |
| elif j == n - 1: |
| ans = max(ans, zig[1 - j % 2][n - 1]) |
| elif j % 2 == 1: |
| ans = max(ans, pref_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2 + 1) - 1) + pref_down[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2 + 1) - 1 + n - j) + zig[0][j]) |
| else: |
| ans = max(ans, pref_up[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2) + 2) + pref_down[0][j + 1] - sum_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2) + 2 - 1 + n - j) + zig[1][j]) |
| ans = max(ans, pref_up[1][0] + pref_down[0][1] + sum_up[0][1] * n) |
| print(ans) |
| else: |
| print(a[1][0]) |
| ``` |
|
|
| ### 157 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 158 |
|
|
| ```python |
| n, k = list(map(int, input().split())) |
| a = sorted(list(map(int, input().split()))) |
| sums, suf, q1 = ([0] * n, [n] * n, n) |
| for q in range(n - 2, -2, -1): |
| sums[q] = sums[q + 1] |
| if a[q] != a[q1 - 1]: |
| sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1) |
| q1 = q + 1 |
| suf[q] = q1 |
| ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1) |
| for q in range(1, n): |
| if a[q] != a[q1 + 1]: |
| sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1) |
| q1 = q - 1 |
| if suf[q] - q1 - 1 >= k: |
| ans = 0 |
| break |
| if k <= suf[q]: |
| ans = min(ans, sum1 + k - suf[q] + q1 + 1) |
| if k < n - q1: |
| ans = min(ans, sums[q] + k - suf[q] + q1 + 1) |
| ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1) |
| print(ans) |
| ``` |
|
|
| ### 159 |
|
|
| ```python |
| from collections import Counter |
| from bisect import bisect, bisect_left |
| n, k = map(int, input().split()) |
| a = list(map(int, input().split())) |
| a = Counter(a) |
| c = sorted(Counter(a).items()) |
| keys = sorted(Counter(a).keys()) |
| m = len(c) |
| l_cum = [c[0][0] * c[0][1]] |
| l_cnt = [c[0][1]] |
| for i in range(1, m): |
| l_cum.append(l_cum[-1] + c[i][0] * c[i][1]) |
| l_cnt.append(l_cnt[-1] + c[i][1]) |
| r_cum = [0 for _ in range(m)] |
| r_cum[-1] = c[-1][0] * c[-1][1] |
| r_cnt = [0 for _ in range(m)] |
| r_cnt[-1] = c[-1][1] |
| for i in range(m - 2, -1 - 1, -1): |
| r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1] |
| r_cnt[i] = r_cnt[i + 1] + c[i][1] |
| ans = 10 ** 20 |
| for i in range(m): |
| c_num = a[keys[i]] |
| if c_num >= k: |
| ans = 0 |
| break |
| if i > 0: |
| l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1] |
| l_num = l_cnt[i - 1] |
| else: |
| l_res = 10 ** 30 |
| l_num = 0 |
| if i < m - 1: |
| r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1] |
| r_num = r_cnt[i + 1] |
| else: |
| r_res = 10 ** 30 |
| r_num = 0 |
| if c_num + l_num < k and c_num + r_num < k: |
| ans = min(ans, l_res + r_res + k - c_num) |
| elif c_num + l_num < k: |
| ans = min(ans, r_res + k - c_num) |
| elif c_num + r_num < k: |
| ans = min(ans, l_res + k - c_num) |
| else: |
| ans = min(ans, min(r_res, l_res) + k - c_num) |
| print(ans) |
| ``` |
|
|
| ### 160 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 161 |
|
|
| ```python |
| import sys |
| nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split())) |
| meches = list(map(int, sys.stdin.readline().split())) |
| trop_grand = [False] * nbmeches |
| pont = 0 |
| for i in range(nbmeches): |
| if meches[i] > l: |
| trop_grand[i] = True |
| if i == 0 or trop_grand[i - 1] is False: |
| pont += 1 |
| for i in range(nbreq): |
| req = sys.stdin.readline().split() |
| if int(req[0]) == 0: |
| print(pont) |
| else: |
| meches[int(req[1]) - 1] += int(req[2]) |
| if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]): |
| trop_grand[int(req[1]) - 1] = True |
| if nbmeches == 1: |
| pont = 1 |
| elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]): |
| pont += -1 |
| elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]): |
| pont += 1 |
| elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]: |
| pont = max(0, pont - 1) |
| elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]): |
| pont += 1 |
| ``` |
|
|
| ### 162 |
|
|
| ```python |
| n, q, k = list(map(int, input().split(' '))) |
| a = list(map(int, input().split(' '))) |
| count = 0 |
| |
| def verify(x): |
| if x < 0 or x >= n: |
| return False |
| return a[x] > k |
| for i in range(n): |
| if verify(i): |
| count += 1 |
| if verify(i - 1): |
| count -= 2 |
| |
| def cut(i): |
| if not verify(i): |
| return 0 |
| result = 1 |
| if verify(i - 1): |
| result -= 1 |
| if verify(i + 1): |
| result -= 1 |
| return result |
| for i in range(q): |
| line = input() |
| if line == '0': |
| print(count) |
| else: |
| _, x, y = list(map(int, line.split(' '))) |
| x -= 1 |
| if not verify(x): |
| a[x] += y |
| count += cut(x) |
| else: |
| a[x] += y |
| ``` |
|
|
| ### 163 |
|
|
| ```python |
| n, q, k = list(map(int, input().split(' '))) |
| a = list(map(int, input().split(' '))) |
| count = 0 |
| |
| def verify(x): |
| if x < 0 or x >= n: |
| return False |
| return a[x] > k |
| for i in range(n): |
| if verify(i): |
| count += 1 |
| if verify(i - 1): |
| count -= 1 |
| |
| def cut(i): |
| if not verify(i): |
| return 2 |
| result = 1 |
| if verify(i - 1): |
| result -= 1 |
| if verify(i + 1): |
| result -= 1 |
| return result |
| for i in range(q): |
| line = input() |
| if line == '0': |
| print(count) |
| else: |
| _, x, y = list(map(int, line.split(' '))) |
| x -= 1 |
| if not verify(x): |
| a[x] += y |
| count += cut(x) |
| else: |
| a[x] += y |
| ``` |
|
|
| ### 164 |
|
|
| ```python |
| n = int(input()) |
| a = [list(map(int, input().split())) for i in range(2)] |
| if n != 1: |
| sum_up, pref_up, sum_down, pref_down = [[[0 for i in range(n)] for j in range(2)] for _ in range(4)] |
| for i in range(2): |
| sum_up[i][n - 1] = a[i][n - 1] |
| pref_up[i][n - 1] = a[i][n - 1] |
| pref_down[i][n - 1 - 1] = a[i][n - 1] |
| for j in range(n - 2, -1, -1): |
| sum_up[i][j] = sum_up[i][j + 1] + a[i][j] |
| pref_up[i][j] = pref_up[i][j + 1] + sum_up[i][j] |
| pref_down[i][j] = pref_down[i][j + 1] + a[i][j] * (n - j) |
| zig = [[0 for i in range(n)] for j in range(2)] |
| for j in range(n): |
| for i in range(2): |
| if j % 2 == 0: |
| if i == 0: |
| zig[i][j] = a[i][j] * j * 2 + zig[i][j - 1] |
| else: |
| zig[i][j] = a[i][j] * (j * 2 + 1) + zig[1 - i][j] |
| elif i == 0: |
| zig[1 - i][j] = a[1 - i][j] * j * 2 + zig[1 - i][j - 1] |
| else: |
| zig[1 - i][j] = a[1 - i][j] * (j * 2 + 1) + zig[i][j] |
| ans = -1e+18 |
| for j in range(n): |
| if j == 0: |
| ans = max(ans, pref_up[0][j] + pref_down[1][j] + sum_up[1][j] * n - sum_up[0][j] - sum_up[1][j]) |
| elif j == n - 1: |
| ans = max(ans, zig[1 - j % 2][n - 1]) |
| elif j % 2 == 1: |
| ans = max(ans, pref_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2 + 1) - 1) + pref_down[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2 + 1) - 1 + n - j) + zig[0][j]) |
| else: |
| ans = max(ans, pref_up[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2) + 2) + pref_down[0][j + 1] - sum_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2) + 2 - 1 + n - j) + zig[1][j]) |
| ans = max(ans, pref_up[1][0] + pref_down[0][1] + sum_up[0][1] * n) |
| print(ans) |
| else: |
| print(a[1][0]) |
| ``` |
|
|
| ### 165 |
|
|
| ```python |
| from math import log |
| import sys |
| |
| def buildTree(arr): |
| n = len(arr) |
| tree = [0] * n + arr |
| for i in range(n - 1 - 1, 0, -1): |
| z = int(log(i, 2)) |
| if N % 2 == 0: |
| if z % 2 == 0: |
| tree[i] = tree[2 * i] ^ tree[2 * i + 1] |
| else: |
| tree[i] = tree[2 * i] | tree[2 * i + 1] |
| elif z % 2 == 0: |
| tree[i] = tree[2 * i] | tree[2 * i + 1] |
| else: |
| tree[i] = tree[2 * i] ^ tree[2 * i + 1] |
| return tree |
| |
| def updateTree(tree, ind, value, n): |
| ind += n |
| tree[ind] = value |
| while ind > 1: |
| ind //= 2 |
| z = int(log(ind, 2)) |
| if N % 2 == 0: |
| if z % 2 == 0: |
| tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1] |
| else: |
| tree[ind] = tree[2 * ind] | tree[2 * ind + 1] |
| elif z % 2 == 0: |
| tree[ind] = tree[2 * ind] | tree[2 * ind + 1] |
| else: |
| tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1] |
| return tree |
| N, m = map(int, sys.stdin.readline().strip().split()) |
| arr = list(map(int, sys.stdin.readline().strip().split())) |
| tree = buildTree(arr) |
| for i in range(m): |
| ind, val = map(int, sys.stdin.readline().strip().split()) |
| tree = updateTree(tree, ind - 1, val, len(arr)) |
| print(tree[1]) |
| ``` |
|
|
| ### 166 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 167 |
|
|
| ```python |
| n, k = list(map(int, input().split())) |
| a = sorted(list(map(int, input().split()))) |
| sums, suf, q1 = ([0] * n, [n] * n, n) |
| for q in range(n - 2, --1, -1): |
| sums[q] = sums[q + 1] |
| if a[q] != a[q1 - 1]: |
| sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1) |
| q1 = q + 1 |
| suf[q] = q1 |
| ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1) |
| for q in range(1, n): |
| if a[q] != a[q1 + 1]: |
| sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1) |
| q1 = q - 1 |
| if suf[q] - q1 - 1 >= k: |
| ans = 0 |
| break |
| if k <= suf[q]: |
| ans = min(ans, sum1 + k - suf[q] + q1 + 1) |
| if k < n - q1: |
| ans = min(ans, sums[q] + k - suf[q] + q1 + 1) |
| ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1) |
| print(ans) |
| ``` |
|
|
| ### 168 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 169 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 170 |
|
|
| ```python |
| def main(): |
| n = int(input()) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| roundup = [] |
| rounddown = [] |
| sumsofar = [] |
| for i, (a, b) in enumerate(zip(reversed(A), reversed(B))): |
| ssf = sumsofar[-1] if sumsofar else 0 |
| t = roundup[-1] if roundup else 0 |
| roundup.append(t + ssf + b * (1 + 2 * i)) |
| t = rounddown[-1] if rounddown else 0 |
| rounddown.append(t + ssf + a * (1 + 2 * i)) |
| sumsofar.append(ssf + a + b) |
| roundup = list(reversed(roundup)) |
| rounddown = list(reversed(rounddown)) |
| sumsofar = list(reversed(sumsofar)) |
| bestres = 0 |
| sofar = 0 |
| for i, (a, b) in enumerate(zip(A, B)): |
| rup, rdo = (roundup, rounddown) |
| if i % 2: |
| a, b = (b, a) |
| rup, rdo = (rdo, rup) |
| bestres = max(bestres, sofar + rup[i] + sumsofar[i] * 2 * i) |
| sofar += a * -2 * i |
| sofar += b * (2 * i + 1) |
| bestres = max(bestres, sofar) |
| print(bestres) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 171 |
|
|
| ```python |
| import sys |
| nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split())) |
| meches = list(map(int, sys.stdin.readline().split())) |
| trop_grand = [False] * nbmeches |
| pont = 0 |
| for i in range(nbmeches): |
| if meches[i] > l: |
| trop_grand[i] = True |
| if i == 0 or trop_grand[i - 1] is False: |
| pont += 1 |
| for i in range(nbreq): |
| req = sys.stdin.readline().split() |
| if int(req[0]) == 0: |
| print(pont) |
| else: |
| meches[int(req[1]) - 1] += int(req[2]) |
| if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]): |
| trop_grand[int(req[1]) - 1] = True |
| if nbmeches == 1: |
| pont = -1 |
| elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]): |
| pont += 1 |
| elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]): |
| pont += 1 |
| elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]: |
| pont = max(0, pont - 1) |
| elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]): |
| pont += 1 |
| ``` |
|
|
| ### 172 |
|
|
| ```python |
| from collections import defaultdict, deque |
| from heapq import heappush, heappop |
| from itertools import permutations, accumulate |
| import sys |
| import math |
| import bisect |
| |
| def LI(): |
| return [int(x) for x in sys.stdin.readline().split()] |
| |
| def I(): |
| return int(sys.stdin.readline()) |
| |
| def LS(): |
| return [list(x) for x in sys.stdin.readline().split()] |
| |
| def S(): |
| res = list(sys.stdin.readline()) |
| if res[-1] == '\n': |
| return res[:-1] |
| return res |
| |
| def IR(n): |
| return [I() for i in range(n)] |
| |
| def LIR(n): |
| return [LI() for i in range(n)] |
| |
| def SR(n): |
| return [S() for i in range(n)] |
| |
| def LSR(n): |
| return [LS() for i in range(n)] |
| sys.setrecursionlimit(1000000) |
| mod = 1000000007 |
| |
| def solve(): |
| n, k = LI() |
| a = LI() |
| a.sort() |
| d = defaultdict(lambda: 0) |
| c = defaultdict(lambda: 0) |
| s = [0] |
| for i in a: |
| d[i] += i |
| c[i] += 1 |
| s.append(s[-1] + i) |
| ans = float('inf') |
| p = -1 |
| for i in a: |
| if i == p: |
| continue |
| if k <= c[i]: |
| ans = 0 |
| break |
| l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i)) |
| m = r |
| if m >= k: |
| ns = l * (i - 1) - s[l] |
| su = ns - k - c[i] |
| if su < ans: |
| ans = su |
| m = n - l |
| if m >= k: |
| ns = s[n] - s[r] - (n - r) * (i + 1) |
| su = ns + k - c[i] |
| if su < ans: |
| ans = su |
| ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l] |
| su = ns + k - c[i] |
| if su < ans: |
| ans = su |
| p = i |
| print(ans) |
| return |
| |
| def __starting_point(): |
| solve() |
| __starting_point() |
| ``` |
|
|
| ### 173 |
|
|
| ```python |
| 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') |
| ``` |
|
|
| ### 174 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 175 |
|
|
| ```python |
| def main(): |
| n = int(input()) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| roundup = [] |
| rounddown = [] |
| sumsofar = [] |
| for i, (a, b) in enumerate(zip(reversed(A), reversed(B))): |
| ssf = sumsofar[-1] if sumsofar else 0 |
| t = roundup[-1] if roundup else 0 |
| roundup.append(t + ssf + b * (1 + 2 * i)) |
| t = rounddown[-1] if rounddown else 0 |
| rounddown.append(t + ssf + a * (1 + 2 * i)) |
| sumsofar.append(ssf + a + b) |
| roundup = list(reversed(roundup)) |
| rounddown = list(reversed(rounddown)) |
| sumsofar = list(reversed(sumsofar)) |
| bestres = 0 |
| sofar = 0 |
| for i, (a, b) in enumerate(zip(A, B)): |
| rup, rdo = (roundup, rounddown) |
| if i % 2: |
| a, b = (b, a) |
| rup, rdo = (rdo, rup) |
| bestres = max(bestres, sofar + rup[i] + sumsofar[i] * 2 * i) |
| sofar += a * 2 * i |
| sofar += b * (-2 * i + 1) |
| bestres = max(bestres, sofar) |
| print(bestres) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 176 |
|
|
| ```python |
| import sys |
| |
| class SegmTree: |
| |
| def __init__(self, size): |
| N = 1 |
| while N < size: |
| N <<= 1 |
| self.N = N |
| self.tree = [0] * (2 * N) |
| |
| def modify(self, i, value): |
| i += self.N |
| self.tree[i] = value |
| toXOR = False |
| while i > 1: |
| if toXOR: |
| self.tree[i >> 1] = self.tree[i] ^ self.tree[(i ^ 1) - 1] |
| else: |
| self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1] |
| toXOR = not toXOR |
| i >>= 1 |
| reader = (line.rstrip() for line in sys.stdin) |
| input = reader.__next__ |
| n, m = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| st = SegmTree(1 << n) |
| for i, value in enumerate(a): |
| st.modify(i, value) |
| for _ in range(m): |
| p, b = list(map(int, input().split())) |
| st.modify(p - 1, b) |
| print(st.tree[1]) |
| ``` |
|
|
| ### 177 |
|
|
| ```python |
| n = int(input()) |
| temp = input().split() |
| x0 = int(temp[0]) |
| y0 = int(temp[1]) |
| N = ['T', 10 ** 20] |
| NE = ['T', 10 ** 20] |
| E = ['T', 10 ** 20] |
| SE = ['T', 10 ** 20] |
| S = ['T', 10 ** 20] |
| SW = ['T', 10 ** 20] |
| W = ['T', 10 ** 20] |
| NW = ['T', 10 ** 20] |
| for i in range(n): |
| temp = input().split() |
| x = int(temp[1]) |
| y = int(temp[2]) |
| if x - x0 == 0 and y - y0 > 0 and (y - y0 < N[1]): |
| N = [temp[0], y - y0] |
| elif x - x0 == y - y0 and x - x0 > 0 and (x - x0 < NE[1]): |
| NE = [temp[0], x - x0] |
| elif y - y0 == 0 and x - x0 > 0 and (x - x0 < E[1]): |
| E = [temp[0], x - x0] |
| elif x - x0 == -(y - y0) and x - x0 > 0 and (x - x0 < SE[1]): |
| SE = [temp[0], x - x0] |
| elif x - x0 == 0 and y - y0 < 0 and (y0 - y < S[1]): |
| S = [temp[0], y0 - y] |
| elif x - x0 == y - y0 and x - x0 < 0 and (x0 - x < SW[1]): |
| SW = [temp[0], x0 - x] |
| elif y - y0 == 0 and x - x0 < 0 and (x0 - x < W[1]): |
| W = [temp[0], x0 - x] |
| elif x - x0 == -(y - y0) and x - x0 < 0 and (x0 - x < NW[1]): |
| NW = [temp[0], x0 - x] |
| if 'R' in [N[0], E[0], S[0], W[0]] and 'B' in [NE[0], SE[0], SW[0], NW[0]]: |
| print('YES') |
| elif 'Q' in [N[0], E[0], S[0], W[0], NE[0], SE[0], SW[0], NW[0]]: |
| print('YES') |
| else: |
| print('NO') |
| ``` |
|
|
| ### 178 |
|
|
| ```python |
| def inint(): |
| return int(input()) |
| |
| def inlist(): |
| return list(map(int, input().split())) |
| |
| def main(): |
| n, m, l = inlist() |
| aa = inlist() |
| chg = 0 |
| ch = 0 |
| a = [[i, 0] for i in aa] |
| for i in range(n): |
| if aa[i - 1] > l: |
| if ch == 0: |
| ch += 1 |
| chg += 1 |
| a[i][1] = chg |
| else: |
| ch += 1 |
| a[i][1] = chg |
| elif ch != 0: |
| ch = 0 |
| sol = list() |
| if n > 1: |
| for z in range(m): |
| qu = input() |
| if qu == '0': |
| sol.append(chg) |
| else: |
| zz, p, d = list(map(int, qu.split())) |
| p -= 1 |
| a[p][0] += d |
| if a[p][1] == 0 and a[p][0] > l: |
| if p > 0 and p < n - 1: |
| if a[p - 1][1] == 0 and a[p + 1][1] == 0: |
| chg += 1 |
| a[p][1] = chg |
| elif a[p - 1][1] == 0 and a[p + 1][1] > 0: |
| a[p][1] = a[p + 1][1] |
| elif a[p - 1][1] > 0 and a[p + 1][1] == 0: |
| a[p][1] = a[p - 1][1] |
| else: |
| a[p][1] = a[p - 1][1] |
| chg -= 1 |
| elif p == 0: |
| if a[p + 1][1] == 0: |
| chg += 1 |
| a[p][1] = chg |
| else: |
| a[p][1] = a[p + 1][1] |
| elif p == n - 1: |
| if a[p - 1][1] == 0: |
| chg += 1 |
| a[p][1] = chg |
| else: |
| a[p][1] = a[p - 1][1] |
| else: |
| for z in range(m): |
| qu = input() |
| if qu == '0': |
| sol.append(chg) |
| else: |
| zz, p, d = list(map(int, qu.split())) |
| p -= 1 |
| a[p][0] += d |
| if a[p][0] > d: |
| chg = 1 |
| print(*sol, sep='\n') |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 179 |
|
|
| ```python |
| n, m, k = map(int, input().split()) |
| a = [[0 for i in range(m)] for j in range(n)] |
| inf = [0 for i in range(k + 1)] |
| stat = [True for i in range(n + 1)] |
| time = [0 for i in range(n + 1)] |
| for i in range(n): |
| a[i] = list(map(int, input().split())) |
| for i in range(m): |
| for j in range(5, n + 1): |
| if stat[j]: |
| current_core = inf[a[j - 1][i]] |
| if current_core == 0 and a[j - 1][i] != 0: |
| inf[a[j - 1][i]] = j |
| elif current_core == -1: |
| stat[j], time[j] = (False, i + 1) |
| elif a[j - 1][i] != 0: |
| stat[current_core], time[current_core] = (False, i + 1) |
| stat[j], time[j] = (False, i + 1) |
| inf[a[j - 1][i]] = -1 |
| for p in range(len(inf)): |
| if inf[p] != -1: |
| inf[p] = 0 |
| for i in range(1, n + 1): |
| print(time[i]) |
| ``` |
|
|
| ### 180 |
|
|
| ```python |
| n, q, k = list(map(int, input().split(' '))) |
| a = list(map(int, input().split(' '))) |
| count = 0 |
| |
| def verify(x): |
| if x < 0 or x >= n: |
| return False |
| return a[x] > k |
| for i in range(n): |
| if verify(i): |
| count += 1 |
| if verify(i - 1): |
| count -= -1 |
| |
| def cut(i): |
| if not verify(i): |
| return 0 |
| result = 1 |
| if verify(i - 1): |
| result -= 1 |
| if verify(i + 1): |
| result -= 1 |
| return result |
| for i in range(q): |
| line = input() |
| if line == '0': |
| print(count) |
| else: |
| _, x, y = list(map(int, line.split(' '))) |
| x -= 1 |
| if not verify(x): |
| a[x] += y |
| count += cut(x) |
| else: |
| a[x] += y |
| ``` |
|
|
| ### 181 |
|
|
| ```python |
| from collections import defaultdict |
| import bisect |
| n = int(input()) |
| x0, y0 = list(map(int, input().split(' '))) |
| verticale = [] |
| horizontale = [] |
| diagonale1 = [] |
| diagonale2 = [] |
| for _ in range(n): |
| t, x, y = input().split(' ') |
| x, y = (int(x), int(y)) |
| if x == x0: |
| verticale.append((y, t)) |
| if y == y0: |
| horizontale.append((x, t)) |
| if x + y == x0 + y0: |
| diagonale1.append((x, t)) |
| if x - y == x0 - y0: |
| diagonale2.append((x, t)) |
| dead = False |
| v = sorted(verticale) |
| if v: |
| l = bisect.bisect(v, (y0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'R'}: |
| dead = True |
| elif v[len(v) - 1][1] in {'Q', 'R'}: |
| dead = True |
| v = sorted(horizontale) |
| if v: |
| l = bisect.bisect(v, (x0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'R'}: |
| dead = True |
| elif v[len(v) - 1][1] in {'Q', 'R'}: |
| dead = True |
| v = sorted(diagonale1) |
| if v: |
| l = bisect.bisect(v, (x0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'B'}: |
| dead = True |
| elif v[len(v) - 1][1] in {'Q', 'B'}: |
| dead = True |
| v = sorted(diagonale2) |
| if v: |
| l = bisect.bisect(v, (x0, 'K')) |
| if 0 < l < len(v): |
| if v[l][1] in {'Q', 'B'} or v[l - 1][1] not in {'Q', 'B'}: |
| dead = True |
| elif l == 0: |
| if v[0][1] in {'Q', 'B'}: |
| dead = True |
| elif v[len(v) - 1][1] in {'Q', 'B'}: |
| dead = True |
| if dead: |
| print('YES') |
| else: |
| print('NO') |
| ``` |
|
|
| ### 182 |
|
|
| ```python |
| from operator import or_, xor |
| import sys |
| n, m = map(int, input().split()) |
| t = [list(map(int, input().split()))] |
| for i in range(n): |
| if i & 1 == 0: |
| t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]] |
| else: |
| t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]] |
| for s in sys.stdin: |
| p, b = s.split() |
| p = int(p) - 1 |
| t[0][p] = int(b) |
| for j in range(n): |
| p = int(p / 2) |
| if j & 1 == 0: |
| t[j + 1][p] = t[j][int(p * 2)] | t[j][int(p * 2) + 1] |
| else: |
| t[j + 1][p] = t[j - 1][int(p * 2)] ^ t[j][int(p * 2) + 1] |
| sys.stdout.write(str(t[-1][0]) + '\n') |
| ``` |
|
|
| ### 183 |
|
|
| ```python |
| def main(): |
| n = int(input()) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| roundup = [] |
| rounddown = [] |
| sumsofar = [] |
| for i, (a, b) in enumerate(zip(reversed(A), reversed(B))): |
| ssf = sumsofar[-1] if sumsofar else 0 |
| t = roundup[-1] if roundup else 0 |
| roundup.append(t + ssf + b * (1 + 2 * i)) |
| t = rounddown[-1] if rounddown else 0 |
| rounddown.append(t + ssf + a * (1 + 2 * i)) |
| sumsofar.append(ssf + a + b) |
| roundup = list(reversed(roundup)) |
| rounddown = list(reversed(rounddown)) |
| sumsofar = list(reversed(sumsofar)) |
| bestres = 0 |
| sofar = 0 |
| for i, (a, b) in enumerate(zip(A, B)): |
| rup, rdo = (roundup, rounddown) |
| if i % 2: |
| a, b = (b, a) |
| rup, rdo = (rdo, rup) |
| bestres = max(bestres, sofar + rup[i] + sumsofar[i] * 2 * i) |
| sofar += a * 3 * i |
| sofar += b * (2 * i + 1) |
| bestres = max(bestres, sofar) |
| print(bestres) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 184 |
|
|
| ```python |
| n = int(input()) |
| a = [list(map(int, input().split())) for i in range(2)] |
| if n != 1: |
| sum_up, pref_up, sum_down, pref_down = [[[0 for i in range(n)] for j in range(2)] for _ in range(4)] |
| for i in range(2): |
| sum_up[i][n - 1] = a[i][n - 1 - 1] |
| pref_up[i][n - 1] = a[i][n - 1] |
| pref_down[i][n - 1] = a[i][n - 1] |
| for j in range(n - 2, -1, -1): |
| sum_up[i][j] = sum_up[i][j + 1] + a[i][j] |
| pref_up[i][j] = pref_up[i][j + 1] + sum_up[i][j] |
| pref_down[i][j] = pref_down[i][j + 1] + a[i][j] * (n - j) |
| zig = [[0 for i in range(n)] for j in range(2)] |
| for j in range(n): |
| for i in range(2): |
| if j % 2 == 0: |
| if i == 0: |
| zig[i][j] = a[i][j] * j * 2 + zig[i][j - 1] |
| else: |
| zig[i][j] = a[i][j] * (j * 2 + 1) + zig[1 - i][j] |
| elif i == 0: |
| zig[1 - i][j] = a[1 - i][j] * j * 2 + zig[1 - i][j - 1] |
| else: |
| zig[1 - i][j] = a[1 - i][j] * (j * 2 + 1) + zig[i][j] |
| ans = -1e+18 |
| for j in range(n): |
| if j == 0: |
| ans = max(ans, pref_up[0][j] + pref_down[1][j] + sum_up[1][j] * n - sum_up[0][j] - sum_up[1][j]) |
| elif j == n - 1: |
| ans = max(ans, zig[1 - j % 2][n - 1]) |
| elif j % 2 == 1: |
| ans = max(ans, pref_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2 + 1) - 1) + pref_down[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2 + 1) - 1 + n - j) + zig[0][j]) |
| else: |
| ans = max(ans, pref_up[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2) + 2) + pref_down[0][j + 1] - sum_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2) + 2 - 1 + n - j) + zig[1][j]) |
| ans = max(ans, pref_up[1][0] + pref_down[0][1] + sum_up[0][1] * n) |
| print(ans) |
| else: |
| print(a[1][0]) |
| ``` |
|
|
| ### 185 |
|
|
| ```python |
| import sys |
| nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split())) |
| meches = list(map(int, sys.stdin.readline().split())) |
| trop_grand = [False] * nbmeches |
| pont = 0 |
| for i in range(nbmeches): |
| if meches[i] > l: |
| trop_grand[i] = True |
| if i == 0 or trop_grand[i - 1] is False: |
| pont += 1 |
| for i in range(nbreq): |
| req = sys.stdin.readline().split() |
| if int(req[0]) == 0: |
| print(pont) |
| else: |
| meches[int(req[1]) - 1] += int(req[2]) |
| if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]): |
| trop_grand[int(req[1]) - 1] = True |
| if nbmeches == 1: |
| pont = 1 |
| elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]): |
| pont += 1 |
| elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]): |
| pont += 1 |
| elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]: |
| pont = max(0, pont - 1) |
| elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]): |
| pont += 1 |
| ``` |
|
|
| ### 186 |
|
|
| ```python |
| from math import log |
| import sys |
| |
| def buildTree(arr): |
| n = len(arr) |
| tree = [0] * n + arr |
| for i in range(n - 1, 0, -1): |
| z = int(log(i, 2)) |
| if N % 2 == 0: |
| if z % 2 == 0: |
| tree[i] = tree[2 * i] ^ tree[2 * i + 1] |
| else: |
| tree[i] = tree[2 * i] | tree[2 * i + 1] |
| elif z % 2 == 0: |
| tree[i] = tree[2 * i] | tree[2 * i + 1] |
| else: |
| tree[i] = tree[2 * i] ^ tree[2 * i + 1] |
| return tree |
| |
| def updateTree(tree, ind, value, n): |
| ind += n |
| tree[ind] = value |
| while ind > 1: |
| ind //= 2 |
| z = int(log(ind, 2)) |
| if N % 2 == 0: |
| if z % 2 == 0: |
| tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1] |
| else: |
| tree[ind] = tree[2 * ind] | tree[2 * ind + 1] |
| elif not z % 2 == 0: |
| tree[ind] = tree[2 * ind] | tree[2 * ind + 1] |
| else: |
| tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1] |
| return tree |
| N, m = map(int, sys.stdin.readline().strip().split()) |
| arr = list(map(int, sys.stdin.readline().strip().split())) |
| tree = buildTree(arr) |
| for i in range(m): |
| ind, val = map(int, sys.stdin.readline().strip().split()) |
| tree = updateTree(tree, ind - 1, val, len(arr)) |
| print(tree[1]) |
| ``` |
|
|
| ### 187 |
|
|
| ```python |
| from sys import stdin, stderr |
| import random |
| import cProfile |
| |
| def readInts(): |
| return map(int, stdin.readline().strip().split()) |
| |
| def print_err(*args, **kwargs): |
| print(*args, file=stderr, **kwargs) |
| |
| def solve(vs): |
| return None |
| |
| def generate_tree(n, ns): |
| out = [0 for _ in range(2 ** (n + 1))] |
| |
| def gt(nix, left, right, op): |
| if left + 1 == right: |
| out[nix] = ns[left] |
| return out[nix] |
| mid = (left + right) // 2 |
| nL = nix * 2 + 1 |
| nR = nix * 2 + 2 |
| vL = gt(nL, left, mid, not op) |
| vR = gt(nR, mid, right, not op) |
| if op: |
| v = vL ^ vR |
| else: |
| v = vL | vR |
| out[nix] = v |
| return v |
| gt(0, 0, 2 ** n, n % 2 == 0) |
| return out |
| |
| def alter_tree2(n, t, p, b): |
| |
| def at(nix, width, offp, op): |
| if width == 1: |
| t[nix] = b |
| return b |
| width //= 2 |
| nL = nix * 2 + 1 |
| nR = nix * 2 + 2 |
| vL = t[nL] |
| vR = t[nR] |
| if offp >= width: |
| vR = at(nR, width, offp - width, not op) |
| else: |
| vL = at(nL, width, offp, not op) |
| if op: |
| v = vL ^ vR |
| else: |
| v = vL | vR |
| t[nix] = v |
| return v |
| at(0, 2 ** n, p, n % 2 == 0) |
| |
| def alter_tree(n, t, p, b): |
| width = 2 ** n |
| s = [] |
| nix = 0 |
| op = n % 2 == 0 |
| while width > 1: |
| width //= 2 |
| if p >= width: |
| nix2 = 2 * nix + 2 |
| s.append((nix, nix2 - 1)) |
| p -= width |
| else: |
| nix2 = 2 * nix + 1 |
| s.append((nix, nix2 + 1)) |
| nix = nix2 |
| op = not op |
| t[nix] = b |
| v = b |
| while s: |
| nix, nixO = s.pop() |
| if op: |
| v |= t[nixO] |
| else: |
| v |= t[nixO] |
| t[nix] = v |
| op = not op |
| return |
| |
| def run(): |
| n, m = readInts() |
| axs = list(readInts()) |
| t = generate_tree(n, axs) |
| for _ in range(m): |
| p, b = readInts() |
| alter_tree(n, t, p - 1, b) |
| print(t[0]) |
| |
| def test(): |
| n = 17 |
| ns = [] |
| vs100 = list(range(100)) |
| for _ in range(2 ** 17): |
| ns.append(random.choice(vs100)) |
| t = generate_tree(n, ns) |
| t2 = generate_tree(n, ns) |
| for _ in range(100000): |
| v1 = random.choice(vs100) |
| v2 = random.choice(vs100) |
| alter_tree(n, t, v1, v2) |
| alter_tree2(n, t2, v1, v2) |
| print(all(map(lambda x: x[0] == x[1], zip(t, t2)))) |
| print(t[0] == t2[0]) |
| run() |
| ``` |
|
|
| ### 188 |
|
|
| ```python |
| n, q, k = list(map(int, input().split(' '))) |
| a = list(map(int, input().split(' '))) |
| count = 0 |
| |
| def verify(x): |
| if x < 0 or x >= n: |
| return False |
| return a[x] > k |
| for i in range(n): |
| if verify(i): |
| count += 1 |
| if verify(i - 1): |
| count -= 1 |
| |
| def cut(i): |
| if not verify(i): |
| return 0 |
| result = 1 |
| if verify(i - 1): |
| result -= 1 |
| if verify(i + 1): |
| result -= 1 |
| return result |
| for i in range(q): |
| line = input() |
| if line == '0': |
| print(count) |
| else: |
| _, x, y = list(map(int, line.split(' '))) |
| x -= 1 |
| if not verify(x): |
| a[x] += y |
| count += cut(x) |
| else: |
| a[x] += y |
| ``` |
|
|
| ### 189 |
|
|
| ```python |
| 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() |
| ``` |
|
|
| ### 190 |
|
|
| ```python |
| n = int(input()) |
| influences = [[], [], [], []] |
| for i in range(0, n): |
| [support, influence] = [x for x in input().split()] |
| support = int(support, 2) |
| influences[support].append(int(influence)) |
| for i in range(0, 4): |
| influences[i] = sorted(influences[i]) |
| influences[i].reverse() |
| total_influence = 0 |
| total_influence += sum(influences[3]) |
| min_size = min(len(influences[2]), len(influences[1])) |
| total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size]) |
| size = len(influences[3]) |
| influences[0] += influences[1][min_size:] + influences[1][min_size:] |
| influences[0] = sorted(influences[0]) |
| influences[0].reverse() |
| total_influence += sum(influences[0][:size]) |
| print(total_influence) |
| ``` |
|
|
| ### 191 |
|
|
| ```python |
| n = int(input()) |
| influences = [[], [], [], []] |
| for i in range(0, n): |
| [support, influence] = [x for x in input().split()] |
| support = int(support, 2) |
| influences[support].append(int(influence)) |
| for i in range(0, 4): |
| influences[i] = sorted(influences[i]) |
| influences[i].reverse() |
| total_influence = 0 |
| total_influence += sum(influences[3]) |
| min_size = min(len(influences[2]), len(influences[1])) |
| total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size]) |
| size = len(influences[3]) |
| influences[0] += influences[1][min_size:] + influences[0][min_size:] |
| influences[0] = sorted(influences[0]) |
| influences[0].reverse() |
| total_influence += sum(influences[0][:size]) |
| print(total_influence) |
| ``` |
|
|
| ### 192 |
|
|
| ```python |
| from collections import defaultdict, deque |
| from heapq import heappush, heappop |
| from itertools import permutations, accumulate |
| import sys |
| import math |
| import bisect |
| |
| def LI(): |
| return [int(x) for x in sys.stdin.readline().split()] |
| |
| def I(): |
| return int(sys.stdin.readline()) |
| |
| def LS(): |
| return [list(x) for x in sys.stdin.readline().split()] |
| |
| def S(): |
| res = list(sys.stdin.readline()) |
| if res[-1] == '\n': |
| return res[:-1] |
| return res |
| |
| def IR(n): |
| return [I() for i in range(n)] |
| |
| def LIR(n): |
| return [LI() for i in range(n)] |
| |
| def SR(n): |
| return [S() for i in range(n)] |
| |
| def LSR(n): |
| return [LS() for i in range(n)] |
| sys.setrecursionlimit(1000000) |
| mod = 1000000007 |
| |
| def solve(): |
| n, k = LI() |
| a = LI() |
| a.sort() |
| d = defaultdict(lambda: 0) |
| c = defaultdict(lambda: 0) |
| s = [0] |
| for i in a: |
| d[i] += i |
| c[i] += 1 |
| s.append(s[-1] + i) |
| ans = float('inf') |
| p = -1 |
| for i in a: |
| if i == p: |
| continue |
| if k >= c[i]: |
| ans = 0 |
| break |
| l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i)) |
| m = r |
| if m >= k: |
| ns = l * (i - 1) - s[l] |
| su = ns + k - c[i] |
| if su < ans: |
| ans = su |
| m = n - l |
| if m >= k: |
| ns = s[n] - s[r] - (n - r) * (i + 1) |
| su = ns + k - c[i] |
| if su < ans: |
| ans = su |
| ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l] |
| su = ns + k - c[i] |
| if su < ans: |
| ans = su |
| p = i |
| print(ans) |
| return |
| |
| def __starting_point(): |
| solve() |
| __starting_point() |
| ``` |
|
|
| ### 193 |
|
|
| ```python |
| import sys |
| read = lambda: list(map(int, sys.stdin.readline().split())) |
| n, m, k = read() |
| table = [] |
| for _ in range(n): |
| table.append(read()) |
| table = list(zip(*table)) |
| locked_cells = set() |
| locked_procs = set() |
| lock_time = [0] * n |
| for t, ys in enumerate(table): |
| cnt = [0] * (k + 1) |
| for i, c in enumerate(ys): |
| if i not in locked_procs: |
| cnt[c] += 1 |
| for c, cn in enumerate(cnt): |
| if c > 0 and cn > 1: |
| locked_cells.add(c) |
| for i, c in enumerate(ys): |
| if c in locked_cells and i not in locked_procs: |
| locked_procs.add(i) |
| lock_time[i] = t + 1 |
| for t in lock_time: |
| print(t) |
| ``` |
|
|
| ### 194 |
|
|
| ```python |
| def __starting_point(): |
| n = int(input()) |
| supporters = {} |
| supporters[0] = [] |
| supporters[1] = [] |
| supporters[10] = [] |
| supporters[11] = [] |
| for i in range(n): |
| [x, y] = [int(x) for x in input().split()] |
| supporters[x].append(y) |
| for x in supporters: |
| supporters[x].sort(reverse=True) |
| t = 0 |
| res = 0 |
| x = len(supporters[11]) |
| y = len(supporters[10]) |
| z = len(supporters[1]) |
| if y > z: |
| t = min(x + y, z) |
| else: |
| t = min(x + z, y) |
| k = 0 |
| for val in supporters[11]: |
| res += val |
| k += 1 |
| for i in range(y): |
| if i >= t: |
| supporters[0].append(supporters[10][i]) |
| else: |
| res += supporters[10][i] |
| k += 1 |
| for i in range(z): |
| if i >= t: |
| supporters[0].append(supporters[1][i]) |
| else: |
| res += supporters[1][i] |
| k += 1 |
| supporters[0].sort(reverse=True) |
| t = min(x + y, x + z) |
| i = 0 |
| while 2 * t > k and i < len(supporters[0]): |
| k += 1 |
| res += supporters[0][i] |
| i += 4 |
| print(res) |
| __starting_point() |
| ``` |
|
|
| ### 195 |
|
|
| ```python |
| n, m, k = map(int, input().split()) |
| a = [[0 for i in range(m)] for j in range(n)] |
| inf = [0 for i in range(k + 1)] |
| stat = [True for i in range(n + 1)] |
| time = [0 for i in range(n + 1)] |
| for i in range(n): |
| a[i] = list(map(int, input().split())) |
| for i in range(m): |
| for j in range(1, n + 1): |
| if stat[j]: |
| current_core = inf[a[j - 1][i]] |
| if current_core == 0 and a[j - 1][i] != 0: |
| inf[a[j - 1][i]] = j |
| elif current_core == -1: |
| stat[j], time[j] = (False, i + 1) |
| elif a[j - 1][i] != 0: |
| stat[current_core], time[current_core] = (False, i + 1) |
| stat[j], time[j] = (False, i + 1) |
| inf[a[j - 1][i]] = -1 |
| for p in range(len(inf)): |
| if inf[p] != -1: |
| inf[p] = 0 |
| for i in range(1, n + 1): |
| print(time[i - 1]) |
| ``` |
|
|
| ### 196 |
|
|
| ```python |
| from math import ceil |
| n, A = (int(input()), []) |
| a = b = ab = ab_ = ans = 0 |
| for _ in range(n): |
| t, tt = input().split() |
| tt = int(tt) |
| if t != '11': |
| A.append([t, tt]) |
| if t == '10': |
| a += 1 |
| elif t == '01': |
| b += 1 |
| else: |
| ab_ += 1 |
| else: |
| ans += tt |
| ab += -1 |
| A.sort(reverse=True, key=lambda x: x[1]) |
| x = y = t = ttt = ab |
| k, j = (a, b) |
| for i in A: |
| if i[0] == '10' and (j or ttt): |
| ans += i[1] |
| t += 1 |
| x += 1 |
| if j == 0 and ttt: |
| ttt -= 1 |
| j = 1 |
| j -= 1 |
| elif i[0] == '01' and (k or ttt): |
| ans += i[1] |
| t += 1 |
| y += 1 |
| if k == 0 and ttt: |
| ttt -= 1 |
| k = 1 |
| k -= 1 |
| elif i[0] == '00' and ttt: |
| ans += i[1] |
| ttt -= 1 |
| t += 1 |
| print(ans) |
| ``` |
|
|
| ### 197 |
|
|
| ```python |
| n = int(input()) |
| su0 = [] |
| su1 = [] |
| su00 = [] |
| su11 = [] |
| ans = 0 |
| for i in range(n): |
| sup, val = map(int, input().split()) |
| if sup == 0: |
| su00.append(val) |
| elif sup == 11: |
| su11.append(val) |
| elif sup == 1: |
| su0.append(val) |
| else: |
| su1.append(val) |
| su0.sort(reverse=True) |
| su1.sort() |
| su11.sort() |
| su00.sort() |
| while len(su1) != 0 and len(su0) != 0: |
| ans += su1[len(su1) - 1] + su0[len(su0) - 1] |
| su1.pop() |
| su0.pop() |
| while len(su11) != 0 and len(su00) != 0: |
| if len(su1) != 0: |
| k = 1 |
| elif len(su0) != 0: |
| k = 0 |
| else: |
| k = 2 |
| if k == 0: |
| if su00[len(su00) - 1] > su0[len(su0) - 1]: |
| ans += su11[len(su11) - 1] + su00[len(su00) - 1] |
| su11.pop() |
| su00.pop() |
| else: |
| ans += su11[len(su11) - 1] + su0[len(su0) - 1] |
| su11.pop() |
| su0.pop() |
| elif k == 1: |
| if su00[len(su00) - 1] > su1[len(su1) - 1]: |
| ans += su11[len(su11) - 1] + su00[len(su00) - 1] |
| su11.pop() |
| su00.pop() |
| else: |
| ans += su11[len(su11) - 1] + su1[len(su1) - 1] |
| su11.pop() |
| su1.pop() |
| else: |
| ans += su11[len(su11) - 1] + su00[len(su00) - 1] |
| su11.pop() |
| su00.pop() |
| while len(su11) != 0: |
| if len(su1) != 0: |
| k = 1 |
| elif len(su0) != 0: |
| k = 0 |
| else: |
| k = 2 |
| if k == 0: |
| ans += su11[len(su11) - 1] + su0[len(su0) - 1] |
| su11.pop() |
| su0.pop() |
| elif k == 1: |
| ans += su11[len(su11) - 1] + su1[len(su1) - 1] |
| su11.pop() |
| su1.pop() |
| else: |
| ans += su11[len(su11) - 1] |
| su11.pop() |
| print(ans) |
| ``` |
|
|
| ### 198 |
|
|
| ```python |
| def inint(): |
| return int(input()) |
| |
| def inlist(): |
| return list(map(int, input().split())) |
| |
| def main(): |
| n, m, l = inlist() |
| aa = inlist() |
| chg = 0 |
| ch = 0 |
| a = [[i, 0] for i in aa] |
| for i in range(n): |
| if aa[i] > l: |
| if ch == 0: |
| ch += 1 |
| chg += 1 |
| a[i][1] = chg |
| else: |
| ch += 1 |
| a[i - 1][1] = chg |
| elif ch != 0: |
| ch = 0 |
| sol = list() |
| if n > 1: |
| for z in range(m): |
| qu = input() |
| if qu == '0': |
| sol.append(chg) |
| else: |
| zz, p, d = list(map(int, qu.split())) |
| p -= 1 |
| a[p][0] += d |
| if a[p][1] == 0 and a[p][0] > l: |
| if p > 0 and p < n - 1: |
| if a[p - 1][1] == 0 and a[p + 1][1] == 0: |
| chg += 1 |
| a[p][1] = chg |
| elif a[p - 1][1] == 0 and a[p + 1][1] > 0: |
| a[p][1] = a[p + 1][1] |
| elif a[p - 1][1] > 0 and a[p + 1][1] == 0: |
| a[p][1] = a[p - 1][1] |
| else: |
| a[p][1] = a[p - 1][1] |
| chg -= 1 |
| elif p == 0: |
| if a[p + 1][1] == 0: |
| chg += 1 |
| a[p][1] = chg |
| else: |
| a[p][1] = a[p + 1][1] |
| elif p == n - 1: |
| if a[p - 1][1] == 0: |
| chg += 1 |
| a[p][1] = chg |
| else: |
| a[p][1] = a[p - 1][1] |
| else: |
| for z in range(m): |
| qu = input() |
| if qu == '0': |
| sol.append(chg) |
| else: |
| zz, p, d = list(map(int, qu.split())) |
| p -= 1 |
| a[p][0] += d |
| if a[p][0] > d: |
| chg = 1 |
| print(*sol, sep='\n') |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 199 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 200 |
|
|
| ```python |
| 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) |
| ``` |
|
|
| ### 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. |
| |
