hihocoder1636 Pangu and Stones（区间DP（石子合并变形））

题目链接：http://hihocoder.com/problemset/problem/1636

题目大意：有n堆石头，每次只能合并l~r堆，每次合并的花费是要合并的石子的重量，问你合并n堆石子的最小花费，若不能合并则输出0。

解题思路：

这算是石子合并的加强版了吧，原来石子合并是只能两堆两堆地合并，而现在对合并堆数加了一个范围[l,r]。这题我看到的时候也没什么想法，看了题解才会的，而且也看的不是特别懂。

首先定义数组dp[i][j][k]表示将[i,j]的石子合并成k堆需要的最小花费。

那么我们可以得到状态转移方程：

①p>1时，dp[i][j][p]=min(dp[i][j][p]，dp[i][k][p-1]+dp[k+1][j][1])，（i=<k<j，2=<p<=r）

②p==1时，dp[i][j][1]=min(dp[i][j][1]，dp[i][j][k]+sum[j]-sum[i-1])，（l=<k<=r）

之前还有几个疑问：

1、为什么①中，p范围是[2,r]而不是[l,r]？

答：[l,r]是的限制是给p==1时即合并的时候用的，单纯地划分区间并没有这个限制。

2、为什么①的状态转移方程是可行的，难道不应该写成dp[i][j][p]=min(dp[i][j][p]，dp[i][k][p-x]+dp[k+1][j][x])吗？

答：如果手动模拟一下会发现，上面连个状态转移方程是等效的，所以①可以求出最优解，而且考虑到时间复杂度的问题，①省去了枚举x的花费，显然更优。

代码：

 #include<cstdio>
 #include<cmath>
 #include<cctype>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 #include<vector>
 #include<queue>
 #include<set>
 #include<map>
 #include<stack>
 #include<string>
 #define lc(a) (a<<1)
 #define rc(a) (a<<1|1)
 #define MID(a,b) ((a+b)>>1)
 #define fin(name)  freopen(name,"r",stdin)
 #define fout(name) freopen(name,"w",stdout)
 #define clr(arr,val) memset(arr,val,sizeof(arr))
 #define _for(i,start,end) for(int i=start;i<=end;i++)
 #define FAST_IO ios::sync_with_stdio(false);cin.tie(0);
 using namespace std;
 typedef long long LL;
 const int N=2e2+;
 const int INF=0x3f3f3f3f;
 const double eps=1e-;

 int sum[N];
 int dp[N][N][N];

 int main(){
     int n,l,r;
     while(cin>>n>>l>>r){
         memset(dp,0x3f,sizeof(dp));
         for(int i=;i<=n;i++){
             cin>>sum[i];
             sum[i]+=sum[i-];
         }
         for(int i=;i<=n;i++){
             for(int j=i;j<=n;j++){
                 dp[i][j][j-i+]=;
             }
         }
         for(int len=;len<n;len++){
             for(int i=;i+len<=n;i++){
                 int j=i+len;
                 //注意p要从2开始,而不是从l开始
                 for(int p=;p<=r;p++){
                     for(int k=i;k<j;k++){
                         if(k-i+<p-) continue;
                         dp[i][j][p]=min(dp[i][j][p],dp[i][k][p-]+dp[k+][j][]);
                     }
                 }
                 for(int p=l;p<=r;p++){
                     dp[i][j][]=min(dp[i][j][],dp[i][j][p]+sum[j]-sum[i-]);
                 }
             }
         }
         if(dp[][n][]==INF)
             cout<<<<endl;
         else
             cout<<dp[][n][]<<endl;
     }
     return ;
 }