Check if Every Row and Column Contains All Numbers

Check if Every Row and Column Contains All Numbers - Problem

Think of this as a magic square validation problem! You're given an n × n matrix and need to determine if it's a valid complete matrix.

A matrix is considered valid if:

Every row contains all integers from 1 to n (inclusive)
Every column contains all integers from 1 to n (inclusive)

For example, in a 3×3 matrix, each row and column must contain exactly the numbers [1, 2, 3] in any order.

Goal: Return true if the matrix is valid, false otherwise.

Input & Output

example_1.py — Valid 3×3 Matrix

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

› Output: true

💡 Note: Each row contains [1,2,3] in some order, and each column also contains [1,2,3] in some order. Row 0: {1,2,3}, Row 1: {3,1,2}, Row 2: {2,3,1}. Column 0: {1,3,2}, Column 1: {2,1,3}, Column 2: {3,2,1}.

example_2.py — Invalid Matrix (Missing Numbers)

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

› Output: false

💡 Note: The first row contains [1,1,1] which has duplicates and is missing 2 and 3. Even though other rows might be valid, all rows must contain exactly the numbers 1 to n.

example_3.py — Single Element Matrix

$ Input: matrix = [[1]]

› Output: true

💡 Note: A 1×1 matrix with the single element 1 is valid since both the row and column contain exactly the numbers from 1 to 1.

Visualization

Tap to expand

Understanding the Visualization

Initialize Tracking

Create empty sets to track numbers seen in each row and column

Single Pass Collection

Traverse matrix once, adding each element to its row and column sets

Validation Check

Verify each row and column set contains exactly numbers 1 to n

Key Takeaway

🎯 Key Insight: We can validate both row and column constraints simultaneously during a single traversal, making the solution both time and space efficient while maintaining clarity.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Single pass through n×n matrix, O(1) set operations for each element

⚠ Quadratic Growth

Space Complexity

O(n²)

O(n) space for each of the n rows and n columns sets

⚠ Quadratic Space

Constraints

n == matrix.length == matrix[i].length
1 ≤ n ≤ 100
1 ≤ matrix[i][j] ≤ n

Asked in

G Google 15 a Amazon 8 ⊞ Microsoft 12 f Meta 6

The optimal approach uses a one-pass hash table solution with O(n²) time complexity. We create sets for each row and column, then traverse the matrix once to populate these sets. Finally, we validate that each set contains exactly the numbers 1 to n. This is more efficient than the brute force approach that makes separate passes for rows and columns.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Validation)	O(n³)	O(n)	Check each row and column separately using nested loops
One-Pass Hash Table (Optimal)	O(n²)	O(n²)	Validate all rows and columns simultaneously in a single matrix traversal

Brute Force (Nested Validation) — Algorithm Steps

For each row, create a set and add all elements
Check if the set contains exactly numbers 1 to n
Repeat the same process for each column
Return false if any row or column fails validation

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Row 1

Validate first row contains all numbers 1 to n

Check All Rows

Continue checking remaining rows

Check Column 1

Start validating columns after all rows pass

Check All Columns

Complete column validation

Code -

solution.c — C

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

bool validMatrix(int matrix[][100], int n) {
    // Check all rows
    for (int i = 0; i < n; i++) {
        bool seen[101] = {false};
        int count = 0;
        for (int j = 0; j < n; j++) {
            if (!seen[matrix[i][j]]) {
                seen[matrix[i][j]] = true;
                count++;
            }
        }
        if (count != n) return false;
        for (int k = 1; k <= n; k++) {
            if (!seen[k]) return false;
        }
    }
    
    // Check all columns
    for (int j = 0; j < n; j++) {
        bool seen[101] = {false};
        int count = 0;
        for (int i = 0; i < n; i++) {
            if (!seen[matrix[i][j]]) {
                seen[matrix[i][j]] = true;
                count++;
            }
        }
        if (count != n) return false;
        for (int k = 1; k <= n; k++) {
            if (!seen[k]) return false;
        }
    }
    
    return true;
}

int main() {
    int matrix[100][100] = {{1,2,3},{3,1,2},{2,3,1}};
    int n = 3;
    printf("%s\n", validMatrix(matrix, n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) to iterate through matrix, O(n) to validate each row/column, done twice

⚠ Quadratic Growth

Space Complexity

O(n)

O(n) space for sets to track numbers in each row/column

⚡ Linearithmic Space

Constraints

n == matrix.length == matrix[i].length
1 ≤ n ≤ 100
1 ≤ matrix[i][j] ≤ n

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Validation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler