Go: package main

import (
	"fmt"
	"bufio"
	"os"
	"strconv"
)

func nextInt(sc *bufio.Scanner) int {
	sc.Scan()
	v, _ := strconv.Atoi(sc.Text())
	return v
}

func min(x, y int) int {
	if x > y {
		return y
	}
	return x
}

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)

	n := nextInt(sc)

	P := make([]int, n+1)
	for i := 1; i <= n; i++ {
		l := nextInt(sc)
		P[i-1] = l
		m := nextInt(sc)
		P[i] = m
	}

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

	for l := 2; l <= n; l++ {
		for i := 1; i <= n - l + 1; i++ {
			j := i + l - 1
			matrix[i][j] = (1 << 21)
			for k := i; k <= j-1; k++ {
				matrix[i][j] = min(matrix[i][j], matrix[i][k] + matrix[k+1][j] + P[i-1] * P[k] * P[j])
			}
		}
	}
	fmt.Println(matrix[1][n])
}

Python: n = int(input())

dimensions = []
for i in range(n):
    a, b = map(int, input().split())
    if i == 0:
        dimensions.append(a)
    dimensions.append(b)
inf = float('inf')
dps = [[inf for _ in range(n)] for _ in range(n)]
for i in range(n):
    dps[i][i] = 0
for i in range(n - 1, -1, -1):
    for j in range(i + 1, n):
        for k in range(i, j):
            dps[i][j] = min(dps[i][j],
                            dps[i][k] + dps[k + 1][j] + (dimensions[i] * dimensions[k + 1] * dimensions[j + 1]))
print(dps[0][n - 1])

Python: N = int(input())
M = [[int(x) for x in input().split()] for _ in range(N)]

p = []

for m in M:
    p.append(m[0])

p.append(M[-1][1])

dp = [[0] * N for j in range(N)]

for l in range(2, N + 1):
    for i in range(N + 1 - l):
        j = i + l - 1
        dp[i][j] = float("inf")
        for k in range(i, j):
            dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + p[i] * p[k + 1] * p[j + 1])

print(dp[0][N - 1])

Python: # http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_10_B&lang=ja
# http://algorithms.blog55.fc2.com/blog-entry-66.html
# https://www.geeksforgeeks.org/python-program-for-matrix-chain-multiplication-dp-8/
import sys

sys.setrecursionlimit(10 ** 6)
n = int(input())
r = []
for i in range(n):
    a, b = map(int, input().split())
    if i == 0:
        r.append(a)
        r.append(b)
    else:
        r.append(b)

dp = [[float('inf')] * (n + 1) for _ in range(n + 1)]


# dp[i][j] MiMi+1...Mjを計算する最適なコスト
# M[1][2] = M[1][1] + M[2][2] +
def chain_order(i, j):
    if i == j:
        return 0
    if dp[i][j] != float('inf'):
        return dp[i][j]
    for k in range(i, j):
        dp[i][j] = min(dp[i][j], chain_order(i, k) + chain_order(k + 1, j) + r[i - 1] * r[k] * r[j])
    return dp[i][j]


# print(r)
print(chain_order(1, len(r)-1))

Python: n=int(input())
m=[]
for i in range(n-1):
    tmp=list(map(int,input().split()))
    m.append(tmp[0])
m.extend(list(map(int,input().split())))
dp=[[10**9]*n for i in range(n)]
for i in range(n):
    dp[i][i]=0
for W in range(1,n):
    for l in range(n-W):
        r=l+W
        for k in range(l,r+1):
            dp[l][r]=min(dp[l][r],m[l]*m[k]*m[r+1]+dp[l][k-1]+dp[k][r])
print(dp[0][n-1])

Python: def main():
    N = int(input())
    p = []
    for i in range(N):
        a, b = map(int, input().split())
        p.append(a)
    else:
        p.append(b)

    m = [[1e10]*(N+1) for _ in range(N+1)]
    for i in range(N+1):
        m[i][i] = 0

    for l in range(2, N+1):
        for i in range(1, N-l+2):
            j = i + l - 1

            m[i][j] = 1e10
            for k in range(i, j):
                m[i][j] = min(m[i][j], m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j])

    print(m[1][N])


if __name__ == '__main__':
    main()

Python: def resolve():
    # cf. http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_10_B&lang=ja
    # http://agent.inf.kyushu-u.ac.jp/~yokoo/lecture/DA2_03.pdf
    def matrix_chain_multiplication(n):
        """
        連鎖行列積問題：
        n 個の行列について、行列 M_i の次元が与えられたとき、
        積 M_1 M_2...M_n の計算に必要なスカラー乗算の最小の回数を返す
        """
        m = [[0 for x in range(n + 1)] for y in range(n + 1)]
        for l in range(2, n + 1):
            for i in range(1, n - l + 2):
                j = i + l - 1
                m[i][j] = 99000001
                for k in range(i, j):
                    m[i][j] = min(m[i][j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j])
        return m[1][n]

    # M1からMnの行数と、Mnの列数を格納。
    # 積が定義されている以上型が合っているはずなのでその他は不要
    p = []

    # 行列の数n
    n = int(input())

    # 行列Mi(i=1...n)の次元r、c
    # rは行数、cは列数
    for i in range(n):
        listed_input = input().split()
        p.append(int(listed_input[0]))

    p.append(int(listed_input[1]))

    print(matrix_chain_multiplication(n))


resolve()

Python: # -*- coding: utf-8 -*-

import random
import sys
import os
import pprint


"""Matrix Chain Multiplication"""

#fd = os.open('ALDS1_10_B.txt', os.O_RDONLY)
#os.dup2(fd, sys.stdin.fileno())

n = int(input())
col = [0] * (n + 1)
for i in range(n):
    row, column = map(int, input().split())
    col[i] = row
    col[i+1] = column

memo = [[0 for i in range(n+1)] for j in range(n+1)]
#pprint.pprint(memo)

for length in range(2, n+1):
    for start_index in range(1, n - length + 2):
        end_index = start_index + length - 1
        candidates = []
        for split_index in range(start_index, end_index):
            left = memo[start_index][split_index]
            right = memo[split_index + 1][end_index]
            plus = col[start_index - 1] * col[split_index] * col[end_index]
            candidates.append(left + plus + right)

        memo[start_index][end_index] = min(candidates)
        #print('memo', start_index, end_index, memo[start_index][end_index])

#pprint.pprint(memo)
print(memo[1][n])

Python: INF = 10**20
n = int(input())
nlist = []
all_mat = []
for i in range(n):
    a,b = map(int, input().split())
    all_mat.append((a,b))
    if (i == 0):
        nlist = [a,b]
    else:
        nlist.append(b)
        
def cost1(nlist):
    if len(nlist) == 0:
        return 0
    m = min(nlist)
    cost = 0
    mid = nlist.index(m)
    a = nlist[:mid]
    b = nlist[mid+1:]
    while (len(a)>1 and len(a) !=0):
        for i in range(len(a)-1):
            cost += a.pop()*a[-1]
            #print(a)
    while (len(b)>1 and len(b) !=0):
        b.reverse()
        for i in range(len(b)-1):
            cost += b.pop()*b[-1]
            #print(b)
    if (len(a) == 1 and len(b) == 1):
        cost += a.pop()*b.pop()
        #print(a,b)
    cost *= m
    return cost
#[34, 44, 13, 30]
def cost2(nlist, mm):
    if len(nlist) == 0:
        return 0
    m = min(nlist)
    cost = 0
    mid = nlist.index(m)
    a = nlist[:mid+1]
    #print(a)
    b = nlist[mid:]
    #print(b)
    while (len(a)>1 and len(a) !=0):
        a.reverse()
        for i in range(len(a)-1):
            cost += a.pop()*a[-1]
            #print(a)
    while (len(b)>1 and len(b) !=0):
        for i in range(len(b)-1):
            cost += b.pop()*b[-1]
            #print(b)
    if (len(a) == 1 and len(b) == 1):
        cost += m*mm
        #print(a,b)
    cost *= mm
    return cost

copy = nlist[:]
m = min(nlist)
#print(nlist)
c = nlist.count(m)
cost = 0
if (c == 1):
    cost = cost1(nlist)
elif (c >= 2):
    cc = 1
    cut_index = [0]
    mcount = nlist.count(m)
    for i in range(mcount):
        cut_index.append(nlist.index(m))
        nlist.remove(m)
    cut = []
    for i in range(mcount):
        cut.append(nlist[cut_index[i]:cut_index[i+1]])
    cut.append(nlist[cut_index[-1]:])
    #print(cut)
    co1 = cut[0] +[m]+ cut[-1]
    cost += cost1(co1)
    for co2 in cut[1:-1]:
        #print(co2)
        cost += cost2(co2,m)
    co3 = cut[0]+cut[-1]
    if (len(co3)>1):
        cost += (len(cut)-2)*m*min(co3)
print(cost)