🙆‍♂️01背包问题

👉Example 1（背包问题一）

👇解法1：（普通版）

public class Solution {
    /**
     * @param m: An integer m denotes the size of a backpack
     * @param A: Given n items with size A[i]
     * @return: The maximum size
     */
    public int backPack(int m, int[] A) {
        // write your code here
        int n = A.length;
        if(m == 0 || A == null || n==0)
        {
             return 0;
        }

        int[][] dp = new int [n+1][m+1];

        for(int i=1; i<=n; i++){
            for(int j=1; j<=m; j++){
                if(j>=A[i-1]){
                    dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j-A[i-1]]+A[i-1]); 
                }else{
                    dp[i][j] = dp[i-1][j];
                }
            }
        }
        return dp[n][m];
    }
}

👇解法2（优化版）

public class Solution {
    /**
     * @param m: An integer m denotes the size of a backpack
     * @param A: Given n items with size A[i]
     * @return: The maximum size
     */
    public int backPack(int m, int[] A) {

        int n = A.length;
        if(m == 0 || A == null || n==0)
        {
             return 0;
        }

        int[] dp = new int [m+1];

        for(int i=1; i<=n; i++){
            for(int j=m; j>=A[i-1]; j--){
                dp[j] = Math.max(dp[j], dp[j-A[i-1]]+A[i-1]);
            }
        }

        return dp[m];
    }
}

👉Example 2（背包问题二）

public class Solution {
    /**
     * @param m: An integer m denotes the size of a backpack
     * @param A: Given n items with size A[i]
     * @param V: Given n items with value V[i]
     * @return: The maximum value
     */
    public int backPackII(int m, int[] A, int[] V) {

        int n = A.length;

        int[] dp = new int[m+1];

        for(int i=1; i<=n; i++){
            for(int j=m; j>=A[i-1]; j--){
                dp[j] = Math.max(dp[j], dp[j-A[i-1]]+V[i-1]);//转移方程，经过空间优化
            }
        }
        return dp[m];
    }
}

🙆完全背包问题

👉Example 1（背包问题三）

public class Solution {
    /**
     * @param A: an integer array
     * @param V: an integer array
     * @param m: An integer
     * @return: an array
     */
    public int backPackIII(int[] A, int[] V, int m) {

        int n = A.length;
        if(n == 0 || A == null || m == 0){
            return 0;
        }

        int[] dp = new int[m+1];

        for(int i=1; i<=n; i++){
            for(int j=1; j<=m; j++){
                if(j>=A[i-1]){
                    dp[j] = Math.max(dp[j],dp[j-A[i-1]]+V[i-1]);//经过空间优化
                }
            }
        }

        return dp[m];
    }
}

🚀Exercises

👉Example 1（背包问题V)

👇解法1：普通版

public class Solution {
    /**
     * @param nums: an integer array and all positive numbers
     * @param target: An integer
     * @return: An integer
     */
    public int backPackV(int[] nums, int target) {

        int n = nums.length;

        if(n == 0 || nums == null){
            return 0;
        }

        int[][] dp = new int[n+1][target+1];
        //初始化
        dp[0][0] = 1; 
        for(int i=1; i<=target; i++){
            dp[0][i] = 0;
        }

        for(int i=1; i<=n; i++){
            dp[i][0] = 1;
            for(int j=1; j<=target; j++){

                //情况1
                dp[i][j] =dp[i-1][j];

                //情况2
                if(j>=nums[i-1]){
                    dp[i][j]+=dp[i-1][j-nums[i-1]];
                }

            }
        }

        return dp[n][target];
    }
}

👇解法2：优化版

public class Solution {
    /**
     * @param nums: an integer array and all positive numbers
     * @param target: An integer
     * @return: An integer
     */
    public int backPackV(int[] nums, int target) {
 
        int n = nums.length;

        if(n == 0 || nums == null){
            return 0;
        }

        int[] dp = new int[target+1];
        dp[0] = 1;//初始化
        
        for(int i=1; i<=n; i++){
            for(int j=target; j>=nums[i-1]; j--){
                  dp[j]+=dp[j-nums[i-1]];
            }
        }

        return dp[target];
    }
}

👉Example 2（组合总和IV)

public class Solution {
    /**
     * @param nums: an integer array and all positive numbers, no duplicates
     * @param target: An integer
     * @return: An integer
     */
    public int backPackVI(int[] nums, int target) {

        if (nums == null || nums.length == 0){
            return 0;
        } 
       int[] dp = new int[target+1];
       dp[0] = 1;

       for(int i=1; i<=target; i++){
           for(int j=1; j<=nums.length; j++){
               if(nums[j-1]<=i){
                   dp[i] += dp[i-nums[j-1]];
               }
           }
       }

       return dp[target];
    }
}