Disconnect Path in a Binary Matrix by at Most One Flip

Disconnect Path in a Binary Matrix by at Most One Flip - Problem

You're given an m × n binary matrix representing a grid where you can only move through cells containing 1. Your goal is to determine if you can disconnect the path from the top-left corner (0, 0) to the bottom-right corner (m-1, n-1) by flipping at most one cell.

Movement Rules:

From cell (row, col), you can move to (row + 1, col) or (row, col + 1)
You can only move to cells with value 1

Flipping Rules:

You can flip at most one cell (changing 0→1 or 1→0)
You cannot flip the start (0, 0) or end (m-1, n-1) cells

Return true if you can make the matrix disconnected, false otherwise.

Input & Output

example_1.py — Basic disconnectable grid

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

› Output: true

💡 Note: We can flip grid[1][0] from 1 to 0, making it impossible to reach from (0,0) to (2,2). The path through (1,0) is the only way to connect the regions.

example_2.py — Multiple paths available

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

› Output: false

💡 Note: There are multiple independent paths from (0,0) to (2,2). Even if we flip one cell, alternative routes still exist, so we cannot disconnect the grid with just one flip.

example_3.py — Already disconnected

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

› Output: true

💡 Note: The grid is already disconnected - there's no path from (0,0) to (2,2). Since we can achieve disconnection without any flips, the answer is true.

Visualization

Tap to expand

Understanding the Visualization

Identify Critical Paths

Find all possible routes from start to end

Analyze Bottlenecks

Look for single points of failure in the network

Apply Graph Theory

Use max-flow to determine minimum cut capacity

Make Decision

If min-cut ≤ 1, the path is vulnerable to single flip

Key Takeaway

🎯 Key Insight: Use max-flow min-cut theorem: if maximum flow ≤ 1, then minimum cut ≤ 1, meaning one cell flip can disconnect the path

Time & Space Complexity

Time Complexity

⏱️

O(mn(m+n))

Max flow in grid graph using Edmonds-Karp algorithm

✓ Linear Growth

Space Complexity

O(mn)

Space for flow network representation

⚡ Linearithmic Space

Constraints

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

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal approach uses the max-flow min-cut theorem to determine if the minimum cut between source and sink is at most 1. If the maximum flow from (0,0) to (m-1,n-1) is ≤ 1, then removing one edge can disconnect the path. This avoids the brute force approach of testing every possible flip.

Common Approaches

Approach	Time	Space	Notes
✓ Max Flow Minimum Cut	O(mn(m+n))	O(mn)	Use maximum flow algorithm to find minimum cut between source and sink

Max Flow Minimum Cut — Algorithm Steps

Build a flow network from the grid
Set (0,0) as source and (m-1,n-1) as sink
Each cell becomes a node, edges have capacity 1
Run max flow algorithm (Ford-Fulkerson or Edmonds-Karp)
If max flow ≤ 1, then minimum cut ≤ 1, so return true
Otherwise return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Graph Construction

Convert grid to flow network with capacity 1 edges

Flow Augmentation

Find augmenting paths from source to sink

Residual Update

Update residual graph after each flow augmentation

Min Cut Analysis

If max flow ≤ 1, then min cut ≤ 1

Code -

solution.c — C

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

typedef struct {
    int* data;
    int front, rear, size;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->data = (int*)malloc(capacity * sizeof(int));
    q->front = q->rear = 0;
    q->size = capacity;
    return q;
}

void enqueue(Queue* q, int item) {
    q->data[q->rear] = item;
    q->rear = (q->rear + 1) % q->size;
}

int dequeue(Queue* q) {
    int item = q->data[q->front];
    q->front = (q->front + 1) % q->size;
    return item;
}

bool isEmpty(Queue* q) {
    return q->front == q->rear;
}

bool bfs(int** residual, int source, int sink, int* parent, int V) {
    bool* visited = (bool*)calloc(V, sizeof(bool));
    Queue* queue = createQueue(V);
    
    enqueue(queue, source);
    visited[source] = true;
    parent[source] = -1;
    
    while (!isEmpty(queue)) {
        int u = dequeue(queue);
        
        for (int v = 0; v < V; v++) {
            if (!visited[v] && residual[u][v] > 0) {
                enqueue(queue, v);
                parent[v] = u;
                visited[v] = true;
                if (v == sink) {
                    free(visited);
                    free(queue->data);
                    free(queue);
                    return true;
                }
            }
        }
    }
    
    free(visited);
    free(queue->data);
    free(queue);
    return false;
}

int maxFlow(int** capacity, int source, int sink, int V) {
    int** residual = (int**)malloc(V * sizeof(int*));
    for (int i = 0; i < V; i++) {
        residual[i] = (int*)malloc(V * sizeof(int));
        for (int j = 0; j < V; j++) {
            residual[i][j] = capacity[i][j];
        }
    }
    
    int* parent = (int*)malloc(V * sizeof(int));
    int maxFlowValue = 0;
    
    while (bfs(residual, source, sink, parent, V)) {
        int pathFlow = INT_MAX;
        for (int v = sink; v != source; v = parent[v]) {
            int u = parent[v];
            if (residual[u][v] < pathFlow) {
                pathFlow = residual[u][v];
            }
        }
        
        for (int v = sink; v != source; v = parent[v]) {
            int u = parent[v];
            residual[u][v] -= pathFlow;
            residual[v][u] += pathFlow;
        }
        
        maxFlowValue += pathFlow;
    }
    
    for (int i = 0; i < V; i++) {
        free(residual[i]);
    }
    free(residual);
    free(parent);
    
    return maxFlowValue;
}

bool isPossibleToCutPath(int** grid, int gridSize, int* gridColSize) {
    int m = gridSize, n = gridColSize[0];
    
    if (grid[0][0] == 0 || grid[m-1][n-1] == 0) return true;
    
    int** capacity = (int**)malloc(m * n * sizeof(int*));
    for (int i = 0; i < m * n; i++) {
        capacity[i] = (int*)calloc(m * n, sizeof(int));
    }
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 0) continue;
            
            int curr = i * n + j;
            int dirs[][2] = {{0, 1}, {1, 0}};
            
            for (int d = 0; d < 2; d++) {
                int ni = i + dirs[d][0], nj = j + dirs[d][1];
                if (ni >= 0 && ni < m && nj >= 0 && nj < n && grid[ni][nj] == 1) {
                    int next = ni * n + nj;
                    capacity[curr][next] = 1;
                    capacity[next][curr] = 1;
                }
            }
        }
    }
    
    int source = 0, sink = (m-1) * n + (n-1);
    bool result = maxFlow(capacity, source, sink, m * n) <= 1;
    
    for (int i = 0; i < m * n; i++) {
        free(capacity[i]);
    }
    free(capacity);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn(m+n))

Max flow in grid graph using Edmonds-Karp algorithm

✓ Linear Growth

Space Complexity

O(mn)

Space for flow network representation

⚡ Linearithmic Space

Constraints

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

31.2K Views

Medium Frequency

~25 min Avg. Time

876 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Max Flow Minimum Cut — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler