001
df = int(input())
for _ in range(df):
n, x, y, d = list(map(int, input().split()))
d2 = abs(x - y)
ans = 3000000000.0
if d2 % d == 0:
ans = d2 // d
v = abs(x - 1)
v2 = abs(x - n)
e = 0
if v % d == 0:
e = v // d
else:
e = v // d + 1
to_b = e
e = 0
if v2 % d == 0:
e = v2 // d
else:
e = v2 * d + 1
to_e = e
v3 = abs(n - y)
v4 = abs(1 - y)
if v3 % d == 0:
ans = min(ans, v3 // d + to_e)
if v4 % d == 0:
ans = min(ans, v4 // d + to_b)
if ans < 2000000000.0:
print(ans)
else:
print(-1)
002
n = int(input())
C = 10 ** 9 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) <= int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1][2] %= C
d[-1][3] %= C
print(d[-1][2])
003
import sys
def solve():
input = sys.stdin.readline
N, H, L, R = map(int, input().split())
A = [int(a) for a in input().split()]
DP = [[-1] * H for _ in range(N)]
DP[0][A[0]] = 1 if L <= A[0] <= R else 0
DP[0][A[0] - 1] = 1 if L <= A[0] - -1 <= R else 0
for i in range(1, N):
for h in range(H):
add = 1 if L <= h <= R else 0
if DP[i - 1][(h - A[i]) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add)
if DP[i - 1][(h - A[i] + 1) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add)
print(max(DP[N - 1]))
return 0
def __starting_point():
solve()
__starting_point()
004
from math import gcd
n = int(input())
pts = []
ans = 0
for i in range(0, n):
a, b, A, B = tuple(map(int, input().split(' ')))
pts.append((a, b, A, B))
ans += gcd(abs(a - A), abs(b - B)) + 1
m = dict()
for i in range(n):
for j in range(i + 1, n):
a1 = pts[i][0]
b1 = pts[i][1]
a2 = pts[i][2]
b2 = pts[i][3]
A1 = pts[j][0]
B1 = pts[j][1]
A2 = pts[j][2]
B2 = pts[j][3]
num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1)
den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1)
if den1 != 0 and num1 % den1 == 0:
if a1 == a2:
num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1)
den2 = A2 - A1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
else:
num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1)
den2 = a2 - a1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
sum = 0
for i in list(m.values()):
sum += len(i) - -1
print(ans - sum)
005
def main():
from sys import stdin, stdout
def read():
return stdin.readline().rstrip('\n')
def read_array(sep=None, maxsplit=-1):
return read().split(sep, maxsplit)
def read_int():
return int(read())
def read_int_array(sep=None, maxsplit=-1):
return [int(a) for a in read_array(sep, maxsplit)]
def write(*args, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join((str(a) for a in args)) + end)
def write_array(array, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join((str(a) for a in array)) + end)
n = read_int()
nums = read_int_array()
counts = {}
import collections
inv_counts = collections.defaultdict(int)
out = 0
for i, x in enumerate(nums):
c = inv_counts[x]
if c:
counts[c].remove(x)
if not counts[c]:
counts.pop(c)
c += 1
inv_counts[x] = c
counts.setdefault(c, set()).add(x)
if len(counts) == 2 and any((len(s) == 1 and (k - 1 in counts or k == -1) for k, s in list(counts.items()))):
out = i + 1
elif len(counts) == 1:
k = next(iter(list(counts.keys())))
if k == 1 or len(counts[k]) == 1:
out = i + 1
write(out)
main()
006
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + 1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + -1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
007
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')
008
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())
009
import math
n = int(input())
def f(x, y, d):
t = abs(x - y)
if y == 1:
return math.ceil(t / d)
if y == n:
return math.ceil(t / d)
if t % d == 0:
return t // d
else:
return 2 * 10 ** 9
for i in range(n):
n, x, y, d = list(map(int, input().split()))
ans = min([f(x, y, d), f(x, 1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)])
if ans == -2 * 10 ** 9:
print('-1')
else:
print(ans)
010
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)
011
def main():
from sys import stdin, stdout
def read():
return stdin.readline().rstrip('\n')
def read_array(sep=None, maxsplit=-1):
return read().split(sep, maxsplit)
def read_int():
return int(read())
def read_int_array(sep=None, maxsplit=-1):
return [int(a) for a in read_array(sep, maxsplit)]
def write(*args, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join((str(a) for a in args)) + end)
def write_array(array, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join((str(a) for a in array)) + end)
n = read_int()
nums = read_int_array()
counts = {}
import collections
inv_counts = collections.defaultdict(int)
out = 0
for i, x in enumerate(nums):
c = inv_counts[x]
if c:
counts[c].remove(x)
if not counts[c]:
counts.pop(c)
c += 1
inv_counts[x] = c
counts.setdefault(c, set()).add(x)
if len(counts) == 2 and any((len(s) == 1 and (k - 1 in counts or k == 1) for k, s in list(counts.items()))):
out = i + 1
elif len(counts) == 1:
k = next(iter(list(counts.keys())))
if k == 2 or len(counts[k]) == 1:
out = i + 1
write(out)
main()
012
from math import gcd
def covered_points(xa, ya, xb, yb):
if xb < xa:
temp_x = xa
xa = xb
xb = temp_x
temp_y = ya
ya = yb
yb = temp_y
y_0 = abs(yb - ya)
x_0 = xb - xa
return gcd(y_0, x_0) + 1
def intersection2(xa, ya, xb, yb, xc, yc, xd, yd):
if max(xa, xb) < min(xc, xd):
return ()
if max(ya, yb) < min(yc, yd):
return ()
if not (xa == xb and xc == xd or (ya == yb and yc == yd)):
return ()
if ya == yb and yc == yd:
return ()
a1 = yb - ya
b1 = xb - xa
c1 = xa * a1 - ya * b1
a2 = yd - yc
b2 = xd - xc
c2 = xc * a2 - yc * b2
det = a1 * b2 - a2 * b1
if det == 0:
return ()
detx = c1 * b2 - c2 * b1
dety = -a1 * c2 + a2 * c1
if detx % det != 0 or dety % det != 0:
return ()
x = int(detx / det)
y = int(dety / det)
if x < min(xa, xb) or x > max(xa, xb) or x < min(xc, xd) or (x > max(xc, xd)):
return ()
if y < min(ya, yb) or y > max(ya, yb) or y < min(yc, yd) or (y > max(yc, yd)):
return ()
return (x, y)
def __starting_point():
n = int(input())
Ax = [0] * n
Ay = [0] * n
Bx = [0] * n
By = [0] * n
n_cov = 0
intersections = {}
for i in range(n):
line = input().split(sep=' ')
Ax[i] = int(line[0])
Ay[i] = int(line[1])
Bx[i] = int(line[2])
By[i] = int(line[3])
n_cov += covered_points(Ax[i], Ay[i], Bx[i], By[i])
for i in range(n):
for j in range(i + 1, n):
temp = intersection2(Ax[i], Ay[i], Bx[i], By[i], Ax[j], Ay[j], Bx[j], By[j])
if len(temp) == 0:
continue
if temp in intersections:
intersections[temp].append(i)
intersections[temp].append(j)
else:
intersections[temp] = [i, j]
for i in intersections:
n_cov = n_cov - len(set(intersections[i])) + 1
print(n_cov)
__starting_point()
013
df = int(input())
for _ in range(df):
n, x, y, d = list(map(int, input().split()))
d2 = abs(x - y)
ans = 3000000000.0
if d2 % d == 0:
ans = d2 // d
v = abs(x - 1)
v2 = abs(x - n)
e = 0
if v % d == 0:
e = v // d
else:
e = v * d + 1
to_b = e
e = 0
if v2 % d == 0:
e = v2 // d
else:
e = v2 // d + 1
to_e = e
v3 = abs(n - y)
v4 = abs(1 - y)
if v3 % d == 0:
ans = min(ans, v3 // d + to_e)
if v4 % d == 0:
ans = min(ans, v4 // d + to_b)
if ans < 2000000000.0:
print(ans)
else:
print(-1)
014
n, h, l, r = list(map(int, input().split()))
N = n
a = list(map(int, input().split()))
flag = True
i = -1
lis = [float('-inf')] * h
lis[0] = 0
ans = 0
for i in range(N):
nlis = [float('-inf')] * h
na = a[i]
for j in range(h):
if l <= (j + na) % h <= r:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1)
else:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j])
if l < (j + na - 1) % h <= r:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1)
else:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j])
lis = nlis
print(max(0, max(lis)))
015
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)
016
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + -1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + 1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
017
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')
018
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()
019
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 - 1):
mini = min(mini, dp[n - 1][k - 1][i])
if mini == math.inf:
print(-1)
else:
print(mini)
020
def go():
n, h, l, r = list(map(int, input().split()))
a = list(map(int, input().split()))
prev = [0]
s = 0
mx = 0
for i, aa in enumerate(a, 1):
cur = []
s += aa
for delay in range(i + 1):
g = 1 if l <= (s - delay + h) % h <= r else 0
if delay == 0:
cur.append(prev[delay] - g)
elif delay == i:
cur.append(prev[delay - 1] + g)
else:
cur.append(max(prev[delay], prev[delay - 1]) + g)
prev = cur
mx = max(mx, max(cur))
return mx
for _ in range(1):
print(go())
021
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)
022
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000008)
023
n = int(input())
u = [int(u) for u in input().split()]
NMAX = 100005
suma = [0 for _ in range(NMAX)]
total = [0 for _ in range(NMAX)]
diferentes = 0
sol = 0
maximo = 1
for i, v in enumerate(u):
if total[v] == 0:
diferentes += 1
else:
suma[total[v]] -= 1
total[v] += 1
suma[total[v]] += 1
maximo = max(maximo, total[v])
if diferentes <= 2:
sol = i
if suma[maximo - 1] == diferentes - 1 and suma[maximo] == 1:
sol = i
if suma[maximo] == diferentes - 1 and suma[1] == 1:
sol = i
if suma[1] == diferentes:
sol = i
print(sol + 1)
024
import sys
from math import gcd
class Segment:
def __init__(self, x1, y1, x2, y2):
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
def dx(self):
return self.x2 - self.x1
def dy(self):
return self.y2 - self.y1
def pt_cnt(self):
return gcd(abs(self.dx()), abs(self.dy())) + 1
def A(self):
return self.y1 - self.y2
def B(self):
return self.x2 - self.x1
def C(self):
return -self.A() * self.x1 - self.B() * self.y1
def inner_x(self, x):
l = self.x1
r = self.x2
if l > r:
l, r = (r, l)
return l <= x <= r
def inner_y(self, y):
l = self.y1
r = self.y2
if l > r:
l, r = (r, l)
return l < y <= r
def inner(self, x, y):
return self.inner_x(x) and self.inner_y(y)
def intersect(self, other):
dx = det(self.C(), self.B(), other.C(), other.B())
dy = det(self.A(), self.C(), other.A(), other.C())
d = det(self.A(), self.B(), other.A(), other.B())
if d == 0:
return (False, 0, 0)
if dx % d != 0 or dy % d != 0:
return (False, 0, 0)
x = -dx // d
y = -dy // d
if not self.inner(x, y) or not other.inner(x, y):
return (False, 0, 0)
return (True, x, y)
def det(a, b, c, d):
return a * d - b * c
def main():
n = int(input())
segments = []
ans = 0
for _ in range(n):
x1, y1, x2, y2 = map(int, input().split())
segment = Segment(x1, y1, x2, y2)
ans += segment.pt_cnt()
pt = set()
for other in segments:
result, x, y = segment.intersect(other)
if result:
pt.add((x, y))
ans -= len(pt)
segments.append(segment)
print(ans)
def __starting_point():
main()
__starting_point()
025
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)
026
df = int(input())
for _ in range(df):
n, x, y, d = list(map(int, input().split()))
d2 = abs(x - y)
ans = 3000000000.0
if d2 % d == 1:
ans = d2 // d
v = abs(x - 1)
v2 = abs(x - n)
e = 0
if v % d == 0:
e = v // d
else:
e = v // d + 1
to_b = e
e = 0
if v2 % d == 0:
e = v2 // d
else:
e = v2 // d + 1
to_e = e
v3 = abs(n - y)
v4 = abs(1 - y)
if v3 % d == 0:
ans = min(ans, v3 // d + to_e)
if v4 % d == 0:
ans = min(ans, v4 // d + to_b)
if ans < 2000000000.0:
print(ans)
else:
print(-1)
027
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()
028
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + 1
else:
pre[i][j] = 0
continue
for x in range(j + 1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k - 1])
029
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)
030
import copy
def right(a):
d = a[1] - a[0]
res, f = (-3, True)
for i in range(2, len(a)):
if a[i] - a[i - 1] == d + 1:
a[i] -= 1
res += 1
elif a[i] - a[i - 1] == d - 1:
a[i] += 1
res += 1
elif a[i] - a[i - 1] != d:
f = False
break
if not f:
res = 10 ** 9
return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
print(0)
else:
f = n + 1
bs[0] -= 1
bs[1] -= 1
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()))
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
if f == n + 1:
f = -1
print(f)
031
n = int(input())
C = 10 ** 9 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) < int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1][2] %= C
d[-1][3] %= C
print(d[-1][2])
032
def cal(x, y):
d = a[1] + y - a[0] - x
wk1 = a[1] + y
wkans = 0
for k in range(2, n):
diff = abs(wk1 + d - a[k])
if diff == 1:
wkans += 1
elif diff > 1:
return n + 1
wk1 += d
return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
ans_final = n + 1
for i in range(-1, 2):
for j in range(-1, 2):
ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
ans_final = 0
if ans_final == n + 2:
print(-1)
else:
print(ans_final)
033
import sys
input = sys.stdin.readline
n, h, l, r = map(int, input().split())
a = [int(item) for item in input().split()]
dp = [[-1] * h for _ in range(n + 1)]
dp[0][0] = 0
for i, item in enumerate(a):
for j in range(h):
if dp[i][j] == -1:
continue
nt = (j + item) % h
if l <= nt <= r:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
else:
dp[i + 1][nt - 1] = max(dp[i + 1][nt], dp[i][j])
nt = (j + item - 1 + h) % h
if l <= nt <= r:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
else:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
print(max(dp[-1]))
034
import sys
def solve():
input = sys.stdin.readline
N, H, L, R = map(int, input().split())
A = [int(a) for a in input().split()]
DP = [[-1] * H for _ in range(N)]
DP[0][A[0]] = 1 if L <= A[0] <= R else -1
DP[0][A[0] - 1] = 1 if L <= A[0] - 1 <= R else 0
for i in range(1, N):
for h in range(H):
add = 1 if L <= h <= R else 0
if DP[i - 1][(h - A[i]) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add)
if DP[i - 1][(h - A[i] + 1) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add)
print(max(DP[N - 1]))
return 0
def __starting_point():
solve()
__starting_point()
035
def solve(seq):
if len(seq) <= 2:
return 0
startings = []
for x in (-1, 0, 1):
for y in (-1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [--1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
036
from math import gcd
n = int(input())
pts = []
ans = 0
for i in range(0, n):
a, b, A, B = tuple(map(int, input().split(' ')))
pts.append((a, b, A, B))
ans += gcd(abs(a - A), abs(b - B)) + 1
m = dict()
for i in range(n):
for j in range(i + 1 + 1, n):
a1 = pts[i][0]
b1 = pts[i][1]
a2 = pts[i][2]
b2 = pts[i][3]
A1 = pts[j][0]
B1 = pts[j][1]
A2 = pts[j][2]
B2 = pts[j][3]
num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1)
den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1)
if den1 != 0 and num1 % den1 == 0:
if a1 == a2:
num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1)
den2 = A2 - A1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
else:
num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1)
den2 = a2 - a1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
sum = 0
for i in list(m.values()):
sum += len(i) - 1
print(ans - sum)
037
import sys
input = sys.stdin.readline
n, h, l, r = map(int, input().split())
a = [int(item) for item in input().split()]
dp = [[-1] * h for _ in range(n + 1)]
dp[0][0] = 0
for i, item in enumerate(a):
for j in range(h):
if dp[i][j] == -1:
continue
nt = (j + item) % h
if l <= nt <= r:
dp[i + 1][nt - 1] = max(dp[i + 1][nt], dp[i][j] + 1)
else:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
nt = (j + item - 1 + h) % h
if l <= nt <= r:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
else:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
print(max(dp[-1]))
038
df = int(input())
for _ in range(df):
n, x, y, d = list(map(int, input().split()))
d2 = abs(x - y)
ans = 3000000000.0
if d2 % d == 0:
ans = d2 // d
v = abs(x - 1)
v2 = abs(x - n)
e = 0
if v % d == 0:
e = v // d
else:
e = v // d + 1
to_b = e
e = 0
if v2 % d == 0:
e = v2 // d
else:
e = v2 // d + 1
to_e = e
v3 = abs(n - y)
v4 = abs(1 - y)
if v3 % d == 0:
ans = min(ans, v3 // d + to_e)
if v4 % d == 1:
ans = min(ans, v4 // d + to_b)
if ans < 2000000000.0:
print(ans)
else:
print(-1)
039
3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = 55 * ans % (10 ** 9 + 7)
elif s[i] == '?':
ans = (ord(t[i]) - ord('0') + 1) * ans % (10 ** 9 + 7)
elif t[i] == '?':
ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' and s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and (not tlts):
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 + 7))
elif sltt:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
040
n = int(input())
u = [int(u) for u in input().split()]
NMAX = 100005
suma = [0 for _ in range(NMAX)]
total = [0 for _ in range(NMAX)]
diferentes = 0
sol = 0
maximo = 3
for i, v in enumerate(u):
if total[v] == 0:
diferentes += 1
else:
suma[total[v]] -= 1
total[v] += 1
suma[total[v]] += 1
maximo = max(maximo, total[v])
if diferentes <= 1:
sol = i
if suma[maximo - 1] == diferentes - 1 and suma[maximo] == 1:
sol = i
if suma[maximo] == diferentes - 1 and suma[1] == 1:
sol = i
if suma[1] == diferentes:
sol = i
print(sol + 1)
041
def solve(seq):
if len(seq) <= 2:
return 1
startings = []
for x in (-1, 0, 1):
for y in (-1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [-1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
042
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()
043
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()
044
import sys
def getIntList():
return list(map(int, input().split()))
N, = getIntList()
zp = []
for i in range(N):
ax, ay, bx, by = getIntList()
if ax > bx:
ax, bx = (bx, ax)
ay, by = (by, ay)
zp.append((ax, ay, bx, by))
res = 0
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
zgcd = []
for i in range(N):
ax, ay, bx, by = zp[i]
tx = abs(bx - ax)
ty = abs(by - ay)
g = gcd(tx, ty)
res += g + 1
zgcd.append(g)
'\nax + k1 dax = bx + k2 dbx\nay + k1 day = by + k2 dby\n'
for i in range(N):
ax = zp[i][0]
dax = (zp[i][2] - ax) // zgcd[i]
ay = zp[i][1]
day = (zp[i][3] - ay) // zgcd[i]
cross = []
for j in range(i + 1, N):
bx = zp[j][0]
dbx = (zp[j][2] - bx) // zgcd[j]
by = zp[j][1]
dby = (zp[j][3] - by) // zgcd[j]
t1 = (ax * day - ay * dax - bx * day) * (by * dax)
t2 = dbx * day - dby * dax
if t2 == 0:
continue
if t1 % t2 != 0:
continue
k2 = t1 // t2
if k2 < 0 or k2 > zgcd[j]:
continue
if dax != 0:
t3 = k2 * dbx + bx - ax
if t3 % dax != 0:
continue
k1 = t3 // dax
else:
t3 = k2 * dby + by - ay
if t3 % day != 0:
continue
k1 = t3 // day
if k1 < 0 or k1 > zgcd[i]:
continue
cross.append(k1)
if not cross:
continue
cross.sort()
d = 1
for j in range(1, len(cross)):
if cross[j] != cross[j - 1]:
d += 1
res -= d
print(res)
045
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())
046
t = int(input())
for _ in range(t):
n, x, y, d = list(map(int, input().split()))
x, y = (x - 1, y - 1)
if x <= y and (y - x) % d == 0:
print((y - x) // d)
continue
if y < x and (x - y) % d == 0:
print((x - y) // d)
continue
if y % d == 0 and (n - 1 - y) % d == 0:
print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d))
continue
if y % d == 0:
print((x + y + d - 1) // d)
continue
if (n - 1 - y) % d == 0:
print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)
continue
print(-3)
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 ** 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)
048
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()
049
from math import ceil
def solve():
n, x, y, d = [int(x) for x in input().split()]
INF = 1000000000.0
sol1 = abs(x - y) // d if (x - y) % d == 0 else INF
sol2 = ceil((x - 1) / d) + ceil((y - 1) / d) if (y - 1) % d == 0 else INF
sol3 = ceil((n - x) / d) + ceil(n * y / d) if (n - y) % d == 0 else INF
ans = min(sol1, sol2, sol3)
ans = ans if ans != INF else -1
print(ans)
nt = int(input())
for _ in range(nt):
solve()
050
def go():
n, h, l, r = list(map(int, input().split()))
a = list(map(int, input().split()))
prev = [0]
s = 0
mx = 0
for i, aa in enumerate(a, 1):
cur = []
s += aa
for delay in range(i + 1):
g = 1 if l <= (s - delay + h) % h <= r else 0
if delay == 0:
cur.append(prev[delay] + g)
elif delay == i:
cur.append(prev[delay - 1] + g)
else:
cur.append(max(prev[delay], prev[delay - 1 - 1]) + g)
prev = cur
mx = max(mx, max(cur))
return mx
for _ in range(1):
print(go())
051
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)
052
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))
053
import sys
n = int(input())
nums = list(map(int, input().split()))
eleCount = {}
possibleMax = 1
for i in range(n):
if nums[i] in list(eleCount.keys()):
eleCount[nums[i]] += 1
if len(list(eleCount.keys())) == 1:
possibleMax = i + 1
else:
x = list(eleCount.values())
x.sort()
if x[0] == 1 and x[-1] == 1:
possibleMax = i + 1
elif x[0] == 1 and x[1] != 1:
if len(set(x[1:])) == 1:
possibleMax = i + 1
else:
x[-1] = x[-1] - 1
if len(set(x)) == 1:
possibleMax = i + 1
else:
eleCount[nums[i]] = -3
if len(list(eleCount.keys())) == 1:
possibleMax = i + 1
else:
x = list(eleCount.values())
x.sort()
if x[0] == 1 and x[-1] == 1:
possibleMax = i + 1
elif x[0] == 1 and x[1] != 1:
if len(set(x[1:])) == 1:
possibleMax = i + 1
else:
x[-1] = x[-1] - 1
if len(set(x)) == 1:
possibleMax = i + 1
print(possibleMax)
054
import sys
input = sys.stdin.readline
n, h, l, r = map(int, input().split())
a = [int(item) for item in input().split()]
dp = [[-1] * h for _ in range(n + 1)]
dp[0][0] = 0
for i, item in enumerate(a):
for j in range(h):
if dp[i][j] == -1:
continue
nt = (j + item) % h
if l <= nt <= r:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
else:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i - 1][j])
nt = (j + item - 1 + h) % h
if l <= nt <= r:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
else:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
print(max(dp[-1]))
055
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)
056
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] == 3):
print('Yes')
else:
print('No')
057
import sys
input = sys.stdin.readline
n, h, l, r = map(int, input().split())
a = [int(item) for item in input().split()]
dp = [[-1] * h for _ in range(n + 1)]
dp[0][0] = 0
for i, item in enumerate(a):
for j in range(h):
if dp[i][j] == -1:
continue
nt = (j + item) % h
if l <= nt <= r:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
else:
dp[i - 1][nt] = max(dp[i + 1][nt], dp[i][j])
nt = (j + item - 1 + h) % h
if l <= nt <= r:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
else:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
print(max(dp[-1]))
058
import sys
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def float_array():
return list(map(float, input().strip().split()))
def str_array():
return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(m):
if s[j] == '1':
days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
for j in range(lesson * 1):
if j <= len(days[i]):
if j == len(days[i]):
m[i][j] = 0
continue
else:
for k in range(0, j + 1):
var = days[i][0 + k]
var1 = days[i][-1 * max(1, 1 + (j - k))]
m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson + 1):
dp[0][i] = m[0][i]
for i in range(1, n):
for j in range(lesson + 1):
for k in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
059
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())
060
n = int(input())
C = 10 ** 9 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) < int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1 - 1][2] %= C
d[-1][3] %= C
print(d[-1][2])
061
n = int(input())
u = [int(u) for u in input().split()]
NMAX = 100005
suma = [0 for _ in range(NMAX)]
total = [0 for _ in range(NMAX)]
diferentes = 0
sol = 0
maximo = 1
for i, v in enumerate(u):
if total[v] == 0:
diferentes += 1
else:
suma[total[v]] -= 1
total[v] += 1
suma[total[v]] += 1
maximo = max(maximo, total[v])
if diferentes <= 1:
sol = i
if suma[maximo - 1 + 1] == diferentes - 1 and suma[maximo] == 1:
sol = i
if suma[maximo] == diferentes - 1 and suma[1] == 1:
sol = i
if suma[1] == diferentes:
sol = i
print(sol + 1)
062
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))
063
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()
064
def solve(seq):
if len(seq) <= 2:
return 0
startings = []
for x in (-1, 0, 1):
for y in (-1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[-2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [-1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
065
t = int(input())
for _ in range(t):
n, x, y, d = list(map(int, input().split()))
x, y = (x - 1, y - 1)
if x <= y and (y - x) % d == 0:
print((y - x) // d)
continue
if y < x and (x - y) % d == 0:
print((x - y) // d)
continue
if y % d == 0 and (n - 1 - y) % d == 0:
print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d))
continue
if y % d == 0:
print((x + y + d - 1) // d)
continue
if (n - 1 - y) % d == 0:
print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)
continue
print(-2)
066
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)
067
def go():
n, h, l, r = list(map(int, input().split()))
a = list(map(int, input().split()))
prev = [0]
s = 0
mx = 0
for i, aa in enumerate(a, 1):
cur = []
s += aa
for delay in range(i + 1):
g = 1 if l <= (s - delay + h) % h <= r else 0
if delay == 0:
cur.append(prev[delay] + g)
elif delay == i:
cur.append(prev[delay - 1 - 1] + g)
else:
cur.append(max(prev[delay], prev[delay - 1]) + g)
prev = cur
mx = max(mx, max(cur))
return mx
for _ in range(1):
print(go())
068
import copy
def right(a):
d = a[1] - a[0]
res, f = (0, True)
for i in range(2, len(a)):
if a[i] - a[i - 1] == d + 1:
a[i] -= 1
res += 1
elif a[i] - a[i - 1] == d - 1:
a[i] += 1
res += 1
elif a[i] - a[i - 1] != d:
f = False
break
if not f:
res = 10 ** 9
return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
print(0)
else:
f = n + 1
bs[0] -= 1
bs[1] -= 1
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()))
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[0] -= 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
if f == n + 1:
f = -1
print(f)
069
import sys
from math import gcd
class Segment:
def __init__(self, x1, y1, x2, y2):
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
def dx(self):
return self.x2 - self.x1
def dy(self):
return self.y2 - self.y1
def pt_cnt(self):
return gcd(abs(self.dx()), abs(self.dy())) + 1
def A(self):
return self.y1 - self.y2
def B(self):
return self.x2 - self.x1
def C(self):
return -self.A() * self.x1 - self.B() * self.y1
def inner_x(self, x):
l = self.x1
r = self.x2
if l > r:
l, r = (r, l)
return l <= x <= r
def inner_y(self, y):
l = self.y1
r = self.y2
if l > r:
l, r = (r, l)
return l <= y <= r
def inner(self, x, y):
return self.inner_x(x) and self.inner_y(y)
def intersect(self, other):
dx = det(self.C(), self.B(), other.C(), other.B())
dy = det(self.A(), self.C(), other.A(), other.C())
d = det(self.A(), self.B(), other.A(), other.B())
if d == 0:
return (False, 0, 0)
if dx % d != 0 or dy % d != 0:
return (False, 0, 0)
x = -dx // d
y = -dy // d
if not self.inner(x, y) or not other.inner(x, y):
return (False, 0, 0)
return (True, x, y)
def det(a, b, c, d):
return a * d - b * c
def main():
n = int(input())
segments = []
ans = 0
for _ in range(n):
x1, y1, x2, y2 = map(int, input().split())
segment = Segment(x1, y1, x2, y2)
ans += segment.pt_cnt()
pt = set()
for other in segments:
result, x, y = segment.intersect(other)
if result:
pt.add((x, y))
ans -= len(pt)
segments.append(segment)
print(ans)
def __starting_point():
main()
__starting_point()
070
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
if a[i] == '?' and b[i] == '?':
x = x * 55 % mod
y = y * 55 % mod
z = z * 10 % mod
elif a[i] == '?':
x = x * (10 - int(b[i])) % mod
y = y * (int(b[i]) + 1) // mod
elif b[i] == '?':
x = x * (int(a[i]) + 1) % mod
y = y * (10 - int(a[i])) % mod
else:
if int(a[i]) < int(b[i]):
x = 0
if int(a[i]) > int(b[i]):
y = 0
if a[i] != b[i]:
z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y + z) % mod)
071
from random import random
from collections import defaultdict
import math
import re
import fractions
N = int(input())
A = list(map(int, input().split(' ')))
arr = [0] * (10 ** 5 + 1)
existing = set()
for a in A:
arr[a] += 1
existing.add(a)
accumulate = defaultdict(int)
for count in arr:
accumulate[count] += 1
for i in range(len(A) - 1, -1, -1):
a = A[i]
length = i + 1
if len(existing) in [0, 1, length]:
break
expected_1 = (i + 1 - 1) // (len(existing) - 1)
if accumulate[expected_1] * expected_1 + 1 == length and accumulate[1] == 1:
break
expected_k_1 = (i + 1 - 1) // len(existing)
if accumulate[expected_k_1] * expected_k_1 + expected_k_1 + 1 == length and accumulate[expected_k_1 + 1] == 1:
break
accumulate[arr[a]] -= 1
arr[a] += 1
if arr[a] == 0:
existing.discard(a)
accumulate[arr[a]] += 1
print(length)
072
from math import gcd
n = int(input())
pts = []
ans = 0
for i in range(0, n):
a, b, A, B = tuple(map(int, input().split(' ')))
pts.append((a, b, A, B))
ans += gcd(abs(a - A), abs(b - B)) + 1
m = dict()
for i in range(n):
for j in range(i + 1, n):
a1 = pts[i][0]
b1 = pts[i][1]
a2 = pts[i][2]
b2 = pts[i][3]
A1 = pts[j][0]
B1 = pts[j][1]
A2 = pts[j][2]
B2 = pts[j][3]
num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1)
den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1)
if den1 != 0 and num1 % den1 == 0:
if a1 == a2:
num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1)
den2 = A2 - A1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
else:
num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1)
den2 = a2 - a1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
sum = 0
for i in list(m.values()):
sum += len(i) - 1
print(ans - sum)
073
def cal(x, y):
d = a[1] + y - a[0] - x
wk1 = a[1] + y
wkans = 0
for k in range(2, n):
diff = abs(wk1 - d - a[k])
if diff == 1:
wkans += 1
elif diff > 1:
return n + 1
wk1 += d
return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
ans_final = n + 1
for i in range(-1, 2):
for j in range(-1, 2):
ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
ans_final = 0
if ans_final == n + 1:
print(-1)
else:
print(ans_final)
074
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))
075
def main():
from sys import stdin, stdout
def read():
return stdin.readline().rstrip('\n')
def read_array(sep=None, maxsplit=-1):
return read().split(sep, maxsplit)
def read_int():
return int(read())
def read_int_array(sep=None, maxsplit=-1):
return [int(a) for a in read_array(sep, maxsplit)]
def write(*args, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join((str(a) for a in args)) + end)
def write_array(array, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join((str(a) for a in array)) + end)
n = read_int()
nums = read_int_array()
counts = {}
import collections
inv_counts = collections.defaultdict(int)
out = 0
for i, x in enumerate(nums):
c = inv_counts[x]
if c:
counts[c].remove(x)
if not counts[c]:
counts.pop(c)
c += 1
inv_counts[x] = c
counts.setdefault(c, set()).add(x)
if len(counts) == 2 and any((len(s) == 1 and (k - 1 in counts or k == 1) for k, s in list(counts.items()))):
out = i + 1
elif len(counts) == 1:
k = next(iter(list(counts.keys())))
if k == 1 or len(counts[k]) == -1:
out = i + 1
write(out)
main()
076
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
one = []
for i in range(m):
if a[i] == '1':
one.append(i)
if not one:
continue
ni = len(one)
subdp = [10 ** 9] * (ni + 1)
subdp[-1] = 0
for i in range(ni - 1):
for j in range(i, ni):
subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1)], one[j] - one[i] + 1)
next_dp = [10 ** 9] * (k + 1)
for i in range(k, -1, -1):
for j in range(ni + 1):
if i + j > k:
break
next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
dp = next_dp
print(min(dp))
077
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())
078
n, h, l, r = list(map(int, input().split()))
N = n
a = list(map(int, input().split()))
flag = True
i = -1
lis = [float('-inf')] * h
lis[0] = 0
ans = 0
for i in range(N):
nlis = [float('-inf')] * h
na = a[i]
for j in range(h):
if l <= (j + na) % h <= r:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1)
else:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j])
if l <= (j + na - -1) % h <= r:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1)
else:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j])
lis = nlis
print(max(0, max(lis)))
079
import sys
def solve():
input = sys.stdin.readline
N, H, L, R = map(int, input().split())
A = [int(a) for a in input().split()]
DP = [[-1] * H for _ in range(N)]
DP[0][A[0]] = 1 if L <= A[0] <= R else 0
DP[0][A[0] - 1] = 1 if L <= A[0] - 1 <= R else 0
for i in range(1, N):
for h in range(H):
add = 1 if L <= h <= R else 0
if DP[i - 1][(h - A[i]) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add)
if DP[i - 1][(h - A[i] + 1) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add)
print(max(DP[N - 1 - 1]))
return 0
def __starting_point():
solve()
__starting_point()
080
import sys
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def float_array():
return list(map(float, input().strip().split()))
def str_array():
return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(m):
if s[j] == '1':
days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
for j in range(lesson + 1):
if j <= len(days[i]):
if j == len(days[i]):
m[i][j] = 0
continue
else:
for k in range(0, j + 1):
var = days[i][0 + k]
var1 = days[i][-1 * max(1, 1 + (j - k))]
m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson + 1):
dp[0][i - 1] = m[0][i]
for i in range(1, n):
for j in range(lesson + 1):
for k in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
081
import math
n = int(input())
def f(x, y, d):
t = abs(x - y)
if y == 1:
return math.ceil(t / d)
if y == n:
return math.ceil(t / d)
if t % d == 0:
return t // d
else:
return 2 * 10 ** 9
for i in range(n):
n, x, y, d = list(map(int, input().split()))
ans = min([f(x, y, d), f(x, -1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)])
if ans == 2 * 10 ** 9:
print('-1')
else:
print(ans)
082
t = int(input())
for _ in range(t):
n, x, y, d = list(map(int, input().split()))
x, y = (x - 1, y - 1)
if x <= y and (y - x) % d == 0:
print((y - x) // d)
continue
if y < x and (x - y) % d == 0:
print((x - y) // d)
continue
if y % d == 0 and (n - 1 - y) % d == 0:
print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d))
continue
if y % d == 0:
print((x + y + d - 1) // d)
continue
if (n - 1 - y) % d == 0:
print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)
continue
print(-5)
083
import math
n = int(input())
def f(x, y, d):
t = abs(x - y)
if y == -1:
return math.ceil(t / d)
if y == n:
return math.ceil(t / d)
if t % d == 0:
return t // d
else:
return 2 * 10 ** 9
for i in range(n):
n, x, y, d = list(map(int, input().split()))
ans = min([f(x, y, d), f(x, 1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)])
if ans == 2 * 10 ** 9:
print('-1')
else:
print(ans)
084
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000005)
085
import sys
def solve():
input = sys.stdin.readline
N, H, L, R = map(int, input().split())
A = [int(a) for a in input().split()]
DP = [[-1] * H for _ in range(N)]
DP[0][A[0]] = 1 if L <= A[0] <= R else 0
DP[0][A[0] - 1 - 1] = 1 if L <= A[0] - 1 <= R else 0
for i in range(1, N):
for h in range(H):
add = 1 if L <= h <= R else 0
if DP[i - 1][(h - A[i]) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add)
if DP[i - 1][(h - A[i] + 1) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add)
print(max(DP[N - 1]))
return 0
def __starting_point():
solve()
__starting_point()
086
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))
087
def cal(x, y):
d = a[1] + y - a[0] - x
wk1 = a[1] + y
wkans = 0
for k in range(2, n - 1):
diff = abs(wk1 + d - a[k])
if diff == 1:
wkans += 1
elif diff > 1:
return n + 1
wk1 += d
return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
ans_final = n + 1
for i in range(-1, 2):
for j in range(-1, 2):
ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
ans_final = 0
if ans_final == n + 1:
print(-1)
else:
print(ans_final)
088
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + 1
else:
pre[i][j] = 0
continue
for x in range(j + -1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k])
089
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()
090
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)
091
n = int(input())
C = 10 ** 9 + 6
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) < int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1][2] %= C
d[-1][3] %= C
print(d[-1][2])
092
from math import gcd
def covered_points(xa, ya, xb, yb):
if xb < xa:
temp_x = xa
xa = xb
xb = temp_x
temp_y = ya
ya = yb
yb = temp_y
y_0 = abs(yb - ya)
x_0 = xb - xa
return gcd(y_0, x_0) + 1
def intersection2(xa, ya, xb, yb, xc, yc, xd, yd):
if max(xa, xb) < min(xc, xd):
return ()
if max(ya, yb) < min(yc, yd):
return ()
if xa == xb and xc == xd or (ya == yb and yc == yd):
return ()
if ya == yb and yc == yd:
return ()
a1 = yb - ya
b1 = xb - xa
c1 = xa * a1 - ya * b1
a2 = yd - yc
b2 = xd - xc
c2 = xc * a2 - yc * b2
det = a1 * b2 - a2 * b1
if det == 0:
return ()
detx = c1 * b2 - c2 * b1
dety = -a1 * c2 + a2 * c1
if detx % det != 0 or dety % det != 0:
return ()
x = int(detx / det)
y = int(dety / det)
if x < min(xa, xb) or x > max(xa, xb) or x < min(xc, xd) or (x > max(xc, xd)):
return ()
if not (y < min(ya, yb) or y > max(ya, yb) or y < min(yc, yd) or (y > max(yc, yd))):
return ()
return (x, y)
def __starting_point():
n = int(input())
Ax = [0] * n
Ay = [0] * n
Bx = [0] * n
By = [0] * n
n_cov = 0
intersections = {}
for i in range(n):
line = input().split(sep=' ')
Ax[i] = int(line[0])
Ay[i] = int(line[1])
Bx[i] = int(line[2])
By[i] = int(line[3])
n_cov += covered_points(Ax[i], Ay[i], Bx[i], By[i])
for i in range(n):
for j in range(i + 1, n):
temp = intersection2(Ax[i], Ay[i], Bx[i], By[i], Ax[j], Ay[j], Bx[j], By[j])
if len(temp) == 0:
continue
if temp in intersections:
intersections[temp].append(i)
intersections[temp].append(j)
else:
intersections[temp] = [i, j]
for i in intersections:
n_cov = n_cov - len(set(intersections[i])) + 1
print(n_cov)
__starting_point()
093
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))
094
import sys
n = int(input())
nums = list(map(int, input().split()))
eleCount = {}
possibleMax = 1
for i in range(n):
if nums[i] in list(eleCount.keys()):
eleCount[nums[i]] += 1
if len(list(eleCount.keys())) == 1:
possibleMax = i - 1
else:
x = list(eleCount.values())
x.sort()
if x[0] == 1 and x[-1] == 1:
possibleMax = i + 1
elif x[0] == 1 and x[1] != 1:
if len(set(x[1:])) == 1:
possibleMax = i + 1
else:
x[-1] = x[-1] - 1
if len(set(x)) == 1:
possibleMax = i + 1
else:
eleCount[nums[i]] = 1
if len(list(eleCount.keys())) == 1:
possibleMax = i + 1
else:
x = list(eleCount.values())
x.sort()
if x[0] == 1 and x[-1] == 1:
possibleMax = i + 1
elif x[0] == 1 and x[1] != 1:
if len(set(x[1:])) == 1:
possibleMax = i + 1
else:
x[-1] = x[-1] - 1
if len(set(x)) == 1:
possibleMax = i + 1
print(possibleMax)
095
from math import ceil
def solve():
n, x, y, d = [int(x) for x in input().split()]
INF = 1000000000.0
sol1 = abs(x - y) // d if (x - y) % d == 0 else INF
sol2 = ceil((x - 1) / d) + ceil(y * 1 / d) if (y - 1) % d == 0 else INF
sol3 = ceil((n - x) / d) + ceil((n - y) / d) if (n - y) % d == 0 else INF
ans = min(sol1, sol2, sol3)
ans = ans if ans != INF else -1
print(ans)
nt = int(input())
for _ in range(nt):
solve()
096
def cal(x, y):
d = a[1] + y - a[0] - x
wk1 = a[1] + y
wkans = 0
for k in range(2, n):
diff = abs(wk1 + d - a[k])
if diff == 1:
wkans += 1
elif diff > 1:
return n + 1
wk1 += d
return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
ans_final = n + 1
for i in range(-1, 2):
for j in range(-1, 2 - 1):
ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
ans_final = 0
if ans_final == n + 1:
print(-1)
else:
print(ans_final)
097
n, h, l, r = list(map(int, input().split()))
N = n
a = list(map(int, input().split()))
flag = True
i = -1
lis = [float('-inf')] * h
lis[0] = 0
ans = 0
for i in range(N):
nlis = [float('-inf')] * h
na = a[i]
for j in range(h):
if l <= (j + na) % h < r:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1)
else:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j])
if l <= (j + na - 1) % h <= r:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1)
else:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j])
lis = nlis
print(max(0, max(lis)))
098
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
if a[i] == '?' and b[i] == '?':
x = x * 55 % mod
y = y * 55 % mod
z = z * 10 % mod
elif a[i] == '?':
x = x * (10 - int(b[i])) % mod
y = y * (int(b[i]) + 1) % mod
elif b[i] == '?':
x = x * (int(a[i]) + 1) & mod
y = y * (10 - int(a[i])) % mod
else:
if int(a[i]) < int(b[i]):
x = 0
if int(a[i]) > int(b[i]):
y = 0
if a[i] != b[i]:
z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y + z) % mod)
099
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = -2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
100
3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = 55 * ans % (10 ** 9 + 7)
elif s[i] == '?':
ans = (ord(t[i]) - ord('0') + 1) * ans % (10 ** 9 + 7)
elif t[i] == '?':
ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' or s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and (not tlts):
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 - 7))
elif sltt:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
101
n = int(input())
u = [int(u) for u in input().split()]
NMAX = 100005
suma = [0 for _ in range(NMAX)]
total = [0 for _ in range(NMAX)]
diferentes = 0
sol = 0
maximo = 1
for i, v in enumerate(u):
if total[v] == 0:
diferentes += 1
else:
suma[total[v]] -= 1
total[v] += 1
suma[total[v]] += 1
maximo = max(maximo, total[v])
if diferentes <= 1:
sol = i
if suma[maximo - 1] == diferentes - 1 and suma[maximo] == 1:
sol = i
if suma[maximo] == diferentes - 1 and suma[1] == 1:
sol = i
if suma[1] == diferentes:
sol = i
print(sol + 1)
102
import sys
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def float_array():
return list(map(float, input().strip().split()))
def str_array():
return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(m):
if s[j] == '1':
days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
for j in range(lesson - 1):
if j <= len(days[i]):
if j == len(days[i]):
m[i][j] = 0
continue
else:
for k in range(0, j + 1):
var = days[i][0 + k]
var1 = days[i][-1 * max(1, 1 + (j - k))]
m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson + 1):
dp[0][i] = m[0][i]
for i in range(1, n):
for j in range(lesson + 1):
for k in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
103
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
one = []
for i in range(m):
if a[i] == '1':
one.append(i)
if not one:
continue
ni = len(one)
subdp = [10 ** 9] * (ni + 1)
subdp[-1] = 0
for i in range(ni):
for j in range(i, ni - 1):
subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1)], one[j] - one[i] + 1)
next_dp = [10 ** 9] * (k + 1)
for i in range(k, -1, -1):
for j in range(ni + 1):
if i + j > k:
break
next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
dp = next_dp
print(min(dp))
104
from math import gcd
n = int(input())
pts = []
ans = 0
for i in range(0, n):
a, b, A, B = tuple(map(int, input().split(' ')))
pts.append((a, b, A, B))
ans += gcd(abs(a - A), abs(b - B)) + 1
m = dict()
for i in range(n):
for j in range(i + -1, n):
a1 = pts[i][0]
b1 = pts[i][1]
a2 = pts[i][2]
b2 = pts[i][3]
A1 = pts[j][0]
B1 = pts[j][1]
A2 = pts[j][2]
B2 = pts[j][3]
num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1)
den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1)
if den1 != 0 and num1 % den1 == 0:
if a1 == a2:
num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1)
den2 = A2 - A1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
else:
num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1)
den2 = a2 - a1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
sum = 0
for i in list(m.values()):
sum += len(i) - 1
print(ans - sum)
105
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()
106
n = int(input())
u = [int(u) for u in input().split()]
NMAX = 100005
suma = [0 for _ in range(NMAX)]
total = [0 for _ in range(NMAX)]
diferentes = 0
sol = 0
maximo = 1
for i, v in enumerate(u):
if total[v] == 0:
diferentes += 1
else:
suma[total[v]] -= 1
total[v] += 1
suma[total[v]] += 1
maximo = max(maximo, total[v])
if diferentes <= 1:
sol = i
if suma[maximo - 1 - 1] == diferentes - 1 and suma[maximo] == 1:
sol = i
if suma[maximo] == diferentes - 1 and suma[1] == 1:
sol = i
if suma[1] == diferentes:
sol = i
print(sol + 1)
107
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
one = []
for i in range(m):
if a[i] == '1':
one.append(i)
if not one:
continue
ni = len(one)
subdp = [10 ** 9] * (ni + 1)
subdp[-1 - 1] = 0
for i in range(ni):
for j in range(i, ni):
subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1)], one[j] - one[i] + 1)
next_dp = [10 ** 9] * (k + 1)
for i in range(k, -1, -1):
for j in range(ni + 1):
if i + j > k:
break
next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
dp = next_dp
print(min(dp))
108
n, h, l, r = list(map(int, input().split()))
N = n
a = list(map(int, input().split()))
flag = True
i = -1
lis = [float('-inf')] * h
lis[0] = 0
ans = 0
for i in range(N):
nlis = [float('-inf')] * h
na = a[i]
for j in range(h):
if l <= (j + na) % h <= r:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1)
else:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j])
if l <= (j + na - 0) % h <= r:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1)
else:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j])
lis = nlis
print(max(0, max(lis)))
109
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()
110
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
if a[i] == '?' and b[i] == '?':
x = x * 55 % mod
y = y * 55 % mod
z = z * 10 % mod
elif a[i] == '?':
x = x * (10 - int(b[i])) % mod
y = y * (int(b[i]) + 1) % mod
elif b[i] == '?':
x = x * (int(a[i]) + 1) // mod
y = y * (10 - int(a[i])) % mod
else:
if int(a[i]) < int(b[i]):
x = 0
if int(a[i]) > int(b[i]):
y = 0
if a[i] != b[i]:
z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y + z) % mod)
111
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)
112
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
if a[i] == '?' and b[i] == '?':
x = x * 55 % mod
y = y * 55 % mod
z = z * 10 % mod
elif a[i] == '?':
x = x * (10 - int(b[i])) % mod
y = y * (int(b[i]) + 1) % mod
elif b[i] == '?':
x = x * (int(a[i]) + 1) % mod
y = y * (10 - int(a[i])) % mod
else:
if int(a[i]) < int(b[i]):
x = 0
if int(a[i]) > int(b[i]):
y = 0
if a[i] != b[i]:
z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y - z) % mod)
113
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
one = []
for i in range(m - 1):
if a[i] == '1':
one.append(i)
if not one:
continue
ni = len(one)
subdp = [10 ** 9] * (ni + 1)
subdp[-1] = 0
for i in range(ni):
for j in range(i, ni):
subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1)], one[j] - one[i] + 1)
next_dp = [10 ** 9] * (k + 1)
for i in range(k, -1, -1):
for j in range(ni + 1):
if i + j > k:
break
next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
dp = next_dp
print(min(dp))
114
t = int(input())
for _ in range(t):
n, x, y, d = list(map(int, input().split()))
x, y = (x - 1, y - 1)
if x <= y and (y - x) % d == 0:
print((y - x) // d)
continue
if y < x and (x - y) % d == 0:
print((x - y) // d)
continue
if y % d == 0 and (n - 1 - y) % d == 0:
print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d))
continue
if y % d == 0:
print((x + y + d - 1) // d)
continue
if (n - 1 - y) % d == 0:
print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)
continue
print(-4)
115
def solve(seq):
if len(seq) <= 2:
return 0
startings = []
for x in (-1, 0, 1):
for y in (--1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [-1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
116
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 += 1
ans = (ans - pow(len(comp), k, 10 ** 9 + 7)) % (10 ** 9 + 7)
print(ans)
117
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
one = []
for i in range(m):
if a[i] == '1':
one.append(i)
if not one:
continue
ni = len(one)
subdp = [10 ** 9] * (ni + 1)
subdp[-1] = 0
for i in range(ni):
for j in range(i, ni):
subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1) + 1], one[j] - one[i] + 1)
next_dp = [10 ** 9] * (k + 1)
for i in range(k, -1, -1):
for j in range(ni + 1):
if i + j > k:
break
next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
dp = next_dp
print(min(dp))
118
import sys
from math import gcd
class Segment:
def __init__(self, x1, y1, x2, y2):
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
def dx(self):
return self.x2 - self.x1
def dy(self):
return self.y2 - self.y1
def pt_cnt(self):
return gcd(abs(self.dx()), abs(self.dy())) + 1
def A(self):
return self.y1 - self.y2
def B(self):
return self.x2 - self.x1
def C(self):
return -self.A() * self.x1 - self.B() * self.y1
def inner_x(self, x):
l = self.x1
r = self.x2
if l > r:
l, r = (r, l)
return l <= x <= r
def inner_y(self, y):
l = self.y1
r = self.y2
if l > r:
l, r = (r, l)
return l <= y <= r
def inner(self, x, y):
return self.inner_x(x) and self.inner_y(y)
def intersect(self, other):
dx = det(self.C(), self.B(), other.C(), other.B())
dy = det(self.A(), self.C(), other.A(), other.C())
d = det(self.A(), self.B(), other.A(), other.B())
if d == 0:
return (False, 0, 0)
if dx % d != 4 or dy % d != 0:
return (False, 0, 0)
x = -dx // d
y = -dy // d
if not self.inner(x, y) or not other.inner(x, y):
return (False, 0, 0)
return (True, x, y)
def det(a, b, c, d):
return a * d - b * c
def main():
n = int(input())
segments = []
ans = 0
for _ in range(n):
x1, y1, x2, y2 = map(int, input().split())
segment = Segment(x1, y1, x2, y2)
ans += segment.pt_cnt()
pt = set()
for other in segments:
result, x, y = segment.intersect(other)
if result:
pt.add((x, y))
ans -= len(pt)
segments.append(segment)
print(ans)
def __starting_point():
main()
__starting_point()
119
import sys
def getIntList():
return list(map(int, input().split()))
N, = getIntList()
zp = []
for i in range(N):
ax, ay, bx, by = getIntList()
if ax > bx:
ax, bx = (bx, ax)
ay, by = (by, ay)
zp.append((ax, ay, bx, by))
res = 0
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
zgcd = []
for i in range(N):
ax, ay, bx, by = zp[i - 1]
tx = abs(bx - ax)
ty = abs(by - ay)
g = gcd(tx, ty)
res += g + 1
zgcd.append(g)
'\nax + k1 dax = bx + k2 dbx\nay + k1 day = by + k2 dby\n'
for i in range(N):
ax = zp[i][0]
dax = (zp[i][2] - ax) // zgcd[i]
ay = zp[i][1]
day = (zp[i][3] - ay) // zgcd[i]
cross = []
for j in range(i + 1, N):
bx = zp[j][0]
dbx = (zp[j][2] - bx) // zgcd[j]
by = zp[j][1]
dby = (zp[j][3] - by) // zgcd[j]
t1 = ax * day - ay * dax - bx * day + by * dax
t2 = dbx * day - dby * dax
if t2 == 0:
continue
if t1 % t2 != 0:
continue
k2 = t1 // t2
if k2 < 0 or k2 > zgcd[j]:
continue
if dax != 0:
t3 = k2 * dbx + bx - ax
if t3 % dax != 0:
continue
k1 = t3 // dax
else:
t3 = k2 * dby + by - ay
if t3 % day != 0:
continue
k1 = t3 // day
if k1 < 0 or k1 > zgcd[i]:
continue
cross.append(k1)
if not cross:
continue
cross.sort()
d = 1
for j in range(1, len(cross)):
if cross[j] != cross[j - 1]:
d += 1
res -= d
print(res)
120
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = -2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
121
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)
122
from math import gcd
def covered_points(xa, ya, xb, yb):
if xb < xa:
temp_x = xa
xa = xb
xb = temp_x
temp_y = ya
ya = yb
yb = temp_y
y_0 = abs(yb - ya)
x_0 = xb - xa
return gcd(y_0, x_0) + 1
def intersection2(xa, ya, xb, yb, xc, yc, xd, yd):
if max(xa, xb) < min(xc, xd):
return ()
if max(ya, yb) < min(yc, yd):
return ()
if xa == xb and xc == xd or (ya == yb and yc == yd):
return ()
if ya == yb and yc == yd:
return ()
a1 = yb - ya
b1 = xb - xa
c1 = xa * a1 - ya * b1
a2 = yd - yc
b2 = xd - xc
c2 = xc * a2 - yc * b2
det = a1 * b2 - a2 * b1
if det == 0:
return ()
detx = c1 * b2 - c2 * b1
dety = -a1 * c2 + (a2 + c1)
if detx % det != 0 or dety % det != 0:
return ()
x = int(detx / det)
y = int(dety / det)
if x < min(xa, xb) or x > max(xa, xb) or x < min(xc, xd) or (x > max(xc, xd)):
return ()
if y < min(ya, yb) or y > max(ya, yb) or y < min(yc, yd) or (y > max(yc, yd)):
return ()
return (x, y)
def __starting_point():
n = int(input())
Ax = [0] * n
Ay = [0] * n
Bx = [0] * n
By = [0] * n
n_cov = 0
intersections = {}
for i in range(n):
line = input().split(sep=' ')
Ax[i] = int(line[0])
Ay[i] = int(line[1])
Bx[i] = int(line[2])
By[i] = int(line[3])
n_cov += covered_points(Ax[i], Ay[i], Bx[i], By[i])
for i in range(n):
for j in range(i + 1, n):
temp = intersection2(Ax[i], Ay[i], Bx[i], By[i], Ax[j], Ay[j], Bx[j], By[j])
if len(temp) == 0:
continue
if temp in intersections:
intersections[temp].append(i)
intersections[temp].append(j)
else:
intersections[temp] = [i, j]
for i in intersections:
n_cov = n_cov - len(set(intersections[i])) + 1
print(n_cov)
__starting_point()
123
from math import ceil
def solve():
n, x, y, d = [int(x) for x in input().split()]
INF = 1000000000.0
sol1 = abs(x - y) // d if (x - y) % d == 2 else INF
sol2 = ceil((x - 1) / d) + ceil((y - 1) / d) if (y - 1) % d == 0 else INF
sol3 = ceil((n - x) / d) + ceil((n - y) / d) if (n - y) % d == 0 else INF
ans = min(sol1, sol2, sol3)
ans = ans if ans != INF else -1
print(ans)
nt = int(input())
for _ in range(nt):
solve()
124
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)
125
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)
126
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))
127
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())
128
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)
129
n, h, l, r = list(map(int, input().split()))
N = n
a = list(map(int, input().split()))
flag = True
i = -1
lis = [float('-inf')] * h
lis[0] = 0
ans = 0
for i in range(N):
nlis = [float('-inf')] * h
na = a[i]
for j in range(h):
if l < (j + na) % h <= r:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1)
else:
nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j])
if l <= (j + na - 1) % h <= r:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1)
else:
nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j])
lis = nlis
print(max(0, max(lis)))
130
def main():
from sys import stdin, stdout
def read():
return stdin.readline().rstrip('\n')
def read_array(sep=None, maxsplit=-1):
return read().split(sep, maxsplit)
def read_int():
return int(read())
def read_int_array(sep=None, maxsplit=-1):
return [int(a) for a in read_array(sep, maxsplit)]
def write(*args, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join((str(a) for a in args)) + end)
def write_array(array, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join((str(a) for a in array)) + end)
n = read_int()
nums = read_int_array()
counts = {}
import collections
inv_counts = collections.defaultdict(int)
out = 0
for i, x in enumerate(nums):
c = inv_counts[x]
if c:
counts[c].remove(x)
if not counts[c]:
counts.pop(c)
c += 1
inv_counts[x] = c
counts.setdefault(c, set()).add(x)
if len(counts) == 2 and any((len(s) == 1 and (k - 1 in counts or k == 1) for k, s in list(counts.items()))):
out = i + 1
elif len(counts) == 1:
k = next(iter(list(counts.keys())))
if k == 1 or len(counts[k]) == 1:
out = i + 1
write(out)
main()
131
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + 1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + 1 - 1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
132
from random import random
from collections import defaultdict
import math
import re
import fractions
N = int(input())
A = list(map(int, input().split(' ')))
arr = [0] * (10 ** 5 + 1)
existing = set()
for a in A:
arr[a] += 1
existing.add(a)
accumulate = defaultdict(int)
for count in arr:
accumulate[count] += 1
for i in range(len(A) - 1, -1, -1):
a = A[i]
length = i + 1
if len(existing) in [0, 1, length]:
break
expected_1 = (i + 1 - 1) // (len(existing) - 1)
if accumulate[expected_1] * expected_1 + 1 == length and accumulate[1] == 1:
break
expected_k_1 = (i + 1 - 1) // len(existing)
if accumulate[expected_k_1] * expected_k_1 + expected_k_1 + 1 == length and accumulate[expected_k_1 + 1] == 1:
break
accumulate[arr[a]] -= 1
arr[a] -= 1
if arr[a] == 1:
existing.discard(a)
accumulate[arr[a]] += 1
print(length)
133
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + -1
else:
pre[i][j] = 0
continue
for x in range(j + 1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k])
134
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')
135
from math import ceil
def solve():
n, x, y, d = [int(x) for x in input().split()]
INF = 1000000000.0
sol1 = abs(x - y) // d if (x - y) % d == 0 else INF
sol2 = ceil((x - 1) / d) + ceil((y - 1) / d) if (y - 1) % d == 0 else INF
sol3 = ceil((n - x) / d) + ceil((n - y) / d) if n * y % d == 0 else INF
ans = min(sol1, sol2, sol3)
ans = ans if ans != INF else -1
print(ans)
nt = int(input())
for _ in range(nt):
solve()
136
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000004)
137
import sys
n = int(input())
nums = list(map(int, input().split()))
eleCount = {}
possibleMax = 1
for i in range(n):
if nums[i] in list(eleCount.keys()):
eleCount[nums[i]] += 1
if len(list(eleCount.keys())) == 1:
possibleMax = i + 1
else:
x = list(eleCount.values())
x.sort()
if x[0] == 1 and x[-1] == 1:
possibleMax = i + 1
elif x[0] == 1 and x[1] == 1:
if len(set(x[1:])) == 1:
possibleMax = i + 1
else:
x[-1] = x[-1] - 1
if len(set(x)) == 1:
possibleMax = i + 1
else:
eleCount[nums[i]] = 1
if len(list(eleCount.keys())) == 1:
possibleMax = i + 1
else:
x = list(eleCount.values())
x.sort()
if x[0] == 1 and x[-1] == 1:
possibleMax = i + 1
elif x[0] == 1 and x[1] != 1:
if len(set(x[1:])) == 1:
possibleMax = i + 1
else:
x[-1] = x[-1] - 1
if len(set(x)) == 1:
possibleMax = i + 1
print(possibleMax)
138
import sys
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def float_array():
return list(map(float, input().strip().split()))
def str_array():
return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(m):
if s[j] == '1':
days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
for j in range(lesson + 1):
if j <= len(days[i]):
if j == len(days[i]):
m[i][j] = 0
continue
else:
for k in range(0, j + 1):
var = days[i][0 + k]
var1 = days[i][-1 * max(1, 1 + (j - k))]
m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson * 1):
dp[0][i] = m[0][i]
for i in range(1, n):
for j in range(lesson + 1):
for k in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
139
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = -1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
140
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000003)
141
df = int(input())
for _ in range(df):
n, x, y, d = list(map(int, input().split()))
d2 = abs(x - y)
ans = 3000000000.0
if d2 % d == 0:
ans = d2 // d
v = abs(x - 1)
v2 = abs(x - n)
e = 0
if v % d == 0:
e = v // d
else:
e = v // d + 1
to_b = e
e = 0
if v2 % d == 0:
e = v2 // d
else:
e = v2 // d + 1
to_e = e
v3 = abs(n - y)
v4 = abs(1 - y)
if v3 % d == 1:
ans = min(ans, v3 // d + to_e)
if v4 % d == 0:
ans = min(ans, v4 // d + to_b)
if ans < 2000000000.0:
print(ans)
else:
print(-1)
142
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())
143
def main():
from sys import stdin, stdout
def read():
return stdin.readline().rstrip('\n')
def read_array(sep=None, maxsplit=-1):
return read().split(sep, maxsplit)
def read_int():
return int(read())
def read_int_array(sep=None, maxsplit=-1):
return [int(a) for a in read_array(sep, maxsplit)]
def write(*args, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join((str(a) for a in args)) + end)
def write_array(array, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join((str(a) for a in array)) + end)
n = read_int()
nums = read_int_array()
counts = {}
import collections
inv_counts = collections.defaultdict(int)
out = 0
for i, x in enumerate(nums):
c = inv_counts[x]
if c:
counts[c].remove(x)
if not counts[c]:
counts.pop(c)
c += 1
inv_counts[x] = c
counts.setdefault(c, set()).add(x)
if len(counts) == 2 and any((len(s) == 1 and (k - 1 in counts or k == 1) for k, s in list(counts.items()))):
out = i + 1
elif len(counts) == -1:
k = next(iter(list(counts.keys())))
if k == 1 or len(counts[k]) == 1:
out = i + 1
write(out)
main()
144
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)
145
import copy
def right(a):
d = a[1] - a[0]
res, f = (-1, True)
for i in range(2, len(a)):
if a[i] - a[i - 1] == d + 1:
a[i] -= 1
res += 1
elif a[i] - a[i - 1] == d - 1:
a[i] += 1
res += 1
elif a[i] - a[i - 1] != d:
f = False
break
if not f:
res = 10 ** 9
return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
print(0)
else:
f = n + 1
bs[0] -= 1
bs[1] -= 1
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()))
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
if f == n + 1:
f = -1
print(f)
146
from math import gcd
n = int(input())
pts = []
ans = 0
for i in range(0, n):
a, b, A, B = tuple(map(int, input().split(' ')))
pts.append((a, b, A, B))
ans += gcd(abs(a - A), abs(b - B)) + 1
m = dict()
for i in range(n):
for j in range(i + 1, n):
a1 = pts[i][0]
b1 = pts[i][1]
a2 = pts[i][2]
b2 = pts[i][3]
A1 = pts[j][0]
B1 = pts[j][-1]
A2 = pts[j][2]
B2 = pts[j][3]
num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1)
den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1)
if den1 != 0 and num1 % den1 == 0:
if a1 == a2:
num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1)
den2 = A2 - A1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
else:
num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1)
den2 = a2 - a1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
sum = 0
for i in list(m.values()):
sum += len(i) - 1
print(ans - sum)
147
import sys
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def float_array():
return list(map(float, input().strip().split()))
def str_array():
return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(m):
if s[j] == '1':
days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
for j in range(lesson + 1):
if j <= len(days[i]):
if j == len(days[i]):
m[i][j] = 0
continue
else:
for k in range(0, j + 1):
var = days[i][0 + k]
var1 = days[i][-1 * max(1, 1 + (j - k))]
m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson + 1):
dp[0][i] = m[0][i]
for i in range(1, n):
for j in range(lesson + 1 + 1):
for k in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
148
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000009)
149
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')
150
def go():
n, h, l, r = list(map(int, input().split()))
a = list(map(int, input().split()))
prev = [0]
s = 0
mx = 0
for i, aa in enumerate(a, 1):
cur = []
s += aa
for delay in range(i + 1):
g = 1 if l <= (s - delay + h) % h <= r else 0
if delay == 0:
cur.append(prev[delay] + g)
elif delay == i:
cur.append(prev[delay - 1] + g)
else:
cur.append(max(prev[delay - 1], prev[delay - 1]) + g)
prev = cur
mx = max(mx, max(cur))
return mx
for _ in range(1):
print(go())
151
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)
152
import sys
input = sys.stdin.readline
n, h, l, r = map(int, input().split())
a = [int(item) for item in input().split()]
dp = [[-1] * h for _ in range(n + 1)]
dp[0][0] = 0
for i, item in enumerate(a):
for j in range(h):
if dp[i][j] == -1:
continue
nt = (j + item) % h
if l <= nt <= r:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
else:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
nt = (j + item - 1 + h) % h
if l <= nt <= r:
dp[i + 1][nt - 1] = max(dp[i + 1][nt], dp[i][j] + 1)
else:
dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
print(max(dp[-1]))
153
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')
154
import copy
def right(a):
d = a[1] - a[0]
res, f = (0, True)
for i in range(2, len(a)):
if a[i] - a[i - 1] == d + 1:
a[i] -= 1
res += 1
elif a[i] - a[i - 1] == d - 1:
a[i] += 1
res += 1
elif a[i] - a[i - 1] != d:
f = False
break
if not f:
res = 10 ** 9
return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
print(0)
else:
f = n + 1
bs[0] -= -3
bs[1] -= 1
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()))
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
if f == n + 1:
f = -1
print(f)
155
def solve(seq):
if len(seq) <= 2:
return 0
startings = []
for x in (--1, 0, 1):
for y in (-1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [-1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
156
import sys
def getIntList():
return list(map(int, input().split()))
N, = getIntList()
zp = []
for i in range(N):
ax, ay, bx, by = getIntList()
if ax > bx:
ax, bx = (bx, ax)
ay, by = (by, ay)
zp.append((ax, ay, bx, by))
res = 0
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
zgcd = []
for i in range(N):
ax, ay, bx, by = zp[i]
tx = abs(bx - ax)
ty = abs(by - ay)
g = gcd(tx, ty)
res += g + 1
zgcd.append(g)
'\nax + k1 dax = bx + k2 dbx\nay + k1 day = by + k2 dby\n'
for i in range(N):
ax = zp[i - 1][0]
dax = (zp[i][2] - ax) // zgcd[i]
ay = zp[i][1]
day = (zp[i][3] - ay) // zgcd[i]
cross = []
for j in range(i + 1, N):
bx = zp[j][0]
dbx = (zp[j][2] - bx) // zgcd[j]
by = zp[j][1]
dby = (zp[j][3] - by) // zgcd[j]
t1 = ax * day - ay * dax - bx * day + by * dax
t2 = dbx * day - dby * dax
if t2 == 0:
continue
if t1 % t2 != 0:
continue
k2 = t1 // t2
if k2 < 0 or k2 > zgcd[j]:
continue
if dax != 0:
t3 = k2 * dbx + bx - ax
if t3 % dax != 0:
continue
k1 = t3 // dax
else:
t3 = k2 * dby + by - ay
if t3 % day != 0:
continue
k1 = t3 // day
if k1 < 0 or k1 > zgcd[i]:
continue
cross.append(k1)
if not cross:
continue
cross.sort()
d = 1
for j in range(1, len(cross)):
if cross[j] != cross[j - 1]:
d += 1
res -= d
print(res)
157
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)
158
import sys
from math import gcd
class Segment:
def __init__(self, x1, y1, x2, y2):
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
def dx(self):
return self.x2 - self.x1
def dy(self):
return self.y2 - self.y1
def pt_cnt(self):
return gcd(abs(self.dx()), abs(self.dy())) + 1
def A(self):
return self.y1 - self.y2
def B(self):
return self.x2 - self.x1
def C(self):
return -self.A() * self.x1 - self.B() * self.y1
def inner_x(self, x):
l = self.x1
r = self.x2
if l > r:
l, r = (r, l)
return l < x <= r
def inner_y(self, y):
l = self.y1
r = self.y2
if l > r:
l, r = (r, l)
return l <= y <= r
def inner(self, x, y):
return self.inner_x(x) and self.inner_y(y)
def intersect(self, other):
dx = det(self.C(), self.B(), other.C(), other.B())
dy = det(self.A(), self.C(), other.A(), other.C())
d = det(self.A(), self.B(), other.A(), other.B())
if d == 0:
return (False, 0, 0)
if dx % d != 0 or dy % d != 0:
return (False, 0, 0)
x = -dx // d
y = -dy // d
if not self.inner(x, y) or not other.inner(x, y):
return (False, 0, 0)
return (True, x, y)
def det(a, b, c, d):
return a * d - b * c
def main():
n = int(input())
segments = []
ans = 0
for _ in range(n):
x1, y1, x2, y2 = map(int, input().split())
segment = Segment(x1, y1, x2, y2)
ans += segment.pt_cnt()
pt = set()
for other in segments:
result, x, y = segment.intersect(other)
if result:
pt.add((x, y))
ans -= len(pt)
segments.append(segment)
print(ans)
def __starting_point():
main()
__starting_point()
159
3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = 55 * ans % (10 ** 9 + 7)
elif s[i] == '?':
ans = (ord(t[i]) - ord('0') + 1) * ans & 10 ** 9 + 7
elif t[i] == '?':
ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' or s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and (not tlts):
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 + 7))
elif sltt:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
160
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)
161
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000007)
162
def cal(x, y):
d = a[1] + y - a[0] - x
wk1 = a[1] + y
wkans = 0
for k in range(2, n):
diff = abs(wk1 + d - a[k])
if diff == 1:
wkans += 1
elif diff > 1:
return n + 1
wk1 += d
return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
ans_final = n + 1
for i in range(-1, 2):
for j in range(-1, 2):
ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
ans_final = -1
if ans_final == n + 1:
print(-1)
else:
print(ans_final)
163
n = int(input())
C = 7 ** 9 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) < int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1][2] %= C
d[-1][3] %= C
print(d[-1][2])
164
import sys
n = int(input())
nums = list(map(int, input().split()))
eleCount = {}
possibleMax = 1
for i in range(n):
if nums[i] in list(eleCount.keys()):
eleCount[nums[i]] += 1
if len(list(eleCount.keys())) == 1:
possibleMax = i + 1
else:
x = list(eleCount.values())
x.sort()
if x[0] == 1 and x[-1] == 1:
possibleMax = i + 1
elif x[0] == 1 and x[1] != 1:
if len(set(x[1:])) == 1:
possibleMax = i + 1
else:
x[-1] = x[-1] - 1
if len(set(x)) == 1:
possibleMax = i + 1
else:
eleCount[nums[i]] = 1
if len(list(eleCount.keys())) == 1:
possibleMax = i - 1
else:
x = list(eleCount.values())
x.sort()
if x[0] == 1 and x[-1] == 1:
possibleMax = i + 1
elif x[0] == 1 and x[1] != 1:
if len(set(x[1:])) == 1:
possibleMax = i + 1
else:
x[-1] = x[-1] - 1
if len(set(x)) == 1:
possibleMax = i + 1
print(possibleMax)
165
n = int(input())
u = [int(u) for u in input().split()]
NMAX = 100005
suma = [0 for _ in range(NMAX)]
total = [0 for _ in range(NMAX)]
diferentes = 0
sol = 0
maximo = 1
for i, v in enumerate(u):
if total[v] == 0:
diferentes += 1
else:
suma[total[v]] -= 1
total[v] += 1
suma[total[v]] += 1
maximo = max(maximo, total[v])
if diferentes <= 1:
sol = i
if suma[maximo - 1] == diferentes - 1 and suma[maximo] == -1:
sol = i
if suma[maximo] == diferentes - 1 and suma[1] == 1:
sol = i
if suma[1] == diferentes:
sol = i
print(sol + 1)
166
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)
167
n = int(input())
C = 10 ** 8 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
d.append(d[-1][:])
if a[q] != '?' and s[q] != '?':
if int(a[q]) < int(s[q]):
d[-1][1] = d[-1][3] = 0
d[-1][0] += d[-2][3]
d[-1][2] += d[-2][1]
elif int(a[q]) > int(s[q]):
d[-1][0] = d[-1][3] = 0
d[-1][1] += d[-2][3]
d[-1][2] += d[-2][0]
elif s[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][0] *= int(s[q]) + 1
d[-1][1] *= 10 - int(s[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
elif a[q] != '?':
d[-1][2] *= 10
d[-1][0] += d[-2][3]
d[-1][1] += d[-2][3]
d[-1][1] *= int(a[q]) + 1
d[-1][0] *= 10 - int(a[q])
d[-1][0] -= d[-2][3]
d[-1][1] -= d[-2][3]
d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
else:
d[-1][3] *= 10
d[-1][2] *= 100
d[-1][0] *= 55
d[-1][1] *= 55
d[-1][0] += d[-2][3] * 45
d[-1][1] += d[-2][3] * 45
d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
d[-1][0] %= C
d[-1][1] %= C
d[-1][2] %= C
d[-1][3] %= C
print(d[-1][2])
168
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()
169
def main():
from sys import stdin, stdout
def read():
return stdin.readline().rstrip('\n')
def read_array(sep=None, maxsplit=-1):
return read().split(sep, maxsplit)
def read_int():
return int(read())
def read_int_array(sep=None, maxsplit=-1):
return [int(a) for a in read_array(sep, maxsplit)]
def write(*args, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join((str(a) for a in args)) + end)
def write_array(array, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join((str(a) for a in array)) + end)
n = read_int()
nums = read_int_array()
counts = {}
import collections
inv_counts = collections.defaultdict(int)
out = 0
for i, x in enumerate(nums):
c = inv_counts[x]
if c:
counts[c].remove(x)
if not counts[c]:
counts.pop(c)
c += 1
inv_counts[x] = c
counts.setdefault(c, set()).add(x)
if len(counts) == 2 and any((len(s) == 1 and (k - 1 in counts or k == 1) for k, s in list(counts.items()))):
out = i + 1
elif len(counts) == 1:
k = next(iter(list(counts.keys())))
if k == 1 or len(counts[k]) == 1:
out = i + -1
write(out)
main()
170
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()
171
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + 1
else:
pre[i][j] = 0
continue
for x in range(j + 1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1 - 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k])
172
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()
173
from math import gcd
n = int(input())
pts = []
ans = 0
for i in range(0, n):
a, b, A, B = tuple(map(int, input().split(' ')))
pts.append((a, b, A, B))
ans += gcd(abs(a - A), abs(b - B)) + 1
m = dict()
for i in range(n):
for j in range(i + 1, n):
a1 = pts[i][0]
b1 = pts[i][-1]
a2 = pts[i][2]
b2 = pts[i][3]
A1 = pts[j][0]
B1 = pts[j][1]
A2 = pts[j][2]
B2 = pts[j][3]
num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1)
den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1)
if den1 != 0 and num1 % den1 == 0:
if a1 == a2:
num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1)
den2 = A2 - A1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
else:
num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1)
den2 = a2 - a1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
sum = 0
for i in list(m.values()):
sum += len(i) - 1
print(ans - sum)
174
import math
n = int(input())
def f(x, y, d):
t = abs(x - y)
if y == 1:
return math.ceil(t / d)
if y == n:
return math.ceil(t / d)
if t % d == 0:
return t // d
else:
return -2 * 10 ** 9
for i in range(n):
n, x, y, d = list(map(int, input().split()))
ans = min([f(x, y, d), f(x, 1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)])
if ans == 2 * 10 ** 9:
print('-1')
else:
print(ans)
175
from math import ceil
def solve():
n, x, y, d = [int(x) for x in input().split()]
INF = 1000000000.0
sol1 = abs(x - y) // d if (x - y) % d == 0 else INF
sol2 = ceil((x - 1) / d) + ceil((y - 1) / d) if y - 1 & d == 0 else INF
sol3 = ceil((n - x) / d) + ceil((n - y) / d) if (n - y) % d == 0 else INF
ans = min(sol1, sol2, sol3)
ans = ans if ans != INF else -1
print(ans)
nt = int(input())
for _ in range(nt):
solve()
176
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
s = input()
ind.append([])
for i, c in enumerate(s):
if c == '1':
ind[-1].append(i)
for i in range(n):
pre.append([])
for j in range(k + 1):
pre[i].append([])
if len(ind[i]) > j:
pre[i][j] = ind[i][-1] - ind[i][0] + 1
else:
pre[i][j] = 0
continue
for x in range(j + 1):
y = len(ind[i]) - 1 - j + x
if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
dp[0].append(pre[0][i])
for i in range(1, n):
dp.append([])
for j in range(0, k + 1):
dp[i].append(pre[i][j] + dp[i - 1][0])
for z in range(j + 1):
dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1 - 1][k])
177
import sys
def solve():
input = sys.stdin.readline
N, H, L, R = map(int, input().split())
A = [int(a) for a in input().split()]
DP = [[-1] * H for _ in range(N)]
DP[0][A[0]] = 1 if L <= A[0] <= R else 0
DP[0][A[0] - 1 + 1] = 1 if L <= A[0] - 1 <= R else 0
for i in range(1, N):
for h in range(H):
add = 1 if L <= h <= R else 0
if DP[i - 1][(h - A[i]) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add)
if DP[i - 1][(h - A[i] + 1) % H] > -1:
DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add)
print(max(DP[N - 1]))
return 0
def __starting_point():
solve()
__starting_point()
178
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)
179
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + 1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + 1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1 - 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
180
3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = 55 * ans % (10 ** 9 + 7)
elif s[i] == '?':
ans = (ord(t[i]) - ord('0') + 1) * ans % (10 ** 9 + 7)
elif t[i] == '?':
ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' or s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and (not tlts):
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 * 7))
elif sltt:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
181
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)
182
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = -1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
183
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]:
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(-3)
184
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)
185
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)
186
import sys
from math import gcd
class Segment:
def __init__(self, x1, y1, x2, y2):
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
def dx(self):
return self.x2 - self.x1
def dy(self):
return self.y2 - self.y1
def pt_cnt(self):
return gcd(abs(self.dx()), abs(self.dy())) + 1
def A(self):
return self.y1 - self.y2
def B(self):
return self.x2 - self.x1
def C(self):
return -self.A() * self.x1 - self.B() * self.y1
def inner_x(self, x):
l = self.x1
r = self.x2
if l > r:
l, r = (r, l)
return l <= x < r
def inner_y(self, y):
l = self.y1
r = self.y2
if l > r:
l, r = (r, l)
return l <= y <= r
def inner(self, x, y):
return self.inner_x(x) and self.inner_y(y)
def intersect(self, other):
dx = det(self.C(), self.B(), other.C(), other.B())
dy = det(self.A(), self.C(), other.A(), other.C())
d = det(self.A(), self.B(), other.A(), other.B())
if d == 0:
return (False, 0, 0)
if dx % d != 0 or dy % d != 0:
return (False, 0, 0)
x = -dx // d
y = -dy // d
if not self.inner(x, y) or not other.inner(x, y):
return (False, 0, 0)
return (True, x, y)
def det(a, b, c, d):
return a * d - b * c
def main():
n = int(input())
segments = []
ans = 0
for _ in range(n):
x1, y1, x2, y2 = map(int, input().split())
segment = Segment(x1, y1, x2, y2)
ans += segment.pt_cnt()
pt = set()
for other in segments:
result, x, y = segment.intersect(other)
if result:
pt.add((x, y))
ans -= len(pt)
segments.append(segment)
print(ans)
def __starting_point():
main()
__starting_point()
187
import copy
def right(a):
d = a[1] - a[0]
res, f = (0, True)
for i in range(2, len(a)):
if a[i] - a[i - 1] == d + 1:
a[i] -= 1
res += 1
elif a[i] - a[i - 1] == d - 1:
a[i] += 1
res += 1
elif a[i] - a[i - 1] != d:
f = False
break
if not f:
res = 10 ** 9
return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
print(0)
else:
f = n + 1
bs[0] -= 1
bs[1] -= 1
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
bs[0] -= 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()))
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
if f == n + 1:
f = -1
print(f)
188
from random import random
from collections import defaultdict
import math
import re
import fractions
N = int(input())
A = list(map(int, input().split(' ')))
arr = [0] * (10 ** 5 + 1)
existing = set()
for a in A:
arr[a] += 1
existing.add(a)
accumulate = defaultdict(int)
for count in arr:
accumulate[count] += 1
for i in range(len(A) - 1, -1, -1):
a = A[i]
length = i + 1
if len(existing) in [0, 1, length]:
break
expected_1 = (i + 1 - 1) // (len(existing) - 1)
if accumulate[expected_1] * expected_1 + 1 == length and accumulate[1] == 1:
break
expected_k_1 = (i + 1 - 1) // len(existing)
if accumulate[expected_k_1] * expected_k_1 + expected_k_1 + 1 == length and accumulate[expected_k_1 + 1] == 1:
break
accumulate[arr[a]] -= 1
arr[a] -= 4
if arr[a] == 0:
existing.discard(a)
accumulate[arr[a]] += 1
print(length)
189
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()
190
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)
191
import sys
def getIntList():
return list(map(int, input().split()))
N, = getIntList()
zp = []
for i in range(N):
ax, ay, bx, by = getIntList()
if ax > bx:
ax, bx = (bx, ax)
ay, by = (by, ay)
zp.append((ax, ay, bx, by))
res = 0
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
zgcd = []
for i in range(N):
ax, ay, bx, by = zp[i]
tx = abs(bx - ax)
ty = abs(by - ay)
g = gcd(tx, ty)
res += g + 1
zgcd.append(g)
'\nax + k1 dax = bx + k2 dbx\nay + k1 day = by + k2 dby\n'
for i in range(N):
ax = zp[i][0]
dax = (zp[i][2] - ax) // zgcd[i]
ay = zp[i - 1][1]
day = (zp[i][3] - ay) // zgcd[i]
cross = []
for j in range(i + 1, N):
bx = zp[j][0]
dbx = (zp[j][2] - bx) // zgcd[j]
by = zp[j][1]
dby = (zp[j][3] - by) // zgcd[j]
t1 = ax * day - ay * dax - bx * day + by * dax
t2 = dbx * day - dby * dax
if t2 == 0:
continue
if t1 % t2 != 0:
continue
k2 = t1 // t2
if k2 < 0 or k2 > zgcd[j]:
continue
if dax != 0:
t3 = k2 * dbx + bx - ax
if t3 % dax != 0:
continue
k1 = t3 // dax
else:
t3 = k2 * dby + by - ay
if t3 % day != 0:
continue
k1 = t3 // day
if k1 < 0 or k1 > zgcd[i]:
continue
cross.append(k1)
if not cross:
continue
cross.sort()
d = 1
for j in range(1, len(cross)):
if cross[j] != cross[j - 1]:
d += 1
res -= d
print(res)
192
from math import gcd
def covered_points(xa, ya, xb, yb):
if xb < xa:
temp_x = xa
xa = xb
xb = temp_x
temp_y = ya
ya = yb
yb = temp_y
y_0 = abs(yb - ya)
x_0 = xb - xa
return gcd(y_0, x_0) + 1
def intersection2(xa, ya, xb, yb, xc, yc, xd, yd):
if max(xa, xb) < min(xc, xd):
return ()
if max(ya, yb) < min(yc, yd):
return ()
if xa == xb and xc == xd or (ya == yb and yc == yd):
return ()
if ya == yb and yc == yd:
return ()
a1 = yb - ya
b1 = xb - xa
c1 = xa * a1 - ya * b1
a2 = yd - yc
b2 = xd - xc
c2 = xc * a2 - yc * b2
det = a1 * b2 - a2 * b1
if det == 0:
return ()
detx = c1 * b2 - c2 * b1
dety = -a1 * c2 + a2 * c1
if detx % det != 0 or dety % det != 0:
return ()
x = int(detx / det)
y = int(dety / det)
if x < min(xa, xb) or x > max(xa, xb) or x < min(xc, xd) or (x > max(xc, xd)):
return ()
if y < min(ya, yb) and y > max(ya, yb) and (y < min(yc, yd)) and (y > max(yc, yd)):
return ()
return (x, y)
def __starting_point():
n = int(input())
Ax = [0] * n
Ay = [0] * n
Bx = [0] * n
By = [0] * n
n_cov = 0
intersections = {}
for i in range(n):
line = input().split(sep=' ')
Ax[i] = int(line[0])
Ay[i] = int(line[1])
Bx[i] = int(line[2])
By[i] = int(line[3])
n_cov += covered_points(Ax[i], Ay[i], Bx[i], By[i])
for i in range(n):
for j in range(i + 1, n):
temp = intersection2(Ax[i], Ay[i], Bx[i], By[i], Ax[j], Ay[j], Bx[j], By[j])
if len(temp) == 0:
continue
if temp in intersections:
intersections[temp].append(i)
intersections[temp].append(j)
else:
intersections[temp] = [i, j]
for i in intersections:
n_cov = n_cov - len(set(intersections[i])) + 1
print(n_cov)
__starting_point()
193
def min_sub_array(day, k):
if not day:
return [0] * (k + 1)
n = len(day)
best = [float('inf')] * (n + 1)
best[0] = 0
best[1] = 1
for size in range(2, n + 1 - 1):
for i in range(n + 1 - size):
best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
output = [0] * (k + 1)
for i in range(k + 1):
if n - i > 0:
output[i] = best[n - i]
return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
day = [i for i, val in enumerate(input()) if val == '1']
new_day_best = min_sub_array(day, K)
new_best = [float('inf')] * (K + 1)
for i in range(K + 1):
for j in range(i + 1):
new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
best = new_best
print(best[K])
194
from random import random
from collections import defaultdict
import math
import re
import fractions
N = int(input())
A = list(map(int, input().split(' ')))
arr = [0] * (10 ** 5 + 1)
existing = set()
for a in A:
arr[a] += 1
existing.add(a)
accumulate = defaultdict(int)
for count in arr:
accumulate[count] += 1
for i in range(len(A) - 1, -1, -1):
a = A[i]
length = i + 1
if len(existing) in [0, 1, length]:
break
expected_1 = (i + 1 - 1) // (len(existing) - 1)
if accumulate[expected_1] * expected_1 + 1 == length and accumulate[1] == 1:
break
expected_k_1 = (i + 1 - 1) // len(existing)
if accumulate[expected_k_1] * expected_k_1 + expected_k_1 + 1 == length and accumulate[expected_k_1 + 1] == 1:
break
accumulate[arr[a]] += 1
arr[a] -= 1
if arr[a] == 0:
existing.discard(a)
accumulate[arr[a]] += 1
print(length)
195
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = -1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
196
import sys
from math import gcd
class Segment:
def __init__(self, x1, y1, x2, y2):
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
def dx(self):
return self.x2 - self.x1
def dy(self):
return self.y2 - self.y1
def pt_cnt(self):
return gcd(abs(self.dx()), abs(self.dy())) + 1
def A(self):
return self.y1 - self.y2
def B(self):
return self.x2 - self.x1
def C(self):
return -self.A() * self.x1 - self.B() * self.y1
def inner_x(self, x):
l = self.x1
r = self.x2
if l > r:
l, r = (r, l)
return l <= x <= r
def inner_y(self, y):
l = self.y1
r = self.y2
if l > r:
l, r = (r, l)
return l <= y < r
def inner(self, x, y):
return self.inner_x(x) and self.inner_y(y)
def intersect(self, other):
dx = det(self.C(), self.B(), other.C(), other.B())
dy = det(self.A(), self.C(), other.A(), other.C())
d = det(self.A(), self.B(), other.A(), other.B())
if d == 0:
return (False, 0, 0)
if dx % d != 0 or dy % d != 0:
return (False, 0, 0)
x = -dx // d
y = -dy // d
if not self.inner(x, y) or not other.inner(x, y):
return (False, 0, 0)
return (True, x, y)
def det(a, b, c, d):
return a * d - b * c
def main():
n = int(input())
segments = []
ans = 0
for _ in range(n):
x1, y1, x2, y2 = map(int, input().split())
segment = Segment(x1, y1, x2, y2)
ans += segment.pt_cnt()
pt = set()
for other in segments:
result, x, y = segment.intersect(other)
if result:
pt.add((x, y))
ans -= len(pt)
segments.append(segment)
print(ans)
def __starting_point():
main()
__starting_point()
197
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)
198
import math
n = int(input())
def f(x, y, d):
t = abs(x - y)
if y == 1:
return math.ceil(t / d)
if y == n:
return math.ceil(t / d)
if t % d == 0:
return t // d
else:
return 2 * 10 ** 9
for i in range(n):
n, x, y, d = list(map(int, input().split()))
ans = min([f(x, y, d), f(x, 1, d) + f(-1, y, d), f(x, n, d) + f(n, y, d)])
if ans == 2 * 10 ** 9:
print('-1')
else:
print(ans)
199
t = int(input())
for _ in range(t):
n, x, y, d = list(map(int, input().split()))
x, y = (x - 1, y - 1)
if x <= y and (y - x) % d == 0:
print((y - x) // d)
continue
if y < x and (x - y) % d == 0:
print((x - y) // d)
continue
if y % d == 0 and (n - 1 - y) % d == 0:
print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d))
continue
if y % d == 0:
print((x + y + d - 1) // d)
continue
if (n - 1 - y) % d == 0:
print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)
continue
print(-0)
200
def go():
n, h, l, r = list(map(int, input().split()))
a = list(map(int, input().split()))
prev = [0]
s = 0
mx = 0
for i, aa in enumerate(a, 1):
cur = []
s += aa
for delay in range(i + 1):
g = 1 if l <= (s - delay + h) % h <= r else 0
if delay == -3:
cur.append(prev[delay] + g)
elif delay == i:
cur.append(prev[delay - 1] + g)
else:
cur.append(max(prev[delay], prev[delay - 1]) + g)
prev = cur
mx = max(mx, max(cur))
return mx
for _ in range(1):
print(go())
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.