Related Articles

# Flood Fill Algorithm

• Difficulty Level : Medium
• Last Updated : 18 Oct, 2021

Given a 2D screen arr[][] where each arr[i][j] is an integer representing the color of that pixel, also given the location of a pixel (X, Y) and a color C, the task is to replace the color of the given pixel and all the adjacent same-colored pixels with the given color.
Example:

Input: arr[][] = {
{1, 1, 1, 1, 1, 1, 1, 1},
{1, 1, 1, 1, 1, 1, 0, 0},
{1, 0, 0, 1, 1, 0, 1, 1},
{1, 2, 2, 2, 2, 0, 1, 0},
{1, 1, 1, 2, 2, 0, 1, 0},
{1, 1, 1, 2, 2, 2, 2, 0},
{1, 1, 1, 1, 1, 2, 1, 1},
{1, 1, 1, 1, 1, 2, 2, 1}}
X = 4, Y = 4, C = 3
Output:
1 1 1 1 1 1 1 1
1 1 1 1 1 1 0 0
1 0 0 1 1 0 1 1
1 3 3 3 3 0 1 0
1 1 1 3 3 0 1 0
1 1 1 3 3 3 3
1 1 1 1 1 3 1 1
1 1 1 1 1 3 3
Explanation:
The values in the given 2D screen indicate colors of the pixels. X and Y are coordinates of the brush, C is the color that should replace the previous color on screen[X][Y] and all surrounding pixels with the same color. Hence all the 2 are replaced with 3.

BFS Approach: The idea is to use BFS traversal to replace the color with the new color.

• Create an empty queue lets say Q.
• Push the starting location of the pixel as given in the input and apply replacement color to it.
• Iterate until Q is not empty and pop the front node (pixel position).
• Check the pixels adjacent to the current pixel and push into the queue if valid (had not been colored with replacement color and have the same color as the old color).

Below is the implementation of the above approach:

## Python3

 `# Python3 implementation of the approach` `# Function that returns true if``# the given pixel is valid``def` `isValid(screen, m, n, x, y, prevC, newC):``    ``if` `x<``0` `or` `x>``=` `m\``       ``or` `y<``0` `or` `y>``=` `n ``or``\``       ``screen[x][y]!``=` `prevC\``       ``or` `screen[x][y]``=``=` `newC:``        ``return` `False``    ``return` `True`  `# FloodFill function``def` `floodFill(screen, ``            ``m, n, x, ``            ``y, prevC, newC):``    ``queue ``=` `[]``    ` `    ``# Append the position of starting``    ``# pixel of the component``    ``queue.append([x, y])` `    ``# Color the pixel with the new color``    ``screen[x][y] ``=` `newC` `    ``# While the queue is not empty i.e. the``    ``# whole component having prevC color``    ``# is not colored with newC color``    ``while` `queue:``        ` `        ``# Dequeue the front node``        ``currPixel ``=` `queue.pop()``        ` `        ``posX ``=` `currPixel[``0``]``        ``posY ``=` `currPixel[``1``]``        ` `        ``# Check if the adjacent``        ``# pixels are valid``        ``if` `isValid(screen, m, n, ``                ``posX ``+` `1``, posY, ``                        ``prevC, newC):``            ` `            ``# Color with newC``            ``# if valid and enqueue``            ``screen[posX ``+` `1``][posY] ``=` `newC``            ``queue.append([posX ``+` `1``, posY])``        ` `        ``if` `isValid(screen, m, n, ``                    ``posX``-``1``, posY, ``                        ``prevC, newC):``            ``screen[posX``-``1``][posY]``=` `newC``            ``queue.append([posX``-``1``, posY])``        ` `        ``if` `isValid(screen, m, n, ``                ``posX, posY ``+` `1``, ``                        ``prevC, newC):``            ``screen[posX][posY ``+` `1``]``=` `newC``            ``queue.append([posX, posY ``+` `1``])``        ` `        ``if` `isValid(screen, m, n, ``                    ``posX, posY``-``1``, ``                        ``prevC, newC):``            ``screen[posX][posY``-``1``]``=` `newC``            ``queue.append([posX, posY``-``1``])`   `# Driver code``screen ``=``[``[``1``, ``1``, ``1``, ``1``, ``1``, ``1``, ``1``, ``1``],``[``1``, ``1``, ``1``, ``1``, ``1``, ``1``, ``0``, ``0``],``[``1``, ``0``, ``0``, ``1``, ``1``, ``0``, ``1``, ``1``],``[``1``, ``2``, ``2``, ``2``, ``2``, ``0``, ``1``, ``0``],``[``1``, ``1``, ``1``, ``2``, ``2``, ``0``, ``1``, ``0``],``[``1``, ``1``, ``1``, ``2``, ``2``, ``2``, ``2``, ``0``],``[``1``, ``1``, ``1``, ``1``, ``1``, ``2``, ``1``, ``1``],``[``1``, ``1``, ``1``, ``1``, ``1``, ``2``, ``2``, ``1``],``    ``]``    ` `# Row of the display``m ``=` `len``(screen)` `# Column of the display``n ``=` `len``(screen[``0``])` `# Co-ordinate provided by the user``x ``=` `4``y ``=` `4` `# Current color at that co-ordinate``prevC ``=` `screen[x][y]` `# New color that has to be filled``newC ``=` `3` `floodFill(screen, m, n, x, y, prevC, newC)`  `# Printing the updated screen``for` `i ``in` `range``(m):``    ``for` `j ``in` `range``(n):``        ``print``(screen[i][j], end ``=``' '``)``    ``print``()`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;``class` `GFG {``    ` `    ``// Function that returns true if``    ``// the given pixel is valid``    ``static` `bool` `isValid(``int``[,] screen, ``int` `m, ``int` `n, ``int` `x, ``int` `y, ``int` `prevC, ``int` `newC)``    ``{``        ``if``(x < 0 || x >= m || y < 0 || y >= n || screen[x, y] != prevC``           ``|| screen[x,y]== newC)``            ``return` `false``;``        ``return` `true``;``    ``}`` ` ` ` `    ``// FloodFill function``    ``static` `void` `floodFill(``int``[,] screen, ``int` `m, ``int` `n, ``int` `x, ``int` `y, ``int` `prevC, ``int` `newC)``    ``{``        ``List> queue = ``new` `List>();`` ` `        ``// Append the position of starting``        ``// pixel of the component``        ``queue.Add(``new` `Tuple<``int``,``int``>(x, y));`` ` `        ``// Color the pixel with the new color``        ``screen[x,y] = newC;`` ` `        ``// While the queue is not empty i.e. the``        ``// whole component having prevC color``        ``// is not colored with newC color``        ``while``(queue.Count > 0)``        ``{``            ``// Dequeue the front node``            ``Tuple<``int``,``int``> currPixel = queue[queue.Count - 1];``            ``queue.RemoveAt(queue.Count - 1);`` ` `            ``int` `posX = currPixel.Item1;``            ``int` `posY = currPixel.Item2;`` ` `            ``// Check if the adjacent``            ``// pixels are valid``            ``if``(isValid(screen, m, n, posX + 1, posY, prevC, newC))``            ``{``                ``// Color with newC``                ``// if valid and enqueue``                ``screen[posX + 1,posY] = newC;``                ``queue.Add(``new` `Tuple<``int``,``int``>(posX + 1, posY));``            ``}`` ` `            ``if``(isValid(screen, m, n, posX-1, posY, prevC, newC))``            ``{``                ``screen[posX-1,posY]= newC;``                ``queue.Add(``new` `Tuple<``int``,``int``>(posX-1, posY));``            ``}`` ` `            ``if``(isValid(screen, m, n, posX, posY + 1, prevC, newC))``            ``{``                ``screen[posX,posY + 1]= newC;``                ``queue.Add(``new` `Tuple<``int``,``int``>(posX, posY + 1));``            ``}`` ` `            ``if``(isValid(screen, m, n, posX, posY-1, prevC, newC))``            ``{``                ``screen[posX,posY-1]= newC;``                ``queue.Add(``new` `Tuple<``int``,``int``>(posX, posY-1));``            ``}``        ``}``    ``}``    ` `  ``static` `void` `Main() {``    ``int``[,] screen ={``    ``{1, 1, 1, 1, 1, 1, 1, 1},``    ``{1, 1, 1, 1, 1, 1, 0, 0},``    ``{1, 0, 0, 1, 1, 0, 1, 1},``    ``{1, 2, 2, 2, 2, 0, 1, 0},``    ``{1, 1, 1, 2, 2, 0, 1, 0},``    ``{1, 1, 1, 2, 2, 2, 2, 0},``    ``{1, 1, 1, 1, 1, 2, 1, 1},``    ``{1, 1, 1, 1, 1, 2, 2, 1}};`` ` `    ``// Row of the display``    ``int` `m = screen.GetLength(0);`` ` `    ``// Column of the display``    ``int` `n = screen.GetLength(1);`` ` `    ``// Co-ordinate provided by the user``    ``int` `x = 4;``    ``int` `y = 4;`` ` `    ``// Current color at that co-ordinate``    ``int` `prevC = screen[x,y];`` ` `    ``// New color that has to be filled``    ``int` `newC = 3;``    ``floodFill(screen, m, n, x, y, prevC, newC);`` ` `    ``// Printing the updated screen``    ``for``(``int` `i = 0; i < m; i++)``    ``{``        ``for``(``int` `j = 0; j < n; j++)``        ``{``            ``Console.Write(screen[i,j] + ``" "``);``        ``}``        ``Console.WriteLine();``    ``}``  ``}``}` `// This code is contributed by divyeshrabadiya07.`

## Javascript

 ``
Output:
```1 1 1 1 1 1 1 1
1 1 1 1 1 1 0 0
1 0 0 1 1 0 1 1
1 3 3 3 3 0 1 0
1 1 1 3 3 0 1 0
1 1 1 3 3 3 3 0
1 1 1 1 1 3 1 1
1 1 1 1 1 3 3 1```

DFS Approach: Similarly DFS approach can be used to implement the Flood Fill algorithm as well.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up