LeetCode best-time-to-buy-and-sell-stock

题目描述

假设你有一个数组，其中第i个元素是某只股票在第i天的价格。
如果你最多只能完成一笔交易(即买一股和卖一股股票)，设计一个算法来求最大利润。

解题思路

方法一

由于最多只能完成一笔交易，因此可以将其视为寻找最大的连续子序和，因此，我们按照这个思路来求解。

设立start来记录子序的首元素，每次都更新结果sum为price[i] - start，这样可以得到当前的子序和，将其与max进行比较，大了就更新。

关键在此！将其与0比较，如果小于0说明之前的子序和是负数，没有意义可以舍弃，因此将sum重置为0，再更新start为当前元素，重新开始。

class Solution {
public:
    int maxProfit(vector<int> &prices) {
        int sum = 0, max = 0;
        if(prices.size() <= 1)
            return 0;
        int start = prices[0];
        for(int i = 0; i < prices.size(); i++){
            sum = prices[i] - start;
            if( max < sum)
                max = sum;
            if(sum < 0){  //归零，前面的不要了，更新start
                sum = 0;
                start = prices[i];
            }
        }
        return max;
    }
};

Java方法

class Solution {
    public int maxProfit(int[] prices) {
        if(prices.length <= 1)
            return 0;
        int max = 0, min = prices[0];  //一个记录结果，一个记录当前前面遍历的最小值
        for(int i = 1; i < prices.length; i++){
           max = Math.max(max, prices[i] - min);
           min = Math.min(min, prices[i]);
        }
        return max;
    }
}

 

方法二

采用动态规划方法

class Solution {
    public int maxProfit(int[] prices) {
        int[] dp = new int[prices.length + 1];
        if(prices.length <= 0)
            return 0;
        int res = 0, min = prices[0];  //一个记录结果，一个记录当前前面遍历的最小值
        for(int i = 1; i < prices.length; i++){
            if(prices[i] >= prices[i - 1]){
                dp[i] = dp[i - 1] + prices[i] - prices[i - 1];
                res = Math.max(res, dp[i]); 
            }
            else{
                if(min < prices[i])  // 更大
                    dp[i] = prices[i] - min;  //得到当前的dp[i]
                else{
                    min = prices[i];
                    dp[i] = 0;
                }
            }
        }
        return res;
    }
}