算法：正数数组分割为个数跟累加和接近的两个集合

最新推荐文章于 2026-06-15 09:13:05 发布

转载最新推荐文章于 2026-06-15 09:13:05 发布 · 329 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

原文链接：https://shimo.im/docs/68cd6h3TwygPwx8W/read

标签

#算法 #动态规划 #c++

算法与数据结构专栏收录该内容

1135 篇文章

订阅专栏

这篇博客介绍了一个使用动态规划求解数组分组的问题，目标是将数组中的正数分为两个集合，使得两集合元素个数尽可能接近且总和差最小。博主首先给出了暴力递归的解决方案，然后优化为动态规划实现，最后通过随机生成数组进行测试验证了两种方法的一致性。

题目描述

给定一个正数数组arr，请把arr中所有的数分成两个集合如果arr长度为偶数，两个集合包含数的个数要一样多

如果arr长度为奇数，两个集合包含数的个数必须只差一个

请尽量让两个集合的累加和接近

最接近的情况下，较小集合的累加和（较大集合的累加和一定是所有数累加和减去较小集合的累加和）

题目解析

暴力

class Solution {
    // arr[i....]自由选择，挑选的个数一定要是picks个，累加和<=rest, 离rest最近的返回
    int process(vector<int>& nums, int idx, int pick, int rest){
        if(idx == nums.size()){  // 没数了！！
            return pick == 0 ? 0 : -1;
        }else{      //还有数
            int p1 = process(nums, idx + 1, pick, rest);  //不要这个数
            int p2 = -1;
            if(rest >= nums[idx]){  //可以要这个数
                int next =  process(nums, idx + 1, pick - 1, rest - nums[idx]);
                if(next != -1){
                    p2 = nums[idx] + next;
                }
            }
            return std::max(p1, p2);
        }
    }
public:
    int SplitSumClosedSizeHalf(vector<int>& nums) {
        int N = nums.size();
        if(N < 2){
            return 0;
        }
        
        int sum = std::accumulate(nums.begin(), nums.end(), 0) / 2;
        if((N / 2)== 0){
            return process(nums, 0, N / 2, sum);
        }else{
            int p1 = process(nums, 0, N/2, sum);
            int p2 = process(nums, 0, (N + 1)/2, sum);
            return std::max(p1, p2);
        }
    }
};

暴力递归改动态规划

    int SplitSumClosedSizeHalf2(vector<int>& nums) {
        int N = nums.size(), M = (N + 1)/2;
        if(N < 2){
            return 0;
        }

        int sum = std::accumulate(nums.begin(), nums.end(), 0) / 2;
        std::vector<std::vector<std::vector<int>>> dp(N + 1,
                                                      std::vector<std::vector<int>>(M + 1,
                                                                                    std::vector<int>(sum + 1, -1)));

        for (int rest = 0; rest <= sum; ++rest)  {
            dp[N][0][rest] = 0;
        }

        for (int idx = N - 1; idx >= 0; --idx) {
            for (int pick = 0; pick <= M; ++pick) {
                for (int rest = 0; rest <= sum; ++rest) {
                    int p1 = dp[idx + 1][pick][rest];  //不要这个数
                    int p2 = -1;
                    if(((pick - 1) >= 0) &&(rest >= nums[idx])){  //可以要这个数
                        int next =  dp[idx + 1][pick - 1][rest - nums[idx]];
                        if(next != -1){
                            p2 = nums[idx] + next;
                        }
                    }
                    dp[idx][pick][rest] =  std::max(p1, p2);
                }
            }
        }

        if((N / 2)== 0){
            return dp[0][N / 2][sum];
        }else{
            return std::max(dp[0][N / 2][sum], dp[0][(N + 1)/2][sum]);
        }
    }

对数器

std::default_random_engine e;
std::vector<std::vector<int>>  generateArray(int maxLen, int minValue, int maxValue){
    std::uniform_int_distribution<int> distS(1, maxLen);
    std::uniform_int_distribution<int> distV(minValue, maxValue);
    int size = distS(e);
    std::vector<std::vector<int>> result(size, std::vector<int>(2));
    for (int i = 0; i < size ; ++i) {
        int v1 = distV(e);
        int v2 = distV(e);
        if(v1 == v2){
            result[i][0] = v1;
            result[i][1] = v1 + 1;
        }else{
            result[i][0] = std::min(v1, v2);
            result[i][1] = std::max(v1, v2);
        }

    }
    return result;
}


int main()
{
    std::vector<int> v = { 1,2,3,5 };
    Solution a;
    int programSize = 12;
    int timeMax = 20;
    int timeTimes = 10;
    for (int i = 0; i < timeTimes; i++) {
        auto programs = generateArray(programSize, 0, timeMax);
        int ans1 = a.SplitSumClosedSizeHalf(v);
        int ans2 = a.SplitSumClosedSizeHalf2(v);
        if(ans1 != ans2){
            printf("error");
            return -1;
        };
    }
    printf("finish!");


}