Maximum Size Square Sub-matrix with all 1s

The Maximum Size Square Sub-matrix with all 1s problem is a classic dynamic programming problem. The goal is to find the largest square sub-matrix that contains only 1s in a given matrix of 0s and 1s.

Algorithm:

Create a new matrix of the same size as the input matrix to store the results. Let's call this matrix dp.

Initialize the first row and the first column of the dp matrix with the same values as the input matrix.

For each cell (i, j) in the input matrix starting from (1, 1):

If the cell in the input matrix is 1, set dp[i][j] to the minimum value of the cells above, to the left, and diagonally above-left to (i, j). Then, increment dp[i][j] by 1.
If the cell in the input matrix is 0, set dp[i][j] to 0, as a square cannot be formed with a 0.

Find the maximum value in the dp matrix. The square of this value represents the size of the largest square sub-matrix with all 1s.

Java code:

public class MaximumSquareSubMatrix {

    public static intfindMaxSquareSubMatrix(int[][] matrix) {
        // Get the number of rows and columns in the input matrix
int rows = matrix.length;
int cols = matrix[0].length;

        // Create a 2D array 'dp' to store the results
int[][] dp = new int[rows][cols];
intmaxSquareSize = 0;

        // Step 1: Initialize the first row and the first column of dp with the values of the input matrix
        for (inti = 0; i< rows; i++) {
dp[i][0] = matrix[i][0];
            // Update 'maxSquareSize' with the maximum value in the first column
maxSquareSize = Math.max(maxSquareSize, dp[i][0]);
        }

        for (int j = 0; j < cols; j++) {
dp[0][j] = matrix[0][j];
            // Update 'maxSquareSize' with the maximum value in the first row
maxSquareSize = Math.max(maxSquareSize, dp[0][j]);
        }

        // Step 2: Calculate the remaining cells in dp
        for (inti = 1; i< rows; i++) {
            for (int j = 1; j < cols; j++) {
                // If the cell in the input matrix is 1
                if (matrix[i][j] == 1) {
                    // Find the minimum value among the cell above, to the left, and diagonally above-left
dp[i][j] = Math.min(Math.min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]) + 1;
                    // Update 'maxSquareSize' with the maximum value found so far in dp
maxSquareSize = Math.max(maxSquareSize, dp[i][j]);
                } else {
                    // If the cell in the input matrix is 0, set the corresponding cell in dp to 0
                    // (as a square sub-matrix cannot be formed with a 0)
dp[i][j] = 0;
                }
            }
        }

        // Step 3: Return the square of 'maxSquareSize', which represents the size of the largest square sub-matrix
        return maxSquareSize * maxSquareSize;
    }

    public static void main(String[] args) {
int[][] matrix = {
            {1, 0, 1, 0, 0},
            {1, 1, 1, 1, 1},
            {0, 1, 1, 1, 1},
            {1, 1, 1, 1, 0},
            {1, 1, 1, 0, 1}
        };

        // Call the 'findMaxSquareSubMatrix' function with the input matrix to find the maximum size of square sub-matrix
intmaxSquareSize = findMaxSquareSubMatrix(matrix);

        // Print the result
System.out.println("Maximum size of square sub-matrix with all 1s: " + maxSquareSize);
    }
}

Output:

Explanation:

The findMaxSquareSubMatrix function takes a 2D matrix as input and returns the size of the maximum square sub-matrix with all 1s.
The dp matrix is used to store the results. It has the same dimensions as the input matrix.
The function initializes the first row and the first column of the dp matrix with the values of the input matrix since they don't have any dependencies on previous rows or columns.
The nested loop iterates through the remaining cells (excluding the first row and first column) of the dp matrix and calculates the size of the largest square sub-matrix that can be formed ending at that cell.
If the cell in the input matrix is 1, the function sets the value of dp[i][j] to the minimum value of the cells above, to the left, and diagonally above-left to (i, j). It then increments the value by 1 to represent the current cell's contribution to the size of the square sub-matrix.
If the cell in the input matrix is 0, the function sets dp[i][j] to 0 since a square sub-matrix cannot be formed with a 0.
While calculating the dp matrix, the function keeps track of the maximum value found so far, which represents the size of the largest square sub-matrix with all 1s.
The function finally returns the square of the maximum value found, which gives the size of the largest square sub-matrix.

Time Complexity: O(rows*cols) //where "rows" is the number of rows in the input matrix and "cols" is the number of columns in the input matrix.

Space Complexity: O(rows*cols) // for dp array

Next TopicMaximum Sum Rectangle in a 2D Matrix

← prev next →