[Swift]LeetCode1034.边框着色 | Coloring A Border

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

Given a 2-dimensional grid of integers, each value in the grid represents the color of the grid square at that location.

Two squares belong to the same connected component if and only if they have the same color and are next to each other in any of the 4 directions.

The border of a connected component is all the squares in the connected component that are either 4-directionally adjacent to a square not in the component, or on the boundary of the grid (the first or last row or column).

Given a square at location (r0, c0) in the grid and a color, color the border of the connected component of that square with the given color, and return the final grid.

Example 1:

Input: grid = [[1,1],[1,2]], r0 = 0, c0 = 0, color = 3
Output: [[3, 3], [3, 2]]

Example 2:

Input: grid = [[1,2,2],[2,3,2]], r0 = 0, c0 = 1, color = 3
Output: [[1, 3, 3], [2, 3, 3]]

Example 3:

Input: grid = [[1,1,1],[1,1,1],[1,1,1]], r0 = 1, c0 = 1, color = 2
Output: [[2, 2, 2], [2, 1, 2], [2, 2, 2]]

Note:

1. 1 <= grid.length <= 50
2. 1 <= grid[0].length <= 50
3. 1 <= grid[i][j] <= 1000
4. 0 <= r0 < grid.length
5. 0 <= c0 < grid[0].length
6. 1 <= color <= 1000

---

给出一个二维整数网格 grid，网格中的每个值表示该位置处的网格块的颜色。

只有当两个网格块的颜色相同，而且在四个方向中任意一个方向上相邻时，它们属于同一连通分量。

连通分量的边界是指连通分量中的所有与不在分量中的正方形相邻（四个方向上）的所有正方形，或者在网格的边界上（第一行/列或最后一行/列）的所有正方形。

给出位于 (r0, c0) 的网格块和颜色 color，使用指定颜色 color 为所给网格块的连通分量的边界进行着色，并返回最终的网格 grid 。

示例 1：

输入：grid = [[1,1],[1,2]], r0 = 0, c0 = 0, color = 3
输出：[[3, 3], [3, 2]]

示例 2：

输入：grid = [[1,2,2],[2,3,2]], r0 = 0, c0 = 1, color = 3
输出：[[1, 3, 3], [2, 3, 3]]

示例 3：

输入：grid = [[1,1,1],[1,1,1],[1,1,1]], r0 = 1, c0 = 1, color = 2
输出：[[2, 2, 2], [2, 1, 2], [2, 2, 2]]

提示：

1. 1 <= grid.length <= 50
2. 1 <= grid[0].length <= 50
3. 1 <= grid[i][j] <= 1000
4. 0 <= r0 < grid.length
5. 0 <= c0 < grid[0].length
6. 1 <= color <= 1000

 

---

140ms

class Solution {
    func colorBorder(_ grid: [[Int]], _ r0: Int, _ c0: Int, _ color: Int) -> [[Int]] {
        guard !grid.isEmpty else { return grid }
        guard !grid[0].isEmpty else { return grid }
        guard grid[r0][c0] != color else { return grid }
        
        let h = grid.count
        let w = grid[0].count
        
        var result = grid
        var queue = [(r0, c0)]
        var visited = Set<Int>()
        
        while !queue.isEmpty {
            var nextQueue = [(Int, Int)]()
            for (r, c) in queue {
                let key = r * w + c
                guard !visited.contains(key) else { continue }
                visited.insert(r * w + c)
                
                if r == 0 || c == 0 || r == h - 1 || c == w - 1 {
                    result[r][c] = color
                }
                
                let this = grid[r][c]
                var validNeighbors = [(Int, Int)]()
                
                if r > 0 {
                    validNeighbors.append((r - 1, c))
                }
                
                if r < h - 1 {
                    validNeighbors.append((r + 1, c))
                }
                
                if c > 0 {
                    validNeighbors.append((r, c - 1))
                }
                
                if c < w - 1 {
                    validNeighbors.append((r, c + 1))
                }
                
                for neighbor in validNeighbors {
                    if grid[neighbor.0][neighbor.1] != this {
                        result[r][c] = color
                    } else if !visited.contains(neighbor.0 * w + neighbor.1) {
                        nextQueue.append((neighbor.0, neighbor.1))
                    }
                }
            }
            queue = nextQueue
        }
        
        return result
    }
}

---

144ms

class Solution {
            
    func dfs(_ grid: inout [[Int]], _ r: Int, _ c: Int, _ color: Int)  {
        if r < 0 || c < 0 || r >= grid.count || c >= grid[r].count || grid[r][c] != color {
            return
        }
        grid[r][c] = -color
        let directs = [(1,0), (-1, 0), (0, 1), (0, -1)]
        for direct in directs {
            dfs(&grid, r + direct.0, c + direct.1, color)
        }

        if r > 0 && r < grid.count - 1 && c > 0 && c < grid[r].count - 1 && (directs.filter { color != abs(grid[r + $0.0][$0.1 + c]) }.count == 0) {
            grid[r][c] = color
        }
    }

    func colorBorder(_ grid: [[Int]], _ r0: Int, _ c0: Int, _ color: Int) -> [[Int]] {
        var grid = grid
        dfs(&grid, r0, c0, grid[r0][c0]);
        for i in grid.indices {
            for j in grid[0].indices {
                grid[i][j] = grid[i][j] < 0 ? color : grid[i][j]
            }
        }
        return grid
    }
}

---

160ms

class Solution {
    func colorBorder(_ grid: [[Int]], _ r0: Int, _ c0: Int, _ color: Int) -> [[Int]] {
        guard !grid.isEmpty else { return grid }
        guard !grid[0].isEmpty else { return grid }
        guard grid[r0][c0] != color else { return grid }
        
        let h = grid.count
        let w = grid[0].count
        
        var result = grid
        var queue = [(r0, c0)]
        var visited = Set<Int>()
        
        while !queue.isEmpty {
            var nextQueue = [(Int, Int)]()
            for (r, c) in queue {
                let key = r * w + c
                guard !visited.contains(key) else { continue }
                visited.insert(r * w + c)
                
                if r == 0 || c == 0 || r == h - 1 || c == w - 1 {
                    result[r][c] = color
                }
                
                let this = grid[r][c]
                var validNeighbors = [(Int, Int)]()
                
                if r > 0 {
                    validNeighbors.append((r - 1, c))
                }
                
                if r < h - 1 {
                    validNeighbors.append((r + 1, c))
                }
                
                if c > 0 {
                    validNeighbors.append((r, c - 1))
                }
                
                if c < w - 1 {
                    validNeighbors.append((r, c + 1))
                }
                
                for neighbor in validNeighbors {
                    if grid[neighbor.0][neighbor.1] != this {
                        result[r][c] = color
                    } else if !visited.contains(neighbor.0 * w + neighbor.1) {
                        nextQueue.append((neighbor.0, neighbor.1))
                    }
                }
            }
            queue = nextQueue
        }
        
        return result
    }
}

---

Runtime: 160 ms

Memory Usage: 19.3 MB

class Solution {
    var conn:[[Int]] = [[Int]]()
    var col:[[Int]] = [[Int]]()
    var H:Int = 0
    var W:Int = 0
    var dx:[Int] = [1, -1, 0, 0]
    var dy:[Int] = [0, 0, 1, -1]
    
    func colorBorder(_ grid: [[Int]], _ r0: Int, _ c0: Int, _ color: Int) -> [[Int]] {
        H = grid.count
        W = grid[0].count
        conn = [[Int]](repeating: [Int](repeating: 0, count: W), count: H)
        col = grid
        dfs_con(r0, c0)
        var ret:[[Int]] = grid
        for x in 0..<H
        {
            for y in 0..<W
            {
                if conn[x][y] != 0
                {
                    for d in 0..<4
                    {
                        let xn:Int = x + dx[d]
                        let yn:Int = y + dy[d]
                        if xn < 0 || yn < 0 || xn >= H || yn >= W || grid[xn][yn] != grid[r0][c0]
                        {
                            ret[x][y] = color
                        }
                    }
                }
            }
        }
        return ret
    }
    
    func dfs_con(_ x:Int,_ y:Int)
    {
        conn[x][y] = 1
        for d in 0..<4
        {
            let xn:Int = x + dx[d]
            let yn:Int = y + dy[d]
            if xn < 0 || yn < 0 || xn >= H || yn >= W
            {
                continue
            }
            if col[x][y] == col[xn][yn] && conn[xn][yn] == 0
            {
                dfs_con(xn, yn)
            }
        }
    }
}