# 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 = { {0, 0},
{1, 1} }
Output: 1
Explanation:
The 1st column of the
matrix contains atleast a 1.

Input:
mat = {{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++ implementation to find the` `// Leftmost Column with atleast a ` `// 1 in a sorted binary matrix`   `#include `   `#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 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 = { 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 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 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# 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`

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.

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : amit143katiyar, chitranayal

Article Tags :