LeetCode DAY28(122. Best Time to Buy and Sell Stock II&55. Jump Game&45. Jump Game II)

Preface

This is a new day to continue my Greedy Algorithm journey.
Learn something new and keep reviewing what I learnt before.

1.Best Time to Buy and Sell Stock II

LeetCode Link: 122. Best Time to Buy and Sell Stock II
You are given an integer array prices where prices[i] is the price of a given stock on the ith day.

On each day, you may decide to buy and/or sell the stock. You can only hold at most one share of the stock at any time. However, you can buy it then immediately sell it on the same day.

Find and return the maximum profit you can achieve.

Example 1:

Input: prices = [7,1,5,3,6,4]
Output: 7
Explanation: Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.
Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.
Total profit is 4 + 3 = 7.
Example 2:

Input: prices = [1,2,3,4,5]
Output: 4
Explanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
Total profit is 4.
Example 3:

Input: prices = [7,6,4,3,1]
Output: 0
Explanation: There is no way to make a positive profit, so we never buy the stock to achieve the maximum profit of 0.

Constraints:

1 <= prices.length <= 3 * 104
0 <= prices[i] <= 104

Analysis and Solution

Greedy Algorithm

LeetCode C++ as followings Greedy Algorithm

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int result = 0;
        for (int i = 1; i < prices.size(); i++) {//traverse vector
            result += max(prices[i] - prices[i - 1], 0);//find the maxProfit
        }
        return result;
    }
};

2. Jump Game

LeetCode Link: 55. Jump Game
You are given an integer array nums. You are initially positioned at the array’s first index, and each element in the array represents your maximum jump length at that position.

Return true if you can reach the last index, or false otherwise.

Example 1:

Input: nums = [2,3,1,1,4]
Output: true
Explanation: Jump 1 step from index 0 to 1, then 3 steps to the last index.
Example 2:

Input: nums = [3,2,1,0,4]
Output: false
Explanation: You will always arrive at index 3 no matter what. Its maximum jump length is 0, which makes it impossible to reach the last index.

Constraints:

1 <= nums.length <= 104
0 <= nums[i] <= 105

Analysis and Solution

Greedy Algorithm

LeetCode C++ as followings Greedy Algorithm

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int cover = 0;
        if (nums.size() == 1) return true; // only one element, which is can achieve
        for (int i = 0; i <= cover; i++) { // Note that here is less than or equal to cover
            cover = max(i + nums[i], cover);
            if (cover >= nums.size() - 1) return true; // Indicates that can be covered to the end
        }
        return false;
    }
};

3.Jump Game II

LeetCode Link: 45. Jump Game II
You are given a 0-indexed array of integers nums of length n. You are initially positioned at nums[0].

Each element nums[i] represents the maximum length of a forward jump from index i. In other words, if you are at nums[i], you can jump to any nums[i + j] where:

0 <= j <= nums[i] and
i + j < n
Return the minimum number of jumps to reach nums[n - 1]. The test cases are generated such that you can reach nums[n - 1].

Example 1:

Input: nums = [2,3,1,1,4]
Output: 2
Explanation: The minimum number of jumps to reach the last index is 2. Jump 1 step from index 0 to 1, then 3 steps to the last index.
Example 2:

Input: nums = [2,3,0,1,4]
Output: 2

Constraints:

1 <= nums.length <= 104
0 <= nums[i] <= 1000
It’s guaranteed that you can reach nums[n - 1].

Analysis and Solution

Greedy Algorithm

LeetCode C++ as followings Greedy Algorithm

class Solution {
public:
    int jump(vector<int>& nums) {
        if (nums.size() == 1) return 0;
        int curDistance = 0;    // Currently index of covering the furthest distance 
        int ans = 0;            // Record the maximum number of steps taken
        int nextDistance = 0;   // The index of next step covers the furthest distance 
        for (int i = 0; i < nums.size(); i++) {
            nextDistance = max(nums[i] + i, nextDistance);  // Update the index of next step to cover the furthest distance
            if (i == curDistance) {                         // Encountered the index of current coverage of the furthest distance 
                if (curDistance < nums.size() - 1) {       // If the current coverage farthest index is not the end point
                    ans++;                                  // need one more steps
                    curDistance = nextDistance;             // Update the index of currently covering the farthest distance 
                    if (nextDistance >= nums.size() - 1) break; // The coverage of the next step can already reach the end, ending the loop
                } else break;                               // Currently covering the farthest distance can reach the end of the nums, no need to do ans++, stop loop immediately
            }
        }
        return ans;
    }
};