Leftmost Column with atleast one 1 in a row-wise sorted binary matrix

Given a binary matrix mat[][] containing 0’s and 1’s. Each row of the matrix is sorted in the non-decreasing order, the task is to find the left-most column of the matrix with at least one 1 in it.
Note: If no such column exists return -1.
Examples:

Input: 
mat[2][2] = { {0, 0},
              {1, 1} }
Output: 1
Explanation: 
The 1st column of the
matrix contains atleast a 1.

Input: 
mat[2][2] = {{0, 0},
             {0, 0}}
Output: -1
Explanation:
There is no such column which 
contains atleast one 1.

Approach: The idea is to iterate over all the rows of the matrix and Binary Search over them for the first occurrence of the 1 in that row. The minimum of all the occurrence of the first 1 in the rows of the matrix will be the desired solution for the problem.
Below is the implementation of the above approach:

C++

// C++ implementation to find the
// Leftmost Column with atleast a
// 1 in a sorted binary matrix

#include <bits/stdc++.h>

#define N 3
using namespace std;

// Function to search for the
// leftmost column of the matrix
// with atleast a 1 in sorted
// binary matrix
int search(int mat[][], int n, int m)
{
    int i, a = INT_MAX;

    // Loop to iterate over all the
    // rows of the matrix
    for (i = 0; i < n; i++) {
        int low = 0;
        int high = m - 1;
        int mid;
        int ans = INT_MAX;

        // Binary Search to find the
        // leftmost occurrence of the 1
        while (low <= high) {
            mid = (low + high) / 2;

            // Condition if the column
            // contains the 1 at this
            // position of matrix
            if (mat[i][mid] == 1) {

                if (mid == 0) {
                    ans = 0;
                    break;
                }
                else if (mat[i][mid - 1] == 0) {
                    ans = mid;
                    break;
                }
            }

            if (mat[i][mid] == 1)
                high = mid - 1;
            else
                low = mid + 1;
        }

        // If there is a better solution
        // then update the answer
        if (ans < a)
            a = ans;
    }

    // Condition if the solution
    // doesn't exist in the matrix
    if (a == INT_MAX)
        return -1;
    return a+1;
}

// Driver Code
int main()
{
    int mat[3][3] = { 0, 0, 0,
                    0, 0, 1,
                    0, 1, 1 };
    cout << search(mat, 3, 3);
    return 0;
}

Java

// Java implementation to find the
// Leftmost Column with atleast a
// 1 in a sorted binary matrix
import java.util.*;

class GFG{

static final int N = 3;

// Function to search for the
// leftmost column of the matrix
// with atleast a 1 in sorted
// binary matrix
static int search(int mat[][], int n, int m)
{
    int i, a = Integer.MAX_VALUE;

    // Loop to iterate over all the
    // rows of the matrix
    for(i = 0; i < n; i++)
    {
       int low = 0;
       int high = m - 1;
       int mid;
       int ans = Integer.MAX_VALUE;

       // Binary Search to find the
       // leftmost occurrence of the 1
       while (low <= high)
       {
           mid = (low + high) / 2;

           // Condition if the column
           // contains the 1 at this
           // position of matrix
           if (mat[i][mid] == 1)
           {
               if (mid == 0)
               {
                   ans = 0;
                   break;
               }
               else if (mat[i][mid - 1] == 0)
               {
                   ans = mid;
                   break;
               }
           }
           if (mat[i][mid] == 1)
               high = mid - 1;
           else
               low = mid + 1;
       }

       // If there is a better solution
       // then update the answer
       if (ans < a)
           a = ans;
    }

    // Condition if the solution
    // doesn't exist in the matrix
    if (a == Integer.MAX_VALUE)
        return -1;
    return a + 1;
}

// Driver Code
public static void main(String[] args)
{
    int mat[][] = { { 0, 0, 0 },
                    { 0, 0, 1 },
                    { 0, 1, 1 } };

    System.out.print(search(mat, 3, 3));
}
}

// This code is contributed by Amit Katiyar

Python3

# Python3 implementation to find the
# Leftmost Column with atleast a
# 1 in a sorted binary matrix
import sys
N = 3

# Function to search for the
# leftmost column of the matrix
# with atleast a 1 in sorted
# binary matrix
def search(mat, n, m):

    a = sys.maxsize

    # Loop to iterate over all the
    # rows of the matrix
    for i in range (n):
        low = 0
        high = m - 1
        ans = sys.maxsize

        # Binary Search to find the
        # leftmost occurrence of the 1
        while (low <= high):
            mid = (low + high) // 2

            # Condition if the column
            # contains the 1 at this
            # position of matrix
            if (mat[i][mid] == 1):

                if (mid == 0):
                    ans = 0
                    break

                elif (mat[i][mid - 1] == 0):
                    ans = mid
                    break

            if (mat[i][mid] == 1):
                high = mid - 1
            else:
                low = mid + 1

        # If there is a better solution
        # then update the answer
        if (ans < a):
            a = ans

    # Condition if the solution
    # doesn't exist in the matrix
    if (a == sys.maxsize):
        return -1
    return a + 1

# Driver Code
if __name__ == "__main__":

    mat = [[0, 0, 0],
           [0, 0, 1],
           [0, 1, 1]]
    print(search(mat, 3, 3))

# This code is contributed by Chitranayal

C#

// C# implementation to find the leftmost
// column with atleast a 1 in a sorted
// binary matrix
using System;

class GFG{

//static readonly int N = 3;

// Function to search for the leftmost
// column of the matrix with atleast a
//  1 in sorted binary matrix
static int search(int [,]mat, int n, int m)
{
    int i, a = int.MaxValue;

    // Loop to iterate over all the
    // rows of the matrix
    for(i = 0; i < n; i++)
    {
       int low = 0;
       int high = m - 1;
       int mid;
       int ans = int.MaxValue;

       // Binary Search to find the
       // leftmost occurrence of the 1
       while (low <= high)
       {
           mid = (low + high) / 2;

           // Condition if the column
           // contains the 1 at this
           // position of matrix
           if (mat[i, mid] == 1)
           {
               if (mid == 0)
               {
                   ans = 0;
                   break;
               }
               else if (mat[i, mid - 1] == 0)
               {
                   ans = mid;
                   break;
               }
           }
           if (mat[i, mid] == 1)
               high = mid - 1;
           else
               low = mid + 1;
       }

       // If there is a better solution
       // then update the answer
       if (ans < a)
           a = ans;
    }

    // Condition if the solution
    // doesn't exist in the matrix
    if (a == int.MaxValue)
        return -1;
    return a + 1;
}

// Driver Code
public static void Main(String[] args)
{
    int [,]mat = { { 0, 0, 0 },
                   { 0, 0, 1 },
                   { 0, 1, 1 } };

    Console.Write(search(mat, 3, 3));
}
}

// This code is contributed by Amit Katiyar

Javascript

<script>

// JavaScript implementation to find the
// Leftmost Column with atleast a
// 1 in a sorted binary matrix

var N = 3;

// Function to search for the
// leftmost column of the matrix
// with atleast a 1 in sorted
// binary matrix
function search(mat, n, m)
{
    var i, a = 1000000000;

    // Loop to iterate over all the
    // rows of the matrix
    for (i = 0; i < n; i++) {
        var low = 0;
        var high = m - 1;
        var mid;
        var ans = 1000000000;

        // Binary Search to find the
        // leftmost occurrence of the 1
        while (low <= high) {
            mid = parseInt((low + high) / 2);

            // Condition if the column
            // contains the 1 at this
            // position of matrix
            if (mat[i][mid] == 1) {

                if (mid == 0) {
                    ans = 0;
                    break;
                }
                else if (mat[i][mid - 1] == 0) {
                    ans = mid;
                    break;
                }
            }

            if (mat[i][mid] == 1)
                high = mid - 1;
            else
                low = mid + 1;
        }

        // If there is a better solution
        // then update the answer
        if (ans < a)
            a = ans;
    }

    // Condition if the solution
    // doesn't exist in the matrix
    if (a == 1000000000)
        return -1;
    return a+1;
}

// Driver Code
var mat = [[0, 0, 0],
                [0, 0, 1],
                [0, 1, 1]];
document.write( search(mat, 3, 3));

</script>

Output:

2

Performance Analysis:

• Time Complexity: O(N*logN)
• Auxiliary Space: O(1)