#include <algorithm>
#include <iostream>
#include <vector>
#include <fstream>
using namespace std;
ifstream fin("podm.in");
ofstream fout("podm.out");
const long long inf = 1LL << 60;
long long n, m, d[505], dp[505][505];
int main() {
    fin >> n;
    for (int i = 0; i <= n; i ++) {
        fin >> d[i];
    }
    for (int i = 1; i <= n; i ++) {
        for (int j = 1; j <= n; j ++) {
            dp[i][j] = inf;
        }
    }
    for (int i = 1; i <= n; i ++) {
        dp[i][i] = 0;
    }
    for (int i = 1; i <= n-1; i ++) {
        dp[i][i+1] = d[i-1] * d[i] * d[i+1];
    }
    for (int len = 3; len <= n; len ++) {
        for (int i = 1; i + len - 1 <= n; i ++) {
            int j = i + len - 1;
            for (int k = i; k <= j - 1; 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];
    return 0;
}

// dp[i][j] = care este numarul minim de inmultiri
//            dintr-o parantezare optima a matricelor intre indicii
//            i si j

// Raspuns: dp[1][n]

// dp[i][j] = d[i-1] * d[i] * d[i+1], daca i + 1 == j (sunt matrice consecutive in sir)
// dp[i][j] = min(dp[i][k] + dp[k+1][j] + d[i-1] * d[k] * d[j]), k intre i si j-1, k - punctul in care taiem in doua,
// matricele intre i si k inclusiv sunt in prima jumatate,
// matricele intre k+1 si j inclusiv sunt in a doua jumatate

// ABCDEF
// (A) * (BCDEF)
// (AB) * (CDEF)
// (ABC) * (DEF)
// (ABCD) * (EF)
// (ABCDE) * (F)