Leetcode动态规划 474 518(背包总结) 377 70 322 279 139 198 213

474. Ones and Zeroes

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 zeroNum = 0, oneNum = 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];
    }
};

完全背包：

518. Coin Change II（小总结）

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

        return dp[amount];
    }
};

1.组合数的递推公式

2.注意组合数和排列数

组合数，对顺序没有要求，即1，2和2，1只算一次，此时，只能先遍历物品，再遍历背包

排列数，先遍历背包，再遍历物品

3.完全背包和01背包

完全背包：每个物品可以重复用，一维数组遍历背包的时候从小开始

01背包：每个物品只能用一次，一维数组遍历时从大到小

377. Combination Sum IV

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; i++){
            for(int j=0; j<nums.size(); j++){
                if(nums[j] <= i && dp[i] < INT_MAX - dp[i-nums[j]]){
                    dp[i] += dp[i-nums[j]];
                }
            }
        }

        return dp[target];
    }
};

排列数

70. Climbing Stairs

1.普通动态规划

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

        return dp[n];
    }
};

 2.背包思想

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

        for(int i=3; i<=n; i++){
            for(int j=0; j<=2; j++){
                dp[i] += dp[i-j];
            }
        }

        return dp[n];
    }
};

322. Coin Change

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;
        return dp[amount];
    }
};

做的不是很顺畅

一些小的地方需要注意：

1.设置vector初始值的时候要设置为max

2.dp[0] = 0

3.这道题要判断dp[j-coins]是不是int_max，不然会runtime error

279. Perfect Squares

class Solution {
public:
    int numSquares(int n) {
        int num = sqrt(n);
        vector<int> dp(n+1, INT_MAX);
        dp[0] = 0;

        for(int i=0; i<=num; 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];
    }
};

出错的地方：

1.一开始把设置为了 j=i   但正确的应该是j=i*i;

2.这里要设定的是dp[0] = 0, 而不是dp[1] = 1

因为不是每一次都必须用到1*1

139. Word Break

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        vector<bool> dp(s.size()+1, false);
        unordered_set<string> wordSet(wordDict.begin(), wordDict.end());
        dp[0] = true;
        for(int i=1; i<=s.size(); i++){
            for(int j=0; j<i; j++){
                string subword = s.substr(j, i-j);
                if(wordSet.find(subword) != wordSet.end() && dp[j])
                    dp[i] = true;
            }
        }

        return dp[s.size()];
    }
};

遍历物品的思路就不太对

之后要再回来做一遍

打家劫舍：

198. House Robber

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

        for(int i=2; i<=nums.size(); i++){
            dp[i] = max(dp[i-1], dp[i-2]+nums[i-1]);
        }

        return dp[nums.size()];
    }
};

213. House Robber II

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

    int robRange(vector<int>& nums, int start, int end){
        if(start == end) return nums[start];
        vector<int> dp(nums.size(), 0);
        dp[start] = nums[start];
        dp[start+1] = max(nums[start], nums[start+1]);

        for(int i=start+2; i<=end; i++){
            dp[i] = max(dp[i-1], dp[i-2]+nums[i]);
        }

        return dp[end];
    }
};

这里的基本思路有了：

主要就是有三种情况，有头无尾，有尾无头，无头无尾，但由于无头无尾一定最小，所以没有体现在代码中

但有一些小问题需要注意：

1.要写start = end的情况

2.这里跟上一题的写法有一点不同， 把dp的下标和nums的统一了，这样看起来更好一点

3.要注意所有的都是以start开始了，而不是0