Remove All Ones With Row and Column Flips II

Remove All Ones With Row and Column Flips II - Problem

Imagine you're playing a strategic elimination game on a binary matrix grid! 🎯

You are given an m × n binary matrix where each cell contains either 0 or 1. Your mission is to remove all the 1's from the grid using a special operation.

The Operation: You can select any cell containing 1 at position (i, j), and when you do, all cells in both row i and column j become 0. It's like placing a cross-shaped bomb that clears an entire row and column!

Goal: Find the minimum number of operations needed to turn all 1's into 0's.

Key Insight: This is a clever optimization problem where the order of operations and strategic thinking matter more than brute force!

Input & Output

example_1.py — Basic Grid

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

› Output: 2

💡 Note: We can eliminate all 1's in 2 operations: First operation at (1,1) clears row 1 and column 1. Second operation at (2,0) clears the remaining 1's in row 2 and column 0.

example_2.py — Single Cell

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

› Output: 2

💡 Note: Need 2 operations to clear all 1's. One operation can clear multiple 1's but may not be enough for complex patterns.

example_3.py — Already Clear

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

› Output: 0

💡 Note: Grid already contains no 1's, so no operations needed.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 15
grid[i][j] is either 0 or 1
The grid will always have a valid solution

Visualization

Tap to expand

Understanding the Visualization

Identify Targets

Scan the grid to find all positions containing 1's that can be targeted

Choose Operation

Select a cell with 1 - this will clear its entire row and column

Apply Cross Clear

All cells in the selected row and column become 0

Update State

The grid state changes, potentially creating new optimal choices

Repeat Until Clear

Continue until no 1's remain, tracking minimum operations via BFS

Key Takeaway

🎯 Key Insight: Use BFS to explore grid states systematically - each operation creates a new state, and the first path to reach an all-zeros state gives the minimum operations needed.

Asked in

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

The optimal approach uses BFS to systematically explore all possible grid states, treating each grid configuration as a node in a graph. We start from the initial grid and apply all possible operations (selecting cells with 1's) to generate new states. The first time we reach an all-zeros state gives us the minimum number of operations, since BFS explores states level by level.

Common Approaches

Approach	Time	Space	Notes
✓ BFS with State Exploration (Optimal)	O(2^(m×n) × m × n)	O(2^(m×n))	Use BFS to systematically explore all possible grid states to find minimum operations
Brute Force (Try All Combinations)	O(2^(m×n))	O(m×n)	Try all possible sequences of operations until finding one that clears the grid

BFS with State Exploration (Optimal) — Algorithm Steps

Convert grid to a hashable state representation
Use BFS queue starting with initial grid state
For each state, try all possible operations (cells with 1)
Apply operation and add new state to queue if not visited
Return operation count when we reach all-zeros state

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Queue

Start with original grid state in queue

Level-by-Level

Process all states at current operation level

Generate States

For each 1 in current state, generate new state by applying operation

Check Visited

Only add new states that haven't been seen before

Found Solution

Return when we reach a state with no 1's

Code -

solution.c — C

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

#define MAX_STATES 10000

typedef struct {
    int** grid;
    int m, n;
    int operations;
} GridState;

typedef struct {
    GridState states[MAX_STATES];
    int front, rear;
} Queue;

bool hasOnes(int** matrix, int m, int n) {
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] == 1) return true;
        }
    }
    return false;
}

int** applyOperation(int** matrix, int m, int n, int i, int j) {
    int** newGrid = (int**)malloc(m * sizeof(int*));
    for (int r = 0; r < m; r++) {
        newGrid[r] = (int*)malloc(n * sizeof(int));
        memcpy(newGrid[r], matrix[r], n * sizeof(int));
    }
    memset(newGrid[i], 0, n * sizeof(int));
    for (int r = 0; r < m; r++) {
        newGrid[r][j] = 0;
    }
    return newGrid;
}

char* gridToString(int** grid, int m, int n) {
    char* str = (char*)malloc((m * n + m + 1) * sizeof(char));
    int pos = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            str[pos++] = '0' + grid[i][j];
        }
        str[pos++] = '|';
    }
    str[pos] = '\0';
    return str;
}

int minOperations(int** grid, int m, int n) {
    if (!hasOnes(grid, m, n)) return 0;
    
    Queue q = {{}, 0, 0};
    char visited[MAX_STATES][100];
    int visitedCount = 0;
    
    // Add initial state
    q.states[q.rear++] = (GridState){grid, m, n, 0};
    strcpy(visited[visitedCount++], gridToString(grid, m, n));
    
    while (q.front < q.rear) {
        GridState current = q.states[q.front++];
        
        for (int i = 0; i < current.m; i++) {
            for (int j = 0; j < current.n; j++) {
                if (current.grid[i][j] == 1) {
                    int** newGrid = applyOperation(current.grid, current.m, current.n, i, j);
                    
                    if (!hasOnes(newGrid, current.m, current.n)) {
                        return current.operations + 1;
                    }
                    
                    char* state = gridToString(newGrid, current.m, current.n);
                    bool found = false;
                    for (int k = 0; k < visitedCount; k++) {
                        if (strcmp(visited[k], state) == 0) {
                            found = true;
                            break;
                        }
                    }
                    
                    if (!found && q.rear < MAX_STATES) {
                        strcpy(visited[visitedCount++], state);
                        q.states[q.rear++] = (GridState){newGrid, current.m, current.n, current.operations + 1};
                    }
                    free(state);
                }
            }
        }
    }
    return -1;
}

int main() {
    int m = 3, n = 4;
    int** grid = (int**)malloc(m * sizeof(int*));
    int data[3][4] = {{0,1,1,1},{1,1,1,1},{1,1,1,1}};
    for (int i = 0; i < m; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            grid[i][j] = data[i][j];
        }
    }
    printf("%d\n", minOperations(grid, m, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

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

We may visit up to 2^(m×n) different states, and each state takes O(m×n) time to process

✓ Linear Growth

Space Complexity

O(2^(m×n))

Queue and visited set can store up to 2^(m×n) different grid states

⚡ Linearithmic Space

43.6K Views

Medium-High Frequency

~25 min Avg. Time

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

BFS with State Exploration (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler