dp背包问题总结

转自leetcode题解回答：[Jackie.YL]

常见的背包问题分为三种：

• 组合问题：如：

  给定不同面额的硬币和一个总金额。写出函数来计算可以凑成总金额的硬币组合数。假设每一种面额的硬币有无限个。

  377. 组合总和 Ⅳ
  494. 目标和
  518. 零钱兑换 II

• true false问题

  如给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

  139. 单词拆分
  416. 分割等和子集

• 最大最小问题

  即给定背包容量与价值，怎样才能将装进背包的物品的价值最大化或最小化。

  474. 一和零
  322. 零钱兑换

组合问题公式

dp[i] += dp[i-num]

True、False问题公式

dp[i] = dp[i] or dp[i-num]

最大最小问题公式

dp[i] = min(dp[i], dp[i-num]+1)或者dp[i] = max(dp[i], dp[i-num]+1)

以上三组公式是解决对应问题的核心公式。

当然拿到问题后，需要做到以下几个步骤：
1.分析是否为背包问题。
2.是以上三种背包问题中的哪一种。
3.是0-1背包问题还是完全背包问题。也就是题目给的nums数组中的元素是否可以重复使用。
4.如果是组合问题，是否需要考虑元素之间的顺序。需要考虑顺序有顺序的解法，不需要考虑顺序又有对应的解法。

接下来讲一下背包问题的判定
背包问题具备的特征：给定一个target，target可以是数字也可以是字符串，再给定一个数组nums，nums中装的可能是数字，也可能是字符串，问：能否使用nums中的元素做各种排列组合得到target。

背包问题技巧：
1.如果是0-1背包，即数组中的元素不可重复使用，nums放在外循环，target在内循环，且内循环倒序；

for num in nums:
    for i in range(target, nums-1, -1):

2.如果是完全背包，即数组中的元素可重复使用，nums放在外循环，target在内循环。且内循环正序。

for num in nums:
    for i in range(nums, target+1):

3.如果组合问题需考虑元素之间的顺序，需将target放在外循环，将nums放在内循环。

for i in range(1, target+1):
    for num in nums:

例题：

组合

注意区分零钱兑换||与组合总和4两个问题是不一样的，零钱兑换对组合顺序无要求，而组合总和对组合顺序还有要求不同也算，而这种不同只需要代码进行内外层循环互换一下即可。

518. 零钱兑换 II

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        int* dp = new int[amount+1];
        memset(dp,0,sizeof(int)*(amount+1));
        dp[0] = 1;

        for (int i = 0;i!=coins.size();i++) {
            for (int j = coins[i];j<=amount;j++) {
                dp[j] += dp[j-coins[i]];
            }
        }
        return dp[amount];
    }
};

494. 目标和

这个题还是比较神奇的，换一个角度来看这道题转化为了一个标准的01背包问题：

把所有符号为正的数总和设为一个背包的容量，容量为x；把所有符号为负的数总和设为一个背包的容量，容量为y。在给定的数组中，有多少种选择方法让背包装满。令sum为数组的总和，则x+y = sum。而两个背包的差为S,则x-y=S。从而求得x=(S+sum)/2。
基于上述分析，题目转换为背包问题：给定一个数组和一个容量为x的背包，求有多少种方式让背包装满。

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int S) {
        long long sum = 0;
        for (int i = 0;i!=nums.size();i++) {
            sum+=nums[i];
        }
        if ((S+sum)%2!=0) return 0;
        if (S>sum) return 0;

        long long len = (S+sum)/2;
        long long* dp = new long long[len+1];//dp数组的意义为使用nums的数凑成的方法数
        //int dp[len+1] = {0};
        memset(dp,0,sizeof(long long)*(len+1));
        dp[0] = 1;

        for (int i = 0;i!=nums.size();i++) {
            for (int j=len;j>=nums[i];j--) {
                dp[j] += dp[j-nums[i]];
            }
        }
        return dp[len];
    }
};

377. 组合总和 Ⅳ

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        int N = nums.size();
        if(N==0)
            return 0;
        vector<unsigned long long> dp(target+1,0);
        dp[0] = 1;
        for(int i = 1;i<=target;i++){
            for(int j = 0;j<N;j++){
                dp[i] += ( (i-nums[j]>=0) ? dp[i-nums[j]] : 0);//当i==nums[j]时，以nums[j]为结尾的所有排列就一个啊，所以可知直接使dp[0]=1实现这一目的
            }
        }
        return dp[target];
    }
};

最大值最小值问题

474. 一和零

dp数组含义：dp[i][j代表使用i个0与j个1所能拼出的最多的字符串数量

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>> dp(m+1,vector<int>(n+1));

        vector<int> zero(strs.size(),0);
        vector<int> one(strs.size(),0);
        for (int i = 0;i<strs.size();i++) {
            for (int j = 0;j<strs[i].size();j++) {
                if (strs[i][j]=='0') zero[i]++;
                else one[i]++;
            }
        }
        for (int k = 0;k!=strs.size();k++){
            for (int i = m;i>=0;i--) {
                for (int j = n;j>=0;j--) {
                    if (i>=zero[k]&&j>=one[k]) dp[i][j] = max(dp[i-zero[k]][j-one[k]]+1,dp[i][j]);
                }
            }
        }

        return dp[m][n];
    }
};

322. 零钱兑换

求最小数量，min

当 i0i0 时无法用硬币组成，为 0 。当 i<0i<0 时，忽略 F(i)F(i)

F(i) 最小硬币数量
F(0) 0 //金额为0不能由硬币组成
F(1) 1 //F(1)=min(F(1-1),F(1-2),F(1-5))+1=1F(1)=min(F(1−1),F(1−2),F(1−5))+1=1
F(2) 1 //F(2)=min(F(2-1),F(2-2),F(2-5))+1=1F(2)=min(F(2−1),F(2−2),F(2−5))+1=1
F(3) 2 //F(3)=min(F(3-1),F(3-2),F(3-5))+1=2F(3)=min(F(3−1),F(3−2),F(3−5))+1=2
F(4) 2 //F(4)=min(F(4-1),F(4-2),F(4-5))+1=2F(4)=min(F(4−1),F(4−2),F(4−5))+1=2
… …
F(11) 3 //F(11)=min(F(11-1),F(11-2),F(11-5))+1=3F(11)=min(F(11−1),F(11−2),F(11−5))+1=3

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        sort(coins.begin(),coins.end());

        vector<int> dp(amount+1,amount+1);

        int N = coins.size();
        dp[0] = 0;
        for (int i = 0;i<N;i++) {
            for (int j = coins[i];j<=amount;j++) {
                dp[j] = min(dp[j],dp[j-coins[i]]+1);
            }
        }
        return dp[amount]>=amount+1?-1:dp[amount];
    }
};

ture false 问题

416. 分割等和子集

这个不能求子集，测试用例会卡住，dp直接照搬给出的套路即可，这是一个01背包问题凑数，记得在前面加上数组和的判定可以直接返回false。dp数组的含义为dp[i]该子集能否凑出i

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum=0;
        int N = nums.size();
        //sort(nums.begin(),nums.end());
        for (int i = 0;i<N;i++) {
            sum+=nums[i];
        }
        if (sum%2==1) return false;
        vector<bool> dp(sum/2+1,false);
        dp[0] = true;

        for (int i = 0;i!=nums.size();i++) {
            for (int j = sum/2;j>=nums[i];j--) {
                dp[j] = dp[j]||dp[j-nums[i]];
            }
        }
        //vector<int> track;
        //backtrack(nums,0,0,sum);
        return dp[sum/2];
    }
};

139. 单词拆分

dp数组的含义为dp[i]，s的前i个字符能否能够由字典里的字符串组成。

class Solution {
public:
    int check(int i,string word,string s) {
        for (int j = 0;j!=word.size();j++) {
            if (s[j+i]!=word[j]) return 0;
        }
        return 1;
    }
    bool wordBreak(string s, vector<string>& wordDict) {
        vector<bool> dp(s.size()+1,false);
        dp[0] = true;

        int N = s.size();
        int M = wordDict.size();
        for (int i = 0;i<=N;i++) {
            for (int j = 0;j<M;j++) {
                if (dp[i]&&check(i,wordDict[j],s)) dp[i+wordDict[j].size()] = true;
            }
        }

        //return check(0,wordDict[0],s);
        return dp[N];
    }
};