Go: package main

import (
	"fmt"
	"math"
)

func main() {
	var n int
	fmt.Scan(&n)

	p := make([]float64, n+1)
	q := make([]float64, n+1)
	psum := make([]float64, n+2) // i番目はi-1までの和とする
	qsum := make([]float64, n+2) // i番目はi-1までの和とする
	for i := 1; i <= n; i++ {
		fmt.Scan(&p[i])
		psum[i+1] = psum[i] + p[i]
	}
	for i := 0; i <= n; i++ {
		fmt.Scan(&q[i])
		qsum[i+1] = qsum[i] + q[i]
	}

	dp := make([][]float64, n+1)
	for i := 0; i <= n; i++ {
		dp[i] = make([]float64, n+1)
	}

	// calc
	for d := 0; d <= n; d++ {
		for l := 0; l+d <= n; l++ {
			r := l+d
			if l == r {
				dp[l][r] = q[l]
				continue
			}

			dp[l][r] = 1 << 30
			// iは中心となるnode
			for i := l+1; i <= r; i++ {
				left := dp[l][i-1] + psum[i] - psum[l+1] + qsum[i] - qsum[l]
				right := dp[i][r] + psum[r+1] - psum[i+1] + qsum[r+1] - qsum[i]
				dp[l][r] = math.Min(dp[l][r], p[i] + left + right)
			}
		}
	}

	fmt.Printf("%.8f\n", dp[0][n])
}

Python: global memo
global memo_pq
global p_list
global q_list



def mk_memo(i,j):#memo[i][j]を求める
    tmp_min=9999999
    for k in range(1,j-1):
        tmp=p_list[i+k] + memo[i][k] + memo_pq[i][k] + memo[i+k+1][j-k-1] + memo_pq[i+k+1][j-k-1]
        if(tmp < tmp_min):
            tmp_min=tmp
    if(j!=1):
        tmp_min=min([tmp_min, p_list[i] +2*q_list[i] + memo[i+1][j-1] +memo_pq[i+1][j-1]])
        tmp_min=min([tmp_min, p_list[i+j-1] +2*q_list[i+j] + memo[i][j-1] +memo_pq[i][j-1]])
    else:
        tmp_min=p_list[i] + 2*q_list[i] + 2*q_list[i+1]
    memo[i][j]=tmp_min



n=int(input())
p_list=list(map(float,input().split()))
q_list=list(map(float,input().split()))



memo=[[0]*(n+1-i) for i in range(n+1)]#memo[i][j]はlist[i]から始まるj個の部分集合に対する解
memo_pq=[[0]*(n+1-i) for i in range(n+1)]#memo_pq[i][j]はlist[i]から始まる
                                       #ｊ個の部分集合に対応する重みpと重みqの和
for p in range(n+1):
    for q in range(n+1-p):
        if(q==0):
            memo_pq[p][q]=q_list[p]
        else:
            memo_pq[p][q]=memo_pq[p][q-1] + p_list[p+q-1] + q_list[p+q]
    



for i in range(n):
    for j in range(1,2+i):
        mk_memo(n-1-i,j)

print(memo[0][-1])

Python: import sys

n = int(sys.stdin.readline())

ky = list(map(float, sys.stdin.readline().split()))
dm = list(map(float, sys.stdin.readline().split()))
depth = [0]*n
ans = max(max(ky),max(dm))*(n*2+1)*(n+1)

print(ky, dm)


def traverse(d, s, e, note):
    global ans
    if s==e:
        depth[s]=d
        r = 0
        for i in range(n):         r += depth[i]*ky[i]
        r += (depth[0]+1)*dm[0]
        for i in range(1, n):      r += (max(depth[i-1], depth[i])+1)*dm[i]
        r += (depth[n-1]+1)*dm[n]
        if ans>r: ans = r
        return
    for m in range(s, e+1):
        depth[m]=d
        if s<=m-1: traverse(d+1,  s, m-1, 'left')
        if m+1<=e: traverse(d+1, m+1, e, 'right')


traverse(1, 0, n-1, '')
print(ans)

Python: import sys

n = int(sys.stdin.readline())
a = [0.0] * (2*n+1)
b = list(map(float, sys.stdin.readline().split()))
for i,c in enumerate(b):    a[i*2+1] = c
b = list(map(float, sys.stdin.readline().split()))
for i,c in enumerate(b):    a[i*2] = c
depth = [0]*(n*2+1)
ans = max(a)*(n*2+1)*(n+1)
def walk(d, s, e):
    global ans
    if s>=e:
        depth[s*2+1]=d
        er = 0
        for i in range(0,n*2+1,2):
            if i==0:      depth[i]=depth[i+1]+1
            elif i==n*2:  depth[i]=depth[i-1]+1
            else:         depth[i]=max(depth[i-1],depth[i+1])+1
        for i in range(n*2+1):
            er += (depth[i]+1)*a[i]
        if ans>er: ans = er
        return
    for m in range(s, e+1):
        depth[m*2+1]=d
        if s<=m-1:  walk(d+1,  s, m-1)
        if m+1<=e:  walk(d+1, m+1, e)
        
walk(0, 0, n-1)
print(ans)

Python: #!/usr/bin/env python3
# ALDS_10_D: Dynamic Programming - Optimal Binary Search Tree


def optimal_cost(n, kp, dp):
    sums = [sum(kp[0:i]) + sum(dp[0:i+1]) for i in range(n+1)]
    expects = [[kp[i] + (dp[i] + dp[i+1])*2 for i in range(n)]]

    for w in range(2, n+1):
        exps = []
        for i in range(n-w+1):
            j = i + w
            exp = min(dp[i] + expects[j-i-2][i+1], expects[j-i-2][i] + dp[j])
            for k in range(i+1, j-1):
                _exp = expects[k-i-1][i] + expects[j-k-2][k+1]
                if exp > _exp:
                    exp = _exp
            exps.append(exp + sums[j] - sums[i] + dp[i])
        expects.append(exps)

    return expects[-1][0]


def run():
    n = int(input())
    ps = [float(x) for x in input().split()]
    qs = [float(x) for x in input().split()]

    print("{:.8f}".format(optimal_cost(n, ps, qs)))


if __name__ == '__main__':
    run()

Python: import sys

n = int(sys.stdin.readline())

ky = list(map(float, sys.stdin.readline().split()))
dm = list(map(float, sys.stdin.readline().split()))
depth = [0]*n
ans = max(max(ky),max(dm))*(n*2+1)*(n+1)


def traverse(d, s, e, note):
    global ans
    if s==e:
        depth[s]=d
        r = 0
        for i in range(n):         r += depth[i]*ky[i]
        r += (depth[0]+1)*dm[0]
        for i in range(1, n):      r += (max(depth[i-1], depth[i])+1)*dm[i]
        r += (depth[n-1]+1)*dm[n]
        if ans>r: ans = r
        return
    for m in range(s, e+1):
        depth[m]=d
        if s<=m-1: traverse(d+1,  s, m-1, 'left')
        if m+1<=e: traverse(d+1, m+1, e, 'right')


traverse(1, 0, n-1, '')
print(ans)

Python: import sys
def input():
    return sys.stdin.readline()[:-1]
    
n = int(input())
p = [None] + list(map(float, input().split()))
q = list(map(float, input().split()))
T = [[500 for i in range(n+1)] for j in range(n+1)]

psum = [0] * (n+1)
qsum = [0] * (n+1)
qsum[0] = q[0]
for i in range(1,n+1):
    psum[i] = psum[i-1] + p[i]
    qsum[i] = qsum[i-1] + q[i]
    
for i in range(1,n+1):
    T[i][i] = p[i] + (q[i-1] + q[i])*2
    
for l in range(2,n+1):
    for i in range(1,n-l+1+1):
        val_list = [T[i][j] + T[j+2][i+l-1] for j in range(i,i+l-2)]
        val_list.append(T[i][i+l-2] + q[i+l-1])
        val_list.append(T[i+1][i+l-1] + q[i-1])
        if i-2>=0:
            w = psum[i+l-1]-psum[i-1] + qsum[i+l-1]-qsum[i-2]
        else:
            w = psum[i+l-1]-psum[i-1] + qsum[i+l-1]
        T[i][i+l-1] = min(val_list) + w
        
print(T[1][n])

Python: import sys
readline = sys.stdin.readline
write = sys.stdout.write

N = int(readline())
*P, = map(float, readline().split())
*Q, = map(float, readline().split())

K = [[None]*(N+1) for i in range(N+1)]
C = [[None]*(N+1) for i in range(N+1)]
S = [0]*(2*N+2)
for i in range(2*N+1):
    S[i+1] = S[i] + (P[i//2] if i % 2 else Q[i//2])

for i in range(N+1):
    C[i][i] = Q[i]
    K[i][i] = i

for l in range(1, N+1):
    for i in range(N+1-l):
        j = i+l
        k0 = K[i][j-1]; k1 = K[i+1][j]
        tmp = 1e30
        k2 = None
        for k in range(k0, min(k1+1, j)):
            v = C[i][k] + C[k+1][j]
            if v < tmp:
                k2 = k
                tmp = v
        K[i][j] = k2
        C[i][j] = tmp + (S[2*j+1] - S[2*i])
write("%.10f\n" % C[0][N])

Python: n=int(input())
p=[float(i) for i in input().split()]
q=[float(i) for i in input().split()]
pq = [q[-1]]*(2*n+1)
dp = {}
for i in range(n):
    pq[2*i] = q[i]
    pq[2*i+1] = p[i]
pq = [0.0]+pq
for j in range(len(pq)):
    for i in range(len(pq)-j):
        if j == 0:
            dp[(i,i+j)] = 0.0
        elif j == 1:
            dp[(i,i+j)] = pq[i+j]
        else:
            tmp = 1001
            for k in range(j):
                c = dp[(i,i+k)] + dp[(i+k+1,i+j)]+sum(pq[i+1:i+j+1])
                if c < tmp:
                    if j == len(pq)-1 and i+k % 2 == 1:
                        continue
                    tmp = c
            dp[(i,i+j)] = tmp
print(dp[(0,2*n+1)])