Remove All Ones With Row and Column Flips

Remove All Ones With Row and Column Flips - Problem

You are given an m x n binary matrix grid. In one operation, you can choose any row or column and flip each value in that row or column (i.e., changing all 0's to 1's, and all 1's to 0's).

Return true if it is possible to remove all 1's from grid using any number of operations or false otherwise.

Input & Output

Example 1 — Basic Case

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

› Output: true

💡 Note: Both rows are identical [0,1]. We can flip column 1 to make all rows [0,0], then they're all zeros.

Example 2 — Complementary Rows

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

› Output: true

💡 Note: Row 2 is the complement of Row 1. We can flip all columns to make both rows [1,0], then flip both rows to get all zeros.

Example 3 — Impossible Case

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

› Output: false

💡 Note: Row 3 [0,1] is neither identical nor complementary to Row 1 [0,0]. Cannot be made consistent through flips.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 8 M Microsoft 12

The key insight is that after optimal row flips, all rows must be either identical or complete complements of each other. The Row Pattern Analysis approach checks if all rows are identical or complementary to the first row in O(m×n) time with O(1) space.

Common Approaches

✓ Brute Force - Try All Flip Combinations

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

Generate all possible states by trying every combination of row flips and column flips. For each combination, check if all 1's can be removed.

Row Pattern Analysis

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

The key insight is that we can always flip the first row to all zeros. Then check if all other rows can be made identical to the first row (all zeros) by column flips only.

Brute Force - Try All Flip Combinations — Algorithm Steps

Step 1: Generate all 2^(m+n) possible flip combinations
Step 2: For each combination, apply row and column flips
Step 3: Check if resulting matrix has all zeros

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Matrix

Start with the given binary matrix

Try Flips

Test all 2^(m+n) combinations of row and column flips

Check Result

For each combination, check if all 1's are removed

Code -

solution.c — C

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

int solution(int** grid, int m, int n) {
    // Try all combinations of row and column flips
    for (int rowMask = 0; rowMask < (1 << m); rowMask++) {
        for (int colMask = 0; colMask < (1 << n); colMask++) {
            // Create copy and apply flips
            int temp[20][20];
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    temp[i][j] = grid[i][j];
                }
            }
            
            // Apply row flips
            for (int i = 0; i < m; i++) {
                if (rowMask & (1 << i)) {
                    for (int j = 0; j < n; j++) {
                        temp[i][j] = 1 - temp[i][j];
                    }
                }
            }
            
            // Apply column flips
            for (int j = 0; j < n; j++) {
                if (colMask & (1 << j)) {
                    for (int i = 0; i < m; i++) {
                        temp[i][j] = 1 - temp[i][j];
                    }
                }
            }
            
            // Check if all zeros
            int allZeros = 1;
            for (int i = 0; i < m && allZeros; i++) {
                for (int j = 0; j < n && allZeros; j++) {
                    if (temp[i][j] == 1) {
                        allZeros = 0;
                    }
                }
            }
            
            if (allZeros) return 1;
        }
    }
    
    return 0;
}

int main() {
    int grid[20][20];
    int m = 0, n = 0;
    char line[1000];
    
    // Read the entire input
    if (fgets(line, sizeof(line), stdin)) {
        char* ptr = line;
        
        // Skip to first '['
        while (*ptr && *ptr != '[') ptr++;
        if (*ptr) ptr++; // skip '['
        
        // Read rows
        while (*ptr) {
            // Skip whitespace and commas
            while (*ptr && (*ptr == ' ' || *ptr == ',')) ptr++;
            
            if (*ptr == '[') {
                ptr++; // skip '['
                n = 0;
                
                // Read values in this row
                while (*ptr && *ptr != ']') {
                    while (*ptr && (*ptr == ' ' || *ptr == ',')) ptr++;
                    if (*ptr >= '0' && *ptr <= '9') {
                        grid[m][n++] = *ptr - '0';
                        ptr++;
                    } else {
                        break;
                    }
                }
                
                if (*ptr == ']') ptr++; // skip ']'
                m++;
            } else if (*ptr == ']') {
                break;
            } else {
                ptr++;
            }
        }
    }
    
    // Create array of pointers
    int* gridPtrs[20];
    for (int i = 0; i < m; i++) {
        gridPtrs[i] = grid[i];
    }
    
    int result = solution(gridPtrs, m, n);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(m+n) × m × n)

Try 2^(m+n) combinations, each taking O(m×n) time to apply flips

✓ Linear Growth

Space Complexity

O(m × n)

Space to store copy of matrix for each attempt

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

842 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 Flip Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler