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+5;
const int INF=0x3f3f3f3f;
const double eps=1e-10;

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