# Find if there is a rectangle in binary matrix with corners as 1

• Difficulty Level : Hard
• Last Updated : 18 Aug, 2021

There is a given binary matrix, we need to find if there exists any rectangle or square in the given matrix whose all four corners are equal to

Examples:

```Input :
mat[][] = { 1 0 0 1 0
0 0 1 0 1
0 0 0 1 0
1 0 1 0 1}
Output : Yes
as there exists-
1 0 1
0 1 0
1 0 1```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

Brute Force Approach-

We start scanning the matrix whenever we find a 1 at any index then we try for all the combinations for index with which we can form the rectangle.
algorithm–

```for i = 1 to rows
for j = 1 to columns
if matrix[i][j] == 1
for k=i+1 to rows
for l=j+1 to columns
if (matrix[i][l]==1 &&
matrix[k][j]==1 &&
m[k][l]==1)
return true
return false```

## C++

 `// A brute force approach based CPP program to` `// find if there is a rectangle with 1 as corners.` `#include ` `using` `namespace` `std;`   `// Returns true if there is a rectangle with` `// 1 as corners.` `bool` `isRectangle(``const` `vector >& m)` `{` `    ``// finding row and column size` `    ``int` `rows = m.size();` `    ``if` `(rows == 0)` `        ``return` `false``;` `    ``int` `columns = m[0].size();`   `    ``// scanning the matrix` `    ``for` `(``int` `y1 = 0; y1 < rows; y1++)` `      ``for` `(``int` `x1 = 0; x1 < columns; x1++)`   `          ``// if any index found 1 then try` `          ``// for all rectangles` `          ``if` `(m[y1][x1] == 1)` `            ``for` `(``int` `y2 = y1 + 1; y2 < rows; y2++)` `              ``for` `(``int` `x2 = x1 + 1; x2 < columns; x2++)` `                ``if` `(m[y1][x2] == 1 && m[y2][x1] == 1 && ` `                                       ``m[y2][x2] == 1)` `                  ``return` `true``;` `    ``return` `false``;` `}`   `// Driver code` `int` `main()` `{` `    ``vector > mat = { { 1, 0, 0, 1, 0 },` `                                 ``{ 0, 0, 1, 0, 1 },` `                                 ``{ 0, 0, 0, 1, 0 },` `                                 ``{ 1, 0, 1, 0, 1 } };` `    ``if` `(isRectangle(mat))` `        ``cout << ``"Yes"``;` `    ``else` `        ``cout << ``"No"``;` `}`

## Java

 `// A brute force approach based CPP program to` `// find if there is a rectangle with 1 as corners.` `public` `class` `FindRectangle {` `    ``// Returns true if there is a rectangle with` `    ``// 1 as corners.` `    ``static` `boolean` `isRectangle(``int` `m[][])` `    ``{` `        ``// finding row and column size` `        ``int` `rows = m.length;` `        ``if` `(rows == ``0``)` `            ``return` `false``;` `        ``int` `columns = m[``0``].length;`   `        ``// scanning the matrix` `        ``for` `(``int` `y1 = ``0``; y1 < rows; y1++)` `          ``for` `(``int` `x1 = ``0``; x1 < columns; x1++)` `            ``// if any index found 1 then try` `            ``// for all rectangles` `            ``if` `(m[y1][x1] == ``1``)` `              ``for` `(``int` `y2 = y1 + ``1``; y2 < rows; y2++)` `                ``for` `(``int` `x2 = x1 + ``1``; x2 < columns; x2++)` `                  ``if` `(m[y1][x2] == ``1` `&& m[y2][x1] == ``1` `&& ` `                                           ``m[y2][x2] == ``1``)` `                    ``return` `true``;` `        ``return` `false``;` `    ``}`   `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `mat[][] = { { ``1``, ``0``, ``0``, ``1``, ``0` `},` `                        ``{ ``0``, ``0``, ``1``, ``0``, ``1` `},` `                        ``{ ``0``, ``0``, ``0``, ``1``, ``0` `},` `                        ``{ ``1``, ``0``, ``1``, ``0``, ``1` `} };` `        ``if` `(isRectangle(mat))` `            ``System.out.print(``"Yes"``);` `        ``else` `            ``System.out.print(``"No"``);` `    ``}` `}` `// This code is contributed by Gaurav Tiwari`

## Python3

 `# A brute force approach based Python3 program to` `# find if there is a rectangle with 1 as corners.`   `# Returns true if there is a rectangle ` `# with 1 as corners.` `def` `isRectangle(m):`   `    ``# finding row and column size` `    ``rows ``=` `len``(m)` `    ``if` `(rows ``=``=` `0``):` `        ``return` `False` `    ``columns ``=` `len``(m[``0``])`   `    ``# scanning the matrix` `    ``for` `y1 ``in` `range``(rows):`   `        ``for` `x1 ``in` `range``(columns):`   `            ``# if any index found 1 then ` `            ``# try for all rectangles` `            ``if` `(m[y1][x1] ``=``=` `1``):` `                ``for` `y2 ``in` `range``(y1 ``+` `1``, rows):` `                    ``for` `x2 ``in` `range``(x1 ``+` `1``, columns):` `                        ``if` `(m[y1][x2] ``=``=` `1` `and` `                            ``m[y2][x1] ``=``=` `1` `and` `                            ``m[y2][x2] ``=``=` `1``):` `                            ``return` `True` `    ``return` `False`   `# Driver code` `mat ``=` `[[``1``, ``0``, ``0``, ``1``, ``0``],` `       ``[``0``, ``0``, ``1``, ``0``, ``1``],` `       ``[``0``, ``0``, ``0``, ``1``, ``0``],` `       ``[``1``, ``0``, ``1``, ``0``, ``1``]]`   `if` `(isRectangle(mat)):` `    ``print``(``"Yes"``)` `else``:` `    ``print``(``"No"``)`   `# This code is contributed` `# by mohit kumar 29`

## C#

 `// A brute force approach based C# program to` `// find if there is a rectangle with 1 as corners.` `using` `System;`   `public` `class` `FindRectangle {` `    ``// Returns true if there is a rectangle with` `    ``// 1 as corners.` `    ``static` `Boolean isRectangle(``int``[, ] m)` `    ``{` `        ``// finding row and column size` `        ``int` `rows = m.GetLength(0);` `        ``if` `(rows == 0)` `            ``return` `false``;` `        ``int` `columns = m.GetLength(1);`   `        ``// scanning the matrix` `        ``for` `(``int` `y1 = 0; y1 < rows; y1++)` `          ``for` `(``int` `x1 = 0; x1 < columns; x1++)`   `            ``// if any index found 1 then try` `            ``// for all rectangles` `            ``if` `(m[y1, x1] == 1)` `              ``for` `(``int` `y2 = y1 + 1; y2 < rows; y2++)` `                ``for` `(``int` `x2 = x1 + 1; x2 < columns; x2++)` `                  ``if` `(m[y1, x2] == 1 && m[y2, x1] == 1 && ` `                                          ``m[y2, x2] == 1)` `                    ``return` `true``;` `        ``return` `false``;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``int``[, ] mat = { { 1, 0, 0, 1, 0 },` `                        ``{ 0, 0, 1, 0, 1 },` `                        ``{ 0, 0, 0, 1, 0 },` `                        ``{ 1, 0, 1, 0, 1 } };` `        ``if` `(isRectangle(mat))` `            ``Console.Write(``"Yes"``);` `        ``else` `            ``Console.Write(``"No"``);` `    ``}` `}`   `// This code contributed by Rajput-Ji`

## Javascript

 ``

Output

`Yes`

Time Complexity: O(m2 * n2

Efficient Approach

1. Scan from top to down, line by line
2. For each line, remember each combination of 2 1’s and push that into a hash-set
3. If we ever find that combination again in a later line, we get our rectangle

Below is the implementation of the above approach:

## C++

 `// An efficient approach based CPP program to` `// find if there is a rectangle with 1 as` `// corners.` `#include ` `using` `namespace` `std;`   `// Returns true if there is a rectangle with` `// 1 as corners.` `bool` `isRectangle(``const` `vector >& matrix)` `{` `    ``// finding row and column size` `    ``int` `rows = matrix.size();` `    ``if` `(rows == 0)` `        ``return` `false``;`   `    ``int` `columns = matrix[0].size();`   `    ``// map for storing the index of combination of 2 1's` `    ``unordered_map<``int``, unordered_set<``int``> > table;`   `    ``// scanning from top to bottom line by line` `    ``for` `(``int` `i = 0; i < rows; ++i) {`   `        ``for` `(``int` `j = 0; j < columns - 1; ++j) {` `            ``for` `(``int` `k = j + 1; k < columns; ++k) {`   `                ``// if found two 1's in a column` `                ``if` `(matrix[i][j] == 1 && matrix[i][k] == 1) {`   `                    ``// check if there exists 1's in same` `                    ``// row previously then return true` `                    ``// we don't need to check (j, k) pair` `                    ``// and again (k, j) pair because we always` `                    ``// store pair in ascending order and similarly` `                    ``// check in ascending order, i.e. j always less` `                    ``// than k.` `                    ``if` `(table.find(j) != table.end()` `                        ``&& table[j].find(k) != table[j].end())` `                        ``return` `true``;`   `                    ``// store the indexes in hashset` `                    ``table[j].insert(k);` `                ``}` `            ``}` `        ``}` `    ``}` `    ``return` `false``;` `}`   `// Driver code` `int` `main()` `{` `    ``vector > mat = { { 1, 0, 0, 1, 0 },` `                                 ``{ 0, 1, 1, 1, 1 },` `                                 ``{ 0, 0, 0, 1, 0 },` `                                 ``{ 1, 1, 1, 1, 0 } };` `    ``if` `(isRectangle(mat))` `        ``cout << ``"Yes"``;` `    ``else` `        ``cout << ``"No"``;` `}` `// This code is improved by Gautam Agrawal`

## Java

 `// An efficient approach based Java program to` `// find if there is a rectangle with 1 as` `// corners.` `import` `java.util.HashMap;` `import` `java.util.HashSet;` `public` `class` `FindRectangle {` `    ``// Returns true if there is a rectangle with` `    ``// 1 as corners.` `    ``static` `boolean` `isRectangle(``int` `matrix[][])` `    ``{` `        ``// finding row and column size` `        ``int` `rows = matrix.length;` `        ``if` `(rows == ``0``)` `            ``return` `false``;` `        ``int` `columns = matrix[``0``].length;`   `        ``// map for storing the index of combination of 2 1's` `        ``HashMap > table = ``new` `HashMap<>();`   `        ``// scanning from top to bottom line by line` `        ``for` `(``int` `i = ``0``; i < rows; i++) {` `            ``for` `(``int` `j = ``0``; j < columns - ``1``; j++) {` `                ``for` `(``int` `k = j + ``1``; k < columns; k++) {` `                    ``// if found two 1's in a column` `                    ``if` `(matrix[i][j] == ``1` `&& matrix[i][k] == ``1``) {` `                        ``// check if there exists 1's in same` `                        ``// row previously then return true` `                        ``if` `(table.containsKey(j) && table.get(j).contains(k)) {` `                            ``return` `true``;` `                        ``}` `                        ``if` `(table.containsKey(k) && table.get(k).contains(j)) {` `                            ``return` `true``;` `                        ``}`   `                        ``// store the indexes in hashset` `                        ``if` `(!table.containsKey(j)) {` `                            ``HashSet x = ``new` `HashSet<>();` `                            ``x.add(k);` `                            ``table.put(j, x);` `                        ``}` `                        ``else` `{` `                            ``table.get(j).add(k);` `                        ``}` `                        ``if` `(!table.containsKey(k)) {` `                            ``HashSet x = ``new` `HashSet<>();` `                            ``x.add(j);` `                            ``table.put(k, x);` `                        ``}` `                        ``else` `{` `                            ``table.get(k).add(j);` `                        ``}` `                    ``}` `                ``}` `            ``}` `        ``}` `        ``return` `false``;` `    ``}`   `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `mat[][] = { { ``1``, ``0``, ``0``, ``1``, ``0` `},` `                        ``{ ``0``, ``0``, ``1``, ``0``, ``1` `},` `                        ``{ ``0``, ``0``, ``0``, ``1``, ``0` `},` `                        ``{ ``1``, ``0``, ``1``, ``0``, ``1` `} };` `        ``if` `(isRectangle(mat))` `            ``System.out.print(``"Yes"``);` `        ``else` `            ``System.out.print(``"No"``);` `    ``}` `}` `// This code is contributed by Gaurav Tiwari`

## Python3

 `# An efficient approach based Python program ` `# to find if there is a rectangle with 1 as ` `# corners. `   `# Returns true if there is a rectangle` `# with 1 as corners. ` `def` `isRectangle(matrix):`   `    ``# finding row and column size ` `    ``rows ``=` `len``(matrix)` `    ``if` `(rows ``=``=` `0``):` `        ``return` `False`   `    ``columns ``=` `len``(matrix[``0``])`   `    ``# map for storing the index of ` `    ``# combination of 2 1's ` `    ``table ``=` `{}`   `    ``# scanning from top to bottom ` `    ``# line by line ` `    ``for` `i ``in` `range``(rows): ` `        ``for` `j ``in` `range``(columns ``-` `1``):` `            ``for` `k ``in` `range``(j ``+` `1``, columns): `   `                ``# if found two 1's in a column ` `                ``if` `(matrix[i][j] ``=``=` `1` `and` `                    ``matrix[i][k] ``=``=` `1``):`   `                    ``# check if there exists 1's in same ` `                    ``# row previously then return true ` `                    ``if` `(j ``in` `table ``and` `k ``in` `table[j]):` `                        ``return` `True`   `                    ``if` `(k ``in` `table ``and` `j ``in` `table[k]):` `                        ``return` `True`   `                    ``# store the indexes in hashset ` `                    ``if` `j ``not` `in` `table:` `                        ``table[j] ``=` `set``()` `                    ``if` `k ``not` `in` `table:` `                        ``table[k] ``=` `set``()` `                    ``table[j].add(k) ` `                    ``table[k].add(j)` `    ``return` `False`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``mat ``=` `[[ ``1``, ``0``, ``0``, ``1``, ``0` `],` `           ``[ ``0``, ``0``, ``1``, ``0``, ``1` `],` `           ``[ ``0``, ``0``, ``0``, ``1``, ``0` `],` `           ``[ ``1``, ``0``, ``1``, ``0``, ``1` `]] ` `    ``if` `(isRectangle(mat)):` `        ``print``(``"Yes"``)` `    ``else``:` `        ``print``(``"No"``)` `    `  `# This code is contributed ` `# by SHUBHAMSINGH10`

## C#

 `// An efficient approach based C# program to` `// find if there is a rectangle with 1 as` `// corners.` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `FindRectangle {` `    ``// Returns true if there is a rectangle with` `    ``// 1 as corners.` `    ``static` `bool` `isRectangle(``int``[, ] matrix)` `    ``{` `        ``// finding row and column size` `        ``int` `rows = matrix.GetLength(0);` `        ``if` `(rows == 0)` `            ``return` `false``;` `        ``int` `columns = matrix.GetLength(1);`   `        ``// map for storing the index of combination of 2 1's` `        ``Dictionary<``int``, HashSet<``int``> > table = ``new` `Dictionary<``int``, HashSet<``int``> >();`   `        ``// scanning from top to bottom line by line` `        ``for` `(``int` `i = 0; i < rows; i++) {` `            ``for` `(``int` `j = 0; j < columns - 1; j++) {` `                ``for` `(``int` `k = j + 1; k < columns; k++) {` `                    ``// if found two 1's in a column` `                    ``if` `(matrix[i, j] == 1 && matrix[i, k] == 1) {` `                        ``// check if there exists 1's in same` `                        ``// row previously then return true` `                        ``if` `(table.ContainsKey(j) && table[j].Contains(k)) {` `                            ``return` `true``;` `                        ``}` `                        ``if` `(table.ContainsKey(k) && table[k].Contains(j)) {` `                            ``return` `true``;` `                        ``}`   `                        ``// store the indexes in hashset` `                        ``if` `(!table.ContainsKey(j)) {` `                            ``HashSet<``int``> x = ``new` `HashSet<``int``>();` `                            ``x.Add(k);` `                            ``table.Add(j, x);` `                        ``}` `                        ``else` `{` `                            ``table[j].Add(k);` `                        ``}` `                        ``if` `(!table.ContainsKey(k)) {` `                            ``HashSet<``int``> x = ``new` `HashSet<``int``>();` `                            ``x.Add(j);` `                            ``table.Add(k, x);` `                        ``}` `                        ``else` `{` `                            ``table[k].Add(j);` `                        ``}` `                    ``}` `                ``}` `            ``}` `        ``}` `        ``return` `false``;` `    ``}`   `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``int``[, ] mat = { { 1, 0, 0, 1, 0 },` `                        ``{ 0, 0, 1, 0, 1 },` `                        ``{ 0, 0, 0, 1, 0 },` `                        ``{ 1, 0, 1, 0, 1 } };` `        ``if` `(isRectangle(mat))` `            ``Console.Write(``"Yes"``);` `        ``else` `            ``Console.Write(``"No"``);` `    ``}` `}`   `// This code is contributed by PrinciRaj1992`

## Javascript

 ``   `   `

Output

`Yes`

Time Complexity: O(n*m2

More Efficient Approach

The previous approach scans through every pair of column indexes to find each combination of 2 1’s.

• To more efficiently find each combination of 2 1’s, convert each row into a set of column indexes.
• Then, select pairs of column indexes from the row set to quickly get each combination of 2 1’s.
• If a pair of column indexes appears more than once, then there is a rectangle whose corners are 1’s.
• The runtime becomes O(m*n+n*n*log(n*n)).  This is because there are m*n cells in the matrix and there are at most O(n^2) combinations of column indexes and we are using a map which will store every entry in log(n) time.
• Also, if n > m, then by first transposing the matrix, the runtime becomes O(m*n+m*m*log(m*m)).

Notice that min{m*n+n*n*log(n*n), m*n+m*m*log(m*m)} is O(m*n + p*p*log(p*p)), p=max(n,m).

Below is the implementation of the above approach:

## C++

 `// C++ implementation comes from:` `// https://github.com/MichaelWehar/FourCornersProblem` `// Written by Niteesh Kumar and Michael Wehar` `// References:` `//   [1] F. MrÃ¡z, D. Prusa, and M. Wehar. ` `//   Two-dimensional Pattern Matching against ` `//    Basic Picture Languages. CIAA 2019.` `//   [2] D. Prusa and M. Wehar. Complexity of ` `//    Searching for 2 by 2 Submatrices in Boolean ` `//    Matrices. DLT 2020.`   `#include ` `using` `namespace` `std;`   `bool` `searchForRectangle(``int` `rows, ``int` `cols,` `                        ``vector> mat) ` `{` `    ``// Make sure that matrix is non-trivial` `    ``if` `(rows < 2 || cols < 2) ` `    ``{` `        ``return` `false``;` `    ``}`   `    ``// Create map` `    ``int` `num_of_keys;` `    ``map<``int``, vector<``int``>> adjsList;` `    ``if` `(rows >= cols) ` `    ``{` `        ``// Row-wise` `        ``num_of_keys = rows;` `        `  `        ``// Convert each row into vector of col indexes` `        ``for` `(``int` `i = 0; i < rows; i++) ` `        ``{` `            ``for` `(``int` `j = 0; j < cols; j++) ` `            ``{` `                ``if` `(mat[i][j])` `                ``{` `                    ``adjsList[i].push_back(j);` `                ``}` `            ``}` `        ``}` `    ``} ` `    `  `    ``else` `    ``{` `        ``// Col-wise` `        ``num_of_keys = cols;` `        `  `        ``// Convert each col into vector of row indexes` `        ``for` `(``int` `i = 0; i < rows; i++) ` `        ``{` `            ``for` `(``int` `j = 0; j < cols; j++) ` `            ``{` `                ``if` `(mat[i][j]) ` `                ``{` `                    ``adjsList[j].push_back(i);` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Search for a rectangle whose four corners are 1's` `    ``map, ``int``> pairs;` `    ``for` `(``int` `i = 0; i < num_of_keys; i++)` `    ``{` `        ``vector<``int``> values = adjsList[i];` `        ``int` `size = values.size();` `        ``for` `(``int` `j = 0; j < size - 1; j++) ` `        ``{` `            ``for` `(``int` `k = j + 1; k < size; k++)` `            ``{` `                ``pair<``int``, ``int``> temp ` `                        ``= make_pair(values[j], ` `                                     ``values[k]);` `                ``if` `(pairs.find(temp) ` `                    ``!= pairs.end()) ` `                ``{` `                    ``return` `true``;` `                ``} ``else` `{` `                    ``pairs[temp] = i;` `                ``}` `            ``}` `        ``}` `    ``}` `    ``return` `false``;` `}`   `// Driver code` `int` `main()` `{` `    ``vector > mat = { { 1, 0, 0, 1, 0 },` `                                 ``{ 0, 1, 1, 1, 1 },` `                                 ``{ 0, 0, 0, 1, 0 },` `                                 ``{ 1, 1, 1, 1, 0 } };` `    ``if` `(searchForRectangle(4, 5, mat))` `        ``cout << ``"Yes"``;` `    ``else` `        ``cout << ``"No"``;` `}`

Output

`Yes`

Time Complexity: O(m*n + p*p*log(p*p)), p=max(n,m).

My Personal Notes arrow_drop_up
Recommended Articles
Page :