#include <fstream>

using namespace std;

ifstream fin("podm.in");
ofstream fout("podm.out");

const int DM = 5e2 + 2;
const long long inf = 1e17;

long long n,d[DM];
long long dp[DM][DM];

int main()
{
	fin >> n;
	for(int i = 0; i <= n; i++) fin >> d[i];

	for(int i = 1; i <= n; i++) dp[i][i] = 0;
	for(int i = 1; i < n; i++) dp[i][i + 1] = d[i - 1] * d[i] * d[i + 1];
	//M[I][J] = produsul matricelor de la i...j. Deci, prin parantezari, la final vom ajunge sa avem doar doua inmultiri
	//acestea fiind, sa zicem Ak si Ak+1. Deci costul final va fi costul inmultirii matricelor
	//Ak (i....k), respectiv Ak+ 1 (k + 1... i.+ j), si costul inmultirii Ak cu Ak + 1
	//Deci, pt m[i][j], mergem de a i....k,  si de la k + 1...j =>> dp[i][k] + dp[k + 1][i + j]
	//pt ca sunt impartite in Ak si Ak+1, avem i <= k < j;
	//evaluarea produsului A i...k cu A k + 1..... d necesita d[i - 1] * d[k] * d[j] inmultiri.

	//""restrangem" (vezi mai sus, obtinerea pt Ak si Ak+1) m[i][j] in i ... k si k + 1 ... i + d
	
	for(int l = 2; l < n; l++)  // l ne ajuta sa impartim sirul
		for(int i = 1; i <= n - l; i++) //i este capatul stranga
		{
			int j = i + l;// j este capatul dreapta
			dp[i][j] = inf;
			for(int k = i; k < j; k++) 
				dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + d[i - 1] * d[k] * d[j]);
		}
	
	fout << dp[1][n];

	fin.close();
	fout.close();
	return 0;
}