Sudo GATE 2020 Mock I (December 27, 2019) - Problem 6

Introduction

In this problem, we are given a boolean matrix mat of size M x N representing doors. True indicates that the door is open and False indicates it is closed. We have to find the minimum number of doors that need to be opened in order to reach from point (i,j) to (x,y).

Approach

We can solve this problem using Breadth-First Search (BFS) on the given matrix mat. We can create a separate matrix dist of size M x N initialized with infinity to keep track of the minimum distance between each cell and the source. We can start BFS from the source cell (i,j) and update the distance to each cell that can be reached from the current cell in the matrix dist. We can also use a boolean matrix visited to keep track of visited cells.

We can explore the neighborhood of the current cell (x,y) in four directions - top, bottom, left and right. For each of these neighbors, we will check if they are valid cells and not already visited. If the neighbor is open, we can calculate the total distance to reach this neighbor and compare it to the previous distance stored in dist. If the new distance is less than the previous distance, we can update the distance in dist and add the neighbor in the queue for BFS.

Once BFS is complete, the minimum distance from the source cell to the destination cell (x,y) will be stored in dist[x][y]. This distance gives us the minimum number of doors that need to be opened to reach from (i,j) to (x,y). If there is no possible path between (i,j) and (x,y), the distance stored in dist[x][y] will be infinity.

Code

def min_doors(mat, i, j, x, y):
    M, N = len(mat), len(mat[0])
    dist = [[float('inf') for _ in range(N)] for _ in range(M)]
    visited = [[False for _ in range(N)] for _ in range(M)]
    dist[i][j] = 0
    visited[i][j] = True
    
    queue = [(i,j)]
    while queue:
        curr = queue.pop(0)
        curr_dist = dist[curr[0]][curr[1]]
        
        if curr == (x,y):
            return curr_dist
        
        neighbors = [(curr[0]-1, curr[1]), (curr[0]+1, curr[1]), 
                     (curr[0], curr[1]-1), (curr[0], curr[1]+1)]
        for neighbor in neighbors:
            if 0 <= neighbor[0] < M and 0 <= neighbor[1] < N and not visited[neighbor[0]][neighbor[1]]:
                if mat[neighbor[0]][neighbor[1]]:
                    new_dist = curr_dist + 1
                    if new_dist < dist[neighbor[0]][neighbor[1]]:
                        dist[neighbor[0]][neighbor[1]] = new_dist
                    visited[neighbor[0]][neighbor[1]] = True
                    queue.append(neighbor)
    
    return dist[x][y]

Explanation

The above code defines a function min_doors that takes mat, i, j, x and y as input arguments. It first initializes dist and visited matrices with default values of infinity and False respectively. It then sets the distance of source cell (i,j) to 0 and marks it as visited.

The function initializes a queue with the source cell (i,j) and starts the BFS loop. For each cell popped from the queue, it gets the distance from the source stored in dist[curr[0]][curr[1]] and checks if it is the destination cell (x,y). If so, the function returns the distance as the minimum number of doors that need to be opened.

Otherwise, it explores the 4 possible neighbors of the current cell (curr[0], curr[1]) - top, bottom, left and right. For each neighbor, it checks if it is a valid cell that has not been visited before. If the neighbor is an open door and the distance to reach it is less than the previous distance stored in dist, it updates the distance in dist and adds the neighbor to the BFS queue.

The function continues BFS until all possible cells have been explored or the destination cell has been reached. Finally, it returns the distance stored in dist[x][y] as the minimum number of doors that need to be opened to reach from (i,j) to (x,y).

Conclusion

In conclusion, we have presented an approach to find the minimum number of doors that need to be opened to reach from one cell to another in a boolean matrix. The BFS-based approach presented here requires O(MN) time and space complexity, which is optimal in the worst case.