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])
}

C++: #include <bits/stdc++.h>

using namespace std;

#define Vi vector<int>
#define FOR(i,s,e) for (int i=s; i<e; i++)
#define ITER(v) v.begin(), v.end()

constexpr int N_MAX = 100;

int n;
int shape[N_MAX][2];
int dp[N_MAX][N_MAX];

int mcm() {
    FOR(d,0,n) {
        FOR(from,0,n-d) {
            int to = from + d;
            if (from == to) {
                dp[from][to] = 0;
            } else {
                int minval = -1;
                FOR(s,0,d) {
                    int cand = dp[from][from+s] + dp[from+s+1][to]
                        + shape[from][0] * shape[from+s][1] * shape[to][1];
                    if (minval == -1) {
                        minval = cand;
                    } else {
                        minval = min(cand, minval);
                    }
                }
                dp[from][to] = minval;
            }
        }
    }
    return dp[0][n-1];
}

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

    cin >> n;
    FOR(i,0,n) {
        cin >> shape[i][0] >> shape[i][1];
    }
    cout << mcm() << endl;

    return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;

int CountMulti(const int& r1,const int& c1,const int& r2,const int& c2){
	return c1*c2*r1;
}

int main(void){
	int N;
	cin >> N;
	vector<long long> rows(N),cols(N);
	for(int i=0;i<N;i++)
		cin >> rows[i] >> cols[i];

	const long long INF = 1e18;
	long long dp[101][101];
	memset(dp,0,sizeof(dp));
	for(int i=0;i<N;i++){
		for(int j=0;j<N;j++){
			if(i == j)dp[i][j] = 0;
			else dp[i][j] = INF;
		}
	}
	for(int i=0;i<N-1;i++){
		dp[i][i+1] = rows[i]*rows[i+1]*cols[i+1];
	}

	for(int d=2;d<N;d++){
		for(int l=0;l<N-d;l++){
			for(int r=l;r<l+d;r++){
				dp[l][l+d] = min(dp[l][l+d], dp[l][r] + dp[r+1][l+d] + rows[l]*rows[r+1]*cols[l+d]);
			}
		}
	}
	cout << dp[0][N-1] << endl;
	return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;

using P = pair<int, int>;

int nmul(int x, int y, int z){
    return x*y*z;
}

int main(){
    int n; cin >> n;
    vector<int> M(n+1);
    int dummy;
    for(int i=0; i<n; ++i){
        cin >> M[i] >> dummy;
    }
    M[n] = dummy;
    vector<vector<int>> dp(n+1, vector<int>(n+1, numeric_limits<int>::max()));
    // dp[i][i+l] = M_i から M_{i+l} までの行列乗算の最適コスト
    for(int l=0; l<n; ++l) dp[l][l] = 0;

    for(int L=1; L<n; ++L){
        for(int l=0; l<n-L; ++l){
            for(int k=0; k<L; ++k){
                dp[l][l+L] = min(dp[l][l+L], dp[l][l+k] + dp[l+k+1][l+L] + nmul(M[l],M[l+k+1],M[l+L+1]));
            }
        }
    }
    cout << dp[0][n-1] << endl;
}

C++: #include<iostream>
#include<cmath>
#include<algorithm>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<iomanip>
#include<bitset>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
typedef pair<ll,P> P1;
typedef pair<P,P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define fi first
#define sc second
#define rep(i,x) for(ll i=0;i<x;i++)
#define repn(i,x) for(ll i=1;i<=x;i++)
#define SORT(x) sort(x.begin(),x.end())
#define ERASE(x) x.erase(unique(x.begin(),x.end()),x.end())
#define POSL(x,v) (lower_bound(x.begin(),x.end(),v)-x.begin())
#define POSU(x,v) (upper_bound(x.begin(),x.end(),v)-x.begin())

const int MAX = 510000;
const int MOD = 1000000007;

ll dp[210][210];
// dp[i][j] は from i to jまで　の積の計算の最小回数

int main(){
  ll N; cin >> N;
  vector<P> a(N); rep(i,N) cin >> a[i].fi >> a[i].sc;

  // dp 初期化
  rep(i,N) rep(j,N) dp[i][j] = INF;
  rep(i,N) dp[i][i] = 0;

  repn(i,N){
    // iはいくつ離れてるか
    rep(j,N){
      // j is start
      for(ll k = j; k <= i + j; k++){
        // k が空いてた
        if(k == j){
          dp[j][j + i] = min(dp[j][j + i] , a[k].fi * a[k].sc * a[j + i].sc  + dp[j + 1][j + i]);
        }
        else if(k == i + j){
          dp[j][j + i] = min(dp[j][j + i] , dp[j][j + i - 1] + a[j].fi * a[k].fi * a[k].sc);
        }
        else{
          dp[j][j + i] = min(dp[j][j + i] ,
            dp[j][k] + a[j].fi * a[k].sc * a[j + i].sc + dp[k + 1][j + i]);
        }
      }
    }
  }

  // rep(i,N) rep(j,N) cout << i << " " << j << " " << dp[i][j] << endl;

  cout << dp[0][N - 1] << endl;
}

C++: #include <iostream>
#include <cstdio>
#include <map>
#define MAX_NUM 100
#define INFTY 1000000000

using namespace std;

//think easy make easy

int n;//num of input


pair<int,int> MatrixChain[MAX_NUM+1];

int calc(int s,int e){//s~eの連鎖行列積の最少計算回数を出力
	int min_time  = INFTY;

	int min_tmp;
	if(s == e){
		return 0;
	}
	for(int i=s;i<e;i++){
		min_tmp = calc(s,i) + calc(i+1,e) 
			+MatrixChain[s].first*MatrixChain[i].second*MatrixChain[e].second;
		if(min_tmp < min_time)
			min_time = min_tmp;
	}
	return min_time;
}

int main(){
	scanf("%d",&n);
	int r,c;//row,column

	for(int i=0;i<n;i++){
		scanf("%d %d",&r,&c);
		MatrixChain[i] = pair<int,int>(r,c);//i:1~n-1
	}

	cout <<calc(0,n-1) <<endl;

	return 0;
}

C++: #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD=1000000007;
#define INF 1LL<<30
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define all(x) (x).begin(),(x).end()

int main() {
    int n;
    cin>>n;
    int m[n+1][n+1],p[n+1];
    rep(i,n){
        cin>>p[i]>>p[i+1];
        m[i][i]=0;
    }
    m[n][n]=0;
    for(int l=2;l<=n;l++){
        for(int i=1;i<=n-l+1;i++){
            int j=i+l-1;
            m[i][j]=1000000;
            for(int k=i;k<j;k++){
                m[i][j]=min(m[i][j],m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j]);
            }
        }
    }

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

C++: #include<iostream>

#define N 101

int n;
int a[N];
int g[N][N];

using namespace std;
int main() {

    cin>>n;
    for(int i = 0; i < n; i++) cin>>a[i]>>a[i+1];
    

    int i = 1, j = 1, k = 1, min, b;
    while(1) {
        if(i == 1 && j == n+1) break;
        if(i == j) g[i][j] = 0;
        
        if(i != j) {
            min = (1<<21);
            for(int x = i; x < j; x++) {
                b = g[i][x] + g[x+1][j] + a[i-1] * a[x] * a[j];
                if(min > b) min = b;
            }
        
            g[i][j] = min;
        }
        
        i++;
        j++;
        if(j > n) {
            i = 1;
            j = ++k;
        }
    }

    cout<<g[1][n]<<endl;

    return 0;
}