Skip to content
Related Articles

Related Articles

Improve Article
Leftmost Column with atleast one 1 in a row-wise sorted binary matrix
  • Difficulty Level : Easy
  • Last Updated : 26 May, 2021

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[][3], 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 occurence 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 occurence 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 occurence 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 occurence 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 occurence 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)

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 industry experts, please refer Geeks Classes Live 




My Personal Notes arrow_drop_up
Recommended Articles
Page :