Find the row with maximum number of 1s

Given a boolean 2D array, where each row is sorted. Find the row with the maximum number of 1s. 

Example:

Input matrix : 0 1 1 1
                        0 0 1 1
                        1 1 1 1  // this row has maximum 1s
                        0 0 0 0
Output: 2

A simple method is to do a row-wise traversal of the matrix, count the number of 1s in each row, and compare the count with the max. Finally, return the index of the row with a maximum of 1s. The time complexity of this method is O(m*n) where m is the number of rows and n is the number of columns in the matrix.

Implementation:

C++

// CPP program to find the row
// with maximum number of 1s
#include <bits/stdc++.h>
using namespace std;
#define R 4
#define C 4

// Function that returns index of row
// with maximum number of 1s.
int rowWithMax1s(bool mat[R][C]) {
    // code here
    int rowIndex = -1 ;
    int maxCount = 0 ;

    for(int i = 0 ; i < R ; i++){
        int count = 0 ;
        for(int j = 0 ; j < C ; j++ ){
            if(mat[i][j] == 1){
                count++ ;
            }
        }
        if(count > maxCount){
            maxCount = count ;
            rowIndex = i ;
        }
    }

    return rowIndex ;
}


// Driver Code
int main()
{
    bool mat[R][C] = { {0, 0, 0, 1},
                    {0, 1, 1, 1},
                    {1, 1, 1, 1},
                    {0, 0, 0, 0}};

    cout << "Index of row with maximum 1s is " << rowWithMax1s(mat);

    return 0;
}

C

// C program to find the row with maximum number of 1s.
#include<stdio.h>
#include<stdbool.h>

#define R 4
#define C 4

// Function that returns index of row
// with maximum number of 1s.
int rowWithMax1s(bool mat[R][C]) {
    int indexOfRowWithMax1s = -1 ;
    int maxCount = 0 ;

    // Visit each row.
    // Count number of 1s.
    /* If count is more that the maxCount then update the maxCount
    and store the index of current row in indexOfRowWithMax1s variable. */
    for(int i = 0 ; i < R ; i++){
        int count = 0 ;
        for(int j = 0 ; j < C ; j++ ){
            if(mat[i][j] == 1){
                count++ ;
            }
        }
        if(count > maxCount){
            maxCount = count ;
            indexOfRowWithMax1s = i ;
        }
    }

    return indexOfRowWithMax1s ;
}

 // Driver Code
int main()
{
    bool mat[R][C] = { {0, 0, 0, 1},
                    {0, 1, 1, 1},
                    {1, 1, 1, 1},
                    {0, 0, 0, 0}};

    int indexOfRowWithMax1s = rowWithMax1s(mat);
    printf("Index of row with maximum 1s is %d",indexOfRowWithMax1s);

    return 0;
}

// This code is contributed by Rohit_Dwivedi

Java

// Java program for the above approach
import java.util.*;

class GFG {

static int R = 4 ;
static int C  = 4 ;

// Function to find the index of first index
// of 1 in a boolean 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 that returns index of row
// with maximum number of 1s.
static int rowWithMax1s(int mat[][])
{
    // Initialize max values
    int max_row_index = 0, max = -1;

    // Traverse for each row and count number of 1s
    // by finding the index of first 1
    int i, index;
    for (i = 0; i < R; i++)
    {
        index = first (mat[i], 0, C-1);
        if (index != -1 && C-index > max)
        {
            max = C - index;
            max_row_index = i;
        }
    }

    return max_row_index;
}

    // 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}};

    System.out.print("Index of row with maximum 1s is " + rowWithMax1s(mat));

    }
}

Python3

# Python implementation of the approach
R,C = 4,4

# Function to find the index of first index
# of 1 in a boolean 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 that returns index of row
# with maximum number of 1s.
def rowWithMax1s(mat):

    # Initialize max values
    max_row_index,Max = 0,-1

    # Traverse for each row and count number of 1s
    # by finding the index of first 1
    for i in range(R):

        index = first (mat[i], 0, C-1)
        if (index != -1 and C-index > Max):
            Max = C - index;
            max_row_index = i

    return max_row_index

# Driver Code
mat = [[0, 0, 0, 1],
       [0, 1, 1, 1],
       [1, 1, 1, 1],
       [0, 0, 0, 0]]
print("Index of row with maximum 1s is " + str(rowWithMax1s(mat)))

# This code is contributed by shinjanpatra

C#

// C# program for the above approach
using System;
using System.Collections.Generic;

public class GFG {

  static int R = 4;
  static int C = 4;

  // Function to find the index of first index
  // of 1 in a bool 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;
  }
  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;
  }

  // Function that returns index of row
  // with maximum number of 1s.
  static int rowWithMax1s(int [,]mat)
  {

    // Initialize max values
    int max_row_index = 0, max = -1;

    // Traverse for each row and count number of 1s
    // by finding the index of first 1
    int i, index;
    for (i = 0; i < R; i++) {
      int []row = GetRow(mat,i);
      index = first(row, 0, C - 1);
      if (index != -1 && C - index > max) {
        max = C - index;
        max_row_index = i;
      }
    }

    return max_row_index;
  }

  // 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 } };

    Console.Write("Index of row with maximum 1s is " + rowWithMax1s(mat));

  }
}

// This code is contributed by Rajput-Ji

Javascript

<script>
// javascript program for the above approach

var R = 4 ;
var C  = 4 ;

// Function to find the index of first index
// of 1 in a boolean array arr
function first(arr , low , high)
{
    if(high >= low)
    {
        // Get the middle index
        var mid = low + parseInt((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 that returns index of row
// with maximum number of 1s.
function rowWithMax1s(mat)
{

    // Initialize max values
    var max_row_index = 0, max = -1;

    // Traverse for each row and count number of 1s
    // by finding the index of first 1
    var i, index;
    for (i = 0; i < R; i++)
    {
        index = first (mat[i], 0, C-1);
        if (index != -1 && C-index > max)
        {
            max = C - index;
            max_row_index = i;
        }
    }
    return max_row_index;
}

    // Driver Code
        var mat = [[0, 0, 0, 1],
                [0, 1, 1, 1],
                [1, 1, 1, 1],
                [0, 0, 0, 0]];
    document.write("Index of row with maximum 1s is " + rowWithMax1s(mat));

// This code is contributed by Rajput-Ji
</script>

Output

Index of row with maximum 1s is 2

Time Complexity:  O(m*n)
Auxiliary Space:  O(1)

We can do better. Since each row is sorted, we can use Binary Search to count 1s in each row. We find the index of the first instance of 1 in each row. The count of 1s will be equal to the total number of columns minus the index of the first 1.

Implementation: See the following code for the implementation of the above approach.  

C++

// CPP program to find the row
// with maximum number of 1s
#include <bits/stdc++.h>
using namespace std;
#define R 4
#define C 4

// Function to find the index of first instance
// of 1 in a boolean 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 that returns index of row
// with maximum number of 1s.
int rowWithMax1s(bool mat[R][C])
{
    // Initialize max values
    int max_row_index = 0, max = -1;

    // Traverse for each row and count number of 1s
    // by finding the index of first 1
    int i, index;
    for (i = 0; i < R; i++)
    {
        index = first (mat[i], 0, C-1);
        if (index != -1 && C-index > max)
        {
            max = C - index;
            max_row_index = i;
        }
    }

    return max_row_index;
}

// Driver Code
int main()
{
    bool mat[R][C] = { {0, 0, 0, 1},
                    {0, 1, 1, 1},
                    {1, 1, 1, 1},
                    {0, 0, 0, 0}};

    cout << "Index of row with maximum 1s is " << rowWithMax1s(mat);

    return 0;
}

// This is code is contributed by rathbhupendra

C

// C program to find the row
// with maximum number of 1s
#include <stdio.h>
#define R 4
#define C 4

// Function to find the index of first index
// of 1 in a boolean 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 that returns index of row
// with maximum number of 1s.
int rowWithMax1s(bool mat[R][C])
{
    // Initialize max values
    int max_row_index = 0, max = -1;

    // Traverse for each row and count number of 1s
    // by finding the index of first 1
    int i, index;
    for (i = 0; i < R; i++)
    {
    index = first (mat[i], 0, C-1);
    if (index != -1 && C-index > max)
    {
        max = C - index;
        max_row_index = i;
    }
    }

    return max_row_index;
}

// Driver Code
int main()
{
    bool mat[R][C] = { {0, 0, 0, 1},
                       {0, 1, 1, 1},
                       {1, 1, 1, 1},
                       {0, 0, 0, 0}};

    printf("Index of row with maximum 1s is %d "
                                , rowWithMax1s(mat));

    return 0;
}

Java

// Java program to find the row
// with maximum number of 1s
import java.io.*;

class GFG {
    static int R = 4, C = 4;
    // Function to find the index of first index
    // of 1 in a boolean 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 that returns index of row
    // with maximum number of 1s.
    static int rowWithMax1s(int mat[][])
    {
        // Initialize max values
        int max_row_index = 0, max = -1;

        // Traverse for each row and count number of
        // 1s by finding the index of first 1
        int i, index;
        for (i = 0; i < R; i++) {
            index = first(mat[i], 0, C - 1);
            if (index != -1 && C - index > max) {
                max = C - index;
                max_row_index = i;
            }
        }

        return max_row_index;
    }
    // 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 } };
        System.out.println("Index of row with maximum 1s is "
                                            + rowWithMax1s(mat));
    }
}

// This code is contributed by 'Gitanjali'.

Python3

# Python3 program to find the row
# with maximum number of 1s

# Function to find the index
# of first index of 1 in a
# boolean 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 that returns
# index of row with maximum
# number of 1s.
def rowWithMax1s( mat):

    # Initialize max values
    R = len(mat)
    C = len(mat[0])
    max_row_index = 0
    max = -1

    # Traverse for each row and
    # count number of 1s by finding
    #  the index of first 1
    for i in range(0, R):
        index = first (mat[i], 0, C - 1)
        if index != -1 and C - index > max:
            max = C - index
            max_row_index = i

    return max_row_index

# Driver Code
mat = [[0, 0, 0, 1],
       [0, 1, 1, 1],
       [1, 1, 1, 1],
       [0, 0, 0, 0]]
print ("Index of row with maximum 1s is",
      rowWithMax1s(mat))

# This code is contributed
# by shreyanshi_arun

C#

// C# program to find the row with maximum
// number of 1s
using System;

class GFG
{
public static int R = 4, C = 4;

// Function to find the index of first index
// of 1 in a boolean array arr[]
public 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 that returns index of row
// with maximum number of 1s.
public static int rowWithMax1s(int[][] mat)
{
    // Initialize max values
    int max_row_index = 0, max = -1;

    // Traverse for each row and count number
    // of 1s by finding the index of first 1
    int i, index;
    for (i = 0; i < R; i++)
    {
        index = first(mat[i], 0, C - 1);
        if (index != -1 && C - index > max)
        {
            max = C - index;
            max_row_index = i;
        }
    }

    return max_row_index;
}

// Driver Code
public static void Main(string[] args)
{
    int[][] mat = new int[][]
    {
        new int[] {0, 0, 0, 1},
        new int[] {0, 1, 1, 1},
        new int[] {1, 1, 1, 1},
        new int[] {0, 0, 0, 0}
    };
    Console.WriteLine("Index of row with maximum 1s is " +
                                       rowWithMax1s(mat));
}
}

// This code is contributed by Shrikant13

PHP

<?php
// PHP program to find the row
// with maximum number of 1s
define("R", 4);
define("C", 4);

// Function to find the index of first
// index of 1 in a boolean array arr[]
function first($arr, $low, $high)
{
    if($high >= $low)
    {
        // Get the middle index
        $mid = $low + intval(($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 that returns index of row
// with maximum number of 1s.
function rowWithMax1s($mat)
{

    // Initialize max values
    $max_row_index = 0;
    $max = -1;

    // Traverse for each row and count number
    // of 1s by finding the index of first 1

    for ($i = 0; $i < R; $i++)
    {
    $index = first ($mat[$i], 0, (C - 1));
    if ($index != -1 && (C - $index) > $max)
    {
        $max = C - $index;
        $max_row_index = $i;
    }
    }

    return $max_row_index;
}

// Driver Code
$mat = array(array(0, 0, 0, 1),
             array(0, 1, 1, 1),
             array(1, 1, 1, 1),
             array(0, 0, 0, 0));

echo "Index of row with maximum 1s is " .
                      rowWithMax1s($mat);

// This code is contributed by rathbhupendra
?>

Javascript

<script>
    // JavaScript program to find the row
    // with maximum number of 1s

    R = 4
    C = 4

    // Function to find the index of first index
    // of 1 in a boolean array arr[]
    const first = (arr, low, high) => {
        if (high >= low) {
            // Get the middle index
            let mid = low + parseInt((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 that returns index of row
    // with maximum number of 1s.
    const rowWithMax1s = (mat) => {
        // Initialize max values
        let max_row_index = 0, max = -1;

        // Traverse for each row and count number of 1s
        // by finding the index of first 1
        let i, index;
        for (i = 0; i < R; i++) {
            index = first(mat[i], 0, C - 1);
            if (index != -1 && C - index > max) {
                max = C - index;
                max_row_index = i;
            }
        }

        return max_row_index;
    }

    // Driver Code

    let mat = [
        [0, 0, 0, 1],
        [0, 1, 1, 1],
        [1, 1, 1, 1],
        [0, 0, 0, 0]
    ];

    document.write(`Index of row with maximum 1s is ${rowWithMax1s(mat)}`);

    // This code is contributed by rakeshsahni

</script>

Output

Index of row with maximum 1s is 2

Time Complexity: O(m log n) where m is the number of rows and n is the number of columns in the matrix.
Auxiliary Space:  O(log n), as implicit stack is created due to recursion.

The above solution can be optimized further. Instead of doing a binary search in every row, we first check whether the row has more 1s than max so far. If the row has more 1s, then only count 1s in the row. Also, to count 1s in a row, we don’t do a binary search in a complete row, we do a search before the index of the last max. 

Implementation: Following is an optimized version of the above solution.  

C++

#include <bits/stdc++.h>
using namespace std;

// The main function that returns index
// of row with maximum number of 1s.
int rowWithMax1s(bool mat[R][C])
{
    int i, index;

    // Initialize max using values from first row.
    int max_row_index = 0;
    int max = first(mat[0], 0, C - 1);

    // Traverse for each row and count number of 1s
    // by finding the index of first 1
    for (i = 1; i < R; i++)
    {
        // Count 1s in this row only if this row
        // has more 1s than max so far

        // Count 1s in this row only if this row
        // has more 1s than max so far
        if (max != -1 && mat[i][C - max - 1] == 1)
        {
            // Note the optimization here also
            index = first (mat[i], 0, C - max);

            if (index != -1 && C - index > max)
            {
                max = C - index;
                max_row_index = i;
            }
        }
        else
        {
            max = first(mat[i], 0, C - 1);
        }
    }
    return max_row_index;
}

// This code is contributed by rathbhupendra

C

// The main function that returns index of row with maximum number of 1s.
int rowWithMax1s(bool mat[R][C])
{
    int i, index;

    // Initialize max using values from first row.
    int max_row_index = 0;
    int max = first(mat[0], 0, C-1);

    // Traverse for each row and count number of 1s by finding the index
    // of first 1
    for (i = 1; i < R; i++)
    {
        // Count 1s in this row only if this row has more 1s than
        // max so far

        // Count 1s in this row only if this row has more 1s than
        // max so far
        if (max != -1 && mat[i][C-max-1] == 1)
        {
            // Note the optimization here also
            index = first (mat[i], 0, C-max);

            if (index != -1 && C-index > max)
            {
                max = C - index;
                max_row_index = i;
            }
        }
        else {
            max = first(mat[i], 0, C - 1);
        }
    }
    return max_row_index;
}

Java

public class gfg
{
  // The main function that returns index
  // of row with maximum number of 1s.
  static int rowWithMax1s(boolean mat[][])
  {
    int i, index;

    // Initialize max using values from first row.
    int max_row_index = 0;
    int max = first(mat[0], 0, C - 1);

    // Traverse for each row and count number of 1s
    // by finding the index of first 1
    for (i = 1; i < R; i++)
    {

      // Count 1s in this row only if this row
      // has more 1s than max so far

      // Count 1s in this row only if this row
      // has more 1s than max so far
      if (max != -1 && mat[i][C - max - 1] == 1)
      {
        // Note the optimization here also
        index = first (mat[i], 0, C - max);

        if (index != -1 && C - index > max)
        {
          max = C - index;
          max_row_index = i;
        }
      }
      else
      {
        max = first(mat[i], 0, C - 1);
      }
    }
    return max_row_index;
  }
}

// This code is contributed by divyesh072019.

Python3

# The main function that returns index
# of row with maximum number of 1s.
def rowWithMax1s(mat) :

    # Initialize max using values from first row.
    max_row_index = 0;
    max = first(mat[0], 0, C - 1)

    # Traverse for each row and count number of 1s
    # by finding the index of first 1
    for i in range(1, R):

        # Count 1s in this row only if this row
        # has more 1s than max so far

        # Count 1s in this row only if this row
        # has more 1s than max so far
        if (max != -1 and mat[i][C - max - 1] == 1):

            # Note the optimization here also
            index = first (mat[i], 0, C - max)

            if (index != -1 and C - index > max):
                max = C - index
                max_row_index = i
        else:
            max = first(mat[i], 0, C - 1)

    return max_row_index;

# This code is contributed by Dharanendra L V

C#

using System;
class GFG
{

    // The main function that returns index
    // of row with maximum number of 1s.
    static int rowWithMax1s(bool[,] mat)
    {
        int i, index;

        // Initialize max using values from first row.
        int max_row_index = 0;
        int max = first(mat[0], 0, C - 1);

        // Traverse for each row and count number of 1s
        // by finding the index of first 1
        for (i = 1; i < R; i++)
        {

            // Count 1s in this row only if this row
            // has more 1s than max so far

            // Count 1s in this row only if this row
            // has more 1s than max so far
            if (max != -1 && mat[i,C - max - 1] == 1)
            {
                // Note the optimization here also
                index = first (mat[i], 0, C - max);

                if (index != -1 && C - index > max)
                {
                    max = C - index;
                    max_row_index = i;
                }
            }
            else
            {
                max = first(mat[i], 0, C - 1);
            }
        }
        return max_row_index;
    }
}

// This code is contributed by divyeshrabadiya07.

Javascript

<script>

// The main function that returns index
// of row with maximum number of 1s.
function rowWithMax1s(mat)
{
    let i, index;

    // Initialize max using values from first row.
    let max_row_index = 0;
    let max = first(mat[0], 0, C - 1);

    // Traverse for each row and count number of 1s
    // by finding the index of first 1
    for(i = 1; i < R; i++)
    {

        // Count 1s in this row only if this row
        // has more 1s than max so far

        // Count 1s in this row only if this row
        // has more 1s than max so far
        if (max != -1 && mat[i][C - max - 1] == 1)
        {

            // Note the optimization here also
            index = first (mat[i], 0, C - max);

            if (index != -1 && C - index > max)
            {
                max = C - index;
                max_row_index = i;
            }
        }
        else
        {
            max = first(mat[i], 0, C - 1);
        }
    }
    return max_row_index;
}

// This code is contributed by suresh07

</script>

 Time complexity: O(m log n), 
Auxiliary Space:  O(log n)

Thanks to Naveen Kumar Singh for suggesting the above solution. 

The worst case of the above solution occurs for a matrix like following. 
0 0 0 … 0 1 
0 0 0 ..0 1 1 
0 … 0 1 1 1 
….0 1 1 1 1

Following method works in O(m+n) time complexity in worst case. 

• Step1: Get the index of first (or leftmost) 1 in the first row.
• Step2: Do following for every row after the first row 
  • …IF the element on left of previous leftmost 1 is 0, ignore this row. 
  • …ELSE Move left until a 0 is found. Update the leftmost index to this index and max_row_index to be the current row.
  • The time complexity is O(m+n) because we can possibly go as far left as we came ahead in the first step.

Implementation: Following is the implementation of this method.

C++

// C++ program to find the row with maximum
// number of 1s
#include <bits/stdc++.h>
using namespace std;
#define R 4
#define C 4
// The main function that returns index of row with maximum
// number of 1s.
int rowWithMax1s(bool mat[R][C])
{
    // Initialize first row as row with max 1s
    int j,max_row_index = 0;
    j = C - 1;

    for (int i = 0; i < R; i++) {
        // Move left until a 0 is found
      bool flag=false; //to check whether a row has more 1's than previous
        while (j >= 0 && mat[i][j] == 1) {
            j = j - 1; // Update the index of leftmost 1
                       // seen so far
          flag=true ;//present row has more 1's than previous
          }
      // if the present row has more 1's than previous
      if(flag){
            max_row_index = i; // Update max_row_index
        }
    }
      if(max_row_index==0&&mat[0][C-1]==0)
            return -1;
    return max_row_index;
}
// Driver Code
int main()
{
    bool mat[R][C] = { {0, 0, 0, 1},
                    {0, 1, 1, 1},
                    {1, 1, 1, 1},
                    {0, 0, 0, 0}};

    cout << "Index of row with maximum 1s is " << rowWithMax1s(mat);

    return 0;
}
// this code is contributed by Rishabh Chauhan

Java

// Java program to find the row
// with maximum number of 1s
import java.io.*;

class GFG {
    static int R = 4, C = 4;
    // Function that returns index of row
    // with maximum number of 1s.
    static int rowWithMax1s(int mat[][])
    {
        // Initialize first row as row with max 1s
        int j,max_row_index = 0;
            j = C - 1;

        for (int i = 0; i < R; i++) {
            // Move left until a 0 is found
            while (j >= 0 && mat[i][j] == 1) {
                j = j - 1; // Update the index of leftmost 1
                       // seen so far
                max_row_index = i; // Update max_row_index
            }
        }
          if(max_row_index==0&&mat[0][C-1]==0)
              return -1;
        return max_row_index;
    }
    // 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 } };
        System.out.println("Index of row with maximum 1s is "+ rowWithMax1s(mat));
    }
}

// This code is contributed by 'Rishabh Chauhan'.

Python3

# Python3 program to find the row
# with maximum number of 1s

# Function that returns
# index of row with maximum
# number of 1s.
def rowWithMax1s( mat):

    # Initialize max values
    R = len(mat)
    C = len(mat[0])
    max_row_index = 0
    index=C-1;
    # Traverse for each row and
    # count number of 1s by finding
    # the index of first 1
    for i in range(0, R):
      flag=False #to check whether a row has more 1's than previous
      while(index >=0 and mat[i][index]==1):
        flag=True #present row has more 1's than previous
        index-=1
        if(flag): #if the present row has more 1's than previous
          max_row_index = i
      if max_row_index==0 and mat[0][C-1]==0:
        return 0;
    return max_row_index

# Driver Code
mat = [[0, 0, 0, 1],
    [0, 1, 1, 1],
    [1, 1, 1, 1],
    [0, 0, 0, 0]]
print ("Index of row with maximum 1s is",
    rowWithMax1s(mat))

# This code is contributed
# by Rishabh Chauhan

C#

// C# program to find the row with maximum
// number of 1s
using System;

class GFG
{
public static int R = 4, C = 4;


// Function that returns index of row
// with maximum number of 1s.
public static int rowWithMax1s(int[][] mat)
{
    // Initialize max values
    int max_row_index = 0;

    int i, index;
    index=C-1;
    for (i = 0; i < R; i++)
    {

        if (index >=0 && mat[i][index]==1)
        {
            index-=1;
            max_row_index = i;
        }
    }
    if (max_row_index==0&&mat[0][C-1]==0)
        return 0;
    return max_row_index;
}

// Driver Code
public static void Main(string[] args)
{
    int[][] mat = new int[][]
    {
        new int[] {0, 0, 0, 1},
        new int[] {0, 1, 1, 1},
        new int[] {1, 1, 1, 1},
        new int[] {0, 0, 0, 0}
    };
    Console.WriteLine("Index of row with maximum 1s is " +rowWithMax1s(mat));
}
}

// This code is contributed by Rishabh Chauhan

Javascript

<script>

        // JavaScript program for the above approach
        let R = 4
        let C = 4

        // The main function that returns index of row with maximum
        // number of 1s.
        function rowWithMax1s(mat)
        {

            // Initialize first row as row with max 1s
            let j, max_row_index = 0;
            j = C - 1;

            for (let i = 0; i < R; i++)
            {

                // Move left until a 0 is found
                let flag = false;

                // to check whether a row has more 1's than previous
                while (j >= 0 && mat[i][j] == 1)
                {

                    j = j - 1; // Update the index of leftmost 1
                    // seen so far
                    flag = true;//present row has more 1's than previous
                }

                // if the present row has more 1's than previous
                if (flag)
                {
                    max_row_index = i; // Update max_row_index
                }
            }
            if (max_row_index == 0 && mat[0][C - 1] == 0)
                return -1;
            return max_row_index;
        }

        // Driver Code
        let mat = [[0, 0, 0, 1],
        [0, 1, 1, 1],
        [1, 1, 1, 1],
        [0, 0, 0, 0]];

        document.write("Index of row with maximum 1s is " + rowWithMax1s(mat));

// This code is contributed by Potta Lokesh
    </script>

Output

Index of row with maximum 1s is 2

Time Complexity: O(m+n) where m is the number of rows and n is the number of columns in the matrix.
Auxiliary Space:  O(1)