力扣第35天----第1049题、第494题、第474题

力扣第35天----第1049题、第494题、第474题

一、第1049题–最后一块石头的重量II

​ 0/1背包问题，滚动数组的方式。有套路的，反复做题，消化这个套路。

​ 滚动数组，时间复杂度O（n^{2）,空间复杂度O（n）。如果采用动态规划–二维数组，时间复杂度O（n}2）,空间复杂度O（n*m），m为dp数组大小。如果使用回溯，那么肯定会超时，时间复杂度O（2^n）。

class Solution {
public:
    int lastStoneWeightII(vector& stones) {
        vector dp(1501,0);          //容量为target的背包所能背的最大重量。
        //最多30个石头，每个石头最多100重量，平分的话，少的部分不会超过1501；
        int sum = 0;
        for(int i = 0; i= stones[i]; --j){   //再遍历背包
                dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);  //递推公式，构建这个dp数组
            }
        }
        return sum - dp[target]*2;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

二、第494题–目标和

​ 这道题，要把字面上的问题，转化为01背包问题，这点不容易想到。变为01背包后，按照套路解题就好了。

​ dp数组—填满背包容量j，需要的次数dp[j]。

​ 递推公式，跟不同路径、爬楼梯有些类似----把前面的结果，累加起来。

​ 初始化----容量为0时，有1种方法，可以理解为空集也算1种集合。这里不要纠结含义，带入验证一下就好了。

​ 遍历顺序----01背包的遍历顺序，2层循环，倒序遍历。

class Solution {
public:
    int findTargetSumWays(vector& nums, int target) {
        int sum = 0;
        for(int i = 0; i dp(bagsize + 1, 0);
        dp[0] = 1;
        for (int i = 0; i= nums[i]; --j){
                dp[j] += dp[j-nums[i]];
            }
        }
        return dp[bagsize];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

三、第474题–一和零

​ 这道题，有些综合。遍历每个物品，对dp数组里的每个背包最大存储进行更新。这里的最大存储是存入str的数量（即dp数组的定义）。所以递推公式中，采用+1的思路，即遍历一个物品，在dp(i-x)(j-y)的基础上再加1，并取max操作。

class Solution {
public:
    int findMaxForm(vector& strs, int m, int n) {
        vector> dp(m+1, vector(n+1, 0)) ;
        for (int i = 0; i < strs.size(); ++i){
            int x = 0;
            int y = 0;
            for (auto c: strs[i]){
                if (c == '0') ++x;
                else ++y;
            }
            for (int i = m; i>=x; --i){
                for (int j = n; j>=y; --j){
                    dp[i][j] = max(dp[i][j], dp[i-x][j-y] +1);
                }
            }
        }
        return dp[m][n];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20