《程序员面试金典（第6版）》面试题 08.10. 颜色填充 （DFS，BFS C++）

题目描述

编写函数，实现许多图片编辑软件都支持的「颜色填充」功能。

• 待填充的图像用二维数组 image 表示，元素为初始颜色值。初始坐标点的行坐标为 sr 列坐标为 sc。需要填充的新颜色为 newColor 。

• 「周围区域」是指颜色相同且在上、下、左、右四个方向上存在相连情况的若干元素。

• 请用新颜色填充初始坐标点的周围区域，并返回填充后的图像。

示例：

• 输入：
  image = [[1,1,1],[1,1,0],[1,0,1]]
  sr = 1, sc = 1, newColor = 2
  输出：[[2,2,2],[2,2,0],[2,0,1]]

解释:

• 初始坐标点位于图像的正中间，坐标 (sr,sc)=(1,1) 。
  初始坐标点周围区域上所有符合条件的像素点的颜色都被更改成 2 。
  注意，右下角的像素没有更改为 2 ，因为它不属于初始坐标点的周围区域。

提示：

• image 和 image[0] 的长度均在范围 [1, 50] 内。
  初始坐标点 (sr,sc) 满足 0 <= sr < image.length 和 0 <= sc < image[0].length 。
  image[i][j] 和 newColor 表示的颜色值在范围 [0, 65535] 内。

解题思路与代码

• 这道题你光读题目你可能没有什么思路，因为这说话也太简略了一点。所以你得结合着示例去看，才大概知道他想让你实现什么效果。所以我这里把题目想让我们做的事情再复述一遍：
• 这道题的题意是，让我们将初始像素点和初始像素点周围区域的所有像素点，变一个颜色。那么问题来了，周围区域的定义是什么？
• 你光看题目不看示例很可能会把周围区域的定义搞错，正确的周围区域的定义是，从初始坐标点出发，上下左右四个格子有没有和初始坐标颜色相同的格子，如果有则划入周围区域的定义。
• 紧接着再看周围区域定义里的所有格子的上下左右是否还有与自己的格子相同的颜色的格子，再划入周围区域的定义里。
• 依次类推，直到周围区域中的每一个格子的上下左右找不到与自己格子相同颜色的格子为止，这样周围区域的定义才算完毕。

具体用代码如何实现呢？我们在下面的方法中重新再去说一下。

方法一：使用队列进行层序遍历 BFS

• 我们刚刚重新了解了一下这道题要让我们做什么。这道题关键让我们去实现的，就是将初始像素点和初始像素点周围区域的所有像素点，变一个颜色，这一点而已。

• 那代码如何实现呢？

• 这种关于周围区域的不断重新定义，让我想起了二叉树的层序遍历。我们可以去用一个队列去实现像素点的不断更新。

• 具体的实现可以去看代码，注释写的很详细

class Solution {
public:
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
        int oldColor = image[sr][sc]; // 记录旧颜色长什么样。

        if (oldColor == newColor) { // 如果新颜色与旧颜色一样就直接返回
            return image;
        }

        queue<pair<int,int>> que; //创建一个队列
        que.emplace(sr,sc);// 并插入一个元素
        //创建这个数组的目的是为了等会少写点代码，把可能的四种情况用数组表示下来。
        int dr[] = {-1,0,1,0};
        int dc[] = {0,-1,0,1};
        //用队列去找相同颜色的格子，这招和二叉树的层次遍历非常像，几乎就是一模一样。
        while(!que.empty()){
            auto cur = que.front();
            que.pop();
            
            int row = cur.first;
            int col = cur.second;

            image[row][col] = newColor; //改变格子颜色

            for(int i = 0; i < 4; ++i){
                int newRow = row + dr[i];
                int newCol = col + dc[i];
                if(newRow >= 0 && newRow < image.size() && newCol >= 0 && newCol < image[0].size() 
                    && image[newRow][newCol] == oldColor){
                    que.emplace(newRow,newCol);
                }
            }
        }
        return image;
    }
};

复杂度分析

时间复杂度：O(N * M)
这里 N 和 M 分别是图像的行数和列数。因为这个算法会遍历所有需要涂色的格子，所以在最坏情况下，它需要遍历整个图像。因此，时间复杂度是 O(N * M)。

空间复杂度：O(N * M)
这里的空间复杂度主要来自于队列 que。在最坏的情况下，所有的格子都需要被涂色，所以队列可能会包含 N * M 个元素。因此，空间复杂度是 O(N * M)。

方法二，使用深度优先搜索进行遍历 DFS

• 由刚刚我发现这个寻找周围区域的格子的方法有点像二叉树的层序遍历了以后，那么再扩展一下，我们是不是也可以像前序遍历遍历二叉树那样去遍历这个周围区域的格子呢？答案是那当然，可以，就让我们来写一下这个代码吧：

class Solution {
public:
    const int dr[4] = {1, 0, 0, -1};
    const int dc[4] = {0, 1, -1, 0};
    
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
        int oldColor = image[sr][sc];
        if (oldColor != newColor) 
        	dfs(image, sr, sc, oldColor, newColor);
        return image;
    }
    
    void dfs(vector<vector<int>>& image, int row, int col, int oldcolor, int newColor) {
        if (image[row][col] == oldcolor) {
            image[row][col] = newColor;
            for (int i = 0; i < 4; i++) {
                int newRow = row + dr[i], newCol = col + dc[i];
                if (newRow >= 0 && newRow < image.size() && newCol >= 0 && newCol < image[0].size() 
                    && image[newRow][newCol] != newColor) 
                    dfs(image, newRow, newCol, oldcolor, newColor);
            }
        }
    }
};

相信能get到方法一的小伙伴们，一定可以get到方法二是怎么做的，这里我也就不去过多解释了

复杂度分析

时间复杂度：O(N * M)
这里 N 和 M 分别是图像的行数和列数。同样，因为这个算法会遍历所有需要涂色的格子，所以在最坏情况下，它需要遍历整个图像。因此，时间复杂度是 O(N * M)。

空间复杂度：O(N * M)
虽然这个算法没有使用队列，但是空间复杂度主要来自于递归调用的栈空间。在最坏的情况下，所有的格子都需要被涂色，所以递归栈的深度可能达到 N * M。因此，空间复杂度是 O(N * M)。

虽然在最坏情况下，这个算法的空间复杂度和之前的广度优先搜索（BFS）方法相同，但在一般情况下，DFS 方法的空间复杂度会低于 BFS。此外，这个方法的实现也更简洁。

总结

从这一道题上，我们可以看出，我们曾经再做如何遍历一颗二叉树的多重方法。在这里，都可以套用到这道题上面来。

总之，这道题很好玩，很有趣。但对于这些知识不了解的小伙伴们，可能就会觉得这道题是一道比较困难的题了。还是挺考验平时做题积累的这道题。