代码随想录刷题第32天

代码随想录刷题第32天

买卖股票的最佳时机 II

/*

* @lc app=leetcode.cn id=122 lang=cpp

*

* [122] 买卖股票的最佳时机 II

*

* https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/description/

*

* algorithms

* Medium (71.52%)

 * Likes:    1986

* Dislikes: 0

 * Total Accepted:    801.7K

* Total Submissions: 1.1M

 * Testcase Example:  '[7,1,5,3,6,4]'

*

* 给你一个整数数组 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 。

*

*

*

* 提示：

*

*

* 1 <= prices.length <= 3 * 10^4

* 0 <= prices[i] <= 10^4

*

*

*/

 

// @lc code=start

#include <vector>

#include <iostream>

using namespace std;

 

class Solution {

public:

    int maxProfit(vector<int>& prices) {

        int result = 0;

        for (int i = 1; i < prices.size(); i++)

        {

            int profit = prices[i] - prices[i-1];

            if (profit > 0)

            {

                result += profit;

            }

 

        }

        return result;

    }

};

// @lc code=end

 

 

买卖股票的最佳时机

/*

* @lc app=leetcode.cn id=121 lang=cpp

*

* [121] 买卖股票的最佳时机

*

* https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/description/

*

* algorithms

* Easy (57.96%)

 * Likes:    2804

* Dislikes: 0

 * Total Accepted:    1M

* Total Submissions: 1.8M

 * Testcase Example:  '[7,1,5,3,6,4]'

*

* 给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

*

* 你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

*

* 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

*

*

*

* 示例 1：

*

*

* 输入：[7,1,5,3,6,4]

* 输出：5

* 解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。

 * ⁠    注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

*

*

* 示例 2：

*

*

* 输入：prices = [7,6,4,3,1]

* 输出：0

* 解释：在这种情况下, 没有交易完成, 所以最大利润为 0。

*

*

*

*

* 提示：

*

*

* 1

* 0

*

*

*/

 

// @lc code=start

#include <vector>

#include <iostream>

using namespace std;

 

class Solution {

public:

    int maxProfit(vector<int>& prices) {

        int result = INT32_MIN;

        int price_min = prices[0];

        for (int i = 1; i < prices.size(); i++)

        {

            if (price_min > prices[i])

            {

                price_min = prices[i];

            }

            if (result < prices[i] - price_min)

            {

                result = prices[i] - price_min;

            }

 

        }

 

        return result = result == INT32_MIN ? 0: result ;

    }

};

// @lc code=end

 

 

跳跃游戏

/*

* @lc app=leetcode.cn id=55 lang=cpp

*

* [55] 跳跃游戏

*

* https://leetcode.cn/problems/jump-game/description/

*

* algorithms

* Medium (43.72%)

 * Likes:    2204

* Dislikes: 0

 * Total Accepted:    654.1K

* Total Submissions: 1.5M

 * Testcase Example:  '[2,3,1,1,4]'

*

* 给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。

* 

* 数组中的每个元素代表你在该位置可以跳跃的最大长度。

* 

* 判断你是否能够到达最后一个下标。

* 

* 

* 

* 示例 1：

* 

* 

* 输入：nums = [2,3,1,1,4]

* 输出：true

* 解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。

* 

* 

* 示例 2：

* 

* 

* 输入：nums = [3,2,1,0,4]

* 输出：false

* 解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。

* 

* 

* 

* 

* 提示：

* 

* 

* 1 

* 0 

* 

* 

*/

 

// @lc code=start

#include <vector>

#include <iostream>

using namespace std;

 

class Solution {

public:

    bool canJump(vector<int>& nums) {

        if (nums.size() == 1)

        {

            return 1;

        }

 

        int cover = 0;

        int i = 0;

        while (i <= cover)

        {

            int cover_tmp = i + nums[i];

            cover = max(cover,cover_tmp);

            i++;

            if (cover >= nums.size() - 1)

            {

                return true;

            }

 

        }

 

        return false;

    }

};

// @lc code=end

 

 

跳跃游戏 II

/*

* @lc app=leetcode.cn id=45 lang=cpp

*

* [45] 跳跃游戏 II

*

* https://leetcode.cn/problems/jump-game-ii/description/

*

* algorithms

* Medium (45.22%)

 * Likes:    1966

* Dislikes: 0

 * Total Accepted:    449.5K

* Total Submissions: 993.9K

 * Testcase Example:  '[2,3,1,1,4]'

*

* 给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。

* 

* 每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j]

* 处:

* 

* 

* 0 <= j <= nums[i] 

* i + j < n

* 

* 

* 返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。

* 

* 

* 

* 示例 1:

* 

* 

* 输入: nums = [2,3,1,1,4]

* 输出: 2

* 解释: 跳到最后一个位置的最小跳跃数是 2。

* 从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。

* 

* 

* 示例 2:

* 

* 

* 输入: nums = [2,3,0,1,4]

* 输出: 2

* 

* 

* 

* 

* 提示:

* 

* 

* 1 <= nums.length <= 10^4

* 0 <= nums[i] <= 1000

* 题目保证可以到达 nums[n-1]

* 

* 

*/

 

// @lc code=start

#include <vector>

#include <iostream>

using namespace std;

 

 

class Solution {

public:

    int jump(vector<int>& nums) {

        int step = 0;

        int curdis = 0;

        int nextdis = 0;

        for (int i = 0; i < nums.size(); i++)

        {

            nextdis = max(i + nums[i] , nextdis);

            if (i == curdis)

            {

                if (curdis < nums.size() - 1)

                {

                    step++;

                  curdis =  nextdis;

                  if (nextdis > nums.size() -1)

                  {

                    break;

                  }

 

                }else

                {

                    break;

                }

 

 

 

            }

 

        }

        return step;

    }

};

// @lc code=end