代码随想录day37|| 52携带研究材料 518零钱兑换Ⅱ 377组合总和Ⅳ 57爬楼梯

完全背包理论基础：

给定 n 个物品，第 i 个物品的重量为 wgt[i−1]、价值为 val[i−1] ，和一个容量为 cap 的背包。每个物品可以重复选取，问在限定背包容量下能放入物品的最大价值

首先再回顾一下01背包的核心代码

for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
    }
}

而完全背包的物品是可以添加多次的，所以要从小到大去遍历，即：

// 先遍历物品，再遍历背包
for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = weight[i]; j <= bagWeight ; j++) { // 遍历背包容量
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

    }
}

组合与排列问题！！！

如果求组合数就是外层for循环遍历物品，内层for遍历背包。

如果求排列数就是外层for遍历背包，内层for循环遍历物品。

如果把遍历nums（物品）放在外循环，遍历target的作为内循环的话，举一个例子：计算dp[4]的时候，结果集只有 {1,3} 这样的集合，不会有{3,1}这样的集合，因为nums遍历放在外层，3只能出现在1后面！

52携带研究材料 

卡码网题目链接

题目描述：

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

小明的行李箱所能承担的总重量为 N，问小明应该如何抉择，才能携带最大价值的研究材料，每种研究材料可以选择无数次，并且可以重复选择。

输入描述

第一行包含两个整数，N，V，分别表示研究材料的种类和行李空间 

接下来包含 N 行，每行两个整数 wi 和 vi，代表第 i 种研究材料的重量和价值

输出描述

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

输入示例

4 5
1 2
2 4
3 4
4 5

输出示例

10

这题就是简单的完全背包问题：

代码：

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

int main() {  
    // N是物品数量, V是背包的最大承重  
    int N, V;  
    cin >> N >> V;  
    
    // 用于存储物品的重量和价值  
    vector<int> weight;  
    vector<int> value;  
    
    // 输入每个物品的重量和价值  
    for (int i = 0; i < N; i++) {  
        int w; // 物品重量  
        int v; // 物品价值  
        cin >> w >> v;  
        weight.push_back(w);  
        value.push_back(v);  
    }  
    
    // dp数组，用于存储在对应容量下，背包可以获取的最大价值  
    vector<int> dp(V + 1, 0);  
    
    // 遍历每一个物品  
    for(int i = 0; i < N; i++) {  
        // 完全背包问题，从当前物品重量到最大重量遍历  
        for(int j = weight[i]; j <= V; j++) {  
            // 转移方程，选择当前物品最大价值比较  
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);  
        }  
    }  
    
    // 输出答案，在最大承重下所能获得的最大价值  
    cout << dp[V] << endl;  
    return 0;  
} 

 

1. 确定dp数组以及下标以及对应值的含义

• dp[j]表示：在容量为 j 的背包中，可以获得的最大价值。
• 下标 j 表示当前的背包容量。

2. 确定递推公式

• 当处理物品 i 时，如果我们选择将该物品放入背包，不再使用已有的容量 j-weight[i] 的最大价值，然后加上当前物品价值 value[i]，即有

dp[j]=max⁡(dp[j],dp[j−weight[i]]+value[i])dp[j]=max(dp[j],dp[j−weight[i]]+value[i])

• 这个公式表示：将当前物品加入背包后，与不加入背包情况下的最大价值进行比较。

3. dp数组如何初始化

• dp[0] = 0（容量为0时的最大价值当然是0）
• 其他dp[j]初始化为0，因为在0容量和没有物品时，价值均为0。

4. 确定遍历顺序

• 外层循环遍历每件物品，即 for(int i = 0; i < N; i++)
• 内层循环是自重量 weight[i] 开始遍历到背包的最大承重 V 的顺序，即 for(int j = weight[i]; j <= V; j++)
• 这可以确保每件物品可以被多次使用，符合完全背包的特性。

5. 举例推导dp数组

假设：

• 背包最大容量 V = 5
• 物品列表：weight = [1, 2, 3], value = [6, 10, 12]

推导步骤：

1. 初始 dp = [0, 0, 0, 0, 0, 0]

2. 处理完第一个物品（重量1，价值6）：

   • j = 1，dp[1] = max(dp[1], dp[1 - 1] + 6) = 6
   • j = 2，dp[2] = max(dp[2], dp[2 - 1] + 6) = 12
   • j = 3，dp[3] = max(dp[3], dp[3 - 1] + 6) = 18
   • j = 4，dp[4] = max(dp[4], dp[4 - 1] + 6) = 24
   • j = 5，dp[5] = max(dp[5], dp[5 - 1] + 6) = 30
   • dp = [0, 6, 12, 18, 24, 30]

3. 处理第二个物品（重量2，价值10）：

   • j = 2，dp[2] = max(dp[2], dp[2 - 2] + 10) = 12（不变）
   • j = 3，dp[3] = max(dp[3], dp[3 - 2] + 10) = 18（不变）
   • j = 4，dp[4] = max(dp[4], dp[4 - 2] + 10) = 24（不变）
   • j = 5，dp[5] = max(dp[5], dp[5 - 2] + 10) = 30（不变）
   • dp = [0, 6, 12, 18, 24, 30]（不变）

4. 处理第三个物品（重量3，价值12）：

   • j = 3，dp[3] = max(dp[3], dp[3 - 3] + 12) = 18（不变）
   • j = 4，dp[4] = max(dp[4], dp[4 - 3] + 12) = 24（不变）
   • j = 5，dp[5] = max(dp[5], dp[5 - 3] + 12) = 30（不变）
   • dp = [0, 6, 12, 18, 24, 30]（不变）

最终，dp[5] = 30，表示在背包最大容量为5的情况下，能获得的最大价值为30。

 518零钱兑换Ⅱ 

力扣题目链接

题目描述：

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。

请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。

假设每一种面额的硬币有无限个。 

题目数据保证结果符合 32 位带符号整数。

示例 1：

输入：amount = 5, coins = [1, 2, 5]
输出：4
解释：有四种方式可以凑成总金额：
5=5
5=2+2+1
5=2+1+1+1
5=1+1+1+1+1

示例 2：

输入：amount = 3, coins = [2]
输出：0
解释：只用面额 2 的硬币不能凑成总金额 3 。

示例 3：

输入：amount = 10, coins = [10] 
输出：1

代码：

class Solution {  
public:  
    int change(int amount, vector<int>& coins) {  
        // dp数组，用于存储凑成不同金额的组合数  
        vector<int> dp(amount + 1, 0);  
        // 初始状态：凑成金额0的方法只有1种，即不选任何硬币  
        dp[0] = 1;  
        
        // 遍历每个硬币  
        for(int i = 0; i < coins.size(); i++) {  
            // 遍历金额从当前硬币面额到总金额  
            for(int j = coins[i]; j <= amount; j++) {  
                // 更新dp数组：凑成金额j的方法数增加凑成金额(j - 当前硬币面额)的方法数  
                dp[j] += dp[j - coins[i]];  
            }  
        }  
        
        // 返回凑成总金额amount的方法数  
        return dp[amount];  
    }  
};  

1. 确定dp数组以及下标以及对应值的含义

• dp[j]表示：凑成金额 j 的不同硬币组合数。
• 下标 j 表示当前的金额。

2. 确定递推公式

• 当处理到硬币 coins[i] 时，若选择将其加入组合中，那么可以凑成金额 j 的组合数就可以通过加上凑成金额 j - coins[i] 的组合数得出。因此，递推公式为：

dp[j]=dp[j]+dp[j−coins[i]]dp[j]=dp[j]+dp[j−coins[i]]

• 这个公式表示：不使用当前硬币的方法数（dp[j]）与加入一个当前硬币的方法数（dp[j - \text{coins}[i]]）之和。

3. dp数组如何初始化

• dp[0] = 1：表示凑成金额 0 的只有一种方法，即不选择任何东西。
• 其他 dp[j] 初始化为 0，因为最初并不知道其他金额的组合数。

4. 确定遍历顺序

• 外层循环遍历每一种硬币，即 for(int i = 0; i < coins.size(); i++)
• 内层循环遍历金额从当前硬币面额到目标金额 amount，即 for(int j = coins[i]; j <= amount; j++)
• 这确保每个硬币都可以被多次使用，符合完全背包的特性。

5. 举例推导dp数组

假设：

• 总金额 amount = 5
• 硬币列表 coins = [1, 2, 5]

推导步骤：

1. 初始 dp = [1, 0, 0, 0, 0, 0]（凑成金额0的方法只有1种）

2. 处理第一个硬币（面额1）：

   • j = 1：dp[1] = dp[1] + dp[0] = 1
   • j = 2：dp[2] = dp[2] + dp[1] = 1
   • j = 3：dp[3] = dp[3] + dp[2] = 1
   • j = 4：dp[4] = dp[4] + dp[3] = 1
   • j = 5：dp[5] = dp[5] + dp[4] = 1
   • 更新 dp = [1, 1, 1, 1, 1, 1]

3. 处理第二个硬币（面额2）：

   • j = 2：dp[2] = dp[2] + dp[0] = 2
   • j = 3：dp[3] = dp[3] + dp[1] = 2
   • j = 4：dp[4] = dp[4] + dp[2] = 3
   • j = 5：dp[5] = dp[5] + dp[3] = 3
   • 更新 dp = [1, 1, 2, 2, 3, 3]

4. 处理第三个硬币（面额5）：

   • j = 5：dp[5] = dp[5] + dp[0] = 4
   • 更新 dp = [1, 1, 2, 2, 3, 4]

最终，dp[5] = 4，说明可以通过四种不同的组合方式凑成金额5。具体组合为：

• 使用5个1元
• 使用1个2元和3个1元
• 使用2个2元和1个1元
• 使用1个5元

377组合总和Ⅳ

力扣题目链接
题目描述：

给你一个由 不同 整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。

题目数据保证答案符合 32 位整数范围。

示例 1：

输入：nums = [1,2,3], target = 4
输出：7
解释：
所有可能的组合为：
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1)
请注意，顺序不同的序列被视作不同的组合。

示例 2：

输入：nums = [9], target = 3
输出：0

class Solution {  
public:  
    int combinationSum4(vector<int>& nums, int target) {  
        // dp数组，dp[i]表示凑成和为i的组合的个数  
        vector<int> dp(target + 1, 0);  
        // 初始状态：凑成和为0的组合有1种，即选择不使用任何元素  
        dp[0] = 1;  
        
        // 从1到target遍历，计算每个和的组合数  
        for (int i = 0; i <= target; i++) {  
            // 遍历数组的每个元素nums[j]  
            for (int j = 0; j < nums.size(); j++) {  
                // 如果当前和i减去nums[j]是非负数，说明nums[j]可以参与构成当前和  
                if (i - nums[j] >= 0 && dp[i] < INT_MAX - dp[i - nums[j]]) {  
                    // 更新dp[i]，将凑成i-nums[j]的组合数加到dp[i]上  
                    dp[i] += dp[i - nums[j]];  
                }  
            }  
        }  

        // 返回凑成和为target的组合总数  
        return dp[target];  
    }  
}; 

1. 确定dp数组以及下标以及对应值的含义

• dp[i]表示：凑成目标和为 i 的不同组合数。
• 下标 i 表示当前的目标和。

2. 确定递推公式

• 当 nums[j] 用于形成总和 i 时，把使用 nums[j] 之前的和 i - nums[j] 的组合数加上

dp[i]=dp[i]+dp[i−nums[j]]dp[i]=dp[i]+dp[i−nums[j]]

• 这个公式强调了利用之前更小的和来构造当前和的组合方式。

3. dp数组如何初始化

• dp[0] = 1 表示凑成和0的唯一组合方式是空选，即不选择任何元素。
• 其他dp[i]初始化为0，因为在没有任何计算之前，其他和的组合数默认为0。

4. 确定遍历顺序

• 外层循环遍历从0至 target 的目标和 i，即 for(int i = 0; i <= target; i++)。
• 内层循环遍历数组 nums 中的每个元素 j，即 for(int j = 0; j < nums.size(); j++)。
• 使用这种循环结构，确保每个目标和从小到大构建，每个元素都可以多次使用，顺序体现所有可能的排列组合。

5. 举例推导dp数组

假设：

• target = 4
• nums = [1, 2, 3]

推导步骤：

1. 初始 dp = [1, 0, 0, 0, 0]（只有一种方式凑成和为0，即不选元素）

2. 计算和为1：

   • i = 1，使用 nums[0] = 1 → dp[1] = dp[1] + dp[0] = 1
   • 更新 dp = [1, 1, 0, 0, 0]

3. 计算和为2：

   • i = 2，使用 nums[0] = 1 → dp[2] = dp[2] + dp[1] = 1
   • i = 2，使用 nums[1] = 2 → dp[2] = dp[2] + dp[0] = 2
   • 更新 dp = [1, 1, 2, 0, 0]

4. 计算和为3：

   • i = 3，使用 nums[0] = 1 → dp[3] = dp[3] + dp[2] = 2
   • i = 3，使用 nums[1] = 2 → dp[3] = dp[3] + dp[1] = 3
   • i = 3，使用 nums[2] = 3 → dp[3] = dp[3] + dp[0] = 4
   • 更新 dp = [1, 1, 2, 4, 0]

5. 计算和为4：

   • i = 4，使用 nums[0] = 1 → dp[4] = dp[4] + dp[3] = 4
   • i = 4，使用 nums[1] = 2 → dp[4] = dp[4] + dp[2] = 6
   • i = 4，使用 nums[2] = 3 → dp[4] = dp[4] + dp[1] = 7
   • 更新 dp = [1, 1, 2, 4, 7]

57爬楼梯

卡码网题目链接

题目描述：

题目描述

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 

每次你可以爬至多m (1 <= m < n)个台阶。你有多少种不同的方法可以爬到楼顶呢？ 

注意：给定 n 是一个正整数。

输入描述

输入共一行，包含两个正整数，分别表示n, m

输出描述

输出一个整数，表示爬到楼顶的方法数。

输入示例

3 2

输出示例

3

代码：

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

int main() {  
    int n, m;  
    // 输入楼梯阶数n和最多可爬的阶数m  
    cin >> n >> m;  

    // dp数组，dp[i]表示到达第i阶楼梯的方法数  
    vector<int> dp(n + 1, 0);  
    // 初始状态：达到第0阶只有一种方法（即不动）  
    dp[0] = 1;  

    // 从第0阶到第n阶计算不同的方法数  
    for (int i = 0; i <= n; i++) {  
        // 对于每一个阶数i，从1到m进行遍历，考虑每种可到达的方式  
        for (int j = 1; j <= m; j++) {  
            // 如果从i-j阶能到达i阶(即i-j是非负数)  
            if (i - j >= 0) {  
                // 累加到达i阶的方法数  
                dp[i] += dp[i - j];  
            }  
        }  
    }  

    // 输出到达第n阶的方法数  
    cout << dp[n] << endl;  
    return 0;  
}

 

. 确定dp数组和其含义

• dp[i] 表示从地面到达第 i 阶的不同方法数。
• 下标 i 则代表特定的楼梯阶数。

2. 确定递推公式

• 考虑从第 i-j 阶爬到第 i 阶，其中 1 <= j <= m。
• 递推公式为：

dp[i]=dp[i]+dp[i−j]dp[i]=dp[i]+dp[i−j]

• 即，我们从第 i-j 阶（如果能到达的话）到达第 i 阶的方法数累加到 dp[i] 中。

3. dp数组如何初始化

• dp[0] = 1: 表示在第0阶的方法数只有1种，即什么都不做。
• 其他dp[i]初始为0，因为在计算前，每种方法的计数都需要通过累加进行更新。

4. 确定遍历顺序

• 外层循环从第0阶到第 n 阶，即 for(int i = 0; i <= n; i++)。
• 内层循环对 1 到 m 的可能步数进行遍历，即 for(int j = 1; j <= m; j++)。
• 此循环结构确保我们计算从每个先前阶数到目标阶数 i 的每一种可能的走法。

5. 举例推导dp数组

假设：

• n = 5, m = 2（最多一次爬2个台阶）

推导步骤：

1. 初始 dp = [1, 0, 0, 0, 0, 0]（只有一种方法到达第0阶）

2. 计算到达第1阶：

   • 使用1步：dp[1] = dp[1] + dp[0] = 1

3. 计算到达第2阶：

   • 使用1步：dp[2] = dp[2] + dp[1] = 1
   • 使用2步：dp[2] = dp[2] + dp[0] = 2

4. 计算到达第3阶：

   • 使用1步：dp[3] = dp[3] + dp[2] = 2
   • 使用2步：dp[3] = dp[3] + dp[1] = 3

5. 计算到达第4阶：

   • 使用1步：dp[4] = dp[4] + dp[3] = 3
   • 使用2步：dp[4] = dp[4] + dp[2] = 5

6. 计算到达第5阶：

   • 使用1步：dp[5] = dp[5] + dp[4] = 5
   • 使用2步：dp[5] = dp[5] + dp[3] = 8