代码随想录算法训练营day41_动态规划

46_携带研究材料

题目：

题目描述

小明是一位科学家，他需要参加一场重要的国际科学大会，以展示自己的最新研究成果。他需要带一些研究材料，但是他的行李箱空间有限。这些研究材料包括实验设备、文献资料和实验样本等等，它们各自占据不同的空间，并且具有不同的价值。 

小明的行李空间为 N，问小明应该如何抉择，才能携带最大价值的研究材料，每种研究材料只能选择一次，并且只有选与不选两种选择，不能进行切割。

输入描述

第一行包含两个正整数，第一个整数 M 代表研究材料的种类，第二个正整数 N，代表小明的行李空间。

第二行包含 M 个正整数，代表每种研究材料的所占空间。 

第三行包含 M 个正整数，代表每种研究材料的价值。

输出描述

输出一个整数，代表小明能够携带的研究材料的最大价值。 

输入示例

6 1
2 2 3 1 5 2
2 3 1 5 4 3

输出示例

5

提示信息

小明能够携带 6 种研究材料，但是行李空间只有 1，而占用空间为 1 的研究材料价值为 5，所以最终答案输出 5。 

数据范围： 
1 <= N <= 5000 
1 <= M <= 5000 
研究材料占用空间和价值都小于等于 1000

算法思想：

动态规划

1、dp[i][j]动态数组的含义：最大重量为j的背包，从0~i号物品中选择装入，可装入的最大物品价值

2、初始化 

dp[i][0] = 0;    // 背包最大容量为0时，可装入价值为0

当只允许选物品0放入背包中时即i=0时，如果j>=weight[0]，dp[0][j] = values[0];否则，dp[0][j] = 0;

3、递推公式

当前物品重量大于背包最大容量，则不装，dp[i][j] = dp[i-1][j];

当前物品重量小于背包最大容量，考虑装还是不装 

dp[i][j] = max(dp[i-1][j],dp[i-1][j-weight[i]]+values[i]);

        不装，dp[i][j] = dp[i-1][j];

        装，dp[i][j] = dp[i-1][j-weight[i]]+values[i]

4、遍历顺序，从上到下，从左到右

代码：

//
//  main.cpp
//  kama_46_携带研究材料
//
//  Created by 徐精泽 on 2024/4/23.
//

#include <iostream>
using namespace std;
#include <cmath>


int main() {
    int M,N;
    cin>>M>>N;
    int weight[M],values[M];
    for(int i=0;i<M;i++){
        cin>>weight[i];
    }
    for(int i=0;i<M;i++){
        cin>>values[i];
    }
    int dp[M][N+1];
    // dp[i][j] 的含义：最大重量为j的背包，从0~i号物品中选择装入，可装入的最大物品价值
    
    //初始化
    for(int i=0;i<M;i++){
        dp[i][0] = 0;    // 背包最大容量为0时，可装入价值为0
        // cout<<"dp["<<i<<"][0]="<<dp[i][0]<<" "<<endl;
    }
    for(int j=0;j<=N;j++){    // 当只允许选物品0放入背包中时
        if(j>=weight[0])
            dp[0][j] = values[0];
        else
            dp[0][j] = 0;
        // cout<<"dp[0]["<<j<<"]="<<dp[0][j]<<endl;
    }
    
    // 递推公式
    // 不放入时，dp[i][j] = dp[i-1][j];
    // 放入时，dp[i][j] = dp[i-1][j-wight[i]]+values[i];
    
    // 遍历，遍历顺序，从左到右，从上到下
    for(int i=1;i<M;i++){
        for(int j=1;j<=N;j++){
            if(j<weight[i]) dp[i][j] = dp[i-1][j];
            else dp[i][j] = max(dp[i-1][j],dp[i-1][j-weight[i]]+values[i]);
            // cout<<dp[i][j]<<" ";
        }
        // cout<<endl;
    }
    cout<<dp[M-1][N];
    
    
    return 0;
}

46_携带研究材料_一维数组写法

题目：

同上

算法思想：

基本上与二维数组类似，只是两层for循环中，直接在上一层第二维数组的基础上进行覆盖更新。因为每次更新要用到前面的值，因此应该从后往前遍历，防止从前往后遍历，处理后面的元素时前面的元素值已经被覆盖更新。

代码：

//
//  main.cpp
//  kamal_46_携带研究材料
//
//  Created by 徐精泽 on 2024/4/24.
//

#include <iostream>
using namespace std;
#include <cmath>


int main() {
    // 一维数组
    // dp[j]含义：表示背包容量最大为j时，可存入物品的最大价值
    // 递推公式：dp[j] = max(dp[j],dp[j-wight[i]]+values[i])
    // 跟二维数组一样是两层for循环，唯一不同的是上一层的状态隐藏掉了，直接在上一层状态的基础上进行更新。
    // 因为求dp[j]要用到上一层的dp[j]和dp[j-wight[i]]
    // 为了防止上层数据已被修改覆盖导致出错，应该cognitive后向前遍历
    
    int M,N;    // M表示物品数、N表示背包最大容量
    cin>>M>>N;
    int weight[M],values[M];
    for(int i=0;i<M;i++)
        cin>>weight[i];
    for(int i=0;i<M;i++)
        cin>>values[i];
    
    // 定义dp数组
    int dp[N+1];
    
    // 初始化dp数组
    for(int i=0;i<=N;i++){
        if(i>=weight[0])
            dp[i]=values[0];
        else
            dp[i]=0;
    }
    
    //两层for循环更新dp数组
    for(int i=1;i<M;i++){
        for(int j=N;j>=0;j--){    // 从后往前遍历
            if(j>=weight[i]){
                dp[j]=max(dp[j],dp[j-weight[i]]+values[i]);
            }
        }
    }
    
    cout<<dp[N];
    
    
    return 0;
}

416_分割等和子集

题目：

给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

示例 1：

输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。

示例 2：

输入：nums = [1,2,3,5]
输出：false
解释：数组不能分割成两个元素和相等的子集。

算法思想：

这题就是上面两个背包问题的实际应用。关键把题意转化成，从物品集中挑选物品，能否正好凑成价值为sum/2。每个物品的重量为nums[i] 价值为nums[i] ，背包最大容量为sum/2

写了用一维数组和二维数组两种写法

代码：

二维数组

class Solution {
     // 二维数组
    public static boolean canPartition(int[] nums) {
        // 算法思想：转化成动态规划，数组元素和为sum，实际上就是问能不能从集合中找到元素正好凑成sum/2
        // 题目变为：从重量为nums[i]价值为nums[i]的物品中，恰好装入容量为sum/2大小的背包中

        int sum = 0;
        for(int i=0;i<nums.length;i++){
            sum += nums[i];
        }
        float target = (float)sum/2;

        // 定义二维动态数组dp[i][j]含义：从0~i物品中选择加入最大容量为j的背包的最大价值
        int dp[][] = new int[nums.length][(int)target+1];

        // 初始化动态数组
        // 当背包最大容量为0时，价值为0
        for (int i = 0; i < nums.length; i++) {
            dp[i][0] = 0;
        }
        // 当只装入0号物品时
        for (int i = 0; i <= (int)target; i++) {
            dp[0][i] = 0;
        }

        // 两层for循环，递推
        for (int i = 1; i < nums.length; i++) {
            for (int j = 0; j <= (int)target; j++) {
                if(j<nums[i])
                    dp[i][j] = dp[i-1][j];
                else
                    dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-nums[i]]+nums[i]);
                if(j==target&&dp[i][j]==target)
                    return true;

            }
        }
        return false;

    }

}

一维数组

class Solution {
    public static boolean canPartition(int[] nums) {
        // 算法思想：转化成动态规划，数组元素和为sum，实际上就是问能不能从集合中找到元素正好凑成sum/2
        // 题目变为：从重量为nums[i]价值为nums[i]的物品中，恰好装入容量为sum/2大小的背包中

        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        float target = (float) sum / 2;

        // 定义动态数组dp
        int dp[] = new int[(int) target + 1];

        // 初始化动态数组
        for (int i = 0; i <= target; i++)
            dp[i] = 0;

        // 两层for循环遍历
        for (int i = 0; i < nums.length; i++) { // 外层物品数
            for (int j = (int) target; j >= 0; j--) { // 内层背包大小，从后向前遍历
                if (j >= nums[i]) {
                    dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]); // 递推公式
                    if ((float) dp[j] == target)
                        return true;
                }
            }

        }
        return false;

    }

}