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

• Difficulty Level : Hard
• Last Updated : 24 Dec, 2022

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)

My Personal Notes arrow_drop_up
Related Articles