Flood Fill Algorithm

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 0 
1 1 1 1 1 3 1 1 
1 1 1 1 1 3 3 1 
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 let’s say Q.
• Push the starting location of the pixel as given in the input and apply the 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 them 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:

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

// Function that returns true if
// the given pixel is valid
bool isValid(int screen[][8], 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
void floodFill(int screen[][8], int m, int n, int x, int y,
               int prevC, int newC)
{
    queue<pair<int, int> > queue;

    // Append the position of starting
    // pixel of the component
    pair<int, int> p(x, y);
    queue.push(p);

    // 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.size() > 0) {
        // Dequeue the front node
        pair<int, int> currPixel = queue.front();
        queue.pop();

        int posX = currPixel.first;
        int posY = currPixel.second;

        // 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;
            p.first = posX + 1;
            p.second = posY;
            queue.push(p);
        }

        if (isValid(screen, m, n, posX - 1, posY, prevC,
                    newC)) {
            screen[posX - 1][posY] = newC;
            p.first = posX - 1;
            p.second = posY;
            queue.push(p);
        }

        if (isValid(screen, m, n, posX, posY + 1, prevC,
                    newC)) {
            screen[posX][posY + 1] = newC;
            p.first = posX;
            p.second = posY + 1;
            queue.push(p);
        }

        if (isValid(screen, m, n, posX, posY - 1, prevC,
                    newC)) {
            screen[posX][posY - 1] = newC;
            p.first = posX;
            p.second = posY - 1;
            queue.push(p);
        }
    }
}

int main()
{
    int screen[][8] = { { 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 = 8;

    // Column of the display
    int n = 8;

    // 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++) {
            cout << screen[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

// This code is contributed by suresh07.

Java

// Java implementation of the approach
import java.util.*;
import java.awt.Point;
public class Main
{
    // Function that returns true if
    // the given pixel is valid
    static boolean 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)
    {
        Vector<Point> queue = new Vector<Point>();

        // Append the position of starting
        // pixel of the component
        queue.add(new Point(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.size() > 0)
        {
            // Dequeue the front node
            Point currPixel = queue.get(queue.size() - 1);
            queue.remove(queue.size() - 1);

            int posX = currPixel.x;
            int posY = currPixel.y;

            // 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 Point(posX + 1, posY));
            }

            if(isValid(screen, m, n, posX-1, posY, prevC, newC))
            {
                screen[posX-1][posY]= newC;
                queue.add(new Point(posX-1, posY));
            }

            if(isValid(screen, m, n, posX, posY + 1, prevC, newC))
            {
                screen[posX][posY + 1]= newC;
                queue.add(new Point(posX, posY + 1));
            }

            if(isValid(screen, m, n, posX, posY-1, prevC, newC))
            {
                screen[posX][posY-1]= newC;
                queue.add(new Point(posX, posY-1));
            }
        }
    }

    public static void main(String[] args) {
        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.length;

        // Column of the display
        int n = screen.length;

        // 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++)
            {
                System.out.print(screen[i][j] + " ");
            }
            System.out.println();
        }
    }
}

// This code is contributed by mukesh07.

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<Tuple<int,int>> queue = new List<Tuple<int,int>>();

        // 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

<script>
    // Javascript implementation of the approach

    // Function that returns true if
    // the given pixel is valid
    function isValid(screen, m, n, x, y, prevC, newC)
    {
        if(x<0 || x>= m || y<0 || y>= n || screen[x][y]!= prevC
           || screen[x][y]== newC)
            return false;
        return true;
    }


    // FloodFill function
    function floodFill(screen, m, n, x, y, prevC, newC)
    {
        let queue = [];

        // Append the position of starting
        // pixel of the component
        queue.push([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.length > 0)
        {
            // Dequeue the front node
            currPixel = queue[queue.length - 1];
            queue.pop();

            let posX = currPixel[0];
            let 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.push([posX + 1, posY]);
            }

            if(isValid(screen, m, n, posX-1, posY, prevC, newC))
            {
                screen[posX-1][posY]= newC;
                queue.push([posX-1, posY]);
            }

            if(isValid(screen, m, n, posX, posY + 1, prevC, newC))
            {
                screen[posX][posY + 1]= newC;
                queue.push([posX, posY + 1]);
            }

            if(isValid(screen, m, n, posX, posY-1, prevC, newC))
            {
                screen[posX][posY-1]= newC;
                queue.push([posX, posY-1]);
            }
        }
    }

    let 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
    let m = screen.length;

    // Column of the display
    let n = screen[0].length;

    // Co-ordinate provided by the user
    let x = 4;
    let y = 4;

    // Current color at that co-ordinate
    let prevC = screen[x][y];

    // New color that has to be filled
    let newC = 3;

    floodFill(screen, m, n, x, y, prevC, newC);


    // Printing the updated screen
    for(let i = 0; i < m; i++)
    {
        for(let j = 0; j < n; j++)
        {
            document.write(screen[i][j] + " ");
        }
        document.write("</br>");
    }

    // This code is contributed by divyesh072019.
</script>

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 

Time Complexity: O(N*M)
Auxiliary Space: O(N*M)

An Approach using DFS:

• Change the color of the source row and source column with the given color
• Do DFS in four direction

Below is the implementation of the above approach:

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

// DFS Approach
void dfs(int row,int col,vector<vector<int>> &image,vector<vector<int>>& ans,int newColor,int iniColor,int n,int m,int delrow[],int delcol[]){

    // Marking it as the newColor
    ans[row][col] = newColor;
    for(int i=0;i<4;i++){
        int nrow = row + delrow[i];
        int ncol = col + delcol[i];
          // Checking Out Of Bound Condition
        if(nrow>=0 && ncol>=0 && nrow<n && ncol<m && image[nrow][ncol]==iniColor && ans[nrow][ncol]!=newColor){
            dfs(nrow,ncol,image,ans,newColor,iniColor,n,m,delrow,delcol);
        }
    }

}
// FloodFill Function
vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
        // Code here
        vector<vector<int>> ans = image;
        int n = image.size();
        int m = image[0].size();
          // Initial Color
        int iniColor = image[sr][sc];
          // vectors for changing of rows and column direction
          // UP LEFT DOWN RIGHT
        int delrow[] = {-1,0,+1,0};
        int delcol[] = {0,+1,0,-1};
          // Calling dfs function
        dfs(sr,sc,image,ans,newColor,iniColor,n,m,delrow,delcol);
        return ans;
    }

// Driver code
int main()
{
    vector<vector<int> > screen
        = { {1, 1, 1},
            {1, 1, 0},
            {1, 0, 1} };

    int n = screen.size();
      int m = screen[0].size();
    // Co-ordinate provided by the user
    int x = 1;
    int y = 1;

    // New color that has to be filled
    int newC = 3;
    vector<vector<int>> ans = floodFill(screen, x, y, newC);


    // Printing the updated screen
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cout << ans[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

// This code is contributed by Tanishq Raj.

Java

import java.util.ArrayList;

public class FloodFill {
    // Floodfill function
    public static void floodFill(int[][] screen, int sr,
                                 int sc, int row, int col,
                                 int source, int color)
    {
        // Condition for checking out of bounds
        if (sr < 0 || sr >= row || sc < 0 || sc >= col)
            return;

        if (screen[sr][sc] != source)
            return;

        screen[sr][sc] = color;
        floodFill(screen, sr - 1, sc, row, col, source,
                  color); // left
        floodFill(screen, sr + 1, sc, row, col, source,
                  color); // right
        floodFill(screen, sr, sc + 1, row, col, source,
                  color); // top
        floodFill(screen, sr, sc - 1, row, col, source,
                  color); // bottom
    }

    public static void main(String[] args)
    {
        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 = 8;

        // Column of the display
        int n = 8;

        // 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, x, y, m, n, prevC, newC);

        // Printing the updated screen
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print(screen[i][j] + " ");
            }
            System.out.println();
        }
    }
}

Python3

from typing import List, Tuple


def flood_fill(screen: List[List[int]], sr: int, sc: int, row: int, col: int, source: int, color: int) -> None:
    # Condition for checking out of bounds
    if sr < 0 or sr >= row or sc < 0 or sc >= col:
        return

    if screen[sr][sc] != source:
        return

    screen[sr][sc] = color
    flood_fill(screen, sr - 1, sc, row, col, source, color)  # left
    flood_fill(screen, sr + 1, sc, row, col, source, color)  # right
    flood_fill(screen, sr, sc + 1, row, col, source, color)  # top
    flood_fill(screen, sr, sc - 1, row, col, source, color)  # bottom


if __name__ == "__main__":
    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 = 8

    # Column of the display
    n = 8

    # Coordinate provided by the user
    x = 4
    y = 4

    # Current color at that coordinate
    prevC = screen[x][y]

    # New color that has to be filled
    newC = 3

    flood_fill(screen, x, y, m, n, prevC, newC)

    # Printing the updated screen
    for i in range(m):
        for j in range(n):
            print(screen[i][j], end=" ")
        print()

C#

using System;

namespace FloodFill {
class Program {
    static void Main(string[] args)
    {
        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 } };

        // Dimensions of the screen
        int m = 8;
        int n = 8;

        // Coordinates provided by the user
        int x = 4;
        int y = 4;

        // Current color at the given coordinate
        int prevC = screen[x, y];

        // New color to fill
        int newC = 3;

        FloodFill(screen, x, y, m, n, 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();
        }

        Console.ReadKey();
    }

    // Flood fill function
    static void FloodFill(int[, ] screen, int sr, int sc,
                          int row, int col, int source,
                          int color)
    {
        // Check for out of bounds
        if (sr < 0 || sr >= row || sc < 0 || sc >= col)
            return;

        // Check if the current pixel is not equal to the
        // source color
        if (screen[sr, sc] != source)
            return;

        screen[sr, sc] = color;

        // Recursively fill the surrounding pixels
        FloodFill(screen, sr - 1, sc, row, col, source,
                  color); // left
        FloodFill(screen, sr + 1, sc, row, col, source,
                  color); // right
        FloodFill(screen, sr, sc + 1, row, col, source,
                  color); // top
        FloodFill(screen, sr, sc - 1, row, col, source,
                  color); // bottom
    }
}
}

Javascript

// JavaScript implementation of the approach


// Floodfill function
function floodFill(screen, sr, sc, row, col, source, color)
{
    // Condition for checking out of bounds
    if (sr < 0 || sr >= row || sc < 0 || sc >= col) return;

    if (screen[sr][sc] != source) return;

    screen[sr][sc] = color;
    floodFill(screen, sr - 1, sc, row, col, source, color); // left
    floodFill(screen, sr + 1, sc, row, col, source, color); // right
    floodFill(screen, sr, sc + 1, row, col, source, color); // top
    floodFill(screen, sr, sc - 1, row, col, source, color); // bottom
}

// Driver code
let 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
let m = 8;

// Column of the display
let n = 8;

// Co-ordinate provided by the user
let x = 4;
let y = 4;

// Current color at that co-ordinate
let prevC = screen[x][y];

// New color that has to be filled
let newC = 3;

floodFill(screen, x, y, m, n, prevC, newC);

// Printing the updated screen
for (let i = 0; i < m; i++) {
    let temp = "";
    for (let j = 0; j < n; j++) {
           document.write(screen[i][j] + " ");
    }
    document.write("</br>");
}


// This code is contributed by Gautam goel

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 

Time Complexity: O(m*n)
Auxiliary Space: O(m + n), due to the recursive call stack.