# MAXIMUM SIZE RECTANGLE

The Maximum Size Cube Double Sub-matrix with All 1s is a classic problem in computer science and algorithmic programming that involves changing the largest blockish sub-matrix in a double matrix (a matrix consisting of only 0s and 1s) where all the rudiments are 1s. This problem is also known as the" Maximum Histogram Area" problem when it's applied to a histogram. Then, there is a brief introduction to the problem and its significance.

### Problem Statement

Given a double matrix, the task is to find the maximum area cube in the matrix where all the rudiments are 1s. The cube must be made up of successive rows and columns.

Example:

Consider the following binary matrix:

The maximum size rectangle binary sub-matrix with all 1s is:

The Area of this rectangle is 5.

### Significance

This problem is essential in colorful operations, including image processing, computer vision, and database systems. It's frequently used to describe the largest connected region in a double image efficiently or to find the largest blockish Area in a histogram, among other operations.

## Approach

Working on this problem efficiently requires an optimized algorithm. One common approach involves using dynamic programming and maintaining a supplementary matrix to store the maximum height of successive 1s ending at each cell. By doing so, you can calculate the maximum Area for each cell in the matrix, considering it as the base of the cube.

Mock law

1. Initialize a supplementary matrix to store the maximum height of successive 1s ending at each cell.
2. Reiterate through each row of the double matrix and modernize the supplementary matrix.
3. For each cell in the matrix, calculate the maximum area cube ending at that cell grounded on the supplementary matrix.
4. Keep track of the maximum Area encountered during the replication.

The Maximum Size Cube double Sub-matrix with All 1s problem is a grueling and intriguing problem that demonstrates the significance of algorithmic optimization in working real-world problems efficiently. It combines the rudiments of dynamic programming and matrix manipulation to find an optimal result.

### Perpetration

Still, also the largest Area of the histogram can be set up If the height of the bars of the histogram is given. This way, in each row, the largest Area of bars of the histogram can be set up. To get the largest cube full of 1's, modernize the coming row with the former row and find the largest Area under the histogram, i.e., consider each 1's as filled places, and 0's with an empty forecourt and consider each row as the base.

### Illustration

Input:

Step 1

0 1 1 0 maximum Area = 2

Step 2

row 1 1 2 2 1 area = 4, maximum Area becomes 4

row 2 2 3 3 2 area = 8, maximum Area becomes 8

row 3 3 4 0 0 area = 6, maximum Area remains 8

### Algorithm

1. Run a circle to cut through the rows.
2. Now, if the current row isn't the first row, also modernize the row as follows: if matrix( i)( j) isn't zero, also matrix( i)( j) = matrix( i- 1)( j) matrix( i)( j).
3. Find the maximum blockish Area under the histogram, and consider the ith row as the height of bars of a histogram. This can be calculated as given in this composition: Largest Rectangular Area in a Histogram
4. Do the former two ways for all rows and publish the maximum Area of all the rows.

#### Note: It's explosively recommended to relate to this post first as the utmost of the law is taken from there.

Code:

Output:

The output of the above code is:

Explanation

The handed Python program defines a class named Solution that addresses the problem of changing the largest cube with all 1s in a double matrix. This is a common problem in computer wisdom and has operations in image processing, computer vision, and algorithmic design.

The result class has two main styles, maxHist and maxRectangle. The maxHist system calculates the maximum Area of a histogram represented by a given row. It utilizes a mound to keep track of the indicators of bars in the histogram. The algorithm iterates through the bars of the histogram, comparing each bar's height with the bar at the top of the stack. However, the current bar's indicator is pushed onto the mound If the current bar is high or the mound is empty. However, the algorithm calculates the Area of the cube formed by the bar at the top of the mound as the lowest bar If the current bar is shorter. The process continues until a high bar is encountered or the mound becomes empty. The maximum Area is streamlined consequently. This system efficiently computes the maximum Area under the histogram indirect time.

The maxRectangle system applies the maxHist system to each row of the double matrix. It iterates through the rows, streamlining the values in each cell grounded on the accumulation of successive 1s above it. This process effectively converts the double matrix into a histogram representation. For each row, it also calls the maxHist system to find the maximum Area of the histogram. The overall result is streamlined with the maximum Area attained from all rows.

The motorist law initializes a double matrix A and creates a case of the result class( ans). It also prints the result attained by calling the maxRectangle system on the matrix. In the handed illustration matrix A, the largest cube with all 1s is formed by the alternate and third rows, performing in an area of 8. The affair of the program is" Area of the maximum cube is 8."

This algorithmic approach is effective and has a time complexity of O( m * n), where m and n are the confines of the matrix. The algorithm optimally utilizes a mound data structure to avoid spare computations and efficiently computes the maximum cube area in a double matrix. Understanding and enforcing similar algorithms are pivotal in working problems related to data structures and computational figures.

Complications

Time Complexity

1. The maxHist system iterates through each element of a row formerly, using a while circle. In the worst case, it traverses all rudiments formerly, performing in a time complexity of O( n), where n is the number of rudiments in a row.
2. The maxRectangle system iterates through each row( m rows), and for each row, it calls the maxHist system, which takes O( n) time. Thus, the overall time complexity is O( m * n), where m is the number of rows, and n is the number of rudiments in a row.

Space Complexity

1. The maxHist system uses a mound to store indicators. In the worst case, when all rudiments are in decreasing order, the mound can store all indicators, performing in a space complexity of O( n), where n is the number of rudiments in a row.
2. The maxRectangle system uses fresh space to store the result and the modified double matrix. The space needed for the result is constant, and the space needed for the modified matrix is also O (m * n), where m is the number of rows, and n is the number of rudiments in a row; thus, the overall space complexity is O( maximum( m, n)).

In summary, the time complexity of the handed law is O( m * n), and the space complexity is O( maximum( m, n)). The algorithm is effective and performs well, especially given the nature of the problem it's designed to break.

## Conclusion

The algorithm employs a dynamic programming approach, treating each row of the double matrix as a histogram. It iterates through each row, streamlining the height of successive 1s and calculating the maximum cube area using a mound-grounded approach. By applying this process row-wise, the algorithm determines the maximum size cube within the double matrix.

The time complexity is O( m * n), where m is the number of rows and n is the number of columns in the matrix. The algorithm efficiently processes each element of the matrix formerly, furnishing a direct time result.

The space complexity is O( maximum( m, n)). The algorithm utilizes a mound for intermediate computations, and the space needed for the modified matrix is commensurable to the outside of the number of rows or columns.

The algorithm is effective in working the problem of changing the largest cube with all 1s in a double matrix. It demonstrates a balance between time and space effectiveness, making it suitable for practical operations where large matrices need to be reused. The use of a mound and dynamic programming principles allows for a clear and terse perpetration, contributing to the algorithm's overall effectiveness.