Related Articles

# Find row with maximum and minimum number of zeroes in given Matrix

• Last Updated : 19 May, 2021

Given a 2D matrix containing only zeroes and ones, where each row is sorted. The task is to find the row with the maximum number of 0s and the row with minimum number of 0s.
Example:

Input: mat[][] = {
{0, 1, 1, 1},
{0, 0, 1, 1},
{1, 1, 1, 1},
{0, 0, 0, 0}}
Output:
Row with min zeroes: 3
Row with max zeroes: 4
Input: mat[][] = {
{0, 1, 1, 1},
{0, 0, 1, 1},
{0, 0, 0, 1},
{0, 0, 0, 0}}
Output:
Row with min zeroes: 1
Row with max zeroes: 4

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.

Simple approach: A simple method is to do a row-wise traversal of the matrix, count the number of 0s in each row, and compare the count with max and min. Finally, return the index of row with maximum 0s and minimum 0s. The time complexity of this method is O(M*N) where M is a number of rows and N is a number of columns in matrix.
Efficient approach: Since each row is sorted, we can use Binary Search to find the count of 0s in each row. The idea is to find the index of first instance of 1 in each row.
The count of 0s in that row will be:

• If 1 exists in the row, then count of 0s will be equal to the index of first 1 in the row considering zero-based indexing.
• If 1 does not exist in the row, then count of 0s will be N which is the total number of columns in the matrix.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;``#define R 4``#define C 4` `// Function to find the index of first 1``// in the binary array arr[]``int` `first(``bool` `arr[], ``int` `low, ``int` `high)``{``    ``if` `(high >= low) {` `        ``// Get the middle index``        ``int` `mid = low + (high - low) / 2;` `        ``// Check if the element at middle index is first 1``        ``if` `((mid == 0 || arr[mid - 1] == 0) && arr[mid] == 1)``            ``return` `mid;` `        ``// If the element is 0, recur for right side``        ``else` `if` `(arr[mid] == 0)``            ``return` `first(arr, (mid + 1), high);` `        ``// If element is not first 1, recur for left side``        ``else``            ``return` `first(arr, low, (mid - 1));``    ``}``    ``return` `-1;``}` `// Function to print rows with maximum``// and minimum number of zeroes``void` `rowWith0s(``bool` `mat[R][C])``{``    ``// Initialize max values``    ``int` `max_row_index = 0, max = INT_MIN;` `    ``// Initialize min values``    ``int` `min_row_index = 0, min = INT_MAX;` `    ``// Traverse for each row and count number of 0s``    ``// by finding the index of first 1``    ``int` `i, index;` `    ``for` `(i = 0; i < R; i++) {``        ``index = first(mat[i], 0, C - 1);` `        ``int` `cntZeroes = 0;` `        ``// If index = -1, that is there is no 1``        ``// in the row, count of zeroes will be C``        ``if` `(index == -1) {``            ``cntZeroes = C;``        ``}` `        ``// Else, count of zeroes will be index``        ``// of first 1``        ``else` `{``            ``cntZeroes = index;``        ``}` `        ``// Find max row index``        ``if` `(max < cntZeroes) {``            ``max = cntZeroes;``            ``max_row_index = i;``        ``}` `        ``// Find min row index``        ``if` `(min > cntZeroes) {``            ``min = cntZeroes;``            ``min_row_index = i;``        ``}``    ``}` `    ``cout << ``"Row with min 0s: "` `<< min_row_index + 1;``    ``cout << ``"\nRow with max 0s: "` `<< max_row_index + 1;``}` `// Driver code``int` `main()``{``    ``bool` `mat[R][C] = { { 0, 0, 0, 1 },``                       ``{ 0, 1, 1, 1 },``                       ``{ 1, 1, 1, 1 },``                       ``{ 0, 0, 0, 0 } };` `    ``rowWith0s(mat);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.io.*;` `class` `GFG``{``    ` `static` `int` `R = ``4``;``static` `int` `C = ``4``;` `// Function to find the index of first 1``// in the binary array arr[]``static` `int` `first(``int` `arr[], ``int` `low, ``int` `high)``{``    ``if` `(high >= low)``    ``{` `        ``// Get the middle index``        ``int` `mid = low + (high - low) / ``2``;` `        ``// Check if the element at middle index is first 1``        ``if` `((mid == ``0` `|| arr[mid - ``1``] == ``0``) && arr[mid] == ``1``)``            ``return` `mid;` `        ``// If the element is 0, recur for right side``        ``else` `if` `(arr[mid] == ``0``)``            ``return` `first(arr, (mid + ``1``), high);` `        ``// If element is not first 1, recur for left side``        ``else``            ``return` `first(arr, low, (mid - ``1``));``    ``}``    ``return` `-``1``;``}` `// Function to print rows with maximum``// and minimum number of zeroes``static` `void` `rowWith0s(``int` `mat[][])``{``    ``// Initialize max values``    ``int` `max_row_index = ``0``, max = Integer.MIN_VALUE;` `    ``// Initialize min values``    ``int` `min_row_index = ``0``, min = Integer.MAX_VALUE;` `    ``// Traverse for each row and count number of 0s``    ``// by finding the index of first 1``    ``int` `i, index;` `    ``for` `(i = ``0``; i < R; i++)``    ``{``        ``index = first(mat[i], ``0``, C - ``1``);` `        ``int` `cntZeroes = ``0``;` `        ``// If index = -1, that is there is no 1``        ``// in the row, count of zeroes will be C``        ``if` `(index == -``1``)``        ``{``            ``cntZeroes = C;``        ``}` `        ``// Else, count of zeroes will be index``        ``// of first 1``        ``else``        ``{``            ``cntZeroes = index;``        ``}` `        ``// Find max row index``        ``if` `(max < cntZeroes)``        ``{``            ``max = cntZeroes;``            ``max_row_index = i;``        ``}` `        ``// Find min row index``        ``if` `(min > cntZeroes)``        ``{``            ``min = cntZeroes;``            ``min_row_index = i;``        ``}``    ``}` `        ``System.out.println (``"Row with min 0s: "` `+ (min_row_index + ``1``));``        ``System.out.println (``"Row with max 0s: "` `+ (max_row_index + ``1``));``}` `// Driver code``public` `static` `void` `main (String[] args)``{` `    ``int` `mat[][] = { { ``0``, ``0``, ``0``, ``1` `},``                    ``{ ``0``, ``1``, ``1``, ``1` `},``                    ``{ ``1``, ``1``, ``1``, ``1` `},``                    ``{ ``0``, ``0``, ``0``, ``0` `} };` `    ``rowWith0s(mat);`  `}``}` `// This code is contributed by ajit.`

## Python3

 `# Python3 implementation of the approach` `import` `sys` `R ``=` `4``C ``=` `4` `# Function to find the index of first 1``# in the binary array arr[]``def` `first(arr, low, high) :` `    ``if` `(high >``=` `low) :` `        ``# Get the middle index``        ``mid ``=` `low ``+` `(high ``-` `low) ``/``/` `2``;` `        ``# Check if the element at middle index is first 1``        ``if` `((mid ``=``=` `0` `or` `arr[mid ``-` `1``] ``=``=` `0``) ``and` `arr[mid] ``=``=` `1``) :``            ``return` `mid;` `        ``# If the element is 0, recur for right side``        ``elif` `(arr[mid] ``=``=` `0``) :``            ``return` `first(arr, (mid ``+` `1``), high);` `        ``# If element is not first 1, recur for left side``        ``else` `:``            ``return` `first(arr, low, (mid ``-` `1``));``    ` `    ``return` `-``1``;`  `# Function to print rows with maximum``# and minimum number of zeroes``def` `rowWith0s(mat) :` `    ``# Initialize max values``    ``row_index ``=` `0``; ``max` `=` `-``(sys.maxsize ``-` `1``);` `    ``# Initialize min values``    ``min_row_index ``=` `0``; ``min` `=` `sys.maxsize;` `    ``# Traverse for each row and count number of 0s``    ``# by finding the index of first 1``    ` `    ``for` `i ``in` `range``(R) :``        ` `        ``index ``=` `first(mat[i], ``0``, C ``-` `1``);` `        ``cntZeroes ``=` `0``;` `        ``# If index = -1, that is there is no 1``        ``# in the row, count of zeroes will be C``        ``if` `(index ``=``=` `-``1``) :``            ``cntZeroes ``=` `C;` `        ``# Else, count of zeroes will be index``        ``# of first 1``        ``else` `:``            ``cntZeroes ``=` `index;` `        ``# Find max row index``        ``if` `(``max` `< cntZeroes) :``            ``max` `=` `cntZeroes;``            ``max_row_index ``=` `i;``        ` `        ``# Find min row index``        ``if` `(``min` `> cntZeroes) :``            ``min` `=` `cntZeroes;``            ``min_row_index ``=` `i;` `    ``print``(``"Row with min 0s:"``,min_row_index ``+` `1``);``    ``print``(``"Row with max 0s:"``, max_row_index ``+` `1``);`  `# Driver code``if` `__name__ ``=``=` `"__main__"` `:` `    ``mat ``=` `[``            ``[ ``0``, ``0``, ``0``, ``1` `],``            ``[ ``0``, ``1``, ``1``, ``1` `],``            ``[ ``1``, ``1``, ``1``, ``1` `],``            ``[ ``0``, ``0``, ``0``, ``0` `]``        ``];` `    ``rowWith0s(mat);` `    ``# This code is contributed by AnkitRai01`

## C#

 `// C# implementation of the approach``using` `System;    ``    ` `class` `GFG``{``    ` `static` `int` `R = 4;``static` `int` `C = 4;` `// Function to find the index of first 1``// in the binary array arr[]``static` `int` `first(``int` `[]arr, ``int` `low, ``int` `high)``{``    ``if` `(high >= low)``    ``{` `        ``// Get the middle index``        ``int` `mid = low + (high - low) / 2;` `        ``// Check if the element at middle index is first 1``        ``if` `((mid == 0 || arr[mid - 1] == 0) && arr[mid] == 1)``            ``return` `mid;` `        ``// If the element is 0, recur for right side``        ``else` `if` `(arr[mid] == 0)``            ``return` `first(arr, (mid + 1), high);` `        ``// If element is not first 1, recur for left side``        ``else``            ``return` `first(arr, low, (mid - 1));``    ``}``    ``return` `-1;``}` `// Function to print rows with maximum``// and minimum number of zeroes``static` `void` `rowWith0s(``int` `[,]mat)``{``    ``// Initialize max values``    ``int` `max_row_index = 0, max = ``int``.MinValue;` `    ``// Initialize min values``    ``int` `min_row_index = 0, min = ``int``.MaxValue;` `    ``// Traverse for each row and count number of 0s``    ``// by finding the index of first 1``    ``int` `i, index;` `    ``for` `(i = 0; i < R; i++)``    ``{``        ``index = first(GetRow(mat,i), 0, C - 1);` `        ``int` `cntZeroes = 0;` `        ``// If index = -1, that is there is no 1``        ``// in the row, count of zeroes will be C``        ``if` `(index == -1)``        ``{``            ``cntZeroes = C;``        ``}` `        ``// Else, count of zeroes will be index``        ``// of first 1``        ``else``        ``{``            ``cntZeroes = index;``        ``}` `        ``// Find max row index``        ``if` `(max < cntZeroes)``        ``{``            ``max = cntZeroes;``            ``max_row_index = i;``        ``}` `        ``// Find min row index``        ``if` `(min > cntZeroes)``        ``{``            ``min = cntZeroes;``            ``min_row_index = i;``        ``}``    ``}` `        ``Console.WriteLine (``"Row with min 0s: "` `+ (min_row_index + 1));``        ``Console.WriteLine (``"Row with max 0s: "` `+ (max_row_index + 1));``}` `public` `static` `int``[] GetRow(``int``[,] matrix, ``int` `row)``{``    ``var` `rowLength = matrix.GetLength(1);``    ``var` `rowVector = ``new` `int``[rowLength];` `    ``for` `(``var` `i = 0; i < rowLength; i++)``    ``rowVector[i] = matrix[row, i];` `    ``return` `rowVector;``}` `// Driver code``public` `static` `void` `Main (String[] args)``{` `    ``int` `[,]mat = { { 0, 0, 0, 1 },``                    ``{ 0, 1, 1, 1 },``                    ``{ 1, 1, 1, 1 },``                    ``{ 0, 0, 0, 0 } };` `    ``rowWith0s(mat);`  `}``}` `/* This code contributed by PrinciRaj1992 */`

## Javascript

 ``
Output:
```Row with min 0s: 3
Row with max 0s: 4```

My Personal Notes arrow_drop_up