Find a Peak Element II - Practice Coding Problems

Find a Peak Element II - Problem

Imagine you're standing on a 2D mountain range represented as a matrix, where each cell contains an elevation value. Your goal is to find a peak element - a position that is strictly higher than all of its neighboring positions (left, right, top, and bottom).

Given an m x n matrix mat where no two adjacent cells have equal values, find any peak element and return its coordinates [i, j].

Important: The matrix is surrounded by an imaginary border of -1 values, making edge and corner elements easier to be peaks. You must solve this efficiently in O(m log n) or O(n log m) time complexity.

Example: In matrix [[1,4,3],[2,5,1]], element 5 at position [1,1] is a peak because it's greater than all neighbors (4, 3, 2, 1).

Input & Output

example_1.py — Basic 2x3 Matrix

$ Input: mat = [[1,4,3],[2,5,1]]

› Output: [1,1]

💡 Note: Element 5 at position [1,1] is greater than all its neighbors: up(4), down(-1), left(2), right(1). Since the matrix is surrounded by -1, the 'down' neighbor is -1.

example_2.py — Larger Matrix

$ Input: mat = [[1,4,3,2],[3,6,2,1],[2,1,5,4]]

› Output: [1,1]

💡 Note: Element 6 at position [1,1] is a peak because it's greater than neighbors: up(4), down(1), left(3), right(2). Multiple peaks may exist, but we only need to find one.

example_3.py — Single Element

$ Input: mat = [[7]]

› Output: [0,0]

💡 Note: In a 1x1 matrix, the single element is always a peak since it's surrounded by -1 values on all sides.

Visualization

Tap to expand

Understanding the Visualization

Divide & Conquer

Start by examining the middle row of the mountain range

Find Local Maximum

In that row, find the highest point (maximum element)

Check Peak Status

See if this point is higher than all neighboring areas

Navigate Smartly

If not a peak, move toward the steepest upward direction

Eliminate Half

This eliminates half the search area, just like binary search

Key Takeaway

🎯 Key Insight: Just like climbing a mountain, if you're not at a peak, there's always a direction that goes upward. Follow it using binary search principles to efficiently eliminate half the search space in each iteration!

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We visit every cell once and check up to 4 neighbors for each

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 500
-10⁵ ≤ mat[i][j] ≤ 10⁵
No two adjacent cells are equal
You must achieve O(m log n) or O(n log m) time complexity

Asked in

G Google 45 f Facebook 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses binary search on matrix rows achieving O(n log m) time complexity. For each middle row, find the maximum element, check if it's a peak, and if not, eliminate half the search space by moving toward the larger neighbor. This approach leverages the key insight that following the steepest ascent always leads to a peak.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Cell)	O(m×n)	O(1)	Check every cell to see if it's greater than all four neighbors
Binary Search on Rows (Optimal)	O(n log m)	O(1)	Use binary search on rows, find max in middle row, then eliminate half the search space

Brute Force (Check Every Cell) — Algorithm Steps

Iterate through each cell (i, j) in the matrix
For each cell, check if it's greater than all adjacent neighbors
Handle boundary conditions by treating out-of-bounds as -1
Return the first peak found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at (0,0)

Begin checking from top-left corner

Check neighbors

Compare current cell with up, down, left, right neighbors

Move to next

If not a peak, move to next cell in row-major order

Found peak

Return coordinates when peak condition is satisfied

Code -

solution.c — C

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

int isPeak(int** mat, int i, int j, int m, int n) {
    int val = mat[i][j];
    int dirs[4][2] = {{-1,0}, {1,0}, {0,-1}, {0,1}};
    
    for (int k = 0; k < 4; k++) {
        int ni = i + dirs[k][0], nj = j + dirs[k][1];
        int neighbor = (ni >= 0 && ni < m && nj >= 0 && nj < n) ? mat[ni][nj] : -1;
        if (val <= neighbor) return 0;
    }
    return 1;
}

int* findPeakGrid(int** mat, int m, int n) {
    int* result = (int*)malloc(2 * sizeof(int));
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (isPeak(mat, i, j, m, n)) {
                result[0] = i;
                result[1] = j;
                return result;
            }
        }
    }
    result[0] = -1;
    result[1] = -1;
    return result;
}

int main() {
    // Parse input and call function
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We visit every cell once and check up to 4 neighbors for each

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 500
-10⁵ ≤ mat[i][j] ≤ 10⁵
No two adjacent cells are equal
You must achieve O(m log n) or O(n log m) time complexity

42.0K Views

Medium-High Frequency

~25 min Avg. Time

1.4K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check Every Cell) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler