石子合并问题汇总

1：任意版
有N堆石子，现要将石子有序的合并成一堆，规定如下：每次只能移动任意的2堆石子合并，合并花费为将的一堆石子的数量。设计一个算法，将这N堆石子合并成一堆的总花费最小（或最大）。
此类问题比较简单，就是哈夫曼编码的变形，用贪心算法即可求得最优解。即每次选两堆最少的，合并成新的一堆，直到只剩一堆为止。证明过程可以参考哈夫曼的证明过程。

2：链式合并
设有N堆沙子排成一排，其编号为1,2,3,…,N(N<=100)。每堆沙子有一定的数量。现要将N堆沙子并成为一堆。归并的过程只能每次将相邻的两堆沙子堆成一堆，这样经过N-1次归并后成为一堆。找出一种合理的归并方法，使总的代价最小最（最大）。
思路：动态规划
假设dp[i][j] 表示从第i个到第j个合并时的最小（最大）代价，则可以得到递推公式

$$dp[i][j]=\begin{cases} 0 & i=j \\ \min\limits_{i\leq k < j}\{dp[i][j], dp[i][k] + dp[k+1][j] + sum[i][j] \} & i < j \end{cases}$$
最后的结果值就是dp[0][n-1]
代码如下：

#include<iostream>
#include<string>
#include<stdio.h>
#include<algorithm>

using namespace std;

const int inf = 99999999;
const int N = 300;
int num[N], sum[N], n;
int dpmax[N][N], dpmin[N][N];

int main() {
    while(cin>>n) {
        int i,j,k,total;
        for(i = 0; i < n; i++) {
            cin>>num[i];
        }

        sum[0] = num[0];
        for(i = 1; i < n; i++) {
            sum[i] = sum[i-1] + num[i];
        }

        for(i = 0; i < n; i++) {
            for(j = i; j < n; j++) {
                dpmax[i][j]= -inf;
                dpmin[i][j] = inf;
            }
        }

        for(i = 0; i < n; i++) {
            dpmax[i][i] = 0;
            dpmin[i][i] = 0;
        }

        for(k = 1; k < n; k++) {//长度
            for(i = 0; i + k < n; i++) {
                for(j = i; j < i + k; j++) {
                    if(i==0) total = sum[i+k];
                    else total = sum[i+k] - sum[i-1];
                    dpmax[i][i+k] = max(dpmax[i][i+k], dpmax[i][j] + dpmax[j+1][i+k] + total);
                    dpmin[i][i+k] = min(dpmin[i][i+k], dpmin[i][j] + dpmin[j+1][i+k] + total);
                }
            }
        }
        int resmax = dpmax[0][n-1];
        int resmin = dpmin[0][n-1];
        cout<<resmin<<"\n"<<resmax<<endl;
    }
    return 0;
}

3: 环形版
如果石子是排成圆形，其余条件不变，那么最优值又是什么呢？

思路：因为原型收尾相接，相当于从每一个元素为起点，长度为n的n条链式问题。所以，这个问题有两种解法：
1 拆环成链 设置大小为2*n 的数组，值为1 … n 1 …n， 这样就可以组成一个链式问题。
2 改变动态规划中的dp的含义。
我们先讨论第一种,dp的公式和链式一样，但是结果不同。代码如下：

#include<iostream>
#include<string>
#include<stdio.h>
#include<algorithm>

using namespace std;

const int inf = 99999999;
const int N = 300;
int num[N], sum[N], n;
int dpmax[N][N], dpmin[N][N];

int main() {
    while(cin>>n) {
        int i,j,k,total;
        for(i = 0; i < n; i++) {
            cin>>num[i];
            num[i+n] = num[i]; //将环变成链
        }

        sum[0] = num[0];
        for(i = 1; i < 2*n; i++) {
            sum[i] = sum[i-1] + num[i];
        }

        for(i = 0; i < 2 * n; i++) {
            for(j = i; j < 2 * n; j++) {
                dpmax[i][j]= -inf;
                dpmin[i][j] = inf;
            }
        }

        for(i = 0; i < 2 * n; i++) {
            dpmax[i][i] = 0;
            dpmin[i][i] = 0;
        }

        for(k = 1; k < n; k++) {//长度
            for(i = 0; i + k < 2 * n; i++) {
                for(j = i; j < i + k; j++) {
                    if(i==0) total = sum[i+k];
                    else total = sum[i+k] - sum[i-1];
                    dpmax[i][i+k] = max(dpmax[i][i+k], dpmax[i][j] + dpmax[j+1][i+k] + total);
                    dpmin[i][i+k] = min(dpmin[i][i+k], dpmin[i][j] + dpmin[j+1][i+k] + total);
                }
            }
        }
        int resmax = -inf;
        int resmin = inf;
        for(i = 0; i + n - 1 < 2 * n; i++) {//以每个元素为起点
            resmax = max(resmax,dpmax[i][i+n-1]);//长度为n
            resmin = min(resmin,dpmin[i][i+n-1]);//长度为n
        }
        cout<<resmin<<"\n"<<resmax<<endl;
    }
    return 0;
}

注意： 循环时，长度还是从1到n的， 最后的结果是 每个元素作为起点长度为n的最小的值中最小的。

思路2：
设dp[i][j] 表示从i开始长度为j的一段合并后的最小（最大）值，这样j的最大为n，很好的避免了下标越界问题。 递推公式如下所示：

$$dp[i][j] = \begin{cases} 0 & j = 0 \\ \min\{ dp[i][k] + dp[(i+ k + 1) \% n][j - k - 1] + sum(i,j) \} & 0 \leq k < j \end{cases}$$
其中：
$$sum[i][j] = \begin{cases} \sum\limits_{k=i}^{j}stone[k] & i + j < n \\ \sum\limits_{k= i}^{n-1} stone[k] + \sum\limits_{k =0 }^{(i+j) \% n}stone[k] & i + j \leq n \end{cases}$$
最后的结果是 每个元素作为起点长度为n的最小的值中最小的。
代码如下：

#include<iostream>
#include<string.h>
#include<stdio.h>

using namespace std;

const int inf = 99999999;
const int N = 300;

int dpmin[N][N];
int dpmax[N][N];
int sum[N], a[N];
int resmin, resmax;
int n;

int getsum(int i, int len) //从i开始的len个
{
    if(i + len >= n) return getsum(i,n-i-1) + getsum(0,(i+len) % n);
    else return sum[i+len] - (i > 0 ? sum[i-1] : 0);
}

void func(int a[], int n)
{
    for(int i = 0; i < n; i++)
        dpmin[i][0] = dpmax[i][0] = 0;

    for(int j = 1; j < n; j++)
    {
        for(int i = 0; i < n; i++)
        {
            dpmin[i][j] = inf;
            dpmax[i][j] = -inf;
            for(int k = 0; k < j; k++)
            {
                dpmin[i][j] = min(dpmin[i][j], dpmin[i][k] + dpmin[(i+k+1) % n][j - k - 1] + getsum(i,j));
                dpmax[i][j] = max(dpmax[i][j], dpmax[i][k] + dpmax[(i + k + 1) % n][j - k - 1] + getsum(i,j));
            }
        }
    }
    resmin = dpmin[0][n-1];
    resmax = dpmax[0][n-1];

    for(int i = 0; i < n; i++)
    {
        resmin = min(resmin, dpmin[i][n-1]);
        resmax = max(resmax, dpmax[i][n-1]);
    }
}

int main()
{
    freopen("input.txt","r",stdin);
    scanf("%d",&n);
    for(int i = 0; i < n; i++)
    {
        scanf("%d",&a[i]);
    }
    sum[0] = a[0];
    for(int i = 1; i < n; i++)
    {
        sum[i] = sum[i-1] + a[i];
    }
    func(a,n);
    printf("%d %d\n", resmin,resmax);

    return 0;
}