GeeksforGeeks App
Open App
Browser
Continue

# Finding the maximum square sub-matrix with all equal elements

Given a N x N matrix, determine the maximum K such that K x K is a submatrix with all equal elements i.e., all the elements in this submatrix must be same.

Constraints:

• 1 <= N <= 1000
• 0 <= Ai , j <= 109

Examples:

```
Input : a[][] = {{2, 3, 3},
{2, 3, 3},
{2, 2, 2}}
Output : 2
Explanation: A 2x2 matrix is formed from index
A0,1 to A1,2

Input : a[][]  = {{9, 9, 9, 8},
{9, 9, 9, 6},
{9, 9, 9, 3},
{2, 2, 2, 2}
Output : 3
Explanation : A 3x3 matrix is formed from index
A0,0 to A2,2```

Method I ( Naive approach ):
We can easily find all the square submatrices in O(n3) time and check whether each submatrix contains equal elements or not in O(n2) time Which makes the total running time of the algorithm as O(n5).

Method II ( Dynamic Programming ):
For each cell (i, j), we store the largest value of K such that K x K is a submatrix with all equal elements and position of (i, j) being the bottom-right most element.
And DPi,j depends upon {DPi-1, j, DPi, j-1, DPi-1, j-1}

```If Ai, j is equal to {Ai-1, j, Ai, j-1, Ai-1, j-1},
all the three values:
DPi, j = min(DPi-1, j, DPi, j-1, DPi-1, j-1) + 1
Else
DPi, j = 1  // Matrix Size 1

The answer would be the maximum of all DPi, j's```

Below is the implementation of above steps.

## C++

 `// C++ program to find maximum K such that K x K``// is a submatrix with equal elements.``#include``#define Row 6``#define Col 6``using` `namespace` `std;` `// Returns size of the largest square sub-matrix``// with all same elements.``int` `largestKSubmatrix(``int` `a[][Col])``{``    ``int` `dp[Row][Col];``    ``memset``(dp, ``sizeof``(dp), 0);` `    ``int` `result = 0;``    ``for` `(``int` `i = 0 ; i < Row ; i++)``    ``{``        ``for` `(``int` `j = 0 ; j < Col ; j++)``        ``{``            ``// If elements is at top row or first``            ``// column, it wont form a  square``            ``// matrix's bottom-right``            ``if` `(i == 0 || j == 0)``                ``dp[i][j] = 1;` `            ``else``            ``{``                ``// Check if adjacent elements are equal``                ``if` `(a[i][j] == a[i-1][j] &&``                    ``a[i][j] == a[i][j-1] &&``                    ``a[i][j] == a[i-1][j-1] )``                    ``dp[i][j] = min(min(dp[i-1][j], dp[i][j-1]),``                                      ``dp[i-1][j-1] ) + 1;` `                ``// If not equal, then it will form a 1x1``                ``// submatrix``                ``else` `dp[i][j] = 1;``            ``}` `            ``// Update result at each (i,j)``            ``result = max(result, dp[i][j]);``        ``}``    ``}` `    ``return` `result;``}` `// Driven Program``int` `main()``{``    ``int` `a[Row][Col] = { 2, 2, 3, 3, 4, 4,``                        ``5, 5, 7, 7, 7, 4,``                        ``1, 2, 7, 7, 7, 4,``                        ``4, 4, 7, 7, 7, 4,``                        ``5, 5, 5, 1, 2, 7,``                        ``8, 7, 9, 4, 4, 4``                      ``};` `    ``cout << largestKSubmatrix(a) << endl;` `    ``return` `0;``}`

## Java

 `// Java program to find maximum``// K such that K x K is a``// submatrix with equal elements.``import` `java.util.*;``import` `java.io.*;` `class` `GFG``{``    ``static` `int` `Row = ``6``, Col = ``6``;``    ` `    ``// Returns size of the largest``    ``// square sub-matrix with``    ``// all same elements.``    ``static` `int` `largestKSubmatrix(``int` `[][]a)``    ``{``        ``int` `[][]dp = ``new` `int` `[Row][Col];``        ``int` `result = ``0``;``        ``for` `(``int` `i = ``0` `;``                 ``i < Row ; i++)``        ``{``            ``for` `(``int` `j = ``0` `;``                     ``j < Col ; j++)``            ``{``                ``// If elements is at top``                ``// row or first column,``                ``// it wont form a square``                ``// matrix's bottom-right``                ``if` `(i == ``0` `|| j == ``0``)``                    ``dp[i][j] = ``1``;` `                ``else``                ``{``                    ``// Check if adjacent``                    ``// elements are equal``                    ``if` `(a[i][j] == a[i - ``1``][j] &&``                        ``a[i][j] == a[i][j - ``1``] &&``                        ``a[i][j] == a[i - ``1``][j - ``1``])``                    ``{``                    ``dp[i][j] = (dp[i - ``1``][j] > dp[i][j - ``1``] &&``                                ``dp[i - ``1``][j] > dp[i - ``1``][j - ``1``] + ``1``) ?``                                                        ``dp[i - ``1``][j] :``                               ``(dp[i][j - ``1``] > dp[i - ``1``][j] &&``                                ``dp[i][j - ``1``] > dp[i - ``1``][j - ``1``] + ``1``) ?``                                                        ``dp[i][j - ``1``] :``                                                 ``dp[i - ``1``][j - ``1``] + ``1``;``                    ``}            ` `                    ``// If not equal, then it``                    ``// will form a 1x1 submatrix``                    ``else` `dp[i][j] = ``1``;``                ``}``            ` `                ``// Update result at each (i,j)``                ``result = result > dp[i][j] ?``                                    ``result : dp[i][j];``            ``}``        ``}``        ``return` `result;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `[][]a = {{``2``, ``2``, ``3``, ``3``, ``4``, ``4``},``                     ``{``5``, ``5``, ``7``, ``7``, ``7``, ``4``},``                     ``{``1``, ``2``, ``7``, ``7``, ``7``, ``4``},``                     ``{``4``, ``4``, ``7``, ``7``, ``7``, ``4``},``                     ``{``5``, ``5``, ``5``, ``1``, ``2``, ``7``},``                      ``{``8``, ``7``, ``9``, ``4``, ``4``, ``4``}};` `        ``System.out.println(largestKSubmatrix(a));` `    ``}``}` `// This code is contributed``// by ChitraNayal`

## C#

 `// C# program to find maximum``// K such that K x K is a``// submatrix with equal elements.``using` `System;` `class` `GFG``{``    ``static` `int` `Row = 6, Col = 6;``    ` `    ``// Returns size of the``    ``// largest square sub-matrix``    ``// with all same elements.``    ``static` `int` `largestKSubmatrix(``int``[,] a)``    ``{``        ``int``[,] dp = ``new` `int` `[Row, Col];``        ``int` `result = 0;``        ``for` `(``int` `i = 0 ; i < Row ; i++)``        ``{``            ``for` `(``int` `j = 0 ;``                     ``j < Col ; j++)``            ``{``                ``// If elements is at top``                ``// row or first column,``                ``// it wont form a square``                ``// matrix's bottom-right``                ``if` `(i == 0 || j == 0)``                    ``dp[i, j] = 1;` `                ``else``                ``{``                    ``// Check if adjacent``                    ``// elements are equal``                    ``if` `(a[i, j] == a[i - 1, j] &&``                        ``a[i, j] == a[i, j - 1] &&``                        ``a[i, j] == a[i - 1, j - 1])``                    ``{``                     ``dp[i, j] = (dp[i - 1, j] > dp[i, j - 1] &&``                                 ``dp[i - 1, j] > dp[i - 1, j - 1] + 1) ?``                                                         ``dp[i - 1, j] :``                                 ``(dp[i, j - 1] > dp[i - 1, j] &&``                                  ``dp[i, j - 1] > dp[i - 1, j - 1] + 1) ?``                                                          ``dp[i, j - 1] :``                                                   ``dp[i - 1, j - 1] + 1;``                    ``}            ` `                    ``// If not equal, then``                    ``// it will form a 1x1``                    ``// submatrix``                    ``else` `dp[i, j] = 1;``                ``}``            ` `                ``// Update result at each (i,j)``                ``result = result > dp[i, j] ?``                                    ``result : dp[i, j];``            ``}``        ``}``        ``return` `result;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int``[,] a = {{2, 2, 3, 3, 4, 4},``                    ``{5, 5, 7, 7, 7, 4},``                    ``{1, 2, 7, 7, 7, 4},``                    ``{4, 4, 7, 7, 7, 4},``                    ``{5, 5, 5, 1, 2, 7},``                    ``{8, 7, 9, 4, 4, 4}};` `        ``Console.Write(largestKSubmatrix(a));``    ``}``}` `// This code is contributed``// by ChitraNayal`

## Python 3

 `# Python 3 program to find``# maximum K such that K x K``# is a submatrix with equal``# elements.``Row ``=` `6``Col ``=` `6` `# Returns size of the``# largest square sub-matrix``# with all same elements.``def` `largestKSubmatrix(a):``    ``dp ``=` `[[``0` `for` `x ``in` `range``(Row)]``             ``for` `y ``in` `range``(Col)]` `    ``result ``=` `0``    ``for` `i ``in` `range``(Row ):``        ``for` `j ``in` `range``(Col):``            ` `            ``# If elements is at top``            ``# row or first column,``            ``# it wont form a square``            ``# matrix's bottom-right``            ``if` `(i ``=``=` `0` `or` `j ``=``=` `0``):``                ``dp[i][j] ``=` `1` `            ``else``:``                ` `                ``# Check if adjacent``                ``# elements are equal``                ``if` `(a[i][j] ``=``=` `a[i ``-` `1``][j] ``and``                    ``a[i][j] ``=``=` `a[i][j ``-` `1``] ``and``                    ``a[i][j] ``=``=` `a[i ``-` `1``][j ``-` `1``]):``                    ` `                    ``dp[i][j] ``=` `min``(``min``(dp[i ``-` `1``][j],``                                       ``dp[i][j ``-` `1``]),``                                       ``dp[i ``-` `1``][j ``-` `1``] ) ``+` `1` `                ``# If not equal, then ``                ``# it will form a 1x1``                ``# submatrix``                ``else``:``                    ``dp[i][j] ``=` `1` `            ``# Update result at each (i,j)``            ``result ``=` `max``(result, dp[i][j])``            ` `    ``return` `result` `# Driver Code``a ``=` `[[ ``2``, ``2``, ``3``, ``3``, ``4``, ``4``],``     ``[ ``5``, ``5``, ``7``, ``7``, ``7``, ``4``],``     ``[ ``1``, ``2``, ``7``, ``7``, ``7``, ``4``],``     ``[ ``4``, ``4``, ``7``, ``7``, ``7``, ``4``],``     ``[ ``5``, ``5``, ``5``, ``1``, ``2``, ``7``],``     ``[ ``8``, ``7``, ``9``, ``4``, ``4``, ``4``]];` `print``(largestKSubmatrix(a))` `# This code is contributed``# by ChitraNayal`

## PHP

 ``

## Javascript

 ``

Output

`3`

Time Complexity : O(Row * Col)
Auxiliary Space : O(Row * Col)

This article is contributed by Shubham Gupta. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up