leetcode题解（0-1背包问题）

时间 2019-11-08

标签 leetcode 题解背包问题繁體版

原文原文链接

主要介绍0-1背包问题，及一些leetcode题解c++

0-1背包问题

定义

有一个背包，他的容量为C(Capacity)。如今有n中不一样的物品，编号为0…n-1，其中每一件物品的重量为w(i)，价值为v(i)。问能够向这个背包中盛放哪些物品，使得在不超过背包容量的基础上，物品的总价值最大。面试

解题思路

这类组合问题，咱们均可以使用递归来完成。只是咱们在其中能不能找到重叠子问题，最优子结构进而转化成记忆化搜索或动态规划来解决。bash

对于这个问题，咱们有两个约束条件微信

首先咱们要在n个物品里选
第二点他的容量要小于等于一个给定的数值C。

状态定义

注意这个问题要使用两个变量来定义状态。优化

F(n,C)考虑将n个物品放进容量为C的背包，使得价值最大。ui

状态转移

对于F(i,c)，有两种状况，将第i个物品加入和直接忽略第i个物品spa

F(i,C) = max{F(i-1, C), v(i) + F(i-1, C-w(i))}
复制代码

代码实现

记忆化搜索法

class Knapsack01{
    
    private:
        vector<vector<int>> memo;
    
        // 用 [0...index]的物品,填充容积为c的背包的最大价值
        int bestValue(const vector<int> &w, const vector<int> v, int index, int c){
    
            if( c <= 0 || index < 0 ) {
                return 0;
            }
    
            if( memo[index][c] != -1 ) {
                return memo[index][c];
            }
    
            int res = bestValue(w, v, index-1, c);
            if( c >= w[index] ) {
                res = max( res , v[index] + bestValue(w, v, index-1, c-w[index]) );
            }
    
            memo[index][c] = res;
            return res;
        }
    public:
        int knapsack01(const vector<int> &w, const vector<int> &v, int C){
    
            assert( w.size() == v.size() && C >= 0 );
            int n = w.size();
            if( n == 0 || C == 0 )
                return 0;
    
            memo = vector<vector<int>>( n, vector<int>(C+1,-1));
            return bestValue(w, v, n-1, C);
        }
    };
    
复制代码

使用动态规划自底向上解决

模拟一下，每一个位置都由两个位置决定code

class Knapsack01{
    
    public:
        // 用 [0...index]的物品,填充容积为c的背包的最大价值
        int knapsack01(const vector<int> &w, const vector<int> &v, int C){
    
            assert( w.size() == v.size() && C >= 0 );
    
            if ( n == 0) {
                return 0;
            }
    
            int n = w.size();
            vector<vector<int>> memo( n, vector<int>(C+1,0));
    
            for ( int j = 0; j <= C; j++ ) {
                memo[0][j] = ( j >= w[0] ? v[0] : 0 );
            }
    
            for ( int i = 1; i < n; i++ ) {
                for ( int j = 0; j <= C; j++ ) {
                    // 0~i这些物品容积为j的背包得到的最大值
                    memo[i][j] = memo[i-1][j];
                    if( j >= w[i] ) {
                        memo[i][j] = max( memo[i][j], v[i] + memo[i-1][j-w[i]]);
                    }
                }
            }
    
            return memo[n-1][C];
        }
    };
    
复制代码

0-1 背包问题优化

分析

上面的0-1背包问题的时间复杂度：O(nC),空间复杂度：O(nC)。cdn

咱们分析一下状态转移方程：F(i,C) = max{F(i-1, C), v(i) + F(i-1, C-w(i))}
第i行元素只依赖于第i-1行元素。理论上，只须要保持两行元素。空间复杂度：O(2*C)=O(C)。blog

两行轮流使用完成背包问题

class Knapsack01{
    
    public:
        int knapsack01(const vector<int> &w, const vector<int> &v, int C){
            assert( w.size() == v.size() && C >= 0 );
            int n = w.size();
            if( n == 0 && C == 0 )
                return 0;
    
            vector<vector<int>> memo( 2, vector<int>(C+1,0));
    
            for( int j = 0 ; j <= C ; j ++ )
                memo[0][j] = ( j >= w[0] ? v[0] : 0 );
    
            for( int i = 1 ; i < n ; i ++ )
                for( int j = 0 ; j <= C ; j ++ ){
                    memo[i%2][j] = memo[(i-1)%2][j];
                    if( j >= w[i] )
                        memo[i%2][j] = max( memo[i%2][j], v[i] + memo[(i-1)%2][j-w[i]]);
                }
            return memo[(n-1)%2][C];
        }
    };
    
复制代码

继续优化

只使用一行完成背包问题，比较复杂：咱们从右向左刷新内容

代码实现

class Knapsack01{
    
    public:
        int knapsack01(const vector<int> &w, const vector<int> &v, int C){
            assert( w.size() == v.size() && C >= 0 );
            int n = w.size();
            if( n == 0 || C == 0 )
                return 0;
    
            vector<int> memo(C+1,0);
    
            for( int j = 0 ; j <= C ; j ++ )
                memo[j] = ( j >= w[0] ? v[0] : 0 );
    
            for( int i = 1 ; i < n ; i ++ )
                for( int j = C ; j >= w[i] ; j -- )
                    memo[j] = max( memo[j], v[i] + memo[j-w[i]]);
    
            return memo[C];
        }
    };
    
    
复制代码

0-1背包问题变种

多重背包问题：每一个物品不止1个，有num(i)个
彻底背包问题：每一个物品能够无限使用
多维费用背包问题：要考虑物品的体积和重量两个维度
物品间加入更多约束：物品间能够相互排斥；也能够相互依赖

面试中的0-1背包问题

leetcode 416. 分割等和子集

分析

典型的背包问题，在n个物品中选出必定物品，填满sum/2的背包。

记忆化搜索法

class Solution {
    private:
        // memo[i][c] 表示使用索引为[0...i]的这些元素,是否能够彻底填充一个容量为c的背包
        // -1 表示为未计算; 0 表示不能够填充; 1 表示能够填充
        vector<vector<int>> memo;
    
        // 使用nums[0...index], 是否能够彻底填充一个容量为sum的背包
        bool tryPartition(const vector<int> &nums, int index, int sum){
    
            if( sum == 0 ) {
                return true;
            }
    
            if( sum < 0 || index < 0 ) {
                return false;
    
            }
    
            if( memo[index][sum] != -1 ) {
                return memo[index][sum] == 1;
            }
    
            memo[index][sum] = (tryPartition(nums, index-1 , sum ) ||
                                tryPartition(nums, index-1 , sum - nums[index] ) ) ? 1 : 0;
    
            return memo[index][sum] == 1;
        }
    public:
        bool canPartition(vector<int>& nums) {
    
            int sum = 0;
            for( int i = 0 ; i < nums.size() ; i ++ ){
                assert( nums[i] > 0 );
                sum += nums[i];
            }
    
            if( sum%2 ) {
                return false;
            }
    
            memo = vector<vector<int>>(nums.size(), vector<int>(sum/2+1,-1));
            return tryPartition(nums, nums.size()-1 , sum/2 );
        }
    };
    
复制代码

自底向上使用动态规划

class Solution {
    
    public:
        bool canPartition(vector<int>& nums) {
    
            int sum = 0;
            for( int i = 0 ; i < nums.size() ; i ++ ){
                assert( nums[i] > 0 );
                sum += nums[i];
            }
    
            if( sum%2 ) {
                return false;
            }
    
            int n = nums.size();
            int C = sum / 2;
            vector<bool> memo(C+1, false);
    
            for ( int i = 0; i <= C; i++ ) {
                memo[i] = ( nums[0] == i );
            }
    
            for ( int i = 1; i < n; i++ ) {
                for ( int j = C; j >= nums[i]; j-- ) {
                    memo[j] = memo[j] || memo[ j - nums[i] ];
                }
            }
    
            return memo[C];
        }
    };
    
复制代码

类似问题

leetcode 322
leetcode 377
leetcode 474
leetcode 139
leetcode 494

-------------------------华丽的分割线--------------------

看完的朋友能够点个喜欢/关注，您的支持是对我最大的鼓励。

我的博客番茄技术小栈和掘金主页

想了解更多，欢迎关注个人微信公众号：番茄技术小栈