# 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[] = { { -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 >& 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];``        ``int` `newY = j + direction[k];` `        ``// 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 >& matrix)``{` `    ``int` `N = matrix.size();``    ``int` `M = matrix.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 > 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

 ``
Output:
`1`

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

My Personal Notes arrow_drop_up