跟着编程之美学算法——数组分割

对于这个问题，首先按照《编程之美》中的分析对这个问题进行一定的简化。从2n个数中找n个元素，有三种可能：大于Sum/2，小于Sum/2以及等于Sum/2。而大于Sum/2与小于等于Sum/2没区别，故可以只考虑小于等于Sum/2的情况。

动态规划第一步，分析子问题：

这里我们用一个三维数组F[][][]表示子问题，F[i][j][k]表示前i个元素中选取j个元素，使得其和不超过k且最接近k。这个子问题可以根据第i个元素是否选择来进行分析：

如果我们想回溯找到一组合理的分割方式，那么在子问题的求解过程中，就要记录有效的路径，这样我们再用一个三维数组path[][][]来记录。

伪代码如下所示：

F[][][] = 0
path[][][] = 1

for i = 1 to 2*N
    nLimit = min(i, N)
    for j = 1 to nLimit
        for k = 1 to sum/2
            F[i][j][k] = F[i-1][j][k]
            if k > A[i] && F[i-1][j-1][k-A[i]] + A[i] > F[i][j][k]
                F[i][j][k] = F[i-1][j-1][k-A[i]] + A[i]
                path[i][j][k] = 1

return F[2N][N][sum/2], path[][][]

按照这样思路，该算法的时间复杂度为O(n^2*sum)，空间复杂度也为O(n^2*sum)。

一下的分析，是针对上面的算法，进一步优化。优化的方向为降低空间复杂度。

优化的思路借鉴了0-1背包问题的思路，最外层循环是对元素的顺序遍历，这一步可以省略，为了保证每次计算时，问题F[i][j][k]的第i-1步为上次的状态，那么我们选择倒叙遍历变量j，这样可以保证变量i-1状态为上一步的状态。

这样改进之后的伪代码是：

F[][] = 0
path[][][] = 0

for i = 1 to 2*N
    nLimit = max(i, N)
    for j = nLimit to 1
        for k = 1 to sum/2
            if k > A[i] && F[j-1][k-A[i]] + A[i] > F[j][k]
                F[j][k] = F[j-1][k-A[i]] + A[i]
                path[i][j][k] = 1
                
return F[N][sum/2], path[][][]

改进后，不保存路径的空间复杂度为O(n*sum)，时间复杂度不变。

下面是根据记录好的path[][][]回溯可行路径的伪码：

F[][] = 0
path[][][] = 0

for i = 1 to 2*N
    nLimit = min(i, N)
    for j = nLimit to 1
        for k = 1 to sum/2
            if k > A[i] && F[j-1][k-A[i]] + A[i] > F[j][k]
                F[j][k] = F[j-1][k-A[i]] + A[i]
                path[i][j][k] = 1
                
return F[N][sum/2], path[][][]

 

最后是我对算法复杂度为O(n*sum)的C++实现:

#include <iostream>

using namespace std;

int Min(int a, int b)
{
    if(a > b)
        return b;
    else
        return a;
}

int Split_Array(int *array, int nLength)
{
    int sum = 0;
    for(int i = 0; i < nLength; i++)
        sum += array[i];
    cout<<"sum: "<<sum<<endl;
    
    int F[nLength/2+1][sum/2+1];
    int path[nLength+1][nLength/2+1][sum/2+1];
    for(int i = 0; i <= nLength/2; i++)
        for(int j = 0; j <= sum/2; j++)
            F[i][j] = 0;
    for(int i = 0; i <= nLength; i++)
        for(int j = 0; j <= nLength/2; j++)
            for(int k = 0; k <= sum/2; k++)
                path[i][j][k] = 0;
    
    for(int i = 1; i <= nLength; i++)
    {
        int nLimit = Min(nLength/2, i);
        for(int j = nLimit; j > 0; j--)
        {
            for(int k = array[i]; k <= sum/2; k++)
            {
                if(F[j][k] < F[j-1][k-array[i]] + array[i])
                {
                    F[j][k] = F[j-1][k-array[i]] + array[i];
                    path[i][j][k] = 1;
                }
            }
        }
    }
    int result = F[nLength/2][sum/2];

    int i = nLength;
    int j = nLength/2;
    int k = sum/2;
    while(i > 0 && j > 0 && k >0)
    {
        if(path[i][j][k] == 1)
        {
            cout<<array[i]<<" ";
            k -= array[i];
            j--;
        }
        i--;
    }
    cout<<endl;
    return result;
}

int main()
{
    int array[10] = {1,5,7,8,9,6,3,11,20,17};
    cout<<Split_Array(array, 10)<<endl;
    return 0;
}