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<stdio.h>

#define N 100
int A[N + 1][N + 1];
int p[N + 1];

int solve(int i, int j)
{
    if(!(A[i][j] < 0)){ return A[i][j]; }
    if(j == i){ A[i][i] = 0; return 0; }
    if(j == i + 1){
        A[i][j] = p[i - 1] * p[i] * p[i + 1];
        return A[i][j];
    }
    int min = -1, x;
    for(int k = i; k < j; k++){
        x = solve(i, k) + solve(k + 1, j) + p[i - 1] * p[k] * p[j];
        if(min < 0){ min = x; }
        else{ if(min > x) min = x; }
    }
    A[i][j] = min;
    return min;
}

int main()
{
    int i, j, n;
    scanf("%d", &n);
    for(i = 1; i <= n; i++){
        scanf("%d %d", &p[i - 1], &p[i]);
        for(j = 1; j <= n; j++){
            A[i][j] = -1;
        }
    }
    printf("%d\n", solve(1, n));
    return 0;
}

C++: // http://algorithms.blog55.fc2.com/blog-entry-66.html

#include <iostream>
using namespace std;
#include <stdio.h>

#define MAX 100
#define INFTY (1 << 21)

int SIZE;
int R[MAX + 2];
int C[MAX+1][MAX+1]; // cost table
int B[MAX+1][MAX+1]; // best table

void compute(){
    for ( int i = 1; i <= SIZE; i++ )
    for ( int j = 1; j <= SIZE; j++ ) C[i][j] = INFTY;
    
    for ( int i = 1; i <= SIZE; i++ ) C[i][i] = 0;
    
    for ( int j = 1; j <= SIZE - 1; j++ ){
        for ( int i = 1; i <= SIZE - j; i++ ){
            for ( int k = i + 1; k <= i + j; k++ ){
                // C[i][i+j] = min( C[i][i+j], 
                //                  C[i][k-1] + C[k][i+j] + R[i]*R[k]*R[i+j+1]);
                int cost = C[i][k-1] + C[k][i+j] + R[i]*R[k]*R[i+j+1];
                if ( cost < C[i][i+j] ){
                    C[i][i+j] =  cost;
                    B[i][i+j] = k;
                }
                
            }
        }
    }
}

void order( int i, int j ){
    if ( i == j ) cout << "M" << i;
    else{
        cout << "(";
        order( i, B[i][j]-1 ); order(B[i][j], j);
        cout << ")";
    }
}

void input(){
    cin >> SIZE;
	int z,i=1;
    for (; i <= SIZE; i++ ) cin >> R[i]>>z;
	R[i]=z;
	//SIZE++;
}

void output(){
    cout <<  C[1][SIZE] << endl;
    //order(1, SIZE);
    //cout << endl;
}

main(){
    input();
    compute();
    output();
}

C++: #include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define NIL -1
#define MAX 1000

static const int N = 1000;

int main()
{
    int n, m[N+1][N+1], p[N+1];

    cin >> n;
    rep(i, n){
        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-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>
#include <algorithm>
using namespace std;

void DP(int i, int j, long long dp[101][101], int r[], int c[]){
    if(i == j) dp[i][j] = 0;
    else if (j - i == 1){
        dp[i][j] = r[i] * c[i] * c[j];
    } else {
        int tmp = i;
        dp[i][j] = dp[i][tmp] + dp[tmp+1][j] + r[i] * r[tmp+1] * c[j];
        // cout <<  "i: "<< i <<" tmp: " << tmp <<" " << r[i] * r[tmp+1] * c[j] <<endl;
        tmp++;
        while(tmp != j){
            dp[i][j] = min(dp[i][j], dp[i][tmp] + dp[tmp + 1][j] + r[i] * r[tmp+1] * c[j]);
            // cout <<  "i: "<<i<<" tmp: " << tmp <<" " << r[i] * r[tmp+1] * c[j] <<endl;
            tmp++;
        }
    }
    
    // cout << "i, j: " << i << ", " << j << " " <<  dp[i][j] << endl;
}

void solve(){
    int n; cin >> n;
    int r[n+1], c[n+1];
    r[0] = 0; c[0] = 0;
    for(int i = 1; i <= n; ++i) {
        cin >> r[i] >> c[i];
    }
    long long dp[101][101] = {};
 
    for(int i = 1; i < n; i ++){
        int tmp = 1;
        for(int j = i + tmp; j <= n; j++, tmp++){
            DP(tmp, j, dp, r, c);
        }
    }
    cout << dp[1][n] << endl;
}

int main (){
    solve();
    return 0;
}

C++: def edit_distance(d)
 n =len(d)
 A=[[0 for i inrange(n)] for j in range(n)]
 for long in range(0,n+1-long):
  k=i-1+long
  def f(i,j,k):
   return A[i][j-1]+A[j][k]+]+M[i][0]*M[j-1][1]*M[k][1]
   A[i][k] = min([f(i,j,k) for j in range(i+1,k+1)])
 return A[0][n-1]
n = input()
M = []
for i in range(n):
 M.append(map(int, raw_input().split()))
print edit_distance (M)

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

const int INF = INT_MAX/3;
typedef vector<int> vi;
typedef pair<int,int> pii;

int main(){
    int n;cin>>n;
    vector<pii> p(n+1);
    for(int i=0;i<n;i++) cin>>p[i].first>>p[i].second;

    vector<vi> mat(n+1,vi(n+1,INF));    //mat[i][j] : Mi*...*Mj???????°??????°
    for(int i=0;i<n;i++) mat[i][i] = 0;

    for(int sz=2;sz<=n;sz++){
        /*
         * mat[i][j] = min( mat[i][k]+mat[k+1][j]+Mi.first*Mk+1.first*Mk+1.second )
         */
        for(int i=0;i<=n-sz;i++){
            int j = i + sz - 1;

            for(int k=i;k<=j-1;k++){
                mat[i][j] = min(mat[i][j] , mat[i][k] + mat[k+1][j] + p[i].first * p[k+1].first * p[j].second);
            }
        }
    }
    cout << mat[0][n-1] << endl;
}

C++: #include <iostream>
#include <algorithm>
using namespace std;
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 -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<bits/stdc++.h>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) for(int i = 0; i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define show(x)  cerr << #x << " = " << (x) << endl;
//const int INF = 1e8;
using namespace std;

// O(n^3)
// dp[i][j] := [i,j]????????????????????????????°?????????????????????°
// i??????????????????(?????°????????°)??????(p[i - 1], p[i])
int matrixChainMultiplication(int n, int p[105]){
    int dp[105][105] = {{0}};
    range(seg, 2, n + 1){ //?¨????????????????????????°
        range(i, 1, n - seg + 2){
            int j = i + seg - 1;
            dp[i][j] = INT_MAX;
            range(k,i,j){
                int cost = dp[i][k] + dp[k + 1][j] + p[i - 1] * p[k] * p[j];
                dp[i][j] = min(dp[i][j], cost);
            }
        }
    }
    return dp[1][n];
}

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

    int p[105];
    rep(i,n){
        cin >> p[i] >> p[i + 1];
    }
    cout << matrixChainMultiplication(n, p) << endl;
}