001
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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.