Find a Peak Element II

Find a Peak Element II - Problem

A peak element in a 2D grid is an element that is strictly greater than all of its adjacent neighbors to the left, right, top, and bottom.

Given a 0-indexed m x n matrix mat where no two adjacent cells are equal, find any peak element mat[i][j] and return the length 2 array [i,j].

You may assume that the entire matrix is surrounded by an outer perimeter with the value -1 in each cell.

You must write an algorithm that runs in O(m log(n)) or O(n log(m)) time.

Input & Output

Example 1 — Basic 3x3 Matrix

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

› Output: [1,1]

💡 Note: Element 7 at [1,1] is greater than all neighbors: 7 > 4 (top), 7 > 2 (left), 7 > 6 (right), 7 > 0 (bottom).

Example 2 — Single Peak

$ Input: mat = [[10,20,15],[21,30,14],[7,16,32]]

› Output: [1,1]

💡 Note: Element 30 at [1,1] is greater than all neighbors: 30 > 20, 30 > 21, 30 > 14, 30 > 16

Example 3 — Corner Peak

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

› Output: [1,1]

💡 Note: Element 4 at [1,1] is greater than all neighbors: 4 > 3, 4 > 2. Boundary cells have value -1.

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 500
-10⁵ ≤ mat[i][j] ≤ 10⁵
No two adjacent cells are equal

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 15 M Microsoft 12

The key insight is using binary search to eliminate columns by comparing the maximum element in the middle column with its neighbors. The optimal binary search approach achieves O(m log n) time complexity by intelligently reducing the search space. Time: O(m log n), Space: O(1)

Common Approaches

✓ Dfs

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

Binary Search on Columns

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

Apply binary search on columns. For the middle column, find the maximum element. If this max element is greater than its left and right neighbors, it's a peak. Otherwise, move toward the side with the larger neighbor.

Brute Force - Check Every Element

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

Iterate through every cell in the matrix and check if it's greater than all its adjacent neighbors (left, right, top, bottom). The first element that satisfies this condition is a peak.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int mat[1000][1000];
static int m, n;

int findMaxInCol(int col) {
    int maxRow = 0;
    for (int i = 1; i < m; i++) {
        if (mat[i][col] > mat[maxRow][col]) {
            maxRow = i;
        }
    }
    return maxRow;
}

int* findPeakGrid(int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    
    int left = 0, right = n - 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        int maxRow = findMaxInCol(mid);
        
        int leftVal = (mid > 0) ? mat[maxRow][mid - 1] : -1;
        int rightVal = (mid < n - 1) ? mat[maxRow][mid + 1] : -1;
        
        if (mat[maxRow][mid] > leftVal && mat[maxRow][mid] > rightVal) {
            result[0] = maxRow;
            result[1] = mid;
            return result;
        }
        else if (leftVal > mat[maxRow][mid]) {
            right = mid - 1;
        }
        else {
            left = mid + 1;
        }
    }
    
    result[0] = 0;
    result[1] = 0;
    return result;
}

void parseMatrix(char* input) {
    int len = strlen(input);
    int i = 0;
    
    // Skip initial '['
    while (i < len && input[i] != '[') i++;
    i++;
    
    m = 0;
    while (i < len && input[i] != ']') {
        if (input[i] == '[') {
            i++; // skip '['
            n = 0;
            while (input[i] != ']') {
                if (input[i] >= '0' && input[i] <= '9') {
                    int num = 0;
                    while (i < len && input[i] >= '0' && input[i] <= '9') {
                        num = num * 10 + (input[i] - '0');
                        i++;
                    }
                    mat[m][n] = num;
                    n++;
                } else {
                    i++;
                }
            }
            i++; // skip ']'
            m++;
        } else {
            i++;
        }
    }
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    parseMatrix(input);
    
    int returnSize;
    int* result = findPeakGrid(&returnSize);
    
    printf("[%d,%d]\n", result[0], result[1]);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium-High Frequency

~25 min Avg. Time

847 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

Algorithm Steps — Algorithm Steps

Code -

Time & Space Complexity

Select Compiler