基于动态规划算法实现数组分割

起源： 

        在师兄网易的面试题中，一BOSS提出以下问题。

        对于一个非负整型数组，是否可以用=，+，-负号串起来。

 

问题分析：

      存在数组用=，+，-串起来。

      即是否能把数组成员分割成两部分切相等。

      即是否存在数组中n个成员相加等于数组成员综合的一半。

      

算法解析：

      

      数组： A[size]   数组和： Sum   

      先判断如果数组和Sum等于奇数，则数组不可以用=，+，-负号串起来。

      如果数组和为偶数，则如下：

      构建矩阵： M[size+1][Sum+1]

      M[i][k]: 如果在数组的前i个元素中，存在组合使得其和为k,则M[i][k]值为1.

               否则M[i][k]的值为0.

      动态规划的条件：

            如果M[i][k]=1，则M[i+1][k]=1且M[i+1][k+A[i+1]]=1

     最终得到矩阵M[size+1][Sum+1],如果M[size][Sum/2]的值为一，则数组可以分割成相等的两部分。

代码实现：

#include "stdafx.h"
#include "stdlib.h"
#include <stack>
using namespace std;

bool isSubsetSplit(int A[], int len, int sum, stack<int> &st)
{

    int **X = (int **)malloc((len + 1)*sizeof(int *));

    for (int idx = 0; idx <= len; idx++)
    {
        X[idx] = (int *)malloc((sum + 1)*sizeof(int));
        for (int m = 0; m <= sum; m++)
        {
            X[idx][m] = 0;
        }
    }


    X[0][0] = 1;
    for (int i = 1; i <= sum; i++)
    {
        X[0][i] = 0; //??0?0?????????? 1.2.3...sum??????0;
    }

    for (int j = 1; j <= len; j++)
    {
        X[j][0] = 1; //???j???j???????????0?????1 ???j???j??????????????0
    }

    for (int i = 1; i <= len; i++) //loop?????????????
    {
        for (int j = 1; j <= sum; j++) //loop?1?sum
        {
            if (X[i - 1][j])
                X[i][j] = 1;
            for (int k = 1; k < i; k++)
            {
                if (X[k][j])
                {
                    X[i][j + A[i]] = 1;
                }
            }

        }
        X[i][A[i]] = 1;
    }



    bool found = false;
    int curSum = sum / 2;
    if (X[len][curSum] == 1)
    {
        for (int i = len - 1; i >= 0; i--)
        {
            if (X[i][curSum] != 1)
            {
                st.push(A[i + 1]);
                curSum -= A[i + 1];
            }
        }

        found = true;
    }
    for (int j = 0; j <= len; j++)
    {
        for (int i = 0; i <= sum; i++){
            printf("%d",X[j][i]);
        }
        printf("
");
    }

    for (int idx = 0; idx <= len; idx++)
    {
        free(X[idx]);
    }
    free(X);

    if (found)
        return true;

    return false;
}


int _tmain(int argc, _TCHAR* argv[])
{
    int Array[] = { 0, 1, 7, 4, 6, 3, 9, 2 };

    stack<int> st;

    bool bSplit = isSubsetSplit(Array, 7, 32, st);
    printf("%d",bSplit);
    char m =getchar();
    

    return 0;
}

 

总结，如果数组非正可负，是否可以如上实现？

其实也是可以的，只需把所有的负数去掉负号，然后从上即可。

具体为什么，留给大家，相信可以理解的。