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

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++
Java
Python3
C#
Javascript
// C++ implementation to find the// Leftmost Column with atleast a// 1 in a sorted binary matrix #include <bits/stdc++.h> #define N 3using namespace std; // Function to search for the// leftmost column of the matrix// with atleast a 1 in sorted// binary matrixint 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 Codeint main(){    int mat[3][3] = { 0, 0, 0,                    0, 0, 1,                    0, 1, 1 };    cout << search(mat, 3, 3);    return 0;}
// Java implementation to find the// Leftmost Column with atleast a// 1 in a sorted binary matriximport 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 matrixstatic 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 Codepublic 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 implementation to find the# Leftmost Column with atleast a# 1 in a sorted binary matriximport sysN = 3 # Function to search for the# leftmost column of the matrix# with atleast a 1 in sorted# binary matrixdef 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 Codeif __name__ == "__main__":       mat = [[0, 0, 0],           [0, 0, 1],           [0, 1, 1]]    print(search(mat, 3, 3))   # This code is contributed by Chitranayal
// C# implementation to find the leftmost // column with atleast a 1 in a sorted// binary matrixusing 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 matrixstatic 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 Codepublic 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
<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 matrixfunction 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 Codevar mat = [[0, 0, 0],                [0, 0, 1],                [0, 1, 1]];document.write( search(mat, 3, 3)); </script>
2
 
Performance Analysis: 
Time Complexity: O(N*logN)
Auxiliary Space: O(1)
amit143katiyar
ukasp
rrrtnx
Binary Search
Matrix
Searching
Sorting
Searching
Sorting
Matrix
Binary Search
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Sudoku | Backtracking-7
Divide and Conquer | Set 5 (Strassen's Matrix Multiplication)
Count all possible paths from top left to bottom right of a mXn matrix
Program to multiply two matrices
Inplace rotate square matrix by 90 degrees | Set 1
Binary Search
Linear Search
Search an element in a sorted and rotated array
Find the Missing Number
K'th Smallest/Largest Element in Unsorted Array | Set 1