Go: package main

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

type Matrix struct {
	r int // num of row
	c int // num of column
}

type Range struct {
	start int // index, inclusive
	end   int // index, inclusive
}

func (r Range) length() int {
	return r.end - r.start + 1
}

func calcMultiplication(x, y Matrix) (Matrix, int) {
	if x.c != y.r {
		panic("cannnot calculate")
	}
	return Matrix{x.r, y.c}, x.r * y.c * x.c
}

func calcMinMatrixChainMultiplication(matrices []Matrix, r Range, memo map[Range]int) (Matrix, int) {
	if v, ok := memo[r]; ok {
		return Matrix{matrices[r.start].r, matrices[r.end].c}, v
	}
	if r.length() == 0 {
		panic("must not be empty")
	} else if r.length() == 1 {
		return matrices[r.start], 0
	}

	var minCount int = math.MaxInt32

	for i := 0; i < r.length()-1; i++ {
		formerRange := Range{r.start, r.start + i}
		latterRange := Range{r.start + i + 1, r.end}
		matF, countF := calcMinMatrixChainMultiplication(matrices, formerRange, memo)
		matL, countL := calcMinMatrixChainMultiplication(matrices, latterRange, memo)
		_, countFL := calcMultiplication(matF, matL)
		count := countF + countL + countFL
		if count < minCount {
			minCount = count
		}
	}
	memo[r] = minCount
	return Matrix{matrices[r.start].r, matrices[r.end].c}, minCount
}

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)
	n, _ := nextInt(sc)
	matrices := make([]Matrix, n)
	for i := 0; i < n; i++ {
		r, _ := nextInt(sc)
		c, _ := nextInt(sc)
		matrices[i] = Matrix{r, c}
	}
	memo := make(map[Range]int)
	_, resultCount := calcMinMatrixChainMultiplication(matrices, Range{0, len(matrices) - 1}, memo)
	fmt.Println(resultCount)
}

func nextInt(sc *bufio.Scanner) (int, error) {
	sc.Scan()
	return strconv.Atoi(sc.Text())
}

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

int main()
{
	int n,i;
	int a[25];
	cin >> n;
	for(i=0;i<n;i++){
		cin >> a[i];
	}
}

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

int main()
{
	int n, p = 0, m = 101, mini;
	int v[101];

	cin >> n;

	for (int i = 0; i < n; i++) {
		cin >> v[i] >> v[i + 1];
		if (m > v[i]) {
			m = v[i];
			mini = i;
		}
	}

	if (n > 1) {
		for (int j = 0; j < n; j++)
			p += v[j] * v[j + 1];
		p += v[0] * v[n];

		if (mini == 0)
			p -= v[0] * v[1];
		else if (mini == n)
			p -= v[n - 1] * v[n];
		else
			p -= v[mini] * (v[mini + 1] + v[mini - 1]);

		p *= v[mini];
	}

	cout << p << endl;

	return 0;
}

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

#define REP(i, n) for(int i = 0; i < (n); i++)

typedef pair<int, int> pii;

const int N_SIZE = 100;

int dp[N_SIZE + 1][N_SIZE + 1];

void solve(int n, pii rc[])
{
  REP(i, n)
    dp[i][i] = rc[i].first * rc[i].second;
  REP(i, n - 1)
    dp[i][i + 1] = dp[i][i] * rc[i + 1].second;
  for(int i = 2; i < n; i++){
    for(int j = 0, k = i + j, m = 100000000; k < n; j++, k++){
      for(int l = j, x; l < k; l++){
	x = ((j == l) ? dp[j][l] * rc[k].second : dp[j][l]) + ((l + 1 == k) ? dp[l + 1][k] * rc[j].first : dp[l + 1][k]);
	if(j != l && l + 1 != k)
	  x += rc[j].first * rc[l].second * rc[k].second;
	m = min(m, x);
      }
      dp[j][k] = m;
      m = 100000000;
    }
  }
}
 
int main()
{
  int n;
  cin >> n;
  pii rc[n];
  REP(i, n)
    cin >> rc[i].first >> rc[i].second;
  if(n == 1){
    cout << "0" << endl;
  }else{
    solve(n, rc);
    cout << dp[0][n - 1] << endl;
  } 
}

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

int main() {
    int n, m[101][101], p[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 l = 2; l <= n; l++) {
        for (int i = 1; i <= n - l + 1; i++) {
            int j = i + l - 1;
            m[i][j] = 200000;
            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;
}

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

struct Matrix {
	int r,c;
};

long f(vector<Matrix> &m, int begin, int end) {
	if (m.size() < 2 || (end - begin) < 2) return 0;
	if ((end - begin) == 2) {
		return m[begin].r * m[begin].c * m[begin+1].c;
	}
	long common = m[begin].r * m[end-1].c;
	long res	= common * m[begin+1].r + f(m,begin+1,end);
	for (int i=2;i<(end-begin);++i) {
		long t = f(m,begin, begin+i) + f(m,begin+i,end) + common * m[begin+i].r;
		res = min(res, t);
	}
	return res;
}

int main() {
	int n;
	cin >> n;
	vector<Matrix> M(n);
	for (int i=0;i<n;++i) {
		int r,c;
		cin >> r >> c;
		M[i].r = r; M[i].c = c;
	}
	cout << f(M, 0, M.size()) << 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>
#include <array>
#include <limits>

using namespace std;

struct MatrixDims {
    int row;
    int col;
    MatrixDims() {}
    MatrixDims(int row, int col) : row(row), col(col) {}
};

array<MatrixDims, 100> matrix_dims;
array<array<int, 100>, 100> dp;

int get_min(int row, int col) {
    int min = numeric_limits<int>::max();
    for (int j = row; j < col; ++j) {
        int sum = dp[row][j] + dp[j+1][col] + matrix_dims[row].row * matrix_dims[j].col * matrix_dims[col].col;
        if (sum < min) min = sum;
    }
    return min;
}

int main()
{
    int n;
    cin >>  n;
    for (int i = 0; i < n; ++i) {
        int row, col;
        cin >> row >> col;
        matrix_dims[i] = MatrixDims(row, col);
    }
    dp.fill({});
    
    for (int endpt = 1; endpt < n; ++endpt) {
        for (int diag_i = 0; (endpt + diag_i) < n; ++diag_i) {
            dp[diag_i][diag_i + endpt] = get_min(diag_i, endpt + diag_i);
        }
    }
    cout << dp[0][n-1] << endl;
}

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];  // pは行と列を入れる配列，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] = (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>

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

int main(void)
{
	int i, j, w, m;
	
	for (i = 0; i < 101; i++){
		for (j = 0; j < 101; j++){
			dp[i][j] = 1 << 28;
		}
	}
	for (i = 0; i < 100; i++){
		dp[i][i + 1] = 0;
	}
	
	scanf("%d", &n);
	for (i = 0; i < n; i++){
		scanf("%d %d", &r[i], &c[i]);
	}
	
	for (w = 2; w <= n; w++){
		for (i = 0; i + w <= n; i++){
			for (m = i + 1; m < i + w; m++){
				if (dp[i][i + w] > dp[i][m] + dp[m][i + w] + r[i] * r[m] * c[i + w - 1]){
					dp[i][i + w] = dp[i][m] + dp[m][i + w] + r[i] * r[m] * c[i + w - 1];
				}
			}
		}
	}
	
	printf("%d\n", dp[0][n]);
}