【背包问题】 一零和 leetcode 474

先看这个

大佬总结的模板，妙啊

leetcode题解

474题

添加链接描述

代码：

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][][] dp = new int[strs.length + 1][m + 1][n + 1];
        for(int s = 1; s < strs.length + 1; s ++){ //遍历元素
            int countZero = 0, countOne = 0;
            for(char c : strs[s - 1].toCharArray()){
                if(c == '0'){
                    countZero ++;
                }else{
                    countOne ++;
                }
            }
            //遍历背包容量，和普通的0-1背包不一样，会出现"0"/"1"这种只有单个0或者1的情况，所以从0开始遍历
            for(int i = 0; i < m + 1; i ++){
                for(int j = 0; j < n + 1; j ++){
                    //如果背包装不下，就继承之前的状态
                    dp[s][i][j] = dp[s - 1][i][j];
                    //如果背包装得下，就叠加之前的状态
                    if(i - countZero >= 0 && j - countOne >= 0){
                        dp[s][i][j] = Math.max(dp[s - 1][i][j], dp[s - 1][i - countZero][j - countOne] + 1);
                    }
                }
            }
        }
        return dp[strs.length][m][n];
    }
}

空间优化后的代码

class Solution {
  public int findMaxForm(String[] strs, int m, int n) {
        if (strs == null || strs.length == 0) {
            return 0;
        }
        int[][] dp = new int[m + 1][n + 1];
        for (String s: strs) {
            int ones = 0, zeros = 0;
            for (char c : s.toCharArray()) {
                if (c == '0') {
                    zeros++;
                }else {
                    ones++;
                }
            }
            for (int i = m; i >= zeros; i--) {
                for (int j = n; j >= ones; j--) {
                    dp[i][j] = Math.max(dp[i][j], dp[i - zeros][j - ones] + 1);
                }
            }
        }
        return dp[m][n];
    }
}

背包问题 第二维 for循环的方向问题：

是从大到小，还是从小到大

0/1 背包问题

每次物品只能取一次

动态规划递归式：

for i = 1..N (N为物品数量)

　　　for (int j = M;  j >= w[i]; j-- )   (M为 我的背包最大能装的重量)
　　　　　 f [ j ] = max { f [ j ]  ,   f [ j-w[i] ]+val[ i ] };

完全背包问题

完全背包问题，就是 每件物品有不只一件，可以选取多件

动态规划递归式(公式与0/1背包相同，但是顺序是从前往后)

for i = 1..N (N为物品数量)

　　　for (int j = w[i];  j <= M;  j++ )   (M为 我的背包最大能装的重量)
　　　　　 f [ j ] = max { f [ j ]  ,   f [ j-w[i] ]+val[ i ] };

再补充一种分组背包问题

问题描述：

代码（重点看里面的注释)

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        n /= 10;                            //因为总钱数和物品单价都是10的倍数，将总钱数 和 物品价格都除以10， 可以优化时空复杂度，尤其是数组的大小，
        int m = sc.nextInt();
        int[][] price = new int[60][3];     // price数组 保存 每个物品的单价， 为什么要用二维数组，因为第二维要说明输入的这个物品是那个物品的 物品本身 还是 第1个附件， 还是第2个附件
        int[][] priceMz = new int[60][3];   // priceMz 数组 保存 每个主物品 及其附件 的 价值， 价值 就是 用商品的价格 乘以 商品的重要性
        
        //读完数字，一定要sc.nextLine();
        sc.nextLine();

        for(int i=1; i<=m; i++){
            int p = sc.nextInt();
            p /= 10;
            int z = sc.nextInt();
            int f = sc.nextInt();

            if(f == 0){
                price[i][0] = p;
                priceMz[i][0] = p*z;
            }else{
                if(price[f][1] == 0){
                    price[f][1] = p;
                    priceMz[f][1] = p*z;
                }else{
                    price[f][2] = p;
                    priceMz[f][2] = p*z;
                }
            }
        } // END for

        //开始背包

        int[][] dp = new int[60][n+1];
        for(int i=1; i<=m; i++){
            //本题还不是严格的按照每一件物品 来进行 背包的， 而是 将每一件主物品和它的所有附件作为一个整体来进行背包的， 然后在处理一个主物品和附件的整体的时候
            // , 再分为三种情况， 第一种情况：只取主物品， 第二种：取主物品和他的第一个附件， 第三种：取主物品和他的第二个附件
            for(int j=0; j<=n; j++){
                int p = price[i][0];
                int v = priceMz[i][0];
                int p1 = price[i][1];
                int v1 = priceMz[i][1];
                int p2 = price[i][2];
                int v2 = priceMz[i][2];

                //注意下面三个公式是不同的
                //第一个公式，因为dp[i][j]此时还没有被算出来，而dp[i-1][j]已经被算出来了，所以在第二层是正序的情况下，要用dp[i-1][j] 得到dp[i][j];
                //第一个公式是在只取当前物品本身，不取它的任何附件
                dp[i][j] = j>=p ? Math.max(dp[i-1][j-p]+v,dp[i-1][j])  :dp[i-1][j];
                // 因为上一个公式已经得到了dp[i][j], 所以只需要比较 取当前物品以及它的第一个附件 和 dp[i][j] 之间的大小关系即可
                dp[i][j] = j>=(p+p1) ? Math.max(dp[i-1][j-p-p1]+v+v1,dp[i][j])  :dp[i][j];
                // 第三个公式，是取 当前物品本身 和 他的 第一、第二个附件
                dp[i][j] = j>=(p+p1+p2) ? Math.max(dp[i-1][j-p-p1-p2]+v+v1+v2,dp[i][j])  :dp[i][j];
            }
        } //end for


        System.out.println(dp[m][n] * 10);

    }
}