// Slower C++ solution:
#include <bits/stdc++.h>                                           

 

#define int long long

//#pragma GCC optimize("Ofast")

//#pragma comment(linker, "/stack:200000000")

//#pragma GCC target("sse,sse2,sse3,ssse3,sse4")

 

 

#define file(s) freopen(s".in","r",stdin); freopen(s".out","w",stdout);

#define forev(i, b, a) for(int i = (b); i >= (a); --i)

#define forn(i, a, b) for(int i = (a); i <= (b); ++i)

#define all(x) x.begin(), x.end()

#define sz(s) (int)s.size()

#define pb push_back

#define ppb pop_back

#define s second

#define f first

 

 

using namespace std;

 

 

typedef pair < long long, long long > pll;    

typedef pair < int, int > pii;

typedef unsigned long long ull;         

typedef vector < pii > vpii;

typedef vector < int > vi;

typedef long double ldb;  

typedef long long ll;  

typedef double db;                      

 

 

const int inf = 1e9, maxn = 4e5 + 148, mod = 1e9 + 7, N = 411;

const int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1}, block = 555;

const pii base = {1171, 3307}, Mod = {1e9 + 7, 1e9 + 9};

const db eps = 1e-12, pi = 3.14159265359;

const ll INF = 1e18;





int n, a[N], dp[N][N];



int get (int l, int r) {

	return a[r] - a[l - 1];

}



int rec (int l, int r) {

	if (r == l)	

		return 0;

	if (dp[l][r] != -1)

		return dp[l][r];



	dp[l][r] = INF;



	forn (L, l, r - 1) 

		dp[l][r] = min(dp[l][r], rec(l, L) + rec(L + 1, r) + get(l, L) + get(L + 1, r));		



	return dp[l][r];	

}





main () {

	cin >> n;

	forn (i, 1, n) {

		cin >> a[i]; 

		a[i] += a[i - 1];

	}



	memset(dp, -1, sizeof(dp));

	cout << rec(1, n) << endl;

}



    

// Faster C++ solution for the same problem (measured speedup: 2.3063099796091855x):
//Bismillahir Rahmanir Rahim

 

//#pragma GCC optimize("Ofast,unroll-loops")

//#pragma GCC target("avx,avx2,fma")

        

#include<bits/stdc++.h>

#include<ext/pb_ds/assoc_container.hpp>

#include<ext/pb_ds/tree_policy.hpp>

 

#define ll long long

#define ull unsigned long long

#define pii pair<int,int>

#define pll pair<ll,ll>

#define xx first

#define yy second

#define sci(n) scanf("%d",&n)

#define scii(n,m) scanf("%d%d",&n,&m)

#define sciii(n,m,w) scanf("%d%d%d",&n,&m,&w)

#define scl(n) scanf("%lld",&n)

#define scll(n,m) scanf("%lld%lld",&n,&m)

#define sclll(n,m,w) scanf("%lld%lld%lld",&n,&m,&w)

#define pf(a)   printf("%d\n",a)

#define CASE(a) printf("Case %d: ",a)

#define endl '\n'

#define READ  freopen("input.txt","r",stdin)

#define WRITE freopen("output.txt","w",stdout);

#define PI acos(-1)

#define mem(a,b) memset(a,b,sizeof(a))

#define SQR(a) (a)*(a)

#define all(v) v.begin(),v.end()

#define pb push_back

#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);

#define mod 1000000007

#define inf INT_MAX

#define eps 1e-9



using namespace __gnu_pbds;

using namespace std;



#define Gene template< class

#define Rics printer& operator,

Gene c> struct rge{c b, e;};

Gene c> rge<c> range(c i, c j){ return {i, j};}

struct printer{

    ~printer(){cerr<<endl;}

    Gene c >Rics(c x){ cerr<<boolalpha<<x; return *this;}

    Rics(string x){cerr<<x;return *this;}

    Gene c, class d >Rics(pair<c, d> x){ return *this,"(",x.first,", ",x.second,")";}

    Gene ... d, Gene ...> class c >Rics(c<d...> x){ return *this, range(begin(x), end(x));}

    Gene c >Rics(rge<c> x){

        *this,"["; for(auto it = x.b; it != x.e; ++it)

            *this,(it==x.b?"":", "),*it; return *this,"]";}

};

#define debug() cerr<<"LINE "<<__LINE__<<" >> ", printer()

#define dbg(x) "[",#x,": ",(x),"] "

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

int my_rand(int l, int r) {

    return uniform_int_distribution<int>(l, r) (rng);

}

 

//int dx[] = {0,1,0,-1,1,1,-1,-1};

//int dy[] = {1,0,-1,0,1,-1,-1,1};

 

//ll ncr(ll n,ll r){if(n==r)return 1;if(r==1)return n;if(dp[n][r]!=-1)return dp[n][r];return dp[n][r]=ncr(n-1,r)+ncr(n-1,r-1);}

 

// bit manipulations

 

//bool checkbit(int mask,int bit){return mask & (1<<bit);}

//int setbit(int mask,int bit){ return mask | (1<<bit) ; }

//int clearbit(int mask,int bit){return mask & ~(1<<bit);}

//int togglebit(int mask,int bit){return mask ^ (1<<bit);}

//int bitno(int mask) {return (int)__builtin_popcount(mask);}

 

template <typename T> T BigMod (T b,T p,T m){if (p == 0) return 1;if (p%2 == 0){T s = BigMod(b,p/2,m);return ((s%m)*(s%m))%m;}return ((b%m)*(BigMod(b,p-1,m)%m))%m;}

template <typename T> T ModInv (T b,T m){return BigMod(b,m-2,m);}

template <typename T> T POW(T B,T P){ if(P==0) return 1; if(P&1) return B*POW(B,P-1);  else return SQR(POW(B,P/2));}

template <typename T> T Dis(T x1,T y1,T x2, T y2){return sqrt( SQR(x1-x2) + SQR(y1-y2) );}

template <typename T> T Angle(T x1,T y1,T x2, T y2){ return atan( double(y1-y2) / double(x1-x2));}

template <typename T> T gcd(T a,T b){if(a<0)return gcd(-a,b);if(b<0)return gcd(a,-b);return (b==0)?a:gcd(b,a%b);}

template <typename T> T lcm(T a,T b) {if(a<0)return lcm(-a,b);if(b<0)return lcm(a,-b);return a*(b/gcd(a,b));}

template <typename T> T euclide(T a,T b,T &x,T &y) {if(a<0){T d=euclide(-a,b,x,y);x=-x;return d;}   if(b<0){T d=euclide(a,-b,x,y);y=-y;return d;}   if(b==0){x=1;y=0;return a;}else{T d=euclide(b,a%b,x,y);T t=x;x=y;y=t-(a/b)*y;return d;}}

template <typename T> void ia (T a[],int n){for (int i=0; i<n; i++) cin >> a[i];}

template <typename T> void pa (T a[],int n){for (int i=0; i<n-1; i++) cout << a[i] << " ";cout << a[n-1] << endl;}

template <typename T> ll isLeft(T a,T b,T c) { return (a.x-b.x)*(b.y-c.y)-(b.x-c.x)*(a.y-b.y);}

 

template<typename T>

using ordered_set=tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;

 

///********************************MY CODE STARTS HERE********************************///

 

 

#define mxn 405



ll arr[mxn];

ll dp[mxn][mxn];

ll cum[mxn];

 

void solve(){

   

   int n;

   cin >> n;



   for(int i = 1;i <= n;i++){

   	  cin >> arr[i];

   	  cum[i] = cum[i - 1] + arr[i];

   }



   for(int i = 0;i <= n;i++){

   	for(int j = 0;j <= n;j++){

   		dp[i][j] = 1e17;

   	}

   }





   for(int sz = 1;sz <= n;sz++){

   	 for(int i = 1;i + sz - 1 <= n;i++){

   	 	int j = i + sz - 1;

   	 	if(sz == 1){

   	 		dp[i][j] = 0;

   	 		continue;

   	 	}

   	 	for(int k = i;k < j;k++){

   	 		dp[i][j] = min(dp[i][j] , cum[j] - cum[i - 1] + dp[i][k] + dp[k + 1][j]);

   	 		//cout << dp[i][j] << endl;

   	 	}

   	 }

   }



   cout << dp[1][n] << endl;





   



}

 

 

int main(){

       IOS;

    

    int T = 1;

    

    // cin >> T;



    while(T--){



    	solve();

    }



return 0;

}