Minimize count of steps to make all Matrix elements as 0 by replacing neighbours of K with 0

• Last Updated : 06 Nov, 2021

Given a 2-D array matrix[][] of size M*N and an integer K. For each occurrence of K in the matrix[][], replace K and all the non-zero adjacent elements to its left, right, top, and bottom with 0. The program must repeat the process until all the values in the matrix become zero. The task is to find the minimum number of steps required to convert the given array matrix[][] to 0. If it’s impossible, then print -1.

Note: One step is defined as choosing an index with value K and changing its value to 0 along with it’s adjacent cells until either all the cells become 0 or index goes out of range.

Examples:

Input: M = 5, N = 5,
matrix = {{5, 6, 0, 5, 6},
{1, 8, 8, 0, 2},
{5, 5, 5, 0, 6},
{4, 5, 5, 5, 0},
{8, 8, 8, 8, 8}},
K = 6
Output: 2
Explanation: First occurrence of 6 is found at matrix, So all the non-zero adjacent elements of left, right, top and bottom becomes zero i.e.
5 6                           0 0
1 8 8                         0 0 0
5 5 5                —>     0 0 0
4 5 5 5                       0 0 0 0
8 8 8 8 8                     0 0 0 0
So, After performing the process for the first occurrence of 6, the matrix becomes
0 0 0 5 6
0 0 0 0 2
0 0 0 0 6
0 0 0 0 0
0 0 0 0 0
Second occurrence of 6 is found at matrix, So all the non -zero adjacent elements of left, right, top and bottom becomes zero After performing the process for the second occurrence of 6, the matrix becomes
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
Now, all the cell values in the matrix become zero. Hence the output is 2

Input: M = 4, N = 5,
matrix = {{5, 0, 0, 5, 6},
{1, 0, 8, 1, 0},
{0, 5, 0, 0, 6},
{4, 5, 0, 5, 2}},
K = 5
Output: 4

Approach: The idea is to traverse the matrix in all four directions left, right, top and bottom, and on finding a cell with value K, use depth-first search to change the value of all adjacent elements to 0. Follow the steps below to solve this problem:

• Initialize the variable interations_count to 0
• Iterate over the range [0, M) using the variable row and perform the following tasks:
• Iterate over the range [0, N) using the variable col and perform the following tasks:
• If matrix[row][col] equals K, then perform DFS using recursion to change all the possible element’s values to 0. Also increase the value of iterations_count by 1.
• After performing the above steps, check if any cell’s value is non-zero. If yes, then print -1, else print the value of iterations_count as the answer.

Below is the implementation of the above approach

C++

 // C++ code for the above approach#include using namespace std; // Function to implement DFSvoid traverse(int M, int N, vector >& matrix,              int row, int col){     // Check the boundary conditions    if (row >= 0 && row < M && col >= 0 && col < N) {        if (matrix[row][col] == 0) {            return;        }         // Change that non-zero        // adjacent element to zero        matrix[row][col] = 0;         // Traverse the matrix in left        traverse(M, N, matrix, row, col - 1);         // Traverse the matrix in Right        traverse(M, N, matrix, row, col + 1);         // Traverse the matrix in Top        traverse(M, N, matrix, row - 1, col);         //// Traverse the matrix in Bottom        traverse(M, N, matrix, row + 1, col);    }} void findCount(int M, int N, vector >& matrix,               int K){     int iterations_count = 0;     // Traverse the matrix and find any element    // equals K, if any elements is found    // increment the interations_count variable    // and pass the element to the traverse function    for (int row = 0; row < M; row++) {        for (int col = 0; col < N; col++) {            if (K == matrix[row][col]) {                iterations_count++;                traverse(M, N, matrix, row, col);            }        }    }     for (int i = 0; i < M; i++) {        for (int j = 0; j < N; j++) {            if (matrix[i][j] != 0) {                iterations_count = -1;            }        }    }     // Print the iterations count    cout << iterations_count;} int main(){     // Initialize the values of M and N    int M = 5, N = 5;     // Assigning the elements of 5*5 matrix    vector > matrix = { { 5, 6, 0, 5, 6 },                                    { 1, 8, 8, 0, 2 },                                    { 5, 5, 5, 0, 6 },                                    { 4, 5, 5, 5, 0 },                                    { 8, 8, 8, 8, 8 } };     // Assign K as 6    int K = 6;     findCount(M, N, matrix, K);    return 0;} // This code is contributed by Potta Lokesh

Java

 // Java program for the above approachpublic class GFG { // Function to implement DFSstatic void traverse(int M, int N,int matrix[][],int row, int col){     // Check the boundary conditions    if (row >= 0 && row < M        && col >= 0 && col < N) {        if (matrix[row][col] == 0) {            return;        }         // Change that non-zero        // adjacent element to zero        matrix[row][col] = 0;         // Traverse the matrix in left        traverse(M, N, matrix, row, col - 1);         // Traverse the matrix in Right        traverse(M, N, matrix, row, col + 1);         // Traverse the matrix in Top        traverse(M, N, matrix, row - 1, col);         //// Traverse the matrix in Bottom        traverse(M, N, matrix, row + 1, col);    }} static void findCount(int M, int N, int matrix[][],int K){     int iterations_count = 0;     // Traverse the matrix and find any element    // equals K, if any elements is found    // increment the interations_count variable    // and pass the element to the traverse function    for (int row = 0; row < M; row++) {        for (int col = 0; col < N; col++) {            if (K == matrix[row][col]) {                iterations_count++;                traverse(M, N, matrix, row, col);            }        }    }     for (int i = 0; i < M; i++) {        for (int j = 0; j < N; j++) {            if (matrix[i][j] != 0) {                iterations_count = -1;            }        }    }     // Print the iterations count    System.out.print(iterations_count);} // Driver Codepublic static void main(String []args){     // Initialize the values of M and N    int M = 5, N = 5;     // Assigning the elements of 5*5 matrix    int matrix[][] = {            { 5, 6, 0, 5, 6 },            { 1, 8, 8, 0, 2 },            { 5, 5, 5, 0, 6 },            { 4, 5, 5, 5, 0 },            { 8, 8, 8, 8, 8 } };     // Assign K as 6    int K = 6;     findCount(M, N, matrix, K); } } // This code is contributed by AnkThon

Python3

 # python program for the above approach # Function to implement DFSdef traverse(M,  N, matrix, row, col):     # Check the boundary conditions    if (row >= 0 and row < M and col >= 0 and col < N):        if (matrix[row][col] == 0):            return         # Change that non-zero        # adjacent element to zero        matrix[row][col] = 0         # Traverse the matrix in left        traverse(M, N, matrix, row, col - 1)         # Traverse the matrix in Right        traverse(M, N, matrix, row, col + 1)         # Traverse the matrix in Top        traverse(M, N, matrix, row - 1, col)         # Traverse the matrix in Bottom        traverse(M, N, matrix, row + 1, col)  def findCount(M, N, matrix, K):    iterations_count = 0     # Traverse the matrix and find any element    # equals K, if any elements is found    # increment the interations_count variable    # and pass the element to the traverse function    for row in range(0, M):        for col in range(0, N):            if (K == matrix[row][col]):                iterations_count += 1                traverse(M, N, matrix, row, col)     for i in range(0, M):        for j in range(0, N):            if (matrix[i][j] != 0):                iterations_count = -1     # Print the iterations count    print(iterations_count) # Driver Codeif __name__ == "__main__":     # Initialize the values of M and N    M = 5    N = 5     # Assigning the elements of 5*5 matrix    matrix = [[5, 6, 0, 5, 6],              [1, 8, 8, 0, 2],              [5, 5, 5, 0, 6],              [4, 5, 5, 5, 0],              [8, 8, 8, 8, 8]]     # Assign K as 6    K = 6    findCount(M, N, matrix, K)     # This code is contributed by rakeshsahni

C#

 // C# program for the above approachusing System; public class GFG {     // Function to implement DFS    static void traverse(int M, int N,int [,]matrix,int row, int col)    {             // Check the boundary conditions        if (row >= 0 && row < M            && col >= 0 && col < N) {            if (matrix[row, col] == 0) {                return;            }                 // Change that non-zero            // adjacent element to zero            matrix[row, col] = 0;                 // Traverse the matrix in left            traverse(M, N, matrix, row, col - 1);                 // Traverse the matrix in Right            traverse(M, N, matrix, row, col + 1);                 // Traverse the matrix in Top            traverse(M, N, matrix, row - 1, col);                 //// Traverse the matrix in Bottom            traverse(M, N, matrix, row + 1, col);        }    }         static void findCount(int M, int N, int [,]matrix,int K)    {             int iterations_count = 0;             // Traverse the matrix and find any element        // equals K, if any elements is found        // increment the interations_count variable        // and pass the element to the traverse function        for (int row = 0; row < M; row++) {            for (int col = 0; col < N; col++) {                if (K == matrix[row, col]) {                    iterations_count++;                    traverse(M, N, matrix, row, col);                }            }        }             for (int i = 0; i < M; i++) {            for (int j = 0; j < N; j++) {                if (matrix[i,j] != 0) {                    iterations_count = -1;                }            }        }             // Print the iterations count        Console.WriteLine(iterations_count);    } // Driver Codepublic static void Main(String []args){     // Initialize the values of M and N    int M = 5, N = 5;     // Assigning the elements of 5*5 matrix    int [,]matrix = {            { 5, 6, 0, 5, 6 },            { 1, 8, 8, 0, 2 },            { 5, 5, 5, 0, 6 },            { 4, 5, 5, 5, 0 },            { 8, 8, 8, 8, 8 } };     // Assign K as 6    int K = 6;     findCount(M, N, matrix, K); } } // This code is contributed by AnkThon

Javascript


Output
2

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

My Personal Notes arrow_drop_up