DP

背包问题集锦
01背包 二维 一维 要求满 不要求满
完全背包 二维 一维 3次循环 2次循环 放满 不放满
多重背包 二维 一维 3循环 2循环利用01背包 最后一种是根据情况选择完全背包和01背包

Author: h2pl

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

@@ -0,0 +1,35 @@
+package DP.背包;
+
+import java.sql.Array;
+import java.util.Arrays;
+
+/**
+ * Created by 周杰伦 on 2018/4/6.
+ */
+public class 划分数组为和相等的两部分 {
+    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];
+    }
+
+}

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

@@ -0,0 +1,99 @@
+package DP.背包;
+
+import java.util.Arrays;
+
+/**
+ * Created by 周杰伦 on 2018/4/7.
+ */
+public class 多重背包 {
+    //首先是正规解法，和完全背包类似。
+    public static int knapsack(int W, int N, int[] weights, int[] values, int []nums) {
+        int[][] dp = new int[N + 1][W + 1];
+        //物品数为0时，取法初始化为0，代表不能装满，但是可以进行累加。因为不需要装满。
+        Arrays.fill(dp[0], 0);
+        for (int i = 1; i <= N; i++) {
+            int w = weights[i - 1], v = values[i - 1];
+            for (int j = w; j <= W; j++) {
+                for (int k = 1;k <= nums[i];i ++) {
+                    if (j >= k * w) {
+                        // 那只是一种理解方法，其实正规的应该是这样的
+                        // dp[i][j] = max ( dp[i-1][j - k*weight[i]] +k*value[i] )0<=k<=nums[i]
+                        // （这个跟完全背包差点就一毛一样了啊喂|||- -）
+                        dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - k * w] + k * v);
+                    } else {
+                        dp[i][j] = dp[i - 1][j];
+                    }
+                }
+            }
+        }
+        return dp[N][W];
+    }
+
+    //根据01背包进行优化
+    //首先这种可以把物品拆开，把相同的num[i]件物品 看成
+    // 价值跟重量相同的num[i]件不同的物品，那么！！
+    // 是不是就转化成了一个规模稍微大一点的01背包了。对不对！！对不对！！
+    public static int knapsack2(int W, int N, int[] weights, int[] values, int []nums) {
+        int []dp = new int[W + 1];
+        for (int i = 1; i <= N; i++) {
+            int w = weights[i - 1], v = values[i - 1];
+            //其实就是把这类物品展开，调用num[i]次01背包代码
+            for (int k = 1;k <= nums[i];k ++) {
+                for (int j = W; j >= w; j--) {
+                    ////正常的01背包代码
+                    dp[j] = Math.max(dp[j], dp[j - w] + v);
+                }
+            }
+        }
+        return dp[W];
+    }
+
+    //最优化的多重背包。
+    //第i件物品若满足总数*重量小于背包重量，即可用完全背包来解。
+    //若不满足，则按照1 2 4的二进制速度上升。复杂度为log2n
+    int Multi_Pack(int wegihts[],int values[],int nums[],int N,int W)//多重背包
+    {
+        int []dp = new int[N + 1];
+        for(int i=1; i<=N; i++)//遍历每种物品
+        {
+            if(nums[i]*wegihts[i] > W)
+                Complete_Pack(wegihts[i],values[i],W,dp);
+                //如果全装进去已经超了重量，相当于这个物品就是无限的
+                //因为是取不光的。那么就用完全背包去套
+            else
+            {
+                int k = 1;
+                //取得光的话，去遍历每种取法
+                //这里用到是二进制思想，降低了复杂度
+                //为什么呢，因为他取的1,2,4,8...与余数个该物品，打包成一个大型的该物品
+                //这样足够凑出了从0-k个该物品取法
+                //把复杂度从k变成了logk
+                //如k=11，则有1,2,4,4，足够凑出0-11个该物品的取法
+                while(k < nums[i])
+                {
+                    ZeroOne_Pack(k*wegihts[i],k*values[i],W,dp);
+                    nums[i] -= k;
+                    k <<= 1;
+                }
+                //如果这一次装k个的空间不够了，就把该价值剩下的物品装进去
+                ZeroOne_Pack(nums[i]*wegihts[i],nums[i]*values[i],W,dp);
+            }
+        }
+        return dp[W];
+    }
+
+    void ZeroOne_Pack(int weight,int value,int W,int []dp)//吧01背包封装成函数
+    {
+        for(int i=W; i>=weight; i--)
+            dp[i] = Math.max(dp[i],dp[i-weight] + value);
+    }
+
+    void Complete_Pack(int weight,int value,int W,int []dp)//把完全背包封装成函数
+    {
+        for(int i=weight; i<=W; i++)
+            dp[i] = Math.max(dp[i],dp[i-weight] + value);
+    }
+
+
+
+}

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

@@ -0,0 +1,12 @@
+package DP.背包;
+
+import java.util.List;
+
+/**
+ * Created by 周杰伦 on 2018/4/6.
+ */
+public class 字符串按单词列表分割 {
+    public boolean wordBreak(String s, List<String> wordDict) {
+        return true;
+    }
+}

src/DP/背包/完全背包.java

@@ -0,0 +1,78 @@
+package DP.背包;
+
+import java.util.Arrays;
+
+/**
+ * Created by 周杰伦 on 2018/4/6.
+ */
+public class 完全背包 {
+    //基本解法
+    //三重循环，效率低
+    public int knapsack(int W, int N, int[] weights, int[] values) {
+        int[][] dp = new int[N + 1][W + 1];
+        for (int i = 1; i <= N; i++) {
+            int w = weights[i - 1], v = values[i - 1];
+            for (int j = 1; j <= W; j++) {
+                for (int k = 0;k <= j/w;k ++) {
+                    if (j >= k * w) {
+                        dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - k * w] + k * v);
+                    } else {
+                        dp[i][j] = dp[i - 1][j];
+                    }
+                }
+            }
+        }
+        return dp[N][W];
+    }
+
+    //转化为01背包的解法
+    //即F[i][j]=F[i][j-C[i]]+W[i]。为什么会是F[i][j-C[i]]+W[i]？
+    // 因为我们前面已经最大限度的放了第i件物品,如果能放就放这最后的一件,
+    //j的循环要正序，因为完全背包的第i个物品出现会影响前面的值。
+    //即前面的值需要修改，以便于影响后面的值。
+    public int knapsack03(int W, int N, int[] weights, int[] values) {
+        int[][] dp = new int[N + 1][W + 1];
+        for (int i = 1; i <= N; i++) {
+            int w = weights[i - 1], v = values[i - 1];
+            for (int j = w; j <= W; j++) {
+                if (j >= w) {
+                    //注意和01背包的区别,这里是dp[i][j-need[i]]+value[i]
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - w] + v);
+                } else {
+                    dp[i][j] = dp[i - 1][j];
+                }
+            }
+        }
+        return dp[N][W];
+    }
+
+    //优化成一维后解法 不必装满
+    public int knapsack2(int W, int N, int[] weights, int[] values) {
+        int[]dp = new int[W + 1];
+        for (int i = 1; i <= N; i++) {
+            int w = weights[i - 1], v = values[i - 1];
+            for (int j = w; j <= W; j ++) {
+                if (j >= w) {
+                    dp[j] = Math.max(dp[j], dp[j - w] + v);
+                }
+            }
+        }
+        return dp[W];
+    }
+
+    //优化成一维后解法 必须装满
+    public int knapsack3(int W, int N, int[] weights, int[] values) {
+        int[]dp = new int[W + 1];
+        Arrays.fill(dp, Integer.MIN_VALUE);
+        dp[0] = 0;
+        for (int i = 1; i <= N; i++) {
+            int w = weights[i - 1], v = values[i - 1];
+            for (int j = w; j <= W; j ++) {
+                if (dp[j - w] != Integer.MIN_VALUE) {
+                    dp[j] = Math.max(dp[j], dp[j - w] + v);
+                }
+            }
+        }
+        return dp[W];
+    }
+}

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

@@ -0,0 +1,49 @@
+package DP.背包;
+
+import java.util.Arrays;
+
+/**
+ * Created by 周杰伦 on 2018/4/6.
+ */
+public class 背包01不用装满 {
+    public static void main(String[] args) {
+        int N = 3;
+        int W = 10;
+        int w[] = {3, 4, 5};
+        int v[] = {4, 5, 6};
+        System.out.println(knapsack(W,N,w,v));
+        System.out.println(knapsack2(W,N,w,v));
+    }
+    public static int knapsack(int W, int N, int[] weights, int[] values) {
+
+        int[][] dp = new int[N + 1][W + 1];
+        //物品数为0时，取法初始化为0，代表不能装满，但是可以进行累加。因为不需要装满。
+        Arrays.fill(dp[0], 0);
+        for (int i = 1; i <= N; i++) {
+            int w = weights[i - 1], v = values[i - 1];
+            for (int j = 1; j <= W; j++) {
+                if (j >= w) {
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - w] + v);
+                } else {
+                    dp[i][j] = dp[i - 1][j];
+                }
+            }
+        }
+        return dp[N][W];
+    }
+
+    // 优化一维 只对一维有这个要求
+    //01背包每个物品只装一次，所以后面的结果不影响前面的结果。j应该逆序来算。
+    //如果正序来算，后面的循环中可能会修改前面的值，这是不被允许的，因为一个物品只放一次。
+    //后面的循环是不能改前面的值的。
+    public static int knapsack2(int W, int N, int[] weights, int[] values) {
+        int []dp = new int[W + 1];
+        for (int i = 1; i <= N; i++) {
+            int w = weights[i - 1], v = values[i - 1];
+            for (int j = W; j >= w; j --) {
+                dp[j] = Math.max(dp[j], dp[j - w] + v);
+            }
+        }
+        return dp[W];
+    }
+}

src/DP/背包/背包01需要装满.java

@@ -0,0 +1,51 @@
+package DP.背包;
+
+import java.util.Arrays;
+
+/**
+ * Created by 周杰伦 on 2018/4/7.
+ */
+public class 背包01需要装满 {
+    public static void main(String[] args) {
+        int N = 3;
+        int W = 10;
+        int w[] = {3, 4, 5};
+        int v[] = {4, 5, 6};
+        System.out.println(knapsack(W,N,w,v));
+        System.out.println(knapsack2(W,N,w,v));
+    }
+    public static int knapsack(int W, int N, int[] weights, int[] values) {
+
+        int[][] dp = new int[N + 1][W + 1];
+        //前0个物品永远无法装满1-W重量的背包。置为负无穷，dp累加时只考虑前面已经装满的清空。
+        Arrays.fill(dp[0], Integer.MIN_VALUE);
+        //前0个物品刚好可以装满容量为0的背包，此时价值为0，以此为初始值进行累加。
+        dp[0][0] = 0;
+        for (int i = 1; i <= N; i++) {
+            int w = weights[i - 1], v = values[i - 1];
+            for (int j = w; j <= W; j++) {
+                if (j >= w && dp[i - 1][j - w] != Integer.MIN_VALUE) {
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - w] + v);
+                }
+            }
+        }
+        return dp[N][W];
+    }
+
+    // 优化一维
+    public static int knapsack2(int W, int N, int[] weights, int[] values) {
+        int []dp = new int[W + 1];
+        //前0个物品永远无法装满1-W重量的背包。置为负无穷，dp累加时只考虑前面已经装满的清空。
+        Arrays.fill(dp, Integer.MIN_VALUE);
+        //前0个物品刚好可以装满容量为0的背包，此时价值为0，以此为初始值进行累加。
+        dp[0]= 0;
+        for (int i = 1; i <= N; i++) {
+            int w = weights[i - 1], v = values[i - 1];
+            for (int j = W; j >= w; j --) {
+                if (dp[j - w] != Integer.MIN_VALUE) {
+                    dp[j] = Math.max(dp[j], dp[j - w] + v);
+                }}
+        }
+        return dp[W];
+    }
+}