动态规划10 【模板】01背包, 分割等和子集, 目标和 , 最后一块石头的重量 II

DP41 【模板】01背包

问题一：求这个背包至多能装多大价值的物品？

1. 状态表示：经验+题目要求
   dp[i][j] 表示 从前i个物品中挑选，总体积不超过j，所有选法中，能选出来的最大价值。

2. 状态转移方程
   根据最后一步的状态：选还是不选
   如果不选：dp[i][j] = dp[i-1][ j ];
   如果选： dp[i][j] = w[i] + dp[ i-1 ][ j - v[i] ]; 但同时需要注意 j-v[i] 的大小，不能为负数。

3. 初始化
i为0，表示从前0个物品选，当然全为0；
j为0，表示从前i个物品选，总体积不超过0，也全为0；

4. 填表顺序

从上往下

    for(int i = 1; i<=n; i++)
    {
        for(int j = 1; j<=V; j++)
        {
            dp[i][j] = dp[i-1][j];
            if(j >= v[i]) dp[i][j] = max(dp[i][j],dp[i-1][j-v[i]] + w[i]);
        }
    }

问题二：若背包恰好装满，求至多能装多大价值的物品？

1. 状态表示：经验+题目要求
   dp[i][j] 表示 从前i个物品中挑选，总体积正好等于j，所有选法中，能选出来的最大价值。

2. 状态转移方程
   根据最后一步的状态：选还是不选，同时当无法体积为j的时候，就令值为-1；
   如果不选：dp[i][j] = dp[i-1][ j ]; 不用考虑等不等于-1
   如果选： dp[i][j] = w[i] + dp[ i-1 ][ j - v[i] ]; 但同时需要注意 j-v[i] 的大小，不能为负数。
   同时需要注意dp[i-1][ j - v[i] ]不为-1

3. 初始化
   i为0，表示从前0个物品选，总体积正好等于 j ，除了0后面全为-1；
   j为0，表示从前i个物品选，总体积正好为0，也全为0；
   

4. 填表顺序
   从上到下

#include <cstring>
#include <iostream>
#include<string>
using namespace std;

const int N = 1010;

int n, V, v[N], w[N];
int dp[N][N];

int main() {
    //读入数据
    cin >> n >> V;
    for(int i = 1; i<=n; i++)
        cin >> v[i] >> w[i];

    for(int i = 1; i<=n; i++)
    {
        for(int j = 1; j<=V; j++)
        {
            dp[i][j] = dp[i-1][j];
            if(j >= v[i]) dp[i][j] = max(dp[i][j],dp[i-1][j-v[i]] + w[i]);
        }
    }

    cout << dp[n][V] << endl;

    memset(dp, 0, sizeof dp);
    for(int i = 1; i<=V; i++) dp[0][i] = -1;
    for(int i = 1; i<=n; i++)
    {
        for(int j = 1; j<=V; j++)
        {
            dp[i][j] = dp[i-1][j];
            if(j >= v[i] && dp[i-1][j-v[i]] != -1) 
                dp[i][j] = max(dp[i][j],dp[i-1][j-v[i]] + w[i]);
        }
    }
    cout<< (dp[n][V] == -1 ? 0 : dp[n][V]) <<endl;

}
// 64 位输出请用 printf("%lld")

416. 分割等和子集

实际上这也是背包问题，判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等 就是 判断能否从里面取一定的数，满足体积为数组和的一半。

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int num = 0;
        for(int i = 0; i<nums.size(); i++)
            num += nums[i];
        int mid = num/2;
        if(num % 2) return false;

        vector<vector<bool>> dp(nums.size()+1,vector<bool>(mid + 1));
        for(int i = 0;i < nums.size()+1; i++) dp[i][0] = true;

        for(int i = 1; i<nums.size() + 1; i++)
        {
            for(int j = 1; j<mid+1; j++)
            {
                dp[i][j] = dp[i-1][j];
                if(j >= nums[i-1])
                    dp[i][j] = dp[i][j] || dp[i-1][j-nums[i-1]];
            }
        }

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

494. 目标和

分析： a为所有带正号的和，b为所有带负号和的绝对值

所以题目就会变为了背包问题。

1. 状态表示：经验+题目要求
   dp[i][j] 表示 从前i个数中挑选，总体积正好等于j，一共多少种选法。
2. 状态转移方程
   根据最后一步的状态：选还是不选
   如果不选：dp[i][j] = dp[i-1][ j ];
   如果选： dp[i][j] = dp[ i-1 ][ j - v[i] ]; 但同时需要注意 j-v[i] 的大小，不能为负数。
   不需要加上这个本身的数字，因为我们这里表示的是多少种选法。

3. 初始化
   i为0，表示从前0个数字选，当j为0时候，dp为1，其他时候都为0；
   j为0，表示从前i个数字选，总体积正好0，这个无法确定，所以就不用初始化，当表直接填就可以。
   
4. 填表顺序

从上往下

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int n = nums.size();
        int sum = 0;
        for(auto x : nums) sum+=x;
        if((sum + target) %2 == 1 || (sum + target) < 0) return 0;
        int aim = (sum + target)/2;
        vector<vector<int>> dp(n+1,vector<int>(aim+1));
        dp[0][0] = 1;
        for(int i = 1; i<=n; i++)
        {
            for(int j = 0; j<=aim; j++)
            {
                dp[i][j] = dp[i-1][j];
                if(j >= nums[i-1])
                    dp[i][j] = dp[i][j] + dp[i-1][j-nums[i-1]];
            }
        }
        return dp[n][aim];
    }
};

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

仔细看的话，其实这道题和目标和问题一样，都是添加正负号

转化：在数组种选择一些数，让这些数尽可能接近 sum/2;

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int n = stones.size();
        int sum = 0;
        for(auto x : stones) sum+=x;
        int aim = sum/2;
        vector<vector<int>> dp(n+1,vector<int>(aim+1));
        for(int i = 1; i<=n; i++)
        {
            for(int j = 0; j<=aim; j++)
            {
                dp[i][j] = dp[i-1][j];
                if(j >= stones[i-1])
                    dp[i][j] = max(dp[i][j], dp[i-1][j-stones[i-1]] + stones[i-1]);
            }
        }
        return sum - 2*dp[n][aim];
    }
};