算法基础——背包问题求解

最新推荐文章于 2024-04-01 19:52:18 发布

hhhSir'blog

最新推荐文章于 2024-04-01 19:52:18 发布

阅读量1.5k

点赞数 1

分类专栏：算法文章标签：动态规划 java 算法

本文链接：https://blog.csdn.net/weixin_41399650/article/details/118659850

版权

算法专栏收录该内容

16 篇文章 0 订阅

订阅专栏

文章目录

前言
总结

前言

背包问题，动态规划算法入坑必备。经典算法，推荐经典讲解——dd大神的算法九讲和y总的视频讲解。
在这里插入图片描述
纯属调侃，以下内容配陈奕迅的“你的背包”更配哈。

01 背包问题

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。

第 i 件物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。

接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例

输出样例：

原始解法：

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        var in = new Scanner(System.in);
        int num = in.nextInt();
        int v = in.nextInt();
        int[][] vToV = new int[num + 1][2];
        //读取数据
        for(int i = 1; i < num + 1; i++){
            vToV[i][0] = in.nextInt();
            vToV[i][1] = in.nextInt();
        }
        //构造dp数组
        int[][] a = new int[num + 1][v + 1];
        for(int i = 1; i < num + 1; i++){
            for(int j = 0; j < v + 1; j++){
                if(j >= vToV[i][0]){
                    a[i][j] = Math.max(a[i - 1][j], a[i - 1][j - vToV[i][0]] + vToV[i][1]);
                }else{
                    a[i][j] = a[i - 1][j];
                }
            }
        }
        System.out.print(a[num][v]);
    }
}

优化之后的解法

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        var in = new Scanner(System.in);
        int num = in.nextInt();
        int v = in.nextInt();
        int[][] vToV = new int[num + 1][2];
        //读取数据
        for(int i = 1; i < num + 1; i++){
            vToV[i][0] = in.nextInt();
            vToV[i][1] = in.nextInt();
        }
        //构造dp数组
        int[] a = new int[v + 1];
        a[0] = 0;
        for(int i = 1; i < num + 1; i++){
            for(int j = v; j > 0; j--){
                if(j >= vToV[i][0]){
                    a[j] = Math.max(a[j], a[j - vToV[i][0]] + vToV[i][1]);
                }
            }
        }
        System.out.print(a[v]);
    }
}

完全背包问题

有 N 种物品和一个容量是 V 的背包，每种物品都有无限件可用。

第 i 种物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。

接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 种物品的体积和价值。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例

输出样例：

暴力解法：

//暴力算法
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        var in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int[] v = new int[n + 1];
        int[] w = new int[n + 1];
        for(int i = 1; i < n + 1; i++){
            v[i] = in.nextInt();
            w[i] = in.nextInt();
        }
        //dp数组
        int[][] dp = new int[n + 1][m + 1];
        dp[0][0] = 0;
        for(int i = 1; i < n + 1; i++){
            for(int j = 0; j < m + 1; j++){
                for(int k = 0; k*v[i] <= j; k++){
                    dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - v[i]*k] + w[i] * k);
                }
            }
        }
        System.out.print(dp[n][m]);
    }
}

运算速度优化解法：

//算法优化：
//f[i][j] = max(f[i-1][j], f[i-1][j-v[i]]+w[i], f[i-1][j-2*v[i]]+2*w[i], f[i-1][j-3v[i]]+3*w[i],...)  k=1,2,...,j/v[i]
//f[i][j-v[i]] =       max(f[i-1][j-v[i]],      f[i-1][j-2*v[i]]+w[i],   f[i-1][j-3v[i]]+2*w[i],...)      k=1,2,...,(j-v[i])/v[i]
//可以推出f[i][j] = max(f[i-1][j], f[i][j - v[i]] + w[i])
//该怎么理解这个递推式呢？与01背包有啥区别呢？01背包一直以选还是不选第i个物品为导向，完全背包问题一直是选几个的问题，要知道第i行都是考虑了第i个的，相当于在上一个选完了的过程中再问一次：再加一个？

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        var in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int[] v = new int[n + 1];
        int[] w = new int[n + 1];
        for(int i = 1; i < n + 1; i++){
            v[i] = in.nextInt();
            w[i] = in.nextInt();
        }
        //dp数组
        int[][] dp = new int[n + 1][m + 1];
        dp[0][0] = 0;
        for(int i = 1; i < n + 1; i++){
            for(int j = 0; j < m + 1; j++){
                if(j - v[i] >= 0){
                    dp[i][j] = Math.max(dp[i -1][j], dp[i][j - v[i]] + w[i]);
                }else{
                    dp[i][j] = dp[i -1][j];
                }
            }
        }
        System.out.print(dp[n][m]);
    }
}

内存再次优化：

//再次优化，显然只要用一维数组就能满足任务要求。
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        var in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int[] v = new int[n + 1];
        int[] w = new int[n + 1];
        for(int i = 1; i < n + 1; i++){
            v[i] = in.nextInt();
            w[i] = in.nextInt();
        }
        //dp数组
        int[] dp = new int[m + 1];
        dp[0] = 0;
        for(int i = 1; i < n + 1; i++){
            for(int j = v[i]; j < m + 1; j++){
                dp[j] = Math.max(dp[j], dp[j - v[i]] + w[i]);
            }
        }
        System.out.print(dp[m]);
    }
}

记录一下优化的效果：
在这里插入图片描述

多重背包问题

有 N 种物品和一个容量是 V 的背包。

第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。

接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。

输出格式
输出一个整数，表示最大价值。

数据范围

0<N≤1000
0<V≤2000
0<vi,wi,si≤2000

提示：
本题考查多重背包的二进制优化方法。

输入样例

输出样例：

未优化版本：

//未优化版本，与完全背包问题相类似。
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int[] v = new int[n + 1];
        int[] w = new int[n + 1];
        int[] num = new int[n + 1];
        for(int i = 1; i < n + 1; i++){
            v[i] = in.nextInt();
            w[i] = in.nextInt();
            num[i] = in.nextInt();
        }
        //dp数组
        int[][] dp = new int[n + 1][m + 1];
        dp[0][0] = 0;
        for(int i = 1; i < n + 1; i++){
            for(int j = 0; j < m + 1; j++){
                for(int k = 0; k <= num[i]; k++){
                    if(k * v[i] <= j){
                        dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - k * v[i]] + k * w[i]);
                    }
                }
            }
        }
        System.out.print(dp[n][m]);
    }
}

二进制优化版本：

//多重背包问题咋优化呐？这里学到的是一种比较巧的方法：
//为啥要优化呢？因为我们不想要第三层循环，这个很耗时间。怎么优化呢？先从下面的性质学起。
//可证明：1,2,4,8,18，...,2**k 中选取0个到k个数，每个只取一次，能组成[0,2**k - 1]这个区间的任何数
//然后，上面这个性质是不是可以理解为从1,2,4,8,18，...,2**k中进行一次01背包问题求解。
//这个思路的转换在于，我们对原始读进来的数据按照这个性质转换一下
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        var in = new Scanner(System.in);
        
        int n = in.nextInt();
        int m = in.nextInt();
        //v、w、s的最大值为2000，所以最大产生的数大小为：log(s)*N,最大值为11*1000
        int[] v = new int[12000];
        int[] w = new int[12000];
        int count = 0;
        for(int i = 1; i < n + 1; i++){
            int a = in.nextInt();
            int b = in.nextInt();
            int c = in.nextInt();
            
            int k = 1;
            while(k <= c){
                count++;
                v[count] = k * a;
                w[count] = k * b;
                c-=k;
                k*=2;
            }
            if(c > 0){
                count++;
                v[count] = a * c;
                w[count] = b * c;
            }
        }
        
        //01背包问题求解。
        int[] dp = new int[m + 1];
        for(int i = 1; i <= count; i++){
            for(int j = m; j >= v[i]; j--){
                dp[j] = Math.max(dp[j], dp[j - v[i]] + w[i]);
            }
        }
        System.out.println(dp[m]);
    }
}

分组背包问题

有 N 组物品和一个容量是 V 的背包。

每组物品有若干个，同一组内的物品最多只能选一个。
每件物品的体积是 vij，价值是 wij，其中 i 是组号，j 是组内编号。

求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。

输出最大价值。

输入格式
第一行有两个整数 N，V，用空格隔开，分别表示物品组数和背包容量。

接下来有 N 组数据：

每组数据第一行有一个整数 Si，表示第 i 个物品组的物品数量；
每组数据接下来有 Si 行，每行有两个整数 vij,wij，用空格隔开，分别表示第 i 个物品组的第 j 个物品的体积和价值；输出格式输出一个整数，表示最大价值。

数据范围

0<N,V≤100
0<Si≤100
0<vij,wij≤100

输入样例

输出样例：

常规解法：

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        var in = new Scanner(System.in);
        int maxN = 110;
        int[][] v = new int[maxN][maxN];
        int[][] w = new int[maxN][maxN];
        int[] s = new int[maxN];
        int[] dp = new int[maxN];
        
        int n = in.nextInt();
        int m = in.nextInt();
        for(int i = 1; i <= n; i++){
            s[i] = in.nextInt();
            for(int j = 0; j < s[i]; j++){
                v[i][j] = in.nextInt();
                w[i][j] = in.nextInt();
            }
        }
        
        for(int i = 1; i <= n; i++){
            for(int j = m; j >= 0; j--){
                for(int k = 0; k < s[i]; k++){
                    if(v[i][k] <= j){
                        dp[j] = Math.max(dp[j], dp[j - v[i][k]] + w[i][k]);
                    }
                }
            }
        }
        System.out.println(dp[m]);
        in.close();
    }
}