【算法/动态规划/完全背包】题解+详细备注（共6题）

完全背包解题模板

完全背包和01背包问题唯一不同的地方就是，每种物品有无限件。因此唯一的不同是体现在遍历顺序步骤

• 确定dp数组以及下标的含义：dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。
• 确定递推公式：

1. 不放物品i：由dp[i - 1][j]推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i - 1][j]。(其实就是当物品i的重量大于背包j的重量时，物品i无法放进背包中，所以被背包内的价值依然和前面相同。)
2. 放物品i：由dp[i - 1][j - weight[i]]推出，dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]的时候不放物品i的最大价值，那么dp[i - 1][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最大价值
3. 所以递归公式：

// 普通递推公式：
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
//求装满背包有几种方法，一般公式都是
dp[j] += dp[j - nums[i]];

• dp数组的初始化

// 初始化 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];
}

• 确定遍历顺序

// 01背包遍历代码
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]);
    }
}

// 完全背包遍历代码
// 先遍历物品，再遍历背包
for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = weight[i]; j <= bagWeight ; j++) { // 遍历背包容量（由于物品有无数件，从小到大遍历）
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

    }
}

// 如果求组合数就是外层for循环遍历物品，内层for遍历背包。
// 如果求排列数就是外层for遍历背包，内层for循环遍历物品。

518.零钱兑换II

class Solution {
public:
    int change(int amount, vector<int>& coins) {
    	// 1.确定dp数组以及下标的含义
    	// 完全背包：dp[j]表示容量为j的背包，所背的最大物品价值为dp[j]
    	// 本题：凑成总金额j的货币组合数为dp[j]
        vector<int> dp(amount+1);
		
		// 3.dp数组初始化
		// 本题：dp[0] = 1是递推公式的基础
        dp[0] = 1;

		// 4.确定遍历顺序
		// 完全背包：外层从小到大遍历物品，内层从小到大遍历背包容量
		// 本题：外层从小到达遍历金币，内层从小到达遍历背包容量
        for(int i{};i<coins.size();++i){
            for(int j = coins[i];j<=amount;++j){
            	// 2.确定递推公式
            	// 完全背包：dp[j] = max(dp[j],dp[j-weight[i]] + value[i])
            	// 完全背包：求装满背包的公式一般都是：dp[j] += dp[j - nums[i]];
            	// dp[j] += dp[j-coins[i]]
                dp[j] += dp[j-coins[i]];
            }
        }


        return dp[amount];
    }
};

377.组合总和Ⅳ

class Solution {
public:
	// 可以元素相同顺序不同的组合算两个组合，其实就是求排列！
	// 如果求排列数就是外层for遍历背包，内层for循环遍历物品。
    int combinationSum4(vector<int>& nums, int target) {
    	// 1.确定dp数组以及数组下标的含义
    	// dp[j]表示和为j的组合的组合的个数为dp[j]
        vector<int> dp(target+1);

        dp[0] = 1;
		// 因为求排列：所以外层循环遍历背包，内层循环遍历物品（完全背包都是从小到大）
        for(int j = 0;j<=target;++j){
            for(int i{};i<nums.size();++i){
            	// 边界条件处理
                if(j-nums[i] >= 0 && dp[j] < INT_MAX - dp[j-nums[i]])
                dp[j] += dp[j-nums[i]];
            }
        }

        return dp[target];
    }
};

70.爬楼梯

class Solution {
public:
    int climbStairs(int n) {
    	// 1.确定dp数组以及下标的含义
    	// 爬到有i个台阶的楼梯的楼顶有dp[i]种方法
        vector<int> dp(n + 1, 0);
        // 3.dp数组初始化
        dp[0] = 1;
		// 4.背包里求排列的问题：外层遍历背包，内层遍历物品
        for (int i = 1; i <= n; i++) { // 遍历背包
            for (int j = 1; j <= m; j++) { // 遍历物品（本题m=2）
            	// 2.确定递推公式
            	// 求装满背包有几种方法，一般都是：dp[i]+=dp[i-j]
                if (i - j >= 0) dp[i] += dp[i - j];
            }
        }
        return dp[n];
    }
};

322.零钱兑换

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
    	// 1.定义dp数组以及数组下标的含义
    	// dp[j]表示凑成总金额j的最少硬币个数为dp[j]
        vector<int> dp(amount+1,INT_MAX);
        // 3.dp数组初始化
        dp[0] = 0;
        // 4.确定遍历顺序
        // 外层遍历物品，内层遍历背包容量
        for(int i{};i<coins.size();++i){
            for(int j = coins[i];j<=amount;++j){
            	// 2.确定递推公式：dp[j] = max(dp[j],dp[j-weight[i]] + value[i]);
                if(dp[j-coins[i]] < INT_MAX)
                dp[j] = min(dp[j],dp[j-coins[i]]+1);
            }
        }
        return dp[amount] == INT_MAX ? -1 : dp[amount];
    }
};

279.完全平方数

class Solution {
public:
    int numSquares(int n) {
    	// 1.定义dp数组以及下标的含义
    	// dp[j]表示和为j的完全平方数的数量为dp[j]
        vector<int> dp(n+1,INT_MAX);
		// 3.dp数组初始化
        dp[0] = 0;
		// 4.确定遍历顺序
		// 外层遍历物品，内层遍历背包容量
        for(int i {1};i*i<=n;++i){
            for(int j = 1; j <=n;++j){
            	// 2.确定递推公式：dp[j] = max(dp[j],dp[j-weight[i]] + value[i])
                if(j-i*i >= 0)
                dp[j] = min(dp[j],dp[j-i*i] + 1);
            }
        }

        return dp[n] == INT_MAX ? -1 : dp[n];
    }
};

139.单词拆分

class Solution {
public:
	// DP解决完全背包问题
    bool wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> unSet(wordDict.begin(),wordDict.end());
        int n = s.size();
        // 1.确定dp数组以及数组下标的含义
        // dp[i] :字符串长度为i的话，dp[i]为true，表示可以拆分成一个或多个在字典中出现的单词
        vector<int> dp(n+1,false);
        dp[0] = true;
        // 4.确定遍历顺序
        // 如果求组合数就是外层for循环遍历物品，内层for遍历背包。
		// 如果求排列数就是外层for遍历背包，内层for循环遍历物品。
		// 本题：外层遍历背包，内层遍历物品
        for(int i = 1;i<=n;++i){
            for(int j{};j<=i;++j){
            	// 2.确定递推公式
                string str = s.substr(j,i-j);
                if(dp[j] && unSet.find(str) != unSet.end()){
                    dp[i] = true;
                }
            }
        }
        return dp[n];
    }
};