leetcode笔记——背包问题总结1

这部分内容是参考大神CyC2018的代码和总结，将leetcode中和背包问题相关的放在这里。

1.字符串按单词列表分割
139. Word Break (Medium)

这个问题也可以使用背包问题的思路，把这个代码放在问题139中了。

2.划分数组为相等的两部分

416. Partition Equal Subset Sum (Medium)

题目：

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

注意:

    每个数组中的元素不会超过 100
    数组的大小不会超过 200

示例 1:

输入: [1, 5, 11, 5]

输出: true

解释: 数组可以分割成 [1, 5, 5] 和 [11].

 

示例 2:

输入: [1, 2, 3, 5]

输出: false

解释: 数组不能分割成两个元素和相等的子集.

思路：这个题可以看成是一个0-1背包问题。其中物品的总个数为数组的长度，每个元素的值为物品的质量，我们可以先求出整个数组的和sum，sum/2可以看成是背包的容量。使用一个一维的布尔数组dp[],dp[i]表示和i能否被数组中的元素表示。这种思路可以解决问题，但并不是最佳的解决方案，速度并不是最快的。

我自己写代码的时候，总是忘记给dp[0]赋初值，并且在写内层j的循环时，总是出错。。。要注意。   for(int j=sum/2;j>=nums[i-1];j--)里面是num[i-1],否则会出现数组越界的错误

代码：

class Solution {
    public boolean canPartition(int[] nums) {
      if(nums.length==1)
          return false;
        int n=nums.length;
        int sum=0;
        for(int i=0;i<n;i++){
            sum=sum+nums[i];
        }
        if(sum%2!=0)
            return false;
       boolean dp[]=new boolean[sum/2+1];
        dp[0]=true;
        for(int i=1;i<=n;i++){
            for(int j=sum/2;j>=nums[i-1];j--){
                dp[j]=dp[j]||dp[j-nums[i-1]];
            }
        }
        return dp[sum/2];
        
        
    }
}

3.改变一组数的正负号使得它们的和为一给定数

494. Target Sum (Medium)

题目：

给定一个非负整数数组，a1, a2, ..., an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。

返回可以使最终数组和为目标数 S 的所有添加符号的方法数。

示例 1:

输入: nums: [1, 1, 1, 1, 1], S: 3
输出: 5
解释:

-1+1+1+1+1 = 3
+1-1+1+1+1 = 3
+1+1-1+1+1 = 3
+1+1+1-1+1 = 3
+1+1+1+1-1 = 3

一共有5种方法让最终目标和为3。

注意:

    数组的长度不会超过20，并且数组中的值全为正数。
    初始的数组的和不会超过1000。
    保证返回的最终结果为32位整数。

思路：

子集和问题
给一个整数集合，问是否存在某个非空子集，使得子集内中的数字和为0
一个等价的问题是：给一个整数集合和另一个整数s，问是否存在某个非空子集，使得子集中的数字和为s。子集合加总问题可以想成是背包问题的一个特例。

这部分是需要一个数学的推导，我们可以将整个数组划分为两个部分，一部分是符号为正的P，一部分是符号为负的N，两者的和分别为，sum(P),sum(N).由题目可以满足情况S=sum(P)-sum(N).此时在等式的两边同时加上sum(P),sum(N),可以得到下面的式子：

S+sum(P)+sum(N)=sum(P)+sum(N)+sum(P)-sum（N）

即sum（P）=[S+sum(P+N)]/2

即整个问题转化成了我们需要在数组中找出一个子数组，使得这个子数组的和为[S+sum(P+N)]/2，可以看做是一个0-1背包问题。设置数组dp[i],表示和为i的情况下有多少种方法。

但是我不太懂问什么dp[0]=1?

我自己写代码的时候碰见的问题是没有注意到特殊的情况，即S的值比整个数组的和还要大，除此之外还有sum+S是个奇数，不能整除。

代码：

class Solution {
    public int findTargetSumWays(int[] nums, int S) {
        
        int n=nums.length;
        int sum=0;
        for(int i=0;i<n;i++){
            sum=sum+nums[i];
        }
        if(sum<S||(sum+S)%2!=0)
            return 0;
        int w=(sum+S)/2;
        int dp[]=new int[w+1];
        dp[0]=1;
        for(int i=1;i<=n;i++){
            for(int j=w;j>=nums[i-1];j--){
                dp[j]=dp[j]+dp[j-nums[i-1]];
            }
        }
        return dp[w];
        
    }
}

4.01字符构成最多的字符串

474. Ones and Zeroes (Medium)

题目：

在计算机界中，我们总是追求用有限的资源获取最大的收益。

现在，假设你分别支配着 m 个 0 和 n 个 1。另外，还有一个仅包含 0 和 1 字符串的数组。

你的任务是使用给定的 m 个 0 和 n 个 1 ，找到能拼出存在于数组中的字符串的最大数量。每个 0 和 1 至多被使用一次。

注意:

    给定 0 和 1 的数量都不会超过 100。
    给定字符串数组的长度不会超过 600。

示例 1:

输入: Array = {"10", "0001", "111001", "1", "0"}, m = 5, n = 3
输出: 4

解释: 总共 4 个字符串可以通过 5 个 0 和 3 个 1 拼出，即 "10","0001","1","0" 。

示例 2:

输入: Array = {"10", "0", "1"}, m = 1, n = 1
输出: 2

解释: 你可以拼出 "10"，但之后就没有剩余数字了。更好的选择是拼出 "0" 和 "1" 。

 

思路：

这个是一个多维费用的0~1背包问题，有两个背包大小，0和1的数量。

这个是我自己的一个理解：这里面是有两个背包，一个是装1的背包，这个背包的容量是m，另外一个是装0的背包，这个背包的容量是n。每一个字符串就相当于是一个物品，其中0或者1的个数就是它的重量。这个题就是两个背包问题。

这个参考了下leetcode中的评论思路。数组dp[k][i][j]表示的是前k个字符中的情况下i个0，j个1最多可以取多少个字符串。

代码：

这个是我自己写的一个。出现了几个错误，一个是以为strs是字符串，实际上是数组，这个在求长度是时候要注意。还有就是在统计字符串中0,1的个数时，不会使用把字符串转化为数组。

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
       if(strs==null||strs.length==0)
           return 0;
        int dp[][]=new int[m+1][n+1];
        for(String s:strs){
            int ones=0;
            int zeros=0;
            int h=s.length();
            for(int i=0;i<h;i++){
                if(s.charAt(i)=='1')
                    ones++;
                else
                    zeros++;
            }
            for(int i=m;i>=zeros;i--){
                for(int j=n;j>=ones;j--){
                    dp[i][j]=Math.max(dp[i][j],dp[i-zeros][j-ones]+1);
                }
            }
        }
        return dp[m][n];
    }
}

以下是更快的实现：

class Solution {
  public int findMaxForm(String[] strs, int m, int n) {
if (strs == null || strs.length == 0) {
return 0;
}
int[][] dp = new int[m + 1][n + 1];
for (String s : strs) { // 每个字符串只能用一次
int ones = 0, zeros = 0;
for (char c : s.toCharArray()) {
if (c == '0') {
zeros++;
} else {
ones++;
}
}
for (int i = m; i >= zeros; i--) {
for (int j = n; j >= ones; j--) {
dp[i][j] = Math.max(dp[i][j], dp[i - zeros][j - ones] + 1);
}
}
}
return dp[m][n];
}
}