Go: package main

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

const N = 100

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

func main() {
	var n int
	fmt.Scan(&n)
	p := make([]int, N+1)
	m := make([][]int, N+1)
	for i := range m {
		m[i] = make([]int, N+1)
	}
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	for i := 1; i <= n; i++ {
		scanner.Scan()
		p[i-1], _ = strconv.Atoi(scanner.Text())
		scanner.Scan()
		p[i], _ = strconv.Atoi(scanner.Text())
	}
	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
			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])
			}
		}
	}
	fmt.Println(m[1][n])
}

C++: #include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<vector>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
const int inf=1e9+7;
const ll mod=1e9+7;

ll DP[105][105];
ll larr[105], rarr[105];

ll solve(int l, int r){
    if(DP[l][r] != 0) return DP[l][r];
    for(int i=l;i<r;++i){
        if(DP[l][r] == 0) DP[l][r] = solve(l, i) + solve(l+1, r) + larr[l] * rarr[i] * rarr[r];
        else DP[l][r] = min(solve(l, i) + solve(i+1, r) + larr[l] * rarr[i] * rarr[r], DP[l][r]);
    }
    return DP[l][r];
}

int main() {
    int n;
    cin>>n;
    for(int i=0;i<n;++i){
        cin>>larr[i]>>rarr[i];
    }
    cout<<solve(0, n-1)<<endl;
}

C++: #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

#define INF 1e9

int main(void){
  int n;
  cin >> n;

  int unwanted;
  vector<int> c(n + 1);
  cin >> c[0] >> c[1];
  for(int i = 2; i <= n; i++){ cin >> unwanted >> c[i]; }

  vector<vector<int> > dp(n, vector<int>(n + 1, INF));
  for(int i = 0; i < n; i++){ dp[i][i + 1] = 0; }

  for(int k = 2; k <= n; k++){
    for(int i = 0; i < n; i++){
      for(int j = 1; j < k; j++){
        if(i + k <= n){
          dp[i][i + k] = min(dp[i][i + k], dp[i][i + j] + dp[i + j][i + k] + c[i] * c[i + j] * c[i + k]);
        }
      }
    }
  }


  // ??????
  cout << dp[0][n] << endl;


  return 0;
}

C++: #include<algorithm>
template<class T>
int mcm(T first, T last) {
    const auto N = std::distance(first, last) - 1;
    int dp[N][N];
    std::fill(dp[0], dp[N], 1 << 28);
    for (int i = 0; i < N; ++i) dp[i][i] = 0;
    for (int L = 1; L < N; ++L)
        for (int i = 0; i < N - L; ++i) {
            int j = i + L;
            for (int k = i; k < j; ++k)
                dp[i][j] = std::min(dp[i][j], dp[i][k] + dp[k + 1][j] + first[i] * first[k + 1] * first[j + 1]);
        }
    return dp[0][N - 1];
}
#include<iostream>
#include<vector>
using namespace std;
int main() {    
    cin.tie(0);
    ios::sync_with_stdio(false);
    int n;
    cin>>n;
    vector<int> vec(n+1);
    for(int i=0;i<n;++i) cin>>vec[i]>>vec[i+1];
    cout<<mcm(vec.begin(),vec.end())<<endl;
}

C++: #include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <cstdio>
#include <cstdlib>
using namespace std;

static const  int N = 100;

int main() {

    int n, p[N+1], m[N+1][N+1];
    cin >> n;
    
    for (int i = 1; i <= n; i++) {
        cin >> p[i-1] >> p[i];
    }
    
    for (int i = 1; i <= n; i++) m[i][i] = 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] = (1 << 21);
            for (int 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]);
            }
        }
    }
    
    cout << m[1][n] << 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++: #include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <climits>
#include <map>
#include <list>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <sstream>
#include <fstream>
#include <iostream>
#include <algorithm>
using namespace std;

int m[128], costs[128][128];
int calc(int s, int e){
	if(s==e) return 0;
	if(costs[s][e] != INT_MAX) return costs[s][e];
	return costs[s][e] = min(m[s-1] * m[s] * m[e] + calc(s+1, e), m[s-1] * m[e-1] * m[e] + calc(s, e-1));
}

int main() {
	int n;
	scanf("%d", &n);
	
	for(int i = 0; i < n; i++){
		scanf("%d %d", &m[i], &m[i+1]);
	}
	
	for(int i = 0; i <= n; i++){
		for(int j = 0; j <= n; j++){
			costs[i][j] = INT_MAX;
		}
	}
	
	printf("%d\n", calc(1, n));
	
	return 0;
}

C++: #include<iostream>


using namespace std;

#define N 100

int memo[N+1][N+1];
int q[N+1];

int main(){
  int n,i,j,k,l,min_memo;

  cin >> n;

  for(i=1;i<=n;i++) cin >> q[i-1] >> q[i];

  for(i=1;i<=n;i++) memo[i][i] = 0;

  for(l=2;l<n+1;l++){
    for(i=1;i<=n-l+1;i++){
      j = i +l -1;
      for(k = i;k<j;k++){
if(k==i) min_memo =  memo[i][k] + memo[k+1][j] + q[i-1]*q[k]*q[j];
    else  min_memo = min(min_memo, memo[i][k] + memo[k+1][j] + q[i-1]*q[k]*q[j]);
      }
      memo[i][j] =min_memo;
    }
  }

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

  return 0;
}

C++: #include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxx = 110;
const int INF = 1 << 30;
int main()
{
	int n, p[maxx], m[maxx][maxx];

	scanf("%d", &n);
	for (int i = 1; i <= n; i++)
		scanf("%d %d", &p[i - 1], &p[i]);

	for (int i = 1; i <= n; i++)
		m[i][i] = 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] = INF;
			for (int 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]);

		}
	}
	printf("%d\n", m[1][n]);
	return 0;
}

C++: #include <stdio.h>
#include <algorithm>
using namespace std;
int n, r[100], c[100], dp[100][101];
int main() {
	scanf("%d", &n);
	for(int i = 0; i < n; i++) scanf("%d%d", &r[i], &c[i]), dp[i][i] = 0;
	for(int i = 1; i <= n; i++) {
		for(int j = 0; i + j <= n; j++) {
			dp[j][i + j] = min(dp[j][i + j - 1], dp[j + 1][i + j]) + r[j] * c[i + j - 1];
		}
	}
	printf("%d\n", dp[0][n]);
	return 0;
}

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

using namespace std;

//think easy make easy

int n;//num of input


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

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

	if(map[s,e] != NIL)
		return map[s,e];

	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;
	}
	map[s,e] = min_time;//メモ
	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
	}
	for(int i=0;i<n;i++){
		for(int j=i;j<n;j++){
			map[i][j] = NIL;
		}
	}

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

	return 0;
}