Description

An image is represented by a 2-D array of integers, each integer representing the pixel value of the image (from 0 to 65535).

Given a coordinate (sr, sc) representing the starting pixel (row and column) of the flood fill, and a pixel value newColor, “flood fill” the image.

To perform a “flood fill”, consider the starting pixel, plus any pixels connected 4-directionally to the starting pixel of the same color as the starting pixel, plus any pixels connected 4-directionally to those pixels (also with the same color as the starting pixel), and so on. Replace the color of all of the aforementioned pixels with the newColor.

At the end, return the modified image.

Example 1:

Input: 
image = [[1,1,1],[1,1,0],[1,0,1]]
sr = 1, sc = 1, newColor = 2
Output: [[2,2,2],[2,2,0],[2,0,1]]
Explanation: 
From the center of the image (with position (sr, sc) = (1, 1)), all pixels connected 
by a path of the same color as the starting pixel are colored with the new color.
Note the bottom corner is not colored 2, because it is not 4-directionally connected
to the starting pixel.

Note:

• The length of image and image[0] will be in the range [1, 50].
• The given starting pixel will satisfy 0 <= sr < image.length and 0 <= sc < image[0].length.
• The value of each color in image[i][j] and newColor will be an integer in [0, 65535].

问题描述

一个图像由一个二维的整数数组表示， 每一个数字代表图像的其中一个像素的值(0到65535)

给定(sr, sc)作为flood fill的起始座标, 以及像素值newColor, “flood fill”图像

“flood fill”的操作如下, 与(sr, sc)在四个方向相邻的像素值相等的座标可以作为(sr’, sc’), 也就是”flood fill”的新的起始座标， 而这些新的座标又可以令与它们四个方向相邻的像素值相等的座标作为起始座标， 依次递归， 将所有的这些座标替换为newColor

问题分析

BFS或者DFS

解法1(BFS)

class Solution {
    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
        if(image[sr][sc] == newColor)  return image;

        int[] directions = {0, 1, 0, -1, 0};
        int org = image[sr][sc];
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(sr);
        queue.offer(sc);

        while (!queue.isEmpty()) {
            int curX = queue.poll();
            int curY = queue.poll();
            for (int i = 0; i < directions.length - 1; i++) {
                int nextX = curX + directions[i];
                int nextY = curY + directions[i + 1];
                if (nextX < 0 || nextY < 0 || nextX >= image.length || nextY >= image[0].length || image[nextX][nextY] != org){
                    continue;
                }
                queue.offer(nextX);
                queue.offer(nextY);
            }
            image[curX][curY] = newColor;
        }

        return image;
    }
}

解法2(DFS)

class Solution {
    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
        if (image[sr][sc] == newColor) return image;

        fill(image, sr, sc, image[sr][sc], newColor);

        return image;
    } 
    private void fill(int[][] image, int sr, int sc, int color, int newColor) {
        if (sr < 0 || sr >= image.length || sc < 0 || sc >= image[0].length || image[sr][sc] != color) return;

        image[sr][sc] = newColor;
        fill(image, sr + 1, sc, color, newColor);
        fill(image, sr - 1, sc, color, newColor);
        fill(image, sr, sc + 1, color, newColor);
        fill(image, sr, sc - 1, color, newColor);
    }

}