[Swift]LeetCode1162. 地图分析 | As Far from Land as Possible

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

Given an N x N grid containing only values 0 and 1, where 0 represents water and 1 represents land, find a water cell such that its distance to the nearest land cell is maximized and return the distance.

The distance used in this problem is the Manhattan distance: the distance between two cells (x0, y0) and (x1, y1) is |x0 - x1| + |y0 - y1|.

If no land or water exists in the grid, return -1.

Example 1:

Input: [[1,0,1],[0,0,0],[1,0,1]]
Output: 2
Explanation: 
The cell (1, 1) is as far as possible from all the land with distance 2.

Example 2:

Input: [[1,0,0],[0,0,0],[0,0,0]]
Output: 4
Explanation: 
The cell (2, 2) is as far as possible from all the land with distance 4.

Note:

1. 1 <= grid.length == grid[0].length <= 100
2. grid[i][j] is 0 or 1

---

你现在手里有一份大小为 N x N 的『地图』（网格） grid，上面的每个『区域』（单元格）都用 0 和 1 标记好了。其中 0 代表海洋，1 代表陆地，你知道距离陆地区域最远的海洋区域是是哪一个吗？请返回该海洋区域到离它最近的陆地区域的距离。

我们这里说的距离是『曼哈顿距离』（ Manhattan Distance）：(x0, y0) 和 (x1, y1) 这两个区域之间的距离是 |x0 - x1| + |y0 - y1| 。

如果我们的地图上只有陆地或者海洋，请返回 -1。

示例 1：

输入：[[1,0,1],[0,0,0],[1,0,1]]
输出：2
解释： 
海洋区域 (1, 1) 和所有陆地区域之间的距离都达到最大，最大距离为 2。

示例 2：

输入：[[1,0,0],[0,0,0],[0,0,0]]
输出：4
解释： 
海洋区域 (2, 2) 和所有陆地区域之间的距离都达到最大，最大距离为 4。

提示：

1. 1 <= grid.length == grid[0].length <= 100
2. grid[i][j] 不是 0 就是 1

---

Runtime: 604 ms

Memory Usage: 20.9 MB

class Solution {
    func maxDistance(_ grid: [[Int]]) -> Int {
        var grid = grid
        var has0:Bool = false
        var has1:Bool = false
        let n:Int = grid.count
        var x:Int = 0
        var y:Int = 0        
        var xx:Int = 0
        var yy:Int = 0
        var ans:Int = 1
        var v:[[Int]] = [[1, 0],[0, 1],[-1, 0],[0, -1]]
        var q:[[Int]] = [[Int]]()
        for i in 0..<n
        {
            for j in 0..<n
            {
                if grid[i][j] == 0 {has0 = true}
                if grid[i][j] == 1
                {
                    has1 = true
                    q.append([i,j])
                }
            }
        }
        if !has0 {return -1}
        if !has1 {return -1}
        while(!q.isEmpty)
        {
            let arr:[Int] = q.removeFirst()
            x = arr[0]
            y = arr[1]
            ans = max(ans, grid[x][y])
            
            for i in 0..<4
            {
                xx = x + v[i][0]
                yy = y + v[i][1]
                if (xx >= 0) && (xx < n) && (yy >= 0) && (yy < n) && (grid[xx][yy] == 0)
                {
                    grid[xx][yy] = grid[x][y] + 1
                    q.append([xx, yy])
                }
            }
        }
        return ans - 1        
    }
}

---

652ms 

class Solution {
    
    typealias Location = (x: Int, y:Int)
    let dicts = [1, 0, -1, 0, 1]
    func maxDistance(_ grid: [[Int]]) -> Int {
        var grid = grid
        var queue = [Location]()
        
        for i in grid.indices {
            for j in grid[0].indices {
                if grid[i][j] == 1 {
                    queue.append(Location(x: i, y: j))
                }
            }
        }
        

        var dist = 1
        while queue.count > 0 {
            
            let size = queue.count 
            dist += 1
            for _ in 0..<size {
                let curr = queue.removeFirst()
                for i in 0...3 {
                    let nextX = curr.x + dicts[i]
                    let nextY = curr.y + dicts[i+1]
                    guard nextX >= 0 && nextY >= 0 && nextX < grid.count && nextY < grid[0].count else {
                        continue
                    }
                    
                    if grid[nextX][nextY] == 0 {
                        queue.append(Location(x: nextX, y: nextY))
                        grid[nextX][nextY] = dist
                    }
                }
            }
        }
        
        var result = -1 
        for i in grid.indices {
            for j in grid[0].indices {
                if grid[i][j] != 1 {
                    result = max(result, grid[i][j] - 1)
                }
            }
        }
        return result
    }
}

---

740ms

class Solution {
    func maxDistance(_ grid: [[Int]]) -> Int {
        // local grid to mark the visited nodes.
        var localGrid = grid
        // queue of tuples to run the BFS.
        var queue:[(x:Int, y:Int)] = []
        // find out the 1's in the grid now.
        let xDim = grid[0].count
        let yDim = grid.count
        var water=0
        for x in 0..<xDim {
            for y in 0..<yDim {
                if grid[x][y] == 1 {
                    queue.append((x:x, y:y))
                }
                if grid[x][y] == 0 {
                    water += 1
                }
            }
        }
        if water == 0 || grid.count == 0 {
            return -1
        }
        var answer = 0
        let neighborOffset:[(x:Int, y:Int)] = [(x:1,y:0),(x:-1,y:0),(x:0,y:1),(x:0,y:-1)]
        // start BFS
        while queue.count > 0 {
            answer += 1
            for i in 0..<queue.count {
                let current = queue.removeFirst()
                //print("Current ((current.x):(current.y))")
                for offset in neighborOffset {
                    //print("Offset ((offset.x):(offset.y))")
                    let xn = current.x + offset.x
                    let yn = current.y + offset.y
                    //print("xn (xn) yn (yn)")
                    if (xn >= 0 && xn < xDim) && (yn >= 0 && yn < yDim) {
                        if localGrid[xn][yn] == 0 {
                            // mark it visited
                            localGrid[xn][yn] = 1
                            //print("((xn):(yn)) = (localGrid)")
                            // add to explore neighbors.
                            queue.append((x:xn, y:yn))
                        }
                    }
                }
            }
        }
        return answer-1
    }
}

---

800ms

class Solution {
    func maxDistance(_ grid: [[Int]]) -> Int {
        let n = grid.count, m = grid[0].count

        var dp = [[Int]](repeating: [Int](repeating: -1, count: 101), count: 101)

        var islands = [(Int, Int)]()
        for i in grid.indices {
            for j in grid[0].indices {
                if grid[i][j] == 1 {
                    islands.append((i,j))
                    dp[i][j] = 0
                }
            }
        }
        let dirs = [(0, 1), (0, -1), (1, 0), (-1, 0)]
        while !islands.isEmpty {
            let front = islands.removeFirst()
            let x = front.0, y = front.1
            for dir in dirs {
                let nx = x + dir.0
                let ny = y + dir.1
                if nx < 0 || nx >= n || ny < 0 || ny >= m { continue }
                if dp[nx][ny] >= 0 { continue }
                dp[nx][ny] = dp[x][y] + 1
                islands.append((nx, ny))
            }
        }

        var ret = -1
        for i in 0..<n {
            for j in 0..<m where dp[i][j] > 0 {
                ret = max(ret, dp[i][j])
            }
        }
        return ret
    }

    func distance(_ p1: (Int, Int), _ p2: (Int, Int)) -> Int {
        return abs(p1.0 - p2.0) + abs(p1.1 - p2.1)
    }
}