Find the Number of Islands using DFS

In this tutorial, we will write a Python program to find the number of islands. We will solve this problem using the various approaches. This problem can be asked in the technical interview. First, let's understand the following problem statement.

In a binary 2D matrix, our task is to determine the count of islands. An island is defined as a collection of adjacent '1's that are connected either horizontally or vertically. For instance, in the matrix below, there are four distinct islands. Our goal is to write the Python program to count the number of such islands within the provided matrix.

Example

Matrix:

[[1, 1, 0, 0, 0],
 [1, 1, 0, 0, 0],
 [0, 0, 1, 0, 0],
 [0, 0, 0, 1, 1]]
Number of Islands: 4

Before diving into the solution, it's important to grasp the concept of connected components. This problem is a classic example of "Counting the number of connected components in an undirected graph."

Suppose a graph with several nodes and edges connecting them. Each connected component would be a group of nodes that are all connected to each other, but not connected to nodes outside of that group. So, you might have one group of nodes that forms a connected component, and another group that is separate and forms a different connected component. These components are like isolated clusters within the larger graph.

We can solve this problem using the DFS() on each component. In each DFS() call, a component or a sub-graph is visited. To find the number of connected components in an undirected graph, we can use the Depth-First Search (DFS) and Breadth-First Search (BFS). Each call to the DFS or BFS algorithm corresponds to exploring and marking one connected component. By counting the number of DFS or BFS calls, we determine the total count of connected components within the graph. Both algorithms can be effectively utilized for this purpose.

Note - A group of connected 1s forms islands.

Finding the number of islands using an Additional Matrix

The additional matrix will help to keep track of the visited nodes in the given matrix and perform DFS to find the total number of island.

Following are the steps to find the number of connected components in a binary 2D matrix using Depth-First Search (DFS):

First, we create a boolean matrix visited with the same dimensions as the given matrix and initialize all its elements to "false."
Initialize a variable count to 0, which will be used to store the answer.
Iterate through rows from 0 to ROW and within each row, iterate through columns from 0 to COL.
If the current cell in the given matrix has a value of 1 and has not been visited. Then call the DFS function to explore the connected component.
Define two arrays, "rowNbr" = { -1, -1, -1, 0, 0, 1, 1, 1 } and "colNbr" = { -1, 0, 1, -1, 1, -1, 0, 1 } to represent neighboring cells. After that, we mark the current cell as visited. Then we iterate through all eight neighbors.
If a neighbor is valid (within matrix boundaries) and has not been visited. Recursively call the DFS function on the neighbor.
Increment the count by 1 for each connected component encountered. Finally, return count as the total count of connected components.

Let's understand the following code snippet.

Example -

class Solution:
    def numIslands(self, grid):
        if not grid:
            return 0

        ROW = len(grid)
        COL = len(grid[0])

        # Define the neighboring directions
        rowNbr = [-1, -1, -1, 0, 0, 1, 1, 1]
        colNbr = [-1, 0, 1, -1, 1, -1, 0, 1]

        def isSafe(row, col, visited):
            return (
                row >= 0 and row < ROW and col >= 0 and col < COL
                and not visited[row][col] and grid[row][col] == "1"
            )

        def DFS(row, col, visited):
            visited[row][col] = True
            for k in range(8):
                if isSafe(row + rowNbr[k], col + colNbr[k], visited):
                    DFS(row + rowNbr[k], col + colNbr[k], visited)

        visited = [[False for j in range(COL)] for i in range(ROW)]
        count = 0

        for i in range(ROW):
            for j in range(COL):
                if not visited[i][j] and grid[i][j] == "1":
                    DFS(i, j, visited)
                    count += 1
        return count
matrix = [
    [1, 1, 0, 0, 0],
    [1, 1, 0, 0, 0],
    [0, 0, 1, 0, 0],
    [0, 0, 0, 1, 1]
]
solution = Solution()
result = solution.numIslands(matrix)
print("Number of islands:", result)

Output

Number of islands: 3

The time complexity is O(rows * cols), and the space complexity is O(rows * cols), where "rows" and "cols" are the dimensions of the input matrix.

Determining the Count of Islands with Depth-First Search (DFS)

Below are the steps of DFS:

First, we start with a count set to 0, which will store the final answer.
Iterate through rows (from 0 to ROW) and within each row, iterate through columns (from 0 to COL).
If the value of the current cell in the given matrix is 1, increment the count by 1.
Invoke the DFS function for further exploration.
If the cell goes beyond the matrix boundaries or the value in the current cell is 0, return.
Update the value at the current cell to 0 to mark it as visited.
Recursively applies DFS to neighboring cells.
Return the count as a result.

Let's implement the above steps in the code -

Example -

def numIslands(matrix):
    if not matrix:
        return 0

    ROW = len(matrix)
    COL = len(matrix[0])

    def DFS(row, col):
        if row < 0 or col < 0 or row >= ROW or col >= COL or matrix[row][col] == '0':
            return
        matrix[row][col] = '0'  # Mark the cell as visited
        DFS(row - 1, col)
        DFS(row + 1, col)
        DFS(row, col - 1)
        DFS(row, col + 1)

    count = 0

    for i in range(ROW):
        for j in range(COL):
            if matrix[i][j] == '1':
                count += 1
                DFS(i, j)

    return count
matrix = [
    [1, 1, 0, 0, 0],
    [1, 1, 0, 0, 0],
    [0, 0, 1, 0, 0],
    [0, 0, 0, 1, 1]
]
result = numIslands(matrix)
print("Number of islands:", result)

Output

Number of islands: 3

Time complexity: O(n*m)

Auxiliary Space: O(n*m)

Conclusion

In this tutorial, we solved the problem of counting islands in a binary 2D matrix using Depth-First Search (DFS). By applying DFS to explore connected components, we efficiently determined the number of islands. We discussed the concept of connected components and how it relates to the problem.

The code example demonstrated two implementations, one using an additional matrix to track visited nodes and another directly marking visited cells in the original matrix. Both methods yielded accurate results. This approach is useful for various applications, offering a clear and effective solution to island counting in binary matrices.

Next TopicKnapsack-problem-in-python

← prev next →