Find maximum path length in a binary matrix

Given a square matrix mat every element of which is either 0 or 1. A value 1 means connected and 0 means not connected. The task is to find the largest length of a path in the matrix after changing atmost one 0 to 1. A path is a 4-directionally connected group of 1s.


Input: mat[][] = {{1, 1}, {1, 0}}
Output: 4
Change the only 0 to 1 and the length of the largest path will be 4.

Input: mat[][] = {{1, 1}, {1, 1}}
Output: 4

Naive Approach: The idea is to change each ‘0’ to ‘1’ one by one and do a Depth First Search to find the size of the largest path.

Efficient Approach: In the naive approach, we have checked every ‘0’. However, we can also make this efficient by storing the size of each group, so that we do not have to use depth-first search to repeatedly calculate the same size all over again.

Note: We need to take care when the 0 touches the same group. For example, consider grid = [[0, 1], [1, 1]]. The right and bottom neighbor of the 0 will belong to the same group after changing 0 to 1.

We can solve this problem by keeping track of group Id (or Index), that will be unique for each group.

Below is the implementation of the above approach:





# Python3 implementation of above approach
# check if index is within range
def neighbors(r, c, N):
    for nr, nc in ((r - 1, c), (r + 1, c), (r, c - 1), (r, c + 1)):
        if 0 <= nr < N and 0 <= nc < N:
            yield nr, nc
# dfs to calculate length of path
def dfs(R, C, index, grid, N):
    ans = 1
    grid[R][C] = index
    for nr, nc in neighbors(R, C, N):
        if grid[nr][nc] == 1:
            ans += dfs(nr, nc, index)
    return ans
# function to return largest possible length of Path
def largestPath(grid):
    N = len(grid)
    area = {}
    index = 2
    for i in range(N):
        for j in range(N):
            if grid[i][j] == 1:
                area[index] = dfs(i, j, index, grid, N)
                index += 1
    ans = max(area.values() or [0])
    for i in range(N):
        for j in range(N):
            if grid[i][j] == 0:
                seen = {grid[nr][nc] for nr, nc in neighbors(i, j, N) if grid[nr][nc] > 1}
                ans = max(ans, 1 + sum(area[i] for i in seen))
    # return maximum possible length
    return ans
# Driver code
I = [[1, 0], [0, 1]]
# Function call to print answer
# This code is written by
# Sanjit_Prasad


Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using or mail your article to See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :