动态规划之背包问题（01背包、完全背包）

一、01背包

有n件物品和一个最多能背重量为w 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次（物品只有一件，放或不放，为01背包问题），求解将哪些物品装入背包里物品价值总和最大。

#include<bits/stdc++.h>
using namespace std;
int begvalue(int n,vector<int> &weight,vector<int> &value)
{
    int m=weight.size();
    vector<vector<int>> dp(m,vector<int>(n+1,0));  //二维数组dp
    //初始化
    for(int j=weight[0];j<=n;j++)
    dp[0][j]=value[0];
    //
    for(int p=1;p<m;p++)
    {
        for(int q=1;q<=n;q++)
        {
            if (q < weight[p]) dp[p][q] = dp[p - 1][q]; //装不下
            else dp[p][q]=max(dp[p-1][q],dp[p-1][q-weight[p]]+value[p]);  //装得下
        }
    }
    return dp[m-1][n];
    
}
int main()
{
    int m,n;
    cin>>m>>n;
    vector<int> weight(m);
    vector<int> value(m);
    for(int i=0;i<m;i++)
    {
        cin>>weight[i];
    }
    for(int j=0;j<m;j++)
    {
        cin>>value[j];
    }
    cout<< begvalue(n,weight,value);
    return 0;
}

优化为一维数组：

#include<bits/stdc++.h>
using namespace std;
int begvalue(int n,vector<int> &weight,vector<int> &value)
{
    int m=weight.size();
    vector<int> dp(n+1,0);  //一维数组，dp[j]：最大承重为j的背包所背的最大价值
    //
    for(int i=0;i<m;i++)
    {
//只有当前背包容量j不小于第i个物品的重量weight[i]，才能放入
        for(int j=n;j>=weight[i];j--) //倒序遍历，防止一个物品被重复放入
        {
            dp[j]=max(dp[j],dp[j-weight[i]]+value[i]);
        }
    }
    return dp[n];
    
}
int main()
{
    int m,n;
    cin>>m>>n;
    vector<int> weight(m);
    vector<int> value(m);
    for(int i=0;i<m;i++)
    {
        cin>>weight[i];
    }
    for(int j=0;j<m;j++)
    {
        cin>>value[j];
    }
    cout<< begvalue(n,weight,value);
    return 0;
}

01背包问题举例之 leetcode474

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的长度，该子集中 最多 有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。

示例 1：

输入：strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3
输出：4
解释：最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001","1","0"} ，因此答案是 4 。
其他满足题意但较小的子集包括 {"0001","1"} 和 {"10","1","0"} 。{"111001"} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。

示例 2：

输入：strs = ["10", "0", "1"], m = 1, n = 1
输出：2
解释：最大的子集是 {"0", "1"} ，所以答案是 2 。

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>> dp (m+1,vector<int>(n+1,0));
        for(string str: strs)
        {
            int zeronum=0;  //这两个应写在循环里面，保证遍历新的字符串时能够重新统计计数
            int onenum=0;
            for(char c: str)
            {
                if (c=='1')
                onenum++;
                else zeronum++;
            }
            for(int i=m;i>=zeronum;i--)
            {
                for(int j=n;j>=onenum;j--)
               {
                dp[i][j]=max(dp[i][j],dp[i-zeronum][j-onenum]+1);
               }
            }
        }
        return dp[m][n];
    }
};

二、完全背包

有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品都有无限个（物品有无限个，可以放入背包多次，为完全背包问题），求解将哪些物品装入背包里物品价值总和最大。

#include<bits/stdc++.h>
using namespace std;
int maxvalue(int n,vector<int> &weight,vector<int> &value)
{
    vector<int> dp(n+1,0);//dp[j]:最大承重为j的背包所背的最大价值
    for(int i=0;i<weight.size();i++)
    {
        for(int j=weight[i];j<=n;j++)  //与01背包的区别
        {
            dp[j]=max(dp[j],dp[j-weight[i]]+value[i]);
        }
    }
    return dp[n];
}
int main()
{
    int m,n;
    cin>>m>>n; //m:种类，n:背包容量
    vector<int> weight(m);
    vector<int> value(m);
    for(int i=0;i<m;i++)
    {
        cin>>weight[i]>>value[i];
    }
    cout<<maxvalue(n,weight,value);
    return 0;
}

leetcode279.完全平方数

给你一个整数 n ，返回 和为 n 的完全平方数的最少数量 。

示例 1：

输入：n = 12
输出：3 
解释：12 = 4 + 4 + 4

示例 2：

输入：n = 13
输出：2
解释：13 = 4 + 9

class Solution {
public:
    int numSquares(int n) {
        vector<int> dp(n+1,10001);//dp[j]:和为n的物品（完全平方数）的最少个数，value:1,4,9,16...
        dp[0]=0;
        vector<int> num(100);
        for(int k=1;k<=100;k++)
        num.push_back(k*k);
        for(int i=0;i<num.size();i++)
        {
            for(int j=num[i];j<=n;j++)
            dp[j]=min(dp[j],dp[j-num[i]]+1);  //状态方程
            
        }
        return dp[n];
    }
};

leetcode139.单词拆分

给你一个字符串 s 和一个字符串列表 wordDict 作为字典。如果可以利用字典中出现的一个或多个单词拼接出 s 则返回 true。

注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。

示例 1：

输入: s = "leetcode", wordDict = ["leet", "code"]
输出: true
解释: 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。

示例 2：

输入: s = "applepenapple", wordDict = ["apple", "pen"]
输出: true
解释: 返回 true 因为 "applepenapple" 可以由 "apple" "pen" "apple" 拼接成。
     注意，你可以重复使用字典中的单词。

示例 3：

输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
输出: false

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> wordset(wordDict.begin(),wordDict.end());//无序set存放字典里的单词
        vector<bool> dp(s.size()+1,false); 
        //先遍历背包再遍历物品
        dp[0]=true;  //初始化
        for(int i=1;i<=s.size();i++)
        {
            for(int j=0;j<i;j++)
            {
                string word=s.substr(j,i-j);//拆分s，截取从j开始的i-j个字符
                if(wordset.find(word)!=wordset.end() && dp[j])  //在字典中找到而且前一个word也找到
                dp[i]=true;
            }
        }
        return dp[s.size()];

    }
};