Largest Square Matrix Problem in Java

The Largest Square Matrix Problem involves finding the size of the largest square sub-matrix within a given binary matrix, where all the elements of the sub-matrix are 1s. It is a classic problem of using dynamic programming to solve a two-dimensional problem efficiently.

In Java, the problem can be approached by creating an auxiliary matrix to store intermediate results, which helps in reducing the time complexity significantly compared to a naive solution.

Problem Statement

Given a boolean matrix of 0's and 1's, find and print the largest square sub-matrix whose all the entries are 1.

Example of Largest Square Matrix

Matrix:

0 0 1 1

0 1 1 1

0 0 0 1

Output:

1 1

Solution to the Problem

Naive Approach

It is the simplest way to find the largest square matrix. The algorithm for the given problem is as follows.

Algorithm

Step 1: Create a 2D auxiliary matrix S with the same dimensions as the input matrix to store the size of the largest square sub-matrix ending at each position.

Step 2: Copy the first row and first column of the input matrix directly into the auxiliary matrix S. Track the maximum size of the square sub-matrix found in these rows and columns.

Step 3: For each cell matrix[i][j] in the input matrix (starting from the second row and second column), if the cell contains a 1, calculate the size of the largest square sub-matrix ending at that cell using the formula:

If the cell contains a 0, set S[i][j] to 0.
Update the maximum size and the position of the bottom-right corner of the largest square sub-matrix found.

Step 4: Print the elements of the largest square sub-matrix using the tracked maximum size and position.

Step 5: Return the size of the largest square sub-matrix with all 1s.

Let's implement the above algorithm in a Java program.

File Name: LargestSquareMatrix.java

public class LargestSquareMatrix {
    // Method to find the size of the largest square sub-matrix with all 1s
    public static int largestSquareMatrix(int[][] matrix) {
        // Check if the matrix is null or empty
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return 0; // Return 0 if the matrix is invalid
        }
        int rows = matrix.length; // Get the number of rows in the matrix
        int cols = matrix[0].length; // Get the number of columns in the matrix
        int[][] S = new int[rows][cols]; // Create a sum matrix with the same dimensions as the input matrix
        int maxSize = 0; // Variable to track the size of the largest square sub-matrix
        int max_i = 0, max_j = 0; // Variables to track the position of the bottom-right corner of the largest square sub-matrix
        // Copy the first row and first column as is from the input matrix to the sum matrix
        for (int i = 0; i < rows; i++) {
            S[i][0] = matrix[i][0];
            if (S[i][0] > maxSize) {
                maxSize = S[i][0];
                max_i = i;
                max_j = 0;
            }
        }
        for (int j = 0; j < cols; j++) {
            S[0][j] = matrix[0][j];
            if (S[0][j] > maxSize) {
                maxSize = S[0][j];
                max_i = 0;
                max_j = j;
            }
        }
        // Construct the rest of the sum matrix
        for (int i = 1; i < rows; i++) {
            for (int j = 1; j < cols; j++) {
                if (matrix[i][j] == 1) {
                    S[i][j] = Math.min(S[i][j-1], Math.min(S[i-1][j], S[i-1][j-1])) + 1;
                    if (S[i][j] > maxSize) {
                        maxSize = S[i][j];
                        max_i = i;
                        max_j = j;
                    }
                } else {
                    S[i][j] = 0;
                }
            }
        }
        // Print the largest square sub-matrix
        System.out.println("The largest square sub-matrix with all 1s is:");
        for (int i = max_i - maxSize + 1; i <= max_i; i++) {
            for (int j = max_j - maxSize + 1; j <= max_j; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
        return maxSize; // Return the size of the largest square sub-matrix
    }
    // Main method to test the largestSquareMatrix method
    public static void main(String[] args) {
        // Define a sample binary matrix
        int[][] matrix = {
            {1, 0, 1, 0, 0},
            {1, 0, 1, 1, 1},
            {1, 1, 1, 1, 1},
            {1, 0, 0, 1, 0}
        };
        // Call the method and print the result
        int maxSize = largestSquareMatrix(matrix);
        System.out.println("The size of the largest square sub-matrix with all 1s is: " + maxSize);
    }
}   

Output:

 
The largest square sub-matrix with all 1s is:
1 1 
1 1 
The size of the largest square sub-matrix with all 1s is: 2

Time Complexity

The time complexity of the above code is O(rows×cols), where rows is the number of rows and cols is the number of columns in the matrix. It is because the code iterates through each cell in the matrix once.

Auxiliary Space

The auxiliary space of the above code is O(rows×cols). It is due to the additional space used by the S matrix, which has the same dimensions as the input matrix.

Using Dynamic Programming Approach

We will use a dynamic programming (DP) table where dp[i][j] represents the side length of the largest square sub-matrix whose bottom-right corner is at (i, j).

Algorithm

Step 1: Create a 2D array dp with the same dimensions as the input matrix.

Step 2: If the element in the original matrix is 0, the corresponding element in the DP table will also be 0 because no square sub-matrix can end at a cell with 0.

Step 3: If the element in the original matrix is 1, the value of dp[i][j] will be the minimum of the values of its top (dp[i-1][j]), left (dp[i][j-1]), and top-left diagonal (dp[i-1][j-1]) neighbors plus 1.

Step 4: It will be the size of the largest square sub-matrix with all 1s.

Let's implement the above algorithm in a Java program.

File Name: LargestSquareMatrixDP.java

public class LargestSquareMatrixDP {
    // Method to find the size of the largest square sub-matrix with all 1s
    public static int largestSquareMatrix(int[][] matrix) {
        // Check if the matrix is null or empty
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return 0; // Return 0 if the matrix is invalid
        }
        int rows = matrix.length; // Get the number of rows in the matrix
        int cols = matrix[0].length; // Get the number of columns in the matrix
        int[][] dp = new int[rows][cols]; // Create a DP array with the same dimensions as the matrix
        int maxSize = 0; // Variable to track the size of the largest square sub-matrix
        // Loop through each cell in the matrix
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                // If the current cell in the matrix contains a 1
                if (matrix[i][j] == 1) {
                    // If the current cell is in the first row or first column
                    if (i == 0 || j == 0) {
                        dp[i][j] = 1; // The size of the largest square sub-matrix ending at this cell is 1
                    } else {
                        // Calculate the size of the largest square sub-matrix ending at this cell
                        dp[i][j] = Math.min(dp[i-1][j], Math.min(dp[i][j-1], dp[i-1][j-1])) + 1;
                    }
                    // Update maxSize if the current square size is larger
                    maxSize = Math.max(maxSize, dp[i][j]);
                }
            }
        }
        return maxSize; // Return the size of the largest square sub-matrix
    }
    // Main method to test the largestSquareMatrix method
    public static void main(String[] args) {
        // Define a sample binary matrix
        int[][] matrix = {
            {1, 0, 1, 0, 0},
            {1, 0, 1, 1, 1},
            {1, 1, 1, 1, 1},
            {1, 0, 0, 1, 0}
        };
        // Call the method and print the result
        System.out.println("The size of the largest square sub-matrix with all 1s is: " + largestSquareMatrix(matrix));
    }
}   

Output:

 
The size of the largest square sub-matrix with all 1s is: 2

Time Complexity

The time complexity of the above code is O(rows×cols), where rows is the number of rows and cols is the number of columns in the matrix. It is because we are iterating through each cell in the matrix once.

Auxiliary Space

The auxiliary space of the above code is O(rows×cols). It is due to the additional space used by the dp array, which has the same dimensions as the input matrix.

Next TopicObject-reference-equality

← prev next →