Leetcode算法训练日记 | day32

专题九  贪心算法

一、最大子数组和

1.题目

Leetcode：第 53 题

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组是数组中的一个连续部分。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

示例 2：

输入：nums = [1]
输出：1

示例 3：

输入：nums = [5,4,-1,7,8]
输出：23

2.解题思路

使用贪心算法解决最大子数组和问题。

（1）一般算法。
（2）贪心算法：在 maxSubArray 函数中，我们使用变量 result 来跟踪遍历过程中发现的最大子序和，初始值为 INT32_MIN。变量 count 用于计算从数组开始到当前索引的连续子数组的和。循环遍历数组 nums，我们将每个元素依次加到 count 上。如果 count 大于 result，则更新 result。如果 count 小于或等于 0，我们将 count 重置为 0，因为这表示当前的子数组和不会对后续子数组和产生贡献，我们从下一个元素开始计算新的子数组和。这种方法利用了贪心算法的思想，即在每一步选择中，都做出在当前状态下最好选择，从而希望导致结果是全局最优的。
最终，函数返回 result，即整个数组中连续子数组的最大和。

3.实现代码

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

// 一、最大子序和（暴力法）
class Solution1 {
public:
    // maxSubArray 函数用于计算（不连续）子数组的最大和
    int maxSubArray(vector<int>& nums) {
        int result = INT32_MIN; // 初始化结果为整数的最小值
        int count = 0; // 初始化计数器，用于计算子数组的和

        // 遍历数组，从每个元素开始
        for (int i = 0; i < nums.size(); i++) {
            // 这里应该从 i 开始一个新的子数组
            count = 0; // 重置计数器
            // 从当前位置 i 开始，遍历到数组末尾
            for (int j = i; j < nums.size(); j++) {
                count += nums[j];// 将当前元素 nums[j] 加到子数组的和中
                result = count > result ? count : result;// 更新结果为当前子数组的和和已知最大和中的较大者
            }
        }
        return result; // 返回计算得到的最大和
    }
};

// 二、最大子序和（贪心算法）
class Solution2 {
public:
    // maxSubArray 函数用于计算连续子数组的最大和
    int maxSubArray(vector<int>& nums) {
        int result = INT32_MIN; // 初始化结果为整数的最小值，用于记录最大子序和
        int count = 0; // 初始化计数器，用于计算当前子数组的和

        // 遍历数组中的每个元素
        for (int i = 0; i < nums.size(); i++) {
            count += nums[i];// 将当前元素的值加到 count 上，count 表示从索引 0 开始到当前索引的连续子数组的和
            // 如果当前子数组的和大于已知的最大子序和，则更新最大子序和
            if (count > result) {
                result = count;
            }
            // 如果当前子数组的和小于等于0，则重置 count 为 0，因为任何负数或零都会拉低后续子数组的和
            // 这相当于我们在遇到负数或零时，从下一个元素开始计算新的子数组和
            if (count <= 0) {
                count = 0;
            }
        }
        return result;// 返回计算得到的最大子序和
    }
};

//测试
int main()
{
    Solution2 p;
    vector<int> nums = { -2,1,-3,4,-1,2,1,-5,4 };
    int result = p.maxSubArray(nums);
    cout << "最大子序和:" << result << endl;
    cout << endl;
    return 0;
}

二、买卖股票的最佳时机Ⅱ

1.题目

Leetcode：第 122 题

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。

在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。

返回 你能获得的 最大 利润 。

示例 1：

输入：prices = [7,1,5,3,6,4]
输出：7
解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
     随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。
     总利润为 4 + 3 = 7 。

示例 2：

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
     总利润为 4 。

示例 3：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0 。

2.解题思路

使用贪心算法解决买卖股票的最佳时机问题。

在 maxProfit 函数中，我们首先初始化一个名为 result 的变量，用于存储最终的最大利润。然后，我们遍历 prices 数组，从第二个元素开始（索引为1），因为我们需要比较连续两天的价格。在循环中，我们使用 max 函数来计算当前价格与前一天价格的差额。max 函数确保即使价格下降，差额也为0，这样就不会减少累积的利润。如果价格上升，差额就是正数，我们将其加到 result 中。最终，函数返回 result，即整个价格列表中通过买卖股票能够获得的最大利润。这个方法利用了贪心算法的思想，即在每一步选择中都做出在当前状态下最优的选择，从而希望导致结果是全局最优的。

3.实现代码

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

class Solution {
public:
    // maxProfit 函数用于计算在给定的价格序列中通过买卖股票能够获得的最大利润
    int maxProfit(vector<int>& prices) {
        int result = 0; // 初始化结果变量，用于累积能够获得的最大利润

        // 遍历价格数组，从第二个价格开始（索引为1）
        for (int i = 1; i < prices.size(); i++) {
            // 计算当前价格与前一天价格的差额
            // 使用标准库中的 max 函数确保差额为非负数，即如果价格下降，则差额为0
            // 这样，我们只累加利润增加的部分，忽略价格下降的部分
            result = result + max(prices[i] - prices[i - 1], 0);
        }
        return result;// 返回计算得到的最大利润
    }
};

//测试
int main()
{
    Solution p;
    vector<int> prices = { 7,1,5,3,6,4 };
    int result = p.maxProfit(prices);
    cout << "最大利润:" << result << endl;
    cout << endl;
    return 0;
}

 

 ps：以上皆是本人在探索算法旅途中的浅薄见解，诚挚地希望得到各位的宝贵意见与悉心指导，若有不足或谬误之处，还请多多指教。