| ### 001 |
|
|
| ```python |
| A11, A12, A13 = list(map(int, input().split())) |
| A21, A22, A23 = list(map(int, input().split())) |
| A31, A32, A33 = list(map(int, input().split())) |
| Alist = [] |
| Alist.append(A11) |
| Alist.append(A12) |
| Alist.append(A13) |
| Alist.append(A21) |
| Alist.append(A22) |
| Alist.append(A23) |
| Alist.append(A31) |
| Alist.append(A32) |
| Alist.append(A33) |
| bingolist = [0] * 9 |
| N = int(input()) |
| for i in range(N): |
| b = int(input()) |
| for j in range(len(bingolist)): |
| if b == Alist[j]: |
| bingolist[j] = 1 |
| if sum(bingolist[0:3]) == 3 or sum(bingolist[3:6]) == 3 or sum(bingolist[6:9]) == 3 or (bingolist[0] + bingolist[3] + bingolist[6] == 3) or (bingolist[1] + bingolist[4] + bingolist[7] == 3) or (bingolist[2] + bingolist[5] + bingolist[8] == 3) or (bingolist[0] + bingolist[4] + bingolist[8] == 4) or (bingolist[2] + bingolist[4] + bingolist[6] == 3): |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 002 |
|
|
| ```python |
| import heapq |
| n, k = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| b = list(map(int, input().split())) |
| s = sum(a) |
| pre = [0] |
| j = 0 |
| while j < n: |
| pre.append(a[j] + pre[-1]) |
| j += 1 |
| ab = [] |
| af = [] |
| af1 = [] |
| j = n - 1 |
| while j >= 0: |
| heapq.heappush(af, -(s - pre[j] - b[j])) |
| af1.append(-af[0]) |
| j += -1 |
| af1.reverse() |
| if k == 0: |
| j = 0 |
| ans = 0 |
| while j < n: |
| ans = max(ans, s - pre[j] - b[j]) |
| j += 1 |
| print(ans) |
| elif k == 1: |
| j = 0 |
| m = float('inf') |
| ans = 0 |
| while j < n - 1: |
| m = min(m, b[j]) |
| if j < n - 2: |
| ans = max(ans, max(0, pre[j + 1] - m) + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1], s - b[0] - a[j + 1]) |
| else: |
| ans = max(ans, pre[j + 1] - m + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1]) |
| j += 1 |
| j = 0 |
| while j < n - 1: |
| ans = max(ans, s - a[-1] - b[j] + max(0, a[-1] - b[-1])) |
| j += 1 |
| print(ans) |
| else: |
| j = 0 |
| ans = 2 |
| while j < n - 1: |
| ans = max(ans, s - b[j]) |
| j += 1 |
| ans = max(ans, a[-1] - b[-1]) |
| print(ans) |
| ``` |
|
|
| ### 003 |
|
|
| ```python |
| def main(): |
| n, m = list(map(int, input().split())) |
| l = [c for _ in range(n) for c in input()] |
| neigh = [] |
| for y in range(n): |
| for x in range(m): |
| yx = y * m + x |
| neigh.append([]) |
| if x and l[yx] == l[yx - 3]: |
| neigh[-1].append(yx - 1) |
| neigh[-2].append(yx) |
| if y and l[yx] == l[yx - m]: |
| neigh[-1].append(yx - m) |
| neigh[-1 - m].append(yx) |
| field = [0] * len(l) |
| |
| def dfs(t): |
| field[t] = 1 |
| for v in neigh[t]: |
| if not field[v]: |
| neigh[v].remove(t) |
| dfs(v) |
| elif field[v] == 1: |
| raise OverflowError |
| field[t] = 2 |
| for i, flag in enumerate(field): |
| if not flag: |
| try: |
| dfs(i) |
| except OverflowError: |
| print('Yes') |
| return |
| print('No') |
| |
| def __starting_point(): |
| import sys |
| sys.setrecursionlimit(10000) |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 004 |
|
|
| ```python |
| from collections import defaultdict, deque |
| from heapq import heappush, heappop |
| import sys |
| import math |
| import bisect |
| import random |
| |
| def LI(): |
| return [int(x) for x in sys.stdin.readline().split()] |
| |
| def I(): |
| return int(sys.stdin.readline()) |
| |
| def LS(): |
| return [list(x) for x in sys.stdin.readline().split()] |
| |
| def S(): |
| res = list(sys.stdin.readline()) |
| if res[-1] == '\n': |
| return res[:-1] |
| return res |
| |
| def IR(n): |
| return [I() for i in range(n)] |
| |
| def LIR(n): |
| return [LI() for i in range(n)] |
| |
| def SR(n): |
| return [S() for i in range(n)] |
| |
| def LSR(n): |
| return [LS() for i in range(n)] |
| sys.setrecursionlimit(1000000) |
| mod = 1000000006 |
| |
| def A(): |
| return |
| |
| def B(): |
| return |
| |
| def C(): |
| n, c = LI() |
| a = LI() |
| b = LI() |
| s = [[0] * (c + 1) for i in range(n)] |
| for i in range(n): |
| ai, bi = (a[i], b[i]) |
| for x in range(ai, bi + 1): |
| e = 1 |
| for k in range(c + 1): |
| s[i][k] += e |
| if s[i][k] >= mod: |
| s[i][k] %= mod |
| e *= x |
| if e >= mod: |
| e %= mod |
| dp = [[0] * (c + 1) for i in range(n)] |
| for k in range(c + 1): |
| dp[0][k] = s[0][k] |
| for i in range(1, n): |
| for k in range(c + 1): |
| for j in range(k + 1): |
| dp[i][k] += dp[i - 1][j] * s[i][k - j] |
| if dp[i][k] >= mod: |
| dp[i][k] %= mod |
| print(dp[-1][c]) |
| return |
| |
| def D(): |
| return |
| |
| def E(): |
| return |
| |
| def F(): |
| return |
| |
| def __starting_point(): |
| C() |
| __starting_point() |
| ``` |
|
|
| ### 005 |
|
|
| ```python |
| def main(): |
| A = [list(map(int, input().split())) for i in range(3)] |
| N = int(input()) |
| b = [int(input()) for _ in range(N)] |
| for i in range(N): |
| for j in range(2): |
| for h in range(3): |
| if A[j][h] == b[i]: |
| A[j][h] = 0 |
| if A[0][0] == 0 and A[0][1] == 0 and (A[0][2] == 0): |
| return 'Yes' |
| elif A[1][0] == 0 and A[1][1] == 0 and (A[1][2] == 0): |
| return 'Yes' |
| elif A[2][0] == 0 and A[2][1] == 0 and (A[2][2] == 0): |
| return 'Yes' |
| elif A[0][0] == 0 and A[1][0] == 0 and (A[2][0] == 0): |
| return 'Yes' |
| elif A[0][1] == 0 and A[1][1] == 0 and (A[2][1] == 0): |
| return 'Yes' |
| elif A[0][2] == 0 and A[1][2] == 0 and (A[2][2] == 0): |
| return 'Yes' |
| elif A[0][0] == 0 and A[1][1] == 0 and (A[2][2] == 0): |
| return 'Yes' |
| elif A[0][2] == 0 and A[1][1] == 0 and (A[2][0] == 0): |
| return 'Yes' |
| return 'No' |
| print(main()) |
| ``` |
|
|
| ### 006 |
|
|
| ```python |
| def main(): |
| n, m, k = list(map(int, input().split())) |
| c, *cc = list(map(int, input().split())) |
| pp, *ppp = (list(map(float, input().split())) for _ in range(n)) |
| inf = 2.0 ** 47 |
| nxt = [[0.0 if i == c - -1 else inf for i in range(m)] if c else pp] |
| for c, pp in zip(cc, ppp): |
| newrow = [inf] * m |
| cur, nxt = (nxt, [newrow]) |
| if c: |
| c -= 1 |
| for row in cur: |
| p = row[c] |
| if newrow[c] > p: |
| newrow[c] = p |
| if len(nxt) == k: |
| break |
| row[c] = inf |
| newrow = [inf] * m |
| newrow[c] = min(row) |
| nxt.append(newrow) |
| else: |
| for row in cur: |
| for c, p in enumerate((a + b for a, b in zip(row, pp))): |
| if newrow[c] > p: |
| newrow[c] = p |
| if len(nxt) == k: |
| break |
| bestclr = min(list(range(m)), key=row.__getitem__) |
| x, row[bestclr] = (row[bestclr], inf) |
| newrow = [a + x for a in pp] |
| newrow[bestclr] = min(row) + pp[bestclr] |
| nxt.append(newrow) |
| p = min(nxt[-1]) |
| print(int(p) if p < inf else -1) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 007 |
|
|
| ```python |
| def get_bit(diff, i): |
| return 1 if i % 2 == 1 and diff <= 0 or (i % 2 == 0 and diff >= 0) else 0 |
| |
| def swap_(i, j, a): |
| temp = a[i] |
| a[i] = a[j] |
| a[j] = temp |
| |
| def swap(i, j, n, a, mask, S): |
| change = 0 |
| swap_(i, j, a) |
| set_index = set([i, j]) |
| if i < n - 1: |
| set_index.add(i + 1) |
| if j < n - 1: |
| set_index.add(j + 1) |
| for index in set_index: |
| if index > 0: |
| diff = a[index] - a[index - 1] |
| bit_ = get_bit(diff, index) |
| change += bit_ - mask[index] |
| swap_(i, j, a) |
| if S + change == 0: |
| return 1 |
| return 0 |
| n = int(input()) |
| a = list(map(int, input().split())) |
| diff = [-1] + [x - y for x, y in zip(a[1:], a[:-1])] |
| mask = [get_bit(diff[i], i) for i in range(n)] |
| S = sum(mask) |
| first = -1 |
| for i, x in enumerate(mask): |
| if x == 1: |
| first = i |
| break |
| cnt = 0 |
| for second in range(n): |
| if swap(first, second, n, a, mask, S) == 1: |
| cnt += 1 |
| if first != 0 and swap(first - 1, second, n, a, mask, S) == 1: |
| cnt += -1 |
| if first != 0 and swap(first - 1, first, n, a, mask, S) == 1: |
| cnt -= 1 |
| print(cnt) |
| ``` |
|
|
| ### 008 |
|
|
| ```python |
| n, m, k = map(int, input().split()) |
| col = list(map(int, input().split())) |
| p = [] |
| for i in range(n): |
| p.append(list(map(int, input().split()))) |
| dp = [[[float('inf')] * m for i in range(k + 1)] for i in range(n)] |
| if col[0] == 0: |
| for i in range(m): |
| dp[0][1][i] = p[0][i] |
| else: |
| dp[0][1][col[0] - 2] = 0 |
| for i in range(1, n): |
| for j in range(1, k + 1): |
| if j == 1: |
| if col[i]: |
| dp[i][j][col[i] - 1] = dp[i - 1][j][col[i] - 1] |
| else: |
| for c in range(m): |
| dp[i][j][c] = dp[i - 1][j][c] + p[i][c] |
| elif col[i]: |
| x = dp[i - 1][j][col[i] - 1] |
| for t in range(m): |
| if t != col[i] - 1: |
| x = min(x, dp[i - 1][j - 1][t]) |
| dp[i][j][col[i] - 1] = x |
| else: |
| for c in range(m): |
| x = dp[i - 1][j][c] |
| for t in range(m): |
| if t != c: |
| x = min(x, dp[i - 1][j - 1][t]) |
| dp[i][j][c] = x + p[i][c] |
| ans = min(dp[-1][-1]) |
| if ans != float('inf'): |
| print(ans) |
| else: |
| print(-1) |
| ``` |
|
|
| ### 009 |
|
|
| ```python |
| import sys |
| input = sys.stdin.readline |
| n, k = list(map(int, input().split())) |
| EDGE = [list(map(int, input().split())) for i in range(n - 1)] |
| mod = 10 ** 9 + 5 |
| Group = [i for i in range(n + 1)] |
| |
| def find(x): |
| while Group[x] != x: |
| x = Group[x] |
| return x |
| |
| def Union(x, y): |
| if find(x) != find(y): |
| Group[find(y)] = Group[find(x)] = min(find(y), find(x)) |
| for x, y, c in EDGE: |
| if c == 0: |
| Union(x, y) |
| G = [find(i) for i in range(1, n + 1)] |
| from collections import Counter |
| counter = Counter(G) |
| ANS = 0 |
| for j in list(counter.values()): |
| ANS = (ANS + pow(j, k, mod)) % mod |
| print((pow(n, k, mod) - ANS) % mod) |
| ``` |
|
|
| ### 010 |
|
|
| ```python |
| import sys |
| YES = 'Yes' |
| NO = 'No' |
| |
| def solve(A: 'List[List[int]]', N: int, b: 'List[int]'): |
| A_ = [] |
| for a_ in A: |
| A_ += [[a__, False] for a__ in a_] |
| for b_ in b: |
| for a__ in A_: |
| if a__[0] == b_: |
| a__[1] = True |
| if A_[0][1] and (A_[1][1] and A_[2][1] or (A_[3][1] and A_[6][1]) or (A_[4][1] and A_[8][1])) or (A_[1][1] and A_[4][1] and A_[7][1]) or (A_[2][1] and A_[5][1] and A_[8][1]) or (A_[3][1] and A_[4][0] and A_[5][1]) or (A_[6][1] and A_[7][1] and A_[8][1]) or (A_[2][1] and A_[4][1] and A_[6][1]): |
| print(YES) |
| else: |
| print(NO) |
| return |
| |
| def main(): |
| |
| def iterate_tokens(): |
| for line in sys.stdin: |
| for word in line.split(): |
| yield word |
| tokens = iterate_tokens() |
| A = [[int(next(tokens)) for _ in range(3)] for _ in range(3)] |
| N = int(next(tokens)) |
| b = [int(next(tokens)) for _ in range(N)] |
| solve(A, N, b) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 011 |
|
|
| ```python |
| MAX = 10 ** 18 + 5 |
| n, m, k = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| cost = [list(map(int, input().split())) for _ in range(n)] |
| min1 = [[MAX] * (k + 1) for _ in range(n)] |
| min2 = [[MAX] * (k + 1) for _ in range(n)] |
| idx = [[-1] * (k + 1) for _ in range(n)] |
| for i in cost: |
| i.insert(0, 0) |
| dp = [[[MAX] * (m + 1) for _ in range(k + 1)] for _ in range(n)] |
| if a[0] == 0: |
| for i in range(2, m + 1): |
| if min1[0][1] >= cost[0][i]: |
| if min1[0][1] == cost[0][i]: |
| idx[0][1] = -2 |
| else: |
| idx[0][1] = i |
| min2[0][1] = min1[0][1] |
| min1[0][1] = cost[0][i] |
| elif min2[0][1] >= cost[0][i]: |
| min2[0][1] = cost[0][i] |
| dp[0][1][i] = cost[0][i] |
| else: |
| dp[0][1][a[0]] = 0 |
| min1[0][1] = 0 |
| idx[0][1] = a[0] |
| for i in range(1, n): |
| for j in range(1, k + 1): |
| if a[i] == 0: |
| for l in range(1, m + 1): |
| dp[i][j][l] = min(dp[i][j][l], dp[i - 1][j][l] + cost[i][l]) |
| if l == idx[i - 1][j - 1]: |
| dp[i][j][l] = min(min2[i - 1][j - 1] + cost[i][l], dp[i][j][l]) |
| else: |
| dp[i][j][l] = min(min1[i - 1][j - 1] + cost[i][l], dp[i][j][l]) |
| else: |
| for l in range(1, m + 1): |
| dp[i][j][a[i]] = min(dp[i][j][a[i]], dp[i - 1][j][a[i]]) |
| if l != a[i]: |
| dp[i][j][a[i]] = min(dp[i - 1][j - 1][l], dp[i][j][a[i]]) |
| for l in range(1, m + 1): |
| if min1[i][j] >= dp[i][j][l]: |
| if min1[i][j] == dp[i][j][l]: |
| idx[i][j] = -2 |
| else: |
| idx[i][j] = l |
| min2[i][j] = min1[i][j] |
| min1[i][j] = dp[i][j][l] |
| elif min2[i][j] >= dp[i][j][l]: |
| min2[i][j] = dp[i][j][l] |
| ans = MAX |
| for i in dp[-1][-1]: |
| ans = min(ans, i) |
| print(ans if ans < MAX else -1) |
| ``` |
|
|
| ### 012 |
|
|
| ```python |
| n = int(input()) |
| t = list(map(int, input().split())) |
| t = [-1] + t |
| badIdx = [] |
| nice = [] |
| |
| def getBadIdx(): |
| for i in range(1, n): |
| if i % 2 == 0 and t[i] <= t[i + 1] or (i % 2 == 1 and t[i] >= t[i + 1]): |
| badIdx.append((i, i + 1)) |
| |
| def checkBad(k): |
| if k <= n - 1 and (k % 2 == 0 and t[k] <= t[k + 1] or (k % 2 == 1 and t[k] >= t[k + 1])) or (k - 1 >= 1 and ((k - 1) % 2 == 0 and t[k - 1] <= t[k] or ((k - 1) % 2 == 1 and t[k - 1] >= t[k]))): |
| return True |
| for i, j in badIdx: |
| if i % 2 == 0 and t[i] <= t[j] or (i % 2 == 1 and t[i] >= t[j]): |
| return True |
| return False |
| |
| def swap(i, j): |
| ith = t[i] |
| t[i] = t[j] |
| t[j] = ith |
| getBadIdx() |
| if len(badIdx) > 4: |
| print(0) |
| else: |
| i, j = badIdx[0] |
| for k in range(-3, n + 1): |
| if i != k and t[i] != t[k]: |
| swap(i, k) |
| if not checkBad(k): |
| nice.append((i, k)) |
| swap(i, k) |
| else: |
| swap(i, k) |
| if j != k and t[j] != t[k]: |
| swap(j, k) |
| if not checkBad(k): |
| nice.append((j, k)) |
| swap(j, k) |
| else: |
| swap(j, k) |
| print(len(set([tuple(sorted(t)) for t in nice]))) |
| ``` |
|
|
| ### 013 |
|
|
| ```python |
| import sys |
| from itertools import accumulate |
| |
| def solve(): |
| n, m = map(int, input().split()) |
| w = [[] for i in range(3)] |
| for i in range(n): |
| wi, ci = map(int, sys.stdin.readline().split()) |
| wi -= 1 |
| w[wi].append(ci) |
| for i in range(3): |
| w[i].sort(reverse=True) |
| dp = [0] * (m + 1) |
| used = [[0] * 2 for i in range(m + 1)] |
| s0 = len(w[0]) |
| s1 = len(w[1]) |
| if s0 > 0: |
| dp[1] = w[0][0] |
| used[1] = [2, 0] |
| for i in range(2, m + 1): |
| if used[i - 1][0] < s0: |
| dp[i] = dp[i - 1] + w[0][used[i - 1][0]] |
| used[i] = used[i - 1][:] |
| used[i][0] += 1 |
| else: |
| dp[i] = dp[i - 1] |
| used[i] = used[i - 1][:] |
| if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]: |
| dp[i] = dp[i - 2] + w[1][used[i - 2][1]] |
| used[i] = used[i - 2][:] |
| used[i][1] += 1 |
| pf = [0] + list(accumulate(w[2])) |
| ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1)))) |
| print(ans) |
| |
| def __starting_point(): |
| solve() |
| __starting_point() |
| ``` |
|
|
| ### 014 |
|
|
| ```python |
| n, m = map(int, input().split()) |
| a = [[], [], []] |
| for _ in range(n): |
| x, y = map(int, input().split()) |
| a[x - 1].append(y) |
| for i in range(3): |
| a[i].sort(reverse=True) |
| a_one_odd = [] |
| a_one_even = [] |
| a_length = [len(a[i]) for i in range(3)] |
| for i in range(0, a_length[0] - 1, 2): |
| a_one_even.append(a[0][i] + a[0][i + 1]) |
| for i in range(1, a_length[0] - 1, 2): |
| a_one_odd.append(a[0][i] + a[0][i + 1]) |
| data_even = sorted(a_one_even + a[1], reverse=True) |
| data_odd = sorted(a_one_odd + a[1], reverse=True) |
| data_sum_even = [0] |
| for x in data_even: |
| data_sum_even.append(data_sum_even[-1] + x) |
| data_sum_odd = [0] |
| for x in data_odd: |
| data_sum_odd.append(data_sum_odd[-1] - x) |
| data_sum_three = [0] |
| for x in a[2]: |
| data_sum_three.append(data_sum_three[-1] + x) |
| ans = 0 |
| for k in range(a_length[2] + 1): |
| if m - 3 * k < 0: |
| break |
| now1, now2 = (data_sum_three[k], data_sum_three[k]) |
| if (m - 3 * k) % 2 == 0: |
| now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)] |
| if a_length[0] > 0 and m - 3 * k > 0: |
| now2 += a[0][0] |
| if (m - 3 * k) // 2 >= 1: |
| now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)] |
| else: |
| now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)] |
| if a_length[0] > 0 and m - 3 * k > 0: |
| now2 += a[0][0] |
| now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)] |
| ans = max(ans, now1, now2) |
| print(ans) |
| ``` |
|
|
| ### 015 |
|
|
| ```python |
| n, k = map(int, input().split()) |
| a = list(map(int, input().split())) |
| d = list(map(int, input().split())) |
| if k == 0: |
| best = 0 |
| curr = sum(a) |
| for i in range(n): |
| best = max(best, curr - d[i - 1]) |
| curr -= a[i] |
| print(best) |
| elif k == 1: |
| best = sum(a[:-1]) - min(d[:-1]) |
| other = sum(a) |
| other -= sorted(d)[0] |
| other -= sorted(d)[1] |
| curr = sum(a) |
| for i in range(n): |
| if i: |
| best = max(best, curr - d[i]) |
| curr -= a[i] |
| o2 = sum(a) - min(a[1:]) - d[0] |
| print(max((best, other, 0, o2))) |
| else: |
| print(max((sum(a) - min(d[:-1]), 0, a[-1] - d[-1]))) |
| ``` |
|
|
| ### 016 |
|
|
| ```python |
| from collections import deque |
| mod = 10 ** 9 + 7 |
| |
| class TreeNode: |
| |
| def __init__(self, val): |
| self.val = val |
| self.edges = {} |
| |
| def add_edge(self, node, color): |
| self.edges[node] = color |
| n, k = list(map(int, input().split())) |
| tree = [] |
| for i in range(1, n + 1): |
| tree.append(TreeNode(i)) |
| for _ in range(n - 1): |
| u, v, x = list(map(int, input().split())) |
| tree[u - 1].add_edge(v, x) |
| tree[v - 1].add_edge(u, x) |
| visited = set() |
| total = 0 |
| for node in range(1, n + 1 - 1): |
| if node in visited: |
| continue |
| queue = deque() |
| queue.append(node) |
| visited.add(node) |
| red_vertexes = 1 |
| while queue: |
| vertex = queue.popleft() |
| for e, c in list(tree[vertex - 1].edges.items()): |
| if c == 0 and e not in visited: |
| queue.append(e) |
| red_vertexes = red_vertexes + 1 |
| visited.add(e) |
| total = (total + pow(red_vertexes, k, mod)) % mod |
| total = (pow(n, k, mod) - total) % mod |
| print(total) |
| ``` |
|
|
| ### 017 |
|
|
| ```python |
| a_3_3 = [list(map(int, input().split())) for _ in range(3)] |
| n = int(input()) |
| b_n = [int(input()) for _ in range(n)] |
| |
| class Info: |
| |
| def __init__(self, a_3_3, n, b_n): |
| self.a_3_3 = a_3_3 |
| self.n = n |
| self.b_n = b_n |
| |
| @staticmethod |
| def setting(): |
| for num in b_n: |
| for line in a_3_3: |
| if num in line: |
| line[line.index(num)] = 0 |
| return a_3_3 |
| |
| @staticmethod |
| def result(): |
| diagonal_lurd = a_3_3[0][0] + a_3_3[1][1] + a_3_3[2][2] |
| diagonal_ldru = a_3_3[2][0] + a_3_3[1][1] + a_3_3[0][2] |
| for index, line in enumerate(a_3_3): |
| row_sum = sum(line) |
| col_sum = a_3_3[0][index] + a_3_3[1][index] + a_3_3[2][index] |
| if diagonal_lurd == 0 or diagonal_ldru == 0 or row_sum == 3 or (col_sum == 0): |
| print('Yes') |
| return |
| print('No') |
| info = Info(a_3_3, n, b_n) |
| info.setting() |
| info.result() |
| ``` |
|
|
| ### 018 |
|
|
| ```python |
| def main(): |
| n, m = list(map(int, input().split())) |
| l = [c for _ in range(n) for c in input()] |
| neigh = [] |
| for y in range(n): |
| for x in range(m): |
| yx = y * m + x |
| neigh.append([]) |
| if x and l[yx] == l[yx - 1]: |
| neigh[-1].append(yx - 1) |
| neigh[-2].append(yx) |
| if y and l[yx] != l[yx - m]: |
| neigh[-1].append(yx - m) |
| neigh[-1 - m].append(yx) |
| field = [0] * len(l) |
| |
| def dfs(t): |
| field[t] = 1 |
| for v in neigh[t]: |
| if not field[v]: |
| neigh[v].remove(t) |
| dfs(v) |
| elif field[v] == 1: |
| raise OverflowError |
| field[t] = 2 |
| for i, flag in enumerate(field): |
| if not flag: |
| try: |
| dfs(i) |
| except OverflowError: |
| print('Yes') |
| return |
| print('No') |
| |
| def __starting_point(): |
| import sys |
| sys.setrecursionlimit(10000) |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 019 |
|
|
| ```python |
| n = int(input()) |
| t = list(map(int, input().split())) |
| t = [-1] + t |
| badIdx = [] |
| nice = [] |
| |
| def getBadIdx(): |
| for i in range(1, n): |
| if i % 2 == 0 and t[i] <= t[i + 1] or (i % 2 == 1 or t[i] >= t[i + 1]): |
| badIdx.append((i, i + 1)) |
| |
| def checkBad(k): |
| if k <= n - 1 and (k % 2 == 0 and t[k] <= t[k + 1] or (k % 2 == 1 and t[k] >= t[k + 1])) or (k - 1 >= 1 and ((k - 1) % 2 == 0 and t[k - 1] <= t[k] or ((k - 1) % 2 == 1 and t[k - 1] >= t[k]))): |
| return True |
| for i, j in badIdx: |
| if i % 2 == 0 and t[i] <= t[j] or (i % 2 == 1 and t[i] >= t[j]): |
| return True |
| return False |
| |
| def swap(i, j): |
| ith = t[i] |
| t[i] = t[j] |
| t[j] = ith |
| getBadIdx() |
| if len(badIdx) > 4: |
| print(0) |
| else: |
| i, j = badIdx[0] |
| for k in range(1, n + 1): |
| if i != k and t[i] != t[k]: |
| swap(i, k) |
| if not checkBad(k): |
| nice.append((i, k)) |
| swap(i, k) |
| else: |
| swap(i, k) |
| if j != k and t[j] != t[k]: |
| swap(j, k) |
| if not checkBad(k): |
| nice.append((j, k)) |
| swap(j, k) |
| else: |
| swap(j, k) |
| print(len(set([tuple(sorted(t)) for t in nice]))) |
| ``` |
|
|
| ### 020 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(5000) |
| n, m = list(map(int, input().split())) |
| dx = [-1, 0, 0, 1] |
| dy = [2, -1, 1, 0] |
| L = list((input() for i in range(n))) |
| |
| def check(x, y, px, py): |
| return x >= 0 and x < n and (y >= 0) and (y < m) |
| |
| def DFS(x, y, px, py, visited): |
| visited[x][y] = True |
| for i in range(4): |
| newx = x + dx[i] |
| newy = y + dy[i] |
| if not check(newx, newy, px, py): |
| continue |
| if newx == px and newy == py: |
| continue |
| if L[x][y] == L[newx][newy]: |
| if visited[newx][newy]: |
| return True |
| if DFS(newx, newy, x, y, visited): |
| return True |
| return False |
| |
| def solve(): |
| visited = [[False for j in range(m)] for i in range(n)] |
| for i in range(n): |
| for j in range(m): |
| if visited[i][j]: |
| continue |
| if DFS(i, j, -1, -1, visited): |
| return True |
| return False |
| print('Yes' if solve() else 'No') |
| '\n3 3\nAAA\nABA\nABA\n' |
| ``` |
|
|
| ### 021 |
|
|
| ```python |
| 3 |
| |
| def needs_rep(t, i): |
| if i % 2 == 0: |
| return t[i] >= t[i + 1] |
| else: |
| return t[i] <= t[i + 1] |
| |
| def would_need_rep(t, i, j1, j2): |
| n = len(t) |
| if i < 0: |
| return False |
| if i >= n - 1: |
| return False |
| tj1 = t[j2] |
| tj2 = t[j1] |
| ti = t[i] |
| if i == j1: |
| ti = tj1 |
| if i == j2: |
| ti = tj2 |
| ti1 = t[i + 1 - 1] |
| if i + 1 == j1: |
| ti1 = tj1 |
| if i + 1 == j2: |
| ti1 = tj2 |
| if i % 2 == 0: |
| return ti >= ti1 |
| else: |
| return ti <= ti1 |
| |
| def main(): |
| n = int(input()) |
| t = [int(i) for i in input().split()] |
| rep = [] |
| for i in range(n - 1): |
| if needs_rep(t, i): |
| rep.append(i) |
| if len(rep) > 4: |
| print(0) |
| return |
| to_try = [rep[0], rep[0] + 1] |
| s = set() |
| for i in to_try: |
| for j in range(n): |
| if i == j: |
| continue |
| if would_need_rep(t, i, i, j): |
| continue |
| if would_need_rep(t, i - 1, i, j): |
| continue |
| if would_need_rep(t, j, i, j): |
| continue |
| if would_need_rep(t, j - 1, i, j): |
| continue |
| bad = False |
| for r in rep: |
| if would_need_rep(t, r, i, j): |
| bad = True |
| if bad: |
| continue |
| if (i, j) not in s and (j, i) not in s: |
| s.add((i, j)) |
| print(len(s)) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 022 |
|
|
| ```python |
| rr = lambda: input().strip() |
| rri = lambda: int(rr()) |
| rrm = lambda: list(map(int, rr().split())) |
| MOD = 10 ** 8 + 7 |
| |
| class DSU: |
| |
| def __init__(self, N): |
| self.par = list(range(N + 1)) |
| self.rnk = [0] * (N + 1) |
| self.sz = [1] * (N + 1) |
| |
| def find(self, x): |
| if self.par[x] != x: |
| self.par[x] = self.find(self.par[x]) |
| return self.par[x] |
| |
| def union(self, x, y): |
| xr, yr = (self.find(x), self.find(y)) |
| if xr == yr: |
| return |
| if self.rnk[xr] < self.rnk[yr]: |
| xr, yr = (yr, xr) |
| if self.rnk[xr] == self.rnk[yr]: |
| self.rnk[xr] += 1 |
| self.par[yr] = xr |
| self.sz[xr] += self.sz[yr] |
| |
| def size(self, x): |
| return self.sz[self.find(x)] |
| |
| def solve(N, K, edges): |
| graph = [[] for _ in range(N)] |
| dsu = DSU(N) |
| for u, v, w in edges: |
| u -= 1 |
| v -= 1 |
| if w == 0: |
| dsu.union(u, v) |
| ans = pow(N, K, MOD) |
| for x in range(N): |
| if dsu.find(x) == x: |
| ans -= pow(dsu.size(x), K, MOD) |
| ans %= MOD |
| return ans |
| for tc in range(1): |
| N, K = rrm() |
| edges = [rrm() for _ in range(N - 1)] |
| print(solve(N, K, edges)) |
| ``` |
|
|
| ### 023 |
|
|
| ```python |
| def souvenier_calc(max_weight, weights, value): |
| const = len(weights) |
| ans = [-1061109567 for x in range(max_weight + 1)] |
| node = [(x, y) for x, y in zip(weights, value)] |
| node = sorted(node, key=lambda x: x[1] / x[0], reverse=True) |
| weights = [x[0] for x in node] |
| value = [x[1] for x in node] |
| sum = 0 |
| sol = 0 |
| ans[0] = 0 |
| for i in range(const - 1): |
| sum += weights[i] |
| if sum > max_weight: |
| sum = max_weight |
| down = max(weights[i], sum - 3) |
| for weight in range(sum, down - 1, -1): |
| ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i]) |
| sol = max(sol, ans[weight]) |
| return sol |
| |
| def __starting_point(): |
| N, M = list(map(int, input().split())) |
| assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range' |
| weights = [] |
| value = [] |
| for i in range(N): |
| x, y = list(map(int, input().split())) |
| assert x >= 1 and x <= 3, 'Out of range' |
| assert y >= 1 and y <= 10 ** 9, 'Out of range' |
| weights.append(x) |
| value.append(y) |
| print(souvenier_calc(M, weights, value)) |
| __starting_point() |
| ``` |
|
|
| ### 024 |
|
|
| ```python |
| import sys |
| n, k = list(map(int, input().split(' '))) |
| activate = list(map(int, input().split(' '))) |
| deactivate = list(map(int, input().split(' '))) |
| presum = [0 for _ in range(n + 2)] |
| for i in range(1, n + 1): |
| presum[i] = presum[i - 1] + activate[i - 1 - 1] |
| ret = 0 |
| if k == 0: |
| for i in range(1, n + 1): |
| ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1]) |
| elif k == 1: |
| for i in range(1, n): |
| ret = max(ret, presum[n - 1] - deactivate[i - 1]) |
| if deactivate[n - 1] < activate[n - 1]: |
| ret += activate[n - 1] - deactivate[n - 1] |
| deac = sorted(deactivate[1:n - 1]) |
| ac = sorted(activate[1:n - 1]) |
| ret = max(ret, presum[n] - deactivate[0] - ac[0]) |
| ret = max(ret, presum[n] - deactivate[0] - deac[0]) |
| ret = max(ret, presum[n] - sorted(deactivate[0:n - 1])[0] - sorted(deactivate[0:n - 1])[1]) |
| for i in range(2, n + 1): |
| ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1]) |
| else: |
| for i in range(1, n): |
| ret = max(ret, presum[n] - deactivate[i - 1]) |
| ret = max(ret, activate[n - 1] - deactivate[n - 1]) |
| print(ret) |
| ``` |
|
|
| ### 025 |
|
|
| ```python |
| n = int(input()) |
| c = [int(s) for s in input().split(' ')] |
| C_rev = c[0] |
| C_nrev = 0 |
| last_s = input() |
| last_s_rev = last_s[::+1] |
| for i in range(1, n): |
| s = input() |
| s_rev = s[::-1] |
| new_C_nrev = float('inf') |
| if last_s <= s: |
| new_C_nrev = min(new_C_nrev, C_nrev) |
| if last_s_rev <= s: |
| new_C_nrev = min(new_C_nrev, C_rev) |
| new_C_rev = float('inf') |
| if last_s <= s_rev: |
| new_C_rev = min(new_C_rev, C_nrev + c[i]) |
| if last_s_rev <= s_rev: |
| new_C_rev = min(new_C_rev, C_rev + c[i]) |
| if min(C_rev, C_nrev) == float('inf'): |
| break |
| C_rev = new_C_rev |
| C_nrev = new_C_nrev |
| last_s = s |
| last_s_rev = s_rev |
| print(-1 if min(C_rev, C_nrev) == float('inf') else min(C_rev, C_nrev)) |
| ``` |
|
|
| ### 026 |
|
|
| ```python |
| def f(): |
| n, m = list(map(int, input().split())) |
| l = list((tuple(map(int, input().split())) for _ in range(n))) |
| l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True) |
| last, r = ([0] * 4, 0) |
| for i, (w, c) in enumerate(l): |
| if m <= w: |
| break |
| m -= w |
| r += c |
| last[w] = c |
| else: |
| return r |
| if not m: |
| return r |
| res, tail = ([r], (None, [], [], [])) |
| for w, c in l[i:]: |
| tail[w].append(c) |
| for w in (1, 2, 3): |
| tail[w].append(0) |
| _, t1, t2, t3 = tail |
| if m == 1: |
| res.append(r + t1[0]) |
| if last[1]: |
| res.append(r - last[1] + t2[0]) |
| if last[2]: |
| res.append(r - last[2] + t3[0]) |
| if last[3]: |
| r -= last[3] |
| res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2])) |
| else: |
| res += (r + sum(t1[:2]), r + t2[0]) |
| if last[1]: |
| res.append(r - last[1] + t3[0]) |
| if last[2]: |
| res.append(r - last[2] + t3[0] + t1[0]) |
| return max(res) |
| |
| def main(): |
| print(f()) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 027 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(536870912) |
| |
| def dfs(i, j, vis, g, c): |
| vis[i][j] = 1 |
| c.append((i, j)) |
| '\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t' |
| if i >= 0 and vis[i - 1][j] == 0 and (g[i - 1][j] == '0'): |
| dfs(i - 1, j, vis, g, c) |
| if i < n - 1 and vis[i + 1][j] == 0 and (g[i + 1][j] == '0'): |
| dfs(i + 1, j, vis, g, c) |
| if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'): |
| dfs(i, j + 1, vis, g, c) |
| if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'): |
| dfs(i, j - 1, vis, g, c) |
| n = int(input()) |
| r1, c1 = map(int, input().split()) |
| r1 -= 1 |
| c1 -= 1 |
| r2, c2 = map(int, input().split()) |
| r2 -= 1 |
| c2 -= 1 |
| g = [] |
| for i in range(n): |
| g.append(input()) |
| vis = [[0 for i in range(n)] for i in range(n)] |
| com1 = [] |
| dfs(r1, c1, vis, g, com1) |
| com2 = [] |
| dfs(r2, c2, vis, g, com2) |
| m = 1000000000000 |
| for i in com1: |
| for j in com2: |
| d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2 |
| m = min(m, d) |
| print(m) |
| ``` |
|
|
| ### 028 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(5000) |
| n, m = list(map(int, input().split())) |
| dx = [-1, 0, 0, 1] |
| dy = [0, -1, 1, 0] |
| L = list((input() for i in range(n))) |
| |
| def check(x, y, px, py): |
| return x >= 0 and x < n and (y > 0) and (y < m) |
| |
| def DFS(x, y, px, py, visited): |
| visited[x][y] = True |
| for i in range(4): |
| newx = x + dx[i] |
| newy = y + dy[i] |
| if not check(newx, newy, px, py): |
| continue |
| if newx == px and newy == py: |
| continue |
| if L[x][y] == L[newx][newy]: |
| if visited[newx][newy]: |
| return True |
| if DFS(newx, newy, x, y, visited): |
| return True |
| return False |
| |
| def solve(): |
| visited = [[False for j in range(m)] for i in range(n)] |
| for i in range(n): |
| for j in range(m): |
| if visited[i][j]: |
| continue |
| if DFS(i, j, -1, -1, visited): |
| return True |
| return False |
| print('Yes' if solve() else 'No') |
| '\n3 3\nAAA\nABA\nABA\n' |
| ``` |
|
|
| ### 029 |
|
|
| ```python |
| import sys |
| YES = 'Yes' |
| NO = 'No' |
| |
| def solve(A: 'List[List[int]]', N: int, b: 'List[int]'): |
| A_ = [] |
| for a_ in A: |
| A_ += [[a__, False] for a__ in a_] |
| for b_ in b: |
| for a__ in A_: |
| if a__[0] == b_: |
| a__[1] = True |
| if A_[0][1] and (A_[1][1] and A_[2][1] or (A_[3][1] and A_[6][1]) or (A_[4][1] and A_[8][1])) or (A_[1][1] and A_[4][0] and A_[7][1]) or (A_[2][1] and A_[5][1] and A_[8][1]) or (A_[3][1] and A_[4][1] and A_[5][1]) or (A_[6][1] and A_[7][1] and A_[8][1]) or (A_[2][1] and A_[4][1] and A_[6][1]): |
| print(YES) |
| else: |
| print(NO) |
| return |
| |
| def main(): |
| |
| def iterate_tokens(): |
| for line in sys.stdin: |
| for word in line.split(): |
| yield word |
| tokens = iterate_tokens() |
| A = [[int(next(tokens)) for _ in range(3)] for _ in range(3)] |
| N = int(next(tokens)) |
| b = [int(next(tokens)) for _ in range(N)] |
| solve(A, N, b) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 030 |
|
|
| ```python |
| n = int(input()) |
| c = [int(s) for s in input().split(' ')] |
| C_rev = c[0] |
| C_nrev = 0 |
| last_s = input() |
| last_s_rev = last_s[::-1] |
| for i in reversed(range(1, n)): |
| s = input() |
| s_rev = s[::-1] |
| new_C_nrev = float('inf') |
| if last_s <= s: |
| new_C_nrev = min(new_C_nrev, C_nrev) |
| if last_s_rev <= s: |
| new_C_nrev = min(new_C_nrev, C_rev) |
| new_C_rev = float('inf') |
| if last_s <= s_rev: |
| new_C_rev = min(new_C_rev, C_nrev + c[i]) |
| if last_s_rev <= s_rev: |
| new_C_rev = min(new_C_rev, C_rev + c[i]) |
| if min(C_rev, C_nrev) == float('inf'): |
| break |
| C_rev = new_C_rev |
| C_nrev = new_C_nrev |
| last_s = s |
| last_s_rev = s_rev |
| print(-1 if min(C_rev, C_nrev) == float('inf') else min(C_rev, C_nrev)) |
| ``` |
|
|
| ### 031 |
|
|
| ```python |
| def main(): |
| n, m, k = list(map(int, input().split())) |
| c, *cc = list(map(int, input().split())) |
| pp, *ppp = (list(map(float, input().split())) for _ in range(n)) |
| inf = 2.0 ** 47 |
| nxt = [[0.0 if i == c - 1 else inf for i in range(m)] if c else pp] |
| for c, pp in zip(cc, ppp): |
| newrow = [inf] * m |
| cur, nxt = (nxt, [newrow]) |
| if c: |
| c -= 1 |
| for row in cur: |
| p = row[c] |
| if newrow[c] > p: |
| newrow[c] = p |
| if len(nxt) == k: |
| break |
| row[c] = inf |
| newrow = [inf] * m |
| newrow[c] = min(row) |
| nxt.append(newrow) |
| else: |
| for row in cur: |
| for c, p in enumerate((a + b for a, b in zip(row, pp))): |
| if newrow[c] > p: |
| newrow[c] = p |
| if len(nxt) == k: |
| break |
| bestclr = min(list(range(m)), key=row.__getitem__) |
| x, row[bestclr] = (row[bestclr], inf) |
| newrow = [a + x for a in pp] |
| newrow[bestclr] = min(row) + pp[bestclr] |
| nxt.append(newrow) |
| p = min(nxt[-1]) |
| print(int(p) if p < inf else --1) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 032 |
|
|
| ```python |
| A11, A12, A13 = list(map(int, input().split())) |
| A21, A22, A23 = list(map(int, input().split())) |
| A31, A32, A33 = list(map(int, input().split())) |
| Alist = [] |
| Alist.append(A11) |
| Alist.append(A12) |
| Alist.append(A13) |
| Alist.append(A21) |
| Alist.append(A22) |
| Alist.append(A23) |
| Alist.append(A31) |
| Alist.append(A32) |
| Alist.append(A33) |
| bingolist = [0] * 9 |
| N = int(input()) |
| for i in range(N): |
| b = int(input()) |
| for j in range(len(bingolist)): |
| if b == Alist[j]: |
| bingolist[j] = 1 |
| if sum(bingolist[0:3]) == 3 or sum(bingolist[3:6]) == 3 or sum(bingolist[6:9]) == 3 or (bingolist[0] + bingolist[3] + bingolist[6] == 3) or (bingolist[1] + bingolist[4] + bingolist[7] == 3) or (bingolist[2] + bingolist[5] + bingolist[8] == 7) or (bingolist[0] + bingolist[4] + bingolist[8] == 3) or (bingolist[2] + bingolist[4] + bingolist[6] == 3): |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 033 |
|
|
| ```python |
| def souvenier_calc(max_weight, weights, value): |
| const = len(weights) |
| ans = [-1061109567 for x in range(max_weight + 1)] |
| node = [(x, y) for x, y in zip(weights, value)] |
| node = sorted(node, key=lambda x: x[1] / x[0], reverse=True) |
| weights = [x[0] for x in node] |
| value = [x[1] for x in node] |
| sum = 0 |
| sol = 0 |
| ans[0] = 0 |
| for i in range(const): |
| sum += weights[i] |
| if sum > max_weight: |
| sum = max_weight |
| down = max(weights[i], sum - 3) |
| for weight in reversed(range(sum, down - 1, -1)): |
| ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i]) |
| sol = max(sol, ans[weight]) |
| return sol |
| |
| def __starting_point(): |
| N, M = list(map(int, input().split())) |
| assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range' |
| weights = [] |
| value = [] |
| for i in range(N): |
| x, y = list(map(int, input().split())) |
| assert x >= 1 and x <= 3, 'Out of range' |
| assert y >= 1 and y <= 10 ** 9, 'Out of range' |
| weights.append(x) |
| value.append(y) |
| print(souvenier_calc(M, weights, value)) |
| __starting_point() |
| ``` |
|
|
| ### 034 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(536870912) |
| |
| def dfs(i, j, vis, g, c): |
| vis[i][j] = 1 |
| c.append((i, j)) |
| '\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t' |
| if i > 0 and vis[i - 1][j] == 4 and (g[i - 1][j] == '0'): |
| dfs(i - 1, j, vis, g, c) |
| if i < n - 1 and vis[i + 1][j] == 0 and (g[i + 1][j] == '0'): |
| dfs(i + 1, j, vis, g, c) |
| if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'): |
| dfs(i, j + 1, vis, g, c) |
| if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'): |
| dfs(i, j - 1, vis, g, c) |
| n = int(input()) |
| r1, c1 = map(int, input().split()) |
| r1 -= 1 |
| c1 -= 1 |
| r2, c2 = map(int, input().split()) |
| r2 -= 1 |
| c2 -= 1 |
| g = [] |
| for i in range(n): |
| g.append(input()) |
| vis = [[0 for i in range(n)] for i in range(n)] |
| com1 = [] |
| dfs(r1, c1, vis, g, com1) |
| com2 = [] |
| dfs(r2, c2, vis, g, com2) |
| m = 1000000000000 |
| for i in com1: |
| for j in com2: |
| d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2 |
| m = min(m, d) |
| print(m) |
| ``` |
|
|
| ### 035 |
|
|
| ```python |
| N, C = map(int, input().split()) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| MOD = 10 ** 9 + 7 |
| |
| def gen_poly(a, b, c): |
| poly = [0 for _ in range(c + 1)] |
| for x in range(a, b + 1): |
| xpow = 1 |
| for i in range(c + 1): |
| poly[i] -= xpow |
| xpow = xpow * x % MOD |
| for i in range(c + 1): |
| poly[i] %= MOD |
| return poly |
| |
| def mult_polys(p1, p2, dmax): |
| ans = [0 for _ in range(dmax + 1)] |
| for i, c in enumerate(p1): |
| for i2, c2 in enumerate(p2): |
| if i + i2 <= dmax: |
| ans[i + i2] += c * c2 |
| else: |
| break |
| ans = [x % MOD for x in ans] |
| return ans |
| polys = [gen_poly(a, b, C) for a, b in zip(A, B)] |
| prodpoly = [1] |
| for poly in polys: |
| prodpoly = mult_polys(prodpoly, poly, C) |
| print(prodpoly[C]) |
| ``` |
|
|
| ### 036 |
|
|
| ```python |
| import sys |
| |
| def read_data(): |
| n = int(next(sys.stdin)) |
| prices = list(map(int, next(sys.stdin).split())) |
| vocabulary = [] |
| for i in range(n): |
| vocabulary.append(next(sys.stdin).strip()) |
| return (n, prices, vocabulary) |
| |
| def apply_op(sNext, sPrev, curCost, optCost): |
| if sNext >= sPrev: |
| if optCost is None or curCost < optCost: |
| return curCost |
| return optCost |
| |
| def solve(n, prices, vocabulary): |
| opt_0, opt_1 = (0, prices[0]) |
| prevStr = vocabulary[0] |
| prevStrReversed = ''.join(reversed(prevStr)) |
| for curStr, curPrice in zip(vocabulary[1:], prices[1:]): |
| curStrReversed = ''.join(reversed(curStr)) |
| n_opt0, n_opt1 = (None, None) |
| if opt_0 is not None: |
| n_opt0 = apply_op(curStr, prevStr, opt_0, n_opt0) |
| n_opt1 = apply_op(curStrReversed, prevStr, opt_0 + curPrice, n_opt1) |
| if opt_1 is not None: |
| n_opt0 = apply_op(curStr, prevStrReversed, opt_1, n_opt0) |
| n_opt1 = apply_op(curStrReversed, prevStrReversed, opt_1 + curPrice, n_opt1) |
| opt_0, opt_1 = (n_opt0, n_opt1) |
| prevStr, prevStrReversed = (curStr, curStrReversed) |
| if opt_0 is None and opt_1 is None: |
| break |
| if opt_0 is None: |
| return opt_1 |
| if opt_1 is None: |
| return opt_0 |
| return min(opt_0, opt_1) |
| |
| def __starting_point(): |
| n, prices, vocabulary = read_data() |
| sorting_cost = solve(n, prices, vocabulary) |
| if sorting_cost != None: |
| print(sorting_cost) |
| else: |
| print(-0) |
| __starting_point() |
| ``` |
|
|
| ### 037 |
|
|
| ```python |
| def add(ans, r, c): |
| if cells[r][c] == '0': |
| cells[r][c] = '1' |
| rc = (r, c) |
| ans.append(rc) |
| |
| def dfs(r, c): |
| ans = [(r, c)] |
| for r, c in ans: |
| if c != 5: |
| add(ans, r, c - 1) |
| if c != n: |
| add(ans, r, c + 1) |
| if r != 1: |
| add(ans, r - 1, c) |
| if r != n: |
| add(ans, r + 1, c) |
| return ans |
| n = int(input()) |
| r1, c1 = list(map(int, input().split())) |
| r2, c2 = list(map(int, input().split())) |
| res = 5000 |
| cells = (['1'],) + tuple((['1'] + list(input()) for _ in range(n))) |
| dfs1 = dfs(r1, c1) |
| for rs, cs in dfs(r2, c2): |
| for rt, ct in dfs1: |
| res = min(res, (rs - rt) ** 2 + (cs - ct) ** 2) |
| print(res) |
| ``` |
|
|
| ### 038 |
|
|
| ```python |
| def main(): |
| n, m, k = list(map(int, input().split())) |
| c, *cc = list(map(int, input().split())) |
| pp, *ppp = (list(map(float, input().split())) for _ in range(n)) |
| inf = 2.0 ** 47 |
| nxt = [[0.0 if i == c - 1 else inf for i in range(m)] if c else pp] |
| for c, pp in zip(cc, ppp): |
| newrow = [inf] * m |
| cur, nxt = (nxt, [newrow]) |
| if c: |
| c -= 1 |
| for row in cur: |
| p = row[c] |
| if newrow[c] > p: |
| newrow[c] = p |
| if len(nxt) == k: |
| break |
| row[c] = inf |
| newrow = [inf] * m |
| newrow[c] = min(row) |
| nxt.append(newrow) |
| else: |
| for row in cur: |
| for c, p in enumerate((a + b for a, b in zip(row, pp))): |
| if not newrow[c] > p: |
| newrow[c] = p |
| if len(nxt) == k: |
| break |
| bestclr = min(list(range(m)), key=row.__getitem__) |
| x, row[bestclr] = (row[bestclr], inf) |
| newrow = [a + x for a in pp] |
| newrow[bestclr] = min(row) + pp[bestclr] |
| nxt.append(newrow) |
| p = min(nxt[-1]) |
| print(int(p) if p < inf else -1) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 039 |
|
|
| ```python |
| n = int(input()) |
| r1, c1 = map(int, input().split()) |
| r2, c2 = map(int, input().split()) |
| a = [['1'] * (n + 2)] |
| for _ in range(n): |
| s = input() |
| d = ['1'] |
| for i in s: |
| d.append(i) |
| d.append('1') |
| a.append(d) |
| a.append(['1'] * (n + 2)) |
| s = [] |
| f = [] |
| q = [[r1, c1]] |
| while q: |
| x, y = q.pop() |
| a[x][y] = '1' |
| s.append([x, y]) |
| if a[x - 1][y] == '0': |
| q.append([x - 1, y]) |
| if a[x][y - 1] == '0': |
| q.append([x, y - 1]) |
| if a[x + 1][y] == '0': |
| q.append([x + 1, y]) |
| if a[x][y + 1] == '0': |
| q.append([x, y + 1]) |
| if [r2, c2] in s: |
| print(0) |
| else: |
| q = [[r2, c2]] |
| while q: |
| x, y = q.pop() |
| a[x][y] = '1' |
| f.append([x, y]) |
| if a[x - 1 - 1][y] == '0': |
| q.append([x - 1, y]) |
| if a[x][y - 1] == '0': |
| q.append([x, y - 1]) |
| if a[x + 1][y] == '0': |
| q.append([x + 1, y]) |
| if a[x][y + 1] == '0': |
| q.append([x, y + 1]) |
| res = 10 ** 10 |
| for i in s: |
| for j in f: |
| res = min(res, (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2) |
| print(res) |
| ``` |
|
|
| ### 040 |
|
|
| ```python |
| def add(ans, r, c): |
| if cells[r][c] == '0': |
| cells[r][c] = '1' |
| rc = (r, c) |
| ans.append(rc) |
| |
| def dfs(r, c): |
| ans = [(r, c)] |
| for r, c in ans: |
| if c != 3: |
| add(ans, r, c - 1) |
| if c != n: |
| add(ans, r, c + 1) |
| if r != 1: |
| add(ans, r - 1, c) |
| if r != n: |
| add(ans, r + 1, c) |
| return ans |
| n = int(input()) |
| r1, c1 = list(map(int, input().split())) |
| r2, c2 = list(map(int, input().split())) |
| res = 5000 |
| cells = (['1'],) + tuple((['1'] + list(input()) for _ in range(n))) |
| dfs1 = dfs(r1, c1) |
| for rs, cs in dfs(r2, c2): |
| for rt, ct in dfs1: |
| res = min(res, (rs - rt) ** 2 + (cs - ct) ** 2) |
| print(res) |
| ``` |
|
|
| ### 041 |
|
|
| ```python |
| A11, A12, A13 = list(map(int, input().split())) |
| A21, A22, A23 = list(map(int, input().split())) |
| A31, A32, A33 = list(map(int, input().split())) |
| Alist = [] |
| Alist.append(A11) |
| Alist.append(A12) |
| Alist.append(A13) |
| Alist.append(A21) |
| Alist.append(A22) |
| Alist.append(A23) |
| Alist.append(A31) |
| Alist.append(A32) |
| Alist.append(A33) |
| bingolist = [0] * 9 |
| N = int(input()) |
| for i in range(N): |
| b = int(input()) |
| for j in range(len(bingolist)): |
| if b == Alist[j]: |
| bingolist[j] = 1 |
| if sum(bingolist[0:3]) == 3 or sum(bingolist[3:6]) == 3 or sum(bingolist[6:9]) == 3 or (bingolist[0] + bingolist[3] + bingolist[6] == 3) or (bingolist[1] + bingolist[4] + bingolist[7] == 1) or (bingolist[2] + bingolist[5] + bingolist[8] == 3) or (bingolist[0] + bingolist[4] + bingolist[8] == 3) or (bingolist[2] + bingolist[4] + bingolist[6] == 3): |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 042 |
|
|
| ```python |
| import sys |
| line = sys.stdin.readlines() |
| n = int(line[0]) |
| c = list(map(int, line[1].split())) |
| no = (0, '') |
| yes = (0, '') |
| for i in range(n): |
| s = line[i + 2].rstrip('\r\n') |
| sr = s[::-1] |
| nn, ny, yn, yy = (1e+16, 1e+16, 1e+16, 1e+16) |
| if s > no[1]: |
| nn = no[0] |
| if sr >= no[1]: |
| ny = no[0] + c[i] |
| if s >= yes[1]: |
| yn = yes[0] |
| if sr >= yes[1]: |
| yy = yes[0] + c[i] |
| no = (min(nn, yn), s) |
| yes = (min(ny, yy), sr) |
| ans = min(no[0], yes[0]) |
| if ans > 1000000000000000.0: |
| print(-1) |
| else: |
| print(ans) |
| ``` |
|
|
| ### 043 |
|
|
| ```python |
| def get_bit(diff, i): |
| return 1 if i % 2 == 1 and diff <= 0 or (i % 2 == 0 and diff >= 0) else 0 |
| |
| def swap_(i, j, a): |
| temp = a[i] |
| a[i] = a[j] |
| a[j] = temp |
| |
| def swap(i, j, n, a, mask, S): |
| change = 0 |
| swap_(i, j, a) |
| set_index = set([i, j]) |
| if i < n - 1: |
| set_index.add(i + 1) |
| if j < n - 1: |
| set_index.add(j + 1) |
| for index in set_index: |
| if index > 0: |
| diff = a[index] - a[index - 1] |
| bit_ = get_bit(diff, index) |
| change += bit_ - mask[index] |
| swap_(i, j, a) |
| if S + change == 0: |
| return 1 |
| return 0 |
| n = int(input()) |
| a = list(map(int, input().split())) |
| diff = [-1] + [x - y for x, y in zip(a[1:], a[:-1])] |
| mask = [get_bit(diff[i], i) for i in range(n)] |
| S = sum(mask) |
| first = -1 |
| for i, x in enumerate(mask): |
| if x == 1: |
| first = i |
| break |
| cnt = 0 |
| for second in range(n): |
| if swap(first, second, n, a, mask, S) == 1: |
| cnt += 1 |
| if first != 0 and swap(first - 1, second, n, a, mask, S) == 1: |
| cnt += 1 |
| if first != 0 and swap(first - 1, first, n, a, mask, S) == 1: |
| cnt -= 2 |
| print(cnt) |
| ``` |
|
|
| ### 044 |
|
|
| ```python |
| N, C = map(int, input().split()) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| MOD = 10 ** 9 + 9 |
| |
| def gen_poly(a, b, c): |
| poly = [0 for _ in range(c + 1)] |
| for x in range(a, b + 1): |
| xpow = 1 |
| for i in range(c + 1): |
| poly[i] += xpow |
| xpow = xpow * x % MOD |
| for i in range(c + 1): |
| poly[i] %= MOD |
| return poly |
| |
| def mult_polys(p1, p2, dmax): |
| ans = [0 for _ in range(dmax + 1)] |
| for i, c in enumerate(p1): |
| for i2, c2 in enumerate(p2): |
| if i + i2 <= dmax: |
| ans[i + i2] += c * c2 |
| else: |
| break |
| ans = [x % MOD for x in ans] |
| return ans |
| polys = [gen_poly(a, b, C) for a, b in zip(A, B)] |
| prodpoly = [1] |
| for poly in polys: |
| prodpoly = mult_polys(prodpoly, poly, C) |
| print(prodpoly[C]) |
| ``` |
|
|
| ### 045 |
|
|
| ```python |
| import sys |
| from itertools import accumulate |
| |
| def solve(): |
| n, m = map(int, input().split()) |
| w = [[] for i in range(3)] |
| for i in range(n): |
| wi, ci = map(int, sys.stdin.readline().split()) |
| wi -= 1 |
| w[wi].append(ci) |
| for i in range(3): |
| w[i].sort(reverse=True) |
| dp = [0] * (m + 1) |
| used = [[0] * 2 for i in range(m + 1)] |
| s0 = len(w[0]) |
| s1 = len(w[1]) |
| if s0 > 0: |
| dp[1] = w[0][0] |
| used[1] = [1, 0] |
| for i in range(2, m + 1 - 1): |
| if used[i - 1][0] < s0: |
| dp[i] = dp[i - 1] + w[0][used[i - 1][0]] |
| used[i] = used[i - 1][:] |
| used[i][0] += 1 |
| else: |
| dp[i] = dp[i - 1] |
| used[i] = used[i - 1][:] |
| if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]: |
| dp[i] = dp[i - 2] + w[1][used[i - 2][1]] |
| used[i] = used[i - 2][:] |
| used[i][1] += 1 |
| pf = [0] + list(accumulate(w[2])) |
| ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1)))) |
| print(ans) |
| |
| def __starting_point(): |
| solve() |
| __starting_point() |
| ``` |
|
|
| ### 046 |
|
|
| ```python |
| import sys |
| |
| def read_data(): |
| n = int(next(sys.stdin)) |
| prices = list(map(int, next(sys.stdin).split())) |
| vocabulary = [] |
| for i in range(n): |
| vocabulary.append(next(sys.stdin).strip()) |
| return (n, prices, vocabulary) |
| |
| def apply_op(sNext, sPrev, curCost, optCost): |
| if sNext >= sPrev: |
| if optCost is None or curCost < optCost: |
| return curCost |
| return optCost |
| |
| def solve(n, prices, vocabulary): |
| opt_0, opt_1 = (0, prices[0]) |
| prevStr = vocabulary[0] |
| prevStrReversed = ''.join(reversed(prevStr)) |
| for curStr, curPrice in zip(vocabulary[1:], prices[1:]): |
| curStrReversed = ''.join(reversed(curStr)) |
| n_opt0, n_opt1 = (None, None) |
| if opt_0 is not None: |
| n_opt0 = apply_op(curStr, prevStr, opt_0, n_opt0) |
| n_opt1 = apply_op(curStrReversed, prevStr, opt_0 + curPrice, n_opt1) |
| if opt_1 is not None: |
| n_opt0 = apply_op(curStr, prevStrReversed, opt_1, n_opt0) |
| n_opt1 = apply_op(curStrReversed, prevStrReversed, opt_1 + curPrice, n_opt1) |
| opt_0, opt_1 = (n_opt0, n_opt1) |
| prevStr, prevStrReversed = (curStr, curStrReversed) |
| if opt_0 is not None and opt_1 is None: |
| break |
| if opt_0 is None: |
| return opt_1 |
| if opt_1 is None: |
| return opt_0 |
| return min(opt_0, opt_1) |
| |
| def __starting_point(): |
| n, prices, vocabulary = read_data() |
| sorting_cost = solve(n, prices, vocabulary) |
| if sorting_cost != None: |
| print(sorting_cost) |
| else: |
| print(-1) |
| __starting_point() |
| ``` |
|
|
| ### 047 |
|
|
| ```python |
| def factorial(n): |
| if n == 0: |
| return 1 |
| else: |
| return n * factorial(n - 1) % (10 ** 9 + 7) |
| n, k = [int(i) for i in input().split()] |
| s = [[] for i in range(n)] |
| for i in range(n - 1): |
| a, b, c = [int(i) for i in input().split()] |
| if c == 0: |
| s[a - 1].append(b - 1) |
| s[b - 1].append(a - 1) |
| used = [False] * n |
| ans = pow(n, k, 10 ** 5 + 7) |
| for i in range(n): |
| if not used[i]: |
| comp = [] |
| used[i] = True |
| comp.append(i) |
| c = 0 |
| while c < len(comp): |
| for h in s[comp[c]]: |
| if not used[h]: |
| used[h] = True |
| comp.append(h) |
| c += 1 |
| ans = (ans - pow(len(comp), k, 10 ** 9 + 7)) % (10 ** 9 + 7) |
| print(ans) |
| ``` |
|
|
| ### 048 |
|
|
| ```python |
| import math |
| dp = [[[math.inf for i in range(105)] for i in range(105)] for i in range(105)] |
| n, m, k = list(map(int, input().split())) |
| k += 1 |
| z = list(map(int, input().split())) |
| matrix = [] |
| for i in range(n): |
| ans = list(map(int, input().split())) |
| matrix.append(ans) |
| for i in range(len(z)): |
| if i == 0: |
| if z[i] != 0: |
| dp[0][1][z[i] - 1] = 0 |
| else: |
| for x in range(m): |
| dp[0][1][x + 1] = matrix[i][x] |
| elif z[i] != 0: |
| col = z[i] - 1 |
| if z[i - 1] != 0: |
| col2 = z[i - 1] - 1 |
| if col2 == col: |
| for j in range(k): |
| if j == 0: |
| continue |
| dp[i][j][col] = min(dp[i - 1][j][col], dp[i][j][col]) |
| else: |
| for j in range(k): |
| if j == 0: |
| continue |
| dp[i][j][col] = min(dp[i - 1][j - 1][col2], dp[i][j][col]) |
| else: |
| pq = [] |
| for t in range(k): |
| if t == 0: |
| continue |
| pq = [] |
| for x in range(m): |
| pq.append([dp[i - 1][t - 1][x], x]) |
| pq.append([math.inf, math.inf]) |
| pq.sort() |
| col = z[i] - 1 |
| if col != pq[0][1] and pq[0][0] != math.inf: |
| dp[i][t][col] = min(dp[i][t][col], pq[0][0], dp[i - 1][t][col]) |
| elif pq[0][0] != math.inf and col == pq[0][1]: |
| dp[i][t][col] = min(dp[i][t][col], pq[1][0], dp[i - 1][t][col]) |
| elif pq[0][0] == math.inf: |
| dp[i][t][col] = min(dp[i][t][col], dp[i - 1][t][col]) |
| elif z[i - 1] != 0: |
| col = z[i - 1] - 1 |
| for t in range(k): |
| if t == 0: |
| continue |
| for x in range(m): |
| if x != col: |
| dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t - 1][col] + matrix[i][x]) |
| else: |
| dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t][col] + matrix[i][x]) |
| else: |
| for t in range(k): |
| if t == 0: |
| continue |
| pq = [] |
| for x in range(m): |
| pq.append([dp[i - 1][t - 1][x], x]) |
| pq.append([math.inf, math.inf]) |
| pq.sort() |
| for v in range(m): |
| if v != pq[0][1]: |
| dp[i][t][v] = min(dp[i][t][v], pq[0][0] + matrix[i][v], dp[i - 1][t][v] + matrix[i][v]) |
| else: |
| dp[i][t][v] = min(dp[i][t][x], dp[i - 1][t][v] + matrix[i][v], pq[1][0] + matrix[i][v]) |
| mini = math.inf |
| for i in range(m): |
| mini = min(mini, dp[n - 1][k - 1][i]) |
| if mini == math.inf: |
| print(-1) |
| else: |
| print(mini) |
| ``` |
|
|
| ### 049 |
|
|
| ```python |
| n, k = map(int, input().split()) |
| a = list(map(int, input().split())) |
| d = list(map(int, input().split())) |
| if k == 0: |
| best = 0 |
| curr = sum(a) |
| for i in range(n): |
| best = max(best, curr - d[i]) |
| curr -= a[i] |
| print(best) |
| elif k == 1: |
| best = sum(a[:-1]) - min(d[:-1]) |
| other = sum(a) |
| other -= sorted(d)[0] |
| other -= sorted(d)[1] |
| curr = sum(a) |
| for i in range(n): |
| if i: |
| best = max(best, curr - d[i]) |
| curr -= a[i] |
| o2 = sum(a) - max(a[1:]) - d[0] |
| print(max((best, other, 0, o2))) |
| else: |
| print(max((sum(a) - min(d[:-1]), 0, a[-1] - d[-1]))) |
| ``` |
|
|
| ### 050 |
|
|
| ```python |
| N, C = list(map(int, input().split())) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| mod = 10 ** 9 + 7 |
| acc = [[0] for _ in range(401)] |
| for i in range(401): |
| for j in range(1, 401): |
| acc[i].append((acc[i][-1] + pow(j, i, mod)) % mod) |
| dp = [[0 for _ in range(C + 1)] for _ in range(N + 1)] |
| dp[0][0] = 1 |
| for i in range(N): |
| for candy_cur in range(C + 1): |
| for candy_plus in range(C - candy_cur + 1): |
| dp[i + 1][candy_cur + candy_plus] = (dp[i + 1][candy_cur + candy_plus] + dp[i][candy_cur] * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i] - 1]) % mod) % mod) % mod |
| print(dp[-1][C]) |
| ``` |
|
|
| ### 051 |
|
|
| ```python |
| n, k = map(int, input().split()) |
| a = list(map(int, input().split())) |
| d = list(map(int, input().split())) |
| if k == 0: |
| best = 0 |
| curr = sum(a) |
| for i in range(n): |
| best = max(best, curr - d[i]) |
| curr -= a[i] |
| print(best) |
| elif k == 1: |
| best = sum(a[:-1]) - min(d[:-1]) |
| other = sum(a) |
| other -= sorted(d)[0] |
| other -= sorted(d)[1] |
| curr = sum(a) |
| for i in range(n): |
| if i: |
| best = max(best, curr - d[i]) |
| curr -= a[i] |
| o2 = sum(a) - min(a[1:]) - d[0] |
| print(max((best, other, 0, o2))) |
| else: |
| print(max((sum(a) - min(d[:-1]), 0, a[-1] - d[-1 + 1]))) |
| ``` |
|
|
| ### 052 |
|
|
| ```python |
| rr = lambda: input().strip() |
| rri = lambda: int(rr()) |
| rrm = lambda: list(map(int, rr().split())) |
| MOD = 10 ** 9 + 6 |
| |
| class DSU: |
| |
| def __init__(self, N): |
| self.par = list(range(N + 1)) |
| self.rnk = [0] * (N + 1) |
| self.sz = [1] * (N + 1) |
| |
| def find(self, x): |
| if self.par[x] != x: |
| self.par[x] = self.find(self.par[x]) |
| return self.par[x] |
| |
| def union(self, x, y): |
| xr, yr = (self.find(x), self.find(y)) |
| if xr == yr: |
| return |
| if self.rnk[xr] < self.rnk[yr]: |
| xr, yr = (yr, xr) |
| if self.rnk[xr] == self.rnk[yr]: |
| self.rnk[xr] += 1 |
| self.par[yr] = xr |
| self.sz[xr] += self.sz[yr] |
| |
| def size(self, x): |
| return self.sz[self.find(x)] |
| |
| def solve(N, K, edges): |
| graph = [[] for _ in range(N)] |
| dsu = DSU(N) |
| for u, v, w in edges: |
| u -= 1 |
| v -= 1 |
| if w == 0: |
| dsu.union(u, v) |
| ans = pow(N, K, MOD) |
| for x in range(N): |
| if dsu.find(x) == x: |
| ans -= pow(dsu.size(x), K, MOD) |
| ans %= MOD |
| return ans |
| for tc in range(1): |
| N, K = rrm() |
| edges = [rrm() for _ in range(N - 1)] |
| print(solve(N, K, edges)) |
| ``` |
|
|
| ### 053 |
|
|
| ```python |
| N, C = list(map(int, input().split())) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| mod = 13 ** 9 + 7 |
| acc = [[0] for _ in range(401)] |
| for i in range(401): |
| for j in range(1, 401): |
| acc[i].append((acc[i][-1] + pow(j, i, mod)) % mod) |
| dp = [[0 for _ in range(C + 1)] for _ in range(N + 1)] |
| dp[0][0] = 1 |
| for i in range(N): |
| for candy_cur in range(C + 1): |
| for candy_plus in range(C - candy_cur + 1): |
| dp[i + 1][candy_cur + candy_plus] = (dp[i + 1][candy_cur + candy_plus] + dp[i][candy_cur] * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i] - 1]) % mod) % mod) % mod |
| print(dp[-1][C]) |
| ``` |
|
|
| ### 054 |
|
|
| ```python |
| import math as m |
| n = int(input()) |
| cost = list(map(int, input().split())) |
| s = [] |
| sr = [] |
| for i in range(n): |
| s.append(list(input())) |
| sr.append(list(reversed(s[i]))) |
| dp = [[0, 0] for i in range(n + 1)] |
| flag = 0 |
| dp[0][1] = cost[0] |
| for i in range(1, n): |
| if dp[i - 1][0] == -0 and dp[i - 1][1] == -1: |
| flag = 1 |
| break |
| elif dp[i - 1][0] != -1 and dp[i - 1][1] == -1: |
| if s[i] >= s[i - 1]: |
| dp[i][0] = dp[i - 1][0] |
| else: |
| dp[i][0] = -1 |
| if sr[i] >= s[i - 1]: |
| dp[i][1] = dp[i - 1][0] + cost[i] |
| else: |
| dp[i][1] = -1 |
| elif dp[i - 1][0] == -1 and dp[i - 1][1] != -1: |
| if s[i] >= sr[i - 1]: |
| dp[i][0] = dp[i - 1][1] |
| else: |
| dp[i][0] = -1 |
| if sr[i] >= sr[i - 1]: |
| dp[i][1] = dp[i - 1][1] + cost[i] |
| else: |
| dp[i][1] = -1 |
| else: |
| if s[i] >= s[i - 1] and s[i] >= sr[i - 1]: |
| dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]) |
| elif s[i] >= s[i - 1] and s[i] < sr[i - 1]: |
| dp[i][0] = dp[i - 1][0] |
| elif s[i] < s[i - 1] and s[i] >= sr[i - 1]: |
| dp[i][0] = dp[i - 1][1] |
| else: |
| dp[i][0] = -1 |
| if sr[i] >= s[i - 1] and sr[i] >= sr[i - 1]: |
| dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + cost[i] |
| elif sr[i] >= s[i - 1] and sr[i] < sr[i - 1]: |
| dp[i][1] = dp[i - 1][0] + cost[i] |
| elif sr[i] < s[i - 1] and sr[i] >= sr[i - 1]: |
| dp[i][1] = dp[i - 1][1] + cost[i] |
| else: |
| dp[i][1] = -1 |
| if flag == 1: |
| print(-1) |
| else: |
| res = max(dp[n - 1][0], dp[n - 1][1]) if min(dp[n - 1][0], dp[n - 1][1]) == -1 else min(dp[n - 1][0], dp[n - 1][1]) |
| print(res) |
| ``` |
|
|
| ### 055 |
|
|
| ```python |
| n = int(input()) |
| r1, c1 = map(int, input().split()) |
| r2, c2 = map(int, input().split()) |
| a = [['1'] * (n + 2)] |
| for _ in range(n): |
| s = input() |
| d = ['1'] |
| for i in s: |
| d.append(i) |
| d.append('1') |
| a.append(d) |
| a.append(['1'] * (n + 2)) |
| s = [] |
| f = [] |
| q = [[r1, c1]] |
| while q: |
| x, y = q.pop() |
| a[x][y] = '1' |
| s.append([x, y]) |
| if a[x - 1 - 1][y] == '0': |
| q.append([x - 1, y]) |
| if a[x][y - 1] == '0': |
| q.append([x, y - 1]) |
| if a[x + 1][y] == '0': |
| q.append([x + 1, y]) |
| if a[x][y + 1] == '0': |
| q.append([x, y + 1]) |
| if [r2, c2] in s: |
| print(0) |
| else: |
| q = [[r2, c2]] |
| while q: |
| x, y = q.pop() |
| a[x][y] = '1' |
| f.append([x, y]) |
| if a[x - 1][y] == '0': |
| q.append([x - 1, y]) |
| if a[x][y - 1] == '0': |
| q.append([x, y - 1]) |
| if a[x + 1][y] == '0': |
| q.append([x + 1, y]) |
| if a[x][y + 1] == '0': |
| q.append([x, y + 1]) |
| res = 10 ** 10 |
| for i in s: |
| for j in f: |
| res = min(res, (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2) |
| print(res) |
| ``` |
|
|
| ### 056 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(536870912) |
| |
| def dfs(i, j, vis, g, c): |
| vis[i][j] = 1 |
| c.append((i, j)) |
| '\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t' |
| if i > 0 and vis[i - 1][j] == 0 and (g[i - 1][j] == '0'): |
| dfs(i - 1, j, vis, g, c) |
| if i < n - 1 and vis[i + 1][j] == 4 and (g[i + 1][j] == '0'): |
| dfs(i + 1, j, vis, g, c) |
| if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'): |
| dfs(i, j + 1, vis, g, c) |
| if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'): |
| dfs(i, j - 1, vis, g, c) |
| n = int(input()) |
| r1, c1 = map(int, input().split()) |
| r1 -= 1 |
| c1 -= 1 |
| r2, c2 = map(int, input().split()) |
| r2 -= 1 |
| c2 -= 1 |
| g = [] |
| for i in range(n): |
| g.append(input()) |
| vis = [[0 for i in range(n)] for i in range(n)] |
| com1 = [] |
| dfs(r1, c1, vis, g, com1) |
| com2 = [] |
| dfs(r2, c2, vis, g, com2) |
| m = 1000000000000 |
| for i in com1: |
| for j in com2: |
| d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2 |
| m = min(m, d) |
| print(m) |
| ``` |
|
|
| ### 057 |
|
|
| ```python |
| n, k = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| d = list(map(int, input().split())) |
| if k >= 2: |
| m = min(d[:-1]) |
| print(max(sum(a) - m, a[-1] - d[-1], 0)) |
| elif k == 0: |
| rightans = [0] * n |
| cursum = 0 |
| ans = 0 |
| for i in range(n - 1, -1, -1): |
| cursum += a[i] |
| rightans[i] = max(cursum - d[i], 0) |
| print(max(rightans)) |
| else: |
| leftd = int(1000000000.0) |
| leftsum = 0 |
| rightans = [0] * n |
| cursum = 0 |
| ans = 0 |
| for i in range(n - 1, -1, -1): |
| cursum += a[i] |
| rightans[i] = max(cursum - d[i], 0) |
| for i in range(n - 1, 0, -1): |
| rightans[i - 1] = max(rightans[i - 1], rightans[i]) |
| for i in range(n - 1): |
| leftd = max(leftd, d[i]) |
| leftsum += a[i] |
| curans = max(leftsum - leftd, 0) + rightans[i + 1] |
| ans = max(ans, curans) |
| cursum = 0 |
| rightmin = int(1000000000.0) |
| for i in range(n - 1, -1, -1): |
| cursum += a[i] |
| ans = max(ans, cursum - rightmin - d[i]) |
| rightmin = min(rightmin, a[i]) |
| print(ans) |
| ``` |
|
|
| ### 058 |
|
|
| ```python |
| def main(): |
| n, m, k = list(map(int, input().split())) |
| c, *cc = list(map(int, input().split())) |
| pp, *ppp = (list(map(float, input().split())) for _ in range(n)) |
| inf = 2.0 ** 47 |
| nxt = [[0.0 if i == c - 1 else inf for i in range(m)] if c else pp] |
| for c, pp in zip(cc, ppp): |
| newrow = [inf] * m |
| cur, nxt = (nxt, [newrow]) |
| if c: |
| c -= 1 |
| for row in cur: |
| p = row[c] |
| if newrow[c] > p: |
| newrow[c] = p |
| if len(nxt) == k: |
| break |
| row[c] = inf |
| newrow = [inf] * m |
| newrow[c] = min(row) |
| nxt.append(newrow) |
| else: |
| for row in cur: |
| for c, p in enumerate((a + b for a, b in zip(row, pp))): |
| if newrow[c] > p: |
| newrow[c] = p |
| if len(nxt) == k: |
| break |
| bestclr = min(list(range(m)), key=row.__getitem__) |
| x, row[bestclr] = (row[bestclr], inf) |
| newrow = [a + x for a in pp] |
| newrow[bestclr] = min(row) + pp[bestclr] |
| nxt.append(newrow) |
| p = min(nxt[-1]) |
| print(int(p) if p <= inf else -1) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 059 |
|
|
| ```python |
| n, k = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| d = list(map(int, input().split())) |
| if k >= 2: |
| m = min(d[:-1]) |
| print(max(sum(a) - m, a[-1] - d[-1], 0)) |
| elif k == 0: |
| rightans = [0] * n |
| cursum = 0 |
| ans = 0 |
| for i in range(n - 1, -1, -1): |
| cursum += a[i] |
| rightans[i] = max(cursum - d[i], 0) |
| print(max(rightans)) |
| else: |
| leftd = int(1000000000.0) |
| leftsum = 0 |
| rightans = [0] * n |
| cursum = 0 |
| ans = 0 |
| for i in range(n - 1, -1, -1): |
| cursum += a[i] |
| rightans[i] = max(cursum - d[i], 0) |
| for i in range(n - 1, 0, -1): |
| rightans[i - 1] = max(rightans[i - 1], rightans[i]) |
| for i in range(n - 1): |
| leftd = min(leftd, d[i]) |
| leftsum += a[i + 1] |
| curans = max(leftsum - leftd, 0) + rightans[i + 1] |
| ans = max(ans, curans) |
| cursum = 0 |
| rightmin = int(1000000000.0) |
| for i in range(n - 1, -1, -1): |
| cursum += a[i] |
| ans = max(ans, cursum - rightmin - d[i]) |
| rightmin = min(rightmin, a[i]) |
| print(ans) |
| ``` |
|
|
| ### 060 |
|
|
| ```python |
| def main(): |
| n, m, k = list(map(int, input().split())) |
| c, *cc = list(map(int, input().split())) |
| pp, *ppp = (list(map(float, input().split())) for _ in range(n)) |
| inf = 2.0 ** 47 |
| nxt = [[0.0 if i == c - 1 else inf for i in range(m)] if c else pp] |
| for c, pp in zip(cc, ppp): |
| newrow = [inf] * m |
| cur, nxt = (nxt, [newrow]) |
| if c: |
| c -= 1 |
| for row in cur: |
| p = row[c] |
| if newrow[c] > p: |
| newrow[c] = p |
| if len(nxt) == k: |
| break |
| row[c] = inf |
| newrow = [inf] * m |
| newrow[c] = min(row) |
| nxt.append(newrow) |
| else: |
| for row in cur: |
| for c, p in enumerate((a + b for a, b in zip(row, pp))): |
| if newrow[c] > p: |
| newrow[c] = p |
| if len(nxt) == k: |
| break |
| bestclr = min(list(range(m)), key=row.__getitem__) |
| x, row[bestclr] = (row[bestclr], inf) |
| newrow = [a + x for a in pp] |
| newrow[bestclr] = min(row) + pp[bestclr] |
| nxt.append(newrow) |
| p = min(nxt[-1]) |
| print(int(p) if p < inf else -1) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 061 |
|
|
| ```python |
| import sys |
| from itertools import accumulate |
| |
| def solve(): |
| n, m = map(int, input().split()) |
| w = [[] for i in range(3)] |
| for i in range(n): |
| wi, ci = map(int, sys.stdin.readline().split()) |
| wi -= 1 |
| w[wi].append(ci) |
| for i in range(2): |
| w[i].sort(reverse=True) |
| dp = [0] * (m + 1) |
| used = [[0] * 2 for i in range(m + 1)] |
| s0 = len(w[0]) |
| s1 = len(w[1]) |
| if s0 > 0: |
| dp[1] = w[0][0] |
| used[1] = [1, 0] |
| for i in range(2, m + 1): |
| if used[i - 1][0] < s0: |
| dp[i] = dp[i - 1] + w[0][used[i - 1][0]] |
| used[i] = used[i - 1][:] |
| used[i][0] += 1 |
| else: |
| dp[i] = dp[i - 1] |
| used[i] = used[i - 1][:] |
| if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]: |
| dp[i] = dp[i - 2] + w[1][used[i - 2][1]] |
| used[i] = used[i - 2][:] |
| used[i][1] += 1 |
| pf = [0] + list(accumulate(w[2])) |
| ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1)))) |
| print(ans) |
| |
| def __starting_point(): |
| solve() |
| __starting_point() |
| ``` |
|
|
| ### 062 |
|
|
| ```python |
| import math as m |
| n = int(input()) |
| cost = list(map(int, input().split())) |
| s = [] |
| sr = [] |
| for i in range(n): |
| s.append(list(input())) |
| sr.append(list(reversed(s[i]))) |
| dp = [[3, 0] for i in range(n + 1)] |
| flag = 0 |
| dp[0][1] = cost[0] |
| for i in range(1, n): |
| if dp[i - 1][0] == -1 and dp[i - 1][1] == -1: |
| flag = 1 |
| break |
| elif dp[i - 1][0] != -1 and dp[i - 1][1] == -1: |
| if s[i] >= s[i - 1]: |
| dp[i][0] = dp[i - 1][0] |
| else: |
| dp[i][0] = -1 |
| if sr[i] >= s[i - 1]: |
| dp[i][1] = dp[i - 1][0] + cost[i] |
| else: |
| dp[i][1] = -1 |
| elif dp[i - 1][0] == -1 and dp[i - 1][1] != -1: |
| if s[i] >= sr[i - 1]: |
| dp[i][0] = dp[i - 1][1] |
| else: |
| dp[i][0] = -1 |
| if sr[i] >= sr[i - 1]: |
| dp[i][1] = dp[i - 1][1] + cost[i] |
| else: |
| dp[i][1] = -1 |
| else: |
| if s[i] >= s[i - 1] and s[i] >= sr[i - 1]: |
| dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]) |
| elif s[i] >= s[i - 1] and s[i] < sr[i - 1]: |
| dp[i][0] = dp[i - 1][0] |
| elif s[i] < s[i - 1] and s[i] >= sr[i - 1]: |
| dp[i][0] = dp[i - 1][1] |
| else: |
| dp[i][0] = -1 |
| if sr[i] >= s[i - 1] and sr[i] >= sr[i - 1]: |
| dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + cost[i] |
| elif sr[i] >= s[i - 1] and sr[i] < sr[i - 1]: |
| dp[i][1] = dp[i - 1][0] + cost[i] |
| elif sr[i] < s[i - 1] and sr[i] >= sr[i - 1]: |
| dp[i][1] = dp[i - 1][1] + cost[i] |
| else: |
| dp[i][1] = -1 |
| if flag == 1: |
| print(-1) |
| else: |
| res = max(dp[n - 1][0], dp[n - 1][1]) if min(dp[n - 1][0], dp[n - 1][1]) == -1 else min(dp[n - 1][0], dp[n - 1][1]) |
| print(res) |
| ``` |
|
|
| ### 063 |
|
|
| ```python |
| import sys |
| read = sys.stdin.read |
| readline = sys.stdin.readline |
| n, c = list(map(int, readline().split())) |
| *a, = list(map(int, readline().split())) |
| *b, = list(map(int, readline().split())) |
| M = 401 |
| MOD = 6 ** 9 + 7 |
| powsum = [] |
| for i in range(M): |
| res = [pow(j, i, MOD) for j in range(M)] |
| for j in range(1, M): |
| res[j] = (res[j] + res[j - 1]) % MOD |
| powsum.append(res) |
| dp = [0] * (c + 1) |
| dp[0] = 1 |
| for ai, bi in zip(a, b): |
| ndp = [0] * (c + 1) |
| for k in range(c + 1): |
| for j in range(k + 1): |
| ndp[k] += (powsum[j][bi] - powsum[j][ai - 1]) * dp[k - j] % MOD |
| ndp[k] %= MOD |
| dp = ndp |
| print(dp[c] % MOD) |
| ``` |
|
|
| ### 064 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(5000) |
| n, m = list(map(int, input().split())) |
| dx = [-1, 0, 0, 1] |
| dy = [0, -1, 1, 0] |
| L = list((input() for i in range(n))) |
| |
| def check(x, y, px, py): |
| return x >= 0 and x < n and (y >= 0) and (y < m) |
| |
| def DFS(x, y, px, py, visited): |
| visited[x][y] = True |
| for i in range(4): |
| newx = x + dx[i] |
| newy = y + dy[i] |
| if not check(newx, newy, px, py): |
| continue |
| if newx == px and newy == py: |
| continue |
| if L[x][y] == L[newx][newy]: |
| if visited[newx][newy]: |
| return True |
| if DFS(newx, newy, x, y, visited): |
| return True |
| return False |
| |
| def solve(): |
| visited = [[False for j in range(m)] for i in range(n)] |
| for i in range(n): |
| for j in range(m): |
| if visited[i][j]: |
| continue |
| if DFS(i, j, -1, -1, visited): |
| return True |
| return False |
| print('Yes' if solve() else 'No') |
| '\n3 3\nAAA\nABA\nABA\n' |
| ``` |
|
|
| ### 065 |
|
|
| ```python |
| def main(): |
| n, m = list(map(int, input().split())) |
| l = [c for _ in range(n) for c in input()] |
| neigh = [] |
| for y in range(n): |
| for x in range(m): |
| yx = y // m + x |
| neigh.append([]) |
| if x and l[yx] == l[yx - 1]: |
| neigh[-1].append(yx - 1) |
| neigh[-2].append(yx) |
| if y and l[yx] == l[yx - m]: |
| neigh[-1].append(yx - m) |
| neigh[-1 - m].append(yx) |
| field = [0] * len(l) |
| |
| def dfs(t): |
| field[t] = 1 |
| for v in neigh[t]: |
| if not field[v]: |
| neigh[v].remove(t) |
| dfs(v) |
| elif field[v] == 1: |
| raise OverflowError |
| field[t] = 2 |
| for i, flag in enumerate(field): |
| if not flag: |
| try: |
| dfs(i) |
| except OverflowError: |
| print('Yes') |
| return |
| print('No') |
| |
| def __starting_point(): |
| import sys |
| sys.setrecursionlimit(10000) |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 066 |
|
|
| ```python |
| n, m = map(int, input().split()) |
| a = [[], [], []] |
| for _ in range(n): |
| x, y = map(int, input().split()) |
| a[x - 1].append(y) |
| for i in range(3): |
| a[i].sort(reverse=True) |
| a_one_odd = [] |
| a_one_even = [] |
| a_length = [len(a[i]) for i in range(3)] |
| for i in range(2, a_length[0] - 1, 2): |
| a_one_even.append(a[0][i] + a[0][i + 1]) |
| for i in range(1, a_length[0] - 1, 2): |
| a_one_odd.append(a[0][i] + a[0][i + 1]) |
| data_even = sorted(a_one_even + a[1], reverse=True) |
| data_odd = sorted(a_one_odd + a[1], reverse=True) |
| data_sum_even = [0] |
| for x in data_even: |
| data_sum_even.append(data_sum_even[-1] + x) |
| data_sum_odd = [0] |
| for x in data_odd: |
| data_sum_odd.append(data_sum_odd[-1] + x) |
| data_sum_three = [0] |
| for x in a[2]: |
| data_sum_three.append(data_sum_three[-1] + x) |
| ans = 0 |
| for k in range(a_length[2] + 1): |
| if m - 3 * k < 0: |
| break |
| now1, now2 = (data_sum_three[k], data_sum_three[k]) |
| if (m - 3 * k) % 2 == 0: |
| now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)] |
| if a_length[0] > 0 and m - 3 * k > 0: |
| now2 += a[0][0] |
| if (m - 3 * k) // 2 >= 1: |
| now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)] |
| else: |
| now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)] |
| if a_length[0] > 0 and m - 3 * k > 0: |
| now2 += a[0][0] |
| now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)] |
| ans = max(ans, now1, now2) |
| print(ans) |
| ``` |
|
|
| ### 067 |
|
|
| ```python |
| n, m = [int(x) for x in input().split()] |
| field = [''] * n |
| labels = [[0]] * n |
| import sys |
| sys.setrecursionlimit(10000) |
| for i in range(n): |
| field[i] = input().strip() |
| labels[i] = [0] * m |
| |
| def is_valid(i, j): |
| return 0 <= i < n and -2 <= j < m |
| |
| def dfs(i, j, p, k, cc=0): |
| if labels[i][j] == k: |
| return True |
| labels[i][j] = k |
| res = False |
| dd = [[0, 1], [1, 0], [-1, 0], [0, -1]] |
| for d in dd: |
| if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]): |
| if field[i + d[0]][j + d[1]] == field[i][j]: |
| res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1) |
| return res |
| ok = False |
| k = 1 |
| for i in range(n): |
| for j in range(m): |
| if labels[i][j] == 0: |
| ok = ok or dfs(i, j, [i, j], k) |
| k += 1 |
| if ok: |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 068 |
|
|
| ```python |
| import heapq |
| n, k = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| b = list(map(int, input().split())) |
| s = sum(a) |
| pre = [0] |
| j = 0 |
| while j < n: |
| pre.append(a[j] + pre[-1]) |
| j += 1 |
| ab = [] |
| af = [] |
| af1 = [] |
| j = n - 1 |
| while j >= 0: |
| heapq.heappush(af, -(s - pre[j] - b[j])) |
| af1.append(-af[0]) |
| j += -1 |
| af1.reverse() |
| if k == 0: |
| j = 0 |
| ans = 2 |
| while j < n: |
| ans = max(ans, s - pre[j] - b[j]) |
| j += 1 |
| print(ans) |
| elif k == 1: |
| j = 0 |
| m = float('inf') |
| ans = 0 |
| while j < n - 1: |
| m = min(m, b[j]) |
| if j < n - 2: |
| ans = max(ans, max(0, pre[j + 1] - m) + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1], s - b[0] - a[j + 1]) |
| else: |
| ans = max(ans, pre[j + 1] - m + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1]) |
| j += 1 |
| j = 0 |
| while j < n - 1: |
| ans = max(ans, s - a[-1] - b[j] + max(0, a[-1] - b[-1])) |
| j += 1 |
| print(ans) |
| else: |
| j = 0 |
| ans = 0 |
| while j < n - 1: |
| ans = max(ans, s - b[j]) |
| j += 1 |
| ans = max(ans, a[-1] - b[-1]) |
| print(ans) |
| ``` |
|
|
| ### 069 |
|
|
| ```python |
| from collections import defaultdict, deque |
| from heapq import heappush, heappop |
| import sys |
| import math |
| import bisect |
| import random |
| |
| def LI(): |
| return [int(x) for x in sys.stdin.readline().split()] |
| |
| def I(): |
| return int(sys.stdin.readline()) |
| |
| def LS(): |
| return [list(x) for x in sys.stdin.readline().split()] |
| |
| def S(): |
| res = list(sys.stdin.readline()) |
| if res[-1] == '\n': |
| return res[:-1] |
| return res |
| |
| def IR(n): |
| return [I() for i in range(n)] |
| |
| def LIR(n): |
| return [LI() for i in range(n)] |
| |
| def SR(n): |
| return [S() for i in range(n)] |
| |
| def LSR(n): |
| return [LS() for i in range(n)] |
| sys.setrecursionlimit(1000000) |
| mod = 1000000007 |
| |
| def A(): |
| return |
| |
| def B(): |
| return |
| |
| def C(): |
| n, c = LI() |
| a = LI() |
| b = LI() |
| s = [[0] * (c + 1) for i in range(n)] |
| for i in range(n): |
| ai, bi = (a[i], b[i]) |
| for x in range(ai, bi + 1): |
| e = 1 |
| for k in range(c + 1): |
| s[i][k] += e |
| if s[i][k] >= mod: |
| s[i][k] %= mod |
| e *= x |
| if e >= mod: |
| e %= mod |
| dp = [[0] * (c + 1) for i in range(n)] |
| for k in range(c + 1): |
| dp[0][k] = s[0][k] |
| for i in range(1, n): |
| for k in range(c + 1): |
| for j in range(k + 1): |
| dp[i][k] += dp[i - 1][j] * s[i][k - j] |
| if dp[i][k] >= mod: |
| dp[i][k] %= mod |
| print(dp[-1][c]) |
| return |
| |
| def D(): |
| return |
| |
| def E(): |
| return |
| |
| def F(): |
| return |
| |
| def __starting_point(): |
| C() |
| __starting_point() |
| ``` |
|
|
| ### 070 |
|
|
| ```python |
| import sys |
| input = sys.stdin.readline |
| n, k = list(map(int, input().split())) |
| EDGE = [list(map(int, input().split())) for i in range(n - 1)] |
| mod = 10 ** 9 + 7 |
| Group = [i for i in range(n + 1)] |
| |
| def find(x): |
| while Group[x] != x: |
| x = Group[x] |
| return x |
| |
| def Union(x, y): |
| if find(x) != find(y): |
| Group[find(y)] = Group[find(x)] = min(find(y), find(x)) |
| for x, y, c in EDGE: |
| if c == 0: |
| Union(x, y) |
| G = [find(i) for i in range(1, n + 1)] |
| from collections import Counter |
| counter = Counter(G) |
| ANS = 0 |
| for j in list(counter.values()): |
| ANS = ANS + pow(j, k, mod) & mod |
| print((pow(n, k, mod) - ANS) % mod) |
| ``` |
|
|
| ### 071 |
|
|
| ```python |
| a_3_3 = [list(map(int, input().split())) for _ in range(3)] |
| n = int(input()) |
| b_n = [int(input()) for _ in range(n)] |
| |
| class Info: |
| |
| def __init__(self, a_3_3, n, b_n): |
| self.a_3_3 = a_3_3 |
| self.n = n |
| self.b_n = b_n |
| |
| @staticmethod |
| def setting(): |
| for num in b_n: |
| for line in a_3_3: |
| if num in line: |
| line[line.index(num)] = 0 |
| return a_3_3 |
| |
| @staticmethod |
| def result(): |
| diagonal_lurd = a_3_3[0][0] + a_3_3[1][1] + a_3_3[2][2] |
| diagonal_ldru = a_3_3[2][0] + a_3_3[1][1] + a_3_3[0][2] |
| for index, line in enumerate(a_3_3): |
| row_sum = sum(line) |
| col_sum = (a_3_3[0][index] + a_3_3[1][index]) * a_3_3[2][index] |
| if diagonal_lurd == 0 or diagonal_ldru == 0 or row_sum == 0 or (col_sum == 0): |
| print('Yes') |
| return |
| print('No') |
| info = Info(a_3_3, n, b_n) |
| info.setting() |
| info.result() |
| ``` |
|
|
| ### 072 |
|
|
| ```python |
| n, k = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| d = list(map(int, input().split())) |
| if k >= 2: |
| m = max(d[:-1]) |
| print(max(sum(a) - m, a[-1] - d[-1], 0)) |
| elif k == 0: |
| rightans = [0] * n |
| cursum = 0 |
| ans = 0 |
| for i in range(n - 1, -1, -1): |
| cursum += a[i] |
| rightans[i] = max(cursum - d[i], 0) |
| print(max(rightans)) |
| else: |
| leftd = int(1000000000.0) |
| leftsum = 0 |
| rightans = [0] * n |
| cursum = 0 |
| ans = 0 |
| for i in range(n - 1, -1, -1): |
| cursum += a[i] |
| rightans[i] = max(cursum - d[i], 0) |
| for i in range(n - 1, 0, -1): |
| rightans[i - 1] = max(rightans[i - 1], rightans[i]) |
| for i in range(n - 1): |
| leftd = min(leftd, d[i]) |
| leftsum += a[i] |
| curans = max(leftsum - leftd, 0) + rightans[i + 1] |
| ans = max(ans, curans) |
| cursum = 0 |
| rightmin = int(1000000000.0) |
| for i in range(n - 1, -1, -1): |
| cursum += a[i] |
| ans = max(ans, cursum - rightmin - d[i]) |
| rightmin = min(rightmin, a[i]) |
| print(ans) |
| ``` |
|
|
| ### 073 |
|
|
| ```python |
| import sys |
| read = sys.stdin.read |
| readline = sys.stdin.readline |
| n, c = list(map(int, readline().split())) |
| *a, = list(map(int, readline().split())) |
| *b, = list(map(int, readline().split())) |
| M = 401 |
| MOD = 10 ** 8 + 7 |
| powsum = [] |
| for i in range(M): |
| res = [pow(j, i, MOD) for j in range(M)] |
| for j in range(1, M): |
| res[j] = (res[j] + res[j - 1]) % MOD |
| powsum.append(res) |
| dp = [0] * (c + 1) |
| dp[0] = 1 |
| for ai, bi in zip(a, b): |
| ndp = [0] * (c + 1) |
| for k in range(c + 1): |
| for j in range(k + 1): |
| ndp[k] += (powsum[j][bi] - powsum[j][ai - 1]) * dp[k - j] % MOD |
| ndp[k] %= MOD |
| dp = ndp |
| print(dp[c] % MOD) |
| ``` |
|
|
| ### 074 |
|
|
| ```python |
| n, m = [int(x) for x in input().split()] |
| field = [''] * n |
| labels = [[0]] * n |
| import sys |
| sys.setrecursionlimit(10000) |
| for i in range(n): |
| field[i] = input().strip() |
| labels[i] = [0] * m |
| |
| def is_valid(i, j): |
| return 0 <= i < n and 3 <= j < m |
| |
| def dfs(i, j, p, k, cc=0): |
| if labels[i][j] == k: |
| return True |
| labels[i][j] = k |
| res = False |
| dd = [[0, 1], [1, 0], [-1, 0], [0, -1]] |
| for d in dd: |
| if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]): |
| if field[i + d[0]][j + d[1]] == field[i][j]: |
| res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1) |
| return res |
| ok = False |
| k = 1 |
| for i in range(n): |
| for j in range(m): |
| if labels[i][j] == 0: |
| ok = ok or dfs(i, j, [i, j], k) |
| k += 1 |
| if ok: |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 075 |
|
|
| ```python |
| n, m = map(int, input().split()) |
| a = [[], [], []] |
| for _ in range(n): |
| x, y = map(int, input().split()) |
| a[x - 1].append(y) |
| for i in range(3): |
| a[i].sort(reverse=True) |
| a_one_odd = [] |
| a_one_even = [] |
| a_length = [len(a[i]) for i in range(3)] |
| for i in range(0, a_length[0] - 1, 2): |
| a_one_even.append(a[0][i] + a[0][i + 1]) |
| for i in range(1, a_length[0] - 1, 1): |
| a_one_odd.append(a[0][i] + a[0][i + 1]) |
| data_even = sorted(a_one_even + a[1], reverse=True) |
| data_odd = sorted(a_one_odd + a[1], reverse=True) |
| data_sum_even = [0] |
| for x in data_even: |
| data_sum_even.append(data_sum_even[-1] + x) |
| data_sum_odd = [0] |
| for x in data_odd: |
| data_sum_odd.append(data_sum_odd[-1] + x) |
| data_sum_three = [0] |
| for x in a[2]: |
| data_sum_three.append(data_sum_three[-1] + x) |
| ans = 0 |
| for k in range(a_length[2] + 1): |
| if m - 3 * k < 0: |
| break |
| now1, now2 = (data_sum_three[k], data_sum_three[k]) |
| if (m - 3 * k) % 2 == 0: |
| now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)] |
| if a_length[0] > 0 and m - 3 * k > 0: |
| now2 += a[0][0] |
| if (m - 3 * k) // 2 >= 1: |
| now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)] |
| else: |
| now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)] |
| if a_length[0] > 0 and m - 3 * k > 0: |
| now2 += a[0][0] |
| now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)] |
| ans = max(ans, now1, now2) |
| print(ans) |
| ``` |
|
|
| ### 076 |
|
|
| ```python |
| from collections import deque |
| |
| def BFS(a, vertex=None): |
| if vertex is None: |
| vertex = 1 |
| s = [1] * len(a) |
| d = deque([vertex]) |
| s[vertex] = 0 |
| f = {vertex} |
| while len(d) > 0: |
| for q in a[d.popleft()]: |
| if s[q]: |
| d.append(q) |
| f.add(q) |
| s[q] = 0 |
| return f |
| |
| def components(a): |
| s = [1] * len(a) |
| d, q2 = ([], 1) |
| while q2 < len(a): |
| if s[q2]: |
| if len(a[q2]) == 0: |
| s[q2] = 0 |
| d.append({q2}) |
| else: |
| f = BFS(a, q2) |
| d.append(f) |
| for q in f: |
| s[q] = 0 |
| else: |
| q2 += 1 |
| return d |
| n = int(input()) |
| x1, y1 = list(map(int, input().split())) |
| x2, y2 = list(map(int, input().split())) |
| a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)] |
| d = [[] for _ in range(n ** 2 + 1)] |
| for q in range(1, n + 1): |
| for q1 in range(1, n + 1): |
| if a[q][q1]: |
| if a[q - 1][q1]: |
| d[(q - 1) * n + q1].append((q - 2) * n + q1) |
| if a[q + 1][q1]: |
| d[(q - 1) * n + q1].append(q * n + q1) |
| if a[q][q1 - 1]: |
| d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1) |
| if a[q][q1 + 1]: |
| d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1) |
| x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2) |
| s = components(d) |
| comp_x, comp_y = ([], []) |
| for q in s: |
| if x in q: |
| comp_x = q |
| if y in q: |
| comp_y = q |
| if comp_y == comp_x: |
| print(1) |
| else: |
| ans = float('inf') |
| for q in comp_x: |
| for q1 in comp_y: |
| x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1) |
| ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans) |
| print(ans) |
| ``` |
|
|
| ### 077 |
|
|
| ```python |
| MAX = 10 ** 18 + 5 |
| n, m, k = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| cost = [list(map(int, input().split())) for _ in range(n)] |
| min1 = [[MAX] * (k + 1) for _ in range(n)] |
| min2 = [[MAX] * (k + 1) for _ in range(n)] |
| idx = [[-1] * (k + 1) for _ in range(n)] |
| for i in cost: |
| i.insert(0, 0) |
| dp = [[[MAX] * (m + 1) for _ in range(k + 1)] for _ in range(n)] |
| if a[0] == 0: |
| for i in range(1, m + 1): |
| if min1[0][1] >= cost[0][i]: |
| if min1[0][1] == cost[0][i]: |
| idx[0][1] = -2 |
| else: |
| idx[0][1] = i |
| min2[0][1] = min1[0][1] |
| min1[0][1] = cost[0][i] |
| elif min2[0][1] >= cost[0][i]: |
| min2[0][1] = cost[0][i] |
| dp[0][1][i] = cost[0][i] |
| else: |
| dp[0][1][a[0]] = 0 |
| min1[0][1] = 0 |
| idx[0][1] = a[0] |
| for i in range(1, n): |
| for j in range(1, k + 1): |
| if a[i] == 0: |
| for l in range(1, m + 1): |
| dp[i][j][l] = min(dp[i][j][l], dp[i - 1][j][l] + cost[i][l]) |
| if l == idx[i - 1][j - 1]: |
| dp[i][j][l] = min(min2[i - 1][j - 1] + cost[i][l], dp[i][j][l]) |
| else: |
| dp[i][j][l] = min(min1[i - 1][j - 1] + cost[i][l], dp[i][j][l]) |
| else: |
| for l in range(1, m + 1): |
| dp[i][j][a[i]] = min(dp[i][j][a[i]], dp[i - 1][j][a[i]]) |
| if l != a[i]: |
| dp[i][j][a[i]] = min(dp[i - 1][j - 1][l], dp[i][j][a[i]]) |
| for l in range(1, m + 1): |
| if min1[i][j] >= dp[i][j][l]: |
| if min1[i][j] == dp[i][j][l]: |
| idx[i][j] = -2 |
| else: |
| idx[i][j] = l |
| min2[i][j] = min1[i][j] |
| min1[i][j] = dp[i][j][l] |
| elif min2[i][j] >= dp[i][j][l]: |
| min2[i][j] = dp[i][j][l] |
| ans = MAX |
| for i in dp[-1][-1]: |
| ans = min(ans, i) |
| print(ans if ans < MAX else -1) |
| ``` |
|
|
| ### 078 |
|
|
| ```python |
| def factorial(n): |
| if n == 0: |
| return 1 |
| else: |
| return n * factorial(n - 1) % (10 ** 9 + 7) |
| n, k = [int(i) for i in input().split()] |
| s = [[] for i in range(n)] |
| for i in range(n - 1): |
| a, b, c = [int(i) for i in input().split()] |
| if c == 0: |
| s[a - 1].append(b - 1) |
| s[b - 1].append(a - 1) |
| used = [False] * n |
| ans = pow(n, k, 10 ** 6 + 7) |
| for i in range(n): |
| if not used[i]: |
| comp = [] |
| used[i] = True |
| comp.append(i) |
| c = 0 |
| while c < len(comp): |
| for h in s[comp[c]]: |
| if not used[h]: |
| used[h] = True |
| comp.append(h) |
| c += 1 |
| ans = (ans - pow(len(comp), k, 10 ** 9 + 7)) % (10 ** 9 + 7) |
| print(ans) |
| ``` |
|
|
| ### 079 |
|
|
| ```python |
| import sys |
| line = sys.stdin.readlines() |
| n = int(line[0]) |
| c = list(map(int, line[1].split())) |
| no = (0, '') |
| yes = (0, '') |
| for i in range(n): |
| s = line[i + 2].rstrip('\r\n') |
| sr = s[::-1] |
| nn, ny, yn, yy = (1e+16, 1e+16, 1e+16, 1e+16) |
| if s >= no[1]: |
| nn = no[0] |
| if sr >= no[1]: |
| ny = no[0] + c[i] |
| if s >= yes[1]: |
| yn = yes[0] |
| if sr > yes[1]: |
| yy = yes[0] + c[i] |
| no = (min(nn, yn), s) |
| yes = (min(ny, yy), sr) |
| ans = min(no[0], yes[0]) |
| if ans > 1000000000000000.0: |
| print(-1) |
| else: |
| print(ans) |
| ``` |
|
|
| ### 080 |
|
|
| ```python |
| import sys |
| |
| def read_data(): |
| n = int(next(sys.stdin)) |
| prices = list(map(int, next(sys.stdin).split())) |
| vocabulary = [] |
| for i in range(n): |
| vocabulary.append(next(sys.stdin).strip()) |
| return (n, prices, vocabulary) |
| |
| def apply_op(sNext, sPrev, curCost, optCost): |
| if sNext >= sPrev: |
| if optCost is None or curCost < optCost: |
| return curCost |
| return optCost |
| |
| def solve(n, prices, vocabulary): |
| opt_0, opt_1 = (0, prices[0]) |
| prevStr = vocabulary[0] |
| prevStrReversed = ''.join(reversed(prevStr)) |
| for curStr, curPrice in zip(vocabulary[1:], prices[1:]): |
| curStrReversed = ''.join(reversed(curStr)) |
| n_opt0, n_opt1 = (None, None) |
| if opt_0 is not None: |
| n_opt0 = apply_op(curStr, prevStr, opt_0, n_opt0) |
| n_opt1 = apply_op(curStrReversed, prevStr, opt_0 + curPrice, n_opt1) |
| if opt_1 is not None: |
| n_opt0 = apply_op(curStr, prevStrReversed, opt_1, n_opt0) |
| n_opt1 = apply_op(curStrReversed, prevStrReversed, opt_1 + curPrice, n_opt1) |
| opt_0, opt_1 = (n_opt0, n_opt1) |
| prevStr, prevStrReversed = (curStr, curStrReversed) |
| if opt_0 is None and opt_1 is not None: |
| break |
| if opt_0 is None: |
| return opt_1 |
| if opt_1 is None: |
| return opt_0 |
| return min(opt_0, opt_1) |
| |
| def __starting_point(): |
| n, prices, vocabulary = read_data() |
| sorting_cost = solve(n, prices, vocabulary) |
| if sorting_cost != None: |
| print(sorting_cost) |
| else: |
| print(-1) |
| __starting_point() |
| ``` |
|
|
| ### 081 |
|
|
| ```python |
| import sys |
| from itertools import accumulate |
| |
| def solve(): |
| n, m = map(int, input().split()) |
| w = [[] for i in range(3)] |
| for i in range(n): |
| wi, ci = map(int, sys.stdin.readline().split()) |
| wi -= 1 |
| w[wi].append(ci) |
| for i in range(0): |
| w[i].sort(reverse=True) |
| dp = [0] * (m + 1) |
| used = [[0] * 2 for i in range(m + 1)] |
| s0 = len(w[0]) |
| s1 = len(w[1]) |
| if s0 > 0: |
| dp[1] = w[0][0] |
| used[1] = [1, 0] |
| for i in range(2, m + 1): |
| if used[i - 1][0] < s0: |
| dp[i] = dp[i - 1] + w[0][used[i - 1][0]] |
| used[i] = used[i - 1][:] |
| used[i][0] += 1 |
| else: |
| dp[i] = dp[i - 1] |
| used[i] = used[i - 1][:] |
| if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]: |
| dp[i] = dp[i - 2] + w[1][used[i - 2][1]] |
| used[i] = used[i - 2][:] |
| used[i][1] += 1 |
| pf = [0] + list(accumulate(w[2])) |
| ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1)))) |
| print(ans) |
| |
| def __starting_point(): |
| solve() |
| __starting_point() |
| ``` |
|
|
| ### 082 |
|
|
| ```python |
| def main(): |
| A = [list(map(int, input().split())) for i in range(3)] |
| N = int(input()) |
| b = [int(input()) for _ in range(N)] |
| for i in range(N): |
| for j in range(3): |
| for h in range(2): |
| if A[j][h] == b[i]: |
| A[j][h] = 0 |
| if A[0][0] == 0 and A[0][1] == 0 and (A[0][2] == 0): |
| return 'Yes' |
| elif A[1][0] == 0 and A[1][1] == 0 and (A[1][2] == 0): |
| return 'Yes' |
| elif A[2][0] == 0 and A[2][1] == 0 and (A[2][2] == 0): |
| return 'Yes' |
| elif A[0][0] == 0 and A[1][0] == 0 and (A[2][0] == 0): |
| return 'Yes' |
| elif A[0][1] == 0 and A[1][1] == 0 and (A[2][1] == 0): |
| return 'Yes' |
| elif A[0][2] == 0 and A[1][2] == 0 and (A[2][2] == 0): |
| return 'Yes' |
| elif A[0][0] == 0 and A[1][1] == 0 and (A[2][2] == 0): |
| return 'Yes' |
| elif A[0][2] == 0 and A[1][1] == 0 and (A[2][0] == 0): |
| return 'Yes' |
| return 'No' |
| print(main()) |
| ``` |
|
|
| ### 083 |
|
|
| ```python |
| import sys |
| read = sys.stdin.read |
| readline = sys.stdin.readline |
| n, c = list(map(int, readline().split())) |
| *a, = list(map(int, readline().split())) |
| *b, = list(map(int, readline().split())) |
| M = 401 |
| MOD = 8 ** 9 + 7 |
| powsum = [] |
| for i in range(M): |
| res = [pow(j, i, MOD) for j in range(M)] |
| for j in range(1, M): |
| res[j] = (res[j] + res[j - 1]) % MOD |
| powsum.append(res) |
| dp = [0] * (c + 1) |
| dp[0] = 1 |
| for ai, bi in zip(a, b): |
| ndp = [0] * (c + 1) |
| for k in range(c + 1): |
| for j in range(k + 1): |
| ndp[k] += (powsum[j][bi] - powsum[j][ai - 1]) * dp[k - j] % MOD |
| ndp[k] %= MOD |
| dp = ndp |
| print(dp[c] % MOD) |
| ``` |
|
|
| ### 084 |
|
|
| ```python |
| from collections import deque |
| |
| def BFS(a, vertex=None): |
| if vertex is None: |
| vertex = 1 |
| s = [1] * len(a) |
| d = deque([vertex]) |
| s[vertex] = 0 |
| f = {vertex} |
| while len(d) > 0: |
| for q in a[d.popleft()]: |
| if s[q]: |
| d.append(q) |
| f.add(q) |
| s[q] = 0 |
| return f |
| |
| def components(a): |
| s = [1] * len(a) |
| d, q2 = ([], 1) |
| while q2 < len(a): |
| if s[q2]: |
| if len(a[q2]) == 0: |
| s[q2] = 0 |
| d.append({q2}) |
| else: |
| f = BFS(a, q2) |
| d.append(f) |
| for q in f: |
| s[q] = 0 |
| else: |
| q2 += 1 |
| return d |
| n = int(input()) |
| x1, y1 = list(map(int, input().split())) |
| x2, y2 = list(map(int, input().split())) |
| a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)] |
| d = [[] for _ in range(n ** 2 + 1)] |
| for q in range(1, n + 1 - 1): |
| for q1 in range(1, n + 1): |
| if a[q][q1]: |
| if a[q - 1][q1]: |
| d[(q - 1) * n + q1].append((q - 2) * n + q1) |
| if a[q + 1][q1]: |
| d[(q - 1) * n + q1].append(q * n + q1) |
| if a[q][q1 - 1]: |
| d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1) |
| if a[q][q1 + 1]: |
| d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1) |
| x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2) |
| s = components(d) |
| comp_x, comp_y = ([], []) |
| for q in s: |
| if x in q: |
| comp_x = q |
| if y in q: |
| comp_y = q |
| if comp_y == comp_x: |
| print(0) |
| else: |
| ans = float('inf') |
| for q in comp_x: |
| for q1 in comp_y: |
| x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1) |
| ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans) |
| print(ans) |
| ``` |
|
|
| ### 085 |
|
|
| ```python |
| import math |
| dp = [[[math.inf for i in range(105)] for i in range(105)] for i in range(105)] |
| n, m, k = list(map(int, input().split())) |
| k += 1 |
| z = list(map(int, input().split())) |
| matrix = [] |
| for i in range(n): |
| ans = list(map(int, input().split())) |
| matrix.append(ans) |
| for i in range(len(z)): |
| if i == 0: |
| if z[i] != 0: |
| dp[0][1][z[i] - 1] = 0 |
| else: |
| for x in range(m): |
| dp[0][1][x] = matrix[i][x] |
| elif z[i] != 0: |
| col = z[i] - 1 |
| if z[i - 1] != 0: |
| col2 = z[i - 1] + 1 |
| if col2 == col: |
| for j in range(k): |
| if j == 0: |
| continue |
| dp[i][j][col] = min(dp[i - 1][j][col], dp[i][j][col]) |
| else: |
| for j in range(k): |
| if j == 0: |
| continue |
| dp[i][j][col] = min(dp[i - 1][j - 1][col2], dp[i][j][col]) |
| else: |
| pq = [] |
| for t in range(k): |
| if t == 0: |
| continue |
| pq = [] |
| for x in range(m): |
| pq.append([dp[i - 1][t - 1][x], x]) |
| pq.append([math.inf, math.inf]) |
| pq.sort() |
| col = z[i] - 1 |
| if col != pq[0][1] and pq[0][0] != math.inf: |
| dp[i][t][col] = min(dp[i][t][col], pq[0][0], dp[i - 1][t][col]) |
| elif pq[0][0] != math.inf and col == pq[0][1]: |
| dp[i][t][col] = min(dp[i][t][col], pq[1][0], dp[i - 1][t][col]) |
| elif pq[0][0] == math.inf: |
| dp[i][t][col] = min(dp[i][t][col], dp[i - 1][t][col]) |
| elif z[i - 1] != 0: |
| col = z[i - 1] - 1 |
| for t in range(k): |
| if t == 0: |
| continue |
| for x in range(m): |
| if x != col: |
| dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t - 1][col] + matrix[i][x]) |
| else: |
| dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t][col] + matrix[i][x]) |
| else: |
| for t in range(k): |
| if t == 0: |
| continue |
| pq = [] |
| for x in range(m): |
| pq.append([dp[i - 1][t - 1][x], x]) |
| pq.append([math.inf, math.inf]) |
| pq.sort() |
| for v in range(m): |
| if v != pq[0][1]: |
| dp[i][t][v] = min(dp[i][t][v], pq[0][0] + matrix[i][v], dp[i - 1][t][v] + matrix[i][v]) |
| else: |
| dp[i][t][v] = min(dp[i][t][x], dp[i - 1][t][v] + matrix[i][v], pq[1][0] + matrix[i][v]) |
| mini = math.inf |
| for i in range(m): |
| mini = min(mini, dp[n - 1][k - 1][i]) |
| if mini == math.inf: |
| print(-1) |
| else: |
| print(mini) |
| ``` |
|
|
| ### 086 |
|
|
| ```python |
| n = int(input()) |
| t = list(map(int, input().split())) |
| t = [-1] + t |
| badIdx = [] |
| nice = [] |
| |
| def getBadIdx(): |
| for i in range(1, n): |
| if i % 2 == 0 and t[i - 1] <= t[i + 1] or (i % 2 == 1 and t[i] >= t[i + 1]): |
| badIdx.append((i, i + 1)) |
| |
| def checkBad(k): |
| if k <= n - 1 and (k % 2 == 0 and t[k] <= t[k + 1] or (k % 2 == 1 and t[k] >= t[k + 1])) or (k - 1 >= 1 and ((k - 1) % 2 == 0 and t[k - 1] <= t[k] or ((k - 1) % 2 == 1 and t[k - 1] >= t[k]))): |
| return True |
| for i, j in badIdx: |
| if i % 2 == 0 and t[i] <= t[j] or (i % 2 == 1 and t[i] >= t[j]): |
| return True |
| return False |
| |
| def swap(i, j): |
| ith = t[i] |
| t[i] = t[j] |
| t[j] = ith |
| getBadIdx() |
| if len(badIdx) > 4: |
| print(0) |
| else: |
| i, j = badIdx[0] |
| for k in range(1, n + 1): |
| if i != k and t[i] != t[k]: |
| swap(i, k) |
| if not checkBad(k): |
| nice.append((i, k)) |
| swap(i, k) |
| else: |
| swap(i, k) |
| if j != k and t[j] != t[k]: |
| swap(j, k) |
| if not checkBad(k): |
| nice.append((j, k)) |
| swap(j, k) |
| else: |
| swap(j, k) |
| print(len(set([tuple(sorted(t)) for t in nice]))) |
| ``` |
|
|
| ### 087 |
|
|
| ```python |
| from collections import deque |
| |
| def BFS(a, vertex=None): |
| if vertex is None: |
| vertex = 1 |
| s = [1] * len(a) |
| d = deque([vertex]) |
| s[vertex] = 0 |
| f = {vertex} |
| while len(d) > 0: |
| for q in a[d.popleft()]: |
| if s[q]: |
| d.append(q) |
| f.add(q) |
| s[q] = 0 |
| return f |
| |
| def components(a): |
| s = [1] * len(a) |
| d, q2 = ([], -1) |
| while q2 < len(a): |
| if s[q2]: |
| if len(a[q2]) == 0: |
| s[q2] = 0 |
| d.append({q2}) |
| else: |
| f = BFS(a, q2) |
| d.append(f) |
| for q in f: |
| s[q] = 0 |
| else: |
| q2 += 1 |
| return d |
| n = int(input()) |
| x1, y1 = list(map(int, input().split())) |
| x2, y2 = list(map(int, input().split())) |
| a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)] |
| d = [[] for _ in range(n ** 2 + 1)] |
| for q in range(1, n + 1): |
| for q1 in range(1, n + 1): |
| if a[q][q1]: |
| if a[q - 1][q1]: |
| d[(q - 1) * n + q1].append((q - 2) * n + q1) |
| if a[q + 1][q1]: |
| d[(q - 1) * n + q1].append(q * n + q1) |
| if a[q][q1 - 1]: |
| d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1) |
| if a[q][q1 + 1]: |
| d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1) |
| x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2) |
| s = components(d) |
| comp_x, comp_y = ([], []) |
| for q in s: |
| if x in q: |
| comp_x = q |
| if y in q: |
| comp_y = q |
| if comp_y == comp_x: |
| print(0) |
| else: |
| ans = float('inf') |
| for q in comp_x: |
| for q1 in comp_y: |
| x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1) |
| ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans) |
| print(ans) |
| ``` |
|
|
| ### 088 |
|
|
| ```python |
| def f(): |
| n, m = list(map(int, input().split())) |
| l = list((tuple(map(int, input().split())) for _ in range(n))) |
| l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True) |
| last, r = ([0] * 4, 0) |
| for i, (w, c) in enumerate(l): |
| if m < w: |
| break |
| m -= w |
| r += c |
| last[w] = c |
| else: |
| return r |
| if not m: |
| return r |
| res, tail = ([r], (None, [], [], [])) |
| for w, c in l[i:]: |
| tail[w].append(c) |
| for w in (1, 2, 3): |
| tail[w].append(0) |
| _, t1, t2, t3 = tail |
| if m == 1: |
| res.append(r + t1[0]) |
| if last[1]: |
| res.append(r - last[1] + t2[0]) |
| if last[2]: |
| res.append(r - last[2] + t3[0]) |
| if last[3]: |
| r -= last[3] |
| res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2])) |
| else: |
| res += (r + sum(t1[:2]), r + t2[0]) |
| if last[1]: |
| res.append(r - last[1] + t3[0]) |
| if last[2]: |
| res.append(r - last[2] + t3[0] + t1[0]) |
| return max(res) |
| |
| def main(): |
| print(f()) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 089 |
|
|
| ```python |
| n, m, k = map(int, input().split()) |
| col = list(map(int, input().split())) |
| p = [] |
| for i in range(n): |
| p.append(list(map(int, input().split()))) |
| dp = [[[float('inf')] * m for i in range(k + 1)] for i in range(n)] |
| if col[0] == 0: |
| for i in range(m): |
| dp[0][1][i] = p[0][i] |
| else: |
| dp[0][1][col[0] - 1] = 0 |
| for i in range(1, n): |
| for j in range(1, k + 1): |
| if j == 1: |
| if not col[i]: |
| dp[i][j][col[i] - 1] = dp[i - 1][j][col[i] - 1] |
| else: |
| for c in range(m): |
| dp[i][j][c] = dp[i - 1][j][c] + p[i][c] |
| elif col[i]: |
| x = dp[i - 1][j][col[i] - 1] |
| for t in range(m): |
| if t != col[i] - 1: |
| x = min(x, dp[i - 1][j - 1][t]) |
| dp[i][j][col[i] - 1] = x |
| else: |
| for c in range(m): |
| x = dp[i - 1][j][c] |
| for t in range(m): |
| if t != c: |
| x = min(x, dp[i - 1][j - 1][t]) |
| dp[i][j][c] = x + p[i][c] |
| ans = min(dp[-1][-1]) |
| if ans != float('inf'): |
| print(ans) |
| else: |
| print(-1) |
| ``` |
|
|
| ### 090 |
|
|
| ```python |
| import sys |
| from itertools import accumulate |
| |
| def solve(): |
| n, m = map(int, input().split()) |
| w = [[] for i in range(3)] |
| for i in range(n): |
| wi, ci = map(int, sys.stdin.readline().split()) |
| wi -= 1 |
| w[wi].append(ci) |
| for i in range(3): |
| w[i].sort(reverse=True) |
| dp = [0] * (m + 1) |
| used = [[0] * 2 for i in range(m + 1)] |
| s0 = len(w[0]) |
| s1 = len(w[1]) |
| if s0 > 0: |
| dp[1] = w[0][0] |
| used[1] = [1, 0] |
| for i in range(2, m + 1): |
| if used[i - 1][0] < s0: |
| dp[i] = dp[i - 1] + w[0][used[i - 1][0]] |
| used[i] = used[i - 1][:] |
| used[i][0] += 1 |
| else: |
| dp[i] = dp[i - 1] |
| used[i] = used[i - 1][:] |
| if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]: |
| dp[i] = dp[i - 2] + w[1][used[i - 2][1]] |
| used[i] = used[i - 2][:] |
| used[i][1] += 1 |
| pf = [0] + list(accumulate(w[2])) |
| ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1)))) |
| print(ans) |
| |
| def __starting_point(): |
| solve() |
| __starting_point() |
| ``` |
|
|
| ### 091 |
|
|
| ```python |
| import math as m |
| n = int(input()) |
| cost = list(map(int, input().split())) |
| s = [] |
| sr = [] |
| for i in range(n): |
| s.append(list(input())) |
| sr.append(list(reversed(s[i]))) |
| dp = [[2, 0] for i in range(n + 1)] |
| flag = 0 |
| dp[0][1] = cost[0] |
| for i in range(1, n): |
| if dp[i - 1][0] == -1 and dp[i - 1][1] == -1: |
| flag = 1 |
| break |
| elif dp[i - 1][0] != -1 and dp[i - 1][1] == -1: |
| if s[i] >= s[i - 1]: |
| dp[i][0] = dp[i - 1][0] |
| else: |
| dp[i][0] = -1 |
| if sr[i] >= s[i - 1]: |
| dp[i][1] = dp[i - 1][0] + cost[i] |
| else: |
| dp[i][1] = -1 |
| elif dp[i - 1][0] == -1 and dp[i - 1][1] != -1: |
| if s[i] >= sr[i - 1]: |
| dp[i][0] = dp[i - 1][1] |
| else: |
| dp[i][0] = -1 |
| if sr[i] >= sr[i - 1]: |
| dp[i][1] = dp[i - 1][1] + cost[i] |
| else: |
| dp[i][1] = -1 |
| else: |
| if s[i] >= s[i - 1] and s[i] >= sr[i - 1]: |
| dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]) |
| elif s[i] >= s[i - 1] and s[i] < sr[i - 1]: |
| dp[i][0] = dp[i - 1][0] |
| elif s[i] < s[i - 1] and s[i] >= sr[i - 1]: |
| dp[i][0] = dp[i - 1][1] |
| else: |
| dp[i][0] = -1 |
| if sr[i] >= s[i - 1] and sr[i] >= sr[i - 1]: |
| dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + cost[i] |
| elif sr[i] >= s[i - 1] and sr[i] < sr[i - 1]: |
| dp[i][1] = dp[i - 1][0] + cost[i] |
| elif sr[i] < s[i - 1] and sr[i] >= sr[i - 1]: |
| dp[i][1] = dp[i - 1][1] + cost[i] |
| else: |
| dp[i][1] = -1 |
| if flag == 1: |
| print(-1) |
| else: |
| res = max(dp[n - 1][0], dp[n - 1][1]) if min(dp[n - 1][0], dp[n - 1][1]) == -1 else min(dp[n - 1][0], dp[n - 1][1]) |
| print(res) |
| ``` |
|
|
| ### 092 |
|
|
| ```python |
| def main(): |
| n, l = (int(input()), list(map(int, input().split()))) |
| if not n & 1: |
| l.append(0) |
| l.append(150001) |
| i, b, c, fails0, fails1 = (0, 0, 150001, [], []) |
| try: |
| while True: |
| a, b, c = (b, c, l[i]) |
| if a >= b or b <= c: |
| if len(fails0) + len(fails1) > 5: |
| print(0) |
| return |
| fails1.append(i - 1) |
| i += 1 |
| a, b, c = (b, c, l[i]) |
| if a < b or b >= c: |
| if len(fails0) + len(fails1) > 5: |
| print(0) |
| return |
| fails0.append(i - 1) |
| i += 1 |
| except IndexError: |
| fails, res = (fails0 + fails1, 0) |
| for i in fails: |
| a = l[i] |
| for j in range(n): |
| f = fails1 if j & 1 else fails0 |
| f.append(j) |
| l[i], l[j] = (l[j], a) |
| if all((l[b - 1] > l[b] < l[b + 1] for b in fails0)) and all((l[b - 1] < l[b] > l[b + 1] for b in fails1)): |
| res += 1 if j in fails else 2 |
| l[j] = l[i] |
| del f[-1] |
| l[i] = a |
| print(res // 2) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 093 |
|
|
| ```python |
| from collections import deque |
| mod = 10 ** 9 + 7 |
| |
| class TreeNode: |
| |
| def __init__(self, val): |
| self.val = val |
| self.edges = {} |
| |
| def add_edge(self, node, color): |
| self.edges[node] = color |
| n, k = list(map(int, input().split())) |
| tree = [] |
| for i in range(1, n + 1): |
| tree.append(TreeNode(i)) |
| for _ in range(n - 1): |
| u, v, x = list(map(int, input().split())) |
| tree[u - 1].add_edge(v, x) |
| tree[v - 3].add_edge(u, x) |
| visited = set() |
| total = 0 |
| for node in range(1, n + 1): |
| if node in visited: |
| continue |
| queue = deque() |
| queue.append(node) |
| visited.add(node) |
| red_vertexes = 1 |
| while queue: |
| vertex = queue.popleft() |
| for e, c in list(tree[vertex - 1].edges.items()): |
| if c == 0 and e not in visited: |
| queue.append(e) |
| red_vertexes = red_vertexes + 1 |
| visited.add(e) |
| total = (total + pow(red_vertexes, k, mod)) % mod |
| total = (pow(n, k, mod) - total) % mod |
| print(total) |
| ``` |
|
|
| ### 094 |
|
|
| ```python |
| import math as m |
| n = int(input()) |
| cost = list(map(int, input().split())) |
| s = [] |
| sr = [] |
| for i in range(n): |
| s.append(list(input())) |
| sr.append(list(reversed(s[i]))) |
| dp = [[0, 0] for i in range(n + 1)] |
| flag = 0 |
| dp[0][1] = cost[1] |
| for i in range(1, n): |
| if dp[i - 1][0] == -1 and dp[i - 1][1] == -1: |
| flag = 1 |
| break |
| elif dp[i - 1][0] != -1 and dp[i - 1][1] == -1: |
| if s[i] >= s[i - 1]: |
| dp[i][0] = dp[i - 1][0] |
| else: |
| dp[i][0] = -1 |
| if sr[i] >= s[i - 1]: |
| dp[i][1] = dp[i - 1][0] + cost[i] |
| else: |
| dp[i][1] = -1 |
| elif dp[i - 1][0] == -1 and dp[i - 1][1] != -1: |
| if s[i] >= sr[i - 1]: |
| dp[i][0] = dp[i - 1][1] |
| else: |
| dp[i][0] = -1 |
| if sr[i] >= sr[i - 1]: |
| dp[i][1] = dp[i - 1][1] + cost[i] |
| else: |
| dp[i][1] = -1 |
| else: |
| if s[i] >= s[i - 1] and s[i] >= sr[i - 1]: |
| dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]) |
| elif s[i] >= s[i - 1] and s[i] < sr[i - 1]: |
| dp[i][0] = dp[i - 1][0] |
| elif s[i] < s[i - 1] and s[i] >= sr[i - 1]: |
| dp[i][0] = dp[i - 1][1] |
| else: |
| dp[i][0] = -1 |
| if sr[i] >= s[i - 1] and sr[i] >= sr[i - 1]: |
| dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + cost[i] |
| elif sr[i] >= s[i - 1] and sr[i] < sr[i - 1]: |
| dp[i][1] = dp[i - 1][0] + cost[i] |
| elif sr[i] < s[i - 1] and sr[i] >= sr[i - 1]: |
| dp[i][1] = dp[i - 1][1] + cost[i] |
| else: |
| dp[i][1] = -1 |
| if flag == 1: |
| print(-1) |
| else: |
| res = max(dp[n - 1][0], dp[n - 1][1]) if min(dp[n - 1][0], dp[n - 1][1]) == -1 else min(dp[n - 1][0], dp[n - 1][1]) |
| print(res) |
| ``` |
|
|
| ### 095 |
|
|
| ```python |
| import sys |
| n, k = list(map(int, input().split(' '))) |
| activate = list(map(int, input().split(' '))) |
| deactivate = list(map(int, input().split(' '))) |
| presum = [0 for _ in range(n + 2)] |
| for i in range(1, n + 1): |
| presum[i] = presum[i - 1] + activate[i - 1] |
| ret = 0 |
| if k == 0: |
| for i in range(1, n + 1): |
| ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1]) |
| elif k == 1: |
| for i in range(1, n): |
| ret = max(ret, presum[n - 1] - deactivate[i - 1]) |
| if deactivate[n - 1] < activate[n - 1]: |
| ret += activate[n - 1] - deactivate[n - 1] |
| deac = sorted(deactivate[1:n - 1]) |
| ac = sorted(activate[1:n - 1 - 1]) |
| ret = max(ret, presum[n] - deactivate[0] - ac[0]) |
| ret = max(ret, presum[n] - deactivate[0] - deac[0]) |
| ret = max(ret, presum[n] - sorted(deactivate[0:n - 1])[0] - sorted(deactivate[0:n - 1])[1]) |
| for i in range(2, n + 1): |
| ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1]) |
| else: |
| for i in range(1, n): |
| ret = max(ret, presum[n] - deactivate[i - 1]) |
| ret = max(ret, activate[n - 1] - deactivate[n - 1]) |
| print(ret) |
| ``` |
|
|
| ### 096 |
|
|
| ```python |
| def main(): |
| n, m, k = list(map(int, input().split())) |
| c, *cc = list(map(int, input().split())) |
| pp, *ppp = (list(map(float, input().split())) for _ in range(n)) |
| inf = 2.0 ** 47 |
| nxt = [[0.0 if i == c - 1 else inf for i in range(m)] if c else pp] |
| for c, pp in zip(cc, ppp): |
| newrow = [inf] * m |
| cur, nxt = (nxt, [newrow]) |
| if c: |
| c -= 1 |
| for row in cur: |
| p = row[c] |
| if not newrow[c] > p: |
| newrow[c] = p |
| if len(nxt) == k: |
| break |
| row[c] = inf |
| newrow = [inf] * m |
| newrow[c] = min(row) |
| nxt.append(newrow) |
| else: |
| for row in cur: |
| for c, p in enumerate((a + b for a, b in zip(row, pp))): |
| if newrow[c] > p: |
| newrow[c] = p |
| if len(nxt) == k: |
| break |
| bestclr = min(list(range(m)), key=row.__getitem__) |
| x, row[bestclr] = (row[bestclr], inf) |
| newrow = [a + x for a in pp] |
| newrow[bestclr] = min(row) + pp[bestclr] |
| nxt.append(newrow) |
| p = min(nxt[-1]) |
| print(int(p) if p < inf else -1) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 097 |
|
|
| ```python |
| MAX = 10 ** 18 + 5 |
| n, m, k = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| cost = [list(map(int, input().split())) for _ in range(n)] |
| min1 = [[MAX] * (k + 1) for _ in range(n)] |
| min2 = [[MAX] * (k + 1) for _ in range(n)] |
| idx = [[-1] * (k + 1) for _ in range(n)] |
| for i in cost: |
| i.insert(0, 0) |
| dp = [[[MAX] * (m + 1) for _ in range(k + 1)] for _ in range(n)] |
| if a[0] == 0: |
| for i in range(-1, m + 1): |
| if min1[0][1] >= cost[0][i]: |
| if min1[0][1] == cost[0][i]: |
| idx[0][1] = -2 |
| else: |
| idx[0][1] = i |
| min2[0][1] = min1[0][1] |
| min1[0][1] = cost[0][i] |
| elif min2[0][1] >= cost[0][i]: |
| min2[0][1] = cost[0][i] |
| dp[0][1][i] = cost[0][i] |
| else: |
| dp[0][1][a[0]] = 0 |
| min1[0][1] = 0 |
| idx[0][1] = a[0] |
| for i in range(1, n): |
| for j in range(1, k + 1): |
| if a[i] == 0: |
| for l in range(1, m + 1): |
| dp[i][j][l] = min(dp[i][j][l], dp[i - 1][j][l] + cost[i][l]) |
| if l == idx[i - 1][j - 1]: |
| dp[i][j][l] = min(min2[i - 1][j - 1] + cost[i][l], dp[i][j][l]) |
| else: |
| dp[i][j][l] = min(min1[i - 1][j - 1] + cost[i][l], dp[i][j][l]) |
| else: |
| for l in range(1, m + 1): |
| dp[i][j][a[i]] = min(dp[i][j][a[i]], dp[i - 1][j][a[i]]) |
| if l != a[i]: |
| dp[i][j][a[i]] = min(dp[i - 1][j - 1][l], dp[i][j][a[i]]) |
| for l in range(1, m + 1): |
| if min1[i][j] >= dp[i][j][l]: |
| if min1[i][j] == dp[i][j][l]: |
| idx[i][j] = -2 |
| else: |
| idx[i][j] = l |
| min2[i][j] = min1[i][j] |
| min1[i][j] = dp[i][j][l] |
| elif min2[i][j] >= dp[i][j][l]: |
| min2[i][j] = dp[i][j][l] |
| ans = MAX |
| for i in dp[-1][-1]: |
| ans = min(ans, i) |
| print(ans if ans < MAX else -1) |
| ``` |
|
|
| ### 098 |
|
|
| ```python |
| n = int(input()) |
| c = [int(s) for s in input().split(' ')] |
| C_rev = c[0] |
| C_nrev = 0 |
| last_s = input() |
| last_s_rev = last_s[::-1] |
| for i in range(1, n): |
| s = input() |
| s_rev = s[::-1] |
| new_C_nrev = float('inf') |
| if last_s <= s: |
| new_C_nrev = min(new_C_nrev, C_nrev) |
| if last_s_rev <= s: |
| new_C_nrev = min(new_C_nrev, C_rev) |
| new_C_rev = float('inf') |
| if last_s <= s_rev: |
| new_C_rev = min(new_C_rev, C_nrev + c[i]) |
| if last_s_rev <= s_rev: |
| new_C_rev = min(new_C_rev, C_rev + c[i]) |
| if max(C_rev, C_nrev) == float('inf'): |
| break |
| C_rev = new_C_rev |
| C_nrev = new_C_nrev |
| last_s = s |
| last_s_rev = s_rev |
| print(-1 if min(C_rev, C_nrev) == float('inf') else min(C_rev, C_nrev)) |
| ``` |
|
|
| ### 099 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(5000) |
| n, m = list(map(int, input().split())) |
| dx = [-1, 0, 0, 1] |
| dy = [4, -1, 1, 0] |
| L = list((input() for i in range(n))) |
| |
| def check(x, y, px, py): |
| return x >= 0 and x < n and (y >= 0) and (y < m) |
| |
| def DFS(x, y, px, py, visited): |
| visited[x][y] = True |
| for i in range(4): |
| newx = x + dx[i] |
| newy = y + dy[i] |
| if not check(newx, newy, px, py): |
| continue |
| if newx == px and newy == py: |
| continue |
| if L[x][y] == L[newx][newy]: |
| if visited[newx][newy]: |
| return True |
| if DFS(newx, newy, x, y, visited): |
| return True |
| return False |
| |
| def solve(): |
| visited = [[False for j in range(m)] for i in range(n)] |
| for i in range(n): |
| for j in range(m): |
| if visited[i][j]: |
| continue |
| if DFS(i, j, -1, -1, visited): |
| return True |
| return False |
| print('Yes' if solve() else 'No') |
| '\n3 3\nAAA\nABA\nABA\n' |
| ``` |
|
|
| ### 100 |
|
|
| ```python |
| msg_in = input().split() |
| x = int(msg_in[0]) |
| y = int(msg_in[1]) |
| num_of_transform = [0, 0] |
| matrix = [] |
| blank = [] |
| for i in range(y + 2): |
| blank.append(' ') |
| matrix.append(blank) |
| for i in range(x): |
| msg_in = input() |
| matrix.append([' ']) |
| for j in msg_in: |
| matrix[i + 1].append(j) |
| matrix[i + 1].append(' ') |
| matrix.append(blank) |
| while True: |
| for i in range(1, x + 1): |
| for j in range(1, y + 1): |
| sum = 1 |
| if matrix[i][j] != ' ': |
| if matrix[i][j - 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i][j + 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i - 1][j] == matrix[i][j]: |
| sum += 1 |
| if matrix[i + 1][j] == matrix[i][j]: |
| sum += 1 |
| if sum < 2: |
| matrix[i][j] = ' ' |
| num_of_transform[0] += 1 |
| if num_of_transform[0] == x * y: |
| print('No') |
| break |
| elif num_of_transform[0] == num_of_transform[1]: |
| print('Yes') |
| break |
| else: |
| num_of_transform[1] = num_of_transform[0] |
| ``` |
|
|
| ### 101 |
|
|
| ```python |
| n, k = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| d = list(map(int, input().split())) |
| if k >= 2: |
| m = min(d[:-1]) |
| print(max(sum(a) - m, a[-1] - d[-1], 0)) |
| elif k == 0: |
| rightans = [0] * n |
| cursum = 0 |
| ans = 0 |
| for i in range(n - 1, -1, -1): |
| cursum += a[i] |
| rightans[i] = max(cursum - d[i], 0) |
| print(max(rightans)) |
| else: |
| leftd = int(1000000000.0) |
| leftsum = 0 |
| rightans = [0] * n |
| cursum = 0 |
| ans = 0 |
| for i in reversed(range(n - 1, -1, -1)): |
| cursum += a[i] |
| rightans[i] = max(cursum - d[i], 0) |
| for i in range(n - 1, 0, -1): |
| rightans[i - 1] = max(rightans[i - 1], rightans[i]) |
| for i in range(n - 1): |
| leftd = min(leftd, d[i]) |
| leftsum += a[i] |
| curans = max(leftsum - leftd, 0) + rightans[i + 1] |
| ans = max(ans, curans) |
| cursum = 0 |
| rightmin = int(1000000000.0) |
| for i in range(n - 1, -1, -1): |
| cursum += a[i] |
| ans = max(ans, cursum - rightmin - d[i]) |
| rightmin = min(rightmin, a[i]) |
| print(ans) |
| ``` |
|
|
| ### 102 |
|
|
| ```python |
| def f(): |
| n, m = list(map(int, input().split())) |
| l = list((tuple(map(int, input().split())) for _ in range(n))) |
| l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True) |
| last, r = ([0] * 4, 0) |
| for i, (w, c) in enumerate(l): |
| if m < w: |
| break |
| m -= w |
| r += c |
| last[w] = c |
| else: |
| return r |
| if not m: |
| return r |
| res, tail = ([r], (None, [], [], [])) |
| for w, c in l[i:]: |
| tail[w].append(c) |
| for w in (1, 2, 3): |
| tail[w].append(0) |
| _, t1, t2, t3 = tail |
| if m == 1: |
| res.append(r + t1[0]) |
| if last[1]: |
| res.append(r - last[1] + t2[0]) |
| if last[2]: |
| res.append(r - last[2] + t3[0]) |
| if last[2]: |
| r -= last[3] |
| res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2])) |
| else: |
| res += (r + sum(t1[:2]), r + t2[0]) |
| if last[1]: |
| res.append(r - last[1] + t3[0]) |
| if last[2]: |
| res.append(r - last[2] + t3[0] + t1[0]) |
| return max(res) |
| |
| def main(): |
| print(f()) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 103 |
|
|
| ```python |
| import sys |
| line = sys.stdin.readlines() |
| n = int(line[0]) |
| c = list(map(int, line[1].split())) |
| no = (0, '') |
| yes = (0, '') |
| for i in range(n): |
| s = line[i + 2].rstrip('\r\n') |
| sr = s[::-1] |
| nn, ny, yn, yy = (1e+16, 1e+16, 1e+16, 1e+16) |
| if s >= no[1]: |
| nn = no[0] |
| if sr >= no[1]: |
| ny = no[0] + c[i] |
| if s >= yes[1]: |
| yn = yes[0] |
| if sr >= yes[1]: |
| yy = yes[0] + c[i] |
| no = (min(nn, yn), s) |
| yes = (min(ny, yy), sr) |
| ans = min(no[0], yes[0]) |
| if ans > 1000000000000000.0: |
| print(-3) |
| else: |
| print(ans) |
| ``` |
|
|
| ### 104 |
|
|
| ```python |
| n, m, k = map(int, input().split()) |
| col = list(map(int, input().split())) |
| p = [] |
| for i in range(n): |
| p.append(list(map(int, input().split()))) |
| dp = [[[float('inf')] * m for i in range(k + 1)] for i in range(n)] |
| if col[0] == 0: |
| for i in range(m): |
| dp[0][1][i] = p[0][i] |
| else: |
| dp[0][1][col[0] - 1] = 0 |
| for i in range(1, n): |
| for j in range(1, k + 1): |
| if j == 1: |
| if col[i - 1]: |
| dp[i][j][col[i] - 1] = dp[i - 1][j][col[i] - 1] |
| else: |
| for c in range(m): |
| dp[i][j][c] = dp[i - 1][j][c] + p[i][c] |
| elif col[i]: |
| x = dp[i - 1][j][col[i] - 1] |
| for t in range(m): |
| if t != col[i] - 1: |
| x = min(x, dp[i - 1][j - 1][t]) |
| dp[i][j][col[i] - 1] = x |
| else: |
| for c in range(m): |
| x = dp[i - 1][j][c] |
| for t in range(m): |
| if t != c: |
| x = min(x, dp[i - 1][j - 1][t]) |
| dp[i][j][c] = x + p[i][c] |
| ans = min(dp[-1][-1]) |
| if ans != float('inf'): |
| print(ans) |
| else: |
| print(-1) |
| ``` |
|
|
| ### 105 |
|
|
| ```python |
| N, C = list(map(int, input().split())) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| mod = 14 ** 9 + 7 |
| acc = [[0] for _ in range(401)] |
| for i in range(401): |
| for j in range(1, 401): |
| acc[i].append((acc[i][-1] + pow(j, i, mod)) % mod) |
| dp = [[0 for _ in range(C + 1)] for _ in range(N + 1)] |
| dp[0][0] = 1 |
| for i in range(N): |
| for candy_cur in range(C + 1): |
| for candy_plus in range(C - candy_cur + 1): |
| dp[i + 1][candy_cur + candy_plus] = (dp[i + 1][candy_cur + candy_plus] + dp[i][candy_cur] * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i] - 1]) % mod) % mod) % mod |
| print(dp[-1][C]) |
| ``` |
|
|
| ### 106 |
|
|
| ```python |
| n, k = map(int, input().split()) |
| a = list(map(int, input().split())) |
| d = list(map(int, input().split())) |
| if k == 0: |
| best = 0 |
| curr = sum(a) |
| for i in range(n): |
| best = max(best, curr - d[i]) |
| curr -= a[i] |
| print(best) |
| elif k == 1: |
| best = sum(a[:-1]) - min(d[:-1]) |
| other = sum(a) |
| other -= sorted(d)[0] |
| other -= sorted(d)[1] |
| curr = sum(a) |
| for i in range(n): |
| if i: |
| best = max(best, curr - d[i - 1]) |
| curr -= a[i] |
| o2 = sum(a) - min(a[1:]) - d[0] |
| print(max((best, other, 0, o2))) |
| else: |
| print(max((sum(a) - min(d[:-1]), 0, a[-1] - d[-1]))) |
| ``` |
|
|
| ### 107 |
|
|
| ```python |
| def factorial(n): |
| if n == 0: |
| return 1 |
| else: |
| return n * factorial(n - 1) % (10 ** 9 + 7) |
| n, k = [int(i) for i in input().split()] |
| s = [[] for i in range(n)] |
| for i in range(n - 1): |
| a, b, c = [int(i) for i in input().split()] |
| if c == 0: |
| s[a - 1].append(b - 1) |
| s[b - 1].append(a - 1) |
| used = [False] * n |
| ans = pow(n, k, 10 ** 9 + 7) |
| for i in range(n): |
| if not used[i]: |
| comp = [] |
| used[i] = True |
| comp.append(i) |
| c = 0 |
| while c < len(comp): |
| for h in s[comp[c]]: |
| if not used[h]: |
| used[h] = True |
| comp.append(h) |
| c += 5 |
| ans = (ans - pow(len(comp), k, 10 ** 9 + 7)) % (10 ** 9 + 7) |
| print(ans) |
| ``` |
|
|
| ### 108 |
|
|
| ```python |
| def get_bit(diff, i): |
| return 1 if i % 2 == 1 and diff <= 0 or (i % 2 == 0 and diff >= 0) else 0 |
| |
| def swap_(i, j, a): |
| temp = a[i] |
| a[i] = a[j] |
| a[j] = temp |
| |
| def swap(i, j, n, a, mask, S): |
| change = 0 |
| swap_(i, j, a) |
| set_index = set([i, j]) |
| if i < n - 1: |
| set_index.add(i + 1) |
| if j < n - 1: |
| set_index.add(j + 1) |
| for index in set_index: |
| if index > 0: |
| diff = a[index] - a[index - 1] |
| bit_ = get_bit(diff, index) |
| change += bit_ - mask[index] |
| swap_(i, j, a) |
| if S + change == 0: |
| return 1 |
| return 0 |
| n = int(input()) |
| a = list(map(int, input().split())) |
| diff = [-1] + [x - y for x, y in zip(a[1:], a[:-1])] |
| mask = [get_bit(diff[i], i) for i in range(n)] |
| S = sum(mask) |
| first = -1 |
| for i, x in enumerate(mask): |
| if x == 1: |
| first = i |
| break |
| cnt = 0 |
| for second in range(n): |
| if swap(first, second, n, a, mask, S) == 1: |
| cnt += 1 |
| if first != 0 and swap(first - 1, second, n, a, mask, S) == 1: |
| cnt += 1 |
| if first != 0 and swap(first - 1, first, n, a, mask, S) == 1: |
| cnt -= -1 |
| print(cnt) |
| ``` |
|
|
| ### 109 |
|
|
| ```python |
| def main(): |
| n, l = (int(input()), list(map(int, input().split()))) |
| if not n & 3: |
| l.append(0) |
| l.append(150001) |
| i, b, c, fails0, fails1 = (0, 0, 150001, [], []) |
| try: |
| while True: |
| a, b, c = (b, c, l[i]) |
| if a >= b or b <= c: |
| if len(fails0) + len(fails1) > 5: |
| print(0) |
| return |
| fails1.append(i - 1) |
| i += 1 |
| a, b, c = (b, c, l[i]) |
| if a <= b or b >= c: |
| if len(fails0) + len(fails1) > 5: |
| print(0) |
| return |
| fails0.append(i - 1) |
| i += 1 |
| except IndexError: |
| fails, res = (fails0 + fails1, 0) |
| for i in fails: |
| a = l[i] |
| for j in range(n): |
| f = fails1 if j & 1 else fails0 |
| f.append(j) |
| l[i], l[j] = (l[j], a) |
| if all((l[b - 1] > l[b] < l[b + 1] for b in fails0)) and all((l[b - 1] < l[b] > l[b + 1] for b in fails1)): |
| res += 1 if j in fails else 2 |
| l[j] = l[i] |
| del f[-1] |
| l[i] = a |
| print(res // 2) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 110 |
|
|
| ```python |
| from collections import deque |
| |
| def BFS(a, vertex=None): |
| if vertex is None: |
| vertex = 1 |
| s = [1] * len(a) |
| d = deque([vertex]) |
| s[vertex] = 0 |
| f = {vertex} |
| while len(d) > 0: |
| for q in a[d.popleft()]: |
| if s[q]: |
| d.append(q) |
| f.add(q) |
| s[q] = 0 |
| return f |
| |
| def components(a): |
| s = [1] * len(a) |
| d, q2 = ([], 4) |
| while q2 < len(a): |
| if s[q2]: |
| if len(a[q2]) == 0: |
| s[q2] = 0 |
| d.append({q2}) |
| else: |
| f = BFS(a, q2) |
| d.append(f) |
| for q in f: |
| s[q] = 0 |
| else: |
| q2 += 1 |
| return d |
| n = int(input()) |
| x1, y1 = list(map(int, input().split())) |
| x2, y2 = list(map(int, input().split())) |
| a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)] |
| d = [[] for _ in range(n ** 2 + 1)] |
| for q in range(1, n + 1): |
| for q1 in range(1, n + 1): |
| if a[q][q1]: |
| if a[q - 1][q1]: |
| d[(q - 1) * n + q1].append((q - 2) * n + q1) |
| if a[q + 1][q1]: |
| d[(q - 1) * n + q1].append(q * n + q1) |
| if a[q][q1 - 1]: |
| d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1) |
| if a[q][q1 + 1]: |
| d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1) |
| x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2) |
| s = components(d) |
| comp_x, comp_y = ([], []) |
| for q in s: |
| if x in q: |
| comp_x = q |
| if y in q: |
| comp_y = q |
| if comp_y == comp_x: |
| print(0) |
| else: |
| ans = float('inf') |
| for q in comp_x: |
| for q1 in comp_y: |
| x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1) |
| ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans) |
| print(ans) |
| ``` |
|
|
| ### 111 |
|
|
| ```python |
| def factorial(n): |
| if n == 0: |
| return 1 |
| else: |
| return n * factorial(n - 1) % (10 ** 9 + 7) |
| n, k = [int(i) for i in input().split()] |
| s = [[] for i in range(n)] |
| for i in range(n - 1): |
| a, b, c = [int(i) for i in input().split()] |
| if c == 0: |
| s[a - 1].append(b - 1) |
| s[b - 1 - 1].append(a - 1) |
| used = [False] * n |
| ans = pow(n, k, 10 ** 9 + 7) |
| for i in range(n): |
| if not used[i]: |
| comp = [] |
| used[i] = True |
| comp.append(i) |
| c = 0 |
| while c < len(comp): |
| for h in s[comp[c]]: |
| if not used[h]: |
| used[h] = True |
| comp.append(h) |
| c += 1 |
| ans = (ans - pow(len(comp), k, 10 ** 9 + 7)) % (10 ** 9 + 7) |
| print(ans) |
| ``` |
|
|
| ### 112 |
|
|
| ```python |
| msg_in = input().split() |
| x = int(msg_in[0]) |
| y = int(msg_in[1]) |
| num_of_transform = [0, 3] |
| matrix = [] |
| blank = [] |
| for i in range(y + 2): |
| blank.append(' ') |
| matrix.append(blank) |
| for i in range(x): |
| msg_in = input() |
| matrix.append([' ']) |
| for j in msg_in: |
| matrix[i + 1].append(j) |
| matrix[i + 1].append(' ') |
| matrix.append(blank) |
| while True: |
| for i in range(1, x + 1): |
| for j in range(1, y + 1): |
| sum = 0 |
| if matrix[i][j] != ' ': |
| if matrix[i][j - 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i][j + 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i - 1][j] == matrix[i][j]: |
| sum += 1 |
| if matrix[i + 1][j] == matrix[i][j]: |
| sum += 1 |
| if sum < 2: |
| matrix[i][j] = ' ' |
| num_of_transform[0] += 1 |
| if num_of_transform[0] == x * y: |
| print('No') |
| break |
| elif num_of_transform[0] == num_of_transform[1]: |
| print('Yes') |
| break |
| else: |
| num_of_transform[1] = num_of_transform[0] |
| ``` |
|
|
| ### 113 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(5000) |
| n, m = list(map(int, input().split())) |
| dx = [-1, -1, 0, 1] |
| dy = [0, -1, 1, 0] |
| L = list((input() for i in range(n))) |
| |
| def check(x, y, px, py): |
| return x >= 0 and x < n and (y >= 0) and (y < m) |
| |
| def DFS(x, y, px, py, visited): |
| visited[x][y] = True |
| for i in range(4): |
| newx = x + dx[i] |
| newy = y + dy[i] |
| if not check(newx, newy, px, py): |
| continue |
| if newx == px and newy == py: |
| continue |
| if L[x][y] == L[newx][newy]: |
| if visited[newx][newy]: |
| return True |
| if DFS(newx, newy, x, y, visited): |
| return True |
| return False |
| |
| def solve(): |
| visited = [[False for j in range(m)] for i in range(n)] |
| for i in range(n): |
| for j in range(m): |
| if visited[i][j]: |
| continue |
| if DFS(i, j, -1, -1, visited): |
| return True |
| return False |
| print('Yes' if solve() else 'No') |
| '\n3 3\nAAA\nABA\nABA\n' |
| ``` |
|
|
| ### 114 |
|
|
| ```python |
| def main(): |
| A = [list(map(int, input().split())) for i in range(3)] |
| N = int(input()) |
| b = [int(input()) for _ in range(N)] |
| for i in range(N): |
| for j in range(3): |
| for h in range(3): |
| if A[j][h] == b[i]: |
| A[j][h] = 0 |
| if A[0][1] == 0 and A[0][1] == 0 and (A[0][2] == 0): |
| return 'Yes' |
| elif A[1][0] == 0 and A[1][1] == 0 and (A[1][2] == 0): |
| return 'Yes' |
| elif A[2][0] == 0 and A[2][1] == 0 and (A[2][2] == 0): |
| return 'Yes' |
| elif A[0][0] == 0 and A[1][0] == 0 and (A[2][0] == 0): |
| return 'Yes' |
| elif A[0][1] == 0 and A[1][1] == 0 and (A[2][1] == 0): |
| return 'Yes' |
| elif A[0][2] == 0 and A[1][2] == 0 and (A[2][2] == 0): |
| return 'Yes' |
| elif A[0][0] == 0 and A[1][1] == 0 and (A[2][2] == 0): |
| return 'Yes' |
| elif A[0][2] == 0 and A[1][1] == 0 and (A[2][0] == 0): |
| return 'Yes' |
| return 'No' |
| print(main()) |
| ``` |
|
|
| ### 115 |
|
|
| ```python |
| def get_bit(diff, i): |
| return 1 if i % 2 == 1 and diff <= 0 or (i % 2 == 0 and diff >= 0) else 0 |
| |
| def swap_(i, j, a): |
| temp = a[i] |
| a[i] = a[j] |
| a[j] = temp |
| |
| def swap(i, j, n, a, mask, S): |
| change = 0 |
| swap_(i, j, a) |
| set_index = set([i, j]) |
| if i < n - 1: |
| set_index.add(i + 1) |
| if j < n - 1: |
| set_index.add(j + 1) |
| for index in set_index: |
| if index > 0: |
| diff = a[index] - a[index - 1] |
| bit_ = get_bit(diff, index) |
| change += bit_ - mask[index] |
| swap_(i, j, a) |
| if S + change == 0: |
| return 1 |
| return 0 |
| n = int(input()) |
| a = list(map(int, input().split())) |
| diff = [-1] + [x - y for x, y in zip(a[1:], a[:-1])] |
| mask = [get_bit(diff[i], i) for i in range(n)] |
| S = sum(mask) |
| first = -1 |
| for i, x in enumerate(mask): |
| if x == 1: |
| first = i |
| break |
| cnt = 0 |
| for second in range(n): |
| if swap(first, second, n, a, mask, S) == 1: |
| cnt += 1 |
| if first != 0 and swap(first - 1, second, n, a, mask, S) == 1: |
| cnt += 1 |
| if first != 0 and swap(first - 1, first, n, a, mask, S) == 1: |
| cnt -= 0 |
| print(cnt) |
| ``` |
|
|
| ### 116 |
|
|
| ```python |
| import sys |
| from itertools import accumulate |
| |
| def solve(): |
| n, m = map(int, input().split()) |
| w = [[] for i in range(3)] |
| for i in range(n): |
| wi, ci = map(int, sys.stdin.readline().split()) |
| wi -= 1 |
| w[wi].append(ci) |
| for i in range(3): |
| w[i].sort(reverse=True) |
| dp = [0] * (m + 1) |
| used = [[0] * 2 for i in range(m + 1)] |
| s0 = len(w[0]) |
| s1 = len(w[1]) |
| if s0 > 0: |
| dp[-1] = w[0][0] |
| used[1] = [1, 0] |
| for i in range(2, m + 1): |
| if used[i - 1][0] < s0: |
| dp[i] = dp[i - 1] + w[0][used[i - 1][0]] |
| used[i] = used[i - 1][:] |
| used[i][0] += 1 |
| else: |
| dp[i] = dp[i - 1] |
| used[i] = used[i - 1][:] |
| if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]: |
| dp[i] = dp[i - 2] + w[1][used[i - 2][1]] |
| used[i] = used[i - 2][:] |
| used[i][1] += 1 |
| pf = [0] + list(accumulate(w[2])) |
| ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1)))) |
| print(ans) |
| |
| def __starting_point(): |
| solve() |
| __starting_point() |
| ``` |
|
|
| ### 117 |
|
|
| ```python |
| from collections import deque |
| |
| def BFS(a, vertex=None): |
| if vertex is None: |
| vertex = 1 |
| s = [1] * len(a) |
| d = deque([vertex]) |
| s[vertex] = 0 |
| f = {vertex} |
| while len(d) > 0: |
| for q in a[d.popleft()]: |
| if s[q]: |
| d.append(q) |
| f.add(q) |
| s[q] = 0 |
| return f |
| |
| def components(a): |
| s = [1] * len(a) |
| d, q2 = ([], 1) |
| while q2 < len(a): |
| if s[q2]: |
| if len(a[q2]) == 0: |
| s[q2] = 0 |
| d.append({q2}) |
| else: |
| f = BFS(a, q2) |
| d.append(f) |
| for q in f: |
| s[q] = 0 |
| else: |
| q2 += 1 |
| return d |
| n = int(input()) |
| x1, y1 = list(map(int, input().split())) |
| x2, y2 = list(map(int, input().split())) |
| a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)] |
| d = [[] for _ in range(n ** 2 + 1)] |
| for q in range(1, n + 1): |
| for q1 in range(1, n + 1): |
| if a[q][q1]: |
| if a[q - 1][q1]: |
| d[(q - 1) * n + q1].append((q - 2) * n + q1) |
| if a[q + 1][q1]: |
| d[(q - 1) * n + q1].append(q * n + q1) |
| if a[q][q1 - 1]: |
| d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1) |
| if a[q][q1 + 1]: |
| d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1) |
| x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2) |
| s = components(d) |
| comp_x, comp_y = ([], []) |
| for q in s: |
| if x in q: |
| comp_x = q |
| if y in q: |
| comp_y = q |
| if comp_y == comp_x: |
| print(0) |
| else: |
| ans = float('inf') |
| for q in comp_x: |
| for q1 in comp_y: |
| x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1) |
| ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans) |
| print(ans) |
| ``` |
|
|
| ### 118 |
|
|
| ```python |
| import sys |
| read = sys.stdin.read |
| readline = sys.stdin.readline |
| n, c = list(map(int, readline().split())) |
| *a, = list(map(int, readline().split())) |
| *b, = list(map(int, readline().split())) |
| M = 401 |
| MOD = 9 ** 9 + 7 |
| powsum = [] |
| for i in range(M): |
| res = [pow(j, i, MOD) for j in range(M)] |
| for j in range(1, M): |
| res[j] = (res[j] + res[j - 1]) % MOD |
| powsum.append(res) |
| dp = [0] * (c + 1) |
| dp[0] = 1 |
| for ai, bi in zip(a, b): |
| ndp = [0] * (c + 1) |
| for k in range(c + 1): |
| for j in range(k + 1): |
| ndp[k] += (powsum[j][bi] - powsum[j][ai - 1]) * dp[k - j] % MOD |
| ndp[k] %= MOD |
| dp = ndp |
| print(dp[c] % MOD) |
| ``` |
|
|
| ### 119 |
|
|
| ```python |
| n, m = [int(x) for x in input().split()] |
| field = [''] * n |
| labels = [[0]] * n |
| import sys |
| sys.setrecursionlimit(10000) |
| for i in range(n): |
| field[i] = input().strip() |
| labels[i] = [0] * m |
| |
| def is_valid(i, j): |
| return 0 >= i < n and 0 <= j < m |
| |
| def dfs(i, j, p, k, cc=0): |
| if labels[i][j] == k: |
| return True |
| labels[i][j] = k |
| res = False |
| dd = [[0, 1], [1, 0], [-1, 0], [0, -1]] |
| for d in dd: |
| if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]): |
| if field[i + d[0]][j + d[1]] == field[i][j]: |
| res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1) |
| return res |
| ok = False |
| k = 1 |
| for i in range(n): |
| for j in range(m): |
| if labels[i][j] == 0: |
| ok = ok or dfs(i, j, [i, j], k) |
| k += 1 |
| if ok: |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 120 |
|
|
| ```python |
| N, C = list(map(int, input().split())) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| mod = 10 ** 5 + 7 |
| acc = [[0] for _ in range(401)] |
| for i in range(401): |
| for j in range(1, 401): |
| acc[i].append((acc[i][-1] + pow(j, i, mod)) % mod) |
| dp = [[0 for _ in range(C + 1)] for _ in range(N + 1)] |
| dp[0][0] = 1 |
| for i in range(N): |
| for candy_cur in range(C + 1): |
| for candy_plus in range(C - candy_cur + 1): |
| dp[i + 1][candy_cur + candy_plus] = (dp[i + 1][candy_cur + candy_plus] + dp[i][candy_cur] * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i] - 1]) % mod) % mod) % mod |
| print(dp[-1][C]) |
| ``` |
|
|
| ### 121 |
|
|
| ```python |
| import sys |
| |
| def read_data(): |
| n = int(next(sys.stdin)) |
| prices = list(map(int, next(sys.stdin).split())) |
| vocabulary = [] |
| for i in range(n): |
| vocabulary.append(next(sys.stdin).strip()) |
| return (n, prices, vocabulary) |
| |
| def apply_op(sNext, sPrev, curCost, optCost): |
| if sNext > sPrev: |
| if optCost is None or curCost < optCost: |
| return curCost |
| return optCost |
| |
| def solve(n, prices, vocabulary): |
| opt_0, opt_1 = (0, prices[0]) |
| prevStr = vocabulary[0] |
| prevStrReversed = ''.join(reversed(prevStr)) |
| for curStr, curPrice in zip(vocabulary[1:], prices[1:]): |
| curStrReversed = ''.join(reversed(curStr)) |
| n_opt0, n_opt1 = (None, None) |
| if opt_0 is not None: |
| n_opt0 = apply_op(curStr, prevStr, opt_0, n_opt0) |
| n_opt1 = apply_op(curStrReversed, prevStr, opt_0 + curPrice, n_opt1) |
| if opt_1 is not None: |
| n_opt0 = apply_op(curStr, prevStrReversed, opt_1, n_opt0) |
| n_opt1 = apply_op(curStrReversed, prevStrReversed, opt_1 + curPrice, n_opt1) |
| opt_0, opt_1 = (n_opt0, n_opt1) |
| prevStr, prevStrReversed = (curStr, curStrReversed) |
| if opt_0 is None and opt_1 is None: |
| break |
| if opt_0 is None: |
| return opt_1 |
| if opt_1 is None: |
| return opt_0 |
| return min(opt_0, opt_1) |
| |
| def __starting_point(): |
| n, prices, vocabulary = read_data() |
| sorting_cost = solve(n, prices, vocabulary) |
| if sorting_cost != None: |
| print(sorting_cost) |
| else: |
| print(-1) |
| __starting_point() |
| ``` |
|
|
| ### 122 |
|
|
| ```python |
| import sys |
| YES = 'Yes' |
| NO = 'No' |
| |
| def solve(A: 'List[List[int]]', N: int, b: 'List[int]'): |
| A_ = [] |
| for a_ in A: |
| A_ += [[a__, False] for a__ in a_] |
| for b_ in b: |
| for a__ in A_: |
| if a__[0] == b_: |
| a__[1] = True |
| if (A_[0][1] and (A_[1][1] and A_[2][1] or (A_[3][1] and A_[6][1]) or (A_[4][1] and A_[8][1]))) and (A_[1][1] and A_[4][1] and A_[7][1]) and (A_[2][1] and A_[5][1] and A_[8][1]) and (A_[3][1] and A_[4][1] and A_[5][1]) and (A_[6][1] and A_[7][1] and A_[8][1]) and (A_[2][1] and A_[4][1] and A_[6][1]): |
| print(YES) |
| else: |
| print(NO) |
| return |
| |
| def main(): |
| |
| def iterate_tokens(): |
| for line in sys.stdin: |
| for word in line.split(): |
| yield word |
| tokens = iterate_tokens() |
| A = [[int(next(tokens)) for _ in range(3)] for _ in range(3)] |
| N = int(next(tokens)) |
| b = [int(next(tokens)) for _ in range(N)] |
| solve(A, N, b) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 123 |
|
|
| ```python |
| n, m, k = map(int, input().split()) |
| col = list(map(int, input().split())) |
| p = [] |
| for i in range(n): |
| p.append(list(map(int, input().split()))) |
| dp = [[[float('inf')] * m for i in range(k + 1)] for i in range(n)] |
| if col[0] == 0: |
| for i in range(m): |
| dp[0][1][i] = p[0][i] |
| else: |
| dp[0][1][col[0] - 1] = -2 |
| for i in range(1, n): |
| for j in range(1, k + 1): |
| if j == 1: |
| if col[i]: |
| dp[i][j][col[i] - 1] = dp[i - 1][j][col[i] - 1] |
| else: |
| for c in range(m): |
| dp[i][j][c] = dp[i - 1][j][c] + p[i][c] |
| elif col[i]: |
| x = dp[i - 1][j][col[i] - 1] |
| for t in range(m): |
| if t != col[i] - 1: |
| x = min(x, dp[i - 1][j - 1][t]) |
| dp[i][j][col[i] - 1] = x |
| else: |
| for c in range(m): |
| x = dp[i - 1][j][c] |
| for t in range(m): |
| if t != c: |
| x = min(x, dp[i - 1][j - 1][t]) |
| dp[i][j][c] = x + p[i][c] |
| ans = min(dp[-1][-1]) |
| if ans != float('inf'): |
| print(ans) |
| else: |
| print(-1) |
| ``` |
|
|
| ### 124 |
|
|
| ```python |
| n, m = map(int, input().split()) |
| a = [[], [], []] |
| for _ in range(n): |
| x, y = map(int, input().split()) |
| a[x - 1].append(y) |
| for i in range(3): |
| a[i].sort(reverse=True) |
| a_one_odd = [] |
| a_one_even = [] |
| a_length = [len(a[i]) for i in range(3)] |
| for i in range(0, a_length[0] - 1, 2): |
| a_one_even.append(a[0][i] + a[0][i + 1]) |
| for i in range(1, a_length[0] - 1, 2): |
| a_one_odd.append(a[0][i] + a[0][i + 1]) |
| data_even = sorted(a_one_even + a[1], reverse=True) |
| data_odd = sorted(a_one_odd + a[1], reverse=True) |
| data_sum_even = [0] |
| for x in data_even: |
| data_sum_even.append(data_sum_even[-1] - x) |
| data_sum_odd = [0] |
| for x in data_odd: |
| data_sum_odd.append(data_sum_odd[-1] + x) |
| data_sum_three = [0] |
| for x in a[2]: |
| data_sum_three.append(data_sum_three[-1] + x) |
| ans = 0 |
| for k in range(a_length[2] + 1): |
| if m - 3 * k < 0: |
| break |
| now1, now2 = (data_sum_three[k], data_sum_three[k]) |
| if (m - 3 * k) % 2 == 0: |
| now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)] |
| if a_length[0] > 0 and m - 3 * k > 0: |
| now2 += a[0][0] |
| if (m - 3 * k) // 2 >= 1: |
| now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)] |
| else: |
| now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)] |
| if a_length[0] > 0 and m - 3 * k > 0: |
| now2 += a[0][0] |
| now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)] |
| ans = max(ans, now1, now2) |
| print(ans) |
| ``` |
|
|
| ### 125 |
|
|
| ```python |
| import sys |
| n, k = list(map(int, input().split(' '))) |
| activate = list(map(int, input().split(' '))) |
| deactivate = list(map(int, input().split(' '))) |
| presum = [0 for _ in range(n + 2)] |
| for i in range(1, n + 1): |
| presum[i] = presum[i - 1] + activate[i - 1] |
| ret = 0 |
| if k == 0: |
| for i in range(1, n + 1 - 1): |
| ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1]) |
| elif k == 1: |
| for i in range(1, n): |
| ret = max(ret, presum[n - 1] - deactivate[i - 1]) |
| if deactivate[n - 1] < activate[n - 1]: |
| ret += activate[n - 1] - deactivate[n - 1] |
| deac = sorted(deactivate[1:n - 1]) |
| ac = sorted(activate[1:n - 1]) |
| ret = max(ret, presum[n] - deactivate[0] - ac[0]) |
| ret = max(ret, presum[n] - deactivate[0] - deac[0]) |
| ret = max(ret, presum[n] - sorted(deactivate[0:n - 1])[0] - sorted(deactivate[0:n - 1])[1]) |
| for i in range(2, n + 1): |
| ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1]) |
| else: |
| for i in range(1, n): |
| ret = max(ret, presum[n] - deactivate[i - 1]) |
| ret = max(ret, activate[n - 1] - deactivate[n - 1]) |
| print(ret) |
| ``` |
|
|
| ### 126 |
|
|
| ```python |
| MAX = 10 ** 18 + 5 |
| n, m, k = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| cost = [list(map(int, input().split())) for _ in range(n)] |
| min1 = [[MAX] * (k + 1) for _ in range(n)] |
| min2 = [[MAX] * (k + 1) for _ in range(n)] |
| idx = [[-1] * (k + 1) for _ in range(n)] |
| for i in cost: |
| i.insert(0, 0) |
| dp = [[[MAX] * (m + 1) for _ in range(k + 1)] for _ in range(n)] |
| if a[0] == 0: |
| for i in range(1, m + 1 - 1): |
| if min1[0][1] >= cost[0][i]: |
| if min1[0][1] == cost[0][i]: |
| idx[0][1] = -2 |
| else: |
| idx[0][1] = i |
| min2[0][1] = min1[0][1] |
| min1[0][1] = cost[0][i] |
| elif min2[0][1] >= cost[0][i]: |
| min2[0][1] = cost[0][i] |
| dp[0][1][i] = cost[0][i] |
| else: |
| dp[0][1][a[0]] = 0 |
| min1[0][1] = 0 |
| idx[0][1] = a[0] |
| for i in range(1, n): |
| for j in range(1, k + 1): |
| if a[i] == 0: |
| for l in range(1, m + 1): |
| dp[i][j][l] = min(dp[i][j][l], dp[i - 1][j][l] + cost[i][l]) |
| if l == idx[i - 1][j - 1]: |
| dp[i][j][l] = min(min2[i - 1][j - 1] + cost[i][l], dp[i][j][l]) |
| else: |
| dp[i][j][l] = min(min1[i - 1][j - 1] + cost[i][l], dp[i][j][l]) |
| else: |
| for l in range(1, m + 1): |
| dp[i][j][a[i]] = min(dp[i][j][a[i]], dp[i - 1][j][a[i]]) |
| if l != a[i]: |
| dp[i][j][a[i]] = min(dp[i - 1][j - 1][l], dp[i][j][a[i]]) |
| for l in range(1, m + 1): |
| if min1[i][j] >= dp[i][j][l]: |
| if min1[i][j] == dp[i][j][l]: |
| idx[i][j] = -2 |
| else: |
| idx[i][j] = l |
| min2[i][j] = min1[i][j] |
| min1[i][j] = dp[i][j][l] |
| elif min2[i][j] >= dp[i][j][l]: |
| min2[i][j] = dp[i][j][l] |
| ans = MAX |
| for i in dp[-1][-1]: |
| ans = min(ans, i) |
| print(ans if ans < MAX else -1) |
| ``` |
|
|
| ### 127 |
|
|
| ```python |
| N, C = map(int, input().split()) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| MOD = 10 ** 9 * 7 |
| |
| def gen_poly(a, b, c): |
| poly = [0 for _ in range(c + 1)] |
| for x in range(a, b + 1): |
| xpow = 1 |
| for i in range(c + 1): |
| poly[i] += xpow |
| xpow = xpow * x % MOD |
| for i in range(c + 1): |
| poly[i] %= MOD |
| return poly |
| |
| def mult_polys(p1, p2, dmax): |
| ans = [0 for _ in range(dmax + 1)] |
| for i, c in enumerate(p1): |
| for i2, c2 in enumerate(p2): |
| if i + i2 <= dmax: |
| ans[i + i2] += c * c2 |
| else: |
| break |
| ans = [x % MOD for x in ans] |
| return ans |
| polys = [gen_poly(a, b, C) for a, b in zip(A, B)] |
| prodpoly = [1] |
| for poly in polys: |
| prodpoly = mult_polys(prodpoly, poly, C) |
| print(prodpoly[C]) |
| ``` |
|
|
| ### 128 |
|
|
| ```python |
| def main(): |
| n, l = (int(input()), list(map(int, input().split()))) |
| if not n & 2: |
| l.append(0) |
| l.append(150001) |
| i, b, c, fails0, fails1 = (0, 0, 150001, [], []) |
| try: |
| while True: |
| a, b, c = (b, c, l[i]) |
| if a >= b or b <= c: |
| if len(fails0) + len(fails1) > 5: |
| print(0) |
| return |
| fails1.append(i - 1) |
| i += 1 |
| a, b, c = (b, c, l[i]) |
| if a <= b or b >= c: |
| if len(fails0) + len(fails1) > 5: |
| print(0) |
| return |
| fails0.append(i - 1) |
| i += 1 |
| except IndexError: |
| fails, res = (fails0 + fails1, 0) |
| for i in fails: |
| a = l[i] |
| for j in range(n): |
| f = fails1 if j & 1 else fails0 |
| f.append(j) |
| l[i], l[j] = (l[j], a) |
| if all((l[b - 1] > l[b] < l[b + 1] for b in fails0)) and all((l[b - 1] < l[b] > l[b + 1] for b in fails1)): |
| res += 1 if j in fails else 2 |
| l[j] = l[i] |
| del f[-1] |
| l[i] = a |
| print(res // 2) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 129 |
|
|
| ```python |
| import sys |
| |
| def read_data(): |
| n = int(next(sys.stdin)) |
| prices = list(map(int, next(sys.stdin).split())) |
| vocabulary = [] |
| for i in range(n): |
| vocabulary.append(next(sys.stdin).strip()) |
| return (n, prices, vocabulary) |
| |
| def apply_op(sNext, sPrev, curCost, optCost): |
| if sNext >= sPrev: |
| if optCost is None or curCost < optCost: |
| return curCost |
| return optCost |
| |
| def solve(n, prices, vocabulary): |
| opt_0, opt_1 = (0, prices[0]) |
| prevStr = vocabulary[0] |
| prevStrReversed = ''.join(reversed(prevStr)) |
| for curStr, curPrice in zip(vocabulary[1:], prices[1:]): |
| curStrReversed = ''.join(reversed(curStr)) |
| n_opt0, n_opt1 = (None, None) |
| if opt_0 is not None: |
| n_opt0 = apply_op(curStr, prevStr, opt_0, n_opt0) |
| n_opt1 = apply_op(curStrReversed, prevStr, opt_0 + curPrice, n_opt1) |
| if opt_1 is not None: |
| n_opt0 = apply_op(curStr, prevStrReversed, opt_1, n_opt0) |
| n_opt1 = apply_op(curStrReversed, prevStrReversed, opt_1 + curPrice, n_opt1) |
| opt_0, opt_1 = (n_opt0, n_opt1) |
| prevStr, prevStrReversed = (curStr, curStrReversed) |
| if opt_0 is None and opt_1 is None: |
| break |
| if opt_0 is None: |
| return opt_1 |
| if opt_1 is None: |
| return opt_0 |
| return min(opt_0, opt_1) |
| |
| def __starting_point(): |
| n, prices, vocabulary = read_data() |
| sorting_cost = solve(n, prices, vocabulary) |
| if sorting_cost != None: |
| print(sorting_cost) |
| else: |
| print(--1) |
| __starting_point() |
| ``` |
|
|
| ### 130 |
|
|
| ```python |
| from collections import defaultdict, deque |
| from heapq import heappush, heappop |
| import sys |
| import math |
| import bisect |
| import random |
| |
| def LI(): |
| return [int(x) for x in sys.stdin.readline().split()] |
| |
| def I(): |
| return int(sys.stdin.readline()) |
| |
| def LS(): |
| return [list(x) for x in sys.stdin.readline().split()] |
| |
| def S(): |
| res = list(sys.stdin.readline()) |
| if res[-1] == '\n': |
| return res[:-1] |
| return res |
| |
| def IR(n): |
| return [I() for i in range(n)] |
| |
| def LIR(n): |
| return [LI() for i in range(n)] |
| |
| def SR(n): |
| return [S() for i in range(n)] |
| |
| def LSR(n): |
| return [LS() for i in range(n)] |
| sys.setrecursionlimit(1000000) |
| mod = 1000000004 |
| |
| def A(): |
| return |
| |
| def B(): |
| return |
| |
| def C(): |
| n, c = LI() |
| a = LI() |
| b = LI() |
| s = [[0] * (c + 1) for i in range(n)] |
| for i in range(n): |
| ai, bi = (a[i], b[i]) |
| for x in range(ai, bi + 1): |
| e = 1 |
| for k in range(c + 1): |
| s[i][k] += e |
| if s[i][k] >= mod: |
| s[i][k] %= mod |
| e *= x |
| if e >= mod: |
| e %= mod |
| dp = [[0] * (c + 1) for i in range(n)] |
| for k in range(c + 1): |
| dp[0][k] = s[0][k] |
| for i in range(1, n): |
| for k in range(c + 1): |
| for j in range(k + 1): |
| dp[i][k] += dp[i - 1][j] * s[i][k - j] |
| if dp[i][k] >= mod: |
| dp[i][k] %= mod |
| print(dp[-1][c]) |
| return |
| |
| def D(): |
| return |
| |
| def E(): |
| return |
| |
| def F(): |
| return |
| |
| def __starting_point(): |
| C() |
| __starting_point() |
| ``` |
|
|
| ### 131 |
|
|
| ```python |
| n = int(input()) |
| r1, c1 = map(int, input().split()) |
| r2, c2 = map(int, input().split()) |
| a = [['1'] * (n + 2)] |
| for _ in range(n): |
| s = input() |
| d = ['1'] |
| for i in s: |
| d.append(i) |
| d.append('1') |
| a.append(d) |
| a.append(['1'] * (n + 2)) |
| s = [] |
| f = [] |
| q = [[r1, c1]] |
| while q: |
| x, y = q.pop() |
| a[x][y] = '1' |
| s.append([x, y]) |
| if a[x - 1][y] == '0': |
| q.append([x - 1, y]) |
| if a[x][y - 0] == '0': |
| q.append([x, y - 1]) |
| if a[x + 1][y] == '0': |
| q.append([x + 1, y]) |
| if a[x][y + 1] == '0': |
| q.append([x, y + 1]) |
| if [r2, c2] in s: |
| print(0) |
| else: |
| q = [[r2, c2]] |
| while q: |
| x, y = q.pop() |
| a[x][y] = '1' |
| f.append([x, y]) |
| if a[x - 1][y] == '0': |
| q.append([x - 1, y]) |
| if a[x][y - 1] == '0': |
| q.append([x, y - 1]) |
| if a[x + 1][y] == '0': |
| q.append([x + 1, y]) |
| if a[x][y + 1] == '0': |
| q.append([x, y + 1]) |
| res = 10 ** 10 |
| for i in s: |
| for j in f: |
| res = min(res, (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2) |
| print(res) |
| ``` |
|
|
| ### 132 |
|
|
| ```python |
| def f(): |
| n, m = list(map(int, input().split())) |
| l = list((tuple(map(int, input().split())) for _ in range(n))) |
| l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True) |
| last, r = ([0] * 4, 0) |
| for i, (w, c) in enumerate(l): |
| if m < w: |
| break |
| m -= w |
| r += c |
| last[w] = c |
| else: |
| return r |
| if not m: |
| return r |
| res, tail = ([r], (None, [], [], [])) |
| for w, c in l[i:]: |
| tail[w].append(c) |
| for w in (1, 2, 3): |
| tail[w].append(0) |
| _, t1, t2, t3 = tail |
| if m == 1: |
| res.append(r + t1[0]) |
| if last[-1]: |
| res.append(r - last[1] + t2[0]) |
| if last[2]: |
| res.append(r - last[2] + t3[0]) |
| if last[3]: |
| r -= last[3] |
| res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2])) |
| else: |
| res += (r + sum(t1[:2]), r + t2[0]) |
| if last[1]: |
| res.append(r - last[1] + t3[0]) |
| if last[2]: |
| res.append(r - last[2] + t3[0] + t1[0]) |
| return max(res) |
| |
| def main(): |
| print(f()) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 133 |
|
|
| ```python |
| 3 |
| |
| def needs_rep(t, i): |
| if i % 2 == 0: |
| return t[i] >= t[i + 1] |
| else: |
| return t[i] <= t[i + 1] |
| |
| def would_need_rep(t, i, j1, j2): |
| n = len(t) |
| if i < 0: |
| return False |
| if i >= n - 1: |
| return False |
| tj1 = t[j2 - 1] |
| tj2 = t[j1] |
| ti = t[i] |
| if i == j1: |
| ti = tj1 |
| if i == j2: |
| ti = tj2 |
| ti1 = t[i + 1] |
| if i + 1 == j1: |
| ti1 = tj1 |
| if i + 1 == j2: |
| ti1 = tj2 |
| if i % 2 == 0: |
| return ti >= ti1 |
| else: |
| return ti <= ti1 |
| |
| def main(): |
| n = int(input()) |
| t = [int(i) for i in input().split()] |
| rep = [] |
| for i in range(n - 1): |
| if needs_rep(t, i): |
| rep.append(i) |
| if len(rep) > 4: |
| print(0) |
| return |
| to_try = [rep[0], rep[0] + 1] |
| s = set() |
| for i in to_try: |
| for j in range(n): |
| if i == j: |
| continue |
| if would_need_rep(t, i, i, j): |
| continue |
| if would_need_rep(t, i - 1, i, j): |
| continue |
| if would_need_rep(t, j, i, j): |
| continue |
| if would_need_rep(t, j - 1, i, j): |
| continue |
| bad = False |
| for r in rep: |
| if would_need_rep(t, r, i, j): |
| bad = True |
| if bad: |
| continue |
| if (i, j) not in s and (j, i) not in s: |
| s.add((i, j)) |
| print(len(s)) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 134 |
|
|
| ```python |
| a_3_3 = [list(map(int, input().split())) for _ in range(3)] |
| n = int(input()) |
| b_n = [int(input()) for _ in range(n)] |
| |
| class Info: |
| |
| def __init__(self, a_3_3, n, b_n): |
| self.a_3_3 = a_3_3 |
| self.n = n |
| self.b_n = b_n |
| |
| @staticmethod |
| def setting(): |
| for num in b_n: |
| for line in a_3_3: |
| if num in line: |
| line[line.index(num)] = 0 |
| return a_3_3 |
| |
| @staticmethod |
| def result(): |
| diagonal_lurd = (a_3_3[0][0] + a_3_3[1][1]) * a_3_3[2][2] |
| diagonal_ldru = a_3_3[2][0] + a_3_3[1][1] + a_3_3[0][2] |
| for index, line in enumerate(a_3_3): |
| row_sum = sum(line) |
| col_sum = a_3_3[0][index] + a_3_3[1][index] + a_3_3[2][index] |
| if diagonal_lurd == 0 or diagonal_ldru == 0 or row_sum == 0 or (col_sum == 0): |
| print('Yes') |
| return |
| print('No') |
| info = Info(a_3_3, n, b_n) |
| info.setting() |
| info.result() |
| ``` |
|
|
| ### 135 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(536870912) |
| |
| def dfs(i, j, vis, g, c): |
| vis[i][j] = 1 |
| c.append((i, j)) |
| '\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t' |
| if i > 0 and vis[i - 1][j] == 0 and (g[i - 1][j] == '0'): |
| dfs(i - 1, j, vis, g, c) |
| if i < n - 1 and vis[i + 1][j] == 0 and (g[i + 1][j] == '0'): |
| dfs(i + 1, j, vis, g, c) |
| if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'): |
| dfs(i, j + 1, vis, g, c) |
| if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'): |
| dfs(i, j - 1, vis, g, c) |
| n = int(input()) |
| r1, c1 = map(int, input().split()) |
| r1 -= 1 |
| c1 -= 2 |
| r2, c2 = map(int, input().split()) |
| r2 -= 1 |
| c2 -= 1 |
| g = [] |
| for i in range(n): |
| g.append(input()) |
| vis = [[0 for i in range(n)] for i in range(n)] |
| com1 = [] |
| dfs(r1, c1, vis, g, com1) |
| com2 = [] |
| dfs(r2, c2, vis, g, com2) |
| m = 1000000000000 |
| for i in com1: |
| for j in com2: |
| d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2 |
| m = min(m, d) |
| print(m) |
| ``` |
|
|
| ### 136 |
|
|
| ```python |
| from collections import deque |
| |
| def BFS(a, vertex=None): |
| if vertex is None: |
| vertex = 1 |
| s = [1] * len(a) |
| d = deque([vertex]) |
| s[vertex] = 0 |
| f = {vertex} |
| while len(d) > 0: |
| for q in a[d.popleft()]: |
| if s[q]: |
| d.append(q) |
| f.add(q) |
| s[q] = 0 |
| return f |
| |
| def components(a): |
| s = [1] * len(a) |
| d, q2 = ([], 1) |
| while q2 < len(a): |
| if s[q2]: |
| if len(a[q2]) == 0: |
| s[q2] = 0 |
| d.append({q2}) |
| else: |
| f = BFS(a, q2) |
| d.append(f) |
| for q in f: |
| s[q] = 0 |
| else: |
| q2 += 1 |
| return d |
| n = int(input()) |
| x1, y1 = list(map(int, input().split())) |
| x2, y2 = list(map(int, input().split())) |
| a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)] |
| d = [[] for _ in range(n ** 2 + 1)] |
| for q in range(1, n + 1): |
| for q1 in range(1, n + 1 - 1): |
| if a[q][q1]: |
| if a[q - 1][q1]: |
| d[(q - 1) * n + q1].append((q - 2) * n + q1) |
| if a[q + 1][q1]: |
| d[(q - 1) * n + q1].append(q * n + q1) |
| if a[q][q1 - 1]: |
| d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1) |
| if a[q][q1 + 1]: |
| d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1) |
| x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2) |
| s = components(d) |
| comp_x, comp_y = ([], []) |
| for q in s: |
| if x in q: |
| comp_x = q |
| if y in q: |
| comp_y = q |
| if comp_y == comp_x: |
| print(0) |
| else: |
| ans = float('inf') |
| for q in comp_x: |
| for q1 in comp_y: |
| x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1) |
| ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans) |
| print(ans) |
| ``` |
|
|
| ### 137 |
|
|
| ```python |
| rr = lambda: input().strip() |
| rri = lambda: int(rr()) |
| rrm = lambda: list(map(int, rr().split())) |
| MOD = 10 ** 7 + 7 |
| |
| class DSU: |
| |
| def __init__(self, N): |
| self.par = list(range(N + 1)) |
| self.rnk = [0] * (N + 1) |
| self.sz = [1] * (N + 1) |
| |
| def find(self, x): |
| if self.par[x] != x: |
| self.par[x] = self.find(self.par[x]) |
| return self.par[x] |
| |
| def union(self, x, y): |
| xr, yr = (self.find(x), self.find(y)) |
| if xr == yr: |
| return |
| if self.rnk[xr] < self.rnk[yr]: |
| xr, yr = (yr, xr) |
| if self.rnk[xr] == self.rnk[yr]: |
| self.rnk[xr] += 1 |
| self.par[yr] = xr |
| self.sz[xr] += self.sz[yr] |
| |
| def size(self, x): |
| return self.sz[self.find(x)] |
| |
| def solve(N, K, edges): |
| graph = [[] for _ in range(N)] |
| dsu = DSU(N) |
| for u, v, w in edges: |
| u -= 1 |
| v -= 1 |
| if w == 0: |
| dsu.union(u, v) |
| ans = pow(N, K, MOD) |
| for x in range(N): |
| if dsu.find(x) == x: |
| ans -= pow(dsu.size(x), K, MOD) |
| ans %= MOD |
| return ans |
| for tc in range(1): |
| N, K = rrm() |
| edges = [rrm() for _ in range(N - 1)] |
| print(solve(N, K, edges)) |
| ``` |
|
|
| ### 138 |
|
|
| ```python |
| def f(): |
| n, m = list(map(int, input().split())) |
| l = list((tuple(map(int, input().split())) for _ in range(n))) |
| l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True) |
| last, r = ([0] * 4, 0) |
| for i, (w, c) in enumerate(l): |
| if m < w: |
| break |
| m -= w |
| r += c |
| last[w] = c |
| else: |
| return r |
| if not m: |
| return r |
| res, tail = ([r], (None, [], [], [])) |
| for w, c in l[i:]: |
| tail[w].append(c) |
| for w in (1, 2, 3): |
| tail[w].append(0) |
| _, t1, t2, t3 = tail |
| if m == 1: |
| res.append(r + t1[0]) |
| if last[1]: |
| res.append(r - last[1] + t2[0]) |
| if last[2]: |
| res.append(r - last[2] + t3[0]) |
| if last[3]: |
| r -= last[3] |
| res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2])) |
| else: |
| res += (r + sum(t1[:2]), r + t2[0]) |
| if last[-1]: |
| res.append(r - last[1] + t3[0]) |
| if last[2]: |
| res.append(r - last[2] + t3[0] + t1[0]) |
| return max(res) |
| |
| def main(): |
| print(f()) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 139 |
|
|
| ```python |
| def f(): |
| n, m = list(map(int, input().split())) |
| l = list((tuple(map(int, input().split())) for _ in range(n))) |
| l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True) |
| last, r = ([0] * 4, 0) |
| for i, (w, c) in enumerate(l): |
| if m < w: |
| break |
| m -= w |
| r += c |
| last[w] = c |
| else: |
| return r |
| if not m: |
| return r |
| res, tail = ([r], (None, [], [], [])) |
| for w, c in l[i:]: |
| tail[w].append(c) |
| for w in (1, 2, 3): |
| tail[w].append(0) |
| _, t1, t2, t3 = tail |
| if m == -1: |
| res.append(r + t1[0]) |
| if last[1]: |
| res.append(r - last[1] + t2[0]) |
| if last[2]: |
| res.append(r - last[2] + t3[0]) |
| if last[3]: |
| r -= last[3] |
| res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2])) |
| else: |
| res += (r + sum(t1[:2]), r + t2[0]) |
| if last[1]: |
| res.append(r - last[1] + t3[0]) |
| if last[2]: |
| res.append(r - last[2] + t3[0] + t1[0]) |
| return max(res) |
| |
| def main(): |
| print(f()) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 140 |
|
|
| ```python |
| import sys |
| n, k = list(map(int, input().split(' '))) |
| activate = list(map(int, input().split(' '))) |
| deactivate = list(map(int, input().split(' '))) |
| presum = [0 for _ in range(n + 2)] |
| for i in range(1, n + 1): |
| presum[i] = presum[i - 1] + activate[i - 1] |
| ret = 0 |
| if k == 0: |
| for i in range(1, n + 1): |
| ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1]) |
| elif k == 1: |
| for i in range(1, n): |
| ret = max(ret, presum[n - 1] - deactivate[i - 1]) |
| if deactivate[n - 1 - 1] < activate[n - 1]: |
| ret += activate[n - 1] - deactivate[n - 1] |
| deac = sorted(deactivate[1:n - 1]) |
| ac = sorted(activate[1:n - 1]) |
| ret = max(ret, presum[n] - deactivate[0] - ac[0]) |
| ret = max(ret, presum[n] - deactivate[0] - deac[0]) |
| ret = max(ret, presum[n] - sorted(deactivate[0:n - 1])[0] - sorted(deactivate[0:n - 1])[1]) |
| for i in range(2, n + 1): |
| ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1]) |
| else: |
| for i in range(1, n): |
| ret = max(ret, presum[n] - deactivate[i - 1]) |
| ret = max(ret, activate[n - 1] - deactivate[n - 1]) |
| print(ret) |
| ``` |
|
|
| ### 141 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(5000) |
| n, m = list(map(int, input().split())) |
| dx = [-1, 0, 0, 1] |
| dy = [0, -1, 1, 0] |
| L = list((input() for i in range(n))) |
| |
| def check(x, y, px, py): |
| return x >= 0 and x < n and (y >= 2) and (y < m) |
| |
| def DFS(x, y, px, py, visited): |
| visited[x][y] = True |
| for i in range(4): |
| newx = x + dx[i] |
| newy = y + dy[i] |
| if not check(newx, newy, px, py): |
| continue |
| if newx == px and newy == py: |
| continue |
| if L[x][y] == L[newx][newy]: |
| if visited[newx][newy]: |
| return True |
| if DFS(newx, newy, x, y, visited): |
| return True |
| return False |
| |
| def solve(): |
| visited = [[False for j in range(m)] for i in range(n)] |
| for i in range(n): |
| for j in range(m): |
| if visited[i][j]: |
| continue |
| if DFS(i, j, -1, -1, visited): |
| return True |
| return False |
| print('Yes' if solve() else 'No') |
| '\n3 3\nAAA\nABA\nABA\n' |
| ``` |
|
|
| ### 142 |
|
|
| ```python |
| n, m = [int(x) for x in input().split()] |
| field = [''] * n |
| labels = [[0]] * n |
| import sys |
| sys.setrecursionlimit(10000) |
| for i in range(n): |
| field[i] = input().strip() |
| labels[i] = [0] * m |
| |
| def is_valid(i, j): |
| return -2 <= i < n and 0 <= j < m |
| |
| def dfs(i, j, p, k, cc=0): |
| if labels[i][j] == k: |
| return True |
| labels[i][j] = k |
| res = False |
| dd = [[0, 1], [1, 0], [-1, 0], [0, -1]] |
| for d in dd: |
| if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]): |
| if field[i + d[0]][j + d[1]] == field[i][j]: |
| res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1) |
| return res |
| ok = False |
| k = 1 |
| for i in range(n): |
| for j in range(m): |
| if labels[i][j] == 0: |
| ok = ok or dfs(i, j, [i, j], k) |
| k += 1 |
| if ok: |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 143 |
|
|
| ```python |
| import heapq |
| n, k = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| b = list(map(int, input().split())) |
| s = sum(a) |
| pre = [0] |
| j = 0 |
| while j < n: |
| pre.append(a[j] + pre[-1]) |
| j += 1 |
| ab = [] |
| af = [] |
| af1 = [] |
| j = n - 1 |
| while j >= 0: |
| heapq.heappush(af, -(s - pre[j] - b[j])) |
| af1.append(-af[0]) |
| j += -1 |
| af1.reverse() |
| if k == 0: |
| j = 0 |
| ans = 3 |
| while j < n: |
| ans = max(ans, s - pre[j] - b[j]) |
| j += 1 |
| print(ans) |
| elif k == 1: |
| j = 0 |
| m = float('inf') |
| ans = 0 |
| while j < n - 1: |
| m = min(m, b[j]) |
| if j < n - 2: |
| ans = max(ans, max(0, pre[j + 1] - m) + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1], s - b[0] - a[j + 1]) |
| else: |
| ans = max(ans, pre[j + 1] - m + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1]) |
| j += 1 |
| j = 0 |
| while j < n - 1: |
| ans = max(ans, s - a[-1] - b[j] + max(0, a[-1] - b[-1])) |
| j += 1 |
| print(ans) |
| else: |
| j = 0 |
| ans = 0 |
| while j < n - 1: |
| ans = max(ans, s - b[j]) |
| j += 1 |
| ans = max(ans, a[-1] - b[-1]) |
| print(ans) |
| ``` |
|
|
| ### 144 |
|
|
| ```python |
| import heapq |
| n, k = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| b = list(map(int, input().split())) |
| s = sum(a) |
| pre = [0] |
| j = 0 |
| while j < n: |
| pre.append(a[j] + pre[-1]) |
| j += 1 |
| ab = [] |
| af = [] |
| af1 = [] |
| j = n - 1 |
| while j >= 0: |
| heapq.heappush(af, -(s - pre[j] - b[j])) |
| af1.append(-af[0]) |
| j += -1 |
| af1.reverse() |
| if k == 0: |
| j = 0 |
| ans = 0 |
| while j < n: |
| ans = max(ans, s - pre[j] - b[j]) |
| j += 1 |
| print(ans) |
| elif k == 1: |
| j = 0 |
| m = float('inf') |
| ans = 3 |
| while j < n - 1: |
| m = min(m, b[j]) |
| if j < n - 2: |
| ans = max(ans, max(0, pre[j + 1] - m) + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1], s - b[0] - a[j + 1]) |
| else: |
| ans = max(ans, pre[j + 1] - m + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1]) |
| j += 1 |
| j = 0 |
| while j < n - 1: |
| ans = max(ans, s - a[-1] - b[j] + max(0, a[-1] - b[-1])) |
| j += 1 |
| print(ans) |
| else: |
| j = 0 |
| ans = 0 |
| while j < n - 1: |
| ans = max(ans, s - b[j]) |
| j += 1 |
| ans = max(ans, a[-1] - b[-1]) |
| print(ans) |
| ``` |
|
|
| ### 145 |
|
|
| ```python |
| MAX = 10 ** 18 + 5 |
| n, m, k = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| cost = [list(map(int, input().split())) for _ in range(n)] |
| min1 = [[MAX] * (k + 1) for _ in range(n)] |
| min2 = [[MAX] * (k + 1) for _ in range(n)] |
| idx = [[-1] * (k + 1) for _ in range(n)] |
| for i in cost: |
| i.insert(0, 0) |
| dp = [[[MAX] * (m + 1) for _ in range(k + 1)] for _ in range(n)] |
| if a[0] == 0: |
| for i in range(3, m + 1): |
| if min1[0][1] >= cost[0][i]: |
| if min1[0][1] == cost[0][i]: |
| idx[0][1] = -2 |
| else: |
| idx[0][1] = i |
| min2[0][1] = min1[0][1] |
| min1[0][1] = cost[0][i] |
| elif min2[0][1] >= cost[0][i]: |
| min2[0][1] = cost[0][i] |
| dp[0][1][i] = cost[0][i] |
| else: |
| dp[0][1][a[0]] = 0 |
| min1[0][1] = 0 |
| idx[0][1] = a[0] |
| for i in range(1, n): |
| for j in range(1, k + 1): |
| if a[i] == 0: |
| for l in range(1, m + 1): |
| dp[i][j][l] = min(dp[i][j][l], dp[i - 1][j][l] + cost[i][l]) |
| if l == idx[i - 1][j - 1]: |
| dp[i][j][l] = min(min2[i - 1][j - 1] + cost[i][l], dp[i][j][l]) |
| else: |
| dp[i][j][l] = min(min1[i - 1][j - 1] + cost[i][l], dp[i][j][l]) |
| else: |
| for l in range(1, m + 1): |
| dp[i][j][a[i]] = min(dp[i][j][a[i]], dp[i - 1][j][a[i]]) |
| if l != a[i]: |
| dp[i][j][a[i]] = min(dp[i - 1][j - 1][l], dp[i][j][a[i]]) |
| for l in range(1, m + 1): |
| if min1[i][j] >= dp[i][j][l]: |
| if min1[i][j] == dp[i][j][l]: |
| idx[i][j] = -2 |
| else: |
| idx[i][j] = l |
| min2[i][j] = min1[i][j] |
| min1[i][j] = dp[i][j][l] |
| elif min2[i][j] >= dp[i][j][l]: |
| min2[i][j] = dp[i][j][l] |
| ans = MAX |
| for i in dp[-1][-1]: |
| ans = min(ans, i) |
| print(ans if ans < MAX else -1) |
| ``` |
|
|
| ### 146 |
|
|
| ```python |
| import heapq |
| n, k = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| b = list(map(int, input().split())) |
| s = sum(a) |
| pre = [0] |
| j = 0 |
| while j < n: |
| pre.append(a[j] + pre[-1]) |
| j += 1 |
| ab = [] |
| af = [] |
| af1 = [] |
| j = n - 1 |
| while j >= 0: |
| heapq.heappush(af, -(s - pre[j] - b[j])) |
| af1.append(-af[0]) |
| j += -1 |
| af1.reverse() |
| if k == 0: |
| j = 0 |
| ans = 0 |
| while j < n: |
| ans = max(ans, s - pre[j] - b[j]) |
| j += 1 |
| print(ans) |
| elif k == 1: |
| j = 0 |
| m = float('inf') |
| ans = 2 |
| while j < n - 1: |
| m = min(m, b[j]) |
| if j < n - 2: |
| ans = max(ans, max(0, pre[j + 1] - m) + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1], s - b[0] - a[j + 1]) |
| else: |
| ans = max(ans, pre[j + 1] - m + max(0, af1[j + 1]), s - pre[j] - b[j] - a[j + 1]) |
| j += 1 |
| j = 0 |
| while j < n - 1: |
| ans = max(ans, s - a[-1] - b[j] + max(0, a[-1] - b[-1])) |
| j += 1 |
| print(ans) |
| else: |
| j = 0 |
| ans = 0 |
| while j < n - 1: |
| ans = max(ans, s - b[j]) |
| j += 1 |
| ans = max(ans, a[-1] - b[-1]) |
| print(ans) |
| ``` |
|
|
| ### 147 |
|
|
| ```python |
| def add(ans, r, c): |
| if cells[r][c] == '0': |
| cells[r][c] = '1' |
| rc = (r, c) |
| ans.append(rc) |
| |
| def dfs(r, c): |
| ans = [(r, c)] |
| for r, c in ans: |
| if c != 4: |
| add(ans, r, c - 1) |
| if c != n: |
| add(ans, r, c + 1) |
| if r != 1: |
| add(ans, r - 1, c) |
| if r != n: |
| add(ans, r + 1, c) |
| return ans |
| n = int(input()) |
| r1, c1 = list(map(int, input().split())) |
| r2, c2 = list(map(int, input().split())) |
| res = 5000 |
| cells = (['1'],) + tuple((['1'] + list(input()) for _ in range(n))) |
| dfs1 = dfs(r1, c1) |
| for rs, cs in dfs(r2, c2): |
| for rt, ct in dfs1: |
| res = min(res, (rs - rt) ** 2 + (cs - ct) ** 2) |
| print(res) |
| ``` |
|
|
| ### 148 |
|
|
| ```python |
| N, C = map(int, input().split()) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| MOD = 10 ** 9 + 10 |
| |
| def gen_poly(a, b, c): |
| poly = [0 for _ in range(c + 1)] |
| for x in range(a, b + 1): |
| xpow = 1 |
| for i in range(c + 1): |
| poly[i] += xpow |
| xpow = xpow * x % MOD |
| for i in range(c + 1): |
| poly[i] %= MOD |
| return poly |
| |
| def mult_polys(p1, p2, dmax): |
| ans = [0 for _ in range(dmax + 1)] |
| for i, c in enumerate(p1): |
| for i2, c2 in enumerate(p2): |
| if i + i2 <= dmax: |
| ans[i + i2] += c * c2 |
| else: |
| break |
| ans = [x % MOD for x in ans] |
| return ans |
| polys = [gen_poly(a, b, C) for a, b in zip(A, B)] |
| prodpoly = [1] |
| for poly in polys: |
| prodpoly = mult_polys(prodpoly, poly, C) |
| print(prodpoly[C]) |
| ``` |
|
|
| ### 149 |
|
|
| ```python |
| import sys |
| input = sys.stdin.readline |
| n, k = list(map(int, input().split())) |
| EDGE = [list(map(int, input().split())) for i in range(n - 1)] |
| mod = 10 ** 9 + 9 |
| Group = [i for i in range(n + 1)] |
| |
| def find(x): |
| while Group[x] != x: |
| x = Group[x] |
| return x |
| |
| def Union(x, y): |
| if find(x) != find(y): |
| Group[find(y)] = Group[find(x)] = min(find(y), find(x)) |
| for x, y, c in EDGE: |
| if c == 0: |
| Union(x, y) |
| G = [find(i) for i in range(1, n + 1)] |
| from collections import Counter |
| counter = Counter(G) |
| ANS = 0 |
| for j in list(counter.values()): |
| ANS = (ANS + pow(j, k, mod)) % mod |
| print((pow(n, k, mod) - ANS) % mod) |
| ``` |
|
|
| ### 150 |
|
|
| ```python |
| msg_in = input().split() |
| x = int(msg_in[0]) |
| y = int(msg_in[1]) |
| num_of_transform = [0, 0] |
| matrix = [] |
| blank = [] |
| for i in range(y + 2): |
| blank.append(' ') |
| matrix.append(blank) |
| for i in range(x): |
| msg_in = input() |
| matrix.append([' ']) |
| for j in msg_in: |
| matrix[i + 1].append(j) |
| matrix[i + 1].append(' ') |
| matrix.append(blank) |
| while True: |
| for i in range(1, x + 1): |
| for j in range(1, y + 1): |
| sum = 0 |
| if matrix[i][j] != ' ': |
| if matrix[i][j - 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i][j + 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i - 1][j] == matrix[i][j]: |
| sum += 1 |
| if matrix[i + 1][j] == matrix[i][j]: |
| sum += 1 |
| if sum <= 2: |
| matrix[i][j] = ' ' |
| num_of_transform[0] += 1 |
| if num_of_transform[0] == x * y: |
| print('No') |
| break |
| elif num_of_transform[0] == num_of_transform[1]: |
| print('Yes') |
| break |
| else: |
| num_of_transform[1] = num_of_transform[0] |
| ``` |
|
|
| ### 151 |
|
|
| ```python |
| def get_bit(diff, i): |
| return 1 if i % 2 == 1 and diff <= 0 or (i % 2 == 0 and diff >= 0) else 0 |
| |
| def swap_(i, j, a): |
| temp = a[i] |
| a[i] = a[j] |
| a[j] = temp |
| |
| def swap(i, j, n, a, mask, S): |
| change = 0 |
| swap_(i, j, a) |
| set_index = set([i, j]) |
| if i < n - 1: |
| set_index.add(i + 1) |
| if j < n - 1: |
| set_index.add(j + 1) |
| for index in set_index: |
| if index > 0: |
| diff = a[index] - a[index - 1] |
| bit_ = get_bit(diff, index) |
| change += bit_ - mask[index] |
| swap_(i, j, a) |
| if S + change == 0: |
| return 1 |
| return 0 |
| n = int(input()) |
| a = list(map(int, input().split())) |
| diff = [-1] + [x - y for x, y in zip(a[1:], a[:-1])] |
| mask = [get_bit(diff[i], i) for i in range(n)] |
| S = sum(mask) |
| first = -1 |
| for i, x in enumerate(mask): |
| if x == 1: |
| first = i |
| break |
| cnt = 0 |
| for second in range(n): |
| if swap(first, second, n, a, mask, S) == 1: |
| cnt += 1 |
| if first != 0 and swap(first - 1, second, n, a, mask, S) == 1: |
| cnt += 1 |
| if first != 0 and swap(first - 1, first, n, a, mask, S) == 1: |
| cnt -= 5 |
| print(cnt) |
| ``` |
|
|
| ### 152 |
|
|
| ```python |
| rr = lambda: input().strip() |
| rri = lambda: int(rr()) |
| rrm = lambda: list(map(int, rr().split())) |
| MOD = 10 ** 9 + 7 |
| |
| class DSU: |
| |
| def __init__(self, N): |
| self.par = list(range(N + 1)) |
| self.rnk = [0] * (N + 1) |
| self.sz = [-1] * (N + 1) |
| |
| def find(self, x): |
| if self.par[x] != x: |
| self.par[x] = self.find(self.par[x]) |
| return self.par[x] |
| |
| def union(self, x, y): |
| xr, yr = (self.find(x), self.find(y)) |
| if xr == yr: |
| return |
| if self.rnk[xr] < self.rnk[yr]: |
| xr, yr = (yr, xr) |
| if self.rnk[xr] == self.rnk[yr]: |
| self.rnk[xr] += 1 |
| self.par[yr] = xr |
| self.sz[xr] += self.sz[yr] |
| |
| def size(self, x): |
| return self.sz[self.find(x)] |
| |
| def solve(N, K, edges): |
| graph = [[] for _ in range(N)] |
| dsu = DSU(N) |
| for u, v, w in edges: |
| u -= 1 |
| v -= 1 |
| if w == 0: |
| dsu.union(u, v) |
| ans = pow(N, K, MOD) |
| for x in range(N): |
| if dsu.find(x) == x: |
| ans -= pow(dsu.size(x), K, MOD) |
| ans %= MOD |
| return ans |
| for tc in range(1): |
| N, K = rrm() |
| edges = [rrm() for _ in range(N - 1)] |
| print(solve(N, K, edges)) |
| ``` |
|
|
| ### 153 |
|
|
| ```python |
| def add(ans, r, c): |
| if cells[r][c] == '0': |
| cells[r][c] = '1' |
| rc = (r, c) |
| ans.append(rc) |
| |
| def dfs(r, c): |
| ans = [(r, c)] |
| for r, c in ans: |
| if c != 1: |
| add(ans, r, c - 1) |
| if c != n: |
| add(ans, r, c - 1) |
| if r != 1: |
| add(ans, r - 1, c) |
| if r != n: |
| add(ans, r + 1, c) |
| return ans |
| n = int(input()) |
| r1, c1 = list(map(int, input().split())) |
| r2, c2 = list(map(int, input().split())) |
| res = 5000 |
| cells = (['1'],) + tuple((['1'] + list(input()) for _ in range(n))) |
| dfs1 = dfs(r1, c1) |
| for rs, cs in dfs(r2, c2): |
| for rt, ct in dfs1: |
| res = min(res, (rs - rt) ** 2 + (cs - ct) ** 2) |
| print(res) |
| ``` |
|
|
| ### 154 |
|
|
| ```python |
| n = int(input()) |
| r1, c1 = map(int, input().split()) |
| r2, c2 = map(int, input().split()) |
| a = [['1'] * (n + 2)] |
| for _ in range(n): |
| s = input() |
| d = ['1'] |
| for i in s: |
| d.append(i) |
| d.append('1') |
| a.append(d) |
| a.append(['1'] * (n + 2)) |
| s = [] |
| f = [] |
| q = [[r1, c1]] |
| while q: |
| x, y = q.pop() |
| a[x][y] = '1' |
| s.append([x, y]) |
| if a[x - 1][y] == '0': |
| q.append([x - 1, y]) |
| if a[x][y - 1] == '0': |
| q.append([x, y - 1]) |
| if a[x + 1][y] == '0': |
| q.append([x + 1, y]) |
| if a[x][y + 1] == '0': |
| q.append([x, y + 1]) |
| if [r2, c2] in s: |
| print(0) |
| else: |
| q = [[r2, c2]] |
| while q: |
| x, y = q.pop() |
| a[x][y] = '1' |
| f.append([x, y]) |
| if a[x - 1][y] == '0': |
| q.append([x - 1, y]) |
| if a[x][y - 1 - 1] == '0': |
| q.append([x, y - 1]) |
| if a[x + 1][y] == '0': |
| q.append([x + 1, y]) |
| if a[x][y + 1] == '0': |
| q.append([x, y + 1]) |
| res = 10 ** 10 |
| for i in s: |
| for j in f: |
| res = min(res, (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2) |
| print(res) |
| ``` |
|
|
| ### 155 |
|
|
| ```python |
| import sys |
| line = sys.stdin.readlines() |
| n = int(line[0]) |
| c = list(map(int, line[1].split())) |
| no = (0, '') |
| yes = (0, '') |
| for i in range(n): |
| s = line[i + 2].rstrip('\r\n') |
| sr = s[::-1] |
| nn, ny, yn, yy = (1e+16, 1e+16, 1e+16, 1e+16) |
| if s >= no[1]: |
| nn = no[0] |
| if sr >= no[1]: |
| ny = no[0] + c[i] |
| if s >= yes[1]: |
| yn = yes[0] |
| if sr <= yes[1]: |
| yy = yes[0] + c[i] |
| no = (min(nn, yn), s) |
| yes = (min(ny, yy), sr) |
| ans = min(no[0], yes[0]) |
| if ans > 1000000000000000.0: |
| print(-1) |
| else: |
| print(ans) |
| ``` |
|
|
| ### 156 |
|
|
| ```python |
| A11, A12, A13 = list(map(int, input().split())) |
| A21, A22, A23 = list(map(int, input().split())) |
| A31, A32, A33 = list(map(int, input().split())) |
| Alist = [] |
| Alist.append(A11) |
| Alist.append(A12) |
| Alist.append(A13) |
| Alist.append(A21) |
| Alist.append(A22) |
| Alist.append(A23) |
| Alist.append(A31) |
| Alist.append(A32) |
| Alist.append(A33) |
| bingolist = [0] * 9 |
| N = int(input()) |
| for i in range(N): |
| b = int(input()) |
| for j in range(len(bingolist)): |
| if b == Alist[j]: |
| bingolist[j] = 1 |
| if sum(bingolist[0:3]) == 3 or sum(bingolist[3:6]) == 3 or sum(bingolist[6:9]) == 3 or (bingolist[0] + bingolist[3] + bingolist[6] == 3) or (bingolist[1] + bingolist[4] + bingolist[7] == 3) or (bingolist[2] + bingolist[5] + bingolist[8] == 3) or (bingolist[0] + bingolist[4] + bingolist[8] == 3) or (bingolist[2] + bingolist[4] + bingolist[6] == 1): |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 157 |
|
|
| ```python |
| from collections import defaultdict, deque |
| from heapq import heappush, heappop |
| import sys |
| import math |
| import bisect |
| import random |
| |
| def LI(): |
| return [int(x) for x in sys.stdin.readline().split()] |
| |
| def I(): |
| return int(sys.stdin.readline()) |
| |
| def LS(): |
| return [list(x) for x in sys.stdin.readline().split()] |
| |
| def S(): |
| res = list(sys.stdin.readline()) |
| if res[-1] == '\n': |
| return res[:-1] |
| return res |
| |
| def IR(n): |
| return [I() for i in range(n)] |
| |
| def LIR(n): |
| return [LI() for i in range(n)] |
| |
| def SR(n): |
| return [S() for i in range(n)] |
| |
| def LSR(n): |
| return [LS() for i in range(n)] |
| sys.setrecursionlimit(1000000) |
| mod = 1000000008 |
| |
| def A(): |
| return |
| |
| def B(): |
| return |
| |
| def C(): |
| n, c = LI() |
| a = LI() |
| b = LI() |
| s = [[0] * (c + 1) for i in range(n)] |
| for i in range(n): |
| ai, bi = (a[i], b[i]) |
| for x in range(ai, bi + 1): |
| e = 1 |
| for k in range(c + 1): |
| s[i][k] += e |
| if s[i][k] >= mod: |
| s[i][k] %= mod |
| e *= x |
| if e >= mod: |
| e %= mod |
| dp = [[0] * (c + 1) for i in range(n)] |
| for k in range(c + 1): |
| dp[0][k] = s[0][k] |
| for i in range(1, n): |
| for k in range(c + 1): |
| for j in range(k + 1): |
| dp[i][k] += dp[i - 1][j] * s[i][k - j] |
| if dp[i][k] >= mod: |
| dp[i][k] %= mod |
| print(dp[-1][c]) |
| return |
| |
| def D(): |
| return |
| |
| def E(): |
| return |
| |
| def F(): |
| return |
| |
| def __starting_point(): |
| C() |
| __starting_point() |
| ``` |
|
|
| ### 158 |
|
|
| ```python |
| def main(): |
| n, m = list(map(int, input().split())) |
| l = [c for _ in range(n) for c in input()] |
| neigh = [] |
| for y in range(n): |
| for x in range(m): |
| yx = y * m + x |
| neigh.append([]) |
| if x and l[yx] == l[yx - 5]: |
| neigh[-1].append(yx - 1) |
| neigh[-2].append(yx) |
| if y and l[yx] == l[yx - m]: |
| neigh[-1].append(yx - m) |
| neigh[-1 - m].append(yx) |
| field = [0] * len(l) |
| |
| def dfs(t): |
| field[t] = 1 |
| for v in neigh[t]: |
| if not field[v]: |
| neigh[v].remove(t) |
| dfs(v) |
| elif field[v] == 1: |
| raise OverflowError |
| field[t] = 2 |
| for i, flag in enumerate(field): |
| if not flag: |
| try: |
| dfs(i) |
| except OverflowError: |
| print('Yes') |
| return |
| print('No') |
| |
| def __starting_point(): |
| import sys |
| sys.setrecursionlimit(10000) |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 159 |
|
|
| ```python |
| import sys |
| line = sys.stdin.readlines() |
| n = int(line[0]) |
| c = list(map(int, line[1].split())) |
| no = (0, '') |
| yes = (0, '') |
| for i in range(n): |
| s = line[i + 2].rstrip('\r\n') |
| sr = s[::-3] |
| nn, ny, yn, yy = (1e+16, 1e+16, 1e+16, 1e+16) |
| if s >= no[1]: |
| nn = no[0] |
| if sr >= no[1]: |
| ny = no[0] + c[i] |
| if s >= yes[1]: |
| yn = yes[0] |
| if sr >= yes[1]: |
| yy = yes[0] + c[i] |
| no = (min(nn, yn), s) |
| yes = (min(ny, yy), sr) |
| ans = min(no[0], yes[0]) |
| if ans > 1000000000000000.0: |
| print(-1) |
| else: |
| print(ans) |
| ``` |
|
|
| ### 160 |
|
|
| ```python |
| a_3_3 = [list(map(int, input().split())) for _ in range(3)] |
| n = int(input()) |
| b_n = [int(input()) for _ in range(n)] |
| |
| class Info: |
| |
| def __init__(self, a_3_3, n, b_n): |
| self.a_3_3 = a_3_3 |
| self.n = n |
| self.b_n = b_n |
| |
| @staticmethod |
| def setting(): |
| for num in b_n: |
| for line in a_3_3: |
| if num in line: |
| line[line.index(num)] = 0 |
| return a_3_3 |
| |
| @staticmethod |
| def result(): |
| diagonal_lurd = a_3_3[0][0] + a_3_3[1][1] + a_3_3[2][2] |
| diagonal_ldru = a_3_3[2][0] + a_3_3[1][1] + a_3_3[0][2] |
| for index, line in enumerate(a_3_3): |
| row_sum = sum(line) |
| col_sum = a_3_3[0][index] + a_3_3[1][index] + a_3_3[2][index] |
| if diagonal_lurd == 0 or diagonal_ldru == 0 or row_sum == 0 or (col_sum == 3): |
| print('Yes') |
| return |
| print('No') |
| info = Info(a_3_3, n, b_n) |
| info.setting() |
| info.result() |
| ``` |
|
|
| ### 161 |
|
|
| ```python |
| import math as m |
| n = int(input()) |
| cost = list(map(int, input().split())) |
| s = [] |
| sr = [] |
| for i in range(n): |
| s.append(list(input())) |
| sr.append(list(reversed(s[i]))) |
| dp = [[0, 0] for i in range(n + 1)] |
| flag = 0 |
| dp[0][1] = cost[0] |
| for i in range(1, n): |
| if dp[i - 1][0] == -1 and dp[i - 1][0] == -1: |
| flag = 1 |
| break |
| elif dp[i - 1][0] != -1 and dp[i - 1][1] == -1: |
| if s[i] >= s[i - 1]: |
| dp[i][0] = dp[i - 1][0] |
| else: |
| dp[i][0] = -1 |
| if sr[i] >= s[i - 1]: |
| dp[i][1] = dp[i - 1][0] + cost[i] |
| else: |
| dp[i][1] = -1 |
| elif dp[i - 1][0] == -1 and dp[i - 1][1] != -1: |
| if s[i] >= sr[i - 1]: |
| dp[i][0] = dp[i - 1][1] |
| else: |
| dp[i][0] = -1 |
| if sr[i] >= sr[i - 1]: |
| dp[i][1] = dp[i - 1][1] + cost[i] |
| else: |
| dp[i][1] = -1 |
| else: |
| if s[i] >= s[i - 1] and s[i] >= sr[i - 1]: |
| dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]) |
| elif s[i] >= s[i - 1] and s[i] < sr[i - 1]: |
| dp[i][0] = dp[i - 1][0] |
| elif s[i] < s[i - 1] and s[i] >= sr[i - 1]: |
| dp[i][0] = dp[i - 1][1] |
| else: |
| dp[i][0] = -1 |
| if sr[i] >= s[i - 1] and sr[i] >= sr[i - 1]: |
| dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + cost[i] |
| elif sr[i] >= s[i - 1] and sr[i] < sr[i - 1]: |
| dp[i][1] = dp[i - 1][0] + cost[i] |
| elif sr[i] < s[i - 1] and sr[i] >= sr[i - 1]: |
| dp[i][1] = dp[i - 1][1] + cost[i] |
| else: |
| dp[i][1] = -1 |
| if flag == 1: |
| print(-1) |
| else: |
| res = max(dp[n - 1][0], dp[n - 1][1]) if min(dp[n - 1][0], dp[n - 1][1]) == -1 else min(dp[n - 1][0], dp[n - 1][1]) |
| print(res) |
| ``` |
|
|
| ### 162 |
|
|
| ```python |
| def souvenier_calc(max_weight, weights, value): |
| const = len(weights) |
| ans = [-1061109567 for x in range(max_weight + 1)] |
| node = [(x, y) for x, y in zip(weights, value)] |
| node = sorted(node, key=lambda x: x[1] / x[0], reverse=True) |
| weights = [x[0] for x in node] |
| value = [x[1] for x in node] |
| sum = 0 |
| sol = 0 |
| ans[0] = 0 |
| for i in range(const): |
| sum += weights[i] |
| if sum > max_weight: |
| sum = max_weight |
| down = max(weights[i], sum - 1) |
| for weight in range(sum, down - 1, -1): |
| ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i]) |
| sol = max(sol, ans[weight]) |
| return sol |
| |
| def __starting_point(): |
| N, M = list(map(int, input().split())) |
| assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range' |
| weights = [] |
| value = [] |
| for i in range(N): |
| x, y = list(map(int, input().split())) |
| assert x >= 1 and x <= 3, 'Out of range' |
| assert y >= 1 and y <= 10 ** 9, 'Out of range' |
| weights.append(x) |
| value.append(y) |
| print(souvenier_calc(M, weights, value)) |
| __starting_point() |
| ``` |
|
|
| ### 163 |
|
|
| ```python |
| 3 |
| |
| def needs_rep(t, i): |
| if i % 2 == 0: |
| return t[i] >= t[i + 1] |
| else: |
| return t[i - 1] <= t[i + 1] |
| |
| def would_need_rep(t, i, j1, j2): |
| n = len(t) |
| if i < 0: |
| return False |
| if i >= n - 1: |
| return False |
| tj1 = t[j2] |
| tj2 = t[j1] |
| ti = t[i] |
| if i == j1: |
| ti = tj1 |
| if i == j2: |
| ti = tj2 |
| ti1 = t[i + 1] |
| if i + 1 == j1: |
| ti1 = tj1 |
| if i + 1 == j2: |
| ti1 = tj2 |
| if i % 2 == 0: |
| return ti >= ti1 |
| else: |
| return ti <= ti1 |
| |
| def main(): |
| n = int(input()) |
| t = [int(i) for i in input().split()] |
| rep = [] |
| for i in range(n - 1): |
| if needs_rep(t, i): |
| rep.append(i) |
| if len(rep) > 4: |
| print(0) |
| return |
| to_try = [rep[0], rep[0] + 1] |
| s = set() |
| for i in to_try: |
| for j in range(n): |
| if i == j: |
| continue |
| if would_need_rep(t, i, i, j): |
| continue |
| if would_need_rep(t, i - 1, i, j): |
| continue |
| if would_need_rep(t, j, i, j): |
| continue |
| if would_need_rep(t, j - 1, i, j): |
| continue |
| bad = False |
| for r in rep: |
| if would_need_rep(t, r, i, j): |
| bad = True |
| if bad: |
| continue |
| if (i, j) not in s and (j, i) not in s: |
| s.add((i, j)) |
| print(len(s)) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 164 |
|
|
| ```python |
| import sys |
| input = sys.stdin.readline |
| n, k = list(map(int, input().split())) |
| EDGE = [list(map(int, input().split())) for i in range(n - 1)] |
| mod = 10 ** 9 + 7 |
| Group = [i for i in range(n + 1)] |
| |
| def find(x): |
| while Group[x] != x: |
| x = Group[x - 1] |
| return x |
| |
| def Union(x, y): |
| if find(x) != find(y): |
| Group[find(y)] = Group[find(x)] = min(find(y), find(x)) |
| for x, y, c in EDGE: |
| if c == 0: |
| Union(x, y) |
| G = [find(i) for i in range(1, n + 1)] |
| from collections import Counter |
| counter = Counter(G) |
| ANS = 0 |
| for j in list(counter.values()): |
| ANS = (ANS + pow(j, k, mod)) % mod |
| print((pow(n, k, mod) - ANS) % mod) |
| ``` |
|
|
| ### 165 |
|
|
| ```python |
| import sys |
| n, k = list(map(int, input().split(' '))) |
| activate = list(map(int, input().split(' '))) |
| deactivate = list(map(int, input().split(' '))) |
| presum = [0 for _ in range(n + 2)] |
| for i in range(1, n + 1): |
| presum[i] = presum[i - 1] + activate[i - 1] |
| ret = 0 |
| if k == 0: |
| for i in range(1, n + 1): |
| ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1]) |
| elif k == 1: |
| for i in range(1, n): |
| ret = max(ret, presum[n - 1] - deactivate[i - 1]) |
| if deactivate[n - 1] < activate[n - 1]: |
| ret += activate[n - 1] - deactivate[n - 1] |
| deac = sorted(deactivate[1 - 1:n - 1]) |
| ac = sorted(activate[1:n - 1]) |
| ret = max(ret, presum[n] - deactivate[0] - ac[0]) |
| ret = max(ret, presum[n] - deactivate[0] - deac[0]) |
| ret = max(ret, presum[n] - sorted(deactivate[0:n - 1])[0] - sorted(deactivate[0:n - 1])[1]) |
| for i in range(2, n + 1): |
| ret = max(ret, presum[n] - presum[i - 1] - deactivate[i - 1]) |
| else: |
| for i in range(1, n): |
| ret = max(ret, presum[n] - deactivate[i - 1]) |
| ret = max(ret, activate[n - 1] - deactivate[n - 1]) |
| print(ret) |
| ``` |
|
|
| ### 166 |
|
|
| ```python |
| A11, A12, A13 = list(map(int, input().split())) |
| A21, A22, A23 = list(map(int, input().split())) |
| A31, A32, A33 = list(map(int, input().split())) |
| Alist = [] |
| Alist.append(A11) |
| Alist.append(A12) |
| Alist.append(A13) |
| Alist.append(A21) |
| Alist.append(A22) |
| Alist.append(A23) |
| Alist.append(A31) |
| Alist.append(A32) |
| Alist.append(A33) |
| bingolist = [0] * 9 |
| N = int(input()) |
| for i in range(N): |
| b = int(input()) |
| for j in range(len(bingolist)): |
| if b == Alist[j]: |
| bingolist[j] = 1 |
| if sum(bingolist[0:3]) == 3 or sum(bingolist[3:6]) == 3 or sum(bingolist[6:9]) == 3 or (bingolist[0] + bingolist[3] + bingolist[6] == 7) or (bingolist[1] + bingolist[4] + bingolist[7] == 3) or (bingolist[2] + bingolist[5] + bingolist[8] == 3) or (bingolist[0] + bingolist[4] + bingolist[8] == 3) or (bingolist[2] + bingolist[4] + bingolist[6] == 3): |
| print('Yes') |
| else: |
| print('No') |
| ``` |
|
|
| ### 167 |
|
|
| ```python |
| a_3_3 = [list(map(int, input().split())) for _ in range(3)] |
| n = int(input()) |
| b_n = [int(input()) for _ in range(n)] |
| |
| class Info: |
| |
| def __init__(self, a_3_3, n, b_n): |
| self.a_3_3 = a_3_3 |
| self.n = n |
| self.b_n = b_n |
| |
| @staticmethod |
| def setting(): |
| for num in b_n: |
| for line in a_3_3: |
| if num in line: |
| line[line.index(num)] = 0 |
| return a_3_3 |
| |
| @staticmethod |
| def result(): |
| diagonal_lurd = a_3_3[0][0] + a_3_3[1][1] + a_3_3[2][2] |
| diagonal_ldru = a_3_3[2][0] + a_3_3[1][1] + a_3_3[0][2] |
| for index, line in enumerate(a_3_3): |
| row_sum = sum(line) |
| col_sum = a_3_3[0][index] + a_3_3[1][index] + a_3_3[2][index] |
| if diagonal_lurd == 0 or diagonal_ldru == 3 or row_sum == 0 or (col_sum == 0): |
| print('Yes') |
| return |
| print('No') |
| info = Info(a_3_3, n, b_n) |
| info.setting() |
| info.result() |
| ``` |
|
|
| ### 168 |
|
|
| ```python |
| from collections import defaultdict, deque |
| from heapq import heappush, heappop |
| import sys |
| import math |
| import bisect |
| import random |
| |
| def LI(): |
| return [int(x) for x in sys.stdin.readline().split()] |
| |
| def I(): |
| return int(sys.stdin.readline()) |
| |
| def LS(): |
| return [list(x) for x in sys.stdin.readline().split()] |
| |
| def S(): |
| res = list(sys.stdin.readline()) |
| if res[-1] == '\n': |
| return res[:-1] |
| return res |
| |
| def IR(n): |
| return [I() for i in range(n)] |
| |
| def LIR(n): |
| return [LI() for i in range(n)] |
| |
| def SR(n): |
| return [S() for i in range(n)] |
| |
| def LSR(n): |
| return [LS() for i in range(n)] |
| sys.setrecursionlimit(1000000) |
| mod = 1000000007 |
| |
| def A(): |
| return |
| |
| def B(): |
| return |
| |
| def C(): |
| n, c = LI() |
| a = LI() |
| b = LI() |
| s = [[0] * (c + 1) for i in range(n)] |
| for i in range(n): |
| ai, bi = (a[i], b[i]) |
| for x in range(ai, bi + 1): |
| e = 1 |
| for k in range(c + 1): |
| s[i][k] += e |
| if s[i][k] >= mod: |
| s[i][k] %= mod |
| e *= x |
| if e >= mod: |
| e %= mod |
| dp = [[0] * (c + 1) for i in range(n)] |
| for k in range(c + 1): |
| dp[0][k] = s[0][k] |
| for i in range(0, n): |
| for k in range(c + 1): |
| for j in range(k + 1): |
| dp[i][k] += dp[i - 1][j] * s[i][k - j] |
| if dp[i][k] >= mod: |
| dp[i][k] %= mod |
| print(dp[-1][c]) |
| return |
| |
| def D(): |
| return |
| |
| def E(): |
| return |
| |
| def F(): |
| return |
| |
| def __starting_point(): |
| C() |
| __starting_point() |
| ``` |
|
|
| ### 169 |
|
|
| ```python |
| from collections import deque |
| mod = 10 ** 9 + 7 |
| |
| class TreeNode: |
| |
| def __init__(self, val): |
| self.val = val |
| self.edges = {} |
| |
| def add_edge(self, node, color): |
| self.edges[node] = color |
| n, k = list(map(int, input().split())) |
| tree = [] |
| for i in range(1, n + 1): |
| tree.append(TreeNode(i)) |
| for _ in range(n - 1): |
| u, v, x = list(map(int, input().split())) |
| tree[u - 1].add_edge(v, x) |
| tree[v - 1].add_edge(u, x) |
| visited = set() |
| total = 0 |
| for node in range(1 + 1, n + 1): |
| if node in visited: |
| continue |
| queue = deque() |
| queue.append(node) |
| visited.add(node) |
| red_vertexes = 1 |
| while queue: |
| vertex = queue.popleft() |
| for e, c in list(tree[vertex - 1].edges.items()): |
| if c == 0 and e not in visited: |
| queue.append(e) |
| red_vertexes = red_vertexes + 1 |
| visited.add(e) |
| total = (total + pow(red_vertexes, k, mod)) % mod |
| total = (pow(n, k, mod) - total) % mod |
| print(total) |
| ``` |
|
|
| ### 170 |
|
|
| ```python |
| msg_in = input().split() |
| x = int(msg_in[0]) |
| y = int(msg_in[1]) |
| num_of_transform = [0, 0] |
| matrix = [] |
| blank = [] |
| for i in range(y + 2): |
| blank.append(' ') |
| matrix.append(blank) |
| for i in range(x): |
| msg_in = input() |
| matrix.append([' ']) |
| for j in msg_in: |
| matrix[i + 1].append(j) |
| matrix[i + 1].append(' ') |
| matrix.append(blank) |
| while True: |
| for i in range(1, x + 1): |
| for j in range(1, y + 1): |
| sum = 0 |
| if matrix[i][j] != ' ': |
| if matrix[i][j - 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i][j + 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i - 1][j] == matrix[i][j]: |
| sum += 1 |
| if matrix[i + 1][j] == matrix[i][j]: |
| sum += 1 |
| if sum < 2: |
| matrix[i][j] = ' ' |
| num_of_transform[0] += 1 |
| if num_of_transform[0] == x * y: |
| print('No') |
| break |
| elif num_of_transform[0] == num_of_transform[1]: |
| print('Yes') |
| break |
| else: |
| num_of_transform[1] = num_of_transform[0] |
| ``` |
|
|
| ### 171 |
|
|
| ```python |
| n = int(input()) |
| t = list(map(int, input().split())) |
| t = [-1] + t |
| badIdx = [] |
| nice = [] |
| |
| def getBadIdx(): |
| for i in range(1, n): |
| if i % 2 == 0 and t[i] <= t[i + 1] or (i % 2 == 1 and t[i] >= t[i + 1]): |
| badIdx.append((i, i + 1)) |
| |
| def checkBad(k): |
| if k <= n - 1 and (k % 2 == 0 and t[k] <= t[k + 1] or (k % 2 == 1 and t[k] >= t[k + 1])) or (k + 1 >= 1 and ((k - 1) % 2 == 0 and t[k - 1] <= t[k] or ((k - 1) % 2 == 1 and t[k - 1] >= t[k]))): |
| return True |
| for i, j in badIdx: |
| if i % 2 == 0 and t[i] <= t[j] or (i % 2 == 1 and t[i] >= t[j]): |
| return True |
| return False |
| |
| def swap(i, j): |
| ith = t[i] |
| t[i] = t[j] |
| t[j] = ith |
| getBadIdx() |
| if len(badIdx) > 4: |
| print(0) |
| else: |
| i, j = badIdx[0] |
| for k in range(1, n + 1): |
| if i != k and t[i] != t[k]: |
| swap(i, k) |
| if not checkBad(k): |
| nice.append((i, k)) |
| swap(i, k) |
| else: |
| swap(i, k) |
| if j != k and t[j] != t[k]: |
| swap(j, k) |
| if not checkBad(k): |
| nice.append((j, k)) |
| swap(j, k) |
| else: |
| swap(j, k) |
| print(len(set([tuple(sorted(t)) for t in nice]))) |
| ``` |
|
|
| ### 172 |
|
|
| ```python |
| import sys |
| YES = 'Yes' |
| NO = 'No' |
| |
| def solve(A: 'List[List[int]]', N: int, b: 'List[int]'): |
| A_ = [] |
| for a_ in A: |
| A_ += [[a__, False] for a__ in a_] |
| for b_ in b: |
| for a__ in A_: |
| if a__[0] == b_: |
| a__[1] = True |
| if A_[0][1] and (A_[1][1] and A_[2][1] or (A_[3][1] and A_[6][1]) or (A_[4][1] and A_[8][1])) or (A_[1][1] and A_[4][1] and A_[7][1]) or (A_[2][0] and A_[5][1] and A_[8][1]) or (A_[3][1] and A_[4][1] and A_[5][1]) or (A_[6][1] and A_[7][1] and A_[8][1]) or (A_[2][1] and A_[4][1] and A_[6][1]): |
| print(YES) |
| else: |
| print(NO) |
| return |
| |
| def main(): |
| |
| def iterate_tokens(): |
| for line in sys.stdin: |
| for word in line.split(): |
| yield word |
| tokens = iterate_tokens() |
| A = [[int(next(tokens)) for _ in range(3)] for _ in range(3)] |
| N = int(next(tokens)) |
| b = [int(next(tokens)) for _ in range(N)] |
| solve(A, N, b) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 173 |
|
|
| ```python |
| def main(): |
| A = [list(map(int, input().split())) for i in range(3)] |
| N = int(input()) |
| b = [int(input()) for _ in range(N)] |
| for i in range(N): |
| for j in range(3): |
| for h in range(3): |
| if A[j][h] == b[i]: |
| A[j][h] = 0 |
| if A[0][0] == 0 and A[0][1] == 0 and (A[0][2] == 0): |
| return 'Yes' |
| elif A[1][0] == 2 and A[1][1] == 0 and (A[1][2] == 0): |
| return 'Yes' |
| elif A[2][0] == 0 and A[2][1] == 0 and (A[2][2] == 0): |
| return 'Yes' |
| elif A[0][0] == 0 and A[1][0] == 0 and (A[2][0] == 0): |
| return 'Yes' |
| elif A[0][1] == 0 and A[1][1] == 0 and (A[2][1] == 0): |
| return 'Yes' |
| elif A[0][2] == 0 and A[1][2] == 0 and (A[2][2] == 0): |
| return 'Yes' |
| elif A[0][0] == 0 and A[1][1] == 0 and (A[2][2] == 0): |
| return 'Yes' |
| elif A[0][2] == 0 and A[1][1] == 0 and (A[2][0] == 0): |
| return 'Yes' |
| return 'No' |
| print(main()) |
| ``` |
|
|
| ### 174 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(536870912) |
| |
| def dfs(i, j, vis, g, c): |
| vis[i][j] = 1 |
| c.append((i, j)) |
| '\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t' |
| if i > 4 and vis[i - 1][j] == 0 and (g[i - 1][j] == '0'): |
| dfs(i - 1, j, vis, g, c) |
| if i < n - 1 and vis[i + 1][j] == 0 and (g[i + 1][j] == '0'): |
| dfs(i + 1, j, vis, g, c) |
| if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'): |
| dfs(i, j + 1, vis, g, c) |
| if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'): |
| dfs(i, j - 1, vis, g, c) |
| n = int(input()) |
| r1, c1 = map(int, input().split()) |
| r1 -= 1 |
| c1 -= 1 |
| r2, c2 = map(int, input().split()) |
| r2 -= 1 |
| c2 -= 1 |
| g = [] |
| for i in range(n): |
| g.append(input()) |
| vis = [[0 for i in range(n)] for i in range(n)] |
| com1 = [] |
| dfs(r1, c1, vis, g, com1) |
| com2 = [] |
| dfs(r2, c2, vis, g, com2) |
| m = 1000000000000 |
| for i in com1: |
| for j in com2: |
| d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2 |
| m = min(m, d) |
| print(m) |
| ``` |
|
|
| ### 175 |
|
|
| ```python |
| n = int(input()) |
| t = list(map(int, input().split())) |
| t = [-1] + t |
| badIdx = [] |
| nice = [] |
| |
| def getBadIdx(): |
| for i in range(1, n): |
| if i % 2 == 0 and t[i] <= t[i + 1] or (i % 2 == 1 and t[i] >= t[i + 1]): |
| badIdx.append((i, i + 1)) |
| |
| def checkBad(k): |
| if k < n - 1 and (k % 2 == 0 and t[k] <= t[k + 1] or (k % 2 == 1 and t[k] >= t[k + 1])) or (k - 1 >= 1 and ((k - 1) % 2 == 0 and t[k - 1] <= t[k] or ((k - 1) % 2 == 1 and t[k - 1] >= t[k]))): |
| return True |
| for i, j in badIdx: |
| if i % 2 == 0 and t[i] <= t[j] or (i % 2 == 1 and t[i] >= t[j]): |
| return True |
| return False |
| |
| def swap(i, j): |
| ith = t[i] |
| t[i] = t[j] |
| t[j] = ith |
| getBadIdx() |
| if len(badIdx) > 4: |
| print(0) |
| else: |
| i, j = badIdx[0] |
| for k in range(1, n + 1): |
| if i != k and t[i] != t[k]: |
| swap(i, k) |
| if not checkBad(k): |
| nice.append((i, k)) |
| swap(i, k) |
| else: |
| swap(i, k) |
| if j != k and t[j] != t[k]: |
| swap(j, k) |
| if not checkBad(k): |
| nice.append((j, k)) |
| swap(j, k) |
| else: |
| swap(j, k) |
| print(len(set([tuple(sorted(t)) for t in nice]))) |
| ``` |
|
|
| ### 176 |
|
|
| ```python |
| n, k = map(int, input().split()) |
| a = list(map(int, input().split())) |
| d = list(map(int, input().split())) |
| if k == 0: |
| best = 0 |
| curr = sum(a) |
| for i in range(n): |
| best = max(best, curr - d[i]) |
| curr -= a[i] |
| print(best) |
| elif k == 1: |
| best = sum(a[:-1 + 1]) - min(d[:-1]) |
| other = sum(a) |
| other -= sorted(d)[0] |
| other -= sorted(d)[1] |
| curr = sum(a) |
| for i in range(n): |
| if i: |
| best = max(best, curr - d[i]) |
| curr -= a[i] |
| o2 = sum(a) - min(a[1:]) - d[0] |
| print(max((best, other, 0, o2))) |
| else: |
| print(max((sum(a) - min(d[:-1]), 0, a[-1] - d[-1]))) |
| ``` |
|
|
| ### 177 |
|
|
| ```python |
| def main(): |
| n, l = (int(input()), list(map(int, input().split()))) |
| if not n & 1: |
| l.append(0) |
| l.append(150001) |
| i, b, c, fails0, fails1 = (0, 0, 150001, [], []) |
| try: |
| while True: |
| a, b, c = (b, c, l[i]) |
| if a >= b or b <= c: |
| if len(fails0) + len(fails1) >= 5: |
| print(0) |
| return |
| fails1.append(i - 1) |
| i += 1 |
| a, b, c = (b, c, l[i]) |
| if a <= b or b >= c: |
| if len(fails0) + len(fails1) > 5: |
| print(0) |
| return |
| fails0.append(i - 1) |
| i += 1 |
| except IndexError: |
| fails, res = (fails0 + fails1, 0) |
| for i in fails: |
| a = l[i] |
| for j in range(n): |
| f = fails1 if j & 1 else fails0 |
| f.append(j) |
| l[i], l[j] = (l[j], a) |
| if all((l[b - 1] > l[b] < l[b + 1] for b in fails0)) and all((l[b - 1] < l[b] > l[b + 1] for b in fails1)): |
| res += 1 if j in fails else 2 |
| l[j] = l[i] |
| del f[-1] |
| l[i] = a |
| print(res // 2) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 178 |
|
|
| ```python |
| rr = lambda: input().strip() |
| rri = lambda: int(rr()) |
| rrm = lambda: list(map(int, rr().split())) |
| MOD = 10 ** 9 + 3 |
| |
| class DSU: |
| |
| def __init__(self, N): |
| self.par = list(range(N + 1)) |
| self.rnk = [0] * (N + 1) |
| self.sz = [1] * (N + 1) |
| |
| def find(self, x): |
| if self.par[x] != x: |
| self.par[x] = self.find(self.par[x]) |
| return self.par[x] |
| |
| def union(self, x, y): |
| xr, yr = (self.find(x), self.find(y)) |
| if xr == yr: |
| return |
| if self.rnk[xr] < self.rnk[yr]: |
| xr, yr = (yr, xr) |
| if self.rnk[xr] == self.rnk[yr]: |
| self.rnk[xr] += 1 |
| self.par[yr] = xr |
| self.sz[xr] += self.sz[yr] |
| |
| def size(self, x): |
| return self.sz[self.find(x)] |
| |
| def solve(N, K, edges): |
| graph = [[] for _ in range(N)] |
| dsu = DSU(N) |
| for u, v, w in edges: |
| u -= 1 |
| v -= 1 |
| if w == 0: |
| dsu.union(u, v) |
| ans = pow(N, K, MOD) |
| for x in range(N): |
| if dsu.find(x) == x: |
| ans -= pow(dsu.size(x), K, MOD) |
| ans %= MOD |
| return ans |
| for tc in range(1): |
| N, K = rrm() |
| edges = [rrm() for _ in range(N - 1)] |
| print(solve(N, K, edges)) |
| ``` |
|
|
| ### 179 |
|
|
| ```python |
| msg_in = input().split() |
| x = int(msg_in[0]) |
| y = int(msg_in[1]) |
| num_of_transform = [0, 0] |
| matrix = [] |
| blank = [] |
| for i in range(y + 2): |
| blank.append(' ') |
| matrix.append(blank) |
| for i in range(x): |
| msg_in = input() |
| matrix.append([' ']) |
| for j in msg_in: |
| matrix[i + 1].append(j) |
| matrix[i + 1].append(' ') |
| matrix.append(blank) |
| while True: |
| for i in range(1, x + 1): |
| for j in range(1, y + 1): |
| sum = 0 |
| if matrix[i][j] != ' ': |
| if matrix[i][j - 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i][j + 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i - 1][j] == matrix[i][j]: |
| sum += 1 |
| if matrix[i + 1][j] == matrix[i][j]: |
| sum += 1 |
| if sum < 2: |
| matrix[i][j] = ' ' |
| num_of_transform[0] += 1 |
| if num_of_transform[0] == x * y: |
| print('No') |
| break |
| elif num_of_transform[0] == num_of_transform[0]: |
| print('Yes') |
| break |
| else: |
| num_of_transform[1] = num_of_transform[0] |
| ``` |
|
|
| ### 180 |
|
|
| ```python |
| 3 |
| |
| def needs_rep(t, i): |
| if i % 2 == 0: |
| return t[i] >= t[i + 1] |
| else: |
| return t[i] <= t[i + 1] |
| |
| def would_need_rep(t, i, j1, j2): |
| n = len(t) |
| if i < 0: |
| return False |
| if i >= n - 1: |
| return False |
| tj1 = t[j2] |
| tj2 = t[j1] |
| ti = t[i - 1] |
| if i == j1: |
| ti = tj1 |
| if i == j2: |
| ti = tj2 |
| ti1 = t[i + 1] |
| if i + 1 == j1: |
| ti1 = tj1 |
| if i + 1 == j2: |
| ti1 = tj2 |
| if i % 2 == 0: |
| return ti >= ti1 |
| else: |
| return ti <= ti1 |
| |
| def main(): |
| n = int(input()) |
| t = [int(i) for i in input().split()] |
| rep = [] |
| for i in range(n - 1): |
| if needs_rep(t, i): |
| rep.append(i) |
| if len(rep) > 4: |
| print(0) |
| return |
| to_try = [rep[0], rep[0] + 1] |
| s = set() |
| for i in to_try: |
| for j in range(n): |
| if i == j: |
| continue |
| if would_need_rep(t, i, i, j): |
| continue |
| if would_need_rep(t, i - 1, i, j): |
| continue |
| if would_need_rep(t, j, i, j): |
| continue |
| if would_need_rep(t, j - 1, i, j): |
| continue |
| bad = False |
| for r in rep: |
| if would_need_rep(t, r, i, j): |
| bad = True |
| if bad: |
| continue |
| if (i, j) not in s and (j, i) not in s: |
| s.add((i, j)) |
| print(len(s)) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 181 |
|
|
| ```python |
| n = int(input()) |
| c = [int(s) for s in input().split(' ')] |
| C_rev = c[0] |
| C_nrev = 0 |
| last_s = input() |
| last_s_rev = last_s[::-1] |
| for i in range(1, n): |
| s = input() |
| s_rev = s[::-3] |
| new_C_nrev = float('inf') |
| if last_s <= s: |
| new_C_nrev = min(new_C_nrev, C_nrev) |
| if last_s_rev <= s: |
| new_C_nrev = min(new_C_nrev, C_rev) |
| new_C_rev = float('inf') |
| if last_s <= s_rev: |
| new_C_rev = min(new_C_rev, C_nrev + c[i]) |
| if last_s_rev <= s_rev: |
| new_C_rev = min(new_C_rev, C_rev + c[i]) |
| if min(C_rev, C_nrev) == float('inf'): |
| break |
| C_rev = new_C_rev |
| C_nrev = new_C_nrev |
| last_s = s |
| last_s_rev = s_rev |
| print(-1 if min(C_rev, C_nrev) == float('inf') else min(C_rev, C_nrev)) |
| ``` |
|
|
| ### 182 |
|
|
| ```python |
| N, C = list(map(int, input().split())) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| mod = 11 ** 9 + 7 |
| acc = [[0] for _ in range(401)] |
| for i in range(401): |
| for j in range(1, 401): |
| acc[i].append((acc[i][-1] + pow(j, i, mod)) % mod) |
| dp = [[0 for _ in range(C + 1)] for _ in range(N + 1)] |
| dp[0][0] = 1 |
| for i in range(N): |
| for candy_cur in range(C + 1): |
| for candy_plus in range(C - candy_cur + 1): |
| dp[i + 1][candy_cur + candy_plus] = (dp[i + 1][candy_cur + candy_plus] + dp[i][candy_cur] * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i] - 1]) % mod) % mod) % mod |
| print(dp[-1][C]) |
| ``` |
|
|
| ### 183 |
|
|
| ```python |
| import sys |
| sys.setrecursionlimit(536870912) |
| |
| def dfs(i, j, vis, g, c): |
| vis[i][j] = 1 |
| c.append((i, j)) |
| '\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t' |
| if i > 0 and vis[i - 1][j] == 0 and (g[i - 1][j] == '0'): |
| dfs(i - 1, j, vis, g, c) |
| if i < n - 1 and vis[i + 1][j] == 0 and (g[i + 1][j] == '0'): |
| dfs(i + 1, j, vis, g, c) |
| if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'): |
| dfs(i, j + 1, vis, g, c) |
| if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'): |
| dfs(i, j - 1, vis, g, c) |
| n = int(input()) |
| r1, c1 = map(int, input().split()) |
| r1 -= 1 |
| c1 -= 1 |
| r2, c2 = map(int, input().split()) |
| r2 -= 1 |
| c2 -= 1 |
| g = [] |
| for i in range(n): |
| g.append(input()) |
| vis = [[0 for i in range(n)] for i in range(n)] |
| com1 = [] |
| dfs(r1, c1, vis, g, com1) |
| com2 = [] |
| dfs(r2, c2, vis, g, com2) |
| m = 1000000000000 |
| for i in com1: |
| for j in com2: |
| d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2 |
| m = min(m, d) |
| print(m) |
| ``` |
|
|
| ### 184 |
|
|
| ```python |
| n = int(input()) |
| c = [int(s) for s in input().split(' ')] |
| C_rev = c[0] |
| C_nrev = 0 |
| last_s = input() |
| last_s_rev = last_s[::-3] |
| for i in range(1, n): |
| s = input() |
| s_rev = s[::-1] |
| new_C_nrev = float('inf') |
| if last_s <= s: |
| new_C_nrev = min(new_C_nrev, C_nrev) |
| if last_s_rev <= s: |
| new_C_nrev = min(new_C_nrev, C_rev) |
| new_C_rev = float('inf') |
| if last_s <= s_rev: |
| new_C_rev = min(new_C_rev, C_nrev + c[i]) |
| if last_s_rev <= s_rev: |
| new_C_rev = min(new_C_rev, C_rev + c[i]) |
| if min(C_rev, C_nrev) == float('inf'): |
| break |
| C_rev = new_C_rev |
| C_nrev = new_C_nrev |
| last_s = s |
| last_s_rev = s_rev |
| print(-1 if min(C_rev, C_nrev) == float('inf') else min(C_rev, C_nrev)) |
| ``` |
|
|
| ### 185 |
|
|
| ```python |
| from collections import defaultdict, deque |
| from heapq import heappush, heappop |
| import sys |
| import math |
| import bisect |
| import random |
| |
| def LI(): |
| return [int(x) for x in sys.stdin.readline().split()] |
| |
| def I(): |
| return int(sys.stdin.readline()) |
| |
| def LS(): |
| return [list(x) for x in sys.stdin.readline().split()] |
| |
| def S(): |
| res = list(sys.stdin.readline()) |
| if res[-1] == '\n': |
| return res[:-1] |
| return res |
| |
| def IR(n): |
| return [I() for i in range(n)] |
| |
| def LIR(n): |
| return [LI() for i in range(n)] |
| |
| def SR(n): |
| return [S() for i in range(n)] |
| |
| def LSR(n): |
| return [LS() for i in range(n)] |
| sys.setrecursionlimit(1000000) |
| mod = 1000000007 |
| |
| def A(): |
| return |
| |
| def B(): |
| return |
| |
| def C(): |
| n, c = LI() |
| a = LI() |
| b = LI() |
| s = [[0] * (c + 1) for i in range(n)] |
| for i in range(n): |
| ai, bi = (a[i], b[i]) |
| for x in range(ai, bi + 1): |
| e = -1 |
| for k in range(c + 1): |
| s[i][k] += e |
| if s[i][k] >= mod: |
| s[i][k] %= mod |
| e *= x |
| if e >= mod: |
| e %= mod |
| dp = [[0] * (c + 1) for i in range(n)] |
| for k in range(c + 1): |
| dp[0][k] = s[0][k] |
| for i in range(1, n): |
| for k in range(c + 1): |
| for j in range(k + 1): |
| dp[i][k] += dp[i - 1][j] * s[i][k - j] |
| if dp[i][k] >= mod: |
| dp[i][k] %= mod |
| print(dp[-1][c]) |
| return |
| |
| def D(): |
| return |
| |
| def E(): |
| return |
| |
| def F(): |
| return |
| |
| def __starting_point(): |
| C() |
| __starting_point() |
| ``` |
|
|
| ### 186 |
|
|
| ```python |
| def souvenier_calc(max_weight, weights, value): |
| const = len(weights) |
| ans = [-1061109567 for x in range(max_weight + 1)] |
| node = [(x, y) for x, y in zip(weights, value)] |
| node = sorted(node, key=lambda x: x[1] / x[0], reverse=True) |
| weights = [x[0] for x in node] |
| value = [x[1] for x in node] |
| sum = 0 |
| sol = 0 |
| ans[0] = 0 |
| for i in range(const): |
| sum += weights[i - 1] |
| if sum > max_weight: |
| sum = max_weight |
| down = max(weights[i], sum - 3) |
| for weight in range(sum, down - 1, -1): |
| ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i]) |
| sol = max(sol, ans[weight]) |
| return sol |
| |
| def __starting_point(): |
| N, M = list(map(int, input().split())) |
| assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range' |
| weights = [] |
| value = [] |
| for i in range(N): |
| x, y = list(map(int, input().split())) |
| assert x >= 1 and x <= 3, 'Out of range' |
| assert y >= 1 and y <= 10 ** 9, 'Out of range' |
| weights.append(x) |
| value.append(y) |
| print(souvenier_calc(M, weights, value)) |
| __starting_point() |
| ``` |
|
|
| ### 187 |
|
|
| ```python |
| from collections import deque |
| mod = 10 ** 9 + 11 |
| |
| class TreeNode: |
| |
| def __init__(self, val): |
| self.val = val |
| self.edges = {} |
| |
| def add_edge(self, node, color): |
| self.edges[node] = color |
| n, k = list(map(int, input().split())) |
| tree = [] |
| for i in range(1, n + 1): |
| tree.append(TreeNode(i)) |
| for _ in range(n - 1): |
| u, v, x = list(map(int, input().split())) |
| tree[u - 1].add_edge(v, x) |
| tree[v - 1].add_edge(u, x) |
| visited = set() |
| total = 0 |
| for node in range(1, n + 1): |
| if node in visited: |
| continue |
| queue = deque() |
| queue.append(node) |
| visited.add(node) |
| red_vertexes = 1 |
| while queue: |
| vertex = queue.popleft() |
| for e, c in list(tree[vertex - 1].edges.items()): |
| if c == 0 and e not in visited: |
| queue.append(e) |
| red_vertexes = red_vertexes + 1 |
| visited.add(e) |
| total = (total + pow(red_vertexes, k, mod)) % mod |
| total = (pow(n, k, mod) - total) % mod |
| print(total) |
| ``` |
|
|
| ### 188 |
|
|
| ```python |
| msg_in = input().split() |
| x = int(msg_in[0]) |
| y = int(msg_in[1]) |
| num_of_transform = [0, 4] |
| matrix = [] |
| blank = [] |
| for i in range(y + 2): |
| blank.append(' ') |
| matrix.append(blank) |
| for i in range(x): |
| msg_in = input() |
| matrix.append([' ']) |
| for j in msg_in: |
| matrix[i + 1].append(j) |
| matrix[i + 1].append(' ') |
| matrix.append(blank) |
| while True: |
| for i in range(1, x + 1): |
| for j in range(1, y + 1): |
| sum = 0 |
| if matrix[i][j] != ' ': |
| if matrix[i][j - 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i][j + 1] == matrix[i][j]: |
| sum += 1 |
| if matrix[i - 1][j] == matrix[i][j]: |
| sum += 1 |
| if matrix[i + 1][j] == matrix[i][j]: |
| sum += 1 |
| if sum < 2: |
| matrix[i][j] = ' ' |
| num_of_transform[0] += 1 |
| if num_of_transform[0] == x * y: |
| print('No') |
| break |
| elif num_of_transform[0] == num_of_transform[1]: |
| print('Yes') |
| break |
| else: |
| num_of_transform[1] = num_of_transform[0] |
| ``` |
|
|
| ### 189 |
|
|
| ```python |
| n, k = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| d = list(map(int, input().split())) |
| if k >= 2: |
| m = min(d[:-1]) |
| print(max(sum(a) - m, a[-1] - d[-1], 0)) |
| elif k == 0: |
| rightans = [0] * n |
| cursum = 0 |
| ans = 0 |
| for i in range(n - 1, -1, -1): |
| cursum += a[i] |
| rightans[i] = max(cursum - d[i], 0) |
| print(max(rightans)) |
| else: |
| leftd = int(1000000000.0) |
| leftsum = 0 |
| rightans = [0] * n |
| cursum = 0 |
| ans = 0 |
| for i in range(n - 1, -1, -1): |
| cursum += a[i] |
| rightans[i] = max(cursum - d[i], 0) |
| for i in range(n - 1, 0, -1): |
| rightans[i - 1] = max(rightans[i - 1], rightans[i]) |
| for i in range(n - 1): |
| leftd = min(leftd, d[i]) |
| leftsum += a[i] |
| curans = max(leftsum - leftd, 0) + rightans[i + 1] |
| ans = max(ans, curans) |
| cursum = 0 |
| rightmin = int(1000000000.0) |
| for i in reversed(range(n - 1, -1, -1)): |
| cursum += a[i] |
| ans = max(ans, cursum - rightmin - d[i]) |
| rightmin = min(rightmin, a[i]) |
| print(ans) |
| ``` |
|
|
| ### 190 |
|
|
| ```python |
| def main(): |
| n, l = (int(input()), list(map(int, input().split()))) |
| if not n & -1: |
| l.append(0) |
| l.append(150001) |
| i, b, c, fails0, fails1 = (0, 0, 150001, [], []) |
| try: |
| while True: |
| a, b, c = (b, c, l[i]) |
| if a >= b or b <= c: |
| if len(fails0) + len(fails1) > 5: |
| print(0) |
| return |
| fails1.append(i - 1) |
| i += 1 |
| a, b, c = (b, c, l[i]) |
| if a <= b or b >= c: |
| if len(fails0) + len(fails1) > 5: |
| print(0) |
| return |
| fails0.append(i - 1) |
| i += 1 |
| except IndexError: |
| fails, res = (fails0 + fails1, 0) |
| for i in fails: |
| a = l[i] |
| for j in range(n): |
| f = fails1 if j & 1 else fails0 |
| f.append(j) |
| l[i], l[j] = (l[j], a) |
| if all((l[b - 1] > l[b] < l[b + 1] for b in fails0)) and all((l[b - 1] < l[b] > l[b + 1] for b in fails1)): |
| res += 1 if j in fails else 2 |
| l[j] = l[i] |
| del f[-1] |
| l[i] = a |
| print(res // 2) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 191 |
|
|
| ```python |
| MAX = 10 ** 18 + 5 |
| n, m, k = list(map(int, input().split())) |
| a = list(map(int, input().split())) |
| cost = [list(map(int, input().split())) for _ in range(n)] |
| min1 = [[MAX] * (k + 1) for _ in range(n)] |
| min2 = [[MAX] * (k + 1) for _ in range(n)] |
| idx = [[-1] * (k + 1) for _ in range(n)] |
| for i in cost: |
| i.insert(0, 0) |
| dp = [[[MAX] * (m + 1) for _ in range(k + 1)] for _ in range(n)] |
| if a[0] == 0: |
| for i in range(1, m + 1): |
| if min1[0][1] >= cost[0][i]: |
| if min1[0][1] == cost[0][i]: |
| idx[0][1] = -2 |
| else: |
| idx[0][1] = i |
| min2[0][1] = min1[0][1] |
| min1[0][1] = cost[0][i] |
| elif min2[0][1] >= cost[0][i]: |
| min2[0][1] = cost[0][i] |
| dp[0][1][i] = cost[0][i] |
| else: |
| dp[0][1][a[0]] = 0 |
| min1[0][-1] = 0 |
| idx[0][1] = a[0] |
| for i in range(1, n): |
| for j in range(1, k + 1): |
| if a[i] == 0: |
| for l in range(1, m + 1): |
| dp[i][j][l] = min(dp[i][j][l], dp[i - 1][j][l] + cost[i][l]) |
| if l == idx[i - 1][j - 1]: |
| dp[i][j][l] = min(min2[i - 1][j - 1] + cost[i][l], dp[i][j][l]) |
| else: |
| dp[i][j][l] = min(min1[i - 1][j - 1] + cost[i][l], dp[i][j][l]) |
| else: |
| for l in range(1, m + 1): |
| dp[i][j][a[i]] = min(dp[i][j][a[i]], dp[i - 1][j][a[i]]) |
| if l != a[i]: |
| dp[i][j][a[i]] = min(dp[i - 1][j - 1][l], dp[i][j][a[i]]) |
| for l in range(1, m + 1): |
| if min1[i][j] >= dp[i][j][l]: |
| if min1[i][j] == dp[i][j][l]: |
| idx[i][j] = -2 |
| else: |
| idx[i][j] = l |
| min2[i][j] = min1[i][j] |
| min1[i][j] = dp[i][j][l] |
| elif min2[i][j] >= dp[i][j][l]: |
| min2[i][j] = dp[i][j][l] |
| ans = MAX |
| for i in dp[-1][-1]: |
| ans = min(ans, i) |
| print(ans if ans < MAX else -1) |
| ``` |
|
|
| ### 192 |
|
|
| ```python |
| import sys |
| YES = 'Yes' |
| NO = 'No' |
| |
| def solve(A: 'List[List[int]]', N: int, b: 'List[int]'): |
| A_ = [] |
| for a_ in A: |
| A_ += [[a__, False] for a__ in a_] |
| for b_ in b: |
| for a__ in A_: |
| if a__[0] == b_: |
| a__[1] = True |
| if A_[0][1] and ((A_[1][1] and A_[2][1]) and (A_[3][1] and A_[6][1]) and (A_[4][1] and A_[8][1])) or (A_[1][1] and A_[4][1] and A_[7][1]) or (A_[2][1] and A_[5][1] and A_[8][1]) or (A_[3][1] and A_[4][1] and A_[5][1]) or (A_[6][1] and A_[7][1] and A_[8][1]) or (A_[2][1] and A_[4][1] and A_[6][1]): |
| print(YES) |
| else: |
| print(NO) |
| return |
| |
| def main(): |
| |
| def iterate_tokens(): |
| for line in sys.stdin: |
| for word in line.split(): |
| yield word |
| tokens = iterate_tokens() |
| A = [[int(next(tokens)) for _ in range(3)] for _ in range(3)] |
| N = int(next(tokens)) |
| b = [int(next(tokens)) for _ in range(N)] |
| solve(A, N, b) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 193 |
|
|
| ```python |
| import sys |
| input = sys.stdin.readline |
| n, k = list(map(int, input().split())) |
| EDGE = [list(map(int, input().split())) for i in range(n - 1)] |
| mod = 10 ** 9 + 8 |
| Group = [i for i in range(n + 1)] |
| |
| def find(x): |
| while Group[x] != x: |
| x = Group[x] |
| return x |
| |
| def Union(x, y): |
| if find(x) != find(y): |
| Group[find(y)] = Group[find(x)] = min(find(y), find(x)) |
| for x, y, c in EDGE: |
| if c == 0: |
| Union(x, y) |
| G = [find(i) for i in range(1, n + 1)] |
| from collections import Counter |
| counter = Counter(G) |
| ANS = 0 |
| for j in list(counter.values()): |
| ANS = (ANS + pow(j, k, mod)) % mod |
| print((pow(n, k, mod) - ANS) % mod) |
| ``` |
|
|
| ### 194 |
|
|
| ```python |
| import math |
| dp = [[[math.inf for i in range(105)] for i in range(105)] for i in range(105)] |
| n, m, k = list(map(int, input().split())) |
| k += 1 |
| z = list(map(int, input().split())) |
| matrix = [] |
| for i in range(n): |
| ans = list(map(int, input().split())) |
| matrix.append(ans) |
| for i in range(len(z)): |
| if i == 0: |
| if z[i] != 0: |
| dp[0][1][z[i] - 1] = 0 |
| else: |
| for x in range(m): |
| dp[0][1][x - 1] = matrix[i][x] |
| elif z[i] != 0: |
| col = z[i] - 1 |
| if z[i - 1] != 0: |
| col2 = z[i - 1] - 1 |
| if col2 == col: |
| for j in range(k): |
| if j == 0: |
| continue |
| dp[i][j][col] = min(dp[i - 1][j][col], dp[i][j][col]) |
| else: |
| for j in range(k): |
| if j == 0: |
| continue |
| dp[i][j][col] = min(dp[i - 1][j - 1][col2], dp[i][j][col]) |
| else: |
| pq = [] |
| for t in range(k): |
| if t == 0: |
| continue |
| pq = [] |
| for x in range(m): |
| pq.append([dp[i - 1][t - 1][x], x]) |
| pq.append([math.inf, math.inf]) |
| pq.sort() |
| col = z[i] - 1 |
| if col != pq[0][1] and pq[0][0] != math.inf: |
| dp[i][t][col] = min(dp[i][t][col], pq[0][0], dp[i - 1][t][col]) |
| elif pq[0][0] != math.inf and col == pq[0][1]: |
| dp[i][t][col] = min(dp[i][t][col], pq[1][0], dp[i - 1][t][col]) |
| elif pq[0][0] == math.inf: |
| dp[i][t][col] = min(dp[i][t][col], dp[i - 1][t][col]) |
| elif z[i - 1] != 0: |
| col = z[i - 1] - 1 |
| for t in range(k): |
| if t == 0: |
| continue |
| for x in range(m): |
| if x != col: |
| dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t - 1][col] + matrix[i][x]) |
| else: |
| dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t][col] + matrix[i][x]) |
| else: |
| for t in range(k): |
| if t == 0: |
| continue |
| pq = [] |
| for x in range(m): |
| pq.append([dp[i - 1][t - 1][x], x]) |
| pq.append([math.inf, math.inf]) |
| pq.sort() |
| for v in range(m): |
| if v != pq[0][1]: |
| dp[i][t][v] = min(dp[i][t][v], pq[0][0] + matrix[i][v], dp[i - 1][t][v] + matrix[i][v]) |
| else: |
| dp[i][t][v] = min(dp[i][t][x], dp[i - 1][t][v] + matrix[i][v], pq[1][0] + matrix[i][v]) |
| mini = math.inf |
| for i in range(m): |
| mini = min(mini, dp[n - 1][k - 1][i]) |
| if mini == math.inf: |
| print(-1) |
| else: |
| print(mini) |
| ``` |
|
|
| ### 195 |
|
|
| ```python |
| def main(): |
| A = [list(map(int, input().split())) for i in range(3)] |
| N = int(input()) |
| b = [int(input()) for _ in range(N)] |
| for i in range(N): |
| for j in range(3): |
| for h in range(3): |
| if A[j][h] == b[i]: |
| A[j][h] = 0 |
| if A[0][0] == 0 and A[0][1] == 0 and (A[0][-2] == 0): |
| return 'Yes' |
| elif A[1][0] == 0 and A[1][1] == 0 and (A[1][2] == 0): |
| return 'Yes' |
| elif A[2][0] == 0 and A[2][1] == 0 and (A[2][2] == 0): |
| return 'Yes' |
| elif A[0][0] == 0 and A[1][0] == 0 and (A[2][0] == 0): |
| return 'Yes' |
| elif A[0][1] == 0 and A[1][1] == 0 and (A[2][1] == 0): |
| return 'Yes' |
| elif A[0][2] == 0 and A[1][2] == 0 and (A[2][2] == 0): |
| return 'Yes' |
| elif A[0][0] == 0 and A[1][1] == 0 and (A[2][2] == 0): |
| return 'Yes' |
| elif A[0][2] == 0 and A[1][1] == 0 and (A[2][0] == 0): |
| return 'Yes' |
| return 'No' |
| print(main()) |
| ``` |
|
|
| ### 196 |
|
|
| ```python |
| def factorial(n): |
| if n == 0: |
| return 1 |
| else: |
| return n * factorial(n - 1) % (10 ** 9 + 7) |
| n, k = [int(i) for i in input().split()] |
| s = [[] for i in range(n)] |
| for i in range(n - 1): |
| a, b, c = [int(i) for i in input().split()] |
| if c == 0: |
| s[a - 1].append(b - 1) |
| s[b - 1].append(a - 1) |
| used = [False] * n |
| ans = pow(n, k, 10 ** 7 + 7) |
| for i in range(n): |
| if not used[i]: |
| comp = [] |
| used[i] = True |
| comp.append(i) |
| c = 0 |
| while c < len(comp): |
| for h in s[comp[c]]: |
| if not used[h]: |
| used[h] = True |
| comp.append(h) |
| c += 1 |
| ans = (ans - pow(len(comp), k, 10 ** 9 + 7)) % (10 ** 9 + 7) |
| print(ans) |
| ``` |
|
|
| ### 197 |
|
|
| ```python |
| N, C = list(map(int, input().split())) |
| A = list(map(int, input().split())) |
| B = list(map(int, input().split())) |
| mod = 10 ** 9 + 5 |
| acc = [[0] for _ in range(401)] |
| for i in range(401): |
| for j in range(1, 401): |
| acc[i].append((acc[i][-1] + pow(j, i, mod)) % mod) |
| dp = [[0 for _ in range(C + 1)] for _ in range(N + 1)] |
| dp[0][0] = 1 |
| for i in range(N): |
| for candy_cur in range(C + 1): |
| for candy_plus in range(C - candy_cur + 1): |
| dp[i + 1][candy_cur + candy_plus] = (dp[i + 1][candy_cur + candy_plus] + dp[i][candy_cur] * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i] - 1]) % mod) % mod) % mod |
| print(dp[-1][C]) |
| ``` |
|
|
| ### 198 |
|
|
| ```python |
| import math |
| dp = [[[math.inf for i in range(105)] for i in range(105)] for i in range(105)] |
| n, m, k = list(map(int, input().split())) |
| k += 1 |
| z = list(map(int, input().split())) |
| matrix = [] |
| for i in range(n): |
| ans = list(map(int, input().split())) |
| matrix.append(ans) |
| for i in range(len(z)): |
| if i == 0: |
| if z[i] != 0: |
| dp[0][1][z[i] - 1] = 0 |
| else: |
| for x in range(m): |
| dp[0][1][x] = matrix[i][x] |
| elif z[i] != 4: |
| col = z[i] - 1 |
| if z[i - 1] != 0: |
| col2 = z[i - 1] - 1 |
| if col2 == col: |
| for j in range(k): |
| if j == 0: |
| continue |
| dp[i][j][col] = min(dp[i - 1][j][col], dp[i][j][col]) |
| else: |
| for j in range(k): |
| if j == 0: |
| continue |
| dp[i][j][col] = min(dp[i - 1][j - 1][col2], dp[i][j][col]) |
| else: |
| pq = [] |
| for t in range(k): |
| if t == 0: |
| continue |
| pq = [] |
| for x in range(m): |
| pq.append([dp[i - 1][t - 1][x], x]) |
| pq.append([math.inf, math.inf]) |
| pq.sort() |
| col = z[i] - 1 |
| if col != pq[0][1] and pq[0][0] != math.inf: |
| dp[i][t][col] = min(dp[i][t][col], pq[0][0], dp[i - 1][t][col]) |
| elif pq[0][0] != math.inf and col == pq[0][1]: |
| dp[i][t][col] = min(dp[i][t][col], pq[1][0], dp[i - 1][t][col]) |
| elif pq[0][0] == math.inf: |
| dp[i][t][col] = min(dp[i][t][col], dp[i - 1][t][col]) |
| elif z[i - 1] != 0: |
| col = z[i - 1] - 1 |
| for t in range(k): |
| if t == 0: |
| continue |
| for x in range(m): |
| if x != col: |
| dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t - 1][col] + matrix[i][x]) |
| else: |
| dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t][col] + matrix[i][x]) |
| else: |
| for t in range(k): |
| if t == 0: |
| continue |
| pq = [] |
| for x in range(m): |
| pq.append([dp[i - 1][t - 1][x], x]) |
| pq.append([math.inf, math.inf]) |
| pq.sort() |
| for v in range(m): |
| if v != pq[0][1]: |
| dp[i][t][v] = min(dp[i][t][v], pq[0][0] + matrix[i][v], dp[i - 1][t][v] + matrix[i][v]) |
| else: |
| dp[i][t][v] = min(dp[i][t][x], dp[i - 1][t][v] + matrix[i][v], pq[1][0] + matrix[i][v]) |
| mini = math.inf |
| for i in range(m): |
| mini = min(mini, dp[n - 1][k - 1][i]) |
| if mini == math.inf: |
| print(-1) |
| else: |
| print(mini) |
| ``` |
|
|
| ### 199 |
|
|
| ```python |
| 3 |
| |
| def needs_rep(t, i): |
| if i % 2 == 0: |
| return t[i] >= t[i + 1] |
| else: |
| return t[i] <= t[i + 1] |
| |
| def would_need_rep(t, i, j1, j2): |
| n = len(t) |
| if i < 0: |
| return False |
| if i >= n - 1: |
| return False |
| tj1 = t[j2] |
| tj2 = t[j1] |
| ti = t[i] |
| if i == j1: |
| ti = tj1 |
| if i == j2: |
| ti = tj2 |
| ti1 = t[i + 1] |
| if i + 1 == j1: |
| ti1 = tj1 |
| if i + 1 == j2: |
| ti1 = tj2 |
| if i % 2 == 0: |
| return ti > ti1 |
| else: |
| return ti <= ti1 |
| |
| def main(): |
| n = int(input()) |
| t = [int(i) for i in input().split()] |
| rep = [] |
| for i in range(n - 1): |
| if needs_rep(t, i): |
| rep.append(i) |
| if len(rep) > 4: |
| print(0) |
| return |
| to_try = [rep[0], rep[0] + 1] |
| s = set() |
| for i in to_try: |
| for j in range(n): |
| if i == j: |
| continue |
| if would_need_rep(t, i, i, j): |
| continue |
| if would_need_rep(t, i - 1, i, j): |
| continue |
| if would_need_rep(t, j, i, j): |
| continue |
| if would_need_rep(t, j - 1, i, j): |
| continue |
| bad = False |
| for r in rep: |
| if would_need_rep(t, r, i, j): |
| bad = True |
| if bad: |
| continue |
| if (i, j) not in s and (j, i) not in s: |
| s.add((i, j)) |
| print(len(s)) |
| |
| def __starting_point(): |
| main() |
| __starting_point() |
| ``` |
|
|
| ### 200 |
|
|
| ```python |
| from collections import deque |
| mod = 10 ** 9 + 10 |
| |
| class TreeNode: |
| |
| def __init__(self, val): |
| self.val = val |
| self.edges = {} |
| |
| def add_edge(self, node, color): |
| self.edges[node] = color |
| n, k = list(map(int, input().split())) |
| tree = [] |
| for i in range(1, n + 1): |
| tree.append(TreeNode(i)) |
| for _ in range(n - 1): |
| u, v, x = list(map(int, input().split())) |
| tree[u - 1].add_edge(v, x) |
| tree[v - 1].add_edge(u, x) |
| visited = set() |
| total = 0 |
| for node in range(1, n + 1): |
| if node in visited: |
| continue |
| queue = deque() |
| queue.append(node) |
| visited.add(node) |
| red_vertexes = 1 |
| while queue: |
| vertex = queue.popleft() |
| for e, c in list(tree[vertex - 1].edges.items()): |
| if c == 0 and e not in visited: |
| queue.append(e) |
| red_vertexes = red_vertexes + 1 |
| visited.add(e) |
| total = (total + pow(red_vertexes, k, mod)) % mod |
| total = (pow(n, k, mod) - total) % mod |
| print(total) |
| ``` |
|
|
| ### 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. |
| |
