leetcode 121. Best Time to Buy and Sell Stock

最新推荐文章于 2025-04-18 22:24:21 发布

原创最新推荐文章于 2025-04-18 22:24:21 发布 · 346 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

leetcode 专栏收录该内容

57 篇文章

订阅专栏

本文介绍了一种寻找股票买卖最佳时机以实现最大利润的算法。该算法通过一次遍历即可得出结果，时间复杂度为O(n)。文章提供了两种解决方案：一种是直观解法，通过记录之前的最低价格来计算当前的最大收益；另一种是使用Kadane算法，适用于价格差数组的情况。

Say you have an array for which the ith element is the price of a given stock on day i.

If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.

Example 1:
Input: [7, 1, 5, 3, 6, 4]
Output: 5

max. difference = 6-1 = 5 (not 7-1 = 6, as selling price needs to be larger than buying price)
Example 2:
Input: [7, 6, 4, 3, 1]
Output: 0

In this case, no transaction is done, i.e. max profit = 0.

主要是找出买入卖出的时机，其实只需要知道卖出的时间即可。这样可以将时间复杂度控制在O(n)
我的直观解法是，用一个变量pre记录访问到当前元素前的最小值，这样如果在当前位置卖出，那么买入点应该是之前最下值处。

public class Solution {
    public int maxProfit(int[] prices) {
        if(prices==null||prices.length==0) return 0;
        int res = 0;
        int pre = prices[0];
        for(int i=1; i< prices.length; i++){
            int cur = prices[i] - pre;
            res = Math.max(res, cur);
            if(prices[i] < pre) pre = prices[i];
        }
        return res;
    }
}

目前Top answer给出的是另一种解法

Kadane's Algorithm - Since no one has mentioned about this so far :) (In case if interviewer twists the input)
The logic to solve this problem is same as "max subarray problem" using Kadane's Algorithm. Since no body has mentioned this so far, I thought it's a good thing for everybody to know.

All the straight forward solution should work, but if the interviewer twists the question slightly by giving the difference array of prices, Ex: for {1, 7, 4, 11}, if he gives {0, 6, -3, 7}, you might end up being confused.

Here, the logic is to calculate the difference (maxCur += prices[i] - prices[i-1]) of the original array, and find a contiguous subarray giving maximum profit. If the difference falls below 0, reset it to zero.

    public int maxProfit(int[] prices) {
        int maxCur = 0, maxSoFar = 0;
        for(int i = 1; i < prices.length; i++) {
            maxCur = Math.max(0, maxCur += prices[i] - prices[i-1]);
            maxSoFar = Math.max(maxCur, maxSoFar);
        }
        return maxSoFar;
    }
*maxCur = current maximum value

*maxSoFar = maximum value found so far

这里核心是下面这句

 maxCur = Math.max(0, maxCur += prices[i] - prices[i-1]);

maxCur也是在当前点卖出的收益，那么一个计算方法是，如果在下一个点卖出那么可以根据收益的增加来更新下一个点的收益。还是觉得我的解法跟直观