Largest possible square submatrix with maximum AND value

Last Updated : 30 May, 2022

Given an integer matrix mat [ ][ ] dimensions, the task is to find the largest possible square matrix from the given matrix with maximum AND value.

AND value of a matrix is defined as the value obtained after performing bitwise AND operation on all elements of the matrix.

Examples:

Input: mat [ ][ ] = {{2, 3, 3}, {2, 3, 3}, {2, 2, 2}}
Output: 4
Explanation:
Given square submatrix has AND value 2.
The submatrix
{{3, 3}
{3, 3}}
of size 4 has maximum AND value 3. All other square submatrices of size 4 have AND value 2.

Input: mat [ ][ ] =
{{9, 9, 9, 8},
{9, 9, 9, 6},
{9, 9, 9, 3},
{2, 2, 2, 2}}
Output: 9
Explanation:
The submatrix of size 9
{{9, 9, 9},
{9, 9, 9},
{9, 9, 9}}
have maximum AND value 9.

Naive Approach:
Generate all square submatrices from the given matrix. Initialize a variable answer to store the maximum & value for submatrices and another variable count to store the number of elements in the submatrix. Print the maximum value of count corresponding to maximum AND value answer obtained from all square submatrices.

Efficient Approach:
Follow the steps below to optimize the above solution:

To maximize the & value, we need to find a submatrix that consists only of the maximum element in the matrix. This is because the maximum possible AND value in the matrix is the maximum element present in the matrix.
Find the maximum possible value present in the matrix.
Use Dynamic programming approach to get maximum size submatrix filled by the maximum matrix element only.
Create an auxiliary dp[][] such that dp[i][j] stores the largest possible square submatrix mat[i][j] can be a part of such that the AND value of that submatrix is equal to mat[i][j].
The recurrence relation is as follows:

If mat[i][j] is equal to {mat[i-1][j], mat[i][j-1], mat[i-1][j-1]} then consider all the three values as a square submatrix and update DP[i][j] as:
DP[i][j] = min(DP[i-1][j], DP[i][j-1], DP[i-1][j-1]) + 1
Otherwise,
DP[i][j] = 1
The answer would be the maximum of all DP [i][j]

Finally, iterate over the dp[][] matrix and find the largest dp[i][j] for every mat[i][j] equal to the maximum element in the array.

Below is implementation of above approach:

C++

// C++ program to find 
// the length of longest 
// possible square submatrix 
// with maximum AND value 
// from the given matrix 
#include <bits/stdc++.h> 
using namespace std; 

// Function to calculate and 
// return the length of 
// square submatrix with 
// maximum AND value 
int MAX_value(vector<vector<int> > arr) 
{ 
    // Extract dimensions 
    int row = arr.size(); 
    int col = arr[0].size(); 

    // Auxiliary array 
    int dp[row][col]; 

    // Initialize auxiliary array 
    memset(dp, sizeof(dp), 0); 

    // c: Stores the maximum 
    // value in the matrix 
    // p: Stores the number 
    // of elements in the 
    // submatrix having 
    // maximum AND value 
    int i = 0, j = 0; 
    int c = arr[0][0], p = 0; 
    int d = row; 

    // Iterate over the matrix 
    // to fill the auxiliary 
    // matrix 
    for (i = 0; i < d; i++) { 
        for (j = 0; j < d; j++) { 

            // Find the max element in the 
            // matrix side by side 
            if (c < arr[i][j]) { 
                c = arr[i][j]; 
            } 

            // Fill first row and 
            // column with 1's 
            if (i == 0 || j == 0) { 
                dp[i][j] = 1; 
            } 
            else { 

                // For every cell, check if 
                // the elements at the left, 
                // top and top left cells 
                // from the current cell 
                // are equal or not 
                if (arr[i - 1][j - 1] == arr[i][j] 
                    && arr[i - 1][j] == arr[i][j] 
                    && arr[i][j - 1] == arr[i][j]) { 

                    // Store the minimum possible 
                    // submatrix size these 
                    // elements are part of 
                    dp[i][j] 
                        = min(dp[i - 1][j - 1], 
                            min(dp[i - 1][j], 
                                dp[i][j - 1])) 
                        + 1; 
                } 
                else { 
                    // Store 1 otherwise 
                    dp[i][j] = 1; 
                } 
            } 
        } 
    } 

    for (i = 0; i < d; i++) { 
        for (j = 0; j < d; j++) { 

            // checking maximum value 
            if (arr[i][j] == c) { 

                // If the maximum AND 
                // value occurs more 
                // than once 
                if (p < dp[i][j]) { 

                    // Update the maximum 
                    // size of submatrix 
                    p = dp[i][j]; 
                } 
            } 
        } 
    } 
    // final output 
    return p * p; 
} 

// Driver Program 
int main() 
{ 
    vector<vector<int> > arr 
        = { { 9, 9, 3, 3, 4, 4 }, 
            { 9, 9, 7, 7, 7, 4 }, 
            { 1, 2, 7, 7, 7, 4 }, 
            { 4, 4, 7, 7, 7, 4 }, 
            { 5, 5, 1, 1, 2, 7 }, 
            { 2, 7, 1, 1, 4, 4 } }; 

    cout << MAX_value(arr) << endl; 

    return 0; 
}

Java

// Java program to find the length
// of longest possible square 
// submatrix with maximum AND 
// value from the given matrix
import java.util.*;

class GFG{

// Function to calculate and return
// the length of square submatrix 
// with maximum AND value
static int MAX_value(int [][]arr)
{
    
    // Extract dimensions
    int row = arr.length;
    int col = arr[0].length;

    // Auxiliary array
    int [][]dp = new int[row][col];

    // c: Stores the maximum
    // value in the matrix
    // p: Stores the number
    // of elements in the
    // submatrix having
    // maximum AND value
    int i = 0, j = 0;
    int c = arr[0][0], p = 0;
    int d = row;

    // Iterate over the matrix
    // to fill the auxiliary
    // matrix
    for(i = 0; i < d; i++) 
    {
        for(j = 0; j < d; j++)
        {
            
            // Find the max element in 
            // the matrix side by side
            if (c < arr[i][j]) 
            {
                c = arr[i][j];
            }

            // Fill first row and
            // column with 1's
            if (i == 0 || j == 0) 
            {
                dp[i][j] = 1;
            }
            else 
            {

                // For every cell, check if the 
                // elements at the left, top and
                // top left cells from the current
                // cell are equal or not
                if (arr[i - 1][j - 1] == arr[i][j] && 
                    arr[i - 1][j] == arr[i][j] && 
                    arr[i][j - 1] == arr[i][j]) 
                {
                    
                    // Store the minimum possible
                    // submatrix size these
                    // elements are part of
                    dp[i][j] = Math.min(dp[i - 1][j - 1],
                               Math.min(dp[i - 1][j],
                                        dp[i][j - 1])) + 1;
                }
                else
                {
                    
                    // Store 1 otherwise
                    dp[i][j] = 1;
                }
            }
        }
    }
    for(i = 0; i < d; i++)
    {
        for(j = 0; j < d; j++)
        {
            
            // Checking maximum value
            if (arr[i][j] == c)
            {
                
                // If the maximum AND
                // value occurs more
                // than once
                if (p < dp[i][j]) 
                {
                    
                    // Update the maximum
                    // size of submatrix
                    p = dp[i][j];
                }
            }
        }
    }
    
    // Final output
    return p * p;
}

// Driver code
public static void main(String[] args)
{
    int [][]arr = { { 9, 9, 3, 3, 4, 4 },
                    { 9, 9, 7, 7, 7, 4 },
                    { 1, 2, 7, 7, 7, 4 },
                    { 4, 4, 7, 7, 7, 4 },
                    { 5, 5, 1, 1, 2, 7 },
                    { 2, 7, 1, 1, 4, 4 } };

    System.out.print(MAX_value(arr) + "\n");
}
}

// This code contributed by amal kumar choubey

Python3

# Python3 program to find the length
# of longest possible square submatrix 
# with maximum AND value from the given
# matrix 

# Function to calculate and return the 
# length of square submatrix with 
# maximum AND value 
def MAX_value(arr): 
    
    # Extract dimensions 
    row = len(arr) 
    col = len(arr) 

    # Auxiliary array 
    # Initialize auxiliary array
    dp = [[0 for i in range(col)] 
             for j in range(row)] 

    # c: Stores the maximum 
    # value in the matrix 
    # p: Stores the number 
    # of elements in the 
    # submatrix having 
    # maximum AND value 
    i, j = 0, 0 
    c, p = arr[0][0], 0
    d = row

    # Iterate over the matrix 
    # to fill the auxiliary 
    # matrix 
    for i in range(d):
        for j in range(d):

            # Find the max element in the 
            # matrix side by side 
            if (c < arr[i][j]):
                c = arr[i][j]

            # Fill first row and 
            # column with 1's 
            if (i == 0 or j == 0):
                dp[i][j] = 1
            else:

                # For every cell, check if 
                # the elements at the left, 
                # top and top left cells 
                # from the current cell 
                # are equal or not 
                if (arr[i - 1][j - 1] == arr[i][j] and 
                    arr[i - 1][j] == arr[i][j] and 
                    arr[i][j - 1] == arr[i][j]):

                    # Store the minimum possible 
                    # submatrix size these 
                    # elements are part of 
                    dp[i][j] = min(dp[i - 1][j - 1], 
                               min(dp[i - 1][j], 
                                dp[i][j - 1])) + 1
                else:
                    
                    # Store 1 otherwise 
                    dp[i][j] = 1

    for i in range(d):
        for j in range(d):

            # Checking maximum value 
            if (arr[i][j] == c):

                # If the maximum AND 
                # value occurs more 
                # than once 
                if (p < dp[i][j]): 

                    # Update the maximum 
                    # size of submatrix 
                    p = dp[i][j]
    
    # Final output 
    return p * p

# Driver Code 
arr = [ [ 9, 9, 3, 3, 4, 4 ], 
        [ 9, 9, 7, 7, 7, 4 ], 
        [ 1, 2, 7, 7, 7, 4 ], 
        [ 4, 4, 7, 7, 7, 4 ], 
        [ 5, 5, 1, 1, 2, 7 ], 
        [ 2, 7, 1, 1, 4, 4 ]] 

print(MAX_value(arr))

# This code is contributed by divyeshrabadiya07

// C# program to find the length
// of longest possible square 
// submatrix with maximum AND 
// value from the given matrix
using System;

class GFG{

// Function to calculate and return
// the length of square submatrix 
// with maximum AND value
static int MAX_value(int [,]arr)
{
    
    // Extract dimensions
    int row = arr.GetLength(0);
    int col = arr.GetLength(1);

    // Auxiliary array
    int [,]dp = new int[row, col];

    // c: Stores the maximum
    // value in the matrix
    // p: Stores the number
    // of elements in the
    // submatrix having
    // maximum AND value
    int i = 0, j = 0;
    int c = arr[0, 0], p = 0;
    int d = row;

    // Iterate over the matrix
    // to fill the auxiliary
    // matrix
    for(i = 0; i < d; i++) 
    {
        for(j = 0; j < d; j++)
        {
            
            // Find the max element in 
            // the matrix side by side
            if (c < arr[i, j]) 
            {
                c = arr[i, j];
            }

            // Fill first row and
            // column with 1's
            if (i == 0 || j == 0) 
            {
                dp[i, j] = 1;
            }
            else
            {
                
                // For every cell, check if the 
                // elements at the left, top and
                // top left cells from the current
                // cell are equal or not
                if (arr[i - 1, j - 1] == arr[i, j] && 
                    arr[i - 1, j] == arr[i, j] && 
                    arr[i, j - 1] == arr[i, j]) 
                {
                    
                    // Store the minimum possible
                    // submatrix size these
                    // elements are part of
                    dp[i, j] = Math.Min(dp[i - 1, j - 1],
                               Math.Min(dp[i - 1, j],
                                        dp[i, j - 1])) + 1;
                }
                else
                {
                    
                    // Store 1 otherwise
                    dp[i, j] = 1;
                }
            }
        }
    }
    for(i = 0; i < d; i++)
    {
        for(j = 0; j < d; j++)
        {
            
            // Checking maximum value
            if (arr[i, j] == c)
            {
                
                // If the maximum AND
                // value occurs more
                // than once
                if (p < dp[i, j]) 
                {
                    
                    // Update the maximum
                    // size of submatrix
                    p = dp[i, j];
                }
            }
        }
    }
    
    // Final output
    return p * p;
}

// Driver code
public static void Main(String[] args)
{
    int [,]arr = { { 9, 9, 3, 3, 4, 4 },
                   { 9, 9, 7, 7, 7, 4 },
                   { 1, 2, 7, 7, 7, 4 },
                   { 4, 4, 7, 7, 7, 4 },
                   { 5, 5, 1, 1, 2, 7 },
                   { 2, 7, 1, 1, 4, 4 } };

    Console.Write(MAX_value(arr) + "\n");
}
}

// This code is contributed by gauravrajput1

JavaScript

<script>

// Javascript program to find the length
// of longest possible square 
// submatrix with maximum AND 
// value from the given matrix

    // Function to calculate and return
    // the length of square submatrix
    // with maximum AND value
    function MAX_value(arr) {

        // Extract dimensions
        var row = arr.length;
        var col = arr[0].length;

        // Auxiliary array
        var dp = Array(row);
        for(var i = 0;i<row;i++)
        dp[i] = Array(col).fill(0);

        // c: Stores the maximum
        // value in the matrix
        // p: Stores the number
        // of elements in the
        // submatrix having
        // maximum AND value
        var i = 0, j = 0;
        var c = arr[0][0], p = 0;
        var d = row;

        // Iterate over the matrix
        // to fill the auxiliary
        // matrix
        for (i = 0; i < d; i++) {
            for (j = 0; j < d; j++) {

                // Find the max element in
                // the matrix side by side
                if (c < arr[i][j]) {
                    c = arr[i][j];
                }

                // Fill first row and
                // column with 1's
                if (i == 0 || j == 0) {
                    dp[i][j] = 1;
                } else {

                    // For every cell, check if the
                    // elements at the left, top and
                    // top left cells from the current
                    // cell are equal or not
                    if (arr[i - 1][j - 1] == arr[i][j] && 
                    arr[i - 1][j] == arr[i][j] &&
                    arr[i][j - 1] == arr[i][j]) {

                        // Store the minimum possible
                        // submatrix size these
                        // elements are part of
                        dp[i][j] = Math.min(dp[i - 1][j - 1], 
                        Math.min(dp[i - 1][j], 
                        dp[i][j - 1])) + 1;
                    } else {

                        // Store 1 otherwise
                        dp[i][j] = 1;
                    }
                }
            }
        }
        for (i = 0; i < d; i++) {
            for (j = 0; j < d; j++) {

                // Checking maximum value
                if (arr[i][j] == c) {

                    // If the maximum AND
                    // value occurs more
                    // than once
                    if (p < dp[i][j]) {

                        // Update the maximum
                        // size of submatrix
                        p = dp[i][j];
                    }
                }
            }
        }

        // Final output
        return p * p;
    }

    // Driver code
    
        var arr = [ [ 9, 9, 3, 3, 4, 4 ],
                    [ 9, 9, 7, 7, 7, 4 ],
                    [ 1, 2, 7, 7, 7, 4 ], 
                    [ 4, 4, 7, 7, 7, 4 ],
                    [ 5, 5, 1, 1, 2, 7 ], 
                    [ 2, 7, 1, 1, 4, 4 ] ];

        document.write(MAX_value(arr) + "\n");

// This code contributed by umadevi9616

</script>

Output:

Time Complexity: O(N*N), as we are using nested loops to traverse N*N times.

Auxiliary Space: O(N*N), as we are using extra space for matrix.

Largest possible square submatrix with maximum AND value

vabzcode12

Improve

Article Tags :

Practice Tags :

Largest possible square submatrix with maximum AND value

Similar Reads

Thank You!

What kind of Experience do you want to share?