Backpack Problems

1. Backpack I

Given n items with size Ai, an integer m denotes the size of a backpack. How full you can fill this backpack?

(http://www.lintcode.com/en/problem/backpack/)

1) brute-force: DFS

2) Whether we put the last item? (assuming n items)

　　No: the maximum to m is the previous n-1 items 

　　Yes: the maximum to m - A[n] for previous n -1 items

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
        //the maximum when trying to put first n items into m capacity backpack 
        //f[n][m] = max(f[n-1][m], f[n-1][m-A[n]]+A[n])
        //f[0][0] = 0, f[0][1] = 0 ...f[0][m]=0
        
        int n = A.length;
        
        int[][] dp = new int[n+1][m+1];
        
        for (int i = 1; i <= n; i++) {
            
            for (int j = 1; j <= m; j++) {
                dp[i][j] =  dp[i-1][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]);
                }
            }
        }
        
        return dp[n][m];
    }
}

 

Optimization by using rolling array

//Optimization by using rolling array 
     public int backPack(int m, int[] A) {
        // write your code here
        // everytime we update dp, only use the last dp row
        // eg. dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j-A[i-1]]+A[i-1]) only related to dp[i-1][...]
        
        int n = A.length;
        
        int[] dp = new int[m+1];
        
        for (int i = 1; i <= n; i++) {
            
            // why we have to use descending order?
            // cause we have to update dp[j] before dp[j-A[i-1]], otherwise, when updating dp[j], we will use the updated/polluted dp[j-A[i-1]] 
            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];
     }

 

2. Backpack II

Given n items with size Ai and value Vi, and a backpack with size m. What's the maximum value can you put into the backpack?

http://www.lintcode.com/en/problem/backpack-ii/

f[n][m] = max(f[n-1][m], f[n-1][m-A[n]]+V[n])

Normal 2-d array

[TO DO]

 

Optimization by using rolling array

public class Solution {
    /**
     * @param m: An integer m denotes the size of a backpack
     * @param A & V: Given n items with size A[i] and value V[i]
     * @return: The maximum value
     */
    public int backPackII(int m, int[] A, int V[]) {
        // write your code here
        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--) {
                // only replace last A[i-1] with V[i-1]
                dp[j] = Math.max(dp[j], dp[j-A[i-1]]+ V[i-1]);
            }
         }
         
        return dp[m];
    }
}

 

3. Backpack III 

What if each item has unlimited numbers?

method 1: f[n][m] = max(f[n-1][m], f[n-1][m- k*A[n]]+ k*V[n]) ,  m-k*A[n] >= 0

method 2: f[n][m] = max(f[n-1][m], f[n][m- A[n]]+ V[n]) 

Normal 2-D array

[TO DO]

Optimization

public class Solution {
    /**
     * @param m: An integer m denotes the size of a backpack
     * @param A & V: Given n items with size A[i] and value V[i]
     * @return: The maximum value
     */
    public int backPackII(int m, int[] A, int V[]) {
        // write your code here
        int n = A.length;
         
         int[] dp = new int[m+1];
        
        for (int i = 1; i <= n; i++) {
            // using asc order
            for (int j = A[i-1]; j <= m; j++) {
                dp[j] = Math.max(dp[j], dp[j-A[i-1]]+ V[i-1]);
            }
         }
         
        return dp[m];
    }
}

 

4. Backpack IV

Each item only has one. How many ways to fill up the bag?

[TO DO]

 

5. Backpack V

Each item has umlimited numbers. How many ways to fill up the bag?

https://leetcode.com/problems/combination-sum-iv/

Note: The combination sum IV in leetcode shares the same DP model and solution with this kind of Backpack problem. 

public class Solution {
    public int combinationSum4(int[] nums, int target) {
        
        int[] dp = new int[target+1];
        
        // how to undestand dp[0] = 1?
        // if target is 0, only 1 way - nothing to add
        dp[0] = 1; 
        Arrays.sort(nums);
        
        for (int i =1; i <= target; i++) {
            for (int num : nums) {
                
                if (i < num) break;
                dp[i] = dp[i] + dp[i-num];
            }
        }
        
        return dp[target];
        
        
    }
}