Remove All Ones With Row and Column Flips

Remove All Ones With Row and Column Flips - Problem

You're given an m × n binary matrix grid containing only 0s and 1s. Your goal is to determine if you can remove all 1s from the matrix using row and column flip operations.

In each operation, you can:

Choose any row and flip all values in that row (0 → 1, 1 → 0)
Choose any column and flip all values in that column (0 → 1, 1 → 0)

Return true if it's possible to make all cells contain 0, or false otherwise.

Key insight: This is actually a problem about linear algebra over GF(2) - we need to check if the all-zeros vector can be reached through XOR operations on rows and columns.

Input & Output

example_1.py — Python

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

› Output: true

💡 Note: We can flip row 1 and column 1 to get all zeros. After flipping row 1: [[0,1,0],[0,1,0],[0,1,0]]. After flipping column 1: [[0,0,0],[0,0,0],[0,0,0]].

example_2.py — Python

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

› Output: false

💡 Note: No combination of row and column flips can eliminate all 1s from this matrix. The system of equations has no solution.

example_3.py — Python

$ Input: grid = [[1]]

› Output: true

💡 Note: Single cell with value 1 can be flipped to 0 by flipping either the row or the column (or both, which would flip it back to 1, then we can flip just one).

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Model the Problem

Each cell with value 1 creates an equation: row_flip[i] ⊕ col_flip[j] = 1

Build Augmented Matrix

Create coefficient matrix where each row represents a cell constraint

Apply Gaussian Elimination

Use XOR operations to reduce the matrix to row echelon form

Check for Contradictions

If any row becomes [0,0,...,0 | 1], the system is unsolvable

Key Takeaway

🎯 Key Insight: The matrix flipping problem is equivalent to solving a system of linear equations over GF(2). This mathematical approach reduces complexity from exponential to polynomial time.

Asked in

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

This problem is elegantly solved using Gaussian elimination over GF(2). Model each cell as a linear equation where row and column flip variables determine the final state. The optimal approach has O(m²n + mn²) complexity compared to the brute force O(2^(m+n)) solution.

Common Approaches

Approach	Time	Space	Notes
✓ Gaussian Elimination (Optimal)	O(m²n + mn²)	O(mn)	Solve as system of linear equations over GF(2) using Gaussian elimination
Brute Force (Try All Combinations)	O(2^(m+n) × m × n)	O(m × n)	Try all 2^(m+n) combinations of row and column flips

Gaussian Elimination (Optimal) — Algorithm Steps

Create augmented matrix where each row represents a cell constraint
Each column represents a row/column flip variable
Apply Gaussian elimination over GF(2) (XOR operations)
Check if the system is consistent (no contradiction)
Return true if system has a solution

Visualization

Tap to expand

Step-by-Step Walkthrough

Model as Linear System

Each cell with value 1 creates an equation with row and column flip variables

Gaussian Elimination

Use XOR operations to reduce the augmented matrix to row echelon form

Check Consistency

Verify no contradictions (0 = 1) exist in the reduced system

Code -

solution.c — C

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

int canRemoveOnes(int** grid, int m, int n) {
    // Count equations needed
    int eqCount = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 1) eqCount++;
        }
    }
    
    if (eqCount == 0) return 1;
    
    // Create equations matrix
    int** equations = (int**)malloc(eqCount * sizeof(int*));
    int eqIdx = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 1) {
                equations[eqIdx] = (int*)calloc(m + n + 1, sizeof(int));
                equations[eqIdx][i] = 1;        // Row i flip
                equations[eqIdx][m + j] = 1;    // Column j flip
                equations[eqIdx][m + n] = 1;    // RHS = 1
                eqIdx++;
            }
        }
    }
    
    // Gaussian elimination over GF(2)
    int rows = eqCount, cols = m + n;
    
    for (int col = 0; col < cols; col++) {
        // Find pivot
        int pivot = -1;
        for (int row = col; row < rows; row++) {
            if (equations[row][col] == 1) {
                pivot = row;
                break;
            }
        }
        
        if (pivot == -1) continue;
        
        // Swap rows
        if (pivot != col && col < rows) {
            int* temp = equations[col];
            equations[col] = equations[pivot];
            equations[pivot] = temp;
        }
        
        // Eliminate
        int pivotRow = (col < rows) ? col : rows - 1;
        for (int row = 0; row < rows; row++) {
            if (row != pivotRow && equations[row][col] == 1) {
                for (int c = 0; c <= cols; c++) {
                    equations[row][c] ^= equations[pivotRow][c];
                }
            }
        }
    }
    
    // Check for contradictions
    int result = 1;
    for (int row = 0; row < rows; row++) {
        int allZero = 1;
        for (int col = 0; col < cols; col++) {
            if (equations[row][col] != 0) {
                allZero = 0;
                break;
            }
        }
        if (allZero && equations[row][cols] == 1) {
            result = 0;
            break;
        }
    }
    
    // Free memory
    for (int i = 0; i < eqCount; i++) {
        free(equations[i]);
    }
    free(equations);
    
    return result;
}

int main() {
    int grid1[] = {0,1,0};
    int grid2[] = {1,0,1};
    int grid3[] = {0,1,0};
    int* grid[] = {grid1, grid2, grid3};
    printf("%s\n", canRemoveOnes(grid, 3, 3) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n + mn²)

Gaussian elimination on matrix of size (m×n) × (m+n)

⚠ Quadratic Growth

Space Complexity

O(mn)

Space for the augmented matrix

⚡ Linearithmic Space

38.5K Views

Medium Frequency

~25 min Avg. Time

1.2K 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

Gaussian Elimination (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler