Leetcode : flood-fill ( 图像渲染 733 )

flood-fill ( 图像渲染 )

题目简介

有一幅以二维整数数组表示的图画，每一个整数表示该图画的像素值大小，数值在 0 到 65535 之间。

给你一个坐标 (sr, sc) 表示图像渲染开始的像素值（行 ，列）和一个新的颜色值 newColor，让你重新上色这幅图像。

为了完成上色工作，从初始坐标开始，记录初始坐标的上下左右四个方向上像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应四个方向上像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为新的颜色值。最后返回经过上色渲染后的图像。

示例 1:
输入:
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] 内。
给出的初始点将满足 0 <= sr < image.length 和 0 <= sc < image[0].length。
image[i][j] 和 newColor 表示的颜色值在范围 [0, 65535] 内。

题解一

深度优先搜索 （dfs）
题目解析 - 思路

从给定的起点开始，进行深度优先搜索。每次到达一个方格时，判断其与初始位置的方格颜色是否相同，相同就将该方格的颜色更新，以防止重复搜索；如果不相同，则进行回溯， 具体回溯方式是将上下左右相邻的色块进行相同的操作， 直到达到边界或者颜色相同为止。

class Solution {
    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
    	// newColor 与 初始颜色(image[sr][sc]) 不变，使用 sr与sc 遍历整张图画进行渲染
        dfs(image, sr, sc, newColor, image[sr][sc]);
        return image;
    }
	// 进行深度搜索遍历
    void dfs(int[][] image, int sr, int sc, int newColor, int oldColor) {
    	// 第一行判断是否超过边界条件
    	// 第二行判断 新颜色与 初始颜色 是否相同，相同则染色，不同则递归
        if (sr < 0 || sc < 0 || sr >= image.length || sc >= image[0].length 
   		     || image[sr][sc] != oldColor || newColor == oldColor){
            return;
        }
        // 染色
        image[sr][sc] = newColor;
        // 到达 初始颜色 的下方色块
        dfs(image, sr - 1, sc, newColor, oldColor);
        // 到达 初始颜色 的上方色块
        dfs(image, sr + 1, sc, newColor, oldColor);
        // 到达 初始颜色 的左方色块
        dfs(image, sr, sc - 1, newColor, oldColor);
        // 到达 初始颜色 的右方色块
        dfs(image, sr, sc + 1, newColor, oldColor); 
    }
}

题解二

广度优先搜索 （bfs）
题目解析 - 思路

从给定的色块开始，每到达到一个方格时，如果其与初始位置的方格颜色相同，就将该方格加入队列，同时将该方格的颜色更新，以防止重复入队。
注意：因为初始位置的颜色会被修改，所以我们需要保存初始位置的颜色，以便于之后的更新操作。
以下为典型的广度优先搜索代码：

class Solution {
	// 记录 遍历顺序 依次是 下、右、左、上
    int[] dx = {1, 0, 0, -1};
    int[] dy = {0, 1, -1, 0};x

    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
        int currColor = image[sr][sc];
        if (currColor == newColor) {
            return image;
        }
        int n = image.length, m = image[0].length;
        // 初始化队列
        Queue<int[]> queue = new LinkedList<int[]>();
        // 将 初始色块位置 推入队中
        queue.offer(new int[]{sr, sc});
        // 修改初始色块并 染色
        image[sr][sc] = newColor;
        while (!queue.isEmpty()) {
        	// 从 队中 拿出一个 （注意：此处放入队中的是位置数组）
            int[] cell = queue.poll();
            int x = cell[0], y = cell[1];
            // 上下左右依次遍历相邻色块
            for (int i = 0; i < 4; i++) {
                int mx = x + dx[i], my = y + dy[i];
                // 判断边界条件 & 当前遍历的颜色是否与 初始颜色相同，相同则染色
                if (mx >= 0 && mx < n && my >= 0 && my < m 
                		&& image[mx][my] == currColor) {
                	// 将染色位置的 色块位置信息推入队中
                    queue.offer(new int[]{mx, my});
                    // 修改色块并 染色
                    image[mx][my] = newColor;
                }
            }
        }
        return image;
    }
}