股票的最大利润2

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

输入: [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
     随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。

输入: [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
     注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
     因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

---

主要是需要把问题转成一个数学问题, 可以理解成找一个数组的递增序列, 然后用极大值-极小值, 还是看图好理解.

现在问题就是怎么确定哪个是极大值,哪个是极小值,在数学上
极小值是price[left]>price[left-1] && price[left]>price[left+1],
极大值是 price[right]>price[right-1] && price[right]>price[right+1], 

实际写的时候, 使用滑动窗口, 在遍历过程中, 每次都增加right的值, 如果leftValue>rightValue,说明此时是下降过程, left的值不对,更新下left;   如果leftValue<rightValue,说明此时是上升过程, left就是附近区域的极小值了.

如何在遍历的过程中确定极大值? 如果right<right+1, 说明还是在上升, 继续增加right;  如果right>right+1, 这说明到本次上升的拐点了, 需要计算下本段上升区间的收益了.

计算好 每段区间的(极大值-极小值), 最终汇总到result中, 就是整体的最大收益了. 整体只需遍历一次, 时间复杂度是O(N).

class Solution {
    func maxProfit(_ prices: [Int]) -> Int {

        // 极小值的下标
        var left = 0
        // 极大值的下标
        var right = 0
        // 最大利润和
        var result = 0

        while right<prices.count {

            // 记录左边值和右边值
            let leftValue = prices[left]
            let rightValue = prices[right]
            // leftValue > rightValue, 说明是处于下降序列中,更新left,直到left是极小值的下标
            if leftValue > rightValue {
                left = right
            }
            // 说明到了最后一天
            if right+1 == prices.count  {
                // 最后一天,只要超过leftValue就可以卖
                if rightValue>leftValue {
                    result += rightValue - leftValue
                }
            } else if rightValue>prices[right+1] {
                // rightValue>prices[right+1], 后一个值比right小,说明right就是此段区间的极大值了,计算一次收益
                result += rightValue - leftValue
                left = right+1
            }
            right += 1

        }
        return result
    }
}

 

---

看了题解, 有动态规划和贪心算法2种, 动态规划比较复杂, 就不写了, 贪心算法倒是比较好理解, 可以认为是对上述算法的优化.

贪心算法的直觉：由于不限制交易次数，只要今天股价比昨天高，就交易。 这样就不用找区间的极大值,极小值了

下面对这个算法进行几点说明：

该算法仅可以用于计算，但 计算的过程并不是真正交易的过程，但可以用贪心算法计算题目要求的最大利润。下面说明等价性：以 [1, 2, 3, 4] 为例，这 4 天的股价依次上升，按照贪心算法，得到的最大利润是：

res =  (prices[3] - prices[2]) + (prices[2] - prices[1]) + (prices[1] - prices[0])
    =  prices[3] - prices[0]

仔细观察上面的式子，按照贪心算法，在下标为 1、2、3 的这三天，我们做的操作应该是买进昨天的，卖出今天的，虽然这种操作题目并不允许，但是它等价于：在下标为 0 的那一天买入，在下标为 3 的那一天卖出, 这样就是和极大值-极小值等价了

为什么叫「贪心算法」
回到贪心算法的定义：

贪心算法 在每一步总是做出在当前看来最好的选择。

「贪心算法」 和 「动态规划」、「回溯搜索」 算法一样，完成一件事情，是 分步决策 的；
「贪心算法」 在每一步总是做出在当前看来最好的选择，我是这样理解 「最好」 这两个字的意思：
「最好」 的意思往往根据题目而来，可能是 「最小」，也可能是 「最大」；
贪心算法和动态规划相比，它既不看前面（也就是说它不需要从前面的状态转移过来），也不看后面（无后效性，后面的选择不会对前面的选择有影响），因此贪心算法时间复杂度一般是线性的，空间复杂度是常数级别的；
这道题 「贪心」 的地方在于，对于 「今天的股价 - 昨天的股价」，得到的结果有 3 种可能：① 正数，② 00，③负数。贪心算法的决策是： 只加正数 。

贪心算法时间复杂度也是O(N), 但是写法上简洁很多. 

class Solution {
    func maxProfit(_ prices: [Int]) -> Int {

        // 最大利润和
        var result = 0
        for i in 1..<prices.count {
            // 只要i比i-1高, 就计算一次收益
            result += max(0, prices[i]-prices[i-1])
        }
        return result
    }
}