Related Articles

Related Articles

Leftmost Column with atleast one 1 in a row-wise sorted binary matrix
  • Difficulty Level : Basic
  • Last Updated : 28 Sep, 2020

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :