深度优先搜索—边框着色(leetcode 1034)

题目描述

给出一个二维整数网格 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 <= grid.length <= 50
    1 <= grid[0].length <= 50
    1 <= grid[i][j] <= 1000
    0 <= r0 < grid.length
    0 <= c0 < grid[0].length
    1 <= color <= 1000

算法分析

1、找到边界
找到边界：如果该节点的下一个dfs节点满足如下条件，那么它就是边界点

      if(x < 0 || x >= grid.size() || y < 0 || y >= grid[0].size() || grid[x][y] != oldColor){
            return 1;
        }

但是邻近“边界节点”的节点也会被判定为"边界节点"，因为边界节点已经改变了颜色，它的下一节点会满足条件grid[x][y] != oldColor。
使用visited标记。visited[i][j]表示连通分量内的节点(i,j)是否已经遍历过，也就是说，联通分量外的节点永远都是false

DFS

class Solution {
public:
    int R,C;
    int COLOR;
    vector<vector<bool>> visit;
    vector<int> dict{-1,0,1,0,-1};

    bool inArea(int x, int y) {
        return x >= 0 && x < R && y >= 0 && y < C;
    }

    void dfs(vector<vector<int>>& grid, int row, int col, int cur_color) {

        for(int i = 0; i < 4; ++i) {
            int new_row = row + dict[i];
            int new_col = col + dict[i+1];

            if(inArea(new_row,new_col)) {
                if(visit[new_row][new_col]) {
                    continue;
                }
                if(grid[new_row][new_col] != cur_color) {
                    grid[row][col] = COLOR;
                } else {
                    visit[new_row][new_col] = true;
                    dfs(grid, new_row, new_col, cur_color);
                }
            } else {
                grid[row][col] = COLOR;
            }
        }
    }

    vector<vector<int>> colorBorder(vector<vector<int>>& grid, int row, int col, int color) {
        R = grid.size();
        C = grid[0].size();
        COLOR = color;
        visit.resize(R, vector<bool>(C, false));
        dfs(grid, row, col, grid[row][col]);
        return grid;
    }
};

 BFS

class Solution {
public:
    vector<vector<int>> colorBorder(vector<vector<int>>& grid, int row, int col, int color) {

        queue<pair<int,int>> que;
        int start_color = grid[row][col];
        int m = grid.size();
        int n = grid[0].size();
        vector<vector<bool>> visit(m, vector<bool>(n, false));
        vector<int> dict{-1,0,1,0,-1};
        que.push(make_pair(row,col));
        visit[row][col] = true;

        while(!que.empty()) {
            int x = que.front().first;
            int y = que.front().second;
            que.pop();
            for(int i =0; i < 4; ++i) {
                int new_row = x + dict[i];
                int new_col = y + dict[i+1];
                if(new_row >= 0 && new_row < m && new_col >= 0 && new_col < n) {
                    if(visit[new_row][new_col]) {
                        continue;
                    }
                    if(grid[new_row][new_col] == start_color) {
                        visit[new_row][new_col] = true;
                        que.push(make_pair(new_row, new_col));
                    } else{
                        grid[x][y] = color;
                    }
                } else {
                    grid[x][y] = color;
                }
            }
        }
        return grid;
    }
};

算法复杂度分析