Go: package main

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

//util
var sc = bufio.NewScanner(os.Stdin)

func nextStr() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

func printList(list []int) {
	buf := bufio.NewWriter(os.Stdout)
	for _, v := range list {
		buf.Write([]byte(fmt.Sprintf(" %d", v)))
	}
	buf.Write([]byte("\n"))
	buf.Flush()
}

//solve
//単純な場合
func matrixChainMultiplication() {
	//行列が1つだけのとき
	for i := 1; i <= n; i++ {
		m[i][i] = 0
	}
	for l := 2; l <= n; l++ {
		for i := 1; i <= n-l+1; i++ {
			j := i + l - 1
			m[i][j] = 1 << 21
			//kまでで区切る
			for k := i; k <= j-1; k++ {
				m[i][j] = min(m[i][j], m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j])
			}
		}
	}
}

func max(a, b int) int {
	if a > b {
		return a
	} else {
		return b
	}
}

func min(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}

const MAX = 100

var n int
var p [MAX + 1]int

//m[i][j]: Mi * Mi+1 * ... * Mjを計算するときに必要なスカラー乗算の最小回数
var m [MAX + 1][MAX + 1]int

func main() {
	sc.Split(bufio.ScanWords)
	n = nextInt()
	for i := 1; i <= n; i++ {

		p[i-1] = nextInt() //行数
		p[i] = nextInt()   //列数
	}

	matrixChainMultiplication()
	fmt.Println(m[1][n])
}

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)

Python: n = int(input())

p = [0 for i in range(n+1)]
for i in range(n):
    p[i],p[i+1] = map(int,input().split())
    
m = [[0 for i in range(n)] for j in range(n)]

for l in range(1,n):
    for i in range(0,n-l):
        j = i + l
        m[i][j]= float("inf")
        for k in range(i,j):
            m[i][j] = min(m[i][j],m[i][k] + m[k+1][j] + p[i]*p[k+1]*p[j+1])


print(m[0][n-1])

Python: import sys

N = int(input())
R = [0]*N
C = [0]*N
for i in range(N):
    R[i], C[i] = map(int, input().split())

INF = 10**18
m = [[INF]*N for i in range(N)]
for i in range(N):
    m[i][i] = 0
for l in range(1, N):
    for i in range(N-l):
        a0 = R[i]
        c0 = C[i+l]
        m[i][i+l] = min(a0*C[j]*c0 + m[i][j] + m[j+1][i+l] for j in range(i, i+l))
print(m[0][N-1])

Python: n = int(input())
nums = []
for _ in range(n):
    nums.append(tuple(map(int,input().split())))
# print(nums)
dp = [[10**9]*n for _ in range(n)]
for i in range(n):
    dp[i][i] = 0
# for i in range(n):
#     print(*dp[i])
for l in range(2,n+1):
    for i in range(n-l+1):
        for k in range(l-1):
            # print(l,i,k,dp[i][i+k],dp[i+k+1][i+l-1])
            dp[i][i+l-1] = min(dp[i][i+l-1],dp[i][i+k] + dp[i+k+1][i+l-1] + nums[i][0]*nums[i+k][1]*nums[i+l-1][1])
print(dp[0][n-1])
# for i in range(n):
#     print(*dp[i])