Question

121. Best Time to Buy and Sell Stock

中文文档

Description

You are given an array prices where prices[i] is the price of a given stock on the ith day.

You want to maximize your profit by choosing a single day to buy one stock and choosing a different day in the future to sell that stock.

Return _the maximum profit you can achieve from this transaction_. If you cannot achieve any profit, return 0.

 

Example 1:

Input: prices = [7,1,5,3,6,4]
Output: 5
Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell.

Example 2:

Input: prices = [7,6,4,3,1]
Output: 0
Explanation: In this case, no transactions are done and the max profit = 0.

 

Constraints:

• 1 <= prices.length <= 105
• 0 <= prices[i] <= 104

Solutions

Solution 1: Enumerate + Maintain the Minimum Value of the Prefix

We can enumerate each element of the array $nums$ as the selling price. Then we need to find a minimum value in front of it as the purchase price to maximize the profit.

Therefore, we use a variable $mi$ to maintain the prefix minimum value of the array $nums$. Then we traverse the array $nums$ and for each element $v$, calculate the difference between it and the minimum value $mi$ in front of it, and update the answer to the maximum of the difference. Then update $mi = min(mi, v)$. Continue to traverse the array $nums$ until the traversal ends.

Finally, return the answer.

The time complexity is $O(n)$, where $n$ is the length of the array $nums$. The space complexity is $O(1)$.

class Solution:
  def maxProfit(self, prices: List[int]) -> int:
    ans, mi = 0, inf
    for v in prices:
      ans = max(ans, v - mi)
      mi = min(mi, v)
    return ans

class Solution {
  public int maxProfit(int[] prices) {
    int ans = 0, mi = prices[0];
    for (int v : prices) {
      ans = Math.max(ans, v - mi);
      mi = Math.min(mi, v);
    }
    return ans;
  }
}

class Solution {
public:
  int maxProfit(vector<int>& prices) {
    int ans = 0, mi = prices[0];
    for (int& v : prices) {
      ans = max(ans, v - mi);
      mi = min(mi, v);
    }
    return ans;
  }
};

func maxProfit(prices []int) (ans int) {
  mi := prices[0]
  for _, v := range prices {
    ans = max(ans, v-mi)
    mi = min(mi, v)
  }
  return
}

function maxProfit(prices: number[]): number {
  let ans = 0;
  let mi = prices[0];
  for (const v of prices) {
    ans = Math.max(ans, v - mi);
    mi = Math.min(mi, v);
  }
  return ans;
}

impl Solution {
  pub fn max_profit(prices: Vec<i32>) -> i32 {
    let mut res = 0;
    let mut min = i32::MAX;
    for price in prices {
      res = res.max(price - min);
      min = min.min(price);
    }
    res
  }
}

/**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function (prices) {
  let ans = 0;
  let mi = prices[0];
  for (const v of prices) {
    ans = Math.max(ans, v - mi);
    mi = Math.min(mi, v);
  }
  return ans;
};

public class Solution {
  public int MaxProfit(int[] prices) {
    int ans = 0, mi = prices[0];
    foreach (int v in prices) {
      ans = Math.Max(ans, v - mi);
      mi = Math.Min(mi, v);
    }
    return ans;
  }
}

class Solution {
  /**
   * @param Integer[] $prices
   * @return Integer
   */
  function maxProfit($prices) {
    $win = 0;
    $minPrice = $prices[0];
    $len = count($prices);
    for ($i = 1; $i < $len; $i++) {
      $minPrice = min($minPrice, $prices[$i]);
      $win = max($win, $prices[$i] - $minPrice);
    }
    return $win;
  }
}