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 <= A_{i , j} <= 10⁹

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(n³) time and check whether each submatrix contains equal elements or not in O(n²) time Which makes the total running time of the algorithm as O(n⁵).

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 DP_i,j depends upon {DP_{i-1, j}, DP_{i, j-1}, DP_{i-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<bits/stdc++.h>
#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

<?php
// Java 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.
function largestKSubmatrix(&$a)
{
    global $Row, $Col;

    $result = 0;
    for ($i = 0 ;
         $i < $Row ; $i++)
    {
        for ($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;
}

// Driver Code
$a = array(array(2, 2, 3, 3, 4, 4),
           array(5, 5, 7, 7, 7, 4),
           array(1, 2, 7, 7, 7, 4),
           array(4, 4, 7, 7, 7, 4),
           array(5, 5, 5, 1, 2, 7),
           array(8, 7, 9, 4, 4, 4));

echo largestKSubmatrix($a);

// This code is contributed
// by ChitraNayal
?>

Javascript

<script>

// Javascript program to find maximum
// K such that K x K is a
// submatrix with equal elements.

    let Row = 6, Col = 6;

    // Returns size of the largest
    // square sub-matrix with
    // all same elements.
    function largestKSubmatrix(a)
    {
        let dp = new Array(Row);
        for(let i = 0; i < Row; i++)
        {
            dp[i] = new Array(Col);
            for(let j = 0; j < Col; j++)
            {
                dp[i][j] = 0;
            }
        }
        let result = 0;
        for (let i = 0 ;
                 i < Row ; i++)
        {
            for (let 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
    let 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]];

    document.write(largestKSubmatrix(a));

    // This code is contributed by avanitrachhadiya2155
</script>

Output

3

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