Go: package main

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

var scanner = bufio.NewScanner(os.Stdin)

func nextString() string {
	scanner.Scan()
	return scanner.Text()
}

func nextInt() int {
	n, err := strconv.Atoi(nextString())
	if err != nil {
		fmt.Printf("strconv.Atoi failed: %v\n", err)
	}
	return n
}

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

func stringifyArray(arr []int) string {
	return strings.TrimRight(fmt.Sprintf("%+v", arr)[1:], "]")
}

func main() {
	scanner.Split(bufio.ScanWords)

	n := nextInt()
	m := make([][]int, n)
	sizes := make([][]int, n)
	for i := 0; i < n; i++ {
		sizes[i] = []int{nextInt(), nextInt()}
		m[i] = make([]int, n)
	}
	// fmt.Println(sizes)

	for w := 1; w < n; w++ {
		for i := 0; i < n-w; i++ {
			j := i + w
			minBetweenIandJ := 10000000
			for k := i; k < j; k++ {
				// fmt.Println(i, j, k, m[i][k], m[k+1][j], sizes[i][0]*sizes[k][1]*sizes[j][1])
				minBetweenIandJ = min(minBetweenIandJ, m[i][k]+m[k+1][j]+sizes[i][0]*sizes[k][1]*sizes[j][1])
			}
			m[i][j] = minBetweenIandJ
		}
	}
	// for i := 0; i < len(m); i++ {
	// 	fmt.Println(stringifyArray(m[i]))
	// }
	fmt.Println(m[0][n-1])
}

Python: def matrix_chmul(matrices):
    length = len(matrices)
    dp = [[0 for n in range(length)] for m in range(length)]
    rowcol = []
    for i in range(length):
        rowcol.extend(matrices[i])
    for i in range(1, length):
        for j in range(length - i):
            if i == 1:
                dp[j][i + j] = rowcol[j * 2] * rowcol[(i + j) * 2] * rowcol[(i + j) * 2 + 1]
            else:
                temp_min = float("inf")
                for k in range(0, i):
                    # print(i, j, k, dp[j][j + k], dp[j + k + 1][i + j])
                    dp[j][i + j] = min(temp_min, (dp[j][j + k] + dp[j + k + 1][i + j] + rowcol[j * 2] * rowcol[(j + k + 1) * 2] * rowcol[(i + j) * 2 + 1] ))
                    temp_min = dp[j][i + j]
        # print(dp)
    return dp[0][length - 1]

length = int(input())
matrices = [[0 for n in range(2)] for m in range(length)]
for _ in range(length):
    x, y = [int(n) for n in input().split(" ")]
    matrices[_] = x, y
print(matrix_chmul(matrices))

Python: import sys, itertools

n = int(sys.stdin.readline())
MM = [list(map(int, sys.stdin.readline().split())) for _ in range(n)]

amin = 0
m = MM[0][:]
for i in range(n-1):
    amin += m[0]*m[1]*MM[i+1][1]
    m[1]=MM[i+1][1]


for t in itertools.permutations(range(n-1), n-2):

    mm=[m[:] for m in MM]
    o = list(t)
    ans=0
    for _ in range(n-2):
        i = o.pop(0)
        ans += mm[i][0]*mm[i+1][1]*mm[i][1]
        if ans>amin: break
        mm[i][1] = mm[i+1][1]
        mm.pop(i+1)
        
        for j in range(len(o)):
            if o[j]>i: o[j] -=1
    else:
        ans += mm[0][0]*mm[0][1]*mm[1][1]
        if amin>ans: amin=ans


print(amin)

Python: def multi_chain_multiplication(n, P):
    M = [[0]*(n+1) for _ in range(n+1)]

    if n > 1:
        for l in range(2, n+1):
            for i in range(1, n-l+2):
                j = i + l - 1
                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-1] * P[k] * P[j])
        return M[i][j]
    else:
        return 0

def read_and_print_min_multiplication(n):
    P = [0] * (n+1)
    for i in range(n):
        A = [int(i) for i in input().split()]
        if i == 0:
            P[i] = A[0]
            P[i+1] = A[1]
        else:
            P[i+1] = A[1]
    print(multi_chain_multiplication(n, P))

n = int(input())
read_and_print_min_multiplication(n)

Python: #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    n = I()
    g = LIR(n)
    dp = [[float("inf")]*(n+1) for i in range(n)]
    for i in range(n):
        dp[i][i+1] = 0
    for k in range(1,n+1):
        for l in range(n):
            hl,wl = g[l]
            r = l+k
            if r > n:
                break
            hr,wr = g[r-1]
            nd = dp[l][r]
            for j in range(l+1,r):
                hj,wj = g[j-1]
                cost = hl*wj*wr
                nd = min(nd,dp[l][j]+dp[j][r]+cost)
            if nd < dp[l][r]:
                dp[l][r] = nd
    print(dp[0][n])
    return

#Solve
if __name__ == "__main__":
    solve()

Python: # https://onlinejudge.u-aizu.ac.jp/problems/ALDS1_10_B
import functools

INF = float('inf')
@functools.lru_cache(maxsize=None)
def rec(l, r):
    if l + 1 == r:
        return 0
    ret = INF
    for mid in range(l+1, r):
        ret = min(ret, rec(l, mid) + rec(mid, r)+R[l]*R[mid]*C[r-1])
    return ret


if __name__ == "__main__":
    N = int(input())
    R = []
    C = []
    for _ in range(N):
        r, c = list(map(int, input().split()))
        R.append(r)
        C.append(c)

    print(rec(0, N))

Python: n = int(input())

N = 101

p = [0] * N
m = [[0] * N for _ in range(N)]

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

# print(p)

for l in range(2, n + 1):
	for i in range(1, n - l + 2):
		j = i + l - 1
		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 - 1] * p[k] * p[j])

print(m[1][n])

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


def solve(N,R,C):
    dp = [[float('inf')]*N for _ in range(N)]

    for i in range(N):
        dp[i][i]=0
    for i in range(N-1,-1,-1):
        for j in range(i+1,N):
            for k in range(i,j):
                dp[i][j] = min(dp[i][j],dp[i][k]+dp[k+1][j]+R[i]*C[k]*C[j])
    ans = dp[0][N-1]
    return ans
print(solve(N,R,C))

Python: def maxChain(n,p):
    m = [[0 for i in range(n+1)] for i 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] = float("inf")
            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 str(m[1][n])
n = int(input())
p = []
for i in range(n):
    L = list(map(int, input().split()))
    if i == 0:
        p.append(L[0])
        p.append(L[1])
    else:
        p.append(L[1])
print(maxChain(n,p))

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

import sys
sys.setrecursionlimit(10 ** 9)
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
INF=float('inf')

N=INT()
P=[0]*(N+1)
for i in range(N):
    r,c=MAP()
    if i==0:
        P[i]=r
    P[i+1]=c

dp=[[INF]*(N+1) for i in range(N+1)]
for i in range(N+1):
    dp[i][i]=0

for l in range(2, N+1):
    for i in range(1, N-l+2):
        j=i+l-1
        for k in range(i, j):
            dp[i][j]=min(dp[i][j], dp[i][k]+dp[k+1][j]+P[i-1]*P[k]*P[j])
print(dp[1][N])