New update is available. Click here to update.

Last Updated: 30 Mar, 2021

Moderate

```
The distance between any two cells (x0, y0) and (x1, y1) is given by the Manhattan distance: |x0 - x1| + |y0 - y1|.
If no land or water exists in the grid, then return -1.
```

```
The first line of input contains an integer βT' representing the number of test cases.
The first line of each test case contains one integer βNβ denoting the size of the matrix.
The next βNβ lines contain βNβ integers separated by spaces describing rows of matrix βARRβ (each element of βARRβ is either 0 or 1).
```

```
For each test case, on a separate line, output one integer - the largest distance from a water cell to the nearest land cell.
```

```
You do not need to print anything. It has already been taken care of. Just implement the given function.
```

```
1 <= T <= 5
1 <= N <= 10^3
ARR[i][j] = 0 or 1
Time limit: 1 sec
```

Approaches

The idea here is to calculate the distance from each land cell and update every water cell to the minimum distance via any land cell.

We declare a 2d matrix **minDistance[][]** initially set to Infinity, and then run BFS from every land cell and calculate the shortest distance to each water cell, and update the **minDistance[][]** to the minimum shortest distance to a water cell. The maximum value which is not equal to infinity, of the water cell in **minDistance[][]** will be our **ans**.

The algorithm is as follows:

- Declare an
**ans**variable and set it to -1, representing the largest distance of a land cell from the nearest water cell. - Declare a
**dx**array representing and set it to {1, 0, -1, 0}, representing the directions of all four neighboring cells. - Declare a
**dy**array representing and set it to {0, 1, 0, -1}, representing the directions of all four neighboring cells. - Declare a 2D array
**minDistance[][]**with**N**rows and**N**columns and set it to infinity, where**minDistance[i][j]**represents the minimum possible distance between a water cell from a land cell. - Iterate from
**i = 0 to N**,- Iterate from
**j = 0 to N**,- If
**ARR[i][j] == 1**,- Run BFS from this land cell.
- Compute the shortest distance from this land cell to every reachable water cell and store it to a matrix
**distance[][]**. - update the
**minDistance[][],**- Set
**minDistance[i][j] = min(minDistance[i][j], distance[i][j])**.

- Set

- If

- Iterate from
- Iterate from
**i = 0 to N**,- Iterate from
**j = 0 to N**,- If
**ARR[i][j] == 0 and minDistance[i][j] < infinity**,- Update
**ans**to**max(ans, minDistance[i][j]).**

- Update

- If

- Iterate from
- Return the
**ans**.

The idea here is to think in reverse order and imagine expanding outward from each land cell i.e. using BFS from all land cells at the same time.

If we put all the land cells in the queue and then we expand in all four directions and visit the water cell one level at a time. The maximum level reached will be our **ans**.

The algorithm is as follows:

- Declare an
**ans**variable and set it to 0, representing the largest distance of a land cell from the nearest water cell. - Declare a
**dx**array representing and set it to {1, 0, -1, 0}, representing the directions of all four neighboring cells. - Declare a
**dy**array representing and set it to {0, 1, 0, -1}, representing the directions of all four neighboring cells. - Declare a 2D array
**visited**with**N**rows and**N**columns, where**visited[i][j] = 0 or 1**, 0 representing the current cell being visited and 1 representing not visited. - Declare a queue of array
**Q**, where the first element of the array is the x coordinate and the second element of the array is the y coordinate.- Push all the land cells to the queue.
- Mark the land cells as visited.

- If
**Q.size == 0 or Q.size == N * N,**- Return -1.

- While
**Q**is not empty,- Declare a variable
**levelSize**and set it to**Q.size**. - Declare a variable
**flag**and set it to 0, representing that we can reach a new level. - Iterate from
**i = 0 to levelSize - 1**,- Declare an array variable
**coordinate**and set it**Q.front.** - Pop an element from the front of the queue.
- Iterate from
**direction = 0 to 3**,- Declare a variable
**X**and set it to**coordinate[0] + dx[direction].** - Declare a variable
**Y**and set it to**coordinate[1] + dx[direction].** - If
**X**and**Y**are invalid coordinates or**visited[X][Y] == 1**, continue as we donβt want to visit any cell more than once. - Set
**visited[X][Y]**to 1. - Push
**(X, Y)**to queue**Q**. - Set
**flag**to 1, as we reached a new level.

- Declare a variable

- Declare an array variable
- If the
**flag**== 1,- Increment
**ans**by 1.

- Increment

- Declare a variable
- Return the
**ans**.

Similar problems

Valid Arrangement of Pairs

Hard

Posted: 28 Jan, 2022

Valid Arrangement of Pairs

Hard

Posted: 28 Jan, 2022

Valid Arrangement of Pairs

Hard

Posted: 28 Jan, 2022

Valid Arrangement of Pairs

Hard

Posted: 28 Jan, 2022

Valid Arrangement of Pairs

Hard

Posted: 28 Jan, 2022

Left Right Print

Moderate

Posted: 9 Jul, 2022

COUNT ISLANDS

Moderate

Posted: 14 Sep, 2022

The Summit

Easy

Posted: 15 Sep, 2022

Distance to a Cycle in Undirected Graph

Moderate

Posted: 7 Nov, 2022