input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce, lru_cache
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N = INT()
A = LIST()
L = [[x, i] for i, x in enumerate(A)]
L.sort()
@lru_cache(maxsize=None)
def rec(l, r):
if l > r:
return 0
idx = r-l # 次に選ぶ幼児
val, i = L[idx]
ret = max(abs(i-l)*val + rec(l+1, r), abs(r-i)*val + rec(l, r-1))
return ret
print((rec(0, N-1)))
| import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N = INT()
A = LIST()
L = [[x, i] for i, x in enumerate(A)]
L.sort()
dp = [[-1]*N for _ in range(N)]
def rec(l, r):
if l > r:
return 0
if dp[l][r] >= 0:
return dp[l][r]
idx = r-l # 次に選ぶ幼児
val, i = L[idx]
dp[l][r] = max(abs(i-l)*val + rec(l+1, r), abs(r-i)*val + rec(l, r-1))
return dp[l][r]
print((rec(0, N-1)))
| p02709 |
n = int(eval(input()))
a = list(map(int,input().split()))
ans = [[0 for i in range(n+1)] for j in range(n+1)]
p = []
for i in range(n):
p.append([a[i],i])
p.sort(reverse=True)
for i in range(1,n+1):
ans[0][i] = ans[0][i-1] + p[i-1][0]*abs(p[i-1][1]-i+1)
for i in range(1,n+1):
ans[i][0] = ans[i-1][0] + p[i-1][0]*abs(n-i-p[i-1][1])
for i in range(1,n):
for j in range(1,n-i+1):
ans[i][j] = max(ans[i][j-1] + p[i+j -1][0]*abs(p[i+j -1][1]-j+1),
ans[i-1][j] + p[i+j - 1][0]*abs(n-i-p[i+j-1][1]))
ma = 0
for i in range(n):
ma = max(ma,ans[0+i][n-i])
print(ma) | #pythonじゃ通らなかった…(´・ω・`)
n = int(eval(input()))
a = list(map(int,input().split()))
ans = [[0 for i in range(n+1)] for j in range(n+1)]
p = []
#それぞれの活発度と元々居た位置の記録
for i in range(n):
p.append([a[i],i])
p.sort(reverse=True)
#活発度の高い順にそれぞれ左と右から詰めて並べていく時のうれしさの変化
for i in range(1,n+1):
ans[0][i] = ans[0][i-1] + p[i-1][0]*abs(p[i-1][1]-i+1)
for i in range(1,n+1):
ans[i][0] = ans[i-1][0] + p[i-1][0]*abs(n-i-p[i-1][1])
#Douteki Planning 活発度の高い順に左にi人、右にj人詰めて並べていった時の最大値
for i in range(1,n):
for j in range(1,n-i+1):
ans[i][j] = max(ans[i][j-1] + p[i+j -1][0]*abs(p[i+j -1][1]-j+1),
ans[i-1][j] + p[i+j - 1][0]*abs(n-i-p[i+j-1][1]))
#全て詰め並べ終わったときのうれしさの最大値(=答え)を探す
ma = 0
for i in range(n):
ma = max(ma,ans[0+i][n-i])
print(ma) | p02709 |
#!python3
import sys
sys.setrecursionlimit(1000000000)
from functools import lru_cache
iim = lambda: list(map(int, input().rstrip().split()))
def resolve():
N = int(eval(input()))
A = list(enumerate(iim()))
A.sort(key=lambda x: x[1], reverse=True)
@lru_cache
def rec(i, j1, j2):
if i == N:
return 0
pos, ai = A[i]
ax = abs(pos - j1) * ai + rec(i+1, j1+1, j2)
bx = abs(pos - j2) * ai + rec(i+1, j1, j2-1)
return max(ax, bx)
print((rec(0, 0, N-1)))
if __name__ == "__main__":
resolve()
| #!python3
iim = lambda: list(map(int, input().rstrip().split()))
def resolve():
N = int(eval(input()))
A = list(enumerate(iim()))
A.sort(key=lambda x: (x[1], (2*x[0]-N)**2), reverse=True)
dp = [0] * (N+1)
dp0 = dp[:]
for i, (j, ai) in enumerate(A):
for k in range(i+1):
dp[k] = max(dp[k], dp0[k] + abs(N-i+k-1-j) * ai)
dp[k+1] = max(dp[k+1], dp0[k] + abs(k-j) * ai)
dp, dp0 = dp0, dp
print((max(dp0)))
if __name__ == "__main__":
resolve()
| p02709 |
N = int(eval(input()))
D = []
for i, a in enumerate(map(int, input().split())):
D.append((a<<11) + i)
D.sort(reverse=True)
dp = [0]*(N+1)
for i, d in enumerate(D,start=1):
x, a = d%(1<<11),d>>11
for j in reversed(list(range(0, i+1))):
dp[j] = max((dp[j-1]+a*abs(x-(j-1)))*(j-1>=0), (dp[j]+a*abs(N-(i-j)-x))*(j<=i-1))
print((max(dp))) | N = int(eval(input()))
D = []
for i, a in enumerate(map(int, input().split())):
D.append((a<<11) + i)
D.sort(reverse=True)
dp = [0]*(N+1)
for i, d in enumerate(D,start=1):
x, a = d%(1<<11),d>>11
for j in reversed(list(range(0, i+1))):
dp[j] = max((dp[j-1]+a*(x-(j-1)))*(j-1>=0), (dp[j]+a*(N-(i-j)-x))*(j<=i-1))
print((max(dp))) | p02709 |
N = int(eval(input()))
D = []
for i, a in enumerate(map(int, input().split())):
D.append((a<<11) + i)
D.sort(reverse=True)
dp = [0]*(N+1)
for i, d in enumerate(D,start=1):
x, a = d%(1<<11),d>>11
for j in reversed(list(range(0, i+1))):
res1 = dp[j-1]+a*(x-(j-1))*(j-1>=0)
res2 = dp[j]+a*(N-(i-j)-x)*(j<=i-1)
if res1>=res2: dp[j] = res1
else: dp[j] = res2
print((max(dp))) | N = int(eval(input()))
D = []
for i, a in enumerate(map(int, input().split())):
D.append((a<<11) + i)
D.sort(reverse=True)
dp = [0]*(N+1)
for i, d in enumerate(D,start=1):
x, a = d%(1<<11),d>>11
for j in reversed(list(range(i))):
dp[j+1] = max(dp[j] + a*(x-j), dp[j+1])
dp[j] += a*(N-(i-j)-x)
print((max(dp))) | p02709 |
N = int(eval(input()))
a = list(map(int, input().split()))
A =[]
for i in range(N):
A.append([i+1,a[i]])
A.sort(key=lambda x: x[1], reverse=True)
dp = [[0] * (N+1) for i in [1] * (N+1)]
for i in range(N+1):
for x in range(i+1):
y = i - x
if x == 0 and y == 0:
dp[x][y] = 0
elif x == 0:
dp[x][y] = dp[x][y-1] + A[y-1][1]*((N-y+1) - (A[y-1][0]))
elif y == 0:
dp[x][y] = dp[x-1][y] + A[x-1][1]*((A[x-1][0]) - x )
else:
dp[x][y] = max(dp[x][y-1] + A[x+y-1][1]*((N-y+1) - (A[x+y-1][0])) , dp[x-1][y] + A[x+y-1][1]*((A[x+y-1][0]) - x ))
ans = 0
for x in range(N+1):
y = N - x
ans = max(ans,dp[x][y])
print(ans) | N = int(eval(input()))
a = list(map(int, input().split()))
A =[]
for i in range(N):
A.append([i+1,a[i]])
A.sort(key=lambda x: x[1], reverse=True)
dp = []
for i in range(N+1,-1,-1):
dp.append([0] * (i+1))
for i in range(N+1):
for x in range(i+1):
y = i - x
if x == 0 and y == 0:
dp[x][y] = 0
elif x == 0:
dp[x][y] = dp[x][y-1] + A[y-1][1]*((N-y+1) - (A[y-1][0]))
elif y == 0:
dp[x][y] = dp[x-1][y] + A[x-1][1]*((A[x-1][0]) - x )
else:
dp[x][y] = max(dp[x][y-1] + A[x+y-1][1]*((N-y+1) - (A[x+y-1][0])) , dp[x-1][y] + A[x+y-1][1]*((A[x+y-1][0]) - x ))
ans = 0
for x in range(N+1):
y = N - x
ans = max(ans,dp[x][y])
print(ans) | p02709 |
N = int(eval(input()))
_L = list(map(int,input().split()))
L =[(v,i) for i,v in enumerate(_L)]
L = sorted(L,key = lambda x:(-x[0],-x[1]))
dp = [[0]*(N+1) for _ in range(N+1)]
for i in range(N):#i番目の数字まで見た
for k in range(N):#k回(i-pi)のパターン
if k>i:
continue
val,ind = L[i]
dp[i+1][k+1] = max(dp[i+1][k+1],dp[i][k] + val * abs(ind-k))#先頭からk番目に動かす
dp[i+1][k] = max(dp[i+1][k],dp[i][k]+val * abs(N-1-(i-k)-ind))#すでに後ろからi-k個は使ってる=>後ろからN- (i-k)+1番目に動かす
print((max(dp[-1])))
| N = int(eval(input()))
_L = list(map(int,input().split()))
L =[(v,i) for i,v in enumerate(_L)]
L = sorted(L,key = lambda x:(-x[0],x[1]))
dp = [[0]*(N+1) for _ in range(N+1)]
for i in range(N):#i番目の数字まで見た
for k in range(N):#k回(i-pi)のパターン
if k>i:
continue
val,ind = L[i]
dp[i+1][k+1] = max(dp[i+1][k+1],dp[i][k] + val * abs(ind-k))#先頭からk番目に動かす
dp[i+1][k] = max(dp[i+1][k],dp[i][k]+val * abs(N-1-(i-k)-ind))#すでに後ろからi-k個は使ってる=>後ろからN- (i-k)+1番目に動かす
print((max(dp[-1])))
| p02709 |
N = int(eval(input()))
A = [(a, i) for i, a in enumerate(map(int, input().split()), start=1)]
A.sort(reverse=True)
dp = [[0] * (N + 1) for _ in range(N + 1)]
for s, (a, i) in enumerate(A):
for l in range(s + 1):
r = s - l
dp[l + 1][r] = max(dp[l + 1][r], dp[l][r] + a * (i - (l + 1)))
dp[l][r + 1] = max(dp[l][r + 1], dp[l][r] + a * (N - r - i))
ans = max([max(d) for d in dp])
print(ans)
| N = int(eval(input()))
A = [(a, i) for i, a in enumerate(map(int, input().split()), start=1)]
A.sort(reverse=True)
dp = [[0] * (N + 1) for _ in range(N + 1)]
for s, (a, i) in enumerate(A):
for l in range(s + 1):
r = s - l
dp[l + 1][r] = max(dp[l + 1][r], dp[l][r] + a * (i - (l + 1)))
dp[l][r + 1] = max(dp[l][r + 1], dp[l][r] + a * (N - r - i))
ans = 0
for i in range(N + 1):
ans = max(ans, dp[i][N - i])
print(ans)
| p02709 |
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
return [ int(input()) for _ in range(n)]
# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
return map(int, open(0).read().split())
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
n,*A = get_all_int()
# dp[i][j] = 活発度高い順のi人目まで処理し、左にjに置いた場合のうれしさの最大
dp = [ [0] * (n+1) for _ in range(n+1) ]
AA = list(enumerate(A))
AA.sort(key=(lambda t: t[1]), reverse=True)
for i, t in enumerate(AA):
# k 移動前の位置
# a 活発度
k,a = t
for j in range(i+1):
# 左に置く (すでに左端にj人居る)
move = abs(k - j)
dp[i+1][j+1] = max(dp[i+1][j+1], dp[i][j] + a*move)
# 右に置く (すでに右端にi-j人居る)
move = abs(k - (n-(i-j)-1))
dp[i+1][j] = max(dp[i+1][j], dp[i][j] + a*move)
ans = 0
for j in range(n+1):
ans = max(ans, dp[n][j])
# left = 0
# right = n-1
# AA = list(enumerate(A))
# AA.sort(key=(lambda t: t[1]), reverse=True)
# ans = 0
# for i,a in AA:
# log(i,a)
# l = abs(left-i)
# r = abs(right-i)
# if l > r:
# log(f" {i}->{left}, ", a*l)
# ans += a * l
# left += 1
# else:
# log(f" {i}->{right}, ", a*r)
# ans += a * r
# right -= 1
print(ans)
| # 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
return list(map(int, open(0).read().split()))
n,*A = get_all_int()
# dp[i][j] = 活発度高い順のi人目まで処理し、左にjに置いた場合のうれしさの最大
dp = [ [0] * (n+1) for _ in range(n+1) ]
AA = list(enumerate(A))
AA.sort(key=(lambda t: t[1]), reverse=True)
for i, t in enumerate(AA):
# k 移動前の位置
# a 活発度
k,a = t
for j in range(i+1):
# 左に置く (すでに左端にj人居る)
move = abs(k - j)
dp[i+1][j+1] = max(dp[i+1][j+1], dp[i][j] + a*move)
# 右に置く (すでに右端にi-j人居る)
move = abs(k - (n-(i-j)-1))
dp[i+1][j] = max(dp[i+1][j], dp[i][j] + a*move)
ans = 0
for j in range(n+1):
ans = max(ans, dp[n][j])
print(ans)
| p02709 |
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
from collections import defaultdict
def resolve():
N = ir()
A = sorted([[i+1, d] for i, d in enumerate(lr())], key=lambda x: x[1])[::-1]
dp = defaultdict(lambda: -float('inf'))
dp[0, 0] = 0
for s in range(1, N+1):
for x in range(s):
for y in range(s-x):
i, d = A[x+y]
dp[x+1, y] = max(dp[x, y]+d*(i-x-1), dp[x+1, y])
dp[x, y+1] = max(dp[x, y]+d*(N-y-i), dp[x, y+1])
ans = 0
for i in range(N+1):
ans = max(ans, dp[i, N-i])
print(ans)
resolve() | import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
from collections import defaultdict
def resolve():
N = ir()
A = sorted([[i+1, d] for i, d in enumerate(lr())], key=lambda x: x[1])[::-1]
dp = defaultdict(lambda: -float('inf'))
dp[0, 0] = 0
for x in range(N):
for y in range(N-x):
i, d = A[x+y]
dp[x+1, y] = max(dp[x, y]+d*(i-x-1), dp[x+1, y])
dp[x, y+1] = max(dp[x, y]+d*(N-y-i), dp[x, y+1])
ans = 0
for i in range(N+1):
ans = max(ans, dp[i, N-i])
print(ans)
resolve() | p02709 |
# -*- coding: utf-8 -*-
N=int(eval(input()))
As=list(map(int, input().split()))
inds=sorted(list(range(len(As))), key=lambda k: As[k])[::-1]
ds=[[0 for j in range(N+1-i)] for i in range(N+1)]
ds[0][0]=0
for i in range(1,N+1):
ds[i][0]=ds[i-1][0]+As[inds[i-1]]*(inds[i-1]-(i-1))
ds[0][i]=ds[0][i-1]+As[inds[i-1]]*(N-i-inds[i-1])
for xy in range(2,N+1):
for x in range(1,xy):
y=xy-x
c1=ds[x-1][y]+As[inds[xy-1]]*(inds[xy-1]-(x-1))
c2=ds[x][y-1]+As[inds[xy-1]]*(N-y-inds[xy-1])
ds[x][y]=max(c1,c2)
ans=0
for x in range(0,N+1):
y=N-x
c=ds[x][y]
ans=max((c,ans))
print(ans)
#print(ds)
#print(inds)
|
# -*- coding: utf-8 -*-
N=int(eval(input()))
As=list(map(int, input().split()))
inds=sorted(list(range(len(As))), key=lambda k: As[k])[::-1]
#ds=[[0 for j in range(N+1-i)] for i in range(N+1)]
ds=[0]
for xy in range(1,N+1):
nds=[0]*(xy+1)
nds[-1]=ds[-1]+As[inds[xy-1]]*(inds[xy-1]-(xy-1))
nds[0]=ds[0]+As[inds[xy-1]]*(N-xy-inds[xy-1])
for x in range(1,xy):
y=xy-x
c1=ds[x-1]+As[inds[xy-1]]*abs(inds[xy-1]-(x-1))
c2=ds[x]+As[inds[xy-1]]*abs(N-y-inds[xy-1])
nds[x]=max(c1,c2)
ds=nds.copy()
#print(ds)
print((max(ds)))
#print(ds)
#print(inds)
| p02709 |
# -*- coding: utf-8 -*-
N=int(eval(input()))
As=list(map(int, input().split()))
inds=sorted(list(range(len(As))), key=lambda k: As[k])[::-1]
#ds=[[0 for j in range(N+1-i)] for i in range(N+1)]
ds=[0]
for xy in range(1,N+1):
nds=[0]*(xy+1)
nds[-1]=ds[-1]+As[inds[xy-1]]*(inds[xy-1]-(xy-1))
nds[0]=ds[0]+As[inds[xy-1]]*(N-xy-inds[xy-1])
for x in range(1,xy):
y=xy-x
c1=ds[x-1]+As[inds[xy-1]]*abs(inds[xy-1]-(x-1))
c2=ds[x]+As[inds[xy-1]]*abs(N-y-inds[xy-1])
nds[x]=max(c1,c2)
ds=nds.copy()
#print(ds)
print((max(ds)))
#print(ds)
#print(inds)
|
# -*- coding: utf-8 -*-
N=int(eval(input()))
As=list(map(int, input().split()))
inds=sorted(list(range(len(As))), key=lambda k: As[k])[::-1]
#ds=[[0 for j in range(N+1-i)] for i in range(N+1)]
ds=[0]
for xy in range(1,N+1):
i=inds[xy-1]
a=As[i]
nds=[0]*(xy+1)
nds[-1]=ds[-1]+a*(i-(xy-1))
nds[0]=ds[0]+a*(N-xy-i)
for x in range(1,xy):
y=xy-x
c1=ds[x-1]+a*abs(i-(x-1))
c2=ds[x]+a*abs(N-y-i)
nds[x]=max(c1,c2)
ds=nds.copy()
#print(ds)
print((max(ds)))
#print(ds)
#print(inds)
| p02709 |
import sys
from functools import lru_cache
sys.setrecursionlimit(2 * 10 ** 5)
N = int(eval(input()))
A = [int(x) for x in input().split()]
A = sorted((a, i) for i, a in enumerate(A))
@lru_cache(maxsize=None)
def dp(l, r):
if l > r:
return 0
a, x = A[r - l]
return max(a * abs(x - l) + dp(l + 1, r), a * abs(x - r) + dp(l, r - 1))
print((dp(0, N - 1))) | import sys
sys.setrecursionlimit(2 * 10 ** 5)
N = int(eval(input()))
A = [int(x) for x in input().split()]
A = sorted((a, i) for i, a in enumerate(A))
cache = [[None for i in range(N + 1)] for j in range(N + 1)]
def dp(l, r):
if l > r:
return 0
if cache[l][r] is None:
a, x = A[r - l]
cache[l][r] = max(a * abs(x - l) + dp(l + 1, r), a * abs(x - r) + dp(l, r - 1))
return cache[l][r]
print((dp(0, N - 1)))
| p02709 |
import sys
input = lambda : sys.stdin.readline().rstrip()
n = int(eval(input()))
a = list(map(int, input().split()))
a = [(item, i) for i,item in enumerate(a)]
s = sorted(a)[::-1] # (value, index)
dp = [[None] * (n+1) for _ in range(n+1)] # 高い方からx+y人について、a_i * (p_i - i) + a_i * (i - p_i) の和の最大値
dp[0][0] = 0
tmp = 0
# dp[x][y] : 右にx個、左にy個
for i in range(n):
val, ind = s[i]
dp[i+1][0] = dp[i][0] + val * ((n-i-1) - ind)
for i in range(n):
val, ind = s[i]
dp[0][i+1] = dp[0][i] + val * (ind - i)
for i in range(2,n+1):
for x in range(1,i):
y = i - x
val, ind = s[i-1]
v1 = dp[x-1][y] + val * ((n-1 - (x-1)) - ind)
v2 = dp[x][y-1] + val * (ind - (y-1))
dp[x][y] = max(v1, v2)
print((max((dp[x][n-x] for x in range(n+1))))) | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n = int(eval(input()))
a = list(map(int, input().split()))
a = [(num,i) for i,num in enumerate(a)]
a.sort(reverse=True)
dp = [[0]*(n+1) for _ in range(n+1)]
for i in range(n+1):
for j in range(n-i+1):
if i>0:
dp[i][j] = max(dp[i][j], dp[i-1][j] + a[i+j-1][0]*abs(a[i+j-1][1]-(i-1)))
if j>0:
dp[i][j] = max(dp[i][j], dp[i][j-1] + a[i+j-1][0]*abs(a[i+j-1][1]-(n-j)))
ans = max(dp[i][n-i] for i in range(n+1))
print(ans) | p02709 |
N=int(eval(input()))
A=list(map(int,input().split()))
L=[]
for i in range(N):
L.append([A[i],i])
#print(L)
ans=0
import copy
from collections import deque
for i in range(1,N):
cnt=0
a=copy.deepcopy(L[:i])
b=copy.deepcopy(L[i:])
#print(a,b)
a.sort(reverse=True)
b.sort(reverse=True)
#print("ab",a,b)
A=deque([N-len(a)+j for j in range(len(a)) ])
B=deque([j for j in range(len(b))])
#print(A)
#print(B)
for j in range(len(a)):
if abs(a[j][0]*(a[j][1]-A[0]))>abs(a[j][0]*(a[j][1]-A[-1])):
cnt+=abs(a[j][0]*(a[j][1]-A[0]))
A.popleft()
else:
cnt+=abs(a[j][0]*(a[j][1]-A[-1]))
A.pop()
#print("A",cnt)
for j in range(len(b)):
if abs(b[j][0]*(b[j][1]-B[0]))>abs(b[j][0]*(b[j][1]-B[-1])):
cnt+=abs(b[j][0]*(b[j][1]-B[0]))
B.popleft()
else:
cnt+=abs(b[j][0]*(b[j][1]-B[-1]))
B.pop()
#print(cnt)
if ans<cnt:
ans=cnt
print(ans)
| N=int(eval(input()))
A=list(map(int,input().split()))
L=[[10**10,0]]
for i in range(N):
L.append([A[i],i])
L.sort(reverse=True)
#print(L)
DP=[[0 for i in range(N+1)]for j in range(N+1)]
#j=右に押し込んだ数
for i in range(1,N+1):
for j in range(i+1):
if j==0:
DP[i][j]=DP[i-1][j]+L[i][0]*abs(L[i][1]-(i-1))
#print(DP,DP[i-1][j]+L[i][0]*abs(L[i][1]-(i-1)))
elif j==i:
DP[i][j]=DP[i-1][j-1]+L[i][0]*abs(L[i][1]-(N-j))
#print(DP,DP[i-1][j-1]+L[i][0]*abs(L[i][1]-(N-j)))
else:
DP[i][j]=max(DP[i-1][j]+L[i][0]*abs(L[i][1]-(i-1-j)),DP[i-1][j-1]+L[i][0]*abs(L[i][1]-(N-j)))
#print(DP,DP[i-1][j]+L[i][0]*abs(L[i][1]-(i-1-j)),DP[i-1][j-1]+L[i][0]*abs(L[i][1]-(N-j)))
print((max(DP[-1]))) | p02709 |
#!/usr/bin/env python3
import sys
def solve(N: int, A: "List[int]"):
A_ = []
indices = []
tmp = sorted(enumerate(A), reverse=True, key=lambda x:x[1])
for row in tmp:
k, v = row
indices.append(k)
A_.append(v)
A = A_
dp = [[0 for i in range(N+1)] for j in range(N+1)]
for i in range(N):
for j in range(0, N-i):
a = A[i+j]
idx = indices[i+j]
dp[i+1][j] = max(dp[i+1][j], dp[i][j] + a * abs(idx - i))
dp[i][j+1] = max(dp[i][j+1], dp[i][j] + a * abs(N - 1 - j - idx))
result = -1
for i in range(N):
tmp = dp[i][N-i]
if tmp > result:
result = tmp
print(result)
return
# Generated by 1.1.6 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()
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
def solve(N: int, A: "List[int]"):
A = sorted(enumerate(A), reverse=True, key=lambda x: x[1])
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
for i in range(N):
for j in range(0, N - i):
idx, a = A[i + j]
#idx = indices[i + j]
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + a * abs(idx - i))
dp[i][j + 1] = max(dp[i][j + 1], dp[i][j] + a * abs(N - 1 - j - idx))
result = -1
for i in range(N):
tmp = dp[i][N - i]
if tmp > result:
result = tmp
print(result)
return
# Generated by 1.1.6 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()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A)
if __name__ == '__main__':
main()
| p02709 |
# from pprint import pprint
n = int(eval(input()))
a = list(map(int, input().split()))
a = sorted(((ax, x) for x, ax in enumerate(a)), reverse=True)
dp = [[-1] * (n+1) for _ in range(n+1)]
dp[0][0] = 0
for i, (ax, x) in enumerate(a):
for j in range(i+1):
dp[j+1][i-j] = max(dp[j+1][i-j], dp[j][i-j] + ax*abs(x-j))
dp[j][i-j+1] = max(dp[j][i-j+1], dp[j][i-j] + ax*abs(n-1-x-i+j))
# pprint(dp)
print((max(dp[i][n-i] for i in range(n+1))))
| # from pprint import pprint
n = int(eval(input()))
a = list(map(int, input().split()))
a = sorted(((ax, x) for x, ax in enumerate(a)), reverse=True)
dp = [[-1] * (n+1) for _ in range(n+1)]
dp[0][0] = 0
for i, (ax, x) in enumerate(a):
for j in range(i+1):
dp[j+1][i-j] = max(dp[j+1][i-j], dp[j][i-j] + ax*abs(x-j))
dp[j][i-j+1] = max(dp[j][i-j+1], dp[j][i-j] + ax*abs(n-1-x-i+j))
# pprint(dp)
print((max(dp[i][n-i] for i in range(n+1))))
| p02709 |
n = int(eval(input()))
a = list(map(int, input().split()))
b = []
for i, v in enumerate(a):
b.append([v, i])
b.sort(reverse = True)
dp = [[0] * (n+1) for _ in range(n+1)]
ans = 0
for i in range(n+1):
for j in range(n+1-i):
if i > 0:
dp[i][j] = max(dp[i][j], dp[i-1][j] + b[i+j-1][0] * (b[i+j-1][1] - (i - 1)))
if j > 0:
dp[i][j] = max(dp[i][j], dp[i][j-1] + b[i+j-1][0] * ((n - j) - b[i+j-1][1]))
for i in range(n+1):
ans = max(ans, dp[i][n-i])
print(ans) | import sys
input = sys.stdin.buffer.readline
n = int(eval(input()))
a = list(map(int, input().split()))
b = []
for i, v in enumerate(a):
b.append([v, i])
b.sort(reverse = True)
dp = [[0] * (n+1) for _ in range(n+1)]
ans = 0
for i in range(n+1):
for j in range(n+1-i):
if i > 0:
dp[i][j] = max(dp[i][j], dp[i-1][j] + b[i+j-1][0] * (b[i+j-1][1] - (i - 1)))
if j > 0:
dp[i][j] = max(dp[i][j], dp[i][j-1] + b[i+j-1][0] * ((n - j) - b[i+j-1][1]))
for i in range(n+1):
ans = max(ans, dp[i][n-i])
print(ans) | p02709 |
n,*a=list(map(int,open(0).read().split()))
dp=[[0]*(n+1)for _ in range(n+1)]
for t,(c,k) in enumerate(sorted((c,k) for k,c in enumerate(a))[::-1]):
for i in range(t+1):
j=t-i
if dp[i+1][j]<=(s:=dp[i][j]+c*abs(i-k)):dp[i+1][j]=s
if dp[i][j+1]<=(s:=dp[i][j]+c*abs(n-1-k-j)):dp[i][j+1]=s
print((max(dp[i][~i]for i in range(n+1)))) | n,*a=list(map(int,open(0).read().split()))
dp=[[0]*(n+1)for _ in range(n+1)]
for t,(c,k) in enumerate(sorted((c,k) for k,c in enumerate(a))[::-1]):
for i in range(t+1):
j=t-i
if dp[i+1][j]<dp[i][j]+c*abs(i-k):dp[i+1][j]=dp[i][j]+c*abs(i-k)
if dp[i][j+1]<dp[i][j]+c*abs(n-1-k-j):dp[i][j+1]=dp[i][j]+c*abs(n-1-k-j)
print((max(dp[i][~i]for i in range(n+1)))) | p02709 |
#!python3
# input
N = int(eval(input()))
A = list(map(int, input().split()))
def main():
P = [(A[i], i + 1) for i in range(N)]
P.sort(reverse=True)
dp = [[0] * (N + 1) for _ in range(N + 1)]
for n, p in zip(list(range(1, N + 1)), P):
for i in range(n):
j = n - 1 - i
left = dp[i][j] + p[0] * abs(p[1] - (i + 1))
dp[i + 1][j] = max(dp[i + 1][j], left)
right = dp[i][j] + p[0] * abs(p[1] - (N - j))
dp[i][j + 1] = max(dp[i][j + 1], right)
ans = max([dp[i][N - i] for i in range(N)])
print(ans)
if __name__ == "__main__":
main()
| #!python3
# input
N = int(eval(input()))
A = list(map(int, input().split()))
# N = 2000
# A = [i for i in range(1, N + 1)]
def main():
P = [(A[i], i + 1) for i in range(N)]
P.sort(reverse=True)
dp = [[0] * (N + 1) for _ in range(N + 1)]
for n, p in zip(list(range(1, N + 1)), P):
x, y = p
for i in range(n):
j = n - 1 - i
left = dp[i][j] + x * abs(y - (i + 1))
dp[i + 1][j] = max(dp[i + 1][j], left)
right = dp[i][j] + x * abs(y - (N - j))
dp[i][j + 1] = max(dp[i][j + 1], right)
ans = max([dp[i][N - i] for i in range(N)])
print(ans)
if __name__ == "__main__":
main()
| p02709 |
N = int(eval(input()))
A = list(map(int, input().split()))
B = [[i, a] for i, a in enumerate(A)]
C = sorted(B, key=lambda b: b[1], reverse=True)
l = 0
r = N - 1
ans = 0
queue = [[C, l, r, 0]]
while queue:
D, l, r, total = queue.pop()
total2 = total + abs(D[0][0] - l) * D[0][1]
if len(D) == 1:
ans = max(ans, total2)
continue
else:
queue.append([D[1:], l+1, r, total2])
total2 = total + abs(D[0][0] - r) * D[0][1]
if len(D) == 1:
ans = max(ans, total2)
continue
else:
queue.append([D[1:], l, r-1, total2])
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
B = [[i, a] for i, a in enumerate(A)]
C = sorted(B, key=lambda b: b[1], reverse=True)
dp = [[-1 for _ in range(N + 1)] for _ in range(N + 1)]
dp[1][0] = (C[0][0] - 0) * C[0][1]
dp[0][1] = ((N - 1) - C[0][0]) * C[0][1]
ans = 0
for i in range(2, N + 1):
for j in range(0, i + 1):
t1, t2 = 0, 0
if j - 1 >= 0:
t1 = dp[j - 1][i - j] + abs((C[i - 1][0] - (j - 1))) * C[i - 1][1]
if i - j - 1 >= 0:
t2 = dp[j][i - j - 1] + abs((C[i - 1][0] - (N - (i - j)))) * C[i - 1][1]
dp[j][i - j] = max(t1, t2)
if i == N:
ans = max(ans, dp[j][i - j])
print(ans)
| p02709 |
import sys,math,copy,queue,itertools,bisect
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
data = [[a,i] for i,a in enumerate(LI())]
data.sort(reverse=True)
dp = [[0 for _ in range(N+1)] for _ in range(N+1)]
for i in range(N):
a, p = data[i]
for j in range(i+1):
dp[i+1][j+1] = max(dp[i+1][j+1],dp[i][j] + abs(N-1-j-p)*a)
dp[i+1][j] = max(dp[i+1][j], dp[i][j] + abs(i-j-p)*a)
print((max(dp[-1])))
| import sys
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
data = [(a,i) for i,a in enumerate(LI())]
data.sort(reverse=True)
dp = [[0] * (N+1) for _ in range(N+1)]
for i in range(N):
a, p = data[i]
for j in range(i+1):
dp[i+1][j+1] = max(dp[i+1][j+1],dp[i][j] + abs(N-1-j-p)*a)
dp[i+1][j] = max(dp[i+1][j], dp[i][j] + abs(i-j-p)*a)
print((max(dp[-1])))
| p02709 |
import sys
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
data = [(a,i) for i,a in enumerate(LI())]
data.sort(reverse=True)
dp = [[0] * (N+1) for _ in range(N+1)]
for i in range(N):
a, p = data[i]
for j in range(i+1):
dp[i+1][j+1] = max(dp[i+1][j+1],dp[i][j] + abs(N-1-j-p)*a)
dp[i+1][j] = max(dp[i+1][j], dp[i][j] + abs(i-j-p)*a)
print((max(dp[-1])))
| import sys
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
data = [[a,i] for i,a in enumerate(LI())]
data.sort(reverse=True)
dp = [[0] * (N+1) for _ in range(N+1)]
for i in range(N):
a, p = data[i]
for j in range(i+1):
dp[i+1][j+1] = max(dp[i+1][j+1],dp[i][j] + abs(N-1-j-p)*a)
dp[i+1][j] = max(dp[i+1][j], dp[i][j] + abs(i-j-p)*a)
print((max(dp[-1])))
| p02709 |
from collections import defaultdict
n=int(eval(input()))
a_=list(map(int,input().split()))
#n=4
#a_=[1,3,4,2]
a=[]
for i,ai in enumerate(a_):
a.append([1+i,ai])
a.sort(key=lambda x:x[1],reverse=True)
dp=defaultdict(lambda:0)
dp[(0,1)]=max(a[0][1]*(n-a[0][0]),0)
dp[(1,0)]=max(a[0][1]*(a[0][0]-1),0)
for i in range(2,n+1):#i人目の幼児。a[i-1]
for x in range(i+1):
y=i-x
if x==0:
dp[(x,y)]=dp[(x,y-1)]+a[i-1][1]*(n-a[i-1][0]-(y-1))
elif y==0:
dp[(x,y)]=dp[(x-1,y)]+a[i-1][1]*(a[i-1][0]-1-(x-1))
else:
dp[(x,y)]=max(dp[(x-1,y)]+a[i-1][1]*(a[i-1][0]-1-(x-1)),dp[(x,y-1)]+a[i-1][1]*(n-a[i-1][0]-(y-1)))
ans=0
for i in range(n+1):
ans=max(ans,dp[(i,n-i)])
print(ans)
| from collections import defaultdict
n=int(eval(input()))
a_=list(map(int,input().split()))
a=[]
for i,ai in enumerate(a_):
a.append([1+i,ai])
a.sort(key=lambda x:x[1],reverse=True)
dp=defaultdict(lambda:0)
dp[(0,1)]=max(a[0][1]*(n-a[0][0]),0)
dp[(1,0)]=max(a[0][1]*(a[0][0]-1),0)
for i in range(2,n+1):#i人目の幼児。a[i-1]
for x in range(i+1):
y=i-x
if x==0:
dp[(x,y)]=dp[(x,y-1)]+a[i-1][1]*(n-a[i-1][0]-(y-1))
elif y==0:
dp[(x,y)]=dp[(x-1,y)]+a[i-1][1]*(a[i-1][0]-1-(x-1))
else:
dp[(x,y)]=max(dp[(x-1,y)]+a[i-1][1]*(a[i-1][0]-1-(x-1)),dp[(x,y-1)]+a[i-1][1]*(n-a[i-1][0]-(y-1)))
ans=0
for i in range(n+1):
ans=max(ans,dp[(i,n-i)])
print(ans)
| p02709 |
#!/usr/bin/env python3
import sys, math, itertools, collections, bisect, heapq
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
n = int(eval(input()))
A = list(map(int,input().split()))
data = [(a,i) for i,a in enumerate(A)]
data.sort(reverse = True)
dp = [[0] * (n+1) for i in range(n+1)]
for i in range(n):
for l in range(i+1):
r = i-l
dp[l+1][r] = max(dp[l+1][r], dp[l][r] + data[i][0] * abs(data[i][1] - l))
dp[l][r+1] = max(dp[l][r+1], dp[l][r] + data[i][0] * abs(data[i][1]-(n-1-r)))
ans = 0
for i in range(n):
ans = max(ans,dp[i][n-i])
print(ans)
| #!/usr/bin/env python3
import sys, math, itertools, collections, bisect, heapq
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
n = int(eval(input()))
A = list(map(int,input().split()))
data = [(ai,i) for i,ai in enumerate(A)]
data.sort(reverse = True)
dp = [[0]*(n+1) for i in range(n+1)]
for i in range(n):
for l in range(i+1):
r = i-l
dp[l+1][r] = max(dp[l+1][r], dp[l][r] + data[i][0] * abs(data[i][1] - l))
dp[l][r+1] = max(dp[l][r+1], dp[l][r] + data[i][0] * abs(data[i][1] - (n-1-r)))
ans = 0
for i in range(n):
ans = max(ans,dp[i][n-i])
print(ans) | p02709 |
n=int(eval(input()))
a=list(map(int,input().split()))
babies=[(a,i) for i,a in enumerate(a)]
babies.sort(reverse=True)
dp=[[0]*(n+1) for i in range(n+1)]#左、右から何人いるか? 家庭菜園
ans=0
for l in range(n):
for r in range(n):
if l+r==n:
ans=max(ans,dp[l][r])
break
activeness,ind=babies[r+l]
dp[l+1][r]=max(dp[r+1][r],dp[l][r]+abs(ind-l)*activeness)
dp[l][r+1]=max(dp[l][r+1],dp[l][r]+abs(ind-(n-1-r))*activeness)
print(ans)
| n=int(eval(input()))
a=list(map(int,input().split()))
babies=[(a,i) for i,a in enumerate(a)]
babies.sort(reverse=True)
dp=[[0]*(n+1) for i in range(n+1)]#左、右から何人いるか dpはl,r埋まってるときの最大スコア 家庭菜園
ans=0
for l in range(n):
for r in range(n):
if l+r==n:
ans=max(ans,dp[l][r])
break
activeness,ind=babies[r+l]
dp[l+1][r]=max(dp[l+1][r],dp[l][r]+abs(ind-l)*activeness)#左を埋める
dp[l][r+1]=max(dp[l][r+1],dp[l][r]+abs(ind-(n-1-r))*activeness)#右を埋める
print(ans)
| p02709 |
e=enumerate
n,*a=list(map(int,open(0).read().split()))
d=[0]
for j,(a,i)in e(sorted((a,i)for i,a in e(a))[::-1]):d=[d[0]+a*(~i-j+n)]+[max(d[k]+a*(~i-j+n+k),d[k-1]+a*abs(i-k+1))for k in range(1,j+1)]+[d[j]+a*abs(i-j)]
print((max(d))) | e=enumerate
n,*a=list(map(int,open(0).read().split()))
d=[0]
for j,(a,i)in e(sorted((a,i)for i,a in e(a))[::-1]):d=[d[0]+a*(~i-j+n)]+[max(d[k+1]+a*(n+k-i-j),d[k]+a*abs(i-k))for k in range(j)]+[d[j]+a*abs(i-j)]
print((max(d))) | p02709 |
e=enumerate
n,a=open(0)
n=int(n)
d=[0]+[-9e18]*n
for j,(a,i)in e(sorted((int(a),i)for i,a in e(a.split()))[::-1]):d=[max(t+a*abs(~i-j+k+n),d[k-1]+a*abs(~i+k)if k else 0)for k,t in e(d)]
print((max(d))) | e=enumerate
n,a=open(0)
n=int(n)
d=[0]+[-1e18]*n
for j,(a,i)in e(sorted((int(a),i)for i,a in e(a.split()))[::-1]):d=[max(t+a*abs(~i-j+k+n),k and d[k-1]+a*abs(~i+k))for k,t in e(d)]
print((max(d))) | p02709 |
e=enumerate
n,a=open(0)
n=int(n)
d=[0]+[1e18]*n
for j,(a,i)in e(sorted((-int(a),i)for i,a in e(a.split()))):d=[min(t+a*abs(~i-j+k+n),d[k-1]+a*abs(~i+k))for k,t in e(d)]
print((-min(d))) | n=int(eval(input()))
d=[0]+[-10**18]*n
for j,(a,i)in enumerate(sorted((-a,i)for i,a in enumerate(map(int,input().split())))):
d=[max(t-a*abs(~i-j+k+n),d[k-1]-a*abs(~i+k))for k,t in enumerate(d)]
print((max(d))) | p02709 |
e=enumerate
n,a=open(0)
d=[0]+[-2**64]*2000
for j,(a,i)in e(sorted((-int(a),i)for i,a in e(a.split()))):d=[max(t-a*(~i-j+k+int(n)),d[k-1]-a*abs(~i+k))for k,t in e(d)]
print((max(d))) | def main():
from random import sample
from operator import itemgetter
e=enumerate
n,a=open(0)
n=int(n)
d=[0]+[-2**64]*n
for j,(a,i)in e(sorted(sample([(a,i)for i,a in e(list(map(int,a.split())))],n),key=itemgetter(0),reverse=1)):
d=[max(t+a*(~i-j+k+n),d[k-1]+a*abs(~i+k))for k,t in e(d)]
print((max(d)))
main() | p02709 |
n=int(eval(input()))
a=list(map(int,input().split()))
b=[(v,s) for s,v in enumerate(a)]
b.sort(reverse=True)
dp=[[0 for i in range(n+1)] for i in range(n+1)]
for i in range(n+1):
for j in range(n+1):
if i+j<=n and (i>0 or j>0):
v=b[i+j-1][0]
pos=b[i+j-1][1]
if i==0:
dp[0][j]=dp[0][j-1]+v*abs(n-j-pos)
elif j==0:
dp[i][0]=dp[i-1][0]+v*abs(i-1-pos)
else:
dp[i][j]=max(dp[i-1][j]+v*abs(i-1-pos),dp[i][j-1]+v*abs(n-j-pos))
ans=0
for i in range(n):
happy=dp[i][n-i]
if happy>ans:
ans=happy
print(ans) | n=int(eval(input()))
a=list(map(int,input().split()))
b=[(v,s) for s,v in enumerate(a)]
b.sort(reverse=True)
dp=[[0 for i in range(n+1)] for i in range(n+1)]
for i in range(n+1):
for j in range(n+1-i):
if i+j==0:
continue
v=b[i+j-1][0]
pos=b[i+j-1][1]
if i==0:
dp[0][j]=dp[0][j-1]+v*abs(n-j-pos)
elif j==0:
dp[i][0]=dp[i-1][0]+v*abs(i-1-pos)
else:
dp[i][j]=max(dp[i-1][j]+v*abs(i-1-pos),dp[i][j-1]+v*abs(n-j-pos))
ans=0
for i in range(n):
happy=dp[i][n-i]
if happy>ans:
ans=happy
print(ans) | p02709 |
# -*- coding: utf-8 -*-
from collections import deque
def create_tmp_list(dq1: deque, dq2: deque):
tmp1 = dq1.copy()
for x in dq2:
if tmp1[0] == x:
tmp1.popleft()
elif tmp1[-1] == x:
tmp1.pop()
return tmp1
# 整数の入力
a = int(eval(input()))
# スペース区切りの整数の入力
strs = input().split()
# nums = []
only_nums = []
dic = {}
for i in range(a):
v = int(strs[i])
v_list = dic.setdefault(v, deque())
v_list.append(i)
only_nums.append(v)
sorted_nums = sorted(only_nums, reverse=True)
# print(sorted_nums)
# print(nums)
# res[x][y]をx人を左から活性度順に並べて、y人を右から活性度順に並べた状態の(スコア最大値, 移動済のindexを記述したリスト)とする
res = []
for i in range(a + 1):
ls = []
for j in range(a + 1):
ls.append((0, deque()))
res.append(ls)
max_num_changed = True
max_num = sorted_nums[0]
for i in range(a + 1):
# print("i in range(a)")
# print(i)
# print(a)
# print("i in range(a)")
if i == 0:
continue
if i == 1:
sorted_nums = sorted_nums[1:]
# x,y = 0,1にした場合
max_num_idx_min = dic[max_num][0]
res[0][1] = (max_num * (a - 1 - max_num_idx_min), deque([max_num_idx_min]))
# x,y = 1,0にした場合
max_num_idx_max = dic[max_num][-1]
res[1][0] = (max_num * max_num_idx_max, deque([max_num_idx_max]))
else:
target_val = sorted_nums[0]
sorted_nums = sorted_nums[1:]
if target_val == max_num:
max_num_changed = False
else:
max_num_changed = True
max_num = target_val
# print(sorted_nums)
score_right = -1
# x,y = i-j,j(0 ≤ j ≤ i)にした場合を考える
# i - 1のresについてそれぞれ次の状態を考えていく
# res[i-1][0], res[i-2][1], res[i-3][2], ... , res[i-1-j][j], ... , res[0][i-1]
ls_j = []
for j in range(i):
if max_num_changed:
already_used_max_num_index = deque()
max_num_idx_max = dic[max_num][-1]
max_num_idx_min = dic[max_num][0]
else:
already_used_max_num_index = res[i-j-1][j][1]
tmp_list = create_tmp_list(dic[max_num], already_used_max_num_index)
max_num_idx_max = tmp_list[-1]
max_num_idx_min = tmp_list[0]
# from i-j-1,j to i-j,j (最大活性のものを左に移動)
score_left = max_num * abs(max_num_idx_max - (i - j - 1)) + res[i - j - 1][j][0]
# 左端はその値をそのまま利用。右側に移動したものよりも大きい場合はleftの値を設定
if j == 0 or score_right < score_left:
res_list = already_used_max_num_index.copy()
res_list.append(max_num_idx_max)
res[i - j][j] = (score_left, res_list)
# from i-j-1,j to i-j-1,j+1 (最大活性のものを右に移動)
score_right = max_num * abs(a - 1 - max_num_idx_min - j) + res[i - j - 1][j][0]
# 右側に移動の場合は一旦その値を暫定値として設定してしまう（必要があれば次のループで上書きされるので問題ない）
# res_list = already_used_max_num_index.copy()
res_list = already_used_max_num_index
res_list.append(max_num_idx_min)
res[i - j - 1][j + 1] = (score_right, res_list)
if i == a:
max_v = 0
for j in range(a + 1):
v = res[j][i - j][0]
if max_v < v:
max_v = v
# print(result)
print(max_v)
| # -*- coding: utf-8 -*-
from collections import deque
def create_tmp_list(dq1: deque, dq2: deque):
tmp1 = dq1.copy()
for x in dq2:
if tmp1[0] == x:
tmp1.popleft()
elif tmp1[-1] == x:
tmp1.pop()
return tmp1
# 整数の入力
a = int(eval(input()))
# スペース区切りの整数の入力
strs = input().split()
vilist = []
for i in range(a):
vilist.append((int(strs[i]), i))
vilist = sorted(vilist, key=lambda vi: vi[0], reverse=True)
# # dp[x][y]をx人を左から活性度順に並べて、y人を右から活性度順に並べた状態の(スコア最大値, 移動済のindexを記述したリスト)とする
# dp = []
# for i in range(a + 1):
# ls = []
# for j in range(a + 1):
# ls.append((0, []))
# dp.append(ls)
#
# # 0番目の人
# # dp[1][0] 左につめる
# dp[1][0] = (vilist[0][0] * abs(vilist[0][1] - 0), [vilist[0][1]])
# # dp[0][1] 右につめる
# dp[0][1] = (vilist[0][0] * abs(a - 1 - vilist[0][1]), [vilist[0][1]])
#
# # 1番目の人
# # dp[2][0] 左につめる
# dp[1][0] = (vilist[0][0] * abs(vilist[0][1] - 0), [vilist[0][1]])
# # dp[0][1] 右につめる
# dp[0][1] = (vilist[0][0] * abs(a - 1 - vilist[0][1]), [vilist[0][1]])
# dp[x][y]をx人を左から活性度順に並べて、y人を右から活性度順に並べた状態のスコア最大値とする
dp = []
for i in range(a + 1):
ls = []
for j in range(a + 1):
ls.append(0)
dp.append(ls)
# # 0番目の人
# # dp[1][0] 左につめる
# dp[1][0] = max(dp[1][0], vilist[0][0] * abs(vilist[0][1] - 0))
# # dp[0][1] 右につめる
# dp[0][1] = max(dp[0][1], vilist[0][0] * abs(a - 1 - vilist[0][1]))
#
# # 1番目の人
# # dp[2][0] 左につめる
# dp[2][0] = max(dp[2][0], dp[1][0] + vilist[1][0] * abs(vilist[1][1] - 1))
# # dp[1][1] 左につめる or 右につめる
# dp[1][1] = max(dp[1][1],
# dp[0][1] + vilist[1][0] * abs(vilist[1][1] - 0),
# dp[1][0] + vilist[1][0] * abs(a - 1 - vilist[1][1]))
# # dp[0][2] 右につめる
# dp[0][2] = max(dp[0][2], dp[0][1] + vilist[1][0] * abs(a - 2 - vilist[1][1]))
#
# # 2番目の人
# # dp[3][0] 左につめる
# dp[3][0] = max(dp[3][0], dp[2][0] + vilist[2][0] * abs(vilist[2][1] - 2))
# # dp[2][1] 左につめる or 右につめる
# dp[2][1] = max(dp[2][1],
# dp[1][1] + vilist[2][0] * abs(vilist[2][1] - 1),
# dp[2][0] + vilist[2][0] * abs(a - 1 - vilist[2][1]))
# # dp[1][2] 左につめる or 右につめる
# dp[1][2] = max(dp[1][2],
# dp[0][2] + vilist[2][0] * abs(vilist[2][1] - 0),
# dp[1][1] + vilist[2][0] * abs(a - 2 - vilist[2][1]))
# # dp[0][3] 右につめる
# dp[0][3] = max(dp[0][3], dp[0][2] + vilist[2][0] * abs(a - 3 - vilist[2][1]))
#
# # 3番目の人
# # dp[4][0] 左につめる
# dp[4][0] = max(dp[4][0], dp[3][0] + vilist[3][0] * abs(vilist[3][1] - 3))
# # dp[3][1] 左につめる or 右につめる
# dp[3][1] = max(dp[3][1],
# dp[2][1] + vilist[3][0] * abs(vilist[3][1] - 2),
# dp[3][0] + vilist[3][0] * abs(a - 1 - vilist[3][1]))
# # dp[2][2] 左につめる or 右につめる
# dp[2][2] = max(dp[2][1],
# dp[1][2] + vilist[3][0] * abs(vilist[3][1] - 1),
# dp[2][1] + vilist[3][0] * abs(a - 2 - vilist[3][1]))
# # dp[1][3] 左につめる or 右につめる
# dp[1][3] = max(dp[1][2],
# dp[0][3] + vilist[3][0] * abs(vilist[3][1] - 0),
# dp[1][2] + vilist[3][0] * abs(a - 3 - vilist[3][1]))
# # dp[0][4] 右につめる
# dp[0][4] = max(dp[0][3], dp[0][3] + vilist[3][0] * abs(a - 4 - vilist[3][1]))
#
# print(max(dp[4][0], dp[3][1], dp[2][2], dp[1][3], dp[0][4]))
# dp[i][j]を考える
for i in range(a+1):
for j in range(a+1-i):
# k = (i + j - 1)番目の人
k = i + j - 1
if i == 0 and j == 0:
continue
if j == 0 and i > 0:
dp[i][0] = max(dp[i][0], dp[i-1][0] + vilist[k][0] * abs(vilist[k][1] - i + 1))
elif i == 0 and j > 0:
dp[0][j] = max(dp[0][j], dp[0][j-1] + vilist[k][0] * abs(a - j - vilist[k][1]))
else:
dp[i][j] = max(dp[i][j],
dp[i-1][j] + vilist[k][0] * abs(vilist[k][1] - i + 1),
dp[i][j-1] + vilist[k][0] * abs(a - j - vilist[k][1]))
max_v = 0
for x in dp:
max_x = max(x)
if max_v < max_x:
max_v = max_x
print(max_v) | p02709 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
n = int(eval(input()))
A = list(map(int, input().split()))
L = [(a, i) for i, a in enumerate(A)]
L.sort(reverse=True)
dp = dict()
def dfs(l, r):
i = (n-1-r) + l
a, idx = L[i]
if i == n-1:
res = max(idx-l, r-idx) * a
return res
if (l, r) in dp:
return dp[(l, r)]
res = max((idx-l)*a + dfs(l+1, r), (r-idx)*a + dfs(l, r-1))
dp[(l, r)] = res
return res
ans = dfs(0, n-1)
print(ans) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
n = int(eval(input()))
A = list(map(int, input().split()))
L = [(a, i) for i, a in enumerate(A)]
L.sort(reverse=True)
dp = [[-1]*n for _ in range(n)]
def dfs(l, r):
i = (n-1-r) + l
a, idx = L[i]
if i == n-1:
res = max(idx-l, r-idx) * a
return res
if dp[l][r] != -1:
return dp[l][r]
res = max((idx-l)*a + dfs(l+1, r), (r-idx)*a + dfs(l, r-1))
dp[l][r] = res
return res
ans = dfs(0, n-1)
print(ans) | p02709 |
from collections import *
import itertools
import sys
sys.setrecursionlimit(10**5)
try: inp = raw_input
except: inp = input
def err(s):
sys.stderr.write('{}\n'.format(s))
def ni():
return int(inp())
def nl():
return [int(_) for _ in inp().split()]
N = ni()
A = nl()
X = sorted(enumerate(A), key=lambda x: x[1], reverse=True)
p = [x for x, _ in X]
sc = [x for _, x in X]
DP = {}
def opt(l, i):
r = N - i + l - 1
if i == N: return 0
T = l, i
if T in DP:
return DP[T]
v1 = abs(p[i]- l)*sc[i] + opt(l+1, i+1)
v2 = abs(p[i] - r)*sc[i] + opt(l, i+1)
DP[T] = max(v1, v2)
return DP[T]
print((opt(0, 0)))
| from collections import *
import itertools
import sys
sys.setrecursionlimit(10**5)
try: inp = raw_input
except: inp = input
def err(s):
sys.stderr.write('{}\n'.format(s))
def ni():
return int(inp())
def nl():
return [int(_) for _ in inp().split()]
N = ni()
A = nl()
X = sorted(enumerate(A), key=lambda x: x[1], reverse=True)
p = [x for x, _ in X]
sc = [x for _, x in X]
DP = [[-1]*N for _ in range(N)]
def opt(l, i):
r = N - i + l - 1
if i == N: return 0
if DP[i][l] != -1: return DP[i][l]
v1 = abs(p[i]- l)*sc[i] + opt(l+1, i+1)
v2 = abs(p[i] - r)*sc[i] + opt(l, i+1)
DP[i][l] = max(v1, v2)
return DP[i][l]
print((opt(0, 0)))
| p02709 |
import itertools
n = int(eval(input()))
A = list(map(int, input().split()))
dp = [[0]*(n+1) for _ in range(n+1)]
for i in range(1, n+1):
for j in range(1, n+1):
dp[i][j] = abs(i-j)*A[i-1]
ans = 0
for x in itertools.permutations(list(range(1, n+1)), n):
cnt = 0
for i, j in enumerate(x):
cnt += dp[i+1][j]
ans = max(ans, cnt)
print(ans)
| n = int(eval(input()))
A = [(a, i) for i, a in enumerate(map(int, input().split()))]
A.sort(reverse=True)
dp = [[0]*(n+1) for _ in range(n+1)]
ans = 0
for L in range(n+1):
for R in range(n+1):
if n <= L+R-1:
continue
a, i = A[L+R-1]
if 0 <= R-1:
dp[L][R] = max(dp[L][R], dp[L][R-1]+abs((n-R)-i)*a)
if 0 <= L-1:
dp[L][R] = max(dp[L][R], dp[L-1][R]+abs(i-(L-1))*a)
ans = max(ans, dp[L][R])
print(ans)
| p02709 |
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
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_str():
'''
一行に複数の文字
'''
return list(input().split())
n=inp()
a = inpl()
sorted_a = sorted(a,reverse=True)
place=defaultdict(lambda: [])
for i in range(n):
place[a[i]].append(i+1)
ans = 0
dp=[[-INF]*(n+1) for i in range(n+1)]
dp[0][0] = 0
for i in range(n):
if i!=0 and sorted_a[i] == sorted_a[i - 1]:
index += 1
else:
index = 0
for j in range(n):
_place = place[sorted_a[i]][index]
#右
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + sorted_a[i] * abs(n - (i - j) - _place))
#左
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j] + sorted_a[i] * abs(_place - j - 1))
print((max(dp[n]))) | 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_str():
'''
一行に複数の文字
'''
return list(input().split())
n=inp()
a = inpl()
sorted_a = sorted(a,reverse=True)
place=dict()
for i in range(n):
if a[i] not in place:
place[a[i]]=[i+1]
else:
place[a[i]].append(i+1)
ans = 0
dp=[[-INF]*(n+1) for i in range(n+1)]
dp[0][0] = 0
for i in range(n):
if i!=0 and sorted_a[i] == sorted_a[i - 1]:
index += 1
else:
index = 0
for j in range(n):
_place = place[sorted_a[i]][index]
#右
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + sorted_a[i] * abs(n - (i - j) - _place))
#左
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j] + sorted_a[i] * abs(_place - j - 1))
print((max(dp[n])))
| p02709 |
from collections import *
from itertools import *
N = int(eval(input()))
A = list(map(int, input().split()))
SA = SB = 0
ABI = sorted(((b:=max(N-i, i-1)*a)|1 and (SA:=SA+a)|1 and (SB:=SB+b)|1 and (a, b, i) for i, a in enumerate(A, 1)), reverse=True)
prev = {(0,0):0}
prev_max = 0
for a, b, i in ABI:
curr = defaultdict(int)
curr_max = 0
for (l,r), p in list(prev.items()):
if p + SB - min(l,r)*SA < prev_max:
continue
curr[l,r+1] = max(curr[l,r+1], p+abs(N-i-r)*a)
curr[l+1,r] = max(curr[l+1,r], p+abs(i-l-1)*a)
curr_max = max(curr_max, curr[l,r+1], curr[l+1,r])
SA -= a
SB -= b
prev = curr
prev_max = curr_max
print(curr_max)
| from collections import *
from itertools import *
N = int(eval(input()))
A = list(map(int, input().split()))
SA = SB = 0
ABI = sorted(((b:=max(N-i, i-1)*a, SA:=SA+a, SB:=SB+b) and (a, b, i) for i, a in enumerate(A, 1)), reverse=True)
prev = {0:0}
prev_max = 0
for k, (a, b, i) in enumerate(ABI):
curr = defaultdict(int)
curr_max = 0
for l, p in list(prev.items()):
r = k-l
if p + SB - min(l,r)*SA < prev_max:
continue
curr[l] = max(curr[l], p+abs(N-i-r)*a)
curr[l+1] = p+abs(i-l-1)*a
curr_max = max(curr_max, curr[l], curr[l+1])
SA -= a
SB -= b
prev = curr
prev_max = curr_max
print(curr_max)
| p02709 |
from collections import *
from itertools import *
N = int(eval(input()))
A = list(map(int, input().split()))
SA = SB = 0
ABI = sorted(((b:=max(N-i, i-1)*a, SA:=SA+a, SB:=SB+b) and (a, b, i) for i, a in enumerate(A, 1)), reverse=True)
prev = {0:0}
prev_max = 0
for k, (a, b, i) in enumerate(ABI):
curr = defaultdict(int)
curr_max = 0
for l, p in list(prev.items()):
r = k-l
if p + SB - max(l,r)*SA < prev_max:
continue
curr[l] = max(curr[l], p+abs(N-i-r)*a)
curr[l+1] = p+abs(i-l-1)*a
curr_max = max(curr_max, curr[l], curr[l+1])
SA -= a
SB -= b
prev = curr
prev_max = curr_max
print(curr_max)
| from collections import *
from itertools import *
N = int(eval(input()))
A = list(map(int, input().split()))
SA = SB = 0
ABI = sorted(((b:=max(N-i, i-1)*a, SA:=SA+a, SB:=SB+b) and (a, b, i) for i, a in enumerate(A, 1)), reverse=True)
prev = {0:0}
prev_max = 0
for k, (a, b, i) in enumerate(ABI):
curr = defaultdict(int)
for l, p in list(prev.items()):
r = k-l
if p + SB - max(l,r)*SA < prev_max:
continue
curr[l] = max(curr[l], p+abs(N-i-r)*a)
curr[l+1] = p+abs(i-l-1)*a
SA -= a
SB -= b
prev = curr
prev_max = max(prev.values())
print(prev_max)
| p02709 |
from collections import *
from itertools import *
N = int(eval(input()))
A = list(map(int, input().split()))
SA = SB = 0
ABI = sorted(((b:=max(N-i, i-1)*a, SA:=SA+a, SB:=SB+b) and (a, b, i) for i, a in enumerate(A, 1)), reverse=True)
prev = [0]
prev_max = 0
for k, (a, b, i) in enumerate(ABI):
curr = [0]*(k+2)
for l in range(k+1):
r = k-l
if prev[l] + SB - min(l,r)*SA < prev_max:
continue
curr[l] = max(curr[l], prev[l]+abs(N-i-r)*a)
curr[l+1] = prev[l]+abs(i-l-1)*a
SA -= a
SB -= b
prev = curr
prev_max = max(prev)
print(prev_max)
| N = int(eval(input()))
A = list(map(int, input().split()))
ABI = sorted(((a, max(N-i, i-1)*a, i) for i, a in enumerate(A, 1)), reverse=True)
prev = [0]
for k, (a, b, i) in enumerate(ABI):
curr = [0]*(k+2)
for l in range(k+1):
curr[l] = max(curr[l], prev[l]+abs(N-i-k+l)*a)
curr[l+1] = prev[l]+abs(i-l-1)*a
prev = curr
print((max(prev)))
| p02709 |
from operator import itemgetter as get
N = int(eval(input()))
A = list(map(int, input().split()))
SA = SB = 0
ABI = sorted(((b:=max(N-i, i-1)*a, SA:=SA+a, SB:=SB+b) and (a, b, i) for i, a in enumerate(A, 1)), reverse=True)
def solve(a, i, prev, th, tha):
pl, pr, ps = 0, -1, 0
for l, r, s in prev:
if s < th-max(l,r)*tha:
continue
if pr == r-1:
yield l, r-1, max(s+abs(r-i)*a, ps+abs(i-pl)*a)
else:
if pl:
yield pl+1, pr, ps+abs(i-pl)*a
yield l, r-1, s+abs(r-i)*a
pl, pr, ps = l, r, s
yield pl+1, pr, ps+abs(i-pl)*a
prev = [(1, N, 0)]
pm = 0
for j, (a,b,i) in enumerate(ABI):
M = 0
prev = [(M:=max(M,s),) and (l, r, s) for l, r, s in solve(a,i, prev, pm-SB, SA)]
pm = M
SA -= a
SB -= b
print(pm)
|
N = int(eval(input()))
A = list(map(int, input().split()))
AI = sorted(((a, i) for i, a in enumerate(A, 1)), reverse=True)
def solve(a, i, prev):
pl, pr, ps = i, 0, 0
for l, r, s in prev:
yield l, r-1, max(s+abs(r-i)*a, ps+abs(i-pl)*a)
pl, pr, ps = l, r, s
yield pl+1, pr, ps+abs(i-pl)*a
prev = [(1, N, 0)]
for a,i in AI:
prev = [*solve(a,i, prev)]
print((max(s for l, r, s in prev)))
| p02709 |
import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()
sys.setrecursionlimit(10**6)
n = ni()
a = na()
b = []
for i in range(n):
b.append((a[i],i))
b.sort(reverse=True)
ans = 0
def f(left,right,k,c):
if k == n:
return c
i,j = b[k]
x = abs(j-left)
y = abs(right-j)
return max(f(left+1,right,k+1,c+x*i), f(left,right-1,k+1,c+y*i))
ans = f(0,n-1,0,0)
print(ans)
| import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()
sys.setrecursionlimit(10**6)
n = ni()
a = na()
b = []
for i in range(n):
b.append((a[i],i))
b.sort(reverse=True)
dp = [[0]*(n+1) for i in range(n+1)]
for i in range(1,n+1):
x,y = b[i-1]
for j in range(i+1):
left = dp[i-1][j-1] + x*abs(y-j+1) if j > 0 else -1
right = dp[i-1][j] + x*abs(n-i+j-y) if j < i else -1
dp[i][j] = max(left,right)
print((max(dp[-1]))) | p02709 |
import itertools
N=int(eval(input()))
actlist=list(map(int,input().split()))
alllist=list(itertools.permutations(list(range(1,N+1))))
count=1
l=len(alllist)
maxnum=0
for i in range(0,l-1):
for j in range(i+1,l):
hapsum=0
for m,n in zip(alllist[i],alllist[j]):
hapsum+=actlist[m-1]*abs(m-n)
if maxnum<hapsum:
maxnum=hapsum
print(maxnum) | N=int(eval(input()))
actlist=list(map(int,input().split()))
As = sorted([(A, i) for i, A in enumerate(actlist)])[::-1]
INF = float('inf')
left=1
right=N
maxnum=0
dp = [[-INF] * (N+1) for _ in range(N+1)]
for r in range(N+1):
for l in range(N-r+1):
if r==0 and l==0:
dp[l][r]=0
else:
dp[l][r]=max(dp[l][r-1]+As[l+r-1][0]*abs(N-r-As[l+r-1][1]),\
dp[l-1][r]+As[l+r-1][0]*abs(l-1-As[l+r-1][1]))
maxnum=dp[l][r] if maxnum<dp[l][r] else maxnum
print(maxnum) | p02709 |
N=int(eval(input()))
actlist=list(map(int,input().split()))
As = sorted([(A, i) for i, A in enumerate(actlist)])[::-1]
INF = float('inf')
left=1
right=N
maxnum=0
dp = [[-INF] * (N+1) for _ in range(N+1)]
for r in range(N+1):
for l in range(N-r+1):
if r==0 and l==0:
dp[l][r]=0
else:
dp[l][r]=max(dp[l][r-1]+As[l+r-1][0]*abs(N-r-As[l+r-1][1]),\
dp[l-1][r]+As[l+r-1][0]*abs(l-1-As[l+r-1][1]))
maxnum=dp[l][r] if maxnum<dp[l][r] else maxnum
print(maxnum) | def main():
N = int(eval(input()))
INF = float('inf')
A = [(i+1, a) for i, a in enumerate(map(int, input().split()))]
A = sorted(A, key=lambda x: x[1], reverse = True)
dp = [[-INF] * (N+1) for _ in range(N+1)]
dp[0][0] = 0
for s in range(1, N+1):
for l in range(s+1):
r = s - l
dp[l][r] = max(dp[l-1][r] + A[s-1][1] * abs(A[s-1][0]-l), dp[l][r-1] + A[s-1][1] * abs(N-r+1-A[s-1][0]))
ans = 0
for m in range(N):
if(dp[m][N-m] > ans):
ans = dp[m][N-m]
print(ans)
main() | p02709 |
import sys
n = int(eval(input()))
a = list(map(int, input().split(' ')))
b = list(range(n))
b.sort(key=lambda x: -a[x])
# print("b after:", b)
# print(list(map(lambda x:a[x],b)))
cache = [[-1 for x in range(n)] for y in range(n)]
# print(cache)
def dfs(left, right):
if left > right:
return 0
if cache[left][right] != -1:
return cache[left][right]
which = n-(right-left+1)
ans1 = dfs(left+1, right)+abs(left-b[which])*a[b[which]]
ans2 = dfs(left, right-1)+abs(right-b[which])*a[b[which]]
cache[left][right] = max(ans1, ans2)
return cache[left][right]
sys.setrecursionlimit(2010)
print((dfs(0, n-1)))
| import sys
import time
t = time.time()
n = int(eval(input()))
a = list(map(int, input().split(' ')))
b = list(range(n))
b.sort(key=lambda x: -a[x])
# print("b after:", b)
# print(list(map(lambda x:a[x],b)))
# print(time.time()-t)
cache = [[-1 for x in range(n)] for y in range(n)]
# print(cache)
def dfs(left, right):
if left > right:
return 0
if cache[left][right] != -1:
return cache[left][right]
which = n-(right-left+1)
ans1 = dfs(left+1, right)+abs(left-b[which])*a[b[which]]
ans2 = dfs(left, right-1)+abs(right-b[which])*a[b[which]]
cache[left][right] = max(ans1, ans2)
return cache[left][right]
sys.setrecursionlimit(2010)
print((dfs(0, n-1)))
| p02709 |
import functools
import sys
sys.setrecursionlimit(10 ** 9)
eval(input())
arr = list(sorted([(v, idx) for idx, v in enumerate(map(int, input().split()))], reverse=True))
@functools.lru_cache(maxsize=None)
def dp(l, r, idx):
if idx == len(arr):
return 0
left = abs(arr[idx][1] - l) * arr[idx][0] + dp(l + 1, r, idx + 1)
right = abs(arr[idx][1] - r) * arr[idx][0] + dp(l, r - 1, idx + 1)
return max(left, right)
print((dp(0, len(arr) - 1, 0)))
| import sys
sys.setrecursionlimit(10 ** 9)
eval(input())
arr = list(sorted([(v, idx) for idx, v in enumerate(map(int, input().split()))], reverse=True))
d = [[-1 for _ in range(len(arr))] for _ in range(len(arr))]
def dp(l, r, idx):
if idx == len(arr):
return 0
if d[l][r] != -1:
return d[l][r]
left = abs(arr[idx][1] - l) * arr[idx][0] + dp(l + 1, r, idx + 1)
right = abs(arr[idx][1] - r) * arr[idx][0] + dp(l, r - 1, idx + 1)
d[l][r] = max(left, right)
return max(left, right)
print((dp(0, len(arr) - 1, 0)))
| p02709 |
from heapq import heappop, heappush
from collections import defaultdict
n = int(eval(input()))
a = list(map(int, input().split()))
hp = []
for i, e in enumerate(a, 1):
heappush(hp, [-e, i])
dp = defaultdict(int)
dp[(0, n + 1)] = 0
while hp:
e, i = heappop(hp)
e = -e
dp2 = defaultdict(int)
for k, v in list(dp.items()):
l, r = k
dp2[(l + 1, r)] = max(dp2[(l + 1, r)], v + abs(l + 1 - i) * e)
dp2[(l, r - 1)] = max(dp2[(l, r - 1)], v + abs(r - 1 - i) * e)
dp = dp2
ans = 0
for k, v in list(dp.items()):
ans = max(ans, v)
print(ans)
| from heapq import heappop, heappush
from collections import defaultdict
n = int(eval(input()))
a = list(map(int, input().split()))
hp = []
for i, e in enumerate(a, 1):
heappush(hp, [-e, i])
dp = defaultdict(int)
dp[(0, n + 1)] = 0
while hp:
e, i = heappop(hp)
e = -e
dp2 = defaultdict(int)
for k, v in list(dp.items()):
l, r = k
dp2[(l + 1, r)] = max(dp2[(l + 1, r)], v + abs(l + 1 - i) * e)
dp2[(l, r - 1)] = max(dp2[(l, r - 1)], v + abs(r - 1 - i) * e)
dp = dp2
ans = max(dp.values())
print(ans)
| p02709 |
N = int(eval(input()))
A = list(map(int,input().split()))
# print(A)
A = [[A[i],i] for i in range(N)]
A.sort(reverse=True)
# print("A :",A)
dp = [[0]*(N+1) for _ in range(N+1)]
# print(dp)
#dp[x][y] : x人は Ai*(i-pi),y人は Ai*(pi-i)
# piは 0,1,2... piはN-1,N-2,N-3,,
dp[0][0] = 0
# y = 0
for x in range(1,N+1):
dp[x][0] = dp[x-1][0]+A[x-1][0]*(A[x-1][1]-x+1)
# print(x,dp)
# x = 0
for y in range(1,N+1):
dp[0][y] = dp[0][y-1]+A[y-1][0]*(N-y - A[y-1][1])
# print(x,dp)
for x in range(1,N):
for y in range(1,N+1-x):
dp[x][y] = max(dp[x-1][y] + A[x+y-1][0]*(A[x+y-1][1]+1 - x), dp[x][y-1] + A[x+y-1][0]*(N-y - A[x+y-1][1]))
# print(dp)
c = 0
for i in range(N):
if c < dp[i][N-i]:
c = dp[i][N-i]
print(c) | # import time
# p0 = time.time()
N = int(eval(input()))
A = list(map(int,input().split()))
# print(A)
A = [[A[i],i] for i in range(N)]
A.sort(reverse=True)
# print("A :",A)
dp = [[0]*(N+1) for _ in range(N+1)]
# print(dp)
#dp[x][y] : x人は Ai*(i-pi),y人は Ai*(pi-i)
# piは 0,1,2... piはN-1,N-2,N-3,,
# p1 = time.time()-p0
dp[0][0] = 0
# y = 0
for x in range(1,N+1):
dp[x][0] = dp[x-1][0]+A[x-1][0]*(A[x-1][1]-x+1)
# print(x,dp)
# x = 0
for y in range(1,N+1):
dp[0][y] = dp[0][y-1]+A[y-1][0]*(N-y - A[y-1][1])
# print(x,dp)
# p2 = time.time()-p0
for x in range(1,N):
for y in range(1,N+1-x):
A0 = A[x+y-1][0]
A1 = A[x+y-1][1]
dp[x][y] = max(dp[x-1][y] + A0*(A1+1 - x), dp[x][y-1] + A0*(N-y - A1))
# print(dp)
# p3 = time.time()-p0
c = 0
for i in range(N):
if c < dp[i][N-i]:
c = dp[i][N-i]
print(c)
# print(p1,p2,p3) | p02709 |
def main():
N = int(eval(input()))
INF = float('inf')
A = [(i+1, a) for i, a in enumerate(map(int, input().split()))]
A = sorted(A, key=lambda x: x[1], reverse = True)
dp = [[-INF] * (N+1) for _ in range(N+1)]
dp[0][0] = 0
for s in range(1, N+1):
for l in range(s+1):
r = s - l
dp[l][r] = max(dp[l-1][r] + A[s-1][1] * abs(A[s-1][0]-l), dp[l][r-1] + A[s-1][1] * abs(N-r+1-A[s-1][0]))
ans = 0
for m in range(N):
if(dp[m][N-m] > ans):
ans = dp[m][N-m]
print(ans)
main()
| def solve():
N = int(eval(input()))
A = [(a, i+1) for i, a in enumerate(map(int, input().split()))]
A.sort(reverse=True)
INF = float('inf')
dp = [[-INF] * (N+1) for _ in range(N+1)]
dp[0][0] = 0
for s in range(1, N+1):
for l in range(s+1):
r = s - l
dp[l][r] = max(dp[l-1][r] + A[s-1][0] * abs(A[s-1][1]-l), dp[l][r-1] + A[s-1][0] * abs(N-r+1-A[s-1][1]))
ans = 0
for m in range(N):
if dp[m][N-m] > ans:
ans = dp[m][N-m]
print(ans)
solve() | p02709 |
n=int(eval(input()))
a=list(map(int,input().split()))
ma=max(a)
l=[[] for _ in range(ma+1)]
chk=[0]*n
ans=0
for i,x in enumerate(a):
l[x].append(i)
cnt=1
dp=[[0]*(n+1) for _ in range(n+1)]
for i in range(ma,0,-1):
for j in l[i]:
for x in range(cnt+1):
if x==0:
dp[x][cnt-x]=dp[x][cnt-x-1]+i*(n-1-(cnt-x-1)-j)
elif x==cnt:
dp[x][cnt-x]=dp[x-1][cnt-x]+i*(j-x+1)
else:
dp[x][cnt-x]=max(dp[x-1][cnt-x]+i*(j-x+1),dp[x][cnt-x-1]+i*(n-1-(cnt-x-1)-j))
cnt+=1
ans=0
for i in range(n+1):
ans=max(ans,dp[i][n-i])
print(ans) | n=int(eval(input()))
a=list(map(int,input().split()))
l=[]
for i,x in enumerate(a):
l.append([x,i])
l.sort(reverse=True)
cnt=1
dp=[[0]*(n+1) for _ in range(n+1)]
for i,j in l:
for x in range(cnt+1):
if x==0:
dp[x][cnt-x]=dp[x][cnt-x-1]+i*(n-1-(cnt-x-1)-j)
elif x==cnt:
dp[x][cnt-x]=dp[x-1][cnt-x]+i*(j-x+1)
else:
dp[x][cnt-x]=max(dp[x-1][cnt-x]+i*(j-x+1),dp[x][cnt-x-1]+i*(n-1-(cnt-x-1)-j))
cnt+=1
ans=0
for i in range(n+1):
ans=max(ans,dp[i][n-i])
print(ans) | p02709 |
n = int(eval(input()))
a = list(map(int, input().split()))
a = list(enumerate(a))
a.sort(key = lambda x: x[1], reverse=True)
a = [list(a[i]) for i in range(n)]
a = [[a[i][0]+1, a[i][1]] for i in range(n)]
DP = [[0 for i in range(n+1)] for j in range(n+1)]
DP[0][0] = 0
for i in range(1, n+1):
DP[0][i] = DP[0][i-1] + abs(a[i-1][1] * (n - i + 1 - a[i-1][0]))
DP[i][0] = DP[i-1][0] + abs(a[i-1][1] * (a[i-1][0] - i))
for x in range(1, i):
y = i - x
DP[x][y] = max(DP[x-1][y] + abs(a[i-1][1] * (a[i-1][0] - x)), \
DP[x][y-1] + abs(a[i-1][1] * (n - y + 1 - a[i-1][0])))
ans = 0
for i in range(n+1):
ans = max(ans, DP[i][n-i])
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
a = list(enumerate(a))
a.sort(key = lambda x: x[1])
DP = [[0 for i in range(n+1)] for j in range(n+1)]
DP[0][0] = 0
for i in range(1, n+1):
pos, val = a.pop()
pos = pos + 1
DP[0][i] = DP[0][i-1] + abs(val * (n - i + 1 - pos))
DP[i][0] = DP[i-1][0] + abs(val * (pos - i))
for x in range(1, i):
y = i - x
DP[x][y] = max(DP[x-1][y] + abs(val * (pos - x)), \
DP[x][y-1] + abs(val * (n - y + 1 - pos)))
ans = 0
for i in range(n+1):
ans = max(ans, DP[i][n-i])
print(ans) | p02709 |
#!/usr/bin/env python3
import sys
INF = float("inf")
MOD = 10**9+7
N = int(eval(input()))
A = list(map(int, input().split()))
AA = [(a, i) for i, a in enumerate(A, start=1)]
AA.sort(reverse=True)
# print(AA)
DP = {}
DP[(0, 0)] = 0
for wa in range(1, N+1):
# AA[:wa]までを考える
a, i = AA[wa-1]
for x in range(wa+1):
y = wa - x
DP[(x, y)] = 0
if x - 1 >= 0:
DP[(x, y)] = max(DP[(x, y)], DP[(x-1, y)]+a*(i-x))
if y - 1 >= 0:
DP[(x, y)] = max(DP[(x, y)], DP[(x, y-1)]+a*(N-y-i+1))
# print(wa, (x, y), (a, i), DP[x][y])
print((max([DP[(x, N-x)] for x in range(N+1)])))
| #!/usr/bin/env python3
import sys
import itertools
sys.setrecursionlimit(10**8)
INF = float("inf")
MOD = 10**9+7
N = int(eval(input()))
A = list(map(int, input().split()))
AA = [(a, i) for i, a in enumerate(A, start=1)]
AA.sort(reverse=True)
# print(AA)
DP = [[0]*(N+1) for _ in range(N+1)]
for wa in range(1, N+1):
# AA[:wa]までを考える
for x in range(wa+1):
y = wa - x
a, i = AA[wa-1]
if x - 1 >= 0:
DP[x][y] = max(DP[x][y], DP[x-1][y]+a*(i-x))
if y - 1 >= 0:
DP[x][y] = max(DP[x][y], DP[x][y-1]+a*(N-y-i+1))
# print(wa, (x, y), (a, i), DP[x][y])
M = -INF
for x in range(N):
y = N-x
M = max(DP[x][y], M)
print(M)
| p02709 |
from heapq import heappush, heappop
n = int(eval(input()))
A = list(map(int, input().split()))
MX = 2005
f_inf = float('inf')
dp = [[0 for _ in range(MX)] for _ in range(MX)]
dp[0][0] = 0
hq = []
for i in range(n):
heappush(hq, (-A[i], i))
ans = 0
for i in range(n):
x, pi = heappop(hq)
for l in range(i+1):
r = i-l
dp[i+1][l+1] = max(dp[i+1][l+1], dp[i][l] + (pi-l)*A[pi])
dp[i+1][l] = max(dp[i+1][l], dp[i][l] + ((n-r-1)-pi)*A[pi])
ans = 0
for i in range(n+1):
ans = max(ans, dp[n][i])
print(ans) | from heapq import heappush, heappop
n = int(eval(input()))
A = list(map(int, input().split()))
f_inf = float('inf')
dp = [[0 for _ in range(n+1)] for _ in range(n+1)]
dp[0][0] = 0
hq = []
for i in range(n):
heappush(hq, (-A[i], i))
ans = 0
for i in range(n):
x, pi = heappop(hq)
for l in range(i+1):
r = i-l
dp[i+1][l+1] = max(dp[i+1][l+1], dp[i][l] + (pi-l)*A[pi])
dp[i+1][l] = max(dp[i+1][l], dp[i][l] + ((n-r-1)-pi)*A[pi])
ans = 0
for i in range(n+1):
ans = max(ans, dp[n][i])
print(ans)
| p02709 |
from heapq import heappush, heappop
n = int(eval(input()))
A = list(map(int, input().split()))
dp = [[0 for _ in range(n+1)] for _ in range(n+1)]
dp[0][0] = 0
hq = []
for i in range(n):
heappush(hq, (-A[i], i))
for i in range(n):
x, pi = heappop(hq)
for l in range(i+1):
r = i-l
dp[i+1][l+1] = max(dp[i+1][l+1], dp[i][l] + (pi-l)*A[pi])
dp[i+1][l] = max(dp[i+1][l], dp[i][l] + ((n-r-1)-pi)*A[pi])
ans = 0
for i in range(n+1):
ans = max(ans, dp[n][i])
print(ans) | from heapq import heappush, heappop
n = int(eval(input()))
A = list(map(int, input().split()))
hq = []
for i in range(n):
heappush(hq, (-A[i], i))
dp = [[0 for _ in range(n+1)] for _ in range(n+1)]
for i in range(n):
x, pi = heappop(hq)
for l in range(i+1):
r = i-l
dp[i+1][l+1] = max(dp[i+1][l+1], dp[i][l] + (pi-l)*A[pi])
dp[i+1][l] = max(dp[i+1][l], dp[i][l] + ((n-r-1)-pi)*A[pi])
ans = 0
for i in range(n+1):
ans = max(ans, dp[n][i])
print(ans) | p02709 |
n = int(eval(input()))
*A, = list(map(int, input().split()))
# n = 6
# A = [8, 6, 9, 1, 2, 1]
# n = 4
# A = [1, 3, 4, 2]
A = [(a, i) for i, a in enumerate(A)]
A.sort(reverse=True)
DP = [[0 for r in range(n+1)] for l in range(n+1)]
for l in range(n):
for r in range(n-l):
a, i = A[l+r]
DP[l+1][r] = max(DP[l+1][r], DP[l][r]+a*abs(i-l))
DP[l][r+1] = max(DP[l][r+1], DP[l][r]+a*abs(i-(n-1-r)))
print((max([DP[l][n-l] for l in range(n)])))
| import sys
sys.setrecursionlimit(10000)
n = int(eval(input()))
*A, = list(map(int, input().split()))
A = [(a, i) for i, a in enumerate(A)]
A.sort(reverse=True)
DP = [[None for r in range(n+1)] for l in range(n+1)]
def dp(l, r):
if l == r:
DP[l][r] = 0
if DP[l][r] != None:
return DP[l][r]
a, i = A[n-(r-l)]
x = dp(l+1, r)+a*abs(i-l)
y = dp(l, r-1)+a*abs(i-(r-1))
DP[l][r] = max(x, y)
return DP[l][r]
print((dp(0, n))) | p02709 |
from sys import stdin
cards = {}
n = int(eval(input()))
for line in stdin:
m, num = line.rstrip().split(' ')
cards[(m, int(num))] = True
for s in ['S','H','C','D']:
for i in range(1, 14):
if not (s, i) in cards:
print(("{} {}".format(s, i))) | marks = ["S", "H", "C", "D"]
cards = {}
n = int(eval(input()))
for _ in range(0, n):
mark, num = input().split()
if mark not in cards:
cards[mark] = []
cards[mark].append(int(num))
for mark in marks:
for n in range(1, 14):
if n in cards[mark]:
continue
print(("{} {}".format(mark, n)))
| p02408 |
r=range
v=input
l=[i+" "+str(j)for i in["S","H","C","D"]for j in r(1,14)]
for i in r(int(v())):l.remove(v())
for i in l:print(i) | r=range
v=input
l=[i+" "+str(j)for i in"SHCD" for j in r(1,14)]
for i in r(int(v())):l.remove(v())
for i in l:print(i) | p02408 |
import sys
n = int( sys.stdin.readline() )
s = [ False ] * 13
h = [ False ] * 13
c = [ False ] * 13
d = [ False ] * 13
for i in range( 0, n ):
pattern, num = sys.stdin.readline().split( " " )
if "S" == pattern:
s[ int( num )-1 ] = True
elif "H" == pattern:
h[ int( num )-1 ] = True
elif "C" == pattern:
c[ int( num )-1 ] = True
elif "D" == pattern:
d[ int( num )-1 ] = True
for i in range( 0, 13 ):
if not s[i]:
print(( "S {:d}".format( i+1 ) ))
for i in range( 0, 13 ):
if not h[i]:
print(( "H {:d}".format( i+1 ) ))
for i in range( 0, 13 ):
if not c[i]:
print(( "C {:d}".format( i+1 ) ))
for i in range( 0, 13 ):
if not d[i]:
print(( "D {:d}".format( i+1 ) )) | import sys
n = int( sys.stdin.readline() )
cards = { 'S': [ False ] * 13, 'H': [ False ] * 13, 'C': [ False ] * 13, 'D': [ False ] * 13 }
for i in range( n ):
pattern, num = sys.stdin.readline().split( " " )
if "S" == pattern:
cards[ 'S' ][ int( num )-1 ] = True
elif "H" == pattern:
cards[ 'H' ][ int( num )-1 ] = True
elif "C" == pattern:
cards[ 'C' ][ int( num )-1 ] = True
elif "D" == pattern:
cards[ 'D' ][ int( num )-1 ] = True
for pattern in ( 'S', 'H', 'C', 'D' ):
for i in range( 13 ):
if not cards[ pattern ][ i ]:
print(( "{:s} {:d}".format( pattern, i+1 ) )) | p02408 |
import sys
n = int( sys.stdin.readline() )
cards = { 'S': [ False ] * 13, 'H': [ False ] * 13, 'C': [ False ] * 13, 'D': [ False ] * 13 }
for i in range( n ):
pattern, num = sys.stdin.readline().split( " " )
if "S" == pattern:
cards[ 'S' ][ int( num )-1 ] = True
elif "H" == pattern:
cards[ 'H' ][ int( num )-1 ] = True
elif "C" == pattern:
cards[ 'C' ][ int( num )-1 ] = True
elif "D" == pattern:
cards[ 'D' ][ int( num )-1 ] = True
for pattern in ( 'S', 'H', 'C', 'D' ):
for i in range( 13 ):
if not cards[ pattern ][ i ]:
print(( "{:s} {:d}".format( pattern, i+1 ) )) | import sys
n = int( sys.stdin.readline() )
cards = { 'S': [ False ] * 13, 'H': [ False ] * 13, 'C': [ False ] * 13, 'D': [ False ] * 13 }
for i in range( n ):
pattern, num = sys.stdin.readline().split( " " )
cards[ pattern ][ int( num )-1 ] = True
for pattern in ( 'S', 'H', 'C', 'D' ):
for i in range( 13 ):
if not cards[ pattern ][ i ]:
print(( "{:s} {:d}".format( pattern, i+1 ) )) | p02408 |
n = int(input())
cards, suits = [], ["S", "H", "C", "D"]
for suit in suits:
for x in range(1, 14):
cards.append('{} {}'.format(suit, x))
for _ in range(n):
target = ' '.join(input().split())
if target in cards:
cards.remove(target)
[print(c) for c in cards]
| # ２次元配列バージョン
# かつ、内包表記バージョン
n = int(input())
suits = ["S", "H", "C", "D"]
cards = [[s, n] for s in suits for n in range(1, 14)]
for i in range(n):
target = list(map(
lambda a: int(a) if a.isnumeric() else a, input().split()
))
if target in cards:
cards.remove(target)
[print("{} {}".format(c[0], c[1])) for c in cards]
| p02408 |
n = int(eval(input()))
s = [0 for s in range(13)]
h = [0 for s in range(13)]
c = [0 for s in range(13)]
d = [0 for s in range(13)]
for i in range(n):
design, N = input().split()
N = int(N)
if design == "S":
s[N-1] = 1
elif design == "H":
h[N-1] = 1
elif design == "C":
c[N-1] = 1
else:
d[N-1] = 1
for i in range(13):
if s[i] == 0:
print(("S {0}".format(i + 1)))
for i in range(13):
if h[i] == 0:
print(("H {0}".format(i + 1)))
for i in range(13):
if c[i] == 0:
print(("C {0}".format(i + 1)))
for i in range(13):
if d[i] == 0:
print(("D {0}".format(i + 1)))
| n = int(eval(input()))
card = set()
for i in range(n):
card_type, card_num = input().split()
card.add(card_type + card_num)
for card_type in ["S", "H", "C", "D"]:
for card_num in range(1, 14):
if card_type + str(card_num) not in card:
print((card_type + " " + str(card_num))) | p02408 |
from collections import defaultdict
MAX = 3652425
n, q = list(map(int, input().split()))
lst = [tuple(map(int, input().split())) for _ in range(n)]
restor = [0] * (MAX + 10010)
t0s = [0] * (MAX + 10010)
t1s = [0] * (MAX + 10010)
t2s = [0] * (MAX + 10010)
t3s = [0] * (MAX + 10010)
t1_cnt_save = defaultdict(int)
t3_cnt_save = defaultdict(int)
t1_cnt = 0
t3_cnt = 0
index = 0
for i, line in enumerate(lst):
w, t ,x = line
while index < MAX and w > restor[index]:
t0s[index + 1] += t0s[index]
t1_cnt -= t1_cnt_save[index + 1]
t1s[index + 1] += t1s[index] + t1_cnt
t3_cnt -= t3_cnt_save[index + 1]
t3s[index + 1] += t3s[index] + 2 * t3_cnt
t2s[index + 1] += t2s[index] + t3s[index + 1]
restor[index + 1] = restor[index] + 1 + t0s[index] + t1s[index] + t2s[index]
index += 1
if w <= restor[index]:
print(index)
if t == 0:
t0s[index] += 1
t0s[index + x] -= 1
elif t == 1:
t1_cnt += 1
t1_cnt_save[index + x] += 1
t1s[index] += 1
t1s[index + x] -= x
elif t == 2:
t3_cnt += 1
t3_cnt_save[index + x] += 1
t3s[index] += 1
t3s[index + x] -= x * 2 - 1
t2s[index] += 1
t2s[index + x] -= x ** 2
else:print("Many years later")
for _ in range(q):
y = int(eval(input()))
while index < y:
t0s[index + 1] += t0s[index]
t1_cnt -= t1_cnt_save[index + 1]
t1s[index + 1] += t1s[index] + t1_cnt
t3_cnt -= t3_cnt_save[index + 1]
t3s[index + 1] += t3s[index] + 2 * t3_cnt
t2s[index + 1] += t2s[index] + t3s[index + 1]
restor[index + 1] = restor[index] + 1 + t0s[index] + t1s[index] + t2s[index]
index += 1
print((restor[y]))
| from collections import defaultdict
def main():
MAX = 3652425
n, q = list(map(int, input().split()))
lst = [tuple(map(int, input().split())) for _ in range(n)]
restore = [0] * (MAX + 10010)
t0s = [0] * (MAX + 10010)
t1s = [0] * (MAX + 10010)
t2s = [0] * (MAX + 10010)
t3s = [0] * (MAX + 10010)
t1_cnt_save = defaultdict(int)
t3_cnt_save = defaultdict(int)
t1_cnt = 0
t3_cnt = 0
day = 0
for i, line in enumerate(lst):
w, t ,x = line
while day < MAX and w > restore[day]:
t0s[day + 1] += t0s[day]
if day + 1 in t1_cnt_save: t1_cnt -= t1_cnt_save[day + 1]
t1s[day + 1] += t1s[day] + t1_cnt
if day + 1 in t3_cnt_save: t3_cnt -= t3_cnt_save[day + 1]
t3s[day + 1] += t3s[day] + 2 * t3_cnt
t2s[day + 1] += t2s[day] + t3s[day + 1]
restore[day + 1] = restore[day] + 1 + t0s[day] + t1s[day] + t2s[day]
day += 1
if w <= restore[day]:
print(day)
if t == 0:
t0s[day] += 1
t0s[day + x] -= 1
elif t == 1:
t1_cnt += 1
t1_cnt_save[day + x] += 1
t1s[day] += 1
t1s[day + x] -= x
elif t == 2:
t3_cnt += 1
t3_cnt_save[day + x] += 1
t3s[day] += 1
t3s[day + x] -= x * 2 - 1
t2s[day] += 1
t2s[day + x] -= x ** 2
else:print("Many years later")
for _ in range(q):
y = int(eval(input()))
while day < y:
t0s[day + 1] += t0s[day]
t1_cnt -= t1_cnt_save[day + 1]
t1s[day + 1] += t1s[day] + t1_cnt
t3_cnt -= t3_cnt_save[day + 1]
t3s[day + 1] += t3s[day] + 2 * t3_cnt
t2s[day + 1] += t2s[day] + t3s[day + 1]
restore[day + 1] = restore[day] + 1 + t0s[day] + t1s[day] + t2s[day]
day += 1
print((restore[y]))
main()
| p01525 |
A, B, C = list(map(int, input().split()))
for i in range(B):
if i*A%B==C:
print('YES')
exit()
print('NO') | A, B, C = list(map(int, input().split()))
for i in range(1, B+1):
if i*A%B==C:
print('YES')
break
else:
print('NO') | p03730 |
# -*- coding utf-8 -*-
a,b,c=list(map(int,input().split()))
ans="NO"
for i in range(1000000):
if (a*i-c)%b==0:
ans='YES'
break
print(ans)
| a,b,c=list(map(int,input().split()))
ans="NO"
for i in range (100000):
if a*i%b==c:
ans="YES"
break
print(ans)
| p03730 |
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
mod = 10**9+7
A,B,C = list(map(int,input().split()))
extra = []
import time
now = time.time()
mod = A
while True:
mod += A
if mod % B == C:
print("YES")
break
if time.time()-now > 1:
print("NO")
break
| # encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
mod = 10**9+7
A,B,C = list(map(int,input().split()))
extra = []
import time
now = time.time()
for i in range(B):
if i*A % B == C:
print("YES")
break
if i == B-1:
print("NO")
| p03730 |
import sys
read = sys.stdin.read
from math import gcd
def main():
a, b, c = list(map(int, input().split()))
gac = gcd(a, -b)
if c % gac == 0:
print('YES')
else:
print('NO')
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
a, b, c = list(map(int, input().split()))
num = 2
rem = a % b
if rem == c:
print('YES')
sys.exit()
while True:
rem_t = (a * num) % b
if rem_t == c:
print('YES')
sys.exit()
elif rem_t == rem:
print('NO')
sys.exit()
num += 1
if __name__ == '__main__':
main() | p03730 |
A,B,C = list(map(int,input().split()))
ans = False
for m in range(B):
if m*A%B==C:
ans = True
break
print(('YES' if ans else 'NO'))
| def gcd(x,y):
while y:
x, y = y, x%y
return x
A,B,C = list(map(int,input().split()))
print(('YES' if C%gcd(A,B)==0 else 'NO'))
| p03730 |
a,b,c=list(map(int,input().split()))
for i in range(1,1000000):
if (i*b+c)%a==0:
print('YES')
exit()
print('NO') | a,b,c=list(map(int,input().split()))
for i in range(1,10000):
if (i*b+c)%a==0:
print('YES')
exit()
print('NO')
| p03730 |
a,b,c=list(map(int,input().split()))
for i in range(1,10**6):
if (a*i)%b==c:
print('YES')
exit()
print('NO') | a,b,c=list(map(int,input().split()))
for i in range(1,b):
if (i*a)%b==c:
print('YES')
exit()
print('NO') | p03730 |
A,B,C = (int(i) for i in input().split())
dekiru = False
for i in range(B):
if((A*(i+1))%B == C):
dekiru = True
if dekiru:
print("YES")
else:
print("NO") | A,B,C = (int(i) for i in input().split())
dividable = False
for i in range(B):
if A*(i+1) % B == C:
dividable = True
if dividable:
print("YES")
else:
print("NO") | p03730 |
row = list(map(int, input().split()))
Flag = False
for i in range(10000000):
if row[0]*i % row[1] == row[2]:
Flag = True
break
if Flag:
print("YES")
else:
print("NO") | row = list(map(int, input().split()))
Flag = False
for i in range(1000000):
if row[0]*i % row[1] == row[2]:
Flag = True
break
if Flag:
print("YES")
else:
print("NO") | p03730 |
a,b,c=list(map(int,input().split()))
x=1
data=set()
now=0
while x==1:
now+=a
now%=b
if now==c:
print('YES')
break
if now in data:
print('NO')
break
data|={now,} | a,b,c=list(map(int,input().split()))
res='NO'
for i in range(1,b+1):
if (a*i)%b==c:
res='YES'
break
print(res) | p03730 |
import math
a, b, c = list(map(int,input().split()))
for i in range(10**7):
n = a * i
if n % b == c:
print('YES')
quit()
print('NO') | a, b, c = list(map(int,input().split()))
for i in range(b):
n = a * i
if n % b == c:
print('YES')
quit()
print('NO') | p03730 |
a,b,c = list(map(int,input().split()))
import sys
for i in range(1000):
if (c + a * i) % b == 0:
print('YES')
sys.exit()
print('NO') | a,b,c = list(map(int,input().split()))
import sys
for i in range(1,b+1):
if ( a * i) % b == c:
print('YES')
sys.exit()
print('NO') | p03730 |
A, B, C=list(map(int, input().split(" ")))
mod=[]
pivot=1
step=1
while True:
pivot = (step*A)%B
if (step*A)%B==C:
print('YES')
#print('debug', step)
break
elif pivot in mod:
print('NO')
break
else:
mod.append(pivot)
step=step+1 | A, B, C=list(map(int, input().split(" ")))
candidate=[(A*i)%B for i in range(1, B-1)]
if C in candidate:
print('YES')
else:
print('NO') | p03730 |
# -*- coding: utf-8 -*-
# AtCoder Beginner Contest
# Problem B
if __name__ == '__main__':
a, b, c = list(map(int, input().split()))
count = 1
while count < 10001:
if ((a * count) % b) == c:
print('YES')
exit()
count += 1
print('NO')
| # -*- coding: utf-8 -*-
# AtCoder Beginner Contest
# Problem B
if __name__ == '__main__':
a, b, c = list(map(int, input().split()))
count = 1
while count < (b + 1):
if ((a * count) % b) == c:
print('YES')
exit()
count += 1
print('NO')
| p03730 |
a,b,c = list(map(int, input().split()))
ans = "NO"
for x in range(b+1):
if (a*x) % b == c:
ans = "YES"
break
print(ans) | a,b,c = list(map(int, input().split()))
ans = "NO"
for i in range(1, b+1):
if (a*i) % b == c:
ans = "YES"
break
print(ans) | p03730 |
A,B,C=list(map(int,input().split()))
a=[A*(i+1)%B for i in range(B)]
if C in a:
print('YES')
else:
print('NO') | A,B,C=list(map(int,input().split()))
for i in range(B):
if A * (i+1) % B == C:
print("YES")
exit()
print("NO") | p03730 |
a,b,c =list(map(int,input().split()))
D=[]
for n in range(1, 10000):
if((a * n) % b) == c:
D.append("Y")
if len(D)>0:
print("YES")
else:
print("NO")
| A, B, C = list(map(int,input().split()))
for i in range(100):
if A*i%B==C:
print("YES")
break
else:
print("NO") | p03730 |
a,b,c = list(map(int,input().split()))
count = 0
if a%2==0 and b%2==0 and c%2!=0:
print("NO")
else:
for i in range(1,1000):
x = a*i
for j in range(1,1000):
if x%b == c:
count += 1
else:
continue
if count==0:
print("NO")
else:
print("YES") | a,b,c, = list(map(int,input().split()))
print(('YES' if any(a*i%b==c for i in range(1,b+1)) else 'NO')) | p03730 |
a, b, c = list(map(int, input().split()))
A = a
for i in range(10**7 + 1):
A += a
if A%b == c:
print("YES")
exit()
print("NO") | a, b, c = list(map(int, input().split()))
for i in range(1, b+1):
if (a*i)%b == c:
print("YES")
exit()
print("NO") | p03730 |
A, B, C = list(map(int, input().split()))
ans = 'NO'
for i in range(1, 1000):
if A*i % B == C:
ans = 'YES'
print(ans)
|
A, B, C = list(map(int, input().split()))
ans = 'NO'
for i in range(1, 1000):
if A*i % B == C:
ans = 'YES'
break
print(ans)
| p03730 |
def resolve():
a, b, c = list(map(int, input().split()))
ans = "NO"
for i in range(1, b+1):
if a * i % b == c:
ans = 'YES'
print(ans)
resolve() | def resolve():
a, b, c = list(map(int, input().split()))
ans = 'NO'
for i in range(1, b):
if a*i % b == c:
ans = 'YES'
print(ans)
resolve() | p03730 |
import sys
if sys.platform =='ios':
sys.stdin=open('input_file.txt')
a,b,c=list(map(int,input().split()))
if any((a*i)%b==c for i in range(1,b+1)):
print("YES")
else:
print("NO") | import sys
a,b,c=list(map(int,input().split()))
for i in range(b):
if (a*i)%b==c:
print("YES")
sys.exit()
print("NO") | p03730 |
a, b, c = list(map(int, input().split()))
ans = 'NO'
if a < b and c%a == 0:
ans = 'YES'
else:
for i in range(1, 100000):
if (b*i + c)%a == 0:
ans = 'YES'
break
print(ans) | a, b, c = list(map(int, input().split()))
ans = 'NO'
if a < b and c%a == 0:
ans = 'YES'
else:
for i in range(1, 10000):
if (b*i + c)%a == 0:
ans = 'YES'
break
print(ans) | p03730 |
a, b, c = list(map(int, input().split()))
ans = 'NO'
if a < b and c%a == 0:
ans = 'YES'
else:
for i in range(1, 1000):
if (b*i + c)%a == 0:
ans = 'YES'
break
print(ans) | a, b, c = list(map(int, input().split()))
ans = 'NO'
if a < b and c%a == 0:
ans = 'YES'
else:
for i in range(1, 100):
if (b*i + c)%a == 0:
ans = 'YES'
break
print(ans) | p03730 |
from sys import stdin
if __name__ == "__main__":
_in = [_.rstrip() for _ in stdin.readlines()]
A,B,C = list(map(int,_in[0].split(' '))) # type:list(int)
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
mod_arr = []
a = 1
while True:
_ = (a*A)%B
if _ == C:
TF = 'YES'
break
elif _ in mod_arr:
TF = 'NO'
break
else:
mod_arr.append(_)
a+=1
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
print(TF)
| from sys import stdin
if __name__ == "__main__":
_in = [_.rstrip() for _ in stdin.readlines()]
A,B,C = list(map(int,_in[0].split(' '))) # type:list(int)
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
for a in range(1,B+1):
_ = (a*A)%B
if _ == C:
TF = 'YES'
break
else:
TF = 'NO'
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
print(TF)
| p03730 |
a,b,c=list(map(int,input().split()))
for i in range(10**6):
if (i*b+c)%a==0:
print("YES")
exit()
print("NO")
| a, b, c = list(map(int, input().split()))
tmp = 0
for i in range(1, b + 1):
tmp = a * i
if tmp % b == c:
print("YES")
exit()
print("NO") | p03730 |
A, B, C = list(map(int, input().split()))
lis = list(range(1, 100000))
AA =0
for i in lis:
AA = A*i
if AA%B == C:
print('YES')
break
else:
print('NO') | A, B, C = list(map(int, input().split()))
for i in range(1, 500):
if (A * i) % B == C:
print('YES')
break
else:
print('NO') | p03730 |
a,b,c=list(map(int,input().split()))
l=[]
for i in range(1,min(a,b)+1):
if a%i==0 and b%i==0:
l.append(i)
if l==[]:
print("YES")
elif c%l[-1]==0:
print("YES")
else:
print("NO") | a,b,c=list(map(int,input().split()))
d=False
for i in range(1,b+1):
if a*i%b==c:
d=True
break
if d==True:
print("YES")
else:
print("NO")
| p03730 |
A, B, C = list(map(int, input().split()))
a = A
count = 10001
result = 'NO'
while count > 0:
if A%B == C:
result = 'YES'
break
A += a
count -= 1
print(result) | A, B, C = list(map(int, input().split()))
a = A
result = 'NO'
for _ in range(10001):
if A%B == C:
result = 'YES'
break
A += a
print(result) | p03730 |
A, B, C = list(map(int,input().split()))
for i in range(1,10000):
a = A*i
if a % B == C:
print('YES')
exit()
print('NO')
| A, B, C = list(map(int,input().split()))
for i in range(1,B+1):
a = A*i
if a % B == C:
print('YES')
exit()
print('NO')
| p03730 |
A,B,C = list(map(int,input().split()))
flag = 0
for i in range(B):
if (i*A)%B==C:
flag = 1
break
if flag==1:
print("YES")
else:
print("NO") | A,B,C = list(map(int,input().split()))
flag = 0
for k in range(B):
if (k*A)%B==C:
flag = 1
break
if flag==1:
print("YES")
else:
print("NO") | p03730 |
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
a, b, c = list(map(int, input().split()))
for i in range(1, 100000):
if (b*i + c)%a == 0:
print("YES")
exit()
print("NO") | a, b, c = list(map(int, input().split()))
for i in range(1, 100000):
if a*i % b == c:
print("YES")
exit()
print("NO") | p03730 |
a, b, c = list(map(int, input().split()))
for i in range(1, 100000):
if a*i % b == c:
print("YES")
exit()
print("NO") | a, b, c = list(map(int, input().split()))
for i in range(1, 100):
if a*i % b == c:
print("YES")
exit()
print("NO") | p03730 |
#coding: utf-8
A, B ,C = map(int, input().split())
count = 0
for i in range(A*B):
if(A*i % B == C):
count = 1
else:
print('',end='')
if(count == 1):
print('YES')
else:
print('NO')
| #coding: utf-8
A, B ,C = list(map(int, input().split()))
count = 0
for i in range(A*B):
if(A*i % B == C):
print('YES')
break
else:
print('NO') | p03730 |
a, b, c = list(map(int, input().split()))
i = 1
while i <= b:
if (a * i) % b == c:
print("YES")
exit()
i += 1
print("NO") | a, b, c = list(map(int, input().split()))
for i in range(1, 101):
if a * i % b == c:
print("YES")
exit()
else:
print("NO") | p03730 |
a, b, c = list(map(int, input().split()))
for i in range(1, 101):
if i * a % b == c:
print("YES")
exit()
else:
print("NO")
| a, b, c = list(map(int, input().split()))
for i in range(1, 100):
if (a * i) % b == c:
print("YES")
exit()
else:
print("NO") | p03730 |
# ABC 60 B
def resolve():
A, B, C = list(map(int, input().split()))
for i in range(B+1):
if A * i % B == C:
print('YES')
return
print('NO')
if __name__ == "__main__":
resolve()
| def resolve():
a, b, c = list(map(int, input().split()))
for i in range(1, 100):
if a * i % b == c:
print("YES")
return
print("NO")
return
if __name__ == "__main__":
resolve()
| p03730 |
# B - Choose Integers
def main():
a, b, c = list(map(int, input().split()))
for i in range(1, 1000):
if a*i % b == c:
print('YES')
exit()
else:
print('NO')
if __name__ == "__main__":
main() | # B - Choose Integers
def main():
a, b, c = list(map(int, input().split()))
for i in range(1, a*b+1):
if a*i % b == c:
print('YES')
exit()
else:
print('NO')
if __name__ == "__main__":
main() | p03730 |
a = list(map(int,input().split()))
b = "NO"
for i in range(10000):
if i%a[0]==0 and i%a[1]==a[2]:
b = "YES"
else:
print(b) | A,B,C = list(map(int,input().split()))
z = "NO"
for i in range(10000):
if i%A==0 and i%B==C:
z = "YES"
print(z)
| p03730 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.