题目：分割等和子集
-
给你一个 只包含正整数 的 非空 数组
nums。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。 -
初步想法排序后双指针，发现不行
-
class Solution { public: bool canPartition(vector<int>& nums) { if(nums.size()<2){ return false; } sort(nums.begin(),nums.end()); int left=0,right=nums.size()-1; int left_sum=nums[left],right_sum=nums[right]; while(left<right-1){ if(left_sum>right_sum){ right--; right_sum += nums[right]; }else{ left++; left_sum += nums[left]; } } cout<<left_sum<<" "<<right_sum<<endl; return left_sum==right_sum; } };//nums = [2,2,1,1]
-
-
只要找到集合里能够出现 sum / 2 的子集总和，就算是可以分割成两个相同元素和子集了。可以用回溯暴力搜索出所有答案的，但最后超时了，也不想再优化了，放弃回溯，直接上01背包吧。
- 背包问题，有N件物品和一个最多能背重量为W 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。背包问题有多种背包方式，常见的有：01背包、完全背包、多重背包、分组背包和混合背包等等。
-
确定dp数组以及下标的含义:dp[j] 表示： 容量为j的背包，所背的物品价值最大可以为dp[j]。
-
确定递推公式:01背包的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);相当于背包里放入数值，那么物品i的重量是nums[i]，其价值也是nums[i]。所以递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
-
dp数组如何初始化：首先dp[0]一定是0。
-
class Solution { public: bool canPartition(vector<int>& nums) { // int sum=0; // vector<int> dp(10001,0); // for(auto i:nums){ // sum+=i; // } // if(sum % 2 == 1){ // return false; // } // int half_sum = sum/2; // for(int i=0;i<nums.size();i++){ // for(int j=half_sum;j>=nums[i];j--){ // dp[j]=max(dp[j],dp[j-nums[i]]+nums[i]); // } // } // if(dp[half_sum]==half_sum){ // return true; // } // return false; }; -
不太好理解，但是可以用二维的数组，横坐标为sum/2的试探，纵坐标为元素的探索
-
class Solution { public: bool canPartition(vector<int>& nums) { if(nums.size()<2){ return false; } int sum=0; for(int i:nums){ sum+=i; } if(sum%2==1){ return false; } int target = sum/2; vector<vector<bool>> dp(nums.size(),vector<bool>(target+1,false)); if(nums[0]<=target){ dp[0][nums[0]] = true; } for(int i=1;i<nums.size();i++){ for(int j=0;j<dp[0].size();j++){ dp[i][j] = dp[i-1][j]; if(nums[i]==j){ dp[i][j]=true; continue; } if(nums[i]<j){ dp[i][j] = dp[i-1][j] || dp[i-1][j-nums[i]]; } } if(dp[i][target]==true){ return true; } } return false; } };
-
题目：最后一块石头的重量 II
-
有一堆石头，用整数数组
stones表示。其中stones[i]表示第i块石头的重量。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为x和y，且x <= y。那么粉碎的可能结果如下：如果 x == y，那么两块石头都会被完全粉碎；如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回0。 -
本题物品的重量为stones[i]，物品的价值也为stones[i]。对应着01背包里的物品重量weight[i]和 物品价值value[i]。
-
确定dp数组以及下标的含义：dp[j]表示容量（这里说容量更形象，其实就是重量）为j的背包，最多可以背最大重量为dp[j]。
-
确定递推公式：01背包的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);本题则是：dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
-
dp数组如何初始化：因为重量都不会是负数，所以dp[j]都初始化为0就可以了，这样在递归公式dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);中dp[j]才不会初始值所覆盖。
-
确定遍历顺序：如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！
-
-
那么分成两堆石头，一堆石头的总重量是dp[target]，另一堆就是sum - dp[target]。在计算target的时候，target = sum / 2 因为是向下取整，所以sum - dp[target] 一定是大于等于dp[target]的。那么相撞之后剩下的最小石头重量就是 (sum - dp[target]) - dp[target]。
-
-
class Solution { public: int lastStoneWeightII(vector<int>& stones) { int sum=0; for(int i:stones){ sum += i; } int target = sum / 2; int dp[1501] = { 0}; for(int i=0;i<stones.size();i++){ for(int j=target;j>=stones[i];j--){ dp[j]=max(dp[j],dp[j-stones[i]]+stones[i]); } } return sum-dp[target]-dp[target]; } }; -
时间复杂度：O(m × n) , m是石头总重量（准确的说是总重量的一半），n为石头块数；空间复杂度：O(m)
-
首先对于背包的所有问题中，01背包是最最基础的，其他背包也是在01背包的基础上稍作变化。
-
确定dp数组以及下标的含义：dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。
-
确定递推公式：dp[i][j] = max(dp[i - 1] [j], dp[i - 1] [j - weight[i]] + value[i]);
-
dp数组如何初始化
-
确定遍历顺序：01背包二维dp数组在遍历顺序上，外层遍历物品 ，内层遍历背包容量 和 外层遍历背包容量 ，内层遍历物品 都是可以的！
-
举例：背包最大重量为4。物品为：【物品0；1；15】【物品1；3；20】【物品2；4；30】对应的dp数组的数值，如图：
题目：目标和
-
给你一个非负整数数组
nums和一个整数target。向数组中的每个整数前添加'+'或'-'，然后串联起所有整数，可以构造一个 表达式 ：例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1” 。返回可以通过上述方法构造的、运算结果等于target的不同 表达式 的数目。 -
假设加法的总和为x，那么减法对应的总和就是sum - x。所以我们要求的是 x - (sum - x) = target；x = (target + sum) / 2；此时问题就转化为，装满容量为x的背包，有几种方法。这里的x，也就是我们后面要求的背包容量。
-
确定dp数组以及下标的含义：dp[j] 表示：填满j（包括j）这么大容积的包，有dp[j]种方法；其实也可以使用二维dp数组来求解本题，dp[i] [j]：使用 下标为[0, i]的nums[i]能够凑满j（包括j）这么大容量的包，有dp[i] [j]种方法。
-
确定递推公式：只要搞到nums[i]，凑成dp[j]就有dp[j - nums[i]] 种方法。
-
dp数组如何初始化：在初始化的时候dp[0] 一定要初始化为1，因为dp[0]是在公式中一切递推结果的起源，如果dp[0]是0的话，递推结果将都是0。
-
class Solution { public: int findTargetSumWays(vector<int>& nums, int target) { int sum=0; for(int i:nums){ sum+=i; } if(abs(target)>sum){ return 0; } if((target+sum) & 1){ return 0; } int left=(target+sum)/2; vector<int> dp(left+1,0); dp[0]=1; for(int i=0;i<nums.size();i++){ for(int j=left;j>=nums[i];j--){ dp[j]+=dp[j-nums[i]]; } } return dp[left]; } }; -
时间复杂度：O(n × m)，n为正数个数，m为背包容量；空间复杂度：O(m)，m为背包容量
-
class Solution { public: int count=0; void track(vector<int> &nums,int target,int sum,int start){ if(start==nums.size()){ if(sum==target){ count++; } }else{ track(nums,target,sum+nums[start],start+1); track(nums,target,sum-nums[start],start+1); } } int findTargetSumWays(vector<int>& nums, int target) { track(nums,target,0,0); return count; } };//回溯 -
时间复杂度： O ( 2 n ) O(2^n) O(2n)，其中 n 是数组 nums \textit{nums} nums 的长度。回溯需要遍历所有不同的表达式，共有 2 n 2^n 2n 种不同的表达式，每种表达式计算结果需要 O(1) 的时间，因此总时间复杂度是 。空间复杂度：O(n)，其中 n 是数组 nums 的长度。空间复杂度主要取决于递归调用的栈空间，栈的深度不超过 n。
-
构建一个二维数组进行存放好理解一些：
- 记数组的元素和为 sum，添加 - 号的元素之和为 neg，则其余添加 + 的元素之和为 sum−neg，得到的表达式的结果为 (sum−neg)−neg=sum−2⋅neg=target；
- 由于数组 nums 中的元素都是非负整数，neg 也必须是非负整数，所以上式成立的前提是 sum−target 是非负偶数。若不符合该条件可直接返回 0。
- 若上式成立，问题转化成在数组 nums 中选取若干元素，使得这些元素之和等于 neg，计算选取元素的方案数。我们可以使用动态规划的方法求解。
- 定义二维数组 dp，其中 dp [ i ] [ j ] \textit{dp}[i][j] dp[i][j] 表示在数组 nums 的前 i 个数中选取元素，使得这些元素之和等于 j 的方案数。假设数组 nums 的长度为 n，则最终答案为 $ \textit{dp}[n][\textit{neg}]$。
-
class Solution { public: int findTargetSumWays(vector<int>& nums, int target) { int sum=0; for(int &num:nums){ sum+=num; } int diff=sum-target; if(diff<0 || diff%2!=0){ return 0; } int n=nums.size(),neg=diff/2; vector<vector<int>> dp(n+1,vector<int>(neg+1)); dp[0][0]=1; for(int i=1;i<=n;i++){ int temp=nums[i-1]; for(int j=0;j<=neg;j++){ dp[i][j]=dp[i-1][j]; if(j>=temp){ dp[i][j]+=dp[i-1][j-temp]; } } } return dp[n][neg]; } };
题目：一和零
-
给你一个二进制字符串数组
strs和两个整数m和n。请你找出并返回strs的最大子集的长度，该子集中 最多 有m个0和n个1。如果x的所有元素也是y的元素，集合x是集合y的 子集 。 -
**本题中strs 数组里的元素就是物品，每个物品都是一个！**确定dp数组（dp table）以及下标的含义：dp[i][j]：最多有i个0和j个1的strs的最大子集的大小为dp[i][j]。
-
确定递推公式：dp[i][j] 可以由前一个strs里的字符串推导出来，strs里的字符串有zeroNum个0，oneNum个1。dp[i][j] 就可以是 dp[i - zeroNum] [j - oneNum] + 1。然后我们在遍历的过程中，取dp[i][j]的最大值。所以递推公式：dp[i][j] = max(dp[i][j], dp[i - zeroNum] [j - oneNum] + 1);回想一下01背包的递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);会发现，字符串的zeroNum和oneNum相当于物品的重量（weight[i]），字符串本身的个数相当于物品的价值（value[i]）。
-
dp数组如何初始化为0
-
class Solution { public: int findMaxForm(vector<string>& strs, int m, int n) { vector<vector<int>> dp(m+1,vector<int>(n+1,0)); for(string str:strs){ int one_count=0,zero_count=0; for(char c:str){ if(c=='0'){ zero_count++; }else{ one_count++; } } for(int i=m;i>=zero_count;i--){ for(int j=n;j>=one_count;j--){ dp[i][j] = max(dp[i-zero_count][j-one_count]+1,dp[i][j]); } } } return dp[m][n]; } }; -
时间复杂度: O(kmn)，k 为strs的长度；空间复杂度: O(mn)。经典的背包问题只有一种容量不同，这道题有两种容量，即选取的字符串子集中的 0 和 1 的数量上限。
完全背包
- 有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品都有无限个（也就是可以放入背包多次），求解将哪些物品装入背包里物品价值总和最大。完全背包和01背包问题唯一不同的地方就是，每种物品有无限件。
题目：零钱兑换 II
-
给你一个整数数组
coins表示不同面额的硬币，另给一个整数amount表示总金额。请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回0。假设每一种面额的硬币有无限个。题目数据保证结果符合 32 位带符号整数。 -
但本题和纯完全背包不一样，**纯完全背包是凑成背包最大价值是多少，而本题是要求凑成总金额的物品组合个数！**注意题目描述中是凑成总金额的硬币组合数，组合不强调元素之间的顺序，排列强调元素之间的顺序。
-
确定dp数组以及下标的含义:dp[j]：凑成总金额j的货币组合数为dp[j]
-
确定递推公式:dp[j] 就是所有的dp[j - coins[i]]（考虑coins[i]的情况）相加。所以递推公式：dp[j] += dp[j - coins[i]];
-
所以递推公式：dp[j] += dp[j - coins[i]];首先dp[0]一定要为1，dp[0] = 1是 递归公式的基础。如果dp[0] = 0 的话，后面所有推导出来的值都是0了。dp[0]=1还说明了一种情况：如果正好选了coins[i]后，也就是j-coins[i] == 0的情况表示这个硬币刚好能选，此时dp[0]为1表示只选coins[i]存在这样的一种选法。
-
class Solution { public: int change(int amount, vector<int>& coins) { vector<int> dp(amount+1,0); dp[0]=1; for(int i=0;i<coins.size();i++){ for(int j=coins[i];j<=amount;j++){ dp[j]+=dp[j-coins[i]]; } } // for(auto i:dp){ // cout<<i<<endl; // } return dp[amount]; } }; -
时间复杂度: O(mn)，其中 m 是amount，n 是 coins 的长度；空间复杂度: O(m)
-
在求装满背包有几种方案的时候，认清遍历顺序是非常关键的。
- 如果求组合数就是外层for循环遍历物品，内层for遍历背包。
- 如果求排列数就是外层for遍历背包，内层for循环遍历物品。
题目：组合总和 Ⅳ
-
给你一个由 不同 整数组成的数组
nums，和一个目标整数target。请你从nums中找出并返回总和为target的元素组合的个数。题目数据保证答案符合 32 位整数范围。 -
本题题目描述说是求组合，但又说是可以元素相同顺序不同的组合算两个组合，**其实就是求排列！**组合不强调顺序，(1,5)和(5,1)是同一个组合。排列强调顺序，(1,5)和(5,1)是两个不同的排列。本质是本题求的是排列总和，而且仅仅是求排列总和的个数，并不是把所有的排列都列出来。把排列都列出来的话，只能使用回溯算法爆搜。
-
确定dp数组以及下标的含义：dp[i]: 凑成目标正整数为i的排列个数为dp[i]
-
确定递推公式：dp[i]（考虑nums[j]）可以由 dp[i - nums[j]]（不考虑nums[j]） 推导出来。
-
dp数组如何初始化：因为递推公式dp[i] += dp[i - nums[j]]的缘故，dp[0]要初始化为1，这样递归其他dp[i]的时候才会有数值基础。
-
确定遍历顺序：个数可以不限使用，说明这是一个完全背包。个数可以不限使用，说明这是一个完全背包。
- 如果求组合数就是外层for循环遍历物品，内层for遍历背包。
- 如果求排列数就是外层for遍历背包，内层for循环遍历物品。
-
用示例中的例子推导一下：
-
class Solution { public: int combinationSum4(vector<int>& nums, int target) { vector<int> dp(target+1,0); dp[0]=1; for(int i=0;i<target+1;i++){ for(int j=0;j<nums.size();j++){ if(i-nums[j]>=0 && dp[i] < INT_MAX-dp[i-nums[j]]){ // C++测试用例有两个数相加超过int的数据，所以需要在if里加上dp[i] < INT_MAX - dp[i - num]。 dp[i] += dp[i-nums[j]]; } } } return dp[target]; } };
