Maximum height of an elevation possible such that adjacent matrix cells have a difference of at most height 1

Given a matrix mat][][] of size M x N which represents the topographic map of a region, and 0 denotes land and 1 denotes elevation, the task is to maximize the height in the matrix by assigning each cell a non-negative height such that the height of a land cell is 0 and two adjacent cells must have an absolute height difference of at most 1.

Examples:

Input: mat[][] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}
Output: {{0, 1, 2}, {1, 0, 1}, {2, 1, 0}}

Input: mat[][] = {{0, 0, 1}, {1, 0, 0}, {0, 0, 0}}
Output: {{1, 1, 0}, {0, 1, 1}, {1, 2, 2}}

Approach: The idea is to use BFS. Follow the steps below to solve the problem:

• Initialize a 2d array, height of size M x N to store the final output matrix.
• Initialize a queue of pair, queue<pair<int, int>>q to store the pair indexes for BFS.
• Traverse the matrix and mark the height of land cell as 0 and enqueue them, also mark them as visited.
• Perform BFS:
• Dequeue a cell from queue and check all its 4 adjacent cells, if any of them is unvisited yet mark the height of this cell as 1 + height of current cell.
• Mark all the unvisited adjacent cell as visited.
• Repeat this unless the queue becomes empty.
• Print the final height matrix.

Below is the implementation of the above approach:

C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `#define M 3``#define N 3` `// Utility function to find the matrix``// having the maximum height``void` `findHeightMatrixUtil(``int` `mat[][N],``                          ``int` `height[M][N])``{``    ``// Stores index pairs for bfs``    ``queue > q;` `    ``// Stores info about the visited cells``    ``int` `vis[M][N] = { 0 };` `    ``// Traverse the matrix``    ``for` `(``int` `i = 0; i < M; i++) {``        ``for` `(``int` `j = 0; j < N; j++) {``            ``if` `(mat[i][j] == 1) {``                ``q.push({ i, j });``                ``height[i][j] = 0;``                ``vis[i][j] = 1;``            ``}``        ``}``    ``}` `    ``// Breadth First Search``    ``while` `(q.empty() == 0) {` `        ``pair<``int``, ``int``> k = q.front();``        ``q.pop();` `        ``// x & y are the row & column``        ``// of current cell``        ``int` `x = k.first, y = k.second;` `        ``// Check all the 4 adjacent cells``        ``// and marking them as visited``        ``// if not visited yet also marking``        ``// their height as 1 + height of cell (x, y)` `        ``if` `(x > 0 && vis[x - 1][y] == 0) {``            ``height[x - 1][y] = height[x][y] + 1;``            ``vis[x - 1][y] = 1;``            ``q.push({ x - 1, y });``        ``}` `        ``if` `(y > 0 && vis[x][y - 1] == 0) {``            ``height[x][y - 1] = height[x][y] + 1;``            ``vis[x][y - 1] = 1;``            ``q.push({ x, y - 1 });``        ``}` `        ``if` `(x < M - 1 && vis[x + 1][y] == 0) {``            ``height[x + 1][y] = height[x][y] + 1;``            ``vis[x + 1][y] = 1;``            ``q.push({ x + 1, y });``        ``}` `        ``if` `(y < N - 1 && vis[x][y + 1] == 0) {``            ``height[x][y + 1] = height[x][y] + 1;``            ``vis[x][y + 1] = 1;``            ``q.push({ x, y + 1 });``        ``}``    ``}``}` `// Function to find the matrix having``// the maximum height``void` `findHeightMatrix(``int` `mat[][N])``{``    ``// Stores output matrix``    ``int` `height[M][N];` `    ``// Calling the helper function``    ``findHeightMatrixUtil(mat, height);` `    ``// Print the final output matrix``    ``for` `(``int` `i = 0; i < M; i++) {``        ``for` `(``int` `j = 0; j < N; j++)``            ``cout << height[i][j] << ``" "``;` `        ``cout << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``// Given matrix``    ``int` `mat[][N]``        ``= { { 0, 0 }, { 0, 1 } };` `    ``// Function call to find``    ``// the matrix having``    ``// the maximum height``    ``findHeightMatrix(mat);` `    ``return` `0;``}`

Java

 `// Java program for the above approach` `import` `java.util.*;` `class` `GFG{` `static` `final` `int` `M = ``3``;``static` `final` `int` `N = ``3``;``static` `class` `pair``{ ``    ``int` `first, second; ``    ``public` `pair(``int` `first, ``int` `second)  ``    ``{ ``        ``this``.first = first; ``        ``this``.second = second; ``    ``}``}``  ` `// Utility function to find the matrix``// having the maximum height``static` `void` `findHeightMatrixUtil(``int` `mat[][],``                          ``int` `height[][])``{``    ``// Stores index pairs for bfs``    ``Queue q = ``new` `LinkedList<>();` `    ``// Stores info about the visited cells``    ``int` `[][]vis = ``new` `int``[M][N];` `    ``// Traverse the matrix``    ``for` `(``int` `i = ``0``; i < M; i++) {``        ``for` `(``int` `j = ``0``; j < N; j++) {``            ``if` `(mat[i][j] == ``1``) {``                ``q.add(``new` `pair( i, j ));``                ``height[i][j] = ``0``;``                ``vis[i][j] = ``1``;``            ``}``        ``}``    ``}` `    ``// Breadth First Search``    ``while` `(q.isEmpty() == ``false``) {` `        ``pair k = q.peek();``        ``q.remove();` `        ``// x & y are the row & column``        ``// of current cell``        ``int` `x = k.first, y = k.second;` `        ``// Check all the 4 adjacent cells``        ``// and marking them as visited``        ``// if not visited yet also marking``        ``// their height as 1 + height of cell (x, y)` `        ``if` `(x > ``0` `&& vis[x - ``1``][y] == ``0``) {``            ``height[x - ``1``][y] = height[x][y] + ``1``;``            ``vis[x - ``1``][y] = ``1``;``            ``q.add(``new` `pair( x - ``1``, y ));``        ``}` `        ``if` `(y > ``0` `&& vis[x][y - ``1``] == ``0``) {``            ``height[x][y - ``1``] = height[x][y] + ``1``;``            ``vis[x][y - ``1``] = ``1``;``            ``q.add(``new` `pair( x, y - ``1` `));``        ``}` `        ``if` `(x < M - ``1` `&& vis[x + ``1``][y] == ``0``) {``            ``height[x + ``1``][y] = height[x][y] + ``1``;``            ``vis[x + ``1``][y] = ``1``;``            ``q.add(``new` `pair( x + ``1``, y ));``        ``}` `        ``if` `(y < N - ``1` `&& vis[x][y + ``1``] == ``0``) {``            ``height[x][y + ``1``] = height[x][y] + ``1``;``            ``vis[x][y + ``1``] = ``1``;``            ``q.add(``new` `pair( x, y + ``1` `));``        ``}``    ``}``}` `// Function to find the matrix having``// the maximum height``static` `void` `findHeightMatrix(``int` `mat[][])``{``    ``// Stores output matrix``    ``int` `[][]height = ``new` `int``[M][N];` `    ``// Calling the helper function``    ``findHeightMatrixUtil(mat, height);` `    ``// Print the final output matrix``    ``for` `(``int` `i = ``0``; i < M; i++) {``        ``for` `(``int` `j = ``0``; j < N; j++)``            ``System.out.print(height[i][j]+ ``" "``);` `        ``System.out.println();``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``// Given matrix``    ``int` `mat[][]``        ``= { { ``0``, ``0``,``0` `}, { ``0``, ``1``,``0` `},{ ``0``, ``0``,``0` `} };` `    ``// Function call to find``    ``// the matrix having``    ``// the maximum height``    ``findHeightMatrix(mat);` `}``}` `// This code is contributed by 29AjayKumar`

Python3

 `# Python3 program for the above approach``M ``=` `3``N ``=` `3` `# Utility function to find the matrix``# having the maximum height``def` `findHeightMatrixUtil(mat, height):` `    ``# Stores index pairs for bfs``    ``q ``=` `[]` `    ``# Stores info about the visited cells``    ``vis ``=` `[[``0` `for` `i ``in` `range``(N)]``for` `j ``in` `range``(M)]` `    ``# Traverse the matrix``    ``for` `i ``in` `range``(M):``        ``for` `j ``in` `range``(N): ``            ``if` `(mat[i][j] ``=``=` `1``):``                ``q.append([i, j])``                ``height[i][j] ``=` `0``                ``vis[i][j] ``=` `1` `    ``# Breadth First Search``    ``while` `(``len``(q) !``=` `0``):` `        ``k ``=` `q[``0``]``        ``q ``=` `q[``1``:]` `        ``# x & y are the row & column``        ``# of current cell``        ``x,y ``=` `k[``0``],k[``1``]` `        ``# Check all the 4 adjacent cells``        ``# and marking them as visited``        ``# if not visited yet also marking``        ``# their height as 1 + height of cell (x, y)` `        ``if` `(x > ``0` `and` `vis[x ``-` `1``][y] ``=``=` `0``):``            ``height[x ``-` `1``][y] ``=` `height[x][y] ``+` `1``            ``vis[x ``-` `1``][y] ``=` `1``            ``q.append([x ``-` `1``, y])` `        ``if` `(y > ``0` `and` `vis[x][y ``-` `1``] ``=``=` `0``):``            ``height[x][y ``-` `1``] ``=` `height[x][y] ``+` `1``            ``vis[x][y ``-` `1``] ``=` `1``            ``q.append([x, y ``-` `1``])` `        ``if` `(x < M ``-` `1` `and` `vis[x ``+` `1``][y] ``=``=` `0``):``            ``height[x ``+` `1``][y] ``=` `height[x][y] ``+` `1``            ``vis[x ``+` `1``][y] ``=` `1``            ``q.append([x ``+` `1``, y])` `        ``if` `(y < N ``-` `1` `and` `vis[x][y ``+` `1``] ``=``=` `0``):``            ``height[x][y ``+` `1``] ``=` `height[x][y] ``+` `1``            ``vis[x][y ``+` `1``] ``=` `1``            ``q.append([x, y ``+` `1``])` `    ``return` `height` `# Function to find the matrix having``# the maximum height``def` `findHeightMatrix(mat):` `    ``# Stores output matrix``    ``height ``=` `[[``0` `for` `i ``in` `range``(N)]``for` `j ``in` `range``(M)]` `    ``# Calling the helper function``    ``height ``=` `findHeightMatrixUtil(mat, height)` `    ``# Print the final output matrix``    ``for` `i ``in` `range``(M):``        ``for` `j ``in` `range``(N):``            ``print``(height[i][j] ,end ``=` `" "``)` `        ``print``()` `# Driver Code``# Given matrix``mat ``=` `[ [ ``0``, ``0``,``0``], [``0``, ``1``,``0` `],[``0``, ``0``,``0` `]]` `# Function call to find``# the matrix having``# the maximum height``findHeightMatrix(mat)` `# This code is contributed by shinjanpatra`

C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG``{` `static` `readonly` `int` `M = 3;``static` `readonly` `int` `N = 3;``class` `pair``{ ``    ``public` `int` `first, second; ``    ``public` `pair(``int` `first, ``int` `second)  ``    ``{ ``        ``this``.first = first; ``        ``this``.second = second; ``    ``}``}``  ` `// Utility function to find the matrix``// having the maximum height``static` `void` `findHeightMatrixUtil(``int` `[,]mat,``                          ``int` `[,]height)``{``  ` `    ``// Stores index pairs for bfs``    ``Queue q = ``new` `Queue();` `    ``// Stores info about the visited cells``    ``int` `[,]vis = ``new` `int``[M,N];` `    ``// Traverse the matrix``    ``for` `(``int` `i = 0; i < M; i++) {``        ``for` `(``int` `j = 0; j < N; j++) {``            ``if` `(mat[i,j] == 1) {``                ``q.Enqueue(``new` `pair( i, j ));``                ``height[i,j] = 0;``                ``vis[i,j] = 1;``            ``}``        ``}``    ``}` `    ``// Breadth First Search``    ``while` `(q.Count != 0 )``    ``{` `        ``pair k = q.Peek();``        ``q.Dequeue();` `        ``// x & y are the row & column``        ``// of current cell``        ``int` `x = k.first, y = k.second;` `        ``// Check all the 4 adjacent cells``        ``// and marking them as visited``        ``// if not visited yet also marking``        ``// their height as 1 + height of cell (x, y)` `        ``if` `(x > 0 && vis[x - 1, y] == 0) {``            ``height[x - 1, y] = height[x, y] + 1;``            ``vis[x - 1, y] = 1;``            ``q.Enqueue(``new` `pair( x - 1, y ));``        ``}` `        ``if` `(y > 0 && vis[x, y - 1] == 0) {``            ``height[x, y - 1] = height[x, y] + 1;``            ``vis[x, y - 1] = 1;``            ``q.Enqueue(``new` `pair( x, y - 1 ));``        ``}` `        ``if` `(x < M - 1 && vis[x + 1, y] == 0) {``            ``height[x + 1, y] = height[x, y] + 1;``            ``vis[x + 1, y] = 1;``            ``q.Enqueue(``new` `pair( x + 1, y ));``        ``}` `        ``if` `(y < N - 1 && vis[x, y + 1] == 0) {``            ``height[x, y + 1] = height[x, y] + 1;``            ``vis[x, y + 1] = 1;``            ``q.Enqueue(``new` `pair( x, y + 1 ));``        ``}``    ``}``}` `// Function to find the matrix having``// the maximum height``static` `void` `findHeightMatrix(``int` `[,]mat)``{``    ``// Stores output matrix``    ``int` `[,]height = ``new` `int``[M, N];` `    ``// Calling the helper function``    ``findHeightMatrixUtil(mat, height);` `    ``// Print the readonly output matrix``    ``for` `(``int` `i = 0; i < M; i++) {``        ``for` `(``int` `j = 0; j < N; j++)``            ``Console.Write(height[i,j]+ ``" "``);` `        ``Console.WriteLine();``    ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``// Given matrix``    ``int` `[,]mat``        ``= { { 0, 0,0 }, { 0, 1,0 },{ 0, 0,0 } };` `    ``// Function call to find``    ``// the matrix having``    ``// the maximum height``    ``findHeightMatrix(mat);` `}``}` `// This code is contributed by 29AjayKumar`

Javascript

 ``

Output:
```2 1 2
1 0 1
2 1 2```

Time Complexity: O(M * N)
Auxiliary Space: O(M * N)

Previous
Next