input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
print((["Yay!", ":(", ":("][sum([int(x) > 8 for x in input().split()])]))
| a, b = [int(x) for x in input().split()]
print((["Yay!", ":("][a > 8 or b > 8])) | p03323 |
A, B = list(map(int, input().split()))
if all([A < 9, B < 9]):
print("Yay!")
else:
print(":(")
| A, B = list(map(int, input().split()))
if A > 8 or B > 8:
print(":(")
else:
print("Yay!")
| p03323 |
import sys
tmp = [int(i) for i in input().split()]
a = tmp[0]
b = tmp[1]
if a <= 8 and b <= 8:
print('Yay!')
sys.stdout.flush()
else:
print(':(') | import sys
tmp = [int(i) for i in input().split()]
a = tmp[0]
b = tmp[1]
if a <= 8 and b <= 8:
print('Yay!')
sys.stdout.flush()
else:
print(':(')
sys.stdout.flush() | p03323 |
print(([':(','Yay!'][eval('max('+input().replace(' ',',')+')')<=8])) | a,b=list(map(int,input().split()))
print(([':(','Yay!'][a<9 and b<9])) | p03323 |
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(eval(input()))
def inpl(): return list(map(int, input().split()))
def inpl_s(): return list(input().split())
atoz = [chr(i) for i in range(97,97+26)]
A,B = inpl()
if A<=8 and B<=8:
print('Yay!')
else:
print(':(')
| A,B = list(map(int, input().split()))
if A<=8 and B<=8:
print('Yay!')
else:
print(':(') | p03323 |
A,B = list(map(int,input().split()))
if max(A,B) <= 8:
print("Yay!")
else:
print(":(") | A, B = list(map(int,input().split()))
if A <= 8 and B <= 8:
print("Yay!")
else:
print(":(") | p03323 |
import functools
import os
INF = float('inf')
def inp():
return int(input())
def inpf():
return float(input())
def inps():
return input()
def inl():
return list(map(int, input().split()))
def inlf():
return list(map(float, input().split()))
def inls():
return input().split()
def debug(fn):
if not os.getenv('LOCAL'):
return fn
@functools.wraps(fn)
def wrapper(*args, **kwargs):
print('DEBUG: {}({}) -> '.format(
fn.__name__,
', '.join(
list(map(str, args)) +
['{}={}'.format(k, str(v)) for k, v in kwargs.items()]
)
), end='')
ret = fn(*args, **kwargs)
print(ret)
return ret
return wrapper
a, b = inl()
print('Yay!' if a*2 <= 16 and b*2 <= 16 else ':(')
| import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
A, B = list(map(int, sys.stdin.buffer.readline().split()))
ok = A <= 8 and B <= 8
if ok:
print('Yay!')
else:
print(':(')
| p03323 |
#S=input()
#N=int(input())
A,B=list(map(int,input().split()))
if A<=8 and B<=8:
print("Yay!")
else:
print(":(") | A,B=list(map(int,input().split()))
if A<9 and B<9:
print("Yay!")
else:
print(":(")
| p03323 |
a,b=list(map(int,input().split()))
print(("Yay!" if a<9 and b<9 else ":(")) | print(("Yay!" if max(list(map(int,input().split())))<9 else ":(")) | p03323 |
A,B = list(map(int,input().split()))
print(([":(","Yay!"][A<9 and B<9])) | if max(list(map(int,input().split())))<=8:
print("Yay!")
else:
print(":(") | p03323 |
a,b=list(map(int,input().split()))
if a<=8 and b<=8:
print("Yay!")
else:
print(":(") | print(("Yay!" if max(list(map(int,input().split())))<9 else ":(")) | p03323 |
a, b = list(map(int, input().split()))
if a > 8 or b > 8:
print(':(')
else:
print('Yay!')
| parameters = list(map(int, input().split()))
if(parameters[0] <= 8 and parameters[1] <= 8):
print('Yay!')
else:
print(':(') | p03323 |
A, B = list(map(int,input().split()))
if(A < 9 and B < 9):
print("Yay!")
else:
print(":(") | A, B = list(map(int,input().split()))
if(A <= 8 and B <= 8):
print("Yay!")
else:
print(":(")
| p03323 |
A, B = list(map(int, input().split()))
ans = 'Yay!' if A <= 8 and B <= 8 else ':('
print(ans)
| A, B = list(map(int, input().split()))
ans = 'Yay!' if max(A, B) <= 8 else ':('
print(ans)
| p03323 |
A = [int(i) for i in input().split()]
if max(A) <= 8:
print('Yay!')
else:
print(':(') | A, B = list(map(int, input().split()))
print(('Yay!' if A <= 8 and B <= 8 else ':(')) | p03323 |
A, B, C = list(map(int, input().split()))
if B + C <= A:
print((0))
else:
print((B + C - A))
| A, B, C = list(map(int, input().split()))
# if B + C <= A:
# print(0)
# else:
# print(B + C - A)
print((max(0, B + C - A)))
| p02951 |
temp=list(map(int, input().split()))
a=temp[2]-(temp[0]-temp[1])
if a>=0:
print(a)
else:
print((0)) | temp=list(map(int, input().split()))
temp=temp[2]-(temp[0]-temp[1])
if temp<0:
print((0))
else:
print((int(temp))) | p02951 |
a, b, c = list(map(int, input().split()))
print((max(c-(a-b), 0))) | a, b, c = list(map(int, input().split()))
ans = max(c-(a-b), 0)
print(ans)
| p02951 |
A, B, C = list(map(int, input().split()))
C -= A-B
if C < 0:
C = 0
print(C)
| A, B, C = list(map(int, input().split()))
d = min(A-B, C)
print((C-d))
| p02951 |
a, b, c = list(map(int, input().split()))
print((max(0, c - min(c, a - b)))) | a, b, c = list(map(int, input().split()))
print((c - min(c, a - b))) | p02951 |
def main():
A, B, C = list(map(int, input().split()))
ans = C - (A - B)
print((max(ans, 0)))
if __name__ == "__main__":
main()
| def main():
A, B, C = list(map(int, input().split()))
t = min(A - B, C)
ans = C - t
print(ans)
if __name__ == "__main__":
main()
| p02951 |
def slove():
import sys
input = sys.stdin.readline
a, b, c = list(map(int, input().rstrip('\n').split()))
print((max(c - (a - b), 0)))
if __name__ == '__main__':
slove()
| #1行に入力が複数の場合
a, b, c = list(map(int, input().split()))
#容器1に入れることができる水の量
can_ad_a = a - b
#aに追加で注げる水の量は
#「aに入れることができる水の量」、「cに入っている水の量」のうち小さい値
#「aに入れた水の量」を「c」から引けば「cに残る水の量」
#min(value, value)で最小値を取得
print((c - min(can_ad_a, c)))
| p02951 |
a, b, c = list(map(int, input().split()))
tmp = a - b
if tmp - c >= 0:
print((0))
else:
print((c- tmp)) | a, b, c = list(map(int, input().split()))
tmp = a - b
print((c - min(tmp, c))) | p02951 |
A,B,C = list(map(int, input().split()))
if A-B<=C:
print((C-(A-B)))
else:
print((0)) | A, B, C = list(map(int, input().split()))
res1 = A - B
if res1 <= C:
trans = res1
else:
trans = C
print((C - trans)) | p02951 |
a, b, c = list(map(int, input().split()))
x = min(a-b, c)
ans = c - x
print(ans) | import sys
sys.setrecursionlimit(10 ** 7)
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
A, B, C = list(map(int, input().split()))
x = A-B
print((0 if C-x < 0 else C-x))
| p02951 |
A, B, C = list(map(int, input().split()))
print((0 if A - B >= C else C - A + B)) | A, B, C = list(map(int, input().split()))
if (A - B > C):
print((0))
else:
print((C - A + B))
| p02951 |
A, B, C = [int(i) for i in input().split()]
print((C - min(A - B, C))) | A, B, C = list(map(int, input().split()))
print((max(C - A + B, 0))) | p02951 |
A,B,C=list(map(int,input().split()))
d=C-(A-B)
print((d if d>0 else 0)) | A,B,C=list(map(int,input().split()))
print((max(0,C-A+B))) | p02951 |
A,B,C=list(map(int,input().split()))
print((max(0,C-A+B))) | A, B, C = list(map(int, input().split()))
water = C-(A-B)
print((water if water > 0 else 0)) | p02951 |
A, B, C = list(map(int, input().split(' ')))
print((max(C - (A - B), 0)))
| #!/usr/bin/env python3
import sys
def solve(A: int, B: int, C: int):
print((max(C - (A - B), 0)))
return
# Generated by 1.1.5 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
C = int(next(tokens)) # type: int
solve(A, B, C)
if __name__ == '__main__':
main()
| p02951 |
a, b, c = list(map(int, input().split()))
if c-(a-b) <= 0:
print((0))
else:
print((c-(a-b))) | a, b, c = list(map(int, input().split()))
print((max(0,c-(a-b)))) | p02951 |
A, B, C = list(map(int, input().split()))
D = B + C - A
print((max(0, D))) | A, B, C = list(map(int, input().split()))
print((max(0, B + C - A))) | p02951 |
A, B, C = list(map(int, input().split()))
if C > (A - B): print((C - (A - B)))
else: print((0)) | import sys
def solve():
input = sys.stdin.readline
A, B, C = list(map(int, input().split()))
print((max(0, C - A + B)))
return 0
if __name__ == "__main__":
solve() | p02951 |
N = list(map(int, input().split()))
a,b,c = N[0],N[1],N[2]
ans = c-(a-b)
if ans < 0:
ans = 0
print(ans) | #一行数値 複数
a,b,c = list(map(int, input().split()))
ans = c-(a-b)
if ans < 0:
ans = 0
print(ans) | p02951 |
import sys
input = sys.stdin.readline
a, b, c = list(map(int, input().split()))
ans = b+c - a
if ans <= 0:
ans = 0
print(ans) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
a, b, c = list(map(int, read().split()))
print((max(0, c - (a - b))))
| p02951 |
a, b, c = list(map(int, input().split()))
if a < b + c:
print((b+c-a))
else:
print((0)) | a,b,c = list(map(int, input().split()))
print((max(0, c-(a-b)))) | p02951 |
a,b,c=list(map(int,input().split()));print((max(0,c-a+b))) | a,b,c = list(map(int,input().split()))
d = a - b
c -= min(c, d)
print(c)
| p02951 |
N = int(eval(input()))
a = list(map(int, input().split()))
def A(i, j):
if i == j:
return 0
elif j == i + 1:
return sum(a[i:i+2])
else:
S = sum(a[i:j+1])
return min([A(i, k) + A(k+1, j) for k in range(i, j)]) + S
print((A(0, N-1))) | N = int(eval(input()))
a = list(map(int, input().split()))
A = [[0 for __ in range(N)] for _ in range(N)]
S = [[0 for __ in range(N)] for _ in range(N)]
for i in range(N-1):
for j in range(i, N):
S[i][j] = sum(a[i:j+1])
for w in range(1, N):
for i in range(N):
j = i + w
if j >= N:
break
A[i][j] = min([
A[i][k] + A[k+1][j] for k in range(i, j)
]) + S[i][j]
print((A[0][-1])) | p03173 |
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
dp = [[float("inf")]*(N-i+1) for i in range(N+1)]
dp[1] = [0] * N
for i in range(2, N+1):
for j in range(N-i+1):
for k in range(1, i):
dp[i][j] = min(dp[k][j] + dp[i-k][j+k] +
sum(A[j:j+i]), dp[i][j])
print((dp[N][0]))
if __name__ == "__main__":
main()
| def main():
N = int(eval(input()))
A = list(map(int, input().split()))
cumsum = [[0]*(N-i+1) for i in range(N+1)]
dp = [[float("inf")]*(N-i+1) for i in range(N+1)]
dp[1] = [0] * N
cumsum[1] = A
for i in range(2, N+1):
for j in range(N-i+1):
cumsum[i][j] = cumsum[i-1][j+1] + A[j]
for k in range(1, i):
dp[i][j] = min(dp[k][j] + dp[i-k][j+k] +
cumsum[i][j], dp[i][j])
print((dp[N][0]))
if __name__ == "__main__":
main()
| p03173 |
import sys
sys.setrecursionlimit(10**9)
n = int(eval(input()))
A = list(map(int, input().split()))
memo = [[float('inf')]*410 for _ in range(410)]
visit = [[False]*410 for _ in range(410)]
from itertools import accumulate
B = [0]+A
B = list(accumulate(B))
def dp(l, r):
if l == r:
return 0
if visit[l][r]:
return memo[l][r]
visit[l][r] = True
res = float('inf')
for c in range(l, r):
res = min(res, dp(l, c)+dp(c+1, r)+B[r+1]-B[l])
memo[l][r] = res
return res
print((dp(0, n-1))) | n = int(eval(input()))
A = list(map(int, input().split()))
from itertools import accumulate
B = [0] + A
B = list(accumulate(B))
INF = 10**18
dp = [[INF]*(n+1) for i in range(n+1)]
# dp[i][j]: 区間[i, j)のスライムを取り除いたコストの最小値
for i in range(n):
dp[i][i+1] = 0
# 区間の幅(d)が狭い方から更新していく(d: 2, 3, ...n+1)
# d = 0, 1については初期化で更新した
for d in range(2, n+1):
for i in range(n+1-d):
j = i + d
for k in range(i+1, j):
dp[i][j] = min(dp[i][j], dp[i][k]+dp[k][j]+B[j]-B[i])
#print(dp)
print((dp[0][n])) | p03173 |
#!/usr/bin/env python3
#EDPC N
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n = I()
a = LI()
b = [0] + list(accumulate(a))
dp = [[inf]*(n) for _ in range(n)]
for i in range(n):
dp[i][i] = 0
for l in range(n-1)[::-1]:
for r in range(l+1,n):
s = b[r+1] - b[l]
if r - l == 1:
dp[l][r] = s
continue
for c in range(l,r):
dp[l][r] = min(dp[l][r],s + dp[l][c] + dp[c+1][r])
print((dp[0][-1])) | #!/usr/bin/env python3
#EDPC N
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n = I()
a = LI()
b = [0] + list(accumulate(a))
dp = [[inf]*(n) for _ in range(n)]
for i in range(n):
dp[i][i] = 0
for l in range(n-1)[::-1]:
for r in range(l+1,n):
s = b[r+1] - b[l]
for c in range(l,r):
dp[l][r] = min(dp[l][r],s + dp[l][c] + dp[c+1][r])
print((dp[0][-1])) | p03173 |
# 大きさがsum(a)のスライムが1匹いる
# dp[l][r]=min(区間[l,r]を分解するための最小コスト)
n=int(eval(input()))
a=list(map(int,input().split()))
INF=10**15
dp=[[0]*n for i in range(n)]
for i in range(n):
dp[i][i]=a[i]
for i in range(n-1):
for j in range(i+1,n):
dp[i][j]=dp[i][j-1]+a[j]
for i in range(n-1):
for j in range(i+1,n):
ans=INF
# print(j-i-1,j)
for k in range(j-i-1,j):
ans=min(ans,dp[j-i-1][k]+dp[k+1][j])
if i<n-2:
dp[j-i-1][j]+=ans
else:
print(ans) | # dp[l][r]=min(区間[l,r]を合成するための最小コスト)
n=int(eval(input()))
a=list(map(int,input().split()))
INF=10**15
dp=[[0]*n for i in range(n)]
for i in range(n):
dp[i][i]=a[i]
# 合成するときの必要経費を構成
for i in range(n-1):
for j in range(i+1,n):
dp[i][j]=dp[i][j-1]+a[j]
dp[0][-1]=0
# dp[i][j]=min(dp[i][k]+dp[k+1][j])+必要経費 で斜め(0,1),(1,2),(0,2),(1,3),...の順に見ていく
# ループの書き方に手間取った
for i in range(n-1):
for j in range(i+1,n):
ans=INF
x=j-i-1
for k in range(x,j):
ans=min(ans,dp[x][k]+dp[k+1][j])
dp[x][j]+=ans
print((dp[0][-1])) | p03173 |
from itertools import accumulate
INF = float('inf')
N = int(eval(input()))
As = list(map(int, input().split()))
accAs = [0] + list(accumulate(As))
dp = [[0] * (N) for _ in range(N)]
for num in range(2, N+1):
for i in range(N-num+1):
cost = INF
for j in range(1, num):
cost = min(cost, dp[i][i+j-1] + dp[i+j][i+num-1])
dp[i][i+num-1] = accAs[i+num] - accAs[i] + cost
print((dp[0][N-1]))
| from itertools import accumulate
def solve():
INF = 10**15
N = int(eval(input()))
As = list(map(int, input().split()))
accAs = list(accumulate([0]+As))
dp = [[INF]*(N) for _ in range(N)]
for i in range(N):
dp[i][i] = 0
for W in range(2, N+1):
for L in range(N-W+1):
R = L+W-1
dp[L][R] = min([dp[L][k-1] + dp[k][R] for k in range(L+1, R+1)]) + accAs[R+1] - accAs[L]
ans = dp[0][-1]
print(ans)
solve()
| p03173 |
from itertools import accumulate
def solve():
INF = 10**15
N = int(eval(input()))
As = list(map(int, input().split()))
accAs = list(accumulate([0]+As))
dp = [[INF]*(N) for _ in range(N)]
for i in range(N):
dp[i][i] = 0
for W in range(2, N+1):
for L in range(N-W+1):
R = L+W-1
dp[L][R] = min([dp[L][k-1] + dp[k][R] for k in range(L+1, R+1)]) + accAs[R+1] - accAs[L]
ans = dp[0][-1]
print(ans)
solve()
| from itertools import accumulate
def solve():
INF = 10**15
N = int(eval(input()))
As = list(map(int, input().split()))
accAs = list(accumulate([0]+As))
dp = [[INF]*(N) for _ in range(N)]
for i in range(N):
dp[i][i] = 0
for L in reversed(list(range(N))):
dpL = dp[L]
for R in range(L+1, N):
dpL[R] = min([dpL[k-1] + dp[k][R] for k in range(L+1, R+1)]) + accAs[R+1] - accAs[L]
print((dp[0][-1]))
solve()
| p03173 |
import math
from functools import lru_cache, reduce
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
def prefix_sum(arr, a):
arr.append(arr[-1]+a)
return arr
def solve():
"""
OPT[i][j] = min(OPT[i][k]+OPT[k+1][j])+sum(A[i:j+1]) i <= k < j
OPT[i][j] = 0 if i == j
"""
N = read_int()
A = read_ints()
prefix = reduce(prefix_sum, A, [0])
@lru_cache(None)
def dp(i, j):
if i == j:
return 0
return min(dp(i, k)+dp(k+1, j)+(prefix[j+1]-prefix[i]) for k in range(i, j))
return dp(0, N-1)
if __name__ == '__main__':
print((solve()))
| import math
from functools import lru_cache, reduce
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
def prefix_sum(arr, a):
arr.append(arr[-1]+a)
return arr
def solve():
"""
OPT[i][j] = min(OPT[i][k]+OPT[k+1][j])+sum(A[i:j+1]) i <= k < j
OPT[i][j] = 0 if i == j
"""
N = read_int()
A = read_ints()
prefix = reduce(prefix_sum, A, [0])
@lru_cache(None)
def dp(i, j):
if i == j:
return 0
return min(dp(i, k)+dp(k+1, j)+(prefix[j+1]-prefix[i]) for k in range(i, j))
OPT = [[0]*N for _ in range(N)]
for j in range(N):
for i in range(j-1, -1, -1):
OPT[i][j] = min(OPT[i][k]+OPT[k+1][j] for k in range(i, j))+(prefix[j+1]-prefix[i])
return OPT[0][N-1]
if __name__ == '__main__':
print((solve()))
| p03173 |
def main():
N = int(eval(input()))
a = list(map(int, input().split()))
l = [[10**9+1] * (N+1) for _ in range(N+1)]
s = [[0] * (N+1) for _ in range(N+1)]
for i in range(N):
for j in range(N+1):
s[i][j] = sum(a[k] for k in range(i, j))
for i in range(N):
l[i][i+1] = 0
for j in range(2, N+1):
for i in range(N):
m = i + j
if m > N:
continue
l[i][m] = min(l[i][k] + l[k][m] for k in range(i+1, m)) + s[i][m]
return l[0][-1]
print((main()))
| def main():
N = int(eval(input()))
a = list(map(int, input().split()))
l = [[10**9+1] * (N+1) for _ in range(N+1)]
s = [[0] * (N+1) for _ in range(N+1)]
for i in range(N-1):
for j in range(i+1, N+1):
s[i][j] = s[i][j-1] + a[j-1]
for i in range(N):
l[i][i+1] = 0
for j in range(2, N+1):
for i in range(N):
m = i + j
if m > N:
continue
l[i][m] = min(l[i][k] + l[k][m] for k in range(i+1, m)) + s[i][m]
return l[0][-1]
print((main()))
| p03173 |
# coding: utf-8
from functools import lru_cache
from itertools import accumulate as accum
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
@lru_cache(maxsize = None)
def f(l, r):
if l == r:
return(0)
cost = float('inf')
for x in range(l, r):
cost_ = f(l, x) + f(x + 1, r)
if cost_ < cost:
cost = cost_
return(cost + acsum[r] - acsum[l - 1])
n = int(eval(input())) # 2 <= n <= 400
acsum = list(accum(list(map(int, input().split())))) + [0]
print((f(0, n - 1)))
| # coding: utf-8
from itertools import accumulate as accum
import sys
input = sys.stdin.readline
def f2(n, a):
acsum = list(accum(a)) + [0]
dp = [[float('inf')] * n for _ in range(n)]
for i in range(n):
dp[i][i] = 0
if i + 1 != n:
dp[i][i + 1] = a[i] + a[i + 1]
for i in range(n - 3, -1, -1):
for j in range(i + 2, n):
c = float('inf')
dpi = dp[i]
for x in range(i, j):
c_ = dpi[x] + dp[x + 1][j]
if c_ < c:
c = c_
dpi[j] = c + acsum[j] - acsum[i - 1]
return(dp[0][n - 1])
n = int(eval(input())) # 2 <= n <= 400
a = list(map(int, input().split()))
print((f2(n, a)))
| p03173 |
from functools import lru_cache
N = int(eval(input()))
A = list(map(int, input().split()))
INF = 1.0e+100
@lru_cache(maxsize=None)
def f(l, r):
if r - l == 1:
return (A[l], 0)
ret = (INF, INF)
for i in range(l+1, r):
(lr, lc) = f(l, i)
(rr, rc) = f(i, r)
if lr+rr+lc+rc < ret[1]:
ret = (lr+rr, lr+rr+lc+rc)
return ret
print((f(0, N)[1]))
| from functools import lru_cache
N = int(eval(input()))
A = list(map(int, input().split()))
INF = 1.0e+100
dp = [[[None, INF] for _ in range(N+1)] for _ in range(N+1)]
for i in range(N):
dp[i][i+1] = [A[i], 0]
for g in range(2, N+1):
for l in range(N-g+1):
r = l + g
for i in range(l+1, r):
lv, lc = dp[l][i]
rv, rc = dp[i][r]
nc = lv + rv + lc + rc
if dp[l][r][1] > nc:
dp[l][r][0] = lv + rv
dp[l][r][1] = nc
print((dp[0][N][1]))
| p03173 |
def f(n, a):
dp = [[0] * n for _ in range(n)]
for i in range(n - 2, -1, -1):
s = a[i]
dpi=dp[i]
for j in range(i + 1, n):
k = []
s += a[j]
for d in range(i, j):
k += [dpi[d] + dp[d + 1][j]]
dp[i][j] = min(k) + s
return dp[0][-1]
n = int(eval(input()))
a = tuple(map(int, input().split()))
print((f(n, a)))
| def f(n, a):
inf = float("inf")
dp = [[0] * n for _ in range(n)]
for i in range(n - 2, -1, -1):
s = a[i]
dpi = dp[i]
for j in range(i + 1, n):
mn = inf
s += a[j]
for d in range(i, j):
k = dpi[d] + dp[d + 1][j]
if k < mn:
mn = k
dpi[j] = mn + s
return dp[0][-1]
n = int(eval(input()))
a = tuple(map(int, input().split()))
print((f(n, a)))
| p03173 |
import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def main():
def cost(l, r):
if l + 2 == r:
return aa[l] + aa[l + 1]
if l + 1 == r:
return 0
if dp[l][r] != -1:
return dp[l][r]
res = 10 ** 10
for m in range(l + 1, r):
res = min(res, cost(l, m) + cost(m, r))
res += cumsum_aa[r] - cumsum_aa[l]
dp[l][r] = res
return res
n = int(input())
aa = list(map(int, input().split()))
dp = [[-1] * (n + 1) for _ in range(n + 1)]
cumsum_aa = [0]
for i, a in enumerate(aa):
cumsum_aa.append(cumsum_aa[i] + a)
print(cost(0, n))
main()
| import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def main():
def cost(l, r):
if l + 2 == r:
return aa[l] + aa[l + 1]
if l + 1 == r:
return 0
if dp[l][r] != -1:
return dp[l][r]
res = 10 ** 16
for m in range(l + 1, r):
res = min(res, cost(l, m) + cost(m, r))
res += cumsum_aa[r] - cumsum_aa[l]
dp[l][r] = res
return res
n = int(input())
aa = list(map(int, input().split()))
dp = [[-1] * (n + 1) for _ in range(n + 1)]
cumsum_aa = [0]
for i, a in enumerate(aa):
cumsum_aa.append(cumsum_aa[i] + a)
print(cost(0, n))
main()
| p03173 |
from itertools import accumulate
import sys
# python template for atcoder1
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int, input().split()))
dp = [[float('inf')]*N for _ in range(N)]
a_acc = [0]+list(accumulate(A))
def dfs(l, r):
"""
List[l:r]
"""
if dp[l][r-1] != float('inf'):
return dp[l][r-1]
if r-l == 1:
dp[l][r-1] = 0
return 0
if r-l == 2:
dp[l][r-1] = A[l]+A[r-1]
return dp[l][r-1]
else:
dp[l][r-1] = min(dfs(l, v)+dfs(v, r)
for v in range(l+1, r))+a_acc[r]-a_acc[l]
return dp[l][r-1]
dfs(0, N)
print((dp[0][-1]))
| from itertools import accumulate
import sys
# python template for atcoder1
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int, input().split()))
dp = [[float(0)]*N for _ in range(N)]
a_acc = [0]+list(accumulate(A))
def dfs(l, r):
"""
List[l:r]
"""
if dp[l][r-1] != float('inf'):
return dp[l][r-1]
if r-l == 1:
dp[l][r-1] = 0
return 0
if r-l == 2:
dp[l][r-1] = A[l]+A[r-1]
return dp[l][r-1]
else:
dp[l][r-1] = min(dfs(l, v)+dfs(v, r)
for v in range(l+1, r))+a_acc[r]-a_acc[l]
return dp[l][r-1]
def bfs():
for d in range(2, N+1):
for l in range(0, N-d+1):
r = l + d
#print("l,r->", l, r)
tmp = float('inf')
for m in range(l+1, r):
tmp = min(tmp, dp[l][m-1]+dp[m][r-1])
#print("tmp->", tmp)
#print("acc->", a_acc[r]-a_acc[l])
dp[l][r-1] = tmp+a_acc[r]-a_acc[l]
# print(a_acc)
bfs()
# print(dp)
ans = int(dp[0][-1])
print(ans)
| p03173 |
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list([int(x)-1 for x in input().split()])
def II(): return int(eval(input()))
def IF(): return float(eval(input()))
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = 1e10
"""
URL: https://atcoder.jp/contests/dp/tasks/dp_n
N - Slimes /
実行時間制限: 2 sec / メモリ制限: 1024 MB
配点 :
100 点
問題文
N 匹のスライムが横一列に並んでいます。
最初、左から i 番目のスライムの大きさは ai です。
太郎君は、すべてのスライムを合体させて 1 匹のスライムにしようとしています。
スライムが 1 匹になるまで、太郎君は次の操作を繰り返し行います。
左右に隣り合う 2 匹のスライムを選び、それらを合体させて新しい 1 匹のスライムにする。
合体前の 2 匹のスライムの大きさを x および y とすると、
合体後のスライムの大きさは x+y となる。
このとき、太郎君は x+y のコストを支払う。
なお、合体の前後でスライムたちの位置関係は変わらない。
太郎君が支払うコストの総和の最小値を求めてください。
"""
#solve
def solve():
n = II()
a = LI()
dp = [[0] * (n + 1) for i in range(n)]
acc = [0] + list(itertools.accumulate(a))
c = defaultdict(int)
def f(l, r):
tmp = inf
if c[(l, r)]: return dp[l][r]
c[(l,r)] = 1
# print(dp, l, r)
if l + 1 == r: return 0
for i in range(l + 1, r):
tmp = min(tmp, f(l, i) + f(i, r) + acc[r] - acc[l])
# print(l,r)
dp[l][r] = tmp
return tmp
print((f(0, n)))
# print(dp)
return
#main
if __name__ == '__main__':
solve()
| #!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list([int(x)-1 for x in input().split()])
def II(): return int(eval(input()))
def IF(): return float(eval(input()))
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float("inf")
"""
URL: https://atcoder.jp/contests/dp/tasks/dp_n
N - Slimes /
実行時間制限: 2 sec / メモリ制限: 1024 MB
配点 :
100 点
問題文
N 匹のスライムが横一列に並んでいます。
最初、左から i 番目のスライムの大きさは ai です。
太郎君は、すべてのスライムを合体させて 1 匹のスライムにしようとしています。
スライムが 1 匹になるまで、太郎君は次の操作を繰り返し行います。
左右に隣り合う 2 匹のスライムを選び、それらを合体させて新しい 1 匹のスライムにする。
合体前の 2 匹のスライムの大きさを x および y とすると、
合体後のスライムの大きさは x+y となる。
このとき、太郎君は x+y のコストを支払う。
なお、合体の前後でスライムたちの位置関係は変わらない。
太郎君が支払うコストの総和の最小値を求めてください。
"""
#solve
def solve():
n = II()
a = LI()
dp = [[0] * (n + 1) for i in range(n)]
acc = [0] + list(itertools.accumulate(a))
c = [[0] * (n + 1) for i in range(n)]
def f(l, r):
tmp = inf
if c[l][r]: return dp[l][r]
c[l][r] = 1
# print(dp, l, r)
if l + 1 == r: return 0
for i in range(l + 1, r):
tmp = min(tmp, f(l, i) + f(i, r) + acc[r] - acc[l])
# print(l,r)
dp[l][r] = tmp
return tmp
print((f(0, n)))
# print(dp)
return
#main
if __name__ == '__main__':
solve()
| p03173 |
import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7 # 998244353
input = lambda:sys.stdin.readline().rstrip()
from functools import lru_cache
def resolve():
n = int(eval(input()))
A = list(map(int, input().split()))
S = [0] * (n + 1)
for i in range(n):
S[i + 1] = S[i] + A[i]
@lru_cache(None)
def dfs(l, r):
# base case
if r - l == 1:
return 0
# recursion
return min(dfs(l, m) + dfs(m, r) + S[r] - S[l] for m in range(l + 1, r))
print((dfs(0, n)))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7 # 998244353
input = lambda:sys.stdin.readline().rstrip()
def resolve():
n = int(eval(input()))
A = list(map(int, input().split()))
S = [0] * (n + 1)
for i in range(n):
S[i + 1] = S[i] + A[i]
dp = [[None] * (n + 1) for _ in range(n + 1)]
for l in range(n):
dp[l][l + 1] = 0
for width in range(2, n + 1):
for l in range(n - width + 1):
r = l + width
res = INF
for m in range(l + 1, r):
res = min(res, dp[l][m] + dp[m][r] + S[r] - S[l])
dp[l][r] = res
print((dp[0][n]))
resolve() | p03173 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_right, bisect_left
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gamma, log
from operator import mul
from functools import reduce
from copy import deepcopy
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): pass
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
n = I()
A = LI()
acc = [0] + list(accumulate(A))
dp = [[0] * n for _ in range(n)]
def f(l, r):
if dp[l][r]:
return dp[l][r]
if l == r:
return 0
m = INF
for i in range(l, r):
m = min(m, f(l, i) + f(i + 1, r) + acc[r + 1] - acc[l])
dp[l][r] = m
return m
print((f(0, n-1)))
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_right, bisect_left
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gamma, log
from operator import mul
from functools import reduce
from copy import deepcopy
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): pass
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
n = I()
A = LI()
acc = [0] + list(accumulate(A))
dp = [[0] * n for _ in range(n)]
def f(l, r):
if dp[l][r] or l == r:
return dp[l][r]
m = INF
for i in range(l, r):
m = min(m, f(l, i) + f(i + 1, r) + acc[r + 1] - acc[l])
dp[l][r] = m
return m
print((f(0, n-1)))
| p03173 |
inf = float('inf')
n = int(eval(input()))
a = tuple(int(x) for x in input().split())
d = [[inf] * n for _ in range(n)]
for i in range(n):
d[i][i] = 0
c = [0]
for aa in a:
c.append(c[-1] + aa)
for i in range(n - 1, -1, -1):
for j in range(i + 1, n):
for k in range(i, j):
# [i, k], (k, j]
d[i][j] = min(d[i][j], d[i][k] + d[k + 1][j])
d[i][j] += c[j + 1] - c[i]
# print(d)
# print(c)
print((d[0][n - 1]))
| inf = 10 ** 16
n = int(eval(input()))
a = tuple(int(x) for x in input().split())
d = [[inf] * n for _ in range(n)]
for i in range(n):
d[i][i] = 0
c = [0]
for aa in a:
c.append(c[-1] + aa)
for i in range(n - 1, -1, -1):
for j in range(i + 1, n):
for k in range(i, j):
# [i, k], (k, j]
d[i][j] = min(d[i][j], d[i][k] + d[k + 1][j])
d[i][j] += c[j + 1] - c[i]
# print(d)
# print(c)
print((d[0][n - 1]))
| p03173 |
def solve(n, a):
from itertools import accumulate
inf = (400 ** 2) * (10 ** 9) + 10
# [l,r)
def dfs(l, r):
if memo[l][r] != -1:
return memo[l][r]
if r - l == 1:
return 0
res = inf
for c in range(l + 1, r):
# [l, c), [c, r)
res = min(res, dfs(l, c) + dfs(c, r))
res += acc[r] - acc[l]
memo[l][r] = res
return res
acc = (0,) + tuple(accumulate(a))
memo = [[-1] * (n + 1) for _ in range(n + 1)]
return dfs(0, n)
if __name__ == '__main__':
n = int(eval(input()))
a = tuple(map(int, input().split()))
print((solve(n, a)))
| def solve(n, a):
from itertools import accumulate
inf = (400 ** 2) * (10 ** 9) + 10
acc = (0,) + tuple(accumulate(a))
cost = [[inf] * (n + 1) for _ in range(n + 1)]
for i in range(n):
cost[i][i + 1] = 0
for l in range(n - 1, -1, -1):
for r in range(l + 2, n + 1):
for c in range(l + 1, r):
cost[l][r] = min(cost[l][r], cost[l][c] + cost[c][r])
cost[l][r] += acc[r] - acc[l]
return cost[0][n]
if __name__ == '__main__':
n = int(eval(input()))
a = tuple(map(int, input().split()))
print((solve(n, a)))
| p03173 |
N = int(eval(input()))
# A = list(map(int, input()))
A = tuple(map(int, input().split()))
from collections import defaultdict, deque
dp = defaultdict(lambda: -1)
q = deque([])
q.append((A, 0))
inf = float("inf")
ans = inf
while q:
t, cost = q.popleft()
if len(t) == 0:
ans = min(ans, cost)
continue
if len(t) == 1:
ans = min(ans, cost + t[0])
continue
tpl = t
for i in range(len(tpl) - 1):
if not (tpl[0:i] + (tpl[i] + tpl[i + 1],) + tpl[i + 2:], tpl[i] + tpl[i + 1]) in q:
q.append((tpl[0:i] + (tpl[i] + tpl[i + 1],) + tpl[i + 2:], cost + tpl[i] + tpl[i + 1]))
print((ans - sum(A)))
exit(0)
| N = int(eval(input()))
A = list(map(int, input().split()))
inf = float("inf")
from itertools import accumulate
Accum = list(accumulate([0] + A))
dp = [ [inf]*(N+1) for _ in range(N+1)]
def dfs(l,r):
if dp[l][r] != inf:
return dp[l][r]
if l == r:
return 0
if l+1 == r:
dp[l][r] = A[l]
return A[l]
local_ans = inf
for i in range(l+1, r): # 0 to 4, 0-1, 1-4
local_ans = min(local_ans, dfs(l,i) + dfs(i,r))
dp[l][r] = local_ans + Accum[r] - Accum[l]
return dp[l][r]
print((dfs(0,N)- sum(A)))
| p03173 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
n,k = LI()
a = LI()
dp = [0 for i in range(k+1)]
f = [0 for i in range(k+1)]
for i in range(k+1):
if not f[i]:
for j in a:
if i-j >= 0:
dp[i] = 1-dp[i-j]
if dp[i] == 0:
break
else:
dp[i] = 1
print((["First","Second"][dp[k]]))
#B
def B():
n = I()
a = LI()
ma = n*(n+1)//2
su = sum(a)
s = [1 for i in range(n+1)]
for i in range(1,n):
s[i+1] = s[i]+n-i+1
d = [None for i in range(ma+1)]
d[0] = 0
k = 1
for i in range(1,n+1):
for j in range(n+1-i):
d[k+j] = i
k += n+1-i
k = n%2
dp = [su if (d[i]+k)%2 else -su for i in range(ma+1)]
dp[0] = 0
if k:
for i in range(n):
dp[i+1] = a[n-1-i]
else:
for i in range(n):
dp[i+1] = -a[n-1-i]
for i in range(1,ma):
r = n-1-(i-s[d[i]])
l = r+1-d[i]
j = i+(n-d[i])
j2 = j+1
if (d[i]+k)%2:
if r < n-1:
if a[r+1]+dp[i] > dp[j]:
dp[j] = a[r+1]+dp[i]
if l > 0:
if a[l-1]+dp[i] > dp[j2]:
dp[j2] = a[l-1]+dp[i]
else:
if r < n-1:
if -a[r+1]+dp[i] < dp[j]:
dp[j] = -a[r+1]+dp[i]
if l > 0:
if -a[l-1]+dp[i] < dp[j2]:
dp[j2] = -a[l-1]+dp[i]
print((dp[ma]))
return
#C
def C():
def comb(a,b):
return fact[a]*inv[b]*inv[a-b]%mod
n,k = LI()
a = LI()
"""
fact = [1]
for i in range(n+k):
fact.append(fact[-1]*(i+1)%mod)
inv = [1]*(n+k+1)
inv[n+k] = pow(fact[n+k],mod-2,mod)
for i in range(n+k)[::-1]:
inv[i] = inv[i+1]*(i+1)%mod
f = [comb(i+n-1,n-1) for i in range(k+1)]
for i in a:
for j in range(k-i)[::-1]:
f[j+i+1] -= f[j]
f[j+i+1] %= mod
print(f[k])
"""
dp = [[0]*(k+1) for i in range(n+1)]
for i in range(k+1):
dp[0][i] = 1
for i in range(n):
ni = i+1
ai = a[i]
for j in range(k+1):
if j >= ai+1:
dp[ni][j] = (dp[i][j]-dp[i][j-ai-1])%mod
else:
dp[ni][j] = dp[i][j]
if i < n-1:
for j in range(k):
dp[ni][j+1] += dp[ni][j]
dp[ni][j+1] %= mod
print((dp[n][k]%mod))
return
#D
def D():
def dp(l,r):
if mem[(l,r)] != None:
return mem[(l,r)]
mem[(l,r)] = float("inf")
for i in range(l+1,r):
res = dp(l,i)+dp(i,r)+a[r]-a[l]
if res < mem[(l,r)]:
mem[(l,r)] = res
return mem[(l,r)]
n = I()
a = LI()
mem = defaultdict(lambda : None)
for i in range(n):
mem[(i,i+1)] = 0
a.insert(0,0)
for i in range(n):
a[i+1] += a[i]
print((dp(0,n)))
return
#E
def E():
n = I()
a = LIR(n)
b = [1<<i for i in range(n+1)]
dp = [0 for i in range(b[n])]
dp[0] = 1
for i in range(n):
for k in range(b[n])[::-1]:
for j in range(n):
if a[i][j] and not b[j]&k:
dp[b[j]|k] += dp[k]
dp[b[j]|k] %= mod
print((dp[-1]))
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == "__main__":
D()
| #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
n,k = LI()
a = LI()
dp = [0 for i in range(k+1)]
f = [0 for i in range(k+1)]
for i in range(k+1):
if not f[i]:
for j in a:
if i-j >= 0:
dp[i] = 1-dp[i-j]
if dp[i] == 0:
break
else:
dp[i] = 1
print((["First","Second"][dp[k]]))
#B
def B():
n = I()
a = LI()
ma = n*(n+1)//2
su = sum(a)
s = [1 for i in range(n+1)]
for i in range(1,n):
s[i+1] = s[i]+n-i+1
d = [None for i in range(ma+1)]
d[0] = 0
k = 1
for i in range(1,n+1):
for j in range(n+1-i):
d[k+j] = i
k += n+1-i
k = n%2
dp = [su if (d[i]+k)%2 else -su for i in range(ma+1)]
dp[0] = 0
if k:
for i in range(n):
dp[i+1] = a[n-1-i]
else:
for i in range(n):
dp[i+1] = -a[n-1-i]
for i in range(1,ma):
r = n-1-(i-s[d[i]])
l = r+1-d[i]
j = i+(n-d[i])
j2 = j+1
if (d[i]+k)%2:
if r < n-1:
if a[r+1]+dp[i] > dp[j]:
dp[j] = a[r+1]+dp[i]
if l > 0:
if a[l-1]+dp[i] > dp[j2]:
dp[j2] = a[l-1]+dp[i]
else:
if r < n-1:
if -a[r+1]+dp[i] < dp[j]:
dp[j] = -a[r+1]+dp[i]
if l > 0:
if -a[l-1]+dp[i] < dp[j2]:
dp[j2] = -a[l-1]+dp[i]
print((dp[ma]))
return
#C
def C():
def comb(a,b):
return fact[a]*inv[b]*inv[a-b]%mod
n,k = LI()
a = LI()
"""
fact = [1]
for i in range(n+k):
fact.append(fact[-1]*(i+1)%mod)
inv = [1]*(n+k+1)
inv[n+k] = pow(fact[n+k],mod-2,mod)
for i in range(n+k)[::-1]:
inv[i] = inv[i+1]*(i+1)%mod
f = [comb(i+n-1,n-1) for i in range(k+1)]
for i in a:
for j in range(k-i)[::-1]:
f[j+i+1] -= f[j]
f[j+i+1] %= mod
print(f[k])
"""
dp = [[0]*(k+1) for i in range(n+1)]
for i in range(k+1):
dp[0][i] = 1
for i in range(n):
ni = i+1
ai = a[i]
for j in range(k+1):
if j >= ai+1:
dp[ni][j] = (dp[i][j]-dp[i][j-ai-1])%mod
else:
dp[ni][j] = dp[i][j]
if i < n-1:
for j in range(k):
dp[ni][j+1] += dp[ni][j]
dp[ni][j+1] %= mod
print((dp[n][k]%mod))
return
#D
def D():
n = I()
a = LI()
a.insert(0,0)
for i in range(n):
a[i+1] += a[i]
dp = [[0]*(n+1) for i in range(n)]
for le in range(1,n):
for l in range(n-le):
r = l+le+1
res = float("inf")
for i in range(l+1,r):
m = dp[l][i]+dp[i][r]
if m < res:
res = m
res += a[r]-a[l]
dp[l][r] = res
print((dp[0][n]))
return
#E
def E():
n = I()
a = LIR(n)
b = [1<<i for i in range(n+1)]
dp = [0 for i in range(b[n])]
dp[0] = 1
for i in range(n):
for k in range(b[n])[::-1]:
for j in range(n):
if a[i][j] and not b[j]&k:
dp[b[j]|k] += dp[k]
dp[b[j]|k] %= mod
print((dp[-1]))
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == "__main__":
D()
| p03173 |
from itertools import accumulate
N, *A = list(map(int, open(0).read().split()))
S = [0] + list(accumulate(A))
memo = {}
def dp(L, R):
if L == R:
return 0
if (L, R) in memo:
return memo[(L, R)]
memo[(L, R)] = min(dp(L, c) + dp(c + 1, R) + S[R + 1] - S[L] for c in range(L, R))
return memo[(L, R)]
print((dp(0, N - 1))) | from itertools import accumulate
N, *A = list(map(int, open(0).read().split()))
S = [0] + list(accumulate(A))
memo = [[-1] * N for _ in range(N)]
def dp(L, R):
if L == R:
return 0
if memo[L][R] >= 0:
return memo[L][R]
memo[L][R] = min(dp(L, c) + dp(c + 1, R) + S[R + 1] - S[L] for c in range(L, R))
return memo[L][R]
print((dp(0, N - 1))) | p03173 |
# dp[i][j] - minimum cost from i to j
INF = 1e18+5
n = int(eval(input()))
arr = [int(x) for x in input().split()]
dp = [[0 for _ in range(n)] for _ in range(n)]
def range_sum(arr, L, R):
s = 0
for i in range(L, R+1):
s += arr[i]
return s
for L in reversed(list(range(n))):
for R in range(L, n):
if L == R:
dp[L][R] = 0
else:
dp[L][R] = INF
s = range_sum(arr, L, R)
# try every possible middle
for mid in range(L, R):
dp[L][R] = min(dp[L][R], dp[L][mid] + dp[mid+1][R] + range_sum(arr, L, R))
print((dp[0][n-1]))
"""
int main() {
const int INF = 1e9+7;
int n;
scanf("%d", &n);
vector<int> arr(n);
vector<vector<ll>> dp(n, vector<ll>(n, -1));
vector<vector<int>> mids(n, vector<int>(n));
vector<ll> pref_sums(n+1);
ll pref_sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
dp[i][i] = 0;
}
for (int i = 0; i <= n; i++) {
pref_sum += arr[i];
pref_sums[i] = pref_sum;
}
for (int length = 1; length < n; length++) {
for (int left = 0; left+length < n; left++) {
int right = left + length;
//cout << left << " " << right << endl;
for (int mid = left; mid < right; mid++) {
ll left_cost = dp[left][mid];
ll right_cost = dp[mid+1][right];
ll range_sum = pref_sums[right] - (left-1 < 0 ? 0 : pref_sums[left-1]);
ll my_cost = left_cost + right_cost + range_sum;
//cout << total << endl;
/*
if (total < dp[left][right]) {
// update chosen mid & min value
dp[left][right] = my_cost;//total;
//mids[left][right] = mid;
}
*/
if (dp[left][right] == -1) {
dp[left][right] = my_cost;
}
else {
dp[left][right] = min(dp[left][right], my_cost);
}
}
}
}
/*
vector<pair<int, int>> v; // (start, end)
v.push_back({0, n-1});
ll ans = 0; //-dp[0][n-1]; // the last one
while (!v.empty()) {
pair<int, int> cur = v.back();
v.pop_back();
if (cur.second - cur.first + 1 >= 2) { // interval at least two
ans += dp[cur.first][cur.second];
int mid = mids[cur.first][cur.second];
cout << "L: " << cur.first << " R: " << cur.second << " Total: " << dp[cur.first][cur.second] << " mid: " << mid << endl;
v.push_back({cur.first, mid});
v.push_back({mid+1, cur.second});
}
}
*/
/*
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int mid = i; mid <= j; mid++) {
ll cur = dp[i][mid];
if (mid+1 <= j) {
cur += dp[mid+1][j];
}
dp[i][j] = min(dp[i][j], cur);
}
}
}
*/
//printf("%lld", ans);
printf("%lld", dp[0][n-1]);
return 0;
}
""" | # dp[i][j] - minimum cost from i to j
INF = 1e18+5
n = int(eval(input()))
arr = [int(x) for x in input().split()]
dp = [[0 for _ in range(n)] for _ in range(n)]
def range_sum(arr, L, R):
s = 0
for i in range(L, R+1):
s += arr[i]
return s
for L in reversed(list(range(n))):
for R in range(L, n):
if L == R:
dp[L][R] = 0
else:
dp[L][R] = INF
s = range_sum(arr, L, R)
# try every possible middle
for mid in range(L, R):
dp[L][R] = min(dp[L][R], dp[L][mid] + dp[mid+1][R] + s)
print((dp[0][n-1]))
"""
int main() {
const int INF = 1e9+7;
int n;
scanf("%d", &n);
vector<int> arr(n);
vector<vector<ll>> dp(n, vector<ll>(n, -1));
vector<vector<int>> mids(n, vector<int>(n));
vector<ll> pref_sums(n+1);
ll pref_sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
dp[i][i] = 0;
}
for (int i = 0; i <= n; i++) {
pref_sum += arr[i];
pref_sums[i] = pref_sum;
}
for (int length = 1; length < n; length++) {
for (int left = 0; left+length < n; left++) {
int right = left + length;
//cout << left << " " << right << endl;
for (int mid = left; mid < right; mid++) {
ll left_cost = dp[left][mid];
ll right_cost = dp[mid+1][right];
ll range_sum = pref_sums[right] - (left-1 < 0 ? 0 : pref_sums[left-1]);
ll my_cost = left_cost + right_cost + range_sum;
//cout << total << endl;
/*
if (total < dp[left][right]) {
// update chosen mid & min value
dp[left][right] = my_cost;//total;
//mids[left][right] = mid;
}
*/
if (dp[left][right] == -1) {
dp[left][right] = my_cost;
}
else {
dp[left][right] = min(dp[left][right], my_cost);
}
}
}
}
/*
vector<pair<int, int>> v; // (start, end)
v.push_back({0, n-1});
ll ans = 0; //-dp[0][n-1]; // the last one
while (!v.empty()) {
pair<int, int> cur = v.back();
v.pop_back();
if (cur.second - cur.first + 1 >= 2) { // interval at least two
ans += dp[cur.first][cur.second];
int mid = mids[cur.first][cur.second];
cout << "L: " << cur.first << " R: " << cur.second << " Total: " << dp[cur.first][cur.second] << " mid: " << mid << endl;
v.push_back({cur.first, mid});
v.push_back({mid+1, cur.second});
}
}
*/
/*
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int mid = i; mid <= j; mid++) {
ll cur = dp[i][mid];
if (mid+1 <= j) {
cur += dp[mid+1][j];
}
dp[i][j] = min(dp[i][j], cur);
}
}
}
*/
//printf("%lld", ans);
printf("%lld", dp[0][n-1]);
return 0;
}
""" | p03173 |
import sys,queue,math,copy,itertools,bisect,collections,heapq
INF = 10**18
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
a = LI()
sn = [[0 for _ in range(N)] for _ in range(N)]
dp = [[INF for _ in range(N)] for _ in range(N)]
for i in range(N):
x = 0
for j in range(i,N):
x += a[j]
sn[i][j] = x
for i in range(N):
dp[i][i] = 0
if i < N-1:
dp[i][i+1] = sn[i][i+1]
for j in range(2,N):
for i in range(j-2,-1,-1):
for k in range(0,j-i):
dp[i][j] = min(dp[i][j],dp[i+k+1][j]+ dp[i][i+k] + sn[i][j])
print((dp[0][-1]))
| import sys
INF = 10**14
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
a = LI()
sn = [[0 for _ in range(N)] for _ in range(N)]
dp = [[INF for _ in range(N)] for _ in range(N)]
for i in range(N):
x = 0
for j in range(i,N):
x += a[j]
sn[i][j] = x
for i in range(N):
dp[i][i] = 0
for j in range(1,N):
for i in range(j-1,-1,-1):
for k in range(0,j-i):
dp[i][j] = min(dp[i][j],dp[i+k+1][j]+ dp[i][i+k] + sn[i][j])
print((dp[0][-1])) | p03173 |
n = int(eval(input()))
a = list(map(int, input().split()))
#dp[l][r] = [l, r)区間のスライムを
dp = [[float("inf")]*(n+1) for i in range(n+1)]
for i in range(n):
dp[i][i] = 0
#cost[r]-cost[l] = [l, r)区間を合計したときのスライムの総和
cost = [0]*(n+1)
for i in range(n):
cost[i+1] = cost[i] + a[i]
#メモ化再帰でdp[0][n]求める
def dfs(l, r):
if dp[l][r] != float("inf"):
return dp[l][r]
else:
res = float("inf")
if (r - l) == 1:
dp[l][r] = 0
return dp[l][r]
for k in range(l, r):
if k == l or k == r:
continue
#dp[l][k] + dp[k][r] + 合体に必要なコスト
res = min(res, dfs(l, k) + dfs(k, r) + (cost[r] - cost[l]))
dp[l][r] = res
return dp[l][r]
dfs(0, n)
print((dp[0][n])) | n = int(eval(input()))
a = list(map(int, input().split()))
#dp[l][r] = [l, r)区間のスライムを合体するときのコストの最小値
dp = [[-1]*(n+1) for i in range(n+1)]
for i in range(n):
dp[i][i] = 0
#cost[r]-cost[l] = [l, r)区間を合計したときのスライムの総和
cost = [0]*(n+1)
for i in range(n):
cost[i+1] = cost[i] + a[i]
#メモ化再帰でdp[0][n]求める
def dfs(l, r):
if dp[l][r] != -1:
return dp[l][r]
elif (r - l) == 1:
dp[l][r] = 0
return dp[l][r]
else:
res = float("inf")
for k in range(l + 1, r):
#dp[l][k] + dp[k][r] + 合体に必要なコスト
res = min(res, dfs(l, k) + dfs(k, r) + (cost[r] - cost[l]))
dp[l][r] = res
return dp[l][r]
dfs(0, n)
print((dp[0][n])) | p03173 |
n = int(eval(input()))
a = list(map(int, input().split()))
#dp[l][r] = [l, r)区間のスライムを合体するときのコストの最小値
dp = [[float("inf")]*(n+1) for i in range(n+1)]
for i in range(n):
dp[i][i] = 0
#cost[r]-cost[l] = [l, r)区間を合計したときのスライムの総和
cost = [0]*(n+1)
for i in range(n):
cost[i+1] = cost[i] + a[i]
#メモ化再帰でdp[0][n]求める
def dfs(l, r):
if dp[l][r] != float("inf"):
return dp[l][r]
elif (r - l) == 1:
dp[l][r] = 0
return dp[l][r]
else:
res = float("inf")
for k in range(l + 1, r):
#dp[l][k] + dp[k][r] + 合体に必要なコスト
res = min(res, dfs(l, k) + dfs(k, r) + (cost[r] - cost[l]))
dp[l][r] = res
return dp[l][r]
dfs(0, n)
print((dp[0][n])) | n = int(eval(input()))
a = list(map(int, input().split()))
#dp[l][r] = [l, r)区間のスライムを合体するときのコストの最小値
dp = [[float("inf")]*(n+1) for i in range(n+1)]
for i in range(n):
dp[i][i] = 0
#cost[r]-cost[l] = [l, r)区間を合計したときのスライムの総和
cost = [0]*(n+1)
for i in range(n):
cost[i+1] = cost[i] + a[i]
#メモ化再帰でdp[0][n]求める
def dfs(l, r, infnum):
if dp[l][r] != infnum:
return dp[l][r]
elif (r - l) == 1:
dp[l][r] = 0
return dp[l][r]
else:
res = float("inf")
for k in range(l + 1, r):
#dp[l][k] + dp[k][r] + 合体に必要なコスト
res = min(res, dfs(l, k, infnum) + dfs(k, r, infnum) + (cost[r] - cost[l]))
dp[l][r] = res
return dp[l][r]
dfs(0, n, float("inf"))
print((dp[0][n])) | p03173 |
n = int(eval(input()))
a = list(map(int, input().split()))
#dp[l][r] = [l, r)区間のスライムを合体するときのコストの最小値
dp = [[float("inf")]*(n+1) for i in range(n+1)]
for i in range(n):
dp[i][i] = 0
#cost[r]-cost[l] = [l, r)区間を合計したときのスライムの総和
cost = [0]*(n+1)
for i in range(n):
cost[i+1] = cost[i] + a[i]
#メモ化再帰でdp[0][n]求める
def dfs(l, r, infnum):
if dp[l][r] != infnum:
return dp[l][r]
elif (r - l) == 1:
dp[l][r] = 0
return dp[l][r]
else:
res = float("inf")
for k in range(l + 1, r):
#dp[l][k] + dp[k][r] + 合体に必要なコスト
res = min(res, dfs(l, k, infnum) + dfs(k, r, infnum) + (cost[r] - cost[l]))
dp[l][r] = res
return dp[l][r]
dfs(0, n, float("inf"))
print((dp[0][n])) | n = int(eval(input()))
a = list(map(int, input().split()))
ruiseki = [0] * (n+1)
for i in range(n):
ruiseki[i+1] = ruiseki[i] + a[i]
dp = [[-1]*(n+1) for i in range(n+1)]
def solve(l, r):
if dp[l][r] != -1:
return dp[l][r]
if r - l == 1:
dp[l][r] = 0
return dp[l][r]
ans = 10**18
for i in range(l+1, r):
ans = min(ans, solve(l, i) + solve(i, r) + ruiseki[r] - ruiseki[l])
dp[l][r] = ans
return dp[l][r]
solve(0, n)
print((dp[0][n])) | p03173 |
def main():
N = int(eval(input()))
a = list(map(int, input().split()))
dp = [[10**13]*N for i in range(N)]
s = [0] * (N+1)
for i, x in enumerate(a):
s[i+1] = s[i] + x
dp[i][i] = 0
for i in range(N-1, -1, -1):
for j in range(i+1, N):
tmp = s[j+1] - s[i]
D = dp[i]
for k in range(i, j):
if D[j] > D[k]+dp[k+1][j] + tmp:
D[j] = D[k]+dp[k+1][j] + tmp
print((dp[0][N-1]))
main()
| def main():
N = int(eval(input()))
a = list(map(int, input().split()))
dp = [[10**13]*N for i in range(N)]
s = [0] * (N+1)
for i in range(N):
s[i+1] = s[i] + a[i]
dp[i][i] = 0
for i in range(N-1, -1, -1):
for j in range(i+1, N):
tmp = s[j+1] - s[i]
for k in range(i, j):
dp[i][j] = min(dp[i][j], dp[i][k]+dp[k+1][j] + tmp)
print((dp[0][N-1]))
main()
| p03173 |
def main():
import sys
input = sys.stdin.readline
N = int(eval(input()))
a = list(map(int, input().split()))
inf = 10 ** 13
dp = [[0]*N for i in range(N)]
s = [0] * (N+1)
for i, x in enumerate(a):
s[i+1] = s[i] + x
dp[i][i] = 0
for i in range(N-2, -1, -1):
DP = dp[i]
si = s[i]
for j in range(i+1, N):
tmp = s[j+1] - si
D = inf
for k in range(i, j):
if D > DP[k]+dp[k+1][j]:
D = DP[k]+dp[k+1][j]
DP[j] = D + tmp
print((dp[0][N-1]))
main()
| def main():
import sys
from itertools import accumulate
input = sys.stdin.readline
N = int(eval(input()))
a = list(map(int, input().split()))
inf = 10 ** 13
dp = [[0]*N for i in range(N)]
s = [0] + list(accumulate(a))
for i, x in enumerate(a):
dp[i][i] = 0
for i in range(N-2, -1, -1):
DP = dp[i]
si = s[i]
for j in range(i+1, N):
tmp = s[j+1] - si
D = inf
for k in range(i, j):
cost = DP[k]+dp[k+1][j]
if D > cost:
D = cost
DP[j] = D + tmp
print((dp[0][N-1]))
main()
| p03173 |
def calc(A,n,dp):
if n==2:
return A[0]+A[1]
s=10**18
for i in range(0,n-1):
B=[]
B=A[0:i]
B.append(A[i]+A[i+1])
B=B+A[i+2:]
l=str(B)
if l in dp:
s=min(s,A[i]+A[i+1]+dp[l])
else:
d=calc(B,n-1,dp)
s=min(s,A[i]+A[i+1]+d)
dp[l]=d
return s
n=int(eval(input()))
A=list(int(i) for i in input().split())
dp={}
print((calc(A,n,dp)))
#for i in range(n):
| n=int(eval(input()))
A=list(int(i) for i in input().split())
prefixsum=[0 for i in range(n+1)]
for i in range(1,n+1):
prefixsum[i]=A[i-1]+prefixsum[i-1]
#print(prefixsum)
dp=[[0 for i in range(n)] for j in range(n)]
for i in range(n-1,-1,-1):
for j in range(i,n):
#starting index i and ending j
#finally we need to print first row last column
#which represent the cost of all the elements
if i==j:
dp[i][j]=0
else:
dp[i][j]=10**18
for k in range(i,j):
dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+prefixsum[j+1]-prefixsum[i])
print((dp[0][-1]))
| p03173 |
N = int(eval(input()))
A = [int(a) for a in input().split()]
dp = [[0] * N for _ in range(N)]
for d in range(1, N):
for l in range(N-d):
r = l + d
if d == 0:
dp[l][r] = A[l]
else:
dp[l][r] = 10**20
for m in range(l, r):
dp[l][r] = min(dp[l][r], dp[l][m] + dp[m+1][r] + sum(A[l:r+1]))
print((dp[0][N-1])) | N = int(eval(input()))
A = [int(a) for a in input().split()]
B = [0]
for a in A:
B.append(B[-1]+a)
dp = [[0] * N for _ in range(N)]
for d in range(1, N):
for l in range(N-d):
r = l + d
if d == 0:
dp[l][r] = A[l]
else:
dp[l][r] = 10**20
for m in range(l, r):
dp[l][r] = min(dp[l][r], dp[l][m] + dp[m+1][r] + B[r+1]-B[l])
print((dp[0][N-1])) | p03173 |
n = int(eval(input()))
a = list(map(int,input().split()))
memo = {}
p = [0]
for num in a:
p += [p[-1] + num]
def dp(i,j):
if i >= j:
return 0
if (i,j) not in memo:
ans = float("inf")
for k in range(i,j):
temp = dp(i,k) + dp(k+1,j) + p[j+1] - p[i]
ans = min(ans,temp)
memo[i,j] = ans
return memo[i,j]
print((dp(0,n-1))) | n = int(eval(input()))
a = list(map(int,input().split()))
memo = {}
p = [0]
for num in a:
p += [p[-1] + num]
dp = [[0 for _ in range(n)] for _ in range(n)]
for l in range(2,n+1):
for i in range(n-l+1):
dp[i][i+l-1] = min([dp[i][k] + dp[k+1][i+l-1] for k in range(i,i+l-1)]) + p[i+l] - p[i]
print((dp[0][n-1])) | p03173 |
n = int(eval(input()))
a = list(map(int,input().split()))
memo = {}
p = [0]
for num in a:
p += [p[-1] + num]
dp = [[0 for _ in range(n)] for _ in range(n)]
for l in range(2,n+1):
for i in range(n-l+1):
dp[i][i+l-1] = min([dp[i][k] + dp[k+1][i+l-1] for k in range(i,i+l-1)]) + p[i+l] - p[i]
print((dp[0][n-1])) | n = int(eval(input()))
a = list(map(int, input().split()))
dp = [[0] * (n+1) for _ in range(n+1)]
s = [0] * (n+1)
for i in range(n):
s[i+1] = s[i] + a[i]
for l in range(2, n+1):
for i in range(n-l+1):
j = i + l
dp[i][j] = s[j] - s[i] + min(dp[i][k] + dp[k][j] for k in range(i+1, j))
print((dp[0][n])) | p03173 |
import sys
#input = sys.stdin.readline
sys.setrecursionlimit(10**9)
N = int(eval(input()))
A = list(map(int,input().split()))
dp = [[0]*(N+1) for i in range(N+1)]
flag = [[0]*(N+1) for i in range(N+1)]
cA = [0]*(N+1)
for i in range(1,N+1) :
cA[i] = cA[i-1] + A[i-1]
def f(left, right) :
if flag[left][right] :
return dp[left][right]
elif left == right :
return 0
else :
res = float("inf")
for i in range(left, right) :
res = min(res, f(left, i) + f(i+1, right))
res += cA[right+1] - cA[left]
dp[left][right] = res
return res
ans = f(0,N-1)
print(ans)
#print(cA) | N = int(eval(input()))
A = list(map(int,input().split()))
dp = [[10**18]*N for i in range(N)]
cA = [0]*(N+1)
for i in range(1,N+1) :
cA[i] = cA[i-1] + A[i-1]
dp[i-1][i-1] = 0
for d in range(1,N) :
for i in range(N-d) :
for cut in range(i, i+d) :
dp[i][i+d] = min(dp[i][i+d], dp[i][cut] + dp[cut+1][i+d] + cA[i+d+1] - cA[i])
ans = dp[0][N-1]
print(ans)
| p03173 |
def main():
INF = 10 ** 12
N = int(eval(input()))
A = list(map(int, input().split(' ')))
cumsum = [0 for _ in range(N)]
cumsum[0] = A[0]
for i in range(1, N):
cumsum[i] = A[i] + cumsum[i - 1]
dp = [[0 for _ in range(N)] for _ in range(N)]
def solve(left, right):
if left == right:
return 0
ret = dp[left][right]
if ret > 0:
return ret
ret = INF
for mid in range(left, right):
ret = min([
ret,
solve(left, mid) + solve(mid + 1, right)
])
ret += cumsum[right] - (cumsum[left - 1] if left > 0 else 0)
dp[left][right] = ret
return ret
print((solve(0, N - 1)))
if __name__ == '__main__':
main() | def main():
INF = 10 ** 15
N = int(eval(input()))
A = list(map(int, input().split(' ')))
cumsum = [0 for _ in range(N)]
cumsum[0] = A[0]
for i in range(1, N):
cumsum[i] = A[i] + cumsum[i - 1]
dp = [[0 for _ in range(N)] for _ in range(N)]
def solve(left, right):
if left == right:
return 0
ret = dp[left][right]
if ret > 0:
return ret
ret = INF
for mid in range(left, right):
ret = min([
ret,
solve(left, mid) + solve(mid + 1, right)
])
ret += cumsum[right] - (cumsum[left - 1] if left > 0 else 0)
dp[left][right] = ret
return ret
print((solve(0, N - 1)))
if __name__ == '__main__':
main()
| p03173 |
N = int(eval(input()))
A = list(map(int, input().split()))
cum = [[0]*(N) for i in range(N)]
for i in range(N):
c = 0
for j in range(i, N):
c += A[j]
cum[i][j] = c
dp = [[0]*N for i in range(N)]
for n in range(1, N+1):
for i in range(N-n):
j = i + n
min_cost = 0
for k in range(i, j):
if min_cost == 0:
min_cost = dp[i][k] + dp[k+1][j]
else:
min_cost = min(min_cost, dp[i][k]+dp[k+1][j])
dp[i][j] = min_cost + cum[i][j]
print((dp[0][N-1])) | N = int(eval(input()))
A = list(map(int, input().split()))
"""
cum = [[0]*(N) for i in range(N)]
for i in range(N):
c = 0
for j in range(i, N):
c += A[j]
cum[i][j] = c
"""
cum = [0]
for a in A:
cum.append(cum[-1] + a)
dp = [[0]*N for i in range(N)]
for n in range(1, N+1):
for i in range(N-n):
j = i + n
min_cost = 0
for k in range(i, j):
if min_cost == 0:
min_cost = dp[i][k] + dp[k+1][j]
else:
min_cost = min(min_cost, dp[i][k]+dp[k+1][j])
dp[i][j] = min_cost + (cum[j+1]-cum[i])
print((dp[0][N-1])) | p03173 |
mod = 10 ** 9 + 7
mod2 = 2 ** 61 + 1
from collections import deque
import heapq
import time
from bisect import bisect_left, insort_left, bisect_right
import sys
import random
import itertools
#input = sys.stdin.readline
def input():
return sys.stdin.readline().strip("\n").strip(" ")
_NUMINT_ALL = list(range(10))
_START_TIME = time.time()
INDEX_KETA = 10**12
def main():
ans = solve()
if ans is True or ans is False:
YesNo(ans)
elif ans is None:
return
if isinstance(ans, tuple):
split_print_space(ans)
else:
print(ans)
def solve():
N = iip()
A = iip()
SA = [0]
cur = 0
for i in A:
cur += i
SA.append(cur)
#print(SA)
size = [[0 for _ in range(N)] for _ in range(N)]
for i in range(N):
for j in range(i, N):
size[i][j] = int(SA[j+1]-SA[i])
#fprint(size)
dp = [[10**12 for _ in range(N)] for _ in range(N)]
for i in range(N):
dp[i][i] = 0
for d in range(N):
for l in range(N):
for r in range(l+1, N):
if l==r:
dp[l][r] = 0
else:
dp[l][r] = min(dp[l][r],
dp[l+1][r] + size[l][l] + size[l+1][r],
dp[l][r-1] + size[r][r] + size[l][r-1])
for k in range(l, r):
dp[l][r] = min(dp[l][r], dp[l][k] + dp[k+1][r] + size[l][k] + size[k+1][r])
#fprint(dp)
print((dp[0][-1]))
#####################################################ライブラリ集ここから
def kiriage_warizan(a, b):
return -(-a//b)
def iip(listed=False): # 数字のinputをlistで受け取る
d = input().rstrip("\n").split()
try:
ret = [int(i) for i in d]
except:
ret = [int(i) if i in _NUMINT_ALL else i for i in d]
if len(ret) == 1 and listed is False:
return ret[0]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def iipt(l, listed=True): # 縦向きに並んでいるデータをリストに落とし込む(iip利用)
if isinstance(l, list):
l = l[0] # 間違って要素１個のタプルを渡されても受け取る
assert isinstance(l, int)
ret = []
for i in range(l):
ret.append(iip(listed=listed))
return ret
def saidai_kouyakusuu(A): # 最大公約数
l = len(A)
while True:
m = min(A)
mx = max(A)
if m == mx:
return m
for i in range(l):
if A[i] % m == 0:
A[i] = m
else:
A[i] %= m
def flatten(l):
return list(itertools.chain.from_iterable(l))
def index_sorted(sorted_list, target):
idx = bisect_left(sorted_list, target)
if idx != len(sorted_list) and sorted_list[idx] == target:
return idx
else:
return False
def time_debug_10percent():
a = random.randint(0, 9)
if a == 9:
sys.exit()
def time_debug(t):
time.sleep(_START_TIME + t - time.time())
sys.exit()
def make_graph_edge_flat(N): # グラフ作成のための辺をリストで返す
ret = []
for i in range(N-1):
a, b, c = iip()
a -= 1
b -= 1
ret[a].append((b, c))
ret[b].append((a, c))
return ret
def sort_tuples(l, index): # タプルのリストを特定のインデックスでソートする
if isinstance(l, list):
l.sort(key=lambda x: x[index])
return l
else:
l = list(l)
return sorted(l, key=lambda x: x[index])
def count_elements(l): # リストの中身の個数を種類分けして辞書で返す
d = {}
for i in l:
if i in d:
d[i] += 1
else:
d[i] = 1
return d
def safeget(l, index, default="exception"): # listの中身を取り出す時、listからはみ出たり
if index >= len(l): # マイナスインデックスになったりするのを防ぐ
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。配列の長さは", len(l), "です"]))
else:
return default
elif index < 0:
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。負の値は許可されていません"]))
else:
return default
else:
return l[index]
def sortstr(s): # 文字列をソートする
return "".join(sorted(s))
def iip_ord(startcode="a"): # 文字列を数字の列に変換する(数字と文字は1:1対応)
if isinstance(startcode, str):
startcode = ord(startcode)
return [ord(i) - startcode for i in eval(input())]
def YesNo(s): # TrueFalseや1, 0をYesNoに変換する
if s:
print("Yes")
else:
print("No")
def fprint(s): # リストを平たくしてprintする(二次元リストを見やすくしたりとか)
if isinstance(s, int):
print(s)
return
keta = max([len(str(i)) for i in itertools.chain.from_iterable(s)])
print("--------")
for i in s:
print([str(j).rjust(keta) for j in i])
print("--------")
def bitall(N): # ビット全探索用のインデックスを出力
ret = []
for i in range(2 ** N):
a = []
for j in range(N):
a.append(i % 2)
i //= 2
ret.append(a)
return ret
def split_print_space(s): # リストの中身をスペース区切りで出力する
print((" ".join([str(i) for i in s])))
def split_print_enter(s): # リストの中身を改行区切りで出力する
print(("\n".join([str(i) for i in s])))
def soinsuu_bunkai(n): # 素因数分解
ret = []
for i in range(2, int(n ** 0.5) + 1):
while n % i == 0:
n //= i
ret.append(i)
if i > n:
break
if n != 1:
ret.append(n)
return ret
def conbination(n, r, mod, test=False): # nCrをmodを使って計算する
if n <= 0:
return 0
if r == 0:
return 1
if r < 0:
return 0
if r == 1:
return n
ret = 1
for i in range(n - r + 1, n + 1):
ret *= i
ret = ret % mod
bunbo = 1
for i in range(1, r + 1):
bunbo *= i
bunbo = bunbo % mod
ret = (ret * inv(bunbo, mod)) % mod
if test:
# print(f"{n}C{r} = {ret}")
pass
return ret
def inv(n, mod): # modnにおける逆元を計算
return power(n, mod - 2)
def power(n, p, mod_=mod): # 繰り返し二乗法でn**p % modを計算
if p == 0:
return 1
if p % 2 == 0:
return (power(n, p // 2, mod_) ** 2) % mod_
if p % 2 == 1:
return (n * power(n, p - 1, mod_)) % mod_
def nibutan_func(func, target, left, right, side="left", seido = 1): # 関数を二分探索
l = left
r = right
if seido == 1:
x = (l + r) // 2
else:
x = (l + r) / 2
while r-l > seido:
#print(x)
if seido == 1:
x = (l + r) // 2
else:
x = (l + r) / 2
if func(x) == target:
if side == "left":
r=x
else:
l=x
elif func(x) > target:
r = x
else:
#print(r, l)
l = x
#print(l, r)
if side == "left" and func(r) == target:
return r
elif side != "left" and func(l) == target:
return l
elif side == "left":
return l
else:
return r
def nibutan_list(list_, target, side="left"): # リストを二分探索
if not isinstance(list_, list):
list_ = list(list_)
l = 0
r = len(list_)
x = (l + r) // 2
while r-l > 1:
x = (l+r)//2
if list_[x] == target:
return x
elif list_[x] > target:
r = x
else:
l = x
if side == "left" or list_[x] == target:
return l
else:
return r
class UfTree():
def __init__(self, maxnum):
self.parent = list(range(maxnum))
self._size = [1] * maxnum
self.rank = [0] * maxnum
def size(self, a):
return self._size[self.root(a)]
def root(self, a):
rank = 0
cur = a
while True:
if self.parent[cur] == cur:
#for i in path: # 経路圧縮
# self.parent[i] = cur
return cur
else:
self.parent[cur] = self.parent[self.parent[cur]]
cur = self.parent[cur]
rank += 1
def unite(self, a, b):
ra = self.root(a)
rb = self.root(b)
if ra == rb:
return self
self._size[ra] += self._size[rb]
self.parent[rb] = ra
return self
if __name__ == "__main__":
main()
| mod = 10 ** 9 + 7
mod2 = 2 ** 61 + 1
from collections import deque
import heapq
import time
from bisect import bisect_left, insort_left, bisect_right
import sys
import random
import itertools
#input = sys.stdin.readline
def input():
return sys.stdin.readline().strip("\n").strip(" ")
_NUMINT_ALL = list(range(10))
_START_TIME = time.time()
INDEX_KETA = 10**12
def main():
ans = solve()
if ans is True or ans is False:
YesNo(ans)
elif ans is None:
return
if isinstance(ans, tuple):
split_print_space(ans)
else:
print(ans)
def solve():
N = iip()
A = iip()
SA = [0]
cur = 0
for i in A:
cur += i
SA.append(cur)
#print(SA)
size = [[0 for _ in range(N)] for _ in range(N)]
for i in range(N):
for j in range(i, N):
size[i][j] = int(SA[j+1]-SA[i])
#fprint(size)
dp = [[10**13 for _ in range(N)] for _ in range(N)]
for i in range(N):
dp[i][i] = 0
for d in range(N):
for l in range(N):
r = l+d
if r >= N:
continue
if l==r:
dp[l][r] = 0
else:
dp[l][r] = min(dp[l][r],
dp[l+1][r] + size[l][l] + size[l+1][r],
dp[l][r-1] + size[r][r] + size[l][r-1])
for k in range(l, r):
dp[l][r] = min(dp[l][r], dp[l][k] + dp[k+1][r] + size[l][k] + size[k+1][r])
#fprint(dp)
print((dp[0][-1]))
#####################################################ライブラリ集ここから
def kiriage_warizan(a, b):
return -(-a//b)
def iip(listed=False): # 数字のinputをlistで受け取る
d = input().rstrip("\n").split()
try:
ret = [int(i) for i in d]
except:
ret = [int(i) if i in _NUMINT_ALL else i for i in d]
if len(ret) == 1 and listed is False:
return ret[0]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def iipt(l, listed=True): # 縦向きに並んでいるデータをリストに落とし込む(iip利用)
if isinstance(l, list):
l = l[0] # 間違って要素１個のタプルを渡されても受け取る
assert isinstance(l, int)
ret = []
for i in range(l):
ret.append(iip(listed=listed))
return ret
def saidai_kouyakusuu(A): # 最大公約数
l = len(A)
while True:
m = min(A)
mx = max(A)
if m == mx:
return m
for i in range(l):
if A[i] % m == 0:
A[i] = m
else:
A[i] %= m
def flatten(l):
return list(itertools.chain.from_iterable(l))
def index_sorted(sorted_list, target):
idx = bisect_left(sorted_list, target)
if idx != len(sorted_list) and sorted_list[idx] == target:
return idx
else:
return False
def time_debug_10percent():
a = random.randint(0, 9)
if a == 9:
sys.exit()
def time_debug(t):
time.sleep(_START_TIME + t - time.time())
sys.exit()
def make_graph_edge_flat(N): # グラフ作成のための辺をリストで返す
ret = []
for i in range(N-1):
a, b, c = iip()
a -= 1
b -= 1
ret[a].append((b, c))
ret[b].append((a, c))
return ret
def sort_tuples(l, index): # タプルのリストを特定のインデックスでソートする
if isinstance(l, list):
l.sort(key=lambda x: x[index])
return l
else:
l = list(l)
return sorted(l, key=lambda x: x[index])
def count_elements(l): # リストの中身の個数を種類分けして辞書で返す
d = {}
for i in l:
if i in d:
d[i] += 1
else:
d[i] = 1
return d
def safeget(l, index, default="exception"): # listの中身を取り出す時、listからはみ出たり
if index >= len(l): # マイナスインデックスになったりするのを防ぐ
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。配列の長さは", len(l), "です"]))
else:
return default
elif index < 0:
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。負の値は許可されていません"]))
else:
return default
else:
return l[index]
def sortstr(s): # 文字列をソートする
return "".join(sorted(s))
def iip_ord(startcode="a"): # 文字列を数字の列に変換する(数字と文字は1:1対応)
if isinstance(startcode, str):
startcode = ord(startcode)
return [ord(i) - startcode for i in eval(input())]
def YesNo(s): # TrueFalseや1, 0をYesNoに変換する
if s:
print("Yes")
else:
print("No")
def fprint(s): # リストを平たくしてprintする(二次元リストを見やすくしたりとか)
if isinstance(s, int):
print(s)
return
keta = max([len(str(i)) for i in itertools.chain.from_iterable(s)])
print("--------")
for i in s:
print([str(j).rjust(keta) for j in i])
print("--------")
def bitall(N): # ビット全探索用のインデックスを出力
ret = []
for i in range(2 ** N):
a = []
for j in range(N):
a.append(i % 2)
i //= 2
ret.append(a)
return ret
def split_print_space(s): # リストの中身をスペース区切りで出力する
print((" ".join([str(i) for i in s])))
def split_print_enter(s): # リストの中身を改行区切りで出力する
print(("\n".join([str(i) for i in s])))
def soinsuu_bunkai(n): # 素因数分解
ret = []
for i in range(2, int(n ** 0.5) + 1):
while n % i == 0:
n //= i
ret.append(i)
if i > n:
break
if n != 1:
ret.append(n)
return ret
def conbination(n, r, mod, test=False): # nCrをmodを使って計算する
if n <= 0:
return 0
if r == 0:
return 1
if r < 0:
return 0
if r == 1:
return n
ret = 1
for i in range(n - r + 1, n + 1):
ret *= i
ret = ret % mod
bunbo = 1
for i in range(1, r + 1):
bunbo *= i
bunbo = bunbo % mod
ret = (ret * inv(bunbo, mod)) % mod
if test:
# print(f"{n}C{r} = {ret}")
pass
return ret
def inv(n, mod): # modnにおける逆元を計算
return power(n, mod - 2)
def power(n, p, mod_=mod): # 繰り返し二乗法でn**p % modを計算
if p == 0:
return 1
if p % 2 == 0:
return (power(n, p // 2, mod_) ** 2) % mod_
if p % 2 == 1:
return (n * power(n, p - 1, mod_)) % mod_
def nibutan_func(func, target, left, right, side="left", seido = 1): # 関数を二分探索
l = left
r = right
if seido == 1:
x = (l + r) // 2
else:
x = (l + r) / 2
while r-l > seido:
#print(x)
if seido == 1:
x = (l + r) // 2
else:
x = (l + r) / 2
if func(x) == target:
if side == "left":
r=x
else:
l=x
elif func(x) > target:
r = x
else:
#print(r, l)
l = x
#print(l, r)
if side == "left" and func(r) == target:
return r
elif side != "left" and func(l) == target:
return l
elif side == "left":
return l
else:
return r
def nibutan_list(list_, target, side="left"): # リストを二分探索
if not isinstance(list_, list):
list_ = list(list_)
l = 0
r = len(list_)
x = (l + r) // 2
while r-l > 1:
x = (l+r)//2
if list_[x] == target:
return x
elif list_[x] > target:
r = x
else:
l = x
if side == "left" or list_[x] == target:
return l
else:
return r
class UfTree():
def __init__(self, maxnum):
self.parent = list(range(maxnum))
self._size = [1] * maxnum
self.rank = [0] * maxnum
def size(self, a):
return self._size[self.root(a)]
def root(self, a):
rank = 0
cur = a
while True:
if self.parent[cur] == cur:
#for i in path: # 経路圧縮
# self.parent[i] = cur
return cur
else:
self.parent[cur] = self.parent[self.parent[cur]]
cur = self.parent[cur]
rank += 1
def unite(self, a, b):
ra = self.root(a)
rb = self.root(b)
if ra == rb:
return self
self._size[ra] += self._size[rb]
self.parent[rb] = ra
return self
if __name__ == "__main__":
main()
| p03173 |
mod = 10 ** 9 + 7
mod2 = 2 ** 61 + 1
from collections import deque
import heapq
import time
from bisect import bisect_left, insort_left, bisect_right
import sys
import random
import itertools
#input = sys.stdin.readline
def input():
return sys.stdin.readline().strip("\n").strip(" ")
_NUMINT_ALL = list(range(10))
_START_TIME = time.time()
INDEX_KETA = 10**12
INF = 18446744073709551615
def main():
ans = solve()
if ans is True or ans is False:
YesNo(ans)
elif ans is None:
return
if isinstance(ans, tuple):
split_print_space(ans)
else:
print(ans)
def solve():
N = iip()
A = iip()
SA = [0]
cur = 0
for i in A:
cur += i
SA.append(cur)
#print(SA)
size = [[0 for _ in range(N)] for _ in range(N)]
for i in range(N):
for j in range(i, N):
size[i][j] = int(SA[j+1]-SA[i])
#fprint(size)
dp = [[INF for _ in range(N)] for _ in range(N)]
for i in range(N):
dp[i][i] = 0
for d in range(N):
for l in range(N):
r = l+d
if r >= N:
continue
if l==r:
dp[l][r] = 0
else:
dp[l][r] = min(dp[l][r],
dp[l+1][r] + size[l][l] + size[l+1][r],
dp[l][r-1] + size[r][r] + size[l][r-1])
for k in range(l, r):
dp[l][r] = min(dp[l][r], dp[l][k] + dp[k+1][r] + size[l][k] + size[k+1][r])
#fprint(dp)
print((dp[0][-1]))
#####################################################ライブラリ集ここから
def kiriage_warizan(a, b):
return -(-a//b)
def iip(listed=False): # 数字のinputをlistで受け取る
d = input().rstrip("\n").split()
try:
ret = [int(i) for i in d]
except:
ret = [int(i) if i in _NUMINT_ALL else i for i in d]
if len(ret) == 1 and listed is False:
return ret[0]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def iipt(l, listed=True): # 縦向きに並んでいるデータをリストに落とし込む(iip利用)
if isinstance(l, list):
l = l[0] # 間違って要素１個のタプルを渡されても受け取る
assert isinstance(l, int)
ret = []
for i in range(l):
ret.append(iip(listed=listed))
return ret
def saidai_kouyakusuu(A): # 最大公約数
l = len(A)
while True:
m = min(A)
mx = max(A)
if m == mx:
return m
for i in range(l):
if A[i] % m == 0:
A[i] = m
else:
A[i] %= m
def flatten(l):
return list(itertools.chain.from_iterable(l))
def index_sorted(sorted_list, target):
idx = bisect_left(sorted_list, target)
if idx != len(sorted_list) and sorted_list[idx] == target:
return idx
else:
return False
def time_debug_10percent():
a = random.randint(0, 9)
if a == 9:
sys.exit()
def time_debug(t):
time.sleep(_START_TIME + t - time.time())
sys.exit()
def make_graph_edge_flat(N): # グラフ作成のための辺をリストで返す
ret = []
for i in range(N-1):
a, b, c = iip()
a -= 1
b -= 1
ret[a].append((b, c))
ret[b].append((a, c))
return ret
def sort_tuples(l, index): # タプルのリストを特定のインデックスでソートする
if isinstance(l, list):
l.sort(key=lambda x: x[index])
return l
else:
l = list(l)
return sorted(l, key=lambda x: x[index])
def count_elements(l): # リストの中身の個数を種類分けして辞書で返す
d = {}
for i in l:
if i in d:
d[i] += 1
else:
d[i] = 1
return d
def safeget(l, index, default="exception"): # listの中身を取り出す時、listからはみ出たり
if index >= len(l): # マイナスインデックスになったりするのを防ぐ
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。配列の長さは", len(l), "です"]))
else:
return default
elif index < 0:
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。負の値は許可されていません"]))
else:
return default
else:
return l[index]
def sortstr(s): # 文字列をソートする
return "".join(sorted(s))
def iip_ord(startcode="a"): # 文字列を数字の列に変換する(数字と文字は1:1対応)
if isinstance(startcode, str):
startcode = ord(startcode)
return [ord(i) - startcode for i in eval(input())]
def YesNo(s): # TrueFalseや1, 0をYesNoに変換する
if s:
print("Yes")
else:
print("No")
def fprint(s): # リストを平たくしてprintする(二次元リストを見やすくしたりとか)
if isinstance(s, int):
print(s)
return
keta = max([len(str(i)) for i in itertools.chain.from_iterable(s)])
print("--------")
for i in s:
print([str(j).rjust(keta) for j in i])
print("--------")
def bitall(N): # ビット全探索用のインデックスを出力
ret = []
for i in range(2 ** N):
a = []
for j in range(N):
a.append(i % 2)
i //= 2
ret.append(a)
return ret
def split_print_space(s): # リストの中身をスペース区切りで出力する
print((" ".join([str(i) for i in s])))
def split_print_enter(s): # リストの中身を改行区切りで出力する
print(("\n".join([str(i) for i in s])))
def soinsuu_bunkai(n): # 素因数分解
ret = []
for i in range(2, int(n ** 0.5) + 1):
while n % i == 0:
n //= i
ret.append(i)
if i > n:
break
if n != 1:
ret.append(n)
return ret
def conbination(n, r, mod, test=False): # nCrをmodを使って計算する
if n <= 0:
return 0
if r == 0:
return 1
if r < 0:
return 0
if r == 1:
return n
ret = 1
for i in range(n - r + 1, n + 1):
ret *= i
ret = ret % mod
bunbo = 1
for i in range(1, r + 1):
bunbo *= i
bunbo = bunbo % mod
ret = (ret * inv(bunbo, mod)) % mod
if test:
# print(f"{n}C{r} = {ret}")
pass
return ret
def inv(n, mod): # modnにおける逆元を計算
return power(n, mod - 2)
def power(n, p, mod_=mod): # 繰り返し二乗法でn**p % modを計算
if p == 0:
return 1
if p % 2 == 0:
return (power(n, p // 2, mod_) ** 2) % mod_
if p % 2 == 1:
return (n * power(n, p - 1, mod_)) % mod_
def nibutan_func(func, target, left, right, side="left", seido = 1): # 関数を二分探索
l = left
r = right
if seido == 1:
x = (l + r) // 2
else:
x = (l + r) / 2
while r-l > seido:
#print(x)
if seido == 1:
x = (l + r) // 2
else:
x = (l + r) / 2
if func(x) == target:
if side == "left":
r=x
else:
l=x
elif func(x) > target:
r = x
else:
#print(r, l)
l = x
#print(l, r)
if side == "left" and func(r) == target:
return r
elif side != "left" and func(l) == target:
return l
elif side == "left":
return l
else:
return r
def nibutan_list(list_, target, side="left"): # リストを二分探索
if not isinstance(list_, list):
list_ = list(list_)
l = 0
r = len(list_)
x = (l + r) // 2
while r-l > 1:
x = (l+r)//2
if list_[x] == target:
return x
elif list_[x] > target:
r = x
else:
l = x
if side == "left" or list_[x] == target:
return l
else:
return r
class UfTree():
def __init__(self, maxnum):
self.parent = list(range(maxnum))
self._size = [1] * maxnum
self.rank = [0] * maxnum
def size(self, a):
return self._size[self.root(a)]
def root(self, a):
rank = 0
cur = a
while True:
if self.parent[cur] == cur:
#for i in path: # 経路圧縮
# self.parent[i] = cur
return cur
else:
self.parent[cur] = self.parent[self.parent[cur]]
cur = self.parent[cur]
rank += 1
def unite(self, a, b):
ra = self.root(a)
rb = self.root(b)
if ra == rb:
return self
self._size[ra] += self._size[rb]
self.parent[rb] = ra
return self
if __name__ == "__main__":
main()
| mod = 10 ** 9 + 7
mod2 = 2 ** 61 + 1
from collections import deque
import heapq
import time
from bisect import bisect_left, insort_left, bisect_right
import sys
import random
import itertools
#input = sys.stdin.readline
def input():
return sys.stdin.readline().strip("\n").strip(" ")
_NUMINT_ALL = list(range(10))
_START_TIME = time.time()
INDEX_KETA = 10**12
INF = 9223372036854775807
def main():
ans = solve()
if ans is True or ans is False:
YesNo(ans)
elif ans is None:
return
if isinstance(ans, tuple):
split_print_space(ans)
else:
print(ans)
def solve():
N = iip()
A = iip()
SA = [0]
cur = 0
for i in A:
cur += i
SA.append(cur)
#print(SA)
size = [[0 for _ in range(N)] for _ in range(N)]
for i in range(N):
for j in range(i, N):
size[i][j] = int(SA[j+1]-SA[i])
#fprint(size)
dp = [[INF for _ in range(N)] for _ in range(N)]
for i in range(N):
dp[i][i] = 0
for d in range(N):
for l in range(N):
r = l+d
if r >= N:
continue
if l==r:
dp[l][r] = 0
else:
dp[l][r] = min(dp[l][r],
dp[l+1][r] + size[l][l] + size[l+1][r],
dp[l][r-1] + size[r][r] + size[l][r-1])
for k in range(l, r):
dp[l][r] = min(dp[l][r], dp[l][k] + dp[k+1][r] + size[l][k] + size[k+1][r])
#fprint(dp)
print((dp[0][-1]))
#####################################################ライブラリ集ここから
def kiriage_warizan(a, b):
return -(-a//b)
def iip(listed=False): # 数字のinputをlistで受け取る
d = input().rstrip("\n").split()
try:
ret = [int(i) for i in d]
except:
ret = [int(i) if i in _NUMINT_ALL else i for i in d]
if len(ret) == 1 and listed is False:
return ret[0]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def iipt(l, listed=True): # 縦向きに並んでいるデータをリストに落とし込む(iip利用)
if isinstance(l, list):
l = l[0] # 間違って要素１個のタプルを渡されても受け取る
assert isinstance(l, int)
ret = []
for i in range(l):
ret.append(iip(listed=listed))
return ret
def saidai_kouyakusuu(A): # 最大公約数
l = len(A)
while True:
m = min(A)
mx = max(A)
if m == mx:
return m
for i in range(l):
if A[i] % m == 0:
A[i] = m
else:
A[i] %= m
def flatten(l):
return list(itertools.chain.from_iterable(l))
def index_sorted(sorted_list, target):
idx = bisect_left(sorted_list, target)
if idx != len(sorted_list) and sorted_list[idx] == target:
return idx
else:
return False
def time_debug_10percent():
a = random.randint(0, 9)
if a == 9:
sys.exit()
def time_debug(t):
time.sleep(_START_TIME + t - time.time())
sys.exit()
def make_graph_edge_flat(N): # グラフ作成のための辺をリストで返す
ret = []
for i in range(N-1):
a, b, c = iip()
a -= 1
b -= 1
ret[a].append((b, c))
ret[b].append((a, c))
return ret
def sort_tuples(l, index): # タプルのリストを特定のインデックスでソートする
if isinstance(l, list):
l.sort(key=lambda x: x[index])
return l
else:
l = list(l)
return sorted(l, key=lambda x: x[index])
def count_elements(l): # リストの中身の個数を種類分けして辞書で返す
d = {}
for i in l:
if i in d:
d[i] += 1
else:
d[i] = 1
return d
def safeget(l, index, default="exception"): # listの中身を取り出す時、listからはみ出たり
if index >= len(l): # マイナスインデックスになったりするのを防ぐ
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。配列の長さは", len(l), "です"]))
else:
return default
elif index < 0:
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。負の値は許可されていません"]))
else:
return default
else:
return l[index]
def sortstr(s): # 文字列をソートする
return "".join(sorted(s))
def iip_ord(startcode="a"): # 文字列を数字の列に変換する(数字と文字は1:1対応)
if isinstance(startcode, str):
startcode = ord(startcode)
return [ord(i) - startcode for i in eval(input())]
def YesNo(s): # TrueFalseや1, 0をYesNoに変換する
if s:
print("Yes")
else:
print("No")
def fprint(s): # リストを平たくしてprintする(二次元リストを見やすくしたりとか)
if isinstance(s, int):
print(s)
return
keta = max([len(str(i)) for i in itertools.chain.from_iterable(s)])
print("--------")
for i in s:
print([str(j).rjust(keta) for j in i])
print("--------")
def bitall(N): # ビット全探索用のインデックスを出力
ret = []
for i in range(2 ** N):
a = []
for j in range(N):
a.append(i % 2)
i //= 2
ret.append(a)
return ret
def split_print_space(s): # リストの中身をスペース区切りで出力する
print((" ".join([str(i) for i in s])))
def split_print_enter(s): # リストの中身を改行区切りで出力する
print(("\n".join([str(i) for i in s])))
def soinsuu_bunkai(n): # 素因数分解
ret = []
for i in range(2, int(n ** 0.5) + 1):
while n % i == 0:
n //= i
ret.append(i)
if i > n:
break
if n != 1:
ret.append(n)
return ret
def conbination(n, r, mod, test=False): # nCrをmodを使って計算する
if n <= 0:
return 0
if r == 0:
return 1
if r < 0:
return 0
if r == 1:
return n
ret = 1
for i in range(n - r + 1, n + 1):
ret *= i
ret = ret % mod
bunbo = 1
for i in range(1, r + 1):
bunbo *= i
bunbo = bunbo % mod
ret = (ret * inv(bunbo, mod)) % mod
if test:
# print(f"{n}C{r} = {ret}")
pass
return ret
def inv(n, mod): # modnにおける逆元を計算
return power(n, mod - 2)
def power(n, p, mod_=mod): # 繰り返し二乗法でn**p % modを計算
if p == 0:
return 1
if p % 2 == 0:
return (power(n, p // 2, mod_) ** 2) % mod_
if p % 2 == 1:
return (n * power(n, p - 1, mod_)) % mod_
def nibutan_func(func, target, left, right, side="left", seido = 1): # 関数を二分探索
l = left
r = right
if seido == 1:
x = (l + r) // 2
else:
x = (l + r) / 2
while r-l > seido:
#print(x)
if seido == 1:
x = (l + r) // 2
else:
x = (l + r) / 2
if func(x) == target:
if side == "left":
r=x
else:
l=x
elif func(x) > target:
r = x
else:
#print(r, l)
l = x
#print(l, r)
if side == "left" and func(r) == target:
return r
elif side != "left" and func(l) == target:
return l
elif side == "left":
return l
else:
return r
def nibutan_list(list_, target, side="left"): # リストを二分探索
if not isinstance(list_, list):
list_ = list(list_)
l = 0
r = len(list_)
x = (l + r) // 2
while r-l > 1:
x = (l+r)//2
if list_[x] == target:
return x
elif list_[x] > target:
r = x
else:
l = x
if side == "left" or list_[x] == target:
return l
else:
return r
class UfTree():
def __init__(self, maxnum):
self.parent = list(range(maxnum))
self._size = [1] * maxnum
self.rank = [0] * maxnum
def size(self, a):
return self._size[self.root(a)]
def root(self, a):
rank = 0
cur = a
while True:
if self.parent[cur] == cur:
#for i in path: # 経路圧縮
# self.parent[i] = cur
return cur
else:
self.parent[cur] = self.parent[self.parent[cur]]
cur = self.parent[cur]
rank += 1
def unite(self, a, b):
ra = self.root(a)
rb = self.root(b)
if ra == rb:
return self
self._size[ra] += self._size[rb]
self.parent[rb] = ra
return self
if __name__ == "__main__":
main()
| p03173 |
#!/usr/bin/env python3
import sys
from itertools import accumulate
import functools
INF = float("inf")
def solve(N: int, a: "List[int]"):
dp = [[0]*N for _ in range(N)]
acc = [0]+list(accumulate(a))
@functools.lru_cache(maxsize=None)
def rec(l, r):
if l == r:
return 0
wa = acc[r+1]-acc[l]
ans = INF
for k in range(l, r):
ans = min(rec(l, k) + rec(k+1, r), ans)
return ans + wa
print((rec(0, N-1)))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, a)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
from itertools import accumulate
import functools
sys.setrecursionlimit(10**8)
INF = float("inf")
def solve(N: int, a: "List[int]"):
dp = [[-1]*N for _ in range(N)]
acc = [0]+list(accumulate(a))
def rec(l, r):
if dp[l][r] > 0:
return dp[l][r]
if l == r:
return 0
wa = acc[r+1]-acc[l]
ans = INF
for k in range(l, r):
ans = min(rec(l, k) + rec(k+1, r), ans)
dp[l][r] = ans + wa
return dp[l][r]
print((rec(0, N-1)))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, a)
if __name__ == '__main__':
main()
| p03173 |
n=int(eval(input()))
a= list(map(int, input().split()))
a+=a
INF=10**12
dp=[[[INF,0] for i in range(2*n+1)] for i in range(2*n+1)]
# dp[i][j][0]: コスト
# dp[i][j][1]:合成したスライムの合計
for i in range(n):
for l in range(2*n-i):
r=l+i
if r==l:
dp[l][r][1]=a[l]
dp[l][r][0]=0
else:
# 合成の仕方を確定
for k in range(l,r):
dp[l][r][0]=min(dp[l][k][1]+dp[k+1][r][1]+dp[l][k][0]+dp[k+1][r][0],dp[l][r][0])
dp[l][r][1]=dp[l][r-1][1]+a[r]
print((dp[0][n-1][0])) | import sys
import itertools
input = sys.stdin.readline
n=int(eval(input()))
a= list(map(int, input().split()))
a+=a
b=itertools.accumulate(a)
b=[0]+list(b)
INF=10**15
dp=[[INF] *(2*n+1) for i in range(2*n+1)]
# dp[i][j][0]: コスト
# dp[i][j][1]:合成したスライムの合計
for i in range(n):
for l in range(2*n-i):
r=l+i
if r==l:
dp[l][r]=0
else:
# 合成の仕方を確定
for k in range(l,r):
dp[l][r]=min(dp[l][k]+dp[k+1][r]+b[r+1]-b[l],dp[l][r])
print((dp[0][n-1])) | p03173 |
inf = float('inf')
def accmulate(array):
global cs
cs = [0]*(len(array)+1)
for i in range(len(array)):
cs[i+1] = cs[i] + array[i]
def query(l,r):
return cs[r+1] - cs[l]
N = int(eval(input()))
A = list(map(int,input().split()))
accmulate(A)
dp = [[inf]*(N+1) for _ in range(N+1)]
for i in range(N):
dp[i][i+1] = 0
for i in range(N-1):
dp[i][i+2] = A[i] + A[i+1]
for b in range(3,N+1):
for i in range(N-b+1):
j = i + b
for k in range(i+1,j):
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j] + query(i,j-1))
ans = dp[0][N]
print(ans) | inf = float('inf')
def accmulate(array):
global cs
cs = [0]*(len(array)+1)
for i in range(len(array)):
cs[i+1] = cs[i] + array[i]
def query(l,r):
return cs[r+1] - cs[l]
N = int(eval(input()))
A = list(map(int,input().split()))
accmulate(A)
dp = [[inf]*(N+1) for _ in range(N+1)]
for i in range(N):
dp[i][i+1] = 0
for b in range(2,N+1):
for i in range(N-b+1):
j = i + b
for k in range(i+1,j):
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j] + query(i,j-1))
ans = dp[0][N]
print(ans) | p03173 |
n = int(eval(input()))
*A, = list(map(int, input().split()))
# n = 4
# A = [10, 20, 30, 40]
inf = 10**20
DP = [[None for r in range(n+1)] for l in range(n)]
S = [0]
for i in range(n):
S.append(S[-1]+A[i])
def f(l, r):
if r <= l+1:
DP[l][r] = 0
if DP[l][r] != None:
return DP[l][r]
DP[l][r] = S[r]-S[l]+min([f(l, i)+f(i, r) for i in range(l+1, r)])
return DP[l][r]
print((f(0, n)))
| n = int(eval(input()))
*A, = list(map(int, input().split()))
# n = 4
# A = [10, 20, 30, 40]
DP = [[None for r in range(n+1)] for l in range(n)]
S = [0]
for i in range(n):
S.append(S[-1]+A[i])
def dp(l, r):
# 区間[l,r)での最小コスト
if r <= l+1:
DP[l][r] = 0
if DP[l][r] != None:
return DP[l][r]
# S[r]-S[l]=sum(A[l:r])
DP[l][r] = S[r]-S[l]+min([dp(l, i)+dp(i, r) for i in range(l+1, r)])
return DP[l][r]
print((dp(0, n)))
| p03173 |
n = int(eval(input()))
*A, = list(map(int, input().split()))
# n = 4
# A = [10, 20, 30, 40]
DP = [[None for r in range(n+1)] for l in range(n)]
S = [0]
for i in range(n):
S.append(S[-1]+A[i])
def dp(l, r):
# 区間[l,r)での最小コスト
if r <= l+1:
DP[l][r] = 0
if DP[l][r] != None:
return DP[l][r]
# S[r]-S[l]=sum(A[l:r])
DP[l][r] = S[r]-S[l]+min([dp(l, i)+dp(i, r) for i in range(l+1, r)])
return DP[l][r]
print((dp(0, n)))
| n = int(eval(input()))
*A, = list(map(int, input().split()))
S = [0]
for i in range(n):
S.append(S[-1]+A[i])
DP = [[None for r in range(n+1)] for l in range(n)]
def dp(l, r):
if r <= l+1:
return 0
if DP[l][r] != None:
return DP[l][r]
DP[l][r] = S[r]-S[l]+min([dp(l, i)+dp(i, r) for i in range(l+1, r)])
return DP[l][r]
print((dp(0, n)))
| p03173 |
def solve(n, k):
MOD = 998244353
if n > k:
return 0
invs = [1] * (k + 1)
pf, kf = 1, 1
for m in range(2, k + 1):
pf = kf
kf *= m
kf %= MOD
invs[m] = pow(kf, MOD - 2, MOD)
ans = 0
if k & 1 == 0:
if n == 1:
ans = 1
else:
r = k >> 1
t = r - n + 1
ans = pf * (invs[r] * invs[r - 1] - invs[r + t] * invs[k - r - t - 1]) % MOD
for r in range(k // 2 + 1, k + 1):
if r * 2 >= n + k:
ans += kf * invs[r] * invs[k - r]
else:
t = r - n + 1
ans += kf * (invs[r] * invs[k - r] - invs[r + t] * invs[k - r - t])
ans %= MOD
return ans
print((solve(*list(map(int, input().split())))))
| def solve(n, k):
MOD = 998244353
if n > k:
return 0
if n == 1:
return pow(2, k - 1, MOD)
invs = [1] * (k + 1)
pf, kf = 1, 1
for m in range(2, k + 1):
pf = kf
kf *= m
kf %= MOD
invs[m] = pow(kf, MOD - 2, MOD)
ans = 0
if k & 1 == 0:
r = k >> 1
s = k - n + 1
ans = pf * (invs[r] * invs[r - 1] - invs[s] * invs[k - s - 1]) % MOD
for r in range(k // 2 + 1, k + 1):
if r * 2 >= n + k:
ans += kf * invs[r] * invs[k - r]
else:
s = r * 2 - n + 1
ans += kf * (invs[r] * invs[k - r] - invs[s] * invs[k - s])
ans %= MOD
return ans
print((solve(*list(map(int, input().split())))))
| p03431 |
def solve(n, k):
MOD = 998244353
if n > k:
return 0
if n == 1:
return pow(2, k - 1, MOD)
invs = [1] * (k + 1)
pf, kf = 1, 1
for m in range(2, k + 1):
pf = kf
kf *= m
kf %= MOD
invs[m] = pow(kf, MOD - 2, MOD)
ans = 0
if k & 1 == 0:
r = k >> 1
s = k - n + 1
ans = pf * (invs[r] * invs[r - 1] - invs[s] * invs[k - s - 1]) % MOD
for r in range(k // 2 + 1, k + 1):
if r * 2 >= n + k:
ans += kf * invs[r] * invs[k - r]
else:
s = r * 2 - n + 1
ans += kf * (invs[r] * invs[k - r] - invs[s] * invs[k - s])
ans %= MOD
return ans
print((solve(*list(map(int, input().split())))))
| def solve(n, k):
MOD = 998244353
if n > k:
return 0
if n == 1:
return pow(2, k - 1, MOD)
pf, kf = 1, 1
for m in range(2, k + 1):
pf = kf
kf *= m
kf %= MOD
inv = pow(kf, MOD - 2, MOD)
invs = [1] * (k + 1)
invs[k] = inv
for m in range(k, 1, -1):
inv *= m
inv %= MOD
invs[m - 1] = inv
ans = 0
if k & 1 == 0:
r = k >> 1
s = k - n + 1
ans = pf * (invs[r] * invs[r - 1] - invs[s] * invs[k - s - 1]) % MOD
for r in range(k // 2 + 1, k + 1):
if r * 2 >= n + k:
ans += kf * invs[r] * invs[k - r]
else:
s = r * 2 - n + 1
ans += kf * (invs[r] * invs[k - r] - invs[s] * invs[k - s])
ans %= MOD
return ans
print((solve(*list(map(int, input().split())))))
| p03431 |
n,k=list(map(int,input().split()))
p=998244353
r=range
f=[1]
for i in r(k):f+=[-~i*f[i]%p]
a=1<<~-k
for i in r(min(n-1,k)):a-=f[k-1]*pow((f[i]*f[k-1-i])%p,-1,p)
print((a%p)) | n,k=list(map(int,input().split()))
p=998244353
r=range
f=[1]
for i in r(k):f+=[-~i*f[i]%p]
a=0
for i in r(n-1,k):a+=f[k-1]*pow(f[i]*f[k-1-i],-1,p)
print((a%p)) | p03431 |
n,k=list(map(int,input().split()))
p=998244353
r=range
f=[1]
for i in r(k):f+=[-~i*f[i]%p]
a=0
for i in r(n-1,k):a+=f[k-1]*pow(f[i]*f[k-1-i],-1,p)
print((a%p)) | n,k=list(map(int,input().split()))
p=998244353
r=range
f=[1]
for i in r(k):f+=[-~i*f[i]%p]
print((sum(f[k-1]*pow(f[i]*f[k-1-i],-1,p)for i in r(n-1,k))%p)) | p03431 |
def combs_mod(n,k,mod):
#nC0からnCkまで
inv = [1]*(k+1)
for i in range(1,k+1):
inv[i] = pow(i,mod-2,mod)
ans = [1]*(k+1)
for i in range(1,k+1):
ans[i] = ans[i-1]*(n+1-i)*inv[i]%mod
return ans
def solve():
mod = 998244353
N, K = list(map(int, input().split()))
ans = 0
if K<N:
return ans
com = combs_mod(K,K,mod)
com2 = combs_mod(K-1,K-1,mod)
for r in range(K+1):
b = K-r
dif = r-b
if dif<0 or r<N:
continue
elif dif==0:
ans += com2[r]
if N>=2:
ans -= com2[N-2]
elif dif<N:
ans += com[r] - com[N-1-dif]
else:
ans += com[r]
ans %= mod
return ans
print((solve())) | def combs_mod(n,k,mod):
#nC0からnCkまで
inv = [1]*(k+1)
for i in range(1,k+1):
inv[i] = pow(i,-1,mod)
ans = [1]*(k+1)
for i in range(1,k+1):
ans[i] = ans[i-1]*(n+1-i)*inv[i]%mod
return ans
def solve():
mod = 998244353
N, K = list(map(int, input().split()))
ans = 0
if K<N:
return ans
com = combs_mod(K,K,mod)
com2 = combs_mod(K-1,K-1,mod)
for r in range(K+1):
b = K-r
dif = r-b
if dif<0 or r<N:
continue
elif dif==0:
ans += com2[r]
if N>=2:
ans -= com2[N-2]
elif dif<N:
ans += com[r] - com[N-1-dif]
else:
ans += com[r]
ans %= mod
return ans
print((solve())) | p03431 |
m=998244353
def c(n,r):return (g[n]*h[r]*h[n-r])%m
g=[1,1]
h=g[:]
v=[0,1]
for i in range(2,999999):
g.append((g[-1]*i)%m)
v.append((-v[m%i]*(m//i))%m)
h.append((h[-1]*v[i])%m)
N,K=list(map(int,input().split()))
P=0
for k in range(N-1,K):P+=c(K-1,k)
print((P%m)) | m=998244353
def c(n,r):return (g[n]*h[r]*h[n-r])%m
g=[1,1]
h=g[:]
v=[0,1]
for i in range(2,999999):
g.append(g[-1]*i%m)
v.append(m//i*-v[m%i]%m)
h.append(h[-1]*v[i]%m)
N,K=list(map(int,input().split()))
P=0
for k in range(N-1,K):P+=c(K-1,k)
print((P%m)) | p03431 |
import sys
def solve():
a = int(eval(input()))
b = int(eval(input()))
if a == b:
print((1))
return
t = a ^ b
N = len(bin(t)) - 2
t = 1 << N
a = a & (t - 1)
b = b & (t - 1)
blen = len(bin(b)) - 2
sb = b & (2**(blen - 1) - 1)
if sb == 0:
sblen = 0
else:
sblen = len(bin(sb)) - 2
s = (1<<sblen) - 1
ymax = b | s
T = 1<<(N - 1)
ans = T - a
if ymax < T + a:
ans += ymax - T + 1 + T - a
else:
ans += T
print(ans)
if __name__ == '__main__':
solve() | import sys
def solve():
a = int(eval(input()))
b = int(eval(input()))
if a == b:
print((1))
return
t = a ^ b
N = bitlen(t)
a = a & (2**N - 1)
b = b & (2**N - 1)
blen = bitlen(b)
sb = b & (2**(blen - 1) - 1)
sblen = bitlen(sb)
s = 2**sblen - 1
ymax = b | s
T = 2**(N - 1)
ans = T - a
if ymax < T + a:
ans += ymax + 1 - a
else:
ans += T
print(ans)
def bitlen(x):
return 1 + bitlen(x >> 1) if x else 0
if __name__ == '__main__':
solve() | p03708 |
N, A, B =(int(x) for x in input().split())
print((min(A*N, B))) | N, A, B = list(map(int, input().split()))
print((min(A*N, B))) | p03501 |
import sys
import math
import collections
import itertools
import array
import inspect
# Set max recursion limit
sys.setrecursionlimit(10000)
# Debug output
def chkprint(*args):
names = {id(v):k for k,v in list(inspect.currentframe().f_back.f_locals.items())}
print((', '.join(names.get(id(arg),'???')+' = '+repr(arg) for arg in args)))
# Binary converter
def to_bin(x):
return bin(x)[2:]
# Set 2 dimension list
def dim2input(N):
li = []
for _ in range(N):
li.append(list(map(int, eval(input()))))
return li
# --------------------------------------------
dp = None
def main():
N, A, B = list(map(int, input().split()))
print((min(N*A, B)))
main()
| import sys
import math
import collections
import itertools
import array
import inspect
# Set max recursion limit
sys.setrecursionlimit(10000)
# Debug output
def chkprint(*args):
names = {
id(v): k
for k, v in list(inspect.currentframe().f_back.f_locals.items())
}
print((', '.join(
names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args)))
# Binary converter
def to_bin(x):
return bin(x)[2:]
def li_input():
return [int(_) for _ in input().split()]
# --------------------------------------------
dp = None
def main():
N, A, B = li_input()
print((min(N * A, B)))
main()
| p03501 |
a=input().split()
N=int(a[0])
A=int(a[1])
B=int(a[2])
if(N*A<=B):
print((N*A))
else:
print(B) | T,A,B = list(map(int,input().split()))
if(A*T<B):
print((A*T))
else:
print(B)
| p03501 |
N,A,B = list(map(int,input().split()))
print((min(N*A, B)))
| N,A,B = list(map(int,input().split()))
print((min(B,N*A))) | p03501 |
a, b, c = list(map(int, input().split()))
if a * b <= c:
print((a * b))
else:
print(c)
| a, b, c = list(map(int, input().split()))
print((min(a * b, c))) | p03501 |
N, A, B = list(map(int,input().split()))
a = A * N
if(a > B):
print(B)
else:
print(a) | N, A, B = list(map(int,input().split()))
print((min(N*A, B))) | p03501 |
i=list(map(int,input().split()))
a=i[0]
b=i[1]
def max(x,y,z):
if x>y:
m=x
else:
m=y
if z>m:
m=z
return m
ans=max(a+b,a-b,a*b)
print(ans) | a, b = list(map(int, input().split()))
print((max(a+b, a-b, a*b)))
#こぴぺ | p02945 |
a,b = list(map(int, input().split()))
print((max(a+b, a-b, a*b))) | a,b=list(map(int,input().split()))
print((max(a+b,max(a-b,a*b)))) | p02945 |
temp=list(map(int, input().split()))
print((max([temp[0]+temp[1], temp[0]-temp[1], temp[0]*temp[1]]))) | A, B= list(map(int, input().split()))
c= A+B
d= A-B
e= A*B
f=max(c, d, e)
print(f) | p02945 |
a = list(map(int,input().split()))
x = a[0] + a[1]
y = a[0] - a[1]
z = a[0] * a[1]
if x >= y and x >= z:
print(x)
elif y >= x and y >= z:
print(y)
else:
print(z)
| a = list(map(int,input().split()))
x = a[0] + a[1]
y = a[0] - a[1]
z = a[0] * a[1]
print((max([x,y,z])))
| p02945 |
import time
time.sleep(3)
a, b = list(map(int, input().split()))
print((max(a + b, a - b, a * b))) | import time
time.sleep(0.5)
a, b = list(map(int, input().split()))
print((max(a + b, a - b, a * b))) | p02945 |
a,b= list(map(int,input().split()))
print((max((a+b,a-b,a*b))))
| a,b= list(map(int,input().split()))
print((max(a+b,a-b,a*b)))
| p02945 |
# coding: utf-8
# Your code here!
A,B = list(map(int,input().split()))
C = A+B
D = A-B
E = A*B
print((max([C,D,E])))
| A,B = list(map(int, input().split()))
print((max(A*B,A-B,A+B))) | p02945 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.