Find a Good Subset of the Matrix - Problem

You are given a 0-indexed m x n binary matrix grid.

Let us call a non-empty subset of rows good if the sum of each column of the subset is at most half of the length of the subset.

More formally, if the length of the chosen subset of rows is k, then the sum of each column should be at most floor(k / 2).

Return an integer array that contains row indices of a good subset sorted in ascending order.

If there are multiple good subsets, you can return any of them. If there are no good subsets, return an empty array.

A subset of rows of the matrix grid is any matrix that can be obtained by deleting some (possibly none or all) rows from grid.

Input & Output

Example 1 — Basic 2x2 Matrix

$ Input: grid = [[0,1],[1,0]]

› Output: [0,1]

💡 Note: Both rows form a good subset: column sums are [1,1], subset size k=2, so floor(2/2)=1. Since 1≤1 for both columns, this is valid.

Example 2 — Single Row Valid

$ Input: grid = [[1,1,1]]

› Output: [0]

💡 Note: Single row subset: column sums are [1,1,1], k=1, so floor(1/2)=0. Since all columns have sum 1 > 0, we need a different subset or return empty.

Example 3 — No Valid Subset

$ Input: grid = [[1,1],[1,1]]

› Output: []

💡 Note: Any non-empty subset will have column sums that exceed floor(k/2). For k=1: need ≤0, but get 1. For k=2: need ≤1, but get 2.

Constraints

1 ≤ m, n ≤ 12
grid[i][j] is either 0 or 1

Visualization

Tap to expand

Asked in

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

The key insight is that we need to find a subset of rows where each column sum is at most floor(k/2). The brute force approach tries all 2^m possible subsets, while bit manipulation optimizes the subset generation. For practical cases, a greedy approach can find solutions faster. Best approach depends on matrix size: O(2^m × n) for complete search, O(m² × n) for greedy heuristic.

Common Approaches

✓ Brute Force - Try All Subsets

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

For each possible subset of rows, calculate the sum of each column and verify if all column sums are ≤ floor(k/2) where k is the subset size. Return the first valid subset found.

Greedy Row Selection

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

Start with single rows and try to greedily add more rows while maintaining the constraint. This heuristic approach may miss optimal solutions but can find valid subsets faster for practical cases.

Optimized Bit Manipulation

⏱️ Time: O(2^m × n) Space: O(1)

Represent each row as a bit pattern and use bitwise operations to quickly calculate column sums. This reduces constant factors but maintains the same exponential complexity.

Brute Force - Try All Subsets — Algorithm Steps

Generate all possible non-empty subsets of row indices
For each subset, calculate column sums
Check if all column sums ≤ floor(subset_size/2)
Return first valid subset found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all possible row combinations

Check Each Subset

Calculate column sums for each combination

Validate

Check if all column sums ≤ floor(k/2)

Code -

solution.c — C

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

void solution(int** grid, int m, int n, int* result, int* resultSize) {
    *resultSize = 0;
    
    // Try starting with each row and build greedily
    for (int start = 0; start < m; start++) {
        int subset[100];
        int subsetSize = 1;
        subset[0] = start;
        
        // Try to add more rows greedily
        for (int candidate = 0; candidate < m; candidate++) {
            if (candidate == start) {
                continue;
            }
            
            // Check if adding this candidate maintains the constraint
            int testSubset[100];
            int testSize = subsetSize;
            for (int i = 0; i < subsetSize; i++) {
                testSubset[i] = subset[i];
            }
            testSubset[testSize] = candidate;
            testSize++;
            
            int k = testSize;
            int maxColSum = k / 2;
            
            int isValid = 1;
            for (int j = 0; j < n && isValid; j++) {
                int colSum = 0;
                for (int idx = 0; idx < testSize; idx++) {
                    colSum += grid[testSubset[idx]][j];
                }
                if (colSum > maxColSum) {
                    isValid = 0;
                }
            }
            
            if (isValid) {
                subset[subsetSize] = candidate;
                subsetSize++;
            }
        }
        
        // Check if current subset is valid and non-empty
        if (subsetSize > 0) {
            int k = subsetSize;
            int maxColSum = k / 2;
            int isGood = 1;
            
            for (int j = 0; j < n && isGood; j++) {
                int colSum = 0;
                for (int idx = 0; idx < subsetSize; idx++) {
                    colSum += grid[subset[idx]][j];
                }
                if (colSum > maxColSum) {
                    isGood = 0;
                }
            }
            
            if (isGood) {
                // Sort subset
                for (int i = 0; i < subsetSize - 1; i++) {
                    for (int j = i + 1; j < subsetSize; j++) {
                        if (subset[i] > subset[j]) {
                            int temp = subset[i];
                            subset[i] = subset[j];
                            subset[j] = temp;
                        }
                    }
                }
                
                for (int i = 0; i < subsetSize; i++) {
                    result[i] = subset[i];
                }
                *resultSize = subsetSize;
                return;
            }
        }
    }
}

int parseGrid(char* line, int grid[100][100], int* m, int* n) {
    int len = strlen(line);
    if (len < 3) return 0;
    
    // Remove outer brackets and newline
    line[len-1] = '\0';
    if (line[len-2] == '\n') line[len-2] = '\0';
    
    *m = 0;
    *n = 0;
    
    int i = 1; // skip first '['
    while (i < len-1) {
        if (line[i] == '[') {
            i++; // skip '['
            int col = 0;
            while (i < len-1 && line[i] != ']') {
                if (line[i] >= '0' && line[i] <= '9') {
                    grid[*m][col] = line[i] - '0';
                    col++;
                } else if (line[i] == ',') {
                    // skip comma
                }
                i++;
            }
            if (*n == 0) *n = col;
            (*m)++;
        }
        i++;
    }
    
    return 1;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    static int grid[100][100];
    int m, n;
    
    if (!parseGrid(line, grid, &m, &n)) {
        printf("[]\n");
        return 0;
    }
    
    int* gridPtrs[100];
    for (int i = 0; i < m; i++) {
        gridPtrs[i] = grid[i];
    }
    
    int result[100];
    int resultSize;
    solution(gridPtrs, m, n, result, &resultSize);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^m × n)

2^m possible subsets, each requiring O(n) column sum calculations

✓ Linear Growth

Space Complexity

O(m)

Storage for current subset being tested

✓ Linear Space

12.5K Views

Medium Frequency

~35 min Avg. Time

234 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

Find a Good Subset of the Matrix - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Subsets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler