Minimum Operations to Remove Adjacent Ones in Matrix

Minimum Operations to Remove Adjacent Ones in Matrix - Problem

You are given a binary matrix where each cell contains either 0 or 1. Your mission is to make the matrix "well-isolated" by strategically flipping 1s to 0s.

A matrix is considered well-isolated when no 1 has any neighboring 1s in the four cardinal directions (up, down, left, right). Think of it like ensuring no two islands touch each other!

Goal: Find the minimum number of flip operations needed to achieve this well-isolated state.

Example: In matrix [[1,1,0],[0,1,1],[0,0,1]], you need to flip at least 2 ones to make it well-isolated.

Input & Output

example_1.py — Small Connected Component

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

› Output: 2

💡 Note: The 1s form connected components. We need to flip 2 positions to make all 1s isolated: flip (0,1) and (1,2) to get [[1,0,0],[0,1,0],[0,0,1]] which is well-isolated.

example_2.py — Already Well-Isolated

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

› Output: 0

💡 Note: The matrix is already well-isolated since no 1 is adjacent to another 1. No operations needed.

example_3.py — Large Connected Component

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

› Output: 3

💡 Note: This forms a large connected component around the center 0. Using minimum vertex cover approach, we need to remove 3 strategically placed 1s to break all connections.

Time & Space Complexity

Time Complexity

⏱️

O(m*n + k^2.5)

O(m*n) to scan matrix and find components, O(k^2.5) for maximum matching where k is number of 1s

✓ Linear Growth

Space Complexity

O(m*n)

Space for graph representation and matching algorithm data structures

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 15
grid[i][j] is either 0 or 1
The number of 1s in the grid is at most 20

Asked in

The optimal approach treats this as a minimum vertex cover problem on bipartite graphs. Each connected component of 1s forms a bipartite graph using chess-board coloring, and we apply König's theorem to find the minimum vertex cover efficiently using maximum bipartite matching algorithms.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^k * m*n)	O(m*n)	Try all possible combinations of flipping 1s to 0s until matrix becomes well-isolated
Minimum Vertex Cover (Optimal Graph Solution)	O(m*n + k^2.5)	O(m*n)	Model as bipartite graph and solve minimum vertex cover using maximum matching

Brute Force (Try All Combinations) — Algorithm Steps

Find all positions containing 1s in the matrix
Generate all possible subsets of these positions
For each subset, create a copy of matrix and flip those positions to 0
Check if the resulting matrix is well-isolated
Track the minimum subset size that makes matrix well-isolated

Visualization

Tap to expand

Step-by-Step Walkthrough

Find All Ones

Locate all positions with value 1 in the matrix

Generate Combinations

Create all possible subsets of these positions

Test Each Subset

For each subset, flip those positions and check if matrix becomes well-isolated

Return Minimum

Return the size of smallest subset that works

Code -

solution.c — C

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

typedef struct {
    int x, y;
} Point;

bool isWellIsolated(int** matrix, int m, int n) {
    int directions[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] == 1) {
                for (int d = 0; d < 4; d++) {
                    int ni = i + directions[d][0];
                    int nj = j + directions[d][1];
                    if (ni >= 0 && ni < m && nj >= 0 && nj < n && matrix[ni][nj] == 1) {
                        return false;
                    }
                }
            }
        }
    }
    return true;
}

int** copyMatrix(int** matrix, int m, int n) {
    int** copy = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        copy[i] = (int*)malloc(n * sizeof(int));
        memcpy(copy[i], matrix[i], n * sizeof(int));
    }
    return copy;
}

void freeMatrix(int** matrix, int m) {
    for (int i = 0; i < m; i++) {
        free(matrix[i]);
    }
    free(matrix);
}

int minOperations(int** grid, int gridSize, int* gridColSize) {
    if (isWellIsolated(grid, gridSize, gridColSize[0])) {
        return 0;
    }
    
    Point* ones = (Point*)malloc(gridSize * gridColSize[0] * sizeof(Point));
    int onesCount = 0;
    
    for (int i = 0; i < gridSize; i++) {
        for (int j = 0; j < gridColSize[0]; j++) {
            if (grid[i][j] == 1) {
                ones[onesCount++] = (Point){i, j};
            }
        }
    }
    
    // Try all possible combinations (simplified for demonstration)
    for (int mask = 1; mask < (1 << onesCount); mask++) {
        int** temp = copyMatrix(grid, gridSize, gridColSize[0]);
        int flips = 0;
        
        for (int i = 0; i < onesCount; i++) {
            if (mask & (1 << i)) {
                temp[ones[i].x][ones[i].y] = 0;
                flips++;
            }
        }
        
        if (isWellIsolated(temp, gridSize, gridColSize[0])) {
            freeMatrix(temp, gridSize);
            free(ones);
            return flips;
        }
        
        freeMatrix(temp, gridSize);
    }
    
    free(ones);
    return onesCount;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^k * m*n)

Where k is number of 1s in matrix. We try 2^k combinations, each taking O(m*n) to verify

✓ Linear Growth

Space Complexity

O(m*n)

Space for matrix copy and recursion stack

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 15
grid[i][j] is either 0 or 1
The number of 1s in the grid is at most 20

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler