#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <limits>

using namespace std;


int main(void)
{
    std::ios::sync_with_stdio(false);
    ifstream in("podm.in");
    ofstream out("podm.out");

    vector<vector<long long>> m(505, vector<long long>(3, 0));
    vector<vector<long long>> dp(505, vector<long long>(505, 0));

    int n;

    in >> n >> m[1][0];

    for (int i = 1; i <= n; ++i) {
        in >> m[i][1];
        m[i + 1][0] = m[i][1];
    }

    // for (int  i = 1; i <= n; i++) {
    //     cout << m[i][0] << " " << m[i][1]<< endl;
    // }


    // for (int j = 1; j <= n; ++j) {
    //     for (int k = 1; k < n; ++k) {
    //         for (int i = 1; i <= n - k; ++i) {
    //             if (i < j) {

    //                 long a = dp[i][j - 1] + m[i][0] * m[j - 1][1] * m[j][1];
    //                 long b = dp[i + 1][j] + m[i + 1][0] * m[j][1] * m[i][0];

    //                 dp[i][j] = min(a, b);
    //             }
    //         }
    //     }
    // }


    for (int i = 1; i < n; i++) {
        for (int j = 1; j <= n - i; j++) {
            if (i == 1) {
                dp[j][j + i] = m[j][0] * m[j][1] * m[j + i][1];
            } else if (i > 1) {

                // int dreapta = j + i;
                dp[j][j + i] = numeric_limits<long>::max();
                
                for (int k = j; k < j + i; k++) {
                    long long a = dp[j][k] + dp[k + 1][j + i] + m[j][0] * m[k][1] * m[j + i][1];
                    dp[j][j + i] = min(dp[j][j + i], a);
                }
            }
        }
    }

    // for (int i = 1; i < n; i++) {
    //     for (int j = 1; j <= n - i; j++) {
    //         int dreapta = j + i; // capătul din dreapta al intervalului
            
    //         dp[j][dreapta] = 2e18; // Un infinit sigur care nu dă overflow la adunare
            
    //         for (int k = j; k < dreapta; k++) {
    //             // Am adăugat 1LL și am corectat indicele final la 'dreapta'
    //             long long cost = dp[j][k] + dp[k + 1][dreapta] + 
    //                              (1LL * m[j][0] * m[k][1] * m[dreapta][1]);
                                 
    //             // dp[j][dreapta] = min(dp[j][dreapta], cost);
    //             dp[j][dreapta] = min(dp[j][dreapta], cost);
    //         }
    //     }
    // }

    // for (int i = 0; i <= n; i++) {
    //     for (int j = 0; j <= n; j++) {
    //         cout << dp[i][j] << " ";
    //     }
    //     cout << endl;
    // }

    out << dp[1][n];


    in.close();
    out.close();
    return 0;
}