动态规划——背包问题 (1)

背包

01背包

每件物品最多用一次

状态表示：f(i,j) ：只考虑前i个物品，且总体积不大于j，能得到的最大价值

状态计算：考虑第i个物品是否放入背包 （分成两组）

import java.util.Scanner;
public class Main{
    public static void main(String[]args) {
        Scanner sc = new Scanner(System.in);
        int N = 1010;
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[]v = new int[N];
        int[]w = new int[N];
        int[]f = new int[N]; //使用滚动数组将二维优化成一维
        for(int i = 1;i <= n;i++) {
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
        }
        
        for(int i = 1;i <= n;i++) {
            //这里要倒序遍历，因为如果从前向后遍历更新，计算后面值时会用到上一层前面的，但是这时前面的值已经是这层的了
            for(int j = m;j >= v[i];j--) {
                f[j] = Math.max(f[j],f[j-v[i]]+w[i]);
            }
        }
        
        System.out.println(f[m]);
    }
}

完全背包

每件物品无限个

状态表示：f(i,j) ：只考虑前i个物品，且总体积不大于j，能得到的最大价值

状态计算：按第i个物品选几个来分（分若干组）

求 只考虑前i个物品，且第i个物品选了k个，且总体积不大于j，能得到的最大价值

1. 去掉k个物品i
2. 求去完后的Max f[i- 1，j-k*v[i]]
3. 再加回来k个物品i f[i- 1，j-k*v[i]] + w[i] * k

import java.util.Scanner;
public class Main{
    public static void main(String[]args) {
        Scanner sc = new Scanner(System.in);
        int N = 1010;
        int n = sc.nextInt(); //物品种类数
        int m = sc.nextInt();
        int[]v = new int[N];
        int[]w = new int[N];
        int[][]f = new int[N][N];
        for(int i = 1;i <= n;i++) {
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
        }
        
        for(int i = 1;i <= n;i++) {
            for(int j = 0;j <= m;j++) {
                for(int k = 0;k * v[i] <= j;k++) {
                    f[i][j] = Math.max(f[i][j],f[i-1][j - k*v[i]] + w[i] * k);
                }
            }
        }
        
        System.out.println(f[n][m]);
        
    }
}

优化：
观察可发现规律，所以可以将k那层循环去除，同时也可以转化成一维

import java.util.Scanner;
public class Main{
    public static void main(String[]args) {
        Scanner sc = new Scanner(System.in);
        int N = 1010;
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[]v = new int[N];
        int[]w = new int[N];
        int[]f = new int[N];
        for(int i = 1;i <= n;i++) {
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
        }
        
        for(int i = 1;i <= n;i++) {
            for(int j = v[i];j <= m;j++) {
            	//这里转化一维不用倒序遍历
                f[j] = Math.max(f[j],f[j - v[i]] + w[i]);
            }
        }
        
        System.out.println(f[m]);
        
    }
}

多重背包

每件物品有s个

状态表示： f(i,j) 只考虑前i个物品，且总体积不大于j，能得到的最大价值

状态计算： 按第i个物品选几个分，最多有s[i] 个

f[i] [j] = max(f[i - 1] [ j - v[i] * k] + k * w[i] ) 且 k = 0, 1, 2 …… s[i]

import java.util.Scanner;
public class Main{
    public static void main(String[]args) {
        Scanner sc = new Scanner(System.in);
        int N = 110;
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[]v = new int[N];
        int[]w = new int[N];
        int[]s = new int[N];
        int[][]f = new int[N][N];
        for(int i = 1;i <= n;i++) {
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
            s[i] = sc.nextInt();
        }
        for(int i = 1;i <= n;i++) {
            for(int j = 0;j <= m;j++) {
                for(int k = 0;k <= s[i] && k*v[i] <= j;k++) {
                    f[i][j] = Math.max(f[i][j],f[i - 1][j - k*v[i]] + k*w[i]);
                }
            }
        }
        
        System.out.println(f[n][m]);
    }
}

朴素解法三层循环，时间复杂度较高，只有在数据量较小时可以通过，需要优化

优化
使用二进制优化方法

可以将每种物品以 1个一组，2个一组，4个一组…… 2^k 一组，打包，每组物品可以选也可以不选，且只有一份，且要保证各个组物品之间凑出来的最大选择个数不得超过该种类物品最大数s，这样就转化成了01背包问题

import java.util.Scanner;
public class Main{
    public static void main(String[]args) {
        Scanner sc = new Scanner(System.in);
        int N = 12000;  //1000 * log2000
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[]v = new int[N];
        int[]w = new int[N];
        int[]f = new int[N];
        int cnt = 0;  //重新打包后物品份数，即转化成01背包问题的物品个数
        for(int i = 1;i <= n;i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            int s = sc.nextInt();
            int k = 1; //每份物品个数
            while(k <= s) {
                cnt++;
                v[cnt] = a * k;
                w[cnt] = b * k;
                s -= k;
                k *= 2;
            }
            if(s > 0) {
                cnt++;
                v[cnt] = a * s;
                w[cnt] = b * s;
            }
        }
        n = cnt;
        
        for(int i = 1;i <= n;i++) {
            for(int j = m;j >= v[i];j--) {
                f[j] = Math.max(f[j],f[j - v[i]]+w[i]);
            }
        }
        
        System.out.println(f[m]);
    }
}

……