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: 3

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

example_2.py — Single Cell

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

› Output: 3

💡 Note: Need 3 operations to clear all 1's. First operation at (0,0) gives [[0,0,0],[0,0,1],[0,1,1]]. Second operation at (1,2) gives [[0,0,0],[0,0,0],[0,1,0]]. Third operation at (2,1) clears all remaining 1's.

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

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

✓ BFS with State Exploration (Optimal)

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

Instead of trying all combinations recursively, we use BFS to explore grid states level by level. Each state represents a grid configuration, and we find the shortest path to the all-zeros state. This is optimal because BFS guarantees we find the minimum number of operations.

Brute Force (Try All Combinations)

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

Generate all possible sequences of operations by trying each cell with a 1 as the next operation target. This explores every possible path but is extremely inefficient for larger grids.

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
#define MAX_SIZE 15

static int grid_storage[MAX_STATES][MAX_SIZE][MAX_SIZE];
static char visited_states[MAX_STATES][200];

typedef struct {
    int grid[MAX_SIZE][MAX_SIZE];
    int m, n;
    int operations;
} GridState;

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

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

void applyOperation(int src[MAX_SIZE][MAX_SIZE], int dst[MAX_SIZE][MAX_SIZE], int m, int n, int i, int j) {
    for (int r = 0; r < m; r++) {
        for (int c = 0; c < n; c++) {
            dst[r][c] = src[r][c];
        }
    }
    for (int col = 0; col < n; col++) {
        dst[i][col] = 0;
    }
    for (int row = 0; row < m; row++) {
        dst[row][j] = 0;
    }
}

void gridToString(int grid[MAX_SIZE][MAX_SIZE], int m, int n, char* str) {
    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';
}

int minOperations(int grid[MAX_SIZE][MAX_SIZE], int m, int n) {
    if (!hasOnes(grid, m, n)) return 0;
    
    static Queue q;
    q.front = q.rear = 0;
    int visitedCount = 0;
    
    // Add initial state
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            q.states[q.rear].grid[i][j] = grid[i][j];
        }
    }
    q.states[q.rear].m = m;
    q.states[q.rear].n = n;
    q.states[q.rear].operations = 0;
    q.rear++;
    
    gridToString(grid, m, n, visited_states[visitedCount++]);
    
    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) {
                    static int newGrid[MAX_SIZE][MAX_SIZE];
                    applyOperation(current.grid, newGrid, current.m, current.n, i, j);
                    
                    if (!hasOnes(newGrid, current.m, current.n)) {
                        return current.operations + 1;
                    }
                    
                    static char state[200];
                    gridToString(newGrid, current.m, current.n, state);
                    
                    bool found = false;
                    for (int k = 0; k < visitedCount; k++) {
                        if (strcmp(visited_states[k], state) == 0) {
                            found = true;
                            break;
                        }
                    }
                    
                    if (!found && q.rear < MAX_STATES && visitedCount < MAX_STATES) {
                        strcpy(visited_states[visitedCount++], state);
                        for (int r = 0; r < current.m; r++) {
                            for (int c = 0; c < current.n; c++) {
                                q.states[q.rear].grid[r][c] = newGrid[r][c];
                            }
                        }
                        q.states[q.rear].m = current.m;
                        q.states[q.rear].n = current.n;
                        q.states[q.rear].operations = current.operations + 1;
                        q.rear++;
                    }
                }
            }
        }
    }
    return -1;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    static int grid[MAX_SIZE][MAX_SIZE];
    int m = 0, n = 0;
    
    // Parse input
    char* ptr = input;
    while (*ptr && *ptr != '[') ptr++; // Find first [
    if (*ptr) ptr++; // Skip [
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++; // Skip [
            int col = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    grid[m][col++] = *ptr - '0';
                }
                ptr++;
            }
            if (n == 0) n = col;
            m++;
            if (*ptr == ']') ptr++; // Skip ]
        } else {
            ptr++;
        }
    }
    
    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