結果

問題 No.1247 ブロック登り
ユーザー tpynerivertpyneriver
提出日時 2020-10-19 20:00:50
言語 PyPy3
(7.3.15)
結果
TLE  
実行時間 -
コード長 2,240 bytes
コンパイル時間 515 ms
コンパイル使用メモリ 86,576 KB
実行使用メモリ 317,592 KB
最終ジャッジ日時 2023-09-28 13:24:20
合計ジャッジ時間 7,443 ms
ジャッジサーバーID
（参考情報） 		judge13 / judge14
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 73 ms
75,752 KB
testcase_01 AC 76 ms
70,840 KB
testcase_02 AC 76 ms
70,984 KB
testcase_03 AC 76 ms
71,276 KB
testcase_04 AC 81 ms
71,160 KB
testcase_05 AC 78 ms
70,992 KB
testcase_06 AC 74 ms
71,264 KB
testcase_07 AC 394 ms
83,828 KB
testcase_08 AC 388 ms
84,004 KB
testcase_09 AC 270 ms
80,768 KB
testcase_10 AC 278 ms
81,296 KB
testcase_11 TLE -
testcase_12 -- -
testcase_13 -- -
testcase_14 -- -
testcase_15 -- -
testcase_16 -- -
testcase_17 -- -
testcase_18 -- -
testcase_19 -- -
testcase_20 -- -
testcase_21 -- -
testcase_22 -- -
testcase_23 -- -
testcase_24 -- -
testcase_25 -- -
testcase_26 -- -
testcase_27 -- -
testcase_28 -- -
権限があれば一括ダウンロードができます

ソースコード

diff # 

import sys
readline = sys.stdin.readline

N, K = map(int, readline().split())

A = list(map(int, readline().split()))

INF = 10**9+7

De = [[-INF]*(N+1) for _ in range(N)]

dpl = [[[-INF]*(t+1) for _ in range(N)] for t in range(K)]
dpr = [[[-INF]*(t+1) for _ in range(N)] for t in range(K)]

for i in range(N):
    dpl[0][i][0] = K*A[i]
    dpr[0][i][0] = K*A[i]


for t in range(0, K-1):
    for l in range(N):
        for lp in range(min(t+1, N-l)):
            r = l + lp + 1
            if dpl[t][l][lp] == -INF:
                continue
            dl = dpl[t][l][lp]
            dr = dpr[t][l][lp]
            if t+2 < K and l+1 != r:
                dpl[t+2][l][lp] = max(dpl[t+2][l][lp], dl)
                dpr[t+2][l][lp] = max(dpr[t+2][l][lp], dr)
            
            if l != 0:
                dpl[t+1][l-1][lp+1] = max(dpl[t+1][l-1][lp+1], dl+(K-1-t)*A[l-1])
            if r != N:
                dpr[t+1][l][lp+1] = max(dpr[t+1][l][lp+1], dr+(K-1-t)*A[r])
            
            if t < t+r-l-1 < K:
                dpl[t+r-l-1][l][lp] = max(dpl[t+r-l-1][l][lp], dr)
                dpr[t+r-l-1][l][lp] = max(dpr[t+r-l-1][l][lp], dl)
            
            
            
            if l+1 != r:
                if (K-t)&1:
                    De[l][min(l+K-t, r)] = max(De[l][min(l+K-t, r)], dl)
                else:
                    De[l+1][min(l+K-t, r)] = max(De[l+1][min(l+K-t, r)], dl)

                if l <= r-K+t: 
                    De[r-K+t][r] = max(De[max(l, r-K+t)][r], dr)
                else:
                    if (r-K+t-l)%2 == 0:
                        De[l][r] = max(De[l][r], dr)
                    else:
                        De[l+1][r] = max(De[l+1][r], dr)
              
ans = [-INF]*N
for l in range(N):
    for lp in range(min(K, N-l)):
        r = l + lp + 1  
        ans[l] = max(ans[l], dpl[K-1][l][lp])
        ans[r-1] = max(ans[r-1], dpr[K-1][l][lp])

for l in range(N):
    for r in range(l+1, N+1):
        d = De[l][r]
        for i in range(l, r, 2):
            ans[i] = max(ans[i], d)


Ans = [-INF]*N

for i in range(N):
    if i > 0:
        Ans[i-1] = max(Ans[i-1], ans[i])
    if i < N-1:
        Ans[i+1] = max(Ans[i+1], ans[i])
print('\n'.join(map(str, Ans)))
0