文章目录

• 1、01背包
• 2、分割等和子集
• 3、目标和
• 4、最后一块石头的重量 II

1、01背包

#include <iostream>
#include<vector>
using namespace std;

int main()
{
    int n,v;
    cin>>n>>v;
    vector<int> Weight(n+1);
    vector<int> Value(n+1);
    vector<int> dp1(v+1); 
    vector<int> dp2(v+1); 
    for(int i=1;i<=n;i++)
        cin>>Weight[i]>>Value[i];
    //（1）求这个背包至多能装多大价值的物品？
    for(int i=1;i<=n;i++)
    {//使用滚动数组进行优化
        for(int j=v;j-Weight[i]>=0;j--)
            dp1[j]=max(dp1[j-Weight[i]]+Value[i],dp1[j]);
    }
    cout<<dp1[v]<<endl;
    //（2）若背包恰好装满，求至多能装多大价值的物品？
    for(int j=1;j<=v;j++)
        dp2[j]=-1;
     for(int i=1;i<=n;i++)
    {//使用滚动数组进行优化
        for(int j=v;j-Weight[i]>=0;j--)
        {
            if(dp2[j-Weight[i]]!=-1)
                dp2[j]=max(dp2[j-Weight[i]]+Value[i],dp2[j]);
        }
    }
    if(dp2[v]==-1)
    {
        int a=0;
        cout<<a;
    }
    else
        cout<<dp2[v];
    return 0;
}

2、分割等和子集

给定一个非空的正整数数组 nums ，请判断能否将这些数字分成元素和相等的两部分。

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

3、目标和

给定一个正整数数组 nums 和一个整数 target 。
向数组中的每个整数前添加 ‘+’ 或 ‘-’ ，然后串联起所有整数，可以构造一个 表达式 ：
例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1” 。
返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int n=nums.size();
        int sum=0;
        for(auto& a:nums)
            sum+=a;
        int a=(sum+target)/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

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。
每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：
如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        //取出sum/2的值，就是最小值了，最后结果就是sum-2*(sum/2能凑出来的最大值)
        int n=stones.size();
        int sum=0;
        for(auto &a :stones)
            sum+=a;
        int m=sum/2;
        vector<int>dp(m+1);
        for(int i=1;i<=n;i++)
        {
            for(int j=m;j>=stones[i-1];j--)
            {
                dp[j]=max(dp[j],dp[j-stones[i-1]]+stones[i-1]);
            }
        }
        return sum-2*dp[m];
    }
};