Buggy python submission (verdict: Time Limit Exceeded):
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(input())
    a = tuple(map(int, input().split()))
    print(solve(n, a))


Fixed submission:
# https://kyopro-friends.hatenablog.com/entry/2019/01/12/231035


def div_cost(left, right):
    # 区間[left, right]が一匹にまとまっているとき、それを分解するために必要な最小コスト
    if bl_calculated[left][right]:
        return memo[left][right]
    bl_calculated[left][right] = True
    if left == right:
        memo[left][right] = 0
        return memo[left][right]
    divided_to_alone_cost = INF
    # divided_to_alone_cost: 区間[left, right]を分解してできた2つの区間それぞれをaの各要素まで分解し切るのに必要なコスト
    for mid in range(left, right):
        divided_to_alone_cost = min(divided_to_alone_cost, div_cost(left, mid) + div_cost(mid + 1, right))
    memo[left][right] = divided_to_alone_cost + (c_sum[right] - c_sum[left - 1])
    # (c_sum[right] - c_sum[left - 1]): 区間[left, right]を分解するのにかかるコスト
    return memo[left][right]


INF = float('inf')

N = int(input())
a = list(map(int, input().split()))

c_sum = [0]
for aa in a:
    c_sum.append(c_sum[-1] + aa)
# 累積和c_sum

memo = [[0 for _ in range(N + 1)] for _ in range(N + 1)]
# memo[left][right] = (区間[left, right]に相当するスライムが一匹にまとまっているとき、それを分解するために必要な最小コスト)

bl_calculated = [[False for _ in range(N + 1)] for _ in range(N + 1)]
# memo[left][right]に最小コストが代入済かどうかのBoolean

print(div_cost(1, N))

Buggy python submission (verdict: Time Limit Exceeded):
def rec(frm, to):
    """return: [frm,to)の合体コスト最小値"""
    if to - frm == 1:
        return 0

    if memo[frm][to]:
        return memo[frm][to]

    res = inf
    for mid in range(frm + 1, to):
        res = min(res, rec(frm, mid) + rec(mid, to))
    res += cum_sum[to] - cum_sum[frm]

    memo[frm][to] = res
    return res


inf = float('inf')

n = int(input())
a = list(map(int, input().split()))

cum_sum = [0] * (n + 1)
for i, aa in enumerate(a):
    cum_sum[i + 1] = cum_sum[i] + aa

memo = [[None] * (n + 1) for _ in range(n + 1)]
# memo[frm][to] = メモ化

print(rec(0, n))


Fixed submission:
# https://kyopro-friends.hatenablog.com/entry/2019/01/12/231035


def div_cost(left, right):
    # 区間[left, right]が一匹にまとまっているとき、それを分解するために必要な最小コスト
    if bl_calculated[left][right]:
        return memo[left][right]
    bl_calculated[left][right] = True
    if left == right:
        memo[left][right] = 0
        return memo[left][right]
    divided_to_alone_cost = INF
    # divided_to_alone_cost: 区間[left, right]を分解してできた2つの区間それぞれをaの各要素まで分解し切るのに必要なコスト
    for mid in range(left, right):
        divided_to_alone_cost = min(divided_to_alone_cost, div_cost(left, mid) + div_cost(mid + 1, right))
    memo[left][right] = divided_to_alone_cost + (c_sum[right] - c_sum[left - 1])
    # (c_sum[right] - c_sum[left - 1]): 区間[left, right]を分解するのにかかるコスト
    return memo[left][right]


INF = float('inf')

N = int(input())
a = list(map(int, input().split()))

c_sum = [0]
for aa in a:
    c_sum.append(c_sum[-1] + aa)
# 累積和c_sum

memo = [[0 for _ in range(N + 1)] for _ in range(N + 1)]
# memo[left][right] = (区間[left, right]に相当するスライムが一匹にまとまっているとき、それを分解するために必要な最小コスト)

bl_calculated = [[False for _ in range(N + 1)] for _ in range(N + 1)]
# memo[left][right]に最小コストが代入済かどうかのBoolean

print(div_cost(1, N))

Buggy python submission (verdict: Time Limit Exceeded):
# https://kyopro-friends.hatenablog.com/entry/2019/01/12/231035


def div_cost(left, right):
    # 区間[left, right]が一匹にまとまっているとき、それを分解するために必要な最小コスト
    if bl_calculated[left][right]:
        return memo[left][right]
    bl_calculated[left][right] = True
    if left == right:
        memo[left][right] = 0
        return memo[left][right]
    divided_to_alone_cost = INF
    # divided_to_alone_cost: 区間[left, right]を分解してできた2つの区間それぞれをaの各要素まで分解し切るのに必要なコスト
    for mid in range(left, right):
        divided_to_alone_cost = min(divided_to_alone_cost, div_cost(left, mid) + div_cost(mid + 1, right))
    memo[left][right] = divided_to_alone_cost + (c_sum[right] - c_sum[left - 1])
    # (c_sum[right] - c_sum[left - 1]): 区間[left, right]を分解するのにかかるコスト
    return memo[left][right]


INF = float('inf')

N = int(input())
a = list(map(int, input().split()))

c_sum = [0]
for aa in a:
    c_sum.append(c_sum[-1] + aa)
# 累積和c_sum

memo = [[0 for _ in range(N + 1)] for _ in range(N + 1)]
# memo[left][right] = (区間[left, right]に相当するスライムが一匹にまとまっているとき、それを分解するために必要な最小コスト)

bl_calculated = [[False for _ in range(N + 1)] for _ in range(N + 1)]
# memo[left][right]に最小コストが代入済かどうかのBoolean

print(div_cost(1, N))


Fixed submission:
# https://kyopro-friends.hatenablog.com/entry/2019/01/12/231035


def div_cost(left, right):
    # 区間[left, right]が一匹にまとまっているとき、それを分解するために必要な最小コスト
    if bl_calculated[left][right]:
        return memo[left][right]
    bl_calculated[left][right] = True
    if left == right:
        memo[left][right] = 0
        return memo[left][right]
    divided_to_alone_cost = INF
    # divided_to_alone_cost: 区間[left, right]を分解してできた2つの区間それぞれをaの各要素まで分解し切るのに必要なコスト
    for mid in range(left, right):
        divided_to_alone_cost = min(divided_to_alone_cost, div_cost(left, mid) + div_cost(mid + 1, right))
    memo[left][right] = divided_to_alone_cost + (c_sum[right] - c_sum[left - 1])
    # (c_sum[right] - c_sum[left - 1]): 区間[left, right]を分解するのにかかるコスト
    return memo[left][right]


INF = float('inf')

N = int(input())
a = list(map(int, input().split()))

c_sum = [0]
for aa in a:
    c_sum.append(c_sum[-1] + aa)
# 累積和c_sum

memo = [[0 for _ in range(N + 1)] for _ in range(N + 1)]
# memo[left][right] = (区間[left, right]に相当するスライムが一匹にまとまっているとき、それを分解するために必要な最小コスト)

bl_calculated = [[False for _ in range(N + 1)] for _ in range(N + 1)]
# memo[left][right]に最小コストが代入済かどうかのBoolean

print(div_cost(1, N))