[Swift]LeetCode849. 到最近的人的最大距离 | Maximize Distance to Closest Person

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

In a row of seats, 1 represents a person sitting in that seat, and 0 represents that the seat is empty. 

There is at least one empty seat, and at least one person sitting.

Alex wants to sit in the seat such that the distance between him and the closest person to him is maximized. 

Return that maximum distance to closest person.

Example 1:

Input: [1,0,0,0,1,0,1]
Output: 2
Explanation: 
If Alex sits in the second open seat (seats[2]), then the closest person has distance 2.
If Alex sits in any other open seat, the closest person has distance 1.
Thus, the maximum distance to the closest person is 2.

Example 2:

Input: [1,0,0,0]
Output: 3
Explanation: 
If Alex sits in the last seat, the closest person is 3 seats away.
This is the maximum distance possible, so the answer is 3.

Note:

1. 1 <= seats.length <= 20000
2. seats contains only 0s or 1s, at least one 0, and at least one 1.

---

在一排座位（ seats）中，1 代表有人坐在座位上，0 代表座位上是空的。

至少有一个空座位，且至少有一人坐在座位上。

亚历克斯希望坐在一个能够使他与离他最近的人之间的距离达到最大化的座位上。

返回他到离他最近的人的最大距离。

示例 1：

输入：[1,0,0,0,1,0,1]
输出：2
解释：
如果亚历克斯坐在第二个空位（seats[2]）上，他到离他最近的人的距离为 2 。
如果亚历克斯坐在其它任何一个空位上，他到离他最近的人的距离为 1 。
因此，他到离他最近的人的最大距离是 2 。 

示例 2：

输入：[1,0,0,0]
输出：3
解释： 
如果亚历克斯坐在最后一个座位上，他离最近的人有 3 个座位远。
这是可能的最大距离，所以答案是 3 。

提示：

1. 1 <= seats.length <= 20000
2. seats 中只含有 0 和 1，至少有一个 0，且至少有一个 1。

---

Runtime: 84 ms

Memory Usage: 19 MB

class Solution {
    func maxDistToClosest(_ seats: [Int]) -> Int {
        var i:Int = 0
        var j:Int = 0
        var res:Int = 0
        var n:Int = seats.count
        while(j < n)
        {
            if seats[j] == 1
            {
                if i == 0
                {
                    res = max(res, j - i)
                }
                else
                {
                    res = max(res, (j - i + 1) / 2)
                }
                i = j + 1
            }            
            j += 1
        }
        return max(res, n - i)
    }
}

---

84ms

class Solution {
    func maxDistToClosest(_ seats: [Int]) -> Int {
        let count = seats.count
        var left = -1
        var dis = 0
        for i in 0..<count {
            if seats[i] == 1 { // 有人
                if left == -1 {
                    dis = max(dis, i - left - 1)
                } else {
                    dis = max(dis, (i - left) / 2)
                }
                left = i
            }
        }
        dis = max(dis, count - 1 - left)
        return dis
    }
}

---

88ms

class Solution {
    func maxDistToClosest(_ seats: [Int]) -> Int {
    
        var maxDistance: Int?        
        var maxSeats = 0
        for num in seats {
            if num == 0 {
                maxSeats += 1
            } else {
                if maxDistance == nil {
                    maxDistance = maxSeats
                } else {
                    let distance = (maxSeats + 1) / 2
                    if distance > maxDistance! {
                        maxDistance = distance
                    }
                }
                maxSeats = 0
            }
        }
        
        if maxSeats > maxDistance! {
            maxDistance = maxSeats
        }
        
        return maxDistance ?? 0
    }
}

---

92ms

class Solution {
    func maxDistToClosest(_ seats: [Int]) -> Int {
        var max0sBetween = 0
        var max0sEdge = 0
        for i in 0..<seats.count where seats[i] == 0 {
            var j = i
            while j < seats.count && seats[j] == 0 {
                j += 1
            }
            if i == 0 || j == seats.count {
                max0sEdge = max(max0sEdge, j - i)
            } else {
                max0sBetween = max(max0sBetween, j - i)
            }
        }
        return max((max0sBetween + 1) / 2, max0sEdge)
    }
}

---

96ms

class Solution {
    func maxDistToClosest(_ seats: [Int]) -> Int {
        var result = 0
        enum Status {
            case idle
            case checkingEmpty(firstEmpty: Int)
            case justFindPerson
        }
        var status = Status.idle
        
        for (index, value) in seats.enumerated() {
            switch value {
            case 0:
                switch status {
                case .idle:
                    status = .checkingEmpty(firstEmpty: index)
                case .checkingEmpty:
                    break
                case .justFindPerson:
                    status = .checkingEmpty(firstEmpty: index)
                }
            case 1:
                switch status {
                case .idle:
                    status = .justFindPerson
                case .checkingEmpty(let firstEmpty):
                    if firstEmpty == 0 {
                        result = index
                    } else {
                        result = max(result, (index - firstEmpty + 1) / 2)
                    }
                    status = .justFindPerson
                case .justFindPerson:
                    break
                }
            default:
                return 0
            }
        }
        
        switch status {
        case .checkingEmpty(let firstEmpty):
            result = max(result, seats.count - firstEmpty)
        default:
            break
        }
        
        return result
    }
}

---

100ms

class Solution {
    func maxDistToClosest(_ seats: [Int]) -> Int {
        var start = 0, dist = -1
        
        var idx = 1, trackMode = seats[0], currDist = 0
        while idx < seats.count {
            guard seats[idx] != trackMode else {
                idx += 1
                continue
            }
            
            trackMode = seats[idx]
            
            if trackMode == 1 {
                currDist = idx - start
                if start == 0 {
                    dist = currDist * 2
                } else {
                    dist = max(currDist, dist)
                }
            } else {
                start = idx
            }
            
            idx += 1
        }
        
        if let last = seats.last, last == 0 {
            currDist = (seats.count - start) * 2
            dist = max(dist, currDist)
        }
        
        return (dist - 1) / 2 + 1
    }
}

---

108ms

class Solution {
    func maxDistToClosest(_ seats: [Int]) -> Int {
    var idx = seats.firstIndex(of: 1)!
    var maxDist = idx
    
    while let next = seats[(idx+1)...].firstIndex(of: 1) {
        maxDist = max(maxDist, (next - idx)/2)
        idx = next
    }

    return max(maxDist, seats.count - idx - 1)
  }
}

---

102ms

class Solution {
    func maxDistToClosest(_ seats: [Int]) -> Int {
        var left: [Int] = []
        var right: [Int] = []
        for i in 0..<seats.count {
            left.append(-1)
            right.append(-1)
        }
        var leftFlag = -1
        for i in 0..<seats.count {
            if seats[i] == 1 {
                leftFlag = i
            }
            if seats[i] == 0 {
                if leftFlag != -1 {
                    left[i] = i - leftFlag
                }
            }
        }
        var rightFlag = -1
        for i in (0..<seats.count).reversed() {
            if seats[i] == 1 {
                rightFlag = i
            }
            if seats[i] == 0 {
                if rightFlag != -1 {
                    right[i] = rightFlag - i
                }
            }
        }
        var maxValue = 0
        for i in 0..<seats.count {
            maxValue = max(maxValue, minBiggerThan0(left[i], right[i]))
        }
        return maxValue
    }
    
    func minBiggerThan0(_ a: Int, _ b: Int) -> Int {
        if a > 0 {
            if b > 0 {
                return min(a, b)
            }
            return a
        }
        if b > 0 {
            return b
        }
        return -1
    }
}

---

148ms

class Solution {
    func maxDistToClosest(_ seats: [Int]) -> Int {
        var prev = -1
        var res = 1

        for (i, v) in seats.enumerated() {
            if v == 1 {
                if prev < 0 {
                    res = i
                } else {
                    res = max(res, (i - prev) / 2)
                }
                prev = i
            }
        }

        return max(res, seats.count - 1 - prev)
    }
}