Find a Good Subset of the Matrix - Practice Coding Problems

Find a Good Subset of the Matrix - Problem

Matrix Row Selection Challenge

You're given a binary matrix and need to find a "good" subset of rows. But what makes a subset "good"?

A subset is considered good when each column's sum is at most half the number of selected rows. More formally, if you select k rows, then every column should have at most ⌊k/2⌋ ones.

Goal: Return the indices of any good subset of rows in ascending order, or an empty array if no good subset exists.

Example: If you select 3 rows, each column can have at most 1 one (since ⌊3/2⌋ = 1).

Input & Output

example_1.py — Basic Case

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

› Output: [0,1]

💡 Note: Rows 0 and 1 form a good subset of size 2. Each column sum is at most ⌊2/2⌋ = 1: Column 0: 0+0=0, Column 1: 1+0=1, Column 2: 1+0=1, Column 3: 0+1=1.

example_2.py — All Zeros Row

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

› Output: [0]

💡 Note: Row 0 is all zeros, forming a good subset of size 1. Each column sum is 0 ≤ ⌊1/2⌋ = 0.

example_3.py — No Good Subset

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

› Output: []

💡 Note: No good subset exists. Any single row has column sums > 0, and both rows together have column sums = 2 > ⌊2/2⌋ = 1.

Constraints

m == grid.length
n == grid[0].length
1 ≤ m, n ≤ 10⁴
1 ≤ m × n ≤ 10⁵
grid[i][j] is either 0 or 1

Visualization

Tap to expand

Understanding the Visualization

Convert to Bitmasks

Each row becomes a binary number representing skill sets

Find Zero Row

A person with no skills forms a valid team of size 1

Find Complementary Pair

Two people with completely different skills form a balanced team

Key Takeaway

🎯 Key Insight: Mathematical properties allow us to solve this efficiently by only checking subsets of size 1 and 2, avoiding exponential complexity.

Asked in

G Google 45 ⊞ Microsoft 32 a Amazon 28 f Meta 21

The optimal solution uses bit manipulation and the key mathematical insight that if a good subset exists, there's always one of size ≤ 2. We check for rows of all zeros (size 1) or pairs of rows with no overlapping 1s (size 2), achieving O(m×n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subsets)	O(2^m × n)	O(1)	Generate all possible subsets and check each one for the good property
Bit Manipulation with Hash Map (Optimal)	O(m × n)	O(m)	Use bit representation of rows and mathematical insights to find good subsets efficiently

Brute Force (Check All Subsets) — Algorithm Steps

Generate all possible non-empty subsets of row indices using bit manipulation
For each subset, calculate the size k
For each column, sum the values in the selected rows
Check if all column sums are ≤ floor(k/2)
Return the first valid subset found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Use binary representation to generate all possible row combinations

Check Columns

For each subset, verify that every column sum ≤ ⌊k/2⌋

Return First Valid

Return the first subset that satisfies the good property

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

O(2^m × n)

We check 2^m subsets, and for each subset we need O(n) time to validate all columns

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

26.8K Views

Medium Frequency

~25 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Subsets) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler