Interval DP (gravel consolidation)

I finally posted an article , The computer was repaired yesterday
Paste the code directly , Because I'm going to play football

/*  Section DP  Interval dynamic programming is an extension of linear dynamic programming , It's dividing problems in stages ,  It has a lot to do with the order in which elements appear in the phase and which elements are merged from the previous phase   The key word is merging , That is, the interval of a problem can be divided into two parts and merged , Then each part of the can be further decomposed   Thinking of this topic ：  Note that only two adjacent heaps can be merged   The interval [i,j] The stones in the merge , The last merger is bound to merge the left and right piles .  Therefore, we can know the consolidation interval [i,j] The minimum value of is to merge the minimum value of the left pile plus the minimum value of the right pile, and then add the value of this merge   But how to decide where to divide the left and right piles , Then you can only traverse .  Divide into two piles, and then continue to divide according to the above ideas .  Similar to the idea of partition   When writing code , First write short intervals and then gradually merge them into large intervals  min(i,j)=min(i,k)+min(k+1,j)+s[j]-s[i-1];  Section dp Common templates ：  Traversal interval length   Traverse the left endpoint   Traversal classification  */
	
#include<iostream>
	
using namespace std;
	
const int M=310;
int N; 
int stones[M];
int dp[M][M];
int s[M];// Prefixes and arrays  
	

int main(){
    
	cin>>N;
	for(int i=1;i<=N;i++){
    
		cin>>stones[i];
		s[i]=s[i-1]+stones[i];
	}
	
	for(int len=2;len<=N;len++){
    
		for(int i=1;i+len-1<=N;i++){
    
			int j=i+len-1;
			dp[i][j]=1e8;
			for(int k=i;k<j;k++){
    
				dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+s[j]-s[i-1]);
			}
		}	
	}
	
	cout<<dp[1][N]<<endl;
	return 0;
}