Lucky Numbers in a Matrix - Practice Coding Problems

Lucky Numbers in a Matrix - Problem

Array Matrix Easy

Given an m × n matrix of distinct numbers, your task is to find all the "lucky numbers" in the matrix.

A lucky number is a special element that satisfies both conditions:

It is the minimum element in its row
It is the maximum element in its column

Think of it as finding the "sweet spot" - numbers that are simultaneously the smallest in their horizontal neighborhood and the largest in their vertical neighborhood!

Example:

Matrix: [[3,7,8],
         [9,11,13],
         [15,16,17]]

Lucky number: 15
- 15 is minimum in row [15,16,17]
- 15 is maximum in column [3,9,15]

Return all lucky numbers in any order.

Input & Output

example_1.py — Basic 3x3 Matrix

$ Input: matrix = [[3,7,8],[9,11,13],[15,16,17]]

› Output: [15]

💡 Note: 15 is the minimum in its row [15,16,17] and maximum in its column [3,9,15], making it the only lucky number.

example_2.py — 4x4 Matrix with Single Lucky Number

$ Input: matrix = [[1,10,4,2],[9,3,8,7],[15,16,17,12]]

› Output: [12]

💡 Note: 12 is minimum in its row [15,16,17,12] and maximum in its column [2,7,12].

example_3.py — No Lucky Numbers

$ Input: matrix = [[7,8],[1,2]]

› Output: []

💡 Note: No element satisfies both conditions. 1 is row minimum but not column maximum, 7 is column maximum but not row minimum.

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ n, m ≤ 50
1 ≤ matrix[i][j] ≤ 10⁵
All elements in the matrix are distinct

Visualization

Tap to expand

Understanding the Visualization

Identify the Challenge

We need elements that are minimum in their row AND maximum in their column

Brute Force Reality

Checking each element requires scanning entire rows and columns repeatedly

The Optimization

Pre-compute all row minimums and column maximums once

Smart Comparison

Each element only needs two comparisons instead of m+n comparisons

Key Takeaway

🎯 Key Insight: The two-pass optimization reduces time complexity from O(m²n²) to O(mn) by eliminating redundant row and column scans. Since all elements are distinct, there can be at most one lucky number in the entire matrix.

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal approach uses two-pass optimization: first pass computes row minimums and column maximums in O(mn) time, second pass checks each element against these precomputed values. This avoids the O(m²n²) repeated scanning of the brute force approach while using only O(m+n) extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Optimization	O(mn)	O(m + n)	Pre-compute row minimums and column maximums, then find intersection
Brute Force (Check Each Element)	O(m²n²)	O(1)	For each element, verify if it's both row minimum and column maximum

Two-Pass Optimization — Algorithm Steps

First pass: compute minimum value for each row
First pass: compute maximum value for each column
Second pass: iterate through matrix elements
Check if element equals both its row minimum and column maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Compute Row Minimums

Row 0: min(3,7,8) = 3, Row 1: min(9,11,13) = 9, Row 2: min(15,16,17) = 15

Compute Column Maximums

Col 0: max(3,9,15) = 15, Col 1: max(7,11,16) = 16, Col 2: max(8,13,17) = 17

Check Each Element

Compare matrix[i][j] with rowMins[i] and colMaxs[j]

Find Match

matrix[2][0] = 15 equals rowMins[2] = 15 and colMaxs[0] = 15

Code -

solution.c — C

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

int* luckyNumbers(int** matrix, int matrixSize, int* matrixColSize, int* returnSize) {
    int m = matrixSize, n = matrixColSize[0];
    int* result = (int*)malloc(m * n * sizeof(int));
    *returnSize = 0;
    
    // First pass: compute row minimums
    int* rowMins = (int*)malloc(m * sizeof(int));
    for (int i = 0; i < m; i++) {
        rowMins[i] = INT_MAX;
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] < rowMins[i]) {
                rowMins[i] = matrix[i][j];
            }
        }
    }
    
    // First pass: compute column maximums
    int* colMaxs = (int*)malloc(n * sizeof(int));
    for (int j = 0; j < n; j++) {
        colMaxs[j] = INT_MIN;
        for (int i = 0; i < m; i++) {
            if (matrix[i][j] > colMaxs[j]) {
                colMaxs[j] = matrix[i][j];
            }
        }
    }
    
    // Second pass: find lucky numbers
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] == rowMins[i] && matrix[i][j] == colMaxs[j]) {
                result[(*returnSize)++] = matrix[i][j];
            }
        }
    }
    
    free(rowMins);
    free(colMaxs);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn)

First pass O(mn) to compute mins/maxs, second pass O(mn) to check elements

✓ Linear Growth

Space Complexity

O(m + n)

Arrays to store m row minimums and n column maximums

⚡ Linearithmic Space

34.6K Views

Medium Frequency

~15 min Avg. Time

980 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

Two-Pass Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler