leetcode背包问题416、494、474、879、1049、279、322、377、518

qq_40707462

已于 2022-03-10 15:06:30 修改

阅读量5.6k

点赞数 8

分类专栏： leetcode 文章标签： leetcode 动态规划算法

于 2021-05-26 20:12:21 首次发布

本文链接：https://blog.csdn.net/qq_40707462/article/details/117296455

版权

leetcode 专栏收录该内容

202 篇文章 2 订阅

订阅专栏

是否可以根据一个 target，再给定一个数组 arrs，问：能否使用 arrs 中的元素做各种排列组合得到 target。

①01 背包问题：【不可重复】

一共有 N 件物品，第 i（i 从 1 开始）件物品的重量为 w[i]，价值为 v[i]。在总重量不超过背包承载上限 W 的情况下，能够装入背包的最大价值是多少？

即数组中的元素不可重复使用，外循环遍历 arrs，内循环遍历 target，且内循环倒序，从target遍历到当前物品的值

②完全背包问题：【可重复】

一共有 N 种物品，每种物品有无限多个，第 i（i 从 1 开始）种物品的重量为 w[i]，价值为 v[i]。在总重量不超过背包承载上限 W 的情况下，能够装入背包的最大价值是多少？

01 背包问题与完全背包问题主要区别就是物品是否可以重复选取。

③ 注意

1、【完全背包】【内外层】
（1）【组合】如果是完全背包，即数组中的元素可重复使用，并且不考虑元素之间顺序，外层arr（保证 arrs 按顺序），内层target正序。

（2）【排列】如果组合问题需考虑元素之间的顺序，外层target，内层arr正序。

2、【01背包】【倒序】
外层arr，内层target倒序，保证每个物品只取了一次，不可重复。
dp[i]（新）=dp[i]（旧）+dp[i-num]（旧）
对于每个target，选择此时这个物品加入背包还是不加，不加就是dp[i]（旧），加就是dp[i-num]（旧）。
从后遍历，dp[i]（新）用的是上一层的dp[i-num]（旧）,如果顺序遍历，dp[i-num]可能会先被更新为本层的新数据dp[i-num]（新），可能出现，前面dp[i-num]（新）加了一次物品a，后面又加了一次，这种情况

3、注意dp的含义：
int[]dp=new int[target+1];
(i跟随target遍历更新)

dp[i]代表达到i的取法有几种，那dp[0]=1，有一种取法，即什么都不取；dp[i]=dp[i]+dp[i-n];
dp[i]代表达到i最多/少用几个物品，那dp[0]=0，表示用0个物品；
dp[i]=max(dp[i], dp[i-n]+1)
dp[i]代表达到i最多/少的重量/价钱，那dp[0]=0，表示用0个物品；
dp[i]=max(dp[i], dp[i-n]+arr[i])

例题

在这里插入图片描述

①01背包

416、分割等和子集

找出和为目标值的子数组【不可重复】，目标值为sum/2
【01背包】外层数组，内层target倒序
在这里插入图片描述

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        if sum(nums)%2!=0:#如过和为奇数那不存在
            return False
        target=sum(nums)//2
        dp=[0 for _ in range(target+1)]
        dp[0]=1

        for num in nums:
            for i in range(target,num-1,-1):
                dp[i]+=dp[i-num]
        return dp[target]!=0

class Solution {
    public boolean canPartition(int[] nums) {
        int l=nums.length;
        int sum=0;
        for(int n:nums) sum+=n;
        if(sum%2!=0) return false;

        int target=sum/2;
        int[]dp=new int[target+1];
        dp[0]=1;
        for(int num :nums){
            for(int i=target;i>=num;i--){
                dp[i]=dp[i]+dp[i-num];
            }
        }
        return dp[target]!=0;
    }
}

494、目标和

找出和为目标值的子数组【不可重复】
【01背包】外层数组，内层target倒序
目标值为(target + sum(nums)) / 2
在这里插入图片描述
假设P是正子集，N是负子集
sum( P) - sum(N) = target
sum( P) + sum(N) + sum( P) - sum(N) = target + sum( P) + sum(N)
2 * sum( P) = target + sum(nums)

因此，原来的问题已转化为一个求子集的和问题：找到nums的一个子集 P，使得sum( P) = (target + sum(nums)) / 2

注意nums=[100]，target=-200这种情况，dp数组可能没法初始化，要提前判断

class Solution:
    def findTargetSumWays(self, nums: List[int], target: int) -> int:
        if (target+sum(nums))%2!=0 or (target+sum(nums))/2<0:#如过和为奇数那不存在
            return 0
        target=(target+sum(nums))//2
        dp=[0 for _ in range(target+1)]
        dp[0]=1

        for num in nums:
            for i in range(target,num-1,-1):
                dp[i]+=dp[i-num]
        return dp[target]

class Solution {
        public int findTargetSumWays(int[] nums, int target) {
            int sum=0;
            for(int n:nums) sum+=n;
            if((target+sum)%2!=0 || (target+sum)/2<0) return 0;

            int t=(target+sum)/2;
            int[] dp=new int[t+1];
            dp[0]=1;
            for(int n:nums){
                for(int i=t;i>=n;i--){
                    dp[i]=dp[i]+dp[i-n];
                }
            }
            return dp[t];
        }
    }

474、一和零（多重背包）

找出和为目标值的最短子数组【不可重复】
【01背包】外层物品，内层target倒序，两个target即双重遍历

注意dp的含义：

dp[i]代表达到i的取法有几种，那dp[0]=1，有一种取法，即什么都不取；dp[i]=dp[i]+dp[i-n];
dp[i]代表达到i最多/少用几个物品，那dp[0]=0，表示用0个物品；
dp[i]=max(dp[i], dp[i-n]+1)

在这里插入图片描述

class Solution:
    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
        dp=[[0]*(n+1) for _ in range(m+1)] 

        for item in strs:  # 遍历物品
            zeroNum=0
            oneNum=0
            for i in item:#当前物品的值 即0和1的个数
                if i =='0':
                    zeroNum+=1
                else:
                    oneNum+=1

            for i in range(m, zeroNum-1, -1): # 遍历target且都从后向前遍历！
                for j in range(n, oneNum-1,-1):
                    dp[i][j]=max(dp[i][j], dp[i-zeroNum][j-oneNum]+1)
        return dp[-1][-1]

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp=new int[m+1][n+1];
        for(String s:strs){//外层arr
            int zero=0,one=0;//计算arr的值，别的题一般是直接给的
            for(char c : s.toCharArray()){
                if(c-'0'==0) zero+=1;
                else one+=1;
            }

            for(int i=m;i>=zero;i--){//内层target倒序
                for(int j=n;j>=one;j--){
                    dp[i][j]=Math.max(dp[i][j],dp[i-zero][j-one]+1);
                }
            }
        }
        return dp[m][n];
    }
}

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

找到石头组合，使其重量最接近总重量的一半
target为总重量的一半，dp[target]里是容量为target的背包所能背的最大重量。
【01背包】外层物品，内层target倒序

在这里插入图片描述

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int len=stones.length;
        int sum=0;
        for(int n:stones) sum+=n;
        int t=sum/2;
        int[]dp=new int[t+1];
        dp[0]=0;

        for(int n:stones){
            for(int i=t;i>=n;i--){
                dp[i]=Math.max(dp[i],dp[i-n]+n);
            }
        }
        return sum-2*dp[t];
    }
}

879、盈利计划（多维背包）

集团里有 n 名员工，他们可以完成各种各样的工作创造利润。
第 i 种工作会产生 profit[i] 的利润，它要求 group[i] 名成员共同参与。如果成员参与了其中一项工作，就不能参与另一项工作。

工作的任何至少产生 minProfit 利润的子集称为盈利计划。并且工作的成员总数最多为 n 。

有多少种计划可以选择？因为答案很大，所以返回结果模 10^9 + 7 的值。

示例 1：

输入：n = 5, minProfit = 3, group = [2,2], profit = [2,3]
输出：2
解释：至少产生 3 的利润，该集团可以完成工作 0 和工作 1 ，或仅完成工作 1 。
总的来说，有两种计划。

示例 2：

输入：n = 10, minProfit = 5, group = [2,3,5], profit = [6,7,8]
输出：7
解释：至少产生 5 的利润，只要完成其中一种工作就行，所以该集团可以完成任何工作。
有 7 种可能的计划：(0)，(1)，(2)，(0,1)，(0,2)，(1,2)，以及 (0,1,2) 。

思路：

将每个任务看作一个「物品」，完成任务所需要的人数看作「成本」，完成任务得到的利润看作「价值」。
其特殊在于存在一维容量维度需要满足「不低于」，而不是常规的「不超过」
定义f[i][j][k] 为考虑前 i件物品，使用人数不超过 j，所得利润至少为 k 的方案数。
对于每件物品（令下标从 1 开始），我们有「选」和「不选」两种决策，f[i][j][k] 为以下两种情况之和.
不选：f[i−1][j][k]
选： f[i−1][j−group[i−1]][max(k−profit[i−1],0)]
利润 k - profit[i - 1]可能会出现负值，设为0即可
初始化：没有物品，盈利为0，人数无要求f[0][x][0]=1
压缩空间的话，可以去掉人数这一维，记得内层，人数 j 和利润k（类似target）倒序

class Solution {
    public int profitableSchemes(int n, int minProfit, int[] group, int[] profit) {
        int mod=(int)1e9+7;
        int m=group.length;
        long[][]dp=new long[n+1][minProfit+1];
        for (int i = 0; i <= n; i++) dp[i][0] = 1;
        for (int i = 1; i <= m; i++){
            for (int j = n; j >= group[i-1]; j--){
                for (int k = minProfit; k >= 0; k--){
                    dp[j][k]+=dp[j-group[i-1]][Math.max(k-profit[i-1],0)];
                    if (dp[j][k] >= mod) dp[j][k] -= mod;                    
                }
            }
        }  
        return (int)dp[n][minProfit]; 
    }
}

②完全背包

279、完全平方数

组成和为target的最小个数【可重复】【组合】
【完全背包】外层循环为选择池 nums，内层循环为 target。
（nums=[1,4,9…]）
（和322零钱兑换完全一样）
在这里插入图片描述

class Solution:
    def numSquares(self, n: int) -> int:
        dp=[math.inf for _ in range(n+1)]
        dp[0]=0

        for i in range(1,int(math.sqrt(n))+1):#遍历nums
            for j in range(i*i,n+1):#遍历target
                dp[j]=min(dp[j],dp[j-i*i]+1)
        return dp[-1]

class Solution {
    public int numSquares(int n) {
        int[] dp=new int[n+1];
        for(int i=1;i<dp.length;i++){
            dp[i]=Integer.MAX_VALUE-1;//注意java中int溢出
        }

        for(int j=1;j*j<=n;j++){
            for(int i=j*j;i<=n;i++){
                dp[i]=Math.min(dp[i],dp[i-j*j]+1);
            }
        }
        return dp[n]==Integer.MAX_VALUE-1? -1:dp[n];
    }
}

322、零钱兑换

组成和为target的最小个数【可重复】【组合】
【完全背包】外层循环为选择池 nums，内层循环为 target正序。
在这里插入图片描述

import math
class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        dp=[math.inf]*(amount+1)
        dp[0]=0
        for coin in coins:
            for i in range(coin,amount+1):
                dp[i]=min(dp[i],dp[i-coin]+1)
        return dp[amount] if dp[-1]!=math.inf else -1

class Solution {
    public int coinChange(int[] coins, int amount) {
        int[] dp=new int[amount+1];
        for(int i=1;i<dp.length;i++){
            dp[i]=Integer.MAX_VALUE-1;//注意java中int溢出
        }

        for(int coin : coins){
            for(int i=coin;i<=amount;i++){
                dp[i]=Math.min(dp[i],dp[i-coin]+1);
            }
        }
        return dp[amount]==Integer.MAX_VALUE-1? -1:dp[amount];
    }
}

518、零钱兑换2

组成target的子数组个数【可重复】【组合】
【完全背包】外层nums，内层target正序
在这里插入图片描述

class Solution:
    def change(self, amount: int, coins: List[int]) -> int:
        dp=[0 for _ in range(amount+1)]#多一位
        dp[0]=1#没有硬币
        for coin in coins:
            for i in range(coin,amount+1):
                dp[i]+=dp[i-coin]
        return dp[amount]

class Solution {
    public int change(int amount, int[] coins) {
        int[] dp=new int[amount+1];
        dp[0]=1;
        for(int coin :coins){
            for(int i=coin;i<=amount;i++){
                dp[i]+=dp[i-coin];
            }
        }
        return dp[amount];
    }
}

377、组合总和4

组成target的子数组个数【可重复】【排列】
【完全背包】外层target，内层nums
在这里插入图片描述

class Solution:
    def combinationSum4(self, nums: List[int], target: int) -> int:
        dp=[0]*(target+1)
        dp[0]=1

        for i in range(1,target+1):
            for num in nums:
                if i>=num:
                    dp[i]+=dp[i-num]
        return dp[-1]

class Solution {
    public int combinationSum4(int[] nums, int target) {
        int[] dp=new int[target+1];
        dp[0]=1;

        for(int i=1;i<=target;i++){
            for(int num : nums){
                if(i>=num){
                    dp[i]+=dp[i-num];
                }
            }
        }
        return dp[target];
    }
}

qq_40707462

关注

8
点赞
踩
23

收藏

觉得还不错? 一键收藏
1
评论
leetcode背包问题416、494、474、879、1049、279、322、377、518

是否可以根据一个 target，再给定一个数组 arrs，问：能否使用 arrs 中的元素做各种排列组合得到 target。①01 背包问题：【不可重复】一共有 N 件物品，第 i（i 从 1 开始）件物品的重量为 w[i]，价值为 v[i]。在总重量不超过背包承载上限 W 的情况下，能够装入背包的最大价值是多少？即数组中的元素不可重复使用，外循环遍历 arrs，内循环遍历 target，且内循环倒序，从target遍历到当前物品的值（倒序，保证每个物品只取了一次：dp[i]（新）=dp[i]（旧
复制链接

扫一扫