[Swift]LeetCode123. 买卖股票的最佳时机 III | Best Time to Buy and Sell Stock III

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9953284.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

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

Design an algorithm to find the maximum profit. You may complete at most two transactions.

Note: You may not engage in multiple transactions at the same time (i.e., you must sell the stock before you buy again).

Example 1:

Input: [3,3,5,0,0,3,1,4]
Output: 6
Explanation: Buy on day 4 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
             Then buy on day 7 (price = 1) and sell on day 8 (price = 4), profit = 4-1 = 3.

Example 2:

Input: [1,2,3,4,5]
Output: 4
Explanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
             Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are
             engaging multiple transactions at the same time. You must sell before buying again.

Example 3:

Input: [7,6,4,3,1]
Output: 0
Explanation: In this case, no transaction is done, i.e. max profit = 0.

---

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

设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。

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

示例 1:

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

示例 2:

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

示例 3:

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

---

24ms

class Solution {
    func maxProfit(_ prices: [Int]) -> Int {
        
        if prices.count < 2 {
            return 0
        }
        
        //计算单次获利最大区间
        let receive = findMax(prices, 0, prices.count-1)
        
        //获利金额
        let profitFirst = receive.profit;
        
        //区间起始位置,将数组分成三部分,分别求第二次获利金额
        let startIndex = receive.startIndex;
        let endIndex = receive.endIndex;
        
        var subRange:[(start:Int, end:Int, isMid:Bool)] = []
        subRange.append((0, startIndex - 1, false));
        subRange.append((startIndex, endIndex, true));
        subRange.append((endIndex + 1, prices.count - 1, false));
        
        var profitSecond = 0
        
        for range in subRange {
            
            var tmpProfit = 0
            if range.isMid {
                tmpProfit = -findMin(prices, range.start, range.end).profit
            } else {
                tmpProfit = findMax(prices, range.start, range.end).profit
            }
            
            profitSecond = max(profitSecond, tmpProfit)
        }
        
        
        
        return profitFirst + profitSecond
    }
    
    
    func findMax(_ prices: [Int], _ startFlag: Int, _ endFlag: Int) -> (profit: Int, startIndex: Int, endIndex: Int) {
        
        if startFlag >= endFlag {
            return (0, 0, 0)
        }
        
        var startIndex = 0
        var endIndex = 0
        
        var tmpProfit = 0;
        var tmpStartIndex = startFlag;
        
        var total = 0
        
        for i in startFlag...endFlag {
            
            total = prices[i] - prices[tmpStartIndex]
            
            if total < 0 {
                tmpStartIndex = i
                total = 0
                
            } else {
                
                if total > tmpProfit {
                    tmpProfit = total
                    endIndex = i
                    startIndex = tmpStartIndex
                }
            }
        }

        return (tmpProfit, startIndex, endIndex)
    }
    
    func findMin(_ prices: [Int], _ startFlag: Int, _ endFlag: Int) -> (profit: Int, startIndex: Int, endIndex: Int) {
        
        if startFlag >= endFlag {
            return (0, 0, 0)
        }
        
        var startIndex = 0
        var endIndex = 0
        
        var tmpLoss = 0;
        var tmpStartIndex = startFlag;
        
        var total = 0
        
        for i in startFlag...endFlag {
            
            total = prices[i] - prices[tmpStartIndex]
            
            if total > 0 {
                tmpStartIndex = i
                total = 0
                
            } else {
                
                if total < tmpLoss {
                    tmpLoss = total
                    endIndex = i
                    startIndex = tmpStartIndex
                }
            }
        }
        
        return (tmpLoss, startIndex, endIndex)
    }
}

---

24ms

class Solution {
    func maxProfit(_ prices: [Int]) -> Int {
        var maxPriceFromLeft = Array(repeating:0,count:prices.count)
        var minPrice = Int.max
        var delta = 0
        
        for (day,price) in prices.enumerated() {
            delta = max(price-minPrice,delta) 
            maxPriceFromLeft[day] = delta
            minPrice = min(minPrice,price)
        }

        var ans = 0
        var maxPrice = 0
        delta = 0
        for index in stride(from:prices.count - 1,through:0,by:-1) {
            delta = max(maxPrice - prices[index],delta)
            ans = max(ans,maxPriceFromLeft[index] + delta)
            maxPrice = max(maxPrice,prices[index])
        }
        
        return ans
    }
}

---

DP+状态机。

每个日期有6个整理状态：

1）零交易，不持有股票；

2）完成零交易，持有股票；

3）完成一笔交易，不持有股票；

4）完成一笔交易，持有股票；

5）两个交易完成，股票不持有；

6）两个交易完成，股票被持有。

这种模式可以推广到nt交易，我们可以使用二维数组来保持每个状态的最大利润，其中第一维是已完成交易的数量，第二维是持有股票与否。这个数组的大小是（NT + 1）* 2。

36ms

class Solution {
    func maxProfit(_ prices: [Int]) -> Int {
        if prices.isEmpty {return 0}
        let nt = 2
        var profits = Array(repeating: [0, -prices[0]], count: nt + 1)
        
        for i in 0..<prices.count {
            profits[0][1] = max(profits[0][1], profits[0][0] - prices[i])
            for t in 1...nt {
                let temp = profits[t][0]
                profits[t][0] = max(profits[t][0], profits[t - 1][1] + prices[i])
                profits[t][1] = max(profits[t][1], profits[t][0] - prices[i])
            }
        }
        print(profits)
        return profits.max{$0[0] < $1[0]}![0]
    }
}

---

52ms

class Solution {
    func maxProfit(_ prices: [Int]) -> Int {
        guard prices.count > 0 else {
            return 0
        }
        
        var maxProfit = 0
        var finalMaxProfit = 0
        var maxProfitLeft = [Int]()
        var low = prices.first!
        var high = prices.last!
        
        for price in prices {
            maxProfit = max(price - low, maxProfit)
            low = min(price, low)
            maxProfitLeft.append(maxProfit)
        }
        
        maxProfit = 0
        
        for i in (0..<prices.count).reversed() {
            let price = prices[i]
            maxProfit = max(high - price, maxProfit)
            high = max(price, high)
            finalMaxProfit = max(finalMaxProfit, maxProfit + maxProfitLeft[i])
        }
        
        return finalMaxProfit
    }
}

---

 

104ms

class Solution {
    func maxProfit(_ prices: [Int]) -> Int {
        guard prices.count > 1 else { return 0 }
        
        var curr = Array(repeating: 0, count: 3)
        var res = Array(repeating: 0, count: 3)
        for i in 0..<prices.count - 1 {
            for j in (1...2).reversed() {
                var diff = prices[i + 1] - prices[i]
                curr[j] = max(res[j - 1] + (diff > 0 ? diff : 0), curr[j] + diff)
                res[j] = max(res[j], curr[j])
            }
        }
        return res[2]
    }
}