Skip to content
Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

Minimum number of flips required such that a Binary Matrix doesn’t contain any path from the top left to the bottom right consisting only of 0s

  • Last Updated : 02 Aug, 2021

Given a binary matrix mat[][] of dimensions N*M, the task is to find the minimum number of flips required from the given binary matrix such that there doesn’t exist any path from the top-left cell to the bottom-right cell consisting of only 0s.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: mat[][] = {{0, 1, 0, 0}, {0, 1, 0, 0}, {0, 1, 0, 0}, {0, 0, 0, 0}}
Output: 1
Explanation:
Operation 1: Flipping the cell at (1, 0) modifies the given matrix to:
0 1 0 0
1 1 0 0
0 1 0 0
0 0 0 0
After the above operations, there doesn’t exists any path from the top-left cell (0, 0) to the bottom-right cell (3, 3) consisting of only 0s. Therefore, the total number of flips required is 1.



Input: mat[][] = {{0, 0, 0, 0}, {0, 0, 0, 0}}
Output: 2

Approach: The given problem can be solved using the DFS Traversal on the given matrix and based on the observation that there exists only at most 2 flipping of nodes such that there doesn’t exist any path from the top-left cell to the bottom-right cell consisting of only 0s. The idea is to perform the DFS traversal from the top-left cell to the bottom-right cell to flip at most one path and print the number of successful DFS calls as the result. Follow the steps below to solve the problem:

  • Initialize a function, say DFS(mat, i, j, N, M) that takes the current cell, the given matrix, and its size as the parameter and perform the following steps:
    • If the current cell reaches the cell (N – 1, M – 1) then return true.
    • Update the value of the cell at (i, j) to 1.
    • Recursively call the DFS function in all the four directions of the current cell i.e., (i + 1, j), (i, j + 1), (i – 1, j), and (i, j – 1) if they exists.
  • If the DFS Call from the cell (0, 0) returns false, then there exists no such path from the top-left to the bottom-right cell consisting of 0s. Therefore print 0 as the result and return from the function.
  • Again if the DFS Call from the cell (0, 0) returns false, then there exists only one path from the top-left to the bottom-right cell consisting of 0s. Therefore print 1 as the result and return from the function.
  • Otherwise, print 2 as the result.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include "bits/stdc++.h"
using namespace std;
 
// The four direction coordinates changes
// from the current cell
int direction[][2] = { { -1, 0 }, { 0, 1 },
                       { 0, -1 }, { 1, 0 } };
 
// Function that returns true if there
// exists any path from the top-left to
// the bottom-right cell of 0s
bool dfs(vector<vector<int> >& matrix,
         int i, int j, int N, int M)
{
 
    // If the bottom-right cell is
    // reached
    if (i == N - 1 and j == M - 1) {
        return true;
    }
 
    // Update the cell to 1
    matrix[i][j] = 1;
 
    // Traverse in all four directions
    for (int k = 0; k < 4; k++) {
 
        // Find the new coordinates
        int newX = i + direction[k][0];
        int newY = j + direction[k][1];
 
        // If the new cell is valid
        if (newX >= 0 and newX < N
            and newY >= 0 and newY < M
            and matrix[newX][newY] == 0) {
 
            // Recursively call DFS
            if (dfs(matrix, newX,
                    newY, N, M)) {
 
                // If path exists, then
                // return true
                return true;
            }
        }
    }
 
    // Return false, if there doesn't
    // exists any such path
    return false;
}
 
// Function to flip the minimum number
// of cells such that there doesn't
// exists any such path from (0, 0) to
// (N - 1, M - 1) cell consisting of 0s
int solve(vector<vector<int> >& matrix)
{
 
    int N = matrix.size();
    int M = matrix[0].size();
 
    // Case 1: If no such path exists
    // already
    if (!dfs(matrix, 0, 0, N, M)) {
        return 0;
    }
 
    // Case 2: If there exists only
    // one path
    if (!dfs(matrix, 0, 0, N, M)) {
        return 1;
    }
 
    // Case 3: If there exists two-path
    return 2;
}
 
// Driver Code
int main()
{
    vector<vector<int> > mat = {
        { 0, 1, 0, 0 },
        { 0, 1, 0, 0 },
        { 0, 0, 0, 0 }
    };
    cout << solve(mat);
 
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
 
class GFG{
     
// The four direction coordinates changes
// from the current cell
static int[][] direction = { { -1, 0 }, { 0, 1 },
                             { 0, -1 }, { 1, 0 } };
 
// Function that returns true if there
// exists any path from the top-left to
// the bottom-right cell of 0s
static boolean dfs(int matrix[][], int i, int j,
                   int N, int M)
{
     
    // If the bottom-right cell is
    // reached
    if (i == N - 1 && j == M - 1)
    {
        return true;
    }
 
    // Update the cell to 1
    matrix[i][j] = 1;
 
    // Traverse in all four directions
    for(int k = 0; k < 4; k++)
    {
         
        // Find the new coordinates
        int newX = i + direction[k][0];
        int newY = j + direction[k][1];
 
        // If the new cell is valid
        if (newX >= 0 && newX < N && newY >= 0 &&
            newY < M && matrix[newX][newY] == 0)
        {
             
            // Recursively call DFS
            if (dfs(matrix, newX, newY, N, M))
            {
                 
                // If path exists, then
                // return true
                return true;
            }
        }
    }
 
    // Return false, if there doesn't
    // exists any such path
    return false;
}
 
// Function to flip the minimum number
// of cells such that there doesn't
// exists any such path from (0, 0) to
// (N - 1, M - 1) cell consisting of 0s
static int solve(int[][] matrix)
{
    int N = matrix.length;
    int M = matrix[0].length;
 
    // Case 1: If no such path exists
    // already
    if (!dfs(matrix, 0, 0, N, M))
    {
        return 0;
    }
 
    // Case 2: If there exists only
    // one path
    if (!dfs(matrix, 0, 0, N, M))
    {
        return 1;
    }
 
    // Case 3: If there exists two-path
    return 2;
}
 
// Driver code
public static void main(String[] args)
{
    int[][] mat = { { 0, 1, 0, 0 },
                    { 0, 1, 0, 0 },
                    { 0, 0, 0, 0 } };
 
    System.out.println(solve(mat));
}
}
 
// This code is contributed by MuskanKalra1

Python3




# Python3 program for the above approach
 
# The four direction coordinates changes
# from the current cell
direction = [ [ -1, 0 ], [ 0, 1 ],
              [ 0, -1 ],[ 1, 0 ] ]
 
# Function that returns true if there
# exists any path from the top-left to
# the bottom-right cell of 0s
def dfs(i, j, N, M):
     
    global matrix
 
    # If the bottom-right cell is
    # reached
    if (i == N - 1 and j == M - 1):
        return True
 
    # Update the cell to 1
    matrix[i][j] = 1
 
    # Traverse in all four directions
    for k in range(4):
         
        # Find the new coordinates
        newX = i + direction[k][0]
        newY = j + direction[k][1]
 
        # If the new cell is valid
        if (newX >= 0 and newX < N and
            newY >= 0 and newY < M and
            matrix[newX][newY] == 0):
                 
            # Recursively call DFS
            if (dfs(newX, newY, N, M)):
                 
                # If path exists, then
                # return true
                return True
 
    # Return false, if there doesn't
    # exists any such path
    return False
 
# Function to flip the minimum number
# of cells such that there doesn't
# exists any such path from (0, 0) to
# (N - 1, M - 1) cell consisting of 0s
def solve():
     
    global matrix
    N = len(matrix)
    M = len(matrix[0])
 
    # Case 1: If no such path exists
    # already
    if (not dfs(0, 0, N, M)):
        return 0
 
    # Case 2: If there exists only
    # one path
    if (not dfs(0, 0, N, M)):
        return 1
 
    # Case 3: If there exists two-path
    return 2
 
# Driver Code
if __name__ == '__main__':
     
    matrix = [ [ 0, 1, 0, 0 ],
               [ 0, 1, 0, 0 ],
               [ 0, 0, 0, 0 ] ]
                
    print(solve())
 
# This code is contributed by mohit kumar 29

C#




// C# program for the above approach
using System;
 
class GFG{
     
// The four direction coordinates changes
// from the current cell
static int[,] direction = { { -1, 0 }, { 0, 1 },
                            { 0, -1 }, { 1, 0 } };
 
// Function that returns true if there
// exists any path from the top-left to
// the bottom-right cell of 0s
static bool dfs(int [,]matrix, int i, int j,
                int N, int M)
{
     
    // If the bottom-right cell is
    // reached
    if (i == N - 1 && j == M - 1)
    {
        return true;
    }
 
    // Update the cell to 1
    matrix[i, j] = 1;
 
    // Traverse in all four directions
    for(int k = 0; k < 4; k++)
    {
         
        // Find the new coordinates
        int newX = i + direction[k, 0];
        int newY = j + direction[k, 1];
 
        // If the new cell is valid
        if (newX >= 0 && newX < N && newY >= 0 &&
            newY < M && matrix[newX, newY] == 0)
        {
             
            // Recursively call DFS
            if (dfs(matrix, newX, newY, N, M))
            {
                 
                // If path exists, then
                // return true
                return true;
            }
        }
    }
 
    // Return false, if there doesn't
    // exists any such path
    return false;
}
 
// Function to flip the minimum number
// of cells such that there doesn't
// exists any such path from (0, 0) to
// (N - 1, M - 1) cell consisting of 0s
static int solve(int[,] matrix)
{
    int N = matrix.GetLength(0);
    int M = matrix.GetLength(1);
 
    // Case 1: If no such path exists
    // already
    if (!dfs(matrix, 0, 0, N, M))
    {
        return 0;
    }
 
    // Case 2: If there exists only
    // one path
    if (!dfs(matrix, 0, 0, N, M))
    {
        return 1;
    }
 
    // Case 3: If there exists two-path
    return 2;
}
 
// Driver code
public static void Main(String[] args)
{
    int[,] mat = { { 0, 1, 0, 0 },
                   { 0, 1, 0, 0 },
                   { 0, 0, 0, 0 } };
 
    Console.WriteLine(solve(mat));
}
}
 
// This code is contributed by gauravrajput1

Javascript




<script>
 
// JavaScript program for the above approach
 
// The four direction coordinates changes
// from the current cell
let direction = [ [ -1, 0 ], [ 0, 1 ],
                       [ 0, -1 ], [ 1, 0 ] ];
 
// Function that returns true if there
// exists any path from the top-left to
// the bottom-right cell of 0s
function dfs(matrix, i, j, N, M)
{
 
    // If the bottom-right cell is
    // reached
    if (i == N - 1 && j == M - 1) {
        return true;
    }
 
    // Update the cell to 1
    matrix[i][j] = 1;
 
    // Traverse in all four directions
    for (let k = 0; k < 4; k++) {
 
        // Find the new coordinates
        let newX = i + direction[k][0];
        let newY = j + direction[k][1];
 
        // If the new cell is valid
        if (newX >= 0 && newX < N
            && newY >= 0 && newY < M
            && matrix[newX][newY] == 0) {
 
            // Recursively call DFS
            if (dfs(matrix, newX,
                    newY, N, M)) {
 
                // If path exists, then
                // return true
                return true;
            }
        }
    }
 
    // Return false, if there doesn't
    // exists any such path
    return false;
}
 
// Function to flip the minimum number
// of cells such that there doesn't
// exists any such path from (0, 0) to
// (N - 1, M - 1) cell consisting of 0s
function solve(matrix)
{
 
    let N = matrix.length;
    let M = matrix[0].length;
 
    // Case 1: If no such path exists
    // already
    if (!dfs(matrix, 0, 0, N, M)) {
        return 0;
    }
 
    // Case 2: If there exists only
    // one path
    if (!dfs(matrix, 0, 0, N, M)) {
        return 1;
    }
 
    // Case 3: If there exists two-path
    return 2;
}
 
// Driver Code
    let mat = [
        [ 0, 1, 0, 0 ],
        [ 0, 1, 0, 0 ],
        [ 0, 0, 0, 0 ]
    ];
    document.write(solve(mat));
 
</script>
Output: 
1

 

Time Complexity: O(N + M) 
Auxiliary Space: O(1) 
 




My Personal Notes arrow_drop_up
Recommended Articles
Page :