【LeetCode】121. Best Time to Buy and Sell Stock

问题描述

问题链接：https://leetcode.com/problems/best-time-to-buy-and-sell-stock/#/description

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.

我的代码

本来是想用动态规划来做的，但是想了想，做的时候变成暴力求解了，然后果断超时。

然后去讨论区看了一个代码，觉得能理解，就写上来了。

public class Solution {
    public int maxProfit(int[] prices) {
        /*
        思路是使用动态规划来求解
        用sofaMin表示到目前为止的最小值，状态转移公式为maxProfile = max(maxProfile,prices[i] - sofaMin)
        */
        if(prices.length == 0){
            return 0;
        }
        int len = prices.length;
        int maxProfit = 0;
        int sofaMin = prices[0];
        for(int i = 0; i < len; i++){
            if(prices[i] > sofaMin){
                maxProfit = Math.max(maxProfit, prices[i] - sofaMin);
            }else {
                sofaMin = prices[i];
            }
        }
        return maxProfit;
    }
}

再到讨论区学习一个。

讨论区

Sharing my simple and clear C++ solution

链接地址：https://discuss.leetcode.com/topic/5863/sharing-my-simple-and-clear-c-solution

这个讲的很清楚。

int maxProfit(vector<int> &prices) {
    int maxPro = 0;
    int minPrice = INT_MAX;
    for(int i = 0; i < prices.size(); i++){
        minPrice = min(minPrice, prices[i]);
        maxPro = max(maxPro, prices[i] - minPrice);
    }
    return maxPro;
}

Kadane’s Algorithm - Since no one has mentioned about this so far :) (In case if interviewer twists the input)

链接地址：https://discuss.leetcode.com/topic/19853/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