Leetcode Hot 100 ——动态规划part01

前置知识

动态规划，英文：Dynamic Programming，简称DP，如果某一问题有很多重叠子问题，使用动态规划是最有效的。

所以动态规划中每一个状态一定是由上一个状态推导出来的，这一点就区分于贪心，贪心没有状态推导，而是从局部直接选最优的。

以背包问题为例，有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

动态规划中dp[j]是由dp[j-weight[i]]推导出来的，然后取max(dp[j], dp[j - weight[i]] + value[i])。

如果是贪心，每次拿物品选一个最大的或者最小的就完事了，和上一个状态没有关系。所以贪心解决不了动态规划的问题。

其实大家也不用死扣动规和贪心的理论区别，后面做做题目自然就知道了。大家知道动规是由前一个状态推导出来的，而贪心是局部直接选最优的，对于刷题来说就够用了。

动态规划的解题步骤

做动规题目的时候，很多同学会陷入一个误区，就是以为把状态转移公式背下来，照葫芦画瓢改改，就开始写代码，甚至把题目AC之后，都不太清楚dp[i]表示的是什么。

状态转移公式（递推公式）是很重要，但动规不仅仅只有递推公式。

对于动态规划问题，我将拆解为如下五步曲，这五步都搞清楚了，才能说把动态规划真的掌握了！

① 确定dp数组（dp table）以及下标的含义

② 确定递推公式

③ dp数组如何初始化

④ 确定遍历顺序

⑤ 举例推导dp数组

一些同学可能想为什么要先确定递推公式，然后在考虑初始化呢？

因为一些情况是递推公式决定了dp数组要如何初始化！

写动规题目，代码出问题很正常！

找问题的最好方式就是把dp数组打印出来，看看究竟是不是按照自己思路推导的！

70、爬楼梯

思路与解法

爬到第一层楼梯有一种方法，爬到二层楼梯有两种方法。

那么第一层楼梯再跨两步就到第三层 ，第二层楼梯再跨一步就到第三层。

所以到第三层楼梯的状态可以由到第二层楼梯和到第一层楼梯状态推导出来，那么就可以想到动态规划了。

可以将该问题分成多个子问题，爬第n阶楼梯的方法数量，等于2部分之和：

① 爬上 n−1 阶楼梯的方法数量。因为再爬1阶就能到第n阶

② 爬上 n−2 阶楼梯的方法数量，因为再爬2阶就能到第n阶

所以我们得到公式 dp[n]=dp[n−1]+dp[n−2]。

下面来分析分析一下动规五部曲：
1、确定dp数组以及下标的含义

dp[i]： 爬到第i层楼梯，有dp[i]种方法

2、确定递推公式

dp[i] = dp[i - 1] + dp[i - 2]

3、dp数组如何初始化

再回顾一下dp[i]的定义：爬到第i层楼梯，有dp[i]种方法。

那么i为0，dp[i]应该是多少呢？

需要注意的是：题目中说了n是一个正整数，题目根本就没说n有为0的情况。

所以本题其实就不应该讨论dp[0]的初始化！

我相信dp[1] = 1，dp[2] = 2，这个初始化大家应该都没有争议的。

所以我的原则是：不考虑dp[0]如何初始化，只初始化dp[1] = 1，dp[2] = 2，然后从i = 3开始递推，这样才符合dp[i]的定义。

4、确定遍历顺序

从递推公式dp[i] = dp[i - 1] + dp[i - 2];中可以看出，遍历顺序一定是从前向后遍历的。

5、举例推导dp数组

举例当n为5的时候，dp table（dp数组）应该是这样的：

此时大家应该发现了，这不就是斐波那契数列么！

唯一的区别是，没有讨论dp[0]应该是什么，因为dp[0]在本题没有意义！

核心代码：

class Solution {
public:
    int climbStairs(int n) {
        if(n<=1) return n; //因为下面直接对dp[2]操作了，防止空指针
        vector<int> dp(n+1);
        dp[1]=1;
        dp[2]=2;
        for(int i=3;i<n+1;i++){ //注意i是从3开始的
            dp[i]=dp[i-2]+dp[i-1];
        }
        return dp[n];
    }
};

【注】

1、创建的数组是dp(n+1)，因为想要 dp[i] 直接对应第 i 阶楼梯。

300. 最长递增子序列

动规五部曲

1、dp[i]的定义

dp[i]表示i之前包括i的以nums[i]结尾的最长递增子序列的长度

2、递推公式

如果 nums[i] > nums[i - 1]，那么以 i 为结尾的连续递增的子序列长度一定等于（以i - 1为结尾的连续递增的子序列长度 + 1）。即：dp[i] = dp[i - 1] + 1;

位置i的最长升序子序列等于（j从0到i-1各个位置的最长升序子序列 + 1 ）中的最大值。

所以：if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);

为什么？注意这里子序列不要求连续，因此当遍历所有 j < i 时，如果 nums[i] > nums[j]，我们就得到一个候选长度 dp[j] + 1，我们需要从所有候选值中选出最大的那个 。

还要兼顾初值，当其它都不满足，返回dp[i]初值，即1。

3、dp[i]的初始化

每一个i，对应的dp[i]（即最长递增子序列）起始大小至少都是1。

4、确定遍历顺序

dp[i]是有0到i-1各个位置的最长递增子序列推导而来，那么遍历i一定是从前向后遍历 。

j其实就是遍历0到i-1（从前面所有候选值里选），所以默认从前向后遍历。

遍历i的循环在外层，遍历j则在内层，代码如下：

for (int i = 1; i < nums.size(); i++) {
    for (int j = 0; j < i; j++) {
        if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
    }
    if (dp[i] > result) result = dp[i];  //取长的子序列
}

核心代码：

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        if(nums.size()==1) return 1;
        vector<int> dp(nums.size(),1);
        int result = 0;
        for(int i=1;i<nums.size();i++){
            for(int j=0;j<i;j++){
                if(nums[i]>nums[j]){
                dp[i]=max(dp[i],dp[j]+1);
                }

                if(dp[i]>result) result = dp[i];
            }
        }
        return result;
    }
};

【注】

1、i初值为1，因为j<i，而j初值为0。

152. 乘积最大子数组

动态规划五部曲

1、 确定dp数组及含义

本题需要两个dp数组，同时维护以当前元素结尾的乘积最大值和最小值，因为负数可能导致最大值变最小值，最小值变最大值。

dp_max[i]：表示以第 i 个元素结尾的乘积最大的连续子数组的乘积。

dp_min[i]： 表示以第 i 个元素结尾的乘积最小的连续子数组的乘积。

2、确定递推公式

对于每个位置 i，我们需要考虑当前元素单独成段，或与前面的子数组合并：

① 单独：nums[i]

② 乘以前一个最大值：dp_max[i-1] * nums[i]

③ 乘以前一个最小值：dp_min[i-1] * nums[i]（负负得正的情况）

取三者的最大值作为新的最大值，三者最小值作为新的最小值：

dp_max[i]=max({nums[i],dp_max[i-1]*nums[i],dp_min[i-1]*nums[i]});
dp_min[i]=min({nums[i],dp_max[i-1]*nums[i],dp_min[i-1]*nums[i]});

3、dp数组初始化

dp_max[0] = nums[0]

dp_min[0] = nums[0]

全局结果 res 初始化为 nums[0]，用于记录所有 dp_max[i] 的最大值。

4、确定遍历顺序

从前至后

5、举例推导dp数组

核心代码：

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int n = nums.size();
        if(n==0) return 0;
        vector<int> dp_min(n),dp_max(n);
        dp_max[0]=nums[0];
        dp_min[0]=nums[0];
        int res=nums[0];
        for(int i=1;i<n;i++){
            dp_max[i]=max({nums[i],dp_max[i-1]*nums[i],dp_min[i-1]*nums[i]});
            dp_min[i]=min({nums[i],dp_max[i-1]*nums[i],dp_min[i-1]*nums[i]});
            res = max(dp_max[i],res);           
        }
        return res;
    }
};

【注】

1、C++ 标准库中的 max 和 min 函数通常只接受两个参数进行比较，要使用 C++11 的初始化列表！

32. 最长有效括号

class Solution {
public:
    int longestValidParentheses(string s) {
        stack<int> st;
        st.push(-1); // 初始边界
        int maxLen = 0;
        for (int i = 0; i < s.size(); ++i) {
            if (s[i] == '(') {
                st.push(i);
            } else { // s[i] == ')'
                st.pop();//注意要先pop，因为要匹配最近的(
                if (st.empty()) {
                    // 没有左括号与之匹配，当前右括号成为新的边界
                    st.push(i);
                } else {
                    // 计算长度
                    maxLen = max(maxLen, i - st.top());
                }
            }
        }
        return maxLen;
    }
};

【注】

1、st.push(-1);

如果没有 -1，一开始栈就是空的，第一次遇到右括号时弹出会出错（空栈不能 pop）。所以-1保证了初始栈非空，所有操作都基于栈非空的前提 。

-1 是一个哨兵值，使得：

① 任何有效子串的长度都可以用 当前索引 - 栈顶索引计算。

② 无需在代码中单独处理开头的情况。

2、maxLen = max(maxLen, i - st.top());
栈顶元素始终是当前最后一个未匹配的括号索引（或初始的 -1） 。当遇到右括号并成功匹配后，弹出对应的左括号，此时新的栈顶就是更早的一个未匹配位置，而从那个位置的下一个字符到当前右括号之间的所有字符恰好构成一个有效的括号子串。因此，子串长度就是当前索引 i 减去新的栈顶索引 st.top()。
长度i - st.top()不用 +1 ，因为st.top() 存储的是最后一个无法匹配的位置（即边界）

198. 打家劫舍

思路与解法

大家如果刚接触这样的题目，会有点困惑，当前的状态我是偷还是不偷呢？

仔细一想，当前房屋偷与不偷取决于前一个房屋和前两个房屋是否被偷了。

所以这里就更感觉到，当前状态和前面状态会有一种依赖关系，那么这种依赖关系就是动规的递推公式。

动规五部曲分析如下：

1、确定dp数组（dp table）以及下标的含义

dp[i]：考虑下标i （包括i） 以内的房屋，最多可以偷窃的总金额为dp[i]

2、确定递推公式

决定dp[i]的因素就是第i房间偷还是不偷。

① 如果偷第i房间，那么dp[i] = dp[i - 2] + nums[i] ，即第i-1房一定是不考虑的，找出下标i-2（包括i-2）以内的房屋，最多可以偷窃的金额为dp[i-2] 加上第i房间偷到的钱。

② 如果不偷第i房间，那么dp[i] = dp[i - 1]，即考虑i-1房（注意这里是考虑，并不是一定要偷i-1房，这是很多同学容易混淆的点）

然后dp[i]取最大值，即dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);

3、dp数组如何初始化

从递推公式dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);可以看出，递推公式的基础就是dp[0]和dp[1] 。

从dp[i]的定义上来讲，dp[0] 一定是 nums[0]，dp[1]就是nums[0]和nums[1]的最大值即：dp[1] = max(nums[0], nums[1]);

4、确定遍历顺序

dp[i]是根据dp[i - 2] 和 dp[i - 1] 推导出来的，那么一定是从前到后遍历！

5、举例推导dp数组

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.size()==0) return 0;
        if(nums.size()==1) return nums[0];        
        vector<int> dp(nums.size());
        dp[0]=nums[0];
        dp[1]=max(nums[0],nums[1]);
        for(int i=2;i<nums.size();i++){
            dp[i]=max(dp[i-1],dp[i-2]+nums[i]);
        }
        return dp[nums.size()-1];
        
    }
};

【注】

1、if(nums.size()==0) return 0; if(nums.size()==1) return nums[0];

动态规划根据递推公式，如果从第3个开始用递推，则要先处理输入为0和为1的情况！

2、最后return dp[nums.size()-1];就是最大的！！

118. 杨辉三角

动规五部曲：
① 确定dp数组（dp table）以及下标的含义

二维数组dp[i][j] 表示杨辉三角中第 i 行第 j 列的元素值。

② 确定递推

③ dp数组如何初始化

基础行 dp[0][0] = 1（第一行只有一个1）。

后续行不需要预先初始化，因为递推过程中会逐一计算。

④ 确定遍历顺序
逐行计算
外层循环： 按行递增，从 i = 1 到 numRows-1（第一行已初始化）。
内层循环： 对当前行 i，遍历列 j 从 0 到 i：

若 j == 0 或 j == i，直接赋值1（先全部初始化为1即可）；

否则按递推公式计算，这需要用到上一行 i-1 的值，因此必须保证上一行已计算完毕。

⑤ 举例推导dp数组

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> dp(numRows);
        for(int i=0;i<numRows;i++){
            dp[i].resize(i+1,1);
            for(int j=1;j<i;j++){
                dp[i][j]=dp[i-1][j-1]+dp[i-1][j];
            }
        }
        return dp;
    }
};

【注】

1、初始条件dp[0][0] = 1 实际上是隐含在代码的初始化过程中的。

2、dp[i].resize(i+1,1); 第i行共i+1个元素，先都初始化为1。这样就无需对每一行的第一个和最后一个元素再单独赋1，只处理每行的第二个和倒数第二个元素即可。

ACM：

#include<bits/stdc++.h>
using namespace std;

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> dp(numRows);
        for(int i=0;i<numRows;i++){
            dp[i].resize(i+1,1);
            for(int j=1;j<i;j++){
                dp[i][j]=dp[i-1][j-1]+dp[i-1][j];
            }
        }
        return dp;
    }
};

int main(){
    int n;
    cin>>n;
    Solution sol;
    vector<vector<int>> res=sol.generate(n);
    for(int i=0;i<res.size();i++){
        for(int j=0;j<res[i].size();j++){
            if(j>0) cout<<" ";
            cout<<res[i][j];
        }
        cout<<endl;
    }
}

【注】

1、 for(int j=0;j<res[i].size();j++){

不是res[0]！！因为每行长度不一样的。

01背包理论基础

思路

正式开始讲解背包问题！

对于面试的话，其实掌握01背包和完全背包，就够用了，最多可以再来一个多重背包。

如果这几种背包，分不清，我这里画了一个图，如下：

01背包和完全背包就够用了。而完全背包又是也是01背包稍作变化而来，即：完全背包的物品数量是无限的。

所以背包问题的理论基础重中之重是01背包，一定要理解透！

leetcode上没有纯01背包的问题，都是01背包应用方面的题目，也就是需要转化为01背包问题。

所以我先通过纯01背包问题，把01背包原理讲清楚，后续再讲解leetcode题目的时候，重点就是讲解如何转化为01背包问题了。

01 背包

有n件物品和一个最多能背重量为w 的背包。第i件物品的重量是weight[i]，得到的价值是value[i]。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

这是标准的背包问题，以至于很多同学看了这个自然就会想到背包，甚至都不知道暴力的解法应该怎么解了。这样其实是没有从底向上去思考，而是习惯性想到了背包，那么暴力的解法应该是怎么样的呢？

每一件物品其实只有两个状态，取或者不取，所以可以使用回溯法搜索出所有的情况，那么时间复杂度就是O(2^n)，这里的n表示物品数量。所以暴力的解法是指数级别的时间复杂度，进而才需要动态规划的解法来进行优化！

在下面的讲解中，我举一个例子：

背包最大重量为4。

物品为：

问背包能背的物品最大价值是多少？

01背包二维dp数组

动规五部曲分析。

1、确定dp数组以及下标的含义

我们需要使用二维数组，为什么呢？

因为有两个维度需要分别表示：物品和背包容量

如图，二维数组为 dp[i][j]。

dp[i][j] 表示：在物品编号下标为[0-i]的物品中进行任意选取，放入容量为 j 的背包中，能够获得的最大总价值。

我们来尝试把上面的 二维表格填写一下。

动态规划的思路是根据子问题的求解推导出整体的最优解。
我们先看把物品0放入背包的情况：

背包容量为0，放不下物品0，此时背包里的价值为0。

背包容量为1，可以放下物品0，此时背包里的价值为15.

背包容量为2，依然可以放下物品0 （注意 01背包里物品只有一个） ，此时背包里的价值为15。

依此类推。

再看把物品1放入背包：

背包容量为 0，放不下物品0或者物品1，此时背包里的价值为0。

背包容量为 1，只能放下物品0，背包里的价值为15。

背包容量为 2，只能放下物品0，背包里的价值为15。

背包容量为 3，上一行同一状态，背包只能放物品0，这次也可以选择物品1了，背包可以放物品1或者 物品0 ，物品1价值更大，背包里的价值为20。

背包容量为 4，上一行同一状态，背包只能放物品0，这次也可以选择物品1了，背包可以放下物品0和 物品1，背包价值为35。

以上举例比较容易看懂，我主要是通过这个例子，来帮助大家明确dp数组的含义。

上图中，我们看 dp[1][4] 表示什么意思呢？

任取物品0与物品1放进容量为4的背包里，最大价值是 dp[1][4]。
要时刻记着这个dp数组的含义，下面的一些步骤都围绕这dp数组的含义进行的。

2、 确定递推公式

对于递推公式，首先我们要明确有哪些方向可以推导出dp[i][j]。

这里以dp[1][4]的状态来举例，求取dp[1][4]有两种情况：

① 放物品1

② 还是不放物品1

① 如果不放物品1 ，那么背包的价值应该是dp[0][4]，即容量为4的背包，只放物品0的情况。
② 如果放物品1 ， 那么背包要先留出物品1的容量 ，目前容量是4，物品1 的容量（就是物品1的重量）为3，此时背包剩下容量为1。

容量为1，只考虑放物品0的最大价值是 dp[0][1]，这个值我们之前就计算过。

所以放物品1的情况 = dp[0][1] + 物品1 的价值

两种情况，分别是放物品1和不放物品1，我们要取最大值 （毕竟求的是最大价值）

dp[1][4] = max(dp[0][4], dp[0][1] + 物品1 的价值)

以上过程，抽象化如下：
不放物品i ：背包容量为j，里面不放物品i的最大价值是dp[i - 1][j]。
放物品i ：背包空出物品i的容量后，背包容量为j - weight[i]，dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]且不放物品i的最大价值，那么dp[i - 1][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最大价值
递归公式 ： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

3、dp数组如何初始化

关于初始化，一定要和dp数组的定义吻合，否则到递推公式的时候就会越来越乱。

① 首先从dp[i][j]的定义出发，如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0。

② 由状态转移方程可以看出i 是由 i-1 推导出来，那么i为0的时候就一定要初始化。

dp[0][j]，即：i为0，存放编号0的物品的时候，各个容量的背包所能存放的最大价值。

很明显当 j < weight[0]的时候，dp[0][j] 应该是0，因为背包容量比编号0的物品重量还小。

当j >=weight[0]时，dp[0][j] 应该是value[0]，因为背包容量放足够放编号0物品。

代码初始化如下：

//当然这一步，如果把dp数组预先初始化为0了，这一步就可以省略，但很多同学应该没有想清楚这一点
for (int i = 1; i < weight.size(); i++) {
    dp[i][0] = 0;
}
// 正序遍历
for (int j = weight[0]; j <= bagweight; j++) {
    dp[0][j] = value[0];
}

一开始就统一把dp数组初始为0，更方便一些。

最后初始化代码如下：

// 初始化 dp
vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 0));
for (int j = weight[0]; j <= bagweight; j++) {
    dp[0][j] = value[0];
}

【注】

① 因为背包重量是从0开始，所以是bagweight + 1。

4、确定遍历顺序

在下图中，可以看出，有两个遍历的维度：物品与背包重量。

那么问题来了，先遍历物品还是先遍历背包重量呢？

其实都可以！！ 但是先遍历物品更好理解。

那么我先给出先遍历物品，然后遍历背包重量的代码。

// weight数组的大小 就是物品个数
for(int i = 1; i < weight.size(); i++) { // 遍历物品
    for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
        if (j < weight[i]) dp[i][j] = dp[i - 1][j];  //要先判断，否则j - weight[i]<0
        else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

    }
}

5、举例推导dp数组

做动态规划的题目，最好的过程就是自己在纸上举一个例子把对应的dp数组的数值推导一下，然后再动手写代码！

很多同学做dp题目，遇到各种问题，然后凭感觉东改改西改改，怎么改都不对，或者稀里糊涂就改过了。主要就是自己没有动手推导一下dp数组的演变过程，如果推导明白了，代码写出来就算有问题，只要把dp数组打印出来，对比一下和自己推导的有什么差异，很快就可以发现问题了。

01背包理论基础（滚动数组）

在使用二维数组的时候，递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);其实可以发现如果把dp[i - 1]那一层拷贝到dp[i]上，表达式完全可以是：
dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);

与其把dp[i - 1]这一层拷贝到dp[i]上，不如只用一个一维数组了，只用dp[j]（一维数组，也可以理解是一个滚动数组）。

dp[i][j]表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。一定要时刻记住这里i和j的含义，要不然很容易看懵了。

动规五部曲分析如下：
1、确定dp数组的定义

在一维dp数组中，dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。

2、一维dp数组的递推公式

二维dp数组的递推公式为：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

一维dp数组，其实就是在上面递推公式的基础上，去掉i这个维度就好。

递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

3、一维dp数组如何初始化

关于初始化，一定要和dp数组的定义吻合，否则到递推公式的时候就会越来越乱。

dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]，那么dp[0]就应该是0，因为背包容量为0所背的物品的最大价值就是0。

那么dp数组除了下标0的位置，初始为0，其他下标应该初始化多少呢？

看一下递归公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

假设物品价值都是大于0的，所以dp数组初始化的时候，都初始为0就可以了。

4、一维dp数组遍历顺序

for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

    }
}

【注】

1、内层循环要倒序！！保证每个物品只被使用一次（0-1 背包的特性）

5、举例推导dp数组

416. 分割等和子集

思路与解法

只要找到集合里能够出现 sum / 2 的子集总和，就算是可以分割成两个相同元素和的子集了。本题的本质是，能否把容量为 sum / 2的背包装满。元素只能使用一次，所以是01背包。

问题转化：

设数组所有元素的总和为 sum。如果 sum 是奇数，则不可能平分，直接返回 false。

如果 sum 是偶数，那么问题转化为：能否从数组中选择一些元素，使它们的和恰好等于 sum/2。这正是经典的 0-1 背包问题：每个元素相当于一个物品，其重量和价值均为元素值，背包容量为 target = sum/2，问能否恰好装满背包？（即最大价值就是sum / 2）

动规五部曲分析如下：

1、确定dp数组以及下标的含义

如果背包所载重量为target，dp[target]就是装满背包之后的总价值，因为本题中每一个元素的数值既是重量，也是价值，所以当dp[target] == target的时候，背包就装满了。

有录友可能想，那还有装不满的时候？

拿输入数组 [1, 5, 11, 5]，举例，dp[7]只能等于6，因为只能放进1和5。

而dp[6]就可以等于6了，放进1 和 5，那么dp[6] == 6，说明背包装满了。

2、确定递推公式

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]);

3、dp数组如何初始化

在01背包，一维dp如何初始化，已经讲过，从dp[j]的定义来看，首先dp[0]一定是0。

如果题目给的价值都是正整数 那么非0下标都初始化为0就可以了，如果题目给的价值有负数，那么非0下标就要初始化为负无穷。这样才能让dp数组在递推的过程中取得最大的价值，而不是被初始值覆盖了。

本题题目中只包含正整数的非空数组，所以非0下标的元素初始化为0就可以了。

代码如下：

// 题目中说：每个数组中的元素不会超过 100，数组的大小不会超过 200
// 总和不会大于20000，背包最大只需要其中一半，所以10001大小就可以了
vector<int> dp(10001, 0);

4、确定遍历顺序

如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！

代码如下：

// 开始 01背包
for(int i = 0; i < nums.size(); i++) {
    for(int j = target; j >= nums[i]; j--) { // 每一个元素一定是不可重复放入，所以从大到小遍历
        dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
    }
}

核心代码：

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        vector<int> dp(10001,0);
        int sum=0;
        for(int i=0;i<nums.size();i++){
            sum+=nums[i];
        }
        if(sum%2==1) return false;
        int target=sum/2;

        for(int i=0;i<nums.size();i++){
            for(int j=target;j>=nums[i];j--){
                dp[j]=max(dp[j],dp[j-nums[i]]+nums[i]);
            }
        }
        if(dp[target]==target) return true;
        else return false;
        
    }
};

【注】

1、 int sum=0; 一定要初始化为0！！

2、如果sum是奇数，直接return false。