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

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10179523.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 ktransactions.

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

Example 1:

Input: [2,4,1], k = 2
Output: 2
Explanation: Buy on day 1 (price = 2) and sell on day 2 (price = 4), profit = 4-2 = 2.

Example 2:

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

---

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

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

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

示例 1:

输入: [2,4,1], k = 2
输出: 2
解释: 在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。

示例 2:

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

---

48ms

class Solution {
    func maxProfit(_ k: Int, _ prices: [Int]) -> Int {
guard prices.count > 1, k > 0 else { return 0 }
    let n = prices.count
    
    if k >= (n / 2) {
        var res = 0
        for i in 1..<n {
            if (prices[i] > prices[i-1]) {
                res += prices[i] - prices[i-1]
            }
            
        }
        return res
    }
        var mp = [[Int]](repeating: [Int](repeating: 0, count: k + 1), count: prices.count)
    for i in 1...k {
        var localMax = -prices[0]
        for j in 1..<n {
            mp[j][i] = max(mp[j-1][i], prices[j]+localMax)
            localMax = max(localMax, mp[j-1][i-1]-prices[j])
        }
    }
    return mp[prices.count-1][k]
    }
}

---

52ms

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

        var n = prices.count
        if n < 2 || k == 0 { return 0 }
        if k >= n { return maxProfit(prices)}
        var l = Array(repeating: 0, count: k+1)
        var g = Array(repeating: 0, count: k+1)
        for i in 0..<n-1 {
            var diff = prices[i+1] - prices[i]
            for j in stride(from: k, through: 1, by: -1){
                l[j] = max(g[j-1] + max(diff, 0), l[j] + diff)
                g[j] = max(g[j], l[j])
            }
        }
        

        return g[k];

    }
    func maxProfit(_ prices: [Int]) -> Int {
        var res = 0
        for i in 1..<prices.count {
            res += max(0, prices[i] - prices[i-1])
        }
        return res
    }
}

---

120ms

class Solution {
    func maxProfit(_ k: Int, _ prices: [Int]) -> Int {
        if k == 0 || prices.count < 2 {
            return 0
        }
        
        let count = prices.count
        if count <= k * 2 + 1 {
            return maxProfitUn(prices)
        }
        
        if k == 2 {
            return maxProfitTwo(prices)
        }
        
        var mustSell = Array(repeating: Array(repeating: 0 , count: k+1), count: count)
        var globalSell = Array(repeating: Array(repeating: 0, count: k+1), count: count)
        
        for j in 1...k {
            for i in 1..<count {
                var profit = prices[i] - prices[i-1]
                profit = max(profit, 0)
                mustSell[i][j] = max(globalSell[i-1][j-1] + profit, mustSell[i-1][j] + prices[i] - prices[i-1])
                globalSell[i][j] = max(globalSell[i-1][j], mustSell[i][j])
            }
        }
        
        return globalSell[count-1][k]
    }
    
    func maxProfitUn(_ prices : [Int]) -> Int {
        if prices.count < 2 {
            return 0
        }
        
        let count = prices.count
        var res = 0
        for i in 1..<count {
            if prices[i] > prices[i-1] {
                res += prices[i] - prices[i-1]
            }
        }
        
        return res
    }
    
    func maxProfitTwo(_ prices : [Int]) -> Int {
        if prices.count < 2 {
            return 0
        }
        
        let count = prices.count
        
        var curMax = 0
        
        var dp = Array(repeating: 0, count: count)
        
        var curMin = prices[0]
        for i in 1..<count {
            curMax = max(curMax, prices[i] - curMin)
            curMin = min(curMin, prices[i])
            dp[i] = curMax
        }
        
        var maxPrice = prices[count - 1]
        curMax = 0
        var dp2 = Array(repeating: 0, count: count)
        for i in stride(from: count-1, to: -1, by: -1) {
            curMax = max(curMax, maxPrice - prices[i])
            maxPrice = max(maxPrice, prices[i])
            dp2[i] = curMax
        }
        
        curMax = 0
        for i in stride(from: count-1, to: 0, by: -1) {
            curMax = max(curMax, dp[i] + dp2[i])
        }
        
        return curMax
    }
}

---

704ms

class Solution {
    
    struct Section {
        
        var start: Int
        var end: Int
        var hasProfit: Bool
        var countedProfit: Int?
        var countedStart: Int?
        var countedEnd: Int?
        var countedHasProfit: Bool?
        
        init() {
            self.start = 0
            self.end = 0
            self.hasProfit = false
        }
        
        init(start: Int, end: Int, hasProfit: Bool) {
            
            self.start = start
            self.end = end
            self.hasProfit = hasProfit
        }
    }
    
    func maxProfit(_ k: Int, _ prices: [Int]) -> Int {
        
        if prices.count < 2 {
            return 0
        }
        
        var totalProfit = 0
        

        var subRange:[Section] = []
        
        subRange.append(Section.init(start: 0, end: prices.count-1, hasProfit: false))
        
        for _ in 0..<k {
            
            var maxProfit = 0
            var tmpProfit = 0
            
            var maxIndex = -1
            
            var maxSection = Section.init()
            
            for index in 0..<subRange.count {
                
                var tmpSection = Section.init()
                
                if let countedProfit = subRange[index].countedProfit {

                    tmpProfit = countedProfit
                    
                    tmpSection.start = subRange[index].countedStart!
                    tmpSection.end = subRange[index].countedEnd!
                    tmpSection.hasProfit = subRange[index].countedHasProfit!
                    
                } else {
                    if subRange[index].hasProfit {
                        
                        tmpProfit = -findMin(prices, subRange[index].start, subRange[index].end, &tmpSection)

                    } else {
                        
                        tmpProfit = findMax(prices, subRange[index].start, subRange[index].end, &tmpSection)
                    }
                    
                    
                    subRange[index].countedProfit = tmpProfit
                    subRange[index].countedStart = tmpSection.start
                    subRange[index].countedEnd = tmpSection.end
                    subRange[index].countedHasProfit = tmpSection.hasProfit
                }
            
                if maxProfit < tmpProfit {
                    
                    maxProfit = tmpProfit
                    maxIndex = index

                    maxSection = tmpSection
                }
            }

            if maxIndex < 0 {
                
                break
            } else {
                
                let tmp = subRange[maxIndex]
                
                
                maxSection.countedProfit = nil
                maxSection.countedStart = nil
                maxSection.countedEnd = nil
                
                if tmp.hasProfit {
                    
                    if maxSection.start > tmp.start {
                        subRange.append(Section.init(start: tmp.start, end:maxSection.start, hasProfit: true))
                    }
                    
                    if maxSection.end < tmp.end {
                        subRange.append(Section.init(start: maxSection.end, end: tmp.end, hasProfit: true))
                    }

                    maxSection.start += 1
                    maxSection.end -= 1
                    
                    if maxSection.start < maxSection.end {
                        subRange[maxIndex] = maxSection
                    } else {
                        subRange.remove(at: maxIndex)
                    }
                    
                    
                } else {
                    
                    if tmp.start < maxSection.start - 1 {
                        subRange.append(Section.init(start: tmp.start, end: maxSection.start - 1, hasProfit: false))
                    }
                    
                    if maxSection.end + 1 < tmp.end {
                        subRange.append(Section.init(start: maxSection.end + 1, end: tmp.end, hasProfit: false))
                    }
                    
                    subRange[maxIndex] = maxSection
                    
                }
                
                totalProfit += maxProfit
                
            }
            
        }
        
        return totalProfit
    }
    
    func findMax(_ prices: [Int], _ startFlag: Int, _ endFlag: Int, _ section: inout Section) -> Int {
        
        if startFlag >= endFlag {
            return 0
        }

        section.hasProfit = true
        
        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
                    section.end = i
                    section.start = tmpStartIndex
                }
            }
        }
        
        return tmpProfit
    }
    
    func findMin(_ prices: [Int], _ startFlag: Int, _ endFlag: Int, _ section: inout Section) -> Int {
        
        if startFlag >= endFlag {
            return 0
        }
        
        
        section.hasProfit = false
        
        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
                    section.end = i
                    section.start = tmpStartIndex
                }
            }
        }
        
        return tmpLoss
    }
}

---

3464ms

class Solution {
    
    class Section {
        
        var start: Int
        var end: Int
        var hasProfit: Bool
        
        
        init(start: Int, end: Int, hasProfit: Bool) {
            
            self.start = start
            self.end = end
            self.hasProfit = hasProfit
        }
    }
    
    func maxProfit(_ k: Int, _ prices: [Int]) -> Int {
        
        if prices.count < 2 {
            return 0
        }
        
        var totalProfit = 0
        

        var subRange:[Section] = []
        
        subRange.append(Section.init(start: 0, end: prices.count-1, hasProfit: false))
        
        for _ in 0..<k {
            
            
            var maxProfit = 0
            var tmpProfit = 0
            
            var maxSectionStart = 0
            var maxSectionEnd = 0
            
            var maxIndex = -1
            
            for index in 0..<subRange.count {
                
                var tmpReceive: (profit: Int, startIndex: Int, endIndex: Int)
           
                
                if subRange[index].hasProfit {
                    tmpReceive = findMin(prices, subRange[index].start, subRange[index].end)
                    tmpProfit = -tmpReceive.profit
                    
                } else {
                    
                    tmpReceive = findMax(prices, subRange[index].start, subRange[index].end)
                    tmpProfit = tmpReceive.profit
                }
                
                
                if maxProfit < tmpProfit {
                    
                    maxProfit = tmpProfit
                    maxIndex = index

                    maxSectionStart = tmpReceive.startIndex
                    maxSectionEnd = tmpReceive.endIndex

                }
            }

            if maxIndex < 0 {
                
                break
            } else {
                
                let tmp = subRange[maxIndex]
                
            
                if tmp.hasProfit {
                    
                    subRange.append(Section.init(start: tmp.start, end: maxSectionStart, hasProfit: true))
                    subRange.append(Section.init(start: maxSectionEnd, end: tmp.end, hasProfit: true))
                    
                    tmp.start = maxSectionStart + 1
                    tmp.end = maxSectionEnd - 1
                    tmp.hasProfit = false
//                    subRange[maxIndex] = tmp
                    
                } else {
                    
                    
                    subRange.append(Section.init(start: tmp.start, end: maxSectionStart - 1, hasProfit: false))
                    subRange.append(Section.init(start: maxSectionEnd + 1, end: tmp.end, hasProfit: false))
                    
                    tmp.start = maxSectionStart
                    tmp.end = maxSectionEnd
                    tmp.hasProfit = true
//                    subRange[maxIndex] = tmp
                    
                }
                
                totalProfit += maxProfit
                
            }
            
        }
        
        return totalProfit
    }
    
    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)
    }
}