代码随想录算法训练营第三十八天|零钱兑换、完全平方数、单词拆分、多重背包、背包总结

零钱兑换 leetcode 322

dp[j]含义：装满容量为j的背包最少需要dp[j]个硬币。

递推公式：如果不放当前物品那么就是dp[j]，如果放就是dp[j-coins[i]]+1，为什么是加一，因为dp[j]的含义是装满容量为j的背包最少需要dp[j]个硬币，那么如果放当前硬币就是当容量减去当前硬币容量最少需要的硬币个数dp[j-coins[i]]之和再加一。所以递推公式为：

dp[j]=min(dp[j],dp[j-coins[i]]+1);

初始化：当容量也就是目标和为0时最少需要多少个硬币肯定是0，那么dp[0]=0;

非零下标初始化，因为我们是取min最小值，所以为了不被覆盖，非零下标应该初始化为int的最大值INT_MAX。

遍历顺序：求组合，先遍历物品（coins数组）再遍历背包（amount）。

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

代码随想录版本：

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 - coins[i]]是初始值则跳过
                    dp[j] = min(dp[j - coins[i]] + 1, dp[j]);
                }
            }
        }
        if (dp[amount] == INT_MAX) return -1;
        return dp[amount];
    }
};

即在选择放不放coins[i]硬币的时候先判断一下，dp[j-coins[i]]有没有被更新过，如果dp[j - coins[i]] = INT_MAX那么说明无法构成j-coins[i]，如果dp[j - coins[i]] != INT_MAX那么说明可以构成j-coins[i]，且之前已经推断出构成j-coins[i]所需最小硬币数dp[j-coins[i]]，可以进一步通过递推公式得出dp[j]。这么看虽然我写的能过，但还是卡哥的更严谨！

完全平方数 leetcode 279

dp[j]含义：表示构成j时需要的最小完全平方数的数量为dp[j]。

递推公式：dp[j]=min(dp[j],dp[j-i*i]+1);

初始化：dp[0]=0。非零下标初始化为int最大值INT_MAX。

遍历顺序：求组合，先遍历物品（完全平方数）再遍历背包（n）。

class Solution {
public:
    int numSquares(int n) {
        vector<int> dp(n+1,INT_MAX);
        dp[0]=0;
        for(int i=1;i*i<=n;i++){
            for(int j=i*i;j<=n;j++){
                if(dp[j-i*i]!=INT_MAX){
                    dp[j]=min(dp[j],dp[j-i*i]+1);
                }
            }
        }
        if(dp[n]==INT_MAX) return -1;
        return dp[n];
    }
};

单词拆分 leetcode 139

dp[i]含义：字符串列表是否可以组成长度为i的字符串，如果可以dp[i]为ture。dp[0]代表空字符串。

递推公式：如果确定dp[j] 是true，且 [j, i] 这个区间的子串出现在字典里，那么dp[i]一定是true。所以递推公式是 if([j, i] 这个区间的子串出现在字典里 && dp[j]是true) 那么 dp[i] = true。

初始化：dp[0]=true，如果初始化为false那么后面的值就都是false了。非零下标初始化为false。

遍历顺序：求排列先遍历背包后遍历物品。

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> word(wordDict.begin(),wordDict.end());
        vector<bool> dp(s.size()+1,false);
        dp[0]=true;
        for(int i=1;i<=s.size();i++){
            for(int j=0;j<i;j++){
                string str=s.substr(j,i-j);//substr(起始位置，截取的个数)
                if(word.find(str)!=word.end()&&dp[j]==true){
                    dp[i]=true;
                }
            }
        }
        return dp[s.size()];
    }
};

多重背包理论基础

多重背包：有N种物品和一个容量为V 的背包。第i种物品最多有Mi件可用，每件耗费的空间是Ci ，价值是Wi 。求解将哪些物品装入背包可使这些物品的耗费的空间 总和不超过背包容量，且价值总和最大。

多重背包和01背包是非常像的，每件物品最多有Mi件可用，把Mi件摊开，其实就是一个01背包问题了。

卡码网 携带矿石资源 56

#include<iostream>
#include<vector>
using namespace std;

int main(){
    int C,N;
    cin>>C>>N;
    vector<int> w(N,0);
    vector<int> v(N,0);
    vector<int> k(N,0);
    for(int i=0;i<w.size();i++){
        cin>>w[i];
    }
    for(int i=0;i<v.size();i++){
        cin>>v[i];
    }
    for(int i=0;i<k.size();i++){
        cin>>k[i];
    }
    
    int newSize=0;
    for(int i=0;i<k.size();i++){
        if(k[i]>1) newSize+=k[i]-1;
    }
    w.resize(N+newSize);
    v.resize(N+newSize);
    for(int i=0;i<k.size();i++){
        while(k[i]>1){
            w.push_back(w[i]);
            v.push_back(v[i]);
            k[i]--;
        }
    }
    
    vector<int> dp(C+1,0);
    for(int i=0;i<w.size();i++){
        for(int j=C;j>=w[i];j--){
            dp[j]=max(dp[j],dp[j-w[i]]+v[i]);
        }
    }
    cout<<dp[C]<<endl;
}

先对容器扩容再展开转换为01背包问题，否则会超时。

背包问题总结

递推公式

问能否能装满背包（或者最多装多少）：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);

问装满背包有几种方法：dp[j] += dp[j - nums[i]] 

问背包装满最大价值：dp[j] = max(dp[j], dp[j - weight[i]] + value[i])

问装满背包所有物品的最小个数：dp[j] = min(dp[j - coins[i]] + 1, dp[j])

遍历顺序

01背包

二维dp数组01背包先遍历物品还是先遍历背包都是可以的，且第二层for循环是从小到大遍历。

一维dp数组01背包只能先遍历物品再遍历背包容量，且第二层for循环是从大到小遍历。

完全背包

纯完全背包的一维dp数组实现，先遍历物品还是先遍历背包都是可以的，且第二层for循环是从小到大遍历。但是仅仅是纯完全背包的遍历顺序是这样的，题目稍有变化，两个for循环的先后顺序就不一样了。

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

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