Given an N*M grid of characters ‘O’, ‘X’, and ‘Y’. Find the minimum Manhattan distance between an X and a Y.
Manhattan Distance : | row_index_x – row_index_y | + | column_index_x – column_index_y |
Examples:
Input: N = 4, M = 4
grid[][] = {{X, O, O, O}
{O, Y, O, Y}
{X, X, O, O}
{O, Y, O, O}}
Output: 1
Explanation:
{{X, O, O, O}
{O, Y, O, Y}
{X, X, O, O}
{O, Y, O, O}}
The shortest X-Y distance in the grid is 1. One possible such X and Y are marked in bold in the above grid.Input: N = 3, M = 3
grid[][] = {{X, X, O}
{O, O, Y}
{Y, O, O}}Output: 2
Explanation:
{{X, X, O}
{O, O, Y}
{Y, O, O}}
The shortest X-Y distance in the grid is 2. One possible such X and Y are marked in bold in the above grid.
Approach: To solve the problem follow the below idea:
The idea is to use dynamic programming(to prevent computation of min distance again and again) to compute the shortest distance between every cell in the grid and the nearest cell with value ‘X’. we initializes the distance to a very large value for every cell except for the ‘X’ cells, which have a distance of 0. It then computes the distance from each cell to its top and left neighbors, and then from each cell to its bottom and right neighbors. Finally, we finds the cell with value ‘Y’ (target) with the shortest distance to an ‘X’ cell.
Step-by-step approach:
- Create a 2D array called dist with dimensions N x M.
- Initialize all elements of dist to a very large value (in this case, 1000000000).
-
Loop through each element of the grid and check if it is an ‘X’ character or not.
- If it is an ‘X’ character, set the corresponding element in dist to 0.
- If it is not an ‘X’ character, calculate the distance to the top and left elements using dist[i-1][j] and dist[i][j-1], respectively. Take the minimum of the two values and add 1 to get the distance to the current element.
-
Loop through each element of the grid again, but this time, check the ,perform step 3 for calculating the relative distance from X .
- Calculate the distances to the bottom and right elements using dist[i+1][j] and dist[i][j+1], respectively. Take the minimum of the two values and add 1 to get the distance to the current element.
- Update the corresponding element in dist if this calculated distance is smaller than its current value.
-
Run a Loop through each element of the grid one final time and find the minimum value of dist for all ‘Y’ characters in the grid.
- keep storing the min distance while traversing the dist array and storing it in ans.
- Return ans.
Below is the implementation of the above approach:
C++
// C++ code for the above approach:#include <bits/stdc++.h>using namespace std;
int shortestXYDist(vector<vector<char> > grid, int N, int M)
{ // Create a 2D array to store distances.
// Initialize with a large value.
int dist[N][M];
for (int i = 0; i < N; i++) {
// Initialize with a large value
// (indicating infinity).
for (int j = 0; j < M; j++) {
dist[i][j] = 1e9;
}
}
// Check top and left directions
// for 'X' cells.
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (grid[i][j] == 'X')
// Set distance to 0 for 'X' cells.
dist[i][j] = 0;
else {
if (i > 0)
// Check above cell.
dist[i][j] = min(dist[i][j],
dist[i - 1][j] + 1);
if (j > 0)
// Check left cell.
dist[i][j] = min(dist[i][j],
dist[i][j - 1] + 1);
}
}
}
// Check bottom and right directions
// for 'X' cells.
for (int i = N - 1; i >= 0; i--) {
for (int j = M - 1; j >= 0; j--) {
if (grid[i][j] == 'X')
// Set distance to 0 for 'X' cells.
dist[i][j] = 0;
else {
if (i < N - 1)
dist[i][j]
= min(dist[i][j],
dist[i + 1][j]
+ 1); // Check below cell.
if (j < M - 1)
// Check right cell.
dist[i][j] = min(dist[i][j],
dist[i][j + 1] + 1);
}
}
}
// Initialize the minimum distance with a
// large value.
int ans = 1e9;
// Find the minimum distance to 'Y' cells.
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (grid[i][j] == 'Y')
// Update the minimum
// distance.
ans = min(ans, dist[i][j]);
}
}
// Return the minimum distance.
return ans;
}// Drivers codeint main()
{ int N = 4;
int M = 4;
vector<vector<char> > grid = { { 'X', 'O', 'O', 'O' },
{ 'O', 'Y', 'O', 'Y' },
{ 'X', 'X', 'O', 'O' },
{ 'O', 'Y', 'O', 'O' } };
int minDistance = shortestXYDist(grid, N, M);
// Function call
cout << "Minimum distance from 'X' to 'Y': "
<< minDistance << endl;
return 0;
} |
Java
import java.util.Arrays;
public class ShortestDistance {
public static int shortestXYDist(char[][] grid, int N,
int M)
{
// Create a 2D array to store distances.
// Initialize with a large value.
int[][] dist = new int[N][M];
for (int i = 0; i < N; i++) {
// Initialize with a large value (indicating
// infinity).
Arrays.fill(dist[i], 1_000_000_000);
}
// Check top and left directions for 'X' cells.
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (grid[i][j] == 'X') {
// Set distance to 0 for 'X' cells.
dist[i][j] = 0;
}
else {
if (i > 0) {
// Check above cell.
dist[i][j] = Math.min(
dist[i][j], dist[i - 1][j] + 1);
}
if (j > 0) {
// Check left cell.
dist[i][j] = Math.min(
dist[i][j], dist[i][j - 1] + 1);
}
}
}
}
// Check bottom and right directions for 'X' cells.
for (int i = N - 1; i >= 0; i--) {
for (int j = M - 1; j >= 0; j--) {
if (grid[i][j] == 'X') {
// Set distance to 0 for 'X' cells.
dist[i][j] = 0;
}
else {
if (i < N - 1) {
// Check below cell.
dist[i][j] = Math.min(
dist[i][j], dist[i + 1][j] + 1);
}
if (j < M - 1) {
// Check right cell.
dist[i][j] = Math.min(
dist[i][j], dist[i][j + 1] + 1);
}
}
}
}
// Initialize the minimum distance with a large
// value.
int ans = 1_000_000_000;
// Find the minimum distance to 'Y' cells.
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (grid[i][j] == 'Y') {
// Update the minimum distance.
ans = Math.min(ans, dist[i][j]);
}
}
}
// Return the minimum distance.
return ans;
}
// Drivers code
public static void main(String[] args)
{
int N = 4;
int M = 4;
char[][] grid = { { 'X', 'O', 'O', 'O' },
{ 'O', 'Y', 'O', 'Y' },
{ 'X', 'X', 'O', 'O' },
{ 'O', 'Y', 'O', 'O' } };
int minDistance = shortestXYDist(grid, N, M);
// Function call
System.out.println(
"Minimum distance from 'X' to 'Y': "
+ minDistance);
}
} |
Python3
def shortestXYDist(grid):
# Get the dimensions of the grid
N = len(grid)
M = len(grid[0])
# Create a 2D array to store distances, initialize with a large value
dist = [[float('inf') for _ in range(M)] for _ in range(N)]
# Check top and left directions for 'X' cells
for i in range(N):
for j in range(M):
if grid[i][j] == 'X':
# Set distance to 0 for 'X' cells
dist[i][j] = 0
else:
if i > 0:
# Check above cell
dist[i][j] = min(dist[i][j], dist[i - 1][j] + 1)
if j > 0:
# Check left cell
dist[i][j] = min(dist[i][j], dist[i][j - 1] + 1)
# Check bottom and right directions for 'X' cells
for i in range(N - 1, -1, -1):
for j in range(M - 1, -1, -1):
if grid[i][j] == 'X':
# Set distance to 0 for 'X' cells
dist[i][j] = 0
else:
if i < N - 1:
# Check below cell
dist[i][j] = min(dist[i][j], dist[i + 1][j] + 1)
if j < M - 1:
# Check right cell
dist[i][j] = min(dist[i][j], dist[i][j + 1] + 1)
# Initialize the minimum distance with a large value
ans = float('inf')
# Find the minimum distance to 'Y' cells
for i in range(N):
for j in range(M):
if grid[i][j] == 'Y':
# Update the minimum distance
ans = min(ans, dist[i][j])
# Return the minimum distance
return ans
# Driver codegrid = [
['X', 'O', 'O', 'O'],
['O', 'Y', 'O', 'Y'],
['X', 'X', 'O', 'O'],
['O', 'Y', 'O', 'O']
]minDistance = shortestXYDist(grid)
# Function callprint("Minimum distance from 'X' to 'Y':", minDistance)
|
C#
using System;
class Program
{ static int ShortestXYDist(char[][] grid, int N, int M)
{
// Create a 2D array to store distances.
// Initialize with the maximum value for an int.
int[,] dist = new int[N, M];
for (int i = 0; i < N; i++)
{
// Initialize with the maximum value for an int
// (indicating infinity).
for (int j = 0; j < M; j++)
{
dist[i, j] = int.MaxValue;
}
}
// Check top and left directions
// for 'X' cells.
for (int i = 0; i < N; i++)
{
for (int j = 0; j < M; j++)
{
if (grid[i][j] == 'X')
{
// Set distance to 0 for 'X' cells.
dist[i, j] = 0;
}
else
{
if (i > 0)
{
// Check above cell.
dist[i, j] = Math.Min(dist[i, j], dist[i - 1, j] + 1);
}
if (j > 0)
{
// Check left cell.
dist[i, j] = Math.Min(dist[i, j], dist[i, j - 1] + 1);
}
}
}
}
// Check bottom and right directions
// for 'X' cells.
for (int i = N - 1; i >= 0; i--)
{
for (int j = M - 1; j >= 0; j--)
{
if (grid[i][j] == 'X')
{
// Set distance to 0 for 'X' cells.
dist[i, j] = 0;
}
else
{
if (i < N - 1)
{
// Check below cell.
dist[i, j] = Math.Min(dist[i, j], dist[i + 1, j] + 1);
}
if (j < M - 1)
{
// Check right cell.
dist[i, j] = Math.Min(dist[i, j], dist[i, j + 1] + 1);
}
}
}
}
// Initialize the minimum distance with the maximum value for an int.
int ans = int.MaxValue;
// Find the minimum distance to 'Y' cells.
for (int i = 0; i < N; i++)
{
for (int j = 0; j < M; j++)
{
if (grid[i][j] == 'Y')
{
// Update the minimum distance.
ans = Math.Min(ans, dist[i, j]);
}
}
}
// Return the minimum distance.
return ans == int.MaxValue ? -1 : ans;
}
// Driver code
static void Main()
{
int N = 4;
int M = 4;
char[][] grid = new char[][]
{
new char[] { 'X', 'O', 'O', 'O' },
new char[] { 'O', 'Y', 'O', 'Y' },
new char[] { 'X', 'X', 'O', 'O' },
new char[] { 'O', 'Y', 'O', 'O' }
};
int minDistance = ShortestXYDist(grid, N, M);
// Function call
Console.WriteLine("Minimum distance from 'X' to 'Y': " +
(minDistance == -1 ? "Not reachable" : minDistance.ToString()));
}
} |
Javascript
function shortestXYDist(grid) {
// Get the dimensions of the grid
const N = grid.length;
const M = grid[0].length;
// Create a 2D array to store distances, initialize with a large value
const dist = Array.from({ length: N }, () => Array(M).fill(Number.POSITIVE_INFINITY));
// Check top and left directions for 'X' cells
for (let i = 0; i < N; i++) {
for (let j = 0; j < M; j++) {
if (grid[i][j] === 'X') {
// Set distance to 0 for 'X' cells
dist[i][j] = 0;
} else {
if (i > 0) {
// Check above cell
dist[i][j] = Math.min(dist[i][j], dist[i - 1][j] + 1);
}
if (j > 0) {
// Check left cell
dist[i][j] = Math.min(dist[i][j], dist[i][j - 1] + 1);
}
}
}
}
// Check bottom and right directions for 'X' cells
for (let i = N - 1; i >= 0; i--) {
for (let j = M - 1; j >= 0; j--) {
if (grid[i][j] === 'X') {
// Set distance to 0 for 'X' cells
dist[i][j] = 0;
} else {
if (i < N - 1) {
// Check below cell
dist[i][j] = Math.min(dist[i][j], dist[i + 1][j] + 1);
}
if (j < M - 1) {
// Check right cell
dist[i][j] = Math.min(dist[i][j], dist[i][j + 1] + 1);
}
}
}
}
// Initialize the minimum distance with a large value
let ans = Number.POSITIVE_INFINITY;
// Find the minimum distance to 'Y' cells
for (let i = 0; i < N; i++) {
for (let j = 0; j < M; j++) {
if (grid[i][j] === 'Y') {
// Update the minimum distance
ans = Math.min(ans, dist[i][j]);
}
}
}
// Return the minimum distance
return ans;
}// Driver codeconst grid = [ ['X', 'O', 'O', 'O'],
['O', 'Y', 'O', 'Y'],
['X', 'X', 'O', 'O'],
['O', 'Y', 'O', 'O']
];const minDistance = shortestXYDist(grid);// Function callconsole.log("Minimum distance from 'X' to 'Y':", minDistance);
|
Output
Minimum distance from 'X' to 'Y': 1
Time Complexity: O(N*M)
Auxiliary Space: O(N*M)