Go: package main

import (
	"fmt"
)

func main() {
	var n int
	fmt.Scan(&n)
	a := make([]int, n+1)
	for i := 0; i < n; i++ {
		fmt.Scan(&a[i])
		fmt.Scan(&a[i+1])
	}

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

	for d := 2; d <= n; d++ {
		for s := 0; s+d <= n; s++ {
			min := 1 << 30
			for j := s+1; j < s+d; j++ {
				val := m[s][j] + m[j][s+d] + a[s]*a[j]*a[s+d]
				if val < min {
					min = val
				}
			}
			m[s][s+d] = min
		}
	}
	fmt.Println(m[0][n])
}

C++: #include <stdio.h>
#include <vector>
#include <list>
#include <map>
#include <array>
#include <memory>
#include <string>
#include <iostream>
#include <sstream>
#include <algorithm>
#include <cmath>
#include <unordered_map>
#include <stdexcept>


using std::string;
using std::vector;


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// util
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

std::vector<std::string> split(const std::string& input, char delimiter)
{
    std::istringstream stream(input);

    std::string field;
    std::vector<std::string> result;
    while (std::getline(stream, field, delimiter)) {
        result.push_back(field);
    }
    return result;
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// user func
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void printList(const vector<int>& list) {
    // print
    for(int i = 0; i < list.size(); i++){
        printf(" %d", list[i]);
    }
    printf("\n");
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// logic
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct _Matrix {
    int row;
    int col;
} Matrix;

std::map<string, int> memo;
int GetCost(const vector<Matrix> list, int begin, int end)
{
    // printf("%d - %d\n", begin, end);
    if (begin == end) return 0;
    string hash = std::to_string(begin) + "," + std::to_string(end);
    if (memo[hash] != 0) return memo[hash];
    int min = std::numeric_limits<int>::max();
    for(int p = begin; p < end; p++){
        int r  = list[begin].row;
        int c1 = list[p].col;
        int c2 = list[end].col;
        int left = GetCost(list, begin, p);
        int right = GetCost(list, p + 1, end);
        min = std::min(min, left + right + r * c1 * c2);
        string lhash = std::to_string(begin) + "," + std::to_string(p);
        string rhash = std::to_string(p + 1) + "," + std::to_string(end);
        memo[lhash] = left;
        memo[rhash] = right;
        // min = std::min(min, GetCost(list, begin, p) + GetCost(list, p + 1, end) + r * c1 * c2);
    }
    return min;
}

void solve() {
    int n;
    scanf("%d", &n);
    vector<Matrix> matrixList(n);
    for(int i = 0; i < n; i++){
        int r, c;
        scanf("%d %d", &r, &c);
        matrixList[i] = {r,c};
    }
    int cost = GetCost(matrixList, 0, n - 1);
    printf("%d\n", cost);
}


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

C++: /*
* @Author: Samson
* @Date:   2018-06-11 12:09:01
* @Last Modified by:   Samson
* @Last Modified time: 2018-06-11 15:37:51
*/
//   @URL : http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_10_B
#include<bits/stdc++.h>
#include<algorithm>
#include <cstdlib>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long LL;
const int MAXN = 1e5+10;

int p[205],f[105][105];

int main(void)
{
	ios::sync_with_stdio(false); 
	//cin.tie(0);
	int n;
	cin>>n;
	for(int i = 1; i <= n; ++i)
		cin>>p[i-1]>>p[i];
	memset(f,INF,sizeof f);
	for(int i = 1; i <= n; ++i)	f[i][i] = 0;
	for(int i = 2; i <= n; ++i)
	{
		for(int l = 1; l <= n-i+1; ++l)
		{
			int r = i+l-1;
			f[l][r] = INF;
			for(int k = l; k <= r-1; ++k)
				f[l][r] = min(f[l][r], f[l][k]+f[k+1][r]+p[l-1]*p[k]*p[r]);
		}
	}
	cout<<f[1][n]<<'\n';
	return 0;
}

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

template<typename T, typename U> void dmin(T &x, U y) { if(x > y) x = y; }

const int MAX_N = 100;
const int INF = 1001001001;

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

  int dp[MAX_N][MAX_N];
  for (int i=0; i<n; i++) {
    for (int j=0; j<n; j++) {
      dp[i][j] = INF;
    }
    dp[i][i] = 0;
  }

  for (int l=2; l<=n; l++) {
    for (int i=0; i+l-1<n; i++) {
      for (int j=1; j<l; j++) {
        dmin(dp[i][i+l-1], dp[i][i+j-1] + rc[i][0]*rc[i+j-1][1]*rc[i+l-1][1] + dp[i+j][i+l-1]);
      }
    }
  }

  cout << dp[0][n-1] << endl;
  return 0;
}

C++: #include <cstdio>
#include <algorithm>
using namespace std;
const int M = 128;
const int inf = (1<<25);

int d[M][M], p[M+2];
int path[M][M];

int main()
{
	int n;
	scanf("%d", &n);
	for (int i = 0; i < n; ++i)
		scanf("%d %d", p+i, p+i+1);
	
	for (int i = 1; i <= n; ++i) d[i][i] = 0;
	for (int ln = 2; ln <= n; ++ln)	// 枚举矩阵链的长度 
	{
		int m = n - ln + 1; 		// 剩余矩阵的长度 
		
		for (int i = 1; i <= m; ++i)// len-ln = j-i+1 j = ln+i-1
		{
			int j = ln + i - 1;
			d[i][j] = inf;			
			for (int k = i; k < j; ++k)
				d[i][j] = min(d[i][j], d[i][k] + d[k+1][j] + p[i-1] * p[k] * p[j]);
		}		
	}
	
	printf("%d\n", d[1][n]);
	return 0;
}

C++: #include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<climits>
#include<iostream>
#include<sstream>
#include<utility>
#include<map>
#include<vector>
#include<queue>
#include<algorithm>
#include<set>
#include<stack>
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
int N;
int r[105],c[105];
ll dp[105][105]={0};

void dbg()
{
	for(int i=0;i<N;i++,puts(""))
		for(int j=0;j<N;j++)
			printf("%7d ",dp[i][j]);
}

int main()
{
	scanf("%d",&N);
	for(int i=0;i<N;i++)
		scanf("%d%d",&r[i],&c[i]);
	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;
			dp[i][j]=1e15;
			for(int k=i;k<j;k++)
			{
				//printf("%d %d %d %d\n",i,j,i+l,k);
				dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+r[i]*c[k]*c[j]);
			}
		}
	//dbg();
	printf("%lld\n",dp[0][N-1]);
	return 0;
}

C++: #include<iostream>
using namespace std;
struct mat
{
	int w;
	int h;
};
typedef struct mat mat_t;
long long min(long long a,long long b);

int n;
mat_t a[101];
long long dp[101][101] ;

int main(){
	cin >> n;
	for(int i=0;i<n;i++){
		cin >> a[i].h >> a[i].w;
	}
	for(int x = 0;x<n;x++){
		for(int y =0;y<n;y++){
			dp[x][y] = 2000000;
			if(x == y) dp[x][y] = 0;
		}
	}
	int i = 0;
	int j = 1;
	for(int l = 1;l<n;l++){
		i = 0;
		for(j=l;j<n;j++){
			for(int k = i;i <= k && k < j;k++){
				dp[i][j] = min(dp[i][j],dp[i][k] + dp[k+1][j] + a[i].h *a[k].w * a[j].w);
			}
			i++;
		}
	}
	cout << dp[0][n-1] << endl;
}

long long min(long long a,long long b) {
	return a<b? a:b;
}