DP石子合并

一、问题：

        有n堆石子，现在要把n堆石子合并成一堆石子，每堆石子给定质量，且每次只能相邻的石堆合并，合并的代价是两堆石子的质量之和，问把n堆石子合并成一堆石子的最小代价。

例：（4堆石子） 1 3 5 2

如果合并1，2两堆得到4，5，2，代价为1 + 3，然后再合并1，2两堆得到9，2，代价为4 + 5，最后合并剩余的两堆，代价为4 + 9 + 9 + 2 = 24  

如果第二次合并2，3两堆，得到的最小代价为22

发现，不同方案的代价可能不同。（暴力）如果枚举所有方案并求其最小代价，时间复杂度为(n-1)!        [(n - 1) * (n - 2) * ... ] ,会超时。

二、思路求解：

此时就想到如何用动态规划的思想把它们一类一类的解决，而不是一个一个的解决。

这里引入闫式DP分析法的思想（视频链接：AcWing 282. 石子合并（闫氏DP分析法） - AcWing）

从两个角度考虑：

1. 状态表示：
   1. 集合（根据经验想如何定义）：f(i,j)表示所有 i 到 j 堆的合并的方案的集合
   2. 属性：Min                    
2. 状态计算（对集合的划分,一般是找最后一个不同点）：

                (最后一次划分) 以分界点k做为划分依据，将f(i,j)划分为 [i, k]和[k + 1,j]两堆，只要让这两堆得代价最小，代价用前缀和的思想就能就出f(i,j)。

                f[i][j] = min(f[i][j],  f[i][k]+f[k + 1][j] + s[j] - s[i - 1])

 三、代码求解：

#include <iostream>
#include <cstring>

using namespace std;

const int N = 310, inf = 0x3f;

int f[N][N];
int a[N], s[N];
int n;

int main()
{
    cin >> n;
    memset(f, inf, sizeof f);
    for (int i = 1; i <= n; i ++)
    {
        scanf("%d", &a[i]);
        s[i] = s[i - 1] + a[i];
        f[i][i] = 0; //初始化
    }
    
    for (int len = 2; len <= n; len ++)//枚举长度(小技巧，避免出现调用没计算过f的情况，保证后面用到的状态前面已经计算过)
    {
        for(int i = 1; i + len - 1 <= n ; i ++ )//枚举左端点
        {
            int j = i + len - 1;
            //枚举k
            for (int k = i; k < j; k ++)
                f[i][j] = min(f[i][j], f[i][k] + f[k + 1][j] + s[j] - s[i - 1]);
        
        }
    }
    cout << f[1][n];
    return 0;
}

 注：如解释有问题，欢迎指教。