动态规划-揹包问题(给定容量获得最大的价值量)2

2024年5月10日 169次阅读

初写博客,如有欠佳之处还望大家海涵,下面评论提出及时改正
动态规划-揹包问题(给定容量获得最大的价值量) ,相比上一篇的解题方法,该解题方法占用空间更大,代码量也比较多
思路:
1. 定义一个int[][]类型的数组,数组行数为两行，列数为输入(max_value)的最大容量,用于存贮当前状态和前一状态,以遍历的物品所在位置的奇偶区分
2. 遍历每个物品，每个物品只有放入和不放入两个状态,定义一变量表示当前的容量,如果当前容量小于物品所需要的容量，则直接把上一状态该容量的值直接赋给该容量的当前状态
3. 奇数状态存在二位数组的第0行，偶数存在第1行，后面的值相应的覆蓋对应的行
4. 二维数组的最后一行的值就是容量值为1-(max_value)对应的最大价值量,最后一个元素就是所要求的结果

public class Test {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        //the variable be used to save the max volume value
        int max_volume = input.nextInt();
        //the variable be used to save the good's kind
        int good_kind = input.nextInt();

        //the array be used to save every current bag's currently statue and forward statue
        int[][] numValue = new int[2][max_volume];
        //the array be used to save every bag's value
        int[] values = new int[good_kind];
        //the array be used to save every bag's volume
        int[] container = new int[good_kind];

        //initial bag's values array
        for(int i = 0; i < good_kind; i++) {
            values[i] = input.nextInt();
        }
        //initial bag's container array
        for(int i = 0; i < good_kind; i++) {
            container[i] = input.nextInt();
        }

        for(int i=1;i<=good_kind;i++){
            //j代表当前的最大容量,由于数组下标从0开始,所以当j为0时表示当前容量最大为1
            for(int j=0;j<max_volume;j++){
                //如果当前货品位置为偶数
                if(i % 2 == 0){
                    //如果当前j的值小于当前物品所需的容量,则把上一状态的该最大容量的值赋给当前物品的当前容量的价值量
                    if(j < container[i-1]-1){
                        numValue[1][j] = numValue[0][j];
                    }else{
                        //如何当前最大容量正好为放入该物品所需容量,剩余容量为0
                        if(j == container[i-1]-1){
                            //判断该容量的上一状态的价值量是否大于当前物品的价值量
                            if(numValue[0][j] > values[i-1]){
                                numValue[1][j] = numValue[0][j];
                            }else{
                                numValue[1][j] = values[i-1];
                            }
                        }else{
                            //判断放入该物品后的剩余容量上一状态的价值量与当前物品的价值量之和是否大于该容量的上一状态的价值量
                            if(numValue[0][j-container[i-1]] + values[i-1] > numValue[0][j]){
                                numValue[1][j] = numValue[0][j-container[i-1]] + values[i-1];
                            }else{
                                numValue[1][j] = numValue[0][j];
                            }
                        }
                    }
                }else{
                    //如果当前货品位置为基数，以上面情况类似
                    if(j < container[i-1]-1){
                        numValue[0][j] = numValue[1][j];
                    }else{
                        if(j == container[i-1]-1){
                            if(numValue[1][j] > values[i-1]){
                                numValue[0][j] = numValue[1][j];
                            }else{
                                numValue[0][j] = values[i-1];
                            }
                        }else{
                            if(numValue[1][j-container[i-1]] + values[i-1] > numValue[1][j]){
                                numValue[0][j] = numValue[1][j-container[i-1]] + values[i-1];
                            }else{
                                numValue[0][j] = numValue[1][j];
                            }
                        }
                    }
                }
            }
        }//输出结果，最后一行状态量就是相应最大容量的最大价值量
        for(int i=0;i<numValue.length;i++){
            for(int j=0;j<numValue[i].length;j++){
                System.out.print(numValue[i][j]+" ");
            }
            System.out.println();
        }
    }
}
点赞