@@ -821,7 +821,205 @@ public int fib(int n){
821821
822822
823823
824- ### 2. 0-1背包问题
824+ ### 2. 背包问题
825+
826+ 先得到该问题的局部解然后扩展到全局问题解。
827+
828+ 我们可以假设一个B(k,C) 方法,第k件物品,当前背包所剩下的容量C(初始则C=W)情况下,能够偷的最大价值量。
829+
830+ B( i , c ) = max{ F( i - 1 , C ) , v(i) + F( i - 1, C - w[ i] ) };
831+
832+ #### (1)记忆化搜索
833+
834+ ``` java
835+ /**
836+ * 记忆化搜索
837+ * 时间复杂度: O(n * C) 其中n为物品个数; C为背包容积
838+ * 空间复杂度: O(n * C)
839+ */
840+ public class Solution01 {
841+ private static int count = 0 ;
842+ private static int [][] memo;
843+
844+ public int knapsack (int [] w , int [] v , int C ) {
845+ int n = w. length;
846+ memo = new int [n][C + 1 ];
847+ for (int i = 0 ;i< n;i++ )
848+ Arrays . fill(memo[i],- 1 );
849+
850+ return bestValue(w, v, n - 1 , C );
851+ }
852+
853+ // 用 [0...index]的物品,填充容积为c的背包的最大价值
854+ private int bestValue (int [] w , int [] v , int i , int C ) {
855+ count++ ;
856+ if (i < 0 || C <= 0 )
857+ return 0 ;
858+
859+ if (memo[i][C ] != - 1 ) // 记忆化搜索
860+ return memo[i][C ];
861+
862+ int res = 0 ;
863+ res = bestValue(w, v, i - 1 , C );
864+ if (C >= w[i])
865+ res = max(res, v[i] + bestValue(w, v, i - 1 , C - w[i]));
866+
867+ return memo[i][C ] = res;
868+ }
869+
870+ private int max (int a , int b ) {
871+ return a > b ? a : b;
872+ }
873+
874+ public static void main (String [] args ) {
875+ int [] w = {5 ,4 ,6 ,3 };
876+ int [] v = {10 ,40 ,30 ,50 };
877+ System . out. println(new Solution01 (). knapsack(w, v, 10 ));
878+ System . out. println(" count of bestValue() exec:" + count);
879+ PrintHelper . print2DArray(memo);
880+ }
881+ }
882+ ```
883+
884+
885+
886+ #### (2)动态规划
887+
888+ <div align =" center " > <img src =" pics/knapsack-01.png " width =" " /></div ><br />
889+
890+
891+
892+ ``` java
893+ /**
894+ * 动态规划
895+ * 时间复杂度: O(n * C) 其中n为物品个数; C为背包容积
896+ * 空间复杂度: O(n * C)
897+ */
898+ public class Solution02 {
899+ public int knapsack (int [] w , int [] v , int C ) {
900+ int n = w. length;
901+ int [][] memo = new int [n][C + 1 ];
902+
903+ if (n == 0 || C == 0 )
904+ return 0 ;
905+
906+ for (int j = 0 ; j <= C ; j++ )
907+ memo[0 ][j] = (j >= w[0 ] ? v[0 ] : 0 );
908+
909+ for (int i = 1 ; i < n; i++ ) {
910+ for (int j = 0 ; j <= C ; j++ ) {
911+ memo[i][j] = memo[i - 1 ][j];
912+ if (j >= w[i]) {
913+ memo[i][j] = max(memo[i][j], v[i] + memo[i - 1 ][j - w[i]]);
914+ }
915+ }
916+ }
917+
918+ return memo[n - 1 ][C ];
919+ }
920+
921+ private int max (int a , int b ) {
922+ return a > b ? a : b;
923+ }
924+
925+
926+ public static void main (String [] args ) {
927+ int [] w = {1 , 2 , 3 };
928+ int [] v = {6 , 10 , 12 };
929+ int C = 5 ;
930+ System . out. println(new Solution02 (). knapsack(w, v, C ));
931+ }
932+ }
933+
934+ ```
935+
936+ #### (3)动态规划优化思路1
937+
938+ 优化思路:第i行元素只依赖于第i-1行元素,理论上,只需要保持两行元素即可
939+
940+ <div align =" center " > <img src =" pics/knapsack-optimized1.png " width =" " /></div ><br />
941+
942+ ``` java
943+ // / 动态规划改进: 滚动数组
944+ // / 时间复杂度: O(n * C) 其中n为物品个数; C为背包容积
945+ // / 空间复杂度: O(C), 实际使用了2*C的额外空间
946+ public class Solution1 {
947+
948+ public int knapsack01 (int [] w , int [] v , int C ){
949+
950+ if (w == null || v == null || w. length != v. length)
951+ throw new IllegalArgumentException (" Invalid w or v" );
952+
953+ if (C < 0 )
954+ throw new IllegalArgumentException (" C must be greater or equal to zero." );
955+
956+ int n = w. length;
957+ if (n == 0 || C == 0 )
958+ return 0 ;
959+
960+ int [][] memo = new int [2 ][C + 1 ];
961+
962+ for (int j = 0 ; j <= C ; j ++ )
963+ memo[0 ][j] = (j >= w[0 ] ? v[0 ] : 0 );
964+
965+ for (int i = 1 ; i < n ; i ++ )
966+ for (int j = 0 ; j <= C ; j ++ ){
967+ memo[i % 2 ][j] = memo[(i- 1 ) % 2 ][j];
968+ if (j >= w[i])
969+ memo[i % 2 ][j] = Math . max(memo[i % 2 ][j], v[i] + memo[(i- 1 ) % 2 ][j - w[i]]);
970+ }
971+
972+ return memo[(n- 1 ) % 2 ][C ];
973+ }
974+ }
975+ ```
976+
977+ #### (4)动态规划优化思路2
978+
979+ <div align =" center " > <img src =" pics/knapsack-optimized2.png " width =" " /></div ><br />
980+
981+ ``` java
982+ // / 动态规划改进
983+ // / 时间复杂度: O(n * C) 其中n为物品个数; C为背包容积
984+ // / 空间复杂度: O(C), 只使用了C的额外空间
985+ public class Solution2 {
986+
987+ public int knapsack01 (int [] w , int [] v , int C ){
988+
989+ if (w == null || v == null || w. length != v. length)
990+ throw new IllegalArgumentException (" Invalid w or v" );
991+
992+ if (C < 0 )
993+ throw new IllegalArgumentException (" C must be greater or equal to zero." );
994+
995+ int n = w. length;
996+ if (n == 0 || C == 0 )
997+ return 0 ;
998+
999+ int [] memo = new int [C + 1 ];
1000+
1001+ for (int j = 0 ; j <= C ; j ++ )
1002+ memo[j] = (j >= w[0 ] ? v[0 ] : 0 );
1003+
1004+ for (int i = 1 ; i < n ; i ++ )
1005+ for (int j = C ; j >= w[i] ; j -- )
1006+ memo[j] = Math . max(memo[j], v[i] + memo[j - w[i]]);
1007+
1008+ return memo[C ];
1009+ }
1010+ }
1011+ ```
1012+
1013+ #### (5)背包问题更多变种
1014+
1015+ - 多重背包问题:每个物品不不⽌止1个,有num(i)个
1016+ - 完全背包问题:每个物品可以⽆无限使⽤用
1017+ - 多维费⽤用背包问题:要考虑物品的体积和重量量两个维度?
1018+ - 物品间加⼊入更更多约束:物品间可以互相排斥;也可以互相依赖
1019+
1020+
1021+
1022+
8251023
8261024动态规划解决01背包问题 - Christal_R - 博客园
8271025https://www.cnblogs.com/Christal-R/p/Dynamic_programming.html
0 commit comments