Go: package main

/*
連鎖行列積
*/

import (
	"bufio"
	"bytes"
	"fmt"
	"log"
	"math"
	"os"
	"strconv"
	"strings"
)

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

type mem *[][]int

func main() {
	scanner := makeScanner(1024)
	n := eGetInt(scanner)
	p := make([]int, n+1)
	for i := 0; i < n; i++ {
		rowcol := eGetInts(scanner)
		p[i] = rowcol[0]
		p[i+1] = rowcol[1]
	}
	m := make([][]int, n)
	for i := 0; i < n; i++ {
		m[i] = make([]int, n)
	}
	// 初期値の格納
	for i := 0; i < n; i++ {
		for j := i; j < n; j++ {
			if i == j {
				m[i][j] = 0 //  同じ行列へのコストは当然0
			} else {
				m[i][j] = math.MaxInt64
			}
		}
	}

	// num : 行列の数. num == 1の場合は初期値0を格納ずみ
	for num := 2; num <= n; num++ {
		// s : スタート行列番号
		for s := 0; s+num <= n; s++ {
			// t : 終了行列番号
			t := s + num - 1
			// k : 仕切
			for k := s; k < t; k++ {
				m[s][t] = min(m[s][t], m[s][k]+m[k+1][t]+p[s]*p[k+1]*p[t+1])
			}
		}
	}
	fmt.Println(m[0][n-1])
}

////////////////////////////////////////////////////////////////////////////////
// ライブラリ
////////////////////////////////////////////////////////////////////////////////
func makeScanner(maxByte int) *bufio.Scanner {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Buffer(make([]uint8, 0, 8192), maxByte)
	return scanner
}
func makeWordScanner() *bufio.Scanner {
	scanner := makeScanner(8192)
	scanner.Split(bufio.ScanWords)
	return scanner
}
func eGetLine(r *bufio.Scanner) string {
	if r.Scan() {
		return r.Text()
	}
	err := r.Err()
	if err != nil {
		log.Fatal(err)
	}
	// EOF
	return ""
}
func eGetInt(r *bufio.Scanner) int {
	line := eGetLine(r)
	return eAtoi(line)
}
func eGetFields(r *bufio.Scanner) []string {
	line := eGetLine(r)
	return strings.Fields(line)
}
func eGetInts(r *bufio.Scanner) []int {
	fields := eGetFields(r)
	ints := make([]int, len(fields))
	for i := 0; i < len(ints); i++ {
		ints[i] = eAtoi(fields[i])
	}
	return ints
}
func eGetChars(r *bufio.Scanner) []string {
	line := eGetLine(r)
	return strings.Split(line, "")
}
func eAtoi(s string) int {
	n, err := strconv.Atoi(s)
	if err != nil {
		log.Fatal(err)
	}
	return n
}

type ints []int

func (s ints) String() string {
	var buf bytes.Buffer
	buf.WriteString("[")
	sep := ""
	for _, v := range s {
		buf.WriteString(fmt.Sprintf("%s%d", sep, v))
		sep = ", "
	}
	buf.WriteString("]")
	return buf.String()
}

func reverse(a ints) ints {
	r := make(ints, len(a))
	for i := 0; i < len(a); i++ {
		r[i] = a[len(a)-1-i]
	}
	return r
}
func max(a ints) (int, bool) {
	if len(a) == 0 {
		return 0, false
	}
	m := a[0]
	for _, e := range a {
		if e > m {
			m = e
		}
	}
	return m, true
}

// func min(a []int) int {
// 	m := a[0]
// 	for _, v := range a {
// 		if v < m {
// 			m = v
// 		}
// 	}
// 	return m
// }

func sum(a ints) int {
	if len(a) == 0 {
		return 0
	}
	sum := 0
	for _, e := range a {
		sum += e
	}
	return sum
}
func find(n int, a ints) int {
	for i, v := range a {
		if n == v {
			return i
		}
	}
	return -1
}

C++: #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i < (n); ++i)
using namespace std;
typedef long long ll;

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);

    int n;
    cin >> n;

    vector<int> r(n), c(n);
    rep(i, n) cin >> r[i] >> c[i];

    const int INF = 1001001001;
    vector<vector<int>> dp(n, vector<int>(n, INF));
    rep(i, n) dp[i][i] = 0;
    for(int w = 1; w < n; ++w) for(int i = 0; i < n-w; ++i){
        int j = i + w;
        for(int k = i; k < j; ++k){
            dp[i][i+w] = min(dp[i][i+w], dp[i][k] + dp[k+1][i+w] + r[i]*c[k]*c[j]);
        }
    }

    // rep(i, n){
    //     rep(j, n) cout << dp[i][j] << " ";
    //     cout << endl;
    // }

    cout << dp[0][n-1] << endl;

    return 0;
}

C++: /**
 * 	matrix chain multiplication
 * 	f(n,m) = multiply Mn*M(n+1)*...*M(m-1)*M(m)
 * 	f(n,n) = 1
 * 	r(n)=c(n-1)
 * 	f(n,n+1) = C(n) * R(n) * C(n+1) = c(n) * c(n-1) * c(n+1)
 * 	f(n,k,m) = f(n,k)*f(k+1,m)*C(n)*r(n)*c(k)
 * 	f(n,m) = min(f(n,k,m)
 */

#include <iostream>
#include <cmath>
#include <climits>

using namespace std;

int r[45] = {0};
int a[100][100] = {0};

int f(int n, int m);
int f(int n, int k, int m);


int f(int n, int k, int m)
{
	return f(n,k) + f(k+1,m) + (r[n] * r[k+1] * r[m+1]);
}

int f(int n, int m)
{
	if (n==m) return 0;
	int & ra = a[n][m];
	if (ra) return ra;
	ra = INT_MAX;
	for (int k=n;k<m;k++)
	{
		int ans = f(n,k,m);
		if (ans < ra) ra = ans;
	}
	return ra;
}

int main()
{
	int rr = 0;
	int cc = 0;
	int n = 0;
	cin >> n;
	for (int i=0;i<n;i++)
	{
		cin >> rr >> cc;
		r[i]=rr;
		r[i+1]=cc;
	}
	for (int i=0;i<n-1;i++)
	{
		a[i][i+1] = r[i] * r[i+1] * r[i+2];
	}
	int ans = f(0,n-1);
	cout << ans << endl;
}

C++: //  AOJ Algorithms and Data Structures I - Dynamic Programming - Matrix Chain Multiplication
// s 2013 0925 1640
// e 

/* 2014 0329 1621

イメージ的には
---------------------
|M11|M12|M13|   |   | 
---------------------
|   |M22|M23|   |   | 
---------------------
|   |   |M33|   |   |  
---------------------
|   |   |   |M44|   |
---------------------
|   |   |   |   |M55|
---------------------

-------------------
|r1|r2|r3|r4|r5|r6|
-------------------

この二つを作って使う

*/


#include<iostream>
#include<cstdio>
#include<vector>

using namespace std;


//コストの計算 costを参照渡しで持ってきて、直接入れる
// s eはstart end の略でcostの配列添え字
void cal_cost(vector< vector<int> >& cost, vector<int> r, int s, int e){
	int ans;
	int k; //切る場所 (k=2 なら、　1|234 )

	if(s==e){ cost[s][e]=0; } //Miiのコストは0
	else{
		cost[s][e]=2000000000; //最小値求めるためのセンチネル　数値は適当
		for(k=s+1; k<=e; k++){
			ans = cost[s][k-1] + cost[k][e] + r[s]*r[k]*r[e+1];
			if(ans<cost[s][e]) cost[s][e] = ans;
		}
	}
}


//http://algorithms.blog55.fc2.com/blog-entry-66.html
//このホームページ見て正解っぽく動的計画法で書いてみる版
int DP_myself( vector< vector<int> > A, int n){
	int i, diff;

	//最終的な出力は最小コストだけでいいので、かけ算の順番は保存しない。するとしたら、cost配列を構造体にして、ルーツの保存しとけば、それでたどれると思う
	// (cost[][]の使い方)  M_ijのコストをcost[i][j]に入れる (M11, M22等はコスト0)
	vector< vector<int> > cost(n,vector<int>(n)); //Mijにかかるコスト（最少）

	//行とか列の長さを入れる配列
	vector<int> r(n+1);

	//rを埋めてく
	for(i=0;i<n;i++){
		r[i]=A[i][0];
	}
	r[n]=A[n-1][1];

	//costを埋めていく(右斜め下に進んで。ピラミッド状に)
	for(diff=0; diff<n; diff++){
		for(i=0; i+diff<n; i++){
			// デバッグ用printf("%d,%d,%d\n", diff,i,i+diff);
			cal_cost(cost, r, i, i+diff); //コストの計算
		}
		
	}

	cout << cost[0][n-1] << endl;

	return 0;
}


int main(){
	int i;
	int n;
	int num_multi=0;
	
	cin >> n;
	//dequeやlistでなくても、途中の要素の削除できるんでvectorでいい。
	// C++で2次元配列を動的に確保する方法 http://samidarehetima.blog9.fc2.com/blog-entry-95.html
	//連鎖行列はA[0][] ~ A[n-1][] まで。
	vector<vector<int> > A(n,vector<int>(2)); //[][0]=r, [][1]=c
	for(i=0;i<n;i++){
		cin >> A[i][0];
		cin >> A[i][1];
	}


	DP_myself(A,n);

    return 0;
}

C++: // ALDS1_10_B.cpp
// Dynamic Programming - Matrix Chain Multiplication

#include <iostream>
#include <algorithm>
#include <vector>
#include <climits>
using namespace std;
static const int N = 100;
int main()
{
    int n;
    int P[N + 1];
    int m[N + 1][N + 1];
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> P[i] >> P[i + 1];
    }

    for (int k = 0; k < n; k++) {
        for (int i = 1; i + k <= n; i++) {
            if (k == 0) m[i][i+k] = 0;
//            else if (k == 1) m[i][i+1] = P[i - 1] * P[i] * P[i + 1];
            else {
                int res = INT_MAX;
                for (int j = 0; j < k; j++) {
                    res  = min(res, m[i][i+j] + m[i+j+1][i+k] + P[i-1] * P[i+j] * P[i+k]);
                }
                m[i][i+k] = res;
            }
        }
    }

    cout << m[1][n] << endl;
    return 0;
}