2021.9.6 力扣-分割等和子集

0-1背包应用的第一道题,也是开学的第一道题。这道题目说实话,如果不是已经提醒过是0-1背包的应用,我是很难往这方面上去想的,况且我最终还是没能想出来。

题目描述:

给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集,使得两个子集的元素和相等。

方法一:

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int n = nums.size();
        if (n == 1)     //只有一个元素,肯定不能分割
        {
            return false;
        }
        int sum = 0;
        int maxnum = INT_MIN;
        for (int i = 0; i < n; i++)
        {
            sum += nums[i];
            maxnum = max(maxnum, nums[i]);
        }
        if (sum % 2 != 0 || maxnum > sum / 2)   //如果数组中的元素和是奇数,则一定不能分割;如果存在某个元素大于元素和的一半,则一定不能分割
        {
            return false;
        }
        vector<vector<int>> f(n , vector<int>(sum / 2 + 1 , false));
        //f[i][j]表示在下标为0 - i的元素,是否存在某些元素的和等于j,若是则为true,否则为false

        f[0][nums[0]] = true; //初始化,下标为0的元素,其值等于nums[0]

        for (int i = 1; i < n; i++)
        {
            for (int j = 1; j <= sum / 2; j++)
            {
                if (j < nums[i])
                {
                    f[i][j] = f[i - 1][j];
                    //如果j<nums[i],那么是否存在某些元素(肯定没有nums[i])的和等于j,就相当于只考虑下标为0 - i-1的元素
                }
                else if (j == nums[i])
                {
                    f[i][j] = true; 
                    //特殊情况,当nums[i]就正好等于j时,f[i][j]也是true
                }
                else if (j > nums[i])
                {
                    f[i][j] = f[i - 1][j] || f[i - 1][j - nums[i]];
                    //前者表示不取nums[i],后者表示取nums[i]
                }
            }
        }
        return f[n - 1][sum / 2];
    }
};

参考了这两篇题解:https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247486632&idx=1&sn=4bb229e3f3f5774ac684c0127c88c984&chksm=f9a23ff9ced5b6effc0f579b60dd1e4910b362c6417f19cd2086e77472da525dfa8475afd4ab&cur_album_id=1485825793120387074&scene=189#rd,以及https://leetcode-cn.com/problems/partition-equal-subset-sum/solution/0-1-bei-bao-wen-ti-xiang-jie-zhen-dui-ben-ti-de-yo/

关于为何能够使用0-1背包:

 由于第一篇题解的解法不易理解,所以我采用的是第二篇题解的解法。

关于递推关系式:

设f[i][j]表示在下标为0 - i的元素,是否存在某些元素的和等于j,若是则为true,否则为false。那么对于nums[i],有不取和取两种情况:若取nums[i],则f[i][j] = f[i-1][j];若不取nums[i],则f[i][j] = f[i-1][j-nums[i]]。即有f[i][j] = f[i-1][j] || f[i-1][j-nums[i]]。

但是还得考虑 j 和 nums[i]的大小关系:①若j<nums[i],说明在考虑nums[i]的情况下不可能存在元素和等于j,所以f[i][j] = f[i-1][j];②若j==nums[i],说明单个元素正好等于j,也是true,这是一种特殊情况,需要单独考虑;③若j>nums[i],则即上述的f[i][j] = f[i-1][j] || f[i-1][j-nums[i]]。

所以有以下代码:

                if (j < nums[i])
                {
                    f[i][j] = f[i - 1][j];
                    //如果j<nums[i],那么是否存在某些元素(肯定没有nums[i])的和等于j,就相当于只考虑下标为0 - i-1的元素
                }
                else if (j == nums[i])
                {
                    f[i][j] = true; 
                    //特殊情况,当nums[i]就正好等于j时,f[i][j]也是true
                }
                else if (j > nums[i])
                {
                    f[i][j] = f[i - 1][j] || f[i - 1][j - nums[i]];
                    //前者表示不取nums[i],后者表示取nums[i]
                }

关于初始化:

首先将所有f中的元素都初始化为false,然后对于f[i][0]:由于不存在元素之和等于0,所以f[i][0]为false;对于f[0][nums[0]]:由于下标为0的元素的值为nums[0],所以f[0][nums[0]]为true。

方法一的空间优化:

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int n = nums.size();
        if (n == 1)     //只有一个元素,肯定不能分割
        {
            return false;
        }
        int sum = 0;
        int maxnum = INT_MIN;
        for (int i = 0; i < n; i++)
        {
            sum += nums[i];
            maxnum = max(maxnum, nums[i]);
        }
        if (sum % 2 != 0 || maxnum > sum / 2)   //如果数组中的元素和是奇数,则一定不能分割;如果存在某个元素大于元素和的一半,则一定不能分割
        {
            return false;
        }
        vector<int> f(sum / 2 + 1, false);
        //f[j]表示在下标为0 - i的元素,是否存在某些元素的和等于j,若是则为true,否则为false

        f[nums[0]] = true; //初始化,下标为0的元素,其值等于nums[0]

        for (int i = 1; i < n; i++)
        {
            for (int j = sum / 2; j >= nums[i]; j--)
            {
                if (j == nums[i])
                {
                    f[j] = true;
                    //特殊情况,当nums[i]就正好等于j时,f[i][j]也是true
                }
                else if (j > nums[i])
                {
                    f[j] = f[j] || f[j - nums[i]];
                    //前者表示不取nums[i],后者表示取nums[i]
                }
            }
        }
        return f[sum / 2];
    }
};

与01背包问题的优化一样,将二维改为一维,同样需要注意的是在遍历的时候,对于背包应该从大到小遍历,原因为:在使用二维vector时,遍历的时候f[i][j]的值依赖于[i-1]层的值,而且[i-1]层的值是不会变的;但是在使用一维vector时,若对背包从小到大遍历,那么f[j-nums[i]]的值可能已经被覆盖了,导致出现错误,所以应该改为从大到小遍历。

  • 3
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值