【leetcode】**416. 分割等和子集（0/1背包问题：dp[i][j]表示从下标[0,i]中挑选出几个元素组成和为j的可能性）

题目

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

注意:
每个数组中的元素不会超过 100
数组的大小不会超过 200

示例 1:
输入: [1, 5, 11, 5]
输出: true
解释: 数组可以分割成 [1, 5, 5] 和 [11].

示例 2:
输入: [1, 2, 3, 5]
输出: false
解释: 数组不能分割成两个元素和相等的子集.

思路

背包问题：二维状态数组dp[i][j]

0/1背包问题。动态规划。

• 状态方程定义dp[i][j]表示从下标为[0,i]中挑选出几个元素组成和为j的可能性，如果可以则为true,不可以则为false。
• 初始状态dp[0][0]=false，因为元素都是正整数。
• 状态转移方程d[i][j]，考虑当前nums[i]到底放还是不放，如果不放则dp[i][j]=dp[i-1][j]；如果放，则dp[i][j]=dp[i-1][j-nums[i]]。
• 最后我们要求的是dp[nums.length()-1][target], target表示数组元素和的平均值

时间复杂度O(Nmean)，空间复杂度O(Nmean)。N为元素个数，mean为元素和的平均值

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        /*
        0/1背包问题。动态规划。
        方程定义dp[i][j]表示从下标为[0,i]中挑选出几个数字组成元素和的j的可能性，如果可以则为true,不可以则为false。
        初始状态dp[0][0]=false，因为元素都是正整数。
        状态转移方程d[i][j]，考虑当前nums[i]到底放还是不放，如果不放则dp[i][j]=dp[i-1][j]；如果放，则dp[i][j]=dp[i-1][j-nums[i]]。
        最后我们要求的是dp[nums.length()-1][target],target表示数组元素和的平均值
        */
        int size = nums.size();
        if(size<=1){
            return false;
        }
        int sum=0, maxvalue=0;
        for(int i=0; i<size; i++){
            sum += nums[i];
            if( nums[i] > maxvalue )
                maxvalue = nums[i];
        }
        //剪枝：1、数组元素和为奇数；2、最大元素大于均值
        int mean = sum/2;
        if( sum%2 || maxvalue > sum/2 ){
            return false;
        }
        bool dp[size][mean+1]; //默认为true
        //初始化：dp[0][0]也默认为false
        for(int i=0; i<size; i++){
            for(int j=0; j<=mean;j++){
                dp[i][j] = false;
            }
        }
        for(int i=1; i<size; i++){
            for(int j=0; j<=mean;j++){
                //单个放就满足要求
                if( j == nums[i] ){
                    dp[i][j] = true;
                }else if( j > nums[i] ){//注意判断j-nums[i]
                    //nums[i]不放 or 放
                    dp[i][j] = dp[i-1][j] || dp[i-1][j-nums[i]];
                }else{
                    dp[i][j] = dp[i-1][j];
                }
                
            }
            //剪枝
            if( dp[i][mean] == true )
                return true;
        }
        return dp[size-1][mean];
    }
};

空间优化：降为一维状态数组，只跟上一行的状态有关

• 原状态方程定义dp[i][j]：从下标为[0,i]中挑选出几个元素组成和为j的可能性
• 状态转移是从左往右，从上往下后填表：dp[i][j] = dp[i-1][j] || dp[i-1][j-nums[i]];

在“填表格”的时候，当前行总是参考了它上面一行 “头顶上” 那个位置和“左上角”某个位置的值。

• 用dp[j]：从每一行挑选出几个元素组成和为j的可能性
• 状态转移：1、不放当前nums[i]，如果上一行就已经满足dp[j]==true，那么当前行的dp[j]也是true；2、放nums[i]，如果上一行的dp[j-nums[i]]为true，那加上当前数dp[j]也是true。综合来说，dp[j] = dp[j] || dp[j-nums[i]]。
• 在这里需要注意，如果我们是从小到大遍历target也就是均值，那么上一行的dp[j-nums[i]]会被当前行覆盖。所以我们应该从大往小去遍历target也就是均值，这样就能保证，绝对可以用到上一行的值。 我们是从右往左，从上往下填表。

时间复杂度O(N*mean)，空间复杂度O(mean)跟元素个数无关了。N为元素个数，mean为元素和的平均值。

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        /*
        0/1背包问题。动态规划。
        方程定义dp[i][j]表示从下标为[0,i]中挑选出几个数字组成元素和的j的可能性，如果可以则为true,不可以则为false。
        初始状态dp[0][0]=false，因为元素都是正整数。
        状态转移方程d[i][j]，考虑当前nums[i]到底放还是不放，如果不放则dp[i][j]=dp[i-1][j]；如果放，则dp[i][j]=dp[i-1][j-nums[i]]。
        最后我们要求的是dp[nums.length()-1][target],target表示数组元素和的平均值.

        * 空间改进，dp[j]表示每一行从下标为[0,i]中挑选出几个数字组成元素和的j的可能性。然后从上往下，但是从右往左填表，每次使用上一行的状态dp[j] = dp[j] || dp[j-nums[i]] 
        */
        int size = nums.size();
        if(size<=1){
            return false;
        }
        int sum=0, maxvalue=0;
        for(int i=0; i<size; i++){
            sum += nums[i];
            if( nums[i] > maxvalue )
                maxvalue = nums[i];
        }
        //剪枝：1、数组元素和为奇数；2、最大元素大于均值
        int mean = sum/2;
        if( sum%2 || maxvalue > sum/2 ){
            return false;
        }
        bool dp[mean+1]; //bool会默认为true
        //初始化：dp[0][0]也默认为false
        for(int j=0; j<=mean;j++){
            dp[j] = false;
        }
        for(int i=1; i<size; i++){ //从上往下
            for(int j=mean; j>=0;j--){ //注意：从右往左填表
                //单个放就满足要求
                if( j == nums[i] ){
                    dp[j] = true;
                }else if( j > nums[i] ){//注意判断j-nums[i]
                    //nums[i]不放 or 放
                    dp[j] = dp[j] || dp[j-nums[i]];
                }else{
                    //dp[j] = dp[j];
                    break; //剪枝：继续往左遍历的j都<nums[i],所以直接跳出即可
                }
            }
            //剪枝
            if( dp[mean] == true )
                return true;
        }
        return dp[mean];
    }
};