[Swift]LeetCode915.将分区数组分成不相交的间隔 | Partition Array into Disjoint Intervals

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

Given an array A, partition it into two (contiguous) subarrays left and right so that:

• Every element in left is less than or equal to every element in right.
• left and right are non-empty.
• left has the smallest possible size.

Return the length of left after such a partitioning.  It is guaranteed that such a partitioning exists.

 Example 1:

Input: [5,0,3,8,6]
Output: 3
Explanation: left = [5,0,3], right = [8,6]

Example 2:

Input: [1,1,1,0,6,12]
Output: 4
Explanation: left = [1,1,1,0], right = [6,12]

 Note:

1. 2 <= A.length <= 30000
2. 0 <= A[i] <= 10^6
3. It is guaranteed there is at least one way to partition A as described.

---

 给定的阵列A，它划分为两个（连续的）子阵列  left 和right 使得：

• 每个元素left 都小于或等于中的每个元素right。
• left并且right是非空的。
• left 具有尽可能小的尺寸。

返回长度的left这样的划分之后。保证存在这样的分区。

例1：

输入：[5,0,3,8,6] 
输出：3 
说明：左= [5,0,3]，右= [8,6]

例2：

输入：[1,1,1,0,6,12] 
输出：4 
说明：左= [1,1,1,0]，右= [6,12]

注意：

1. 2 <= A.length <= 30000
2. 0 <= A[i] <= 10^6
3. 保证至少有一种分区方式如上所述A。

---

36ms

class Solution {
    func partitionDisjoint(_ A: [Int]) -> Int {

        var maxSoFar = A[0], previousMax = A[0], answer = 1
        
        for i in 0..<A.count {
            
            if A[i] < maxSoFar &&
                A[i] < previousMax {
                answer = i + 1
                previousMax = maxSoFar
            } else if A[i] > maxSoFar {
                maxSoFar = A[i]
            }
        }
        
        return answer
    }
}

---

56ms

class Solution {
     func partitionDisjoint(_ A: [Int]) -> Int {
        if A.isEmpty {
            return 0
        }

        var indexAndMin: (Int, Int) = (0, A[0])

        // find min - O(N)
        for (i, v) in A.enumerated() {
            if indexAndMin.1 >= v {
                indexAndMin = (i, v)
            }
        }

        // find left max - O(N)
        var leftMax = 0
        for i in 0...indexAndMin.0 {
            leftMax = max(A[i], leftMax)
        }

        // find right less - O(N)
        var pivotIndex = 0
        var leftMaxCandidate = leftMax
        var i = indexAndMin.0

        while i < A.count {
            leftMaxCandidate = max(A[i], leftMaxCandidate)

            if A[i] < leftMax {
                leftMax = leftMaxCandidate
                pivotIndex = i
            }
            i += 1
        }

        return pivotIndex + 1
    }
}

---

60ms

class Solution {
    func partitionDisjoint(_ A: [Int]) -> Int {
        var dpM = [Int](repeating: 0, count: A.count)
        var dpm = [Int](repeating: 0, count: A.count)
        var M = 0
        var m = Int(Int32.max)
        for i in 0 ..< A.count {
            M = max(M, A[i])
            dpM[i] = M
        }
        for i in (0 ..< A.count).reversed() {
            m = min(m, A[i])
            dpm[i] = m
        }
        for i in 0 ..< A.count-1 {
            if dpM[i] <= dpm[i+1] {
                return i+1
            } 
        }
        return -1
        
    }
}

---

80ms

class Solution {
    func partitionDisjoint(_ A: [Int]) -> Int {
        var leftBiggest = Array(repeating: 0, count: A.count)
        var rightSmallest = Array(repeating: 0, count: A.count)
        
        leftBiggest[0] = A[0]
        for i in 1..<A.count {
            leftBiggest[i] = max(leftBiggest[i-1], A[i])
        }
        
        rightSmallest[A.count - 1] = A[A.count - 1]
        for i in (0..<A.count-1).reversed() {
            rightSmallest[i] = min(rightSmallest[i+1], A[i])
        }
        
        for i in 0..<A.count-1 {
            if leftBiggest[i] <= rightSmallest[i+1] {
                return i + 1
            }
        }
        
        return -1
    }
}

---

104ms

class Solution {
    func partitionDisjoint(_ A: [Int]) -> Int {
        var maxArray = A
        var minArray = A
        for i in 1..<maxArray.count {
            maxArray[i] = max(maxArray[i], maxArray[i - 1])
        }
        for i in (0...maxArray.count - 2).reversed() {
            minArray[i] = min(A[i + 1], minArray[i + 1])
        }
        for i in 0...A.count - 1 {
            if maxArray[i] <= minArray[i] {
                return i + 1
            }
        }
        return -1
    }
}

---

120ms

class Solution {
        var debug = false
        init(debug: Bool = false) {
            self.debug = debug
        }
        func partitionDisjoint(_ A: [Int]) -> Int {
            return partitionDisjoint(A, start: 0, end: A.count - 1, leftMax: -1)
        }
        func partitionDisjoint(_ arr: [Int], start: Int, end: Int, leftMax: Int) -> Int {
            if debug {
                let subarray = arr[start...end]
                print("============start: (start), end: (end), (subarray)")
            }
            var min = Int.max
            var minIndex = -1
            var max = -1
            var maxIndex = -1
            for (index, num) in arr.enumerated() where index >= start && index <= end {
                if num < min {
                    min = num
                    minIndex = index
                }
                if num >= max {
                    max = num
                    maxIndex = index
                }
            }

            var leftMax = -1
            var rightMin = Int.max
            var rightMinIndex = -1
            var partitionIndex = minIndex
            var newStart = start

            while leftMax < 0 || leftMax > rightMin {
                newStart = leftMax < 0 ? start : partitionIndex
                partitionIndex = rightMinIndex
                rightMin = Int.max
                rightMinIndex = -1
                for (index, num) in arr.enumerated() where index >= newStart && index < maxIndex {
                    if index <= partitionIndex {
                        if num > leftMax {
                            leftMax = num
                        }
                        continue
                    }
                    if num < rightMin {
                        rightMin = num
                        rightMinIndex = index
                    }
                    if num < leftMax {
                        rightMinIndex = index
                    }
                }
            }
            return partitionIndex + 1
        }
    }

---

128ms

class Solution {
    func partitionDisjoint(_ A: [Int]) -> Int {
        var lmax = A.first!
        var rmin = A[1..<A.count].min()!
        for i in 0...(A.count-2) {
            lmax = max(lmax, A[i])
            if (A[i]==rmin) {  rmin = A[(i+1)..<A.count].min()! }
            if lmax <= rmin { return i+1 }
        }
        return 0
    }
}

---

300ms

class Solution {
    func partitionDisjoint(_ A: [Int]) -> Int {
        var n = A.count
        var pre:[Int] = [Int](repeating: 0,count: n + 1)
        for i in 0..<n
        {
            pre[i + 1] = max(pre[i], A[i])
            
        }
        var suf:[Int] = [Int](repeating: 0,count: n + 1)
        suf[n] = 999999999
        for i in (0..<n).reversed()
        {
            suf[i] = min(suf[i+1], A[i])
        }
        for i in 1..<n
        {
            if pre[i] <= suf[i]
            {
                return i
            }
        }
        fatalError()
    }
}

---

320ms

class Solution {
    func partitionDisjoint(_ A: [Int]) -> Int {
        var leftMax = A[0], maxVal = A[0], len = 1
        for i in 1..<A.count {
            if A[i] < leftMax {
                // A[i] is smaller, so it must be included to the left
                len = i + 1
                // Update leftMax to latest maxVal
                leftMax = maxVal
            } else if A[i] > maxVal {
                maxVal = A[i]
            }
        }
        return len
    }
}

---

324ms

class Solution {
    func partitionDisjoint(_ A: [Int]) -> Int {
        var localMax = A[0]
        var partitionIdx = 0
        var maxV = localMax
        for i in 1..<A.count{
            if localMax > A[i]{
                localMax = maxV
                partitionIdx = i
            } else {
                maxV = max(maxV, A[i])
            }
        }
        
        return partitionIdx + 1
    }
}

---

328ms

class Solution {
    func partitionDisjoint(_ A: [Int]) -> Int {
        var leftMax = A[0], maxVal = A[0], len = 1
        for i in 1..<A.count {
            if A[i] < leftMax {
                // A[i] is smaller, so it must be included to the left
                len = i + 1
                // Update leftMax to latest maxVal
                leftMax = maxVal
            } else {
                maxVal = max(maxVal, A[i])
            }
        }
        return len
    }
}

---

340ms

class Solution {
    func partitionDisjoint(_ A: [Int]) -> Int {
        var minRight = [Int](repeating: 0, count: A.count)
        var min = Int.max
        for i in stride(from:A.count - 1, through: 0, by: -1) {
            if A[i] < min {
                min = A[i]
            }
            minRight[i] = min
            
            if min == 0 {
                break
            }
        }
        
        var max = A[0]
        for i in 1..<A.count {
            if max <= minRight[i] {
                return i
            }
            if A[i] > max {
                max = A[i]
            }
        }
        return 0
    }
}

---

344ms

class Solution {
    func partitionDisjoint(_ A: [Int]) -> Int {
        var minArray = A
        for idx in (1 ..< A.count-1).reversed() {
            minArray[idx] = min(minArray[idx], minArray[idx+1])
        }
        var maxValue = A[0]
        for idx in 0 ..< A.count {
            maxValue = max(maxValue, A[idx])
            if maxValue <= minArray[idx + 1] { return idx+1 }
        }
        fatalError()
    }
}

---

372ms

class Solution {
    func partitionDisjoint(_ A: [Int]) -> Int {
        var maxSoFar = A[0], previousMax = A[0], answer = 1
        
        for i in 0..<A.count {
            
            if A[i] < maxSoFar &&
                A[i] < previousMax {
                answer = i + 1
                previousMax = maxSoFar
            } else if A[i] > maxSoFar {
                maxSoFar = A[i]
            }
        }
        
        return answer
    }
}

---

400ms

class Solution {
    func partitionDisjoint(_ A: [Int]) -> Int {
        var leftMax = A[0]
        var sorted = A.sorted()
        
        var rightMin = sorted[0]
        sorted.remove(at: sorted.index(of: A[0])!)
        var idx = 1
        while idx < A.count {
            defer { idx += 1 }
            let a = A[idx]
            if leftMax <= rightMin {
                return idx
            }
            
            leftMax = max(leftMax, a)
            if sorted.count == 0 { break }
            let t = binarySearch(sorted, a)!
            sorted.remove(at: t)
            rightMin = sorted[0]
        }
        
        return A.count
    }
    
    func binarySearch<T: Comparable>(_ a: [T], _ key: T) -> Int? {
        var lowerBound = 0
        var upperBound = a.count
        while lowerBound < upperBound {
            let midIndex = lowerBound + (upperBound - lowerBound) / 2
            if a[midIndex] == key {
                return midIndex
            } else if a[midIndex] < key {
                lowerBound = midIndex + 1
            } else {
                upperBound = midIndex
            }
        }
        return nil
    }
}

---

496ms

class Solution {
    func partitionDisjoint(_ A: [Int]) -> Int {
        var leftMax = A[0]
        var rightMin = Int.max
        var sorted = A.sorted()
        
        rightMin = sorted[0]
        sorted.remove(at: sorted.index(of: A[0])!)
        var index = 1
        while index < A.count {
            defer { index += 1 }
            let a = A[index]
            if leftMax <= rightMin {
                return index
            }
            
            leftMax = max(leftMax, a)
            if sorted.count == 0 { break }
            let t = binarySearch(sorted, a)!
            //print(index, leftMax, rightMin, t)
            //print(sorted)
            sorted.remove(at: t)
            rightMin = sorted[0]
        }
        
        return A.count
    }
    
func binarySearch<T: Comparable>(_ a: [T], _ key: T) -> Int? {
    var lowerBound = 0
    var upperBound = a.count
    while lowerBound < upperBound {
        let midIndex = lowerBound + (upperBound - lowerBound) / 2
        if a[midIndex] == key {
            return midIndex
        } else if a[midIndex] < key {
            lowerBound = midIndex + 1
        } else {
            upperBound = midIndex
        }
    }
    return nil
}
    
}

---

552ms

class Solution {
    func partitionDisjoint(_ A: [Int]) -> Int {
        var leftMax = A[0], maxVal = A[0], len = 1
        for i in 1..<A.count {
            if A[i] < leftMax {
                // A[i] is smaller, so it must be included to the left
                len = i + 1
                // Update leftMax to latest maxVal
                leftMax = maxVal
            } else if A[i] > maxVal{
                maxVal = A[i]
            }
        }
        return len
    }
}