[Swift]LeetCode152. 乘积最大子序列 | Maximum Product Subarray

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

Given an integer array nums, find the contiguous subarray within an array (containing at least one number) which has the largest product.

Example 1:

Input: [2,3,-2,4]
Output: 6
Explanation: [2,3] has the largest product 6.

Example 2:

Input: [-2,0,-1]
Output: 0
Explanation: The result cannot be 2, because [-2,-1] is not a subarray.

---

给定一个整数数组 nums ，找出一个序列中乘积最大的连续子序列（该序列至少包含一个数）。

示例 1:

输入: [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。

示例 2:

输入: [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。

---

12ms

class Solution {
    func maxProduct(_ nums: [Int]) -> Int {
        guard nums.count > 0 else { return 0 }
        
        var minValue = nums[0], maxValue = nums[0], finalValue = nums[0]
        
        for i in 1..<nums.count {
            if nums[i] > 0 {
                maxValue = max(nums[i], maxValue * nums[i])
                minValue = min(nums[i], minValue * nums[i])
            }else {
                var tmp = maxValue
                maxValue = max(nums[i], minValue * nums[i])
                minValue = min(nums[i], tmp * nums[i])
            }
            finalValue = max(finalValue, maxValue)
        }
        
        return finalValue
    }
}

---

16ms

class Solution {
    func maxProduct(_ nums: [Int]) -> Int {
        return getResult(nums)
    }
    
   private func getResult(_ array: [Int]) -> Int {
        var result = array[0]
        var previousMin = array[0]
        var previousMax = array[0]
        var currentMin = array[0]
        var currentMax = array[0]

        for el in array.dropFirst() {
            currentMax = max(max(previousMax * el, previousMin * el), el)
            currentMin = min(min(previousMax * el, previousMin * el), el)
            result = max(currentMax, result)
            previousMax = currentMax
            previousMin = currentMin
        }

        return result
    }
}

---

28ms

class Solution {
    func maxProduct(_ nums: [Int]) -> Int {
        guard !nums.isEmpty else { return 0 }

        var ret = nums.first!
        var (iMin, iMax) = (nums.first!, nums.first!)

        for n in nums.dropFirst() {
            if n < 0 {
                (iMin, iMax) = (iMax, iMin)
            }

            iMin = min(n, iMin * n)
            iMax = max(n, iMax * n)

            ret = max(ret, iMax)
        }

        return ret
    }
}

---

32ms

class Solution {

    func maxProduct(_ nums: [Int]) -> Int {
        guard nums.count > 0 else {
            return 0
        }
        
        var minimum = 1
        var maximum = 1
        var oldMax = maximum
        var globalMax = nums[0]
        
        for num in nums {
            if num < 0 {
                oldMax = maximum
                maximum = max(num, minimum*num)
                minimum = min(num, oldMax*num)
            } else {
                maximum = max(num, maximum*num)
                minimum = min(num, minimum*num)
            }
            globalMax = max(globalMax, maximum)
        }
        
        return globalMax
    }
}

---

36ms

class Solution {
    func maxProduct(_ nums: [Int]) -> Int {
        var lhs = 1
        var rhs = 1
        var maxhs = nums[0]
        
        for i in 0..<nums.count {
            lhs *= nums[i]
            rhs *= nums[nums.count - i - 1]
            maxhs = max(maxhs, lhs, rhs)
            
            if lhs == 0 { lhs = 1}
            if rhs == 0 { rhs = 1}
            
        }
        return maxhs
    }
}

---

40ms

class Solution {
    func maxProduct(_ nums: [Int]) -> Int {
        guard nums.count > 0 else {
            return 0
        }

        var maxN = nums[0], maxT = 1, minT = 1
        for i in 0..<nums.count {
            let tmp1 = maxT * nums[i]
            let tmp2 = minT * nums[i]
            maxN = max(maxN, tmp1, tmp2)
            maxT = max(tmp1, tmp2, 1)
            minT = min(tmp1, tmp2, 1)
        }
        return maxN
    }
}