Flip Columns For Maximum Number of Equal Rows

Flip Columns For Maximum Number of Equal Rows - Problem

Imagine you have a binary matrix (containing only 0s and 1s) and you possess a magical power: you can flip entire columns at will! When you flip a column, every 0 becomes a 1 and every 1 becomes a 0 in that column.

Your goal is to strategically choose which columns to flip so that you maximize the number of rows that become uniform (all 0s or all 1s). Think of it as organizing a binary pattern to create the most harmony possible!

Input: An m × n binary matrix
Output: The maximum number of rows that can be made uniform after optimally flipping columns

Example: If you have matrix [[0,1],[1,1]], you can flip column 0 to get [[1,1],[0,1]], making the first row uniform. The answer would be 1.

Input & Output

example_1.py — Basic Matrix

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

› Output: 1

💡 Note: After flipping column 0, we get [[1,1],[0,1]]. The first row becomes uniform (all 1s), so the answer is 1.

example_2.py — Larger Matrix

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

› Output: 2

💡 Note: Rows [0,1,0] and [1,0,1] are complements of each other. By flipping appropriate columns, both can be made uniform, giving us 2 equal rows.

example_3.py — All Same Pattern

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

› Output: 3

💡 Note: All rows are already uniform (all 0s), so we don't need to flip any columns. The answer is 3.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Identify Patterns

Each row has a binary pattern, like a unique fingerprint

Find Complements

For each pattern, create its opposite (0→1, 1→0)

Group Compatible Rows

Rows that are complements of each other can become identical after column flips

Count Maximum Group

The largest group represents the maximum achievable uniform rows

Key Takeaway

🎯 Key Insight: Rows that are binary complements of each other can always be made identical by choosing the right column flips. We group compatible rows and find the largest group.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 f Meta 8

The optimal solution uses pattern grouping with a hash table. Key insight: two rows can be made identical if one is the complement of the other. We create a canonical pattern for each row (the lexicographically smaller of the row and its complement) and count occurrences. The maximum count gives us the answer in O(m×n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Column Combinations)	O(2^n × m × n)	O(m × n)	Try every possible combination of column flips and count uniform rows
One-Pass Hash Table (Optimal)	O(m × n)	O(m × n)	Group rows by their canonical pattern in a single pass

Brute Force (Try All Column Combinations) — Algorithm Steps

Generate all possible column flip combinations using bit manipulation
For each combination, create a copy of the matrix
Apply the column flips to the matrix copy
Count how many rows are uniform (all 0s or all 1s)
Track the maximum count across all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Matrix

Start with the given binary matrix

Generate Combinations

Create all possible column flip combinations using bit masks

Apply Flips

For each combination, flip the selected columns

Count Uniform Rows

Count rows that are all 0s or all 1s

Track Maximum

Keep track of the highest count found

Code -

solution.c — C

int maxEqualRowsAfterFlips(int** matrix, int matrixSize, int* matrixColSize) {
    int m = matrixSize, n = matrixColSize[0];
    int maxEqual = 0;
    
    // Try all 2^n possible column flip combinations
    for (int mask = 0; mask < (1 << n); mask++) {
        // Create a copy of the matrix
        int temp[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                temp[i][j] = matrix[i][j];
            }
        }
        
        // Apply column flips based on the mask
        for (int col = 0; col < n; col++) {
            if (mask & (1 << col)) {
                for (int row = 0; row < m; row++) {
                    temp[row][col] = 1 - temp[row][col];
                }
            }
        }
        
        // Count uniform rows
        int uniformCount = 0;
        for (int i = 0; i < m; i++) {
            int uniform = 1;
            for (int j = 1; j < n; j++) {
                if (temp[i][j] != temp[i][0]) {
                    uniform = 0;
                    break;
                }
            }
            if (uniform) uniformCount++;
        }
        
        if (uniformCount > maxEqual) {
            maxEqual = uniformCount;
        }
    }
    
    return maxEqual;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × m × n)

2^n combinations, each requiring O(m×n) time to process the matrix

⚠ Quadratic Growth

Space Complexity

O(m × n)

Space for the matrix copy during each combination test

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~18 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 (Try All Column Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler