动态规划-背包问题

package demo3;

/**
 * @author xianyu
 * @version 1.0
 * @date 2020/4/10 15:52
 * // 动态规划01背包问题
 */
public class DynamicProgramming {

    public static void main(String[] args) {
//        int[] weight = {2,3,4,5,9};
//        int[] value = {3,4,5,8,10};
//        int[] num = {1,1,1,1,1};
        int[] weight = {3,4,2,5};
        int[] value = {2,3,2,3};
        int[] num = {2,2,1,4};
        int n = weight.length;
        int capacity = 10;
        //ZeroOneKnapsack1(weight,value,n,capacity);
        //completeKnapsack(weight,value,n,capacity);
        multiKnapsack(weight,value,num,n,capacity);
    }


    // weight物品重量  value物品价格 n商品数目 capacity表示背包容量
    public static void ZeroOneKnapsack1(int[] weight,int[] value,int n,int capacity){
        // 初始化动态规划数组
        int[][] dp = new int[n+1][capacity+1];
        // 为了便于理解，将dp[i][0]和dp[0][j]均置为0，从1开始计算
        for(int i=1; i<n+1; i++){
            for(int j=1; j<capacity+1; j++){
                //如果第i件物品的重量大于背包容量j,则不装入背包
                //由于weight和value数组下标都是从0开始,故注意第i个物品的重量为weight[i-1],价值为value[i-1]
                if(weight[i-1]>j){
                    dp[i][j] = dp[i-1][j];
                } else {
                    dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-weight[i-1]]+value[i-1]);
                }
            }
        }
        int maxValue = dp[n][capacity];
        //则容量为V的背包能够装入物品的最大值为
        System.out.println(maxValue);

        //逆推找出装入背包的所有商品的编号
        int curCapacity = capacity;
        String numStr = "";
        for(int i=n; i>0; i--){
            // 如果dp[i][curCapacity]>dp[i-1][curCapacity], 说明第i件物品是放入背包的
            if(dp[i][curCapacity]>dp[i-1][curCapacity]){
                numStr = i + " " + numStr;
                curCapacity = curCapacity-weight[i-1];
            }
            if(curCapacity==0)
                break;
        }
        System.out.println(numStr);

    }


    // 01背包问题的优化
    // 只用一个一维数组记录状态，dp[i]表示容量为i的背包所能装入物品的最大价值
    // 用逆序来实现
    public static void ZeroOneKnapsack2(int[] weight,int[] value,int n,int capacity){
        int[] dp = new int[capacity+1];
        for(int i=1;i<n+1; i++){
            // 逆序实现
            for(int j=capacity; j>=weight[i-1]; j--){
                dp[j] = Math.max(dp[j-weight[i-1]]+value[i-1],dp[j]);
            }
        }
        System.out.println(dp[capacity]);
    }

/*
     * 第二类背包：完全背包
     * 思路分析：
            * 01背包问题是在前一个子问题（i-1种物品）的基础上来解决当前问题（i种物品），
            * 向i-1种物品时的背包添加第i种物品；而完全背包问题是在解决当前问题（i种物品）
            * 向i种物品时的背包添加第i种物品。
            * 推公式计算时，f[i][y] = max{f[i-1][y], (f[i][y-weight[i]]+value[i])}，
            * 注意这里当考虑放入一个物品 i 时应当考虑还可能继续放入 i，
            * 因此这里是f[i][y-weight[i]]+value[i], 而不是f[i-1][y-weight[i]]+value[i]。
*/

    public static void completeKnapsack(int[] weight,int[] value,int n,int capacity){
        // 初始化动态规划数组
        int[][] dp = new int[n+1][capacity+1];
        for (int i = 1; i < n+1; i++) {
            for (int j = 1; j < capacity+1; j++) {
                if(weight[i-1] > j){
                    dp[i][j] = dp[i-1][j];
                } else {
                    dp[i][j] = Math.max(dp[i-1][j],dp[i][j-weight[i-1]]+value[i-1]);
                }
            }
        }

        int maxValue = dp[n][capacity];
        System.out.println(maxValue);

        int curCapacity = capacity;
        String numStr = "";
        for(int i = n; i > 0; i--){
            while(dp[i][curCapacity]>dp[i-1][curCapacity]){
                numStr = i + " " + numStr;
                curCapacity = curCapacity-weight[i-1];
            }
            if(curCapacity==0)
                break;
        }

        System.out.println(numStr);
    }


    // 多重背包问题
    public static void multiKnapsack(int[] weight,int[] value,int[] num,int n,int capacity) {
        // 初始化数组
        int[][] dp = new int[n+1][capacity+1];
        for(int i=1; i<n+1; i++){
            for (int j = 1; j < capacity+1; j++) {
                //如果第i件物品的重量大于背包容量j,则不装入背包
                if(weight[i-1]>capacity){
                    dp[i][j] = dp[i-1][j];
                } else {
                    // 考虑物品件数限制
                    int maxCapacity = Math.min(num[i-1],j/weight[i-1]);  // 最多能够装几个物品i
                    for(int k=0; k<maxCapacity+1; k++){
                        dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-k*weight[i-1]]+k*value[i-1]);
                    }
                }
            }
        }

        System.out.println(dp[n][capacity]);
        int curCapacity = capacity;
        String numStr = "";
        for(int i=n; i>0; i--){
            //若果dp[i][j]>dp[i-1][j],这说明第i件物品是放入背包的
            while(dp[i][curCapacity]>dp[i-1][curCapacity]){
                numStr = i + " " + numStr;
                curCapacity = curCapacity-weight[i-1];
            }
            if(curCapacity==0)
                break;
        }
        System.out.println(numStr);
    }

}

转自转载