代码随想录-笔记-其八

让我们开始：动态规划！

70. 爬楼梯 - 力扣（LeetCode）

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

class Solution {
public:
    int climbStairs(int n) {
        vector<int> dp(n+1);
        if(n==0)return 0;
        if(n==1)return 1;
        dp[1]=1,dp[2]=2;
        for(int i=3;i<=n;++i){
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
};

动态规划是客观地说最注重逻辑的题型，因为我们必须要找到由子问题推导到主问题的这个过程才可以做。爬楼梯的这个逻辑是什么呢？当我们i来到3以后，我们就可以把爬三阶楼梯拆分成爬一个二阶（三减一）的楼梯方法加一次爬一阶和爬一个一阶（三减二）的楼梯加一次爬两阶，同理四阶就是一个爬一个三阶的楼梯方法加一次一步和爬二阶的楼梯方法加一次两步。

746. 使用最小花费爬楼梯 - 力扣（LeetCode）

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

请你计算并返回达到楼梯顶部的最低花费。

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

这个题的递推的关键在于找到最小花费，我们需要考量爬到i阶楼梯的最小花费，由于每次只能爬一阶或者二阶，所以我们只需要往前找一阶的最小花费加上该阶的花费与往前两阶的最小花费与该阶的花费即可。

62. 不同路径 - 力扣（LeetCode）

一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m+1,vector<int>(n+1));
        for(int i=1;i<=m;++i){
            dp[i][1]=1;
        }
        for(int j=1;j<=n;++j){
            dp[1][j]=1;
        }
        for(int i=2;i<=m;++i){
            for(int j=2;j<=n;++j){
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m][n];
    }
};

二维动态规划的例题，这里的dp[i][j]代表的意思是i*j的网格到终点的路径数，如果是一行或者一列的话都是1，然后第i行j列等同于从i-1行j列的路径数与i行j-1列的路径数的总和。

63. 不同路径 II - 力扣（LeetCode）

给定一个 m x n 的整数数组 grid。一个机器人初始位于 左上角（即 grid[0][0]）。机器人尝试移动到 右下角（即 grid[m - 1][n - 1]）。机器人每次只能向下或者向右移动一步。

网格中的障碍物和空位置分别用 1 和 0 来表示。机器人的移动路径中不能包含任何有障碍物的方格。

返回机器人能够到达右下角的不同路径数量。

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        if(obstacleGrid.empty()||obstacleGrid[0][0]==1)return 0;
        int m=obstacleGrid.size(),n=obstacleGrid[0].size();
        vector<vector<int>> dp(m,vector<int>(n));
        dp[0][0]=1;
        for(int i=1;i<m;++i){
            if(obstacleGrid[i][0]==0&&dp[i-1][0]!=0)dp[i][0]=1;
            else dp[i][0]=0;
        }
        for(int j=1;j<n;++j){
            if(obstacleGrid[0][j]==0&&dp[0][j-1]!=0)dp[0][j]=1;
            else dp[0][j]=0;
        } 
        for(int i=1;i<m;++i){
            for(int j=1;j<n;++j){
                if(obstacleGrid[i][j]==0){
                    dp[i][j]=dp[i-1][j]+dp[i][j-1];
                }
                else dp[i][j]=0;
            }
        }
        return dp[m-1][n-1];
    }
};

这个题无疑要麻烦得多，因为障碍物的出现，我们必须随时检查障碍物是否存在。除此之外和正常的不同路径区别不大，注意边界条件的处理以及网格的下标与我们动态数组的下标的对应关系。

343. 整数拆分 - 力扣（LeetCode）

给定一个正整数 n ，将其拆分为 k 个 正整数 的和（ k >= 2 ），并使这些整数的乘积最大化。

返回 你可以获得的最大乘积 。

class Solution {
public:
    int integerBreak(int n) {
        vector<int> dp(n+1);
        dp[2]=1;
        for(int i=3;i<=n;++i){
            for(int j=1;j<=i/2;++j){
                dp[i]=max(dp[i],max(dp[i-j]*j,(i-j)*j));
            }
        }
        return dp[n];
    }
};

这个题虽然结果看起来似乎非常简单，但其中涉及到的思路其实挺复杂。这里dp[i]主要考虑了三种情况：dp[i]本身，dp[i-j]*j（整数i-j的最大乘积乘以j），(i-j)*j（整数i-j乘以j），来考虑整数i的最大乘积，j利用了乘法的性质可以少遍历一半的区间。

96. 不同的二叉搜索树 - 力扣（LeetCode）

给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。

class Solution 
{
public:
    int numTrees(int n) 
    {
        vector<int> f(n+1,0);
        f[0]=1;
        f[1]=1;
        for(int i=2;i<=n;i++)
        {
            for(int j=1;j<=i;j++)
            {
                f[i]+=f[i-j]*f[j-1];
            }
        }
        return f[n];
    }
};

这里我就不用自己的话赘述了。直接上图吧

本质上是一个找规律并表达出来的问题。

46. 携带研究材料（第六期模拟笔试） (kamacoder.com)

小明是一位科学家，他需要参加一场重要的国际科学大会，以展示自己的最新研究成果。他需要带一些研究材料，但是他的行李箱空间有限。这些研究材料包括实验设备、文献资料和实验样本等等，它们各自占据不同的空间，并且具有不同的价值。

小明的行李空间为 N，问小明应该如何抉择，才能携带最大价值的研究材料，每种研究材料只能选择一次，并且只有选与不选两种选择，不能进行切割。

#include <iostream>
#include <vector>
using namespace std;
int main(){
    int n,zooms;
    cin>>n>>zooms;
    vector<int> weights(n);
    vector<int> values(n);
    for(int i=0;i<n;++i){
        cin>>weights[i];
    }
    for(int i=0;i<n;++i){
        cin>>values[i];
    }
    vector<vector<int>> dp(n+1,vector<int>(zooms+1,0));
    for(int j=weights[0];j<=zooms;++j){
        dp[0][j]=values[0];
    }
    for(int i=1;i<n;++i){
        for(int j=0;j<=zooms;++j){
            if(j<weights[i])dp[i][j]=dp[i-1][j];
            else dp[i][j]=max(dp[i-1][j],dp[i-1][j-weights[i]]+values[i]);
        }
    }
    cout<<dp[n-1][zooms]<<endl;
    return 0;
}

0-1背包作为动态规划的经典题目，可以说非常重要，难点其实主要在于对dp数组的理解以及初始化的过程，要做到每一步在干嘛心中有数才可以。

#include <iostream>
#include <vector>
using namespace std;
int main(){
    int n,zooms;
    cin>>n>>zooms;
    vector<int> weights(n);
    vector<int> values(n);
    for(int i=0;i<n;++i){
        cin>>weights[i];
    }
    for(int i=0;i<n;++i){
        cin>>values[i];
    }
    vector<int> dp(zooms+1,0);
    for(int i=0;i<n;++i){
        for(int j=zooms;j>=weights[i];--j){
            dp[j]=max(dp[j],dp[j-weights[i]]+values[i]);
        }
    }
    cout<<dp[zooms]<<endl;
    return 0;
}

在这里放上第二种做法：将二维数组dp转换为一维数组，从背包空间容量大小开始从上往下遍历，分别得到最大的价值。值得一提的是一维的动态规划数组一定不能正向遍历，因为这会反复调用已经被确认的dp数组里的值，变成完全背包问题。

416. 分割等和子集 - 力扣（LeetCode）

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

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum=accumulate(nums.begin(), nums.end(), 0);
        if(sum%2!=0)return false;
        int target=sum/2;
        vector<int> dp(target+1);
        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]);
            }
        }
        return dp[target]==target;
    }
};

这是一个典型的0-1背包应用题，我们要判断能否分割成两个和相等的子集，其实就是判断我们能否填满容量为数组总和一半的背包，就变成了我们的0-1背包问题，这里我们的物体的容量和价值相同，都是nums[i]。

1049. 最后一块石头的重量 II - 力扣（LeetCode）

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。

每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。

最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int n=stones.size();
        vector<int> dp(15001,0);
        int sum=accumulate(stones.begin(), stones.end(), 0);
        int target=sum/2;
        for(int i=0;i<n;++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];
    }
};

这个题其实和上个题类似，也是找能否填满容量为数组总和的一半的背包问题，不过这个题不用返回是否，而是返回最小的差值，具体来说，只是return 的东西不太一样。

494. 目标和 - 力扣（LeetCode）

给你一个非负整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ：

例如，nums = [2, 1] ，可以在 2 之前添加 '+' ，在 1 之前添加 '-' ，然后串联起来得到表达式 "+2-1" 。

返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum=accumulate(nums.begin(), nums.end(), 0);
        if((target+sum)%2!=0)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];
    }
};

这个题其实比想象中还要难理解，对于这个题而言，可能真正的难点在于如何将问题转换为背包问题，我将视频链接放在这里。
动态规划之背包问题，装满背包有多少种方法？| LeetCode：494.目标和_哔哩哔哩_bilibili

474. 一和零 - 力扣（LeetCode）

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的长度，该子集中最多有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的子集。

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 oneNum=0,zeroNum=0;
            for(char c:str){
                if(c=='0')zeroNum++;
                else oneNum++;
            }
            for(int i=m;i>=zeroNum;--i){
                for(int j=n;j>=oneNum;--j){
                    dp[i][j]=max(dp[i][j],dp[i-zeroNum][j-oneNum]+1);
                }
            }
        }
        return dp[m][n];
    }
};

这个题其实是一个比较经典的0-1背包问题，只是将物品的序号由一个一维的数组变成了一个二维的数组，这就比较考察我们对0-1背包的基本理解了。这题比较容易犯错的地方在于最后的递推公式中的加一，因为这里我们的dp数组的含义是最多包含m个0和n个1的string的最大子集个数，所以我们只能加一，用0-1背包类比的话，就是所有的物品的value都是1。

52. 携带研究材料（第七期模拟笔试） (kamacoder.com)

小明是一位科学家，他需要参加一场重要的国际科学大会，以展示自己的最新研究成果。他需要带一些研究材料，但是他的行李箱空间有限。这些研究材料包括实验设备、文献资料和实验样本等等，它们各自占据不同的重量，并且具有不同的价值。

小明的行李箱所能承担的总重量是有限的，问小明应该如何抉择，才能携带最大价值的研究材料，每种研究材料可以选择无数次，并且可以重复选择。

#include <iostream>
#include <vector>
using namespace std;
int main(){
    int n,badgeweights;
    cin>>n>>badgeweights;
    vector<int> weights(n+1);
    vector<int> values(n+1);
    for(int i=0;i<n;++i){
        cin>>weights[i]>>values[i];
    }
    vector<int> dp(badgeweights+1,0);
    for(int i=0;i<n;++i){
        for(int j=0;j<=badgeweights;++j){
            if(weights[i]<=j){
                dp[j]=max(dp[j],dp[j-weights[i]]+values[i]);
            }
        }
    }
    cout<<dp[badgeweights]<<endl;
    return 0;
}

这个就属于完全背包的问题了，所谓完全背包就是在0-1背包的基础上物品可以无限选择，主要带来的改动就是在遍历的过程中我们可以采取两个从小到大的遍历了：因为覆盖原来的值也无所谓。

518. 零钱兑换 II - 力扣（LeetCode）

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。

请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。

假设每一种面额的硬币有无限个。

题目数据保证结果符合 32 位带符号整数

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        vector<uint64_t> 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]];
            }
        }
        return dp[amount];
    }
};

与目标和类似的一题，但是把背包替换成了完全背包，两题的递推公式是一样的：dp[j]+=dp[j-nums[i]];但是问题在于对背包的遍历：对于0-1背包，我们一般从后往前遍历：因为对于dp数组中的数来说，他们的值的变化依据来自于表左上方，也就是当前序号之前的值，如果从前往后遍历，容易反复使用；但对于完全背包来说，我们无所谓反复使用，甚至可以说需要反复使用，所以完全背包就是从前往后遍历。

377. 组合总和 Ⅳ - 力扣（LeetCode）

给你一个由不同整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。

题目数据保证答案符合 32 位整数范围。

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        vector<unsigned long long> dp(target + 1, 0); // 使用更大的类型以防止溢出
        dp[0] = 1; // 只有当目标值为0时，有一种方法，即不选择任何数
        
        for (int j = 1; j <= target; ++j) { // 遍历所有可能的目标值
            for (int i = 0; i < nums.size(); ++i) { // 遍历所有可能的数字
                if (j >= nums[i]) { // 确保不会访问负索引
                    dp[j] += dp[j - nums[i]];
                }
            }
        }
        
        return dp[target];
    }
};

这个题与上述的完全背包求组合数又不一样：这个题求的是排列数！所谓组合和排列的区别只在于有无顺序，而反应在题目中，最大的区别就在于是先遍历物品还是先遍历背包。我们不妨这样想：如果我们先遍历物品，我们是根据物品填背包，物品是首先被考虑的，那么什么时候放进背包就不重要了，这就是组合；反之，我们先遍历背包，是根据背包来选物品，那么这个时候我们先放哪个物品进去都会对后续的背包选择物品产生影响，这就是排列。

57. 爬楼梯（第八期模拟笔试） (kamacoder.com)

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬至多m (1 <= m < n)个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

#include <iostream>
#include <vector>
using namespace std;
int main(){
    int n,weights;
    cin>>n>>weights;
    vector<int> dp(n+1,0);
    dp[0]=1;
    for(int j=1;j<=n;++j){
        for(int i=1;i<=weights;++i){
            if(i<=j){
                dp[j]+=dp[j-i];
            }
        }
    }
    cout<<dp[n]<<endl;
    return 0;
}

又是一个求排列的题，并无太多特殊之处。

322. 零钱兑换 - 力扣（LeetCode）

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。

计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。

你可以认为每种硬币的数量是无限的。

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int> dp(amount+1,INT_MAX);
        dp[0]=0;
        for(int i=0;i<coins.size();++i){
            for(int j=coins[i];j<=amount;++j){
                if(dp[j-coins[i]]!=INT_MAX){
                    dp[j]=min(dp[j],dp[j-coins[i]]+1);
                }
            }
        }
        if(dp[amount]==INT_MAX)return -1;
        else return dp[amount];
    }
};

这个题和之前的要求又反过来了：要求最少的硬币数量，所以我们的递推公式需要变成求min，除此之外，我们还要注意我们的初始化条件：dp[0]=0,在这里dp的意义是最少的硬币数，所以我们针对0元的最少硬币自然是0；

279. 完全平方数 - 力扣（LeetCode）

给你一个整数 n ，返回 和为 n 的完全平方数的最少数量 。

完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。

class Solution {
public:
    int numSquares(int n) {
        vector<int> dp(n + 1, INT_MAX);
        dp[0] = 0;
        for (int i = 0; i <= n; i++) { // 遍历背包
            for (int j = 1; j * j <= i; j++) { // 遍历物品
                dp[i] = min(dp[i - j * j] + 1, dp[i]);
            }
        }
        return dp[n];
    }
};

其实也是个经典的完全背包问题，我们的n就是背包容量，完全平方数就是物品，其weights是j*j,value是1。