Go: package main

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

func nextInt(sc *bufio.Scanner) int {
	sc.Scan()
	v, _ := strconv.Atoi(sc.Text())
	return v
}

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

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)

	n := nextInt(sc)

	P := make([]int, n+1)
	for i := 1; i <= n; i++ {
		l := nextInt(sc)
		P[i-1] = l
		m := nextInt(sc)
		P[i] = m
	}

	matrix := make([][]int, n+1)
	for i := 0; i < n+1; i++ {
		matrix[i] = make([]int, n+1)
	}

	for l := 2; l <= n; l++ {
		for i := 1; i <= n - l + 1; i++ {
			j := i + l - 1
			matrix[i][j] = (1 << 21)
			for k := i; k <= j-1; k++ {
				matrix[i][j] = min(matrix[i][j], matrix[i][k] + matrix[k+1][j] + P[i-1] * P[k] * P[j])
			}
		}
	}
	fmt.Println(matrix[1][n])
}

C++: #include<iostream>
#include<string>
#include<algorithm>
#include<stdio.h>
#include<stdlib.h>
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 <bits/stdc++.h>
using namespace std;

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

	    vector<pair<int,int> > B(n);
	    for(int i=0;i<n;i++)
	    {
                int a,b;
                cin>>a>>b;
                B[i].first=a;
	        B[i].second=b;
	    }
	    vector<vector<int> > dp(n,vector<int>(n,0));
	    for(int i=0;i<n-1;i++)
	        dp[i][i+1]=B[i].first*B[i].second*B[i+1].second;
	    for(int l=2;l<=n-1;l++)
	    {
	        for(int i=0;i<n-l;i++)
	        {
	            int j=i+l;
	            dp[i][j]=INT_MAX;
	            int q=dp[i][j];
	            for(int k=1;i+k<=j;k++)
	            {

	              q=min(q,dp[i][i+k-1]+dp[i+k][j]+B[i].first*B[i+k].first*B[j].second);
	                if( q < dp[i][j])
	                dp[i][j]=q;

	            }
	        }
	    }
	  /* for(int i=0;i<n;i++)
	   {
	       for(int j=0;j<n;j++)
	       cout<<dp[i][j]<<"           ";
	       cout<<endl;
	   }*/
	    cout<<dp[0][n-1]<<endl;

	return 0;
}

C++: #include <iostream>
#include<climits>
#include<vector>
using namespace std;
 
int MCM(int p[],int n) {
    vector<vector<int> > m(n+1,vector<int>(n+1));
    for (int i = 0; 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] = INT_MAX;
            for (int k = i; k <= j-1; k++) {
                int q = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];
                if (m[i][j] > q) {
                    m[i][j] = q;
                }
 
            }
        }
 
    }
    return m[1][n];
}
 
int main() {
    int n, p[200];
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> p[i] >> p[i + 1];
    }
    cout << MCM(p, n) << endl;
    return 0;
}

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

const int N=100;

int main(){
	int n,p[N+1],m[N+1][N+1];//m代表所需乘法运算的最小次数 
	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]=(l<<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>
#include <cstdio>
#include <cmath>
#include <string>
#include <cctype>
#include <stack>
#include <queue>
#include <vector>
#include <cstdlib>
#include <list>
#define _USE_MATH_DEFINES
#include <math.h>

using namespace std;

int main() {

	int n, p[101], m[101][101];

	cin >> n;
	for (int i = 1; i < n; i++) {
		cin >> p[i - 1] >> p[i];
		m[i][i] = 0;
	}

	for (int i = 2; i <= n; i++) {
		for (int j = 1; j <= n - i; j++) {
			int k = i + j - 1;
			m[j][k] = (1 << 21);
			for (int l = j; l <= k - 1; l++) {
				m[j][k] = min(m[j][k], m[j][l] + m[l + 1][k] + p[j - 1] * p[l] * p[k]);
			}
		}
	}
	cout << m[1][n] << endl;

	return 0;
}

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

struct matrix {int r, c;};
typedef matrix M;
#define v vector
typedef v<int> vi;
typedef v<vi> vvi;
typedef v<M> vm;

vm m;
vvi t;

int McM(int b, int e) {
	int r = t[b][e];
	if (r != INT_MAX)
		return r;
	if (b == e)
		r = 0;
	else
		for (int i = b; i < e; i++)
			r = min(r, McM(b, i) + McM(i + 1, e) + m[b].r * m[i].c * m[e].c);
	t[b][e] = r;
	return r;
}

int main() {
	int n;
	cin >> n;
	m = vm(n);
	t = vvi(n, vi(n, INT_MAX));
	for (M &x: m)
		cin >> x.r >> x.c;
	cout << McM(0, n - 1) << endl;
}

C++: #include <cstdio>
#include <cstring>
#include <climits>
#include <algorithm>

using namespace std;

int r[100], c[100];
int dp[100][100];

int optMat(int left, int right)
{
	if (dp[left][right] >= 0){
		return (dp[left][right]);
	}
	if (left == right){
		return (0);
	}
	
	int res = INT_MAX;
	for (int i = left; i < right; i++){
		res = min(res, optMat(left, i) + optMat(i + 1, right) + r[left] * c[i] * c[right]);
	}
	
	return (dp[left][right] = res);
}

int main()
{
	int N;
	
	scanf("%d", &N);
	
	for (int i = 0; i < N; i++){
		scanf("%d %d", &r[i], &c[i]);
	}
	
	memset(dp, -1, sizeof(dp));
	
	printf("%d\n", optMat(0, N - 1));
	
	return (0);
}

C++: #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cassert>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
#define rep(i,n) FOR(i,0,n)
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define vint vector<int>
#define vdouble vector<double>
#define vstring vector<string>
using namespace std;

#include<map>
#include<set>
#include<queue>

typedef long long ll;
typedef unsigned long long ull;

const int MAX_N = 1000000;
const int MAX_L = 10000;
int N;

struct Matrix{ int R, W; };
Matrix M[MAX_N];

int mem[MAX_L][MAX_L];
Matrix memM[MAX_L][MAX_L];


void eval(Matrix M[], int s, int e){

	if (s == e){
		mem[s][e] = 0;
		memM[s][e] = M[s];
		return;
	}

	int minval = 1000000000;
	for (int mid = s; mid < e; mid++){
		Matrix m1 = memM[s][mid];
		Matrix m2 = memM[mid+1][e];
		int val = mem[s][mid] + mem[mid+1][e] + (m1.W * m1.R * m2.W);
		
		if (val < minval){
			minval = val;
			mem[s][e] = val;
			Matrix m; m.R = m1.R; m.W = m2.W;
			memM[s][e] = m;
		}
	}

}

int solve(Matrix M[], int N){

	for (int d = 0; d <= N; d++)
		for (int s = 0; s + d <= N; s++)
		{
			eval(M, s, s + d);
		}

	return mem[0][N];
}

int main() {

	cin >> N;
	rep(i, N){
		Matrix m;
		cin >> m.R;
		cin >> m.W;
		M[i] = m;
	}

	cout << solve(M, N) << endl;

	// debug
	rep (i, N){
		rep(j, N){
			cerr << mem[i][j] << ' ';
		}
		cerr << endl;
	}
}

C++: #include<iostream>
#include<stdio.h>
#include<algorithm>

using namespace std;

void output(int, int, int, int);

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

int SIZE;
int R[MAX + 2];
int C[MAX + 1][MAX + 1];
int B[MAX + 1][MAX + 1];

void compute() {
	for (int i = 1; i <= SIZE; i++)
		for (int j = 1; j <= SIZE; j++) C[i][j] = INF;

	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++) {
				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 input() {
	int r, c;
	cin >> SIZE;
	for (int i = 1; i <= SIZE; i++) {
		cin >> r;
		cin >> c;
		R[i] =r;
	}
	R[SIZE + 1] = c;

}

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

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