Find Smallest Common Element in All Rows - Practice Coding Problems

Find Smallest Common Element in All Rows - Problem

You're given an m x n matrix where each row is sorted in strictly increasing order. Your task is to find the smallest element that appears in every single row of the matrix.

Think of it like finding a common favorite among different groups - you need an element that shows up in all rows, and if there are multiple such elements, you want the smallest one.

Example: If you have a matrix like [[1,2,3,4],[2,3,4,5],[3,4,5,6]], the elements that appear in all rows are [3,4], so you should return 3 since it's the smallest.

If no element appears in all rows, return -1.

The key insight here is leveraging the fact that each row is already sorted - this gives us multiple optimization opportunities!

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: Elements that appear in all rows: [3,4]. The smallest is 3.

example_2.py — No Common Elements

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

› Output: -1

💡 Note: No element appears in all three rows, so return -1.

example_3.py — Single Common Element

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

› Output: 2

💡 Note: Elements 2, 3, and 4 appear in all rows. The smallest is 2.

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 1000
1 ≤ mat[i][j] ≤ 10⁴
Each row is sorted in strictly increasing order

Visualization

Tap to expand

Understanding the Visualization

Start with first catalog

Since it's sorted by price, checking in order guarantees we find the cheapest first

Search other catalogs efficiently

Use the sorted nature - binary search instead of scanning every book

Return first match

The first book found in all catalogs is guaranteed to be the cheapest

Key Takeaway

🎯 Key Insight: Use the sorted property of each row! Binary search reduces lookup time from O(n) to O(log n), making the overall solution much more efficient.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses binary search to leverage the sorted property of each row. Instead of linearly scanning each row (O(n) per row), we can binary search for elements from the first row in O(log n) time. This gives us O(m × n × log n) complexity, which is much better than the brute force O(m × n²) approach. The hash table counting approach is also viable with O(m × n) complexity but uses extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Element)	O(m × n²)	O(1)	Check each element in first row against all other rows
Binary Search Optimization	O(m × n × log n)	O(1)	Use binary search to check if elements from first row exist in other rows
Hash Table with Row Counting	O(m × n)	O(k)	Count occurrences of each element across all rows

Brute Force (Check Every Element) — Algorithm Steps

Iterate through each element in the first row (sorted order ensures we find smallest first)
For each element, check if it exists in all other rows by scanning each row
Return the first element found in all rows, or -1 if none exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Take first element from sorted first row

Check all rows

Scan through every element in every other row

Move to next element

If not found in all rows, try next element from first row

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

int smallestCommonElement(int** mat, int matSize, int* matColSize) {
    if (matSize == 0 || matColSize[0] == 0) return -1;
    
    int m = matSize, n = matColSize[0];
    
    // Check each element in first row
    for (int i = 0; i < n; i++) {
        int element = mat[0][i];
        bool foundInAll = true;
        
        // Check if this element exists in all other rows
        for (int row = 1; row < m; row++) {
            bool found = false;
            for (int col = 0; col < matColSize[row]; col++) {
                if (mat[row][col] == element) {
                    found = true;
                    break;
                }
            }
            if (!found) {
                foundInAll = false;
                break;
            }
        }
        
        if (foundInAll) return element;
    }
    
    return -1;
}

int main() {
    // Example usage
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n²)

For each of n elements in first row, we scan all n elements in each of m-1 other rows

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for iteration, no additional data structures

✓ Linear Space

42.8K Views

Medium Frequency

~15 min Avg. Time

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