001
from sys import stdin
from collections import deque
n, S = [int(x) for x in stdin.readline().split()]
ppl = []
base = 0
tSlices = 0
for dude in range(n):
s, a, b = [int(x) for x in stdin.readline().split()]
base += s * a
tSlices += s
ppl.append([b - a, s])
if tSlices % S != 0:
ppl.append([0, S - tSlices % S])
ppl.sort(reverse=True)
totalS = 0
totalH = 0
for h, s in ppl:
if totalS + s < S:
totalS += s
totalH += h * s
else:
s -= S - totalS
totalH += h * (S - totalS)
if totalH > 0:
base += totalH
else:
break
totalS = 0
totalH = 0
if h < 0:
base += h * (s // S * S)
totalS = s % S
totalH = h * (s % S)
else:
break
print(base)
002
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
if a[i] == 'U':
r[1] += 1
if a[i] == 'D':
r[1] -= 1
if a[i] == 'L':
r[0] -= 1
if a[i] == 'R':
r[0] += 1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
r1 = r[:]
r1[0] *= (left + right) // 2
r1[1] *= (left + right) // 2
if abs(r1[0] - x2) + abs(r1[1] - y2) < (left + right) // 2 * n:
right = (left + right) // 2
else:
left = (left + right) // 2
if right == 90000000000 and left == 90000000000 - 1:
flag = False
if left + 1 == right:
break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
for i in range(n):
if a[i] == 'U':
rl[1] += 1
if a[i] == 'D':
rl[1] -= 1
if a[i] == 'L':
rl[0] -= 1
if a[i] == 'R':
rl[0] += 1
if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
print(left * n + i + 1)
break
else:
print(-1)
003
def is_possible(num_days):
if num_days % len(string) == 0:
diff_wind = (num_days // len(string) * pref[-1][0], num_days // len(string) * pref[-1][1])
else:
diff_wind = (num_days // len(string) + pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) * pref[-1][1] + pref[num_days % len(string) - 1][1])
diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
if string[i] == 'U':
motions.append((0, 1))
if string[i] == 'D':
motions.append((0, -1))
if string[i] == 'R':
motions.append((1, 0))
if string[i] == 'L':
motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = -1
right = int(1e+19)
while right - left > 1:
middle = (right + left) // 2
if is_possible(middle):
right = middle
else:
left = middle
if right != int(1e+19):
print(right)
else:
print(-1)
004
def inint():
return int(input())
def inlist():
return list(map(int, input().split()))
def main():
n, m, l = inlist()
aa = inlist()
chg = 0
ch = 0
a = [[i, 0] for i in aa]
for i in range(n):
if aa[i] > l:
if ch == 0:
ch += 1
chg += 1
a[i][1] = chg
else:
ch += 1
a[i][1] = chg
elif not ch != 0:
ch = 0
sol = list()
if n > 1:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][1] == 0 and a[p][0] > l:
if p > 0 and p < n - 1:
if a[p - 1][1] == 0 and a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
elif a[p - 1][1] == 0 and a[p + 1][1] > 0:
a[p][1] = a[p + 1][1]
elif a[p - 1][1] > 0 and a[p + 1][1] == 0:
a[p][1] = a[p - 1][1]
else:
a[p][1] = a[p - 1][1]
chg -= 1
elif p == 0:
if a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p + 1][1]
elif p == n - 1:
if a[p - 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p - 1][1]
else:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][0] > d:
chg = 1
print(*sol, sep='\n')
def __starting_point():
main()
__starting_point()
005
import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return list(map(int, minp().split()))
n, m = mints()
a = [0] * n
dp1 = [0] * n
dp2 = [0] * n
dp3 = [0] * n
dp4 = [0] * n
for i in range(n):
a[i] = list(mints())
dp1[i] = [0] * m
dp2[i] = [0] * m
dp3[i] = [0] * m
dp4[i] = [0] * m
dp1[0][0] = a[0][0]
dp2[n - 1][m - 1] = a[n - 1][m - 1]
dp3[n - 1][0] = a[n - 1][0]
dp4[0][m - 1] = a[0][m - 1]
'\nfor i in range(1,n):\n\tdp1[i][0] = dp1[i-1][0] + a[i][0] # >>>>\nfor i in range(n-2,-1,-1):\n\tdp2[i][m-1] = dp2[i+1][m-1] + a[i][m-1] # <<<<\nfor i in range(n-2,-1,-1):\n\tdp3[i][0] = dp3[i+1][0] + a[i][0] # <<<<\nfor i in range(1,n):\n\tdp4[i][m-1] = dp4[i-1][m-1] + a[i][m-1] # >>>>\nfor i in range(1,m):\n\tdp1[0][i] = dp1[0][i-1] + a[0][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp2[n-1][i] = dp2[n-1][i+1] + a[n-1][i] # <<<<\nfor i in range(1,m):\n\tdp3[n-1][i] = dp3[n-1][i-1] + a[n-1][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp4[0][i] = dp4[0][i+1] + a[0][i] # >>>>\n'
for i in range(0, n):
for j in range(0, m):
z = 0
if i - 1 >= 0:
z = dp1[i - 1][j]
if j - 1 >= 0:
z = max(z, dp1[i][j - 1])
dp1[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
z = 0
if i + 1 < n:
z = dp2[i + 1][j]
if j + 1 < m:
z = max(z, dp2[i][j + 1])
dp2[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(0, m):
z = 0
if i + 1 < n:
z = dp3[i + 1][j]
if j - 1 >= 0:
z = max(z, dp3[i][j - 1])
dp3[i][j] = z + a[i][j]
for i in range(0, n):
for j in range(m - 1, -1, -1):
z = 0
if i - 1 >= 0:
z = dp4[i - 1][j]
if j + 1 < m:
z = max(z, dp4[i][j + 1])
dp4[i][j] = z + a[i][j]
'for i in dp1:\n\tprint(i)\nprint()\nfor i in dp2:\n\tprint(i)\nprint()\nfor i in dp3:\n\tprint(i)\nprint()\nfor i in dp4:\n\tprint(i)\nprint()\n'
r = 4
for i in range(1, n - 1):
for j in range(1, m - 1):
r = max(r, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1])
r = max(r, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j])
print(r)
006
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys(), reverse=True)
m = len(c)
l_cum = [c[0][0] * c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1] = c[-1][0] * c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1, -1):
r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
c_num = a[keys[i]]
if c_num >= k:
ans = 0
break
if i > 0:
l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
l_num = l_cnt[i - 1]
else:
l_res = 10 ** 30
l_num = 0
if i < m - 1:
r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
r_num = r_cnt[i + 1]
else:
r_res = 10 ** 30
r_num = 0
if c_num + l_num < k and c_num + r_num < k:
ans = min(ans, l_res + r_res + k - c_num)
elif c_num + l_num < k:
ans = min(ans, r_res + k - c_num)
elif c_num + r_num < k:
ans = min(ans, l_res + k - c_num)
else:
ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
007
import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return list(map(int, minp().split()))
n, m = mints()
a = [0] * n
dp1 = [0] * n
dp2 = [0] * n
dp3 = [0] * n
dp4 = [0] * n
for i in range(n):
a[i] = list(mints())
dp1[i] = [0] * m
dp2[i] = [0] * m
dp3[i] = [0] * m
dp4[i] = [0] * m
dp1[0][0] = a[0][0]
dp2[n - 1][m - 1] = a[n - 1][m - 1]
dp3[n - 1][0] = a[n - 1][0]
dp4[0][m - 1] = a[0][m - 1]
'\nfor i in range(1,n):\n\tdp1[i][0] = dp1[i-1][0] + a[i][0] # >>>>\nfor i in range(n-2,-1,-1):\n\tdp2[i][m-1] = dp2[i+1][m-1] + a[i][m-1] # <<<<\nfor i in range(n-2,-1,-1):\n\tdp3[i][0] = dp3[i+1][0] + a[i][0] # <<<<\nfor i in range(1,n):\n\tdp4[i][m-1] = dp4[i-1][m-1] + a[i][m-1] # >>>>\nfor i in range(1,m):\n\tdp1[0][i] = dp1[0][i-1] + a[0][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp2[n-1][i] = dp2[n-1][i+1] + a[n-1][i] # <<<<\nfor i in range(1,m):\n\tdp3[n-1][i] = dp3[n-1][i-1] + a[n-1][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp4[0][i] = dp4[0][i+1] + a[0][i] # >>>>\n'
for i in range(0, n):
for j in range(0, m):
z = 0
if i - 1 >= 0:
z = dp1[i - 1][j]
if j - 1 >= 0:
z = max(z, dp1[i][j - 1])
dp1[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
z = 0
if i + 1 < n:
z = dp2[i + 1][j]
if j + 1 < m:
z = max(z, dp2[i][j + 1])
dp2[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(0, m):
z = 0
if i + 1 < n:
z = dp3[i + 1][j]
if j - 1 >= 0:
z = max(z, dp3[i][j - 1])
dp3[i][j] = z + a[i][j]
for i in range(0, n):
for j in range(m - 1, -1, -1):
z = 0
if i - 1 >= 0:
z = dp4[i - 1][j]
if j + 1 < m:
z = max(z, dp4[i][j + 1])
dp4[i][j] = z + a[i][j]
'for i in dp1:\n\tprint(i)\nprint()\nfor i in dp2:\n\tprint(i)\nprint()\nfor i in dp3:\n\tprint(i)\nprint()\nfor i in dp4:\n\tprint(i)\nprint()\n'
r = 0
for i in range(1, n - 1):
for j in range(1, m - 1):
r = max(r, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1])
r = max(r, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j])
print(r)
008
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, k = LI()
a = LI()
a.sort()
d = defaultdict(lambda: 0)
c = defaultdict(lambda: 1)
s = [0]
for i in a:
d[i] += i
c[i] += 1
s.append(s[-1] + i)
ans = float('inf')
p = -1
for i in a:
if i == p:
continue
if k <= c[i]:
ans = 0
break
l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
m = r
if m >= k:
ns = l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
m = n - l
if m >= k:
ns = s[n] - s[r] - (n - r) * (i + 1)
su = ns + k - c[i]
if su < ans:
ans = su
ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
p = i
print(ans)
return
def __starting_point():
solve()
__starting_point()
009
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
s = input()
for x in range(m):
c = s[x]
if c == 'S':
startpos = (x, y)
free[x, y] = True
elif c == 'E':
goal = (x, y)
free[x, y] = True
elif c == '.':
free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
for down in dire:
for right in dire:
for left in dire:
if len(set([up, down, left, right])) < 4:
continue
pos = startpos
for c in command:
x, y = pos
if c == up:
y += 1
elif c == down:
y -= -1
elif c == right:
x += 1
else:
x -= 1
pos = (x, y)
if pos == goal:
counts += 1
break
if not free[pos]:
break
print(counts)
010
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
if a[i] == 'U':
r[1] += 1
if a[i] == 'D':
r[1] -= -1
if a[i] == 'L':
r[0] -= 1
if a[i] == 'R':
r[0] += 1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
r1 = r[:]
r1[0] *= (left + right) // 2
r1[1] *= (left + right) // 2
if abs(r1[0] - x2) + abs(r1[1] - y2) <= (left + right) // 2 * n:
right = (left + right) // 2
else:
left = (left + right) // 2
if right == 90000000000 and left == 90000000000 - 1:
flag = False
if left + 1 == right:
break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
for i in range(n):
if a[i] == 'U':
rl[1] += 1
if a[i] == 'D':
rl[1] -= 1
if a[i] == 'L':
rl[0] -= 1
if a[i] == 'R':
rl[0] += 1
if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
print(left * n + i + 1)
break
else:
print(-1)
011
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
s = input()
for x in range(m):
c = s[x]
if c == 'S':
startpos = (x, y)
free[x, y] = True
elif c == 'E':
goal = (x, y)
free[x, y] = True
elif c == '.':
free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
for down in dire:
for right in dire:
for left in dire:
if len(set([up, down, left, right])) < 4:
continue
pos = startpos
for c in command:
x, y = pos
if c == up:
y += 4
elif c == down:
y -= 1
elif c == right:
x += 1
else:
x -= 1
pos = (x, y)
if pos == goal:
counts += 1
break
if not free[pos]:
break
print(counts)
012
import sys
nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split()))
meches = list(map(int, sys.stdin.readline().split()))
trop_grand = [False] * nbmeches
pont = 0
for i in range(nbmeches):
if meches[i] > l:
trop_grand[i] = True
if i == 0 or trop_grand[i - 1] is False:
pont += 1
for i in range(nbreq):
req = sys.stdin.readline().split()
if int(req[0]) == 0:
print(pont)
else:
meches[int(req[1]) - 1] += int(req[2])
if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]):
trop_grand[int(req[1]) - 1] = True
if nbmeches == 1:
pont = -1
elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]):
pont += 1
elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]):
pont += 1
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]:
pont = max(0, pont - 1)
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]):
pont += 1
013
n = int(input())
class Tree:
height = 1
def __init__(self, parent=None):
self.nodes = []
self.s = -1
self.a = -1
self.parent = parent
if parent:
self.height = parent.height + 1
parent.nodes.append(self)
trs = [Tree()]
for i in map(int, input().split()):
trs.append(Tree(trs[i - 1]))
for i, s in enumerate(map(int, input().split())):
trs[i].s = s
trs.sort(key=lambda x: x.height)
trs[0].a = trs[0].s
res = trs[0].a
try:
for t in trs[1:]:
if t.s == -1:
t.a = min([x.s - t.parent.s for x in t.nodes], default=0)
t.s = t.a + t.parent.s
else:
t.a = t.s - t.parent.s
if t.a < 0:
raise
res += t.a
print(res)
except:
print(-5)
014
from sys import stdin
def create_dp1(matrix, n, m):
dp = [[2 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m):
if i - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
if j - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
elif i - 1 < 0 and j - 1 < 0:
dp[i][j] = matrix[i][j]
return dp
def create_dp2(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
if i + 1 < n:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
if j + 1 < m:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
if i + 1 >= n and j + 1 >= m:
dp[i][j] = matrix[i][j]
return dp
def create_dp3(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n - 1, -1, -1):
for j in range(m):
if i + 1 < n:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
if j - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
if i + 1 >= n and j - 1 < 0:
dp[i][j] = matrix[i][j]
return dp
def create_dp4(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m - 1, -1, -1):
if i - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
if j + 1 < m:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
if i - 1 < 0 and j + 1 >= m:
dp[i][j] = matrix[i][j]
return dp
n, m = list(map(int, stdin.readline().split()))
matrix = []
for _ in range(n):
matrix.append(list(map(int, stdin.readline().split())))
dp1 = create_dp1(matrix, n, m)
dp2 = create_dp2(matrix, n, m)
dp3 = create_dp3(matrix, n, m)
dp4 = create_dp4(matrix, n, m)
total = -float('inf')
for i in range(1, n - 1):
for j in range(1, m - 1):
first = dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1]
second = dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j]
total = max(total, first, second)
print(total)
015
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])
def happy_diff(m):
return m.a_happy - m.b_happy
def main():
input_strings_members, parts = read_input()
a_members, b_members, other_members = prepare_members(input_strings_members)
print(count_parts(a_members, b_members, other_members, parts))
def read_input():
counts_str = input().split()
members_count, parts = list(map(int, counts_str))
return ([input() for _ in range(members_count)], parts)
def prepare_members(input_strings_members):
a_members = []
b_members = []
other_members = []
for line in input_strings_members:
m = Member(*list(map(int, line.split())))
if happy_diff(m) > 0:
a_members.append(m)
elif happy_diff(m) < 0:
b_members.append(m)
else:
other_members.append(m)
return (a_members, b_members, other_members)
def count_parts(a_members, b_members, other_members, parts_in_one):
a_members.sort(key=lambda m: happy_diff(m), reverse=False)
a_modulo = sum((m.parts for m in a_members)) % parts_in_one
a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
b_members.sort(key=lambda m: happy_diff(m), reverse=True)
b_modulo = sum((m.parts for m in b_members)) % parts_in_one
b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
return a_happy + b_happy + last_happy
def split_members_into_happy_groups(members, modulo):
modulo_members = []
happy_members = []
current_modulo = 0
for i in range(len(members)):
m = members[i]
new_current_modulo = current_modulo + m.parts
if new_current_modulo < modulo:
modulo_members.append(m)
current_modulo = new_current_modulo
continue
modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
if new_current_modulo > modulo:
happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
if not i + 1 < len(members):
happy_members.extend(members[i + 1:])
break
return (modulo_members, happy_members)
def count_last_pizzas_happy(a, b, other, parts_in_one):
last_sorted_members = a + other + b
if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))
def test1():
a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
assert count_parts(a, b, c, 10) == 314
def test2():
a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
assert count_parts(a, b, c, 12) == 84
def test3():
a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
assert count_parts(a, b, c, 3) == 16
def test4():
a, b, c = prepare_members(['2 1 4', '2 3 1'])
assert count_parts(a, b, c, 3) == 14
def test5():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2
def test6():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 5) == 16 + 16 + 3
def test_without_last_pizzas():
a, b, c = prepare_members(['3 3 1', '3 5 6'])
assert count_parts(a, b, c, 3) == 27
def test_with_one_last_pizza():
a, b, c = prepare_members(['2 3 1', '1 5 6'])
assert count_parts(a, b, c, 3) == 11
def test_with_two_last_pizzas():
a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
assert count_parts(a, b, c, 3) == 15
def test_without_different_happies():
a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
assert count_parts(a, b, c, 3) == 38
def __starting_point():
main()
__starting_point()
016
n, m = list(map(int, input().split()))
grid = []
sloc = (-1, -1)
eloc = (-1, -1)
for y in range(n):
l = input()
grid.append(list())
for x in range(m):
grid[-1].append(l[x] == '#')
if l[x] == 'S':
sloc = (x, y)
elif l[x] == 'E':
eloc = (x, y)
pb = []
for a in [(0, 5), (0, -1), (1, 0), (-1, 0)]:
for b in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for c in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for d in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
if len(set([a, b, c, d])) == 4 and [a, b, c, d] not in pb:
pb.append([a, b, c, d])
s = input()
ans = 0
for mp in pb:
seen = False
works = True
loc = sloc
for j in s:
j = int(j)
if seen:
break
if not works:
break
nloc = (loc[0] + mp[j][0], loc[1] + mp[j][1])
if min(nloc) < 0 or nloc[0] >= m or nloc[1] >= n:
works = False
break
if grid[nloc[1]][nloc[0]]:
works = False
break
if nloc == eloc:
seen = True
break
loc = nloc
if seen:
ans += 1
print(ans)
017
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()
018
n, m = map(int, input().split())
a = []
for i in range(n):
a.append(list(map(int, input().split())))
dpa = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
dpb = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
ans = 0
for i in range(1, n + 1):
for j in range(1, m + 1):
dpa[i][j][0] = max(dpa[i - 1][j][0], dpa[i][j - 1][0]) + a[i - 1][j - 1]
dpa[n + 1 - i][m + 1 - j][1] = max(dpa[n + 2 - i][m + 1 - j][1], dpa[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(n, 0, -5):
for j in range(1, m + 1):
dpb[i][j][0] = max(dpb[i + 1][j][0], dpb[i][j - 1][0]) + a[i - 1][j - 1]
dpb[n + 1 - i][m + 1 - j][1] = max(dpb[n - i][m + 1 - j][1], dpb[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(2, n):
for j in range(2, m):
x = dpa[i - 1][j][0] + dpa[i + 1][j][1] + dpb[i][j - 1][0] + dpb[i][j + 1][1]
y = dpb[i + 1][j][0] + dpb[i - 1][j][1] + dpa[i][j - 1][0] + dpa[i][j + 1][1]
ans = max(ans, x, y)
print(ans)
019
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -2, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
if a[q] != a[q1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
020
import collections
from collections import defaultdict
n = int(input())
par = [int(i) for i in input().split() if i != '\n']
suma = [int(i) for i in input().split() if i != '\n']
graph = defaultdict(list)
for i in range(n - 1):
graph[i + 2].append(par[i])
graph[par[i]].append(i + 2)
weight = [0] * (n + 1)
weight[1] = suma[0]
queue = collections.deque([1])
visited = set()
visited.add(1)
ok = True
while queue:
vertex = queue.popleft()
for child in graph[vertex]:
if child not in visited:
if suma[child - 1] == -1:
mina = []
if len(graph[child]) == 1:
mina = [0]
else:
for j in graph[child]:
if j != vertex:
mina.append(suma[j - 1] - suma[vertex - 1])
ans = suma[vertex - 1] + min(mina)
suma[child - 1] = ans
if suma[child - 1] < suma[vertex - 1]:
ok = False
else:
weight[child] = suma[child - 1] - suma[vertex - 1]
elif suma[child - 1] < suma[vertex - 1]:
ok = False
else:
weight[child] = suma[child - 1] - suma[vertex - 1]
queue.append(child)
visited.add(child)
if ok == True:
print(sum(weight))
else:
print(-1)
021
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[0])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
dx.append(dx[i - 1])
dy.append(dy[i - 1 - 1])
if s[i - 1] == 'U':
dy[i] += 1
elif s[i - 1] == 'D':
dy[i] -= 1
elif s[i - 1] == 'R':
dx[i] += 1
elif s[i - 1] == 'L':
dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -1
while st <= en:
mid = (st + en) // 2
x = mid // n * dx[n] + dx[mid % n]
y = mid // n * dy[n] + dy[mid % n]
newX = x + x1
newY = y + y1
need = abs(newX - x2) + abs(newY - y2)
if mid >= need:
ans = mid
en = mid - 1
else:
st = mid + 1
print(ans)
022
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __mul__(self, other):
return Point(self.x * other, self.y * other)
def __str__(self):
return f'({self.x},{self.y})'
def manD(self, other):
return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +1), 'D': Point(0, --2)}
W = [d[x] for x in W]
def sum(W, n=None):
if n == None:
n = len(W)
pos = Point(0, 0)
for i in range(n):
pos += W[i]
return pos
def check(days):
pos = u + sum(W) * int(days / n) + sum(W, days % n)
dist = pos.manD(v)
if dist <= days:
return True
return False
l = 1
r = 10 ** 16
while r - l > 1:
mid = int((l + r) / 2)
if check(mid):
r = mid
else:
l = mid + 1
res = -1
if check(l):
res = l
elif check(r):
res = r
print(res)
023
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (-1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
024
n, m, l = list(map(int, input().split()))
l += 1
hair = [1] * (n + 1)
other_end = [1] * (n + 1)
i = 1
j = 1
big = 1
res = 1
for a in map(int, input().split()):
hair[i] = a
if a > l:
if big == 1:
j = i
big = 2
elif big == 2:
k = i - 1
other_end[k] = j
other_end[j] = k
res += 1
big = 1
i += 1
if big == 2:
other_end[n] = j
other_end[j] = n
res += 1
for _ in range(m):
t = input()
if t == '0':
if res == 1:
print('0')
else:
print(res - 1)
else:
t1, p, d = list(map(int, t.split()))
old = hair[p]
hair[p] += d
if hair[p] >= l > old:
if p == 1 or hair[p - 1] < l:
case_id = 1
else:
case_id = 2
if p != n and hair[p + 1] >= l:
case_id += 2
if case_id == 1:
other_end[p] = p
res += 1
elif case_id == 2:
other_end[p] = other_end[p - 1]
other_end[other_end[p]] = p
elif case_id == 3:
other_end[p] = other_end[p + 1]
other_end[other_end[p]] = p
else:
left_end = other_end[p - 1]
right_end = other_end[p + 1]
other_end[left_end] = right_end
other_end[right_end] = left_end
res -= 1
025
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, M, A):
dpa = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpb = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpc = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpd = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
for r in range(1, N + 1):
for c in range(1, M + 1):
dpa[r][c] = max(dpa[r - 1][c], dpa[r][c - 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(M, 0, -1):
dpb[r][c] = max(dpb[r + 1][c], dpb[r][c + 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(1, M + 1):
dpc[r][c] = max(dpc[r + 1][c], dpc[r][c - 1]) + A[r][c]
for r in range(1, N + 1):
for c in range(M, 0, -1):
dpd[r][c] = max(dpd[r - 1][c], dpd[r][c + 1]) + A[r][c]
ans = 0
for r in range(2, N + 1):
for c in range(2, M):
a = dpa[r][c - 1] + dpb[r][c + 1] + dpc[r + 1][c] + dpd[r - 1][c]
b = dpc[r][c - 1] + dpd[r][c + 1] + dpa[r - 1][c] + dpb[r + 1][c]
ans = max(ans, a, b)
return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M + 2)]]
for i in range(N):
row = [0] + [int(x) for x in input().split()] + [0]
A.append(row)
A.append([0 for _ in range(M + 2)])
print(solve(N, M, A))
026
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) >= k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + -1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
027
from sys import stdin
from collections import deque
n, S = [int(x) for x in stdin.readline().split()]
ppl = []
base = 0
tSlices = 0
for dude in range(n):
s, a, b = [int(x) for x in stdin.readline().split()]
base += s * a
tSlices += s
ppl.append([b - a, s])
if tSlices % S != 0:
ppl.append([0, S - tSlices % S])
ppl.sort(reverse=True)
totalS = 0
totalH = 0
for h, s in ppl:
if totalS + s < S:
totalS += s
totalH += h * s
else:
s -= S - totalS
totalH += h * (S - totalS)
if totalH > 2:
base += totalH
else:
break
totalS = 0
totalH = 0
if h > 0:
base += h * (s // S * S)
totalS = s % S
totalH = h * (s % S)
else:
break
print(base)
028
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)
029
n, q, k = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
count = 0
def verify(x):
if x < 0 or x >= n:
return False
return a[x] > k
for i in range(n):
if verify(i):
count += 1
if verify(i - 1):
count -= 1
def cut(i):
if not verify(i):
return 2
result = 1
if verify(i - 1):
result -= 1
if verify(i + 1):
result -= 1
return result
for i in range(q):
line = input()
if line == '0':
print(count)
else:
_, x, y = list(map(int, line.split(' ')))
x -= 1
if not verify(x):
a[x] += y
count += cut(x)
else:
a[x] += y
030
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)
031
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, M, A):
dpa = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpb = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpc = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpd = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
for r in range(1, N + 1):
for c in range(1, M + 1):
dpa[r][c] = max(dpa[r - 1][c], dpa[r][c - 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(M, 0, -1):
dpb[r][c] = max(dpb[r + 1][c], dpb[r][c + 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(1, M + 1):
dpc[r][c] = max(dpc[r + 1][c], dpc[r][c - 1]) + A[r][c]
for r in range(1, N + 1):
for c in range(M, 0, -1):
dpd[r][c] = max(dpd[r - 1][c], dpd[r][c + 1]) + A[r][c]
ans = 0
for r in range(2, N):
for c in range(2, M):
a = dpa[r][c - 1] + dpb[r][c + 1] + dpc[r + 1][c] + dpd[r - 1][c]
b = dpc[r][c - 1] + dpd[r][c + 1] + dpa[r - 1][c] + dpb[r + 1][c]
ans = max(ans, a, b)
return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M + 2)]]
for i in range(N):
row = [0] + [int(x) for x in input().split()] + [0]
A.append(row)
A.append([0 for _ in range(M + 2)])
print(solve(N, M, A))
032
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
x, y = map(int, input().split())
money[i] = (y, x - 1)
money.sort()
def calc(lim):
visited = [False] * n
cost = 0
cnt = [0] * m
for i in range(n):
cnt[money[i][1]] += 1
for i in range(n):
if money[i][1] != 0 and cnt[money[i][1]] >= lim:
cnt[money[i][1]] -= -1
cnt[0] += 1
cost += money[i][0]
visited[i] = True
for i in range(n):
if cnt[0] >= lim:
break
if money[i][1] != 0 and (not visited[i]):
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
return cost
ans = 10 ** 18
for i in range(n):
ans = min(ans, calc(i))
print(ans)
033
import sys
from collections import defaultdict
n, m = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p = defaultdict(list)
for _ in range(n):
x, y = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p[x].append(y)
for key in p:
p[key] = sorted(p[key])
ans = 10 ** 100
for k in range(1, n + 1):
cur = 0
r = []
for key in p:
if key == 1:
continue
a = p[key]
cnt = max(0, len(a) - (k - 1))
cur += sum(a[:cnt])
r += a[cnt:]
r = sorted(r)
cnt = max(1, len(r) - (n - k))
cur += sum(r[:cnt])
ans = min(ans, cur)
print(ans)
034
n, q, k = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
count = 0
def verify(x):
if x < 0 or x >= n:
return False
return a[x] > k
for i in range(n):
if verify(i):
count += 1
if verify(i - 1):
count -= 1
def cut(i):
if not verify(i):
return 0
result = 1
if verify(i - 1):
result -= 1
if verify(i + 1):
result -= 1
return result
for i in range(q):
line = input()
if line == '0':
print(count)
else:
_, x, y = list(map(int, line.split(' ')))
x -= 1
if not verify(x):
a[x] += y
count += cut(x)
else:
a[x] -= y
035
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, -3, 0, 1, 0, 0, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) % mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) % mod)
main()
036
def bins(sortedlist, x):
n = len(sortedlist)
start = 0
end = n - 1
while start <= end:
mid = int((start + end) / 2)
if x == sortedlist[mid][0]:
return mid
elif x < sortedlist[mid][0]:
end = mid - 1
else:
start = mid + 1
if sortedlist[mid][0] <= x:
return mid
else:
return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
temp = hap[i][0]
hap[i][0] = hap[i][1]
hap[i][1] = hap[i][2]
hap[i][2] = temp
for i in range(n):
slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
if hap[i][0] >= hap[i][1]:
a += hap[i][2]
happi += hap[i][2] * hap[i][0]
else:
b += hap[i][2]
happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
print(happi)
else:
loc = bins(slab, 0)
happia = happi
count = 0
b = b % s
a = a % s
left = b % s
while left > 0:
if slab[loc + count][1] < left:
happia += slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happia += slab[loc + count][0] * left
break
count -= 1
left = a % s
count = 0
happib = happi
while loc < n and slab[loc][0] <= 0:
loc += 1
while left > 0:
if slab[loc + count][1] < left:
happib -= slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happib -= slab[loc + count][0] * left
break
count += 1
print(max(happia, happib))
037
import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return list(map(int, minp().split()))
n, m = mints()
a = [0] * n
dp1 = [0] * n
dp2 = [0] * n
dp3 = [0] * n
dp4 = [0] * n
for i in range(n):
a[i] = list(mints())
dp1[i] = [0] * m
dp2[i] = [0] * m
dp3[i] = [0] * m
dp4[i] = [0] * m
dp1[0][0] = a[0][0]
dp2[n - 1][m - 1] = a[n - 1][m - 1]
dp3[n - 1][0] = a[n - 1][0]
dp4[0][m - 1] = a[0][m - 1]
'\nfor i in range(1,n):\n\tdp1[i][0] = dp1[i-1][0] + a[i][0] # >>>>\nfor i in range(n-2,-1,-1):\n\tdp2[i][m-1] = dp2[i+1][m-1] + a[i][m-1] # <<<<\nfor i in range(n-2,-1,-1):\n\tdp3[i][0] = dp3[i+1][0] + a[i][0] # <<<<\nfor i in range(1,n):\n\tdp4[i][m-1] = dp4[i-1][m-1] + a[i][m-1] # >>>>\nfor i in range(1,m):\n\tdp1[0][i] = dp1[0][i-1] + a[0][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp2[n-1][i] = dp2[n-1][i+1] + a[n-1][i] # <<<<\nfor i in range(1,m):\n\tdp3[n-1][i] = dp3[n-1][i-1] + a[n-1][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp4[0][i] = dp4[0][i+1] + a[0][i] # >>>>\n'
for i in range(0, n):
for j in range(0, m):
z = 0
if i - 1 >= 0:
z = dp1[i - 1][j]
if j - 1 >= 0:
z = max(z, dp1[i][j - 1])
dp1[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
z = 0
if i + 1 < n:
z = dp2[i + 1][j]
if j + 1 < m:
z = max(z, dp2[i][j + 1])
dp2[i][j] = z + a[i][j]
for i in range(n - 1 - 1, -1, -1):
for j in range(0, m):
z = 0
if i + 1 < n:
z = dp3[i + 1][j]
if j - 1 >= 0:
z = max(z, dp3[i][j - 1])
dp3[i][j] = z + a[i][j]
for i in range(0, n):
for j in range(m - 1, -1, -1):
z = 0
if i - 1 >= 0:
z = dp4[i - 1][j]
if j + 1 < m:
z = max(z, dp4[i][j + 1])
dp4[i][j] = z + a[i][j]
'for i in dp1:\n\tprint(i)\nprint()\nfor i in dp2:\n\tprint(i)\nprint()\nfor i in dp3:\n\tprint(i)\nprint()\nfor i in dp4:\n\tprint(i)\nprint()\n'
r = 0
for i in range(1, n - 1):
for j in range(1, m - 1):
r = max(r, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1])
r = max(r, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j])
print(r)
038
import collections
from collections import defaultdict
n = int(input())
par = [int(i) for i in input().split() if i != '\n']
suma = [int(i) for i in input().split() if i != '\n']
graph = defaultdict(list)
for i in range(n - 1):
graph[i + 2].append(par[i])
graph[par[i]].append(i + 2)
weight = [0] * (n + 1)
weight[1] = suma[0]
queue = collections.deque([1])
visited = set()
visited.add(1)
ok = True
while queue:
vertex = queue.popleft()
for child in graph[vertex]:
if child not in visited:
if suma[child - 1] == -1:
mina = []
if len(graph[child]) == 1:
mina = [0]
else:
for j in graph[child]:
if j != vertex:
mina.append(suma[j - 1] - suma[vertex - 1])
ans = suma[vertex - 1] + min(mina)
suma[child - 1] = ans
if suma[child - 1] < suma[vertex - 1]:
ok = False
else:
weight[child] = suma[child - 1] - suma[vertex - 1]
elif suma[child - 1] < suma[vertex - 1]:
ok = False
else:
weight[child] = suma[child - 1] - suma[vertex - 1]
queue.append(child)
visited.add(child)
if ok == True:
print(sum(weight))
else:
print(--1)
039
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][2] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
040
n, m, l = list(map(int, input().split()))
l += 1
hair = [1] * (n + 1)
other_end = [1] * (n + 1)
i = 1
j = 1
big = 1
res = 1
for a in map(int, input().split()):
hair[i] = a
if a >= l:
if big == 1:
j = i
big = 2
elif big == 2:
k = i - 1
other_end[k] = j
other_end[j] = k
res += 1
big = 1
i += 1
if big == -2:
other_end[n] = j
other_end[j] = n
res += 1
for _ in range(m):
t = input()
if t == '0':
if res == 1:
print('0')
else:
print(res - 1)
else:
t1, p, d = list(map(int, t.split()))
old = hair[p]
hair[p] += d
if hair[p] >= l > old:
if p == 1 or hair[p - 1] < l:
case_id = 1
else:
case_id = 2
if p != n and hair[p + 1] >= l:
case_id += 2
if case_id == 1:
other_end[p] = p
res += 1
elif case_id == 2:
other_end[p] = other_end[p - 1]
other_end[other_end[p]] = p
elif case_id == 3:
other_end[p] = other_end[p + 1]
other_end[other_end[p]] = p
else:
left_end = other_end[p - 1]
right_end = other_end[p + 1]
other_end[left_end] = right_end
other_end[right_end] = left_end
res -= 1
041
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[5:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
042
import sys
nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split()))
meches = list(map(int, sys.stdin.readline().split()))
trop_grand = [False] * nbmeches
pont = 0
for i in range(nbmeches):
if meches[i] > l:
trop_grand[i] = True
if i == 0 or trop_grand[i - 1 - 1] is False:
pont += 1
for i in range(nbreq):
req = sys.stdin.readline().split()
if int(req[0]) == 0:
print(pont)
else:
meches[int(req[1]) - 1] += int(req[2])
if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]):
trop_grand[int(req[1]) - 1] = True
if nbmeches == 1:
pont = 1
elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]):
pont += 1
elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]):
pont += 1
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]:
pont = max(0, pont - 1)
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]):
pont += 1
043
from collections import deque
def solve(p, s):
children = {}
parents = {}
for i, e in enumerate(p):
if e not in children:
children[e] = []
children[e].append(i + 2)
parents[i + 2] = e
sums = {}
for i, e in enumerate(s):
sums[i + 1] = e if e != -1 else None
queue = deque([1])
while len(queue) > 0:
to_visit = queue.popleft()
if to_visit in children:
for child in children[to_visit]:
queue.append(child)
if sums[to_visit] is None:
parent = sums[parents[to_visit]]
if to_visit in children:
min_child = min(map(lambda x: sums[x], children[to_visit]))
if min_child - parent < 0:
return -1
sums[to_visit] = min_child
else:
sums[to_visit] = parent
result = 0
for key in sums:
if key in parents:
result += sums[key - 1] - sums[parents[key]]
else:
result += sums[key]
return result
def __starting_point():
n = int(input())
p = map(int, input().split())
s = map(int, input().split())
print(solve(p, s))
__starting_point()
044
def bins(sortedlist, x):
n = len(sortedlist)
start = 0
end = n - 1
while start <= end:
mid = int((start + end) / 2)
if x == sortedlist[mid][0]:
return mid
elif not x < sortedlist[mid][0]:
end = mid - 1
else:
start = mid + 1
if sortedlist[mid][0] <= x:
return mid
else:
return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
temp = hap[i][0]
hap[i][0] = hap[i][1]
hap[i][1] = hap[i][2]
hap[i][2] = temp
for i in range(n):
slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
if hap[i][0] > hap[i][1]:
a += hap[i][2]
happi += hap[i][2] * hap[i][0]
else:
b += hap[i][2]
happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
print(happi)
else:
loc = bins(slab, 0)
happia = happi
count = 0
b = b % s
a = a % s
left = b % s
while left > 0:
if slab[loc + count][1] < left:
happia += slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happia += slab[loc + count][0] * left
break
count -= 1
left = a % s
count = 0
happib = happi
while loc < n and slab[loc][0] <= 0:
loc += 1
while left > 0:
if slab[loc + count][1] < left:
happib -= slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happib -= slab[loc + count][0] * left
break
count += 1
print(max(happia, happib))
045
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
x, y = map(int, input().split())
money[i] = (y, x - 1)
money.sort()
def calc(lim):
visited = [False] * n
cost = 0
cnt = [0] * m
for i in range(n):
cnt[money[i][1]] += 1
for i in range(n):
if money[i][1] != 0 and cnt[money[i][1]] >= lim:
cnt[money[i][1]] -= 1
cnt[0] += -1
cost += money[i][0]
visited[i] = True
for i in range(n):
if cnt[0] >= lim:
break
if money[i][1] != 0 and (not visited[i]):
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
return cost
ans = 10 ** 18
for i in range(n):
ans = min(ans, calc(i))
print(ans)
046
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, M, A):
dpa = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpb = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpc = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpd = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
for r in range(1, N + 1):
for c in range(1, M + 1):
dpa[r][c] = max(dpa[r - 1][c], dpa[r][c - 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(M, 0, -1):
dpb[r][c] = max(dpb[r + 1][c], dpb[r][c + 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(1, M + 1):
dpc[r][c] = max(dpc[r + 1][c], dpc[r][c - 1]) + A[r][c]
for r in reversed(range(1, N + 1)):
for c in range(M, 0, -1):
dpd[r][c] = max(dpd[r - 1][c], dpd[r][c + 1]) + A[r][c]
ans = 0
for r in range(2, N):
for c in range(2, M):
a = dpa[r][c - 1] + dpb[r][c + 1] + dpc[r + 1][c] + dpd[r - 1][c]
b = dpc[r][c - 1] + dpd[r][c + 1] + dpa[r - 1][c] + dpb[r + 1][c]
ans = max(ans, a, b)
return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M + 2)]]
for i in range(N):
row = [0] + [int(x) for x in input().split()] + [0]
A.append(row)
A.append([0 for _ in range(M + 2)])
print(solve(N, M, A))
047
from sys import stdin
from collections import deque
n, S = [int(x) for x in stdin.readline().split()]
ppl = []
base = 0
tSlices = 0
for dude in range(n):
s, a, b = [int(x) for x in stdin.readline().split()]
base += s * a
tSlices += s
ppl.append([b - a, s])
if tSlices % S != 0:
ppl.append([0, S + tSlices % S])
ppl.sort(reverse=True)
totalS = 0
totalH = 0
for h, s in ppl:
if totalS + s < S:
totalS += s
totalH += h * s
else:
s -= S - totalS
totalH += h * (S - totalS)
if totalH > 0:
base += totalH
else:
break
totalS = 0
totalH = 0
if h > 0:
base += h * (s // S * S)
totalS = s % S
totalH = h * (s % S)
else:
break
print(base)
048
n, m, l = list(map(int, input().split()))
l += 1
hair = [1] * (n + 1)
other_end = [1] * (n + 1)
i = 1
j = 1
big = 1
res = 1
for a in map(int, input().split()):
hair[i] = a
if a >= l:
if big == 1:
j = i
big = 2
elif big == 2:
k = i - 1
other_end[k] = j
other_end[j] = k
res += 1
big = 1
i += 1
if big == 2:
other_end[n] = j
other_end[j] = n
res -= 1
for _ in range(m):
t = input()
if t == '0':
if res == 1:
print('0')
else:
print(res - 1)
else:
t1, p, d = list(map(int, t.split()))
old = hair[p]
hair[p] += d
if hair[p] >= l > old:
if p == 1 or hair[p - 1] < l:
case_id = 1
else:
case_id = 2
if p != n and hair[p + 1] >= l:
case_id += 2
if case_id == 1:
other_end[p] = p
res += 1
elif case_id == 2:
other_end[p] = other_end[p - 1]
other_end[other_end[p]] = p
elif case_id == 3:
other_end[p] = other_end[p + 1]
other_end[other_end[p]] = p
else:
left_end = other_end[p - 1]
right_end = other_end[p + 1]
other_end[left_end] = right_end
other_end[right_end] = left_end
res -= 1
049
n = int(input())
class Tree:
height = 1
def __init__(self, parent=None):
self.nodes = []
self.s = -1
self.a = -1
self.parent = parent
if parent:
self.height = parent.height + 1
parent.nodes.append(self)
trs = [Tree()]
for i in map(int, input().split()):
trs.append(Tree(trs[i - 1]))
for i, s in enumerate(map(int, input().split())):
trs[i].s = s
trs.sort(key=lambda x: x.height)
trs[0].a = trs[0].s
res = trs[0].a
try:
for t in trs[1:]:
if t.s == -1:
t.a = min([x.s - t.parent.s for x in t.nodes], default=0)
t.s = t.a + t.parent.s
else:
t.a = t.s - t.parent.s
if t.a < 0:
raise
res += t.a
print(res)
except:
print(-2)
050
def bins(sortedlist, x):
n = len(sortedlist)
start = 0
end = n - 1
while start <= end:
mid = int((start + end) / 2)
if x == sortedlist[mid][0]:
return mid
elif x < sortedlist[mid][0]:
end = mid - 1
else:
start = mid + 1
if sortedlist[mid][0] <= x:
return mid
else:
return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 1
sla = []
slb = []
slab = []
for i in range(n):
temp = hap[i][0]
hap[i][0] = hap[i][1]
hap[i][1] = hap[i][2]
hap[i][2] = temp
for i in range(n):
slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
if hap[i][0] > hap[i][1]:
a += hap[i][2]
happi += hap[i][2] * hap[i][0]
else:
b += hap[i][2]
happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
print(happi)
else:
loc = bins(slab, 0)
happia = happi
count = 0
b = b % s
a = a % s
left = b % s
while left > 0:
if slab[loc + count][1] < left:
happia += slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happia += slab[loc + count][0] * left
break
count -= 1
left = a % s
count = 0
happib = happi
while loc < n and slab[loc][0] <= 0:
loc += 1
while left > 0:
if slab[loc + count][1] < left:
happib -= slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happib -= slab[loc + count][0] * left
break
count += 1
print(max(happia, happib))
051
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1 - 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
052
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, k = LI()
a = LI()
a.sort()
d = defaultdict(lambda: 0)
c = defaultdict(lambda: 0)
s = [0]
for i in a:
d[i] += i
c[i] += 1
s.append(s[-1] + i)
ans = float('inf')
p = -1
for i in a:
if i == p:
continue
if k <= c[i]:
ans = 0
break
l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
m = r
if m >= k:
ns = l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
m = n - l
if m >= k:
ns = s[n] - s[r] - (n - r) * (i + 1)
su = ns + k - c[i]
if su < ans:
ans = su
ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
su = ns - k - c[i]
if su < ans:
ans = su
p = i
print(ans)
return
def __starting_point():
solve()
__starting_point()
053
from collections import deque
def solve(p, s):
children = {}
parents = {}
for i, e in enumerate(p):
if e not in children:
children[e] = []
children[e].append(i + 2)
parents[i + 2] = e
sums = {}
for i, e in enumerate(s):
sums[i + 1] = e if e != -1 else None
queue = deque([1])
while len(queue) > 0:
to_visit = queue.popleft()
if to_visit in children:
for child in children[to_visit]:
queue.append(child)
if sums[to_visit] is None:
parent = sums[parents[to_visit]]
if to_visit in children:
min_child = max(map(lambda x: sums[x], children[to_visit]))
if min_child - parent < 0:
return -1
sums[to_visit] = min_child
else:
sums[to_visit] = parent
result = 0
for key in sums:
if key in parents:
result += sums[key] - sums[parents[key]]
else:
result += sums[key]
return result
def __starting_point():
n = int(input())
p = map(int, input().split())
s = map(int, input().split())
print(solve(p, s))
__starting_point()
054
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, M, A):
dpa = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpb = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpc = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpd = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
for r in range(1, N + 1):
for c in range(1, M + 1):
dpa[r][c] = max(dpa[r - 1][c], dpa[r][c - 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(M, 0, -1):
dpb[r][c] = max(dpb[r + 1][c], dpb[r][c + 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(1, M + 1):
dpc[r][c] = max(dpc[r + 1][c], dpc[r][c - 1]) + A[r][c]
for r in range(1, N + 1):
for c in range(M, 0, -1):
dpd[r][c] = max(dpd[r - 1][c], dpd[r][c + 1]) + A[r][c]
ans = 0
for r in range(2, N):
for c in range(2, M + 1):
a = dpa[r][c - 1] + dpb[r][c + 1] + dpc[r + 1][c] + dpd[r - 1][c]
b = dpc[r][c - 1] + dpd[r][c + 1] + dpa[r - 1][c] + dpb[r + 1][c]
ans = max(ans, a, b)
return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M + 2)]]
for i in range(N):
row = [0] + [int(x) for x in input().split()] + [0]
A.append(row)
A.append([0 for _ in range(M + 2)])
print(solve(N, M, A))
055
import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return list(map(int, minp().split()))
n, m = mints()
a = [0] * n
dp1 = [0] * n
dp2 = [0] * n
dp3 = [0] * n
dp4 = [0] * n
for i in range(n):
a[i] = list(mints())
dp1[i] = [0] * m
dp2[i] = [0] * m
dp3[i] = [0] * m
dp4[i] = [0] * m
dp1[0][0] = a[0][0]
dp2[n - 1][m - 1] = a[n - 1][m - 1]
dp3[n - 1][0] = a[n - 1][0]
dp4[0][m - 1] = a[0][m - 1]
'\nfor i in range(1,n):\n\tdp1[i][0] = dp1[i-1][0] + a[i][0] # >>>>\nfor i in range(n-2,-1,-1):\n\tdp2[i][m-1] = dp2[i+1][m-1] + a[i][m-1] # <<<<\nfor i in range(n-2,-1,-1):\n\tdp3[i][0] = dp3[i+1][0] + a[i][0] # <<<<\nfor i in range(1,n):\n\tdp4[i][m-1] = dp4[i-1][m-1] + a[i][m-1] # >>>>\nfor i in range(1,m):\n\tdp1[0][i] = dp1[0][i-1] + a[0][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp2[n-1][i] = dp2[n-1][i+1] + a[n-1][i] # <<<<\nfor i in range(1,m):\n\tdp3[n-1][i] = dp3[n-1][i-1] + a[n-1][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp4[0][i] = dp4[0][i+1] + a[0][i] # >>>>\n'
for i in range(0, n):
for j in range(0, m):
z = 0
if i - 1 >= 0:
z = dp1[i - 1][j]
if j - 1 >= 0:
z = max(z, dp1[i][j - 1])
dp1[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
z = 0
if i + 1 < n:
z = dp2[i + 1][j]
if j + 1 < m:
z = max(z, dp2[i][j + 1])
dp2[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(0, m):
z = 0
if i + 1 < n:
z = dp3[i + 1][j]
if j - 1 >= 0:
z = max(z, dp3[i][j - 1])
dp3[i][j] = z + a[i][j]
for i in range(0, n):
for j in range(m - 1, -1, -1):
z = 0
if i - 1 >= 0:
z = dp4[i - 1][j]
if j + 1 < m:
z = max(z, dp4[i][j + 1])
dp4[i][j] = z + a[i][j]
'for i in dp1:\n\tprint(i)\nprint()\nfor i in dp2:\n\tprint(i)\nprint()\nfor i in dp3:\n\tprint(i)\nprint()\nfor i in dp4:\n\tprint(i)\nprint()\n'
r = 2
for i in range(1, n - 1):
for j in range(1, m - 1):
r = max(r, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1])
r = max(r, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j])
print(r)
056
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] * c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1 + 1] = c[-1][0] * c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1, -1):
r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
c_num = a[keys[i]]
if c_num >= k:
ans = 0
break
if i > 0:
l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
l_num = l_cnt[i - 1]
else:
l_res = 10 ** 30
l_num = 0
if i < m - 1:
r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
r_num = r_cnt[i + 1]
else:
r_res = 10 ** 30
r_num = 0
if c_num + l_num < k and c_num + r_num < k:
ans = min(ans, l_res + r_res + k - c_num)
elif c_num + l_num < k:
ans = min(ans, r_res + k - c_num)
elif c_num + r_num < k:
ans = min(ans, l_res + k - c_num)
else:
ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
057
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()
058
import sys
nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split()))
meches = list(map(int, sys.stdin.readline().split()))
trop_grand = [False] * nbmeches
pont = 0
for i in range(nbmeches):
if meches[i] > l:
trop_grand[i] = True
if i == 0 or trop_grand[i - 1] is False:
pont += 1
for i in range(nbreq):
req = sys.stdin.readline().split()
if int(req[0]) == 0:
print(pont)
else:
meches[int(req[1]) - 1] += int(req[2])
if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]):
trop_grand[int(req[1]) - 1] = True
if nbmeches == 1:
pont = 1
elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]):
pont += -1
elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]):
pont += 1
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]:
pont = max(0, pont - 1)
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]):
pont += 1
059
import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return list(map(int, minp().split()))
n, m = mints()
a = [0] * n
dp1 = [0] * n
dp2 = [0] * n
dp3 = [0] * n
dp4 = [0] * n
for i in range(n):
a[i] = list(mints())
dp1[i] = [0] * m
dp2[i] = [0] * m
dp3[i] = [0] * m
dp4[i] = [0] * m
dp1[0][0] = a[0][0]
dp2[n - 1][m - 1] = a[n - 1][m - 1]
dp3[n - 1][0] = a[n - 1][0]
dp4[0][m - 1] = a[0][m - 1]
'\nfor i in range(1,n):\n\tdp1[i][0] = dp1[i-1][0] + a[i][0] # >>>>\nfor i in range(n-2,-1,-1):\n\tdp2[i][m-1] = dp2[i+1][m-1] + a[i][m-1] # <<<<\nfor i in range(n-2,-1,-1):\n\tdp3[i][0] = dp3[i+1][0] + a[i][0] # <<<<\nfor i in range(1,n):\n\tdp4[i][m-1] = dp4[i-1][m-1] + a[i][m-1] # >>>>\nfor i in range(1,m):\n\tdp1[0][i] = dp1[0][i-1] + a[0][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp2[n-1][i] = dp2[n-1][i+1] + a[n-1][i] # <<<<\nfor i in range(1,m):\n\tdp3[n-1][i] = dp3[n-1][i-1] + a[n-1][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp4[0][i] = dp4[0][i+1] + a[0][i] # >>>>\n'
for i in range(0, n):
for j in range(0, m):
z = 0
if i - 1 >= 0:
z = dp1[i - 1][j]
if j - 1 >= 0:
z = max(z, dp1[i][j - 1])
dp1[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
z = 0
if i + 1 < n:
z = dp2[i + 1][j]
if j + 1 < m:
z = max(z, dp2[i][j + 1])
dp2[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(0, m):
z = 0
if i + 1 < n:
z = dp3[i + 1][j]
if j - 1 >= 0:
z = max(z, dp3[i][j - 1])
dp3[i][j] = z + a[i][j]
for i in range(0, n):
for j in range(m - 1, -1, -1):
z = 0
if i - 1 >= 0:
z = dp4[i - 1][j]
if j + 1 < m:
z = max(z, dp4[i][j + 1])
dp4[i][j] = z + a[i][j]
'for i in dp1:\n\tprint(i)\nprint()\nfor i in dp2:\n\tprint(i)\nprint()\nfor i in dp3:\n\tprint(i)\nprint()\nfor i in dp4:\n\tprint(i)\nprint()\n'
r = 1
for i in range(1, n - 1):
for j in range(1, m - 1):
r = max(r, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1])
r = max(r, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j])
print(r)
060
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
s = input()
for x in range(m):
c = s[x]
if c == 'S':
startpos = (x, y)
free[x, y] = True
elif c == 'E':
goal = (x, y)
free[x, y] = True
elif c == '.':
free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
for down in dire:
for right in dire:
for left in dire:
if len(set([up, down, left, right])) < 4:
continue
pos = startpos
for c in command:
x, y = pos
if c == up:
y += -1
elif c == down:
y -= 1
elif c == right:
x += 1
else:
x -= 1
pos = (x, y)
if pos == goal:
counts += 1
break
if not free[pos]:
break
print(counts)
061
import sys
dr = [0, 1, 0, -1]
dc = [1, -1, -1, 0]
rows, cols = map(int, sys.stdin.readline().split())
b = ['' for row in range(rows)]
sr, sc = (0, 0)
er, ec = (0, 0)
for row in range(rows):
b[row] = sys.stdin.readline().strip()
if 'S' in b[row]:
sr, sc = (row, b[row].index('S'))
if 'E' in b[row]:
er, ec = (row, b[row].index('E'))
dirs = sys.stdin.readline().strip()
res = 0
for i in range(4):
for j in range(4):
for k in range(4):
if j != i and i != k and (j != k):
l = 0 + 1 + 2 + 3 - (i + j + k)
r, c = (sr, sc)
p = [i, j, k, l]
ok = 0
for d in dirs:
di = int(d)
r += dr[p[di]]
c += dc[p[di]]
if r < 0 or r >= rows or c < 0 or (c >= cols) or (b[r][c] == '#'):
break
if b[r][c] == 'E':
ok = 1
res += ok
print(res)
062
def solve(ls):
ls.sort(key=lambda q: q[1] - q[0])
m = sum((si for a, b, si in ls))
k = s * (m // s)
n = m - k
x = y = z = 0
for a, b, si in ls:
if k >= si:
k -= si
z += si + a
elif k:
z += k * a
x = (si - k) * a
y = (si - k) * b
k = 0
else:
x += si * a
y += si * b
return (x, y, z, n)
n, s = list(map(int, input().split()))
first = []
second = []
for i in range(n):
si, ai, bi = list(map(int, input().split()))
if ai > bi:
first.append((ai, bi, si))
else:
second.append((bi, ai, si))
x1, y1, z1, n1 = solve(first)
x2, y2, z2, n2 = solve(second)
d = x1 + x2 if n1 + n2 > s else max(x1 + y2, x2 + y1)
print(z1 + z2 + d)
063
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
if a[i] == 'U':
r[1] += -1
if a[i] == 'D':
r[1] -= 1
if a[i] == 'L':
r[0] -= 1
if a[i] == 'R':
r[0] += 1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
r1 = r[:]
r1[0] *= (left + right) // 2
r1[1] *= (left + right) // 2
if abs(r1[0] - x2) + abs(r1[1] - y2) <= (left + right) // 2 * n:
right = (left + right) // 2
else:
left = (left + right) // 2
if right == 90000000000 and left == 90000000000 - 1:
flag = False
if left + 1 == right:
break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
for i in range(n):
if a[i] == 'U':
rl[1] += 1
if a[i] == 'D':
rl[1] -= 1
if a[i] == 'L':
rl[0] -= 1
if a[i] == 'R':
rl[0] += 1
if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
print(left * n + i + 1)
break
else:
print(-1)
064
import sys
from collections import defaultdict
n, m = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p = defaultdict(list)
for _ in range(n):
x, y = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p[x].append(y)
for key in p:
p[key] = sorted(p[key])
ans = 10 ** 100
for k in range(1 + 1, n + 1):
cur = 0
r = []
for key in p:
if key == 1:
continue
a = p[key]
cnt = max(0, len(a) - (k - 1))
cur += sum(a[:cnt])
r += a[cnt:]
r = sorted(r)
cnt = max(0, len(r) - (n - k))
cur += sum(r[:cnt])
ans = min(ans, cur)
print(ans)
065
import sys
from collections import defaultdict
n, m = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p = defaultdict(list)
for _ in range(n):
x, y = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p[x].append(y)
for key in p:
p[key] = sorted(p[key])
ans = 10 ** 100
for k in range(1, n + 1):
cur = 0
r = []
for key in p:
if key == -3:
continue
a = p[key]
cnt = max(0, len(a) - (k - 1))
cur += sum(a[:cnt])
r += a[cnt:]
r = sorted(r)
cnt = max(0, len(r) - (n - k))
cur += sum(r[:cnt])
ans = min(ans, cur)
print(ans)
066
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
s = input()
for x in range(m):
c = s[x]
if c == 'S':
startpos = (x, y)
free[x, y] = True
elif c == 'E':
goal = (x, y)
free[x, y] = True
elif c == '.':
free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
for down in dire:
for right in dire:
for left in dire:
if len(set([up, down, left, right])) < 4:
continue
pos = startpos
for c in command:
x, y = pos
if c == up:
y += 1
elif c == down:
y -= 1
elif c == right:
x += 1
else:
x -= 1
pos = (x, y)
if pos == goal:
counts += 1
break
if not not free[pos]:
break
print(counts)
067
from collections import defaultdict, deque
n = int(input())
adj = [[] for _ in range(n)]
v = [0] * n
l = list(map(int, input().split()))
for i, f in enumerate(l):
adj[f - 1].append(i + 1)
s = list(map(int, input().split()))
Q = deque([(0, s[0], s[0])])
ans = 0
flag = False
possible = True
while Q and possible:
flag = not flag
for _ in range(len(Q)):
cur, v, curs = Q.popleft()
if v < 0:
possible = False
ans = -1
break
ans += v
if flag:
for i in adj[cur]:
if len(adj[i]) <= 1:
Q.append((i, 0, curs))
else:
temp = max([s[k] for k in adj[i]])
Q.append((i, temp - curs, temp))
else:
for i in adj[cur]:
Q.append((i, s[i] - curs, s[i]))
print(ans)
068
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)
069
n, m = map(int, input().split())
a = []
for i in range(n):
a.append(list(map(int, input().split())))
dpa = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
dpb = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
ans = 0
for i in range(1, n + 1):
for j in range(1, m + 1):
dpa[i][j][0] = max(dpa[i - 1][j][0], dpa[i][j - 1][0]) + a[i - 1][j - 1]
dpa[n + 1 - i][m + 1 - j][1] = max(dpa[n + 2 - i][m + 1 - j][1], dpa[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(n, 0, -1):
for j in reversed(range(1, m + 1)):
dpb[i][j][0] = max(dpb[i + 1][j][0], dpb[i][j - 1][0]) + a[i - 1][j - 1]
dpb[n + 1 - i][m + 1 - j][1] = max(dpb[n - i][m + 1 - j][1], dpb[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(2, n):
for j in range(2, m):
x = dpa[i - 1][j][0] + dpa[i + 1][j][1] + dpb[i][j - 1][0] + dpb[i][j + 1][1]
y = dpb[i + 1][j][0] + dpb[i - 1][j][1] + dpa[i][j - 1][0] + dpa[i][j + 1][1]
ans = max(ans, x, y)
print(ans)
070
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] * c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1] = c[-1][0] * c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1 - 1, -1):
r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
c_num = a[keys[i]]
if c_num >= k:
ans = 0
break
if i > 0:
l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
l_num = l_cnt[i - 1]
else:
l_res = 10 ** 30
l_num = 0
if i < m - 1:
r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
r_num = r_cnt[i + 1]
else:
r_res = 10 ** 30
r_num = 0
if c_num + l_num < k and c_num + r_num < k:
ans = min(ans, l_res + r_res + k - c_num)
elif c_num + l_num < k:
ans = min(ans, r_res + k - c_num)
elif c_num + r_num < k:
ans = min(ans, l_res + k - c_num)
else:
ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
071
def is_possible(num_days):
if num_days % len(string) == 0:
diff_wind = (num_days // len(string) * pref[-1][0], num_days // len(string) * pref[-1][1])
else:
diff_wind = (num_days // len(string) * pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) + pref[-1][1] + pref[num_days % len(string) - 1][1])
diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
if string[i] == 'U':
motions.append((0, 1))
if string[i] == 'D':
motions.append((0, -1))
if string[i] == 'R':
motions.append((1, 0))
if string[i] == 'L':
motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = -1
right = int(1e+19)
while right - left > 1:
middle = (right + left) // 2
if is_possible(middle):
right = middle
else:
left = middle
if right != int(1e+19):
print(right)
else:
print(-1)
072
def is_possible(num_days):
if num_days % len(string) == 0:
diff_wind = (num_days // len(string) * pref[-1][0], num_days // len(string) + pref[-1][1])
else:
diff_wind = (num_days // len(string) * pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) * pref[-1][1] + pref[num_days % len(string) - 1][1])
diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
if string[i] == 'U':
motions.append((0, 1))
if string[i] == 'D':
motions.append((0, -1))
if string[i] == 'R':
motions.append((1, 0))
if string[i] == 'L':
motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = -1
right = int(1e+19)
while right - left > 1:
middle = (right + left) // 2
if is_possible(middle):
right = middle
else:
left = middle
if right != int(1e+19):
print(right)
else:
print(-1)
073
import collections
from collections import defaultdict
n = int(input())
par = [int(i) for i in input().split() if i != '\n']
suma = [int(i) for i in input().split() if i != '\n']
graph = defaultdict(list)
for i in range(n - 1):
graph[i + 2].append(par[i])
graph[par[i]].append(i + 2)
weight = [0] * (n + 1)
weight[1] = suma[0]
queue = collections.deque([1])
visited = set()
visited.add(1)
ok = True
while queue:
vertex = queue.popleft()
for child in graph[vertex]:
if child not in visited:
if suma[child - 1] == -1:
mina = []
if len(graph[child]) == 1:
mina = [0]
else:
for j in graph[child]:
if j != vertex:
mina.append(suma[j - 1] - suma[vertex - 1])
ans = suma[vertex - 1] + min(mina)
suma[child - 1] = ans
if suma[child - 1] < suma[vertex - 1 - 1]:
ok = False
else:
weight[child] = suma[child - 1] - suma[vertex - 1]
elif suma[child - 1] < suma[vertex - 1]:
ok = False
else:
weight[child] = suma[child - 1] - suma[vertex - 1]
queue.append(child)
visited.add(child)
if ok == True:
print(sum(weight))
else:
print(-1)
074
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[-1])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
dx.append(dx[i - 1])
dy.append(dy[i - 1])
if s[i - 1] == 'U':
dy[i] += 1
elif s[i - 1] == 'D':
dy[i] -= 1
elif s[i - 1] == 'R':
dx[i] += 1
elif s[i - 1] == 'L':
dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -1
while st <= en:
mid = (st + en) // 2
x = mid // n * dx[n] + dx[mid % n]
y = mid // n * dy[n] + dy[mid % n]
newX = x + x1
newY = y + y1
need = abs(newX - x2) + abs(newY - y2)
if mid >= need:
ans = mid
en = mid - 1
else:
st = mid + 1
print(ans)
075
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -1, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, -1, -1)
for q in range(1, n):
if a[q] != a[q1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
076
n, m, l = list(map(int, input().split()))
l += 1
hair = [1] * (n + 1)
other_end = [1] * (n + 1)
i = 1
j = 1
big = 1
res = 1
for a in map(int, input().split()):
hair[i] = a
if a >= l:
if big == 1:
j = i
big = 2
elif big == 2:
k = i - 1
other_end[k] = j
other_end[j] = k
res -= 1
big = 1
i += 1
if big == 2:
other_end[n] = j
other_end[j] = n
res += 1
for _ in range(m):
t = input()
if t == '0':
if res == 1:
print('0')
else:
print(res - 1)
else:
t1, p, d = list(map(int, t.split()))
old = hair[p]
hair[p] += d
if hair[p] >= l > old:
if p == 1 or hair[p - 1] < l:
case_id = 1
else:
case_id = 2
if p != n and hair[p + 1] >= l:
case_id += 2
if case_id == 1:
other_end[p] = p
res += 1
elif case_id == 2:
other_end[p] = other_end[p - 1]
other_end[other_end[p]] = p
elif case_id == 3:
other_end[p] = other_end[p + 1]
other_end[other_end[p]] = p
else:
left_end = other_end[p - 1]
right_end = other_end[p + 1]
other_end[left_end] = right_end
other_end[right_end] = left_end
res -= 1
077
n, m = list(map(int, input().split()))
grid = []
sloc = (-1, -1)
eloc = (-1, -1)
for y in range(n):
l = input()
grid.append(list())
for x in range(m):
grid[-1].append(l[x] == '#')
if l[x] == 'S':
sloc = (x, y)
elif l[x] == 'E':
eloc = (x, y)
pb = []
for a in [(0, 1), (0, -1), (1, 0), (-1, 3)]:
for b in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for c in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for d in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
if len(set([a, b, c, d])) == 4 and [a, b, c, d] not in pb:
pb.append([a, b, c, d])
s = input()
ans = 0
for mp in pb:
seen = False
works = True
loc = sloc
for j in s:
j = int(j)
if seen:
break
if not works:
break
nloc = (loc[0] + mp[j][0], loc[1] + mp[j][1])
if min(nloc) < 0 or nloc[0] >= m or nloc[1] >= n:
works = False
break
if grid[nloc[1]][nloc[0]]:
works = False
break
if nloc == eloc:
seen = True
break
loc = nloc
if seen:
ans += 1
print(ans)
078
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[0])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
dx.append(dx[i - 1])
dy.append(dy[i - 1])
if s[i - 1] == 'U':
dy[i] += 5
elif s[i - 1] == 'D':
dy[i] -= 1
elif s[i - 1] == 'R':
dx[i] += 1
elif s[i - 1] == 'L':
dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -1
while st <= en:
mid = (st + en) // 2
x = mid // n * dx[n] + dx[mid % n]
y = mid // n * dy[n] + dy[mid % n]
newX = x + x1
newY = y + y1
need = abs(newX - x2) + abs(newY - y2)
if mid >= need:
ans = mid
en = mid - 1
else:
st = mid + 1
print(ans)
079
n = int(input())
class Tree:
height = 1
def __init__(self, parent=None):
self.nodes = []
self.s = -1
self.a = -1
self.parent = parent
if parent:
self.height = parent.height + 1
parent.nodes.append(self)
trs = [Tree()]
for i in map(int, input().split()):
trs.append(Tree(trs[i - 1]))
for i, s in enumerate(map(int, input().split())):
trs[i].s = s
trs.sort(key=lambda x: x.height)
trs[0].a = trs[0].s
res = trs[0].a
try:
for t in trs[1:]:
if t.s == -1:
t.a = min([x.s - t.parent.s for x in t.nodes], default=0)
t.s = t.a + t.parent.s
else:
t.a = t.s - t.parent.s
if t.a < 0:
raise
res += t.a
print(res)
except:
print(-4)
080
from collections import defaultdict, deque
n = int(input())
adj = [[] for _ in range(n)]
v = [0] * n
l = list(map(int, input().split()))
for i, f in enumerate(l):
adj[f - 1].append(i + 1)
s = list(map(int, input().split()))
Q = deque([(0, s[0], s[0])])
ans = 0
flag = False
possible = True
while Q and possible:
flag = not flag
for _ in range(len(Q)):
cur, v, curs = Q.popleft()
if v < 0:
possible = False
ans = -1
break
ans += v
if flag:
for i in adj[cur]:
if len(adj[i]) <= 1:
Q.append((i, 0, curs))
else:
temp = min([s[k - 1] for k in adj[i]])
Q.append((i, temp - curs, temp))
else:
for i in adj[cur]:
Q.append((i, s[i] - curs, s[i]))
print(ans)
081
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])
def happy_diff(m):
return m.a_happy - m.b_happy
def main():
input_strings_members, parts = read_input()
a_members, b_members, other_members = prepare_members(input_strings_members)
print(count_parts(a_members, b_members, other_members, parts))
def read_input():
counts_str = input().split()
members_count, parts = list(map(int, counts_str))
return ([input() for _ in range(members_count)], parts)
def prepare_members(input_strings_members):
a_members = []
b_members = []
other_members = []
for line in input_strings_members:
m = Member(*list(map(int, line.split())))
if happy_diff(m) > 0:
a_members.append(m)
elif happy_diff(m) < 0:
b_members.append(m)
else:
other_members.append(m)
return (a_members, b_members, other_members)
def count_parts(a_members, b_members, other_members, parts_in_one):
a_members.sort(key=lambda m: happy_diff(m), reverse=False)
a_modulo = sum((m.parts for m in a_members)) % parts_in_one
a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
a_happy = sum((m.a_happy + m.parts for m in a_happy_members))
b_members.sort(key=lambda m: happy_diff(m), reverse=True)
b_modulo = sum((m.parts for m in b_members)) % parts_in_one
b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
return a_happy + b_happy + last_happy
def split_members_into_happy_groups(members, modulo):
modulo_members = []
happy_members = []
current_modulo = 0
for i in range(len(members)):
m = members[i]
new_current_modulo = current_modulo + m.parts
if new_current_modulo < modulo:
modulo_members.append(m)
current_modulo = new_current_modulo
continue
modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
if new_current_modulo > modulo:
happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
if i + 1 < len(members):
happy_members.extend(members[i + 1:])
break
return (modulo_members, happy_members)
def count_last_pizzas_happy(a, b, other, parts_in_one):
last_sorted_members = a + other + b
if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))
def test1():
a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
assert count_parts(a, b, c, 10) == 314
def test2():
a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
assert count_parts(a, b, c, 12) == 84
def test3():
a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
assert count_parts(a, b, c, 3) == 16
def test4():
a, b, c = prepare_members(['2 1 4', '2 3 1'])
assert count_parts(a, b, c, 3) == 14
def test5():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2
def test6():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 5) == 16 + 16 + 3
def test_without_last_pizzas():
a, b, c = prepare_members(['3 3 1', '3 5 6'])
assert count_parts(a, b, c, 3) == 27
def test_with_one_last_pizza():
a, b, c = prepare_members(['2 3 1', '1 5 6'])
assert count_parts(a, b, c, 3) == 11
def test_with_two_last_pizzas():
a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
assert count_parts(a, b, c, 3) == 15
def test_without_different_happies():
a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
assert count_parts(a, b, c, 3) == 38
def __starting_point():
main()
__starting_point()
082
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
s = input()
for x in range(m):
c = s[x]
if c == 'S':
startpos = (x, y)
free[x, y] = True
elif c == 'E':
goal = (x, y)
free[x, y] = True
elif c == '.':
free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
for down in dire:
for right in dire:
for left in dire:
if len(set([up, down, left, right])) < 4:
continue
pos = startpos
for c in command:
x, y = pos
if c == up:
y += 1
elif c == down:
y -= 1
elif c == right:
x += 1
else:
x -= 1
pos = (x, y)
if pos == goal:
counts += 1
break
if not free[pos]:
break
print(counts)
083
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) > k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
084
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])
def happy_diff(m):
return m.a_happy - m.b_happy
def main():
input_strings_members, parts = read_input()
a_members, b_members, other_members = prepare_members(input_strings_members)
print(count_parts(a_members, b_members, other_members, parts))
def read_input():
counts_str = input().split()
members_count, parts = list(map(int, counts_str))
return ([input() for _ in range(members_count)], parts)
def prepare_members(input_strings_members):
a_members = []
b_members = []
other_members = []
for line in input_strings_members:
m = Member(*list(map(int, line.split())))
if happy_diff(m) > 0:
a_members.append(m)
elif happy_diff(m) < 0:
b_members.append(m)
else:
other_members.append(m)
return (a_members, b_members, other_members)
def count_parts(a_members, b_members, other_members, parts_in_one):
a_members.sort(key=lambda m: happy_diff(m), reverse=False)
a_modulo = sum((m.parts for m in a_members)) % parts_in_one
a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
b_members.sort(key=lambda m: happy_diff(m), reverse=True)
b_modulo = sum((m.parts for m in b_members)) % parts_in_one
b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
return a_happy + b_happy + last_happy
def split_members_into_happy_groups(members, modulo):
modulo_members = []
happy_members = []
current_modulo = 0
for i in range(len(members)):
m = members[i]
new_current_modulo = current_modulo + m.parts
if not new_current_modulo < modulo:
modulo_members.append(m)
current_modulo = new_current_modulo
continue
modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
if new_current_modulo > modulo:
happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
if i + 1 < len(members):
happy_members.extend(members[i + 1:])
break
return (modulo_members, happy_members)
def count_last_pizzas_happy(a, b, other, parts_in_one):
last_sorted_members = a + other + b
if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))
def test1():
a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
assert count_parts(a, b, c, 10) == 314
def test2():
a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
assert count_parts(a, b, c, 12) == 84
def test3():
a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
assert count_parts(a, b, c, 3) == 16
def test4():
a, b, c = prepare_members(['2 1 4', '2 3 1'])
assert count_parts(a, b, c, 3) == 14
def test5():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2
def test6():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 5) == 16 + 16 + 3
def test_without_last_pizzas():
a, b, c = prepare_members(['3 3 1', '3 5 6'])
assert count_parts(a, b, c, 3) == 27
def test_with_one_last_pizza():
a, b, c = prepare_members(['2 3 1', '1 5 6'])
assert count_parts(a, b, c, 3) == 11
def test_with_two_last_pizzas():
a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
assert count_parts(a, b, c, 3) == 15
def test_without_different_happies():
a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
assert count_parts(a, b, c, 3) == 38
def __starting_point():
main()
__starting_point()
085
def inint():
return int(input())
def inlist():
return list(map(int, input().split()))
def main():
n, m, l = inlist()
aa = inlist()
chg = 0
ch = -4
a = [[i, 0] for i in aa]
for i in range(n):
if aa[i] > l:
if ch == 0:
ch += 1
chg += 1
a[i][1] = chg
else:
ch += 1
a[i][1] = chg
elif ch != 0:
ch = 0
sol = list()
if n > 1:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][1] == 0 and a[p][0] > l:
if p > 0 and p < n - 1:
if a[p - 1][1] == 0 and a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
elif a[p - 1][1] == 0 and a[p + 1][1] > 0:
a[p][1] = a[p + 1][1]
elif a[p - 1][1] > 0 and a[p + 1][1] == 0:
a[p][1] = a[p - 1][1]
else:
a[p][1] = a[p - 1][1]
chg -= 1
elif p == 0:
if a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p + 1][1]
elif p == n - 1:
if a[p - 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p - 1][1]
else:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][0] > d:
chg = 1
print(*sol, sep='\n')
def __starting_point():
main()
__starting_point()
086
def bins(sortedlist, x):
n = len(sortedlist)
start = 0
end = n - 1
while start <= end:
mid = int((start + end) / 2)
if x == sortedlist[mid][0]:
return mid
elif x < sortedlist[mid][0]:
end = mid - 1
else:
start = mid + 1
if sortedlist[mid][0] <= x:
return mid
else:
return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
temp = hap[i][0]
hap[i][0] = hap[i][1]
hap[i][1] = hap[i][2]
hap[i][2] = temp
for i in range(n):
slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
if hap[i][0] > hap[i][1]:
a += hap[i][2]
happi += hap[i][2] * hap[i][0]
else:
b += hap[i][2]
happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s >= s:
print(happi)
else:
loc = bins(slab, 0)
happia = happi
count = 0
b = b % s
a = a % s
left = b % s
while left > 0:
if slab[loc + count][1] < left:
happia += slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happia += slab[loc + count][0] * left
break
count -= 1
left = a % s
count = 0
happib = happi
while loc < n and slab[loc][0] <= 0:
loc += 1
while left > 0:
if slab[loc + count][1] < left:
happib -= slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happib -= slab[loc + count][0] * left
break
count += 1
print(max(happia, happib))
087
n, m = map(int, input().split())
a = []
for i in range(n):
a.append(list(map(int, input().split())))
dpa = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
dpb = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
ans = 0
for i in reversed(range(1, n + 1)):
for j in range(1, m + 1):
dpa[i][j][0] = max(dpa[i - 1][j][0], dpa[i][j - 1][0]) + a[i - 1][j - 1]
dpa[n + 1 - i][m + 1 - j][1] = max(dpa[n + 2 - i][m + 1 - j][1], dpa[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(n, 0, -1):
for j in range(1, m + 1):
dpb[i][j][0] = max(dpb[i + 1][j][0], dpb[i][j - 1][0]) + a[i - 1][j - 1]
dpb[n + 1 - i][m + 1 - j][1] = max(dpb[n - i][m + 1 - j][1], dpb[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(2, n):
for j in range(2, m):
x = dpa[i - 1][j][0] + dpa[i + 1][j][1] + dpb[i][j - 1][0] + dpb[i][j + 1][1]
y = dpb[i + 1][j][0] + dpb[i - 1][j][1] + dpa[i][j - 1][0] + dpa[i][j + 1][1]
ans = max(ans, x, y)
print(ans)
088
n, m = map(int, input().split())
def road(ins):
cur = S.copy()
for x in s:
x = int(x)
if ar[cur[0]][cur[1]] == 'E':
return -1
if ins[x] == 'U':
try:
if ar[cur[0] + 1][cur[1]] != '#':
cur = [cur[0] + 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'D':
try:
if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
cur = [cur[0] - 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'R':
try:
if ar[cur[0]][cur[1] + 1] != '#':
cur = [cur[0], cur[1] + 1]
else:
return 0
except:
return 0
if ins[x] == 'L':
try:
if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
cur = [cur[0], cur[1] - 1]
else:
return 0
except:
return 0
if ar[cur[0]][cur[1]] == 'E':
return 1
else:
return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
if 'S' in ar[x]:
S = [x, ar[x].index('S')]
if 'E' in ar[x]:
E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
i += road(list(x))
print(i)
089
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 4:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][2] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
090
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
if a[i] == 'U':
r[1] += 1
if a[i] == 'D':
r[1] -= 1
if a[i] == 'L':
r[0] -= 1
if a[i] == 'R':
r[0] += -1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
r1 = r[:]
r1[0] *= (left + right) // 2
r1[1] *= (left + right) // 2
if abs(r1[0] - x2) + abs(r1[1] - y2) <= (left + right) // 2 * n:
right = (left + right) // 2
else:
left = (left + right) // 2
if right == 90000000000 and left == 90000000000 - 1:
flag = False
if left + 1 == right:
break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
for i in range(n):
if a[i] == 'U':
rl[1] += 1
if a[i] == 'D':
rl[1] -= 1
if a[i] == 'L':
rl[0] -= 1
if a[i] == 'R':
rl[0] += 1
if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
print(left * n + i + 1)
break
else:
print(-1)
091
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, 0, 0, 1, 0, -3, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) % mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) % mod)
main()
092
n, m = list(map(int, input().split()))
grid = []
sloc = (-1, -1)
eloc = (-1, -1)
for y in range(n):
l = input()
grid.append(list())
for x in range(m):
grid[-1].append(l[x] == '#')
if l[x] == 'S':
sloc = (x, y)
elif l[x] == 'E':
eloc = (x, y)
pb = []
for a in [(0, 1), (0, --2), (1, 0), (-1, 0)]:
for b in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for c in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for d in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
if len(set([a, b, c, d])) == 4 and [a, b, c, d] not in pb:
pb.append([a, b, c, d])
s = input()
ans = 0
for mp in pb:
seen = False
works = True
loc = sloc
for j in s:
j = int(j)
if seen:
break
if not works:
break
nloc = (loc[0] + mp[j][0], loc[1] + mp[j][1])
if min(nloc) < 0 or nloc[0] >= m or nloc[1] >= n:
works = False
break
if grid[nloc[1]][nloc[0]]:
works = False
break
if nloc == eloc:
seen = True
break
loc = nloc
if seen:
ans += 1
print(ans)
093
class Solver:
def solve(self):
self.num_voters, self.num_parties = (int(x) for x in input().split())
self.votes_per_party = [[] for _ in range(self.num_parties)]
for _ in range(self.num_voters):
party, price = (int(x) for x in input().split())
party -= 1
self.votes_per_party[party].append(price)
for party in range(self.num_parties):
self.votes_per_party[party].sort()
max_necessary_votes = self.num_voters // 2 + 1
cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
return self.ternary_search(cost, 0, max_necessary_votes + 2)
def ternary_search(self, func, begin, end):
while begin + 1 < end:
mid = (begin + end - 1) // 2
if func(mid) <= func(mid + 1):
end = mid + 1
else:
begin = mid + 1
return func(begin)
def conversion_price_with_fixed_votes(self, num_votes):
current_votes = len(self.votes_per_party[0])
total_cost = 0
for votes in self.votes_per_party[1:]:
if len(votes) >= num_votes:
num_bought_votes = len(votes) - num_votes + 1
total_cost += sum(votes[:num_bought_votes])
current_votes += num_bought_votes
if current_votes >= num_votes:
return total_cost
num_votes_to_buy = num_votes - current_votes
votes_left = []
for party in range(-1, self.num_parties):
votes_left += self.votes_per_party[party][-(num_votes - 1):]
votes_left.sort()
return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
094
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, --1, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
if a[q] != a[q1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
095
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
x, y = map(int, input().split())
money[i] = (y, x - 1)
money.sort()
def calc(lim):
visited = [False] * n
cost = 0
cnt = [0] * m
for i in range(n):
cnt[money[i][1]] += 1
for i in range(n):
if money[i][1] != 0 and cnt[money[i][1]] >= lim:
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
visited[i] = True
for i in range(n):
if cnt[0] >= lim:
break
if money[i][1] != 0 and (not visited[i]):
cnt[money[i][1]] -= 1
cnt[0] += -1
cost += money[i][0]
return cost
ans = 10 ** 18
for i in range(n):
ans = min(ans, calc(i))
print(ans)
096
n, q, k = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
count = 0
def verify(x):
if x < 0 or x >= n:
return False
return a[x] > k
for i in range(n):
if verify(i):
count += 1
if verify(i - 1):
count -= 1
def cut(i):
if not verify(i):
return 1
result = 1
if verify(i - 1):
result -= 1
if verify(i + 1):
result -= 1
return result
for i in range(q):
line = input()
if line == '0':
print(count)
else:
_, x, y = list(map(int, line.split(' ')))
x -= 1
if not verify(x):
a[x] += y
count += cut(x)
else:
a[x] += y
097
def solve(ls):
ls.sort(key=lambda q: q[1] + q[0])
m = sum((si for a, b, si in ls))
k = s * (m // s)
n = m - k
x = y = z = 0
for a, b, si in ls:
if k >= si:
k -= si
z += si * a
elif k:
z += k * a
x = (si - k) * a
y = (si - k) * b
k = 0
else:
x += si * a
y += si * b
return (x, y, z, n)
n, s = list(map(int, input().split()))
first = []
second = []
for i in range(n):
si, ai, bi = list(map(int, input().split()))
if ai > bi:
first.append((ai, bi, si))
else:
second.append((bi, ai, si))
x1, y1, z1, n1 = solve(first)
x2, y2, z2, n2 = solve(second)
d = x1 + x2 if n1 + n2 > s else max(x1 + y2, x2 + y1)
print(z1 + z2 + d)
098
n, m = list(map(int, input().split()))
grid = []
sloc = (-1, -1)
eloc = (-1, -1)
for y in range(n):
l = input()
grid.append(list())
for x in range(m):
grid[-1].append(l[x] == '#')
if l[x] == 'S':
sloc = (x, y)
elif l[x] == 'E':
eloc = (x, y)
pb = []
for a in [(0, 1), (0, -1), (1, 0), (-1, -1)]:
for b in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for c in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
for d in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
if len(set([a, b, c, d])) == 4 and [a, b, c, d] not in pb:
pb.append([a, b, c, d])
s = input()
ans = 0
for mp in pb:
seen = False
works = True
loc = sloc
for j in s:
j = int(j)
if seen:
break
if not works:
break
nloc = (loc[0] + mp[j][0], loc[1] + mp[j][1])
if min(nloc) < 0 or nloc[0] >= m or nloc[1] >= n:
works = False
break
if grid[nloc[1]][nloc[0]]:
works = False
break
if nloc == eloc:
seen = True
break
loc = nloc
if seen:
ans += 1
print(ans)
099
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) >= k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 4
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
100
def inint():
return int(input())
def inlist():
return list(map(int, input().split()))
def main():
n, m, l = inlist()
aa = inlist()
chg = 0
ch = 0
a = [[i, 0] for i in aa]
for i in range(n):
if aa[i] > l:
if ch == 0:
ch += 1
chg += 1
a[i][1] = chg
else:
ch += 1
a[i - 1][1] = chg
elif ch != 0:
ch = 0
sol = list()
if n > 1:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][1] == 0 and a[p][0] > l:
if p > 0 and p < n - 1:
if a[p - 1][1] == 0 and a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
elif a[p - 1][1] == 0 and a[p + 1][1] > 0:
a[p][1] = a[p + 1][1]
elif a[p - 1][1] > 0 and a[p + 1][1] == 0:
a[p][1] = a[p - 1][1]
else:
a[p][1] = a[p - 1][1]
chg -= 1
elif p == 0:
if a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p + 1][1]
elif p == n - 1:
if a[p - 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p - 1][1]
else:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][0] > d:
chg = 1
print(*sol, sep='\n')
def __starting_point():
main()
__starting_point()
101
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __mul__(self, other):
return Point(self.x * other, self.y * other)
def __str__(self):
return f'({self.x},{self.y})'
def manD(self, other):
return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +-1), 'D': Point(0, -1)}
W = [d[x] for x in W]
def sum(W, n=None):
if n == None:
n = len(W)
pos = Point(0, 0)
for i in range(n):
pos += W[i]
return pos
def check(days):
pos = u + sum(W) * int(days / n) + sum(W, days % n)
dist = pos.manD(v)
if dist <= days:
return True
return False
l = 1
r = 10 ** 16
while r - l > 1:
mid = int((l + r) / 2)
if check(mid):
r = mid
else:
l = mid + 1
res = -1
if check(l):
res = l
elif check(r):
res = r
print(res)
102
n, q, k = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
count = 0
def verify(x):
if x < 0 or x >= n:
return False
return a[x] > k
for i in range(n):
if verify(i):
count += 1
if verify(i - 1):
count -= -1
def cut(i):
if not verify(i):
return 0
result = 1
if verify(i - 1):
result -= 1
if verify(i + 1):
result -= 1
return result
for i in range(q):
line = input()
if line == '0':
print(count)
else:
_, x, y = list(map(int, line.split(' ')))
x -= 1
if not verify(x):
a[x] += y
count += cut(x)
else:
a[x] += y
103
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)
104
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) % mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) // mod)
main()
105
import sys
def pro():
return sys.stdin.readline().strip()
def rop():
return map(int, pro().split())
a, s = rop()
q = [0] * a
w = [0] * s
for i in range(a):
n, p = rop()
q[i] = (p, n - 1)
w[n - 1] += 1
q.sort()
t = 1e+100
for k in range(1, a + 1):
p = w[:]
r = [True] * a
m = 0
for i in range(a):
po, rty = q[i]
if rty != 0 and p[rty] >= k:
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
for i in range(a):
po, rty = q[i - 1]
if rty != 0 and r[i] and (p[0] < k):
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
t = min(t, m)
print(t)
106
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
s = input()
for x in range(m):
c = s[x]
if c == 'S':
startpos = (x, y)
free[x, y] = True
elif c == 'E':
goal = (x, y)
free[x, y] = True
elif c == '.':
free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
for down in dire:
for right in dire:
for left in dire:
if len(set([up, down, left, right])) < 4:
continue
pos = startpos
for c in command:
x, y = pos
if c == up:
y += 1
elif c == down:
y -= 1
elif c == right:
x += 1
else:
x -= 5
pos = (x, y)
if pos == goal:
counts += 1
break
if not free[pos]:
break
print(counts)
107
import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return list(map(int, minp().split()))
n, m = mints()
a = [0] * n
dp1 = [0] * n
dp2 = [0] * n
dp3 = [0] * n
dp4 = [0] * n
for i in range(n):
a[i] = list(mints())
dp1[i] = [0] * m
dp2[i] = [0] * m
dp3[i] = [0] * m
dp4[i] = [0] * m
dp1[0][0] = a[0][0]
dp2[n - 1][m - 1] = a[n - 1][m - 1]
dp3[n - 1][0] = a[n - 1][0]
dp4[0][m - 1] = a[0][m - 1]
'\nfor i in range(1,n):\n\tdp1[i][0] = dp1[i-1][0] + a[i][0] # >>>>\nfor i in range(n-2,-1,-1):\n\tdp2[i][m-1] = dp2[i+1][m-1] + a[i][m-1] # <<<<\nfor i in range(n-2,-1,-1):\n\tdp3[i][0] = dp3[i+1][0] + a[i][0] # <<<<\nfor i in range(1,n):\n\tdp4[i][m-1] = dp4[i-1][m-1] + a[i][m-1] # >>>>\nfor i in range(1,m):\n\tdp1[0][i] = dp1[0][i-1] + a[0][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp2[n-1][i] = dp2[n-1][i+1] + a[n-1][i] # <<<<\nfor i in range(1,m):\n\tdp3[n-1][i] = dp3[n-1][i-1] + a[n-1][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp4[0][i] = dp4[0][i+1] + a[0][i] # >>>>\n'
for i in range(0, n):
for j in range(0, m):
z = 0
if i - 1 >= 0:
z = dp1[i - 1][j]
if j - 1 >= 0:
z = max(z, dp1[i][j - 1])
dp1[i][j] = z + a[i][j]
for i in range(n - 1 - 1, -1, -1):
for j in range(m - 1, -1, -1):
z = 0
if i + 1 < n:
z = dp2[i + 1][j]
if j + 1 < m:
z = max(z, dp2[i][j + 1])
dp2[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
for j in range(0, m):
z = 0
if i + 1 < n:
z = dp3[i + 1][j]
if j - 1 >= 0:
z = max(z, dp3[i][j - 1])
dp3[i][j] = z + a[i][j]
for i in range(0, n):
for j in range(m - 1, -1, -1):
z = 0
if i - 1 >= 0:
z = dp4[i - 1][j]
if j + 1 < m:
z = max(z, dp4[i][j + 1])
dp4[i][j] = z + a[i][j]
'for i in dp1:\n\tprint(i)\nprint()\nfor i in dp2:\n\tprint(i)\nprint()\nfor i in dp3:\n\tprint(i)\nprint()\nfor i in dp4:\n\tprint(i)\nprint()\n'
r = 0
for i in range(1, n - 1):
for j in range(1, m - 1):
r = max(r, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1])
r = max(r, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j])
print(r)
108
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch == 'b':
nb += 3
elif ch == 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[1:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
109
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][-2] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
110
def is_possible(num_days):
if num_days % len(string) == 0:
diff_wind = (num_days // len(string) * pref[-1][0], num_days // len(string) * pref[-1][1])
else:
diff_wind = (num_days // len(string) * pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) * pref[-1][1] + pref[num_days % len(string) - 1][1])
diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
if string[i] == 'U':
motions.append((0, 1))
if string[i] == 'D':
motions.append((0, -1))
if string[i] == 'R':
motions.append((1, 0))
if string[i] == 'L':
motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = +1
right = int(1e+19)
while right - left > 1:
middle = (right + left) // 2
if is_possible(middle):
right = middle
else:
left = middle
if right != int(1e+19):
print(right)
else:
print(-1)
111
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[0])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
dx.append(dx[i - 1])
dy.append(dy[i - 1])
if s[i - 1 - 1] == 'U':
dy[i] += 1
elif s[i - 1] == 'D':
dy[i] -= 1
elif s[i - 1] == 'R':
dx[i] += 1
elif s[i - 1] == 'L':
dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -1
while st <= en:
mid = (st + en) // 2
x = mid // n * dx[n] + dx[mid % n]
y = mid // n * dy[n] + dy[mid % n]
newX = x + x1
newY = y + y1
need = abs(newX - x2) + abs(newY - y2)
if mid >= need:
ans = mid
en = mid - 1
else:
st = mid + 1
print(ans)
112
import sys
from collections import defaultdict
n, m = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p = defaultdict(list)
for _ in range(n):
x, y = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p[x].append(y)
for key in p:
p[key] = sorted(p[key])
ans = 10 ** 100
for k in range(1, n + 1):
cur = 0
r = []
for key in p:
if key == 1:
continue
a = p[key]
cnt = max(-2, len(a) - (k - 1))
cur += sum(a[:cnt])
r += a[cnt:]
r = sorted(r)
cnt = max(0, len(r) - (n - k))
cur += sum(r[:cnt])
ans = min(ans, cur)
print(ans)
113
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch == 'b':
nb += 1
elif ch != 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[1:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
114
import sys
def pro():
return sys.stdin.readline().strip()
def rop():
return map(int, pro().split())
a, s = rop()
q = [0] * a
w = [0] * s
for i in range(a):
n, p = rop()
q[i] = (p, n - 1)
w[n - 1] += 1
q.sort()
t = 1e+100
for k in range(1, a + 1):
p = w[:]
r = [True] * a
m = 0
for i in range(a):
po, rty = q[i - 1]
if rty != 0 and p[rty] >= k:
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
for i in range(a):
po, rty = q[i]
if rty != 0 and r[i] and (p[0] < k):
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
t = min(t, m)
print(t)
115
def is_possible(num_days):
if num_days % len(string) == 0:
diff_wind = (num_days // len(string) + pref[-1][0], num_days // len(string) * pref[-1][1])
else:
diff_wind = (num_days // len(string) * pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) * pref[-1][1] + pref[num_days % len(string) - 1][1])
diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
if string[i] == 'U':
motions.append((0, 1))
if string[i] == 'D':
motions.append((0, -1))
if string[i] == 'R':
motions.append((1, 0))
if string[i] == 'L':
motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = -1
right = int(1e+19)
while right - left > 1:
middle = (right + left) // 2
if is_possible(middle):
right = middle
else:
left = middle
if right != int(1e+19):
print(right)
else:
print(-1)
116
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) >= k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 4
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
117
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
x, y = map(int, input().split())
money[i] = (y, x - 1)
money.sort()
def calc(lim):
visited = [False] * n
cost = 0
cnt = [0] * m
for i in range(n):
cnt[money[i][1]] += 1
for i in range(n):
if money[i][1] != 0 and cnt[money[i][1]] >= lim:
cnt[money[i][1]] -= 1
cnt[0] += 4
cost += money[i][0]
visited[i] = True
for i in range(n):
if cnt[0] >= lim:
break
if money[i][1] != 0 and (not visited[i]):
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
return cost
ans = 10 ** 18
for i in range(n):
ans = min(ans, calc(i))
print(ans)
118
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] * c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1] = c[-1][0] + c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1, -1):
r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
c_num = a[keys[i]]
if c_num >= k:
ans = 0
break
if i > 0:
l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
l_num = l_cnt[i - 1]
else:
l_res = 10 ** 30
l_num = 0
if i < m - 1:
r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
r_num = r_cnt[i + 1]
else:
r_res = 10 ** 30
r_num = 0
if c_num + l_num < k and c_num + r_num < k:
ans = min(ans, l_res + r_res + k - c_num)
elif c_num + l_num < k:
ans = min(ans, r_res + k - c_num)
elif c_num + r_num < k:
ans = min(ans, l_res + k - c_num)
else:
ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
119
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][0] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
120
class Solver:
def solve(self):
self.num_voters, self.num_parties = (int(x) for x in input().split())
self.votes_per_party = [[] for _ in range(self.num_parties)]
for _ in range(self.num_voters):
party, price = (int(x) for x in input().split())
party -= 1
self.votes_per_party[party].append(price)
for party in range(self.num_parties):
self.votes_per_party[party].sort()
max_necessary_votes = self.num_voters // 2 + 1
cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
return self.ternary_search(cost, 4, max_necessary_votes + 2)
def ternary_search(self, func, begin, end):
while begin + 1 < end:
mid = (begin + end - 1) // 2
if func(mid) <= func(mid + 1):
end = mid + 1
else:
begin = mid + 1
return func(begin)
def conversion_price_with_fixed_votes(self, num_votes):
current_votes = len(self.votes_per_party[0])
total_cost = 0
for votes in self.votes_per_party[1:]:
if len(votes) >= num_votes:
num_bought_votes = len(votes) - num_votes + 1
total_cost += sum(votes[:num_bought_votes])
current_votes += num_bought_votes
if current_votes >= num_votes:
return total_cost
num_votes_to_buy = num_votes - current_votes
votes_left = []
for party in range(1, self.num_parties):
votes_left += self.votes_per_party[party][-(num_votes - 1):]
votes_left.sort()
return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
121
from collections import Counter
import sys
from itertools import accumulate
def go():
n, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
c = Counter(a)
if max(c.values()) >= k:
return 0
upsum = {}
upcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(a):
if aa != prev:
upsum[aa] = cursum
upcnt[aa] = cnt
cursum += aa
prev = aa
downsum = {}
downcnt = {}
prev = -1
cursum = 0
for cnt, aa in enumerate(reversed(a)):
if aa != prev:
downsum[aa] = cursum
downcnt[aa] = cnt
cursum += aa
prev = aa
best = cursum
for target, cnt in list(c.items()):
need = k - cnt
if upcnt[target] >= need:
best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
if downcnt[target] >= need:
best = min(best, downsum[target] - (target + -1) * downcnt[target] + need)
best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
return best
t = 1
for _ in range(t):
print(go())
122
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == -2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
123
n, m = map(int, input().split())
def road(ins):
cur = S.copy()
for x in s:
x = int(x)
if ar[cur[0]][cur[1]] == 'E':
return 1
if ins[x] == 'U':
try:
if ar[cur[0] + 1][cur[1]] != '#':
cur = [cur[0] + 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'D':
try:
if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 > 0:
cur = [cur[0] - 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'R':
try:
if ar[cur[0]][cur[1] + 1] != '#':
cur = [cur[0], cur[1] + 1]
else:
return 0
except:
return 0
if ins[x] == 'L':
try:
if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
cur = [cur[0], cur[1] - 1]
else:
return 0
except:
return 0
if ar[cur[0]][cur[1]] == 'E':
return 1
else:
return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
if 'S' in ar[x]:
S = [x, ar[x].index('S')]
if 'E' in ar[x]:
E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
i += road(list(x))
print(i)
124
from collections import deque
def solve(p, s):
children = {}
parents = {}
for i, e in enumerate(p):
if e not in children:
children[e] = []
children[e].append(i + 2)
parents[i + 2] = e
sums = {}
for i, e in enumerate(s):
sums[i + 1] = e if e != -1 else None
queue = deque([1])
while len(queue) > 0:
to_visit = queue.popleft()
if to_visit in children:
for child in children[to_visit]:
queue.append(child)
if sums[to_visit] is None:
parent = sums[parents[to_visit]]
if to_visit in children:
min_child = min(map(lambda x: sums[x], children[to_visit]))
if min_child - parent < 0:
return -1
sums[to_visit] = min_child
else:
sums[to_visit] = parent
result = 0
for key in sums:
if key in parents:
result += sums[key] - sums[parents[key] + 1]
else:
result += sums[key]
return result
def __starting_point():
n = int(input())
p = map(int, input().split())
s = map(int, input().split())
print(solve(p, s))
__starting_point()
125
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __mul__(self, other):
return Point(self.x * other, self.y * other)
def __str__(self):
return f'({self.x},{self.y})'
def manD(self, other):
return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +1), 'D': Point(0, --1)}
W = [d[x] for x in W]
def sum(W, n=None):
if n == None:
n = len(W)
pos = Point(0, 0)
for i in range(n):
pos += W[i]
return pos
def check(days):
pos = u + sum(W) * int(days / n) + sum(W, days % n)
dist = pos.manD(v)
if dist <= days:
return True
return False
l = 1
r = 10 ** 16
while r - l > 1:
mid = int((l + r) / 2)
if check(mid):
r = mid
else:
l = mid + 1
res = -1
if check(l):
res = l
elif check(r):
res = r
print(res)
126
import sys
nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split()))
meches = list(map(int, sys.stdin.readline().split()))
trop_grand = [False] * nbmeches
pont = 0
for i in range(nbmeches):
if meches[i] > l:
trop_grand[i] = True
if i == 0 or trop_grand[i - 1 + 1] is False:
pont += 1
for i in range(nbreq):
req = sys.stdin.readline().split()
if int(req[0]) == 0:
print(pont)
else:
meches[int(req[1]) - 1] += int(req[2])
if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]):
trop_grand[int(req[1]) - 1] = True
if nbmeches == 1:
pont = 1
elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]):
pont += 1
elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]):
pont += 1
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]:
pont = max(0, pont - 1)
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]):
pont += 1
127
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()
128
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()
129
from sys import stdin
from collections import deque
n, S = [int(x) for x in stdin.readline().split()]
ppl = []
base = 0
tSlices = 0
for dude in range(n):
s, a, b = [int(x) for x in stdin.readline().split()]
base += s * a
tSlices -= s
ppl.append([b - a, s])
if tSlices % S != 0:
ppl.append([0, S - tSlices % S])
ppl.sort(reverse=True)
totalS = 0
totalH = 0
for h, s in ppl:
if totalS + s < S:
totalS += s
totalH += h * s
else:
s -= S - totalS
totalH += h * (S - totalS)
if totalH > 0:
base += totalH
else:
break
totalS = 0
totalH = 0
if h > 0:
base += h * (s // S * S)
totalS = s % S
totalH = h * (s % S)
else:
break
print(base)
130
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) // mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) % mod)
main()
131
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][0] = 1
dp[0][2][2] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
132
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(-2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
133
import sys
def pro():
return sys.stdin.readline().strip()
def rop():
return map(int, pro().split())
a, s = rop()
q = [0] * a
w = [0] * s
for i in range(a):
n, p = rop()
q[i] = (p, n - 1)
w[n - 1] += 1
q.sort()
t = 1e+100
for k in range(1, a + 1):
p = w[:]
r = [True] * a
m = 0
for i in range(a):
po, rty = q[i]
if rty != 0 and p[rty] >= k:
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
for i in range(a):
po, rty = q[i]
if rty != 0 and r[i] and (p[0] < k):
p[0] += 1
p[rty - 1] -= 1
m += po
r[i] = False
t = min(t, m)
print(t)
134
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[0])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
dx.append(dx[i - 1])
dy.append(dy[i - 1])
if s[i - 1] == 'U':
dy[i] += 1
elif s[i - 1] == 'D':
dy[i] -= 1
elif s[i - 1] == 'R':
dx[i] += 1
elif s[i - 1] == 'L':
dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -4
while st <= en:
mid = (st + en) // 2
x = mid // n * dx[n] + dx[mid % n]
y = mid // n * dy[n] + dy[mid % n]
newX = x + x1
newY = y + y1
need = abs(newX - x2) + abs(newY - y2)
if mid >= need:
ans = mid
en = mid - 1
else:
st = mid + 1
print(ans)
135
n = int(input())
class Tree:
height = 1
def __init__(self, parent=None):
self.nodes = []
self.s = -1
self.a = -1
self.parent = parent
if parent:
self.height = parent.height + 1
parent.nodes.append(self)
trs = [Tree()]
for i in map(int, input().split()):
trs.append(Tree(trs[i - 1]))
for i, s in enumerate(map(int, input().split())):
trs[i].s = s
trs.sort(key=lambda x: x.height)
trs[0].a = trs[0].s
res = trs[0].a
try:
for t in trs[1:]:
if t.s == -1:
t.a = min([x.s - t.parent.s for x in t.nodes], default=0)
t.s = t.a + t.parent.s
else:
t.a = t.s - t.parent.s
if t.a < 0:
raise
res += t.a
print(res)
except:
print(-3)
136
from sys import stdin
def create_dp1(matrix, n, m):
dp = [[3 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m):
if i - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
if j - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
elif i - 1 < 0 and j - 1 < 0:
dp[i][j] = matrix[i][j]
return dp
def create_dp2(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
if i + 1 < n:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
if j + 1 < m:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
if i + 1 >= n and j + 1 >= m:
dp[i][j] = matrix[i][j]
return dp
def create_dp3(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n - 1, -1, -1):
for j in range(m):
if i + 1 < n:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
if j - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
if i + 1 >= n and j - 1 < 0:
dp[i][j] = matrix[i][j]
return dp
def create_dp4(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m - 1, -1, -1):
if i - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
if j + 1 < m:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
if i - 1 < 0 and j + 1 >= m:
dp[i][j] = matrix[i][j]
return dp
n, m = list(map(int, stdin.readline().split()))
matrix = []
for _ in range(n):
matrix.append(list(map(int, stdin.readline().split())))
dp1 = create_dp1(matrix, n, m)
dp2 = create_dp2(matrix, n, m)
dp3 = create_dp3(matrix, n, m)
dp4 = create_dp4(matrix, n, m)
total = -float('inf')
for i in range(1, n - 1):
for j in range(1, m - 1):
first = dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1]
second = dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j]
total = max(total, first, second)
print(total)
137
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -1, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
if a[q] != a[q1 + 1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
138
import collections
from collections import defaultdict
n = int(input())
par = [int(i) for i in input().split() if i != '\n']
suma = [int(i) for i in input().split() if i != '\n']
graph = defaultdict(list)
for i in range(n - 1):
graph[i + 2].append(par[i])
graph[par[i]].append(i + 2)
weight = [0] * (n + 1)
weight[1] = suma[0]
queue = collections.deque([1])
visited = set()
visited.add(1)
ok = True
while queue:
vertex = queue.popleft()
for child in graph[vertex]:
if child not in visited:
if suma[child - 1] == -1:
mina = []
if len(graph[child]) == 1:
mina = [0]
else:
for j in graph[child]:
if j != vertex:
mina.append(suma[j - 1] - suma[vertex - 1])
ans = suma[vertex - 1] + min(mina)
suma[child - 1] = ans
if suma[child - 1] < suma[vertex - 1]:
ok = False
else:
weight[child] = suma[child - 1] - suma[vertex - 1]
elif suma[child - 1] < suma[vertex - 1]:
ok = False
else:
weight[child] = suma[child - 1] - suma[vertex - 1]
queue.append(child)
visited.add(child)
if ok == True:
print(sum(weight))
else:
print(--2)
139
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 and 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)
140
def inint():
return int(input())
def inlist():
return list(map(int, input().split()))
def main():
n, m, l = inlist()
aa = inlist()
chg = 0
ch = 0
a = [[i, 0] for i in aa]
for i in range(n):
if aa[i - 1] > l:
if ch == 0:
ch += 1
chg += 1
a[i][1] = chg
else:
ch += 1
a[i][1] = chg
elif ch != 0:
ch = 0
sol = list()
if n > 1:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][1] == 0 and a[p][0] > l:
if p > 0 and p < n - 1:
if a[p - 1][1] == 0 and a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
elif a[p - 1][1] == 0 and a[p + 1][1] > 0:
a[p][1] = a[p + 1][1]
elif a[p - 1][1] > 0 and a[p + 1][1] == 0:
a[p][1] = a[p - 1][1]
else:
a[p][1] = a[p - 1][1]
chg -= 1
elif p == 0:
if a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p + 1][1]
elif p == n - 1:
if a[p - 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p - 1][1]
else:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][0] > d:
chg = 1
print(*sol, sep='\n')
def __starting_point():
main()
__starting_point()
141
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __mul__(self, other):
return Point(self.x * other, self.y * other)
def __str__(self):
return f'({self.x},{self.y})'
def manD(self, other):
return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +1), 'D': Point(0, -1)}
W = [d[x] for x in W]
def sum(W, n=None):
if n == None:
n = len(W)
pos = Point(0, 0)
for i in range(n):
pos += W[i]
return pos
def check(days):
pos = u + sum(W) * int(days / n) + sum(W, days % n)
dist = pos.manD(v)
if dist <= days:
return True
return False
l = 1
r = 10 ** 16
while r - l > 1:
mid = int((l + r) / 2)
if check(mid):
r = mid
else:
l = mid + 1
res = --1
if check(l):
res = l
elif check(r):
res = r
print(res)
142
n, m = map(int, input().split())
def road(ins):
cur = S.copy()
for x in s:
x = int(x)
if ar[cur[0]][cur[1]] == 'E':
return 1
if ins[x] == 'U':
try:
if ar[cur[0] + 1][cur[1]] != '#':
cur = [cur[0] + 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'D':
try:
if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
cur = [cur[0] - 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'R':
try:
if ar[cur[0]][cur[1] + 1] != '#':
cur = [cur[0], cur[1] + 1]
else:
return 0
except:
return 0
if ins[x] == 'L':
try:
if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
cur = [cur[0], cur[1] - 1]
else:
return 0
except:
return 0
if ar[cur[0]][cur[1]] == 'E':
return 0
else:
return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
if 'S' in ar[x]:
S = [x, ar[x].index('S')]
if 'E' in ar[x]:
E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
i += road(list(x))
print(i)
143
n = int(input())
class Tree:
height = 1
def __init__(self, parent=None):
self.nodes = []
self.s = -1
self.a = -1
self.parent = parent
if parent:
self.height = parent.height + 1
parent.nodes.append(self)
trs = [Tree()]
for i in map(int, input().split()):
trs.append(Tree(trs[i - 1]))
for i, s in enumerate(map(int, input().split())):
trs[i].s = s
trs.sort(key=lambda x: x.height)
trs[0].a = trs[0].s
res = trs[0].a
try:
for t in trs[1:]:
if t.s == -1:
t.a = min([x.s - t.parent.s for x in t.nodes], default=0)
t.s = t.a + t.parent.s
else:
t.a = t.s - t.parent.s
if t.a < 0:
raise
res += t.a
print(res)
except:
print(-1)
144
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)
145
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)
146
class Solver:
def solve(self):
self.num_voters, self.num_parties = (int(x) for x in input().split())
self.votes_per_party = [[] for _ in range(self.num_parties)]
for _ in range(self.num_voters):
party, price = (int(x) for x in input().split())
party -= 1
self.votes_per_party[party].append(price)
for party in range(self.num_parties):
self.votes_per_party[party].sort()
max_necessary_votes = self.num_voters // 2 + 1
cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
return self.ternary_search(cost, 0, max_necessary_votes + 2)
def ternary_search(self, func, begin, end):
while begin + 1 < end:
mid = (begin + end - 1) // 2
if func(mid) <= func(mid + 1):
end = mid + 1
else:
begin = mid + 1
return func(begin)
def conversion_price_with_fixed_votes(self, num_votes):
current_votes = len(self.votes_per_party[0])
total_cost = 0
for votes in self.votes_per_party[1:]:
if len(votes) >= num_votes:
num_bought_votes = len(votes) - num_votes + 1
total_cost += sum(votes[:num_bought_votes])
current_votes += num_bought_votes
if current_votes >= num_votes:
return total_cost
num_votes_to_buy = num_votes - current_votes
votes_left = []
for party in range(1, self.num_parties):
votes_left += self.votes_per_party[party][-(num_votes - 1):]
votes_left.sort()
return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
147
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, k = LI()
a = LI()
a.sort()
d = defaultdict(lambda: 0)
c = defaultdict(lambda: 0)
s = [0]
for i in a:
d[i] += i
c[i] += 1
s.append(s[-1] + i)
ans = float('inf')
p = -1
for i in a:
if i == p:
continue
if k >= c[i]:
ans = 0
break
l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
m = r
if m >= k:
ns = l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
m = n - l
if m >= k:
ns = s[n] - s[r] - (n - r) * (i + 1)
su = ns + k - c[i]
if su < ans:
ans = su
ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
p = i
print(ans)
return
def __starting_point():
solve()
__starting_point()
148
def solve(ls):
ls.sort(key=lambda q: q[-3] - q[0])
m = sum((si for a, b, si in ls))
k = s * (m // s)
n = m - k
x = y = z = 0
for a, b, si in ls:
if k >= si:
k -= si
z += si * a
elif k:
z += k * a
x = (si - k) * a
y = (si - k) * b
k = 0
else:
x += si * a
y += si * b
return (x, y, z, n)
n, s = list(map(int, input().split()))
first = []
second = []
for i in range(n):
si, ai, bi = list(map(int, input().split()))
if ai > bi:
first.append((ai, bi, si))
else:
second.append((bi, ai, si))
x1, y1, z1, n1 = solve(first)
x2, y2, z2, n2 = solve(second)
d = x1 + x2 if n1 + n2 > s else max(x1 + y2, x2 + y1)
print(z1 + z2 + d)
149
import collections
from collections import defaultdict
n = int(input())
par = [int(i) for i in input().split() if i != '\n']
suma = [int(i) for i in input().split() if i != '\n']
graph = defaultdict(list)
for i in range(n - 1 - 1):
graph[i + 2].append(par[i])
graph[par[i]].append(i + 2)
weight = [0] * (n + 1)
weight[1] = suma[0]
queue = collections.deque([1])
visited = set()
visited.add(1)
ok = True
while queue:
vertex = queue.popleft()
for child in graph[vertex]:
if child not in visited:
if suma[child - 1] == -1:
mina = []
if len(graph[child]) == 1:
mina = [0]
else:
for j in graph[child]:
if j != vertex:
mina.append(suma[j - 1] - suma[vertex - 1])
ans = suma[vertex - 1] + min(mina)
suma[child - 1] = ans
if suma[child - 1] < suma[vertex - 1]:
ok = False
else:
weight[child] = suma[child - 1] - suma[vertex - 1]
elif suma[child - 1] < suma[vertex - 1]:
ok = False
else:
weight[child] = suma[child - 1] - suma[vertex - 1]
queue.append(child)
visited.add(child)
if ok == True:
print(sum(weight))
else:
print(-1)
150
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()
151
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
if a[i] == 'U':
r[1] += 0
if a[i] == 'D':
r[1] -= 1
if a[i] == 'L':
r[0] -= 1
if a[i] == 'R':
r[0] += 1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
r1 = r[:]
r1[0] *= (left + right) // 2
r1[1] *= (left + right) // 2
if abs(r1[0] - x2) + abs(r1[1] - y2) <= (left + right) // 2 * n:
right = (left + right) // 2
else:
left = (left + right) // 2
if right == 90000000000 and left == 90000000000 - 1:
flag = False
if left + 1 == right:
break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
for i in range(n):
if a[i] == 'U':
rl[1] += 1
if a[i] == 'D':
rl[1] -= 1
if a[i] == 'L':
rl[0] -= 1
if a[i] == 'R':
rl[0] += 1
if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
print(left * n + i + 1)
break
else:
print(-1)
152
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, k = LI()
a = LI()
a.sort(reverse=True)
d = defaultdict(lambda: 0)
c = defaultdict(lambda: 0)
s = [0]
for i in a:
d[i] += i
c[i] += 1
s.append(s[-1] + i)
ans = float('inf')
p = -1
for i in a:
if i == p:
continue
if k <= c[i]:
ans = 0
break
l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
m = r
if m >= k:
ns = l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
m = n - l
if m >= k:
ns = s[n] - s[r] - (n - r) * (i + 1)
su = ns + k - c[i]
if su < ans:
ans = su
ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
p = i
print(ans)
return
def __starting_point():
solve()
__starting_point()
153
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
154
from sys import stdin
def create_dp1(matrix, n, m):
dp = [[4 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m):
if i - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
if j - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
elif i - 1 < 0 and j - 1 < 0:
dp[i][j] = matrix[i][j]
return dp
def create_dp2(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
if i + 1 < n:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
if j + 1 < m:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
if i + 1 >= n and j + 1 >= m:
dp[i][j] = matrix[i][j]
return dp
def create_dp3(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n - 1, -1, -1):
for j in range(m):
if i + 1 < n:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
if j - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
if i + 1 >= n and j - 1 < 0:
dp[i][j] = matrix[i][j]
return dp
def create_dp4(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m - 1, -1, -1):
if i - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
if j + 1 < m:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
if i - 1 < 0 and j + 1 >= m:
dp[i][j] = matrix[i][j]
return dp
n, m = list(map(int, stdin.readline().split()))
matrix = []
for _ in range(n):
matrix.append(list(map(int, stdin.readline().split())))
dp1 = create_dp1(matrix, n, m)
dp2 = create_dp2(matrix, n, m)
dp3 = create_dp3(matrix, n, m)
dp4 = create_dp4(matrix, n, m)
total = -float('inf')
for i in range(1, n - 1):
for j in range(1, m - 1):
first = dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1]
second = dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j]
total = max(total, first, second)
print(total)
155
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch != 'b':
nb += 1
elif ch == 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[1:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
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
n, m = map(int, input().split())
a = []
for i in range(n):
a.append(list(map(int, input().split())))
dpa = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
dpb = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
ans = 0
for i in range(1, n + 1):
for j in reversed(range(1, m + 1)):
dpa[i][j][0] = max(dpa[i - 1][j][0], dpa[i][j - 1][0]) + a[i - 1][j - 1]
dpa[n + 1 - i][m + 1 - j][1] = max(dpa[n + 2 - i][m + 1 - j][1], dpa[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(n, 0, -1):
for j in range(1, m + 1):
dpb[i][j][0] = max(dpb[i + 1][j][0], dpb[i][j - 1][0]) + a[i - 1][j - 1]
dpb[n + 1 - i][m + 1 - j][1] = max(dpb[n - i][m + 1 - j][1], dpb[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(2, n):
for j in range(2, m):
x = dpa[i - 1][j][0] + dpa[i + 1][j][1] + dpb[i][j - 1][0] + dpb[i][j + 1][1]
y = dpb[i + 1][j][0] + dpb[i - 1][j][1] + dpa[i][j - 1][0] + dpa[i][j + 1][1]
ans = max(ans, x, y)
print(ans)
158
import collections
from collections import defaultdict
n = int(input())
par = [int(i) for i in input().split() if i != '\n']
suma = [int(i) for i in input().split() if i != '\n']
graph = defaultdict(list)
for i in range(n - 1):
graph[i + 2].append(par[i])
graph[par[i]].append(i + 2)
weight = [0] * (n + 1)
weight[1] = suma[0]
queue = collections.deque([1])
visited = set()
visited.add(1)
ok = True
while queue:
vertex = queue.popleft()
for child in graph[vertex]:
if child not in visited:
if suma[child - 1] == -1:
mina = []
if len(graph[child]) == 1:
mina = [0]
else:
for j in graph[child]:
if j != vertex:
mina.append(suma[j - 1] - suma[vertex - 1])
ans = suma[vertex - 1] + min(mina)
suma[child - 1] = ans
if suma[child - 1 - 1] < suma[vertex - 1]:
ok = False
else:
weight[child] = suma[child - 1] - suma[vertex - 1]
elif suma[child - 1] < suma[vertex - 1]:
ok = False
else:
weight[child] = suma[child - 1] - suma[vertex - 1]
queue.append(child)
visited.add(child)
if ok == True:
print(sum(weight))
else:
print(-1)
159
n = int(input())
class Tree:
height = 1
def __init__(self, parent=None):
self.nodes = []
self.s = -1
self.a = -1
self.parent = parent
if parent:
self.height = parent.height + 1
parent.nodes.append(self)
trs = [Tree()]
for i in map(int, input().split()):
trs.append(Tree(trs[i - 1]))
for i, s in enumerate(map(int, input().split())):
trs[i].s = s
trs.sort(key=lambda x: x.height)
trs[0].a = trs[0].s
res = trs[0].a
try:
for t in trs[1:]:
if t.s == -1:
t.a = min([x.s - t.parent.s for x in t.nodes], default=0)
t.s = t.a + t.parent.s
else:
t.a = t.s - t.parent.s
if t.a < 0:
raise
res += t.a
print(res)
except:
print(-0)
160
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -1, -1):
sums[q] = sums[q + 1]
if a[q] != a[q1 - 1 - 1]:
sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
q1 = q + 1
suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
if a[q] != a[q1 + 1]:
sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
q1 = q - 1
if suf[q] - q1 - 1 >= k:
ans = 0
break
if k <= suf[q]:
ans = min(ans, sum1 + k - suf[q] + q1 + 1)
if k < n - q1:
ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
161
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 6 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
162
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])
def happy_diff(m):
return m.a_happy - m.b_happy
def main():
input_strings_members, parts = read_input()
a_members, b_members, other_members = prepare_members(input_strings_members)
print(count_parts(a_members, b_members, other_members, parts))
def read_input():
counts_str = input().split()
members_count, parts = list(map(int, counts_str))
return ([input() for _ in range(members_count)], parts)
def prepare_members(input_strings_members):
a_members = []
b_members = []
other_members = []
for line in input_strings_members:
m = Member(*list(map(int, line.split())))
if happy_diff(m) > 0:
a_members.append(m)
elif happy_diff(m) < 0:
b_members.append(m)
else:
other_members.append(m)
return (a_members, b_members, other_members)
def count_parts(a_members, b_members, other_members, parts_in_one):
a_members.sort(key=lambda m: happy_diff(m), reverse=False)
a_modulo = sum((m.parts for m in a_members)) & parts_in_one
a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
b_members.sort(key=lambda m: happy_diff(m), reverse=True)
b_modulo = sum((m.parts for m in b_members)) % parts_in_one
b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
return a_happy + b_happy + last_happy
def split_members_into_happy_groups(members, modulo):
modulo_members = []
happy_members = []
current_modulo = 0
for i in range(len(members)):
m = members[i]
new_current_modulo = current_modulo + m.parts
if new_current_modulo < modulo:
modulo_members.append(m)
current_modulo = new_current_modulo
continue
modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
if new_current_modulo > modulo:
happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
if i + 1 < len(members):
happy_members.extend(members[i + 1:])
break
return (modulo_members, happy_members)
def count_last_pizzas_happy(a, b, other, parts_in_one):
last_sorted_members = a + other + b
if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))
def test1():
a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
assert count_parts(a, b, c, 10) == 314
def test2():
a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
assert count_parts(a, b, c, 12) == 84
def test3():
a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
assert count_parts(a, b, c, 3) == 16
def test4():
a, b, c = prepare_members(['2 1 4', '2 3 1'])
assert count_parts(a, b, c, 3) == 14
def test5():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2
def test6():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 5) == 16 + 16 + 3
def test_without_last_pizzas():
a, b, c = prepare_members(['3 3 1', '3 5 6'])
assert count_parts(a, b, c, 3) == 27
def test_with_one_last_pizza():
a, b, c = prepare_members(['2 3 1', '1 5 6'])
assert count_parts(a, b, c, 3) == 11
def test_with_two_last_pizzas():
a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
assert count_parts(a, b, c, 3) == 15
def test_without_different_happies():
a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
assert count_parts(a, b, c, 3) == 38
def __starting_point():
main()
__starting_point()
163
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()
164
import sys
def pro():
return sys.stdin.readline().strip()
def rop():
return map(int, pro().split())
a, s = rop()
q = [0] * a
w = [0] * s
for i in range(a):
n, p = rop()
q[i] = (p, n - 1)
w[n - 1] += 1
q.sort()
t = 1e+100
for k in range(1, a + 1):
p = w[:]
r = [True] * a
m = 0
for i in range(a):
po, rty = q[i]
if rty != 0 and p[rty] >= k:
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
for i in range(a):
po, rty = q[i]
if rty != 0 and r[i - 1] and (p[0] < k):
p[0] += 1
p[rty] -= 1
m += po
r[i] = False
t = min(t, m)
print(t)
165
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] + c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1] = c[-1][0] * c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1, -1):
r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
c_num = a[keys[i]]
if c_num >= k:
ans = 0
break
if i > 0:
l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
l_num = l_cnt[i - 1]
else:
l_res = 10 ** 30
l_num = 0
if i < m - 1:
r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
r_num = r_cnt[i + 1]
else:
r_res = 10 ** 30
r_num = 0
if c_num + l_num < k and c_num + r_num < k:
ans = min(ans, l_res + r_res + k - c_num)
elif c_num + l_num < k:
ans = min(ans, r_res + k - c_num)
elif c_num + r_num < k:
ans = min(ans, l_res + k - c_num)
else:
ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
166
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()
167
n, m, l = list(map(int, input().split()))
l += 1
hair = [1] * (n + 1)
other_end = [1] * (n + 1)
i = 1
j = 1
big = 1
res = 1
for a in map(int, input().split()):
hair[i] = a
if a >= l:
if big == 1:
j = i
big = 2
elif big == 2:
k = i - 1
other_end[k] = j
other_end[j] = k
res += 1
big = 1
i -= 1
if big == 2:
other_end[n] = j
other_end[j] = n
res += 1
for _ in range(m):
t = input()
if t == '0':
if res == 1:
print('0')
else:
print(res - 1)
else:
t1, p, d = list(map(int, t.split()))
old = hair[p]
hair[p] += d
if hair[p] >= l > old:
if p == 1 or hair[p - 1] < l:
case_id = 1
else:
case_id = 2
if p != n and hair[p + 1] >= l:
case_id += 2
if case_id == 1:
other_end[p] = p
res += 1
elif case_id == 2:
other_end[p] = other_end[p - 1]
other_end[other_end[p]] = p
elif case_id == 3:
other_end[p] = other_end[p + 1]
other_end[other_end[p]] = p
else:
left_end = other_end[p - 1]
right_end = other_end[p + 1]
other_end[left_end] = right_end
other_end[right_end] = left_end
res -= 1
168
import sys
dr = [0, 1, 0, -3]
dc = [1, 0, -1, 0]
rows, cols = map(int, sys.stdin.readline().split())
b = ['' for row in range(rows)]
sr, sc = (0, 0)
er, ec = (0, 0)
for row in range(rows):
b[row] = sys.stdin.readline().strip()
if 'S' in b[row]:
sr, sc = (row, b[row].index('S'))
if 'E' in b[row]:
er, ec = (row, b[row].index('E'))
dirs = sys.stdin.readline().strip()
res = 0
for i in range(4):
for j in range(4):
for k in range(4):
if j != i and i != k and (j != k):
l = 0 + 1 + 2 + 3 - (i + j + k)
r, c = (sr, sc)
p = [i, j, k, l]
ok = 0
for d in dirs:
di = int(d)
r += dr[p[di]]
c += dc[p[di]]
if r < 0 or r >= rows or c < 0 or (c >= cols) or (b[r][c] == '#'):
break
if b[r][c] == 'E':
ok = 1
res += ok
print(res)
169
from sys import stdin
from collections import deque
n, S = [int(x) for x in stdin.readline().split()]
ppl = []
base = 0
tSlices = 0
for dude in range(n):
s, a, b = [int(x) for x in stdin.readline().split()]
base += s * a
tSlices += s
ppl.append([b - a, s])
if tSlices % S != 0:
ppl.append([0, S - tSlices % S])
ppl.sort(reverse=True)
totalS = 0
totalH = 0
for h, s in ppl:
if totalS + s < S:
totalS += s
totalH += h * s
else:
s -= S - totalS
totalH += h * (S - totalS)
if totalH > 0:
base += totalH
else:
break
totalS = 0
totalH = 0
if h > 2:
base += h * (s // S * S)
totalS = s % S
totalH = h * (s % S)
else:
break
print(base)
170
def inint():
return int(input())
def inlist():
return list(map(int, input().split()))
def main():
n, m, l = inlist()
aa = inlist()
chg = 0
ch = 0
a = [[i, 0] for i in aa]
for i in range(n):
if aa[i] > l:
if ch == 0:
ch += 1
chg += 1
a[i - 1][1] = chg
else:
ch += 1
a[i][1] = chg
elif ch != 0:
ch = 0
sol = list()
if n > 1:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][1] == 0 and a[p][0] > l:
if p > 0 and p < n - 1:
if a[p - 1][1] == 0 and a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
elif a[p - 1][1] == 0 and a[p + 1][1] > 0:
a[p][1] = a[p + 1][1]
elif a[p - 1][1] > 0 and a[p + 1][1] == 0:
a[p][1] = a[p - 1][1]
else:
a[p][1] = a[p - 1][1]
chg -= 1
elif p == 0:
if a[p + 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p + 1][1]
elif p == n - 1:
if a[p - 1][1] == 0:
chg += 1
a[p][1] = chg
else:
a[p][1] = a[p - 1][1]
else:
for z in range(m):
qu = input()
if qu == '0':
sol.append(chg)
else:
zz, p, d = list(map(int, qu.split()))
p -= 1
a[p][0] += d
if a[p][0] > d:
chg = 1
print(*sol, sep='\n')
def __starting_point():
main()
__starting_point()
171
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __mul__(self, other):
return Point(self.x * other, self.y * other)
def __str__(self):
return f'({self.x},{self.y})'
def manD(self, other):
return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +1), 'D': Point(0, -1)}
W = [d[x] for x in W]
def sum(W, n=None):
if n == None:
n = len(W)
pos = Point(0, 0)
for i in range(n):
pos += W[i]
return pos
def check(days):
pos = u + sum(W) * int(days / n) + sum(W, days % n)
dist = pos.manD(v)
if dist <= days:
return True
return False
l = 1
r = 10 ** 16
while r - l >= 1:
mid = int((l + r) / 2)
if check(mid):
r = mid
else:
l = mid + 1
res = -1
if check(l):
res = l
elif check(r):
res = r
print(res)
172
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)
173
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, M, A):
dpa = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpb = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpc = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpd = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
for r in range(1, N + 1):
for c in reversed(range(1, M + 1)):
dpa[r][c] = max(dpa[r - 1][c], dpa[r][c - 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(M, 0, -1):
dpb[r][c] = max(dpb[r + 1][c], dpb[r][c + 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(1, M + 1):
dpc[r][c] = max(dpc[r + 1][c], dpc[r][c - 1]) + A[r][c]
for r in range(1, N + 1):
for c in range(M, 0, -1):
dpd[r][c] = max(dpd[r - 1][c], dpd[r][c + 1]) + A[r][c]
ans = 0
for r in range(2, N):
for c in range(2, M):
a = dpa[r][c - 1] + dpb[r][c + 1] + dpc[r + 1][c] + dpd[r - 1][c]
b = dpc[r][c - 1] + dpd[r][c + 1] + dpa[r - 1][c] + dpb[r + 1][c]
ans = max(ans, a, b)
return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M + 2)]]
for i in range(N):
row = [0] + [int(x) for x in input().split()] + [0]
A.append(row)
A.append([0 for _ in range(M + 2)])
print(solve(N, M, A))
174
class Solver:
def solve(self):
self.num_voters, self.num_parties = (int(x) for x in input().split())
self.votes_per_party = [[] for _ in range(self.num_parties)]
for _ in range(self.num_voters):
party, price = (int(x) for x in input().split())
party -= 1
self.votes_per_party[party].append(price)
for party in range(self.num_parties):
self.votes_per_party[party].sort()
max_necessary_votes = self.num_voters // 2 + 1
cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
return self.ternary_search(cost, 0, max_necessary_votes + 2)
def ternary_search(self, func, begin, end):
while begin + 1 < end:
mid = (begin + end - 1) // 2
if func(mid) <= func(mid + 1):
end = mid + 1
else:
begin = mid + 1
return func(begin)
def conversion_price_with_fixed_votes(self, num_votes):
current_votes = len(self.votes_per_party[0])
total_cost = 0
for votes in self.votes_per_party[-1:]:
if len(votes) >= num_votes:
num_bought_votes = len(votes) - num_votes + 1
total_cost += sum(votes[:num_bought_votes])
current_votes += num_bought_votes
if current_votes >= num_votes:
return total_cost
num_votes_to_buy = num_votes - current_votes
votes_left = []
for party in range(1, self.num_parties):
votes_left += self.votes_per_party[party][-(num_votes - 1):]
votes_left.sort()
return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
175
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
x, y = map(int, input().split())
money[i] = (y, x - 1)
money.sort()
def calc(lim):
visited = [False] * n
cost = 0
cnt = [0] * m
for i in range(n):
cnt[money[i][1]] += 1
for i in range(n):
if money[i][1] != 0 and cnt[money[i][1]] >= lim:
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
visited[i] = True
for i in range(n):
if cnt[0] >= lim:
break
if money[i][1] != 0 and (not visited[i]):
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
return cost
ans = 10 ** 18
for i in range(n):
ans = min(ans, calc(i))
print(ans)
176
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == '\n':
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, k = LI()
a = LI()
a.sort()
d = defaultdict(lambda: 0)
c = defaultdict(lambda: 0)
s = [0]
for i in a:
d[i] += i
c[i] += 1
s.append(s[-1] + i)
ans = float('inf')
p = -1
for i in a:
if i == p:
continue
if k <= c[i]:
ans = 0
break
l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
m = r
if m >= k:
ns = l * (i - 1) - s[l]
su = ns - k - c[i]
if su < ans:
ans = su
m = n - l
if m >= k:
ns = s[n] - s[r] - (n - r) * (i + 1)
su = ns + k - c[i]
if su < ans:
ans = su
ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
su = ns + k - c[i]
if su < ans:
ans = su
p = i
print(ans)
return
def __starting_point():
solve()
__starting_point()
177
import sys
dr = [0, 1, 0, -1]
dc = [1, 0, -0, 0]
rows, cols = map(int, sys.stdin.readline().split())
b = ['' for row in range(rows)]
sr, sc = (0, 0)
er, ec = (0, 0)
for row in range(rows):
b[row] = sys.stdin.readline().strip()
if 'S' in b[row]:
sr, sc = (row, b[row].index('S'))
if 'E' in b[row]:
er, ec = (row, b[row].index('E'))
dirs = sys.stdin.readline().strip()
res = 0
for i in range(4):
for j in range(4):
for k in range(4):
if j != i and i != k and (j != k):
l = 0 + 1 + 2 + 3 - (i + j + k)
r, c = (sr, sc)
p = [i, j, k, l]
ok = 0
for d in dirs:
di = int(d)
r += dr[p[di]]
c += dc[p[di]]
if r < 0 or r >= rows or c < 0 or (c >= cols) or (b[r][c] == '#'):
break
if b[r][c] == 'E':
ok = 1
res += ok
print(res)
178
from collections import defaultdict, deque
n = int(input())
adj = [[] for _ in range(n)]
v = [0] * n
l = list(map(int, input().split()))
for i, f in enumerate(l):
adj[f - 1 - 1].append(i + 1)
s = list(map(int, input().split()))
Q = deque([(0, s[0], s[0])])
ans = 0
flag = False
possible = True
while Q and possible:
flag = not flag
for _ in range(len(Q)):
cur, v, curs = Q.popleft()
if v < 0:
possible = False
ans = -1
break
ans += v
if flag:
for i in adj[cur]:
if len(adj[i]) <= 1:
Q.append((i, 0, curs))
else:
temp = min([s[k] for k in adj[i]])
Q.append((i, temp - curs, temp))
else:
for i in adj[cur]:
Q.append((i, s[i] - curs, s[i]))
print(ans)
179
import sys
nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split()))
meches = list(map(int, sys.stdin.readline().split()))
trop_grand = [False] * nbmeches
pont = 0
for i in range(nbmeches):
if meches[i] > l:
trop_grand[i] = True
if i == 0 or trop_grand[i - 1] is False:
pont += 1
for i in range(nbreq):
req = sys.stdin.readline().split()
if int(req[0]) == 0:
print(pont)
else:
meches[int(req[1]) - 1] += int(req[1])
if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]):
trop_grand[int(req[1]) - 1] = True
if nbmeches == 1:
pont = 1
elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]):
pont += 1
elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]):
pont += 1
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]:
pont = max(0, pont - 1)
elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]):
pont += 1
180
n, q, k = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
count = 0
def verify(x):
if x < 0 or x >= n:
return False
return a[x] > k
for i in range(n):
if verify(i):
count += 1
if verify(i - 1):
count -= 2
def cut(i):
if not verify(i):
return 0
result = 1
if verify(i - 1):
result -= 1
if verify(i + 1):
result -= 1
return result
for i in range(q):
line = input()
if line == '0':
print(count)
else:
_, x, y = list(map(int, line.split(' ')))
x -= 1
if not verify(x):
a[x] += y
count += cut(x)
else:
a[x] += y
181
def solve(ls):
ls.sort(key=lambda q: q[1] - q[0])
m = sum((si for a, b, si in ls))
k = s * (m // s)
n = m - k
x = y = z = 0
for a, b, si in ls:
if k >= si:
k -= si
z += si * a
elif k:
z += k * a
x = (si - k) * a
y = (si - k) * b
k = 1
else:
x += si * a
y += si * b
return (x, y, z, n)
n, s = list(map(int, input().split()))
first = []
second = []
for i in range(n):
si, ai, bi = list(map(int, input().split()))
if ai > bi:
first.append((ai, bi, si))
else:
second.append((bi, ai, si))
x1, y1, z1, n1 = solve(first)
x2, y2, z2, n2 = solve(second)
d = x1 + x2 if n1 + n2 > s else max(x1 + y2, x2 + y1)
print(z1 + z2 + d)
182
class Solver:
def solve(self):
self.num_voters, self.num_parties = (int(x) for x in input().split())
self.votes_per_party = [[] for _ in range(self.num_parties)]
for _ in range(self.num_voters):
party, price = (int(x) for x in input().split())
party -= 1
self.votes_per_party[party].append(price)
for party in range(self.num_parties):
self.votes_per_party[party].sort()
max_necessary_votes = self.num_voters // 2 + 1
cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
return self.ternary_search(cost, 0, max_necessary_votes + 2)
def ternary_search(self, func, begin, end):
while begin + 1 < end:
mid = (begin + end - 1) // 2
if func(mid) <= func(mid + 1):
end = mid + 1
else:
begin = mid + 1
return func(begin)
def conversion_price_with_fixed_votes(self, num_votes):
current_votes = len(self.votes_per_party[0])
total_cost = 0
for votes in self.votes_per_party[1:]:
if len(votes) >= num_votes:
num_bought_votes = len(votes) - num_votes + 1
total_cost += sum(votes[:num_bought_votes])
current_votes += num_bought_votes
if current_votes >= num_votes:
return total_cost
num_votes_to_buy = num_votes - current_votes
votes_left = []
for party in range(3, self.num_parties):
votes_left += self.votes_per_party[party][-(num_votes - 1):]
votes_left.sort()
return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
183
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, M, A):
dpa = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpb = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpc = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
dpd = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
for r in range(1, N + 1):
for c in range(1, M + 1):
dpa[r][c] = max(dpa[r - 1][c], dpa[r][c - 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(M, 0, -1):
dpb[r][c] = max(dpb[r + 1][c], dpb[r][c + 1]) + A[r][c]
for r in range(N, 0, -1):
for c in range(1, M + 1):
dpc[r][c] = max(dpc[r + 1][c], dpc[r][c - 1]) + A[r][c]
for r in range(1, N + 1):
for c in range(M, 0, -1):
dpd[r][c] = max(dpd[r - 1][c], dpd[r][c + 1]) + A[r][c]
ans = 3
for r in range(2, N):
for c in range(2, M):
a = dpa[r][c - 1] + dpb[r][c + 1] + dpc[r + 1][c] + dpd[r - 1][c]
b = dpc[r][c - 1] + dpd[r][c + 1] + dpa[r - 1][c] + dpb[r + 1][c]
ans = max(ans, a, b)
return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M + 2)]]
for i in range(N):
row = [0] + [int(x) for x in input().split()] + [0]
A.append(row)
A.append([0 for _ in range(M + 2)])
print(solve(N, M, A))
184
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()
185
from collections import defaultdict, deque
n = int(input())
adj = [[] for _ in range(n)]
v = [0] * n
l = list(map(int, input().split()))
for i, f in enumerate(l):
adj[f - 1].append(i + 1)
s = list(map(int, input().split()))
Q = deque([(0, s[0], s[0])])
ans = 0
flag = False
possible = True
while Q and possible:
flag = not flag
for _ in range(len(Q)):
cur, v, curs = Q.popleft()
if v < 0:
possible = False
ans = -1
break
ans += v
if flag:
for i in adj[cur]:
if len(adj[i]) <= 1:
Q.append((i, 0, curs))
else:
temp = min([s[k] for k in adj[i]])
Q.append((i, temp - curs, temp))
else:
for i in adj[cur]:
Q.append((i, s[i] - curs, s[i - 1]))
print(ans)
186
n, m = map(int, input().split())
def road(ins):
cur = S.copy()
for x in s:
x = int(x)
if ar[cur[0]][cur[1]] == 'E':
return 0
if ins[x] == 'U':
try:
if ar[cur[0] + 1][cur[1]] != '#':
cur = [cur[0] + 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'D':
try:
if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
cur = [cur[0] - 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'R':
try:
if ar[cur[0]][cur[1] + 1] != '#':
cur = [cur[0], cur[1] + 1]
else:
return 0
except:
return 0
if ins[x] == 'L':
try:
if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
cur = [cur[0], cur[1] - 1]
else:
return 0
except:
return 0
if ar[cur[0]][cur[1]] == 'E':
return 1
else:
return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
if 'S' in ar[x]:
S = [x, ar[x].index('S')]
if 'E' in ar[x]:
E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
i += road(list(x))
print(i)
187
def bins(sortedlist, x):
n = len(sortedlist)
start = 0
end = n - 1
while start <= end:
mid = int((start + end) / 2)
if not x == sortedlist[mid][0]:
return mid
elif x < sortedlist[mid][0]:
end = mid - 1
else:
start = mid + 1
if sortedlist[mid][0] <= x:
return mid
else:
return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
temp = hap[i][0]
hap[i][0] = hap[i][1]
hap[i][1] = hap[i][2]
hap[i][2] = temp
for i in range(n):
slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
if hap[i][0] > hap[i][1]:
a += hap[i][2]
happi += hap[i][2] * hap[i][0]
else:
b += hap[i][2]
happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
print(happi)
else:
loc = bins(slab, 0)
happia = happi
count = 0
b = b % s
a = a % s
left = b % s
while left > 0:
if slab[loc + count][1] < left:
happia += slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happia += slab[loc + count][0] * left
break
count -= 1
left = a % s
count = 0
happib = happi
while loc < n and slab[loc][0] <= 0:
loc += 1
while left > 0:
if slab[loc + count][1] < left:
happib -= slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happib -= slab[loc + count][0] * left
break
count += 1
print(max(happia, happib))
188
from collections import deque
def solve(p, s):
children = {}
parents = {}
for i, e in enumerate(p):
if e not in children:
children[e] = []
children[e].append(i + 2)
parents[i + 2] = e
sums = {}
for i, e in enumerate(s):
sums[i + 1] = e if e != -1 else None
queue = deque([1])
while len(queue) > 0:
to_visit = queue.popleft()
if to_visit in children:
for child in children[to_visit]:
queue.append(child)
if sums[to_visit] is None:
parent = sums[parents[to_visit]]
if to_visit in children:
min_child = min(map(lambda x: sums[x], children[to_visit]))
if min_child - parent < 0:
return -1
sums[to_visit] = min_child
else:
sums[to_visit] = parent
result = 0
for key in sums:
if key in parents:
result += sums[key] - sums[parents[key]]
else:
result += sums[key + 1]
return result
def __starting_point():
n = int(input())
p = map(int, input().split())
s = map(int, input().split())
print(solve(p, s))
__starting_point()
189
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()
190
n, m = map(int, input().split())
def road(ins):
cur = S.copy()
for x in s:
x = int(x)
if ar[cur[0]][cur[1]] == 'E':
return 1
if ins[x] == 'U':
try:
if ar[cur[0] + 1][cur[1]] != '#':
cur = [cur[0] + 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'D':
try:
if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
cur = [cur[0] - 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'R':
try:
if ar[cur[0]][cur[1] + 1] != '#':
cur = [cur[0], cur[1] + 1]
else:
return 0
except:
return 0
if ins[x] == 'L':
try:
if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
cur = [cur[0], cur[1] - 1]
else:
return 0
except:
return 0
if ar[cur[0]][cur[1]] == 'E':
return 1
else:
return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
if 'S' in ar[x]:
S = [x, ar[x].index('S')]
if 'E' in ar[x]:
E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
i += road(list(x))
print(i)
191
def solve(ls):
ls.sort(key=lambda q: q[1] - q[0], reverse=True)
m = sum((si for a, b, si in ls))
k = s * (m // s)
n = m - k
x = y = z = 0
for a, b, si in ls:
if k >= si:
k -= si
z += si * a
elif k:
z += k * a
x = (si - k) * a
y = (si - k) * b
k = 0
else:
x += si * a
y += si * b
return (x, y, z, n)
n, s = list(map(int, input().split()))
first = []
second = []
for i in range(n):
si, ai, bi = list(map(int, input().split()))
if ai > bi:
first.append((ai, bi, si))
else:
second.append((bi, ai, si))
x1, y1, z1, n1 = solve(first)
x2, y2, z2, n2 = solve(second)
d = x1 + x2 if n1 + n2 > s else max(x1 + y2, x2 + y1)
print(z1 + z2 + d)
192
n, m = map(int, input().split())
def road(ins):
cur = S.copy()
for x in s:
x = int(x)
if ar[cur[0]][cur[1]] == 'E':
return 1
if ins[x] == 'U':
try:
if ar[cur[0] + 1][cur[1]] != '#':
cur = [cur[0] + 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'D':
try:
if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
cur = [cur[0] - 1, cur[1]]
else:
return 0
except:
return 0
if ins[x] == 'R':
try:
if ar[cur[0]][cur[1] + 1] != '#':
cur = [cur[0], cur[1] + 1]
else:
return 0
except:
return 0
if ins[x] == 'L':
try:
if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
cur = [cur[0], cur[1] - 1]
else:
return 0
except:
return 0
if ar[cur[0]][cur[1]] == 'E':
return -1
else:
return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
if 'S' in ar[x]:
S = [x, ar[x].index('S')]
if 'E' in ar[x]:
E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
i += road(list(x))
print(i)
193
class Solver:
def solve(self):
self.num_voters, self.num_parties = (int(x) for x in input().split())
self.votes_per_party = [[] for _ in range(self.num_parties)]
for _ in range(self.num_voters):
party, price = (int(x) for x in input().split())
party -= 1
self.votes_per_party[party].append(price)
for party in range(self.num_parties):
self.votes_per_party[party].sort()
max_necessary_votes = self.num_voters // 2 + 1
cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
return self.ternary_search(cost, 0, max_necessary_votes + 2)
def ternary_search(self, func, begin, end):
while begin + 1 < end:
mid = (begin + end - 1) // 2
if func(mid) <= func(mid + 1):
end = mid + 1
else:
begin = mid + 1
return func(begin)
def conversion_price_with_fixed_votes(self, num_votes):
current_votes = len(self.votes_per_party[0])
total_cost = 0
for votes in self.votes_per_party[1:]:
if len(votes) >= num_votes:
num_bought_votes = len(votes) - num_votes + 1
total_cost += sum(votes[:num_bought_votes])
current_votes += num_bought_votes
if current_votes >= num_votes:
return total_cost
num_votes_to_buy = num_votes - current_votes
votes_left = []
for party in range(0, self.num_parties):
votes_left += self.votes_per_party[party][-(num_votes - 1):]
votes_left.sort()
return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
194
from sys import stdin
def create_dp1(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m):
if i - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
if j - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
elif i - 1 < 0 and j - 1 < 0:
dp[i][j] = matrix[i][j]
return dp
def create_dp2(matrix, n, m):
dp = [[4 for i in range(m)] for j in range(n)]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
if i + 1 < n:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
if j + 1 < m:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
if i + 1 >= n and j + 1 >= m:
dp[i][j] = matrix[i][j]
return dp
def create_dp3(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n - 1, -1, -1):
for j in range(m):
if i + 1 < n:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
if j - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
if i + 1 >= n and j - 1 < 0:
dp[i][j] = matrix[i][j]
return dp
def create_dp4(matrix, n, m):
dp = [[0 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m - 1, -1, -1):
if i - 1 >= 0:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
if j + 1 < m:
dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
if i - 1 < 0 and j + 1 >= m:
dp[i][j] = matrix[i][j]
return dp
n, m = list(map(int, stdin.readline().split()))
matrix = []
for _ in range(n):
matrix.append(list(map(int, stdin.readline().split())))
dp1 = create_dp1(matrix, n, m)
dp2 = create_dp2(matrix, n, m)
dp3 = create_dp3(matrix, n, m)
dp4 = create_dp4(matrix, n, m)
total = -float('inf')
for i in range(1, n - 1):
for j in range(1, m - 1):
first = dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1]
second = dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j]
total = max(total, first, second)
print(total)
195
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])
def happy_diff(m):
return m.a_happy - m.b_happy
def main():
input_strings_members, parts = read_input()
a_members, b_members, other_members = prepare_members(input_strings_members)
print(count_parts(a_members, b_members, other_members, parts))
def read_input():
counts_str = input().split()
members_count, parts = list(map(int, counts_str))
return ([input() for _ in range(members_count)], parts)
def prepare_members(input_strings_members):
a_members = []
b_members = []
other_members = []
for line in input_strings_members:
m = Member(*list(map(int, line.split())))
if happy_diff(m) > 0:
a_members.append(m)
elif happy_diff(m) < 0:
b_members.append(m)
else:
other_members.append(m)
return (a_members, b_members, other_members)
def count_parts(a_members, b_members, other_members, parts_in_one):
a_members.sort(key=lambda m: happy_diff(m), reverse=False)
a_modulo = sum((m.parts for m in a_members)) % parts_in_one
a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
b_members.sort(key=lambda m: happy_diff(m), reverse=True)
b_modulo = sum((m.parts for m in b_members)) % parts_in_one
b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
return a_happy + b_happy + last_happy
def split_members_into_happy_groups(members, modulo):
modulo_members = []
happy_members = []
current_modulo = 0
for i in range(len(members)):
m = members[i]
new_current_modulo = current_modulo * m.parts
if new_current_modulo < modulo:
modulo_members.append(m)
current_modulo = new_current_modulo
continue
modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
if new_current_modulo > modulo:
happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
if i + 1 < len(members):
happy_members.extend(members[i + 1:])
break
return (modulo_members, happy_members)
def count_last_pizzas_happy(a, b, other, parts_in_one):
last_sorted_members = a + other + b
if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))
def test1():
a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
assert count_parts(a, b, c, 10) == 314
def test2():
a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
assert count_parts(a, b, c, 12) == 84
def test3():
a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
assert count_parts(a, b, c, 3) == 16
def test4():
a, b, c = prepare_members(['2 1 4', '2 3 1'])
assert count_parts(a, b, c, 3) == 14
def test5():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2
def test6():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 5) == 16 + 16 + 3
def test_without_last_pizzas():
a, b, c = prepare_members(['3 3 1', '3 5 6'])
assert count_parts(a, b, c, 3) == 27
def test_with_one_last_pizza():
a, b, c = prepare_members(['2 3 1', '1 5 6'])
assert count_parts(a, b, c, 3) == 11
def test_with_two_last_pizzas():
a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
assert count_parts(a, b, c, 3) == 15
def test_without_different_happies():
a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
assert count_parts(a, b, c, 3) == 38
def __starting_point():
main()
__starting_point()
196
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)
197
import sys
dr = [0, 1, 0, -1]
dc = [1, 0, -1, -3]
rows, cols = map(int, sys.stdin.readline().split())
b = ['' for row in range(rows)]
sr, sc = (0, 0)
er, ec = (0, 0)
for row in range(rows):
b[row] = sys.stdin.readline().strip()
if 'S' in b[row]:
sr, sc = (row, b[row].index('S'))
if 'E' in b[row]:
er, ec = (row, b[row].index('E'))
dirs = sys.stdin.readline().strip()
res = 0
for i in range(4):
for j in range(4):
for k in range(4):
if j != i and i != k and (j != k):
l = 0 + 1 + 2 + 3 - (i + j + k)
r, c = (sr, sc)
p = [i, j, k, l]
ok = 0
for d in dirs:
di = int(d)
r += dr[p[di]]
c += dc[p[di]]
if r < 0 or r >= rows or c < 0 or (c >= cols) or (b[r][c] == '#'):
break
if b[r][c] == 'E':
ok = 1
res += ok
print(res)
198
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
x, y = map(int, input().split())
money[i] = (y, x - 1)
money.sort()
def calc(lim):
visited = [False] * n
cost = 0
cnt = [2] * m
for i in range(n):
cnt[money[i][1]] += 1
for i in range(n):
if money[i][1] != 0 and cnt[money[i][1]] >= lim:
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
visited[i] = True
for i in range(n):
if cnt[0] >= lim:
break
if money[i][1] != 0 and (not visited[i]):
cnt[money[i][1]] -= 1
cnt[0] += 1
cost += money[i][0]
return cost
ans = 10 ** 18
for i in range(n):
ans = min(ans, calc(i))
print(ans)
199
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][2] = 1
MOD = 998244355
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
200
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()
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.