Saddle Point Finder - Problem

A saddle point in a matrix is an element that is simultaneously the minimum in its row and the maximum in its column.

Given a 2D matrix, find all saddle points and return their coordinates as an array of [row, col] pairs.

Note: If no saddle points exist, return an empty array. Matrix elements can be positive, negative, or zero.

Input & Output

Example 1 — Matrix with One Saddle Point

$ Input: matrix = [[1,7,3],[9,11,5],[4,3,2]]

› Output: [[2,2]]

💡 Note: Element at [2,2] is 2. It's the minimum in row 2: [4,3,2] and maximum in column 2: [3,5,2]. Therefore, it's a saddle point.

Example 2 — Matrix with No Saddle Points

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

› Output: []

💡 Note: No element satisfies both conditions. Element 1 is row min but not column max, element 4 is column max but not row min.

Example 3 — Single Element Matrix

$ Input: matrix = [[5]]

› Output: [[0,0]]

💡 Note: Single element 5 is both minimum in its row and maximum in its column by definition.

Constraints

1 ≤ m, n ≤ 300
-10⁴ ≤ matrix[i][j] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15

The key insight is pre-calculating row minimums and column maximums to avoid redundant scans. Best approach uses two-pass preprocessing for O(m×n) time complexity. Time: O(m×n), Space: O(m+n).

Common Approaches

✓ Brute Force

⏱️ Time: O(m×n×(m+n)) Space: O(1)

For each element in the matrix, scan its complete row to verify it's the minimum, then scan its complete column to verify it's the maximum. If both conditions are met, it's a saddle point.

Optimized with Preprocessing

⏱️ Time: O(m×n) Space: O(m+n)

First pass: calculate the minimum value for each row and maximum value for each column. Second pass: check each element against pre-calculated values to identify saddle points efficiently.

Brute Force — Algorithm Steps

Iterate through every matrix element
For each element, check if it's minimum in its row
For same element, check if it's maximum in its column
If both conditions true, add coordinates to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Element

Pick current element (1,7,3)

Check Row

Scan entire row for minimum

Check Column

Scan entire column for maximum

Add if Both

Add to result if both conditions met

Code -

solution.c — C

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

int** solution(int** matrix, int m, int n, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    if (m == 0 || n == 0) return NULL;
    
    int** result = malloc(m * n * sizeof(int*));
    *returnColumnSizes = malloc(m * n * sizeof(int));
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int current = matrix[i][j];
            
            // Check if minimum in row
            int isRowMin = 1;
            for (int k = 0; k < n; k++) {
                if (matrix[i][k] < current) {
                    isRowMin = 0;
                    break;
                }
            }
            
            if (!isRowMin) continue;
            
            // Check if maximum in column
            int isColMax = 1;
            for (int k = 0; k < m; k++) {
                if (matrix[k][j] > current) {
                    isColMax = 0;
                    break;
                }
            }
            
            if (isColMax) {
                result[*returnSize] = malloc(2 * sizeof(int));
                result[*returnSize][0] = i;
                result[*returnSize][1] = j;
                (*returnColumnSizes)[*returnSize] = 2;
                (*returnSize)++;
            }
        }
    }
    
    return result;
}

int main() {
    // Simplified input parsing for demo
    int matrix[3][3] = {{1, 7, 3}, {9, 11, 5}, {4, 3, 2}};
    int* mat[3] = {matrix[0], matrix[1], matrix[2]};
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(mat, 3, 3, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[%d,%d]", result[i][0], result[i][1]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n×(m+n))

For each of m×n elements, we scan m elements in row and n elements in column

✓ Linear Growth

Space Complexity

O(1)

Only using variables for iteration, no extra data structures

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

842 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

Saddle Point Finder - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler