Find Largest Rectangle in Matrix Java

In computational problems, finding the largest rectangle in a binary matrix is a classic problem that tests one's understanding of dynamic programming and stack-based approaches. The problem is often encountered in various fields, such as image processing, computer vision, and even game development. In this section, we will delve into an efficient algorithm to solve this problem using Java.

Problem Definition

Given a binary matrix (a matrix containing only 0s and 1s), the task is to find the area of the largest rectangle containing only 1s.

For example, consider the following binary matrix:

The largest rectangle containing only 1s has an area of 6.

Approach

We can break down the problem into smaller subproblems that can be solved efficiently. Here's a step-by-step approach:

Transform the Matrix: Convert each row of the matrix into a histogram representation.

Largest Rectangle in Histogram: Use a stack-based approach to find the largest rectangle in the histogram for each row.

Step-by-Step Solution

1. Transforming the Matrix

The idea is to treat each row as the base of a histogram. For each row in the matrix, if the element is 1, we add the value of the element directly above it (in the previous row) to it. This way, each row will represent a histogram of heights.

Consider the matrix:

The transformation will look like this:

2. Largest Rectangle in Histogram

For each row in the transformed matrix, we will use a stack-based approach to find the largest rectangle in a histogram.

Here's the logic to find the largest rectangle in a histogram:

Initialize:

Create a stack to store indices of the histogram.
Initialize max_area to 0.

Iterate through Histogram

For each bar in the histogram, if the stack is empty or the current bar is higher than the bar at the stack's top index, push the current index onto the stack.

If the current bar is lower than the bar at the stack's top index, pop the stack and calculate the area with the popped bar as the smallest (or minimum height) bar. Update the max_area if the newly calculated area is larger.

After the end of the histogram, pop all the remaining bars in the stack and calculate their areas as above.

Algorithm

Set 'MAX_AREA' equal to the 0.
Initialize 'PREVIOUS_ROW' and 'RESULTANT_ROW' vectors with values 0 and 'TOTAL_COLUMNS' size.
For 'CURRENT_ROW' from 0 to 'TOTAL_ROWS', do:
For 'CURRENT_COLUMN' from 0 to 'TOTAL_COLUMNS', do:
1. If MATRIX[CURRENT_ROW][CURRENT_COLUMN] is not 0, then:
  1. Set RESULTANT_ROW[CURRENT_COLUMN] = PREVIOUS_ROW[CURRENT_COLUMN] + MATRIX[CURRENT_ROW][CURRENT_COLUMN]
2. Else:
  1. Set RESULTANT_ROW[CURRENT_COLUMN] = 0.
Set 'CURRENT_MAX_AREA' = LARGEST_RECTANGLE('RESULTANT_ROW' ).
Set 'MAX_AREA' = max('MAX_AREA' , 'CURRENT_MAX_AREA' ).
Set 'PREVIOUS_ROW' = 'RESULTANT_ROW'.
Return 'MAX_AREA'.

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

Implementation

Here's the complete Java code to solve the problem:

File Name: LargestRectangleInMatrix.java

 
import java.util.Stack;
public class LargestRectangleInMatrix {
    public static int maximalRectangle(char[][] matrix) {
        if (matrix.length == 0) return 0;
        int maxArea = 0;
        int[] heights = new int[matrix[0].length];
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                // Update the heights array
                heights[j] = matrix[i][j] == '1' ? heights[j] + 1 : 0;
            }
            // Calculate the maximal rectangle area for the current row's histogram
            maxArea = Math.max(maxArea, largestRectangleArea(heights));
        }
        return maxArea;
    }
    private static int largestRectangleArea(int[] heights) {
        Stack<Integer> stack = new Stack<>();
        int maxArea = 0;
        int[] extendedHeights = new int[heights.length + 1];
        System.arraycopy(heights, 0, extendedHeights, 0, heights.length);
        extendedHeights[heights.length] = 0; // Add a zero height to flush out remaining bars
        for (int i = 0; i < extendedHeights.length; i++) {
            while (!stack.isEmpty() && extendedHeights[i] < extendedHeights[stack.peek()]) {
                int height = extendedHeights[stack.pop()];
                int width = stack.isEmpty() ? i : i - stack.peek() - 1;
                maxArea = Math.max(maxArea, height * width);
            }
            stack.push(i);
        }
        return maxArea;
    }
    public static void main(String[] args) {
        char[][] matrix = {
            {'1', '0', '1', '0', '0'},
            {'1', '0', '1', '1', '1'},
            {'1', '1', '1', '1', '1'},
            {'1', '0', '0', '1', '0'}
        };
        System.out.println("The area of the largest rectangle is: " + maximalRectangle(matrix));
    }
}   

Output:

 
The area of the largest rectangle is: 6

Explanation

The maximalRectangle() method is the main function that calculates the largest rectangle in the binary matrix. We initialize an array height to keep track of the heights of histograms for each column. We iterate through each row and update the heights array. If the current element in the matrix is '1', we increase the height by 1; otherwise, we reset the height to 0. For each updated heights array, we calculate the maximal rectangle area using the largestRectangleArea() method.

The largestRectangleArea() method calculates the largest rectangle in a histogram represented by the heights array. We use a stack to store indices of the heights array.

We iterate through the heights array and calculate the maximal rectangle area by maintaining the stack and popping elements when necessary to calculate the area.

The main method provides a sample matrix and prints the area of the largest rectangle.

Complexity Analysis

Time Complexity: The time complexity of the algorithm is O(n×m), where n is the number of rows and m is the number of columns. Because we traverse each element of the matrix once and for each row, we calculate the maximal rectangle area in O(m) time.

Space Complexity: The space complexity is O(m) due to the additional space used by the heights array and the stack.

Conclusion

Finding the largest rectangle in a binary matrix is a problem that combines elements of dynamic programming and stack-based techniques. By transforming the matrix into a series of histograms and applying an efficient stack-based method to find the maximal rectangle in each histogram, we can solve this problem effectively. The provided Java implementation illustrates this approach and can be used as a reference for similar problems.

Understanding and implementing this algorithm enhances one's ability to solve complex problems that involve multidimensional data structures and advanced algorithmic techniques.

Next TopicFloatbuffer-flip-methods-in-java-with-examples

← prev next →