Map of Highest Peak - Practice Coding Problems

Map of Highest Peak - Problem

Map of Highest Peak - Create an optimal height map that maximizes the peak elevation!

You're given a matrix representing land and water cells on a map. Your task is to assign heights to each cell following specific rules:

🌊 Water cells (value = 1) must have height 0
🏔️ Land cells (value = 0) can have any non-negative height
📏 Adjacent cells can differ in height by at most 1

The goal is to maximize the highest peak in the entire map. Think of it as creating the most dramatic mountain landscape possible while respecting the physical constraints!

Example: If you have water in the center and land around it, the land cells closest to water will be height 1, the next layer will be height 2, and so on, creating natural-looking mountain ridges.

Input & Output

example_1.py — Basic 2x2 Grid

$ Input: isWater = [[0,1],[0,0]]

› Output: [[1,0],[2,1]]

💡 Note: Water cell at (0,1) has height 0. Adjacent cells get height 1. Cell (1,0) is farthest from water, so it gets height 2.

example_2.py — 3x3 Grid with Center Water

$ Input: isWater = [[0,0,1],[0,0,0],[0,0,0]]

› Output: [[2,1,0],[3,2,1],[4,3,2]]

💡 Note: Water is at top-right. Heights increase as we move away from water, creating a diagonal pattern with maximum height 4.

example_3.py — All Water

$ Input: isWater = [[1,1],[1,1]]

› Output: [[0,0],[0,0]]

💡 Note: All cells are water, so all heights are 0. This is an edge case where no land cells exist.

Constraints

m == isWater.length
n == isWater[i].length
1 ≤ m, n ≤ 1000
isWater[i][j] is 0 or 1
At least one cell is a water cell

Visualization

Tap to expand

Understanding the Visualization

Water Foundation

All water cells start at elevation 0 (sea level)

First Ridge

Land cells touching water get elevation 1

Higher Peaks

Each subsequent layer gets +1 elevation

Maximum Heights

Cells farthest from any water become the highest peaks

Key Takeaway

🎯 Key Insight: Multi-source BFS naturally computes the shortest distance (optimal height) from each cell to the nearest water source, creating the tallest possible mountain landscape while respecting adjacency constraints.

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

The optimal solution uses Multi-Source BFS starting from all water cells simultaneously. This approach achieves O(mn) time complexity by processing each cell exactly once. The key insight is that the optimal height equals the distance to nearest water source, which BFS naturally computes level by level.

Common Approaches

Approach	Time	Space	Notes
✓ Multi-Source BFS (Optimal)	O(mn)	O(mn)	Use BFS starting from all water cells simultaneously to assign optimal heights

Multi-Source BFS (Optimal) — Algorithm Steps

Initialize queue with all water cell coordinates and set their heights to 0
Mark all land cells as unvisited (-1 initially)
Perform BFS: process current level, assign heights
For each cell, add unvisited neighbors to queue with height = current + 1
Continue until queue is empty (all cells processed)

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from Water

All water cells (height 0) added to queue

Level 1 Expansion

Process all cells adjacent to water, assign height 1

Level 2 Expansion

Process cells adjacent to height 1, assign height 2

Continue

Expand outward until all cells processed

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int x, y;
} Point;

int** highestPeak(int** isWater, int m, int n) {
    int** result = (int**)malloc(m * sizeof(int*));
    Point* queue = (Point*)malloc(m * n * sizeof(Point));
    int front = 0, rear = 0;
    
    // Initialize result matrix and queue
    for (int i = 0; i < m; i++) {
        result[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            if (isWater[i][j] == 1) {
                result[i][j] = 0;
                queue[rear++] = (Point){i, j};
            } else {
                result[i][j] = -1;
            }
        }
    }
    
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
    // Multi-source BFS
    while (front < rear) {
        Point curr = queue[front++];
        
        for (int d = 0; d < 4; d++) {
            int nx = curr.x + directions[d][0];
            int ny = curr.y + directions[d][1];
            
            if (nx >= 0 && nx < m && ny >= 0 && ny < n && result[nx][ny] == -1) {
                result[nx][ny] = result[curr.x][curr.y] + 1;
                queue[rear++] = (Point){nx, ny};
            }
        }
    }
    
    free(queue);
    return result;
}

int main() {
    int m = 2, n = 2;
    int** isWater = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        isWater[i] = (int*)malloc(n * sizeof(int));
    }
    
    isWater[0][0] = 0; isWater[0][1] = 1;
    isWater[1][0] = 0; isWater[1][1] = 0;
    
    int** result = highestPeak(isWater, m, n);
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn)

Each cell is visited exactly once during BFS traversal

✓ Linear Growth

Space Complexity

O(mn)

Queue can contain up to O(mn) cells in worst case, plus result matrix

⚡ Linearithmic Space

38.3K Views

Medium Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Multi-Source BFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler