#include <fstream>
#define infinit 1000000000000LL
#define nmax 509
using namespace std;

long long int t[nmax], d[nmax][nmax];
int n;

void Citire()
{
    int i;
    ifstream fin("podm.in");
    fin >> n;
    for (i = 0; i <= n; ++i)
        fin >> t[i];
    fin.close();
}

void Rezolva()
{
    int i, j, dif, k;
    long long int minim;
    for (i = 1; i < n; ++i)
        d[i][i + 1] = t[i - 1] * t[i] * t[i + 1]; /// initializari

    for (dif = 2; dif < n; dif++)
        for (i = 1; i <= n - dif; ++i)
        {
            j = i + dif;
            minim = infinit;
            for (k = i; k < j; ++k)
                minim = min(minim, d[i][k] + d[k+1][j] + t[i - 1]*t[k]*t[j]);
            d[i][j] = minim;
        }
}

void Afisare()
{
    ofstream fout("podm.out");
    fout << d[1][n] << "\n";
    fout.close();
/*
-------------------------------------------------------------------------------------------------------------------------------------------------------------

Se da N -> lungimea unui sir de biti (0 si 1).
Se stie ca sirul contine exact 3 de 1.
Sa se determine al M-lea sir ordonat lexicografic de acest gen

N = 5
M = 7

1 -> 00111
2 -> 01011
3 -> 01101
4 -> 01110

5 -> 10011
6 -> 10101
7 -> 10110
8 -> 11001
9 -> 11010

cate siruri de n biti cu exact 3 de 1 exista => raspuns: Combinari de N luate cate 3

Generarea intr-o matrice a triunghiului lui pascal

recurenta a[i][j] = a[i-1][j-1] + a[i-1][j];
initializare  a[i][0] = 1, pentru i = 0, N
                    a[i][i] = 1,  pentru i = 1, N


pentru a gasi Cn luate cate k ne ducem in matrice la pozitia a[n][k]

(eu am nevoie doar de linia Combinari de n luate cate k, cu k = 0, 3 adica linia n din matrice!)

n = N;

cate siruri sunt care incep cu 0 => Cn-1 luate cate 3
C4 luate cate 3 = 4

ce cazuri avem?  zicem ca M = 3

C[n-1][3] = M    atunci afisez 0, apoi cati de 1 mai am, apoi cati de 0 au mai ramas pana la final
C[n-1][3] > M    atunci sirul sigur incepe cu 0, afisez 0, merg mai departe, mai am 3 de 0    CAZ 1
C[n-1][3] < M    atunci sirul sigur incepe cu 1, afisez 1, merg mai departe, mai am 2 de 0    CAZ 2

mergem pe cazul 1
C3 luate cate 3 inseamna 1

C[n-2][3] = M   atunci afisez 0, apoi cati de 1 mai am, apoi cati de 0 au mai ramas pana la final
C[n-2][3] > M   atunci sirul sigur continua cu 0, afisez 0, merg mai departe, mai am 3 de 0    CAZ 1
C[n-2][3] < M   atunci sirul sigur continua cu 1, afisez 1, scad din nr de 1 ramasi, raman cu 2 de 1  CAZ 2

am ramas cu 2 de 1

C2 luate cate 2 inseamna 1

C[n-3][2] = M  atunci afisez 0, apoi cati de 1 mai am, apoi cati de 0 au mai ramas pana la final
C[n-3][2] > M  .... nu e
C[n-3][2] < M  atunci sirul sigur continua cu 1, afisez 1, scad din nr de 1 ramasi, raman cu 1 de 1  CAZ 2

am ramas cu 1 de 1

C1 luate cate 1 inseamna 1

C[n-4][1] = M   ... nu e
C[n-3][2] > M
*/
}

int main()
{
    Citire();
    Rezolva();
    Afisare();
    return 0;
}