GFG App
Open App
Browser
Continue

# Minimum Distance from a given Cell to all other Cells of a Matrix

Given two integers R and C, denoting the number of rows and columns in a matrix, and two integers X and Y, the task is to find the minimum distance from the given cell to all other cells of the matrix.

Examples:

Input: R = 5, C = 5, X = 2, Y = 2
Output:
2 2 2 2 2
2 1 1 1 2
2 1 0 1 2
2 1 1 1 2
2 2 2 2 2

Input: R = 5, C = 5, X = 1, Y = 1
Output:
1 1 1 2 3
1 0 1 2 3
1 1 1 2 3
2 2 2 2 3
3 3 3 3 3

Approach:
Follow the steps below to solve the problem:

• Assign the distance of the initial cells as 0.
• Initialize a Queue and insert the pair {X, Y} into the Queue.
• Iterate until the Queue is not empty, and for every unvisited cell, assign the current distance and insert the index {i, j} into the Queue using the BFS technique.
• Print the distance of each cell at the end.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement` `// the above approach` `#include ` `using` `namespace` `std;`   `int` `mat[1001][1001];` `int` `r, c, x, y;`   `// Stores the accessible directions` `int` `dx[] = { 0, -1, -1, -1, 0, 1, 1, 1 };` `int` `dy[] = { 1, 1, 0, -1, -1, -1, 0, 1 };`   `// Function to find the minimum distance from a` `// given cell to all other cells in the matrix` `void` `FindMinimumDistance()` `{` `    ``// Stores the accessible cells` `    ``// from current cell` `    ``queue > q;`   `    ``// Insert pair (x, y)` `    ``q.push({ x, y });` `    ``mat[x][y] = 0;`   `    ``// Iterate until queue is empty` `    ``while` `(!q.empty()) {`   `        ``// Extract the pair` `        ``x = q.front().first;` `        ``y = q.front().second;`   `        ``// Pop them` `        ``q.pop();`   `        ``for` `(``int` `i = 0; i < 8; i++) {` `            ``int` `a = x + dx[i];` `            ``int` `b = y + dy[i];`   `            ``// Checking boundary condition` `            ``if` `(a < 0 || a >= r || b >= c || b < 0)` `                ``continue``;`   `            ``// If the cell is not visited` `            ``if` `(mat[a][b] == 0) {`   `                ``// Assign the minimum distance` `                ``mat[a][b] = mat[x][y] + 1;`   `                ``// Insert the traversed neighbour` `                ``// into the queue` `                ``q.push({ a, b });` `            ``}` `        ``}` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``r = 5, c = 5, x = 1, y = 1;`   `    ``int` `t = x;` `    ``int` `l = y;` `    ``mat[x][y] = 0;`   `    ``FindMinimumDistance();`   `    ``mat[t][l] = 0;`   `    ``// Print the required distances` `    ``for` `(``int` `i = 0; i < r; i++) {` `        ``for` `(``int` `j = 0; j < c; j++) {` `            ``cout << mat[i][j] << ``" "``;` `        ``}` `        ``cout << endl;` `    ``}` `}`

## Java

 `// Java program to implement` `// the above approach` `import` `java.util.*;`   `class` `GFG{` `    `  `static` `class` `pair` `{ ` `    ``int` `first, second; ` `    ``public` `pair(``int` `first, ``int` `second) ` `    ``{ ` `        ``this``.first = first; ` `        ``this``.second = second; ` `    ``} ` `} `   `static` `int` `[][]mat = ``new` `int``[``1001``][``1001``];` `static` `int` `r, c, x, y;`   `// Stores the accessible directions` `static` `int` `dx[] = { ``0``, -``1``, -``1``, -``1``, ``0``, ``1``, ``1``, ``1` `};` `static` `int` `dy[] = { ``1``, ``1``, ``0``, -``1``, -``1``, -``1``, ``0``, ``1` `};`   `// Function to find the minimum distance from a` `// given cell to all other cells in the matrix` `static` `void` `FindMinimumDistance()` `{` `    `  `    ``// Stores the accessible cells` `    ``// from current cell` `    ``Queue q = ``new` `LinkedList<>();`   `    ``// Insert pair (x, y)` `    ``q.add(``new` `pair(x, y));` `    ``mat[x][y] = ``0``;`   `    ``// Iterate until queue is empty` `    ``while` `(!q.isEmpty())` `    ``{` `        `  `        ``// Extract the pair` `        ``x = q.peek().first;` `        ``y = q.peek().second;`   `        ``// Pop them` `        ``q.remove();`   `        ``for``(``int` `i = ``0``; i < ``8``; i++)` `        ``{` `            ``int` `a = x + dx[i];` `            ``int` `b = y + dy[i];`   `            ``// Checking boundary condition` `            ``if` `(a < ``0` `|| a >= r ||` `               ``b >= c || b < ``0``)` `                ``continue``;`   `            ``// If the cell is not visited` `            ``if` `(mat[a][b] == ``0``) ` `            ``{` `                `  `                ``// Assign the minimum distance` `                ``mat[a][b] = mat[x][y] + ``1``;`   `                ``// Insert the traversed neighbour` `                ``// into the queue` `                ``q.add(``new` `pair(a, b));` `            ``}` `        ``}` `    ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``r = ``5``; c = ``5``; x = ``1``; y = ``1``;`   `    ``int` `t = x;` `    ``int` `l = y;` `    ``mat[x][y] = ``0``;`   `    ``FindMinimumDistance();`   `    ``mat[t][l] = ``0``;`   `    ``// Print the required distances` `    ``for``(``int` `i = ``0``; i < r; i++)` `    ``{` `        ``for``(``int` `j = ``0``; j < c; j++)` `        ``{` `            ``System.out.print(mat[i][j] + ``" "``);` `        ``}` `        ``System.out.println();` `    ``}` `}` `}`   `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program to implement` `# the above approach` `mat ``=` `[[``0` `for` `x ``in` `range``(``1001``)] ` `          ``for` `y ``in` `range``(``1001``)]`   `# Stores the accessible directions` `dx ``=` `[ ``0``, ``-``1``, ``-``1``, ``-``1``, ``0``, ``1``, ``1``, ``1` `]` `dy ``=` `[ ``1``, ``1``, ``0``, ``-``1``, ``-``1``, ``-``1``, ``0``, ``1` `]`   `# Function to find the minimum distance` `# from a given cell to all other cells` `# in the matrix` `def` `FindMinimumDistance():` `    `  `    ``global` `x, y, r, c`   `    ``# Stores the accessible cells` `    ``# from current cell` `    ``q ``=` `[]`   `    ``# Insert pair (x, y)` `    ``q.append([x, y])` `    ``mat[x][y] ``=` `0`   `    ``# Iterate until queue is empty` `    ``while``(``len``(q) !``=` `0``):`   `        ``# Extract the pair` `        ``x ``=` `q[``0``][``0``]` `        ``y ``=` `q[``0``][``1``]`   `        ``# Pop them` `        ``q.pop(``0``)`   `        ``for` `i ``in` `range``(``8``):` `            ``a ``=` `x ``+` `dx[i]` `            ``b ``=` `y ``+` `dy[i]`   `            ``# Checking boundary condition` `            ``if``(a < ``0` `or` `a >``=` `r ``or` `              ``b >``=` `c ``or` `b < ``0``):` `                ``continue`   `            ``# If the cell is not visited` `            ``if``(mat[a][b] ``=``=` `0``):`   `                ``# Assign the minimum distance` `                ``mat[a][b] ``=` `mat[x][y] ``+` `1`   `                ``# Insert the traversed neighbour` `                ``# into the queue` `                ``q.append([a, b])`   `# Driver Code` `r ``=` `5` `c ``=` `5` `x ``=` `1` `y ``=` `1` `t ``=` `x` `l ``=` `y`   `mat[x][y] ``=` `0`   `FindMinimumDistance()` `mat[t][l] ``=` `0`   `# Print the required distances ` `for` `i ``in` `range``(r):` `    ``for` `j ``in` `range``(c):` `        ``print``(mat[i][j], end ``=` `" "``)` `        `  `    ``print``()`   `# This code is contributed by Shivam Singh`

## C#

 `// C# program to implement` `// the above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{` `    `  `class` `pair` `{ ` `    ``public` `int` `first, second; ` `    ``public` `pair(``int` `first, ``int` `second) ` `    ``{ ` `        ``this``.first = first; ` `        ``this``.second = second; ` `    ``} ` `} `   `static` `int` `[,]mat = ``new` `int``[1001, 1001];` `static` `int` `r, c, x, y;`   `// Stores the accessible directions` `static` `int` `[]dx = { 0, -1, -1, -1, 0, 1, 1, 1 };` `static` `int` `[]dy = { 1, 1, 0, -1, -1, -1, 0, 1 };`   `// Function to find the minimum distance from a` `// given cell to all other cells in the matrix` `static` `void` `FindMinimumDistance()` `{` `    `  `    ``// Stores the accessible cells` `    ``// from current cell` `    ``Queue q = ``new` `Queue();`   `    ``// Insert pair (x, y)` `    ``q.Enqueue(``new` `pair(x, y));` `    ``mat[x, y] = 0;`   `    ``// Iterate until queue is empty` `    ``while` `(q.Count != 0)` `    ``{` `        `  `        ``// Extract the pair` `        ``x = q.Peek().first;` `        ``y = q.Peek().second;`   `        ``// Pop them` `        ``q.Dequeue();`   `        ``for``(``int` `i = 0; i < 8; i++)` `        ``{` `            ``int` `a = x + dx[i];` `            ``int` `b = y + dy[i];`   `            ``// Checking boundary condition` `            ``if` `(a < 0 || a >= r ||` `                ``b >= c || b < 0)` `                ``continue``;`   `            ``// If the cell is not visited` `            ``if` `(mat[a, b] == 0) ` `            ``{` `                `  `                ``// Assign the minimum distance` `                ``mat[a, b] = mat[x, y] + 1;`   `                ``// Insert the traversed neighbour` `                ``// into the queue` `                ``q.Enqueue(``new` `pair(a, b));` `            ``}` `        ``}` `    ``}` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``r = 5; c = 5; x = 1; y = 1;`   `    ``int` `t = x;` `    ``int` `l = y;` `    ``mat[x, y] = 0;`   `    ``FindMinimumDistance();`   `    ``mat[t, l] = 0;`   `    ``// Print the required distances` `    ``for``(``int` `i = 0; i < r; i++)` `    ``{` `        ``for``(``int` `j = 0; j < c; j++)` `        ``{` `            ``Console.Write(mat[i, j] + ``" "``);` `        ``}` `        ``Console.WriteLine();` `    ``}` `}` `}`   `// This code is contributed by shikhasingrajput`

## Javascript

 ``

Output:

```1 1 1 2 3
1 0 1 2 3
1 1 1 2 3
2 2 2 2 3
3 3 3 3 3```

Time Complexity: O(R * C)
Auxiliary Space: O(R * C)

My Personal Notes arrow_drop_up