Flood fill Algorithm – how to implement fill() in paint?

24 Jun, 2022
In MS-Paint, when we take the brush to a pixel and click, the color of the region of that pixel is replaced with a new selected color. Following is the problem statement to do this task. 
Given a 2D screen, location of a pixel in the screen and a color, replace color of the given pixel and all adjacent same colored pixels with the given color.
Example: 
Input:
screen[M][N] = {{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, newColor = 3
The values in the given 2D screen
  indicate colors of the pixels.
x and y are coordinates of the brush,
   newColor is the color that
should replace the previous color on 
   screen[x][y] and all surrounding
pixels with same color.

Output:
Screen should be changed to following.
screen[M][N] = {{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},
               };
This question can be solved using either Recursion or BFS. Both the solutions are discussed below 
Method 1 (Using Recursion): The idea is simple, we first replace the color of the current pixel, then recur for 4 surrounding points. The following is a detailed algorithm. 
// A recursive function to replace 
// previous color 'prevC' at  '(x, y)' 
// and all surrounding pixels of (x, y)
// with new color 'newC' and
floodFill(screen[M][N], x, y, prevC, newC)
1) If x or y is outside the screen, then return.
2) If color of screen[x][y] is not same as prevC, then return
3) Recur for north, south, east and west.
    floodFillUtil(screen, x+1, y, prevC, newC);
    floodFillUtil(screen, x-1, y, prevC, newC);
    floodFillUtil(screen, x, y+1, prevC, newC);
    floodFillUtil(screen, x, y-1, prevC, newC); 
The following is the implementation of the above algorithm.  
C++
Java
Python3
C#
Javascript
// A C++ program to implement flood fill algorithm#include<iostream>using namespace std; // Dimensions of paint screen#define M 8#define N 8 // A recursive function to replace previous color 'prevC' at  '(x, y)'// and all surrounding pixels of (x, y) with new color 'newC' andvoid floodFillUtil(int screen[][N], int x, int y, int prevC, int newC){    // Base cases    if (x < 0 || x >= M || y < 0 || y >= N)        return;    if (screen[x][y] != prevC)        return;    if (screen[x][y] == newC)        return;     // Replace the color at (x, y)    screen[x][y] = newC;     // Recur for north, east, south and west    floodFillUtil(screen, x+1, y, prevC, newC);    floodFillUtil(screen, x-1, y, prevC, newC);    floodFillUtil(screen, x, y+1, prevC, newC);    floodFillUtil(screen, x, y-1, prevC, newC);} // It mainly finds the previous color on (x, y) and// calls floodFillUtil()void floodFill(int screen[][N], int x, int y, int newC){    int prevC = screen[x][y];      if(prevC==newC) return;    floodFillUtil(screen, x, y, prevC, newC);} // Driver codeint main(){    int screen[M][N] = {{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},                     };    int x = 4, y = 4, newC = 3;    floodFill(screen, x, y, newC);     cout << "Updated screen after call to floodFill: \n";    for (int i=0; i<M; i++)    {        for (int j=0; j<N; j++)           cout << screen[i][j] << " ";        cout << endl;    }}//Updated by Arun Pandey
// Java program to implement flood fill algorithmclass GFG{ // Dimensions of paint screenstatic int M = 8;static int N = 8; // A recursive function to replace previous color 'prevC' at '(x, y)'// and all surrounding pixels of (x, y) with new color 'newC' andstatic void floodFillUtil(int screen[][], int x, int y,                                    int prevC, int newC){    // Base cases    if (x < 0 || x >= M || y < 0 || y >= N)        return;    if (screen[x][y] != prevC)        return;     // Replace the color at (x, y)    screen[x][y] = newC;     // Recur for north, east, south and west    floodFillUtil(screen, x+1, y, prevC, newC);    floodFillUtil(screen, x-1, y, prevC, newC);    floodFillUtil(screen, x, y+1, prevC, newC);    floodFillUtil(screen, x, y-1, prevC, newC);} // It mainly finds the previous color on (x, y) and// calls floodFillUtil()static void floodFill(int screen[][], int x, int y, int newC){    int prevC = screen[x][y];      if(prevC==newC) return;    floodFillUtil(screen, x, y, prevC, newC);} // Driver codepublic 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},                    };    int x = 4, y = 4, newC = 3;    floodFill(screen, x, y, newC);     System.out.println("Updated screen after call to floodFill: ");    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 has been contributed by 29AjayKumar// Updated by Arun Pandey
# Python3 program to implement# flood fill algorithm # Dimensions of paint screenM = 8N = 8 # A recursive function to replace# previous color 'prevC' at '(x, y)'# and all surrounding pixels of (x, y)# with new color 'newC' anddef floodFillUtil(screen, x, y, prevC, newC):         # Base cases    if (x < 0 or x >= M or y < 0 or        y >= N or screen[x][y] != prevC or        screen[x][y] == newC):        return     # Replace the color at (x, y)    screen[x][y] = newC     # Recur for north, east, south and west    floodFillUtil(screen, x + 1, y, prevC, newC)    floodFillUtil(screen, x - 1, y, prevC, newC)    floodFillUtil(screen, x, y + 1, prevC, newC)    floodFillUtil(screen, x, y - 1, prevC, newC) # It mainly finds the previous color on (x, y) and# calls floodFillUtil()def floodFill(screen, x, y, newC):    prevC = screen[x][y]    if(prevC==newC):      return    floodFillUtil(screen, x, y, prevC, newC) # Driver Codescreen = [[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 = 4y = 4newC = 3floodFill(screen, x, y, newC) print ("Updated screen after call to floodFill:")for i in range(M):    for j in range(N):        print(screen[i][j], end = ' ')    print() # This code is contributed by Ashutosh450# Updated by Arun Pandey
// C# program to implement// flood fill algorithmusing System;     class GFG{ // Dimensions of paint screenstatic int M = 8;static int N = 8; // A recursive function to replace// previous color 'prevC' at '(x, y)'// and all surrounding pixels of (x, y)// with new color 'newC' andstatic void floodFillUtil(int [,]screen,                          int x, int y,                          int prevC, int newC){    // Base cases    if (x < 0 || x >= M ||        y < 0 || y >= N)        return;    if (screen[x, y] != prevC)        return;     // Replace the color at (x, y)    screen[x, y] = newC;     // Recur for north, east, south and west    floodFillUtil(screen, x + 1, y, prevC, newC);    floodFillUtil(screen, x - 1, y, prevC, newC);    floodFillUtil(screen, x, y + 1, prevC, newC);    floodFillUtil(screen, x, y - 1, prevC, newC);} // It mainly finds the previous color// on (x, y) and calls floodFillUtil()static void floodFill(int [,]screen, int x,                      int y, int newC){    int prevC = screen[x, y];      if(prevC == newC)      return;    floodFillUtil(screen, x, y, prevC, newC);} // Driver codepublic 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}};    int x = 4, y = 4, newC = 3;    floodFill(screen, x, y, newC);     Console.WriteLine("Updated screen after" +                      "call to floodFill: ");    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 PrinciRaj1992// Updated by Arun Pandey
<script>      // JavaScript program to implement      // flood fill algorithm      // Dimensions of paint screen      var M = 8;      var N = 8;       // A recursive function to replace      // previous color 'prevC' at '(x, y)'      // and all surrounding pixels of (x, y)      // with new color 'newC' and      function floodFillUtil(screen, x, y, prevC, newC)      {               // Base cases        if (x < 0 || x >= M || y < 0 || y >= N) return;        if (screen[x][y] != prevC) return;         // Replace the color at (x, y)        screen[x][y] = newC;         // Recur for north, east, south and west        floodFillUtil(screen, x + 1, y, prevC, newC);        floodFillUtil(screen, x - 1, y, prevC, newC);        floodFillUtil(screen, x, y + 1, prevC, newC);        floodFillUtil(screen, x, y - 1, prevC, newC);      }       // It mainly finds the previous color      // on (x, y) and calls floodFillUtil()      function floodFill(screen, x, y, newC) {        var prevC = screen[x][y];        if (prevC == newC) return;        floodFillUtil(screen, x, y, prevC, newC);      }       // Driver code      var 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],      ];      var x = 4,        y = 4,        newC = 3;      floodFill(screen, x, y, newC);       document.write("Updated screen after" + "call to floodFill: <br>");      for (var i = 0; i < M; i++) {        for (var j = 0; j < N; j++) document.write(screen[i][j] + " ");        document.write("<br>");      }             // This code is contributed by rdtank.    </script>
Updated screen after call to floodFill: 
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 x N).Auxiliary Space: O(M x N), as implicit stack is created due to recursion
Method 2 (Using the BFS approach):
Algorithm for BFS based approach :
Create a queue of pairs.Insert an initial index given in the queue.Mark initial index as visited in vis[][] matrix.Until the queue is not empty repeat step 4.1 to 4.6Take the front element from the queuePop from the queueStore current value/color at coordinate taken out from queue (precolor)Update the value/color of the current index which is taken out from the queueCheck for all 4 direction i.e (x+1,y),(x-1,y),(x,y+1),(x,y-1) is valid or not and if valid then check that value at that coordinate should be equal to precolor and value of that coordinate in vis[][] is 0.If all the above condition is true push the corresponding coordinate in queue and mark as 1 in vis[][]Print the matrix.
Create a queue of pairs.
Insert an initial index given in the queue.
Mark initial index as visited in vis[][] matrix.
Until the queue is not empty repeat step 4.1 to 4.6Take the front element from the queuePop from the queueStore current value/color at coordinate taken out from queue (precolor)Update the value/color of the current index which is taken out from the queueCheck for all 4 direction i.e (x+1,y),(x-1,y),(x,y+1),(x,y-1) is valid or not and if valid then check that value at that coordinate should be equal to precolor and value of that coordinate in vis[][] is 0.If all the above condition is true push the corresponding coordinate in queue and mark as 1 in vis[][]
Take the front element from the queue
Pop from the queue
Store current value/color at coordinate taken out from queue (precolor)
Update the value/color of the current index which is taken out from the queue
Check for all 4 direction i.e (x+1,y),(x-1,y),(x,y+1),(x,y-1) is valid or not and if valid then check that value at that coordinate should be equal to precolor and value of that coordinate in vis[][] is 0.
If all the above condition is true push the corresponding coordinate in queue and mark as 1 in vis[][]
Print the matrix.
Below is the implementation of the above approach:  
C++
Java
Python3
C#
Javascript
// C++ program for above approach#include <bits/stdc++.h>using namespace std; // Function to check valid coordinateint validCoord(int x, int y, int n, int m){     if (x < 0 || y < 0) {        return 0;    }    if (x >= n || y >= m) {        return 0;    }    return 1;} // Function to run bfsvoid bfs(int n, int m, int data[][8],                     int x, int y, int color){     // Visiting array  int vis[101][101];     // Initializing all as zero  memset(vis, 0, sizeof(vis));     // Creating queue for bfs  queue<pair<int, int> > obj;     // Pushing pair of {x, y}  obj.push({ x, y });     // Marking {x, y} as visited  vis[x][y] = 1;     // Until queue is empty  while (obj.empty() != 1)  {     // Extracting front pair    pair<int, int> coord = obj.front();    int x = coord.first;    int y = coord.second;    int preColor = data[x][y];     data[x][y] = color;         // Popping front pair of queue    obj.pop();     // For Upside Pixel or Cell    if (validCoord(x + 1, y, n, m)        && vis[x + 1][y] == 0        && data[x + 1][y] == preColor)    {      obj.push({ x + 1, y });      vis[x + 1][y] = 1;    }         // For Downside Pixel or Cell    if (validCoord(x - 1, y, n, m)        && vis[x - 1][y] == 0        && data[x - 1][y] == preColor)    {      obj.push({ x - 1, y });      vis[x - 1][y] = 1;    }         // For Right side Pixel or Cell    if (validCoord(x, y + 1, n, m)        && vis[x][y + 1] == 0        && data[x][y + 1] == preColor)    {      obj.push({ x, y + 1 });      vis[x][y + 1] = 1;    }         // For Left side Pixel or Cell    if (validCoord(x, y - 1, n, m)        && vis[x][y - 1] == 0        && data[x][y - 1] == preColor)    {      obj.push({ x, y - 1 });      vis[x][y - 1] = 1;    }  }     // Printing The Changed Matrix Of Pixels  for (int i = 0; i < n; i++)  {    for (int j = 0; j < m; j++)    {      cout << data[i][j] << " ";    }    cout << endl;  }  cout << endl;} // Driver Codeint main(){  int n, m, x, y, color;  n = 8;  m = 8;   int data[8][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 },  };   x = 4, y = 4, color = 3;     // Function Call  bfs(n, m, data, x, y, color);  return 0;}
// Java program for above approachimport java.io.*;import java.util.*; // Class to store the pairsclass Pair implements Comparable<Pair> {    int first;    int second;     public Pair(int first, int second) {        this.first = first;        this.second = second;    }     @Override    public int compareTo(Pair o) {        return second - o.second;    }} class GFG {    public static int validCoord(int x, int y, int n, int m)    {        if (x < 0 || y < 0) {            return 0;        }        if (x >= n || y >= m) {            return 0;        }        return 1;    }    // Function to run bfs    public static void bfs(int n, int m, int data[][],int x, int y, int color)    {           // Visiting array         int vis[][]=new int[101][101];                 // Initializing all as zero        for(int i=0;i<=100;i++){            for(int j=0;j<=100;j++){                vis[i][j]=0;            }        }                 // Creating queue for bfs         Queue<Pair> obj = new LinkedList<>();           // Pushing pair of {x, y}         Pair pq=new Pair(x,y);         obj.add(pq);                  // Marking {x, y} as visited         vis[x][y] = 1;           // Until queue is empty        while (!obj.isEmpty())        {            // Extracting front pair            Pair coord = obj.peek();            int x1 = coord.first;            int y1 = coord.second;            int preColor = data[x1][y1];                         data[x1][y1] = color;                 // Popping front pair of queue            obj.remove();             // For Upside Pixel or Cell            if ((validCoord(x1 + 1, y1, n, m)==1) && vis[x1 + 1][y1] == 0 && data[x1 + 1][y1] == preColor)            {                Pair p=new Pair(x1 +1, y1);                obj.add(p);                vis[x1 + 1][y1] = 1;            }                 // For Downside Pixel or Cell            if ((validCoord(x1 - 1, y1, n, m)==1) && vis[x1 - 1][y1] == 0 && data[x1 - 1][y1] == preColor)            {                Pair p=new Pair(x1-1,y1);                obj.add(p);                vis[x1- 1][y1] = 1;            }                 // For Right side Pixel or Cell            if ((validCoord(x1, y1 + 1, n, m)==1) && vis[x1][y1 + 1] == 0 && data[x1][y1 + 1] == preColor)            {                Pair p=new Pair(x1,y1 +1);                obj.add(p);                vis[x1][y1 + 1] = 1;            }                 // For Left side Pixel or Cell            if ((validCoord(x1, y1 - 1, n, m)==1) && vis[x1][y1 - 1] == 0 && data[x1][y1 - 1] == preColor)            {                Pair p=new Pair(x1,y1 -1);                obj.add(p);                vis[x1][y1 - 1] = 1;            }        }            // Printing The Changed Matrix Of Pixels        for (int i = 0; i < n; i++)        {            for (int j = 0; j < m; j++)            {               System.out.print(data[i][j]+" ");            }            System.out.println();        }        System.out.println();    }    public static void main (String[] args) {        int nn, mm, xx, yy, colorr;        nn = 8;        mm = 8;         int data[][] = {{ 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 },};         xx = 4; yy = 4; colorr = 3;           // Function Call        bfs(nn, mm, data, xx, yy, colorr);    }}// This code is contributed by Manu Pathria
# Python3 program for above approach # Function to check valid coordinatedef validCoord(x, y, n, m):    if x < 0 or y < 0:        return 0    if x >= n or y >= m:        return 0    return 1 # Function to run bfsdef bfs(n, m, data, X, Y, color):     # Visiting array  vis = [[0 for i in range(101)] for j in range(101)]       # Creating queue for bfs  obj = []       # Pushing pair of {x, y}  obj.append([X, Y])       # Marking {x, y} as visited  vis[X][Y] = 1       # Until queue is empty  while len(obj) > 0:         # Extracting front pair    coord = obj[0]    x = coord[0]    y = coord[1]    preColor = data[x][y]       data[x][y] = color           # Popping front pair of queue    obj.pop(0)       # For Upside Pixel or Cell    if validCoord(x + 1, y, n, m) == 1 and vis[x + 1][y] == 0 and data[x + 1][y] == preColor:      obj.append([x + 1, y])      vis[x + 1][y] = 1           # For Downside Pixel or Cell    if validCoord(x - 1, y, n, m) == 1 and vis[x - 1][y] == 0 and data[x - 1][y] == preColor:      obj.append([x - 1, y])      vis[x - 1][y] = 1           # For Right side Pixel or Cell    if validCoord(x, y + 1, n, m) == 1 and vis[x][y + 1] == 0 and data[x][y + 1] == preColor:      obj.append([x, y + 1])      vis[x][y + 1] = 1           # For Left side Pixel or Cell    if validCoord(x, y - 1, n, m) == 1 and vis[x][y - 1] == 0 and data[x][y - 1] == preColor:      obj.append([x, y - 1])      vis[x][y - 1] = 1       # Printing The Changed Matrix Of Pixels  for i in range(n):    for j in range(m):      print(data[i][j], end = " ")    print()  print() n = 8m = 8 data = [  [ 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, y, color = 4, 4, 3 # Function Callbfs(n, m, data, x, y, color) # This code is contributed by decode2207.
// C# program for above approachusing System;using System.Collections.Generic;class GFG {         // Function to check valid coordinate    static int validCoord(int x, int y, int n, int m)    {              if (x < 0 || y < 0) {            return 0;        }        if (x >= n || y >= m) {            return 0;        }        return 1;    }          // Function to run bfs    static void bfs(int n, int m, int[,] data, int X, int Y, int color)    {              // Visiting array      int[,] vis = new int[101,101];              // Creating queue for bfs      List<Tuple<int, int>> obj = new List<Tuple<int, int>>();              // Pushing pair of {x, y}      obj.Add(new Tuple<int,int>( X, Y ));              // Marking {x, y} as visited      vis[X,Y] = 1;              // Until queue is empty      while (obj.Count > 0)      {              // Extracting front pair        Tuple<int, int> coord = obj[0];        int x = coord.Item1;        int y = coord.Item2;        int preColor = data[x,y];              data[x,y] = color;                  // Popping front pair of queue        obj.RemoveAt(0);              // For Upside Pixel or Cell        if (validCoord(x + 1, y, n, m) == 1            && vis[x + 1,y] == 0            && data[x + 1,y] == preColor)        {          obj.Add(new Tuple<int,int>(x + 1, y));          vis[x + 1,y] = 1;        }                  // For Downside Pixel or Cell        if (validCoord(x - 1, y, n, m) == 1            && vis[x - 1,y] == 0            && data[x - 1,y] == preColor)        {          obj.Add(new Tuple<int,int>(x - 1, y));          vis[x - 1,y] = 1;        }                  // For Right side Pixel or Cell        if (validCoord(x, y + 1, n, m) == 1            && vis[x,y + 1] == 0            && data[x,y + 1] == preColor)        {          obj.Add(new Tuple<int,int>(x, y + 1));          vis[x,y + 1] = 1;        }                  // For Left side Pixel or Cell        if (validCoord(x, y - 1, n, m) == 1            && vis[x,y - 1] == 0            && data[x,y - 1] == preColor)        {          obj.Add(new Tuple<int,int>(x, y - 1));          vis[x,y - 1] = 1;        }      }              // Printing The Changed Matrix Of Pixels      for (int i = 0; i < n; i++)      {        for (int j = 0; j < m; j++)        {          Console.Write(data[i,j] + " ");        }        Console.WriteLine();      }      Console.WriteLine();    }   static void Main() {      int n, m, x, y, color;      n = 8;      m = 8;            int[,] data = {        { 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;      color = 3;              // Function Call      bfs(n, m, data, x, y, color);  }} // This code is contributed by divyeshrabadiya07.
<script>    // Javascript program for above approach         // Function to check valid coordinate    function validCoord(x, y, n, m)    {        if (x < 0 || y < 0) {            return 0;        }        if (x >= n || y >= m) {            return 0;        }        return 1;    }         // Function to run bfs    function bfs(n, m, data, X, Y, color)    {               // Visiting array      let vis = new Array(101);      for(let i = 0; i < 101; i++)      {          vis[i] = new Array(101);        for(let j = 0; j < 101; j++)        {            vis[i][j] = 0;        }      }               // Creating queue for bfs      let obj = [];               // Pushing pair of {x, y}      obj.push([X, Y]);               // Marking {x, y} as visited      vis[X][Y] = 1;               // Until queue is empty      while (obj.length > 0)      {               // Extracting front pair        let coord = obj[0];        let x = coord[0];        let y = coord[1];        let preColor = data[x][y];               data[x][y] = color;                   // Popping front pair of queue        obj.shift();               // For Upside Pixel or Cell        if (validCoord(x + 1, y, n, m) == 1            && vis[x + 1][y] == 0            && data[x + 1][y] == preColor)        {          obj.push([x + 1, y]);          vis[x + 1][y] = 1;        }                   // For Downside Pixel or Cell        if (validCoord(x - 1, y, n, m) == 1            && vis[x - 1][y] == 0            && data[x - 1][y] == preColor)        {          obj.push([x - 1, y]);          vis[x - 1][y] = 1;        }                   // For Right side Pixel or Cell        if (validCoord(x, y + 1, n, m) == 1            && vis[x][y + 1] == 0            && data[x][y + 1] == preColor)        {          obj.push([x, y + 1]);          vis[x][y + 1] = 1;        }                   // For Left side Pixel or Cell        if (validCoord(x, y - 1, n, m) == 1            && vis[x][y - 1] == 0            && data[x][y - 1] == preColor)        {          obj.push([x, y - 1]);          vis[x][y - 1] = 1;        }      }               // Printing The Changed Matrix Of Pixels      for (let i = 0; i < n; i++)      {        for (let j = 0; j < m; j++)        {          document.write(data[i][j] + " ");        }        document.write("</br>");      }      document.write("</br>");    }         let n, m, x, y, color;    n = 8;    m = 8;     let data = [      [ 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, color = 3;     // Function Call    bfs(n, m, data, x, y, color); // This code is contributed by mukesh07.</script>
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 x N).Auxiliary Space: O(M x N),
29AjayKumar
princiraj1992
ashutosh450
ShivangiKansal
riteshgfgcode
manupathria
adnanirshad158
arunpandey1112000
rdtank
sooda367
akshaysingh98088
kk773572498
kaustavbora
simmytarika5
surinderdawra388
surindertarika1234
sweetyty
divyeshrabadiya07
rkbhola5
mukesh07
decode2207
codewithshinchan
hardikkoriintern
computer-graphics
Google
Graph
Matrix
Recursion
Google
Recursion
Matrix
Graph
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Breadth First Search or BFS for a Graph
Depth First Search or DFS for a Graph
Dijkstra's shortest path algorithm | Greedy Algo-7
Prim’s Minimum Spanning Tree (MST) | Greedy Algo-5
Graph and its representations
Matrix Chain Multiplication | DP-8
Program to find largest element in an array
Rat in a Maze | Backtracking-2
Sudoku | Backtracking-7
The Celebrity Problem