Maximum Rows Covered by Columns

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 matrix such that you cover as many rows as possible.

A row is considered covered if all the 1's in that row are also part of a column that you have selected. If a row does not have any 1s, it is also considered covered.

More formally, let us consider selected = {c1, c2, ...., cnumSelect} as the set of columns selected by you. A row i is covered by selected if:

For each cell where matrix[i][j] == 1, the column j is in selected.
Or, no cell in row i has a value of 1.

Return the maximum number of rows that can be covered by a set of numSelect columns.

Input & Output

Example 1 — Basic Coverage

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

› Output: 2

💡 Note: Select columns [0,2]: Row 0 has no 1s (covered), Row 1 has 1s at positions 0,2 which are both selected (covered). Total: 2 rows.

Example 2 — Partial Coverage

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

› Output: 2

💡 Note: Select column [0]: Row 0 has 1 at position 0 (covered), Row 1 has no 1s (covered). Both rows covered.

Example 3 — Impossible Full Coverage

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

› Output: 1

💡 Note: Can only select 1 column. Either column covers exactly 1 row, so maximum is 1.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8 a Amazon 6 f Meta 4

The key insight is to recognize this as a combinatorial optimization problem where we need to find the optimal subset of columns. The bit manipulation approach provides the most efficient solution by converting rows to bitmasks for O(1) coverage checking. Best approach: Bit Manipulation - Time: O(2ⁿ × m), Space: O(m)

Common Approaches

✓ Backtracking with Pruning

⏱️ Time: O(2^n) Space: O(n)

This approach uses backtracking to systematically explore column combinations, but adds pruning to avoid exploring branches that cannot possibly lead to a better solution than the current best.

Bit Manipulation Optimization

⏱️ Time: O(C(n,k) × m) Space: O(m)

This approach converts each matrix row into a bitmask representing which columns contain 1s. Then uses bitwise operations to quickly check if a column selection covers each row, making the coverage check much more efficient.

Brute Force - Try All Combinations

⏱️ Time: O(C(n,k) × m × n) Space: O(k)

This approach systematically tries every possible way to select numSelect columns from all available columns. For each combination, it checks how many rows are completely covered by the selected columns.

Backtracking with Pruning — Algorithm Steps

Step 1: Start backtracking from first column with empty selection
Step 2: At each step, try including or excluding current column
Step 3: Prune branches that cannot beat current maximum
Step 4: When selection is complete, count covered rows and update maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Recursion

Begin with empty column selection

Branch & Prune

Include/exclude columns, prune impossible paths

Track Maximum

Update best coverage found so far

Code -

solution.c — C

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

int maxCovered = 0;

int countCovered(int** matrix, int m, int n, int* selected, int selectedSize) {
    int covered = 0;
    int colSet[20] = {0}; // Assuming max 20 columns
    
    for (int i = 0; i < selectedSize; i++) {
        colSet[selected[i]] = 1;
    }
    
    for (int i = 0; i < m; i++) {
        int isCovered = 1;
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] == 1 && !colSet[j]) {
                isCovered = 0;
                break;
            }
        }
        if (isCovered) covered++;
    }
    
    return covered;
}

void backtrack(int** matrix, int m, int n, int colIdx, int* selected, int selectedSize, int numSelect) {
    if (selectedSize == numSelect) {
        int covered = countCovered(matrix, m, n, selected, selectedSize);
        if (covered > maxCovered) {
            maxCovered = covered;
        }
        return;
    }
    
    if (colIdx >= n || selectedSize + (n - colIdx) < numSelect) {
        return; // Pruning
    }
    
    // Include current column
    selected[selectedSize] = colIdx;
    backtrack(matrix, m, n, colIdx + 1, selected, selectedSize + 1, numSelect);
    
    // Exclude current column
    backtrack(matrix, m, n, colIdx + 1, selected, selectedSize, numSelect);
}

int solution(int** matrix, int m, int n, int numSelect) {
    maxCovered = 0;
    int selected[20]; // Assuming max 20 columns
    backtrack(matrix, m, n, 0, selected, 0, numSelect);
    return maxCovered;
}

void parseMatrix(char* line, int*** matrix, int* m, int* n) {
    // Simple parsing for format like [[0,0,0],[1,0,1]]
    *m = 0;
    *n = 0;
    
    // Count rows and columns
    int rowCount = 0;
    for (int i = 0; line[i]; i++) {
        if (line[i] == '[' && i > 0) rowCount++;
    }
    
    // Count columns in first row
    int colCount = 0;
    int inFirstRow = 0;
    for (int i = 0; line[i]; i++) {
        if (line[i] == '[' && !inFirstRow) {
            inFirstRow = 1;
        } else if (inFirstRow && (line[i] == '0' || line[i] == '1')) {
            colCount++;
        } else if (inFirstRow && line[i] == ']') {
            break;
        }
    }
    
    *m = rowCount;
    *n = colCount;
    
    // Allocate matrix
    *matrix = (int**)malloc(*m * sizeof(int*));
    for (int i = 0; i < *m; i++) {
        (*matrix)[i] = (int*)malloc(*n * sizeof(int));
    }
    
    // Parse values
    int row = 0, col = 0;
    int inRow = 0;
    for (int i = 0; line[i] && row < *m; i++) {
        if (line[i] == '[') {
            inRow = 1;
            col = 0;
        } else if (line[i] == ']') {
            if (inRow) {
                row++;
                inRow = 0;
            }
        } else if (inRow && (line[i] == '0' || line[i] == '1') && col < *n) {
            (*matrix)[row][col] = line[i] - '0';
            col++;
        }
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int** matrix;
    int m, n;
    parseMatrix(line, &matrix, &m, &n);
    
    int numSelect;
    scanf("%d", &numSelect);
    
    printf("%d\n", solution(matrix, m, n, numSelect));
    
    // Cleanup
    for (int i = 0; i < m; i++) {
        free(matrix[i]);
    }
    free(matrix);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case explores all subsets, but pruning reduces actual complexity

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth up to n levels plus selection tracking

✓ Linear Space

12.0K Views

Medium Frequency

~25 min Avg. Time

285 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

Backtracking with Pruning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler