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>
#include <cstdlib>
#include <cstdio>

using namespace std;

typedef struct matrix{
  int row;
  int column;
  struct matrix *next;
  struct matrix *back; 
}Matrix;

Matrix *push_back(Matrix *begin, int row, int column) {
  Matrix *p = (Matrix*)malloc(sizeof(Matrix));
  p->row = row;
  p->column = column;
  p->next = NULL;
  p->back = NULL;
  if(begin == NULL) return p;
  Matrix *p2 = begin;
  while(p2->next != NULL) p2 = p2->next;
  p2->next = p;
  p->back = p2;
  return begin;
}

Matrix *product_count(Matrix *x, int type, int *count) {
  Matrix *a,*b;
  if(type == 0) {
    a = x->back;
    b = x;
  }
  else {
    a = x;
    b = a->next;
  }
  *count = 0;
  if(a == NULL || b == NULL) return x;
  *count += a->row * a->column * b->column;
  Matrix *c = (Matrix*)malloc(sizeof(Matrix));
  c->row = a->row;
  c->column = b->column;
  c->next = b->next;
  c->back = a->back;
  if(a->back != NULL) a->back->next = c;
  if(b->next != NULL) b->next->back = c;
  free(a);
  free(b);
  return c;
}

Matrix *product_atob(Matrix *a, Matrix *b, int type,  long *sum) {
  int count;
  if(a == b) return a;
  if(type == 0) {
    while(a->next != b) {
      b = product_count(b, 0, &count);
      *sum += count;
    }
  }
  else {
   while(a->next != b) {
      a = product_count(a, 1, &count);
      *sum += count;
    }
  }
  a = product_count(a, 1, &count);
  *sum += count;
  return a;
}

Matrix *solve(Matrix *x, long *sum) {
  if(x->next == NULL) return x;
  Matrix *min = x->next, *p = x;
  while (p->next != NULL) {
    p = p->next;
    if(min->column > p->column) min = p;
  }
  if(min->column < x->row) {
    x = product_atob(x, min, 0, sum);
  }
  else if(min->column > x->row) {
    while(min->next != NULL) min = min->next;
    x = product_atob(x, min, 1, sum);
  }
  else {
    Matrix *min2 = x->next;
    p = x->next;
    while (p != min) {
      if(min2->column > min->column && min2->column > p->column) min2 = p;
      p = p->next;
    }
    x = product_atob(x, min2, 1, sum);
    product_atob(x->next, min, 0, sum);
    x = product_atob(x, x->next, 1, sum);
  }
  if(x->next != NULL) {
    p = solve(x->next,sum);
    x = product_atob(x,p,0,sum);
  }
  return x;
}

int main()
{
  int i,n,r,c;
  Matrix *begin = NULL;
  scanf("%d",&n);
  for (i = 0; i < n; i++) {
    scanf("%d %d",&r,&c);
    begin = push_back(begin,r,c);

  }
  long sum = 0;
  begin = solve(begin, &sum);
  cout << sum << 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];
    
    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;

#define FOR(i,a,b) for (int i=(a);i<(b);i++)
#define RFOR(i,a,b) for (int i=(b)-1;i>=(a);i--)
#define REP(i,n) for (int i=0;i<(n);i++)
#define RREP(i,n) for (int i=(n)-1;i>=0;i--)

const int MAX_N = 100;
vector<int> r(MAX_N);
vector<int> c(MAX_N);
//DP????????????
//DP[i,j]???i????????????j????????????????????????????????£?????¨??????????°????????????°
vector<vector<int> > DP(MAX_N, vector<int>(MAX_N,-1));

int dev(int k, int l){
	//?¨????????????????????????´???
	if(DP[k][l]<0){
		int mini=INT_MAX;
		if(k==l){
			mini=0;
		}
		FOR(i,0,l-k){
			int left = dev(k,k+i);
			int right = dev(k+i+1,l);
			mini=min(mini, left + right + r[k]*c[k+i]*c[l]);
		}
		DP[k][l]=mini;
	}
	return DP[k][l];	
}

int main(){
	int n;
	cin>>n;
	REP(i,n){
		cin>>r[i]>>c[i];
	}
	int res = dev(0,n-1);
	/*
	REP(i,n){
		REP(j,n){
			cout<<"["<<i<<"]["<<j<<"] "<<DP[i][j]<<endl;
		}
	}*/
	cout<<res<<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<bits/stdc++.h>

using namespace std;

struct Matrix
{
	int r,c;
};

int main()
{
	Matrix Mat[100]; 
	int n,dp[100][100];
	memset(dp,0,sizeof(dp));
	scanf("%d",&n);
	for(int i=0;i<n;i++)
		scanf("%d%d",&Mat[i].r,&Mat[i].c);
	for(int i=1;i<n;i++)
		for(int j=0;i+j<n;j++)
		{
			dp[j][i+j]=INT_MAX;
			for(int k=j;k<i+j;k++)
				dp[j][i+j]=min(dp[j][i+j],dp[j][k]+dp[k+1][i+j]+Mat[j].r*Mat[i+j].c*Mat[k].c);
		}
	printf("%d\n",dp[0][n-1]);
	return 0;
}