Flip Columns For Maximum Number of Equal Rows

Flip Columns For Maximum Number of Equal Rows - Problem

You are given an m x n binary matrix matrix. You can choose any number of columns in the matrix and flip every cell in that column (i.e., change the value of the cell from 0 to 1 or vice versa).

Return the maximum number of rows that have all values equal after some number of flips.

A row has all values equal if all cells in that row are either 0 or 1.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: We can flip column 0 to make row 1 become [1,1] (uniform), or flip column 1 to make row 1 become [0,0] (uniform). Either way, maximum 1 row can be uniform.

Example 2 — Multiple Uniform Rows

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

› Output: 2

💡 Note: Flipping column 0 makes both rows uniform: [1,1] and [0,0]. Both patterns [0,1] and [1,0] are complements, so they can both become uniform with the same flip.

Example 3 — Already Uniform

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

› Output: 2

💡 Note: Row 1 [0,0,1] and row 3 [1,1,0] are complements of each other, so they can both be made uniform with the same column flips. Row 1 [0,0,0] forms its own group. Maximum uniform rows achievable is 2.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 8 a Amazon 5

The key insight is that rows with complementary patterns (like [0,1,0] and [1,0,1]) can both be made uniform with the same column flips. The optimal approach uses pattern frequency counting with O(m×n) time and O(m×n) space complexity.

Common Approaches

✓ Brute Force - Try All Column Combinations

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

Generate all 2^n possible combinations of column flips, apply each combination to the matrix, and count how many rows become uniform (all 0s or all 1s). Return the maximum count found.

Hash Map - Pattern Frequency Counting

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

The key insight is that rows with identical patterns or complementary patterns (like [0,1,0] and [1,0,1]) can both be made uniform with the same set of column flips. We count the frequency of each pattern and its complement, then return the maximum frequency.

Brute Force - Try All Column Combinations — Algorithm Steps

Step 1: Generate all 2^n possible column flip combinations using bit manipulation
Step 2: For each combination, simulate flipping the specified columns
Step 3: Count how many rows have all equal values after flipping
Step 4: Keep track of the maximum count achieved

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Try all 2^n possible column flip patterns

Apply Flips

For each combination, flip the specified columns

Count Uniform

Count rows that become all 0s or all 1s

Code -

solution.c — C

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

int solution(int** matrix, int m, int n) {
    int maxUniform = 0;
    
    // Try all 2^n possible column flip combinations
    for (int mask = 0; mask < (1 << n); mask++) {
        int uniformCount = 0;
        
        // Check each row with current column flips
        for (int i = 0; i < m; i++) {
            // Apply flips based on mask and check if row becomes uniform
            int* flippedRow = (int*)malloc(n * sizeof(int));
            for (int j = 0; j < n; j++) {
                if (mask & (1 << j)) {
                    flippedRow[j] = 1 - matrix[i][j];  // Flip
                } else {
                    flippedRow[j] = matrix[i][j];  // No flip
                }
            }
            
            // Check if all values in flipped row are equal
            int uniform = 1;
            for (int j = 1; j < n; j++) {
                if (flippedRow[j] != flippedRow[0]) {
                    uniform = 0;
                    break;
                }
            }
            if (uniform) uniformCount++;
            free(flippedRow);
        }
        
        if (uniformCount > maxUniform) {
            maxUniform = uniformCount;
        }
    }
    
    return maxUniform;
}

int parseMatrix(char* input, int*** matrix, int* m, int* n) {
    // Remove outer brackets
    char* start = strchr(input, '[');
    char* end = strrchr(input, ']');
    if (!start || !end) return 0;
    
    start++; // Skip first [
    *end = '\0'; // Remove last ]
    
    // Count rows by counting ][ patterns
    *m = 1;
    char* ptr = start;
    while ((ptr = strstr(ptr, "],[")) != NULL) {
        (*m)++;
        ptr += 3;
    }
    
    // Allocate matrix
    *matrix = (int**)malloc(*m * sizeof(int*));
    
    // Parse each row
    char* rowStart = start;
    for (int i = 0; i < *m; i++) {
        // Skip [ if present
        while (*rowStart == '[') rowStart++;
        
        // Find end of this row
        char* rowEnd = strchr(rowStart, ']');
        if (!rowEnd) rowEnd = rowStart + strlen(rowStart);
        
        // Count numbers in row
        int colCount = 1;
        for (char* p = rowStart; p < rowEnd; p++) {
            if (*p == ',') colCount++;
        }
        if (i == 0) *n = colCount;
        
        // Allocate row
        (*matrix)[i] = (int*)malloc(*n * sizeof(int));
        
        // Parse numbers
        char* token = rowStart;
        for (int j = 0; j < *n; j++) {
            (*matrix)[i][j] = atoi(token);
            token = strchr(token, ',');
            if (token) token++;
        }
        
        // Move to next row
        rowStart = rowEnd + 1;
        while (*rowStart && (*rowStart == ',' || *rowStart == '[')) rowStart++;
    }
    
    return 1;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    input[strcspn(input, "\n")] = 0;
    
    int** matrix;
    int m, n;
    
    if (parseMatrix(input, &matrix, &m, &n)) {
        printf("%d\n", solution(matrix, m, n));
        
        // Free memory
        for (int i = 0; i < m; i++) {
            free(matrix[i]);
        }
        free(matrix);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n × 2ⁿ)

For each of 2^n combinations, we check m rows with n columns each

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track current combination and counts

⚡ Linearithmic Space

26.7K Views

Medium Frequency

~25 min Avg. Time

890 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