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

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

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

Implementation:

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
Auxiliary Space: O(1), since no extra space has been taken.

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)
Auxiliary Space: O(n*m)

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"``;` `}`

Java

 `// Java 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.`   `import` `java.util.*;`   `class` `GFG {`   `    ``// Function to search for a rectangle` `    ``static` `boolean` `searchForRectangle(``int` `rows, ``int` `cols,` `                                     ``int``[][] mat) ` `    ``{`   `        ``// Make sure that matrix is non-trivial` `        ``if` `(rows < ``2` `|| cols < ``2``)` `            ``return` `false``;`   `        ``// Create map` `        ``int` `num_of_keys;` `        ``Map> adjsList ` `            ``= ``new` `HashMap<>();` `        ``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] == ``1``) ` `                    ``{` `                        ``if` `(!adjsList.containsKey(i)) ` `                        ``{` `                            ``List temp ` `                                ``= ``new` `ArrayList<>();` `                            ``temp.add(j);` `                            ``adjsList.put(i, temp);` `                        ``} ` `                        ``else` `                        ``{` `                            ``adjsList.get(i).add(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] == ``1``) ` `                    ``{` `                        ``if` `(!adjsList.containsKey(j)) ` `                        ``{` `                            ``List temp ` `                                ``= ``new` `ArrayList<>();` `                            ``temp.add(i);` `                            ``adjsList.put(j, temp);` `                        ``} ` `                        ``else` `                        ``{` `                            ``adjsList.get(j).add(i);` `                        ``}` `                    ``}` `                ``}` `            ``}` `        ``}`   `        ``// Search for a rectangle` `        ``// whose four corners are 1's` `        ``Map pairs ` `            ``= ``new` `HashMap<>();` `        ``for` `(``int` `i = ``0``; i < num_of_keys; i++) ` `        ``{` `            ``List values ` `                ``= adjsList.get(i);` `            ``int` `size = values.size();` `            ``for` `(``int` `j = ``0``; j < size - ``1``; j++) ` `            ``{` `                ``for` `(``int` `k = j + ``1``; k < size; k++) ` `                ``{` `                    ``String temp ` `                        ``= values.get(j) + ``" "` `                          ``+ values.get(k);` `                    ``if` `(pairs.containsKey(temp)) ` `                    ``{` `                        ``return` `true``;` `                    ``} ` `                    ``else` `                    ``{` `                        ``pairs.put(temp, i);` `                    ``}` `                ``}` `            ``}` `        ``}` `        ``return` `false``;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``int``[][] 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))` `            ``System.out.println(``"Yes"``);` `        ``else` `            ``System.out.println(``"No"``);` `    ``}` `}` `// This code is contributed by Srj_27`

Python3

 `# Python3 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.` `def` `searchForRectangle( rows,  cols, mat) :`   `    ``# Make sure that matrix is non-trivial` `    ``if` `(rows < ``2` `or` `cols < ``2``) :` `    `  `        ``return` `False``;` `    `  `    ``# Create map` `    ``adjsList ``=` `dict``();` `    ``if` `(rows >``=` `cols): ` `    `  `        ``# Row-wise` `        ``num_of_keys ``=` `rows;` `        `  `        ``# Convert each row into vector of col indexes` `        ``for` `i ``in` `range``(rows):` `            `  `            ``for` `j ``in` `range``(cols):` `        `  `                ``if` `(mat[i][j]):` `                    `  `                    ``if` `i ``not` `in` `adjsList:` `                        ``adjsList[i] ``=` `[]` `                    ``adjsList[i].append(j);` `    ``else` `:` `    `  `        ``# Col-wise` `        ``num_of_keys ``=` `cols;` `        `  `        ``# Convert each col into vector of row indexes` `        ``for` `i ``in` `range``(rows):` `            `  `            ``for` `j ``in` `range``(cols):` `        `  `                ``if` `(mat[i][j] ``=``=` `1``) :` `                    `  `                    ``if` `j ``not` `in` `adjsList:` `                        ``adjsList[j] ``=` `[]` `                    ``adjsList[j].append(i);` `                `  `    ``# Search for a rectangle whose four corners are 1's` `    ``pairs ``=` `dict``();` `    `  `    ``for` `i ``in` `range``(num_of_keys):`   `        ``values ``=` `adjsList[i];` `        ``size ``=` `len``(values)` `        `  `        ``for` `j ``in` `range``(size ``-` `1``):` `            `  `            ``for` `k ``in` `range``(j ``+` `1``, size):`   `                ``temp  ``=` `(values[j], values[k]);` `                `  `                ``if` `temp ``in` `pairs:` `                    ``return` `True``;` `                 `  `                ``else``:` `                    ``pairs[temp] ``=` `i;` `    ``return` `False``;`   `# Driver code` `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)):` `    ``print``(``"Yes"``);` `else``:` `    ``print``(``"No"``)` `    `  `# This code is contributed by phasing17.`

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.`   `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG` `{`   `  ``static` `bool` `searchForRectangle(``int` `rows, ``int` `cols,` `                                 ``int``[,] mat) ` `  ``{` `    ``// Make sure that matrix is non-trivial` `    ``if` `(rows < 2 || cols < 2) ` `    ``{` `      ``return` `false``;` `    ``}`   `    ``// Create map` `    ``int` `num_of_keys;` `    ``Dictionary<``int``, List<``int``>> adjsList = ``new` `Dictionary<``int``, List<``int``>>();` `    ``if` `(rows >= cols) ` `    ``{` `      ``// Row-wise` `      ``num_of_keys = rows;`   `      ``// Convert each row into List of col indexes` `      ``for` `(``int` `i = 0; i < rows; i++) ` `      ``{` `        ``for` `(``int` `j = 0; j < cols; j++) ` `        ``{` `          ``if` `(mat[i, j] == 1)` `          ``{` `            ``if` `(!adjsList.ContainsKey(i))` `              ``adjsList[i] = ``new` `List<``int``>();` `            ``adjsList[i].Add(j);` `          ``}` `        ``}` `      ``}` `    ``} `   `    ``else` `    ``{` `      ``// Col-wise` `      ``num_of_keys = cols;`   `      ``// Convert each col into List of row indexes` `      ``for` `(``int` `i = 0; i < rows; i++) ` `      ``{` `        ``for` `(``int` `j = 0; j < cols; j++) ` `        ``{` `          ``if` `(mat[i, j] == 1) ` `          ``{` `            ``if` `(!adjsList.ContainsKey(i))` `              ``adjsList[i] = ``new` `List<``int``>();` `            ``adjsList[i].Add(j);` `          ``}` `        ``}` `      ``}` `    ``}`   `    ``// Search for a rectangle whose four corners are 1's` `    ``Dictionary, ``int``> pairs = ``new` `Dictionary, ``int``>();` `    ``for` `(``int` `i = 0; i < num_of_keys; i++)` `    ``{` `      ``List<``int``> values = adjsList[i];` `      ``int` `size = values.Count;` `      ``for` `(``int` `j = 0; j < size - 1; j++) ` `      ``{` `        ``for` `(``int` `k = j + 1; k < size; k++)` `        ``{` `          ``var` `temp  = Tuple.Create(values[j], ` `                                   ``values[k]);` `          ``if` `(!pairs.ContainsKey(temp))` `          ``{` `            ``return` `true``;` `          ``} ``else` `{` `            ``pairs[temp] = i;` `          ``}` `        ``}` `      ``}` `    ``}` `    ``return` `false``;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{` `    ``int``[, ] 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))` `      ``Console.WriteLine(``"Yes"``);` `    ``else` `      ``Console.WriteLine(``"No"``);` `  ``}` `}`   `// This code is contributed by phasing17`

Javascript

 `// JS 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.`   `function` `searchForRectangle( rows,  cols, mat) ` `{` `    ``// Make sure that matrix is non-trivial` `    ``if` `(rows < 2 || cols < 2) ` `    ``{` `        ``return` `false``;` `    ``}`   `    ``// Create map` `    ``let num_of_keys;` `    ``let adjsList = {};` `    ``if` `(rows >= cols) ` `    ``{` `        ``// Row-wise` `        ``num_of_keys = rows;` `        `  `        ``// Convert each row into vector of col indexes` `        ``for` `(``var` `i = 0; i < rows; i++) ` `        ``{` `            ``for` `(``var` `j = 0; j < cols; j++) ` `            ``{` `                ``if` `(mat[i][j])` `                ``{` `                    ``if` `(!adjsList.hasOwnProperty(i))` `                        ``adjsList[i] = []` `                    ``adjsList[i].push(j);` `                ``}` `            ``}` `        ``}` `    ``} ` `    `  `    ``else` `    ``{` `        ``// Col-wise` `        ``num_of_keys = cols;` `        `  `        ``// Convert each col into vector of row indexes` `        ``for` `(``var` `i = 0; i < rows; i++) ` `        ``{` `            ``for` `(``var` `j = 0; j < cols; j++) ` `            ``{` `                ``if` `(mat[i][j] == 1) ` `                ``{` `                    ``if` `(!adjsList.hasOwnProperty(j))` `                        ``adjsList[j] = []` `                    ``adjsList[j].push(i);` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Search for a rectangle whose four corners are 1's` `    ``let pairs = {};` `    ``for` `(``var` `i = 0; i < num_of_keys; i++)` `    ``{` `        ``let values = adjsList[i];` `        ``let size = values.length` `        ``for` `(``var` `j = 0; j < size - 1; j++) ` `        ``{` `            ``for` `(``var` `k = j + 1; k < size; k++)` `            ``{` `                ``let temp  = (values[j] + ``"#"` `+ values[k]);` `                ``if` `(pairs.hasOwnProperty(temp))` `                ``{` `                    ``return` `true``;` `                ``} ` `                ``else` `{` `                    ``pairs[temp] = i;` `                ``}` `            ``}` `        ``}` `    ``}` `    ``return` `false``;` `}`   `// Driver code` `let 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))` `    ``console.log(``"Yes"``);` `else` `    ``console.log(``"No"``)` `    `  `    ``// This code is contributed by phasing17.`

Output

`Yes`

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

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Similar Reads
Complete Tutorials