背包问题2

背包问题

0-1背包

有N件物品和一个容量为V的背包。第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

特点是：每种物品仅有一件，可以选择放或不放。

用子问题定义状态：即f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。则其状态转移方程便是：f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]}。

题目1 目标和

题目描述

给定一个非负整数数组，a1, a2, …, an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。

返回可以使最终数组和为目标数 S 的所有添加符号的方法数。

输入输出

输入：nums: [1, 1, 1, 1, 1], S: 3
输出：5
解释：

-1+1+1+1+1 = 3
+1-1+1+1+1 = 3
+1+1-1+1+1 = 3
+1+1+1-1+1 = 3
+1+1+1+1-1 = 3

一共有5种方法让最终目标和为3。

思路

将所有的元素前都设定为负号求和sub，选一部分为正号使得等于目标值，此时target变为target - sub。选取物品的重量为原来的两倍。转换成了0-1背包问题。

代码一

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sub = 0;
        for(int i = 0 ; i < nums.size(); i++){
            sub -= nums[i];
        }
        target = target - sub;//
        vector<vector<int>> dp(nums.size() + 1,vector<int>(target + 1, 0));
        dp[0][0] = 1;
        for(int i = 1; i <= nums.size(); i++){
            for(int j = 0; j <= target; j++){
                if(j < 2*nums[i - 1])
                dp[i][j] = dp[i - 1][j];
                else
                dp[i][j] = dp[i - 1][j] + dp[i -1][j - 2*nums[i - 1]];
            }
        }
        return dp[nums.size()][target];
    }
};

优化空间后

0 -1背包从后往前遍历，完全背包从前往后。

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sub = 0;
        for(int i = 0 ; i < nums.size(); i++){
            sub -= nums[i];
        }
        target = target - sub;
       vector<int> dp(target + 1, 0);
       dp[0] = 1;
       for(int i = 0; i < nums.size(); i++){
           for(int j = target; j >= 2*nums[i]; j--){
               dp[j] = dp[j] + dp[j - 2*nums[i]];
           }
       }
        return dp[target];
    }
};

题目2 分割等和子集

题目描述

给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

注意:

每个数组中的元素不会超过 100
数组的大小不会超过 200

输入输出

输入: [1, 5, 11, 5]

输出: true

解释: 数组可以分割成 [1, 5, 5] 和 [11].

思路

将所有元素求和，为奇数则直接返回false，取一半作为背包容量，对元素进行选与不选转换为0-1背包问题。

代码

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;
        for(int i = 0 ; i < nums.size(); i++){
            sum += nums[i];
        }
        int half = sum/2;
        if(half*2 != sum)
            return false;
        vector<int> dp(half + 1, INT_MIN);
        dp[0] = 0;
        for(int i = 0; i < nums.size(); i++){
            for(int j = half; j >= nums[i]; j--){
                dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
            }
        }
        if(dp[half]>=0)
             return true;
        return false;

    }
};

完全背包

有N种物品和一个容量为V的背包，每种物品都有无限件可用。第i种物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

基本思路
这个问题非常类似于01背包问题，所不同的是每种物品有无限件。也就是从每种物品的角度考虑，与它相关的策略已并非取或不取两种，而是有取0件、取1件、取2件……等很多种。如果仍然按照解01背包时的思路，令f[i][v]表示前i种物品恰放入一个容量为v的背包的最大权值。仍然可以按照每种物品不同的策略写出状态转移方程，像这样：f[i][v]=max{f[i-1][v-kc[i]]+kw[i]|0<=kc[i]<= v}。这跟01背包问题一样有O(NV)个状态需要求解，但求解每个状态的时间则不是常数了，求解状态f[i][v]的时间是O(v/c[i])，总的复杂度是超过O(VN)的。

O(VN)的算法

这个算法使用一维数组，伪代码：

for i=1..N
    for v=0..V
        f[v]=max{f[v],f[v-cost]+weight}

推导

题目1 零钱兑换

题目描述

给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。

你可以认为每种硬币的数量是无限的。

输入输出

输入：coins = [1, 2, 5], amount = 11
输出：3
解释：11 = 5 + 5 + 1

思路

完全背包问题，dp[i][j] 记录到第i个面值兑换总额为j所需要的硬币最少个数，用一维数组优化空间复杂度，从前往后遍历。

代码

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