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<bits/stdc++.h>
using namespace std;
const long long INF = 1e7 + 1;
const long long MOD = 1000000007;
const long double PI = 3.1415926;
#define FOR(i,r,n) for(ll i = (ll)(r); i < (ll)(n); i++)
#define RFOR(i,r,n) for(ll i=(ll)(n-1);i>=r;i--)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) RFOR(i,0,n)
#define ALL(x) x.begin(),x.end()
#define RALL(x) x.rbegin(),x.rend()
typedef long long int ll;
typedef vector<ll> vi;
typedef vector < pair<ll, ll > > vp;
typedef vector <string> vs;
typedef vector <char> vc;
typedef list <ll> lst;

ll n, m, k, ans = 0, sum = 0, cnt = 0;
string s;
char c;

/*--------------------template--------------------*/

typedef pair<int, int> pii;

ll DP[105][105];
ll p[105];

ll f(ll r, ll c)
{
	ll mi = INF;
	REP(i, c - r)
	{
		mi = min(mi, DP[r][r + i] + DP[r + i + 1][c] + p[r - 1] * p[r + i] * p[c]);
	}
	return mi;
}

int main()
{
	cin >> n;
	REP(i, n+1)
	{
		DP[i][i] = 0;
	}
	cin >> p[0] >> p[1];
	REP(i, n - 1)
	{
		cin >> k >> p[i+2];
	}
	REP(i, n - 1)
	{
		DP[i + 1][i + 2] = p[i] * p[i + 1] * p[i + 2];
	}
	REP(i, n - 2)
	{
		//REP(j, 3 + i, n + 1)
		for(int j=3+i;j<=n;j++)
		{
			DP[j - 2 - i][j] = f(j - 2 - i,j);
		}
	}
	
	cout << DP[1][n] << endl;

	return 0;
}

C++: #include<iostream>
#include<algorithm>
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[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j]);
}
}
}
cout << m[1][n]<< endl;

return 0;

}

C++: #include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <cmath>
#include <cstdio>
#include <cstring>
using namespace std;
typedef long long int ll;
#define rep(i, a, n) for (ll i = a; i < (ll)(n); i++)
long long GCD(long long a, long long b) { return b ? GCD(b, a%b) : a; }
long long LCM(long long a, long long b)  {return a/GCD(a,b)*b;}

int main()
{
    int n;
    int p[101];
    int m[101][101];
    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 c=1;c<n;c++)
        for(int i=1;i<=n-c;i++)
        {
            int j=i+c;
            m[i][j]=99999999;
            for(int k=i;k<j;k++)
            {
                m[i][j]=std::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++: #include <iostream>
#include <algorithm>

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++: #include<iostream>
using namespace std;

#define N 100

int main() {
  int i, j, k, l, n, p[N+1], cost[N+1][N+1], min_cost;

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

  // 初期値
  for (i = 1; i <= n; i++) cost[i][i] = 0;

  for (l = 2; l <= n; l++) {  // 行列の個数
    for (i = 1; i <= n - l + 1; i++) {
      j = i + l - 1;
      for (k = i; k < j; k++) {
        if (k == i) min_cost = cost[i][k] + cost[k+1][j] + p[i-1] * p[k] * p[j];
        else min_cost = min(min_cost, cost[i][k] + cost[k+1][j] + p[i-1] * p[k] * p[j]);
      }
      cost[i][j] = min_cost;
    }
  }

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

  return 0;
}

C++: #include "stdafx.h"
#include<iostream>
#include<vector>
using namespace std;

vector<vector<int> > cost,best;
vector<int> A;

void compute(int s,int e){
	int minc = 0;
	int mink = -1;
	for(int k=s+1;k<=e;++k){
		if (cost[s][k-1] < 0){
			compute(s,k-1);
		}
		if (cost[k][e] < 0) {
			compute(k,e);
		}
		int c = cost[s][k-1] + A[s]*A[k]*A[e+1] + cost[k][e];
		if (mink < 0 || c < minc) {
			minc = c;
			mink = k;
		}
	}
	cost[s][e] = minc;
	best[s][e] = mink;
}

int main(){
	int n;
	cin >> n;
	A.resize(n+1);
	for(int i=0;i<n;++i) {
		int r,c;
		cin >> r >> c;
		if (i==0){
			A[0] = r;
		}
		if (A[i] != r){ cout << "error";exit(0);}
		A[i+1] = c;
	}
	cost.resize(n);
	best.resize(n);
	for(int i=0;i<n;++i){
		cost[i].resize(n);
		best[i].resize(n);
		for(unsigned j=0;j<cost[i].size();++j){
			cost[i][j] = -1;
			best[i][j] = -1;
		}
		cost[i][i]=0;
		best[i][i]=i;
	}
	compute(0,n-1);
	cout << cost[0][n-1] << std::endl;
}

C++: //Matrix Chain Multiplication
#include <iostream>
#include <climits>

using namespace std;

int matrixChainMultiplication(int p[], int n) {
    int dp[n+1][n+1];
    for(int i = 0; i < n + 1; i++) dp[i][i] = 0;
    for(int l=2; l<n+1; l++) {
        for(int i=1; i<n-l+2; i++) {
            int j = i+l-1;
            dp[i][j] = INT_MAX;
            for(int k=i+1; k<j+1; k++) {
                dp[i][j] = min(dp[i][j], dp[i][k-1] + dp[k][j] + p[i - 1] * p[k - 1] * p[j]);
            }
        }
    }
    return dp[1][n];
}

int main() {
    int n, r, c;
    cin >> n;
    int p[n+1];
    for(int i=0; i<n; i++) {
        cin >> r >>  c;
        if(i == 0) p[0] = r;
        p[i+1] = c;
    }

    cout << matrixChainMultiplication(p, n) << endl;
}

C++: #include<iostream>
#include<algorithm>

using namespace std;

static const int N=100;

int main(){
int n,A[N+1],B[N+1][N+1];
cin>>n;
for(int i=1;i<=n;i++){
    cin>>A[i-1]>>A[i];
}
for(int i=1;i<=n;i++)B[i][i]=0;
for(int l=2;l<=n;l++){
    for(int i=1;i<=n-l+1;i++){
        int j=i+l-1;
        B[i][j]=(1<<21);
        for(int k=i;k<=j-1;k++){
            B[i][j]=min(B[i][j],B[i][k]+B[k+1][j]+A[i-1]*A[k]*A[j]);
        }
    }
}
cout<<B[1][n]<<endl;

return 0;
}

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

int main() {
    int N, p[101], m[101][101];
    cin >> N;
    for (int i = 0; i < N; i++) {
        cin >> p[i] >> p[i+1];
    }
    
    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++: #include <stdio.h>
#define N 101
#define INF 100000

int m[N][N];
int p[N];

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


  scanf("%d", &n);
  for ( i = 0; i < n; i++ ){
    scanf("%d%d", &p[i] ,&trash );
  }
  p[i] = trash;

  for( l = 2 ; l <= n ; l++ ){
    for( i = 1 ; i < (n+l-1) ; i++){
      j = i + l - 1;
      m[i][j] = INF;
      for( k = i ; k <= (j-1) ; k++ ){
	q = m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j];
	if( m[i][j] == -1 || m[i][j] > q){
	  m[i][j] = q;
	}
      }
    }
  }

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

  return 0; // Don't forget return 0
}