Lucky Numbers in a Matrix

Lucky Numbers in a Matrix - Problem

Array Matrix Easy

Given an m x n matrix of distinct numbers, return all lucky numbers in the matrix in any order.

A lucky number is an element of the matrix such that it is the minimum element in its row and maximum in its column.

Input & Output

Example 1 — Basic Case with Lucky Number

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

› Output: [15]

💡 Note: 15 is the minimum in row 2 [15,16,17] and maximum in column 0 [3,9,15], making it a lucky number

Example 2 — No Lucky Numbers

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

› Output: []

💡 Note: No element satisfies both conditions: being minimum in its row AND maximum in its column

Example 3 — Single Element Matrix

$ Input: matrix = [[7]]

› Output: [7]

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

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

Asked in

a Amazon 25 M Microsoft 18

The key insight is that a lucky number must simultaneously be the minimum in its row AND maximum in its column. The optimal approach precomputes row minimums and column maximums in O(mn) time, then finds intersections. Time: O(mn), Space: O(m+n).

Common Approaches

✓ Brute Force - Check Every Element

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

Iterate through every matrix element and for each one, scan its entire row to confirm it's the minimum, then scan its entire column to confirm it's the maximum. Add to result if both conditions are met.

Optimized - Precompute Row Min & Column Max

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

First pass computes the minimum element in each row and maximum element in each column. Second pass checks if any element equals both its row minimum and column maximum simultaneously.

Brute Force - Check Every Element — Algorithm Steps

Iterate through each matrix element
For each element, scan its row to check if it's minimum
Scan its column to check if it's maximum
Add to result if both conditions are true

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Element

Pick current element to test

Check Row

Scan entire row to verify it's minimum

Check Column

Scan entire column to verify it's maximum

Code -

solution.c — C

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

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

int main() {
    // For simplicity, assuming input format and parsing
    // In real implementation, would need proper JSON parsing
    int matrixSize = 3;
    int matrixColSize[] = {4, 4, 4};
    int** matrix = (int**)malloc(matrixSize * sizeof(int*));
    
    // Example input parsing would go here
    // This is a simplified version for the template
    
    int returnSize;
    int* result = solution(matrix, matrixSize, matrixColSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

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

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for iteration, no extra data structures

✓ 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check Every Element — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler