Given a matrix grid[][], where '*' represents your location, '#' represents food cells, 'O' represents free space, 'X' represents obstacles. The task is to find the shortest path from your location to any food cell in a given matrix grid, Return the length of the shortest path to reach any food cell, or -1 if no path exists.
Example:
Input: grid = [["X","X","X","X","X","X"],["X","*","O","O","O","X"],["X","O","O","#","O","X"],["X","X","X","X","X","X"]]
Output: 3
Explanation: only 3 steps needed o reach the food.Input: grid = [["X","X","X","X","X"],["X","*","X","O","X"],["X","O","X","#","X"],["X","X","X","X","X"]]
Output: -1
Explanation: Not possible to reach the food.
Approach:
The idea is to use multi-source Breadth-First Search (BFS) algorithm. Starts the BFS from the given location and explores the neighbor nodes at the present depth prior to moving on to nodes at the next depth level.
This property of BFS is useful in this problem because it guarantees that we explore all cells at a given distance before moving on to the cells at the next distance. Therefore, the first time we reach a food cell, we can be sure that we have found the shortest path.
Steps-by-step approach:
- Initialize a queue (Q) to keep track of cells to visit.
- Map grid values ('*', '#', 'O') to integers (1, 2, 3) for better handling.
- Find the starting points marked by '*' and add it to the queue.
- Perform a Breadth-First Search (BFS) traversal of the grid using the queue.
- For each cell popped from the queue:
- If it's a food cell ('#'), update the shortest path length and exit the BFS loop.
- If it's an empty space ('O'), mark it as visited and continue exploring neighboring cells.
- Use a priority queue to ensure food cells are explored first.
- At the end of BFS, return the length of the shortest path to reach any food cell. If no path exists, return -1.
Below are the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
// Function to find the shortest path from your location to
// any food cell
int findShortestPathToFood(vector<vector<char> >& grid)
{
// Initialize a queue to keep track of cells to visit
queue<vector<int> > Q; // <value, distance, x, y>
/*
we mapped grid value to integer:
'*': 1
'#': 2
'O': 3
*/
// Define the four possible directions to move in the
// grid
vector<vector<int> > directions
= { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } };
// Get the size of the grid
int numRows = grid.size(), numCols = grid[0].size();
// Find your location in the grid and add it to the
// queue
for (int row = 0; row < numRows; row++) {
for (int col = 0; col < numCols; col++) {
if (grid[row][col] == '*') {
Q.push({ 1, 0, row, col });
}
}
}
// Initialize the result to -1 (no path found)
int shortestPathLength = -1;
// Create a visited matrix to keep track of visited
// cells
vector<vector<int> > visited(numRows,
vector<int>(numCols));
// Start BFS
while (!Q.empty()) {
auto currentCell = Q.front();
Q.pop();
// If we have reached a food cell, update the
// shortest path length and break
if (currentCell[0] == 2) {
shortestPathLength = currentCell[1];
break;
}
// Visit all adjacent cells
for (int i = 0; i < 4; i++) {
int newRow = directions[i][0] + currentCell[2];
int newCol = directions[i][1] + currentCell[3];
// If the new cell is within the grid, not an
// obstacle, and not visited
if (newRow >= 0 && newRow < numRows
&& newCol >= 0 && newCol < numCols
&& (grid[newRow][newCol] == 'O'
|| grid[newRow][newCol] == '#')
&& visited[newRow][newCol] == 0) {
// Mark the new cell as visited
visited[newRow][newCol] = 1;
// If the new cell is a food cell, add it to
// the queue with a priority of 2
if (grid[newRow][newCol] == '#') {
Q.push({ 2, currentCell[1] + 1, newRow,
newCol });
}
// If the new cell is a free space, add it
// to the queue with a priority of 3
else {
Q.push({ 3, currentCell[1] + 1, newRow,
newCol });
}
}
}
}
// Return the length of the shortest path to reach any
// food cell, or -1 if no path exists
return shortestPathLength;
}
int main()
{
vector<vector<char> > grid
= { { 'X', 'X', 'X', 'X', 'X', 'X' },
{ 'X', '*', 'O', 'O', 'O', 'X' },
{ 'X', 'O', 'O', '#', 'O', 'X' },
{ 'X', 'X', 'X', 'X', 'X', 'X' } };
cout << findShortestPathToFood(grid);
return 0;
}
Java
import java.util.LinkedList;
import java.util.Queue;
public class GFG {
// Function to find the shortest path from your location to
// any food cell
public static int findShortestPathToFood(char[][] grid) {
// Initialize a queue to keep track of cells to visit
Queue<int[]> queue = new LinkedList<>(); // <value, distance, x, y>
/*
we mapped grid value to integer:
'*': 1
'#': 2
'O': 3
*/
// Define the four possible directions to move in the
// grid
int[][] directions = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
// Get the size of the grid
int numRows = grid.length;
int numCols = grid[0].length;
// Find your location in the grid and add it to the
// queue
for (int row = 0; row < numRows; row++) {
for (int col = 0; col < numCols; col++) {
if (grid[row][col] == '*') {
queue.add(new int[]{1, 0, row, col});
}
}
}
// Initialize the result to -1 (no path found)
int shortestPathLength = -1;
// Create a visited matrix to keep track of visited
// cells
boolean[][] visited = new boolean[numRows][numCols];
// Start BFS
while (!queue.isEmpty()) {
int[] currentCell = queue.poll();
// If we have reached a food cell, update the
// shortest path length and break
if (currentCell[0] == 2) {
shortestPathLength = currentCell[1];
break;
}
// Visit all adjacent cells
for (int[] direction : directions) {
int newRow = direction[0] + currentCell[2];
int newCol = direction[1] + currentCell[3];
// If the new cell is within the grid, not an
// obstacle, and not visited
if (newRow >= 0 && newRow < numRows
&& newCol >= 0 && newCol < numCols
&& (grid[newRow][newCol] == 'O'
|| grid[newRow][newCol] == '#')
&& !visited[newRow][newCol]) {
// Mark the new cell as visited
visited[newRow][newCol] = true;
// If the new cell is a food cell, add it to
// the queue with a priority of 2
if (grid[newRow][newCol] == '#') {
queue.add(new int[]{2, currentCell[1] + 1, newRow, newCol});
}
// If the new cell is a free space, add it
// to the queue with a priority of 3
else {
queue.add(new int[]{3, currentCell[1] + 1, newRow, newCol});
}
}
}
}
// Return the length of the shortest path to reach any
// food cell, or -1 if no path exists
return shortestPathLength;
}
public static void main(String[] args) {
char[][] grid = {
{'X', 'X', 'X', 'X', 'X', 'X'},
{'X', '*', 'O', 'O', 'O', 'X'},
{'X', 'O', 'O', '#', 'O', 'X'},
{'X', 'X', 'X', 'X', 'X', 'X'}
};
System.out.println(findShortestPathToFood(grid));
}
}
Python3
from collections import deque
# Function to find the shortest path from your location to any food cell
def findShortestPathToFood(grid):
# Define the four possible directions to move in the grid
directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
# Get the size of the grid
numRows, numCols = len(grid), len(grid[0])
# Initialize a queue to keep track of cells to visit
Q = deque() # (value, distance, x, y)
# Find your location in the grid and add it to the queue
for row in range(numRows):
for col in range(numCols):
if grid[row][col] == '*':
Q.append((1, 0, row, col))
# Initialize the result to -1 (no path found)
shortestPathLength = -1
# Create a visited matrix to keep track of visited cells
visited = [[0] * numCols for _ in range(numRows)]
# Start BFS
while Q:
currentCell = Q.popleft()
# If we have reached a food cell, update the shortest path length and break
if currentCell[0] == 2:
shortestPathLength = currentCell[1]
break
# Visit all adjacent cells
for direction in directions:
newRow, newCol = direction[0] + currentCell[2], direction[1] + currentCell[3]
# If the new cell is within the grid, not an obstacle, and not visited
if 0 <= newRow < numRows and 0 <= newCol < numCols and (grid[newRow][newCol] == 'O' or grid[newRow][newCol] == '#') and not visited[newRow][newCol]:
# Mark the new cell as visited
visited[newRow][newCol] = 1
# If the new cell is a food cell, add it to the queue with a priority of 2
if grid[newRow][newCol] == '#':
Q.append((2, currentCell[1] + 1, newRow, newCol))
# If the new cell is a free space, add it to the queue with a priority of 3
else:
Q.append((3, currentCell[1] + 1, newRow, newCol))
# Return the length of the shortest path to reach any food cell, or -1 if no path exists
return shortestPathLength
# Driver code
if __name__ == "__main__":
grid = [
['X', 'X', 'X', 'X', 'X', 'X'],
['X', '*', 'O', 'O', 'O', 'X'],
['X', 'O', 'O', '#', 'O', 'X'],
['X', 'X', 'X', 'X', 'X', 'X']
]
print(findShortestPathToFood(grid))
JavaScript
// Function to find the shortest path from your location to any food cell
function findShortestPathToFood(grid) {
// Initialize a queue to keep track of cells to visit
const queue = []; // [value, distance, x, y]
/*
We mapped grid value to integer:
'*': 1
'#': 2
'O': 3
*/
// Define the four possible directions to move in the grid
const directions = [[1, 0], [-1, 0], [0, 1], [0, -1]];
// Get the size of the grid
const numRows = grid.length;
const numCols = grid[0].length;
// Find your location in the grid and add it to the queue
for (let row = 0; row < numRows; row++) {
for (let col = 0; col < numCols; col++) {
if (grid[row][col] === '*') {
queue.push([1, 0, row, col]);
}
}
}
// Initialize the result to -1 (no path found)
let shortestPathLength = -1;
// Create a visited matrix to keep track of visited cells
const visited = new Array(numRows).fill(null).map(() => new Array(numCols).fill(false));
// Start BFS
while (queue.length) {
const currentCell = queue.shift();
// If we have reached a food cell, update the shortest path length and break
if (currentCell[0] === 2) {
shortestPathLength = currentCell[1];
break;
}
// Visit all adjacent cells
for (const direction of directions) {
const newRow = direction[0] + currentCell[2];
const newCol = direction[1] + currentCell[3];
// If the new cell is within the grid, not an obstacle, and not visited
if (newRow >= 0 && newRow < numRows
&& newCol >= 0 && newCol < numCols
&& (grid[newRow][newCol] === 'O' || grid[newRow][newCol] === '#')
&& !visited[newRow][newCol]) {
// Mark the new cell as visited
visited[newRow][newCol] = true;
// If the new cell is a food cell, add it to the queue with a priority of 2
if (grid[newRow][newCol] === '#') {
queue.push([2, currentCell[1] + 1, newRow, newCol]);
}
// If the new cell is a free space, add it to the queue with a priority of 3
else {
queue.push([3, currentCell[1] + 1, newRow, newCol]);
}
}
}
}
// Return the length of the shortest path to reach any food cell, or -1 if no path exists
return shortestPathLength;
}
// Driver code
const grid = [
['X', 'X', 'X', 'X', 'X', 'X'],
['X', '*', 'O', 'O', 'O', 'X'],
['X', 'O', 'O', '#', 'O', 'X'],
['X', 'X', 'X', 'X', 'X', 'X']
];
console.log(findShortestPathToFood(grid));
Output
3
Time complexity: O(N*M), where N and M are the number of rows and columns in the given matrix
Auxiliary Space: O(N*M)