2017北京ICPC Pangu and Stones（区间DP）

题意：

n个石子堆排成一排，每次可以将连续的最少L堆，最多R堆石子合并在一起，消耗的代价为要合并的石子总数

求合并成1堆的最小代价，如果无法做到输出0、

分析：

关键在于二维数组无法通过枚举解决了，所以要多开一维，用三维数组来做。

表示的状态为从第 i 堆，到第 j 堆，合并为 x 堆，最小需要的代价。

时间复杂度为O（n^4）。 状态的转移就在于先枚举长度，再枚举起点，因而知道终点，再枚举要将这段区间合并为x堆。当要合并为1堆时，是所求的状态，就要从L堆到R堆中计算出来，而当要合并为不止1堆时，就像普通区间dp那样，枚举分割线。

其实这个只在计算合成一堆的时候计算 sum 值，而不在计算合成多堆时计算 sum 值的原因在于，将多堆石子分成更少堆时，至少是要把两堆合成一堆，所以合成一堆是时候才是关键所在。

#include 
#include 
#include 
using namespace std;

const int maxn = 105;
const int inf = 0x3f3f3f3f;
int a[maxn],pre[maxn];
int dp[maxn][maxn][maxn];

int main(){
    int n,l,r;
    while(scanf("%d%d%d",&n,&l,&r)!=EOF){
        pre[0] = 0;
        for(int i=1; i<=n; i++){
            scanf("%d",a+i);
            pre[i] = pre[i-1] + a[i];
        }
        memset(dp,inf,sizeof(dp));
        for(int i=1; i<=n; i++){
            dp[i][i][1] = 0;
        }
        for(int len=l; len<=r; len++){
            for(int i=1; i<=n-len+1; i++){
                int j=i+len-1;
                dp[i][j][len] = 0;
                dp[i][j][1] = pre[j]-pre[i-1];
            }
        }
        
        for(int len=2; len<=n; len++){     //先枚举长度
            for(int i=1; i<=n-len+1; i++){         //再枚举起点
                int e=i+len-1;
                for(int x=len; x>=1; x--){    //枚举堆数
                    if(x==1){
                        for(int j=l; j<=r; j++){  //如果是合并为1堆，就枚举堆数
                            dp[i][e][1] = min(dp[i][e][1], dp[i][e][j]+pre[e]-pre[i-1]);
                        }
                    }
                    else{
                        for(int j=i; j<=e-1; j++){  //如果合并为多堆，就枚举分割线
                            dp[i][e][x] = min(dp[i][e][x], dp[i][j][x-1]+dp[j+1][e][1]);
                        }
                    }
                }
            }
        }
        
        
        printf("%d\n", dp[1][n][1] == inf? 0: dp[1][n][1]);
    }
}

 

转载于:https://www.cnblogs.com/-Zzz-/p/11614546.html