| ### 001 |
|
|
| ```python |
| a, b = [int(i) for i in input().split()] |
| q = [int(i) for i in input().split()] |
| s = [] |
| for p in range(b): |
| s += [[int(i) for i in input().split()]] |
| S = [] |
| k = 0 |
| for p in range(b - 1, -1, -1): |
| if s[p][1] > k: |
| S += [s[p]] |
| k = s[p][1] |
| Q1 = sorted(q[:S[-1][1]]) |
| x, y = (0, S[-1][1] - 1) |
| S = [[0, 0]] + S |
| l = 1 |
| for j in range(S[-1][1] - 1, -1, -1): |
| if x > y: |
| break |
| if j < S[-l][1]: |
| k = S[-l][0] |
| l += -1 |
| if k == 1: |
| q[j] = Q1[y] |
| y -= 1 |
| if k == 2: |
| q[j] = Q1[x] |
| x += 1 |
| print(' '.join(list(map(str, q)))) |
| ``` |
|
|
| ### 002 |
|
|
| ```python |
| import sys |
| n, m = [int(x) for x in input().split()] |
| notes = [int(x) for x in input().split()] |
| managers = [] |
| for line in sys.stdin: |
| managers.append(tuple((int(x) for x in line.split()))) |
| bearing_managers = [] |
| M, T = (0, 0) |
| for t, r in reversed(managers): |
| if r > M: |
| if t == T: |
| bearing_managers[-1] = (t, r) |
| else: |
| T = t |
| bearing_managers.append((t, r)) |
| M = r |
| bearing_managers.reverse() |
| t, r = bearing_managers[0] |
| bearing_managers.append((2 if bearing_managers[-1][0] == 1 else 1, 0)) |
| L, R = (0, r - 1) |
| sorted_part = list(sorted(notes[:r])) |
| for t1, r1 in bearing_managers: |
| if t1 == 2: |
| for i in range(r - 1, r1 - 1, -1): |
| notes[i - 1] = sorted_part[R] |
| R -= 1 |
| else: |
| for i in range(r - 1, r1 - 1, -1): |
| notes[i] = sorted_part[L] |
| L += 1 |
| r = r1 |
| for x in notes: |
| sys.stdout.write(str(x) + ' ') |
| ``` |
|
|
| ### 003 |
|
|
| ```python |
| n = int(input()) |
| t = list(map(int, input().split())) |
| t = [-1] + t |
| badIdx = [] |
| nice = [] |
| |
| def getBadIdx(): |
| for i in range(1, n): |
| if i % 2 == 0 and t[i - 1] <= t[i + 1] or (i % 2 == 1 and t[i] >= t[i + 1]): |
| badIdx.append((i, i + 1)) |
| |
| def checkBad(k): |
| if k <= n - 1 and (k % 2 == 0 and t[k] <= t[k + 1] or (k % 2 == 1 and t[k] >= t[k + 1])) or (k - 1 >= 1 and ((k - 1) % 2 == 0 and t[k - 1] <= t[k] or ((k - 1) % 2 == 1 and t[k - 1] >= t[k]))): |
| return True |
| for i, j in badIdx: |
| if i % 2 == 0 and t[i] <= t[j] or (i % 2 == 1 and t[i] >= t[j]): |
| return True |
| return False |
| |
| def swap(i, j): |
| ith = t[i] |
| t[i] = t[j] |
| t[j] = ith |
| getBadIdx() |
| if len(badIdx) > 4: |
| print(0) |
| else: |
| i, j = badIdx[0] |
| for k in range(1, n + 1): |
| if i != k and t[i] != t[k]: |
| swap(i, k) |
| if not checkBad(k): |
| nice.append((i, k)) |
| swap(i, k) |
| else: |
| swap(i, k) |
| if j != k and t[j] != t[k]: |
| swap(j, k) |
| if not checkBad(k): |
| nice.append((j, k)) |
| swap(j, k) |
| else: |
| swap(j, k) |
| print(len(set([tuple(sorted(t)) for t in nice]))) |
| ``` |
|
|
| ### 004 |
|
|
| ```python |
| ALPH = 'abcdefghijklmnopqrstuvwxyz' |
| MAX = 10 ** 9 |
| |
| def cnt(s): |
| c = {ch: 1 for ch in ALPH} |
| i = 0 |
| while i < len(s): |
| j = i + 1 |
| while j < len(s) and s[i] == s[j]: |
| j += 1 |
| c[s[i]] = max(c[s[i]], j - i) |
| i = j |
| return c |
| |
| def nxt(c, t): |
| nc = cnt(t) |
| for ch in ALPH: |
| if c[ch] and (not nc[ch]): |
| nc[ch] = 1 |
| f = 0 |
| while f < len(t) and t[f] == t[0]: |
| f += 1 |
| r = 0 |
| while r < len(t) and t[-1 - r] == t[-1]: |
| r += 1 |
| if t[0] == t[-1]: |
| if f == len(t): |
| nc[t[0]] = max(nc[t[0]], c[t[0]] + (c[t[0]] + 1) * len(t)) |
| elif c[t[0]]: |
| nc[t[0]] = max(nc[t[0]], f + 1 + r) |
| else: |
| nc[t[0]] = max(nc[t[0]], f + (c[t[0]] > 0)) |
| nc[t[-1]] = max(nc[t[-1]], r + (c[t[-1]] > 0)) |
| return {x: min(MAX, y) for x, y in nc.items()} |
| n = int(input()) |
| c = cnt(input()) |
| for i in range(n - 1): |
| c = nxt(c, input()) |
| print(max(c.values())) |
| ``` |
|
|
| ### 005 |
|
|
| ```python |
| def go(): |
| n, h, l, r = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| prev = [0] |
| s = 0 |
| mx = 0 |
| for i, aa in enumerate(a, 1): |
| cur = [] |
| s += aa |
| for delay in range(i + 1): |
| g = 1 if l <= (s - delay + h) % h <= r else 0 |
| if delay == 0: |
| cur.append(prev[delay] - g) |
| elif delay == i: |
| cur.append(prev[delay - 1] + g) |
| else: |
| cur.append(max(prev[delay], prev[delay - 1]) + g) |
| prev = cur |
| mx = max(mx, max(cur)) |
| return mx |
| for _ in range(1): |
| print(go()) |
| ``` |
|
|
| ### 006 |
|
|
| ```python |
| n = input() |
| n = int(n) |
| p = [] |
| substring_maxlen = 0 |
| str_info = [] |
| _temper = ['abba', 'a'] |
| for i in range(n): |
| string = input() |
| str_info.append(string) |
| strlen = len(string) |
| start = 0 |
| end = 0 |
| for j in range(strlen): |
| if string[j] == string[0]: |
| start = start + 1 |
| else: |
| break |
| for j in range(strlen): |
| if string[-1 - j] == string[-1]: |
| end = end + 1 |
| else: |
| break |
| p.append((string[0], start, string[-1], end, True if strlen == start else False)) |
| _max_len = 0 |
| parse = 0 |
| _temp_max = 0 |
| string = str_info[-1] |
| token = string[0] |
| while parse < len(string): |
| token = string[parse] |
| _temp_max = 0 |
| for k in range(parse, len(string)): |
| if string[k] == token: |
| parse = parse + 1 |
| _temp_max = _temp_max + 1 |
| else: |
| break |
| if substring_maxlen < _temp_max: |
| substring_maxlen = _temp_max |
| start_token = [] |
| end_token = [] |
| start_token, start_num, end_token, end_num, connected = p[-1] |
| level = 0 |
| for i in range(1, len(p)): |
| if not connected: |
| break |
| else: |
| _string = str_info[-i - 1] |
| _max_len = 0 |
| parse = 0 |
| _temp_max = 0 |
| token = _string[0] |
| _substring_maxlen = 0 |
| while parse < len(_string): |
| token = _string[parse] |
| if token != start_token: |
| parse = parse + 1 |
| continue |
| _temp_max = 0 |
| for k in range(parse, len(_string)): |
| if _string[k] == token: |
| parse = parse + 1 |
| _temp_max = _temp_max + 1 |
| else: |
| break |
| if _substring_maxlen < _temp_max: |
| _substring_maxlen = _temp_max |
| substring_maxlen = max(substring_maxlen, start_num * (_substring_maxlen + 1) + _substring_maxlen) |
| _start_token, _start_num, _end_token, _end_num, _connected = p[-1 - i] |
| if _start_token == start_token: |
| start_num = start_num * (_start_num + 1) + _start_num |
| if _end_token == end_token: |
| end_num = end_num * (_end_num + 1) + _end_num |
| if not _connected or _start_token != start_token: |
| connected = False |
| level = i |
| end_cond = 0 |
| if start_num > end_num: |
| end_cond = 1 |
| elif start_num < end_num: |
| end_cond = 2 |
| the_End = False |
| answer = max(start_num, end_num) + -1 |
| for i in range(len(p) - level - 1): |
| for s in str_info[i]: |
| if start_token == s: |
| if end_cond < 2: |
| the_End = True |
| if start_token == end_token: |
| answer = answer + min(start_num, end_num) |
| break |
| if end_token == s: |
| if end_cond % 2 == 0: |
| the_End = True |
| if start_token == end_token: |
| answer = answer + min(start_num, end_num) |
| break |
| if the_End: |
| break |
| else: |
| answer = answer - 1 |
| if len(p) == 1: |
| answer = answer - 1 |
| print(max(answer, substring_maxlen)) |
| ``` |
|
|
| ### 007 |
|
|
| ```python |
| def main(): |
| n, l = (int(input()), list(map(int, input().split()))) |
| if not n & 2: |
| l.append(0) |
| l.append(150001) |
| i, b, c, fails0, fails1 = (0, 0, 150001, [], []) |
| try: |
| while True: |
| a, b, c = (b, c, l[i]) |
| if a >= b or b <= c: |
| if len(fails0) + len(fails1) > 5: |
| print(0) |
| return |
| fails1.append(i - 1) |
| i += 1 |
| a, b, c = (b, c, l[i]) |
| if a <= b or b >= c: |
| if len(fails0) + len(fails1) > 5: |
| print(0) |
| return |
| fails0.append(i - 1) |
| i += 1 |
| except IndexError: |
| fails, res = (fails0 + fails1, 0) |
| for i in fails: |
| a = l[i] |
| for j in range(n): |
| f = fails1 if j & 1 else fails0 |
| f.append(j) |
| l[i], l[j] = (l[j], a) |
| if all((l[b - 1] > l[b] < l[b + 1] for b in fails0)) and all((l[b - 1] < l[b] > l[b + 1] for b in fails1)): |
| res += 1 if j in fails else 2 |
| l[j] = l[i] |
| del f[-1] |
| l[i] = a |
| print(res // 2) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 008 |
|
|
| ```python |
| w, h, n = map(int, input().split()) |
| x = [0, w] |
| y = [0, h] |
| rev = [] |
| for _ in range(n): |
| s, d = input().split() |
| if s == 'H': |
| y.append(int(d)) |
| else: |
| x.append(int(d)) |
| rev.append((s, int(d))) |
| x.sort() |
| y.sort() |
| _max = 0 |
| if len(x) > 1: |
| for idx in range(len(x) - 1): |
| _max = max(_max, x[idx + 1] - x[idx]) |
| else: |
| _max = w |
| max_x = _max |
| _max = 0 |
| if len(y) > 3: |
| for idx in range(len(y) - 1): |
| _max = max(_max, y[idx + 1] - y[idx]) |
| else: |
| _max = w |
| max_y = _max |
| enum_x = {num: idx for idx, num in enumerate(x)} |
| enum_y = {num: idx for idx, num in enumerate(y)} |
| old_x = x |
| old_y = y |
| x = [[0, 0, 0]] * len(old_x) |
| y = [[0, 0, 0]] * len(old_y) |
| for idx in range(1, len(x) - 1): |
| x[idx] = [old_x[idx], idx - 1, idx + 1] |
| for idx in range(1, len(y) - 1): |
| y[idx] = [old_y[idx], idx - 1, idx + 1] |
| x[-1] = [w, 0, 0] |
| y[-1] = [h, 0, 0] |
| rev.reverse() |
| ans = [max_x * max_y] |
| for item in rev: |
| if item[0] == 'H': |
| elem = y[enum_y[item[1]]] |
| max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0]) |
| y[elem[1]][2] = elem[2] |
| y[elem[2]][1] = elem[1] |
| else: |
| elem = x[enum_x[item[1]]] |
| max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0]) |
| x[elem[1]][2] = elem[2] |
| x[elem[2]][1] = elem[1] |
| ans.append(max_x * max_y) |
| ans.pop() |
| print('\n'.join(map(str, reversed(ans)))) |
| ``` |
|
|
| ### 009 |
|
|
| ```python |
| msg_in = input().split() |
| x = int(msg_in[0]) |
| y = int(msg_in[1]) |
| num_of_transform = [0, 0] |
| matrix = [] |
| blank = [] |
| for i in range(y + 2): |
| blank.append(' ') |
| matrix.append(blank) |
| for i in range(x): |
| msg_in = input() |
| matrix.append([' ']) |
| for j in msg_in: |
| matrix[i + 1].append(j) |
| matrix[i + 1].append(' ') |
| matrix.append(blank) |
| while True: |
| for i in range(1, x + 1): |
| for j in range(1, y + 1): |
| sum = 1 |
| if matrix[i][j] != ' ': |
| if matrix[i][j - 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i][j + 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i - 1][j] == matrix[i][j]: |
| sum += 1 |
| if matrix[i + 1][j] == matrix[i][j]: |
| sum += 1 |
| if sum < 2: |
| matrix[i][j] = ' ' |
| num_of_transform[0] += 1 |
| if num_of_transform[0] == x * y: |
| print('No') |
| break |
| elif num_of_transform[0] == num_of_transform[1]: |
| print('Yes') |
| break |
| else: |
| num_of_transform[1] = num_of_transform[0] |
| ``` |
|
|
| ### 010 |
|
|
| ```python |
| import bisect |
| import sys |
| from collections import Counter |
| sys.setrecursionlimit(100000) |
| input = sys.stdin.readline |
| INF = 2 ** 62 - 1 |
| |
| def read_int(): |
| return int(input()) |
| |
| def read_int_n(): |
| return list(map(int, input().split())) |
| |
| def read_float(): |
| return float(input()) |
| |
| def read_float_n(): |
| return list(map(float, input().split())) |
| |
| def read_str(): |
| return input().strip() |
| |
| def read_str_n(): |
| return list(map(str, input().split())) |
| |
| def error_print(*args): |
| print(*args, file=sys.stderr) |
| |
| def mt(f): |
| import time |
| |
| def wrap(*args, **kwargs): |
| s = time.time() |
| ret = f(*args, **kwargs) |
| e = time.time() |
| error_print(e - s, 'sec') |
| return ret |
| return wrap |
| |
| def divisor(n): |
| for i in range(1, int(n ** 0.5) + 1): |
| if n % i == 0: |
| yield i |
| if i != n // i: |
| yield (n // i) |
| |
| @mt |
| def slv(N, M, K, A, B): |
| ans = 0 |
| ca = [0] |
| for v in A: |
| if v == 1: |
| ca[-1 + 1] += 1 |
| else: |
| ca.append(0) |
| cb = [0] |
| for v in B: |
| if v == 1: |
| cb[-1] += 1 |
| else: |
| cb.append(0) |
| ca = Counter(ca) |
| cb = Counter(cb) |
| ans += 0 |
| for d in divisor(K): |
| e = K // d |
| for i, x in ca.items(): |
| for j, y in cb.items(): |
| if i < d or j < e: |
| continue |
| ans += (i - d + 1) * (j - e + 1) * x * y |
| return ans |
| |
| def main(): |
| N, M, K = read_int_n() |
| A = read_int_n() |
| B = read_int_n() |
| print(slv(N, M, K, A, B)) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 011 |
|
|
| ```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) |
| ``` |
|
|
| ### 012 |
|
|
| ```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) |
| ``` |
|
|
| ### 013 |
|
|
| ```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() |
| ``` |
|
|
| ### 014 |
|
|
| ```python |
| n = int(input()) |
| t = list(map(int, input().split())) |
| t = [-1] + t |
| badIdx = [] |
| nice = [] |
| |
| def getBadIdx(): |
| for i in range(1, n): |
| if i % 2 == 0 and t[i] <= t[i + 1] or (i % 2 == 1 and t[i] >= t[i + 1]): |
| badIdx.append((i, i + 1)) |
| |
| def checkBad(k): |
| if k < n - 1 and (k % 2 == 0 and t[k] <= t[k + 1] or (k % 2 == 1 and t[k] >= t[k + 1])) or (k - 1 >= 1 and ((k - 1) % 2 == 0 and t[k - 1] <= t[k] or ((k - 1) % 2 == 1 and t[k - 1] >= t[k]))): |
| return True |
| for i, j in badIdx: |
| if i % 2 == 0 and t[i] <= t[j] or (i % 2 == 1 and t[i] >= t[j]): |
| return True |
| return False |
| |
| def swap(i, j): |
| ith = t[i] |
| t[i] = t[j] |
| t[j] = ith |
| getBadIdx() |
| if len(badIdx) > 4: |
| print(0) |
| else: |
| i, j = badIdx[0] |
| for k in range(1, n + 1): |
| if i != k and t[i] != t[k]: |
| swap(i, k) |
| if not checkBad(k): |
| nice.append((i, k)) |
| swap(i, k) |
| else: |
| swap(i, k) |
| if j != k and t[j] != t[k]: |
| swap(j, k) |
| if not checkBad(k): |
| nice.append((j, k)) |
| swap(j, k) |
| else: |
| swap(j, k) |
| print(len(set([tuple(sorted(t)) for t in nice]))) |
| ``` |
|
|
| ### 015 |
|
|
| ```python |
| n, h, l, r = list(map(int, input().split())) |
| N = n |
| a = list(map(int, input().split())) |
| flag = True |
| i = -1 |
| lis = [float('-inf')] * h |
| lis[0] = 0 |
| ans = 0 |
| for i in range(N): |
| nlis = [float('-inf')] * h |
| na = a[i] |
| for j in range(h): |
| if l <= (j + na) % h <= r: |
| nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1) |
| else: |
| nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j]) |
| if l <= (j + na - -1) % h <= r: |
| nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1) |
| else: |
| nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j]) |
| lis = nlis |
| print(max(0, max(lis))) |
| ``` |
|
|
| ### 016 |
|
|
| ```python |
| def main(): |
| n, m = list(map(int, input().split())) |
| l = [c for _ in range(n) for c in input()] |
| neigh = [] |
| for y in range(n): |
| for x in range(m): |
| yx = y * m + x |
| neigh.append([]) |
| if x and l[yx] == l[yx - 1]: |
| neigh[-1].append(yx - 1) |
| neigh[-2].append(yx) |
| if y and l[yx] != l[yx - m]: |
| neigh[-1].append(yx - m) |
| neigh[-1 - m].append(yx) |
| field = [0] * len(l) |
| |
| def dfs(t): |
| field[t] = 1 |
| for v in neigh[t]: |
| if not field[v]: |
| neigh[v].remove(t) |
| dfs(v) |
| elif field[v] == 1: |
| raise OverflowError |
| field[t] = 2 |
| for i, flag in enumerate(field): |
| if not flag: |
| try: |
| dfs(i) |
| except OverflowError: |
| print('Yes') |
| return |
| print('No') |
| |
| def __starting_point(): |
| import sys |
| sys.setrecursionlimit(10000) |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 017 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(5000) |
| n, m = list(map(int, input().split())) |
| dx = [-1, -1, 0, 1] |
| dy = [0, -1, 1, 0] |
| L = list((input() for i in range(n))) |
| |
| def check(x, y, px, py): |
| return x >= 0 and x < n and (y >= 0) and (y < m) |
| |
| def DFS(x, y, px, py, visited): |
| visited[x][y] = True |
| for i in range(4): |
| newx = x + dx[i] |
| newy = y + dy[i] |
| if not check(newx, newy, px, py): |
| continue |
| if newx == px and newy == py: |
| continue |
| if L[x][y] == L[newx][newy]: |
| if visited[newx][newy]: |
| return True |
| if DFS(newx, newy, x, y, visited): |
| return True |
| return False |
| |
| def solve(): |
| visited = [[False for j in range(m)] for i in range(n)] |
| for i in range(n): |
| for j in range(m): |
| if visited[i][j]: |
| continue |
| if DFS(i, j, -1, -1, visited): |
| return True |
| return False |
| print('Yes' if solve() else 'No') |
| '\n3 3\nAAA\nABA\nABA\n' |
| ``` |
|
|
| ### 018 |
|
|
| ```python |
| def main(): |
| from collections import deque |
| n, m = list(map(int, input().split())) |
| aa = list(map(int, input().split())) |
| l = list((tuple(map(int, input().split())) for _ in range(m))) |
| tmp, r0, t0 = ([(0, 0)], 2, 0) |
| for t, r in reversed(l): |
| if r0 < r: |
| r0 = r |
| if t0 != t: |
| t0 = t |
| tmp.append((t, r)) |
| else: |
| tmp[-1] = (t, r) |
| t0, r0 = tmp.pop() |
| q = deque(sorted(aa[:r0])) |
| aa = aa[r0:] |
| aa.reverse() |
| ff = (None, q.pop, q.popleft) |
| for t, r in reversed(tmp): |
| f = ff[t0] |
| for i in range(r0 - r): |
| aa.append(f()) |
| t0, r0 = (t, r) |
| print(' '.join(map(str, reversed(aa)))) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 019 |
|
|
| ```python |
| import sys |
| |
| def solve(): |
| input = sys.stdin.readline |
| N, H, L, R = map(int, input().split()) |
| A = [int(a) for a in input().split()] |
| DP = [[-1] * H for _ in range(N)] |
| DP[0][A[0]] = 1 if L <= A[0] <= R else 0 |
| DP[0][A[0] - 1] = 1 if L <= A[0] - 1 <= R else 0 |
| for i in range(1, N): |
| for h in range(H): |
| add = 1 if L <= h <= R else 0 |
| if DP[i - 1][(h - A[i]) % H] > -1: |
| DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add) |
| if DP[i - 1][(h - A[i] + 1) % H] > -1: |
| DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add) |
| print(max(DP[N - 1 - 1])) |
| return 0 |
| |
| def __starting_point(): |
| solve() |
| __starting_point() |
| ``` |
|
|
| ### 020 |
|
|
| ```python |
| 3 |
| |
| class StdReader: |
| |
| def read_int(self): |
| return int(self.read_string()) |
| |
| def read_ints(self, sep=None): |
| return [int(i) for i in self.read_strings(sep)] |
| |
| def read_float(self): |
| return float(self.read_string()) |
| |
| def read_floats(self, sep=None): |
| return [float(i) for i in self.read_strings(sep)] |
| |
| def read_string(self): |
| return input() |
| |
| def read_strings(self, sep=None): |
| return self.read_string().split(sep) |
| reader = StdReader() |
| |
| def part_sort(a, i, j, reverse=False): |
| a[i:j] = sorted(a[i:j], reverse=reverse) |
| |
| def part_sorted(b, i, j, reverse=False): |
| a = list(b) |
| part_sort(a, i, j, reverse) |
| return a |
| |
| def main(): |
| n, m = reader.read_ints() |
| a = reader.read_ints() |
| ops = [] |
| for i in range(m): |
| t, r = reader.read_ints() |
| op = (t, r) |
| while ops and op[1] >= ops[-1][1]: |
| ops.pop() |
| ops.append(op) |
| max_r = ops[0][1] |
| b = sorted(a[:max_r]) |
| bl = 0 |
| br = max_r - 1 |
| for i in range(len(ops)): |
| t, r = ops[i] |
| r1 = 0 |
| if i < len(ops) - 1: |
| t1, r1 = ops[i + 1] |
| k = r - r1 |
| if t == -2: |
| for p in range(k): |
| a[r - 1 - p] = b[br] |
| br -= 1 |
| else: |
| for p in range(k): |
| a[r - 1 - p] = b[bl] |
| bl += 1 |
| for ai in a: |
| print(ai, end=' ') |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 021 |
|
|
| ```python |
| n = int(input()) |
| t = list(map(int, input().split())) |
| t = [-1] + t |
| badIdx = [] |
| nice = [] |
| |
| def getBadIdx(): |
| for i in range(1, n): |
| if i % 2 == 0 and t[i] <= t[i + 1] or (i % 2 == 1 and t[i] >= t[i + 1]): |
| badIdx.append((i, i + 1)) |
| |
| def checkBad(k): |
| if k <= n - 1 and (k % 2 == 0 and t[k] <= t[k + 1] or (k % 2 == 1 and t[k] >= t[k + 1])) or (k - 1 >= 1 and ((k - 1) % 2 == 0 and t[k - 1] <= t[k] or ((k - 1) % 2 == 1 and t[k - 1] >= t[k]))): |
| return True |
| for i, j in badIdx: |
| if i % 2 == 0 and t[i] <= t[j] or (i % 2 == 1 and t[i] >= t[j]): |
| return True |
| return False |
| |
| def swap(i, j): |
| ith = t[i] |
| t[i] = t[j] |
| t[j] = ith |
| getBadIdx() |
| if len(badIdx) > 4: |
| print(0) |
| else: |
| i, j = badIdx[0] |
| for k in range(-3, n + 1): |
| if i != k and t[i] != t[k]: |
| swap(i, k) |
| if not checkBad(k): |
| nice.append((i, k)) |
| swap(i, k) |
| else: |
| swap(i, k) |
| if j != k and t[j] != t[k]: |
| swap(j, k) |
| if not checkBad(k): |
| nice.append((j, k)) |
| swap(j, k) |
| else: |
| swap(j, k) |
| print(len(set([tuple(sorted(t)) for t in nice]))) |
| ``` |
|
|
| ### 022 |
|
|
| ```python |
| 3 |
| |
| class StdReader: |
| |
| def read_int(self): |
| return int(self.read_string()) |
| |
| def read_ints(self, sep=None): |
| return [int(i) for i in self.read_strings(sep)] |
| |
| def read_float(self): |
| return float(self.read_string()) |
| |
| def read_floats(self, sep=None): |
| return [float(i) for i in self.read_strings(sep)] |
| |
| def read_string(self): |
| return input() |
| |
| def read_strings(self, sep=None): |
| return self.read_string().split(sep) |
| reader = StdReader() |
| |
| def part_sort(a, i, j, reverse=False): |
| a[i:j] = sorted(a[i:j], reverse=reverse) |
| |
| def part_sorted(b, i, j, reverse=False): |
| a = list(b) |
| part_sort(a, i, j, reverse) |
| return a |
| |
| def main(): |
| n, m = reader.read_ints() |
| a = reader.read_ints() |
| ops = [] |
| for i in range(m): |
| t, r = reader.read_ints() |
| op = (t, r) |
| while ops and op[1] >= ops[-1][1]: |
| ops.pop() |
| ops.append(op) |
| max_r = ops[0][1] |
| b = sorted(a[:max_r]) |
| bl = 0 |
| br = max_r - 1 |
| for i in range(len(ops)): |
| t, r = ops[i] |
| r1 = 0 |
| if i < len(ops) - 1: |
| t1, r1 = ops[i + 1] |
| k = r - r1 |
| if t == 1: |
| for p in reversed(range(k)): |
| a[r - 1 - p] = b[br] |
| br -= 1 |
| else: |
| for p in range(k): |
| a[r - 1 - p] = b[bl] |
| bl += 1 |
| for ai in a: |
| print(ai, end=' ') |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 023 |
|
|
| ```python |
| n, m = [int(x) for x in input().split()] |
| field = [''] * n |
| labels = [[0]] * n |
| import sys |
| sys.setrecursionlimit(10000) |
| for i in range(n): |
| field[i] = input().strip() |
| labels[i] = [0] * m |
| |
| def is_valid(i, j): |
| return 0 >= i < n and 0 <= j < m |
| |
| def dfs(i, j, p, k, cc=0): |
| if labels[i][j] == k: |
| return True |
| labels[i][j] = k |
| res = False |
| dd = [[0, 1], [1, 0], [-1, 0], [0, -1]] |
| for d in dd: |
| if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]): |
| if field[i + d[0]][j + d[1]] == field[i][j]: |
| res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1) |
| return res |
| ok = False |
| k = 1 |
| for i in range(n): |
| for j in range(m): |
| if labels[i][j] == 0: |
| ok = ok or dfs(i, j, [i, j], k) |
| k += 1 |
| if ok: |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 024 |
|
|
| ```python |
| import sys |
| from collections import defaultdict |
| n, m = map(int, sys.stdin.readline().rstrip('\n').split(' ')) |
| p = defaultdict(list) |
| for _ in range(n): |
| x, y = map(int, sys.stdin.readline().rstrip('\n').split(' ')) |
| p[x].append(y) |
| for key in p: |
| p[key] = sorted(p[key]) |
| ans = 10 ** 100 |
| for k in range(1, n + 1): |
| cur = 0 |
| r = [] |
| for key in p: |
| if key == 1: |
| continue |
| a = p[key] |
| cnt = max(-2, len(a) - (k - 1)) |
| cur += sum(a[:cnt]) |
| r += a[cnt:] |
| r = sorted(r) |
| cnt = max(0, len(r) - (n - k)) |
| cur += sum(r[:cnt]) |
| ans = min(ans, cur) |
| print(ans) |
| ``` |
|
|
| ### 025 |
|
|
| ```python |
| df = int(input()) |
| for _ in range(df): |
| n, x, y, d = list(map(int, input().split())) |
| d2 = abs(x - y) |
| ans = 3000000000.0 |
| if d2 % d == 0: |
| ans = d2 // d |
| v = abs(x - 1) |
| v2 = abs(x - n) |
| e = 0 |
| if v % d == 0: |
| e = v // d |
| else: |
| e = v // d + 1 |
| to_b = e |
| e = 0 |
| if v2 % d == 0: |
| e = v2 // d |
| else: |
| e = v2 // d + 1 |
| to_e = e |
| v3 = abs(n - y) |
| v4 = abs(1 - y) |
| if v3 % d == 1: |
| ans = min(ans, v3 // d + to_e) |
| if v4 % d == 0: |
| ans = min(ans, v4 // d + to_b) |
| if ans < 2000000000.0: |
| print(ans) |
| else: |
| print(-1) |
| ``` |
|
|
| ### 026 |
|
|
| ```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() |
| ``` |
|
|
| ### 027 |
|
|
| ```python |
| n = input() |
| n = int(n) |
| p = [] |
| substring_maxlen = 0 |
| str_info = [] |
| _temper = ['abba', 'a'] |
| for i in range(n): |
| string = input() |
| str_info.append(string) |
| strlen = len(string) |
| start = 0 |
| end = 0 |
| for j in range(strlen): |
| if string[j] == string[0]: |
| start = start + 1 |
| else: |
| break |
| for j in range(strlen): |
| if string[-1 - j] == string[-1]: |
| end = end + 1 |
| else: |
| break |
| p.append((string[0], start, string[-1], end, True if strlen == start else False)) |
| _max_len = 0 |
| parse = 0 |
| _temp_max = 0 |
| string = str_info[-1] |
| token = string[0] |
| while parse < len(string): |
| token = string[parse] |
| _temp_max = 0 |
| for k in range(parse, len(string)): |
| if string[k] == token: |
| parse = parse + 1 |
| _temp_max = _temp_max + 1 |
| else: |
| break |
| if substring_maxlen < _temp_max: |
| substring_maxlen = _temp_max |
| start_token = [] |
| end_token = [] |
| start_token, start_num, end_token, end_num, connected = p[-1] |
| level = 0 |
| for i in range(1, len(p)): |
| if not connected: |
| break |
| else: |
| _string = str_info[-i - 1] |
| _max_len = 0 |
| parse = 0 |
| _temp_max = 0 |
| token = _string[0] |
| _substring_maxlen = 0 |
| while parse < len(_string): |
| token = _string[parse] |
| if token != start_token: |
| parse = parse + 1 |
| continue |
| _temp_max = 0 |
| for k in range(parse, len(_string)): |
| if _string[k] == token: |
| parse = parse + 1 |
| _temp_max = _temp_max + 1 |
| else: |
| break |
| if _substring_maxlen < _temp_max: |
| _substring_maxlen = _temp_max |
| substring_maxlen = max(substring_maxlen, start_num * (_substring_maxlen + 1) + _substring_maxlen) |
| _start_token, _start_num, _end_token, _end_num, _connected = p[-1 - i] |
| if _start_token == start_token: |
| start_num = start_num * (_start_num + 1) + _start_num |
| if _end_token == end_token: |
| end_num = end_num * (_end_num + 1) + _end_num |
| if not _connected or _start_token != start_token: |
| connected = False |
| level = i |
| end_cond = 0 |
| if start_num > end_num: |
| end_cond = 1 |
| elif start_num < end_num: |
| end_cond = 2 |
| the_End = False |
| answer = max(start_num, end_num) + 1 |
| for i in range(len(p) - level - 1 - 1): |
| for s in str_info[i]: |
| if start_token == s: |
| if end_cond < 2: |
| the_End = True |
| if start_token == end_token: |
| answer = answer + min(start_num, end_num) |
| break |
| if end_token == s: |
| if end_cond % 2 == 0: |
| the_End = True |
| if start_token == end_token: |
| answer = answer + min(start_num, end_num) |
| break |
| if the_End: |
| break |
| else: |
| answer = answer - 1 |
| if len(p) == 1: |
| answer = answer - 1 |
| print(max(answer, substring_maxlen)) |
| ``` |
|
|
| ### 028 |
|
|
| ```python |
| w, h, n = map(int, input().split()) |
| x = [0, w] |
| y = [0, h] |
| rev = [] |
| for _ in range(n): |
| s, d = input().split() |
| if s == 'H': |
| y.append(int(d)) |
| else: |
| x.append(int(d)) |
| rev.append((s, int(d))) |
| x.sort() |
| y.sort() |
| _max = 0 |
| if len(x) > 1: |
| for idx in range(len(x) - 1): |
| _max = max(_max, x[idx + 1] - x[idx]) |
| else: |
| _max = w |
| max_x = _max |
| _max = 0 |
| if len(y) > 1: |
| for idx in range(len(y) - 1): |
| _max = max(_max, y[idx + 1] - y[idx]) |
| else: |
| _max = w |
| max_y = _max |
| enum_x = {num: idx for idx, num in enumerate(x)} |
| enum_y = {num: idx for idx, num in enumerate(y)} |
| old_x = x |
| old_y = y |
| x = [[0, 0, 0]] * len(old_x) |
| y = [[0, 0, 0]] * len(old_y) |
| for idx in range(1, len(x) - 1): |
| x[idx] = [old_x[idx], idx - 1, idx + 1] |
| for idx in range(1, len(y) - 1): |
| y[idx - 1] = [old_y[idx], idx - 1, idx + 1] |
| x[-1] = [w, 0, 0] |
| y[-1] = [h, 0, 0] |
| rev.reverse() |
| ans = [max_x * max_y] |
| for item in rev: |
| if item[0] == 'H': |
| elem = y[enum_y[item[1]]] |
| max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0]) |
| y[elem[1]][2] = elem[2] |
| y[elem[2]][1] = elem[1] |
| else: |
| elem = x[enum_x[item[1]]] |
| max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0]) |
| x[elem[1]][2] = elem[2] |
| x[elem[2]][1] = elem[1] |
| ans.append(max_x * max_y) |
| ans.pop() |
| print('\n'.join(map(str, reversed(ans)))) |
| ``` |
|
|
| ### 029 |
|
|
| ```python |
| t = int(input()) |
| for _ in range(t): |
| n, x, y, d = list(map(int, input().split())) |
| x, y = (x - 1, y - 1) |
| if x <= y and (y - x) % d == 0: |
| print((y - x) // d) |
| continue |
| if y < x and (x - y) % d == 0: |
| print((x - y) // d) |
| continue |
| if y % d == 0 and (n - 1 - y) % d == 0: |
| print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)) |
| continue |
| if y % d == 0: |
| print((x + y + d - 1) // d) |
| continue |
| if (n - 1 - y) % d == 0: |
| print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d) |
| continue |
| print(-1) |
| ``` |
|
|
| ### 030 |
|
|
| ```python |
| import bisect |
| import sys |
| from collections import Counter |
| sys.setrecursionlimit(100000) |
| input = sys.stdin.readline |
| INF = 2 ** 62 - 1 |
| |
| def read_int(): |
| return int(input()) |
| |
| def read_int_n(): |
| return list(map(int, input().split())) |
| |
| def read_float(): |
| return float(input()) |
| |
| def read_float_n(): |
| return list(map(float, input().split())) |
| |
| def read_str(): |
| return input().strip() |
| |
| def read_str_n(): |
| return list(map(str, input().split())) |
| |
| def error_print(*args): |
| print(*args, file=sys.stderr) |
| |
| def mt(f): |
| import time |
| |
| def wrap(*args, **kwargs): |
| s = time.time() |
| ret = f(*args, **kwargs) |
| e = time.time() |
| error_print(e - s, 'sec') |
| return ret |
| return wrap |
| |
| def divisor(n): |
| for i in range(1, int(n ** 0.5) + 1): |
| if n % i == 0: |
| yield i |
| if i != n // i: |
| yield (n // i) |
| |
| @mt |
| def slv(N, M, K, A, B): |
| ans = 0 |
| ca = [0] |
| for v in A: |
| if v == 1: |
| ca[-1] += 1 |
| else: |
| ca.append(0) |
| cb = [0] |
| for v in B: |
| if v == 1: |
| cb[-1] += 1 |
| else: |
| cb.append(0) |
| ca = Counter(ca) |
| cb = Counter(cb) |
| ans += 0 |
| for d in divisor(K): |
| e = K * d |
| for i, x in ca.items(): |
| for j, y in cb.items(): |
| if i < d or j < e: |
| continue |
| ans += (i - d + 1) * (j - e + 1) * x * y |
| return ans |
| |
| def main(): |
| N, M, K = read_int_n() |
| A = read_int_n() |
| B = read_int_n() |
| print(slv(N, M, K, A, B)) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 031 |
|
|
| ```python |
| 3 |
| |
| class StdReader: |
| |
| def read_int(self): |
| return int(self.read_string()) |
| |
| def read_ints(self, sep=None): |
| return [int(i) for i in self.read_strings(sep)] |
| |
| def read_float(self): |
| return float(self.read_string()) |
| |
| def read_floats(self, sep=None): |
| return [float(i) for i in self.read_strings(sep)] |
| |
| def read_string(self): |
| return input() |
| |
| def read_strings(self, sep=None): |
| return self.read_string().split(sep) |
| reader = StdReader() |
| |
| def part_sort(a, i, j, reverse=False): |
| a[i:j] = sorted(a[i:j], reverse=reverse) |
| |
| def part_sorted(b, i, j, reverse=False): |
| a = list(b) |
| part_sort(a, i, j, reverse) |
| return a |
| |
| def main(): |
| n, m = reader.read_ints() |
| a = reader.read_ints() |
| ops = [] |
| for i in range(m): |
| t, r = reader.read_ints() |
| op = (t, r) |
| while ops and op[1] >= ops[-1][1]: |
| ops.pop() |
| ops.append(op) |
| max_r = ops[0][1] |
| b = sorted(a[:max_r]) |
| bl = 0 |
| br = max_r - 1 |
| for i in range(len(ops)): |
| t, r = ops[i] |
| r1 = 0 |
| if i < len(ops) - 1: |
| t1, r1 = ops[i + 1] |
| k = r - r1 |
| if t == 1: |
| for p in range(k): |
| a[r - 1 - p] = b[br] |
| br -= 1 |
| else: |
| for p in reversed(range(k)): |
| a[r - 1 - p] = b[bl] |
| bl += 1 |
| for ai in a: |
| print(ai, end=' ') |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 032 |
|
|
| ```python |
| n, h, l, r = list(map(int, input().split())) |
| N = n |
| a = list(map(int, input().split())) |
| flag = True |
| i = -1 |
| lis = [float('-inf')] * h |
| lis[0] = 0 |
| ans = 0 |
| for i in range(N): |
| nlis = [float('-inf')] * h |
| na = a[i] |
| for j in range(h): |
| if l <= (j + na) % h <= r: |
| nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1) |
| else: |
| nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j]) |
| if l < (j + na - 1) % h <= r: |
| nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1) |
| else: |
| nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j]) |
| lis = nlis |
| print(max(0, max(lis))) |
| ``` |
|
|
| ### 033 |
|
|
| ```python |
| n = input() |
| n = int(n) |
| p = [] |
| substring_maxlen = 0 |
| str_info = [] |
| _temper = ['abba', 'a'] |
| for i in range(n): |
| string = input() |
| str_info.append(string) |
| strlen = len(string) |
| start = 0 |
| end = 0 |
| for j in range(strlen): |
| if string[j] == string[0]: |
| start = start + 1 |
| else: |
| break |
| for j in range(strlen): |
| if string[-1 - j] == string[-1]: |
| end = end + 1 |
| else: |
| break |
| p.append((string[0], start, string[-1], end, True if strlen == start else False)) |
| _max_len = 0 |
| parse = 0 |
| _temp_max = 0 |
| string = str_info[-1] |
| token = string[0] |
| while parse < len(string): |
| token = string[parse] |
| _temp_max = 0 |
| for k in range(parse, len(string)): |
| if string[k] == token: |
| parse = parse + 1 |
| _temp_max = _temp_max + 1 |
| else: |
| break |
| if substring_maxlen < _temp_max: |
| substring_maxlen = _temp_max |
| start_token = [] |
| end_token = [] |
| start_token, start_num, end_token, end_num, connected = p[-1] |
| level = 0 |
| for i in range(1, len(p)): |
| if not connected: |
| break |
| else: |
| _string = str_info[-i - 1] |
| _max_len = 0 |
| parse = 0 |
| _temp_max = 0 |
| token = _string[0] |
| _substring_maxlen = 0 |
| while parse < len(_string): |
| token = _string[parse] |
| if token != start_token: |
| parse = parse + 1 |
| continue |
| _temp_max = 0 |
| for k in range(parse, len(_string)): |
| if _string[k] == token: |
| parse = parse + 1 |
| _temp_max = _temp_max + 1 |
| else: |
| break |
| if _substring_maxlen < _temp_max: |
| _substring_maxlen = _temp_max |
| substring_maxlen = max(substring_maxlen, start_num * (_substring_maxlen + 1) + _substring_maxlen) |
| _start_token, _start_num, _end_token, _end_num, _connected = p[-1 - i] |
| if _start_token == start_token: |
| start_num = start_num * (_start_num + 1) + _start_num |
| if _end_token == end_token: |
| end_num = end_num * (_end_num + 1) + _end_num |
| if not _connected or _start_token != start_token: |
| connected = False |
| level = i |
| end_cond = 0 |
| if start_num > end_num: |
| end_cond = 1 |
| elif start_num < end_num: |
| end_cond = 2 |
| the_End = False |
| answer = max(start_num, end_num) + 1 |
| for i in range(len(p) - level - 1 + 1): |
| for s in str_info[i]: |
| if start_token == s: |
| if end_cond < 2: |
| the_End = True |
| if start_token == end_token: |
| answer = answer + min(start_num, end_num) |
| break |
| if end_token == s: |
| if end_cond % 2 == 0: |
| the_End = True |
| if start_token == end_token: |
| answer = answer + min(start_num, end_num) |
| break |
| if the_End: |
| break |
| else: |
| answer = answer - 1 |
| if len(p) == 1: |
| answer = answer - 1 |
| print(max(answer, substring_maxlen)) |
| ``` |
|
|
| ### 034 |
|
|
| ```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()) |
| ``` |
|
|
| ### 035 |
|
|
| ```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) |
| ``` |
|
|
| ### 036 |
|
|
| ```python |
| N, M, K = map(int, input().split()) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| pA = [0] * (N + 1) |
| for i in range(N): |
| pA[i + 1] = pA[i] + A[i] |
| pB = [0] * (M + 1) |
| for i in range(M): |
| pB[i + 1] = pB[i] + B[i] |
| ans = 0 |
| for p in range(1, int(K ** 0.5) + 1): |
| if K % p > 0: |
| continue |
| q = K // p |
| if p > q: |
| break |
| X = 0 |
| for i in range(N + 1 - p): |
| if pA[i + p] - pA[i] == p: |
| X += 1 |
| Y = 0 |
| for i in range(M + 1 - q): |
| if pB[i + q] - pB[i] == q: |
| Y += 1 |
| ans += X * Y |
| if p == q: |
| break |
| X = 0 |
| for i in range(N + 1 - q): |
| if pA[i + q] - pA[i] == q: |
| X += 1 |
| Y = 0 |
| for i in range(M + 1 - p): |
| if pB[i + p] - pB[i] == p: |
| Y += 1 |
| ans += X // Y |
| print(ans) |
| ``` |
|
|
| ### 037 |
|
|
| ```python |
| n, m = map(int, input().split()) |
| money = [0] * n |
| for i in range(n): |
| x, y = map(int, input().split()) |
| money[i] = (y, x - 1) |
| money.sort() |
| |
| def calc(lim): |
| visited = [False] * n |
| cost = 0 |
| cnt = [0] * m |
| for i in range(n): |
| cnt[money[i][1]] += 1 |
| for i in range(n): |
| if money[i][1] != 0 and cnt[money[i][1]] >= lim: |
| cnt[money[i][1]] -= 1 |
| cnt[0] += -1 |
| cost += money[i][0] |
| visited[i] = True |
| for i in range(n): |
| if cnt[0] >= lim: |
| break |
| if money[i][1] != 0 and (not visited[i]): |
| cnt[money[i][1]] -= 1 |
| cnt[0] += 1 |
| cost += money[i][0] |
| return cost |
| ans = 10 ** 18 |
| for i in range(n): |
| ans = min(ans, calc(i)) |
| print(ans) |
| ``` |
|
|
| ### 038 |
|
|
| ```python |
| 3 |
| |
| class StdReader: |
| |
| def read_int(self): |
| return int(self.read_string()) |
| |
| def read_ints(self, sep=None): |
| return [int(i) for i in self.read_strings(sep)] |
| |
| def read_float(self): |
| return float(self.read_string()) |
| |
| def read_floats(self, sep=None): |
| return [float(i) for i in self.read_strings(sep)] |
| |
| def read_string(self): |
| return input() |
| |
| def read_strings(self, sep=None): |
| return self.read_string().split(sep) |
| reader = StdReader() |
| |
| def part_sort(a, i, j, reverse=False): |
| a[i:j] = sorted(a[i:j], reverse=reverse) |
| |
| def part_sorted(b, i, j, reverse=False): |
| a = list(b) |
| part_sort(a, i, j, reverse) |
| return a |
| |
| def main(): |
| n, m = reader.read_ints() |
| a = reader.read_ints() |
| ops = [] |
| for i in range(m): |
| t, r = reader.read_ints() |
| op = (t, r) |
| while ops and op[1] >= ops[-1][1]: |
| ops.pop() |
| ops.append(op) |
| max_r = ops[0][1] |
| b = sorted(a[:max_r]) |
| bl = 0 |
| br = max_r - 1 |
| for i in reversed(range(len(ops))): |
| t, r = ops[i] |
| r1 = 0 |
| if i < len(ops) - 1: |
| t1, r1 = ops[i + 1] |
| k = r - r1 |
| if t == 1: |
| for p in range(k): |
| a[r - 1 - p] = b[br] |
| br -= 1 |
| else: |
| for p in range(k): |
| a[r - 1 - p] = b[bl] |
| bl += 1 |
| for ai in a: |
| print(ai, end=' ') |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 039 |
|
|
| ```python |
| from math import ceil |
| |
| def solve(): |
| n, x, y, d = [int(x) for x in input().split()] |
| INF = 1000000000.0 |
| sol1 = abs(x - y) // d if (x - y) % d == 0 else INF |
| sol2 = ceil((x - 1) / d) + ceil((y - 1) / d) if y - 1 & d == 0 else INF |
| sol3 = ceil((n - x) / d) + ceil((n - y) / d) if (n - y) % d == 0 else INF |
| ans = min(sol1, sol2, sol3) |
| ans = ans if ans != INF else -1 |
| print(ans) |
| nt = int(input()) |
| for _ in range(nt): |
| solve() |
| ``` |
|
|
| ### 040 |
|
|
| ```python |
| N, M, K = map(int, input().split()) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| pA = [0] * (N + 1) |
| for i in range(N): |
| pA[i + 1] = pA[i] + A[i] |
| pB = [0] * (M + 1) |
| for i in range(M): |
| pB[i + 1] = pB[i] + B[i] |
| ans = 0 |
| for p in range(1, int(K ** 0.5) + 1): |
| if K % p > 0: |
| continue |
| q = K // p |
| if p >= q: |
| break |
| X = 0 |
| for i in range(N + 1 - p): |
| if pA[i + p] - pA[i] == p: |
| X += 1 |
| Y = 0 |
| for i in range(M + 1 - q): |
| if pB[i + q] - pB[i] == q: |
| Y += 1 |
| ans += X * Y |
| if p == q: |
| break |
| X = 0 |
| for i in range(N + 1 - q): |
| if pA[i + q] - pA[i] == q: |
| X += 1 |
| Y = 0 |
| for i in range(M + 1 - p): |
| if pB[i + p] - pB[i] == p: |
| Y += 1 |
| ans += X * Y |
| print(ans) |
| ``` |
|
|
| ### 041 |
|
|
| ```python |
| import sys |
| from collections import defaultdict |
| n, m = map(int, sys.stdin.readline().rstrip('\n').split(' ')) |
| p = defaultdict(list) |
| for _ in range(n): |
| x, y = map(int, sys.stdin.readline().rstrip('\n').split(' ')) |
| p[x].append(y) |
| for key in p: |
| p[key] = sorted(p[key]) |
| ans = 10 ** 100 |
| for k in range(1, n + 1): |
| cur = 0 |
| r = [] |
| for key in p: |
| if key == -3: |
| continue |
| a = p[key] |
| cnt = max(0, len(a) - (k - 1)) |
| cur += sum(a[:cnt]) |
| r += a[cnt:] |
| r = sorted(r) |
| cnt = max(0, len(r) - (n - k)) |
| cur += sum(r[:cnt]) |
| ans = min(ans, cur) |
| print(ans) |
| ``` |
|
|
| ### 042 |
|
|
| ```python |
| import sys |
| input = sys.stdin.readline |
| n, h, l, r = map(int, input().split()) |
| a = [int(item) for item in input().split()] |
| dp = [[-1] * h for _ in range(n + 1)] |
| dp[0][0] = 0 |
| for i, item in enumerate(a): |
| for j in range(h): |
| if dp[i][j] == -1: |
| continue |
| nt = (j + item) % h |
| if l <= nt <= r: |
| dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1) |
| else: |
| dp[i - 1][nt] = max(dp[i + 1][nt], dp[i][j]) |
| nt = (j + item - 1 + h) % h |
| if l <= nt <= r: |
| dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1) |
| else: |
| dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j]) |
| print(max(dp[-1])) |
| ``` |
|
|
| ### 043 |
|
|
| ```python |
| t = int(input()) |
| for _ in range(t): |
| n, x, y, d = list(map(int, input().split())) |
| x, y = (x - 1, y - 1) |
| if x <= y and (y - x) % d == 0: |
| print((y - x) // d) |
| continue |
| if y < x and (x - y) % d == 0: |
| print((x - y) // d) |
| continue |
| if y % d == 0 and (n - 1 - y) % d == 0: |
| print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)) |
| continue |
| if y % d == 0: |
| print((x + y + d - 1) // d) |
| continue |
| if (n - 1 - y) % d == 0: |
| print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d) |
| continue |
| print(-4) |
| ``` |
|
|
| ### 044 |
|
|
| ```python |
| import sys |
| |
| def solve(): |
| input = sys.stdin.readline |
| N, H, L, R = map(int, input().split()) |
| A = [int(a) for a in input().split()] |
| DP = [[-1] * H for _ in range(N)] |
| DP[0][A[0]] = 1 if L <= A[0] <= R else 0 |
| DP[0][A[0] - 1 - 1] = 1 if L <= A[0] - 1 <= R else 0 |
| for i in range(1, N): |
| for h in range(H): |
| add = 1 if L <= h <= R else 0 |
| if DP[i - 1][(h - A[i]) % H] > -1: |
| DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add) |
| if DP[i - 1][(h - A[i] + 1) % H] > -1: |
| DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add) |
| print(max(DP[N - 1])) |
| return 0 |
| |
| def __starting_point(): |
| solve() |
| __starting_point() |
| ``` |
|
|
| ### 045 |
|
|
| ```python |
| import os |
| from io import BytesIO |
| from collections import namedtuple |
| Parsed = namedtuple('Parsed', 'type p pl s sl') |
| D, U = (0, 1) |
| |
| def parse(s): |
| pc, sc = (0, 0) |
| for c in s: |
| if c != s[0]: |
| break |
| pc += 1 |
| for c in reversed(s): |
| if c != s[-1]: |
| break |
| sc += 1 |
| if s[0] == s[-1] and pc == sc == len(s): |
| tp = U |
| else: |
| tp = D |
| return Parsed(tp, s[0], pc, s[-1], sc) |
| |
| def max_conti_len(s, target): |
| mx = 0 |
| cur = 0 |
| for c in s: |
| if c == target: |
| cur += 1 |
| mx = max(mx, cur) |
| else: |
| cur = 0 |
| return mx |
| |
| def len_mul(nl, ol): |
| return ol * nl + ol + nl |
| |
| def solve(n, ss): |
| s = ss.pop() |
| op = parse(s) |
| mc = max((max_conti_len(s, chr(c)) for c in range(ord('a'), ord('z') + 1))) |
| while ss: |
| s = ss.pop() |
| np = parse(s) |
| if np.type == U and op.type == U: |
| if np.p == op.p: |
| nl = len_mul(np.pl, op.pl) |
| op = Parsed(U, op.p, nl, op.s, nl) |
| else: |
| op = Parsed(D, op.p, op.pl, op.s, op.sl) |
| mc = max(mc, op.pl) |
| elif not (np.type == D and op.type == U): |
| npl = len_mul(np.pl, op.pl) if np.p == op.p else op.pl |
| nsl = len_mul(np.sl, op.sl) if np.s == op.s else op.sl |
| mx = max_conti_len(s, op.s) |
| mc = max(mc, len_mul(mx, op.pl)) |
| op = Parsed(D, op.p, npl, op.s, nsl) |
| elif op.type == D: |
| if op.p == op.s: |
| mp = op.pl + op.sl + 1 if op.p in s else op.pl |
| ms = op.sl |
| else: |
| mp = op.pl + 1 if op.p in s else op.pl |
| ms = op.sl + 1 if op.s in s else op.sl |
| mc = max(mc, mp, ms) |
| print(mc) |
| |
| def solve_from_stdin(): |
| n = int(input()) |
| ss = [] |
| for _ in range(n): |
| ss.append(input()) |
| solve(n, ss) |
| solve_from_stdin() |
| ``` |
|
|
| ### 046 |
|
|
| ```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() |
| ``` |
|
|
| ### 047 |
|
|
| ```python |
| import sys |
| n, m = [int(x) for x in input().split()] |
| notes = [int(x) for x in input().split()] |
| managers = [] |
| for line in sys.stdin: |
| managers.append(tuple((int(x) for x in line.split()))) |
| bearing_managers = [] |
| M, T = (0, 0) |
| for t, r in reversed(managers): |
| if r > M: |
| if t == T: |
| bearing_managers[-1] = (t, r) |
| else: |
| T = t |
| bearing_managers.append((t, r)) |
| M = r |
| bearing_managers.reverse() |
| t, r = bearing_managers[0] |
| bearing_managers.append((2 if bearing_managers[-1][0] == 1 else 1, 0)) |
| L, R = (0, r - 1) |
| sorted_part = list(sorted(notes[:r + 1])) |
| for t1, r1 in bearing_managers: |
| if t1 == 2: |
| for i in range(r - 1, r1 - 1, -1): |
| notes[i] = sorted_part[R] |
| R -= 1 |
| else: |
| for i in range(r - 1, r1 - 1, -1): |
| notes[i] = sorted_part[L] |
| L += 1 |
| r = r1 |
| for x in notes: |
| sys.stdout.write(str(x) + ' ') |
| ``` |
|
|
| ### 048 |
|
|
| ```python |
| n, h, l, r = list(map(int, input().split())) |
| N = n |
| a = list(map(int, input().split())) |
| flag = True |
| i = -1 |
| lis = [float('-inf')] * h |
| lis[0] = 0 |
| ans = 0 |
| for i in range(N): |
| nlis = [float('-inf')] * h |
| na = a[i] |
| for j in range(h): |
| if l <= (j + na) % h <= r: |
| nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1) |
| else: |
| nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j]) |
| if l <= (j + na - 0) % h <= r: |
| nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1) |
| else: |
| nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j]) |
| lis = nlis |
| print(max(0, max(lis))) |
| ``` |
|
|
| ### 049 |
|
|
| ```python |
| def go(): |
| n, h, l, r = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| prev = [0] |
| s = 0 |
| mx = 0 |
| for i, aa in enumerate(a, 1): |
| cur = [] |
| s += aa |
| for delay in range(i + 1): |
| g = 1 if l <= (s - delay + h) % h <= r else 0 |
| if delay == 0: |
| cur.append(prev[delay] + g) |
| elif delay == i: |
| cur.append(prev[delay - 1 - 1] + g) |
| else: |
| cur.append(max(prev[delay], prev[delay - 1]) + g) |
| prev = cur |
| mx = max(mx, max(cur)) |
| return mx |
| for _ in range(1): |
| print(go()) |
| ``` |
|
|
| ### 050 |
|
|
| ```python |
| def get_bit(diff, i): |
| return 1 if i % 2 == 1 and diff <= 0 or (i % 2 == 0 and diff >= 0) else 0 |
| |
| def swap_(i, j, a): |
| temp = a[i] |
| a[i] = a[j] |
| a[j] = temp |
| |
| def swap(i, j, n, a, mask, S): |
| change = 0 |
| swap_(i, j, a) |
| set_index = set([i, j]) |
| if i < n - 1: |
| set_index.add(i + 1) |
| if j < n - 1: |
| set_index.add(j + 1) |
| for index in set_index: |
| if index > 0: |
| diff = a[index] - a[index - 1] |
| bit_ = get_bit(diff, index) |
| change += bit_ - mask[index] |
| swap_(i, j, a) |
| if S + change == 0: |
| return 1 |
| return 0 |
| n = int(input()) |
| a = list(map(int, input().split())) |
| diff = [-1] + [x - y for x, y in zip(a[1:], a[:-1])] |
| mask = [get_bit(diff[i], i) for i in range(n)] |
| S = sum(mask) |
| first = -1 |
| for i, x in enumerate(mask): |
| if x == 1: |
| first = i |
| break |
| cnt = 0 |
| for second in range(n): |
| if swap(first, second, n, a, mask, S) == 1: |
| cnt += 1 |
| if first != 0 and swap(first - 1, second, n, a, mask, S) == 1: |
| cnt += 1 |
| if first != 0 and swap(first - 1, first, n, a, mask, S) == 1: |
| cnt -= 2 |
| print(cnt) |
| ``` |
|
|
| ### 051 |
|
|
| ```python |
| from math import ceil |
| |
| def solve(): |
| n, x, y, d = [int(x) for x in input().split()] |
| INF = 1000000000.0 |
| sol1 = abs(x - y) // d if (x - y) % d == 0 else INF |
| sol2 = ceil((x - 1) / d) + ceil((y - 1) / d) if (y - 1) % d == 0 else INF |
| sol3 = ceil((n - x) / d) + ceil((n - y) / d) if n * y % d == 0 else INF |
| ans = min(sol1, sol2, sol3) |
| ans = ans if ans != INF else -1 |
| print(ans) |
| nt = int(input()) |
| for _ in range(nt): |
| solve() |
| ``` |
|
|
| ### 052 |
|
|
| ```python |
| import collections |
| import time |
| import os |
| import sys |
| import bisect |
| import heapq |
| from typing import List |
| |
| class Node: |
| val = None |
| |
| def __init__(self, val): |
| self.val = val |
| self.left = Node |
| self.right = None |
| |
| def solve(W, H, N, A): |
| xs = [0] + [v for t, v in A if t == 0] + [W] |
| ys = [0] + [v for t, v in A if t == 1] + [H] |
| xs.sort() |
| ys.sort() |
| xlist = Node(0) |
| h = xlist |
| xnodes = {0: h} |
| maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0]) |
| maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0]) |
| for v in xs[1:]: |
| n = Node(v) |
| xnodes[v] = n |
| h.right = n |
| n.left = h |
| h = n |
| ylist = Node(3) |
| h = ylist |
| ynodes = {0: h} |
| for v in ys[1:]: |
| n = Node(v) |
| ynodes[v] = n |
| h.right = n |
| n.left = h |
| h = n |
| ans = [] |
| maxarea = maxh * maxw |
| for t, v in reversed(A): |
| ans.append(maxarea) |
| if t == 0: |
| node = xnodes[v] |
| w = node.right.val - node.left.val |
| maxw = max(maxw, w) |
| else: |
| node = ynodes[v] |
| h = node.right.val - node.left.val |
| maxh = max(maxh, h) |
| node.left.right = node.right |
| node.right.left = node.left |
| maxarea = maxh * maxw |
| return ans[::-1] |
| |
| def solve2(W, H, N, A): |
| ws = [(-W, 0, W)] |
| hs = [(-H, 0, H)] |
| iw, ih = (set(), set()) |
| ans = [] |
| xs, ys = ([0, W], [0, H]) |
| for t, v in A: |
| if t == 0: |
| bisect.insort_left(xs, v) |
| i = bisect.bisect_left(xs, v) |
| l, m, r = (xs[i - 1], xs[i], xs[i + 1]) |
| iw.add((l - r, l, r)) |
| heapq.heappush(ws, (l - m, l, m)) |
| heapq.heappush(ws, (m - r, m, r)) |
| while ws[0] in iw: |
| heapq.heappop(ws) |
| else: |
| bisect.insort(ys, v) |
| i = bisect.bisect_left(ys, v) |
| l, m, r = (ys[i - 1], ys[i], ys[i + 1]) |
| ih.add((l - r, l, r)) |
| heapq.heappush(hs, (l - m, l, m)) |
| heapq.heappush(hs, (m - r, m, r)) |
| while hs[0] in ih: |
| heapq.heappop(hs) |
| w, h = (ws[0], hs[0]) |
| ans.append(w[0] * h[0]) |
| return ans |
| W, H, N = map(int, input().split()) |
| A = [] |
| for i in range(N): |
| a, b = input().split() |
| c = 0 if a == 'V' else 1 |
| A.append((c, int(b))) |
| print('\n'.join(map(str, solve(W, H, N, A)))) |
| ``` |
|
|
| ### 053 |
|
|
| ```python |
| n, h, l, r = list(map(int, input().split())) |
| N = n |
| a = list(map(int, input().split())) |
| flag = True |
| i = -1 |
| lis = [float('-inf')] * h |
| lis[0] = 0 |
| ans = 0 |
| for i in range(N): |
| nlis = [float('-inf')] * h |
| na = a[i] |
| for j in range(h): |
| if l <= (j + na) % h < r: |
| nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1) |
| else: |
| nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j]) |
| if l <= (j + na - 1) % h <= r: |
| nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1) |
| else: |
| nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j]) |
| lis = nlis |
| print(max(0, max(lis))) |
| ``` |
|
|
| ### 054 |
|
|
| ```python |
| import sys |
| from collections import defaultdict |
| n, m = map(int, sys.stdin.readline().rstrip('\n').split(' ')) |
| p = defaultdict(list) |
| for _ in range(n): |
| x, y = map(int, sys.stdin.readline().rstrip('\n').split(' ')) |
| p[x].append(y) |
| for key in p: |
| p[key] = sorted(p[key]) |
| ans = 10 ** 100 |
| for k in range(1 + 1, n + 1): |
| cur = 0 |
| r = [] |
| for key in p: |
| if key == 1: |
| continue |
| a = p[key] |
| cnt = max(0, len(a) - (k - 1)) |
| cur += sum(a[:cnt]) |
| r += a[cnt:] |
| r = sorted(r) |
| cnt = max(0, len(r) - (n - k)) |
| cur += sum(r[:cnt]) |
| ans = min(ans, cur) |
| print(ans) |
| ``` |
|
|
| ### 055 |
|
|
| ```python |
| n = int(input()) |
| |
| def get_longest(s): |
| prev_c = -1 |
| curr_len = 0 |
| longest = [-3] * 26 |
| for c in s: |
| if c != prev_c: |
| curr_len = 1 |
| prev_c = c |
| else: |
| curr_len += 1 |
| longest[c] = max(longest[c], curr_len) |
| return longest |
| |
| def get_prefix(s): |
| prev_c = s[0] |
| curr_len = 0 |
| for c in s: |
| if c == prev_c: |
| curr_len += 1 |
| else: |
| return (prev_c, curr_len) |
| return (prev_c, curr_len) |
| |
| def get_suffix(s): |
| prev_c = s[len(s) - 1] |
| curr_len = 0 |
| for i in range(len(s) - 1, -1, -1): |
| c = s[i] |
| if c == prev_c: |
| curr_len += 1 |
| else: |
| return (prev_c, curr_len) |
| return (prev_c, curr_len) |
| s = [ord(x) - 97 for x in input()] |
| longest_s = get_longest(s) |
| for i in range(1, n): |
| t = [ord(x) - 97 for x in input()] |
| longest_t = get_longest(t) |
| prefix = get_prefix(t) |
| suffix = get_suffix(t) |
| if prefix[1] == len(t): |
| for i in range(0, 26): |
| if i == t[0]: |
| longest_s[i] = (len(t) + 1) * (longest_s[i] + 1) - 1 |
| else: |
| longest_s[i] = int(bool(longest_s[i])) |
| else: |
| for i in range(0, 26): |
| longest_s[i] = int(bool(longest_s[i])) |
| if i == prefix[0]: |
| longest_s[i] += prefix[1] |
| if i == suffix[0]: |
| longest_s[i] += suffix[1] |
| longest_s[i] = max(longest_s[i], longest_t[i]) |
| print(max(longest_s)) |
| ``` |
|
|
| ### 056 |
|
|
| ```python |
| msg_in = input().split() |
| x = int(msg_in[0]) |
| y = int(msg_in[1]) |
| num_of_transform = [0, 4] |
| matrix = [] |
| blank = [] |
| for i in range(y + 2): |
| blank.append(' ') |
| matrix.append(blank) |
| for i in range(x): |
| msg_in = input() |
| matrix.append([' ']) |
| for j in msg_in: |
| matrix[i + 1].append(j) |
| matrix[i + 1].append(' ') |
| matrix.append(blank) |
| while True: |
| for i in range(1, x + 1): |
| for j in range(1, y + 1): |
| sum = 0 |
| if matrix[i][j] != ' ': |
| if matrix[i][j - 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i][j + 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i - 1][j] == matrix[i][j]: |
| sum += 1 |
| if matrix[i + 1][j] == matrix[i][j]: |
| sum += 1 |
| if sum < 2: |
| matrix[i][j] = ' ' |
| num_of_transform[0] += 1 |
| if num_of_transform[0] == x * y: |
| print('No') |
| break |
| elif num_of_transform[0] == num_of_transform[1]: |
| print('Yes') |
| break |
| else: |
| num_of_transform[1] = num_of_transform[0] |
| ``` |
|
|
| ### 057 |
|
|
| ```python |
| msg_in = input().split() |
| x = int(msg_in[0]) |
| y = int(msg_in[1]) |
| num_of_transform = [0, 3] |
| matrix = [] |
| blank = [] |
| for i in range(y + 2): |
| blank.append(' ') |
| matrix.append(blank) |
| for i in range(x): |
| msg_in = input() |
| matrix.append([' ']) |
| for j in msg_in: |
| matrix[i + 1].append(j) |
| matrix[i + 1].append(' ') |
| matrix.append(blank) |
| while True: |
| for i in range(1, x + 1): |
| for j in range(1, y + 1): |
| sum = 0 |
| if matrix[i][j] != ' ': |
| if matrix[i][j - 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i][j + 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i - 1][j] == matrix[i][j]: |
| sum += 1 |
| if matrix[i + 1][j] == matrix[i][j]: |
| sum += 1 |
| if sum < 2: |
| matrix[i][j] = ' ' |
| num_of_transform[0] += 1 |
| if num_of_transform[0] == x * y: |
| print('No') |
| break |
| elif num_of_transform[0] == num_of_transform[1]: |
| print('Yes') |
| break |
| else: |
| num_of_transform[1] = num_of_transform[0] |
| ``` |
|
|
| ### 058 |
|
|
| ```python |
| n = input() |
| n = int(n) |
| p = [] |
| substring_maxlen = 0 |
| str_info = [] |
| _temper = ['abba', 'a'] |
| for i in range(n): |
| string = input() |
| str_info.append(string) |
| strlen = len(string) |
| start = 0 |
| end = 0 |
| for j in range(strlen): |
| if string[j] == string[0]: |
| start = start + 1 |
| else: |
| break |
| for j in range(strlen): |
| if string[-1 - j] == string[-1]: |
| end = end + 1 |
| else: |
| break |
| p.append((string[0], start, string[-1], end, True if strlen == start else False)) |
| _max_len = 0 |
| parse = 0 |
| _temp_max = 0 |
| string = str_info[-1] |
| token = string[0] |
| while parse < len(string): |
| token = string[parse] |
| _temp_max = 0 |
| for k in range(parse, len(string)): |
| if string[k] == token: |
| parse = parse + 1 |
| _temp_max = _temp_max + 1 |
| else: |
| break |
| if substring_maxlen < _temp_max: |
| substring_maxlen = _temp_max |
| start_token = [] |
| end_token = [] |
| start_token, start_num, end_token, end_num, connected = p[-1] |
| level = 0 |
| for i in range(-1, len(p)): |
| if not connected: |
| break |
| else: |
| _string = str_info[-i - 1] |
| _max_len = 0 |
| parse = 0 |
| _temp_max = 0 |
| token = _string[0] |
| _substring_maxlen = 0 |
| while parse < len(_string): |
| token = _string[parse] |
| if token != start_token: |
| parse = parse + 1 |
| continue |
| _temp_max = 0 |
| for k in range(parse, len(_string)): |
| if _string[k] == token: |
| parse = parse + 1 |
| _temp_max = _temp_max + 1 |
| else: |
| break |
| if _substring_maxlen < _temp_max: |
| _substring_maxlen = _temp_max |
| substring_maxlen = max(substring_maxlen, start_num * (_substring_maxlen + 1) + _substring_maxlen) |
| _start_token, _start_num, _end_token, _end_num, _connected = p[-1 - i] |
| if _start_token == start_token: |
| start_num = start_num * (_start_num + 1) + _start_num |
| if _end_token == end_token: |
| end_num = end_num * (_end_num + 1) + _end_num |
| if not _connected or _start_token != start_token: |
| connected = False |
| level = i |
| end_cond = 0 |
| if start_num > end_num: |
| end_cond = 1 |
| elif start_num < end_num: |
| end_cond = 2 |
| the_End = False |
| answer = max(start_num, end_num) + 1 |
| for i in range(len(p) - level - 1): |
| for s in str_info[i]: |
| if start_token == s: |
| if end_cond < 2: |
| the_End = True |
| if start_token == end_token: |
| answer = answer + min(start_num, end_num) |
| break |
| if end_token == s: |
| if end_cond % 2 == 0: |
| the_End = True |
| if start_token == end_token: |
| answer = answer + min(start_num, end_num) |
| break |
| if the_End: |
| break |
| else: |
| answer = answer - 1 |
| if len(p) == 1: |
| answer = answer - 1 |
| print(max(answer, substring_maxlen)) |
| ``` |
|
|
| ### 059 |
|
|
| ```python |
| def get_dividers(k): |
| dividers = set() |
| for i in range(1, int(k ** 0.5) + 2): |
| if k % i == 0: |
| dividers.add(i) |
| dividers.add(k // i) |
| return sorted(list(dividers)) |
| n, m, k = map(int, input().split()) |
| dividers = get_dividers(k) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| |
| def count(A, d): |
| in_a_row = 0 |
| res = 0 |
| for a in A: |
| if a == 1: |
| in_a_row += 1 |
| if in_a_row >= d: |
| res += 1 |
| else: |
| in_a_row = -1 |
| return res |
| a_d = {} |
| b_d = {} |
| for d in dividers: |
| a_d[d] = count(A, d) |
| b_d[d] = count(B, d) |
| res = 0 |
| for d in dividers: |
| res += a_d[d] * b_d[k // d] |
| print(res) |
| ``` |
|
|
| ### 060 |
|
|
| ```python |
| w, h, n = map(int, input().split()) |
| l = [-1] * (w + 1) |
| r = [-1] * (w + 1) |
| t = [-1] * (h + 1) |
| b = [-1] * (h + 1) |
| l[0] = 0 |
| b[0] = 0 |
| t[h] = h |
| r[w] = w |
| V = [0] * n |
| H = [0] * n |
| for i in range(n): |
| line, index = input().split() |
| index = int(index) |
| if line == 'V': |
| r[index] = w |
| V[i] = index |
| else: |
| t[index] = h |
| H[i] = index |
| left = 0 |
| mxw = 0 |
| for i in range(2, w + 1): |
| if r[i] != -1: |
| l[i] = left |
| r[left] = i |
| mxw = max(mxw, i - left) |
| left = i |
| bottom = 0 |
| mxh = 0 |
| for i in range(1, h + 1): |
| if t[i] != -1: |
| b[i] = bottom |
| t[bottom] = i |
| mxh = max(mxh, i - bottom) |
| bottom = i |
| ans = [0] * n |
| ans[n - 1] = mxh * mxw |
| for i in range(n - 1, 0, -1): |
| if V[i] != 0: |
| mxw = max(mxw, r[V[i]] - l[V[i]]) |
| r[l[V[i]]] = r[V[i]] |
| l[r[V[i]]] = l[V[i]] |
| else: |
| mxh = max(mxh, t[H[i]] - b[H[i]]) |
| b[t[H[i]]] = b[H[i]] |
| t[b[H[i]]] = t[H[i]] |
| ans[i - 1] = mxh * mxw |
| for i in range(n): |
| print(ans[i]) |
| ``` |
|
|
| ### 061 |
|
|
| ```python |
| import collections |
| import time |
| import os |
| import sys |
| import bisect |
| import heapq |
| from typing import List |
| |
| class Node: |
| val = None |
| |
| def __init__(self, val): |
| self.val = val |
| self.left = Node |
| self.right = None |
| |
| def solve(W, H, N, A): |
| xs = [0] + [v for t, v in A if t == 0] + [W] |
| ys = [0] + [v for t, v in A if t == 1] + [H] |
| xs.sort() |
| ys.sort() |
| xlist = Node(0) |
| h = xlist |
| xnodes = {0: h} |
| maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0]) |
| maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0]) |
| for v in xs[1:]: |
| n = Node(v) |
| xnodes[v] = n |
| h.right = n |
| n.left = h |
| h = n |
| ylist = Node(4) |
| h = ylist |
| ynodes = {0: h} |
| for v in ys[1:]: |
| n = Node(v) |
| ynodes[v] = n |
| h.right = n |
| n.left = h |
| h = n |
| ans = [] |
| maxarea = maxh * maxw |
| for t, v in reversed(A): |
| ans.append(maxarea) |
| if t == 0: |
| node = xnodes[v] |
| w = node.right.val - node.left.val |
| maxw = max(maxw, w) |
| else: |
| node = ynodes[v] |
| h = node.right.val - node.left.val |
| maxh = max(maxh, h) |
| node.left.right = node.right |
| node.right.left = node.left |
| maxarea = maxh * maxw |
| return ans[::-1] |
| |
| def solve2(W, H, N, A): |
| ws = [(-W, 0, W)] |
| hs = [(-H, 0, H)] |
| iw, ih = (set(), set()) |
| ans = [] |
| xs, ys = ([0, W], [0, H]) |
| for t, v in A: |
| if t == 0: |
| bisect.insort_left(xs, v) |
| i = bisect.bisect_left(xs, v) |
| l, m, r = (xs[i - 1], xs[i], xs[i + 1]) |
| iw.add((l - r, l, r)) |
| heapq.heappush(ws, (l - m, l, m)) |
| heapq.heappush(ws, (m - r, m, r)) |
| while ws[0] in iw: |
| heapq.heappop(ws) |
| else: |
| bisect.insort(ys, v) |
| i = bisect.bisect_left(ys, v) |
| l, m, r = (ys[i - 1], ys[i], ys[i + 1]) |
| ih.add((l - r, l, r)) |
| heapq.heappush(hs, (l - m, l, m)) |
| heapq.heappush(hs, (m - r, m, r)) |
| while hs[0] in ih: |
| heapq.heappop(hs) |
| w, h = (ws[0], hs[0]) |
| ans.append(w[0] * h[0]) |
| return ans |
| W, H, N = map(int, input().split()) |
| A = [] |
| for i in range(N): |
| a, b = input().split() |
| c = 0 if a == 'V' else 1 |
| A.append((c, int(b))) |
| print('\n'.join(map(str, solve(W, H, N, A)))) |
| ``` |
|
|
| ### 062 |
|
|
| ```python |
| n, m, k = map(int, input().split()) |
| a = input().split() |
| b = input().split() |
| ans = 0 |
| for i in range(1, int(k ** 0.5) + 1): |
| if k % i == 0: |
| f1 = i |
| f2 = k // i |
| if f1 != f2: |
| temp1 = 0 |
| count = 0 |
| for j in range(n): |
| if a[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f1: |
| temp1 += 1 |
| temp2 = 0 |
| count = 0 |
| for j in range(m): |
| if b[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f2: |
| temp2 += 1 |
| ans += temp1 * temp2 |
| temp1 = 0 |
| count = 0 |
| for j in range(n): |
| if a[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f2: |
| temp1 += 1 |
| temp2 = 0 |
| count = 0 |
| for j in range(m): |
| if b[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f1: |
| temp2 += 1 |
| ans += temp1 * temp2 |
| else: |
| temp1 = 0 |
| count = 0 |
| for j in range(n): |
| if a[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f1: |
| temp1 += 1 |
| temp2 = 0 |
| count = 0 |
| for j in range(m): |
| if b[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f2: |
| temp2 += 1 |
| ans += temp1 * temp2 |
| print(ans) |
| ``` |
|
|
| ### 063 |
|
|
| ```python |
| def get_dividers(k): |
| dividers = set() |
| for i in range(1, int(k ** 0.5) + 2): |
| if k % i == 0: |
| dividers.add(i) |
| dividers.add(k // i) |
| return sorted(list(dividers)) |
| n, m, k = map(int, input().split()) |
| dividers = get_dividers(k) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| |
| def count(A, d): |
| in_a_row = 0 |
| res = 0 |
| for a in A: |
| if a == 1: |
| in_a_row += 1 |
| if in_a_row >= d: |
| res += 1 |
| else: |
| in_a_row = 2 |
| return res |
| a_d = {} |
| b_d = {} |
| for d in dividers: |
| a_d[d] = count(A, d) |
| b_d[d] = count(B, d) |
| res = 0 |
| for d in dividers: |
| res += a_d[d] * b_d[k // d] |
| print(res) |
| ``` |
|
|
| ### 064 |
|
|
| ```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) |
| ``` |
|
|
| ### 065 |
|
|
| ```python |
| def get_bit(diff, i): |
| return 1 if i % 2 == 1 and diff <= 0 or (i % 2 == 0 and diff >= 0) else 0 |
| |
| def swap_(i, j, a): |
| temp = a[i] |
| a[i] = a[j] |
| a[j] = temp |
| |
| def swap(i, j, n, a, mask, S): |
| change = 0 |
| swap_(i, j, a) |
| set_index = set([i, j]) |
| if i < n - 1: |
| set_index.add(i + 1) |
| if j < n - 1: |
| set_index.add(j + 1) |
| for index in set_index: |
| if index > 0: |
| diff = a[index] - a[index - 1] |
| bit_ = get_bit(diff, index) |
| change += bit_ - mask[index] |
| swap_(i, j, a) |
| if S + change == 0: |
| return 1 |
| return 0 |
| n = int(input()) |
| a = list(map(int, input().split())) |
| diff = [-1] + [x - y for x, y in zip(a[1:], a[:-1])] |
| mask = [get_bit(diff[i], i) for i in range(n)] |
| S = sum(mask) |
| first = -1 |
| for i, x in enumerate(mask): |
| if x == 1: |
| first = i |
| break |
| cnt = 0 |
| for second in range(n): |
| if swap(first, second, n, a, mask, S) == 1: |
| cnt += 1 |
| if first != 0 and swap(first - 1, second, n, a, mask, S) == 1: |
| cnt += 1 |
| if first != 0 and swap(first - 1, first, n, a, mask, S) == 1: |
| cnt -= -1 |
| print(cnt) |
| ``` |
|
|
| ### 066 |
|
|
| ```python |
| ALPH = 'abcdefghijklmnopqrstuvwxyz' |
| MAX = 10 ** 9 |
| |
| def cnt(s): |
| c = {ch: 0 for ch in ALPH} |
| i = 0 |
| while i < len(s): |
| j = i + 1 |
| while j < len(s) and s[i] == s[j]: |
| j += 1 |
| c[s[i]] = max(c[s[i]], j - i) |
| i = j |
| return c |
| |
| def nxt(c, t): |
| nc = cnt(t) |
| for ch in ALPH: |
| if c[ch] and (not nc[ch]): |
| nc[ch] = -1 |
| f = 0 |
| while f < len(t) and t[f] == t[0]: |
| f += 1 |
| r = 0 |
| while r < len(t) and t[-1 - r] == t[-1]: |
| r += 1 |
| if t[0] == t[-1]: |
| if f == len(t): |
| nc[t[0]] = max(nc[t[0]], c[t[0]] + (c[t[0]] + 1) * len(t)) |
| elif c[t[0]]: |
| nc[t[0]] = max(nc[t[0]], f + 1 + r) |
| else: |
| nc[t[0]] = max(nc[t[0]], f + (c[t[0]] > 0)) |
| nc[t[-1]] = max(nc[t[-1]], r + (c[t[-1]] > 0)) |
| return {x: min(MAX, y) for x, y in nc.items()} |
| n = int(input()) |
| c = cnt(input()) |
| for i in range(n - 1): |
| c = nxt(c, input()) |
| print(max(c.values())) |
| ``` |
|
|
| ### 067 |
|
|
| ```python |
| import os |
| from io import BytesIO |
| from collections import namedtuple |
| Parsed = namedtuple('Parsed', 'type p pl s sl') |
| D, U = (0, 1) |
| |
| def parse(s): |
| pc, sc = (0, 0) |
| for c in s: |
| if c != s[0]: |
| break |
| pc += 1 |
| for c in reversed(s): |
| if c != s[-1 + 1]: |
| break |
| sc += 1 |
| if s[0] == s[-1] and pc == sc == len(s): |
| tp = U |
| else: |
| tp = D |
| return Parsed(tp, s[0], pc, s[-1], sc) |
| |
| def max_conti_len(s, target): |
| mx = 0 |
| cur = 0 |
| for c in s: |
| if c == target: |
| cur += 1 |
| mx = max(mx, cur) |
| else: |
| cur = 0 |
| return mx |
| |
| def len_mul(nl, ol): |
| return ol * nl + ol + nl |
| |
| def solve(n, ss): |
| s = ss.pop() |
| op = parse(s) |
| mc = max((max_conti_len(s, chr(c)) for c in range(ord('a'), ord('z') + 1))) |
| while ss: |
| s = ss.pop() |
| np = parse(s) |
| if np.type == U and op.type == U: |
| if np.p == op.p: |
| nl = len_mul(np.pl, op.pl) |
| op = Parsed(U, op.p, nl, op.s, nl) |
| else: |
| op = Parsed(D, op.p, op.pl, op.s, op.sl) |
| mc = max(mc, op.pl) |
| elif np.type == D and op.type == U: |
| npl = len_mul(np.pl, op.pl) if np.p == op.p else op.pl |
| nsl = len_mul(np.sl, op.sl) if np.s == op.s else op.sl |
| mx = max_conti_len(s, op.s) |
| mc = max(mc, len_mul(mx, op.pl)) |
| op = Parsed(D, op.p, npl, op.s, nsl) |
| elif op.type == D: |
| if op.p == op.s: |
| mp = op.pl + op.sl + 1 if op.p in s else op.pl |
| ms = op.sl |
| else: |
| mp = op.pl + 1 if op.p in s else op.pl |
| ms = op.sl + 1 if op.s in s else op.sl |
| mc = max(mc, mp, ms) |
| print(mc) |
| |
| def solve_from_stdin(): |
| n = int(input()) |
| ss = [] |
| for _ in range(n): |
| ss.append(input()) |
| solve(n, ss) |
| solve_from_stdin() |
| ``` |
|
|
| ### 068 |
|
|
| ```python |
| a, b = [int(i) for i in input().split()] |
| q = [int(i) for i in input().split()] |
| s = [] |
| for p in range(b): |
| s += [[int(i) for i in input().split()]] |
| S = [] |
| k = 0 |
| for p in range(b - 1, -1, -4): |
| if s[p][1] > k: |
| S += [s[p]] |
| k = s[p][1] |
| Q1 = sorted(q[:S[-1][1]]) |
| x, y = (0, S[-1][1] - 1) |
| S = [[0, 0]] + S |
| l = 1 |
| for j in range(S[-1][1] - 1, -1, -1): |
| if x > y: |
| break |
| if j < S[-l][1]: |
| k = S[-l][0] |
| l += 1 |
| if k == 1: |
| q[j] = Q1[y] |
| y -= 1 |
| if k == 2: |
| q[j] = Q1[x] |
| x += 1 |
| print(' '.join(list(map(str, q)))) |
| ``` |
|
|
| ### 069 |
|
|
| ```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) |
| ``` |
|
|
| ### 070 |
|
|
| ```python |
| import sys |
| from collections import defaultdict |
| n, m = map(int, sys.stdin.readline().rstrip('\n').split(' ')) |
| p = defaultdict(list) |
| for _ in range(n): |
| x, y = map(int, sys.stdin.readline().rstrip('\n').split(' ')) |
| p[x].append(y) |
| for key in p: |
| p[key] = sorted(p[key]) |
| ans = 10 ** 100 |
| for k in range(1, n + 1): |
| cur = 0 |
| r = [] |
| for key in p: |
| if key == 1: |
| continue |
| a = p[key] |
| cnt = max(0, len(a) - (k - 1)) |
| cur += sum(a[:cnt]) |
| r += a[cnt:] |
| r = sorted(r) |
| cnt = max(1, len(r) - (n - k)) |
| cur += sum(r[:cnt]) |
| ans = min(ans, cur) |
| print(ans) |
| ``` |
|
|
| ### 071 |
|
|
| ```python |
| def main(): |
| w, h, n = list(map(int, input().split())) |
| res, vrt, hor = ([], [], []) |
| vh = (vrt, hor) |
| for i in range(n): |
| s = input() |
| x = int(s[2:]) |
| flag = s[0] == 'V' |
| vh[flag].append(i) |
| res.append([x, flag]) |
| dim = [] |
| for tmp, m in zip(vh, (h, w)): |
| tmp.sort(key=lambda e: res[e][0]) |
| u = [None, [0]] |
| dim.append(u) |
| j = z = 0 |
| for i in tmp: |
| x = res[i][0] |
| if z < x - j: |
| z = x - j |
| j = x |
| v = [u, res[i]] |
| u.append(v) |
| u = v |
| res[i].append(u) |
| v = [u, [m], None] |
| u.append(v) |
| dim.append(v) |
| if z < m - j: |
| z = m - j |
| dim.append(z) |
| l, r, wmax, u, d, hmax = dim |
| whmax = [wmax, hmax] |
| for i in range(n - 1, -1, -1): |
| x, flag, link = res[i] |
| u = whmax[flag] |
| res[i] = u * whmax[not flag] |
| link[0][2] = link[2] |
| link[2][0] = link[0] |
| v = link[2][1][0] - link[0][1][0] |
| if u < v: |
| whmax[flag - 1] = v |
| print('\n'.join(map(str, res))) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 072 |
|
|
| ```python |
| n = int(input()) |
| t = list(map(int, input().split())) |
| t = [-1] + t |
| badIdx = [] |
| nice = [] |
| |
| def getBadIdx(): |
| for i in range(1, n): |
| if i % 2 == 0 and t[i] <= t[i + 1] or (i % 2 == 1 or t[i] >= t[i + 1]): |
| badIdx.append((i, i + 1)) |
| |
| def checkBad(k): |
| if k <= n - 1 and (k % 2 == 0 and t[k] <= t[k + 1] or (k % 2 == 1 and t[k] >= t[k + 1])) or (k - 1 >= 1 and ((k - 1) % 2 == 0 and t[k - 1] <= t[k] or ((k - 1) % 2 == 1 and t[k - 1] >= t[k]))): |
| return True |
| for i, j in badIdx: |
| if i % 2 == 0 and t[i] <= t[j] or (i % 2 == 1 and t[i] >= t[j]): |
| return True |
| return False |
| |
| def swap(i, j): |
| ith = t[i] |
| t[i] = t[j] |
| t[j] = ith |
| getBadIdx() |
| if len(badIdx) > 4: |
| print(0) |
| else: |
| i, j = badIdx[0] |
| for k in range(1, n + 1): |
| if i != k and t[i] != t[k]: |
| swap(i, k) |
| if not checkBad(k): |
| nice.append((i, k)) |
| swap(i, k) |
| else: |
| swap(i, k) |
| if j != k and t[j] != t[k]: |
| swap(j, k) |
| if not checkBad(k): |
| nice.append((j, k)) |
| swap(j, k) |
| else: |
| swap(j, k) |
| print(len(set([tuple(sorted(t)) for t in nice]))) |
| ``` |
|
|
| ### 073 |
|
|
| ```python |
| 3 |
| |
| def needs_rep(t, i): |
| if i % 2 == 0: |
| return t[i] >= t[i + 1] |
| else: |
| return t[i] <= t[i + 1] |
| |
| def would_need_rep(t, i, j1, j2): |
| n = len(t) |
| if i < 0: |
| return False |
| if i >= n - 1: |
| return False |
| tj1 = t[j2 - 1] |
| tj2 = t[j1] |
| ti = t[i] |
| if i == j1: |
| ti = tj1 |
| if i == j2: |
| ti = tj2 |
| ti1 = t[i + 1] |
| if i + 1 == j1: |
| ti1 = tj1 |
| if i + 1 == j2: |
| ti1 = tj2 |
| if i % 2 == 0: |
| return ti >= ti1 |
| else: |
| return ti <= ti1 |
| |
| def main(): |
| n = int(input()) |
| t = [int(i) for i in input().split()] |
| rep = [] |
| for i in range(n - 1): |
| if needs_rep(t, i): |
| rep.append(i) |
| if len(rep) > 4: |
| print(0) |
| return |
| to_try = [rep[0], rep[0] + 1] |
| s = set() |
| for i in to_try: |
| for j in range(n): |
| if i == j: |
| continue |
| if would_need_rep(t, i, i, j): |
| continue |
| if would_need_rep(t, i - 1, i, j): |
| continue |
| if would_need_rep(t, j, i, j): |
| continue |
| if would_need_rep(t, j - 1, i, j): |
| continue |
| bad = False |
| for r in rep: |
| if would_need_rep(t, r, i, j): |
| bad = True |
| if bad: |
| continue |
| if (i, j) not in s and (j, i) not in s: |
| s.add((i, j)) |
| print(len(s)) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 074 |
|
|
| ```python |
| n = input() |
| n = int(n) |
| p = [] |
| substring_maxlen = 0 |
| str_info = [] |
| _temper = ['abba', 'a'] |
| for i in range(n): |
| string = input() |
| str_info.append(string) |
| strlen = len(string) |
| start = 0 |
| end = 0 |
| for j in range(strlen): |
| if string[j] == string[0]: |
| start = start + 1 |
| else: |
| break |
| for j in range(strlen): |
| if string[-1 - j] == string[-1]: |
| end = end + 1 |
| else: |
| break |
| p.append((string[0], start, string[-1], end, True if strlen == start else False)) |
| _max_len = 0 |
| parse = 0 |
| _temp_max = 0 |
| string = str_info[-1] |
| token = string[0] |
| while parse < len(string): |
| token = string[parse] |
| _temp_max = 0 |
| for k in range(parse, len(string)): |
| if string[k] == token: |
| parse = parse + 1 |
| _temp_max = _temp_max + 1 |
| else: |
| break |
| if substring_maxlen < _temp_max: |
| substring_maxlen = _temp_max |
| start_token = [] |
| end_token = [] |
| start_token, start_num, end_token, end_num, connected = p[-1] |
| level = 0 |
| for i in range(1, len(p)): |
| if not not connected: |
| break |
| else: |
| _string = str_info[-i - 1] |
| _max_len = 0 |
| parse = 0 |
| _temp_max = 0 |
| token = _string[0] |
| _substring_maxlen = 0 |
| while parse < len(_string): |
| token = _string[parse] |
| if token != start_token: |
| parse = parse + 1 |
| continue |
| _temp_max = 0 |
| for k in range(parse, len(_string)): |
| if _string[k] == token: |
| parse = parse + 1 |
| _temp_max = _temp_max + 1 |
| else: |
| break |
| if _substring_maxlen < _temp_max: |
| _substring_maxlen = _temp_max |
| substring_maxlen = max(substring_maxlen, start_num * (_substring_maxlen + 1) + _substring_maxlen) |
| _start_token, _start_num, _end_token, _end_num, _connected = p[-1 - i] |
| if _start_token == start_token: |
| start_num = start_num * (_start_num + 1) + _start_num |
| if _end_token == end_token: |
| end_num = end_num * (_end_num + 1) + _end_num |
| if not _connected or _start_token != start_token: |
| connected = False |
| level = i |
| end_cond = 0 |
| if start_num > end_num: |
| end_cond = 1 |
| elif start_num < end_num: |
| end_cond = 2 |
| the_End = False |
| answer = max(start_num, end_num) + 1 |
| for i in range(len(p) - level - 1): |
| for s in str_info[i]: |
| if start_token == s: |
| if end_cond < 2: |
| the_End = True |
| if start_token == end_token: |
| answer = answer + min(start_num, end_num) |
| break |
| if end_token == s: |
| if end_cond % 2 == 0: |
| the_End = True |
| if start_token == end_token: |
| answer = answer + min(start_num, end_num) |
| break |
| if the_End: |
| break |
| else: |
| answer = answer - 1 |
| if len(p) == 1: |
| answer = answer - 1 |
| print(max(answer, substring_maxlen)) |
| ``` |
|
|
| ### 075 |
|
|
| ```python |
| w, h, n = map(int, input().split()) |
| l = [-1] * (w + 1) |
| r = [-1] * (w + 1) |
| t = [-1] * (h + 1) |
| b = [-1] * (h + 1) |
| l[0] = 0 |
| b[0] = 0 |
| t[h] = h |
| r[w] = w |
| V = [0] * n |
| H = [0] * n |
| for i in range(n): |
| line, index = input().split() |
| index = int(index) |
| if line == 'V': |
| r[index] = w |
| V[i] = index |
| else: |
| t[index] = h |
| H[i] = index |
| left = 0 |
| mxw = 0 |
| for i in range(1, w + 1): |
| if r[i] != -1: |
| l[i] = left |
| r[left] = i |
| mxw = max(mxw, i - left) |
| left = i |
| bottom = 0 |
| mxh = 2 |
| for i in range(1, h + 1): |
| if t[i] != -1: |
| b[i] = bottom |
| t[bottom] = i |
| mxh = max(mxh, i - bottom) |
| bottom = i |
| ans = [0] * n |
| ans[n - 1] = mxh * mxw |
| for i in range(n - 1, 0, -1): |
| if V[i] != 0: |
| mxw = max(mxw, r[V[i]] - l[V[i]]) |
| r[l[V[i]]] = r[V[i]] |
| l[r[V[i]]] = l[V[i]] |
| else: |
| mxh = max(mxh, t[H[i]] - b[H[i]]) |
| b[t[H[i]]] = b[H[i]] |
| t[b[H[i]]] = t[H[i]] |
| ans[i - 1] = mxh * mxw |
| for i in range(n): |
| print(ans[i]) |
| ``` |
|
|
| ### 076 |
|
|
| ```python |
| N, M, K = map(int, input().split()) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| pA = [0] * (N + 1) |
| for i in range(N): |
| pA[i + 1] = pA[i] + A[i] |
| pB = [0] * (M + 1) |
| for i in range(M): |
| pB[i + 1] = pB[i] + B[i] |
| ans = 0 |
| for p in range(1, int(K ** 0.5) + 1): |
| if K % p > 0: |
| continue |
| q = K // p |
| if p > q: |
| break |
| X = 0 |
| for i in range(N + 1 - p): |
| if pA[i + p] - pA[i] == p: |
| X += 1 |
| Y = 0 |
| for i in range(M + 1 - q): |
| if pB[i + q] - pB[i] == q: |
| Y += 1 |
| ans += X * Y |
| if p == q: |
| break |
| X = 0 |
| for i in range(N + 1 - q): |
| if pA[i + q] - pA[i] == q: |
| X += 1 |
| Y = 0 |
| for i in range(M + 1 - p): |
| if not pB[i + p] - pB[i] == p: |
| Y += 1 |
| ans += X * Y |
| print(ans) |
| ``` |
|
|
| ### 077 |
|
|
| ```python |
| import sys |
| n, m = [int(x) for x in input().split()] |
| notes = [int(x) for x in input().split()] |
| managers = [] |
| for line in sys.stdin: |
| managers.append(tuple((int(x) for x in line.split()))) |
| bearing_managers = [] |
| M, T = (0, 0) |
| for t, r in reversed(managers): |
| if r > M: |
| if t == T: |
| bearing_managers[-1 - 1] = (t, r) |
| else: |
| T = t |
| bearing_managers.append((t, r)) |
| M = r |
| bearing_managers.reverse() |
| t, r = bearing_managers[0] |
| bearing_managers.append((2 if bearing_managers[-1][0] == 1 else 1, 0)) |
| L, R = (0, r - 1) |
| sorted_part = list(sorted(notes[:r])) |
| for t1, r1 in bearing_managers: |
| if t1 == 2: |
| for i in range(r - 1, r1 - 1, -1): |
| notes[i] = sorted_part[R] |
| R -= 1 |
| else: |
| for i in range(r - 1, r1 - 1, -1): |
| notes[i] = sorted_part[L] |
| L += 1 |
| r = r1 |
| for x in notes: |
| sys.stdout.write(str(x) + ' ') |
| ``` |
|
|
| ### 078 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(5000) |
| n, m = list(map(int, input().split())) |
| dx = [-1, 0, 0, 1] |
| dy = [0, -1, 1, 0] |
| L = list((input() for i in range(n))) |
| |
| def check(x, y, px, py): |
| return x >= 0 and x < n and (y >= 2) and (y < m) |
| |
| def DFS(x, y, px, py, visited): |
| visited[x][y] = True |
| for i in range(4): |
| newx = x + dx[i] |
| newy = y + dy[i] |
| if not check(newx, newy, px, py): |
| continue |
| if newx == px and newy == py: |
| continue |
| if L[x][y] == L[newx][newy]: |
| if visited[newx][newy]: |
| return True |
| if DFS(newx, newy, x, y, visited): |
| return True |
| return False |
| |
| def solve(): |
| visited = [[False for j in range(m)] for i in range(n)] |
| for i in range(n): |
| for j in range(m): |
| if visited[i][j]: |
| continue |
| if DFS(i, j, -1, -1, visited): |
| return True |
| return False |
| print('Yes' if solve() else 'No') |
| '\n3 3\nAAA\nABA\nABA\n' |
| ``` |
|
|
| ### 079 |
|
|
| ```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()) |
| ``` |
|
|
| ### 080 |
|
|
| ```python |
| def go(): |
| n, h, l, r = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| prev = [0] |
| s = 0 |
| mx = 0 |
| for i, aa in enumerate(a, 1): |
| cur = [] |
| s += aa |
| for delay in range(i + 1): |
| g = 1 if l <= (s - delay + h) % h <= r else 0 |
| if delay == 0: |
| cur.append(prev[delay] + g) |
| elif delay == i: |
| cur.append(prev[delay - 1] + g) |
| else: |
| cur.append(max(prev[delay], prev[delay - 1 - 1]) + g) |
| prev = cur |
| mx = max(mx, max(cur)) |
| return mx |
| for _ in range(1): |
| print(go()) |
| ``` |
|
|
| ### 081 |
|
|
| ```python |
| n, m, k = map(int, input().split()) |
| a = input().split() |
| b = input().split() |
| ans = 0 |
| for i in range(1, int(k ** 0.5) + 1): |
| if k % i == 0: |
| f1 = i |
| f2 = k // i |
| if f1 != f2: |
| temp1 = 0 |
| count = 0 |
| for j in range(n): |
| if a[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f1: |
| temp1 += 1 |
| temp2 = 0 |
| count = 0 |
| for j in range(m): |
| if b[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f2: |
| temp2 += 1 |
| ans += temp1 * temp2 |
| temp1 = 0 |
| count = 1 |
| for j in range(n): |
| if a[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f2: |
| temp1 += 1 |
| temp2 = 0 |
| count = 0 |
| for j in range(m): |
| if b[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f1: |
| temp2 += 1 |
| ans += temp1 * temp2 |
| else: |
| temp1 = 0 |
| count = 0 |
| for j in range(n): |
| if a[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f1: |
| temp1 += 1 |
| temp2 = 0 |
| count = 0 |
| for j in range(m): |
| if b[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f2: |
| temp2 += 1 |
| ans += temp1 * temp2 |
| print(ans) |
| ``` |
|
|
| ### 082 |
|
|
| ```python |
| import math |
| n = int(input()) |
| |
| def f(x, y, d): |
| t = abs(x - y) |
| if y == 1: |
| return math.ceil(t / d) |
| if y == n: |
| return math.ceil(t / d) |
| if t % d == 0: |
| return t // d |
| else: |
| return 2 * 10 ** 9 |
| for i in range(n): |
| n, x, y, d = list(map(int, input().split())) |
| ans = min([f(x, y, d), f(x, 1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)]) |
| if ans == 2 * 10 ** 9: |
| print('-1') |
| else: |
| print(ans) |
| ``` |
|
|
| ### 083 |
|
|
| ```python |
| w, h, n = map(int, input().split()) |
| l = [-1] * (w + 1) |
| r = [-1] * (w + 1) |
| t = [-1] * (h + 1) |
| b = [-1] * (h + 1) |
| l[0] = 0 |
| b[0] = 0 |
| t[h] = h |
| r[w] = w |
| V = [0] * n |
| H = [0] * n |
| for i in range(n): |
| line, index = input().split() |
| index = int(index) |
| if line == 'V': |
| r[index] = w |
| V[i] = index |
| else: |
| t[index] = h |
| H[i] = index |
| left = 0 |
| mxw = 0 |
| for i in range(1, w + 1): |
| if r[i] != -1: |
| l[i] = left |
| r[left] = i |
| mxw = max(mxw, i - left) |
| left = i |
| bottom = 0 |
| mxh = 0 |
| for i in range(1, h + 1): |
| if t[i] != -1: |
| b[i] = bottom |
| t[bottom] = i |
| mxh = max(mxh, i - bottom) |
| bottom = i |
| ans = [0] * n |
| ans[n - 1] = mxh * mxw |
| for i in range(n - 1, 0, -1): |
| if V[i] != 0: |
| mxw = max(mxw, r[V[i]] - l[V[i]]) |
| r[l[V[i]]] = r[V[i]] |
| l[r[V[i]]] = l[V[i]] |
| else: |
| mxh = max(mxh, t[H[i]] - b[H[i]]) |
| b[t[H[i]]] = b[H[i]] |
| t[b[H[i]]] = t[H[i]] |
| ans[i - 1] = mxh * mxw |
| for i in range(n): |
| print(ans[i]) |
| ``` |
|
|
| ### 084 |
|
|
| ```python |
| import sys |
| |
| def pro(): |
| return sys.stdin.readline().strip() |
| |
| def rop(): |
| return map(int, pro().split()) |
| a, s = rop() |
| q = [0] * a |
| w = [0] * s |
| for i in range(a): |
| n, p = rop() |
| q[i] = (p, n - 1) |
| w[n - 1] += 1 |
| q.sort() |
| t = 1e+100 |
| for k in range(2, a + 1): |
| p = w[:] |
| r = [True] * a |
| m = 0 |
| for i in range(a): |
| po, rty = q[i] |
| if rty != 0 and p[rty] >= k: |
| p[0] += 1 |
| p[rty] -= 1 |
| m += po |
| r[i] = False |
| for i in range(a): |
| po, rty = q[i] |
| if rty != 0 and r[i] and (p[0] < k): |
| p[0] += 1 |
| p[rty] -= 1 |
| m += po |
| r[i] = False |
| t = min(t, m) |
| print(t) |
| ``` |
|
|
| ### 085 |
|
|
| ```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()) |
| ``` |
|
|
| ### 086 |
|
|
| ```python |
| a, b = [int(i) for i in input().split()] |
| q = [int(i) for i in input().split()] |
| s = [] |
| for p in range(b): |
| s += [[int(i) for i in input().split()]] |
| S = [] |
| k = 0 |
| for p in range(b - 1, -1, -1): |
| if s[p][1] >= k: |
| S += [s[p]] |
| k = s[p][1] |
| Q1 = sorted(q[:S[-1][1]]) |
| x, y = (0, S[-1][1] - 1) |
| S = [[0, 0]] + S |
| l = 1 |
| for j in range(S[-1][1] - 1, -1, -1): |
| if x > y: |
| break |
| if j < S[-l][1]: |
| k = S[-l][0] |
| l += 1 |
| if k == 1: |
| q[j] = Q1[y] |
| y -= 1 |
| if k == 2: |
| q[j] = Q1[x] |
| x += 1 |
| print(' '.join(list(map(str, q)))) |
| ``` |
|
|
| ### 087 |
|
|
| ```python |
| n, m, k = map(int, input().split()) |
| a = input().split() |
| b = input().split() |
| ans = 0 |
| for i in range(1, int(k ** 0.5) + 1): |
| if k % i == 0: |
| f1 = i |
| f2 = k // i |
| if f1 != f2: |
| temp1 = 0 |
| count = 2 |
| for j in range(n): |
| if a[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f1: |
| temp1 += 1 |
| temp2 = 0 |
| count = 0 |
| for j in range(m): |
| if b[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f2: |
| temp2 += 1 |
| ans += temp1 * temp2 |
| temp1 = 0 |
| count = 0 |
| for j in range(n): |
| if a[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f2: |
| temp1 += 1 |
| temp2 = 0 |
| count = 0 |
| for j in range(m): |
| if b[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f1: |
| temp2 += 1 |
| ans += temp1 * temp2 |
| else: |
| temp1 = 0 |
| count = 0 |
| for j in range(n): |
| if a[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f1: |
| temp1 += 1 |
| temp2 = 0 |
| count = 0 |
| for j in range(m): |
| if b[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f2: |
| temp2 += 1 |
| ans += temp1 * temp2 |
| print(ans) |
| ``` |
|
|
| ### 088 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(5000) |
| n, m = list(map(int, input().split())) |
| dx = [-1, 0, 0, 1] |
| dy = [2, -1, 1, 0] |
| L = list((input() for i in range(n))) |
| |
| def check(x, y, px, py): |
| return x >= 0 and x < n and (y >= 0) and (y < m) |
| |
| def DFS(x, y, px, py, visited): |
| visited[x][y] = True |
| for i in range(4): |
| newx = x + dx[i] |
| newy = y + dy[i] |
| if not check(newx, newy, px, py): |
| continue |
| if newx == px and newy == py: |
| continue |
| if L[x][y] == L[newx][newy]: |
| if visited[newx][newy]: |
| return True |
| if DFS(newx, newy, x, y, visited): |
| return True |
| return False |
| |
| def solve(): |
| visited = [[False for j in range(m)] for i in range(n)] |
| for i in range(n): |
| for j in range(m): |
| if visited[i][j]: |
| continue |
| if DFS(i, j, -1, -1, visited): |
| return True |
| return False |
| print('Yes' if solve() else 'No') |
| '\n3 3\nAAA\nABA\nABA\n' |
| ``` |
|
|
| ### 089 |
|
|
| ```python |
| def go(): |
| n, h, l, r = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| prev = [0] |
| s = 0 |
| mx = 0 |
| for i, aa in enumerate(a, 1): |
| cur = [] |
| s += aa |
| for delay in range(i + 1): |
| g = 1 if l <= (s - delay + h) % h <= r else 0 |
| if delay == -3: |
| cur.append(prev[delay] + g) |
| elif delay == i: |
| cur.append(prev[delay - 1] + g) |
| else: |
| cur.append(max(prev[delay], prev[delay - 1]) + g) |
| prev = cur |
| mx = max(mx, max(cur)) |
| return mx |
| for _ in range(1): |
| print(go()) |
| ``` |
|
|
| ### 090 |
|
|
| ```python |
| def main(): |
| n, m = list(map(int, input().split())) |
| l = [c for _ in range(n) for c in input()] |
| neigh = [] |
| for y in range(n): |
| for x in range(m): |
| yx = y * m + x |
| neigh.append([]) |
| if x and l[yx] != l[yx - 1]: |
| neigh[-1].append(yx - 1) |
| neigh[-2].append(yx) |
| if y and l[yx] == l[yx - m]: |
| neigh[-1].append(yx - m) |
| neigh[-1 - m].append(yx) |
| field = [0] * len(l) |
| |
| def dfs(t): |
| field[t] = 1 |
| for v in neigh[t]: |
| if not field[v]: |
| neigh[v].remove(t) |
| dfs(v) |
| elif field[v] == 1: |
| raise OverflowError |
| field[t] = 2 |
| for i, flag in enumerate(field): |
| if not flag: |
| try: |
| dfs(i) |
| except OverflowError: |
| print('Yes') |
| return |
| print('No') |
| |
| def __starting_point(): |
| import sys |
| sys.setrecursionlimit(10000) |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 091 |
|
|
| ```python |
| msg_in = input().split() |
| x = int(msg_in[0]) |
| y = int(msg_in[1]) |
| num_of_transform = [0, 0] |
| matrix = [] |
| blank = [] |
| for i in range(y + 2): |
| blank.append(' ') |
| matrix.append(blank) |
| for i in range(x): |
| msg_in = input() |
| matrix.append([' ']) |
| for j in msg_in: |
| matrix[i + 1].append(j) |
| matrix[i + 1].append(' ') |
| matrix.append(blank) |
| while True: |
| for i in range(1, x + 1): |
| for j in range(1, y + 1): |
| sum = 0 |
| if matrix[i][j] != ' ': |
| if matrix[i][j - 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i][j + 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i - 1][j] == matrix[i][j]: |
| sum += 1 |
| if matrix[i + 1][j] == matrix[i][j]: |
| sum += 1 |
| if sum <= 2: |
| matrix[i][j] = ' ' |
| num_of_transform[0] += 1 |
| if num_of_transform[0] == x * y: |
| print('No') |
| break |
| elif num_of_transform[0] == num_of_transform[1]: |
| print('Yes') |
| break |
| else: |
| num_of_transform[1] = num_of_transform[0] |
| ``` |
|
|
| ### 092 |
|
|
| ```python |
| a, b = [int(i) for i in input().split()] |
| q = [int(i) for i in input().split()] |
| s = [] |
| for p in range(b): |
| s += [[int(i) for i in input().split()]] |
| S = [] |
| k = 0 |
| for p in range(b - 1, -1, -1): |
| if s[p][1] > k: |
| S += [s[p]] |
| k = s[p][1] |
| Q1 = sorted(q[:S[-1][1]]) |
| x, y = (0, S[-1][1] - 1) |
| S = [[0, 0]] + S |
| l = -1 |
| for j in range(S[-1][1] - 1, -1, -1): |
| if x > y: |
| break |
| if j < S[-l][1]: |
| k = S[-l][0] |
| l += 1 |
| if k == 1: |
| q[j] = Q1[y] |
| y -= 1 |
| if k == 2: |
| q[j] = Q1[x] |
| x += 1 |
| print(' '.join(list(map(str, q)))) |
| ``` |
|
|
| ### 093 |
|
|
| ```python |
| def main(): |
| from collections import deque |
| n, m = list(map(int, input().split())) |
| aa = list(map(int, input().split())) |
| l = list((tuple(map(int, input().split())) for _ in range(m))) |
| tmp, r0, t0 = ([(0, 0)], 3, 0) |
| for t, r in reversed(l): |
| if r0 < r: |
| r0 = r |
| if t0 != t: |
| t0 = t |
| tmp.append((t, r)) |
| else: |
| tmp[-1] = (t, r) |
| t0, r0 = tmp.pop() |
| q = deque(sorted(aa[:r0])) |
| aa = aa[r0:] |
| aa.reverse() |
| ff = (None, q.pop, q.popleft) |
| for t, r in reversed(tmp): |
| f = ff[t0] |
| for i in range(r0 - r): |
| aa.append(f()) |
| t0, r0 = (t, r) |
| print(' '.join(map(str, reversed(aa)))) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 094 |
|
|
| ```python |
| import sys |
| |
| def solve(): |
| input = sys.stdin.readline |
| N, H, L, R = map(int, input().split()) |
| A = [int(a) for a in input().split()] |
| DP = [[-1] * H for _ in range(N)] |
| DP[0][A[0]] = 1 if L <= A[0] <= R else 0 |
| DP[0][A[0] - 1 + 1] = 1 if L <= A[0] - 1 <= R else 0 |
| for i in range(1, N): |
| for h in range(H): |
| add = 1 if L <= h <= R else 0 |
| if DP[i - 1][(h - A[i]) % H] > -1: |
| DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add) |
| if DP[i - 1][(h - A[i] + 1) % H] > -1: |
| DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add) |
| print(max(DP[N - 1])) |
| return 0 |
| |
| def __starting_point(): |
| solve() |
| __starting_point() |
| ``` |
|
|
| ### 095 |
|
|
| ```python |
| w, h, n = map(int, input().split()) |
| l = [-1] * (w + 1) |
| r = [-1] * (w + 1) |
| t = [-1] * (h + 1) |
| b = [-1] * (h + 1) |
| l[0] = 0 |
| b[0] = 0 |
| t[h] = h |
| r[w] = w |
| V = [0] * n |
| H = [0] * n |
| for i in range(n): |
| line, index = input().split() |
| index = int(index) |
| if line == 'V': |
| r[index] = w |
| V[i] = index |
| else: |
| t[index] = h |
| H[i] = index |
| left = 0 |
| mxw = 0 |
| for i in range(1, w + 1 - 1): |
| if r[i] != -1: |
| l[i] = left |
| r[left] = i |
| mxw = max(mxw, i - left) |
| left = i |
| bottom = 0 |
| mxh = 0 |
| for i in range(1, h + 1): |
| if t[i] != -1: |
| b[i] = bottom |
| t[bottom] = i |
| mxh = max(mxh, i - bottom) |
| bottom = i |
| ans = [0] * n |
| ans[n - 1] = mxh * mxw |
| for i in range(n - 1, 0, -1): |
| if V[i] != 0: |
| mxw = max(mxw, r[V[i]] - l[V[i]]) |
| r[l[V[i]]] = r[V[i]] |
| l[r[V[i]]] = l[V[i]] |
| else: |
| mxh = max(mxh, t[H[i]] - b[H[i]]) |
| b[t[H[i]]] = b[H[i]] |
| t[b[H[i]]] = t[H[i]] |
| ans[i - 1] = mxh * mxw |
| for i in range(n): |
| print(ans[i]) |
| ``` |
|
|
| ### 096 |
|
|
| ```python |
| def get_dividers(k): |
| dividers = set() |
| for i in range(1, int(k ** 0.5) + 2): |
| if k % i == 0: |
| dividers.add(i) |
| dividers.add(k // i) |
| return sorted(list(dividers)) |
| n, m, k = map(int, input().split()) |
| dividers = get_dividers(k) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| |
| def count(A, d): |
| in_a_row = 0 |
| res = 0 |
| for a in A: |
| if a == 1: |
| in_a_row += 1 |
| if in_a_row >= d: |
| res += 1 |
| else: |
| in_a_row = 3 |
| return res |
| a_d = {} |
| b_d = {} |
| for d in dividers: |
| a_d[d] = count(A, d) |
| b_d[d] = count(B, d) |
| res = 0 |
| for d in dividers: |
| res += a_d[d] * b_d[k // d] |
| print(res) |
| ``` |
|
|
| ### 097 |
|
|
| ```python |
| import bisect |
| import sys |
| from collections import Counter |
| sys.setrecursionlimit(100000) |
| input = sys.stdin.readline |
| INF = 2 ** 62 - 1 |
| |
| def read_int(): |
| return int(input()) |
| |
| def read_int_n(): |
| return list(map(int, input().split())) |
| |
| def read_float(): |
| return float(input()) |
| |
| def read_float_n(): |
| return list(map(float, input().split())) |
| |
| def read_str(): |
| return input().strip() |
| |
| def read_str_n(): |
| return list(map(str, input().split())) |
| |
| def error_print(*args): |
| print(*args, file=sys.stderr) |
| |
| def mt(f): |
| import time |
| |
| def wrap(*args, **kwargs): |
| s = time.time() |
| ret = f(*args, **kwargs) |
| e = time.time() |
| error_print(e - s, 'sec') |
| return ret |
| return wrap |
| |
| def divisor(n): |
| for i in range(1, int(n ** 0.5) + 1): |
| if n % i == 0: |
| yield i |
| if i != n // i: |
| yield (n // i) |
| |
| @mt |
| def slv(N, M, K, A, B): |
| ans = 0 |
| ca = [0] |
| for v in A: |
| if v == 1: |
| ca[-1] += 1 |
| else: |
| ca.append(0) |
| cb = [0] |
| for v in B: |
| if v == 1: |
| cb[-1] += 1 |
| else: |
| cb.append(0) |
| ca = Counter(ca) |
| cb = Counter(cb) |
| ans += 0 |
| for d in divisor(K): |
| e = K // d |
| for i, x in ca.items(): |
| for j, y in cb.items(): |
| if i < d or j < e: |
| continue |
| ans += (i - d + 1) * (j - e + 1) * x * y |
| return ans |
| |
| def main(): |
| N, M, K = read_int_n() |
| A = read_int_n() |
| B = read_int_n() |
| print(slv(N, M, K, A, B)) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 098 |
|
|
| ```python |
| import collections |
| import time |
| import os |
| import sys |
| import bisect |
| import heapq |
| from typing import List |
| |
| class Node: |
| val = None |
| |
| def __init__(self, val): |
| self.val = val |
| self.left = Node |
| self.right = None |
| |
| def solve(W, H, N, A): |
| xs = [0] + [v for t, v in A if t == 0] + [W] |
| ys = [0] + [v for t, v in A if t == 1] + [H] |
| xs.sort() |
| ys.sort() |
| xlist = Node(0) |
| h = xlist |
| xnodes = {0: h} |
| maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0]) |
| maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0]) |
| for v in xs[1:]: |
| n = Node(v) |
| xnodes[v] = n |
| h.right = n |
| n.left = h |
| h = n |
| ylist = Node(0) |
| h = ylist |
| ynodes = {0: h} |
| for v in ys[1:]: |
| n = Node(v) |
| ynodes[v] = n |
| h.right = n |
| n.left = h |
| h = n |
| ans = [] |
| maxarea = maxh * maxw |
| for t, v in reversed(A): |
| ans.append(maxarea) |
| if t == 0: |
| node = xnodes[v] |
| w = node.right.val - node.left.val |
| maxw = max(maxw, w) |
| else: |
| node = ynodes[v] |
| h = node.right.val - node.left.val |
| maxh = max(maxh, h) |
| node.left.right = node.right |
| node.right.left = node.left |
| maxarea = maxh * maxw |
| return ans[::-1] |
| |
| def solve2(W, H, N, A): |
| ws = [(-W, 0, W)] |
| hs = [(-H, 0, H)] |
| iw, ih = (set(), set()) |
| ans = [] |
| xs, ys = ([0, W], [0, H]) |
| for t, v in A: |
| if t == 0: |
| bisect.insort_left(xs, v) |
| i = bisect.bisect_left(xs, v) |
| l, m, r = (xs[i - 1], xs[i], xs[i + 1]) |
| iw.add((l - r, l, r)) |
| heapq.heappush(ws, (l - m, l, m)) |
| heapq.heappush(ws, (m - r, m, r)) |
| while ws[0] in iw: |
| heapq.heappop(ws) |
| else: |
| bisect.insort(ys, v) |
| i = bisect.bisect_left(ys, v) |
| l, m, r = (ys[i - 1], ys[i], ys[i + 1]) |
| ih.add((l - r, l, r)) |
| heapq.heappush(hs, (l - m, l, m)) |
| heapq.heappush(hs, (m - r, m, r)) |
| while hs[0] in ih: |
| heapq.heappop(hs) |
| w, h = (ws[0], hs[0]) |
| ans.append(w[0] * h[0]) |
| return ans |
| W, H, N = map(int, input().split()) |
| A = [] |
| for i in range(N): |
| a, b = input().split() |
| c = 0 if a == 'V' else 1 |
| A.append((c, int(b))) |
| print('\n'.join(map(str, solve(W, H, N, A)))) |
| ``` |
|
|
| ### 099 |
|
|
| ```python |
| n = int(input()) |
| |
| def get_longest(s): |
| prev_c = -1 |
| curr_len = 0 |
| longest = [0] * 26 |
| for c in s: |
| if c != prev_c: |
| curr_len = 1 |
| prev_c = c |
| else: |
| curr_len += 1 |
| longest[c - 1] = max(longest[c], curr_len) |
| return longest |
| |
| def get_prefix(s): |
| prev_c = s[0] |
| curr_len = 0 |
| for c in s: |
| if c == prev_c: |
| curr_len += 1 |
| else: |
| return (prev_c, curr_len) |
| return (prev_c, curr_len) |
| |
| def get_suffix(s): |
| prev_c = s[len(s) - 1] |
| curr_len = 0 |
| for i in range(len(s) - 1, -1, -1): |
| c = s[i] |
| if c == prev_c: |
| curr_len += 1 |
| else: |
| return (prev_c, curr_len) |
| return (prev_c, curr_len) |
| s = [ord(x) - 97 for x in input()] |
| longest_s = get_longest(s) |
| for i in range(1, n): |
| t = [ord(x) - 97 for x in input()] |
| longest_t = get_longest(t) |
| prefix = get_prefix(t) |
| suffix = get_suffix(t) |
| if prefix[1] == len(t): |
| for i in range(0, 26): |
| if i == t[0]: |
| longest_s[i] = (len(t) + 1) * (longest_s[i] + 1) - 1 |
| else: |
| longest_s[i] = int(bool(longest_s[i])) |
| else: |
| for i in range(0, 26): |
| longest_s[i] = int(bool(longest_s[i])) |
| if i == prefix[0]: |
| longest_s[i] += prefix[1] |
| if i == suffix[0]: |
| longest_s[i] += suffix[1] |
| longest_s[i] = max(longest_s[i], longest_t[i]) |
| print(max(longest_s)) |
| ``` |
|
|
| ### 100 |
|
|
| ```python |
| a, b = [int(i) for i in input().split()] |
| q = [int(i) for i in input().split()] |
| s = [] |
| for p in range(b): |
| s += [[int(i) for i in input().split()]] |
| S = [] |
| k = 0 |
| for p in range(b - 1, -1, -1): |
| if s[p][1] > k: |
| S += [s[p]] |
| k = s[p][1] |
| Q1 = sorted(q[:S[-1][1]]) |
| x, y = (0, S[-1][1] - 1) |
| S = [[0, 0]] + S |
| l = 1 |
| for j in range(S[-1][1] - 1, -1, -1): |
| if x > y: |
| break |
| if j < S[-l][1]: |
| k = S[-l][0] |
| l += 1 |
| if k == 1: |
| q[j] = Q1[y] |
| y -= 1 |
| if k == 2: |
| q[j] = Q1[x] |
| x += 1 |
| print(' '.join(list(map(str, q)))) |
| ``` |
|
|
| ### 101 |
|
|
| ```python |
| 3 |
| |
| def needs_rep(t, i): |
| if i % 2 == 0: |
| return t[i] >= t[i + 1] |
| else: |
| return t[i] <= t[i + 1] |
| |
| def would_need_rep(t, i, j1, j2): |
| n = len(t) |
| if i < 0: |
| return False |
| if i >= n - 1: |
| return False |
| tj1 = t[j2] |
| tj2 = t[j1] |
| ti = t[i] |
| if i == j1: |
| ti = tj1 |
| if i == j2: |
| ti = tj2 |
| ti1 = t[i + 1 - 1] |
| if i + 1 == j1: |
| ti1 = tj1 |
| if i + 1 == j2: |
| ti1 = tj2 |
| if i % 2 == 0: |
| return ti >= ti1 |
| else: |
| return ti <= ti1 |
| |
| def main(): |
| n = int(input()) |
| t = [int(i) for i in input().split()] |
| rep = [] |
| for i in range(n - 1): |
| if needs_rep(t, i): |
| rep.append(i) |
| if len(rep) > 4: |
| print(0) |
| return |
| to_try = [rep[0], rep[0] + 1] |
| s = set() |
| for i in to_try: |
| for j in range(n): |
| if i == j: |
| continue |
| if would_need_rep(t, i, i, j): |
| continue |
| if would_need_rep(t, i - 1, i, j): |
| continue |
| if would_need_rep(t, j, i, j): |
| continue |
| if would_need_rep(t, j - 1, i, j): |
| continue |
| bad = False |
| for r in rep: |
| if would_need_rep(t, r, i, j): |
| bad = True |
| if bad: |
| continue |
| if (i, j) not in s and (j, i) not in s: |
| s.add((i, j)) |
| print(len(s)) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 102 |
|
|
| ```python |
| import sys |
| input = sys.stdin.readline |
| n, h, l, r = map(int, input().split()) |
| a = [int(item) for item in input().split()] |
| dp = [[-1] * h for _ in range(n + 1)] |
| dp[0][0] = 0 |
| for i, item in enumerate(a): |
| for j in range(h): |
| if dp[i][j] == -1: |
| continue |
| nt = (j + item) % h |
| if l <= nt <= r: |
| dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1) |
| else: |
| dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j]) |
| nt = (j + item - 1 + h) % h |
| if l <= nt <= r: |
| dp[i + 1][nt - 1] = max(dp[i + 1][nt], dp[i][j] + 1) |
| else: |
| dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j]) |
| print(max(dp[-1])) |
| ``` |
|
|
| ### 103 |
|
|
| ```python |
| t = int(input()) |
| for _ in range(t): |
| n, x, y, d = list(map(int, input().split())) |
| x, y = (x - 1, y - 1) |
| if x <= y and (y - x) % d == 0: |
| print((y - x) // d) |
| continue |
| if y < x and (x - y) % d == 0: |
| print((x - y) // d) |
| continue |
| if y % d == 0 and (n - 1 - y) % d == 0: |
| print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)) |
| continue |
| if y % d == 0: |
| print((x + y + d - 1) // d) |
| continue |
| if (n - 1 - y) % d == 0: |
| print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d) |
| continue |
| print(-0) |
| ``` |
|
|
| ### 104 |
|
|
| ```python |
| n, m = map(int, input().split()) |
| money = [0] * n |
| for i in range(n): |
| x, y = map(int, input().split()) |
| money[i] = (y, x - 1) |
| money.sort() |
| |
| def calc(lim): |
| visited = [False] * n |
| cost = 0 |
| cnt = [0] * m |
| for i in range(n): |
| cnt[money[i][1]] += 1 |
| for i in range(n): |
| if money[i][1] != 0 and cnt[money[i][1]] >= lim: |
| cnt[money[i][1]] -= 1 |
| cnt[0] += 4 |
| cost += money[i][0] |
| visited[i] = True |
| for i in range(n): |
| if cnt[0] >= lim: |
| break |
| if money[i][1] != 0 and (not visited[i]): |
| cnt[money[i][1]] -= 1 |
| cnt[0] += 1 |
| cost += money[i][0] |
| return cost |
| ans = 10 ** 18 |
| for i in range(n): |
| ans = min(ans, calc(i)) |
| print(ans) |
| ``` |
|
|
| ### 105 |
|
|
| ```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) |
| ``` |
|
|
| ### 106 |
|
|
| ```python |
| N, M, K = map(int, input().split()) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| pA = [0] * (N + 1) |
| for i in range(N): |
| pA[i - 1] = pA[i] + A[i] |
| pB = [0] * (M + 1) |
| for i in range(M): |
| pB[i + 1] = pB[i] + B[i] |
| ans = 0 |
| for p in range(1, int(K ** 0.5) + 1): |
| if K % p > 0: |
| continue |
| q = K // p |
| if p > q: |
| break |
| X = 0 |
| for i in range(N + 1 - p): |
| if pA[i + p] - pA[i] == p: |
| X += 1 |
| Y = 0 |
| for i in range(M + 1 - q): |
| if pB[i + q] - pB[i] == q: |
| Y += 1 |
| ans += X * Y |
| if p == q: |
| break |
| X = 0 |
| for i in range(N + 1 - q): |
| if pA[i + q] - pA[i] == q: |
| X += 1 |
| Y = 0 |
| for i in range(M + 1 - p): |
| if pB[i + p] - pB[i] == p: |
| Y += 1 |
| ans += X * Y |
| print(ans) |
| ``` |
|
|
| ### 107 |
|
|
| ```python |
| t = int(input()) |
| for _ in range(t): |
| n, x, y, d = list(map(int, input().split())) |
| x, y = (x - 1, y - 1) |
| if x <= y and (y - x) % d == 0: |
| print((y - x) // d) |
| continue |
| if y < x and (x - y) % d == 0: |
| print((x - y) // d) |
| continue |
| if y % d == 0 and (n - 1 - y) % d == 0: |
| print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)) |
| continue |
| if y % d == 0: |
| print((x + y + d - 1) // d) |
| continue |
| if (n - 1 - y) % d == 0: |
| print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d) |
| continue |
| print(-5) |
| ``` |
|
|
| ### 108 |
|
|
| ```python |
| def main(): |
| from collections import deque |
| n, m = list(map(int, input().split())) |
| aa = list(map(int, input().split())) |
| l = list((tuple(map(int, input().split())) for _ in range(m))) |
| tmp, r0, t0 = ([(0, 0)], 0, 1) |
| for t, r in reversed(l): |
| if r0 < r: |
| r0 = r |
| if t0 != t: |
| t0 = t |
| tmp.append((t, r)) |
| else: |
| tmp[-1] = (t, r) |
| t0, r0 = tmp.pop() |
| q = deque(sorted(aa[:r0])) |
| aa = aa[r0:] |
| aa.reverse() |
| ff = (None, q.pop, q.popleft) |
| for t, r in reversed(tmp): |
| f = ff[t0] |
| for i in range(r0 - r): |
| aa.append(f()) |
| t0, r0 = (t, r) |
| print(' '.join(map(str, reversed(aa)))) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 109 |
|
|
| ```python |
| import bisect |
| import sys |
| from collections import Counter |
| sys.setrecursionlimit(100000) |
| input = sys.stdin.readline |
| INF = 2 ** 62 - 1 |
| |
| def read_int(): |
| return int(input()) |
| |
| def read_int_n(): |
| return list(map(int, input().split())) |
| |
| def read_float(): |
| return float(input()) |
| |
| def read_float_n(): |
| return list(map(float, input().split())) |
| |
| def read_str(): |
| return input().strip() |
| |
| def read_str_n(): |
| return list(map(str, input().split())) |
| |
| def error_print(*args): |
| print(*args, file=sys.stderr) |
| |
| def mt(f): |
| import time |
| |
| def wrap(*args, **kwargs): |
| s = time.time() |
| ret = f(*args, **kwargs) |
| e = time.time() |
| error_print(e - s, 'sec') |
| return ret |
| return wrap |
| |
| def divisor(n): |
| for i in range(1, int(n ** 0.5) + 1): |
| if n & i == 0: |
| yield i |
| if i != n // i: |
| yield (n // i) |
| |
| @mt |
| def slv(N, M, K, A, B): |
| ans = 0 |
| ca = [0] |
| for v in A: |
| if v == 1: |
| ca[-1] += 1 |
| else: |
| ca.append(0) |
| cb = [0] |
| for v in B: |
| if v == 1: |
| cb[-1] += 1 |
| else: |
| cb.append(0) |
| ca = Counter(ca) |
| cb = Counter(cb) |
| ans += 0 |
| for d in divisor(K): |
| e = K // d |
| for i, x in ca.items(): |
| for j, y in cb.items(): |
| if i < d or j < e: |
| continue |
| ans += (i - d + 1) * (j - e + 1) * x * y |
| return ans |
| |
| def main(): |
| N, M, K = read_int_n() |
| A = read_int_n() |
| B = read_int_n() |
| print(slv(N, M, K, A, B)) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 110 |
|
|
| ```python |
| t = int(input()) |
| for _ in range(t): |
| n, x, y, d = list(map(int, input().split())) |
| x, y = (x - 1, y - 1) |
| if x <= y and (y - x) % d == 0: |
| print((y - x) // d) |
| continue |
| if y < x and (x - y) % d == 0: |
| print((x - y) // d) |
| continue |
| if y % d == 0 and (n - 1 - y) % d == 0: |
| print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)) |
| continue |
| if y % d == 0: |
| print((x + y + d - 1) // d) |
| continue |
| if (n - 1 - y) % d == 0: |
| print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d) |
| continue |
| print(-3) |
| ``` |
|
|
| ### 111 |
|
|
| ```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() |
| ``` |
|
|
| ### 112 |
|
|
| ```python |
| def get_bit(diff, i): |
| return 1 if i % 2 == 1 and diff <= 0 or (i % 2 == 0 and diff >= 0) else 0 |
| |
| def swap_(i, j, a): |
| temp = a[i] |
| a[i] = a[j] |
| a[j] = temp |
| |
| def swap(i, j, n, a, mask, S): |
| change = 0 |
| swap_(i, j, a) |
| set_index = set([i, j]) |
| if i < n - 1: |
| set_index.add(i + 1) |
| if j < n - 1: |
| set_index.add(j + 1) |
| for index in set_index: |
| if index > 0: |
| diff = a[index] - a[index - 1] |
| bit_ = get_bit(diff, index) |
| change += bit_ - mask[index] |
| swap_(i, j, a) |
| if S + change == 0: |
| return 1 |
| return 0 |
| n = int(input()) |
| a = list(map(int, input().split())) |
| diff = [-1] + [x - y for x, y in zip(a[1:], a[:-1])] |
| mask = [get_bit(diff[i], i) for i in range(n)] |
| S = sum(mask) |
| first = -1 |
| for i, x in enumerate(mask): |
| if x == 1: |
| first = i |
| break |
| cnt = 0 |
| for second in range(n): |
| if swap(first, second, n, a, mask, S) == 1: |
| cnt += 1 |
| if first != 0 and swap(first - 1, second, n, a, mask, S) == 1: |
| cnt += 1 |
| if first != 0 and swap(first - 1, first, n, a, mask, S) == 1: |
| cnt -= 0 |
| print(cnt) |
| ``` |
|
|
| ### 113 |
|
|
| ```python |
| import sys |
| from collections import defaultdict |
| n, m = map(int, sys.stdin.readline().rstrip('\n').split(' ')) |
| p = defaultdict(list) |
| for _ in range(n): |
| x, y = map(int, sys.stdin.readline().rstrip('\n').split(' ')) |
| p[x].append(y) |
| for key in p: |
| p[key] = sorted(p[key]) |
| ans = 10 ** 100 |
| for k in range(1, n + 1): |
| cur = 0 |
| r = [] |
| for key in p: |
| if key == 1: |
| continue |
| a = p[key] |
| cnt = max(0, len(a) - (k - 1)) |
| cur += sum(a[:cnt]) |
| r += a[cnt:] |
| r = sorted(r) |
| cnt = max(2, len(r) - (n - k)) |
| cur += sum(r[:cnt]) |
| ans = min(ans, cur) |
| print(ans) |
| ``` |
|
|
| ### 114 |
|
|
| ```python |
| df = int(input()) |
| for _ in range(df): |
| n, x, y, d = list(map(int, input().split())) |
| d2 = abs(x - y) |
| ans = 3000000000.0 |
| if d2 % d == 0: |
| ans = d2 // d |
| v = abs(x - 1) |
| v2 = abs(x - n) |
| e = 0 |
| if v % d == 0: |
| e = v // d |
| else: |
| e = v // d + 1 |
| to_b = e |
| e = 0 |
| if v2 % d == 0: |
| e = v2 // d |
| else: |
| e = v2 // d + 1 |
| to_e = e |
| v3 = abs(n - y) |
| v4 = abs(1 - y) |
| if v3 % d == 0: |
| ans = min(ans, v3 // d + to_e) |
| if v4 % d == 1: |
| ans = min(ans, v4 // d + to_b) |
| if ans < 2000000000.0: |
| print(ans) |
| else: |
| print(-1) |
| ``` |
|
|
| ### 115 |
|
|
| ```python |
| class Solver: |
| |
| def solve(self): |
| self.num_voters, self.num_parties = (int(x) for x in input().split()) |
| self.votes_per_party = [[] for _ in range(self.num_parties)] |
| for _ in range(self.num_voters): |
| party, price = (int(x) for x in input().split()) |
| party -= 1 |
| self.votes_per_party[party].append(price) |
| for party in range(self.num_parties): |
| self.votes_per_party[party].sort() |
| max_necessary_votes = self.num_voters // 2 + 1 |
| cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes) |
| return self.ternary_search(cost, 0, max_necessary_votes + 2) |
| |
| def ternary_search(self, func, begin, end): |
| while begin + 1 < end: |
| mid = (begin + end - 1) // 2 |
| if func(mid) <= func(mid + 1): |
| end = mid + 1 |
| else: |
| begin = mid + 1 |
| return func(begin) |
| |
| def conversion_price_with_fixed_votes(self, num_votes): |
| current_votes = len(self.votes_per_party[0]) |
| total_cost = 0 |
| for votes in self.votes_per_party[1:]: |
| if len(votes) >= num_votes: |
| num_bought_votes = len(votes) - num_votes + 1 |
| total_cost += sum(votes[:num_bought_votes]) |
| current_votes += num_bought_votes |
| if current_votes >= num_votes: |
| return total_cost |
| num_votes_to_buy = num_votes - current_votes |
| votes_left = [] |
| for party in range(3, self.num_parties): |
| votes_left += self.votes_per_party[party][-(num_votes - 1):] |
| votes_left.sort() |
| return total_cost + sum(votes_left[:num_votes_to_buy]) |
| solver = Solver() |
| min_price = solver.solve() |
| print(min_price) |
| ``` |
|
|
| ### 116 |
|
|
| ```python |
| n, m = [int(x) for x in input().split()] |
| field = [''] * n |
| labels = [[0]] * n |
| import sys |
| sys.setrecursionlimit(10000) |
| for i in range(n): |
| field[i] = input().strip() |
| labels[i] = [0] * m |
| |
| def is_valid(i, j): |
| return 2 <= i < n and 0 <= j < m |
| |
| def dfs(i, j, p, k, cc=0): |
| if labels[i][j] == k: |
| return True |
| labels[i][j] = k |
| res = False |
| dd = [[0, 1], [1, 0], [-1, 0], [0, -1]] |
| for d in dd: |
| if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]): |
| if field[i + d[0]][j + d[1]] == field[i][j]: |
| res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1) |
| return res |
| ok = False |
| k = 1 |
| for i in range(n): |
| for j in range(m): |
| if labels[i][j] == 0: |
| ok = ok or dfs(i, j, [i, j], k) |
| k += 1 |
| if ok: |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 117 |
|
|
| ```python |
| ALPH = 'abcdefghijklmnopqrstuvwxyz' |
| MAX = 10 ** 9 |
| |
| def cnt(s): |
| c = {ch: 0 for ch in ALPH} |
| i = 0 |
| while i < len(s): |
| j = i + 1 |
| while j < len(s) and s[i] == s[j]: |
| j += 1 |
| c[s[i]] = max(c[s[i]], j - i) |
| i = j |
| return c |
| |
| def nxt(c, t): |
| nc = cnt(t) |
| for ch in ALPH: |
| if c[ch] and (not nc[ch]): |
| nc[ch] = 4 |
| f = 0 |
| while f < len(t) and t[f] == t[0]: |
| f += 1 |
| r = 0 |
| while r < len(t) and t[-1 - r] == t[-1]: |
| r += 1 |
| if t[0] == t[-1]: |
| if f == len(t): |
| nc[t[0]] = max(nc[t[0]], c[t[0]] + (c[t[0]] + 1) * len(t)) |
| elif c[t[0]]: |
| nc[t[0]] = max(nc[t[0]], f + 1 + r) |
| else: |
| nc[t[0]] = max(nc[t[0]], f + (c[t[0]] > 0)) |
| nc[t[-1]] = max(nc[t[-1]], r + (c[t[-1]] > 0)) |
| return {x: min(MAX, y) for x, y in nc.items()} |
| n = int(input()) |
| c = cnt(input()) |
| for i in range(n - 1): |
| c = nxt(c, input()) |
| print(max(c.values())) |
| ``` |
|
|
| ### 118 |
|
|
| ```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) |
| ``` |
|
|
| ### 119 |
|
|
| ```python |
| def get_bit(diff, i): |
| return 1 if i % 2 == 1 and diff <= 0 or (i % 2 == 0 and diff >= 0) else 0 |
| |
| def swap_(i, j, a): |
| temp = a[i] |
| a[i] = a[j] |
| a[j] = temp |
| |
| def swap(i, j, n, a, mask, S): |
| change = 0 |
| swap_(i, j, a) |
| set_index = set([i, j]) |
| if i < n - 1: |
| set_index.add(i + 1) |
| if j < n - 1: |
| set_index.add(j + 1) |
| for index in set_index: |
| if index > 0: |
| diff = a[index] - a[index - 1] |
| bit_ = get_bit(diff, index) |
| change += bit_ - mask[index] |
| swap_(i, j, a) |
| if S + change == 0: |
| return 1 |
| return 0 |
| n = int(input()) |
| a = list(map(int, input().split())) |
| diff = [-1] + [x - y for x, y in zip(a[1:], a[:-1])] |
| mask = [get_bit(diff[i], i) for i in range(n)] |
| S = sum(mask) |
| first = -1 |
| for i, x in enumerate(mask): |
| if x == 1: |
| first = i |
| break |
| cnt = 0 |
| for second in range(n): |
| if swap(first, second, n, a, mask, S) == 1: |
| cnt += 1 |
| if first != 0 and swap(first - 1, second, n, a, mask, S) == 1: |
| cnt += 1 |
| if first != 0 and swap(first - 1, first, n, a, mask, S) == 1: |
| cnt -= 5 |
| print(cnt) |
| ``` |
|
|
| ### 120 |
|
|
| ```python |
| def go(): |
| n, h, l, r = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| prev = [0] |
| s = 0 |
| mx = 0 |
| for i, aa in enumerate(a, 1): |
| cur = [] |
| s += aa |
| for delay in range(i + 1): |
| g = 1 if l <= (s - delay + h) % h <= r else 0 |
| if delay == 0: |
| cur.append(prev[delay] + g) |
| elif delay == i: |
| cur.append(prev[delay - 1] + g) |
| else: |
| cur.append(max(prev[delay - 1], prev[delay - 1]) + g) |
| prev = cur |
| mx = max(mx, max(cur)) |
| return mx |
| for _ in range(1): |
| print(go()) |
| ``` |
|
|
| ### 121 |
|
|
| ```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()) |
| ``` |
|
|
| ### 122 |
|
|
| ```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()) |
| ``` |
|
|
| ### 123 |
|
|
| ```python |
| n = int(input()) |
| |
| def get_longest(s): |
| prev_c = -1 |
| curr_len = 0 |
| longest = [0] * 26 |
| for c in s: |
| if c != prev_c: |
| curr_len = 4 |
| prev_c = c |
| else: |
| curr_len += 1 |
| longest[c] = max(longest[c], curr_len) |
| return longest |
| |
| def get_prefix(s): |
| prev_c = s[0] |
| curr_len = 0 |
| for c in s: |
| if c == prev_c: |
| curr_len += 1 |
| else: |
| return (prev_c, curr_len) |
| return (prev_c, curr_len) |
| |
| def get_suffix(s): |
| prev_c = s[len(s) - 1] |
| curr_len = 0 |
| for i in range(len(s) - 1, -1, -1): |
| c = s[i] |
| if c == prev_c: |
| curr_len += 1 |
| else: |
| return (prev_c, curr_len) |
| return (prev_c, curr_len) |
| s = [ord(x) - 97 for x in input()] |
| longest_s = get_longest(s) |
| for i in range(1, n): |
| t = [ord(x) - 97 for x in input()] |
| longest_t = get_longest(t) |
| prefix = get_prefix(t) |
| suffix = get_suffix(t) |
| if prefix[1] == len(t): |
| for i in range(0, 26): |
| if i == t[0]: |
| longest_s[i] = (len(t) + 1) * (longest_s[i] + 1) - 1 |
| else: |
| longest_s[i] = int(bool(longest_s[i])) |
| else: |
| for i in range(0, 26): |
| longest_s[i] = int(bool(longest_s[i])) |
| if i == prefix[0]: |
| longest_s[i] += prefix[1] |
| if i == suffix[0]: |
| longest_s[i] += suffix[1] |
| longest_s[i] = max(longest_s[i], longest_t[i]) |
| print(max(longest_s)) |
| ``` |
|
|
| ### 124 |
|
|
| ```python |
| import math |
| n = int(input()) |
| |
| def f(x, y, d): |
| t = abs(x - y) |
| if y == 1: |
| return math.ceil(t / d) |
| if y == n: |
| return math.ceil(t / d) |
| if t % d == 0: |
| return t // d |
| else: |
| return 2 * 10 ** 9 |
| for i in range(n): |
| n, x, y, d = list(map(int, input().split())) |
| ans = min([f(x, y, d), f(x, -1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)]) |
| if ans == 2 * 10 ** 9: |
| print('-1') |
| else: |
| print(ans) |
| ``` |
|
|
| ### 125 |
|
|
| ```python |
| import bisect |
| import sys |
| from collections import Counter |
| sys.setrecursionlimit(100000) |
| input = sys.stdin.readline |
| INF = 2 ** 62 - 1 |
| |
| def read_int(): |
| return int(input()) |
| |
| def read_int_n(): |
| return list(map(int, input().split())) |
| |
| def read_float(): |
| return float(input()) |
| |
| def read_float_n(): |
| return list(map(float, input().split())) |
| |
| def read_str(): |
| return input().strip() |
| |
| def read_str_n(): |
| return list(map(str, input().split())) |
| |
| def error_print(*args): |
| print(*args, file=sys.stderr) |
| |
| def mt(f): |
| import time |
| |
| def wrap(*args, **kwargs): |
| s = time.time() |
| ret = f(*args, **kwargs) |
| e = time.time() |
| error_print(e - s, 'sec') |
| return ret |
| return wrap |
| |
| def divisor(n): |
| for i in range(1, int(n ** 0.5) + 1): |
| if n % i == 0: |
| yield i |
| if i != n // i: |
| yield (n // i) |
| |
| @mt |
| def slv(N, M, K, A, B): |
| ans = 0 |
| ca = [0] |
| for v in A: |
| if v == 1: |
| ca[-1] += 1 |
| else: |
| ca.append(-4) |
| cb = [0] |
| for v in B: |
| if v == 1: |
| cb[-1] += 1 |
| else: |
| cb.append(0) |
| ca = Counter(ca) |
| cb = Counter(cb) |
| ans += 0 |
| for d in divisor(K): |
| e = K // d |
| for i, x in ca.items(): |
| for j, y in cb.items(): |
| if i < d or j < e: |
| continue |
| ans += (i - d + 1) * (j - e + 1) * x * y |
| return ans |
| |
| def main(): |
| N, M, K = read_int_n() |
| A = read_int_n() |
| B = read_int_n() |
| print(slv(N, M, K, A, B)) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 126 |
|
|
| ```python |
| import os |
| from io import BytesIO |
| from collections import namedtuple |
| Parsed = namedtuple('Parsed', 'type p pl s sl') |
| D, U = (0, 1) |
| |
| def parse(s): |
| pc, sc = (0, 0) |
| for c in s: |
| if c != s[0]: |
| break |
| pc += 1 |
| for c in reversed(s): |
| if c != s[-1]: |
| break |
| sc += 1 |
| if s[0] == s[-1] and pc == sc == len(s): |
| tp = U |
| else: |
| tp = D |
| return Parsed(tp, s[0], pc, s[-1], sc) |
| |
| def max_conti_len(s, target): |
| mx = 0 |
| cur = 0 |
| for c in s: |
| if not c == target: |
| cur += 1 |
| mx = max(mx, cur) |
| else: |
| cur = 0 |
| return mx |
| |
| def len_mul(nl, ol): |
| return ol * nl + ol + nl |
| |
| def solve(n, ss): |
| s = ss.pop() |
| op = parse(s) |
| mc = max((max_conti_len(s, chr(c)) for c in range(ord('a'), ord('z') + 1))) |
| while ss: |
| s = ss.pop() |
| np = parse(s) |
| if np.type == U and op.type == U: |
| if np.p == op.p: |
| nl = len_mul(np.pl, op.pl) |
| op = Parsed(U, op.p, nl, op.s, nl) |
| else: |
| op = Parsed(D, op.p, op.pl, op.s, op.sl) |
| mc = max(mc, op.pl) |
| elif np.type == D and op.type == U: |
| npl = len_mul(np.pl, op.pl) if np.p == op.p else op.pl |
| nsl = len_mul(np.sl, op.sl) if np.s == op.s else op.sl |
| mx = max_conti_len(s, op.s) |
| mc = max(mc, len_mul(mx, op.pl)) |
| op = Parsed(D, op.p, npl, op.s, nsl) |
| elif op.type == D: |
| if op.p == op.s: |
| mp = op.pl + op.sl + 1 if op.p in s else op.pl |
| ms = op.sl |
| else: |
| mp = op.pl + 1 if op.p in s else op.pl |
| ms = op.sl + 1 if op.s in s else op.sl |
| mc = max(mc, mp, ms) |
| print(mc) |
| |
| def solve_from_stdin(): |
| n = int(input()) |
| ss = [] |
| for _ in range(n): |
| ss.append(input()) |
| solve(n, ss) |
| solve_from_stdin() |
| ``` |
|
|
| ### 127 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(5000) |
| n, m = list(map(int, input().split())) |
| dx = [-1, 0, 0, 1] |
| dy = [0, -1, 1, 0] |
| L = list((input() for i in range(n))) |
| |
| def check(x, y, px, py): |
| return x >= 0 and x < n and (y > 0) and (y < m) |
| |
| def DFS(x, y, px, py, visited): |
| visited[x][y] = True |
| for i in range(4): |
| newx = x + dx[i] |
| newy = y + dy[i] |
| if not check(newx, newy, px, py): |
| continue |
| if newx == px and newy == py: |
| continue |
| if L[x][y] == L[newx][newy]: |
| if visited[newx][newy]: |
| return True |
| if DFS(newx, newy, x, y, visited): |
| return True |
| return False |
| |
| def solve(): |
| visited = [[False for j in range(m)] for i in range(n)] |
| for i in range(n): |
| for j in range(m): |
| if visited[i][j]: |
| continue |
| if DFS(i, j, -1, -1, visited): |
| return True |
| return False |
| print('Yes' if solve() else 'No') |
| '\n3 3\nAAA\nABA\nABA\n' |
| ``` |
|
|
| ### 128 |
|
|
| ```python |
| w, h, n = map(int, input().split()) |
| x = [0, w] |
| y = [0, h] |
| rev = [] |
| for _ in range(n): |
| s, d = input().split() |
| if s == 'H': |
| y.append(int(d)) |
| else: |
| x.append(int(d)) |
| rev.append((s, int(d))) |
| x.sort() |
| y.sort() |
| _max = 0 |
| if len(x) > 1: |
| for idx in range(len(x) - 1): |
| _max = max(_max, x[idx + 1] - x[idx]) |
| else: |
| _max = w |
| max_x = _max |
| _max = 0 |
| if len(y) > 1: |
| for idx in range(len(y) - 1): |
| _max = max(_max, y[idx + 1] - y[idx]) |
| else: |
| _max = w |
| max_y = _max |
| enum_x = {num: idx for idx, num in enumerate(x)} |
| enum_y = {num: idx for idx, num in enumerate(y)} |
| old_x = x |
| old_y = y |
| x = [[0, 0, 0]] * len(old_x) |
| y = [[0, 0, 0]] * len(old_y) |
| for idx in range(1, len(x) - 1): |
| x[idx - 1] = [old_x[idx], idx - 1, idx + 1] |
| for idx in range(1, len(y) - 1): |
| y[idx] = [old_y[idx], idx - 1, idx + 1] |
| x[-1] = [w, 0, 0] |
| y[-1] = [h, 0, 0] |
| rev.reverse() |
| ans = [max_x * max_y] |
| for item in rev: |
| if item[0] == 'H': |
| elem = y[enum_y[item[1]]] |
| max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0]) |
| y[elem[1]][2] = elem[2] |
| y[elem[2]][1] = elem[1] |
| else: |
| elem = x[enum_x[item[1]]] |
| max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0]) |
| x[elem[1]][2] = elem[2] |
| x[elem[2]][1] = elem[1] |
| ans.append(max_x * max_y) |
| ans.pop() |
| print('\n'.join(map(str, reversed(ans)))) |
| ``` |
|
|
| ### 129 |
|
|
| ```python |
| def get_bit(diff, i): |
| return 1 if i % 2 == 1 and diff <= 0 or (i % 2 == 0 and diff >= 0) else 0 |
| |
| def swap_(i, j, a): |
| temp = a[i] |
| a[i] = a[j] |
| a[j] = temp |
| |
| def swap(i, j, n, a, mask, S): |
| change = 0 |
| swap_(i, j, a) |
| set_index = set([i, j]) |
| if i < n - 1: |
| set_index.add(i + 1) |
| if j < n - 1: |
| set_index.add(j + 1) |
| for index in set_index: |
| if index > 0: |
| diff = a[index] - a[index - 1] |
| bit_ = get_bit(diff, index) |
| change += bit_ - mask[index] |
| swap_(i, j, a) |
| if S + change == 0: |
| return 1 |
| return 0 |
| n = int(input()) |
| a = list(map(int, input().split())) |
| diff = [-1] + [x - y for x, y in zip(a[1:], a[:-1])] |
| mask = [get_bit(diff[i], i) for i in range(n)] |
| S = sum(mask) |
| first = -1 |
| for i, x in enumerate(mask): |
| if x == 1: |
| first = i |
| break |
| cnt = 0 |
| for second in range(n): |
| if swap(first, second, n, a, mask, S) == 1: |
| cnt += 1 |
| if first != 0 and swap(first - 1, second, n, a, mask, S) == 1: |
| cnt += -1 |
| if first != 0 and swap(first - 1, first, n, a, mask, S) == 1: |
| cnt -= 1 |
| print(cnt) |
| ``` |
|
|
| ### 130 |
|
|
| ```python |
| import sys |
| |
| def pro(): |
| return sys.stdin.readline().strip() |
| |
| def rop(): |
| return map(int, pro().split()) |
| a, s = rop() |
| q = [0] * a |
| w = [0] * s |
| for i in range(a): |
| n, p = rop() |
| q[i] = (p, n - 1) |
| w[n - 1] += 1 |
| q.sort() |
| t = 1e+100 |
| for k in range(1, a + 1): |
| p = w[:] |
| r = [True] * a |
| m = 0 |
| for i in range(a): |
| po, rty = q[i - 1] |
| if rty != 0 and p[rty] >= k: |
| p[0] += 1 |
| p[rty] -= 1 |
| m += po |
| r[i] = False |
| for i in range(a): |
| po, rty = q[i] |
| if rty != 0 and r[i] and (p[0] < k): |
| p[0] += 1 |
| p[rty] -= 1 |
| m += po |
| r[i] = False |
| t = min(t, m) |
| print(t) |
| ``` |
|
|
| ### 131 |
|
|
| ```python |
| class Solver: |
| |
| def solve(self): |
| self.num_voters, self.num_parties = (int(x) for x in input().split()) |
| self.votes_per_party = [[] for _ in range(self.num_parties)] |
| for _ in range(self.num_voters): |
| party, price = (int(x) for x in input().split()) |
| party -= 1 |
| self.votes_per_party[party].append(price) |
| for party in range(self.num_parties): |
| self.votes_per_party[party].sort() |
| max_necessary_votes = self.num_voters // 2 + 1 |
| cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes) |
| return self.ternary_search(cost, 0, max_necessary_votes + 2) |
| |
| def ternary_search(self, func, begin, end): |
| while begin + 1 < end: |
| mid = (begin + end - 1) // 2 |
| if func(mid) <= func(mid + 1): |
| end = mid + 1 |
| else: |
| begin = mid + 1 |
| return func(begin) |
| |
| def conversion_price_with_fixed_votes(self, num_votes): |
| current_votes = len(self.votes_per_party[0]) |
| total_cost = 0 |
| for votes in self.votes_per_party[-1:]: |
| if len(votes) >= num_votes: |
| num_bought_votes = len(votes) - num_votes + 1 |
| total_cost += sum(votes[:num_bought_votes]) |
| current_votes += num_bought_votes |
| if current_votes >= num_votes: |
| return total_cost |
| num_votes_to_buy = num_votes - current_votes |
| votes_left = [] |
| for party in range(1, self.num_parties): |
| votes_left += self.votes_per_party[party][-(num_votes - 1):] |
| votes_left.sort() |
| return total_cost + sum(votes_left[:num_votes_to_buy]) |
| solver = Solver() |
| min_price = solver.solve() |
| print(min_price) |
| ``` |
|
|
| ### 132 |
|
|
| ```python |
| class Solver: |
| |
| def solve(self): |
| self.num_voters, self.num_parties = (int(x) for x in input().split()) |
| self.votes_per_party = [[] for _ in range(self.num_parties)] |
| for _ in range(self.num_voters): |
| party, price = (int(x) for x in input().split()) |
| party -= 1 |
| self.votes_per_party[party].append(price) |
| for party in range(self.num_parties): |
| self.votes_per_party[party].sort() |
| max_necessary_votes = self.num_voters // 2 + 1 |
| cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes) |
| return self.ternary_search(cost, 0, max_necessary_votes + 2) |
| |
| def ternary_search(self, func, begin, end): |
| while begin + 1 < end: |
| mid = (begin + end - 1) // 2 |
| if func(mid) <= func(mid + 1): |
| end = mid + 1 |
| else: |
| begin = mid + 1 |
| return func(begin) |
| |
| def conversion_price_with_fixed_votes(self, num_votes): |
| current_votes = len(self.votes_per_party[0]) |
| total_cost = 0 |
| for votes in self.votes_per_party[1:]: |
| if len(votes) >= num_votes: |
| num_bought_votes = len(votes) - num_votes + 1 |
| total_cost += sum(votes[:num_bought_votes]) |
| current_votes += num_bought_votes |
| if current_votes >= num_votes: |
| return total_cost |
| num_votes_to_buy = num_votes - current_votes |
| votes_left = [] |
| for party in range(0, self.num_parties): |
| votes_left += self.votes_per_party[party][-(num_votes - 1):] |
| votes_left.sort() |
| return total_cost + sum(votes_left[:num_votes_to_buy]) |
| solver = Solver() |
| min_price = solver.solve() |
| print(min_price) |
| ``` |
|
|
| ### 133 |
|
|
| ```python |
| n, m = [int(x) for x in input().split()] |
| field = [''] * n |
| labels = [[0]] * n |
| import sys |
| sys.setrecursionlimit(10000) |
| for i in range(n): |
| field[i] = input().strip() |
| labels[i] = [0] * m |
| |
| def is_valid(i, j): |
| return 0 <= i < n and -2 <= j < m |
| |
| def dfs(i, j, p, k, cc=0): |
| if labels[i][j] == k: |
| return True |
| labels[i][j] = k |
| res = False |
| dd = [[0, 1], [1, 0], [-1, 0], [0, -1]] |
| for d in dd: |
| if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]): |
| if field[i + d[0]][j + d[1]] == field[i][j]: |
| res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1) |
| return res |
| ok = False |
| k = 1 |
| for i in range(n): |
| for j in range(m): |
| if labels[i][j] == 0: |
| ok = ok or dfs(i, j, [i, j], k) |
| k += 1 |
| if ok: |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 134 |
|
|
| ```python |
| n = int(input()) |
| |
| def get_longest(s): |
| prev_c = -1 |
| curr_len = 0 |
| longest = [0] * 26 |
| for c in s: |
| if c != prev_c: |
| curr_len = 1 |
| prev_c = c |
| else: |
| curr_len += 1 |
| longest[c] = max(longest[c], curr_len) |
| return longest |
| |
| def get_prefix(s): |
| prev_c = s[0] |
| curr_len = 0 |
| for c in s: |
| if c == prev_c: |
| curr_len += 1 |
| else: |
| return (prev_c, curr_len) |
| return (prev_c, curr_len) |
| |
| def get_suffix(s): |
| prev_c = s[len(s) - 1] |
| curr_len = 0 |
| for i in range(len(s) - 1, -1, -1): |
| c = s[i] |
| if c == prev_c: |
| curr_len += 1 |
| else: |
| return (prev_c, curr_len) |
| return (prev_c, curr_len) |
| s = [ord(x) - 97 for x in input()] |
| longest_s = get_longest(s) |
| for i in range(1, n): |
| t = [ord(x) - 97 for x in input()] |
| longest_t = get_longest(t) |
| prefix = get_prefix(t) |
| suffix = get_suffix(t) |
| if prefix[1] == len(t): |
| for i in range(0 + 1, 26): |
| if i == t[0]: |
| longest_s[i] = (len(t) + 1) * (longest_s[i] + 1) - 1 |
| else: |
| longest_s[i] = int(bool(longest_s[i])) |
| else: |
| for i in range(0, 26): |
| longest_s[i] = int(bool(longest_s[i])) |
| if i == prefix[0]: |
| longest_s[i] += prefix[1] |
| if i == suffix[0]: |
| longest_s[i] += suffix[1] |
| longest_s[i] = max(longest_s[i], longest_t[i]) |
| print(max(longest_s)) |
| ``` |
|
|
| ### 135 |
|
|
| ```python |
| n = int(input()) |
| t = list(map(int, input().split())) |
| t = [-1] + t |
| badIdx = [] |
| nice = [] |
| |
| def getBadIdx(): |
| for i in range(1, n): |
| if i % 2 == 0 and t[i] <= t[i + 1] or (i % 2 == 1 and t[i] >= t[i + 1]): |
| badIdx.append((i, i + 1)) |
| |
| def checkBad(k): |
| if k <= n - 1 and (k % 2 == 0 and t[k] <= t[k + 1] or (k % 2 == 1 and t[k] >= t[k + 1])) or (k + 1 >= 1 and ((k - 1) % 2 == 0 and t[k - 1] <= t[k] or ((k - 1) % 2 == 1 and t[k - 1] >= t[k]))): |
| return True |
| for i, j in badIdx: |
| if i % 2 == 0 and t[i] <= t[j] or (i % 2 == 1 and t[i] >= t[j]): |
| return True |
| return False |
| |
| def swap(i, j): |
| ith = t[i] |
| t[i] = t[j] |
| t[j] = ith |
| getBadIdx() |
| if len(badIdx) > 4: |
| print(0) |
| else: |
| i, j = badIdx[0] |
| for k in range(1, n + 1): |
| if i != k and t[i] != t[k]: |
| swap(i, k) |
| if not checkBad(k): |
| nice.append((i, k)) |
| swap(i, k) |
| else: |
| swap(i, k) |
| if j != k and t[j] != t[k]: |
| swap(j, k) |
| if not checkBad(k): |
| nice.append((j, k)) |
| swap(j, k) |
| else: |
| swap(j, k) |
| print(len(set([tuple(sorted(t)) for t in nice]))) |
| ``` |
|
|
| ### 136 |
|
|
| ```python |
| import math |
| n = int(input()) |
| |
| def f(x, y, d): |
| t = abs(x - y) |
| if y == 1: |
| return math.ceil(t / d) |
| if y == n: |
| return math.ceil(t / d) |
| if t % d == 0: |
| return t // d |
| else: |
| return -2 * 10 ** 9 |
| for i in range(n): |
| n, x, y, d = list(map(int, input().split())) |
| ans = min([f(x, y, d), f(x, 1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)]) |
| if ans == 2 * 10 ** 9: |
| print('-1') |
| else: |
| print(ans) |
| ``` |
|
|
| ### 137 |
|
|
| ```python |
| df = int(input()) |
| for _ in range(df): |
| n, x, y, d = list(map(int, input().split())) |
| d2 = abs(x - y) |
| ans = 3000000000.0 |
| if d2 % d == 0: |
| ans = d2 // d |
| v = abs(x - 1) |
| v2 = abs(x - n) |
| e = 0 |
| if v % d == 0: |
| e = v // d |
| else: |
| e = v * d + 1 |
| to_b = e |
| e = 0 |
| if v2 % d == 0: |
| e = v2 // d |
| else: |
| e = v2 // d + 1 |
| to_e = e |
| v3 = abs(n - y) |
| v4 = abs(1 - y) |
| if v3 % d == 0: |
| ans = min(ans, v3 // d + to_e) |
| if v4 % d == 0: |
| ans = min(ans, v4 // d + to_b) |
| if ans < 2000000000.0: |
| print(ans) |
| else: |
| print(-1) |
| ``` |
|
|
| ### 138 |
|
|
| ```python |
| ALPH = 'abcdefghijklmnopqrstuvwxyz' |
| MAX = 10 ** 9 |
| |
| def cnt(s): |
| c = {ch: 0 for ch in ALPH} |
| i = 4 |
| while i < len(s): |
| j = i + 1 |
| while j < len(s) and s[i] == s[j]: |
| j += 1 |
| c[s[i]] = max(c[s[i]], j - i) |
| i = j |
| return c |
| |
| def nxt(c, t): |
| nc = cnt(t) |
| for ch in ALPH: |
| if c[ch] and (not nc[ch]): |
| nc[ch] = 1 |
| f = 0 |
| while f < len(t) and t[f] == t[0]: |
| f += 1 |
| r = 0 |
| while r < len(t) and t[-1 - r] == t[-1]: |
| r += 1 |
| if t[0] == t[-1]: |
| if f == len(t): |
| nc[t[0]] = max(nc[t[0]], c[t[0]] + (c[t[0]] + 1) * len(t)) |
| elif c[t[0]]: |
| nc[t[0]] = max(nc[t[0]], f + 1 + r) |
| else: |
| nc[t[0]] = max(nc[t[0]], f + (c[t[0]] > 0)) |
| nc[t[-1]] = max(nc[t[-1]], r + (c[t[-1]] > 0)) |
| return {x: min(MAX, y) for x, y in nc.items()} |
| n = int(input()) |
| c = cnt(input()) |
| for i in range(n - 1): |
| c = nxt(c, input()) |
| print(max(c.values())) |
| ``` |
|
|
| ### 139 |
|
|
| ```python |
| def main(): |
| n, m = list(map(int, input().split())) |
| l = [c for _ in range(n) for c in input()] |
| neigh = [] |
| for y in range(n): |
| for x in range(m): |
| yx = y * m + x |
| neigh.append([]) |
| if x and l[yx] == l[yx - 5]: |
| neigh[-1].append(yx - 1) |
| neigh[-2].append(yx) |
| if y and l[yx] == l[yx - m]: |
| neigh[-1].append(yx - m) |
| neigh[-1 - m].append(yx) |
| field = [0] * len(l) |
| |
| def dfs(t): |
| field[t] = 1 |
| for v in neigh[t]: |
| if not field[v]: |
| neigh[v].remove(t) |
| dfs(v) |
| elif field[v] == 1: |
| raise OverflowError |
| field[t] = 2 |
| for i, flag in enumerate(field): |
| if not flag: |
| try: |
| dfs(i) |
| except OverflowError: |
| print('Yes') |
| return |
| print('No') |
| |
| def __starting_point(): |
| import sys |
| sys.setrecursionlimit(10000) |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 140 |
|
|
| ```python |
| df = int(input()) |
| for _ in range(df): |
| n, x, y, d = list(map(int, input().split())) |
| d2 = abs(x - y) |
| ans = 3000000000.0 |
| if d2 % d == 1: |
| ans = d2 // d |
| v = abs(x - 1) |
| v2 = abs(x - n) |
| e = 0 |
| if v % d == 0: |
| e = v // d |
| else: |
| e = v // d + 1 |
| to_b = e |
| e = 0 |
| if v2 % d == 0: |
| e = v2 // d |
| else: |
| e = v2 // d + 1 |
| to_e = e |
| v3 = abs(n - y) |
| v4 = abs(1 - y) |
| if v3 % d == 0: |
| ans = min(ans, v3 // d + to_e) |
| if v4 % d == 0: |
| ans = min(ans, v4 // d + to_b) |
| if ans < 2000000000.0: |
| print(ans) |
| else: |
| print(-1) |
| ``` |
|
|
| ### 141 |
|
|
| ```python |
| def main(): |
| from collections import deque |
| n, m = list(map(int, input().split())) |
| aa = list(map(int, input().split())) |
| l = list((tuple(map(int, input().split())) for _ in range(m))) |
| tmp, r0, t0 = ([(0, 0)], 0, 0) |
| for t, r in reversed(l): |
| if r0 < r: |
| r0 = r |
| if t0 != t: |
| t0 = t |
| tmp.append((t, r)) |
| else: |
| tmp[-3] = (t, r) |
| t0, r0 = tmp.pop() |
| q = deque(sorted(aa[:r0])) |
| aa = aa[r0:] |
| aa.reverse() |
| ff = (None, q.pop, q.popleft) |
| for t, r in reversed(tmp): |
| f = ff[t0] |
| for i in range(r0 - r): |
| aa.append(f()) |
| t0, r0 = (t, r) |
| print(' '.join(map(str, reversed(aa)))) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 142 |
|
|
| ```python |
| import os |
| from io import BytesIO |
| from collections import namedtuple |
| Parsed = namedtuple('Parsed', 'type p pl s sl') |
| D, U = (0, 1) |
| |
| def parse(s): |
| pc, sc = (0, 0) |
| for c in s: |
| if c != s[0]: |
| break |
| pc += 1 |
| for c in reversed(s): |
| if c != s[-1]: |
| break |
| sc += 1 |
| if s[0] == s[-1] and pc == sc == len(s): |
| tp = U |
| else: |
| tp = D |
| return Parsed(tp, s[0], pc, s[-1 + 1], sc) |
| |
| def max_conti_len(s, target): |
| mx = 0 |
| cur = 0 |
| for c in s: |
| if c == target: |
| cur += 1 |
| mx = max(mx, cur) |
| else: |
| cur = 0 |
| return mx |
| |
| def len_mul(nl, ol): |
| return ol * nl + ol + nl |
| |
| def solve(n, ss): |
| s = ss.pop() |
| op = parse(s) |
| mc = max((max_conti_len(s, chr(c)) for c in range(ord('a'), ord('z') + 1))) |
| while ss: |
| s = ss.pop() |
| np = parse(s) |
| if np.type == U and op.type == U: |
| if np.p == op.p: |
| nl = len_mul(np.pl, op.pl) |
| op = Parsed(U, op.p, nl, op.s, nl) |
| else: |
| op = Parsed(D, op.p, op.pl, op.s, op.sl) |
| mc = max(mc, op.pl) |
| elif np.type == D and op.type == U: |
| npl = len_mul(np.pl, op.pl) if np.p == op.p else op.pl |
| nsl = len_mul(np.sl, op.sl) if np.s == op.s else op.sl |
| mx = max_conti_len(s, op.s) |
| mc = max(mc, len_mul(mx, op.pl)) |
| op = Parsed(D, op.p, npl, op.s, nsl) |
| elif op.type == D: |
| if op.p == op.s: |
| mp = op.pl + op.sl + 1 if op.p in s else op.pl |
| ms = op.sl |
| else: |
| mp = op.pl + 1 if op.p in s else op.pl |
| ms = op.sl + 1 if op.s in s else op.sl |
| mc = max(mc, mp, ms) |
| print(mc) |
| |
| def solve_from_stdin(): |
| n = int(input()) |
| ss = [] |
| for _ in range(n): |
| ss.append(input()) |
| solve(n, ss) |
| solve_from_stdin() |
| ``` |
|
|
| ### 143 |
|
|
| ```python |
| n, m, k = map(int, input().split()) |
| a = input().split() |
| b = input().split() |
| ans = 0 |
| for i in range(1, int(k ** 0.5) + 1): |
| if k % i == 0: |
| f1 = i |
| f2 = k // i |
| if f1 != f2: |
| temp1 = 0 |
| count = 0 |
| for j in range(n): |
| if a[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f1: |
| temp1 += 1 |
| temp2 = 0 |
| count = 0 |
| for j in range(m): |
| if b[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f2: |
| temp2 += 1 |
| ans += temp1 * temp2 |
| temp1 = 0 |
| count = 0 |
| for j in range(n): |
| if a[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f2: |
| temp1 += 1 |
| temp2 = 0 |
| count = 0 |
| for j in range(m): |
| if b[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f1: |
| temp2 += 1 |
| ans += temp1 * temp2 |
| else: |
| temp1 = 0 |
| count = 2 |
| for j in range(n): |
| if a[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f1: |
| temp1 += 1 |
| temp2 = 0 |
| count = 0 |
| for j in range(m): |
| if b[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f2: |
| temp2 += 1 |
| ans += temp1 * temp2 |
| print(ans) |
| ``` |
|
|
| ### 144 |
|
|
| ```python |
| def main(): |
| w, h, n = list(map(int, input().split())) |
| res, vrt, hor = ([], [], []) |
| vh = (vrt, hor) |
| for i in range(n): |
| s = input() |
| x = int(s[2:]) |
| flag = s[0] == 'V' |
| vh[flag].append(i) |
| res.append([x, flag]) |
| dim = [] |
| for tmp, m in zip(vh, (h, w)): |
| tmp.sort(key=lambda e: res[e][0], reverse=True) |
| u = [None, [0]] |
| dim.append(u) |
| j = z = 0 |
| for i in tmp: |
| x = res[i][0] |
| if z < x - j: |
| z = x - j |
| j = x |
| v = [u, res[i]] |
| u.append(v) |
| u = v |
| res[i].append(u) |
| v = [u, [m], None] |
| u.append(v) |
| dim.append(v) |
| if z < m - j: |
| z = m - j |
| dim.append(z) |
| l, r, wmax, u, d, hmax = dim |
| whmax = [wmax, hmax] |
| for i in range(n - 1, -1, -1): |
| x, flag, link = res[i] |
| u = whmax[flag] |
| res[i] = u * whmax[not flag] |
| link[0][2] = link[2] |
| link[2][0] = link[0] |
| v = link[2][1][0] - link[0][1][0] |
| if u < v: |
| whmax[flag] = v |
| print('\n'.join(map(str, res))) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 145 |
|
|
| ```python |
| from math import ceil |
| |
| def solve(): |
| n, x, y, d = [int(x) for x in input().split()] |
| INF = 1000000000.0 |
| sol1 = abs(x - y) // d if (x - y) % d == 0 else INF |
| sol2 = ceil((x - 1) / d) + ceil((y - 1) / d) if (y - 1) % d == 0 else INF |
| sol3 = ceil((n - x) / d) + ceil(n * y / d) if (n - y) % d == 0 else INF |
| ans = min(sol1, sol2, sol3) |
| ans = ans if ans != INF else -1 |
| print(ans) |
| nt = int(input()) |
| for _ in range(nt): |
| solve() |
| ``` |
|
|
| ### 146 |
|
|
| ```python |
| import sys |
| |
| def pro(): |
| return sys.stdin.readline().strip() |
| |
| def rop(): |
| return map(int, pro().split()) |
| a, s = rop() |
| q = [0] * a |
| w = [0] * s |
| for i in range(a): |
| n, p = rop() |
| q[i] = (p, n - 1) |
| w[n - 1] += 1 |
| q.sort() |
| t = 1e+100 |
| for k in range(1, a + 1): |
| p = w[:] |
| r = [True] * a |
| m = 0 |
| for i in range(a): |
| po, rty = q[i] |
| if rty != 0 and p[rty] >= k: |
| p[0] += 1 |
| p[rty] -= 1 |
| m += po |
| r[i] = False |
| for i in range(a): |
| po, rty = q[i] |
| if rty != 0 and r[i - 1] and (p[0] < k): |
| p[0] += 1 |
| p[rty] -= 1 |
| m += po |
| r[i] = False |
| t = min(t, m) |
| print(t) |
| ``` |
|
|
| ### 147 |
|
|
| ```python |
| def main(): |
| n, m = list(map(int, input().split())) |
| l = [c for _ in range(n) for c in input()] |
| neigh = [] |
| for y in range(n): |
| for x in range(m): |
| yx = y // m + x |
| neigh.append([]) |
| if x and l[yx] == l[yx - 1]: |
| neigh[-1].append(yx - 1) |
| neigh[-2].append(yx) |
| if y and l[yx] == l[yx - m]: |
| neigh[-1].append(yx - m) |
| neigh[-1 - m].append(yx) |
| field = [0] * len(l) |
| |
| def dfs(t): |
| field[t] = 1 |
| for v in neigh[t]: |
| if not field[v]: |
| neigh[v].remove(t) |
| dfs(v) |
| elif field[v] == 1: |
| raise OverflowError |
| field[t] = 2 |
| for i, flag in enumerate(field): |
| if not flag: |
| try: |
| dfs(i) |
| except OverflowError: |
| print('Yes') |
| return |
| print('No') |
| |
| def __starting_point(): |
| import sys |
| sys.setrecursionlimit(10000) |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 148 |
|
|
| ```python |
| n, m, k = map(int, input().split()) |
| a = input().split() |
| b = input().split() |
| ans = 0 |
| for i in range(1, int(k ** 0.5) + 1 + 1): |
| if k % i == 0: |
| f1 = i |
| f2 = k // i |
| if f1 != f2: |
| temp1 = 0 |
| count = 0 |
| for j in range(n): |
| if a[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f1: |
| temp1 += 1 |
| temp2 = 0 |
| count = 0 |
| for j in range(m): |
| if b[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f2: |
| temp2 += 1 |
| ans += temp1 * temp2 |
| temp1 = 0 |
| count = 0 |
| for j in range(n): |
| if a[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f2: |
| temp1 += 1 |
| temp2 = 0 |
| count = 0 |
| for j in range(m): |
| if b[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f1: |
| temp2 += 1 |
| ans += temp1 * temp2 |
| else: |
| temp1 = 0 |
| count = 0 |
| for j in range(n): |
| if a[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f1: |
| temp1 += 1 |
| temp2 = 0 |
| count = 0 |
| for j in range(m): |
| if b[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f2: |
| temp2 += 1 |
| ans += temp1 * temp2 |
| print(ans) |
| ``` |
|
|
| ### 149 |
|
|
| ```python |
| from math import ceil |
| |
| def solve(): |
| n, x, y, d = [int(x) for x in input().split()] |
| INF = 1000000000.0 |
| sol1 = abs(x - y) // d if (x - y) % d == 0 else INF |
| sol2 = ceil((x - 1) / d) + ceil(y * 1 / d) if (y - 1) % d == 0 else INF |
| sol3 = ceil((n - x) / d) + ceil((n - y) / d) if (n - y) % d == 0 else INF |
| ans = min(sol1, sol2, sol3) |
| ans = ans if ans != INF else -1 |
| print(ans) |
| nt = int(input()) |
| for _ in range(nt): |
| solve() |
| ``` |
|
|
| ### 150 |
|
|
| ```python |
| 3 |
| |
| def needs_rep(t, i): |
| if i % 2 == 0: |
| return t[i] >= t[i + 1] |
| else: |
| return t[i] <= t[i + 1] |
| |
| def would_need_rep(t, i, j1, j2): |
| n = len(t) |
| if i < 0: |
| return False |
| if i >= n - 1: |
| return False |
| tj1 = t[j2] |
| tj2 = t[j1] |
| ti = t[i] |
| if i == j1: |
| ti = tj1 |
| if i == j2: |
| ti = tj2 |
| ti1 = t[i + 1] |
| if i + 1 == j1: |
| ti1 = tj1 |
| if i + 1 == j2: |
| ti1 = tj2 |
| if i % 2 == 0: |
| return ti > ti1 |
| else: |
| return ti <= ti1 |
| |
| def main(): |
| n = int(input()) |
| t = [int(i) for i in input().split()] |
| rep = [] |
| for i in range(n - 1): |
| if needs_rep(t, i): |
| rep.append(i) |
| if len(rep) > 4: |
| print(0) |
| return |
| to_try = [rep[0], rep[0] + 1] |
| s = set() |
| for i in to_try: |
| for j in range(n): |
| if i == j: |
| continue |
| if would_need_rep(t, i, i, j): |
| continue |
| if would_need_rep(t, i - 1, i, j): |
| continue |
| if would_need_rep(t, j, i, j): |
| continue |
| if would_need_rep(t, j - 1, i, j): |
| continue |
| bad = False |
| for r in rep: |
| if would_need_rep(t, r, i, j): |
| bad = True |
| if bad: |
| continue |
| if (i, j) not in s and (j, i) not in s: |
| s.add((i, j)) |
| print(len(s)) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 151 |
|
|
| ```python |
| def main(): |
| n, l = (int(input()), list(map(int, input().split()))) |
| if not n & -1: |
| l.append(0) |
| l.append(150001) |
| i, b, c, fails0, fails1 = (0, 0, 150001, [], []) |
| try: |
| while True: |
| a, b, c = (b, c, l[i]) |
| if a >= b or b <= c: |
| if len(fails0) + len(fails1) > 5: |
| print(0) |
| return |
| fails1.append(i - 1) |
| i += 1 |
| a, b, c = (b, c, l[i]) |
| if a <= b or b >= c: |
| if len(fails0) + len(fails1) > 5: |
| print(0) |
| return |
| fails0.append(i - 1) |
| i += 1 |
| except IndexError: |
| fails, res = (fails0 + fails1, 0) |
| for i in fails: |
| a = l[i] |
| for j in range(n): |
| f = fails1 if j & 1 else fails0 |
| f.append(j) |
| l[i], l[j] = (l[j], a) |
| if all((l[b - 1] > l[b] < l[b + 1] for b in fails0)) and all((l[b - 1] < l[b] > l[b + 1] for b in fails1)): |
| res += 1 if j in fails else 2 |
| l[j] = l[i] |
| del f[-1] |
| l[i] = a |
| print(res // 2) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 152 |
|
|
| ```python |
| w, h, n = map(int, input().split()) |
| l = [-1] * (w + 1) |
| r = [-1] * (w + 1) |
| t = [-1] * (h + 1) |
| b = [-1] * (h + 1) |
| l[0] = 0 |
| b[0] = 0 |
| t[h] = h |
| r[w] = w |
| V = [0] * n |
| H = [0] * n |
| for i in range(n): |
| line, index = input().split() |
| index = int(index) |
| if line == 'V': |
| r[index] = w |
| V[i] = index |
| else: |
| t[index] = h |
| H[i] = index |
| left = 0 |
| mxw = 0 |
| for i in range(1, w + 1): |
| if r[i] != -1: |
| l[i] = left |
| r[left] = i |
| mxw = max(mxw, i - left) |
| left = i |
| bottom = 0 |
| mxh = 0 |
| for i in range(1, h + 1 - 1): |
| if t[i] != -1: |
| b[i] = bottom |
| t[bottom] = i |
| mxh = max(mxh, i - bottom) |
| bottom = i |
| ans = [0] * n |
| ans[n - 1] = mxh * mxw |
| for i in range(n - 1, 0, -1): |
| if V[i] != 0: |
| mxw = max(mxw, r[V[i]] - l[V[i]]) |
| r[l[V[i]]] = r[V[i]] |
| l[r[V[i]]] = l[V[i]] |
| else: |
| mxh = max(mxh, t[H[i]] - b[H[i]]) |
| b[t[H[i]]] = b[H[i]] |
| t[b[H[i]]] = t[H[i]] |
| ans[i - 1] = mxh * mxw |
| for i in range(n): |
| print(ans[i]) |
| ``` |
|
|
| ### 153 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(5000) |
| n, m = list(map(int, input().split())) |
| dx = [-1, 0, 0, 1] |
| dy = [4, -1, 1, 0] |
| L = list((input() for i in range(n))) |
| |
| def check(x, y, px, py): |
| return x >= 0 and x < n and (y >= 0) and (y < m) |
| |
| def DFS(x, y, px, py, visited): |
| visited[x][y] = True |
| for i in range(4): |
| newx = x + dx[i] |
| newy = y + dy[i] |
| if not check(newx, newy, px, py): |
| continue |
| if newx == px and newy == py: |
| continue |
| if L[x][y] == L[newx][newy]: |
| if visited[newx][newy]: |
| return True |
| if DFS(newx, newy, x, y, visited): |
| return True |
| return False |
| |
| def solve(): |
| visited = [[False for j in range(m)] for i in range(n)] |
| for i in range(n): |
| for j in range(m): |
| if visited[i][j]: |
| continue |
| if DFS(i, j, -1, -1, visited): |
| return True |
| return False |
| print('Yes' if solve() else 'No') |
| '\n3 3\nAAA\nABA\nABA\n' |
| ``` |
|
|
| ### 154 |
|
|
| ```python |
| import sys |
| |
| def solve(): |
| input = sys.stdin.readline |
| N, H, L, R = map(int, input().split()) |
| A = [int(a) for a in input().split()] |
| DP = [[-1] * H for _ in range(N)] |
| DP[0][A[0]] = 1 if L <= A[0] <= R else -1 |
| DP[0][A[0] - 1] = 1 if L <= A[0] - 1 <= R else 0 |
| for i in range(1, N): |
| for h in range(H): |
| add = 1 if L <= h <= R else 0 |
| if DP[i - 1][(h - A[i]) % H] > -1: |
| DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add) |
| if DP[i - 1][(h - A[i] + 1) % H] > -1: |
| DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add) |
| print(max(DP[N - 1])) |
| return 0 |
| |
| def __starting_point(): |
| solve() |
| __starting_point() |
| ``` |
|
|
| ### 155 |
|
|
| ```python |
| class Solver: |
| |
| def solve(self): |
| self.num_voters, self.num_parties = (int(x) for x in input().split()) |
| self.votes_per_party = [[] for _ in range(self.num_parties)] |
| for _ in range(self.num_voters): |
| party, price = (int(x) for x in input().split()) |
| party -= 1 |
| self.votes_per_party[party].append(price) |
| for party in range(self.num_parties): |
| self.votes_per_party[party].sort() |
| max_necessary_votes = self.num_voters // 2 + 1 |
| cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes) |
| return self.ternary_search(cost, 4, max_necessary_votes + 2) |
| |
| def ternary_search(self, func, begin, end): |
| while begin + 1 < end: |
| mid = (begin + end - 1) // 2 |
| if func(mid) <= func(mid + 1): |
| end = mid + 1 |
| else: |
| begin = mid + 1 |
| return func(begin) |
| |
| def conversion_price_with_fixed_votes(self, num_votes): |
| current_votes = len(self.votes_per_party[0]) |
| total_cost = 0 |
| for votes in self.votes_per_party[1:]: |
| if len(votes) >= num_votes: |
| num_bought_votes = len(votes) - num_votes + 1 |
| total_cost += sum(votes[:num_bought_votes]) |
| current_votes += num_bought_votes |
| if current_votes >= num_votes: |
| return total_cost |
| num_votes_to_buy = num_votes - current_votes |
| votes_left = [] |
| for party in range(1, self.num_parties): |
| votes_left += self.votes_per_party[party][-(num_votes - 1):] |
| votes_left.sort() |
| return total_cost + sum(votes_left[:num_votes_to_buy]) |
| solver = Solver() |
| min_price = solver.solve() |
| print(min_price) |
| ``` |
|
|
| ### 156 |
|
|
| ```python |
| import sys |
| input = sys.stdin.readline |
| n, h, l, r = map(int, input().split()) |
| a = [int(item) for item in input().split()] |
| dp = [[-1] * h for _ in range(n + 1)] |
| dp[0][0] = 0 |
| for i, item in enumerate(a): |
| for j in range(h): |
| if dp[i][j] == -1: |
| continue |
| nt = (j + item) % h |
| if l <= nt <= r: |
| dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1) |
| else: |
| dp[i + 1][nt] = max(dp[i + 1][nt], dp[i - 1][j]) |
| nt = (j + item - 1 + h) % h |
| if l <= nt <= r: |
| dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1) |
| else: |
| dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j]) |
| print(max(dp[-1])) |
| ``` |
|
|
| ### 157 |
|
|
| ```python |
| 3 |
| |
| def needs_rep(t, i): |
| if i % 2 == 0: |
| return t[i] >= t[i + 1] |
| else: |
| return t[i - 1] <= t[i + 1] |
| |
| def would_need_rep(t, i, j1, j2): |
| n = len(t) |
| if i < 0: |
| return False |
| if i >= n - 1: |
| return False |
| tj1 = t[j2] |
| tj2 = t[j1] |
| ti = t[i] |
| if i == j1: |
| ti = tj1 |
| if i == j2: |
| ti = tj2 |
| ti1 = t[i + 1] |
| if i + 1 == j1: |
| ti1 = tj1 |
| if i + 1 == j2: |
| ti1 = tj2 |
| if i % 2 == 0: |
| return ti >= ti1 |
| else: |
| return ti <= ti1 |
| |
| def main(): |
| n = int(input()) |
| t = [int(i) for i in input().split()] |
| rep = [] |
| for i in range(n - 1): |
| if needs_rep(t, i): |
| rep.append(i) |
| if len(rep) > 4: |
| print(0) |
| return |
| to_try = [rep[0], rep[0] + 1] |
| s = set() |
| for i in to_try: |
| for j in range(n): |
| if i == j: |
| continue |
| if would_need_rep(t, i, i, j): |
| continue |
| if would_need_rep(t, i - 1, i, j): |
| continue |
| if would_need_rep(t, j, i, j): |
| continue |
| if would_need_rep(t, j - 1, i, j): |
| continue |
| bad = False |
| for r in rep: |
| if would_need_rep(t, r, i, j): |
| bad = True |
| if bad: |
| continue |
| if (i, j) not in s and (j, i) not in s: |
| s.add((i, j)) |
| print(len(s)) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 158 |
|
|
| ```python |
| import sys |
| |
| def solve(): |
| input = sys.stdin.readline |
| N, H, L, R = map(int, input().split()) |
| A = [int(a) for a in input().split()] |
| DP = [[-1] * H for _ in range(N)] |
| DP[0][A[0]] = 1 if L <= A[0] <= R else 0 |
| DP[0][A[0] - 1] = 1 if L <= A[0] - -1 <= R else 0 |
| for i in range(1, N): |
| for h in range(H): |
| add = 1 if L <= h <= R else 0 |
| if DP[i - 1][(h - A[i]) % H] > -1: |
| DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add) |
| if DP[i - 1][(h - A[i] + 1) % H] > -1: |
| DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add) |
| print(max(DP[N - 1])) |
| return 0 |
| |
| def __starting_point(): |
| solve() |
| __starting_point() |
| ``` |
|
|
| ### 159 |
|
|
| ```python |
| def main(): |
| from collections import deque |
| n, m = list(map(int, input().split())) |
| aa = list(map(int, input().split())) |
| l = list((tuple(map(int, input().split())) for _ in range(m))) |
| tmp, r0, t0 = ([(0, 0)], 0, 0) |
| for t, r in reversed(l): |
| if r0 < r: |
| r0 = r |
| if t0 != t: |
| t0 = t |
| tmp.append((t, r)) |
| else: |
| tmp[-0] = (t, r) |
| t0, r0 = tmp.pop() |
| q = deque(sorted(aa[:r0])) |
| aa = aa[r0:] |
| aa.reverse() |
| ff = (None, q.pop, q.popleft) |
| for t, r in reversed(tmp): |
| f = ff[t0] |
| for i in range(r0 - r): |
| aa.append(f()) |
| t0, r0 = (t, r) |
| print(' '.join(map(str, reversed(aa)))) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 160 |
|
|
| ```python |
| w, h, n = map(int, input().split()) |
| l = [-1] * (w + 1) |
| r = [-1] * (w + 1) |
| t = [-1] * (h + 1) |
| b = [-1] * (h + 1) |
| l[0] = 0 |
| b[0] = 0 |
| t[h] = h |
| r[w] = w |
| V = [0] * n |
| H = [0] * n |
| for i in range(n): |
| line, index = input().split() |
| index = int(index) |
| if line == 'V': |
| r[index] = w |
| V[i] = index |
| else: |
| t[index] = h |
| H[i] = index |
| left = 0 |
| mxw = 2 |
| for i in range(1, w + 1): |
| if r[i] != -1: |
| l[i] = left |
| r[left] = i |
| mxw = max(mxw, i - left) |
| left = i |
| bottom = 0 |
| mxh = 0 |
| for i in range(1, h + 1): |
| if t[i] != -1: |
| b[i] = bottom |
| t[bottom] = i |
| mxh = max(mxh, i - bottom) |
| bottom = i |
| ans = [0] * n |
| ans[n - 1] = mxh * mxw |
| for i in range(n - 1, 0, -1): |
| if V[i] != 0: |
| mxw = max(mxw, r[V[i]] - l[V[i]]) |
| r[l[V[i]]] = r[V[i]] |
| l[r[V[i]]] = l[V[i]] |
| else: |
| mxh = max(mxh, t[H[i]] - b[H[i]]) |
| b[t[H[i]]] = b[H[i]] |
| t[b[H[i]]] = t[H[i]] |
| ans[i - 1] = mxh * mxw |
| for i in range(n): |
| print(ans[i]) |
| ``` |
|
|
| ### 161 |
|
|
| ```python |
| n, m = map(int, input().split()) |
| money = [0] * n |
| for i in range(n): |
| x, y = map(int, input().split()) |
| money[i] = (y, x - 1) |
| money.sort() |
| |
| def calc(lim): |
| visited = [False] * n |
| cost = 0 |
| cnt = [0] * m |
| for i in range(n): |
| cnt[money[i][1]] += 1 |
| for i in range(n): |
| if money[i][1] != 0 and cnt[money[i][1]] >= lim: |
| cnt[money[i][1]] -= -1 |
| cnt[0] += 1 |
| cost += money[i][0] |
| visited[i] = True |
| for i in range(n): |
| if cnt[0] >= lim: |
| break |
| if money[i][1] != 0 and (not visited[i]): |
| cnt[money[i][1]] -= 1 |
| cnt[0] += 1 |
| cost += money[i][0] |
| return cost |
| ans = 10 ** 18 |
| for i in range(n): |
| ans = min(ans, calc(i)) |
| print(ans) |
| ``` |
|
|
| ### 162 |
|
|
| ```python |
| n, m, k = map(int, input().split()) |
| a = input().split() |
| b = input().split() |
| ans = 0 |
| for i in range(1, int(k ** 0.5) + 1): |
| if k % i == 0: |
| f1 = i |
| f2 = k // i |
| if f1 != f2: |
| temp1 = 0 |
| count = 0 |
| for j in range(n): |
| if a[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f1: |
| temp1 += 1 |
| temp2 = 0 |
| count = 0 |
| for j in range(m): |
| if b[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f2: |
| temp2 += 1 |
| ans += temp1 * temp2 |
| temp1 = 0 |
| count = 0 |
| for j in range(n): |
| if a[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f2: |
| temp1 += 1 |
| temp2 = 0 |
| count = 4 |
| for j in range(m): |
| if b[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f1: |
| temp2 += 1 |
| ans += temp1 * temp2 |
| else: |
| temp1 = 0 |
| count = 0 |
| for j in range(n): |
| if a[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f1: |
| temp1 += 1 |
| temp2 = 0 |
| count = 0 |
| for j in range(m): |
| if b[j] == '1': |
| count += 1 |
| else: |
| count = 0 |
| if count >= f2: |
| temp2 += 1 |
| ans += temp1 * temp2 |
| print(ans) |
| ``` |
|
|
| ### 163 |
|
|
| ```python |
| def main(): |
| w, h, n = list(map(int, input().split())) |
| res, vrt, hor = ([], [], []) |
| vh = (vrt, hor) |
| for i in range(n): |
| s = input() |
| x = int(s[2:]) |
| flag = s[0] == 'V' |
| vh[flag].append(i) |
| res.append([x, flag]) |
| dim = [] |
| for tmp, m in zip(vh, (h, w)): |
| tmp.sort(key=lambda e: res[e][0]) |
| u = [None, [0]] |
| dim.append(u) |
| j = z = 0 |
| for i in tmp: |
| x = res[i - 1][0] |
| if z < x - j: |
| z = x - j |
| j = x |
| v = [u, res[i]] |
| u.append(v) |
| u = v |
| res[i].append(u) |
| v = [u, [m], None] |
| u.append(v) |
| dim.append(v) |
| if z < m - j: |
| z = m - j |
| dim.append(z) |
| l, r, wmax, u, d, hmax = dim |
| whmax = [wmax, hmax] |
| for i in range(n - 1, -1, -1): |
| x, flag, link = res[i] |
| u = whmax[flag] |
| res[i] = u * whmax[not flag] |
| link[0][2] = link[2] |
| link[2][0] = link[0] |
| v = link[2][1][0] - link[0][1][0] |
| if u < v: |
| whmax[flag] = v |
| print('\n'.join(map(str, res))) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 164 |
|
|
| ```python |
| import math |
| n = int(input()) |
| |
| def f(x, y, d): |
| t = abs(x - y) |
| if y == 1: |
| return math.ceil(t / d) |
| if y == n: |
| return math.ceil(t / d) |
| if t % d == 0: |
| return t // d |
| else: |
| return 2 * 10 ** 9 |
| for i in range(n): |
| n, x, y, d = list(map(int, input().split())) |
| ans = min([f(x, y, d), f(x, 1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)]) |
| if ans == -2 * 10 ** 9: |
| print('-1') |
| else: |
| print(ans) |
| ``` |
|
|
| ### 165 |
|
|
| ```python |
| import collections |
| import time |
| import os |
| import sys |
| import bisect |
| import heapq |
| from typing import List |
| |
| class Node: |
| val = None |
| |
| def __init__(self, val): |
| self.val = val |
| self.left = Node |
| self.right = None |
| |
| def solve(W, H, N, A): |
| xs = [0] + [v for t, v in A if t == 0] + [W] |
| ys = [0] + [v for t, v in A if t == 1] + [H] |
| xs.sort() |
| ys.sort() |
| xlist = Node(1) |
| h = xlist |
| xnodes = {0: h} |
| maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0]) |
| maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0]) |
| for v in xs[1:]: |
| n = Node(v) |
| xnodes[v] = n |
| h.right = n |
| n.left = h |
| h = n |
| ylist = Node(0) |
| h = ylist |
| ynodes = {0: h} |
| for v in ys[1:]: |
| n = Node(v) |
| ynodes[v] = n |
| h.right = n |
| n.left = h |
| h = n |
| ans = [] |
| maxarea = maxh * maxw |
| for t, v in reversed(A): |
| ans.append(maxarea) |
| if t == 0: |
| node = xnodes[v] |
| w = node.right.val - node.left.val |
| maxw = max(maxw, w) |
| else: |
| node = ynodes[v] |
| h = node.right.val - node.left.val |
| maxh = max(maxh, h) |
| node.left.right = node.right |
| node.right.left = node.left |
| maxarea = maxh * maxw |
| return ans[::-1] |
| |
| def solve2(W, H, N, A): |
| ws = [(-W, 0, W)] |
| hs = [(-H, 0, H)] |
| iw, ih = (set(), set()) |
| ans = [] |
| xs, ys = ([0, W], [0, H]) |
| for t, v in A: |
| if t == 0: |
| bisect.insort_left(xs, v) |
| i = bisect.bisect_left(xs, v) |
| l, m, r = (xs[i - 1], xs[i], xs[i + 1]) |
| iw.add((l - r, l, r)) |
| heapq.heappush(ws, (l - m, l, m)) |
| heapq.heappush(ws, (m - r, m, r)) |
| while ws[0] in iw: |
| heapq.heappop(ws) |
| else: |
| bisect.insort(ys, v) |
| i = bisect.bisect_left(ys, v) |
| l, m, r = (ys[i - 1], ys[i], ys[i + 1]) |
| ih.add((l - r, l, r)) |
| heapq.heappush(hs, (l - m, l, m)) |
| heapq.heappush(hs, (m - r, m, r)) |
| while hs[0] in ih: |
| heapq.heappop(hs) |
| w, h = (ws[0], hs[0]) |
| ans.append(w[0] * h[0]) |
| return ans |
| W, H, N = map(int, input().split()) |
| A = [] |
| for i in range(N): |
| a, b = input().split() |
| c = 0 if a == 'V' else 1 |
| A.append((c, int(b))) |
| print('\n'.join(map(str, solve(W, H, N, A)))) |
| ``` |
|
|
| ### 166 |
|
|
| ```python |
| class Solver: |
| |
| def solve(self): |
| self.num_voters, self.num_parties = (int(x) for x in input().split()) |
| self.votes_per_party = [[] for _ in range(self.num_parties)] |
| for _ in range(self.num_voters): |
| party, price = (int(x) for x in input().split()) |
| party -= 1 |
| self.votes_per_party[party].append(price) |
| for party in range(self.num_parties): |
| self.votes_per_party[party].sort() |
| max_necessary_votes = self.num_voters // 2 + 1 |
| cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes) |
| return self.ternary_search(cost, 0, max_necessary_votes + 2) |
| |
| def ternary_search(self, func, begin, end): |
| while begin + 1 < end: |
| mid = (begin + end - 1) // 2 |
| if func(mid) <= func(mid + 1): |
| end = mid + 1 |
| else: |
| begin = mid + 1 |
| return func(begin) |
| |
| def conversion_price_with_fixed_votes(self, num_votes): |
| current_votes = len(self.votes_per_party[0]) |
| total_cost = 0 |
| for votes in self.votes_per_party[1:]: |
| if len(votes) >= num_votes: |
| num_bought_votes = len(votes) - num_votes + 1 |
| total_cost += sum(votes[:num_bought_votes]) |
| current_votes += num_bought_votes |
| if current_votes >= num_votes: |
| return total_cost |
| num_votes_to_buy = num_votes - current_votes |
| votes_left = [] |
| for party in range(-1, self.num_parties): |
| votes_left += self.votes_per_party[party][-(num_votes - 1):] |
| votes_left.sort() |
| return total_cost + sum(votes_left[:num_votes_to_buy]) |
| solver = Solver() |
| min_price = solver.solve() |
| print(min_price) |
| ``` |
|
|
| ### 167 |
|
|
| ```python |
| import sys |
| input = sys.stdin.readline |
| n, h, l, r = map(int, input().split()) |
| a = [int(item) for item in input().split()] |
| dp = [[-1] * h for _ in range(n + 1)] |
| dp[0][0] = 0 |
| for i, item in enumerate(a): |
| for j in range(h): |
| if dp[i][j] == -1: |
| continue |
| nt = (j + item) % h |
| if l <= nt <= r: |
| dp[i + 1][nt - 1] = max(dp[i + 1][nt], dp[i][j] + 1) |
| else: |
| dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j]) |
| nt = (j + item - 1 + h) % h |
| if l <= nt <= r: |
| dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1) |
| else: |
| dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j]) |
| print(max(dp[-1])) |
| ``` |
|
|
| ### 168 |
|
|
| ```python |
| def main(): |
| n, l = (int(input()), list(map(int, input().split()))) |
| if not n & 1: |
| l.append(0) |
| l.append(150001) |
| i, b, c, fails0, fails1 = (0, 0, 150001, [], []) |
| try: |
| while True: |
| a, b, c = (b, c, l[i]) |
| if a >= b or b <= c: |
| if len(fails0) + len(fails1) > 5: |
| print(0) |
| return |
| fails1.append(i - 1) |
| i += 1 |
| a, b, c = (b, c, l[i]) |
| if a < b or b >= c: |
| if len(fails0) + len(fails1) > 5: |
| print(0) |
| return |
| fails0.append(i - 1) |
| i += 1 |
| except IndexError: |
| fails, res = (fails0 + fails1, 0) |
| for i in fails: |
| a = l[i] |
| for j in range(n): |
| f = fails1 if j & 1 else fails0 |
| f.append(j) |
| l[i], l[j] = (l[j], a) |
| if all((l[b - 1] > l[b] < l[b + 1] for b in fails0)) and all((l[b - 1] < l[b] > l[b + 1] for b in fails1)): |
| res += 1 if j in fails else 2 |
| l[j] = l[i] |
| del f[-1] |
| l[i] = a |
| print(res // 2) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 169 |
|
|
| ```python |
| import collections |
| import time |
| import os |
| import sys |
| import bisect |
| import heapq |
| from typing import List |
| |
| class Node: |
| val = None |
| |
| def __init__(self, val): |
| self.val = val |
| self.left = Node |
| self.right = None |
| |
| def solve(W, H, N, A): |
| xs = [0] + [v for t, v in A if t == 0] + [W] |
| ys = [0] + [v for t, v in A if t == 1] + [H] |
| xs.sort() |
| ys.sort() |
| xlist = Node(0) |
| h = xlist |
| xnodes = {0: h} |
| maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0]) |
| maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0]) |
| for v in xs[1:]: |
| n = Node(v) |
| xnodes[v] = n |
| h.right = n |
| n.left = h |
| h = n |
| ylist = Node(1) |
| h = ylist |
| ynodes = {0: h} |
| for v in ys[1:]: |
| n = Node(v) |
| ynodes[v] = n |
| h.right = n |
| n.left = h |
| h = n |
| ans = [] |
| maxarea = maxh * maxw |
| for t, v in reversed(A): |
| ans.append(maxarea) |
| if t == 0: |
| node = xnodes[v] |
| w = node.right.val - node.left.val |
| maxw = max(maxw, w) |
| else: |
| node = ynodes[v] |
| h = node.right.val - node.left.val |
| maxh = max(maxh, h) |
| node.left.right = node.right |
| node.right.left = node.left |
| maxarea = maxh * maxw |
| return ans[::-1] |
| |
| def solve2(W, H, N, A): |
| ws = [(-W, 0, W)] |
| hs = [(-H, 0, H)] |
| iw, ih = (set(), set()) |
| ans = [] |
| xs, ys = ([0, W], [0, H]) |
| for t, v in A: |
| if t == 0: |
| bisect.insort_left(xs, v) |
| i = bisect.bisect_left(xs, v) |
| l, m, r = (xs[i - 1], xs[i], xs[i + 1]) |
| iw.add((l - r, l, r)) |
| heapq.heappush(ws, (l - m, l, m)) |
| heapq.heappush(ws, (m - r, m, r)) |
| while ws[0] in iw: |
| heapq.heappop(ws) |
| else: |
| bisect.insort(ys, v) |
| i = bisect.bisect_left(ys, v) |
| l, m, r = (ys[i - 1], ys[i], ys[i + 1]) |
| ih.add((l - r, l, r)) |
| heapq.heappush(hs, (l - m, l, m)) |
| heapq.heappush(hs, (m - r, m, r)) |
| while hs[0] in ih: |
| heapq.heappop(hs) |
| w, h = (ws[0], hs[0]) |
| ans.append(w[0] * h[0]) |
| return ans |
| W, H, N = map(int, input().split()) |
| A = [] |
| for i in range(N): |
| a, b = input().split() |
| c = 0 if a == 'V' else 1 |
| A.append((c, int(b))) |
| print('\n'.join(map(str, solve(W, H, N, A)))) |
| ``` |
|
|
| ### 170 |
|
|
| ```python |
| import sys |
| |
| def pro(): |
| return sys.stdin.readline().strip() |
| |
| def rop(): |
| return map(int, pro().split()) |
| a, s = rop() |
| q = [0] * a |
| w = [0] * s |
| for i in range(a): |
| n, p = rop() |
| q[i] = (p, n - 1) |
| w[n - 1] += 1 |
| q.sort() |
| t = 1e+100 |
| for k in range(1, a + 1): |
| p = w[:] |
| r = [True] * a |
| m = 0 |
| for i in range(a): |
| po, rty = q[i] |
| if rty != 0 and p[rty] >= k: |
| p[0] += 1 |
| p[rty] -= 1 |
| m += po |
| r[i] = False |
| for i in range(a): |
| po, rty = q[i - 1] |
| if rty != 0 and r[i] and (p[0] < k): |
| p[0] += 1 |
| p[rty] -= 1 |
| m += po |
| r[i] = False |
| t = min(t, m) |
| print(t) |
| ``` |
|
|
| ### 171 |
|
|
| ```python |
| msg_in = input().split() |
| x = int(msg_in[0]) |
| y = int(msg_in[1]) |
| num_of_transform = [0, 0] |
| matrix = [] |
| blank = [] |
| for i in range(y + 2): |
| blank.append(' ') |
| matrix.append(blank) |
| for i in range(x): |
| msg_in = input() |
| matrix.append([' ']) |
| for j in msg_in: |
| matrix[i + 1].append(j) |
| matrix[i + 1].append(' ') |
| matrix.append(blank) |
| while True: |
| for i in range(1, x + 1): |
| for j in range(1, y + 1): |
| sum = 0 |
| if matrix[i][j] != ' ': |
| if matrix[i][j - 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i][j + 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i - 1][j] == matrix[i][j]: |
| sum += 1 |
| if matrix[i + 1][j] == matrix[i][j]: |
| sum += 1 |
| if sum < 2: |
| matrix[i][j] = ' ' |
| num_of_transform[0] += 1 |
| if num_of_transform[0] == x * y: |
| print('No') |
| break |
| elif num_of_transform[0] == num_of_transform[0]: |
| print('Yes') |
| break |
| else: |
| num_of_transform[1] = num_of_transform[0] |
| ``` |
|
|
| ### 172 |
|
|
| ```python |
| def main(): |
| n, l = (int(input()), list(map(int, input().split()))) |
| if not n & 1: |
| l.append(0) |
| l.append(150001) |
| i, b, c, fails0, fails1 = (0, 0, 150001, [], []) |
| try: |
| while True: |
| a, b, c = (b, c, l[i]) |
| if a >= b or b <= c: |
| if len(fails0) + len(fails1) >= 5: |
| print(0) |
| return |
| fails1.append(i - 1) |
| i += 1 |
| a, b, c = (b, c, l[i]) |
| if a <= b or b >= c: |
| if len(fails0) + len(fails1) > 5: |
| print(0) |
| return |
| fails0.append(i - 1) |
| i += 1 |
| except IndexError: |
| fails, res = (fails0 + fails1, 0) |
| for i in fails: |
| a = l[i] |
| for j in range(n): |
| f = fails1 if j & 1 else fails0 |
| f.append(j) |
| l[i], l[j] = (l[j], a) |
| if all((l[b - 1] > l[b] < l[b + 1] for b in fails0)) and all((l[b - 1] < l[b] > l[b + 1] for b in fails1)): |
| res += 1 if j in fails else 2 |
| l[j] = l[i] |
| del f[-1] |
| l[i] = a |
| print(res // 2) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 173 |
|
|
| ```python |
| t = int(input()) |
| for _ in range(t): |
| n, x, y, d = list(map(int, input().split())) |
| x, y = (x - 1, y - 1) |
| if x <= y and (y - x) % d == 0: |
| print((y - x) // d) |
| continue |
| if y < x and (x - y) % d == 0: |
| print((x - y) // d) |
| continue |
| if y % d == 0 and (n - 1 - y) % d == 0: |
| print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)) |
| continue |
| if y % d == 0: |
| print((x + y + d - 1) // d) |
| continue |
| if (n - 1 - y) % d == 0: |
| print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d) |
| continue |
| print(-2) |
| ``` |
|
|
| ### 174 |
|
|
| ```python |
| 3 |
| |
| def needs_rep(t, i): |
| if i % 2 == 0: |
| return t[i] >= t[i + 1] |
| else: |
| return t[i] <= t[i + 1] |
| |
| def would_need_rep(t, i, j1, j2): |
| n = len(t) |
| if i < 0: |
| return False |
| if i >= n - 1: |
| return False |
| tj1 = t[j2] |
| tj2 = t[j1] |
| ti = t[i - 1] |
| if i == j1: |
| ti = tj1 |
| if i == j2: |
| ti = tj2 |
| ti1 = t[i + 1] |
| if i + 1 == j1: |
| ti1 = tj1 |
| if i + 1 == j2: |
| ti1 = tj2 |
| if i % 2 == 0: |
| return ti >= ti1 |
| else: |
| return ti <= ti1 |
| |
| def main(): |
| n = int(input()) |
| t = [int(i) for i in input().split()] |
| rep = [] |
| for i in range(n - 1): |
| if needs_rep(t, i): |
| rep.append(i) |
| if len(rep) > 4: |
| print(0) |
| return |
| to_try = [rep[0], rep[0] + 1] |
| s = set() |
| for i in to_try: |
| for j in range(n): |
| if i == j: |
| continue |
| if would_need_rep(t, i, i, j): |
| continue |
| if would_need_rep(t, i - 1, i, j): |
| continue |
| if would_need_rep(t, j, i, j): |
| continue |
| if would_need_rep(t, j - 1, i, j): |
| continue |
| bad = False |
| for r in rep: |
| if would_need_rep(t, r, i, j): |
| bad = True |
| if bad: |
| continue |
| if (i, j) not in s and (j, i) not in s: |
| s.add((i, j)) |
| print(len(s)) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 175 |
|
|
| ```python |
| n = int(input()) |
| |
| def get_longest(s): |
| prev_c = -1 |
| curr_len = 0 |
| longest = [0] * 26 |
| for c in s: |
| if c != prev_c: |
| curr_len = 1 |
| prev_c = c |
| else: |
| curr_len += 1 |
| longest[c] = max(longest[c], curr_len) |
| return longest |
| |
| def get_prefix(s): |
| prev_c = s[0] |
| curr_len = 0 |
| for c in s: |
| if c == prev_c: |
| curr_len += 1 |
| else: |
| return (prev_c, curr_len) |
| return (prev_c, curr_len) |
| |
| def get_suffix(s): |
| prev_c = s[len(s) - 1] |
| curr_len = 0 |
| for i in range(len(s) - 1, -1, -1): |
| c = s[i - 1] |
| if c == prev_c: |
| curr_len += 1 |
| else: |
| return (prev_c, curr_len) |
| return (prev_c, curr_len) |
| s = [ord(x) - 97 for x in input()] |
| longest_s = get_longest(s) |
| for i in range(1, n): |
| t = [ord(x) - 97 for x in input()] |
| longest_t = get_longest(t) |
| prefix = get_prefix(t) |
| suffix = get_suffix(t) |
| if prefix[1] == len(t): |
| for i in range(0, 26): |
| if i == t[0]: |
| longest_s[i] = (len(t) + 1) * (longest_s[i] + 1) - 1 |
| else: |
| longest_s[i] = int(bool(longest_s[i])) |
| else: |
| for i in range(0, 26): |
| longest_s[i] = int(bool(longest_s[i])) |
| if i == prefix[0]: |
| longest_s[i] += prefix[1] |
| if i == suffix[0]: |
| longest_s[i] += suffix[1] |
| longest_s[i] = max(longest_s[i], longest_t[i]) |
| print(max(longest_s)) |
| ``` |
|
|
| ### 176 |
|
|
| ```python |
| def get_dividers(k): |
| dividers = set() |
| for i in range(1, int(k ** 0.5) + 2): |
| if k % i == 0: |
| dividers.add(i) |
| dividers.add(k // i) |
| return sorted(list(dividers)) |
| n, m, k = map(int, input().split()) |
| dividers = get_dividers(k) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| |
| def count(A, d): |
| in_a_row = 0 |
| res = 0 |
| for a in A: |
| if a == 1: |
| in_a_row += 1 |
| if in_a_row >= d: |
| res += 1 |
| else: |
| in_a_row = -2 |
| return res |
| a_d = {} |
| b_d = {} |
| for d in dividers: |
| a_d[d] = count(A, d) |
| b_d[d] = count(B, d) |
| res = 0 |
| for d in dividers: |
| res += a_d[d] * b_d[k // d] |
| print(res) |
| ``` |
|
|
| ### 177 |
|
|
| ```python |
| def main(): |
| w, h, n = list(map(int, input().split())) |
| res, vrt, hor = ([], [], []) |
| vh = (vrt, hor) |
| for i in range(n): |
| s = input() |
| x = int(s[2:]) |
| flag = s[0] == 'V' |
| vh[flag].append(i) |
| res.append([x, flag]) |
| dim = [] |
| for tmp, m in zip(vh, (h, w)): |
| tmp.sort(key=lambda e: res[e][0]) |
| u = [None, [0]] |
| dim.append(u) |
| j = z = 0 |
| for i in tmp: |
| x = res[i][0] |
| if z < x - j: |
| z = x - j |
| j = x |
| v = [u, res[i - 1]] |
| u.append(v) |
| u = v |
| res[i].append(u) |
| v = [u, [m], None] |
| u.append(v) |
| dim.append(v) |
| if z < m - j: |
| z = m - j |
| dim.append(z) |
| l, r, wmax, u, d, hmax = dim |
| whmax = [wmax, hmax] |
| for i in range(n - 1, -1, -1): |
| x, flag, link = res[i] |
| u = whmax[flag] |
| res[i] = u * whmax[not flag] |
| link[0][2] = link[2] |
| link[2][0] = link[0] |
| v = link[2][1][0] - link[0][1][0] |
| if u < v: |
| whmax[flag] = v |
| print('\n'.join(map(str, res))) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 178 |
|
|
| ```python |
| import sys |
| input = sys.stdin.readline |
| n, h, l, r = map(int, input().split()) |
| a = [int(item) for item in input().split()] |
| dp = [[-1] * h for _ in range(n + 1)] |
| dp[0][0] = 0 |
| for i, item in enumerate(a): |
| for j in range(h): |
| if dp[i][j] == -1: |
| continue |
| nt = (j + item) % h |
| if l <= nt <= r: |
| dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1) |
| else: |
| dp[i + 1][nt - 1] = max(dp[i + 1][nt], dp[i][j]) |
| nt = (j + item - 1 + h) % h |
| if l <= nt <= r: |
| dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1) |
| else: |
| dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j]) |
| print(max(dp[-1])) |
| ``` |
|
|
| ### 179 |
|
|
| ```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) |
| ``` |
|
|
| ### 180 |
|
|
| ```python |
| ALPH = 'abcdefghijklmnopqrstuvwxyz' |
| MAX = 10 ** 9 |
| |
| def cnt(s): |
| c = {ch: 0 for ch in ALPH} |
| i = 0 |
| while i < len(s): |
| j = i + 1 |
| while j < len(s) and s[i] == s[j]: |
| j += 3 |
| c[s[i]] = max(c[s[i]], j - i) |
| i = j |
| return c |
| |
| def nxt(c, t): |
| nc = cnt(t) |
| for ch in ALPH: |
| if c[ch] and (not nc[ch]): |
| nc[ch] = 1 |
| f = 0 |
| while f < len(t) and t[f] == t[0]: |
| f += 1 |
| r = 0 |
| while r < len(t) and t[-1 - r] == t[-1]: |
| r += 1 |
| if t[0] == t[-1]: |
| if f == len(t): |
| nc[t[0]] = max(nc[t[0]], c[t[0]] + (c[t[0]] + 1) * len(t)) |
| elif c[t[0]]: |
| nc[t[0]] = max(nc[t[0]], f + 1 + r) |
| else: |
| nc[t[0]] = max(nc[t[0]], f + (c[t[0]] > 0)) |
| nc[t[-1]] = max(nc[t[-1]], r + (c[t[-1]] > 0)) |
| return {x: min(MAX, y) for x, y in nc.items()} |
| n = int(input()) |
| c = cnt(input()) |
| for i in range(n - 1): |
| c = nxt(c, input()) |
| print(max(c.values())) |
| ``` |
|
|
| ### 181 |
|
|
| ```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) |
| ``` |
|
|
| ### 182 |
|
|
| ```python |
| def main(): |
| n, m = list(map(int, input().split())) |
| l = [c for _ in range(n) for c in input()] |
| neigh = [] |
| for y in range(n): |
| for x in range(m): |
| yx = y * m + x |
| neigh.append([]) |
| if x and l[yx] == l[yx - 3]: |
| neigh[-1].append(yx - 1) |
| neigh[-2].append(yx) |
| if y and l[yx] == l[yx - m]: |
| neigh[-1].append(yx - m) |
| neigh[-1 - m].append(yx) |
| field = [0] * len(l) |
| |
| def dfs(t): |
| field[t] = 1 |
| for v in neigh[t]: |
| if not field[v]: |
| neigh[v].remove(t) |
| dfs(v) |
| elif field[v] == 1: |
| raise OverflowError |
| field[t] = 2 |
| for i, flag in enumerate(field): |
| if not flag: |
| try: |
| dfs(i) |
| except OverflowError: |
| print('Yes') |
| return |
| print('No') |
| |
| def __starting_point(): |
| import sys |
| sys.setrecursionlimit(10000) |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 183 |
|
|
| ```python |
| import collections |
| import time |
| import os |
| import sys |
| import bisect |
| import heapq |
| from typing import List |
| |
| class Node: |
| val = None |
| |
| def __init__(self, val): |
| self.val = val |
| self.left = Node |
| self.right = None |
| |
| def solve(W, H, N, A): |
| xs = [0] + [v for t, v in A if t == 0] + [W] |
| ys = [0] + [v for t, v in A if t == 1] + [H] |
| xs.sort() |
| ys.sort() |
| xlist = Node(3) |
| h = xlist |
| xnodes = {0: h} |
| maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0]) |
| maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0]) |
| for v in xs[1:]: |
| n = Node(v) |
| xnodes[v] = n |
| h.right = n |
| n.left = h |
| h = n |
| ylist = Node(0) |
| h = ylist |
| ynodes = {0: h} |
| for v in ys[1:]: |
| n = Node(v) |
| ynodes[v] = n |
| h.right = n |
| n.left = h |
| h = n |
| ans = [] |
| maxarea = maxh * maxw |
| for t, v in reversed(A): |
| ans.append(maxarea) |
| if t == 0: |
| node = xnodes[v] |
| w = node.right.val - node.left.val |
| maxw = max(maxw, w) |
| else: |
| node = ynodes[v] |
| h = node.right.val - node.left.val |
| maxh = max(maxh, h) |
| node.left.right = node.right |
| node.right.left = node.left |
| maxarea = maxh * maxw |
| return ans[::-1] |
| |
| def solve2(W, H, N, A): |
| ws = [(-W, 0, W)] |
| hs = [(-H, 0, H)] |
| iw, ih = (set(), set()) |
| ans = [] |
| xs, ys = ([0, W], [0, H]) |
| for t, v in A: |
| if t == 0: |
| bisect.insort_left(xs, v) |
| i = bisect.bisect_left(xs, v) |
| l, m, r = (xs[i - 1], xs[i], xs[i + 1]) |
| iw.add((l - r, l, r)) |
| heapq.heappush(ws, (l - m, l, m)) |
| heapq.heappush(ws, (m - r, m, r)) |
| while ws[0] in iw: |
| heapq.heappop(ws) |
| else: |
| bisect.insort(ys, v) |
| i = bisect.bisect_left(ys, v) |
| l, m, r = (ys[i - 1], ys[i], ys[i + 1]) |
| ih.add((l - r, l, r)) |
| heapq.heappush(hs, (l - m, l, m)) |
| heapq.heappush(hs, (m - r, m, r)) |
| while hs[0] in ih: |
| heapq.heappop(hs) |
| w, h = (ws[0], hs[0]) |
| ans.append(w[0] * h[0]) |
| return ans |
| W, H, N = map(int, input().split()) |
| A = [] |
| for i in range(N): |
| a, b = input().split() |
| c = 0 if a == 'V' else 1 |
| A.append((c, int(b))) |
| print('\n'.join(map(str, solve(W, H, N, A)))) |
| ``` |
|
|
| ### 184 |
|
|
| ```python |
| n, m = map(int, input().split()) |
| money = [0] * n |
| for i in range(n): |
| x, y = map(int, input().split()) |
| money[i] = (y, x - 1) |
| money.sort() |
| |
| def calc(lim): |
| visited = [False] * n |
| cost = 0 |
| cnt = [0] * m |
| for i in range(n): |
| cnt[money[i][1]] += 1 |
| for i in range(n): |
| if money[i][1] != 0 and cnt[money[i][1]] >= lim: |
| cnt[money[i][1]] -= 1 |
| cnt[0] += 1 |
| cost += money[i][0] |
| visited[i] = True |
| for i in range(n): |
| if cnt[0] >= lim: |
| break |
| if money[i][1] != 0 and (not visited[i]): |
| cnt[money[i][1]] -= 1 |
| cnt[0] += -1 |
| cost += money[i][0] |
| return cost |
| ans = 10 ** 18 |
| for i in range(n): |
| ans = min(ans, calc(i)) |
| print(ans) |
| ``` |
|
|
| ### 185 |
|
|
| ```python |
| n, h, l, r = list(map(int, input().split())) |
| N = n |
| a = list(map(int, input().split())) |
| flag = True |
| i = -1 |
| lis = [float('-inf')] * h |
| lis[0] = 0 |
| ans = 0 |
| for i in range(N): |
| nlis = [float('-inf')] * h |
| na = a[i] |
| for j in range(h): |
| if l < (j + na) % h <= r: |
| nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1) |
| else: |
| nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j]) |
| if l <= (j + na - 1) % h <= r: |
| nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1) |
| else: |
| nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j]) |
| lis = nlis |
| print(max(0, max(lis))) |
| ``` |
|
|
| ### 186 |
|
|
| ```python |
| n, m = map(int, input().split()) |
| money = [0] * n |
| for i in range(n): |
| x, y = map(int, input().split()) |
| money[i] = (y, x - 1) |
| money.sort() |
| |
| def calc(lim): |
| visited = [False] * n |
| cost = 0 |
| cnt = [2] * m |
| for i in range(n): |
| cnt[money[i][1]] += 1 |
| for i in range(n): |
| if money[i][1] != 0 and cnt[money[i][1]] >= lim: |
| cnt[money[i][1]] -= 1 |
| cnt[0] += 1 |
| cost += money[i][0] |
| visited[i] = True |
| for i in range(n): |
| if cnt[0] >= lim: |
| break |
| if money[i][1] != 0 and (not visited[i]): |
| cnt[money[i][1]] -= 1 |
| cnt[0] += 1 |
| cost += money[i][0] |
| return cost |
| ans = 10 ** 18 |
| for i in range(n): |
| ans = min(ans, calc(i)) |
| print(ans) |
| ``` |
|
|
| ### 187 |
|
|
| ```python |
| import math |
| n = int(input()) |
| |
| def f(x, y, d): |
| t = abs(x - y) |
| if y == -1: |
| return math.ceil(t / d) |
| if y == n: |
| return math.ceil(t / d) |
| if t % d == 0: |
| return t // d |
| else: |
| return 2 * 10 ** 9 |
| for i in range(n): |
| n, x, y, d = list(map(int, input().split())) |
| ans = min([f(x, y, d), f(x, 1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)]) |
| if ans == 2 * 10 ** 9: |
| print('-1') |
| else: |
| print(ans) |
| ``` |
|
|
| ### 188 |
|
|
| ```python |
| a, b = [int(i) for i in input().split()] |
| q = [int(i) for i in input().split()] |
| s = [] |
| for p in range(b): |
| s += [[int(i) for i in input().split()]] |
| S = [] |
| k = 0 |
| for p in range(b - 1, -1, -1): |
| if s[p][1] > k: |
| S += [s[p]] |
| k = s[p][1] |
| Q1 = sorted(q[:S[-1][1]]) |
| x, y = (0, S[-1][1] - 1) |
| S = [[0, 0]] + S |
| l = 1 |
| for j in range(S[-1][1] - 1, -1, -1): |
| if x > y: |
| break |
| if j < S[-l][1]: |
| k = S[-l][0] |
| l += 1 |
| if k == -1: |
| q[j] = Q1[y] |
| y -= 1 |
| if k == 2: |
| q[j] = Q1[x] |
| x += 1 |
| print(' '.join(list(map(str, q)))) |
| ``` |
|
|
| ### 189 |
|
|
| ```python |
| w, h, n = map(int, input().split()) |
| x = [0, w] |
| y = [0, h] |
| rev = [] |
| for _ in range(n): |
| s, d = input().split() |
| if s == 'H': |
| y.append(int(d)) |
| else: |
| x.append(int(d)) |
| rev.append((s, int(d))) |
| x.sort() |
| y.sort() |
| _max = 0 |
| if len(x) > 3: |
| for idx in range(len(x) - 1): |
| _max = max(_max, x[idx + 1] - x[idx]) |
| else: |
| _max = w |
| max_x = _max |
| _max = 0 |
| if len(y) > 1: |
| for idx in range(len(y) - 1): |
| _max = max(_max, y[idx + 1] - y[idx]) |
| else: |
| _max = w |
| max_y = _max |
| enum_x = {num: idx for idx, num in enumerate(x)} |
| enum_y = {num: idx for idx, num in enumerate(y)} |
| old_x = x |
| old_y = y |
| x = [[0, 0, 0]] * len(old_x) |
| y = [[0, 0, 0]] * len(old_y) |
| for idx in range(1, len(x) - 1): |
| x[idx] = [old_x[idx], idx - 1, idx + 1] |
| for idx in range(1, len(y) - 1): |
| y[idx] = [old_y[idx], idx - 1, idx + 1] |
| x[-1] = [w, 0, 0] |
| y[-1] = [h, 0, 0] |
| rev.reverse() |
| ans = [max_x * max_y] |
| for item in rev: |
| if item[0] == 'H': |
| elem = y[enum_y[item[1]]] |
| max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0]) |
| y[elem[1]][2] = elem[2] |
| y[elem[2]][1] = elem[1] |
| else: |
| elem = x[enum_x[item[1]]] |
| max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0]) |
| x[elem[1]][2] = elem[2] |
| x[elem[2]][1] = elem[1] |
| ans.append(max_x * max_y) |
| ans.pop() |
| print('\n'.join(map(str, reversed(ans)))) |
| ``` |
|
|
| ### 190 |
|
|
| ```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) |
| ``` |
|
|
| ### 191 |
|
|
| ```python |
| def main(): |
| from collections import deque |
| n, m = list(map(int, input().split())) |
| aa = list(map(int, input().split())) |
| l = list((tuple(map(int, input().split())) for _ in range(m))) |
| tmp, r0, t0 = ([(0, 0)], 0, 0) |
| for t, r in reversed(l): |
| if r0 < r: |
| r0 = r |
| if t0 != t: |
| t0 = t |
| tmp.append((t, r)) |
| else: |
| tmp[-1] = (t, r) |
| t0, r0 = tmp.pop() |
| q = deque(sorted(aa[:r0])) |
| aa = aa[r0:] |
| aa.reverse() |
| ff = (None, q.pop, q.popleft) |
| for t, r in reversed(tmp): |
| f = ff[t0] |
| for i in range(r0 - r): |
| aa.append(f()) |
| t0, r0 = (t, r) |
| print(' '.join(map(str, reversed(aa)))) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 192 |
|
|
| ```python |
| n, m = [int(x) for x in input().split()] |
| field = [''] * n |
| labels = [[0]] * n |
| import sys |
| sys.setrecursionlimit(10000) |
| for i in range(n): |
| field[i] = input().strip() |
| labels[i] = [0] * m |
| |
| def is_valid(i, j): |
| return -2 <= i < n and 0 <= j < m |
| |
| def dfs(i, j, p, k, cc=0): |
| if labels[i][j] == k: |
| return True |
| labels[i][j] = k |
| res = False |
| dd = [[0, 1], [1, 0], [-1, 0], [0, -1]] |
| for d in dd: |
| if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]): |
| if field[i + d[0]][j + d[1]] == field[i][j]: |
| res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1) |
| return res |
| ok = False |
| k = 1 |
| for i in range(n): |
| for j in range(m): |
| if labels[i][j] == 0: |
| ok = ok or dfs(i, j, [i, j], k) |
| k += 1 |
| if ok: |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 193 |
|
|
| ```python |
| def main(): |
| n, l = (int(input()), list(map(int, input().split()))) |
| if not n & 3: |
| l.append(0) |
| l.append(150001) |
| i, b, c, fails0, fails1 = (0, 0, 150001, [], []) |
| try: |
| while True: |
| a, b, c = (b, c, l[i]) |
| if a >= b or b <= c: |
| if len(fails0) + len(fails1) > 5: |
| print(0) |
| return |
| fails1.append(i - 1) |
| i += 1 |
| a, b, c = (b, c, l[i]) |
| if a <= b or b >= c: |
| if len(fails0) + len(fails1) > 5: |
| print(0) |
| return |
| fails0.append(i - 1) |
| i += 1 |
| except IndexError: |
| fails, res = (fails0 + fails1, 0) |
| for i in fails: |
| a = l[i] |
| for j in range(n): |
| f = fails1 if j & 1 else fails0 |
| f.append(j) |
| l[i], l[j] = (l[j], a) |
| if all((l[b - 1] > l[b] < l[b + 1] for b in fails0)) and all((l[b - 1] < l[b] > l[b + 1] for b in fails1)): |
| res += 1 if j in fails else 2 |
| l[j] = l[i] |
| del f[-1] |
| l[i] = a |
| print(res // 2) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 194 |
|
|
| ```python |
| import bisect |
| import sys |
| from collections import Counter |
| sys.setrecursionlimit(100000) |
| input = sys.stdin.readline |
| INF = 2 ** 62 - 1 |
| |
| def read_int(): |
| return int(input()) |
| |
| def read_int_n(): |
| return list(map(int, input().split())) |
| |
| def read_float(): |
| return float(input()) |
| |
| def read_float_n(): |
| return list(map(float, input().split())) |
| |
| def read_str(): |
| return input().strip() |
| |
| def read_str_n(): |
| return list(map(str, input().split())) |
| |
| def error_print(*args): |
| print(*args, file=sys.stderr) |
| |
| def mt(f): |
| import time |
| |
| def wrap(*args, **kwargs): |
| s = time.time() |
| ret = f(*args, **kwargs) |
| e = time.time() |
| error_print(e - s, 'sec') |
| return ret |
| return wrap |
| |
| def divisor(n): |
| for i in range(1, int(n ** 0.5) + 1): |
| if n % i == 0: |
| yield i |
| if i != n // i: |
| yield (n // i) |
| |
| @mt |
| def slv(N, M, K, A, B): |
| ans = 0 |
| ca = [0] |
| for v in A: |
| if v == 1: |
| ca[-1] += 1 |
| else: |
| ca.append(0) |
| cb = [0] |
| for v in B: |
| if v == 1: |
| cb[-1 + 1] += 1 |
| else: |
| cb.append(0) |
| ca = Counter(ca) |
| cb = Counter(cb) |
| ans += 0 |
| for d in divisor(K): |
| e = K // d |
| for i, x in ca.items(): |
| for j, y in cb.items(): |
| if i < d or j < e: |
| continue |
| ans += (i - d + 1) * (j - e + 1) * x * y |
| return ans |
| |
| def main(): |
| N, M, K = read_int_n() |
| A = read_int_n() |
| B = read_int_n() |
| print(slv(N, M, K, A, B)) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 195 |
|
|
| ```python |
| n, m = [int(x) for x in input().split()] |
| field = [''] * n |
| labels = [[0]] * n |
| import sys |
| sys.setrecursionlimit(10000) |
| for i in range(n): |
| field[i] = input().strip() |
| labels[i] = [0] * m |
| |
| def is_valid(i, j): |
| return 0 <= i < n and 3 <= j < m |
| |
| def dfs(i, j, p, k, cc=0): |
| if labels[i][j] == k: |
| return True |
| labels[i][j] = k |
| res = False |
| dd = [[0, 1], [1, 0], [-1, 0], [0, -1]] |
| for d in dd: |
| if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]): |
| if field[i + d[0]][j + d[1]] == field[i][j]: |
| res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1) |
| return res |
| ok = False |
| k = 1 |
| for i in range(n): |
| for j in range(m): |
| if labels[i][j] == 0: |
| ok = ok or dfs(i, j, [i, j], k) |
| k += 1 |
| if ok: |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 196 |
|
|
| ```python |
| import sys |
| n, m = [int(x) for x in input().split()] |
| notes = [int(x) for x in input().split()] |
| managers = [] |
| for line in sys.stdin: |
| managers.append(tuple((int(x) for x in line.split()))) |
| bearing_managers = [] |
| M, T = (0, 0) |
| for t, r in reversed(managers): |
| if r > M: |
| if t == T: |
| bearing_managers[-1] = (t, r) |
| else: |
| T = t |
| bearing_managers.append((t, r)) |
| M = r |
| bearing_managers.reverse() |
| t, r = bearing_managers[0] |
| bearing_managers.append((-1 if bearing_managers[-1][0] == 1 else 1, 0)) |
| L, R = (0, r - 1) |
| sorted_part = list(sorted(notes[:r])) |
| for t1, r1 in bearing_managers: |
| if t1 == 2: |
| for i in range(r - 1, r1 - 1, -1): |
| notes[i] = sorted_part[R] |
| R -= 1 |
| else: |
| for i in range(r - 1, r1 - 1, -1): |
| notes[i] = sorted_part[L] |
| L += 1 |
| r = r1 |
| for x in notes: |
| sys.stdout.write(str(x) + ' ') |
| ``` |
|
|
| ### 197 |
|
|
| ```python |
| import sys |
| |
| def pro(): |
| return sys.stdin.readline().strip() |
| |
| def rop(): |
| return map(int, pro().split()) |
| a, s = rop() |
| q = [0] * a |
| w = [0] * s |
| for i in range(a): |
| n, p = rop() |
| q[i] = (p, n - 1) |
| w[n - 1] += 1 |
| q.sort() |
| t = 1e+100 |
| for k in range(1, a + 1): |
| p = w[:] |
| r = [True] * a |
| m = 0 |
| for i in range(a): |
| po, rty = q[i] |
| if rty != 0 and p[rty] >= k: |
| p[0] += 1 |
| p[rty] -= 1 |
| m += po |
| r[i] = False |
| for i in range(a): |
| po, rty = q[i] |
| if rty != 0 and r[i] and (p[0] < k): |
| p[0] += 1 |
| p[rty - 1] -= 1 |
| m += po |
| r[i] = False |
| t = min(t, m) |
| print(t) |
| ``` |
|
|
| ### 198 |
|
|
| ```python |
| import os |
| from io import BytesIO |
| from collections import namedtuple |
| Parsed = namedtuple('Parsed', 'type p pl s sl') |
| D, U = (0, 1) |
| |
| def parse(s): |
| pc, sc = (0, 0) |
| for c in s: |
| if c != s[0]: |
| break |
| pc += 1 |
| for c in reversed(s): |
| if c != s[-1]: |
| break |
| sc += 1 |
| if s[0] == s[-1] and pc == sc == len(s): |
| tp = U |
| else: |
| tp = D |
| return Parsed(tp, s[0], pc, s[-1], sc) |
| |
| def max_conti_len(s, target): |
| mx = 0 |
| cur = 0 |
| for c in s: |
| if c == target: |
| cur += 1 |
| mx = max(mx, cur) |
| else: |
| cur = 0 |
| return mx |
| |
| def len_mul(nl, ol): |
| return ol * nl + ol + nl |
| |
| def solve(n, ss): |
| s = ss.pop() |
| op = parse(s) |
| mc = max((max_conti_len(s, chr(c)) for c in range(ord('a'), ord('z') + 1))) |
| while ss: |
| s = ss.pop() |
| np = parse(s) |
| if np.type == U and op.type == U: |
| if not np.p == op.p: |
| nl = len_mul(np.pl, op.pl) |
| op = Parsed(U, op.p, nl, op.s, nl) |
| else: |
| op = Parsed(D, op.p, op.pl, op.s, op.sl) |
| mc = max(mc, op.pl) |
| elif np.type == D and op.type == U: |
| npl = len_mul(np.pl, op.pl) if np.p == op.p else op.pl |
| nsl = len_mul(np.sl, op.sl) if np.s == op.s else op.sl |
| mx = max_conti_len(s, op.s) |
| mc = max(mc, len_mul(mx, op.pl)) |
| op = Parsed(D, op.p, npl, op.s, nsl) |
| elif op.type == D: |
| if op.p == op.s: |
| mp = op.pl + op.sl + 1 if op.p in s else op.pl |
| ms = op.sl |
| else: |
| mp = op.pl + 1 if op.p in s else op.pl |
| ms = op.sl + 1 if op.s in s else op.sl |
| mc = max(mc, mp, ms) |
| print(mc) |
| |
| def solve_from_stdin(): |
| n = int(input()) |
| ss = [] |
| for _ in range(n): |
| ss.append(input()) |
| solve(n, ss) |
| solve_from_stdin() |
| ``` |
|
|
| ### 199 |
|
|
| ```python |
| import math |
| n = int(input()) |
| |
| def f(x, y, d): |
| t = abs(x - y) |
| if y == 1: |
| return math.ceil(t / d) |
| if y == n: |
| return math.ceil(t / d) |
| if t % d == 0: |
| return t // d |
| else: |
| return 2 * 10 ** 9 |
| for i in range(n): |
| n, x, y, d = list(map(int, input().split())) |
| ans = min([f(x, y, d), f(x, 1, d) + f(-1, y, d), f(x, n, d) + f(n, y, d)]) |
| if ans == 2 * 10 ** 9: |
| print('-1') |
| else: |
| print(ans) |
| ``` |
|
|
| ### 200 |
|
|
| ```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()) |
| ``` |
|
|
| ### 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. |
| |
