leetcode416——分割等和子集——java实现

题目要求：

分析：
这是一个0，1揹包问题。（更多揹包问题，请看这里：传送门：经典算法总结——揹包问题（java实现）【已完结】）
这里要注意，当sum为奇数的时候，就直接不用做了，因为sum/2是一个小数。

具体代码如下：

class Solution {
    public boolean canPartition(int[] nums) {
        int len = nums.length;
        int sum = 0;
        for(int i = 0; i < len; i ++) {
            sum += nums[i];
        }
        boolean[][] dp = new boolean[len + 1][sum / 2 + 1];
        
        if(sum % 2 != 0) {
            return false;
        }
        
        //这里也可以将初始条件设置为dp[0][0] = 0，接下来等于多少计算机就会自己推算了
        for (int i = 1; i < sum / 2 + 1; i++) {
            if (nums[0] == i) {
                dp[0][i] = true;
            }
        }
        
        for(int i = 1; i < len; i ++) {
            for(int j = 0; j < sum / 2 + 1; j ++) {
                if(nums[i] > j) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = dp[i - 1][j - nums[i]] || dp[i - 1][j];
                }
            }
        }
        return dp[len - 1][sum / 2];
    }
}

上面的方法是看别人的，我觉得其实按照我的智商，是想不到直接new一个boolean的dp是怎么去做的，所以我又写了一个按照自己这种菜鸡程度才能想到的代码，具体如下：

class Solution {
    public boolean canPartition(int[] nums) {
        int len = nums.length;
        int sum = 0;
        for(int i = 0; i < len; i ++) {
            sum += nums[i];
        }
        if(sum % 2 != 0)
            return false;
        
        int target = sum / 2;
        int[][] dp = new int[len + 1][target + 1];
        
        for(int i = 0; i <= target; i ++) {
            dp[0][i] = 0;
        }
        
        for(int i = 1; i <= len; i ++) {
            for(int j = 0; j <= target; j ++) {
                if(j < nums[i - 1]) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - nums[i-1]] + nums[i - 1]);
                }
            }
        }
        if(dp[len][target] == target) {
            return true;
        }
        return false;
    }
}
性能是不太好，但是胜在自己能想到。