相邻石子的合并问题--什么是动态规划问题，什么时候用动态规划

问题描述：

石子合并问题是最经典的DP问题。首先它有如下3种题型：

(1)有N堆石子，现要将石子有序的合并成一堆，规定如下：每次只能移动任意的2堆石子合并，合并花费为新合成的一堆石子的数量。求将这N堆石子合并成

分析：当然这种情况是最简单的情况，合并的是任意两堆，直接贪心即可，每次选择最小的两堆合并。本问题实际上就是哈夫曼的变形。

(2)有N堆石子，现要将石子有序的合并成一堆，规定如下：每次只能移动相邻的2堆石子合并，合并花费为新合成的一堆石子的数量。求将这N堆石子合并成一堆的总花费最小（或最大）。

(3)问题(2)的是在石子排列是直线情况下的解法，如果把石子改为环形排列，又怎么做呢？

直接看第二个问题（直线型动态规划）：

假设： i 到 j（闭区间） 的问题可以看成是
从 i 到 k 的 （闭区间）问题与
从k+1到 j 的（闭区间）问题的 “和问题”
并且 两段子问题都是最优解时
和问题也是最优解
证明： 显然能把问题看成是两段问题的“和问题”，但是否满足子问题也是最优子结构呢？如果不是在 k 处取到 最优解 而是在h处取到最优解，那么根据题目要求 则 (i ,j )=(i, h ) + ( h+1,j)为最小值，也就是当 加数1最小 并且加数2 最小 时，和也最小 ，此时与假设矛盾，所以，子问题也满足最优子结构性质
递推关系式： dp[ i ] [ j ] = min( dp[ i ] [ k ] + dp[ k+1 ][ j ] ) +i到j的区间和

（反正区间和是定值，放在里面放在外面无所谓）

#include<iostream>
using namespace std;
const int maxn=1000;
int dp1[maxn][maxn];
int dp2[maxn][maxn];

int sum[maxn][maxn];
int data[maxn];
const int inf=0x1000000;
main(){
    int n;
    cin>>n;
    for(int a=1;a<=n;a++){
        cin>>data[a];
        sum[a][a]=data[a]; // 区间和
    }
    for(int len=2;len<=n;len++){ // 区间长度为2
        for(int i=1;i+len-1<=n;i++){ // 下标从1开始
            int j=(i+len-1);            // 此时的区间的末尾是j
            dp1[i][j]=inf;
            dp2[i][j]=0;

            /*
            最关键的是：
                深刻理解dp[i][i] : 我从i 到 i 不用消耗体力
                深刻理解dp[i][j]
                    把i到j这个区间分成两个区间
                    两个区间都是最优的，那么加上一个区间和(sum[][])还是最优的
                    满足最优子结构性质
            */
            for(int k=i;k<j;k++){
                sum[i][j] = sum[i][k] + sum[k + 1][j]; // 其实本质上都是区间和
                dp2[i][j]=max(dp2[i][j],dp2[i][k]+dp2[k+1][j]+sum[i][j]);
                dp1[i][j]=min(dp1[i][j],dp1[i][k]+dp1[k+1][j]+sum[i][j]);
            }
        }
    }
    for(int a=1;a<=n;a++){
        for(int b=1;b<=n;b++){
            cout<<dp1[a][b]<<' ';
        }
        cout<<endl;
    }
    cout<<endl;
    for(int a=1;a<=n;a++){
        for(int b=1;b<=n;b++){
            cout<<dp2[a][b]<<' ';
        }
        cout<<endl;
    }
}
/**

6 
3 4 6 5 4 2

0 7 20 36 51 61
0 0 10 25 38 48
0 0 0 11 24 34
0 0 0 0 9 17
0 0 0 0 0 6
0 0 0 0 0 0

0 7 23 44 67 91
0 0 10 26 45 66
0 0 0 11 26 43
0 0 0 0 9 20
0 0 0 0 0 6
0 0 0 0 0 0


*/

第三个问题（环形的动态规划）：

假设证明与上面的思路是一样的
但是值得注意的是: 及时len的长度已经确定，但是最开始的下标依旧可以指向最后一个，因为最后的下标用模除来逻辑上表述循环。但是区间和就变成了手动求出（原本还可以用前缀和O（1）求区间和）

#include<iostream>
using namespace std;

const int maxn=1000;
int dp[maxn][maxn];
const int inf=100000;

int data[maxn];
main(){
    int n;

    cin>>n;
    for(int a=0;a<n;a++ ){
        cin>>data[a];

    }
    for(int len=2;len<=n;len++){
        for(int i=0;i<n;i++){
            int j=(i+len-1)%n;
            int sum=0;
            // 求和
            for(int a=i;a!=j;a=(a+1)%n){
                sum=sum+data[a];
            }
            sum+=data[j];
            dp[i][j]=inf;
            for(int k=i;k!=j;k=(k+1)%n){
                int next=(k+1)%n;
                dp[i][j]=min(dp[i][j],dp[i][k]+dp[next][j]+sum);
            }
        }
    }
    for(int a=0;a<n;a++){
        for(int b=0;b<n;b++){
            cout<<dp[a][b]<<' ';
        }
        cout<<endl;
    }
}
/*
6
3 4 6 5 4 2

对例子(3 4 6 5 4 2)来说:
 第一阶段：s[1,1]=0,s[2,1]=0,s[3,1]=0,s[4,1]=0,s[5,1]=0,s[6,1]=0，因为一开始还没有合并，所以这些值应该全部为0。
 第二阶段：两两合并过程如下，其中sum(i,j)表示从i开始数j个数的和
           s[1,2]=s[1,1]+s[2,1]+sum(1,2)
           s[2,2]=s[2,1]+s[3,1]+sum(2,2)
           s[3,2]=s[3,1]+s[4,1]+sum(3,2)
           s[4,2]=s[4,1]+s[5,1]+sum(4,2)
           s[5,2]=s[5,1]+s[6,1]+sum(5,2)
           s[6,2]=s[6,1]+s[1,1]+sum(6,2)
 第三阶段：三三合并可以拆成两两合并，拆分方法有两种，前两个为一组或后两个为一组
      s[1,3]=s[1,2]+s[3,1]+sum(1,3)或s[1,3]=s[1,1]+s[2,2]+sum(1,3)，取其最优(最大或最小)
      s[2,3]=s[2,2]+s[4,1]+sum(2,3)或s[1,3]=s[2,1]+s[3,2]+sum(2,3)，取其最优
 第四阶段：四四合并的拆分方法用三种，同理求出三种分法的得分，取其最优即可。以后第五阶段、第六阶段依次类推，最后在第六阶段中找出最优答案即可。





 0 7 20 36 51 61
62 0 10 25 38 48
45 61 0 11 24 34
28 41 61 0 9 17
14 26 43 61 0 6
5 14 29 45 62 0


*/

如果你真的明白了这个问题，那就进行优化把