Flood Fill Algorithm | Python | DFS #QuarantineAndCode

Hello Everyone, I’d like to start a new series called “Quarantine and Code”. I saw the hashtag on twitter and it inspired me to do some tutorials while spending most of my time indoors. The algorithm I’ll be solving today is pretty famous. It’s a graph algorithm called Flood Fill and it’s very similar to Number of Islands. You can find the algorithm here on LeetCode. In this tutorial we will be using Depth First Search.

Video Tutorial

Before we get started, here is the full code.

Full Code

floodFill

Input

9

So what is flood fill and what does it do?

If given a grid and an axis point, turn the number found at the access point into another number, as well as all of its’ equivalents. Granted, numbers signify colors, so in the example above, we are coloring all 1s into 2s. The caveat is that we can only color 1s above, below, left and right. There is no diagonal crossing, so the output of [[1,1,1],[1,1,0],[1,0,1]] will be [[2,2,2],[2,2,0],[2,0,1]]. As you can see, there is still a 1. There is no way to access it, as diagonal crossing is not allowed and we cannot change any other numbers. We are only changing the value of “oldColor” into the value of “newColor“, so any other number (0) will remain the same. Let’s begin.

The Break Down

1

To start off, we have our first function, floodfill, which takes 4 arguments. We are given the grid to navigate through as well as the row and column number to find the old color. We are also given a new color to change the old color to.

Following the example above, grid[1][1] will be equal to 1. So oldColor == 1. If newColor is equal to the same number as oldColor, we just return the grid as there is nothing to fill since there will be no change.

2

Within the same function, we call an outside function, recurse, passing in the additional variable, oldColor. This line will move outside of the floodfill function and when it returns, it will have the new grid filled.

3

This is where the magic begins. We are taking in the grid, row, col, newColor and oldColor passed to us by floodfill. First, we check to see if “grid[row][col]” does not equal the oldColor, because if it doesn’t, then there is no further work to do so we can just return to the previous recursive call or back to floodfill.

However, if it does equal the oldColor, 1, then of course we want to change it to a 2. so we move down to color “grid[row][col]” from 1 -> 2.

Recursion

4

Moving along we have four if statements that, if true, will call a recursive function.

In the first if statement, row != 0, we are checking to see if we are on the first row. Remember, index counting starts from 0, and the grid given is made up of 3 lists (0,1,2). We want to look at the number above “grid[row][col]” (or 1) to see if it is the oldColor so that we can change it to the newColor. However, if we are on the first row it is not possible to look up as there is nothing above the first, so if row == 0, we move on to the next if statement. If not, we call the recurse function with all the above arguments and minus row by 1. Following the example given, if starting row is 1, then 1-1 will give us 0, and give us access to the first row to check and change the value. So “grid[1][1]” would become “grid[0][1]”.

The second if statement follows the same logic, it’s checking to make sure we are also not on column 0, as if we were, there would be no way to look to the left of us. However, we are on column 1, so 1-1 would give us 0, so we can look to the left once the above recursive call has returned.

5

In the third if statement we are checking to see if we are not on the last row. Remember, the true length of the grid has 3 lists, but index counting starts at 0. row != 2 is what it equates to, and we want to make sure we are not on the last (row 2) row, as there is no way to look below us. If we are on row 0 or 1, we can look below.

Finally, we are checking to make sure we are not on the last column. Exact logic here as well. col != len(grid[0]) – 1 equates to col != 2. grid[0] has a length of 3 items, which means there are three columns. Starting at index 0, we want to make sure we are not looking to the right of column 2 (the last column) as there is nothing there.

So, that’s the explanation. Here is the before and after graph.

*If you do not still understand my explanation , please use Pythontutor.com, and plug the code in. It will walk you though step by step on what is being done in the code. You got this.

More Code

I found these two methods on Leetcode, so if you’d like to learn other ways to solve this algorithm, these are a bit more readable than other versions I’ve found online.

Method 2

7

Method 3

8

#QuarantineandCode

Que tenga un buen dia! 🙂

 

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s