【LeetCode每日一题】——416.分割等和子集

一【题目类别】

• 动态规划

二【题目难度】

• 中等

三【题目编号】

• 416.分割等和子集

四【题目描述】

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

五【题目示例】

• 示例 1：
  输入：nums = [1,5,11,5]
  输出：true
  解释：数组可以分割成 [1, 5, 5] 和 [11] 。
• 示例 2：
  输入：nums = [1,2,3,5]
  输出：false
  解释：数组不能分割成两个元素和相等的子集。

六【题目提示】

• 1 <= nums.length <= 200
• 1 <= nums[i] <= 100

七【解题思路】

• 属于0-1背包问题，把数组中的元素看为物品，而根据题目分析要求我们找出一部分元素等于数组元素和的一半，也就是在这些物品中找出一部分物品可以填满数组元素和的一半大小的背包，那么建立二维数组，行数就是物品在nums中的索引，列就是0-数组元素和的一半大小，也就是背包容量大小，通过不断的将物品（数组中的元素）加入背包，通过判断选或者不选判断能否填满背包

八【时间频度】

• 时间复杂度：$O(N\ast C)$，N为元素个数，C为数组元素和的一半

九【代码实现】

1. Java语言版

package DynamicProgramming;

public class p416_PartitionEqualSubsetSum {

    public static void main(String[] args) {
        p416_PartitionEqualSubsetSum p416_partitionEqualSubsetSum = new p416_PartitionEqualSubsetSum();
        int[] nums = {1,5,11,5};
        boolean res = p416_partitionEqualSubsetSum.canPartition(nums);
        if(res){
            System.out.println("可以");
        }else{
            System.out.println("不可以");
        }
    }

    public boolean canPartition(int[] nums) {
        // 定义数组行数
        int len = nums.length;
        // 准备求和
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        // 只有sum不为奇数才可以继续
        if (sum % 2 != 0) {
            return false;
        }
        // dp[i][j] = x 表示，对于前 i 个物品，当前背包的容量为 j 时，若 x 为 true，则说明可以恰好将背包装满，若 x 为 false，则说明不能恰好将背包装满,当然，最后返回最后一个位置的元素
        boolean[][] dp = new boolean[len + 1][sum / 2 + 1];
        // 因为自己本身这个元素只能填满和自己相等的背包，所以置为true
        for (int i = 0; i <= len; i++) {
            dp[i][0] = true;
        }
        for (int i = 1; i <= len; i++) {
            for (int j = 0; j <= sum / 2; j++) {
                // 如果当前元素的大小小于背包的剩余容量，那么说明可以放入背包，延续上一个状态，并且判断剩余背包容量是否满足当前情况
                if (j >= nums[i - 1]) {
                    dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i - 1]];
                } else {
                    // 反之如果不可以放入，那么依然延续上一个状态
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        // 最后返回最后一个元素的状态
        return dp[len][sum / 2];
    }

}

2. C语言版

#include
#include

/*注：1为true，0为false*/
typedef int bool;

bool canPartition(int* nums, int numsSize) {
	int i, j, target;
	/*统计所有数字之和，这个值就是目标值*/
	int sum = 0;
	for (int i = 0; i < numsSize; i++) {
		sum += nums[i];
	}
	/*如果为奇数返回false*/
	if (sum % 2 != 0) {
		return 0;
	}
	/*目标值*/
	target = sum / 2;
	/*为dp申请内存，都初始化为false，然后第一列为true*/
	bool **dp = (bool **)malloc(sizeof(bool *) * (numsSize + 1));
	for (int i = 0; i < numsSize + 1; i++) {
		dp[i] = (bool *)malloc(sizeof(bool) * (target + 1));
		memset(dp[i], 0, sizeof(bool) * (target + 1));
		dp[i][0] = 1;
	}
	/*从dp[1][1]开始遍历数组，如果dp[i-1][j]为true的话，那么dp[i][j]肯定为true，*/
	/*这说明已经有组合能够达到局部目标值了，再增加数组也不会改变结果，dp[i-1][j-nums[j-1]]*/
	for (int i = 1; i < numsSize + 1; i++) {
		for (int j = 1; j < target + 1; j++) {
			if (dp[i - 1][j] == 1 || (j - nums[i - 1] >= 0 && dp[i - 1][j - nums[i - 1]] == 1)) {
				dp[i][j] = 1;
			}
		}
	}
	/*最后最后一行最后一列的值*/
	return dp[numsSize][target];
}

int main(void) {
	/*主函数省略*/
}

十【提交结果】

1. Java语言版
   

2. C语言版