DP

多重背包 多维度费用的背包
背包的解题思路
背包变型题

Author: h2pl

src/DP/背包/划分数组为和相等的两部分.java

@@ -0,0 +1,20 @@
+package DP.背包;
+
+/**
+ * Created by 周杰伦 on 2018/4/8.
+ */
+public class 多维费用的背包 {
+    //是01背包的延伸，费用变成了2维
+    //接下来的注释是背包问题的一般解法
+    public static int knapsack2(int W1,int W2, int N, int[][] weights, int[] values) {
+        int [][]dp = new int[W1 + 1][W2 + 1];
+        for (int i = 1; i <= N; i++) {
+            int w1 = weights[i - 1][0],w2 = weights[i - 1][1], v = values[i - 1];
+            for (int j = W1; j >= w1;j --) {
+                for (int k = W2;j >= w2;k -- )
+                dp[j][k] = Math.max(dp[j][k], dp[j - w1][k - w2] + v);
+            }
+        }
+        return dp[W1][W2];
+    }
+}

src/DP/背包/多维费用的背包.java

@@ -7,6 +7,7 @@
  */
 public class 多重背包 {
     //首先是正规解法，和完全背包类似。
+    //多重背包限制了每个物品的数量，介于01和完全背包之间。
     public static int knapsack(int W, int N, int[] weights, int[] values, int []nums) {
         int[][] dp = new int[N + 1][W + 1];
         //物品数为0时，取法初始化为0，代表不能装满，但是可以进行累加。因为不需要装满。

src/DP/背包/多重背包.java

@@ -1,4 +1,4 @@
-package DP;
+package DP.背包.字符串;
 
 /**
  * Created by 周杰伦 on 2018/4/3.

src/DP/分割整数构成字母字符串.java renamed to src/DP/背包/字符串/分割整数构成字母字符串.java

@@ -0,0 +1,38 @@
+package DP.背包.字符串;
+
+/**
+ * Created by 周杰伦 on 2018/4/8.
+ */
+public class 字符01构成最多的字符串 {
+    public static void main(String[] args) {
+        String []a = {"10", "0001", "111001", "1", "0"};
+        System.out.println(findMaxForm(a, 5, 3));
+    }
+    public static int findMaxForm(String[] strs, int m, int n) {
+        //代表i个0和j个1能够成最多的字符串个数
+        //首先写出矩阵
+        int [][]dp = new int[m + 1][n + 1];
+        dp[0][0] = 0;
+        //然后根据条件写一个商品的for循环
+        for (String str : strs) {
+            int needZero = 0;
+            int needOne = 0;
+            //再根据条件写费用的循环。
+            //可能是二维费用，则有两个循环。多重背包也类似
+            //如果是完全背包，则用顺序，01背包用逆序。
+
+            //该步相当于计算放入第i件物品所需的费用。
+            //因为是二维的，所以类比到01背包，在背包中就是重量和体积
+            for (int i = 0;i < str.length();i ++) {
+                if (str.charAt(i) == '0')needZero ++;
+                else needOne ++;
+            }
+            for (int j = m;j >= needZero;j --) {
+                for (int k = n;k >= needOne;k --) {
+                    dp[j][k] = Math.max(dp[j - needZero][k - needOne] + 1, dp[j][k]);
+                }
+            }
+        }
+        return dp[m][n];
+    }
+}

src/DP/背包/字符串/字符01构成最多的字符串.java

@@ -0,0 +1,53 @@
+package DP.背包.字符串;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Created by 周杰伦 on 2018/4/6.
+ */
+public class 字符串按单词列表分割 {
+    public static void main(String[] args) {
+        String s = "leetcode";
+        List<String> wordDict = new ArrayList<>();
+        wordDict.add("leet");
+        wordDict.add("code");
+        System.out.println(wordBreak(s,wordDict));
+    }
+    //该题与完全背包还是有差异的。解法比较巧妙,最好记着
+    public static boolean wordBreak(String s, List<String> wordDict) {
+        //dp[i] represents if s.substring(0, i) is wordbreakable.
+        boolean []dp = new boolean[s.length() + 1];
+        Arrays.fill(dp, false);
+        dp[0] = true;
+        for (int i = 1;i <= s.length();i ++) {
+            for (int j = 0;j < i;j ++) {
+                if (dp[j] && wordDict.contains(s.substring(j,i))) {
+                    dp[i] = true;
+                    break;
+                }
+            }
+        }
+        return dp[s.length()];
+    }
+    //这是一个完全背包问题，和 0-1 背包不同的是，完全背包中物品可以使用多次。
+    // 在这一题当中，词典中的单词可以被使用多次。
+
+    //0-1 背包和完全背包在实现上的不同之处是，0-1 背包对物品的迭代是在最外层，
+    // 而完全背包对物品的迭代是在最里层。
+    public boolean wordBreak2(String s, List<String> wordDict) {
+        int n = s.length();
+        boolean[] dp = new boolean[n + 1];
+        dp[0] = true;
+        for (int i = 1; i <= n; i++) {
+            for (String word : wordDict) { // 每个单词可以使用多次
+                int len = word.length();
+                if (len <= i && word.equals(s.substring(i - len, i))) {
+                    dp[i] = dp[i] || dp[i - len];
+                }
+            }
+        }
+        return dp[n];
+    }
+}

src/DP/背包/字符串/字符串按单词列表分割.java

@@ -17,6 +17,7 @@ public static void main(String[] args) {
     public static int knapsack(int W, int N, int[] weights, int[] values) {
 
         int[][] dp = new int[N + 1][W + 1];
+        //不用装满就设为0，需要装满的话，求最大值时设为负无穷，求最小值时设为正无穷。
         //物品数为0时，取法初始化为0，代表不能装满，但是可以进行累加。因为不需要装满。
         Arrays.fill(dp[0], 0);
         for (int i = 1; i <= N; i++) {

src/DP/背包/字符串按单词列表分割.java

@@ -35,7 +35,7 @@ public static int knapsack(int W, int N, int[] weights, int[] values) {
     // 优化一维
     public static int knapsack2(int W, int N, int[] weights, int[] values) {
         int []dp = new int[W + 1];
-        //前0个物品永远无法装满1-W重量的背包。置为负无穷，dp累加时只考虑前面已经装满的清空。
+        //前0个物品永远无法装满1-W重量的背包。置为负无穷，dp累加时只考虑前面已经装满的情况。
         Arrays.fill(dp, Integer.MIN_VALUE);
         //前0个物品刚好可以装满容量为0的背包，此时价值为0，以此为初始值进行累加。
         dp[0]= 0;

src/DP/背包/背包01不用装满.java

@@ -0,0 +1,66 @@
+package DP.背包.背包扩展;
+
+import java.sql.Array;
+import java.util.Arrays;
+
+/**
+ * Created by 周杰伦 on 2018/4/6.
+ */
+public class 划分数组为和相等的两部分 {
+    public static void main(String[] args) {
+        int []a = {1, 5, 11, 5};
+        System.out.println(canPartition2(a));
+    }
+    //优化版
+    //本题的背包重量就是和的一半。
+    //每个数都是一个物品的费用。
+    //于是得dp[i] = dp[i - num[i]] || dp[i]
+    //由于本题是判断能否加到一个和，所以只判断true和false
+    //如果是凑成的数量就是 + 1，如果是价值就是加v[i]
+    public static boolean canPartition2(int[] nums) {
+        int sum = 0;
+        for (int i : nums) {
+            sum += i;
+        }
+        if (sum % 2 != 0)return false;
+        sum = sum/2;
+        //代表前i个数选出的和可以累加为j。但是i可以选择拿或不拿。
+        boolean []dp = new boolean[sum + 1];
+        Arrays.fill(dp, false);
+        dp[0] = true;
+
+        for (int i = 0;i < nums.length;i ++) {
+            for (int j = sum;j >= nums[i];j --) {
+                dp[j] = dp[j] || dp[j - nums[i]];
+            }
+        }
+        return dp[sum];
+    }
+
+
+    public boolean canPartition(int[] nums) {
+        int sum = 0;
+        for (int i : nums) {
+            sum += i;
+        }
+        if (sum % 2 != 0)return false;
+        sum = sum/2;
+        //代表前i个数选出的和可以累加为j。但是i可以选择拿或不拿。
+        boolean [][]dp = new boolean[nums.length + 1][sum + 1];
+        for (int j = 0;j < nums.length + 1;j ++) {
+            Arrays.fill(dp[j], false);
+        }
+        dp[0][0] = true;
+        for (int i = 1;i <= nums.length;i ++) {
+            for (int j = 1;j <= sum;j ++) {
+                if (j >= nums[i - 1]) {
+                    dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i - 1]];
+                }else {
+                    dp[i][j] = dp[i - 1][j];
+                }
+            }
+        }
+        return dp[nums.length][sum];
+    }
+
+}