Maximum Rows Covered by Columns - Practice Coding Problems

Maximum Rows Covered by Columns - Problem

You are given an m x n binary matrix matrix and an integer numSelect.

Your goal is to select exactly numSelect distinct columns from the matrix such that you cover as many rows as possible.

A row is considered covered if:

All the 1's in that row are in columns that you have selected, OR
The row contains no 1's at all (empty rows are always covered)

For example, if a row is [0, 1, 0, 1, 0] and you select columns {1, 3}, this row is covered because all its 1's are in your selected columns.

Return the maximum number of rows that can be covered by selecting exactly numSelect columns.

Input & Output

example_1.py — Basic Case

$ Input: matrix = [[0,0,0],[1,0,1],[0,1,1],[0,0,1]], numSelect = 2

› Output: 3

💡 Note: Selecting columns 1 and 2 covers 3 rows: Row 0 (no 1's), Row 2 (1's in cols 1,2), and Row 3 (1 in col 2). Row 1 has 1's in cols 0,2 but we didn't select col 0, so it's not covered.

example_2.py — All Rows Covered

$ Input: matrix = [[1],[0],[0]], numSelect = 1

› Output: 3

💡 Note: Selecting column 0 covers all 3 rows: Row 0 (1 in selected col 0), Row 1 (no 1's), Row 2 (no 1's). All rows without 1's are automatically covered.

example_3.py — Optimal Selection

$ Input: matrix = [[1,0,0,0,0,1,1,0],[1,0,0,0,0,0,1,1],[1,0,0,0,0,0,1,1]], numSelect = 4

› Output: 3

💡 Note: We can select columns {0,5,6,7} to cover all 3 rows. Row 0 needs cols 0,5,6. Rows 1,2 need cols 0,6,7. Selecting all four covers everything.

Visualization

Tap to expand

Understanding the Visualization

Analyze Floor Plans

Each row represents a floor layout with important areas marked as 1's

Budget Constraint

You must install exactly numSelect cameras in different positions (columns)

Coverage Rule

A floor is secure only if ALL its important areas are monitored by your cameras

Optimization Goal

Find camera placement that secures the maximum number of floors

Key Takeaway

🎯 Key Insight: This is a combinatorial optimization problem where we must exhaustively try different combinations to find the optimal solution, but bit manipulation can significantly speed up the coverage checking process.

Time & Space Complexity

Time Complexity

⏱️

O(C(n, numSelect) * m * n)

C(n, numSelect) combinations, each taking O(m * n) to evaluate all rows and columns

✓ Linear Growth

Space Complexity

O(numSelect)

Space to store current combination of selected columns

⚡ Linearithmic Space

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 12
matrix[i][j] is either 0 or 1
1 ≤ numSelect ≤ n

Asked in

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

This problem requires finding the optimal combination of numSelect columns that covers the maximum number of rows. The key insight is to use bit manipulation to represent row patterns efficiently, where each row becomes a bitmask indicating positions of 1's. The optimal approach generates all possible column combinations and uses bitwise operations (row_mask & col_mask) == row_mask to quickly check if a row is covered by selected columns.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(C(n, numSelect) * m * n)	O(numSelect)	Generate all possible combinations of numSelect columns and check coverage for each
Optimized Bit Manipulation	O(C(n, numSelect) * m)	O(m)	Use bit manipulation to efficiently represent and check row patterns

Brute Force (Try All Combinations) — Algorithm Steps

Generate all combinations of numSelect columns from total columns
For each combination, iterate through all rows
For each row, check if all 1's are in selected columns
Count covered rows for this combination
Keep track of maximum covered rows across all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible ways to select numSelect columns

Check Each Combination

For each combination, verify which rows are fully covered

Count Coverage

Count how many rows each combination covers

Find Maximum

Return the combination that covers the most rows

Code -

solution.c — C

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

int popcount(int x) {
    int count = 0;
    while (x) {
        count += x & 1;
        x >>= 1;
    }
    return count;
}

int maximumRows(int** matrix, int matrixSize, int* matrixColSize, int numSelect) {
    int m = matrixSize, n = matrixColSize[0];
    int maxCovered = 0;
    
    // Generate all combinations using bit manipulation
    for (int mask = 0; mask < (1 << n); mask++) {
        if (popcount(mask) == numSelect) {
            int coveredRows = 0;
            
            for (int i = 0; i < m; i++) {
                int isCovered = 1;
                for (int j = 0; j < n; j++) {
                    if (matrix[i][j] == 1 && !(mask & (1 << j))) {
                        isCovered = 0;
                        break;
                    }
                }
                if (isCovered) coveredRows++;
            }
            
            if (coveredRows > maxCovered) {
                maxCovered = coveredRows;
            }
        }
    }
    
    return maxCovered;
}

int main() {
    int matrix[][3] = {{0,0,0},{1,0,1},{0,1,1},{0,0,1}};
    int* matrixPtr[4];
    int matrixColSize[4] = {3,3,3,3};
    
    for (int i = 0; i < 4; i++) {
        matrixPtr[i] = matrix[i];
    }
    
    printf("%d\n", maximumRows(matrixPtr, 4, matrixColSize, 2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n, numSelect) * m * n)

C(n, numSelect) combinations, each taking O(m * n) to evaluate all rows and columns

✓ Linear Growth

Space Complexity

O(numSelect)

Space to store current combination of selected columns

⚡ Linearithmic Space

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 12
matrix[i][j] is either 0 or 1
1 ≤ numSelect ≤ n

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler