【背包问题】01背包

1.01背包（模板题）

01背包（模板题）

 思路：

代码：

#include <iostream>
#include<cstring>
using namespace std;
const int N = 1010;
int n, V;
int 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 = 0; j <= V; j++)
//         {
//             dp[i][j] = dp[i - 1][j];
//             if(j - v[i] >= 0)
//                 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 = 0; j <= V; j++)
//         {
//             dp[i][j] = dp[i - 1][j];
//             if(j - v[i] >= 0 && 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;
//     return 0;    
// }
//空间优化版本
int dp[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 = V; j >= v[i]; j--)
        {
                dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
        }
    }
    cout << dp[V] << endl;
    memset(dp, 0, sizeof dp);
    //初始化
    for(int i = 1; i <= V; i++) dp[i] = -1;
    for(int i = 1; i <= n; i++)
    {
        for(int j = V; j >= v[i]; j--)
        {
            if(dp[j - v[i]] != -1)
                dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
        }
    }
    cout << (dp[V] == -1 ? 0 : dp[V]) << endl;
    return 0;    
}

2.分割等和子集

分割等和子集

代码：

// class Solution {
// public:
//     bool canPartition(vector<int>& nums) {
//         int n = nums.size(), sum = 0;
//         for(auto& e : nums) sum += e;
//         if(sum % 2) return false;
//         int aim = sum / 2;
//         vector<vector<bool>> dp(n + 1, vector<bool>(aim + 1));
//         for(int i = 0; i <= n; i++) dp[i][0] = true;
//         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] >= 0)
//                     dp[i][j] = dp[i][j] || dp[i - 1][j - nums[i - 1]];
//             }
//         return dp[n][aim];
//     }
// };

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

 

3.目标和

目标和

代码：

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        // 设正数为a，负数的绝对值为b，a - b = target, a + b = sum -> a = (target + sum)/2 
        //转化：求从数组中选一些数，让这些数恰好等于a = (target + sum)/2 
        int n = nums.size(), sum = 0;
        for(auto e : nums) sum += e;
        int a = (target + sum) / 2;
        if(a < 0 || (sum + target) % 2) return 0; 
        vector<int> dp(a + 1);
        dp[0] = 1;
        for(int i = 1; i <= n; i++)
            for(int j = a; j >= nums[i - 1]; j--)
                dp[j] = dp[j] + dp[j - nums[i - 1]];
        return dp[a];
    }
};

 

4.最后一块石头的重量ii

最后一块石头的重量ii

代码：

class Solution {
public:
    int lastStoneWeightII(vector<int>& s) {
        //我们模拟这个石头粉碎过程，
        //发现其实只需要把数组中的每个数添加正号或负号得到的最终结果尽可能小即可
        //与目标和类似，设a为正号，b为负号 |a - b|尽可能小，a + b = sum
        //a - b越接近绝对值才可能越小，所以a越接近sum/2结果越小
        //转化：从数组中选择一些数，让这些数尽可能的接近sum / 2->01背包问题
        int n = s.size(), sum = 0;
        for(auto e : s) sum += e;
        int a = sum / 2;
        vector<int> dp(a + 1);
        for(int i = 1; i <= n; i++)
            for(int j = a; j >= s[i - 1]; j--)
                    dp[j] = max(dp[j], dp[j - s[i - 1]] + s[i - 1]);
        return sum - 2 * dp[a];//a 和 b -》a:dp[n][a], b:sum - dp[n][a] -> b - a = sum - 2 * dp[n][a]
    }
};