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<iostream>
using namespace std;

int x[101];
int S[101][101];

int solve(int n){
  for(int i = 2; i <= n; i++){
    for ( int l = 1; l <= n - i + 1 ; l++){
      // l は 始まりの数
      int j = l + i - 1; // 終わりの数
      S[l][j] = 100000;
      for ( int k = l; k <= j-1; k++){
        S[l][j] = min(S[l][j], S[l][k] + S[k+1][j] + x[l-1]*x[k]*x[j]);
      }
    }
  }

 return S[1][n];
}

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

  // init
  for ( int i = 0; i <= n; i++){
    S[i][i] = 0;
  }

  cout << solve(n) << endl;

  return 0;
}

C++: //http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_10_B&lang=ja
//Matrix Chain Multiplication
#include <bits/stdc++.h>
#if LOCAL
#include "dump.hpp"
#else
#define dump(...)
#endif
using namespace std;
using ll=long long;
#define FOR(i,a,b) for(ll i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
template<class T>bool chmax(T &a, const T &b) {if (a<b) { a=b; return 1; } return 0;}
template<class T>bool chmin(T &a, const T &b) {if (b<a) { a=b; return 1; } return 0;}
int main() {
#if LOCAL&01
	//std::ifstream in("./test/sample-1.in");
	std::ifstream in("./input.txt");
	std::cin.rdbuf(in.rdbuf());
#else
	cin.tie(0);
	ios::sync_with_stdio(false);
#endif
  ll n; cin>>n;
  vector<pair<ll,ll>> rcn(n);
  for(auto&& rc:rcn){
   cin>>rc.first>>rc.second;
  }
	vector<vector<ll>> dp(n,vector<ll>(n+1,-1));
  auto dfs = [&](auto&& self, ll l, ll r)->ll{
    if(l+1>=r)return 0;
		if(dp[l][r]>=0)return dp[l][r];
    ll ret=INT64_MAX;
    FOR(k,l+1,r){
      ll mulnum = rcn.at(l).first * rcn.at(k).first * rcn.at(r-1).second;
      chmin(ret, self(self,l,k)+self(self,k,r) + mulnum);
    }
		dump(l,r,ret);
		dp[l][r]=ret;
    return ret;
  };

	ll ans=dfs(dfs,0,n);
	cout<<ans<<endl;

  return 0;
}

C++: #include<stdio.h>
int main()
{
  int n,r[100],c[100][100];
  int i,j,k,l,m;
   
  scanf("%d",&n);
  for(i=0;i<n;i++){
    scanf("%d%d",&r[i],&j);
  }
  r[n]=j;
  for(i=1;i<=n;i++){
    c[i][i]=0;
  }
     
  for(l=2;l<=n;l++){
    for(i=1;i<=n-l+1;i++){
      j =i+l-1;
      c[i][j]=1000000;
      for(k=i;k<=j-1;k++){
    m=c[i][k]+c[k+1][j]+(r[i-1]*r[k]*r[j]);
       
    if(c[i][j]>m){
      c[i][j]=m;
    }
      }
    }
  }
  printf("%d\n",c[1][n]);
   
  return 0;
}

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

int main() {
  uint32_t n = 0;
  std::cin >> n;
  std::vector<uint32_t> mat(n + 1);
  for (uint32_t i = 0; i < n; i++) {
    std::cin >> mat[i] >> mat[i + 1];
  }

  std::vector<std::vector<uint32_t>> dp(n + 1,
                                        std::vector<uint32_t>(n + 1, -1));
  for (size_t i = 0; i < dp.size(); i++) dp[i][i] = 0;

  for (size_t d = 1; d < n; d++) {
    for (size_t i = 1; i < dp.size() - d; i++) {
      for (size_t j = 0; j < d; j++) {
        dp[i][i + d] =
            std::min(dp[i][i + d], mat[i - 1] * mat[i + j] * mat[i + d] +
                                       dp[i][i + j] + dp[i + j + 1][i + d]);
      }
    }
  }

  std::cout << dp[1][n] << std::endl;

  return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;

int main(void) {
	int n, i, j, k, len;
	cin >> n;
	int p[n + 1], m[n + 1][n + 1];
	for (i = 0; i <= n; i++)
	{
		if (i == 0) {
			cin >> p[i];
		} else if (i == 1) {
			cin >> p[i];
		} else {
			cin >> p[i] >> p[i];
		}
	}

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

	for (len = 2; len <= n; len++) {
		for (i = 1; i <= n - len + 1; i++) {
			j = i + len - 1;
			m[i][j] = INT_MAX;
			for (k = i; k < j; 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;
}

C++: /**
 * 附上C++做法, c++的cin和string真好用，比java理解起来难，但是操作起来舒服很多，
 * java的string是immutable的这点比较麻烦
 * 感觉c++跟其他所有面向对象语言都不太一样
 */
#include <iostream>
#include <string>
#include <vector>
#include <map>

using namespace std;

#include <iostream>
#include <set>
#include <string>
#include <climits>

#include <iostream>
#include <set>
#include <string>
#include <climits>


/**
 * Given two strings str1 and str2 of the same length, determine whether you can transform str1 into str2 by doing zero or more conversions.

In one conversion you can convert all occurrences of one character in str1 to any other lowercase English character.

Return true if and only if you can transform str1 into str2.



Example 1:

Input: str1 = "aabcc", str2 = "ccdee"
Output: true
Explanation: Convert 'c' to 'e' then 'b' to 'd' then 'a' to 'c'. Note that the order of conversions matter.
Example 2:

Input: str1 = "leetcode", str2 = "codeleet"
Output: false
Explanation: There is no way to transform str1 to str2.


Note:

1 <= str1.length == str2.length <= 10^4
Both str1 and str2 contain only lowercase English letters.


6
30 35
35 15
15 5
5 10
10 20
20 25
 */

#include <vector>
#include <unordered_map>

//矩阵连乘问题，递归方程采用课本P47的递归方程。
//与课本P47的程序相比，两者都是填m[][]的上三角，
//但本程序是横向填表，而课本程序是斜向填表。
//本程序按照 自底向上，自左向右 的顺序来计算m[][]的上三角。
//程序中有记录相应断开位置到s[][]。

#include <iostream>

using namespace std;

void MatrixChain(int, int[], int **);

void CalculateMin(int i, int j, int dimen[], int **dp);


//void MatrixChain(int n, int dimen[], int **dp) {
//    //以下双重循环对m[][]的上三角进行填表
//    //填表顺序为自底向上，自左向右
//    for (int i = n; i >= 1; i--) {//i表示行
//        for (int j = i; j <= n; j++) {//j表示列，因为只填上三角，所以j的初值为i
//            //以下按照矩阵连乘问题的递归公式来求每一个m[i][j]
//            if (i == j) {
//                cout << sizeof(dp) << endl;
//                cout << dp[i][j] << endl;
//                dp[i][j] = 0;
//                cout << dp[i][j] << endl;
//                cout << 44 << endl;
//
//            } else {
//                CalculateMin(i, j, dimen, dp);
//            }
//        }
//    }
//}

void matrixChain(int n, int dimen[], int **dp) {
    for (int len = 0; len <= n; ++len) {
        for (int i = 1; i + len <= n; ++i) {
            int j = i + len;
            if (i == j) {
                dp[i][j] = 0;
            } else {
                CalculateMin(i, j, dimen, dp);
            }
        }
    }
}


void CalculateMin(int i, int j, int dimen[], int **dp) {
    dp[i][j] = dp[i][i] + dp[i + 1][j] + dimen[i - 1] * dimen[i] * dimen[j];
    for (int k = i + 1; k < j; k++) {//k用于尝试不同的断开位置
        int curr = dp[i][k] + dp[k + 1][j] + dimen[i - 1] * dimen[k] * dimen[j];
        if (curr < dp[i][j]) {//当前k值作为Ai连乘到Aj的断开位置能获得更少计算量
            dp[i][j] = curr; //刷新最优值
            //pivot[i][j] = k;   //刷新相应断开位置
        }
    }
}

int main() {
    int n;
    cin >> n;
    int *tempP = new int[2 * n]; //dimen[0]为A1的行数；dimen[i]为Ai的列数
    int *dimen = new int[n + 1];    //dimen[0]为A1的行数；dimen[i]为Ai的列数
    int **dp = new int *[n + 1]; //dp[i][j]为Ai连乘到Aj的最少乘次数
    for (int i = 1; i <= n; i++) {
        dp[i] = new int[n + 1];
    }
    for (int i = 0; i < 2 * n; i++) {
        cin >> tempP[i];
    }
    for (int i = 0; i <= n; i++) {
        dimen[i] = i == 0 ? tempP[0] : tempP[i * 2 - 1];
    }
    matrixChain(n, dimen, dp);
    cout << dp[1][n] << endl; //最优值存储在m[1][n]
    return 0;
}