/* @Author: Shubham Anand */
 
#include <unordered_map>
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <limits>
#include <chrono>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <list>
#include <map>
#include <set>
 
#define FILEIN          freopen("input.txt", "r", stdin)
#define FILEOUT         freopen("output.txt", "w", stdout)
#define FASTIO          std::ios_base::sync_with_stdio(0); std::cin.tie(NULL); std::cout.tie(NULL)
#define PAUSE           while(1){}
#define NEWLINE         std::cout << "\n"
#define EDGES           std::unordered_map<std::pair<int,int>,int>
#define PB(N)           push_back(N)
 
/* Constants */
const unsigned int MODULO = 1e9+7;
const unsigned int INF = std::numeric_limits<int>::max();
const int NINF = std::numeric_limits<int>::min();
 
/* Input Output */
template <class T> void write(const T &a, char del='\n')        { if(del=='~')std::cout<<a; else std::cout<<a<<del; }
template <class T> void line(const T &w)                        { for(int i=0;i<(w+1)/2;i++)write('_','_');NEWLINE; }
template <class T> void read(T &a)                              { std::cin >> a; }
 
/* Modular Ops */
template <class T> T add(T a, T b, T m) { a=a%m; b=b%m; return (a+b)%m; }
template <class T> T mul(T a, T b, T m) { a=a%m; b=b%m; return (a*b)%m; }
 
/* Basic Algorithms */
template <class T> T gcd(T a, T b)      { if(b>a){return gcd(b,a);} if(b==0){return a;} return gcd(b, a%b); }
template <class T> T bexp(T a, T b, T m){ if(b==1){return a;}if(b&1){return mul(a,bexp(a,b-1,m),m);}T c=bexp(a,b/2,m); return mul(c,c,m);}
template <class T> T inv(T a, T m)      { return bexp(a,m-2,m); }
 
/* Commonly used data structures */
namespace ds {
    template<class T> struct Point{ T x,y,z; Point(T _x=0,T _y=0,T _z=0):x(_x), y(_y), z(_z){}; };
    template<class T> struct Graph{ std::vector<T> *adj; Graph(T n){adj=new std::vector<T>[n];} void add(T u, T v, bool d=0){adj[u].PB(v);if(!d){adj[v].PB(u);}} void w_add(T u, T v, T w, bool d=0){adj[u].PB(std::make_pair(v,w)); if (!d){adj[v].PB(std::make_pair(u,w));}}};
}
 
/* Function to calculate runtime */
void time(void func()) {
    std::chrono::time_point<std::chrono::high_resolution_clock> start, end;
    start = std::chrono::high_resolution_clock::now();
    func();
    end = std::chrono::high_resolution_clock::now();
    long long elapsed_time = std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count();
    std::cout << "\tElapsed Time: " << elapsed_time << "ms\n";
}
 
/* Declare any global objects here */
typedef unsigned long long ull;
const int nax = 401;
ull dp[nax][nax];
ull cost[nax][nax];
/************** END ****************/

ull getWeight(int i, int j, ull *w) {
    // std::cout << i << " " << j << "\n";
    if (i==j) { cost[i][j] = 0; return w[i]; }
    if (~dp[i][j]) { return dp[i][j]; }
    ull min = std::numeric_limits<ull>::max();
    for (int k=i; k<j; k++) {
        ull left_weight = getWeight(i,k,w);
        ull right_weight = getWeight(k+1,j,w);
        ull left_cost = left_weight + cost[i][k];
        ull right_cost = right_weight + cost[k+1][j];
        // min = std::min(min,  left_weight);
        if (left_cost + right_cost < cost[i][j]) {
            min = left_weight + right_weight;
            cost[i][j] = left_cost + right_cost;
        }
    }
    dp[i][j] = min;
    return dp[i][j];
}

void solve() {

    int N; std::cin >> N;
    ull w[N];
    for (int i=0; i<N; i++) { read(w[i]); }
    memset(dp, -1, sizeof(dp));
    memset(cost, std::numeric_limits<int>::max(), sizeof(cost));

    getWeight(0,N-1,w);

    std::cout << cost[0][N-1] << "\n";

}
 
signed main() {
 
    // FILEIN; 
    // FILEOUT;
    FASTIO;
 
    int T = 1;
    // Uncomment to read testcases
    // read(T);
    
    while (T--) {
        // time(solve);
        solve();
    }
 
    return 0;
}

Measured memory_bytes: 2816