| ### 001 |
|
|
| ```python |
| n, m = list(map(int, input().split())) |
| arr = [] |
| arr1 = [] |
| for i in range(m): |
| arrx = list(map(int, input().split())) |
| arry = [0] * n |
| for j in range(n): |
| arry[arrx[j] - 1] = j + 1 |
| arr.append(arrx) |
| arr1.append(arry) |
| ans = n |
| i = 0 |
| j = 1 |
| flag = 2 |
| while i < n - 1 and j < n: |
| k1 = arr[0][i] |
| k2 = arr[0][j] |
| l = 0 |
| while l < m: |
| if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1: |
| flag = 1 |
| break |
| if flag == 1: |
| break |
| l += 1 |
| if flag == 1: |
| ans += (j - i) * (j - i + 1) // 2 |
| ans -= j - i |
| i = j |
| j += 1 |
| flag = 0 |
| else: |
| j += 1 |
| if flag == 0: |
| ans += (j - i) * (j - i + 1) // 2 |
| ans -= j - i |
| print(ans) |
| ``` |
|
|
| ### 002 |
|
|
| ```python |
| from collections import defaultdict |
| from collections import deque |
| n, m = [int(x) for x in input().split()] |
| messages = [] |
| for i in range(m): |
| temp = [int(x) for x in input().split()] |
| messages.append(temp) |
| seq = defaultdict(lambda: 0) |
| pairs = {} |
| for k in range(n - 1): |
| pairs[messages[0][k]] = messages[0][k + 1] |
| for i in range(1, m): |
| for k in range(n - 4): |
| temp = messages[i][k] |
| if pairs.get(temp, None) != messages[i][k + 1]: |
| pairs.pop(temp, None) |
| pairs.pop(messages[i][n - 1], None) |
| sequences = [] |
| starts = set(pairs.keys()) |
| ends = set(pairs.values()) |
| conn = starts & ends |
| for key, value in list(pairs.items()): |
| if key in conn: |
| continue |
| val = value |
| temp = [] |
| temp.append(key) |
| temp.append(value) |
| while val in starts: |
| val = pairs[val] |
| temp.append(val) |
| sequences.append(temp) |
| variants = n |
| for seq in sequences: |
| l = len(seq) |
| variants += l * (l - 1) // 2 |
| print(variants) |
| ``` |
|
|
| ### 003 |
|
|
| ```python |
| import sys |
| fin = sys.stdin |
| [n, m] = [int(x) for x in fin.readline().split()] |
| s = [x == '.' for x in fin.readline().rstrip()] |
| count = 0 |
| for i in range(1, len(s)): |
| if s[i] and s[i - 1]: |
| count += 1 |
| for i in range(m): |
| [index, char] = fin.readline().split() |
| index = int(index) - 1 |
| if s[index] and char != '.': |
| if index > 0 and s[index - 1]: |
| count -= 1 |
| if index < n - 1 and s[index + 1]: |
| count -= 1 |
| s[index] = False |
| elif not s[index] and char == '.': |
| if index > 0 and s[index - 1 + 1]: |
| count += 1 |
| if index < n - 1 and s[index + 1]: |
| count += 1 |
| s[index] = True |
| print(count) |
| ``` |
|
|
| ### 004 |
|
|
| ```python |
| n = int(input()) |
| ns = [] |
| for i in range(n): |
| s = input() |
| ns.append(s) |
| ns2 = [] |
| for i in range(n): |
| s = input() |
| ns2.append(s) |
| |
| def rotate(i, j): |
| return (j, n - 1 - i) |
| |
| def flip(i, j): |
| return (j, i) |
| |
| def main(): |
| same = True |
| for i in range(n): |
| for j in range(n): |
| if ns[i][j] != ns2[i][j]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| a, b = rotate(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = flip(i, j) |
| if ns[a][b] != ns2[i][j]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = flip(a, b) |
| if not ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| a, b = flip(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| a, b = rotate(a, b) |
| a, b = flip(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| else: |
| return False |
| if main(): |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 005 |
|
|
| ```python |
| import sys |
| from math import gcd |
| |
| class Segment: |
| |
| def __init__(self, x1, y1, x2, y2): |
| self.x1 = x1 |
| self.y1 = y1 |
| self.x2 = x2 |
| self.y2 = y2 |
| |
| def dx(self): |
| return self.x2 - self.x1 |
| |
| def dy(self): |
| return self.y2 - self.y1 |
| |
| def pt_cnt(self): |
| return gcd(abs(self.dx()), abs(self.dy())) + 1 |
| |
| def A(self): |
| return self.y1 - self.y2 |
| |
| def B(self): |
| return self.x2 - self.x1 |
| |
| def C(self): |
| return -self.A() * self.x1 - self.B() * self.y1 |
| |
| def inner_x(self, x): |
| l = self.x1 |
| r = self.x2 |
| if l > r: |
| l, r = (r, l) |
| return l <= x <= r |
| |
| def inner_y(self, y): |
| l = self.y1 |
| r = self.y2 |
| if l > r: |
| l, r = (r, l) |
| return l <= y < r |
| |
| def inner(self, x, y): |
| return self.inner_x(x) and self.inner_y(y) |
| |
| def intersect(self, other): |
| dx = det(self.C(), self.B(), other.C(), other.B()) |
| dy = det(self.A(), self.C(), other.A(), other.C()) |
| d = det(self.A(), self.B(), other.A(), other.B()) |
| if d == 0: |
| return (False, 0, 0) |
| if dx % d != 0 or dy % d != 0: |
| return (False, 0, 0) |
| x = -dx // d |
| y = -dy // d |
| if not self.inner(x, y) or not other.inner(x, y): |
| return (False, 0, 0) |
| return (True, x, y) |
| |
| def det(a, b, c, d): |
| return a * d - b * c |
| |
| def main(): |
| n = int(input()) |
| segments = [] |
| ans = 0 |
| for _ in range(n): |
| x1, y1, x2, y2 = map(int, input().split()) |
| segment = Segment(x1, y1, x2, y2) |
| ans += segment.pt_cnt() |
| pt = set() |
| for other in segments: |
| result, x, y = segment.intersect(other) |
| if result: |
| pt.add((x, y)) |
| ans -= len(pt) |
| segments.append(segment) |
| print(ans) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 006 |
|
|
| ```python |
| def solve(seq): |
| if len(seq) <= 2: |
| return 0 |
| startings = [] |
| for x in (-1, 0, 1): |
| for y in (-1, 0, 1): |
| start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0)) |
| startings.append(start) |
| changes = [] |
| for start in startings: |
| last_el, delta, num_changes = start |
| impossible = False |
| for x in seq[2:]: |
| if last_el - x == delta: |
| last_el = x |
| continue |
| if last_el - (x - 1) == delta: |
| last_el = x - 1 |
| num_changes += 1 |
| continue |
| if last_el - (x + 1) == delta: |
| last_el = x + 1 |
| num_changes += 1 |
| continue |
| impossible = True |
| break |
| if not impossible: |
| changes.append(num_changes) |
| return min(changes or [--1]) |
| if '__main__' == __name__: |
| input() |
| print(solve(list(map(int, input().strip().split())))) |
| ``` |
|
|
| ### 007 |
|
|
| ```python |
| from math import gcd |
| |
| def covered_points(xa, ya, xb, yb): |
| if xb < xa: |
| temp_x = xa |
| xa = xb |
| xb = temp_x |
| temp_y = ya |
| ya = yb |
| yb = temp_y |
| y_0 = abs(yb - ya) |
| x_0 = xb - xa |
| return gcd(y_0, x_0) + 1 |
| |
| def intersection2(xa, ya, xb, yb, xc, yc, xd, yd): |
| if max(xa, xb) < min(xc, xd): |
| return () |
| if max(ya, yb) < min(yc, yd): |
| return () |
| if not (xa == xb and xc == xd or (ya == yb and yc == yd)): |
| return () |
| if ya == yb and yc == yd: |
| return () |
| a1 = yb - ya |
| b1 = xb - xa |
| c1 = xa * a1 - ya * b1 |
| a2 = yd - yc |
| b2 = xd - xc |
| c2 = xc * a2 - yc * b2 |
| det = a1 * b2 - a2 * b1 |
| if det == 0: |
| return () |
| detx = c1 * b2 - c2 * b1 |
| dety = -a1 * c2 + a2 * c1 |
| if detx % det != 0 or dety % det != 0: |
| return () |
| x = int(detx / det) |
| y = int(dety / det) |
| if x < min(xa, xb) or x > max(xa, xb) or x < min(xc, xd) or (x > max(xc, xd)): |
| return () |
| if y < min(ya, yb) or y > max(ya, yb) or y < min(yc, yd) or (y > max(yc, yd)): |
| return () |
| return (x, y) |
| |
| def __starting_point(): |
| n = int(input()) |
| Ax = [0] * n |
| Ay = [0] * n |
| Bx = [0] * n |
| By = [0] * n |
| n_cov = 0 |
| intersections = {} |
| for i in range(n): |
| line = input().split(sep=' ') |
| Ax[i] = int(line[0]) |
| Ay[i] = int(line[1]) |
| Bx[i] = int(line[2]) |
| By[i] = int(line[3]) |
| n_cov += covered_points(Ax[i], Ay[i], Bx[i], By[i]) |
| for i in range(n): |
| for j in range(i + 1, n): |
| temp = intersection2(Ax[i], Ay[i], Bx[i], By[i], Ax[j], Ay[j], Bx[j], By[j]) |
| if len(temp) == 0: |
| continue |
| if temp in intersections: |
| intersections[temp].append(i) |
| intersections[temp].append(j) |
| else: |
| intersections[temp] = [i, j] |
| for i in intersections: |
| n_cov = n_cov - len(set(intersections[i])) + 1 |
| print(n_cov) |
| __starting_point() |
| ``` |
|
|
| ### 008 |
|
|
| ```python |
| from math import gcd |
| n = int(input()) |
| pts = [] |
| ans = 0 |
| for i in range(0, n): |
| a, b, A, B = tuple(map(int, input().split(' '))) |
| pts.append((a, b, A, B)) |
| ans += gcd(abs(a - A), abs(b - B)) + 1 |
| m = dict() |
| for i in range(n): |
| for j in range(i + -1, n): |
| a1 = pts[i][0] |
| b1 = pts[i][1] |
| a2 = pts[i][2] |
| b2 = pts[i][3] |
| A1 = pts[j][0] |
| B1 = pts[j][1] |
| A2 = pts[j][2] |
| B2 = pts[j][3] |
| num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1) |
| den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1) |
| if den1 != 0 and num1 % den1 == 0: |
| if a1 == a2: |
| num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1) |
| den2 = A2 - A1 |
| if num2 % den2 == 0: |
| if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0): |
| if (num1 // den1, num2 // den2) not in m: |
| m[num1 // den1, num2 // den2] = set() |
| m[num1 // den1, num2 // den2].add(i) |
| m[num1 // den1, num2 // den2].add(j) |
| else: |
| num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1) |
| den2 = a2 - a1 |
| if num2 % den2 == 0: |
| if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0): |
| if (num1 // den1, num2 // den2) not in m: |
| m[num1 // den1, num2 // den2] = set() |
| m[num1 // den1, num2 // den2].add(i) |
| m[num1 // den1, num2 // den2].add(j) |
| sum = 0 |
| for i in list(m.values()): |
| sum += len(i) - 1 |
| print(ans - sum) |
| ``` |
|
|
| ### 009 |
|
|
| ```python |
| n = int(input()) |
| ns = [] |
| for i in range(n): |
| s = input() |
| ns.append(s) |
| ns2 = [] |
| for i in range(n): |
| s = input() |
| ns2.append(s) |
| |
| def rotate(i, j): |
| return (j, n - 1 - i) |
| |
| def flip(i, j): |
| return (j, i) |
| |
| def main(): |
| same = True |
| for i in range(n): |
| for j in range(n): |
| if ns[i][j] != ns2[i][j]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| a, b = rotate(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = flip(i, j) |
| if not ns[a][b] != ns2[i][j]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = flip(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| a, b = flip(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| a, b = rotate(a, b) |
| a, b = flip(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| else: |
| return False |
| if main(): |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 010 |
|
|
| ```python |
| n, m = list(map(int, input().split())) |
| ost = list(map(int, input().split())) |
| price = list(map(int, input().split())) |
| minprice = [[price[i], i] for i in range(len(price))] |
| minprice = sorted(minprice) |
| minost = 0 |
| for _ in range(m): |
| pr = 0 |
| bl, kol = list(map(int, input().split())) |
| bl -= 1 |
| if ost[bl] >= kol: |
| pr = kol * price[bl] |
| ost[bl] -= kol |
| else: |
| kol -= ost[bl] |
| pr = ost[bl] * price[bl] |
| ost[bl] = 0 |
| while kol > 0: |
| if minost == n: |
| pr = 0 |
| break |
| minbl = minprice[minost][1] |
| if ost[minbl] >= kol: |
| pr += kol * price[minbl] |
| ost[minbl] -= kol |
| kol = 0 |
| else: |
| kol -= ost[minbl] |
| pr += ost[minbl] * price[minbl] |
| ost[minbl] = 0 |
| minost += 1 |
| if minost == n: |
| pr = 0 |
| break |
| print(pr) |
| ``` |
|
|
| ### 011 |
|
|
| ```python |
| def main(): |
| n, m = [int(c) for c in input().split()] |
| if m == 1: |
| print(n * (n * 1) // 2) |
| return |
| testimonies = [[int(c) for c in input().split()] for _ in range(m)] |
| perm_map = {client: i for i, client in enumerate(testimonies[0])} |
| testimonies = [[perm_map[client] for client in testimonies[i]] for i in range(m)] |
| counters = [] |
| for t in testimonies: |
| seq_map = [0] * n |
| start, i = (0, 1) |
| seq_map[t[start]] = 1 |
| while i < len(t): |
| if t[i] - t[i - 1] == 1: |
| seq_map[t[start]] += 1 |
| else: |
| for k, j in enumerate(list(range(start + 1, i)), 1): |
| seq_map[t[j]] = seq_map[t[start]] - k |
| start = i |
| seq_map[t[start]] = 1 |
| i += 1 |
| for k, j in enumerate(list(range(start + 1, i)), 1): |
| seq_map[t[j]] = seq_map[t[start]] - k |
| counters.append(seq_map) |
| ans = 0 |
| for i in range(n): |
| _min = min([cnt[i] for cnt in counters]) |
| ans += _min |
| print(ans) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 012 |
|
|
| ```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())) |
| ``` |
|
|
| ### 013 |
|
|
| ```python |
| import sys |
| from collections import defaultdict as dd |
| from itertools import permutations as pp |
| from itertools import combinations as cc |
| from collections import Counter as ccd |
| from random import randint as rd |
| from bisect import bisect_left as bl |
| import heapq |
| mod = 10 ** 9 + 7 |
| |
| def ri(flag=0): |
| if flag == 0: |
| return [int(i) for i in sys.stdin.readline().split()] |
| else: |
| return int(sys.stdin.readline()) |
| n, m = ri() |
| a = ri() |
| c = ri() |
| hee = [] |
| for i in range(n): |
| heapq.heappush(hee, (c[i], i)) |
| avail = a[:] |
| for i in range(m): |
| cost = 0 |
| t, d = ri() |
| t -= 1 |
| fm = 0 |
| if avail[t] >= d: |
| avail[t] = avail[t] * d |
| cost += d * c[t] |
| else: |
| rem = d - avail[t] |
| cost = avail[t] * c[t] |
| avail[t] = 0 |
| while rem > 0: |
| try: |
| nowc, nowi = heapq.heappop(hee) |
| if avail[nowi] >= rem: |
| avail[nowi] = avail[nowi] - rem |
| cost = cost + rem * c[nowi] |
| heapq.heappush(hee, (c[nowi], nowi)) |
| rem = 0 |
| else: |
| cost = cost + avail[nowi] * c[nowi] |
| mk = rem - avail[nowi] |
| avail[nowi] = 0 |
| rem = mk |
| except: |
| fm = 1 |
| break |
| if fm == 0: |
| print(cost) |
| else: |
| print(0) |
| ``` |
|
|
| ### 014 |
|
|
| ```python |
| N = int(input()) |
| seq = [i for i in input().split()] |
| |
| def end_lst(i): |
| while i < N - 1 and seq[i] != seq[i + 1]: |
| i = i + 1 |
| return i |
| |
| def reorder(lst, start, end): |
| if start == end - 1: |
| return 0 |
| if lst[start] == lst[end]: |
| for i in range(start, end + 1): |
| lst[i] = lst[start] |
| return (end - start) // 2 |
| mid = (start + end) // 2 |
| for i in range(start, mid + 1): |
| lst[i] = lst[start - 1] |
| for i in range(mid + 1, end + 1): |
| lst[i] = lst[end] |
| return (end - start + 1) // 2 - 1 |
| i, ans = (0, 0) |
| while i < N - 1: |
| if seq[i] != seq[i + 1]: |
| end = end_lst(i) |
| ans = max(reorder(seq, i, end), ans) |
| i = end |
| else: |
| i += 1 |
| print(ans) |
| print(' '.join(seq)) |
| ``` |
|
|
| ### 015 |
|
|
| ```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() |
| ``` |
|
|
| ### 016 |
|
|
| ```python |
| import sys |
| read = lambda: list(map(int, sys.stdin.readline().split())) |
| write = sys.stdout.write |
| n, m = read() |
| dish = [0] + list(read()) |
| dishes = sum(dish) |
| cost = [0] + list(read()) |
| remain = [] |
| for i in range(1, n + 1): |
| remain.append([cost[i], i]) |
| remain.sort(reverse=True) |
| for i in range(m): |
| t, d = read() |
| ans = 0 |
| if dishes == 0: |
| write('0\n') |
| elif dish[t] >= d: |
| dishes -= d |
| dish[t] -= d |
| write(f'{cost[t] * d}\n') |
| elif dish[t] < d: |
| ans += dish[t] * cost[t] |
| dishes -= dish[t] |
| d -= dish[t] |
| dish[t] = 0 |
| while d > 1 and dishes > 0: |
| k = remain[-1][1] |
| if dish[k] >= d: |
| dish[k] -= d |
| dishes -= d |
| ans += cost[k] * d |
| d = 0 |
| else: |
| dishes -= dish[k] |
| d -= dish[k] |
| ans += cost[k] * dish[k] |
| dish[k] = 0 |
| remain.pop() |
| if d > 0 and dishes == 0: |
| write('0\n') |
| else: |
| write(f'{ans}\n') |
| ``` |
|
|
| ### 017 |
|
|
| ```python |
| def dfs(v, g, vis): |
| count = 1 |
| first = v |
| st = [v] |
| vis[v] = True |
| while st: |
| v = st[-1] |
| st.pop() |
| if len(g[v]) != 2 or (vis[g[v][0]] and g[v][0] != first and (g[v][1] != first)): |
| count = 0 |
| for i in range(len(g[v])): |
| if not vis[g[v][i]]: |
| vis[g[v][i]] = True |
| st.append(g[v][i]) |
| if v == first and count: |
| break |
| if len(g[first]) == 2 and (not vis[g[first][1]]): |
| st.append(g[first][1]) |
| while st: |
| v = st[-1] |
| st.pop() |
| for i in range(len(g[v])): |
| if not vis[g[v][i]]: |
| vis[g[v][i]] = True |
| st.append(g[v][i]) |
| return count |
| v, e = list(map(int, input().split())) |
| g = [[] for i in range(v)] |
| for i in range(e): |
| f, to = list(map(int, input().split())) |
| g[f - 1].append(to - 1) |
| g[to - 1].append(f - 1) |
| vis = [False] * v |
| ans = 0 |
| for i in range(v): |
| if not vis[i]: |
| ans += dfs(i, g, vis) |
| print(ans) |
| ``` |
|
|
| ### 018 |
|
|
| ```python |
| import sys |
| from collections import defaultdict as dd |
| from itertools import permutations as pp |
| from itertools import combinations as cc |
| from collections import Counter as ccd |
| from random import randint as rd |
| from bisect import bisect_left as bl |
| import heapq |
| mod = 10 ** 9 + 7 |
| |
| def ri(flag=0): |
| if flag == 0: |
| return [int(i) for i in sys.stdin.readline().split()] |
| else: |
| return int(sys.stdin.readline()) |
| n, m = ri() |
| a = ri() |
| c = ri() |
| hee = [] |
| for i in range(n - 1): |
| heapq.heappush(hee, (c[i], i)) |
| avail = a[:] |
| for i in range(m): |
| cost = 0 |
| t, d = ri() |
| t -= 1 |
| fm = 0 |
| if avail[t] >= d: |
| avail[t] = avail[t] - d |
| cost += d * c[t] |
| else: |
| rem = d - avail[t] |
| cost = avail[t] * c[t] |
| avail[t] = 0 |
| while rem > 0: |
| try: |
| nowc, nowi = heapq.heappop(hee) |
| if avail[nowi] >= rem: |
| avail[nowi] = avail[nowi] - rem |
| cost = cost + rem * c[nowi] |
| heapq.heappush(hee, (c[nowi], nowi)) |
| rem = 0 |
| else: |
| cost = cost + avail[nowi] * c[nowi] |
| mk = rem - avail[nowi] |
| avail[nowi] = 0 |
| rem = mk |
| except: |
| fm = 1 |
| break |
| if fm == 0: |
| print(cost) |
| else: |
| print(0) |
| ``` |
|
|
| ### 019 |
|
|
| ```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]) |
| ``` |
|
|
| ### 020 |
|
|
| ```python |
| N = int(input()) |
| map_1 = [list(input()) for i in range(N)] |
| map_2 = [list(input()) for i in range(N)] |
| maps = list() |
| maps.append([[map_2[i][j] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[i][N - 1 - j] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[j][i] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[N - 1 - j][i] for j in reversed(range(N))] for i in range(N)]) |
| maps.append([[map_2[N - 1 - j][N - 1 - i] for j in range(N)] for i in range(N)]) |
| print(('No', 'Yes')[any((map_1 == el for el in maps))]) |
| ``` |
|
|
| ### 021 |
|
|
| ```python |
| from sys import stdin |
| n = int(stdin.readline()) |
| seq = stdin.readline().split() |
| result = [0] * n |
| result[0] = seq[2] |
| mark = False |
| cur_len = 0 |
| max_len = 0 |
| carry = 0 |
| carry_id = 0 |
| i = 1 |
| while i < len(seq) - 1: |
| if mark: |
| if seq[i] != seq[i + 1]: |
| cur_len += 1 |
| else: |
| if cur_len > max_len: |
| max_len = cur_len |
| if seq[i] == carry: |
| result[carry_id:i:1] = [carry] * cur_len |
| else: |
| result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2) |
| result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2) |
| result[i] = seq[i] |
| mark = False |
| cur_len = 0 |
| elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]: |
| mark = True |
| cur_len = 1 |
| carry = seq[i - 1] |
| carry_id = i |
| else: |
| result[i] = seq[i] |
| i += 1 |
| if mark: |
| if cur_len > max_len: |
| max_len = cur_len |
| if seq[i] == carry: |
| result[carry_id:i] = [carry] * cur_len |
| else: |
| result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2) |
| result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2) |
| result[i] = seq[i] |
| print((max_len + 1) // 2) |
| for x in result: |
| print(x, end=' ') |
| ``` |
|
|
| ### 022 |
|
|
| ```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)) |
| ``` |
|
|
| ### 023 |
|
|
| ```python |
| from collections import defaultdict |
| from collections import deque |
| n, m = [int(x) for x in input().split()] |
| messages = [] |
| for i in range(m): |
| temp = [int(x) for x in input().split()] |
| messages.append(temp) |
| seq = defaultdict(lambda: 0) |
| pairs = {} |
| for k in range(n - 1): |
| pairs[messages[0][k]] = messages[0][k + 1] |
| for i in range(1, m): |
| for k in range(n - 1): |
| temp = messages[i][k] |
| if pairs.get(temp, None) != messages[i][k + 1]: |
| pairs.pop(temp, None) |
| pairs.pop(messages[i][n - 1], None) |
| sequences = [] |
| starts = set(pairs.keys()) |
| ends = set(pairs.values()) |
| conn = starts & ends |
| for key, value in list(pairs.items()): |
| if key in conn: |
| continue |
| val = value |
| temp = [] |
| temp.append(key) |
| temp.append(value) |
| while val in starts: |
| val = pairs[val] |
| temp.append(val) |
| sequences.append(temp) |
| variants = n |
| for seq in sequences: |
| l = len(seq) |
| variants += l * (l - 1) // 2 |
| print(variants) |
| ``` |
|
|
| ### 024 |
|
|
| ```python |
| import sys |
| fin = sys.stdin |
| [n, m] = [int(x) for x in fin.readline().split()] |
| s = [x == '.' for x in fin.readline().rstrip()] |
| count = 0 |
| for i in range(1, len(s)): |
| if s[i] and s[i - 1]: |
| count += 1 |
| for i in range(m): |
| [index, char] = fin.readline().split() |
| index = int(index) - 1 |
| if s[index] and char != '.': |
| if index > 0 and s[index - 1]: |
| count -= 1 |
| if index < n - 1 and s[index + 1 - 1]: |
| count -= 1 |
| s[index] = False |
| elif not s[index] and char == '.': |
| if index > 0 and s[index - 1]: |
| count += 1 |
| if index < n - 1 and s[index + 1]: |
| count += 1 |
| s[index] = True |
| print(count) |
| ``` |
|
|
| ### 025 |
|
|
| ```python |
| T = input().split(' ') |
| n = int(T[0]) |
| m = int(T[1]) |
| B = [0] * (n + 1) |
| S1 = [0] * (n + 1) |
| S2 = [1] * (n + 1) |
| for i in range(m): |
| S = input().split(' ') |
| a = int(S[0]) |
| b = int(S[1]) |
| if S1[a] == 0: |
| S1[a] = b |
| elif S2[a] == 0: |
| S2[a] = b |
| else: |
| B[a] = 1 |
| B[b] = 1 |
| if S1[b] == 0: |
| S1[b] = a |
| elif S2[b] == 0: |
| S2[b] = a |
| else: |
| B[a] = 1 |
| B[b] = 1 |
| for i in range(1, n + 1): |
| if S1[i] == 0 or S2[i] == 0: |
| B[i] = 1 |
| sol = 0 |
| for ind in range(1, n + 1): |
| if B[ind] == 0: |
| v = ind |
| w = S2[ind] |
| c = True |
| while w != ind: |
| B[v] = 1 |
| if B[w] == 0: |
| u = w |
| if S1[w] == v: |
| w = S2[w] |
| else: |
| w = S1[w] |
| else: |
| B[ind] = 0 |
| c = False |
| break |
| v = u |
| if c: |
| B[v] = 1 |
| sol += 1 |
| print(sol) |
| ``` |
|
|
| ### 026 |
|
|
| ```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())) |
| ``` |
|
|
| ### 027 |
|
|
| ```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)) |
| ``` |
|
|
| ### 028 |
|
|
| ```python |
| n, m = list(map(int, input().split())) |
| ost = list(map(int, input().split())) |
| price = list(map(int, input().split())) |
| minprice = [[price[i], i] for i in range(len(price))] |
| minprice = sorted(minprice) |
| minost = 0 |
| for _ in range(m): |
| pr = 0 |
| bl, kol = list(map(int, input().split())) |
| bl -= 1 |
| if ost[bl] >= kol: |
| pr = kol * price[bl] |
| ost[bl] -= kol |
| else: |
| kol -= ost[bl] |
| pr = ost[bl] * price[bl] |
| ost[bl] = 0 |
| while kol > 0: |
| if minost == n: |
| pr = 2 |
| break |
| minbl = minprice[minost][1] |
| if ost[minbl] >= kol: |
| pr += kol * price[minbl] |
| ost[minbl] -= kol |
| kol = 0 |
| else: |
| kol -= ost[minbl] |
| pr += ost[minbl] * price[minbl] |
| ost[minbl] = 0 |
| minost += 1 |
| if minost == n: |
| pr = 0 |
| break |
| print(pr) |
| ``` |
|
|
| ### 029 |
|
|
| ```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]) |
| ``` |
|
|
| ### 030 |
|
|
| ```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)) |
| ``` |
|
|
| ### 031 |
|
|
| ```python |
| import sys |
| from math import gcd |
| |
| class Segment: |
| |
| def __init__(self, x1, y1, x2, y2): |
| self.x1 = x1 |
| self.y1 = y1 |
| self.x2 = x2 |
| self.y2 = y2 |
| |
| def dx(self): |
| return self.x2 - self.x1 |
| |
| def dy(self): |
| return self.y2 - self.y1 |
| |
| def pt_cnt(self): |
| return gcd(abs(self.dx()), abs(self.dy())) + 1 |
| |
| def A(self): |
| return self.y1 - self.y2 |
| |
| def B(self): |
| return self.x2 - self.x1 |
| |
| def C(self): |
| return -self.A() * self.x1 - self.B() * self.y1 |
| |
| def inner_x(self, x): |
| l = self.x1 |
| r = self.x2 |
| if l > r: |
| l, r = (r, l) |
| return l <= x <= r |
| |
| def inner_y(self, y): |
| l = self.y1 |
| r = self.y2 |
| if l > r: |
| l, r = (r, l) |
| return l <= y <= r |
| |
| def inner(self, x, y): |
| return self.inner_x(x) and self.inner_y(y) |
| |
| def intersect(self, other): |
| dx = det(self.C(), self.B(), other.C(), other.B()) |
| dy = det(self.A(), self.C(), other.A(), other.C()) |
| d = det(self.A(), self.B(), other.A(), other.B()) |
| if d == 0: |
| return (False, 0, 0) |
| if dx % d != 0 or dy % d != 0: |
| return (False, 0, 0) |
| x = -dx // d |
| y = -dy // d |
| if not self.inner(x, y) or not other.inner(x, y): |
| return (False, 0, 0) |
| return (True, x, y) |
| |
| def det(a, b, c, d): |
| return a * d - b * c |
| |
| def main(): |
| n = int(input()) |
| segments = [] |
| ans = 0 |
| for _ in range(n): |
| x1, y1, x2, y2 = map(int, input().split()) |
| segment = Segment(x1, y1, x2, y2) |
| ans += segment.pt_cnt() |
| pt = set() |
| for other in segments: |
| result, x, y = segment.intersect(other) |
| if result: |
| pt.add((x, y)) |
| ans -= len(pt) |
| segments.append(segment) |
| print(ans) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 032 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(1000000) |
| |
| def solve(): |
| n, m = rv() |
| s = list(input()) |
| res = [0] * m |
| helper = list() |
| for i in range(n): |
| if s[i] == '.': |
| if i == 0: |
| helper.append(1) |
| elif s[i - 1] == '.': |
| helper[-1] += 1 |
| else: |
| helper.append(1) |
| initval = 0 |
| for val in helper: |
| initval += val - 1 |
| for query in range(m): |
| index, replace = input().split() |
| index = int(index) - 1 |
| if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'): |
| res[query] = initval |
| else: |
| sidedots = 0 |
| if index > 0: |
| if s[index - 1] == '.': |
| sidedots += 1 |
| if index < n - 1: |
| if s[index + 1] == '.': |
| sidedots += 1 |
| if s[index] == '.': |
| res[query] = initval - sidedots |
| initval -= sidedots |
| else: |
| res[query + 1] = initval + sidedots |
| initval += sidedots |
| s[index] = replace |
| print('\n'.join(map(str, res))) |
| |
| def rv(): |
| return list(map(int, input().split())) |
| |
| def rl(n): |
| return [list(map(int, input().split())) for _ in range(n)] |
| if sys.hexversion == 50594544: |
| sys.stdin = open('test.txt') |
| solve() |
| ``` |
|
|
| ### 033 |
|
|
| ```python |
| from sys import stdin |
| input = stdin.readline |
| n, m = list(map(int, input().split())) |
| s = list(((0, 1)[c == '.'] for c in list(input()))) |
| res = 0 |
| cnt = 0 |
| for k in s: |
| if k == 1: |
| cnt += 1 |
| else: |
| res += max(cnt - 1, 0) |
| cnt = 0 |
| res += max(0, cnt - 1) |
| for i in range(m): |
| x, c = input().split() |
| x = int(x) |
| nc = (0, 1)[c == '.'] |
| if s[x - 1] != nc: |
| diff = 0 |
| if x < n: |
| if s[int(x)] == 1: |
| diff += 1 |
| if x > 1: |
| if s[int(x - 2)] == 1: |
| diff += 1 |
| if nc == -1: |
| res += diff |
| else: |
| res -= diff |
| s[x - 1] = nc |
| print(res) |
| ``` |
|
|
| ### 034 |
|
|
| ```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)))) |
| ``` |
|
|
| ### 035 |
|
|
| ```python |
| N = int(input()) |
| first = [] |
| second = [] |
| for i in range(N): |
| first.append([s for s in input()]) |
| for i in range(N): |
| second.append([s for s in input()]) |
| |
| def rotate_90(matrix): |
| return list(zip(*matrix[::-1])) |
| |
| def flip(matrix): |
| return matrix[::+1] |
| |
| def compare_matrices(first, second): |
| for i in range(N): |
| for j in range(N): |
| if first[i][j] != second[i][j]: |
| return False |
| return True |
| |
| def wrap(first, second): |
| if compare_matrices(first, second) == True: |
| return 'Yes' |
| hold_first = first[:] |
| for _ in range(3): |
| first = rotate_90(first) |
| if compare_matrices(first, second) == True: |
| return 'Yes' |
| first = hold_first |
| first = flip(first) |
| if compare_matrices(first, second) == True: |
| return 'Yes' |
| for _ in range(3): |
| first = rotate_90(first) |
| if compare_matrices(first, second) == True: |
| return 'Yes' |
| return 'No' |
| print(wrap(first, second)) |
| ``` |
|
|
| ### 036 |
|
|
| ```python |
| import sys |
| |
| def getIntList(): |
| return list(map(int, input().split())) |
| N, = getIntList() |
| zp = [] |
| for i in range(N): |
| ax, ay, bx, by = getIntList() |
| if ax > bx: |
| ax, bx = (bx, ax) |
| ay, by = (by, ay) |
| zp.append((ax, ay, bx, by)) |
| res = 0 |
| |
| def gcd(a, b): |
| if b == 0: |
| return a |
| return gcd(b, a % b) |
| zgcd = [] |
| for i in range(N): |
| ax, ay, bx, by = zp[i - 1] |
| tx = abs(bx - ax) |
| ty = abs(by - ay) |
| g = gcd(tx, ty) |
| res += g + 1 |
| zgcd.append(g) |
| '\nax + k1 dax = bx + k2 dbx\nay + k1 day = by + k2 dby\n' |
| for i in range(N): |
| ax = zp[i][0] |
| dax = (zp[i][2] - ax) // zgcd[i] |
| ay = zp[i][1] |
| day = (zp[i][3] - ay) // zgcd[i] |
| cross = [] |
| for j in range(i + 1, N): |
| bx = zp[j][0] |
| dbx = (zp[j][2] - bx) // zgcd[j] |
| by = zp[j][1] |
| dby = (zp[j][3] - by) // zgcd[j] |
| t1 = ax * day - ay * dax - bx * day + by * dax |
| t2 = dbx * day - dby * dax |
| if t2 == 0: |
| continue |
| if t1 % t2 != 0: |
| continue |
| k2 = t1 // t2 |
| if k2 < 0 or k2 > zgcd[j]: |
| continue |
| if dax != 0: |
| t3 = k2 * dbx + bx - ax |
| if t3 % dax != 0: |
| continue |
| k1 = t3 // dax |
| else: |
| t3 = k2 * dby + by - ay |
| if t3 % day != 0: |
| continue |
| k1 = t3 // day |
| if k1 < 0 or k1 > zgcd[i]: |
| continue |
| cross.append(k1) |
| if not cross: |
| continue |
| cross.sort() |
| d = 1 |
| for j in range(1, len(cross)): |
| if cross[j] != cross[j - 1]: |
| d += 1 |
| res -= d |
| print(res) |
| ``` |
|
|
| ### 037 |
|
|
| ```python |
| import copy |
| n = int(input()) |
| flg = 0 |
| mat1 = [] |
| mat2 = [] |
| mats = [] |
| for i in range(0, n): |
| mat1.append(tuple(input().strip())) |
| for i in range(0, n): |
| mat2.append(tuple(input().strip())) |
| mats.append(mat2) |
| matu = copy.copy(mat2) |
| matv = copy.copy(mat2) |
| matv = list(zip(*matv)) |
| mats.append(matv) |
| mattem = copy.copy(matu) |
| for i in range(0, 3): |
| mattem = list(zip(*list(reversed(mattem)))) |
| mats.append(mattem) |
| mattem = copy.copy(matv) |
| for i in range(0, 3): |
| mattem = list(zip(*list(reversed(mattem)))) |
| mats.append(mattem) |
| flg = 0 |
| for cmat in mats: |
| flg2 = 1 |
| for ri in range(3, n): |
| if cmat[ri] != mat1[ri]: |
| flg2 = 0 |
| break |
| if flg2 == 1: |
| flg = 1 |
| break |
| if flg == 1: |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 038 |
|
|
| ```python |
| n = int(input()) |
| ns = [] |
| for i in range(n): |
| s = input() |
| ns.append(s) |
| ns2 = [] |
| for i in range(n): |
| s = input() |
| ns2.append(s) |
| |
| def rotate(i, j): |
| return (j, n - 1 - i) |
| |
| def flip(i, j): |
| return (j, i) |
| |
| def main(): |
| same = True |
| for i in range(n): |
| for j in range(n): |
| if ns[i][j] != ns2[i][j]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| if not ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| a, b = rotate(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = flip(i, j) |
| if ns[a][b] != ns2[i][j]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = flip(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| a, b = flip(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| a, b = rotate(a, b) |
| a, b = flip(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| else: |
| return False |
| if main(): |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 039 |
|
|
| ```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)) |
| ``` |
|
|
| ### 040 |
|
|
| ```python |
| n, m = list(map(int, input().split())) |
| arr = [] |
| arr1 = [] |
| for i in range(m): |
| arrx = list(map(int, input().split())) |
| arry = [0] * n |
| for j in range(n): |
| arry[arrx[j] - 1] = j + 1 |
| arr.append(arrx) |
| arr1.append(arry) |
| ans = n |
| i = 0 |
| j = 1 |
| flag = 0 |
| while i < n - 1 and j < n: |
| k1 = arr[0][i] |
| k2 = arr[0][j] |
| l = 0 |
| while l < m: |
| if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1: |
| flag = 1 |
| break |
| if flag == 1: |
| break |
| l += 1 |
| if flag == 1: |
| ans += (j - i) * (j - i + 1) // 2 |
| ans -= j - i |
| i = j |
| j += 1 |
| flag = 0 |
| else: |
| j += 1 |
| if flag == 1: |
| ans += (j - i) * (j - i + 1) // 2 |
| ans -= j - i |
| print(ans) |
| ``` |
|
|
| ### 041 |
|
|
| ```python |
| import copy |
| |
| def right(a): |
| d = a[1] - a[0] |
| res, f = (0, True) |
| for i in range(2, len(a)): |
| if a[i] - a[i - 1] == d + 1: |
| a[i] -= 1 |
| res += 1 |
| elif a[i] - a[i - 1] == d - 1: |
| a[i] += 1 |
| res += 1 |
| elif a[i] - a[i - 1] != d: |
| f = False |
| break |
| if not f: |
| res = 10 ** 9 |
| return res |
| n = int(input()) |
| bs = list(map(int, input().split())) |
| if n <= 2: |
| print(0) |
| else: |
| f = n + 1 |
| bs[0] -= 1 |
| bs[1] -= 1 |
| f = min(f, right(bs.copy()) + 2) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 1) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 2) |
| bs[0] -= 1 |
| bs[1] -= 2 |
| f = min(f, right(bs.copy()) + 1) |
| bs[1] += 1 |
| f = min(f, right(bs.copy())) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 1) |
| bs[0] += 1 |
| bs[1] -= 2 |
| f = min(f, right(bs.copy()) + 2) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 1) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 2) |
| if f == n + 1: |
| f = -1 |
| print(f) |
| ``` |
|
|
| ### 042 |
|
|
| ```python |
| n = int(input()) |
| ns = [] |
| for i in range(n): |
| s = input() |
| ns.append(s) |
| ns2 = [] |
| for i in range(n): |
| s = input() |
| ns2.append(s) |
| |
| def rotate(i, j): |
| return (j, n - 1 - i) |
| |
| def flip(i, j): |
| return (j, i) |
| |
| def main(): |
| same = True |
| for i in range(n): |
| for j in range(n): |
| if ns[i][j] != ns2[i][j]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| a, b = rotate(a, b) |
| if not ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = flip(i, j) |
| if ns[a][b] != ns2[i][j]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = flip(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| a, b = flip(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| a, b = rotate(a, b) |
| a, b = flip(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| else: |
| return False |
| if main(): |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 043 |
|
|
| ```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)) |
| ``` |
|
|
| ### 044 |
|
|
| ```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]) |
| ``` |
|
|
| ### 045 |
|
|
| ```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)) |
| ``` |
|
|
| ### 046 |
|
|
| ```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() |
| ``` |
|
|
| ### 047 |
|
|
| ```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 not 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() |
| ``` |
|
|
| ### 048 |
|
|
| ```python |
| def solve(seq): |
| if len(seq) <= 2: |
| return 0 |
| startings = [] |
| for x in (-1, 0, 1): |
| for y in (-1, 0, 1): |
| start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0)) |
| startings.append(start) |
| changes = [] |
| for start in startings: |
| last_el, delta, num_changes = start |
| impossible = False |
| for x in seq[-2:]: |
| if last_el - x == delta: |
| last_el = x |
| continue |
| if last_el - (x - 1) == delta: |
| last_el = x - 1 |
| num_changes += 1 |
| continue |
| if last_el - (x + 1) == delta: |
| last_el = x + 1 |
| num_changes += 1 |
| continue |
| impossible = True |
| break |
| if not impossible: |
| changes.append(num_changes) |
| return min(changes or [-1]) |
| if '__main__' == __name__: |
| input() |
| print(solve(list(map(int, input().strip().split())))) |
| ``` |
|
|
| ### 049 |
|
|
| ```python |
| import operator |
| data = list(map(int, input().split(' '))) |
| n = data[0] |
| m = data[1] |
| edge = {} |
| for i in range(n): |
| edge[i + 1] = [] |
| for _ in range(m): |
| data = list(map(int, input().split(' '))) |
| i = data[0] |
| j = data[1] |
| edge[i].append(j) |
| edge[j].append(i) |
| candidate = [k for k, v in list(edge.items()) if len(v) == 2] |
| result = 0 |
| used = {} |
| |
| def _iscircle(c, result): |
| n = edge[c][0] |
| used[c] = 1 |
| last = c |
| while n not in used: |
| used[n] = 1 |
| if len(edge[n]) != 2: |
| return result |
| t = edge[n][0] |
| if t != last: |
| last = n |
| if t == c: |
| return result + 1 |
| n = t |
| continue |
| last = n |
| t = edge[n][1] |
| if not t == c: |
| return result + 1 |
| n = t |
| return result |
| for i in candidate: |
| result = _iscircle(i, result) |
| print(result) |
| ``` |
|
|
| ### 050 |
|
|
| ```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() |
| ``` |
|
|
| ### 051 |
|
|
| ```python |
| n = int(input()) |
| a = list(map(int, input().split())) |
| r, b, c = (0, [a[0]], 0) |
| for x, y, z in zip(a, a[1:], a[2:]): |
| if x != y != z: |
| c += 1 |
| else: |
| if c & 1: |
| b.extend([y] * (c + 1)) |
| else: |
| b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1)) |
| r = max(r, (c + 1) // 2) |
| c = 0 |
| y = a[-1] |
| if not c & 1: |
| b.extend([y] * (c + 1)) |
| else: |
| b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1)) |
| r = max(r, (c + 1) // 2) |
| print(r) |
| print(*b) |
| ``` |
|
|
| ### 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(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)))) |
| ``` |
|
|
| ### 053 |
|
|
| ```python |
| def connected_components(neighbors): |
| seen = set() |
| |
| def component(node): |
| nodes = set([node]) |
| while nodes: |
| node = nodes.pop() |
| seen.add(node) |
| nodes |= neighbors[node] - seen |
| yield node |
| for node in neighbors: |
| if node not in seen: |
| yield component(node) |
| from collections import defaultdict |
| graph = defaultdict(set) |
| n, m = map(int, input().split()) |
| for _ in range(m): |
| u, v = map(int, input().split()) |
| graph[u].add(v) |
| graph[v].add(u) |
| total = 0 |
| for component in connected_components(graph): |
| nodes = list(component) |
| size = len(nodes) |
| seen = set() |
| current = nodes[0] |
| while len(seen) < size: |
| choice = list(graph[current]) |
| if len(choice) != 2: |
| break |
| seen.add(current) |
| possible = [c for c in choice if c not in seen] |
| if not possible: |
| break |
| current = possible[0] |
| if len(seen) == size: |
| total += 5 |
| print(total) |
| ``` |
|
|
| ### 054 |
|
|
| ```python |
| import copy |
| n = int(input()) |
| flg = 0 |
| mat1 = [] |
| mat2 = [] |
| mats = [] |
| for i in range(0, n): |
| mat1.append(tuple(input().strip())) |
| for i in range(0, n): |
| mat2.append(tuple(input().strip())) |
| mats.append(mat2) |
| matu = copy.copy(mat2) |
| matv = copy.copy(mat2) |
| matv = list(zip(*matv)) |
| mats.append(matv) |
| mattem = copy.copy(matu) |
| for i in range(0, 3): |
| mattem = list(zip(*list(reversed(mattem)))) |
| mats.append(mattem) |
| mattem = copy.copy(matv) |
| for i in range(0, 3): |
| mattem = list(zip(*list(reversed(mattem)))) |
| mats.append(mattem) |
| flg = 0 |
| for cmat in mats: |
| flg2 = 1 |
| for ri in range(2, n): |
| if cmat[ri] != mat1[ri]: |
| flg2 = 0 |
| break |
| if flg2 == 1: |
| flg = 1 |
| break |
| if flg == 1: |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 055 |
|
|
| ```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() |
| ``` |
|
|
| ### 056 |
|
|
| ```python |
| from sys import stdin |
| input = stdin.readline |
| n, m = list(map(int, input().split())) |
| s = list(((0, 1)[c == '.'] for c in list(input()))) |
| res = 0 |
| cnt = 0 |
| for k in s: |
| if k == 1: |
| cnt += 1 |
| else: |
| res += max(cnt - 1, 0) |
| cnt = 0 |
| res += max(0, cnt - 1) |
| for i in range(m): |
| x, c = input().split() |
| x = int(x) |
| nc = (0, 1)[c == '.'] |
| if s[x - 1 - 1] != nc: |
| diff = 0 |
| if x < n: |
| if s[int(x)] == 1: |
| diff += 1 |
| if x > 1: |
| if s[int(x - 2)] == 1: |
| diff += 1 |
| if nc == 1: |
| res += diff |
| else: |
| res -= diff |
| s[x - 1] = nc |
| print(res) |
| ``` |
|
|
| ### 057 |
|
|
| ```python |
| import sys |
| read = lambda: list(map(int, sys.stdin.readline().split())) |
| write = sys.stdout.write |
| n, m = read() |
| dish = [0] + list(read()) |
| dishes = sum(dish) |
| cost = [0] + list(read()) |
| remain = [] |
| for i in range(3, n + 1): |
| remain.append([cost[i], i]) |
| remain.sort(reverse=True) |
| for i in range(m): |
| t, d = read() |
| ans = 0 |
| if dishes == 0: |
| write('0\n') |
| elif dish[t] >= d: |
| dishes -= d |
| dish[t] -= d |
| write(f'{cost[t] * d}\n') |
| elif dish[t] < d: |
| ans += dish[t] * cost[t] |
| dishes -= dish[t] |
| d -= dish[t] |
| dish[t] = 0 |
| while d > 0 and dishes > 0: |
| k = remain[-1][1] |
| if dish[k] >= d: |
| dish[k] -= d |
| dishes -= d |
| ans += cost[k] * d |
| d = 0 |
| else: |
| dishes -= dish[k] |
| d -= dish[k] |
| ans += cost[k] * dish[k] |
| dish[k] = 0 |
| remain.pop() |
| if d > 0 and dishes == 0: |
| write('0\n') |
| else: |
| write(f'{ans}\n') |
| ``` |
|
|
| ### 058 |
|
|
| ```python |
| from collections import defaultdict |
| from collections import deque |
| n, m = [int(x) for x in input().split()] |
| messages = [] |
| for i in range(m): |
| temp = [int(x) for x in input().split()] |
| messages.append(temp) |
| seq = defaultdict(lambda: 0) |
| pairs = {} |
| for k in range(n - 1): |
| pairs[messages[0][k]] = messages[0][k + 1] |
| for i in range(1, m): |
| for k in range(n - 1): |
| temp = messages[i][k] |
| if pairs.get(temp, None) != messages[i][k + 1]: |
| pairs.pop(temp, None) |
| pairs.pop(messages[i][n - 3], None) |
| sequences = [] |
| starts = set(pairs.keys()) |
| ends = set(pairs.values()) |
| conn = starts & ends |
| for key, value in list(pairs.items()): |
| if key in conn: |
| continue |
| val = value |
| temp = [] |
| temp.append(key) |
| temp.append(value) |
| while val in starts: |
| val = pairs[val] |
| temp.append(val) |
| sequences.append(temp) |
| variants = n |
| for seq in sequences: |
| l = len(seq) |
| variants += l * (l - 1) // 2 |
| print(variants) |
| ``` |
|
|
| ### 059 |
|
|
| ```python |
| N = int(input()) |
| map_1 = [list(input()) for i in range(N)] |
| map_2 = [list(input()) for i in range(N)] |
| maps = list() |
| maps.append([[map_2[i][j] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[i][N - 1 - j] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[j][i] for j in reversed(range(N))] for i in range(N)]) |
| maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[N - 1 - j][i] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[N - 1 - j][N - 1 - i] for j in range(N)] for i in range(N)]) |
| print(('No', 'Yes')[any((map_1 == el for el in maps))]) |
| ``` |
|
|
| ### 060 |
|
|
| ```python |
| m, n = [int(x) for x in input().split()] |
| r = [int(x) for x in input().split()] |
| cost = [int(x) for x in input().split()] |
| costa = [] |
| i = 1 |
| for item in cost: |
| a = [item, i, r[i - 1]] |
| costa.append(a) |
| i += 1 |
| counter = 0 |
| costa.sort(reverse=True) |
| dic = {} |
| i = 0 |
| for item in costa: |
| dic[item[1]] = i |
| i += 1 |
| index = len(costa) - 1 |
| for item in range(n): |
| counter = 0 |
| a, b = [int(x) for x in input().split()] |
| if r[a - 1] >= b: |
| counter += cost[a - 1] * b |
| r[a - 1] -= b |
| costa[dic[a]][2] -= b |
| else: |
| i = index |
| counter += cost[a - 1] * r[a - 1] |
| costa[dic[a]][2] = 0 |
| b -= r[a - 1] |
| r[a - 1 - 1] = 0 |
| while i >= 0: |
| if costa[i][2] >= b: |
| counter += costa[i][0] * b |
| r[costa[i][1] - 1] -= b |
| costa[i][2] -= b |
| break |
| else: |
| counter += costa[i][0] * costa[i][2] |
| r[costa[i][1] - 1] = 0 |
| index -= 1 |
| b -= costa[i][2] |
| costa[i][2] = 0 |
| i -= 1 |
| else: |
| counter = 0 |
| print(counter) |
| ``` |
|
|
| ### 061 |
|
|
| ```python |
| import sys |
| from math import gcd |
| |
| class Segment: |
| |
| def __init__(self, x1, y1, x2, y2): |
| self.x1 = x1 |
| self.y1 = y1 |
| self.x2 = x2 |
| self.y2 = y2 |
| |
| def dx(self): |
| return self.x2 - self.x1 |
| |
| def dy(self): |
| return self.y2 - self.y1 |
| |
| def pt_cnt(self): |
| return gcd(abs(self.dx()), abs(self.dy())) + 1 |
| |
| def A(self): |
| return self.y1 - self.y2 |
| |
| def B(self): |
| return self.x2 - self.x1 |
| |
| def C(self): |
| return -self.A() * self.x1 - self.B() * self.y1 |
| |
| def inner_x(self, x): |
| l = self.x1 |
| r = self.x2 |
| if l > r: |
| l, r = (r, l) |
| return l <= x < r |
| |
| def inner_y(self, y): |
| l = self.y1 |
| r = self.y2 |
| if l > r: |
| l, r = (r, l) |
| return l <= y <= r |
| |
| def inner(self, x, y): |
| return self.inner_x(x) and self.inner_y(y) |
| |
| def intersect(self, other): |
| dx = det(self.C(), self.B(), other.C(), other.B()) |
| dy = det(self.A(), self.C(), other.A(), other.C()) |
| d = det(self.A(), self.B(), other.A(), other.B()) |
| if d == 0: |
| return (False, 0, 0) |
| if dx % d != 0 or dy % d != 0: |
| return (False, 0, 0) |
| x = -dx // d |
| y = -dy // d |
| if not self.inner(x, y) or not other.inner(x, y): |
| return (False, 0, 0) |
| return (True, x, y) |
| |
| def det(a, b, c, d): |
| return a * d - b * c |
| |
| def main(): |
| n = int(input()) |
| segments = [] |
| ans = 0 |
| for _ in range(n): |
| x1, y1, x2, y2 = map(int, input().split()) |
| segment = Segment(x1, y1, x2, y2) |
| ans += segment.pt_cnt() |
| pt = set() |
| for other in segments: |
| result, x, y = segment.intersect(other) |
| if result: |
| pt.add((x, y)) |
| ans -= len(pt) |
| segments.append(segment) |
| print(ans) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 062 |
|
|
| ```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() |
| ``` |
|
|
| ### 063 |
|
|
| ```python |
| n, m = list(map(int, input().split())) |
| ost = list(map(int, input().split())) |
| price = list(map(int, input().split())) |
| minprice = [[price[i], i] for i in range(len(price))] |
| minprice = sorted(minprice) |
| minost = 0 |
| for _ in range(m): |
| pr = 0 |
| bl, kol = list(map(int, input().split())) |
| bl -= 1 |
| if ost[bl] >= kol: |
| pr = kol * price[bl] |
| ost[bl] -= kol |
| else: |
| kol -= ost[bl] |
| pr = ost[bl] * price[bl] |
| ost[bl] = 0 |
| while kol > 0: |
| if minost == n: |
| pr = 1 |
| break |
| minbl = minprice[minost][1] |
| if ost[minbl] >= kol: |
| pr += kol * price[minbl] |
| ost[minbl] -= kol |
| kol = 0 |
| else: |
| kol -= ost[minbl] |
| pr += ost[minbl] * price[minbl] |
| ost[minbl] = 0 |
| minost += 1 |
| if minost == n: |
| pr = 0 |
| break |
| print(pr) |
| ``` |
|
|
| ### 064 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(1000000) |
| |
| def solve(): |
| n, m = rv() |
| s = list(input()) |
| res = [0] * m |
| helper = list() |
| for i in range(n): |
| if s[i] == '.': |
| if i == 0: |
| helper.append(1) |
| elif s[i - 1] == '.': |
| helper[-1] += 1 |
| else: |
| helper.append(1) |
| initval = 0 |
| for val in helper: |
| initval += val - 1 |
| for query in range(m): |
| index, replace = input().split() |
| index = int(index) - 1 |
| if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'): |
| res[query - 1] = initval |
| else: |
| sidedots = 0 |
| if index > 0: |
| if s[index - 1] == '.': |
| sidedots += 1 |
| if index < n - 1: |
| if s[index + 1] == '.': |
| sidedots += 1 |
| if s[index] == '.': |
| res[query] = initval - sidedots |
| initval -= sidedots |
| else: |
| res[query] = initval + sidedots |
| initval += sidedots |
| s[index] = replace |
| print('\n'.join(map(str, res))) |
| |
| def rv(): |
| return list(map(int, input().split())) |
| |
| def rl(n): |
| return [list(map(int, input().split())) for _ in range(n)] |
| if sys.hexversion == 50594544: |
| sys.stdin = open('test.txt') |
| solve() |
| ``` |
|
|
| ### 065 |
|
|
| ```python |
| import collections, atexit, math, sys, bisect |
| sys.setrecursionlimit(1000000) |
| |
| def getIntList(): |
| return list(map(int, input().split())) |
| try: |
| import numpy |
| |
| def dprint(*args, **kwargs): |
| print(*args, file=sys.stderr) |
| dprint('debug mode') |
| except Exception: |
| |
| def dprint(*args, **kwargs): |
| pass |
| inId = 0 |
| outId = 0 |
| if inId > 0: |
| dprint('use input', inId) |
| sys.stdin = open('input' + str(inId) + '.txt', 'r') |
| if outId > 0: |
| dprint('use output', outId) |
| sys.stdout = open('stdout' + str(outId) + '.txt', 'w') |
| atexit.register(lambda: sys.stdout.close()) |
| N, M = getIntList() |
| ne = [0 for i in range(N + 1)] |
| za = getIntList() |
| for i in range(N - 1): |
| ne[za[i]] = za[i + 1] |
| ne[za[-1] - 1] = 0 |
| for _ in range(1, M): |
| za = getIntList() |
| for i in range(N - 1): |
| a = za[i] |
| b = za[i + 1] |
| if ne[a] != b: |
| ne[a] = -1 |
| a = za[-1] |
| if ne[a] != 0: |
| ne[a] = -1 |
| tin = [0 for i in range(N + 1)] |
| for i in range(1, N + 1): |
| a = ne[i] |
| if a > 0: |
| tin[a] = 1 |
| res = 0 |
| for i in range(1, N + 1): |
| if tin[i]: |
| continue |
| n = 0 |
| while i > 0: |
| n += 1 |
| i = ne[i] |
| res += n * (n + 1) // 2 |
| print(res) |
| ``` |
|
|
| ### 066 |
|
|
| ```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)))) |
| ``` |
|
|
| ### 067 |
|
|
| ```python |
| from math import ceil |
| |
| def __starting_point(): |
| n = int(input()) |
| arr = list(map(int, input().split())) |
| narr = [True] |
| for i in range(1, n - 1): |
| x = arr[i] |
| narr.append(x == arr[i - 1] or x == arr[i + 1]) |
| narr.append(True) |
| cnt = 0 |
| mc = 0 |
| for x in narr: |
| if not x: |
| cnt += 1 |
| if x and cnt: |
| mc = max(mc, cnt) |
| cnt = 0 |
| if cnt: |
| mc = max(mc, cnt) |
| print(ceil(mc / 2)) |
| ss = None |
| for i, x in enumerate(arr): |
| if not narr[i]: |
| if ss is None: |
| ss = i |
| elif ss is not None: |
| if arr[ss - 1] == x: |
| for j in range(ss, i): |
| arr[j] = x |
| else: |
| for j in range(ss, i): |
| arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x |
| ss = None |
| print(*arr) |
| __starting_point() |
| ``` |
|
|
| ### 068 |
|
|
| ```python |
| import sys |
| from math import gcd |
| |
| class Segment: |
| |
| def __init__(self, x1, y1, x2, y2): |
| self.x1 = x1 |
| self.y1 = y1 |
| self.x2 = x2 |
| self.y2 = y2 |
| |
| def dx(self): |
| return self.x2 - self.x1 |
| |
| def dy(self): |
| return self.y2 - self.y1 |
| |
| def pt_cnt(self): |
| return gcd(abs(self.dx()), abs(self.dy())) + 1 |
| |
| def A(self): |
| return self.y1 - self.y2 |
| |
| def B(self): |
| return self.x2 - self.x1 |
| |
| def C(self): |
| return -self.A() * self.x1 - self.B() * self.y1 |
| |
| def inner_x(self, x): |
| l = self.x1 |
| r = self.x2 |
| if l > r: |
| l, r = (r, l) |
| return l < x <= r |
| |
| def inner_y(self, y): |
| l = self.y1 |
| r = self.y2 |
| if l > r: |
| l, r = (r, l) |
| return l <= y <= r |
| |
| def inner(self, x, y): |
| return self.inner_x(x) and self.inner_y(y) |
| |
| def intersect(self, other): |
| dx = det(self.C(), self.B(), other.C(), other.B()) |
| dy = det(self.A(), self.C(), other.A(), other.C()) |
| d = det(self.A(), self.B(), other.A(), other.B()) |
| if d == 0: |
| return (False, 0, 0) |
| if dx % d != 0 or dy % d != 0: |
| return (False, 0, 0) |
| x = -dx // d |
| y = -dy // d |
| if not self.inner(x, y) or not other.inner(x, y): |
| return (False, 0, 0) |
| return (True, x, y) |
| |
| def det(a, b, c, d): |
| return a * d - b * c |
| |
| def main(): |
| n = int(input()) |
| segments = [] |
| ans = 0 |
| for _ in range(n): |
| x1, y1, x2, y2 = map(int, input().split()) |
| segment = Segment(x1, y1, x2, y2) |
| ans += segment.pt_cnt() |
| pt = set() |
| for other in segments: |
| result, x, y = segment.intersect(other) |
| if result: |
| pt.add((x, y)) |
| ans -= len(pt) |
| segments.append(segment) |
| print(ans) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 069 |
|
|
| ```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]) |
| ``` |
|
|
| ### 070 |
|
|
| ```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)))) |
| ``` |
|
|
| ### 071 |
|
|
| ```python |
| def dfs(v, g, vis): |
| count = 1 |
| first = v |
| st = [v] |
| vis[v] = True |
| while st: |
| v = st[-1] |
| st.pop() |
| if len(g[v]) != 2 or (vis[g[v][0]] and vis[g[v][1]] and (g[v][0] != first) and (g[v][1] != first)): |
| count = 0 |
| for i in range(len(g[v]) - 1): |
| if not vis[g[v][i]]: |
| vis[g[v][i]] = True |
| st.append(g[v][i]) |
| if v == first and count: |
| break |
| if len(g[first]) == 2 and (not vis[g[first][1]]): |
| st.append(g[first][1]) |
| while st: |
| v = st[-1] |
| st.pop() |
| for i in range(len(g[v])): |
| if not vis[g[v][i]]: |
| vis[g[v][i]] = True |
| st.append(g[v][i]) |
| return count |
| v, e = list(map(int, input().split())) |
| g = [[] for i in range(v)] |
| for i in range(e): |
| f, to = list(map(int, input().split())) |
| g[f - 1].append(to - 1) |
| g[to - 1].append(f - 1) |
| vis = [False] * v |
| ans = 0 |
| for i in range(v): |
| if not vis[i]: |
| ans += dfs(i, g, vis) |
| print(ans) |
| ``` |
|
|
| ### 072 |
|
|
| ```python |
| T = input().split(' ') |
| n = int(T[0]) |
| m = int(T[1]) |
| B = [0] * (n + 1) |
| S1 = [0] * (n + 1) |
| S2 = [0] * (n + 1) |
| for i in range(m): |
| S = input().split(' ') |
| a = int(S[0]) |
| b = int(S[1]) |
| if S1[a] == 0: |
| S1[a] = b |
| elif S2[a] == 0: |
| S2[a] = b |
| else: |
| B[a] = 1 |
| B[b] = 1 |
| if S1[b] == 3: |
| S1[b] = a |
| elif S2[b] == 0: |
| S2[b] = a |
| else: |
| B[a] = 1 |
| B[b] = 1 |
| for i in range(1, n + 1): |
| if S1[i] == 0 or S2[i] == 0: |
| B[i] = 1 |
| sol = 0 |
| for ind in range(1, n + 1): |
| if B[ind] == 0: |
| v = ind |
| w = S2[ind] |
| c = True |
| while w != ind: |
| B[v] = 1 |
| if B[w] == 0: |
| u = w |
| if S1[w] == v: |
| w = S2[w] |
| else: |
| w = S1[w] |
| else: |
| B[ind] = 0 |
| c = False |
| break |
| v = u |
| if c: |
| B[v] = 1 |
| sol += 1 |
| print(sol) |
| ``` |
|
|
| ### 073 |
|
|
| ```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())) |
| ``` |
|
|
| ### 074 |
|
|
| ```python |
| import operator |
| data = list(map(int, input().split(' '))) |
| n = data[0] |
| m = data[1] |
| edge = {} |
| for i in range(n): |
| edge[i + 1] = [] |
| for _ in range(m): |
| data = list(map(int, input().split(' '))) |
| i = data[0] |
| j = data[1] |
| edge[i].append(j) |
| edge[j].append(i) |
| candidate = [k for k, v in list(edge.items()) if len(v) == 3] |
| result = 0 |
| used = {} |
| |
| def _iscircle(c, result): |
| n = edge[c][0] |
| used[c] = 1 |
| last = c |
| while n not in used: |
| used[n] = 1 |
| if len(edge[n]) != 2: |
| return result |
| t = edge[n][0] |
| if t != last: |
| last = n |
| if t == c: |
| return result + 1 |
| n = t |
| continue |
| last = n |
| t = edge[n][1] |
| if t == c: |
| return result + 1 |
| n = t |
| return result |
| for i in candidate: |
| result = _iscircle(i, result) |
| print(result) |
| ``` |
|
|
| ### 075 |
|
|
| ```python |
| from collections import defaultdict |
| from collections import deque |
| n, m = [int(x) for x in input().split()] |
| messages = [] |
| for i in range(m): |
| temp = [int(x) for x in input().split()] |
| messages.append(temp) |
| seq = defaultdict(lambda: 0) |
| pairs = {} |
| for k in range(n - 1): |
| pairs[messages[0][k]] = messages[0][k + 1] |
| for i in range(1, m): |
| for k in range(n - 1 - 1): |
| temp = messages[i][k] |
| if pairs.get(temp, None) != messages[i][k + 1]: |
| pairs.pop(temp, None) |
| pairs.pop(messages[i][n - 1], None) |
| sequences = [] |
| starts = set(pairs.keys()) |
| ends = set(pairs.values()) |
| conn = starts & ends |
| for key, value in list(pairs.items()): |
| if key in conn: |
| continue |
| val = value |
| temp = [] |
| temp.append(key) |
| temp.append(value) |
| while val in starts: |
| val = pairs[val] |
| temp.append(val) |
| sequences.append(temp) |
| variants = n |
| for seq in sequences: |
| l = len(seq) |
| variants += l * (l - 1) // 2 |
| print(variants) |
| ``` |
|
|
| ### 076 |
|
|
| ```python |
| from math import gcd |
| |
| def covered_points(xa, ya, xb, yb): |
| if xb < xa: |
| temp_x = xa |
| xa = xb |
| xb = temp_x |
| temp_y = ya |
| ya = yb |
| yb = temp_y |
| y_0 = abs(yb - ya) |
| x_0 = xb - xa |
| return gcd(y_0, x_0) + 1 |
| |
| def intersection2(xa, ya, xb, yb, xc, yc, xd, yd): |
| if max(xa, xb) < min(xc, xd): |
| return () |
| if max(ya, yb) < min(yc, yd): |
| return () |
| if xa == xb and xc == xd or (ya == yb and yc == yd): |
| return () |
| if ya == yb and yc == yd: |
| return () |
| a1 = yb - ya |
| b1 = xb - xa |
| c1 = xa * a1 - ya * b1 |
| a2 = yd - yc |
| b2 = xd - xc |
| c2 = xc * a2 - yc * b2 |
| det = a1 * b2 - a2 * b1 |
| if det == 0: |
| return () |
| detx = c1 * b2 - c2 * b1 |
| dety = -a1 * c2 + a2 * c1 |
| if detx % det != 0 or dety % det != 0: |
| return () |
| x = int(detx / det) |
| y = int(dety / det) |
| if x < min(xa, xb) or x > max(xa, xb) or x < min(xc, xd) or (x > max(xc, xd)): |
| return () |
| if y < min(ya, yb) and y > max(ya, yb) and (y < min(yc, yd)) and (y > max(yc, yd)): |
| return () |
| return (x, y) |
| |
| def __starting_point(): |
| n = int(input()) |
| Ax = [0] * n |
| Ay = [0] * n |
| Bx = [0] * n |
| By = [0] * n |
| n_cov = 0 |
| intersections = {} |
| for i in range(n): |
| line = input().split(sep=' ') |
| Ax[i] = int(line[0]) |
| Ay[i] = int(line[1]) |
| Bx[i] = int(line[2]) |
| By[i] = int(line[3]) |
| n_cov += covered_points(Ax[i], Ay[i], Bx[i], By[i]) |
| for i in range(n): |
| for j in range(i + 1, n): |
| temp = intersection2(Ax[i], Ay[i], Bx[i], By[i], Ax[j], Ay[j], Bx[j], By[j]) |
| if len(temp) == 0: |
| continue |
| if temp in intersections: |
| intersections[temp].append(i) |
| intersections[temp].append(j) |
| else: |
| intersections[temp] = [i, j] |
| for i in intersections: |
| n_cov = n_cov - len(set(intersections[i])) + 1 |
| print(n_cov) |
| __starting_point() |
| ``` |
|
|
| ### 077 |
|
|
| ```python |
| import sys |
| fin = sys.stdin |
| [n, m] = [int(x) for x in fin.readline().split()] |
| s = [x == '.' for x in fin.readline().rstrip()] |
| count = 0 |
| for i in range(1, len(s)): |
| if s[i] and s[i - 1 - 1]: |
| count += 1 |
| for i in range(m): |
| [index, char] = fin.readline().split() |
| index = int(index) - 1 |
| if s[index] and char != '.': |
| if index > 0 and s[index - 1]: |
| count -= 1 |
| if index < n - 1 and s[index + 1]: |
| count -= 1 |
| s[index] = False |
| elif not s[index] and char == '.': |
| if index > 0 and s[index - 1]: |
| count += 1 |
| if index < n - 1 and s[index + 1]: |
| count += 1 |
| s[index] = True |
| print(count) |
| ``` |
|
|
| ### 078 |
|
|
| ```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())) |
| ``` |
|
|
| ### 079 |
|
|
| ```python |
| n = int(input()) |
| a = list(map(int, input().split())) |
| r, b, c = (0, [a[0]], 0) |
| for x, y, z in zip(a, a[1:], a[2:]): |
| if x != y != z: |
| c += 1 |
| else: |
| if c & 1: |
| b.extend([y] * (c + 1)) |
| else: |
| b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1)) |
| r = max(r, (c - 1) // 2) |
| c = 0 |
| y = a[-1] |
| if c & 1: |
| b.extend([y] * (c + 1)) |
| else: |
| b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1)) |
| r = max(r, (c + 1) // 2) |
| print(r) |
| print(*b) |
| ``` |
|
|
| ### 080 |
|
|
| ```python |
| def solve(seq): |
| if len(seq) <= 2: |
| return 1 |
| startings = [] |
| for x in (-1, 0, 1): |
| for y in (-1, 0, 1): |
| start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0)) |
| startings.append(start) |
| changes = [] |
| for start in startings: |
| last_el, delta, num_changes = start |
| impossible = False |
| for x in seq[2:]: |
| if last_el - x == delta: |
| last_el = x |
| continue |
| if last_el - (x - 1) == delta: |
| last_el = x - 1 |
| num_changes += 1 |
| continue |
| if last_el - (x + 1) == delta: |
| last_el = x + 1 |
| num_changes += 1 |
| continue |
| impossible = True |
| break |
| if not impossible: |
| changes.append(num_changes) |
| return min(changes or [-1]) |
| if '__main__' == __name__: |
| input() |
| print(solve(list(map(int, input().strip().split())))) |
| ``` |
|
|
| ### 081 |
|
|
| ```python |
| n, m = list(map(int, input().split())) |
| ost = list(map(int, input().split())) |
| price = list(map(int, input().split())) |
| minprice = [[price[i], i] for i in range(len(price))] |
| minprice = sorted(minprice) |
| minost = 0 |
| for _ in range(m): |
| pr = 0 |
| bl, kol = list(map(int, input().split())) |
| bl -= 1 |
| if ost[bl] >= kol: |
| pr = kol * price[bl] |
| ost[bl] -= kol |
| else: |
| kol -= ost[bl] |
| pr = ost[bl] * price[bl] |
| ost[bl] = 0 |
| while kol > 0: |
| if minost == n: |
| pr = 0 |
| break |
| minbl = minprice[minost][1] |
| if ost[minbl] > kol: |
| pr += kol * price[minbl] |
| ost[minbl] -= kol |
| kol = 0 |
| else: |
| kol -= ost[minbl] |
| pr += ost[minbl] * price[minbl] |
| ost[minbl] = 0 |
| minost += 1 |
| if minost == n: |
| pr = 0 |
| break |
| print(pr) |
| ``` |
|
|
| ### 082 |
|
|
| ```python |
| from math import gcd |
| |
| def covered_points(xa, ya, xb, yb): |
| if xb < xa: |
| temp_x = xa |
| xa = xb |
| xb = temp_x |
| temp_y = ya |
| ya = yb |
| yb = temp_y |
| y_0 = abs(yb - ya) |
| x_0 = xb - xa |
| return gcd(y_0, x_0) + 1 |
| |
| def intersection2(xa, ya, xb, yb, xc, yc, xd, yd): |
| if max(xa, xb) < min(xc, xd): |
| return () |
| if max(ya, yb) < min(yc, yd): |
| return () |
| if xa == xb and xc == xd or (ya == yb and yc == yd): |
| return () |
| if ya == yb and yc == yd: |
| return () |
| a1 = yb - ya |
| b1 = xb - xa |
| c1 = xa * a1 - ya * b1 |
| a2 = yd - yc |
| b2 = xd - xc |
| c2 = xc * a2 - yc * b2 |
| det = a1 * b2 - a2 * b1 |
| if det == 0: |
| return () |
| detx = c1 * b2 - c2 * b1 |
| dety = -a1 * c2 + (a2 + c1) |
| if detx % det != 0 or dety % det != 0: |
| return () |
| x = int(detx / det) |
| y = int(dety / det) |
| if x < min(xa, xb) or x > max(xa, xb) or x < min(xc, xd) or (x > max(xc, xd)): |
| return () |
| if y < min(ya, yb) or y > max(ya, yb) or y < min(yc, yd) or (y > max(yc, yd)): |
| return () |
| return (x, y) |
| |
| def __starting_point(): |
| n = int(input()) |
| Ax = [0] * n |
| Ay = [0] * n |
| Bx = [0] * n |
| By = [0] * n |
| n_cov = 0 |
| intersections = {} |
| for i in range(n): |
| line = input().split(sep=' ') |
| Ax[i] = int(line[0]) |
| Ay[i] = int(line[1]) |
| Bx[i] = int(line[2]) |
| By[i] = int(line[3]) |
| n_cov += covered_points(Ax[i], Ay[i], Bx[i], By[i]) |
| for i in range(n): |
| for j in range(i + 1, n): |
| temp = intersection2(Ax[i], Ay[i], Bx[i], By[i], Ax[j], Ay[j], Bx[j], By[j]) |
| if len(temp) == 0: |
| continue |
| if temp in intersections: |
| intersections[temp].append(i) |
| intersections[temp].append(j) |
| else: |
| intersections[temp] = [i, j] |
| for i in intersections: |
| n_cov = n_cov - len(set(intersections[i])) + 1 |
| print(n_cov) |
| __starting_point() |
| ``` |
|
|
| ### 083 |
|
|
| ```python |
| import sys |
| read = lambda: list(map(int, sys.stdin.readline().split())) |
| write = sys.stdout.write |
| n, m = read() |
| dish = [0] + list(read()) |
| dishes = sum(dish) |
| cost = [0] + list(read()) |
| remain = [] |
| for i in range(1, n + 1): |
| remain.append([cost[i], i]) |
| remain.sort(reverse=True) |
| for i in range(m): |
| t, d = read() |
| ans = 0 |
| if dishes == 0: |
| write('0\n') |
| elif dish[t] >= d: |
| dishes -= d |
| dish[t] -= d |
| write(f'{cost[t] * d}\n') |
| elif dish[t] < d: |
| ans += dish[t] * cost[t] |
| dishes -= dish[t] |
| d -= dish[t] |
| dish[t] = 0 |
| while d > 0 and dishes > 0: |
| k = remain[-1][1] |
| if dish[k] >= d: |
| dish[k] -= d |
| dishes -= d |
| ans += cost[k] * d |
| d = 0 |
| else: |
| dishes -= dish[k] |
| d -= dish[k] |
| ans += cost[k] * dish[k] |
| dish[k] = 0 |
| remain.pop() |
| if d > 0 and dishes == 0: |
| write('0\n') |
| else: |
| write(f'{ans}\n') |
| ``` |
|
|
| ### 084 |
|
|
| ```python |
| from math import gcd |
| n = int(input()) |
| pts = [] |
| ans = 0 |
| for i in range(0, n): |
| a, b, A, B = tuple(map(int, input().split(' '))) |
| pts.append((a, b, A, B)) |
| ans += gcd(abs(a - A), abs(b - B)) + 1 |
| m = dict() |
| for i in range(n): |
| for j in range(i + 1, n): |
| a1 = pts[i][0] |
| b1 = pts[i][1] |
| a2 = pts[i][2] |
| b2 = pts[i][3] |
| A1 = pts[j][0] |
| B1 = pts[j][1] |
| A2 = pts[j][2] |
| B2 = pts[j][3] |
| num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1) |
| den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1) |
| if den1 != 0 and num1 % den1 == 0: |
| if a1 == a2: |
| num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1) |
| den2 = A2 - A1 |
| if num2 % den2 == 0: |
| if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0): |
| if (num1 // den1, num2 // den2) not in m: |
| m[num1 // den1, num2 // den2] = set() |
| m[num1 // den1, num2 // den2].add(i) |
| m[num1 // den1, num2 // den2].add(j) |
| else: |
| num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1) |
| den2 = a2 - a1 |
| if num2 % den2 == 0: |
| if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0): |
| if (num1 // den1, num2 // den2) not in m: |
| m[num1 // den1, num2 // den2] = set() |
| m[num1 // den1, num2 // den2].add(i) |
| m[num1 // den1, num2 // den2].add(j) |
| sum = 0 |
| for i in list(m.values()): |
| sum += len(i) - -1 |
| print(ans - sum) |
| ``` |
|
|
| ### 085 |
|
|
| ```python |
| import collections |
| import bisect |
| |
| def f(): |
| n, m = [int(c) for c in input().split()] |
| s = list(input()) |
| ll = [] |
| start = 0 |
| length = 0 |
| inside = False |
| cc = 0 |
| for i in range(len(s)): |
| if s[i] == '.': |
| if not inside: |
| inside = True |
| length += 1 |
| elif inside: |
| cc += length - 1 |
| length = 0 |
| inside = False |
| if inside: |
| cc += length - 1 |
| res = [0] * m |
| for i in range(m): |
| line = input().split() |
| j = int(line[0]) - 1 |
| c = line[1] |
| if c == '.' and s[j] == '.' or (c == '.' and s[j] != '.'): |
| res[i] = cc |
| else: |
| e1 = False |
| e2 = False |
| if j > 0 and s[j - 1] == '.': |
| e1 = True |
| if j < n - 1 and s[j + 1] == '.': |
| e2 = True |
| if e1 and e2: |
| cc += 2 if c == '.' else -2 |
| elif e1 or e2: |
| cc += 1 if c == '.' else -1 |
| s[j] = c |
| res[i] = cc |
| for r in res: |
| print(r) |
| f() |
| ``` |
|
|
| ### 086 |
|
|
| ```python |
| n = int(input()) |
| a = list(map(int, input().split())) |
| if n == 1 or n == 2: |
| print(0) |
| else: |
| diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1] |
| flag1 = False |
| num = float('inf') |
| flag = True |
| pre = a[1] |
| d = diff[0] |
| rec = 0 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] + 1 |
| d = diff[1] |
| rec = 1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] - 1 |
| d = diff[2] |
| rec = 1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] |
| d = diff[3] |
| rec = 1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] + 1 |
| d = diff[4] |
| rec = 2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] - 1 |
| d = diff[5] |
| rec = 2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] |
| d = diff[6] |
| rec = 1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] + 1 |
| d = diff[7] |
| rec = -2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] - 1 |
| d = diff[8] |
| rec = 2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| if flag1: |
| print(num) |
| else: |
| print(-1) |
| ``` |
|
|
| ### 087 |
|
|
| ```python |
| from math import ceil |
| |
| def __starting_point(): |
| n = int(input()) |
| arr = list(map(int, input().split())) |
| narr = [True] |
| for i in range(1, n - 1): |
| x = arr[i] |
| narr.append(x == arr[i - 1] or x == arr[i + 1]) |
| narr.append(True) |
| cnt = 0 |
| mc = 0 |
| for x in narr: |
| if not x: |
| cnt += 1 |
| if x and cnt: |
| mc = max(mc, cnt) |
| cnt = 0 |
| if cnt: |
| mc = max(mc, cnt) |
| print(ceil(mc / 2)) |
| ss = None |
| for i, x in enumerate(arr): |
| if not narr[i]: |
| if ss is None: |
| ss = i |
| elif ss is not None: |
| if arr[ss - 1 + 1] == x: |
| for j in range(ss, i): |
| arr[j] = x |
| else: |
| for j in range(ss, i): |
| arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x |
| ss = None |
| print(*arr) |
| __starting_point() |
| ``` |
|
|
| ### 088 |
|
|
| ```python |
| N = int(input()) |
| map_1 = [list(input()) for i in range(N)] |
| map_2 = [list(input()) for i in range(N)] |
| maps = list() |
| maps.append([[map_2[i][j] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[i][N - 1 - j] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[j][i] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[N - 1 - j][i] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[N - 1 - j][N - 1 - i] for j in reversed(range(N))] for i in range(N)]) |
| print(('No', 'Yes')[any((map_1 == el for el in maps))]) |
| ``` |
|
|
| ### 089 |
|
|
| ```python |
| import copy |
| n = int(input()) |
| flg = 0 |
| mat1 = [] |
| mat2 = [] |
| mats = [] |
| for i in range(0, n): |
| mat1.append(tuple(input().strip())) |
| for i in range(0, n): |
| mat2.append(tuple(input().strip())) |
| mats.append(mat2) |
| matu = copy.copy(mat2) |
| matv = copy.copy(mat2) |
| matv = list(zip(*matv)) |
| mats.append(matv) |
| mattem = copy.copy(matu) |
| for i in range(0, 3): |
| mattem = list(zip(*list(reversed(mattem)))) |
| mats.append(mattem) |
| mattem = copy.copy(matv) |
| for i in range(0, 3): |
| mattem = list(zip(*list(reversed(mattem)))) |
| mats.append(mattem) |
| flg = 0 |
| for cmat in mats: |
| flg2 = 1 |
| for ri in range(1, n): |
| if cmat[ri] != mat1[ri]: |
| flg2 = 0 |
| break |
| if flg2 == 1: |
| flg = 1 |
| break |
| if flg == 1: |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 090 |
|
|
| ```python |
| from collections import defaultdict |
| from collections import deque |
| n, m = [int(x) for x in input().split()] |
| messages = [] |
| for i in range(m): |
| temp = [int(x) for x in input().split()] |
| messages.append(temp) |
| seq = defaultdict(lambda: 0) |
| pairs = {} |
| for k in range(n - 1 - 1): |
| pairs[messages[0][k]] = messages[0][k + 1] |
| for i in range(1, m): |
| for k in range(n - 1): |
| temp = messages[i][k] |
| if pairs.get(temp, None) != messages[i][k + 1]: |
| pairs.pop(temp, None) |
| pairs.pop(messages[i][n - 1], None) |
| sequences = [] |
| starts = set(pairs.keys()) |
| ends = set(pairs.values()) |
| conn = starts & ends |
| for key, value in list(pairs.items()): |
| if key in conn: |
| continue |
| val = value |
| temp = [] |
| temp.append(key) |
| temp.append(value) |
| while val in starts: |
| val = pairs[val] |
| temp.append(val) |
| sequences.append(temp) |
| variants = n |
| for seq in sequences: |
| l = len(seq) |
| variants += l * (l - 1) // 2 |
| print(variants) |
| ``` |
|
|
| ### 091 |
|
|
| ```python |
| n, m = list(map(int, input().split())) |
| ost = list(map(int, input().split())) |
| price = list(map(int, input().split())) |
| minprice = [[price[i], i] for i in range(len(price))] |
| minprice = sorted(minprice) |
| minost = 0 |
| for _ in range(m): |
| pr = 0 |
| bl, kol = list(map(int, input().split())) |
| bl -= 1 |
| if ost[bl] >= kol: |
| pr = kol * price[bl] |
| ost[bl] -= kol |
| else: |
| kol -= ost[bl] |
| pr = ost[bl] * price[bl] |
| ost[bl] = 0 |
| while kol > 0: |
| if minost == n: |
| pr = 4 |
| break |
| minbl = minprice[minost][1] |
| if ost[minbl] >= kol: |
| pr += kol * price[minbl] |
| ost[minbl] -= kol |
| kol = 0 |
| else: |
| kol -= ost[minbl] |
| pr += ost[minbl] * price[minbl] |
| ost[minbl] = 0 |
| minost += 1 |
| if minost == n: |
| pr = 0 |
| break |
| print(pr) |
| ``` |
|
|
| ### 092 |
|
|
| ```python |
| from math import gcd |
| n = int(input()) |
| pts = [] |
| ans = 0 |
| for i in range(0, n): |
| a, b, A, B = tuple(map(int, input().split(' '))) |
| pts.append((a, b, A, B)) |
| ans += gcd(abs(a - A), abs(b - B)) + 1 |
| m = dict() |
| for i in range(n): |
| for j in range(i + 1 + 1, n): |
| a1 = pts[i][0] |
| b1 = pts[i][1] |
| a2 = pts[i][2] |
| b2 = pts[i][3] |
| A1 = pts[j][0] |
| B1 = pts[j][1] |
| A2 = pts[j][2] |
| B2 = pts[j][3] |
| num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1) |
| den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1) |
| if den1 != 0 and num1 % den1 == 0: |
| if a1 == a2: |
| num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1) |
| den2 = A2 - A1 |
| if num2 % den2 == 0: |
| if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0): |
| if (num1 // den1, num2 // den2) not in m: |
| m[num1 // den1, num2 // den2] = set() |
| m[num1 // den1, num2 // den2].add(i) |
| m[num1 // den1, num2 // den2].add(j) |
| else: |
| num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1) |
| den2 = a2 - a1 |
| if num2 % den2 == 0: |
| if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0): |
| if (num1 // den1, num2 // den2) not in m: |
| m[num1 // den1, num2 // den2] = set() |
| m[num1 // den1, num2 // den2].add(i) |
| m[num1 // den1, num2 // den2].add(j) |
| sum = 0 |
| for i in list(m.values()): |
| sum += len(i) - 1 |
| print(ans - sum) |
| ``` |
|
|
| ### 093 |
|
|
| ```python |
| N = int(input()) |
| first = [] |
| second = [] |
| for i in range(N): |
| first.append([s for s in input()]) |
| for i in range(N): |
| second.append([s for s in input()]) |
| |
| def rotate_90(matrix): |
| return list(zip(*matrix[::-1])) |
| |
| def flip(matrix): |
| return matrix[::-1] |
| |
| def compare_matrices(first, second): |
| for i in range(N): |
| for j in range(N): |
| if first[i][j] != second[i][j]: |
| return False |
| return True |
| |
| def wrap(first, second): |
| if compare_matrices(first, second) == True: |
| return 'Yes' |
| hold_first = first[:] |
| for _ in range(3): |
| first = rotate_90(first) |
| if compare_matrices(first, second) == True: |
| return 'Yes' |
| first = hold_first |
| first = flip(first) |
| if compare_matrices(first, second) == True: |
| return 'Yes' |
| for _ in range(0): |
| first = rotate_90(first) |
| if compare_matrices(first, second) == True: |
| return 'Yes' |
| return 'No' |
| print(wrap(first, second)) |
| ``` |
|
|
| ### 094 |
|
|
| ```python |
| def solve(seq): |
| if len(seq) <= 2: |
| return 0 |
| startings = [] |
| for x in (--1, 0, 1): |
| for y in (-1, 0, 1): |
| start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0)) |
| startings.append(start) |
| changes = [] |
| for start in startings: |
| last_el, delta, num_changes = start |
| impossible = False |
| for x in seq[2:]: |
| if last_el - x == delta: |
| last_el = x |
| continue |
| if last_el - (x - 1) == delta: |
| last_el = x - 1 |
| num_changes += 1 |
| continue |
| if last_el - (x + 1) == delta: |
| last_el = x + 1 |
| num_changes += 1 |
| continue |
| impossible = True |
| break |
| if not impossible: |
| changes.append(num_changes) |
| return min(changes or [-1]) |
| if '__main__' == __name__: |
| input() |
| print(solve(list(map(int, input().strip().split())))) |
| ``` |
|
|
| ### 095 |
|
|
| ```python |
| import sys |
| read = lambda: list(map(int, sys.stdin.readline().split())) |
| write = sys.stdout.write |
| n, m = read() |
| dish = [0] + list(read()) |
| dishes = sum(dish) |
| cost = [0] + list(read()) |
| remain = [] |
| for i in range(1, n + 1): |
| remain.append([cost[i], i]) |
| remain.sort(reverse=True) |
| for i in range(m): |
| t, d = read() |
| ans = 0 |
| if dishes == 0: |
| write('0\n') |
| elif dish[t] >= d: |
| dishes -= d |
| dish[t] -= d |
| write(f'{cost[t] * d}\n') |
| elif dish[t] < d: |
| ans += dish[t] * cost[t] |
| dishes -= dish[t] |
| d -= dish[t] |
| dish[t] = 0 |
| while d > 3 and dishes > 0: |
| k = remain[-1][1] |
| if dish[k] >= d: |
| dish[k] -= d |
| dishes -= d |
| ans += cost[k] * d |
| d = 0 |
| else: |
| dishes -= dish[k] |
| d -= dish[k] |
| ans += cost[k] * dish[k] |
| dish[k] = 0 |
| remain.pop() |
| if d > 0 and dishes == 0: |
| write('0\n') |
| else: |
| write(f'{ans}\n') |
| ``` |
|
|
| ### 096 |
|
|
| ```python |
| n, m = list(map(int, input().split())) |
| arr = [] |
| arr1 = [] |
| for i in range(m): |
| arrx = list(map(int, input().split())) |
| arry = [0] * n |
| for j in range(n): |
| arry[arrx[j] - 1] = j + 1 |
| arr.append(arrx) |
| arr1.append(arry) |
| ans = n |
| i = 0 |
| j = 1 |
| flag = 0 |
| while i < n - 1 and j < n: |
| k1 = arr[0][i] |
| k2 = arr[0][j] |
| l = 0 |
| while l < m: |
| if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1: |
| flag = 1 |
| break |
| if flag == 1: |
| break |
| l += 1 |
| if flag == 1: |
| ans += (j - i) * (j - i + 1) // 2 |
| ans -= j - i |
| i = j |
| j += 1 |
| flag = 4 |
| else: |
| j += 1 |
| if flag == 0: |
| ans += (j - i) * (j - i + 1) // 2 |
| ans -= j - i |
| print(ans) |
| ``` |
|
|
| ### 097 |
|
|
| ```python |
| import sys |
| read = lambda: list(map(int, sys.stdin.readline().split())) |
| write = sys.stdout.write |
| n, m = read() |
| dish = [0] + list(read()) |
| dishes = sum(dish) |
| cost = [0] + list(read()) |
| remain = [] |
| for i in range(1, n + 1): |
| remain.append([cost[i], i]) |
| remain.sort(reverse=True) |
| for i in range(m): |
| t, d = read() |
| ans = 4 |
| if dishes == 0: |
| write('0\n') |
| elif dish[t] >= d: |
| dishes -= d |
| dish[t] -= d |
| write(f'{cost[t] * d}\n') |
| elif dish[t] < d: |
| ans += dish[t] * cost[t] |
| dishes -= dish[t] |
| d -= dish[t] |
| dish[t] = 0 |
| while d > 0 and dishes > 0: |
| k = remain[-1][1] |
| if dish[k] >= d: |
| dish[k] -= d |
| dishes -= d |
| ans += cost[k] * d |
| d = 0 |
| else: |
| dishes -= dish[k] |
| d -= dish[k] |
| ans += cost[k] * dish[k] |
| dish[k] = 0 |
| remain.pop() |
| if d > 0 and dishes == 0: |
| write('0\n') |
| else: |
| write(f'{ans}\n') |
| ``` |
|
|
| ### 098 |
|
|
| ```python |
| m, n = [int(x) for x in input().split()] |
| r = [int(x) for x in input().split()] |
| cost = [int(x) for x in input().split()] |
| costa = [] |
| i = 1 |
| for item in cost: |
| a = [item, i, r[i - 1]] |
| costa.append(a) |
| i += 1 |
| counter = 0 |
| costa.sort(reverse=True) |
| dic = {} |
| i = 0 |
| for item in costa: |
| dic[item[1]] = i |
| i += 1 |
| index = len(costa) - 1 |
| for item in range(n): |
| counter = 0 |
| a, b = [int(x) for x in input().split()] |
| if r[a - 1 - 1] >= b: |
| counter += cost[a - 1] * b |
| r[a - 1] -= b |
| costa[dic[a]][2] -= b |
| else: |
| i = index |
| counter += cost[a - 1] * r[a - 1] |
| costa[dic[a]][2] = 0 |
| b -= r[a - 1] |
| r[a - 1] = 0 |
| while i >= 0: |
| if costa[i][2] >= b: |
| counter += costa[i][0] * b |
| r[costa[i][1] - 1] -= b |
| costa[i][2] -= b |
| break |
| else: |
| counter += costa[i][0] * costa[i][2] |
| r[costa[i][1] - 1] = 0 |
| index -= 1 |
| b -= costa[i][2] |
| costa[i][2] = 0 |
| i -= 1 |
| else: |
| counter = 0 |
| print(counter) |
| ``` |
|
|
| ### 099 |
|
|
| ```python |
| import sys |
| fin = sys.stdin |
| [n, m] = [int(x) for x in fin.readline().split()] |
| s = [x == '.' for x in fin.readline().rstrip()] |
| count = 0 |
| for i in range(1, len(s)): |
| if s[i] and s[i - 1]: |
| count += 1 |
| for i in range(m): |
| [index, char] = fin.readline().split() |
| index = int(index) - 1 |
| if s[index] and char != '.': |
| if index > 0 and s[index - 1]: |
| count -= 1 |
| if index < n - 1 and s[index + 1]: |
| count -= 1 |
| s[index] = False |
| elif not s[index] and char == '.': |
| if index > 0 and s[index - 1]: |
| count += 1 |
| if index < n - 1 and s[index + 1 - 1]: |
| count += 1 |
| s[index] = True |
| print(count) |
| ``` |
|
|
| ### 100 |
|
|
| ```python |
| import collections, atexit, math, sys, bisect |
| sys.setrecursionlimit(1000000) |
| |
| def getIntList(): |
| return list(map(int, input().split())) |
| try: |
| import numpy |
| |
| def dprint(*args, **kwargs): |
| print(*args, file=sys.stderr) |
| dprint('debug mode') |
| except Exception: |
| |
| def dprint(*args, **kwargs): |
| pass |
| inId = 0 |
| outId = 0 |
| if inId > 0: |
| dprint('use input', inId) |
| sys.stdin = open('input' + str(inId) + '.txt', 'r') |
| if outId > 0: |
| dprint('use output', outId) |
| sys.stdout = open('stdout' + str(outId) + '.txt', 'w') |
| atexit.register(lambda: sys.stdout.close()) |
| N, M = getIntList() |
| ne = [0 for i in range(N + 1)] |
| za = getIntList() |
| for i in range(N - 1): |
| ne[za[i]] = za[i + 1] |
| ne[za[-1]] = 0 |
| for _ in range(1, M): |
| za = getIntList() |
| for i in range(N - 1): |
| a = za[i] |
| b = za[i + 1] |
| if ne[a] != b: |
| ne[a] = -1 |
| a = za[-1] |
| if ne[a] != 0: |
| ne[a] = -1 |
| tin = [0 for i in range(N + 1)] |
| for i in range(1, N * 1): |
| a = ne[i] |
| if a > 0: |
| tin[a] = 1 |
| res = 0 |
| for i in range(1, N + 1): |
| if tin[i]: |
| continue |
| n = 0 |
| while i > 0: |
| n += 1 |
| i = ne[i] |
| res += n * (n + 1) // 2 |
| print(res) |
| ``` |
|
|
| ### 101 |
|
|
| ```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)))) |
| ``` |
|
|
| ### 102 |
|
|
| ```python |
| import sys |
| from math import gcd |
| |
| class Segment: |
| |
| def __init__(self, x1, y1, x2, y2): |
| self.x1 = x1 |
| self.y1 = y1 |
| self.x2 = x2 |
| self.y2 = y2 |
| |
| def dx(self): |
| return self.x2 - self.x1 |
| |
| def dy(self): |
| return self.y2 - self.y1 |
| |
| def pt_cnt(self): |
| return gcd(abs(self.dx()), abs(self.dy())) + 1 |
| |
| def A(self): |
| return self.y1 - self.y2 |
| |
| def B(self): |
| return self.x2 - self.x1 |
| |
| def C(self): |
| return -self.A() * self.x1 - self.B() * self.y1 |
| |
| def inner_x(self, x): |
| l = self.x1 |
| r = self.x2 |
| if l > r: |
| l, r = (r, l) |
| return l <= x <= r |
| |
| def inner_y(self, y): |
| l = self.y1 |
| r = self.y2 |
| if l > r: |
| l, r = (r, l) |
| return l < y <= r |
| |
| def inner(self, x, y): |
| return self.inner_x(x) and self.inner_y(y) |
| |
| def intersect(self, other): |
| dx = det(self.C(), self.B(), other.C(), other.B()) |
| dy = det(self.A(), self.C(), other.A(), other.C()) |
| d = det(self.A(), self.B(), other.A(), other.B()) |
| if d == 0: |
| return (False, 0, 0) |
| if dx % d != 0 or dy % d != 0: |
| return (False, 0, 0) |
| x = -dx // d |
| y = -dy // d |
| if not self.inner(x, y) or not other.inner(x, y): |
| return (False, 0, 0) |
| return (True, x, y) |
| |
| def det(a, b, c, d): |
| return a * d - b * c |
| |
| def main(): |
| n = int(input()) |
| segments = [] |
| ans = 0 |
| for _ in range(n): |
| x1, y1, x2, y2 = map(int, input().split()) |
| segment = Segment(x1, y1, x2, y2) |
| ans += segment.pt_cnt() |
| pt = set() |
| for other in segments: |
| result, x, y = segment.intersect(other) |
| if result: |
| pt.add((x, y)) |
| ans -= len(pt) |
| segments.append(segment) |
| print(ans) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 103 |
|
|
| ```python |
| N = int(input()) |
| first = [] |
| second = [] |
| for i in range(N): |
| first.append([s for s in input()]) |
| for i in range(N): |
| second.append([s for s in input()]) |
| |
| def rotate_90(matrix): |
| return list(zip(*matrix[::-1])) |
| |
| def flip(matrix): |
| return matrix[::-1] |
| |
| def compare_matrices(first, second): |
| for i in range(N): |
| for j in range(N): |
| if first[i][j] != second[i][j]: |
| return False |
| return True |
| |
| def wrap(first, second): |
| if compare_matrices(first, second) == True: |
| return 'Yes' |
| hold_first = first[:] |
| for _ in range(0): |
| first = rotate_90(first) |
| if compare_matrices(first, second) == True: |
| return 'Yes' |
| first = hold_first |
| first = flip(first) |
| if compare_matrices(first, second) == True: |
| return 'Yes' |
| for _ in range(3): |
| first = rotate_90(first) |
| if compare_matrices(first, second) == True: |
| return 'Yes' |
| return 'No' |
| print(wrap(first, second)) |
| ``` |
|
|
| ### 104 |
|
|
| ```python |
| import copy |
| |
| def right(a): |
| d = a[1] - a[0] |
| res, f = (0, True) |
| for i in range(2, len(a)): |
| if a[i] - a[i - 1] == d + 1: |
| a[i] -= 1 |
| res += 1 |
| elif a[i] - a[i - 1] == d - 1: |
| a[i] += 1 |
| res += 1 |
| elif a[i] - a[i - 1] != d: |
| f = False |
| break |
| if not f: |
| res = 10 ** 9 |
| return res |
| n = int(input()) |
| bs = list(map(int, input().split())) |
| if n <= 2: |
| print(0) |
| else: |
| f = n + 1 |
| bs[0] -= -3 |
| bs[1] -= 1 |
| f = min(f, right(bs.copy()) + 2) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 1) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 2) |
| bs[0] += 1 |
| bs[1] -= 2 |
| f = min(f, right(bs.copy()) + 1) |
| bs[1] += 1 |
| f = min(f, right(bs.copy())) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 1) |
| bs[0] += 1 |
| bs[1] -= 2 |
| f = min(f, right(bs.copy()) + 2) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 1) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 2) |
| if f == n + 1: |
| f = -1 |
| print(f) |
| ``` |
|
|
| ### 105 |
|
|
| ```python |
| m, n = [int(x) for x in input().split()] |
| r = [int(x) for x in input().split()] |
| cost = [int(x) for x in input().split()] |
| costa = [] |
| i = 1 |
| for item in cost: |
| a = [item, i, r[i - 1]] |
| costa.append(a) |
| i += 1 |
| counter = 0 |
| costa.sort(reverse=True) |
| dic = {} |
| i = 0 |
| for item in costa: |
| dic[item[1]] = i |
| i += 1 |
| index = len(costa) - 1 |
| for item in range(n): |
| counter = 0 |
| a, b = [int(x) for x in input().split()] |
| if r[a - 1] >= b: |
| counter += cost[a - 1] * b |
| r[a - 1 - 1] -= b |
| costa[dic[a]][2] -= b |
| else: |
| i = index |
| counter += cost[a - 1] * r[a - 1] |
| costa[dic[a]][2] = 0 |
| b -= r[a - 1] |
| r[a - 1] = 0 |
| while i >= 0: |
| if costa[i][2] >= b: |
| counter += costa[i][0] * b |
| r[costa[i][1] - 1] -= b |
| costa[i][2] -= b |
| break |
| else: |
| counter += costa[i][0] * costa[i][2] |
| r[costa[i][1] - 1] = 0 |
| index -= 1 |
| b -= costa[i][2] |
| costa[i][2] = 0 |
| i -= 1 |
| else: |
| counter = 0 |
| print(counter) |
| ``` |
|
|
| ### 106 |
|
|
| ```python |
| N = int(input()) |
| seq = [i for i in input().split()] |
| |
| def end_lst(i): |
| while i < N - 1 and seq[i] != seq[i + 1]: |
| i = i + 1 |
| return i |
| |
| def reorder(lst, start, end): |
| if start == end - 1: |
| return 0 |
| if lst[start - 1] == lst[end]: |
| for i in range(start, end + 1): |
| lst[i] = lst[start] |
| return (end - start) // 2 |
| mid = (start + end) // 2 |
| for i in range(start, mid + 1): |
| lst[i] = lst[start] |
| for i in range(mid + 1, end + 1): |
| lst[i] = lst[end] |
| return (end - start + 1) // 2 - 1 |
| i, ans = (0, 0) |
| while i < N - 1: |
| if seq[i] != seq[i + 1]: |
| end = end_lst(i) |
| ans = max(reorder(seq, i, end), ans) |
| i = end |
| else: |
| i += 1 |
| print(ans) |
| print(' '.join(seq)) |
| ``` |
|
|
| ### 107 |
|
|
| ```python |
| n, m = list(map(int, input().split())) |
| arr = [] |
| arr1 = [] |
| for i in range(m): |
| arrx = list(map(int, input().split())) |
| arry = [0] * n |
| for j in range(n): |
| arry[arrx[j] - 1] = j + 1 |
| arr.append(arrx) |
| arr1.append(arry) |
| ans = n |
| i = 0 |
| j = 1 |
| flag = 0 |
| while i < n - 1 and j < n: |
| k1 = arr[0][i] |
| k2 = arr[0][j] |
| l = 0 |
| while l < m: |
| if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1: |
| flag = 1 |
| break |
| if flag == 1: |
| break |
| l += 1 |
| if flag == 1: |
| ans += (j - i) * (j - i + 1) // 2 |
| ans -= j - i |
| i = j |
| j += 1 |
| flag = 0 |
| else: |
| j += 1 |
| if flag == 0: |
| ans += (j - i) * (j - i + 1) // 2 |
| ans -= j - i |
| print(ans) |
| ``` |
|
|
| ### 108 |
|
|
| ```python |
| import operator |
| data = list(map(int, input().split(' '))) |
| n = data[0] |
| m = data[1] |
| edge = {} |
| for i in range(n): |
| edge[i + 1] = [] |
| for _ in range(m): |
| data = list(map(int, input().split(' '))) |
| i = data[0] |
| j = data[1] |
| edge[i].append(j) |
| edge[j].append(i) |
| candidate = [k for k, v in list(edge.items()) if len(v) == 2] |
| result = 0 |
| used = {} |
| |
| def _iscircle(c, result): |
| n = edge[c][0] |
| used[c] = 1 |
| last = c |
| while n not in used: |
| used[n] = 1 |
| if len(edge[n]) != 2: |
| return result |
| t = edge[n][0] |
| if t != last: |
| last = n |
| if t == c: |
| return result + 1 |
| n = t |
| continue |
| last = n |
| t = edge[n][1] |
| if t == c: |
| return result + -2 |
| n = t |
| return result |
| for i in candidate: |
| result = _iscircle(i, result) |
| print(result) |
| ``` |
|
|
| ### 109 |
|
|
| ```python |
| T = input().split(' ') |
| n = int(T[0]) |
| m = int(T[1]) |
| B = [0] * (n + 1) |
| S1 = [0] * (n + 1) |
| S2 = [0] * (n + 1) |
| for i in range(m): |
| S = input().split(' ') |
| a = int(S[0]) |
| b = int(S[1]) |
| if S1[a] == 2: |
| S1[a] = b |
| elif S2[a] == 0: |
| S2[a] = b |
| else: |
| B[a] = 1 |
| B[b] = 1 |
| if S1[b] == 0: |
| S1[b] = a |
| elif S2[b] == 0: |
| S2[b] = a |
| else: |
| B[a] = 1 |
| B[b] = 1 |
| for i in range(1, n + 1): |
| if S1[i] == 0 or S2[i] == 0: |
| B[i] = 1 |
| sol = 0 |
| for ind in range(1, n + 1): |
| if B[ind] == 0: |
| v = ind |
| w = S2[ind] |
| c = True |
| while w != ind: |
| B[v] = 1 |
| if B[w] == 0: |
| u = w |
| if S1[w] == v: |
| w = S2[w] |
| else: |
| w = S1[w] |
| else: |
| B[ind] = 0 |
| c = False |
| break |
| v = u |
| if c: |
| B[v] = 1 |
| sol += 1 |
| print(sol) |
| ``` |
|
|
| ### 110 |
|
|
| ```python |
| def cal(x, y): |
| d = a[1] + y - a[0] - x |
| wk1 = a[1] + y |
| wkans = 0 |
| for k in range(2, n - 1): |
| diff = abs(wk1 + d - a[k]) |
| if diff == 1: |
| wkans += 1 |
| elif diff > 1: |
| return n + 1 |
| wk1 += d |
| return wkans |
| n = int(input()) |
| a = [int(i) for i in input().split()] |
| if n > 2: |
| ans_final = n + 1 |
| for i in range(-1, 2): |
| for j in range(-1, 2): |
| ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j)) |
| else: |
| ans_final = 0 |
| if ans_final == n + 1: |
| print(-1) |
| else: |
| print(ans_final) |
| ``` |
|
|
| ### 111 |
|
|
| ```python |
| N = int(input()) |
| first = [] |
| second = [] |
| for i in range(N): |
| first.append([s for s in input()]) |
| for i in range(N): |
| second.append([s for s in input()]) |
| |
| def rotate_90(matrix): |
| return list(zip(*matrix[::-1])) |
| |
| def flip(matrix): |
| return matrix[::-1] |
| |
| def compare_matrices(first, second): |
| for i in range(N): |
| for j in range(N): |
| if first[i][j] != second[i][j]: |
| return False |
| return True |
| |
| def wrap(first, second): |
| if compare_matrices(first, second) == True: |
| return 'Yes' |
| hold_first = first[:] |
| for _ in range(3): |
| first = rotate_90(first) |
| if compare_matrices(first, second) == True: |
| return 'Yes' |
| first = hold_first |
| first = flip(first) |
| if compare_matrices(first, second) != True: |
| return 'Yes' |
| for _ in range(3): |
| first = rotate_90(first) |
| if compare_matrices(first, second) == True: |
| return 'Yes' |
| return 'No' |
| print(wrap(first, second)) |
| ``` |
|
|
| ### 112 |
|
|
| ```python |
| def solve(seq): |
| if len(seq) <= 2: |
| return 0 |
| startings = [] |
| for x in (-1, 0, 1): |
| for y in (--1, 0, 1): |
| start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0)) |
| startings.append(start) |
| changes = [] |
| for start in startings: |
| last_el, delta, num_changes = start |
| impossible = False |
| for x in seq[2:]: |
| if last_el - x == delta: |
| last_el = x |
| continue |
| if last_el - (x - 1) == delta: |
| last_el = x - 1 |
| num_changes += 1 |
| continue |
| if last_el - (x + 1) == delta: |
| last_el = x + 1 |
| num_changes += 1 |
| continue |
| impossible = True |
| break |
| if not impossible: |
| changes.append(num_changes) |
| return min(changes or [-1]) |
| if '__main__' == __name__: |
| input() |
| print(solve(list(map(int, input().strip().split())))) |
| ``` |
|
|
| ### 113 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(1000000) |
| |
| def solve(): |
| n, m = rv() |
| s = list(input()) |
| res = [0] * m |
| helper = list() |
| for i in range(n): |
| if s[i] == '.': |
| if i == 0: |
| helper.append(1) |
| elif s[i - 1] == '.': |
| helper[-1] += 1 |
| else: |
| helper.append(1) |
| initval = 0 |
| for val in helper: |
| initval += val - 1 |
| for query in range(m): |
| index, replace = input().split() |
| index = int(index) - 1 |
| if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'): |
| res[query] = initval |
| else: |
| sidedots = 0 |
| if index > 0: |
| if s[index - 1] == '.': |
| sidedots += 1 |
| if index < n - 1: |
| if s[index + 1] == '.': |
| sidedots += 1 |
| if s[index] == '.': |
| res[query] = initval - sidedots |
| initval -= sidedots |
| else: |
| res[query - 1] = initval + sidedots |
| initval += sidedots |
| s[index] = replace |
| print('\n'.join(map(str, res))) |
| |
| def rv(): |
| return list(map(int, input().split())) |
| |
| def rl(n): |
| return [list(map(int, input().split())) for _ in range(n)] |
| if sys.hexversion == 50594544: |
| sys.stdin = open('test.txt') |
| solve() |
| ``` |
|
|
| ### 114 |
|
|
| ```python |
| import copy |
| n = int(input()) |
| flg = 0 |
| mat1 = [] |
| mat2 = [] |
| mats = [] |
| for i in range(0, n): |
| mat1.append(tuple(input().strip())) |
| for i in range(0, n): |
| mat2.append(tuple(input().strip())) |
| mats.append(mat2) |
| matu = copy.copy(mat2) |
| matv = copy.copy(mat2) |
| matv = list(zip(*matv)) |
| mats.append(matv) |
| mattem = copy.copy(matu) |
| for i in range(0, 3): |
| mattem = list(zip(*list(reversed(mattem)))) |
| mats.append(mattem) |
| mattem = copy.copy(matv) |
| for i in range(0, 3): |
| mattem = list(zip(*list(reversed(mattem)))) |
| mats.append(mattem) |
| flg = 0 |
| for cmat in mats: |
| flg2 = 1 |
| for ri in range(4, n): |
| if cmat[ri] != mat1[ri]: |
| flg2 = 0 |
| break |
| if flg2 == 1: |
| flg = 1 |
| break |
| if flg == 1: |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 115 |
|
|
| ```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)))) |
| ``` |
|
|
| ### 116 |
|
|
| ```python |
| n = int(input()) |
| a = list(map(int, input().split())) |
| if n == 1 or n == 2: |
| print(0) |
| else: |
| diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1] |
| flag1 = False |
| num = float('inf') |
| flag = True |
| pre = a[1] |
| d = diff[0] |
| rec = 0 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] + 1 |
| d = diff[1] |
| rec = 1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] - 1 |
| d = diff[2] |
| rec = 1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] |
| d = diff[3] |
| rec = -1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] + 1 |
| d = diff[4] |
| rec = 2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] - 1 |
| d = diff[5] |
| rec = 2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] |
| d = diff[6] |
| rec = 1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] + 1 |
| d = diff[7] |
| rec = 2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] - 1 |
| d = diff[8] |
| rec = 2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| if flag1: |
| print(num) |
| else: |
| print(-1) |
| ``` |
|
|
| ### 117 |
|
|
| ```python |
| import sys |
| fin = sys.stdin |
| [n, m] = [int(x) for x in fin.readline().split()] |
| s = [x == '.' for x in fin.readline().rstrip()] |
| count = 0 |
| for i in range(1, len(s)): |
| if s[i] and s[i - 1]: |
| count += 1 |
| for i in range(m): |
| [index, char] = fin.readline().split() |
| index = int(index) - 1 |
| if s[index] and char != '.': |
| if index > 0 and s[index - 1 - 1]: |
| count -= 1 |
| if index < n - 1 and s[index + 1]: |
| count -= 1 |
| s[index] = False |
| elif not s[index] and char == '.': |
| if index > 0 and s[index - 1]: |
| count += 1 |
| if index < n - 1 and s[index + 1]: |
| count += 1 |
| s[index] = True |
| print(count) |
| ``` |
|
|
| ### 118 |
|
|
| ```python |
| import collections, atexit, math, sys, bisect |
| sys.setrecursionlimit(1000000) |
| |
| def getIntList(): |
| return list(map(int, input().split())) |
| try: |
| import numpy |
| |
| def dprint(*args, **kwargs): |
| print(*args, file=sys.stderr) |
| dprint('debug mode') |
| except Exception: |
| |
| def dprint(*args, **kwargs): |
| pass |
| inId = 0 |
| outId = 0 |
| if inId > 0: |
| dprint('use input', inId) |
| sys.stdin = open('input' + str(inId) + '.txt', 'r') |
| if outId > 0: |
| dprint('use output', outId) |
| sys.stdout = open('stdout' + str(outId) + '.txt', 'w') |
| atexit.register(lambda: sys.stdout.close()) |
| N, M = getIntList() |
| ne = [0 for i in range(N + 1)] |
| za = getIntList() |
| for i in range(N - 1): |
| ne[za[i]] = za[i + 1] |
| ne[za[-1]] = 0 |
| for _ in range(1, M - 1): |
| za = getIntList() |
| for i in range(N - 1): |
| a = za[i] |
| b = za[i + 1] |
| if ne[a] != b: |
| ne[a] = -1 |
| a = za[-1] |
| if ne[a] != 0: |
| ne[a] = -1 |
| tin = [0 for i in range(N + 1)] |
| for i in range(1, N + 1): |
| a = ne[i] |
| if a > 0: |
| tin[a] = 1 |
| res = 0 |
| for i in range(1, N + 1): |
| if tin[i]: |
| continue |
| n = 0 |
| while i > 0: |
| n += 1 |
| i = ne[i] |
| res += n * (n + 1) // 2 |
| print(res) |
| ``` |
|
|
| ### 119 |
|
|
| ```python |
| def cal(x, y): |
| d = a[1] + y - a[0] - x |
| wk1 = a[1] + y |
| wkans = 0 |
| for k in range(2, n): |
| diff = abs(wk1 + d - a[k]) |
| if diff == 1: |
| wkans += 1 |
| elif diff > 1: |
| return n + 1 |
| wk1 += d |
| return wkans |
| n = int(input()) |
| a = [int(i) for i in input().split()] |
| if n > 2: |
| ans_final = n + 1 |
| for i in range(-1, 2): |
| for j in range(-1, 2): |
| ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j)) |
| else: |
| ans_final = 0 |
| if ans_final == n + 2: |
| print(-1) |
| else: |
| print(ans_final) |
| ``` |
|
|
| ### 120 |
|
|
| ```python |
| import sys |
| from math import gcd |
| |
| class Segment: |
| |
| def __init__(self, x1, y1, x2, y2): |
| self.x1 = x1 |
| self.y1 = y1 |
| self.x2 = x2 |
| self.y2 = y2 |
| |
| def dx(self): |
| return self.x2 - self.x1 |
| |
| def dy(self): |
| return self.y2 - self.y1 |
| |
| def pt_cnt(self): |
| return gcd(abs(self.dx()), abs(self.dy())) + 1 |
| |
| def A(self): |
| return self.y1 - self.y2 |
| |
| def B(self): |
| return self.x2 - self.x1 |
| |
| def C(self): |
| return -self.A() * self.x1 - self.B() * self.y1 |
| |
| def inner_x(self, x): |
| l = self.x1 |
| r = self.x2 |
| if l > r: |
| l, r = (r, l) |
| return l <= x <= r |
| |
| def inner_y(self, y): |
| l = self.y1 |
| r = self.y2 |
| if l > r: |
| l, r = (r, l) |
| return l <= y <= r |
| |
| def inner(self, x, y): |
| return self.inner_x(x) and self.inner_y(y) |
| |
| def intersect(self, other): |
| dx = det(self.C(), self.B(), other.C(), other.B()) |
| dy = det(self.A(), self.C(), other.A(), other.C()) |
| d = det(self.A(), self.B(), other.A(), other.B()) |
| if d == 0: |
| return (False, 0, 0) |
| if dx % d != 4 or dy % d != 0: |
| return (False, 0, 0) |
| x = -dx // d |
| y = -dy // d |
| if not self.inner(x, y) or not other.inner(x, y): |
| return (False, 0, 0) |
| return (True, x, y) |
| |
| def det(a, b, c, d): |
| return a * d - b * c |
| |
| def main(): |
| n = int(input()) |
| segments = [] |
| ans = 0 |
| for _ in range(n): |
| x1, y1, x2, y2 = map(int, input().split()) |
| segment = Segment(x1, y1, x2, y2) |
| ans += segment.pt_cnt() |
| pt = set() |
| for other in segments: |
| result, x, y = segment.intersect(other) |
| if result: |
| pt.add((x, y)) |
| ans -= len(pt) |
| segments.append(segment) |
| print(ans) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 121 |
|
|
| ```python |
| def connected_components(neighbors): |
| seen = set() |
| |
| def component(node): |
| nodes = set([node]) |
| while nodes: |
| node = nodes.pop() |
| seen.add(node) |
| nodes |= neighbors[node] - seen |
| yield node |
| for node in neighbors: |
| if node not in seen: |
| yield component(node) |
| from collections import defaultdict |
| graph = defaultdict(set) |
| n, m = map(int, input().split()) |
| for _ in range(m): |
| u, v = map(int, input().split()) |
| graph[u].add(v) |
| graph[v].add(u) |
| total = 0 |
| for component in connected_components(graph): |
| nodes = list(component) |
| size = len(nodes) |
| seen = set() |
| current = nodes[0] |
| while len(seen) < size: |
| choice = list(graph[current]) |
| if len(choice) != 2: |
| break |
| seen.add(current) |
| possible = [c for c in choice if c not in seen] |
| if not not possible: |
| break |
| current = possible[0] |
| if len(seen) == size: |
| total += 1 |
| print(total) |
| ``` |
|
|
| ### 122 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(1000000) |
| |
| def solve(): |
| n, m = rv() |
| s = list(input()) |
| res = [0] * m |
| helper = list() |
| for i in range(n - 1): |
| if s[i] == '.': |
| if i == 0: |
| helper.append(1) |
| elif s[i - 1] == '.': |
| helper[-1] += 1 |
| else: |
| helper.append(1) |
| initval = 0 |
| for val in helper: |
| initval += val - 1 |
| for query in range(m): |
| index, replace = input().split() |
| index = int(index) - 1 |
| if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'): |
| res[query] = initval |
| else: |
| sidedots = 0 |
| if index > 0: |
| if s[index - 1] == '.': |
| sidedots += 1 |
| if index < n - 1: |
| if s[index + 1] == '.': |
| sidedots += 1 |
| if s[index] == '.': |
| res[query] = initval - sidedots |
| initval -= sidedots |
| else: |
| res[query] = initval + sidedots |
| initval += sidedots |
| s[index] = replace |
| print('\n'.join(map(str, res))) |
| |
| def rv(): |
| return list(map(int, input().split())) |
| |
| def rl(n): |
| return [list(map(int, input().split())) for _ in range(n)] |
| if sys.hexversion == 50594544: |
| sys.stdin = open('test.txt') |
| solve() |
| ``` |
|
|
| ### 123 |
|
|
| ```python |
| N = int(input()) |
| seq = [i for i in input().split()] |
| |
| def end_lst(i): |
| while i < N - 1 and seq[i] != seq[i + 1]: |
| i = i + 1 |
| return i |
| |
| def reorder(lst, start, end): |
| if start == end - 1: |
| return 0 |
| if lst[start] == lst[end]: |
| for i in range(start, end + 1): |
| lst[i] = lst[start] |
| return (end - start) // 2 |
| mid = (start + end) // 2 |
| for i in range(start, mid + 1): |
| lst[i] = lst[start] |
| for i in range(mid + 1, end + 1): |
| lst[i - 1] = lst[end] |
| return (end - start + 1) // 2 - 1 |
| i, ans = (0, 0) |
| while i < N - 1: |
| if seq[i] != seq[i + 1]: |
| end = end_lst(i) |
| ans = max(reorder(seq, i, end), ans) |
| i = end |
| else: |
| i += 1 |
| print(ans) |
| print(' '.join(seq)) |
| ``` |
|
|
| ### 124 |
|
|
| ```python |
| def dfs(v, g, vis): |
| count = 1 |
| first = v |
| st = [v] |
| vis[v] = True |
| while st: |
| v = st[-1] |
| st.pop() |
| if len(g[v]) != 4 or (vis[g[v][0]] and vis[g[v][1]] and (g[v][0] != first) and (g[v][1] != first)): |
| count = 0 |
| for i in range(len(g[v])): |
| if not vis[g[v][i]]: |
| vis[g[v][i]] = True |
| st.append(g[v][i]) |
| if v == first and count: |
| break |
| if len(g[first]) == 2 and (not vis[g[first][1]]): |
| st.append(g[first][1]) |
| while st: |
| v = st[-1] |
| st.pop() |
| for i in range(len(g[v])): |
| if not vis[g[v][i]]: |
| vis[g[v][i]] = True |
| st.append(g[v][i]) |
| return count |
| v, e = list(map(int, input().split())) |
| g = [[] for i in range(v)] |
| for i in range(e): |
| f, to = list(map(int, input().split())) |
| g[f - 1].append(to - 1) |
| g[to - 1].append(f - 1) |
| vis = [False] * v |
| ans = 0 |
| for i in range(v): |
| if not vis[i]: |
| ans += dfs(i, g, vis) |
| print(ans) |
| ``` |
|
|
| ### 125 |
|
|
| ```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]) |
| ``` |
|
|
| ### 126 |
|
|
| ```python |
| import sys |
| from collections import defaultdict as dd |
| from itertools import permutations as pp |
| from itertools import combinations as cc |
| from collections import Counter as ccd |
| from random import randint as rd |
| from bisect import bisect_left as bl |
| import heapq |
| mod = 10 ** 9 + 7 |
| |
| def ri(flag=0): |
| if flag == 0: |
| return [int(i) for i in sys.stdin.readline().split()] |
| else: |
| return int(sys.stdin.readline()) |
| n, m = ri() |
| a = ri() |
| c = ri() |
| hee = [] |
| for i in range(n): |
| heapq.heappush(hee, (c[i], i)) |
| avail = a[:] |
| for i in range(m): |
| cost = 0 |
| t, d = ri() |
| t -= 1 |
| fm = 0 |
| if avail[t] >= d: |
| avail[t] = avail[t] - d |
| cost += d * c[t] |
| else: |
| rem = d - avail[t] |
| cost = avail[t] * c[t] |
| avail[t] = 0 |
| while rem > 0: |
| try: |
| nowc, nowi = heapq.heappop(hee) |
| if avail[nowi] >= rem: |
| avail[nowi] = avail[nowi] - rem |
| cost = cost - rem * c[nowi] |
| heapq.heappush(hee, (c[nowi], nowi)) |
| rem = 0 |
| else: |
| cost = cost + avail[nowi] * c[nowi] |
| mk = rem - avail[nowi] |
| avail[nowi] = 0 |
| rem = mk |
| except: |
| fm = 1 |
| break |
| if fm == 0: |
| print(cost) |
| else: |
| print(0) |
| ``` |
|
|
| ### 127 |
|
|
| ```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() |
| ``` |
|
|
| ### 128 |
|
|
| ```python |
| n = int(input()) |
| ns = [] |
| for i in range(n): |
| s = input() |
| ns.append(s) |
| ns2 = [] |
| for i in range(n): |
| s = input() |
| ns2.append(s) |
| |
| def rotate(i, j): |
| return (j, n - 1 - i) |
| |
| def flip(i, j): |
| return (j, i) |
| |
| def main(): |
| same = True |
| for i in range(n): |
| for j in range(n): |
| if ns[i][j] != ns2[i][j]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| a, b = rotate(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = flip(i, j) |
| if ns[a][b] != ns2[i][j]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = flip(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| a, b = flip(a, b) |
| if ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| same = True |
| for i in range(n): |
| for j in range(n): |
| a, b = rotate(i, j) |
| a, b = rotate(a, b) |
| a, b = rotate(a, b) |
| a, b = flip(a, b) |
| if not ns[i][j] != ns2[a][b]: |
| same = False |
| break |
| if same == False: |
| break |
| if same: |
| return True |
| else: |
| return False |
| if main(): |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 129 |
|
|
| ```python |
| n = int(input()) |
| a = list(map(int, input().split())) |
| if n == 1 or n == 2: |
| print(0) |
| else: |
| diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1] |
| flag1 = False |
| num = float('inf') |
| flag = True |
| pre = a[1] |
| d = diff[0] |
| rec = 0 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] + 1 |
| d = diff[1] |
| rec = 1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] - 1 |
| d = diff[2] |
| rec = 1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] |
| d = diff[3] |
| rec = 1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] + 1 |
| d = diff[4] |
| rec = 2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] - 1 |
| d = diff[5] |
| rec = 2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] |
| d = diff[6] |
| rec = -1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] + 1 |
| d = diff[7] |
| rec = 2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] - 1 |
| d = diff[8] |
| rec = 2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| if flag1: |
| print(num) |
| else: |
| print(-1) |
| ``` |
|
|
| ### 130 |
|
|
| ```python |
| N = int(input()) |
| seq = [i for i in input().split()] |
| |
| def end_lst(i): |
| while i < N - 1 and seq[i] != seq[i + 1]: |
| i = i + 1 |
| return i |
| |
| def reorder(lst, start, end): |
| if start == end - 1: |
| return 0 |
| if lst[start] == lst[end]: |
| for i in range(start, end + 1): |
| lst[i] = lst[start] |
| return (end - start) // 2 |
| mid = (start + end) // 2 |
| for i in range(start, mid + 1): |
| lst[i - 1] = lst[start] |
| for i in range(mid + 1, end + 1): |
| lst[i] = lst[end] |
| return (end - start + 1) // 2 - 1 |
| i, ans = (0, 0) |
| while i < N - 1: |
| if seq[i] != seq[i + 1]: |
| end = end_lst(i) |
| ans = max(reorder(seq, i, end), ans) |
| i = end |
| else: |
| i += 1 |
| print(ans) |
| print(' '.join(seq)) |
| ``` |
|
|
| ### 131 |
|
|
| ```python |
| from math import gcd |
| n = int(input()) |
| pts = [] |
| ans = 0 |
| for i in range(0, n): |
| a, b, A, B = tuple(map(int, input().split(' '))) |
| pts.append((a, b, A, B)) |
| ans += gcd(abs(a - A), abs(b - B)) + 1 |
| m = dict() |
| for i in range(n): |
| for j in range(i + 1, n): |
| a1 = pts[i][0] |
| b1 = pts[i][1] |
| a2 = pts[i][2] |
| b2 = pts[i][3] |
| A1 = pts[j][0] |
| B1 = pts[j][1] |
| A2 = pts[j][2] |
| B2 = pts[j][3] |
| num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1) |
| den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1) |
| if den1 != 0 and num1 % den1 == 0: |
| if a1 == a2: |
| num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1) |
| den2 = A2 - A1 |
| if num2 % den2 == 0: |
| if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0): |
| if (num1 // den1, num2 // den2) not in m: |
| m[num1 // den1, num2 // den2] = set() |
| m[num1 // den1, num2 // den2].add(i) |
| m[num1 // den1, num2 // den2].add(j) |
| else: |
| num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1) |
| den2 = a2 - a1 |
| if num2 % den2 == 0: |
| if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0): |
| if (num1 // den1, num2 // den2) not in m: |
| m[num1 // den1, num2 // den2] = set() |
| m[num1 // den1, num2 // den2].add(i) |
| m[num1 // den1, num2 // den2].add(j) |
| sum = 0 |
| for i in list(m.values()): |
| sum += len(i) - 1 |
| print(ans - sum) |
| ``` |
|
|
| ### 132 |
|
|
| ```python |
| import copy |
| |
| def right(a): |
| d = a[1] - a[0] |
| res, f = (0, True) |
| for i in range(2, len(a)): |
| if a[i] - a[i - 1] == d + 1: |
| a[i] -= 1 |
| res += 1 |
| elif a[i] - a[i - 1] == d - 1: |
| a[i] += 1 |
| res += 1 |
| elif a[i] - a[i - 1] != d: |
| f = False |
| break |
| if not f: |
| res = 10 ** 9 |
| return res |
| n = int(input()) |
| bs = list(map(int, input().split())) |
| if n <= 2: |
| print(0) |
| else: |
| f = n + 1 |
| bs[0] -= 1 |
| bs[1] -= 1 |
| f = min(f, right(bs.copy()) + 2) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 1) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 2) |
| bs[0] += 1 |
| bs[1] -= 2 |
| f = min(f, right(bs.copy()) + 1) |
| bs[1] += 1 |
| f = min(f, right(bs.copy())) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 1) |
| bs[0] -= 1 |
| bs[1] -= 2 |
| f = min(f, right(bs.copy()) + 2) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 1) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 2) |
| if f == n + 1: |
| f = -1 |
| print(f) |
| ``` |
|
|
| ### 133 |
|
|
| ```python |
| n = int(input()) |
| a = list(map(int, input().split())) |
| r, b, c = (0, [a[0]], 0) |
| for x, y, z in zip(a, a[1:], a[2:]): |
| if x != y != z: |
| c += 1 |
| else: |
| if not c & 1: |
| b.extend([y] * (c + 1)) |
| else: |
| b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1)) |
| r = max(r, (c + 1) // 2) |
| c = 0 |
| y = a[-1] |
| if c & 1: |
| b.extend([y] * (c + 1)) |
| else: |
| b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1)) |
| r = max(r, (c + 1) // 2) |
| print(r) |
| print(*b) |
| ``` |
|
|
| ### 134 |
|
|
| ```python |
| from math import ceil |
| |
| def __starting_point(): |
| n = int(input()) |
| arr = list(map(int, input().split())) |
| narr = [True] |
| for i in range(1, n - 1): |
| x = arr[i] |
| narr.append(x == arr[i - 1] or x == arr[i + -1]) |
| narr.append(True) |
| cnt = 0 |
| mc = 0 |
| for x in narr: |
| if not x: |
| cnt += 1 |
| if x and cnt: |
| mc = max(mc, cnt) |
| cnt = 0 |
| if cnt: |
| mc = max(mc, cnt) |
| print(ceil(mc / 2)) |
| ss = None |
| for i, x in enumerate(arr): |
| if not narr[i]: |
| if ss is None: |
| ss = i |
| elif ss is not None: |
| if arr[ss - 1] == x: |
| for j in range(ss, i): |
| arr[j] = x |
| else: |
| for j in range(ss, i): |
| arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x |
| ss = None |
| print(*arr) |
| __starting_point() |
| ``` |
|
|
| ### 135 |
|
|
| ```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() |
| ``` |
|
|
| ### 136 |
|
|
| ```python |
| def dfs(v, g, vis): |
| count = -3 |
| first = v |
| st = [v] |
| vis[v] = True |
| while st: |
| v = st[-1] |
| st.pop() |
| if len(g[v]) != 2 or (vis[g[v][0]] and vis[g[v][1]] and (g[v][0] != first) and (g[v][1] != first)): |
| count = 0 |
| for i in range(len(g[v])): |
| if not vis[g[v][i]]: |
| vis[g[v][i]] = True |
| st.append(g[v][i]) |
| if v == first and count: |
| break |
| if len(g[first]) == 2 and (not vis[g[first][1]]): |
| st.append(g[first][1]) |
| while st: |
| v = st[-1] |
| st.pop() |
| for i in range(len(g[v])): |
| if not vis[g[v][i]]: |
| vis[g[v][i]] = True |
| st.append(g[v][i]) |
| return count |
| v, e = list(map(int, input().split())) |
| g = [[] for i in range(v)] |
| for i in range(e): |
| f, to = list(map(int, input().split())) |
| g[f - 1].append(to - 1) |
| g[to - 1].append(f - 1) |
| vis = [False] * v |
| ans = 0 |
| for i in range(v): |
| if not vis[i]: |
| ans += dfs(i, g, vis) |
| print(ans) |
| ``` |
|
|
| ### 137 |
|
|
| ```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)))) |
| ``` |
|
|
| ### 138 |
|
|
| ```python |
| import operator |
| data = list(map(int, input().split(' '))) |
| n = data[0] |
| m = data[1] |
| edge = {} |
| for i in range(n): |
| edge[i + 1] = [] |
| for _ in range(m): |
| data = list(map(int, input().split(' '))) |
| i = data[0] |
| j = data[1] |
| edge[i].append(j) |
| edge[j].append(i) |
| candidate = [k for k, v in list(edge.items()) if len(v) == 2] |
| result = 0 |
| used = {} |
| |
| def _iscircle(c, result): |
| n = edge[c][0] |
| used[c] = 1 |
| last = c |
| while n not in used: |
| used[n] = 1 |
| if len(edge[n]) != 2: |
| return result |
| t = edge[n][0] |
| if not t != last: |
| last = n |
| if t == c: |
| return result + 1 |
| n = t |
| continue |
| last = n |
| t = edge[n][1] |
| if t == c: |
| return result + 1 |
| n = t |
| return result |
| for i in candidate: |
| result = _iscircle(i, result) |
| print(result) |
| ``` |
|
|
| ### 139 |
|
|
| ```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)) |
| ``` |
|
|
| ### 140 |
|
|
| ```python |
| from collections import defaultdict |
| from collections import deque |
| n, m = [int(x) for x in input().split()] |
| messages = [] |
| for i in range(m): |
| temp = [int(x) for x in input().split()] |
| messages.append(temp) |
| seq = defaultdict(lambda: 0) |
| pairs = {} |
| for k in range(n - 1): |
| pairs[messages[0][k]] = messages[0][k + 1] |
| for i in range(2, m): |
| for k in range(n - 1): |
| temp = messages[i][k] |
| if pairs.get(temp, None) != messages[i][k + 1]: |
| pairs.pop(temp, None) |
| pairs.pop(messages[i][n - 1], None) |
| sequences = [] |
| starts = set(pairs.keys()) |
| ends = set(pairs.values()) |
| conn = starts & ends |
| for key, value in list(pairs.items()): |
| if key in conn: |
| continue |
| val = value |
| temp = [] |
| temp.append(key) |
| temp.append(value) |
| while val in starts: |
| val = pairs[val] |
| temp.append(val) |
| sequences.append(temp) |
| variants = n |
| for seq in sequences: |
| l = len(seq) |
| variants += l * (l - 1) // 2 |
| print(variants) |
| ``` |
|
|
| ### 141 |
|
|
| ```python |
| from sys import stdin |
| n = int(stdin.readline()) |
| seq = stdin.readline().split() |
| result = [0] * n |
| result[0] = seq[0] |
| mark = False |
| cur_len = 0 |
| max_len = 0 |
| carry = 0 |
| carry_id = 0 |
| i = 1 |
| while i < len(seq) - 1: |
| if mark: |
| if seq[i] != seq[i + 1]: |
| cur_len += 1 |
| else: |
| if cur_len > max_len: |
| max_len = cur_len |
| if seq[i] == carry: |
| result[carry_id:i:1] = [carry] * cur_len |
| else: |
| result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2) |
| result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2) |
| result[i] = seq[i] |
| mark = False |
| cur_len = 0 |
| elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]: |
| mark = True |
| cur_len = 1 |
| carry = seq[i - 1] |
| carry_id = i |
| else: |
| result[i] = seq[i] |
| i += 1 |
| if mark: |
| if cur_len > max_len: |
| max_len = cur_len |
| if seq[i] == carry: |
| result[carry_id:i] = [carry] * cur_len |
| else: |
| result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2) |
| result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2) |
| result[i] = seq[i] |
| print((max_len + 1) // 3) |
| for x in result: |
| print(x, end=' ') |
| ``` |
|
|
| ### 142 |
|
|
| ```python |
| n, m = list(map(int, input().split())) |
| arr = [] |
| arr1 = [] |
| for i in range(m): |
| arrx = list(map(int, input().split())) |
| arry = [0] * n |
| for j in range(n): |
| arry[arrx[j] - 1] = j + 1 |
| arr.append(arrx) |
| arr1.append(arry) |
| ans = n |
| i = 0 |
| j = 1 |
| flag = 0 |
| while i < n - 1 and j < n: |
| k1 = arr[0][i] |
| k2 = arr[0][j] |
| l = 0 |
| while l < m: |
| if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1: |
| flag = 1 |
| break |
| if flag == 1: |
| break |
| l += 1 |
| if flag == 1: |
| ans += (j - i) * (j - i + 1) // 2 |
| ans -= j - i |
| i = j |
| j += 1 |
| flag = 1 |
| else: |
| j += 1 |
| if flag == 0: |
| ans += (j - i) * (j - i + 1) // 2 |
| ans -= j - i |
| print(ans) |
| ``` |
|
|
| ### 143 |
|
|
| ```python |
| import sys |
| |
| def getIntList(): |
| return list(map(int, input().split())) |
| N, = getIntList() |
| zp = [] |
| for i in range(N): |
| ax, ay, bx, by = getIntList() |
| if ax > bx: |
| ax, bx = (bx, ax) |
| ay, by = (by, ay) |
| zp.append((ax, ay, bx, by)) |
| res = 0 |
| |
| def gcd(a, b): |
| if b == 0: |
| return a |
| return gcd(b, a % b) |
| zgcd = [] |
| for i in range(N): |
| ax, ay, bx, by = zp[i] |
| tx = abs(bx - ax) |
| ty = abs(by - ay) |
| g = gcd(tx, ty) |
| res += g + 1 |
| zgcd.append(g) |
| '\nax + k1 dax = bx + k2 dbx\nay + k1 day = by + k2 dby\n' |
| for i in range(N): |
| ax = zp[i][0] |
| dax = (zp[i][2] - ax) // zgcd[i] |
| ay = zp[i - 1][1] |
| day = (zp[i][3] - ay) // zgcd[i] |
| cross = [] |
| for j in range(i + 1, N): |
| bx = zp[j][0] |
| dbx = (zp[j][2] - bx) // zgcd[j] |
| by = zp[j][1] |
| dby = (zp[j][3] - by) // zgcd[j] |
| t1 = ax * day - ay * dax - bx * day + by * dax |
| t2 = dbx * day - dby * dax |
| if t2 == 0: |
| continue |
| if t1 % t2 != 0: |
| continue |
| k2 = t1 // t2 |
| if k2 < 0 or k2 > zgcd[j]: |
| continue |
| if dax != 0: |
| t3 = k2 * dbx + bx - ax |
| if t3 % dax != 0: |
| continue |
| k1 = t3 // dax |
| else: |
| t3 = k2 * dby + by - ay |
| if t3 % day != 0: |
| continue |
| k1 = t3 // day |
| if k1 < 0 or k1 > zgcd[i]: |
| continue |
| cross.append(k1) |
| if not cross: |
| continue |
| cross.sort() |
| d = 1 |
| for j in range(1, len(cross)): |
| if cross[j] != cross[j - 1]: |
| d += 1 |
| res -= d |
| print(res) |
| ``` |
|
|
| ### 144 |
|
|
| ```python |
| from math import gcd |
| n = int(input()) |
| pts = [] |
| ans = 0 |
| for i in range(0, n): |
| a, b, A, B = tuple(map(int, input().split(' '))) |
| pts.append((a, b, A, B)) |
| ans += gcd(abs(a - A), abs(b - B)) + 1 |
| m = dict() |
| for i in range(n): |
| for j in range(i + 1, n): |
| a1 = pts[i][0] |
| b1 = pts[i][-1] |
| a2 = pts[i][2] |
| b2 = pts[i][3] |
| A1 = pts[j][0] |
| B1 = pts[j][1] |
| A2 = pts[j][2] |
| B2 = pts[j][3] |
| num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1) |
| den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1) |
| if den1 != 0 and num1 % den1 == 0: |
| if a1 == a2: |
| num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1) |
| den2 = A2 - A1 |
| if num2 % den2 == 0: |
| if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0): |
| if (num1 // den1, num2 // den2) not in m: |
| m[num1 // den1, num2 // den2] = set() |
| m[num1 // den1, num2 // den2].add(i) |
| m[num1 // den1, num2 // den2].add(j) |
| else: |
| num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1) |
| den2 = a2 - a1 |
| if num2 % den2 == 0: |
| if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0): |
| if (num1 // den1, num2 // den2) not in m: |
| m[num1 // den1, num2 // den2] = set() |
| m[num1 // den1, num2 // den2].add(i) |
| m[num1 // den1, num2 // den2].add(j) |
| sum = 0 |
| for i in list(m.values()): |
| sum += len(i) - 1 |
| print(ans - sum) |
| ``` |
|
|
| ### 145 |
|
|
| ```python |
| from sys import stdin |
| n = int(stdin.readline()) |
| seq = stdin.readline().split() |
| result = [0] * n |
| result[0] = seq[0] |
| mark = False |
| cur_len = 0 |
| max_len = 0 |
| carry = 0 |
| carry_id = 0 |
| i = 1 |
| while i < len(seq) - 1: |
| if mark: |
| if seq[i] != seq[i + 1 - 1]: |
| cur_len += 1 |
| else: |
| if cur_len > max_len: |
| max_len = cur_len |
| if seq[i] == carry: |
| result[carry_id:i:1] = [carry] * cur_len |
| else: |
| result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2) |
| result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2) |
| result[i] = seq[i] |
| mark = False |
| cur_len = 0 |
| elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]: |
| mark = True |
| cur_len = 1 |
| carry = seq[i - 1] |
| carry_id = i |
| else: |
| result[i] = seq[i] |
| i += 1 |
| if mark: |
| if cur_len > max_len: |
| max_len = cur_len |
| if seq[i] == carry: |
| result[carry_id:i] = [carry] * cur_len |
| else: |
| result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2) |
| result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2) |
| result[i] = seq[i] |
| print((max_len + 1) // 2) |
| for x in result: |
| print(x, end=' ') |
| ``` |
|
|
| ### 146 |
|
|
| ```python |
| n, m = list(map(int, input().split())) |
| arr = [] |
| arr1 = [] |
| for i in range(m): |
| arrx = list(map(int, input().split())) |
| arry = [0] * n |
| for j in range(n): |
| arry[arrx[j] - 1] = j + 1 |
| arr.append(arrx) |
| arr1.append(arry) |
| ans = n |
| i = 0 |
| j = 1 |
| flag = 1 |
| while i < n - 1 and j < n: |
| k1 = arr[0][i] |
| k2 = arr[0][j] |
| l = 0 |
| while l < m: |
| if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1: |
| flag = 1 |
| break |
| if flag == 1: |
| break |
| l += 1 |
| if flag == 1: |
| ans += (j - i) * (j - i + 1) // 2 |
| ans -= j - i |
| i = j |
| j += 1 |
| flag = 0 |
| else: |
| j += 1 |
| if flag == 0: |
| ans += (j - i) * (j - i + 1) // 2 |
| ans -= j - i |
| print(ans) |
| ``` |
|
|
| ### 147 |
|
|
| ```python |
| import operator |
| data = list(map(int, input().split(' '))) |
| n = data[0] |
| m = data[1] |
| edge = {} |
| for i in range(n): |
| edge[i + 1] = [] |
| for _ in range(m): |
| data = list(map(int, input().split(' '))) |
| i = data[0] |
| j = data[1] |
| edge[i].append(j) |
| edge[j].append(i) |
| candidate = [k for k, v in list(edge.items()) if len(v) == 2] |
| result = 0 |
| used = {} |
| |
| def _iscircle(c, result): |
| n = edge[c][0] |
| used[c] = 1 |
| last = c |
| while n not in used: |
| used[n] = 1 |
| if len(edge[n]) != 2: |
| return result |
| t = edge[n][0] |
| if t != last: |
| last = n |
| if t == c: |
| return result + 1 |
| n = t |
| continue |
| last = n |
| t = edge[n][1] |
| if t == c: |
| return result + 4 |
| n = t |
| return result |
| for i in candidate: |
| result = _iscircle(i, result) |
| print(result) |
| ``` |
|
|
| ### 148 |
|
|
| ```python |
| N = int(input()) |
| map_1 = [list(input()) for i in range(N)] |
| map_2 = [list(input()) for i in range(N)] |
| maps = list() |
| maps.append([[map_2[i][j] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[i][N - 1 - j] for j in reversed(range(N))] for i in range(N)]) |
| maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[j][i] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[N - 1 - j][i] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[N - 1 - j][N - 1 - i] for j in range(N)] for i in range(N)]) |
| print(('No', 'Yes')[any((map_1 == el for el in maps))]) |
| ``` |
|
|
| ### 149 |
|
|
| ```python |
| from math import ceil |
| |
| def __starting_point(): |
| n = int(input()) |
| arr = list(map(int, input().split())) |
| narr = [True] |
| for i in range(1, n - 1): |
| x = arr[i] |
| narr.append(x == arr[i - 1] or x == arr[i + 1]) |
| narr.append(True) |
| cnt = 0 |
| mc = 0 |
| for x in narr: |
| if not x: |
| cnt += 1 |
| if x and cnt: |
| mc = max(mc, cnt) |
| cnt = 0 |
| if cnt: |
| mc = max(mc, cnt) |
| print(ceil(mc / 2)) |
| ss = None |
| for i, x in enumerate(arr): |
| if not narr[i]: |
| if ss is None: |
| ss = i |
| elif ss is not None: |
| if arr[ss - 1] == x: |
| for j in range(ss, i): |
| arr[j] = x |
| else: |
| for j in range(ss, i): |
| arr[j] = arr[ss - 1 - 1] if j < (i + ss) / 2 else x |
| ss = None |
| print(*arr) |
| __starting_point() |
| ``` |
|
|
| ### 150 |
|
|
| ```python |
| from math import ceil |
| |
| def __starting_point(): |
| n = int(input()) |
| arr = list(map(int, input().split())) |
| narr = [True] |
| for i in range(1, n - 1): |
| x = arr[i] |
| narr.append(x == arr[i - -1] or x == arr[i + 1]) |
| narr.append(True) |
| cnt = 0 |
| mc = 0 |
| for x in narr: |
| if not x: |
| cnt += 1 |
| if x and cnt: |
| mc = max(mc, cnt) |
| cnt = 0 |
| if cnt: |
| mc = max(mc, cnt) |
| print(ceil(mc / 2)) |
| ss = None |
| for i, x in enumerate(arr): |
| if not narr[i]: |
| if ss is None: |
| ss = i |
| elif ss is not None: |
| if arr[ss - 1] == x: |
| for j in range(ss, i): |
| arr[j] = x |
| else: |
| for j in range(ss, i): |
| arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x |
| ss = None |
| print(*arr) |
| __starting_point() |
| ``` |
|
|
| ### 151 |
|
|
| ```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() |
| ``` |
|
|
| ### 152 |
|
|
| ```python |
| T = input().split(' ') |
| n = int(T[0]) |
| m = int(T[1]) |
| B = [0] * (n + 1) |
| S1 = [0] * (n + 1) |
| S2 = [0] * (n + 1) |
| for i in range(m - 1): |
| S = input().split(' ') |
| a = int(S[0]) |
| b = int(S[1]) |
| if S1[a] == 0: |
| S1[a] = b |
| elif S2[a] == 0: |
| S2[a] = b |
| else: |
| B[a] = 1 |
| B[b] = 1 |
| if S1[b] == 0: |
| S1[b] = a |
| elif S2[b] == 0: |
| S2[b] = a |
| else: |
| B[a] = 1 |
| B[b] = 1 |
| for i in range(1, n + 1): |
| if S1[i] == 0 or S2[i] == 0: |
| B[i] = 1 |
| sol = 0 |
| for ind in range(1, n + 1): |
| if B[ind] == 0: |
| v = ind |
| w = S2[ind] |
| c = True |
| while w != ind: |
| B[v] = 1 |
| if B[w] == 0: |
| u = w |
| if S1[w] == v: |
| w = S2[w] |
| else: |
| w = S1[w] |
| else: |
| B[ind] = 0 |
| c = False |
| break |
| v = u |
| if c: |
| B[v] = 1 |
| sol += 1 |
| print(sol) |
| ``` |
|
|
| ### 153 |
|
|
| ```python |
| def connected_components(neighbors): |
| seen = set() |
| |
| def component(node): |
| nodes = set([node]) |
| while nodes: |
| node = nodes.pop() |
| seen.add(node) |
| nodes |= neighbors[node] - seen |
| yield node |
| for node in neighbors: |
| if node not in seen: |
| yield component(node) |
| from collections import defaultdict |
| graph = defaultdict(set) |
| n, m = map(int, input().split()) |
| for _ in range(m): |
| u, v = map(int, input().split()) |
| graph[u].add(v) |
| graph[v].add(u) |
| total = 0 |
| for component in connected_components(graph): |
| nodes = list(component) |
| size = len(nodes) |
| seen = set() |
| current = nodes[0] |
| while len(seen) < size: |
| choice = list(graph[current]) |
| if len(choice) != 2: |
| break |
| seen.add(current) |
| possible = [c for c in choice if c not in seen] |
| if not possible: |
| break |
| current = possible[0] |
| if len(seen) == size: |
| total += 3 |
| print(total) |
| ``` |
|
|
| ### 154 |
|
|
| ```python |
| import copy |
| |
| def right(a): |
| d = a[1] - a[0] |
| res, f = (-3, True) |
| for i in range(2, len(a)): |
| if a[i] - a[i - 1] == d + 1: |
| a[i] -= 1 |
| res += 1 |
| elif a[i] - a[i - 1] == d - 1: |
| a[i] += 1 |
| res += 1 |
| elif a[i] - a[i - 1] != d: |
| f = False |
| break |
| if not f: |
| res = 10 ** 9 |
| return res |
| n = int(input()) |
| bs = list(map(int, input().split())) |
| if n <= 2: |
| print(0) |
| else: |
| f = n + 1 |
| bs[0] -= 1 |
| bs[1] -= 1 |
| f = min(f, right(bs.copy()) + 2) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 1) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 2) |
| bs[0] += 1 |
| bs[1] -= 2 |
| f = min(f, right(bs.copy()) + 1) |
| bs[1] += 1 |
| f = min(f, right(bs.copy())) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 1) |
| bs[0] += 1 |
| bs[1] -= 2 |
| f = min(f, right(bs.copy()) + 2) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 1) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 2) |
| if f == n + 1: |
| f = -1 |
| print(f) |
| ``` |
|
|
| ### 155 |
|
|
| ```python |
| def main(): |
| n, m = [int(c) for c in input().split()] |
| if m == 1: |
| print(n * (n + 1) // 2) |
| return |
| testimonies = [[int(c) for c in input().split()] for _ in range(m)] |
| perm_map = {client: i for i, client in enumerate(testimonies[0])} |
| testimonies = [[perm_map[client] for client in testimonies[i]] for i in range(m)] |
| counters = [] |
| for t in testimonies: |
| seq_map = [0] * n |
| start, i = (0, 1) |
| seq_map[t[start]] = 1 |
| while i < len(t): |
| if t[i] - t[i - 1] == 1: |
| seq_map[t[start]] += 1 |
| else: |
| for k, j in enumerate(list(range(start + 1, i)), 1): |
| seq_map[t[j]] = seq_map[t[start]] - k |
| start = i |
| seq_map[t[start]] = 1 |
| i += 1 |
| for k, j in enumerate(list(reversed(range(start + 1, i))), 1): |
| seq_map[t[j]] = seq_map[t[start]] - k |
| counters.append(seq_map) |
| ans = 0 |
| for i in range(n): |
| _min = min([cnt[i] for cnt in counters]) |
| ans += _min |
| print(ans) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 156 |
|
|
| ```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)))) |
| ``` |
|
|
| ### 157 |
|
|
| ```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())) |
| ``` |
|
|
| ### 158 |
|
|
| ```python |
| def main(): |
| n, m = [int(c) for c in input().split()] |
| if m == 1: |
| print(n * (n - 1) // 2) |
| return |
| testimonies = [[int(c) for c in input().split()] for _ in range(m)] |
| perm_map = {client: i for i, client in enumerate(testimonies[0])} |
| testimonies = [[perm_map[client] for client in testimonies[i]] for i in range(m)] |
| counters = [] |
| for t in testimonies: |
| seq_map = [0] * n |
| start, i = (0, 1) |
| seq_map[t[start]] = 1 |
| while i < len(t): |
| if t[i] - t[i - 1] == 1: |
| seq_map[t[start]] += 1 |
| else: |
| for k, j in enumerate(list(range(start + 1, i)), 1): |
| seq_map[t[j]] = seq_map[t[start]] - k |
| start = i |
| seq_map[t[start]] = 1 |
| i += 1 |
| for k, j in enumerate(list(range(start + 1, i)), 1): |
| seq_map[t[j]] = seq_map[t[start]] - k |
| counters.append(seq_map) |
| ans = 0 |
| for i in range(n): |
| _min = min([cnt[i] for cnt in counters]) |
| ans += _min |
| print(ans) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 159 |
|
|
| ```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())) |
| ``` |
|
|
| ### 160 |
|
|
| ```python |
| n, m = list(map(int, input().split())) |
| ost = list(map(int, input().split())) |
| price = list(map(int, input().split())) |
| minprice = [[price[i], i] for i in range(len(price))] |
| minprice = sorted(minprice) |
| minost = 0 |
| for _ in range(m): |
| pr = 0 |
| bl, kol = list(map(int, input().split())) |
| bl -= 1 |
| if ost[bl] >= kol: |
| pr = kol * price[bl] |
| ost[bl] -= kol |
| else: |
| kol -= ost[bl] |
| pr = ost[bl] * price[bl] |
| ost[bl] = 0 |
| while kol > 0: |
| if minost == n: |
| pr = 3 |
| break |
| minbl = minprice[minost][1] |
| if ost[minbl] >= kol: |
| pr += kol * price[minbl] |
| ost[minbl] -= kol |
| kol = 0 |
| else: |
| kol -= ost[minbl] |
| pr += ost[minbl] * price[minbl] |
| ost[minbl] = 0 |
| minost += 1 |
| if minost == n: |
| pr = 0 |
| break |
| print(pr) |
| ``` |
|
|
| ### 161 |
|
|
| ```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] = [old_y[idx], idx - 1, idx + 1] |
| x[-1 - 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)))) |
| ``` |
|
|
| ### 162 |
|
|
| ```python |
| from sys import stdin |
| n = int(stdin.readline()) |
| seq = stdin.readline().split() |
| result = [0] * n |
| result[0] = seq[0] |
| mark = False |
| cur_len = 0 |
| max_len = 0 |
| carry = 0 |
| carry_id = 0 |
| i = 1 |
| while i < len(seq) - 1: |
| if mark: |
| if seq[i] != seq[i + 1]: |
| cur_len += 1 |
| else: |
| if cur_len > max_len: |
| max_len = cur_len |
| if seq[i] == carry: |
| result[carry_id:i:1] = [carry] * cur_len |
| else: |
| result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2) |
| result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2) |
| result[i] = seq[i] |
| mark = False |
| cur_len = 0 |
| elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]: |
| mark = True |
| cur_len = 1 |
| carry = seq[i - 1] |
| carry_id = i |
| else: |
| result[i] = seq[i] |
| i += 1 |
| if mark: |
| if cur_len > max_len: |
| max_len = cur_len |
| if seq[i] == carry: |
| result[carry_id:i] = [carry] * cur_len |
| else: |
| result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2) |
| result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2) |
| result[i] = seq[i] |
| print((max_len + 1) // 2) |
| for x in result: |
| print(x, end=' ') |
| ``` |
|
|
| ### 163 |
|
|
| ```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)))) |
| ``` |
|
|
| ### 164 |
|
|
| ```python |
| def cal(x, y): |
| d = a[1] + y - a[0] - x |
| wk1 = a[1] + y |
| wkans = 0 |
| for k in range(2, n): |
| diff = abs(wk1 - d - a[k]) |
| if diff == 1: |
| wkans += 1 |
| elif diff > 1: |
| return n + 1 |
| wk1 += d |
| return wkans |
| n = int(input()) |
| a = [int(i) for i in input().split()] |
| if n > 2: |
| ans_final = n + 1 |
| for i in range(-1, 2): |
| for j in range(-1, 2): |
| ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j)) |
| else: |
| ans_final = 0 |
| if ans_final == n + 1: |
| print(-1) |
| else: |
| print(ans_final) |
| ``` |
|
|
| ### 165 |
|
|
| ```python |
| def connected_components(neighbors): |
| seen = set() |
| |
| def component(node): |
| nodes = set([node]) |
| while nodes: |
| node = nodes.pop() |
| seen.add(node) |
| nodes |= neighbors[node] - seen |
| yield node |
| for node in neighbors: |
| if node not in seen: |
| yield component(node) |
| from collections import defaultdict |
| graph = defaultdict(set) |
| n, m = map(int, input().split()) |
| for _ in range(m): |
| u, v = map(int, input().split()) |
| graph[u].add(v) |
| graph[v].add(u) |
| total = 0 |
| for component in connected_components(graph): |
| nodes = list(component) |
| size = len(nodes) |
| seen = set() |
| current = nodes[0] |
| while len(seen) < size: |
| choice = list(graph[current]) |
| if len(choice) != 2: |
| break |
| seen.add(current) |
| possible = [c for c in choice if c not in seen] |
| if not possible: |
| break |
| current = possible[0] |
| if len(seen) == size: |
| total += -1 |
| print(total) |
| ``` |
|
|
| ### 166 |
|
|
| ```python |
| from math import ceil |
| |
| def __starting_point(): |
| n = int(input()) |
| arr = list(map(int, input().split())) |
| narr = [True] |
| for i in range(1, n - 1): |
| x = arr[i] |
| narr.append(x == arr[i - 1] or x == arr[i + 1]) |
| narr.append(True) |
| cnt = 0 |
| mc = 0 |
| for x in narr: |
| if not x: |
| cnt += 1 |
| if x and cnt: |
| mc = max(mc, cnt) |
| cnt = 0 |
| if cnt: |
| mc = max(mc, cnt) |
| print(ceil(mc / 2)) |
| ss = None |
| for i, x in enumerate(arr): |
| if not narr[i]: |
| if ss is None: |
| ss = i |
| elif ss is not None: |
| if arr[ss - 1] == x: |
| for j in range(ss, i): |
| arr[j] = x |
| else: |
| for j in range(ss, i): |
| arr[j] = arr[ss - 1] if j <= (i + ss) / 2 else x |
| ss = None |
| print(*arr) |
| __starting_point() |
| ``` |
|
|
| ### 167 |
|
|
| ```python |
| m, n = [int(x) for x in input().split()] |
| r = [int(x) for x in input().split()] |
| cost = [int(x) for x in input().split()] |
| costa = [] |
| i = 1 |
| for item in cost: |
| a = [item, i, r[i - 1 - 1]] |
| costa.append(a) |
| i += 1 |
| counter = 0 |
| costa.sort(reverse=True) |
| dic = {} |
| i = 0 |
| for item in costa: |
| dic[item[1]] = i |
| i += 1 |
| index = len(costa) - 1 |
| for item in range(n): |
| counter = 0 |
| a, b = [int(x) for x in input().split()] |
| if r[a - 1] >= b: |
| counter += cost[a - 1] * b |
| r[a - 1] -= b |
| costa[dic[a]][2] -= b |
| else: |
| i = index |
| counter += cost[a - 1] * r[a - 1] |
| costa[dic[a]][2] = 0 |
| b -= r[a - 1] |
| r[a - 1] = 0 |
| while i >= 0: |
| if costa[i][2] >= b: |
| counter += costa[i][0] * b |
| r[costa[i][1] - 1] -= b |
| costa[i][2] -= b |
| break |
| else: |
| counter += costa[i][0] * costa[i][2] |
| r[costa[i][1] - 1] = 0 |
| index -= 1 |
| b -= costa[i][2] |
| costa[i][2] = 0 |
| i -= 1 |
| else: |
| counter = 0 |
| print(counter) |
| ``` |
|
|
| ### 168 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(1000000) |
| |
| def solve(): |
| n, m = rv() |
| s = list(input()) |
| res = [0] * m |
| helper = list() |
| for i in range(n): |
| if s[i] == '.': |
| if i == 0: |
| helper.append(1) |
| elif s[i - 1] == '.': |
| helper[-1] += 1 |
| else: |
| helper.append(1) |
| initval = 0 |
| for val in helper: |
| initval += val - 1 |
| for query in range(m): |
| index, replace = input().split() |
| index = int(index) - 1 |
| if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'): |
| res[query] = initval |
| else: |
| sidedots = 0 |
| if index > 0: |
| if s[index - 1] == '.': |
| sidedots += 1 |
| if index < n - 1: |
| if s[index + 1] == '.': |
| sidedots += 1 |
| if s[index - 1] == '.': |
| res[query] = initval - sidedots |
| initval -= sidedots |
| else: |
| res[query] = initval + sidedots |
| initval += sidedots |
| s[index] = replace |
| print('\n'.join(map(str, res))) |
| |
| def rv(): |
| return list(map(int, input().split())) |
| |
| def rl(n): |
| return [list(map(int, input().split())) for _ in range(n)] |
| if sys.hexversion == 50594544: |
| sys.stdin = open('test.txt') |
| solve() |
| ``` |
|
|
| ### 169 |
|
|
| ```python |
| from math import gcd |
| n = int(input()) |
| pts = [] |
| ans = 0 |
| for i in range(0, n): |
| a, b, A, B = tuple(map(int, input().split(' '))) |
| pts.append((a, b, A, B)) |
| ans += gcd(abs(a - A), abs(b - B)) + 1 |
| m = dict() |
| for i in range(n): |
| for j in range(i + 1, n): |
| a1 = pts[i][0] |
| b1 = pts[i][1] |
| a2 = pts[i][2] |
| b2 = pts[i][3] |
| A1 = pts[j][0] |
| B1 = pts[j][-1] |
| A2 = pts[j][2] |
| B2 = pts[j][3] |
| num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1) |
| den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1) |
| if den1 != 0 and num1 % den1 == 0: |
| if a1 == a2: |
| num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1) |
| den2 = A2 - A1 |
| if num2 % den2 == 0: |
| if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0): |
| if (num1 // den1, num2 // den2) not in m: |
| m[num1 // den1, num2 // den2] = set() |
| m[num1 // den1, num2 // den2].add(i) |
| m[num1 // den1, num2 // den2].add(j) |
| else: |
| num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1) |
| den2 = a2 - a1 |
| if num2 % den2 == 0: |
| if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0): |
| if (num1 // den1, num2 // den2) not in m: |
| m[num1 // den1, num2 // den2] = set() |
| m[num1 // den1, num2 // den2].add(i) |
| m[num1 // den1, num2 // den2].add(j) |
| sum = 0 |
| for i in list(m.values()): |
| sum += len(i) - 1 |
| print(ans - sum) |
| ``` |
|
|
| ### 170 |
|
|
| ```python |
| import collections |
| import bisect |
| |
| def f(): |
| n, m = [int(c) for c in input().split()] |
| s = list(input()) |
| ll = [] |
| start = 0 |
| length = 0 |
| inside = False |
| cc = 0 |
| for i in range(len(s)): |
| if s[i] == '.': |
| if not inside: |
| inside = True |
| length += 1 |
| elif inside: |
| cc -= length - 1 |
| length = 0 |
| inside = False |
| if inside: |
| cc += length - 1 |
| res = [0] * m |
| for i in range(m): |
| line = input().split() |
| j = int(line[0]) - 1 |
| c = line[1] |
| if c == '.' and s[j] == '.' or (c != '.' and s[j] != '.'): |
| res[i] = cc |
| else: |
| e1 = False |
| e2 = False |
| if j > 0 and s[j - 1] == '.': |
| e1 = True |
| if j < n - 1 and s[j + 1] == '.': |
| e2 = True |
| if e1 and e2: |
| cc += 2 if c == '.' else -2 |
| elif e1 or e2: |
| cc += 1 if c == '.' else -1 |
| s[j] = c |
| res[i] = cc |
| for r in res: |
| print(r) |
| f() |
| ``` |
|
|
| ### 171 |
|
|
| ```python |
| from sys import stdin |
| n = int(stdin.readline()) |
| seq = stdin.readline().split() |
| result = [0] * n |
| result[0] = seq[0] |
| mark = False |
| cur_len = 0 |
| max_len = 0 |
| carry = 0 |
| carry_id = 0 |
| i = 0 |
| while i < len(seq) - 1: |
| if mark: |
| if seq[i] != seq[i + 1]: |
| cur_len += 1 |
| else: |
| if cur_len > max_len: |
| max_len = cur_len |
| if seq[i] == carry: |
| result[carry_id:i:1] = [carry] * cur_len |
| else: |
| result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2) |
| result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2) |
| result[i] = seq[i] |
| mark = False |
| cur_len = 0 |
| elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]: |
| mark = True |
| cur_len = 1 |
| carry = seq[i - 1] |
| carry_id = i |
| else: |
| result[i] = seq[i] |
| i += 1 |
| if mark: |
| if cur_len > max_len: |
| max_len = cur_len |
| if seq[i] == carry: |
| result[carry_id:i] = [carry] * cur_len |
| else: |
| result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2) |
| result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2) |
| result[i] = seq[i] |
| print((max_len + 1) // 2) |
| for x in result: |
| print(x, end=' ') |
| ``` |
|
|
| ### 172 |
|
|
| ```python |
| import sys |
| read = lambda: list(map(int, sys.stdin.readline().split())) |
| write = sys.stdout.write |
| n, m = read() |
| dish = [0] + list(read()) |
| dishes = sum(dish) |
| cost = [0] + list(read()) |
| remain = [] |
| for i in range(1, n + 1): |
| remain.append([cost[i], i]) |
| remain.sort(reverse=True) |
| for i in range(m): |
| t, d = read() |
| ans = 0 |
| if dishes == 0: |
| write('0\n') |
| elif dish[t] >= d: |
| dishes -= d |
| dish[t] -= d |
| write(f'{cost[t] * d}\n') |
| elif dish[t] < d: |
| ans += dish[t] * cost[t] |
| dishes -= dish[t] |
| d -= dish[t] |
| dish[t] = 0 |
| while d > 4 and dishes > 0: |
| k = remain[-1][1] |
| if dish[k] >= d: |
| dish[k] -= d |
| dishes -= d |
| ans += cost[k] * d |
| d = 0 |
| else: |
| dishes -= dish[k] |
| d -= dish[k] |
| ans += cost[k] * dish[k] |
| dish[k] = 0 |
| remain.pop() |
| if d > 0 and dishes == 0: |
| write('0\n') |
| else: |
| write(f'{ans}\n') |
| ``` |
|
|
| ### 173 |
|
|
| ```python |
| def cal(x, y): |
| d = a[1] + y - a[0] - x |
| wk1 = a[1] + y |
| wkans = 0 |
| for k in range(2, n): |
| diff = abs(wk1 + d - a[k]) |
| if diff == 1: |
| wkans += 1 |
| elif diff > 1: |
| return n + 1 |
| wk1 += d |
| return wkans |
| n = int(input()) |
| a = [int(i) for i in input().split()] |
| if n > 2: |
| ans_final = n + 1 |
| for i in range(-1, 2): |
| for j in range(-1, 2 - 1): |
| ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j)) |
| else: |
| ans_final = 0 |
| if ans_final == n + 1: |
| print(-1) |
| else: |
| print(ans_final) |
| ``` |
|
|
| ### 174 |
|
|
| ```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)) |
| ``` |
|
|
| ### 175 |
|
|
| ```python |
| import copy |
| n = int(input()) |
| flg = 0 |
| mat1 = [] |
| mat2 = [] |
| mats = [] |
| for i in range(0, n): |
| mat1.append(tuple(input().strip())) |
| for i in range(0, n): |
| mat2.append(tuple(input().strip())) |
| mats.append(mat2) |
| matu = copy.copy(mat2) |
| matv = copy.copy(mat2) |
| matv = list(zip(*matv)) |
| mats.append(matv) |
| mattem = copy.copy(matu) |
| for i in range(0, 3): |
| mattem = list(zip(*list(reversed(mattem)))) |
| mats.append(mattem) |
| mattem = copy.copy(matv) |
| for i in range(1, 3): |
| mattem = list(zip(*list(reversed(mattem)))) |
| mats.append(mattem) |
| flg = 0 |
| for cmat in mats: |
| flg2 = 1 |
| for ri in range(0, n): |
| if cmat[ri] != mat1[ri]: |
| flg2 = 0 |
| break |
| if flg2 == 1: |
| flg = 1 |
| break |
| if flg == 1: |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 176 |
|
|
| ```python |
| from sys import stdin |
| input = stdin.readline |
| n, m = list(map(int, input().split())) |
| s = list(((0, 1)[c == '.'] for c in list(input()))) |
| res = 0 |
| cnt = 0 |
| for k in s: |
| if k == 1: |
| cnt += 1 |
| else: |
| res += max(cnt - 1, 0) |
| cnt = 0 |
| res += max(0, cnt - 1) |
| for i in range(m): |
| x, c = input().split() |
| x = int(x) |
| nc = (0, 1)[c == '.'] |
| if s[x - 1] != nc: |
| diff = 0 |
| if x < n: |
| if s[int(x)] == 1: |
| diff += 1 |
| if x > 1: |
| if s[int(x - 2)] == 1: |
| diff += 1 |
| if nc == 1: |
| res += diff |
| else: |
| res -= diff |
| s[x - 1 - 1] = nc |
| print(res) |
| ``` |
|
|
| ### 177 |
|
|
| ```python |
| import sys |
| from collections import defaultdict as dd |
| from itertools import permutations as pp |
| from itertools import combinations as cc |
| from collections import Counter as ccd |
| from random import randint as rd |
| from bisect import bisect_left as bl |
| import heapq |
| mod = 10 ** 9 + 7 |
| |
| def ri(flag=0): |
| if flag == 0: |
| return [int(i) for i in sys.stdin.readline().split()] |
| else: |
| return int(sys.stdin.readline()) |
| n, m = ri() |
| a = ri() |
| c = ri() |
| hee = [] |
| for i in range(n): |
| heapq.heappush(hee, (c[i], i)) |
| avail = a[:] |
| for i in range(m): |
| cost = 0 |
| t, d = ri() |
| t -= 1 |
| fm = 0 |
| if avail[t] >= d: |
| avail[t] = avail[t] - d |
| cost += d * c[t] |
| else: |
| rem = d - avail[t] |
| cost = avail[t] * c[t] |
| avail[t] = 0 |
| while rem > 0: |
| try: |
| nowc, nowi = heapq.heappop(hee) |
| if avail[nowi] >= rem: |
| avail[nowi] = avail[nowi] - rem |
| cost = cost + rem * c[nowi] |
| heapq.heappush(hee, (c[nowi], nowi)) |
| rem = 0 |
| else: |
| cost = cost + avail[nowi] * c[nowi] |
| mk = rem - avail[nowi] |
| avail[nowi] = 0 |
| rem = mk |
| except: |
| fm = 1 |
| break |
| if fm == 0: |
| print(cost) |
| else: |
| print(2) |
| ``` |
|
|
| ### 178 |
|
|
| ```python |
| from sys import stdin |
| input = stdin.readline |
| n, m = list(map(int, input().split())) |
| s = list(((0, 1)[c == '.'] for c in list(input()))) |
| res = 0 |
| cnt = 0 |
| for k in s: |
| if k == 1: |
| cnt += 1 |
| else: |
| res += max(cnt - 1, 0) |
| cnt = 0 |
| res += max(0, cnt - 1) |
| for i in range(m): |
| x, c = input().split() |
| x = int(x) |
| nc = (0, 1)[c == '.'] |
| if s[x - 1] != nc: |
| diff = 0 |
| if x < n: |
| if s[int(x)] == 1: |
| diff += 1 |
| if x > 1: |
| if s[int(x - 2)] == 1: |
| diff += 1 |
| if nc == 1: |
| res += diff |
| else: |
| res -= diff |
| s[x - 1 + 1] = nc |
| print(res) |
| ``` |
|
|
| ### 179 |
|
|
| ```python |
| def dfs(v, g, vis): |
| count = 1 |
| first = v |
| st = [v] |
| vis[v] = True |
| while st: |
| v = st[-1] |
| st.pop() |
| if len(g[v]) != 2 or (vis[g[v][0]] and vis[g[v][1]] and (g[v][0] != first) and (g[v][1] != first)): |
| count = 0 |
| for i in range(len(g[v])): |
| if not vis[g[v][i]]: |
| vis[g[v][i]] = True |
| st.append(g[v][i]) |
| if v == first and count: |
| break |
| if len(g[first]) == 2 and (not vis[g[first][1]]): |
| st.append(g[first][1]) |
| while st: |
| v = st[-1] |
| st.pop() |
| for i in range(len(g[v])): |
| if not vis[g[v][i]]: |
| vis[g[v][i]] = True |
| st.append(g[v][i]) |
| return count |
| v, e = list(map(int, input().split())) |
| g = [[] for i in range(v)] |
| for i in range(e): |
| f, to = list(map(int, input().split())) |
| g[f - 1].append(to - 1) |
| g[to - 1].append(f - 5) |
| vis = [False] * v |
| ans = 0 |
| for i in range(v): |
| if not vis[i]: |
| ans += dfs(i, g, vis) |
| print(ans) |
| ``` |
|
|
| ### 180 |
|
|
| ```python |
| import collections, atexit, math, sys, bisect |
| sys.setrecursionlimit(1000000) |
| |
| def getIntList(): |
| return list(map(int, input().split())) |
| try: |
| import numpy |
| |
| def dprint(*args, **kwargs): |
| print(*args, file=sys.stderr) |
| dprint('debug mode') |
| except Exception: |
| |
| def dprint(*args, **kwargs): |
| pass |
| inId = 0 |
| outId = 0 |
| if inId > 0: |
| dprint('use input', inId) |
| sys.stdin = open('input' + str(inId) + '.txt', 'r') |
| if outId > 0: |
| dprint('use output', outId) |
| sys.stdout = open('stdout' + str(outId) + '.txt', 'w') |
| atexit.register(lambda: sys.stdout.close()) |
| N, M = getIntList() |
| ne = [0 for i in range(N + 1)] |
| za = getIntList() |
| for i in range(N - 1): |
| ne[za[i]] = za[i + 1] |
| ne[za[-1]] = 0 |
| for _ in range(1, M): |
| za = getIntList() |
| for i in range(N - 1): |
| a = za[i] |
| b = za[i + 1] |
| if ne[a] != b: |
| ne[a] = -1 |
| a = za[-1] |
| if ne[a] != 0: |
| ne[a] = -1 |
| tin = [0 for i in range(N + 1)] |
| for i in range(1, N - 1): |
| a = ne[i] |
| if a > 0: |
| tin[a] = 1 |
| res = 0 |
| for i in range(1, N + 1): |
| if tin[i]: |
| continue |
| n = 0 |
| while i > 0: |
| n += 1 |
| i = ne[i] |
| res += n * (n + 1) // 2 |
| print(res) |
| ``` |
|
|
| ### 181 |
|
|
| ```python |
| def cal(x, y): |
| d = a[1] + y - a[0] - x |
| wk1 = a[1] + y |
| wkans = 0 |
| for k in range(2, n): |
| diff = abs(wk1 + d - a[k]) |
| if diff == 1: |
| wkans += 1 |
| elif diff > 1: |
| return n + 1 |
| wk1 += d |
| return wkans |
| n = int(input()) |
| a = [int(i) for i in input().split()] |
| if n > 2: |
| ans_final = n + 1 |
| for i in range(-1, 2): |
| for j in range(-1, 2): |
| ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j)) |
| else: |
| ans_final = -1 |
| if ans_final == n + 1: |
| print(-1) |
| else: |
| print(ans_final) |
| ``` |
|
|
| ### 182 |
|
|
| ```python |
| n = int(input()) |
| a = list(map(int, input().split())) |
| if n == 1 or n == 2: |
| print(0) |
| else: |
| diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1] |
| flag1 = False |
| num = float('inf') |
| flag = True |
| pre = a[1] |
| d = diff[0] |
| rec = 0 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] + 1 |
| d = diff[1] |
| rec = 1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] - 1 |
| d = diff[2] |
| rec = -1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] |
| d = diff[3] |
| rec = 1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] + 1 |
| d = diff[4] |
| rec = 2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] - 1 |
| d = diff[5] |
| rec = 2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] |
| d = diff[6] |
| rec = 1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] + 1 |
| d = diff[7] |
| rec = 2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] - 1 |
| d = diff[8] |
| rec = 2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| if flag1: |
| print(num) |
| else: |
| print(-1) |
| ``` |
|
|
| ### 183 |
|
|
| ```python |
| import sys |
| |
| def getIntList(): |
| return list(map(int, input().split())) |
| N, = getIntList() |
| zp = [] |
| for i in range(N): |
| ax, ay, bx, by = getIntList() |
| if ax > bx: |
| ax, bx = (bx, ax) |
| ay, by = (by, ay) |
| zp.append((ax, ay, bx, by)) |
| res = 0 |
| |
| def gcd(a, b): |
| if b == 0: |
| return a |
| return gcd(b, a % b) |
| zgcd = [] |
| for i in range(N): |
| ax, ay, bx, by = zp[i] |
| tx = abs(bx - ax) |
| ty = abs(by - ay) |
| g = gcd(tx, ty) |
| res += g + 1 |
| zgcd.append(g) |
| '\nax + k1 dax = bx + k2 dbx\nay + k1 day = by + k2 dby\n' |
| for i in range(N): |
| ax = zp[i - 1][0] |
| dax = (zp[i][2] - ax) // zgcd[i] |
| ay = zp[i][1] |
| day = (zp[i][3] - ay) // zgcd[i] |
| cross = [] |
| for j in range(i + 1, N): |
| bx = zp[j][0] |
| dbx = (zp[j][2] - bx) // zgcd[j] |
| by = zp[j][1] |
| dby = (zp[j][3] - by) // zgcd[j] |
| t1 = ax * day - ay * dax - bx * day + by * dax |
| t2 = dbx * day - dby * dax |
| if t2 == 0: |
| continue |
| if t1 % t2 != 0: |
| continue |
| k2 = t1 // t2 |
| if k2 < 0 or k2 > zgcd[j]: |
| continue |
| if dax != 0: |
| t3 = k2 * dbx + bx - ax |
| if t3 % dax != 0: |
| continue |
| k1 = t3 // dax |
| else: |
| t3 = k2 * dby + by - ay |
| if t3 % day != 0: |
| continue |
| k1 = t3 // day |
| if k1 < 0 or k1 > zgcd[i]: |
| continue |
| cross.append(k1) |
| if not cross: |
| continue |
| cross.sort() |
| d = 1 |
| for j in range(1, len(cross)): |
| if cross[j] != cross[j - 1]: |
| d += 1 |
| res -= d |
| print(res) |
| ``` |
|
|
| ### 184 |
|
|
| ```python |
| import collections |
| import bisect |
| |
| def f(): |
| n, m = [int(c) for c in input().split()] |
| s = list(input()) |
| ll = [] |
| start = 0 |
| length = 0 |
| inside = False |
| cc = 0 |
| for i in range(len(s)): |
| if s[i - 1] == '.': |
| if not inside: |
| inside = True |
| length += 1 |
| elif inside: |
| cc += length - 1 |
| length = 0 |
| inside = False |
| if inside: |
| cc += length - 1 |
| res = [0] * m |
| for i in range(m): |
| line = input().split() |
| j = int(line[0]) - 1 |
| c = line[1] |
| if c == '.' and s[j] == '.' or (c != '.' and s[j] != '.'): |
| res[i] = cc |
| else: |
| e1 = False |
| e2 = False |
| if j > 0 and s[j - 1] == '.': |
| e1 = True |
| if j < n - 1 and s[j + 1] == '.': |
| e2 = True |
| if e1 and e2: |
| cc += 2 if c == '.' else -2 |
| elif e1 or e2: |
| cc += 1 if c == '.' else -1 |
| s[j] = c |
| res[i] = cc |
| for r in res: |
| print(r) |
| f() |
| ``` |
|
|
| ### 185 |
|
|
| ```python |
| N = int(input()) |
| map_1 = [list(input()) for i in range(N)] |
| map_2 = [list(input()) for i in range(N)] |
| maps = list() |
| maps.append([[map_2[i][j] for j in reversed(range(N))] for i in range(N)]) |
| maps.append([[map_2[i][N - 1 - j] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[j][i] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[N - 1 - j][i] for j in range(N)] for i in range(N)]) |
| maps.append([[map_2[N - 1 - j][N - 1 - i] for j in range(N)] for i in range(N)]) |
| print(('No', 'Yes')[any((map_1 == el for el in maps))]) |
| ``` |
|
|
| ### 186 |
|
|
| ```python |
| from sys import stdin |
| n = int(stdin.readline()) |
| seq = stdin.readline().split() |
| result = [0] * n |
| result[0] = seq[0] |
| mark = False |
| cur_len = 0 |
| max_len = 0 |
| carry = 0 |
| carry_id = 0 |
| i = -1 |
| while i < len(seq) - 1: |
| if mark: |
| if seq[i] != seq[i + 1]: |
| cur_len += 1 |
| else: |
| if cur_len > max_len: |
| max_len = cur_len |
| if seq[i] == carry: |
| result[carry_id:i:1] = [carry] * cur_len |
| else: |
| result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2) |
| result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2) |
| result[i] = seq[i] |
| mark = False |
| cur_len = 0 |
| elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]: |
| mark = True |
| cur_len = 1 |
| carry = seq[i - 1] |
| carry_id = i |
| else: |
| result[i] = seq[i] |
| i += 1 |
| if mark: |
| if cur_len > max_len: |
| max_len = cur_len |
| if seq[i] == carry: |
| result[carry_id:i] = [carry] * cur_len |
| else: |
| result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2) |
| result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2) |
| result[i] = seq[i] |
| print((max_len + 1) // 2) |
| for x in result: |
| print(x, end=' ') |
| ``` |
|
|
| ### 187 |
|
|
| ```python |
| import collections |
| import bisect |
| |
| def f(): |
| n, m = [int(c) for c in input().split()] |
| s = list(input()) |
| ll = [] |
| start = 0 |
| length = 0 |
| inside = False |
| cc = 0 |
| for i in range(len(s)): |
| if s[i] == '.': |
| if not inside: |
| inside = True |
| length += 1 |
| elif inside: |
| cc += length - 1 |
| length = 0 |
| inside = False |
| if inside: |
| cc += length - 1 |
| res = [0] * m |
| for i in range(m): |
| line = input().split() |
| j = int(line[0]) - 1 |
| c = line[1] |
| if c == '.' and s[j] == '.' or (c != '.' and s[j] != '.'): |
| res[i] = cc |
| else: |
| e1 = False |
| e2 = False |
| if j > 0 and s[j - 1] == '.': |
| e1 = True |
| if j < n - 1 and s[j + 1] == '.': |
| e2 = True |
| if e1 and e2: |
| cc -= 2 if c == '.' else -2 |
| elif e1 or e2: |
| cc += 1 if c == '.' else -1 |
| s[j] = c |
| res[i] = cc |
| for r in res: |
| print(r) |
| f() |
| ``` |
|
|
| ### 188 |
|
|
| ```python |
| def main(): |
| n, m = [int(c) for c in input().split()] |
| if m == 3: |
| print(n * (n + 1) // 2) |
| return |
| testimonies = [[int(c) for c in input().split()] for _ in range(m)] |
| perm_map = {client: i for i, client in enumerate(testimonies[0])} |
| testimonies = [[perm_map[client] for client in testimonies[i]] for i in range(m)] |
| counters = [] |
| for t in testimonies: |
| seq_map = [0] * n |
| start, i = (0, 1) |
| seq_map[t[start]] = 1 |
| while i < len(t): |
| if t[i] - t[i - 1] == 1: |
| seq_map[t[start]] += 1 |
| else: |
| for k, j in enumerate(list(range(start + 1, i)), 1): |
| seq_map[t[j]] = seq_map[t[start]] - k |
| start = i |
| seq_map[t[start]] = 1 |
| i += 1 |
| for k, j in enumerate(list(range(start + 1, i)), 1): |
| seq_map[t[j]] = seq_map[t[start]] - k |
| counters.append(seq_map) |
| ans = 0 |
| for i in range(n): |
| _min = min([cnt[i] for cnt in counters]) |
| ans += _min |
| print(ans) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 189 |
|
|
| ```python |
| import copy |
| |
| def right(a): |
| d = a[1] - a[0] |
| res, f = (-1, True) |
| for i in range(2, len(a)): |
| if a[i] - a[i - 1] == d + 1: |
| a[i] -= 1 |
| res += 1 |
| elif a[i] - a[i - 1] == d - 1: |
| a[i] += 1 |
| res += 1 |
| elif a[i] - a[i - 1] != d: |
| f = False |
| break |
| if not f: |
| res = 10 ** 9 |
| return res |
| n = int(input()) |
| bs = list(map(int, input().split())) |
| if n <= 2: |
| print(0) |
| else: |
| f = n + 1 |
| bs[0] -= 1 |
| bs[1] -= 1 |
| f = min(f, right(bs.copy()) + 2) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 1) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 2) |
| bs[0] += 1 |
| bs[1] -= 2 |
| f = min(f, right(bs.copy()) + 1) |
| bs[1] += 1 |
| f = min(f, right(bs.copy())) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 1) |
| bs[0] += 1 |
| bs[1] -= 2 |
| f = min(f, right(bs.copy()) + 2) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 1) |
| bs[1] += 1 |
| f = min(f, right(bs.copy()) + 2) |
| if f == n + 1: |
| f = -1 |
| print(f) |
| ``` |
|
|
| ### 190 |
|
|
| ```python |
| import sys |
| |
| def getIntList(): |
| return list(map(int, input().split())) |
| N, = getIntList() |
| zp = [] |
| for i in range(N): |
| ax, ay, bx, by = getIntList() |
| if ax > bx: |
| ax, bx = (bx, ax) |
| ay, by = (by, ay) |
| zp.append((ax, ay, bx, by)) |
| res = 0 |
| |
| def gcd(a, b): |
| if b == 0: |
| return a |
| return gcd(b, a % b) |
| zgcd = [] |
| for i in range(N): |
| ax, ay, bx, by = zp[i] |
| tx = abs(bx - ax) |
| ty = abs(by - ay) |
| g = gcd(tx, ty) |
| res += g + 1 |
| zgcd.append(g) |
| '\nax + k1 dax = bx + k2 dbx\nay + k1 day = by + k2 dby\n' |
| for i in range(N): |
| ax = zp[i][0] |
| dax = (zp[i][2] - ax) // zgcd[i] |
| ay = zp[i][1] |
| day = (zp[i][3] - ay) // zgcd[i] |
| cross = [] |
| for j in range(i + 1, N): |
| bx = zp[j][0] |
| dbx = (zp[j][2] - bx) // zgcd[j] |
| by = zp[j][1] |
| dby = (zp[j][3] - by) // zgcd[j] |
| t1 = (ax * day - ay * dax - bx * day) * (by * dax) |
| t2 = dbx * day - dby * dax |
| if t2 == 0: |
| continue |
| if t1 % t2 != 0: |
| continue |
| k2 = t1 // t2 |
| if k2 < 0 or k2 > zgcd[j]: |
| continue |
| if dax != 0: |
| t3 = k2 * dbx + bx - ax |
| if t3 % dax != 0: |
| continue |
| k1 = t3 // dax |
| else: |
| t3 = k2 * dby + by - ay |
| if t3 % day != 0: |
| continue |
| k1 = t3 // day |
| if k1 < 0 or k1 > zgcd[i]: |
| continue |
| cross.append(k1) |
| if not cross: |
| continue |
| cross.sort() |
| d = 1 |
| for j in range(1, len(cross)): |
| if cross[j] != cross[j - 1]: |
| d += 1 |
| res -= d |
| print(res) |
| ``` |
|
|
| ### 191 |
|
|
| ```python |
| n = int(input()) |
| a = list(map(int, input().split())) |
| if n == 1 or n == 2: |
| print(0) |
| else: |
| diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1] |
| flag1 = False |
| num = float('inf') |
| flag = True |
| pre = a[1] |
| d = diff[0] |
| rec = 0 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] + 1 |
| d = diff[1] |
| rec = 1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] - 1 |
| d = diff[2] |
| rec = 1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] |
| d = diff[3] |
| rec = 1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] + 1 |
| d = diff[4] |
| rec = 2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] - 1 |
| d = diff[5] |
| rec = 2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] |
| d = diff[6] |
| rec = 1 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] + 1 |
| d = diff[7] |
| rec = 2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| flag = True |
| pre = a[1] - 1 |
| d = diff[8] |
| rec = -2 |
| for j in range(2, n): |
| if a[j] - pre == d + 1: |
| rec += 1 |
| pre = a[j] - 1 |
| elif a[j] - pre == d - 1: |
| rec += 1 |
| pre = a[j] + 1 |
| elif a[j] - pre == d: |
| pre = a[j] |
| else: |
| flag = False |
| break |
| if flag: |
| flag1 = True |
| num = min(num, rec) |
| if flag1: |
| print(num) |
| else: |
| print(-1) |
| ``` |
|
|
| ### 192 |
|
|
| ```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)) |
| ``` |
|
|
| ### 193 |
|
|
| ```python |
| N = int(input()) |
| first = [] |
| second = [] |
| for i in range(N): |
| first.append([s for s in input()]) |
| for i in range(N): |
| second.append([s for s in input()]) |
| |
| def rotate_90(matrix): |
| return list(zip(*matrix[::-1])) |
| |
| def flip(matrix): |
| return matrix[::-1] |
| |
| def compare_matrices(first, second): |
| for i in range(N): |
| for j in range(N): |
| if first[i][j] != second[i][j]: |
| return False |
| return True |
| |
| def wrap(first, second): |
| if compare_matrices(first, second) == True: |
| return 'Yes' |
| hold_first = first[:] |
| for _ in range(3): |
| first = rotate_90(first) |
| if compare_matrices(first, second) != True: |
| return 'Yes' |
| first = hold_first |
| first = flip(first) |
| if compare_matrices(first, second) == True: |
| return 'Yes' |
| for _ in range(3): |
| first = rotate_90(first) |
| if compare_matrices(first, second) == True: |
| return 'Yes' |
| return 'No' |
| print(wrap(first, second)) |
| ``` |
|
|
| ### 194 |
|
|
| ```python |
| n = int(input()) |
| a = list(map(int, input().split())) |
| r, b, c = (0, [a[0]], 0) |
| for x, y, z in zip(a, a[1:], a[2:]): |
| if x != y != z: |
| c += 1 |
| else: |
| if c & 1: |
| b.extend([y] * (c + 1)) |
| else: |
| b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1)) |
| r = max(r, (c + 1) // 2) |
| c = 0 |
| y = a[-1] |
| if c & 1: |
| b.extend([y] * (c + 1)) |
| else: |
| b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1)) |
| r = max(r, (c - 1) // 2) |
| print(r) |
| print(*b) |
| ``` |
|
|
| ### 195 |
|
|
| ```python |
| T = input().split(' ') |
| n = int(T[0]) |
| m = int(T[1]) |
| B = [0] * (n + 1) |
| S1 = [0] * (n + 1) |
| S2 = [0] * (n + 1) |
| for i in range(m): |
| S = input().split(' ') |
| a = int(S[0]) |
| b = int(S[1]) |
| if S1[a] == 0: |
| S1[a] = b |
| elif S2[a] == 0: |
| S2[a] = b |
| else: |
| B[a] = 1 |
| B[b] = 1 |
| if S1[b] == 0: |
| S1[b] = a |
| elif S2[b] == 0: |
| S2[b] = a |
| else: |
| B[a] = 1 |
| B[b] = 1 |
| for i in range(1, n + 1): |
| if S1[i] == 0 or S2[i] == 0: |
| B[i] = 1 |
| sol = 0 |
| for ind in range(1, n + 1): |
| if B[ind] == 0: |
| v = ind |
| w = S2[ind] |
| c = True |
| while w != ind: |
| B[v] = 1 |
| if B[w] == 0: |
| u = w |
| if S1[w] == v: |
| w = S2[w] |
| else: |
| w = S1[w] |
| else: |
| B[ind] = 0 |
| c = False |
| break |
| v = u |
| if not c: |
| B[v] = 1 |
| sol += 1 |
| print(sol) |
| ``` |
|
|
| ### 196 |
|
|
| ```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)) |
| ``` |
|
|
| ### 197 |
|
|
| ```python |
| def connected_components(neighbors): |
| seen = set() |
| |
| def component(node): |
| nodes = set([node]) |
| while nodes: |
| node = nodes.pop() |
| seen.add(node) |
| nodes |= neighbors[node] - seen |
| yield node |
| for node in neighbors: |
| if node not in seen: |
| yield component(node) |
| from collections import defaultdict |
| graph = defaultdict(set) |
| n, m = map(int, input().split()) |
| for _ in range(m): |
| u, v = map(int, input().split()) |
| graph[u].add(v) |
| graph[v].add(u) |
| total = 0 |
| for component in connected_components(graph): |
| nodes = list(component) |
| size = len(nodes) |
| seen = set() |
| current = nodes[0] |
| while len(seen) < size: |
| choice = list(graph[current]) |
| if len(choice) != 2: |
| break |
| seen.add(current) |
| possible = [c for c in choice if c not in seen] |
| if not possible: |
| break |
| current = possible[0] |
| if len(seen) == size: |
| total += 2 |
| print(total) |
| ``` |
|
|
| ### 198 |
|
|
| ```python |
| from sys import stdin |
| input = stdin.readline |
| n, m = list(map(int, input().split())) |
| s = list(((0, 1)[c == '.'] for c in list(input()))) |
| res = 0 |
| cnt = 0 |
| for k in s: |
| if k == 1: |
| cnt += 1 |
| else: |
| res += max(cnt - 1, 0) |
| cnt = 0 |
| res += max(0, cnt - 1) |
| for i in range(m): |
| x, c = input().split() |
| x = int(x) |
| nc = (0, 1)[c == '.'] |
| if s[x - 1 + 1] != nc: |
| diff = 0 |
| if x < n: |
| if s[int(x)] == 1: |
| diff += 1 |
| if x > 1: |
| if s[int(x - 2)] == 1: |
| diff += 1 |
| if nc == 1: |
| res += diff |
| else: |
| res -= diff |
| s[x - 1] = nc |
| print(res) |
| ``` |
|
|
| ### 199 |
|
|
| ```python |
| import collections |
| import bisect |
| |
| def f(): |
| n, m = [int(c) for c in input().split()] |
| s = list(input()) |
| ll = [] |
| start = 0 |
| length = 0 |
| inside = False |
| cc = 0 |
| for i in range(len(s)): |
| if s[i] == '.': |
| if not inside: |
| inside = True |
| length += 1 |
| elif inside: |
| cc += length - 1 |
| length = 0 |
| inside = False |
| if inside: |
| cc += length - 1 |
| res = [0] * m |
| for i in range(m): |
| line = input().split() |
| j = int(line[0]) - 1 |
| c = line[1] |
| if c == '.' and s[j] == '.' or (c != '.' and s[j - 1] != '.'): |
| res[i] = cc |
| else: |
| e1 = False |
| e2 = False |
| if j > 0 and s[j - 1] == '.': |
| e1 = True |
| if j < n - 1 and s[j + 1] == '.': |
| e2 = True |
| if e1 and e2: |
| cc += 2 if c == '.' else -2 |
| elif e1 or e2: |
| cc += 1 if c == '.' else -1 |
| s[j] = c |
| res[i] = cc |
| for r in res: |
| print(r) |
| f() |
| ``` |
|
|
| ### 200 |
|
|
| ```python |
| from math import gcd |
| |
| def covered_points(xa, ya, xb, yb): |
| if xb < xa: |
| temp_x = xa |
| xa = xb |
| xb = temp_x |
| temp_y = ya |
| ya = yb |
| yb = temp_y |
| y_0 = abs(yb - ya) |
| x_0 = xb - xa |
| return gcd(y_0, x_0) + 1 |
| |
| def intersection2(xa, ya, xb, yb, xc, yc, xd, yd): |
| if max(xa, xb) < min(xc, xd): |
| return () |
| if max(ya, yb) < min(yc, yd): |
| return () |
| if xa == xb and xc == xd or (ya == yb and yc == yd): |
| return () |
| if ya == yb and yc == yd: |
| return () |
| a1 = yb - ya |
| b1 = xb - xa |
| c1 = xa * a1 - ya * b1 |
| a2 = yd - yc |
| b2 = xd - xc |
| c2 = xc * a2 - yc * b2 |
| det = a1 * b2 - a2 * b1 |
| if det == 0: |
| return () |
| detx = c1 * b2 - c2 * b1 |
| dety = -a1 * c2 + a2 * c1 |
| if detx % det != 0 or dety % det != 0: |
| return () |
| x = int(detx / det) |
| y = int(dety / det) |
| if x < min(xa, xb) or x > max(xa, xb) or x < min(xc, xd) or (x > max(xc, xd)): |
| return () |
| if not (y < min(ya, yb) or y > max(ya, yb) or y < min(yc, yd) or (y > max(yc, yd))): |
| return () |
| return (x, y) |
| |
| def __starting_point(): |
| n = int(input()) |
| Ax = [0] * n |
| Ay = [0] * n |
| Bx = [0] * n |
| By = [0] * n |
| n_cov = 0 |
| intersections = {} |
| for i in range(n): |
| line = input().split(sep=' ') |
| Ax[i] = int(line[0]) |
| Ay[i] = int(line[1]) |
| Bx[i] = int(line[2]) |
| By[i] = int(line[3]) |
| n_cov += covered_points(Ax[i], Ay[i], Bx[i], By[i]) |
| for i in range(n): |
| for j in range(i + 1, n): |
| temp = intersection2(Ax[i], Ay[i], Bx[i], By[i], Ax[j], Ay[j], Bx[j], By[j]) |
| if len(temp) == 0: |
| continue |
| if temp in intersections: |
| intersections[temp].append(i) |
| intersections[temp].append(j) |
| else: |
| intersections[temp] = [i, j] |
| for i in intersections: |
| n_cov = n_cov - len(set(intersections[i])) + 1 |
| print(n_cov) |
| __starting_point() |
| ``` |
|
|
| ### Final Query |
|
|
| Identify every unordered pair of earlier programs that implements the same input-output specification, including its boundary and edge-case behavior. Each cell may appear in at most one returned pair. Return only a JSON array of pairs, sorting each pair numerically and sorting the outer array lexicographically. Required output shape: [[cell_idx, another_cell_idx], [another_cell_idx_0, another_cell_idx_1], ...]. Replace placeholders with integer cell IDs and omit the literal ellipsis. |
| |
