Map of Highest Peak

Map of Highest Peak - Problem

You are given an integer matrix isWater of size m x n that represents a map of land and water cells.

If isWater[i][j] == 0, cell (i, j) is a land cell.
If isWater[i][j] == 1, cell (i, j) is a water cell.

You must assign each cell a height in a way that follows these rules:

The height of each cell must be non-negative.
If the cell is a water cell, its height must be 0.
Any two adjacent cells must have an absolute height difference of at most 1. A cell is adjacent to another cell if the former is directly north, east, south, or west of the latter (i.e., their sides are touching).

Find an assignment of heights such that the maximum height in the matrix is maximized.

Return an integer matrix height of size m x n where height[i][j] is cell (i, j)'s height. If there are multiple solutions, return any of them.

Input & Output

Example 1 — Basic Island

$ 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 distance 2 from water, so height 2.

Example 2 — Multiple Water Sources

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

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

💡 Note: Two water cells at (0,2) and (1,0). Heights are minimum distance to any water cell.

Example 3 — All Water

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

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

💡 Note: All cells are water, so all heights are 0.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to use multi-source BFS starting from all water cells simultaneously. This treats the problem as finding shortest distances from multiple sources. Best approach is Multi-Source BFS with Time: O(mn), Space: O(mn).

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Memoization

⏱️ Time: N/A Space: N/A

Iterative Height Assignment

⏱️ Time: O(m²n²) Space: O(1)

Start with water cells at height 0, then repeatedly scan the entire matrix. For each land cell, try to set its height based on the minimum height of adjacent cells plus 1. Continue until no more updates are possible.

Multi-Source BFS (Optimal)

⏱️ Time: O(mn) Space: O(mn)

Use multi-source BFS starting from all water cells at height 0. Process cells level by level, assigning height equal to distance from nearest water. This ensures maximum heights are achieved optimally.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

int countPartitions(const char* str, int k) {
    int partitions = 0;
    int i = 0;
    int n = strlen(str);
    
    while (i < n) {
        bool chars[26] = {false};
        int distinctCount = 0;
        int j = i;
        
        while (j < n) {
            int charIndex = str[j] - 'a';
            if (!chars[charIndex]) {
                if (distinctCount == k) {
                    break;
                }
                chars[charIndex] = true;
                distinctCount++;
            }
            j++;
        }
        partitions++;
        i = j;
    }
    
    return partitions;
}

int solution(char* s, int k) {
    int maxPartitions = countPartitions(s, k);
    int n = strlen(s);
    
    // Try changing each character
    for (int i = 0; i < n; i++) {
        char original = s[i];
        for (char c = 'a'; c <= 'z'; c++) {
            if (c != original) {
                s[i] = c;
                int partitions = countPartitions(s, k);
                if (partitions > maxPartitions) {
                    maxPartitions = partitions;
                }
            }
        }
        s[i] = original;  // restore
    }
    
    return maxPartitions;
}

int main() {
    char s[1001];
    int k;
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;  // remove newline
    scanf("%d", &k);
    printf("%d\n", solution(s, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

892 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