Find Maximum side length of square in a Matrix

Given a square matrix of odd order N. The task is to find the side-length of the largest square formed in the matrix. A square in matrix is said to be formed if all elements on its perimeter is same and its centre is centre of matrix. Centre of matrix is also a square with side length 1.

Examples: 

Input : matrix[][] = {2, 3, 0,
                      0, 2, 0,
                      0, 1, 1}
Output : 1

Input : matrix[][] = {2, 2, 2,
                      2, 1, 2,
                      2, 2, 2}
Output : 3

The centre of any odd order matrix is element with index i = j = n/2. Now, for finding largest square in matrix, check all surrounding elements from centre which are at same distance. For a square which is i-unit away from centre check all the element which are in the n/2-i and n/2+i row and column also difference of n/2 and either of index of element does-not exceed i. Please find the format of a square with different possible side length in below example. 

x x x x x
x y y y x
x y c y x
x y y y x
x x x x x

Points to care about : 

• As centre element is also a form of square minimum possible side length is 1.
• Longest square can be with all elements present in 1st row and 1 column, hence maximum possible side-length is n 

Algorithm : 

• Iterate over i=0 to n/2
  • iterate over column i to n-i-1 for row i and n-i-1 both 
    and vice-versa and check whether all elements are same or not.
  • If yes then length of square is n-2*i.
  • Else go for next iteration

Below is the implementation of the above approach:

// C++ program to find max possible side-length
// of a square in a given matrix

#include <bits/stdc++.h>
#define n 5
using namespace std;

// Function to return side-length of square
int largestSideLen(int matrix[][n])
{
    int result = 1;

    // Traverse the matrix
    for (int i = 0; i < n / 2; i++) {

        int element = matrix[i][i];
        int isSquare = 1;

        for (int j = i; j < n - i; j++) {
            // for row i
            if (matrix[i][j] != element)
                isSquare = 0;
            // for row n-i-1
            if (matrix[n - i - 1][j] != element)
                isSquare = 0;
            // for column i
            if (matrix[j][i] != element)
                isSquare = 0;
            // for column n-i-1
            if (matrix[j][n - i - 1] != element)
                isSquare = 0;
        }

        if (isSquare)
            return n - 2 * i;
    }

    // Return result
    return result;
}

// Driver program
int main()
{
    int matrix[n][n] = { 1, 1, 1, 1, 1,
                         1, 2, 2, 2, 1,
                         1, 2, 1, 2, 1,
                         1, 2, 2, 2, 1,
                         1, 1, 1, 1, 1 };

    cout << largestSideLen(matrix);

    return 0;
}

// Java program to find max possible side-length
// of a square in a given matrix

import java.io.*;

class GFG {
static int n = 5;
    // Function to return side-length of square
static int largestSideLen(int matrix[][])
{
    int result = 1;

    // Traverse the matrix
    for (int i = 0; i < (n / 2); i++) {

        int element = matrix[i][i];
        int isSquare = 1;

        for (int j = i; j < n - i; j++) {
            // for row i
            if (matrix[i][j] != element)
                isSquare = 0;
            // for row n-i-1
            if (matrix[n - i - 1][j] != element)
                isSquare = 0;
            // for column i
            if (matrix[j][i] != element)
                isSquare = 0;
            // for column n-i-1
            if (matrix[j][n - i - 1] != element)
                isSquare = 0;
        }

        if (isSquare > 0)
            return n - (2 * i);
    }

    // Return result
    return result;
}

// Driver program
    
    public static void main (String[] args) {
        int matrix[][] = {{ 1, 1, 1, 1, 1},
                        {1, 2, 2, 2, 1},
                        {1, 2, 1, 2, 1},
                        {1, 2, 2, 2, 1},
                        {1, 1, 1, 1, 1 }};

    System.out.println (largestSideLen(matrix));
        
        
    }
}

# Python 3 program to find max possible 
# side-length of a square in a given matrix

n = 5

# Function to return side-length of square
def largestSideLen(matrix):
    result = 1

    # Traverse the matrix
    for i in range(int(n / 2)):
        element = matrix[i][i]
        isSquare = 1

        for j in range(i, n - i):
            
            # for row i
            if (matrix[i][j] != element):
                isSquare = 0
                
            # for row n-i-1
            if (matrix[n - i - 1][j] != element):
                isSquare = 0
                
            # for column i
            if (matrix[j][i] != element):
                isSquare = 0
                
            # for column n-i-1
            if (matrix[j][n - i - 1] != element):
                isSquare = 0

        if (isSquare):
            return n - 2 * i

    # Return result
    return result

# Driver Code
if __name__ == '__main__':
    matrix = [[1, 1, 1, 1, 1],
              [1, 2, 2, 2, 1],
              [1, 2, 1, 2, 1],
              [1, 2, 2, 2, 1],
              [1, 1, 1, 1, 1]]

    print(largestSideLen(matrix))

# This code is contributed by
# Surendra_Gangwar

// C#  program to find max possible side-length
// of a square in a given matrix
using System;

public class GFG{
    static int n = 5;
    // Function to return side-length of square
static int largestSideLen(int [,]matrix)
{
    int result = 1;

    // Traverse the matrix
    for (int i = 0; i < (n / 2); i++) {

        int element = matrix[i,i];
        int isSquare = 1;

        for (int j = i; j < n - i; j++) {
            // for row i
            if (matrix[i,j] != element)
                isSquare = 0;
            // for row n-i-1
            if (matrix[n - i - 1,j] != element)
                isSquare = 0;
            // for column i
            if (matrix[j,i] != element)
                isSquare = 0;
            // for column n-i-1
            if (matrix[j,n - i - 1] != element)
                isSquare = 0;
        }

        if (isSquare > 0)
            return n - (2 * i);
    }

    // Return result
    return result;
}

// Driver program
    
    
    static public void Main (){
        int [,]matrix = {{ 1, 1, 1, 1, 1},
                        {1, 2, 2, 2, 1},
                        {1, 2, 1, 2, 1},
                        {1, 2, 2, 2, 1},
                        {1, 1, 1, 1, 1 }};

           Console.WriteLine(largestSideLen(matrix));
        
    }
}

<?php
// PHP program to find max possible
// side-length of a square in a given matrix 

// Function to return side-length of square 
function largestSideLen($matrix) 
{ 
    $n = 5; 
    $result = 1; 

    // Traverse the matrix 
    for ($i = 0; $i < ($n / 2); $i++)
    { 

        $element = $matrix[$i][$i]; 
        $isSquare = 1; 

        for ($j = $i; $j < ($n - $i); $j++) 
        { 
            // for row i 
            if ($matrix[$i][$j] != $element) 
                $isSquare = 0; 
                
            // for row n-i-1 
            if ($matrix[$n - $i - 1][$j] != $element) 
                $isSquare = 0; 
                
            // for column i 
            if ($matrix[$j][$i] != $element) 
                $isSquare = 0; 
                
            // for column n-i-1 
            if ($matrix[$j][$n - $i - 1] != $element) 
                $isSquare = 0; 
        } 

        if ($isSquare) 
            return ($n - 2 * $i); 
    } 

    // Return result 
    return $result; 
} 

// Driver Code 
$matrix = array( 1, 1, 1, 1, 1, 
                 1, 2, 2, 2, 1, 
                 1, 2, 1, 2, 1, 
                 1, 2, 2, 2, 1, 
                 1, 1, 1, 1, 1 ); 

echo largestSideLen($matrix); 

// This code is contributed by Sachin
?>

<script>

// Javascript program to find max 
// possible side-length
// of a square in a given matrix

const n = 5;

// Function to return 
// side-length of square
function largestSideLen(matrix)
{
    let result = 1;

    // Traverse the matrix
    for (let i = 0; i < parseInt(n / 2); i++) 
    {

        let element = matrix[i][i];
        let isSquare = 1;

        for (let j = i; j < n - i; j++) {
            // for row i
            if (matrix[i][j] != element)
                isSquare = 0;
            // for row n-i-1
            if (matrix[n - i - 1][j] != element)
                isSquare = 0;
            // for column i
            if (matrix[j][i] != element)
                isSquare = 0;
            // for column n-i-1
            if (matrix[j][n - i - 1] != element)
                isSquare = 0;
        }

        if (isSquare)
            return n - 2 * i;
    }

    // Return result
    return result;
}

// Driver program
    let matrix = [ [1, 1, 1, 1, 1],
                   [1, 2, 2, 2, 1],
                   [1, 2, 1, 2, 1],
                   [1, 2, 2, 2, 1],
                   [1, 1, 1, 1, 1 ]];

    document.write(largestSideLen(matrix));

</script>

5