[Swift]LeetCode994. 腐烂的橘子 | Rotting Oranges

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

In a given grid, each cell can have one of three values:

• the value 0 representing an empty cell;
• the value 1 representing a fresh orange;
• the value 2 representing a rotten orange.

Every minute, any fresh orange that is adjacent (4-directionally) to a rotten orange becomes rotten.

Return the minimum number of minutes that must elapse until no cell has a fresh orange.  If this is impossible, return -1 instead. 

Example 1:

Input: [[2,1,1],[1,1,0],[0,1,1]]
Output: 4

Example 2:

Input: [[2,1,1],[0,1,1],[1,0,1]]
Output: -1
Explanation:  The orange in the bottom left corner (row 2, column 0) is never rotten, because rotting only happens 4-directionally.

Example 3:

Input: [[0,2]]
Output: 0
Explanation:  Since there are already no fresh oranges at minute 0, the answer is just 0. 

Note:

1. 1 <= grid.length <= 10
2. 1 <= grid[0].length <= 10
3. grid[i][j] is only 0, 1, or 2.

---

在给定的网格中，每个单元格可以有以下三个值之一：

• 值 0 代表空单元格；
• 值 1 代表新鲜橘子；
• 值 2 代表腐烂的橘子。

每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。

返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1。 

示例 1：

输入：[[2,1,1],[1,1,0],[0,1,1]]
输出：4

示例 2：

输入：[[2,1,1],[0,1,1],[1,0,1]]
输出：-1
解释：左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个正向上。

示例 3：

输入：[[0,2]]
输出：0
解释：因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。 

提示：

1. 1 <= grid.length <= 10
2. 1 <= grid[0].length <= 10
3. grid[i][j] 仅为 0、1 或 2

---

24ms

class Solution {
    func orangesRotting(_ grid: [[Int]]) -> Int {
        if grid.isEmpty {
            return -1
        }
        var grid = grid
        var grid1 = grid
        
        let yy = grid.count
        let xx = grid[0].count
        
        var mins = 0
        
        while true {
            var noFresh = true
            var processStopped = true

            for i in 0..<yy {
                for j in 0..<xx {
                    let x = grid[i][j]
                    
                    if x == 1 {
                        noFresh = false
                        if isNextRotten(grid, row: i, column: j) {
                            grid1[i][j] = 2
                            processStopped = false
                        }
                    } 
                }
            }

            if noFresh {
                return mins
            }

            if processStopped {
                return -1   
            }

            grid = grid1
            mins += 1
        }
        
        return -1
    }
    
    func isNextRotten(_ grid: [[Int]], row i: Int, column j: Int) -> Bool {
        if i > 0 {
            if grid[i - 1][j] == 2 {
                return true
            }
        }
        
        if i < grid.count - 1 {
            if grid[i + 1][j] == 2 {
                return true
            }
        }
        
        if j > 0 {
            if grid[i][j - 1] == 2 {
                return true
            }
        }
        
        if j < grid[0].count - 1 {
            if grid[i][j + 1] == 2 {
                return true
            }
        }
        
        return false
    }
}

---

Runtime: 28 ms

Memory Usage: 19.3 MB

class Solution {
    var D:[[Int]] = [[-1, 0],[1, 0],[0, -1],[0, 1]]
    func orangesRotting(_ grid: [[Int]]) -> Int {
        var R:Int = grid.count
        var C:Int = grid[0].count
        var ans:[[Int]] = [[Int]](repeating:[Int](repeating:0,count:C),count:R)
        for i in 0..<R
        {
            for j in 0..<C
            {
                if grid[i][j] == 2
                {
                    bfs(grid, &ans, i, j)
                }
            }
        }
        var res:Int = 0
        for i in 0..<R
        {
            for j in 0..<C
            {
                if grid[i][j] == 1
                {
                    if ans[i][j] == 0
                    {
                        return -1
                    }         
                    res = max(res, ans[i][j])
                }
                
            }
        }
        return res
    }
    
    func bfs(_ grid: [[Int]],_ ans: inout [[Int]],_ sx:Int,_ sy:Int)
    {
        var R:Int = grid.count
        var C:Int = grid[0].count
        var q:[[Int]] = [[Int]]()
        q.append([sx,sy,0])
        while(!q.isEmpty)
        {
            var cur:[Int] = q.removeFirst()
            var cost:Int = cur[2] + 1
            for d in D
            {
                var x:Int = cur[0] + d[0]
                var y:Int = cur[1] + d[1]
                if x >= 0 && y >= 0 && x < R && y < C && grid[x][y] == 1 && (ans[x][y] == 0 || ans[x][y] > cost)
                {
                    ans[x][y] = cost
                    q.append([x,y,cost])
                }
            }
        }        
    }
}

---

28ms

class Solution {
    func orangesRotting(_ grid: [[Int]]) -> Int {
        guard grid.count > 0 else {
            return 0
        }
        guard grid[0].count > 0 else {
            return 0
        }
        
        var count = 0
        
        for i in grid.indices {
            for j in grid[0].indices {
                if grid[i][j] == 0 || grid[i][j] == 2 {
                    count += 1
                }
            }
        }
        
        var step = 0
        
        var isEnd = false
        var grid = grid
        let countL = grid.count
        let countC = grid[0].count
        
        while !isEnd {
            isEnd = true
            
            var changed: [[Int]] = Array.init(repeating: Array.init(repeating: 0, count: countC), count: countL)
            
            for i in 0..<countL {
                for j in 0..<countC {
                    if grid[i][j] == 2 && changed[i][j] == 0  {
                        if i > 0 && grid[i - 1][j] == 1 {
                            grid[i - 1][j] = 2
                            changed[i - 1][j] = 1
                            isEnd = false
                            count += 1
                        }
                        if j > 0 && grid[i][j - 1] == 1 {
                            grid[i][j - 1] = 2
                            changed[i][j - 1] = 1
                            isEnd = false
                            count += 1
                        }
                        if i + 1 < countL && grid[i + 1][j] == 1 {
                            grid[i + 1][j] = 2
                            changed[i + 1][j] = 1
                            isEnd = false
                            count += 1
                        }
                        if j + 1 < countC && grid[i][j + 1] == 1 {
                            grid[i][j + 1] = 2
                            changed[i][j + 1] = 1
                            isEnd = false
                            count += 1
                        }
                    }
                }
            }
            
            if isEnd == false {
                step += 1
            }
        }
        
        if count != countL * countC {
            step = -1
        }
        
        return step
    }
}

---

32ms

class Solution {
    
    func orangesRotting(_ grid: [[Int]]) -> Int {
        if grid.isEmpty {
            return -1
        }
        
        var grid = grid
        var grid1 = grid
        
        let rows = grid.count
        let columns = grid[0].count
        
        var mins = 0
        
        while true {
            var noFresh = true
            var noProcess = true
            
            for i in 0..<rows {
                for j in 0..<columns {
                    let x = grid[i][j]
                    
                    if x == 1 {
                        noFresh = false
                        
                        if isRottenNearly(grid, row: i, col: j) {
                            noProcess = false
                            grid1[i][j] = 2
                        }
                    }
                }
            }
            
            if noFresh {
                return mins
            }
            
            if noProcess {
                return -1
            }
            
            mins += 1
            grid = grid1
        }
        
        return -1
    }
    
    func isRottenNearly(_ grid: [[Int]], row i: Int, col j: Int) -> Bool {
        if i > 0 { // n
            if grid[i - 1][j] == 2 {
                return true
            }
        }

        if j > 0 { // w
            if grid[i][j - 1] == 2 {
                return true
            }
        }
        
        if i < grid.count - 1 { // s
            if grid[i + 1][j] == 2 {
                return true
            }
        }
        
        if j < grid[0].count - 1 { // e
            if grid[i][j + 1] == 2 {
                return true
            }
        }        
        return false
    }    
}

---

36ms

class Solution {
    func orangesRotting(_ originalGrid: [[Int]]) -> Int {
        guard originalGrid.count > 0, originalGrid[0].count > 0 else { return -1 }
        var grid = [[Int]](repeating: Array(repeating: -1, count: originalGrid[0].count), count: originalGrid.count)
        var minutes = 0
        for r in 0..<originalGrid.count {
            for c in 0..<originalGrid[0].count {
                if originalGrid[r][c] == 1 {
                    grid[r][c] = Int.max
                } else if originalGrid[r][c] == 2 {
                    grid[r][c] = 0
                }
            }
        }
        for r in 0..<grid.count {
            for c in 0..<grid[0].count {
                if grid[r][c] == 0 {
                    bfs(&grid, r, c)
                }
            }
        }
        var res = 0
        for r in 0..<grid.count {
            for c in 0..<grid[0].count {
                res = max(res, grid[r][c])
            }
        }
        return res == Int.max ? -1 : res
    }

    func bfs(_ grid: inout [[Int]], _ r: Int, _ c: Int) {
        var q = Queue<(Int, Int)>()
        var visited: [[Bool]] = Array(repeating: Array(repeating: false, count: grid[0].count), count: grid.count)
        q.push((r, c))
        while !q.isEmpty {
            let (row, col) = q.pop()
            if row > 0 && grid[row - 1][col] > 0 && visited[row - 1][col] == false {
                grid[row - 1][col] = min(grid[row - 1][col], grid[row][col] + 1)
                q.push((row - 1, col))
            }
            if (row + 1) < grid.count && grid[row + 1][col] > 0 && visited[row + 1][col] == false {
                grid[row + 1][col] = min(grid[row + 1][col], grid[row][col] + 1)
                q.push((row + 1, col))
            }
            if col > 0 && grid[row][col - 1] > 0 && visited[row][col - 1] == false {
                grid[row][col - 1] = min(grid[row][col - 1], grid[row][col] + 1)
                q.push((row, col - 1))
            }
            if (col + 1) < grid[0].count && grid[row][col + 1] > 0 && visited[row ][col + 1] == false {
                grid[row][col + 1] = min(grid[row][col + 1], grid[row][col] + 1)
                q.push((row, col + 1))
            }
            visited[row][col] = true
        }
    }
}

struct Queue<T> {
    var arr: [T] = []
    var head = 0
    
    mutating func push(_ val: T) {
        arr.append(val)
    }
    
    mutating func pop() -> T {
        let res = arr[head]
        head += 1
        return res
    }
    
    var isEmpty: Bool {
        return head >= arr.count
    }
    
    var size: Int {
        return arr.count - head
    }
}