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

注意:

每个数组中的元素不会超过 100
数组的大小不会超过 200
示例 1:

输入: [1, 5, 11, 5]

输出: true

解释: 数组可以分割成 [1, 5, 5] 和 [11].

示例 2:

输入: [1, 2, 3, 5]

输出: false

解释: 数组不能分割成两个元素和相等的子集.

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/partition-equal-subset-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

典型的背包问题，在n个物品中选出一定物品，填满sum/2的背包

F(n,C) 考虑将n个物品填满容量为C的背包

F(i,C)=F(i-1,c)||F(i,c-w(i))

时间复杂度：O(nsum/2)=O(nsum)

递归解法

 //记忆搜索法
    private int[][] mem;

    /**
     *
     */
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }

        //如果所有的总和不能除以2 说明没有满足条件的
        if (sum % 2 != 0) {
            return false;
        }

        mem = new int[nums.length][sum / 2 + 1];

        for (int i = 0; i < mem.length; i++) {
            Arrays.fill(mem[i], -1);
        }
        //背包问题解法  F(i,C)=F(i-1,C)|| F(i,C-w(i));
        //包含它 或者不包含
        return recursionPartition(nums, nums.length - 1, sum / 2);

    }


    private boolean recursionPartition(int[] nums, int index, int sum) {

        if (sum == 0) {
            return true;
        }

        if (index < 0 || sum < 0) {
            return false;
        }

        if (mem[index][sum] != -1) {
            return mem[index][sum] == 1;
        }


        mem[index][sum] = recursionPartition(nums, index - 1, sum) ||
                recursionPartition(nums, index - 1, sum - nums[index]) ? 1 : 0;

        return mem[index][sum] == 1;
    }

动态规划解法

/// Dynamic Programming
/// Time Complexity: O(len(nums) * O(sum(nums)))
/// Space Complexity: O(len(nums) * O(sum(nums)))

 public boolean canPartition(int[] nums) {

        int sum = 0;
        for(int i = 0 ; i < nums.length ; i ++){
            if(nums[i] <= 0)
                throw new IllegalArgumentException("numbers in nums must be greater than zero.");
            sum += nums[i];
        }

        if(sum % 2 == 1)
            return false;

        int n = nums.length;
        int C = sum / 2;

        boolean[] memo = new boolean[C + 1];
        for(int i = 0 ; i <= C ; i ++)
            memo[i] = (nums[0] == i);

        for(int i = 1 ; i < n ; i ++)
            for(int j = C; j >= nums[i] ; j --)
                memo[j] = memo[j] || memo[j - nums[i]];

        return memo[C];
    }