# Largest area of rectangle with permutations

Given a binary grid **A** of size `N x M` consisting of 0's and 1's, find the **area of the largest rectangle** inside the grid such that all the cells inside the chosen rectangle should have 1 in them.

You are allowed to permutate the columns matrix i.e. you can arrange each of the column in any order in the final grid.

Please follow the sample input and explanation for more clarity.

\
**Input Format**

First and only argument is an 2D binary array **A**.\
\
**Output Format**

Return a single integer denoting the **area of the largest rectangle** inside the grid such that all the cells inside the chosen rectangle should have 1 in them.\
\
**Example Input**

Input 1:

```
 A = [  [1, 0, 1]
        [0, 1 ,0]
        [1, 0, 0]
    ]
```

\
**Example Output**

Output 1:

```
 2
```

\
**Example Explanation**

Explanation 1:

```
    1 0 1
    0 1 0
    1 0 0

At present we can see that max rectangle satisfying the criteria mentioned in the problem
 is of 1 * 1 = 1 area i.e either of the 4 cells which contain 1 in it.

Now since we are allowed to permutate the columns of the given matrix, we can take column 1
 and column 3 and make them neighbours. One of the possible configuration of the grid can be:
 1 1 0
 0 0 1
 1 0 0

Now In this grid, first column is column 1, second column is column 3 and third column
 is column 2 from the original given grid.

Now, we can see that if we calculate the max area rectangle, we get max area as 1 * 2 = 2
 which is bigger than the earlier case. Hence 2 will be the answer in this case.
```

```java
public class Solution {
    public int solve(int matrix[][]) {
        int R = matrix.length, C = matrix[0].length;
        // A 2D dp array to store count of consecutive 1's
        // in every column.
        int hist[][] = new int[R][C];
        for (int i = 0; i < C; i++) {
            hist[0][i] = matrix[0][i];
            for (int j = 1; j < R; j++)
                hist[j][i] = (matrix[j][i] == 0) ? 0 : hist[j - 1][i] + 1;
        }
        // Step 2: Sort rows of hist[][] in non-increasing order
        // Rows become independent because each row contain information of number of 1’s above it.
        for (int i = 0; i < R; i++) {
            ArrayList<Integer> row = new ArrayList<>();
            for (int j = 0; j < hist[i].length; j++)
                row.add(hist[i][j]);
            Collections.sort(row, (a, b) -> b - a);
            for (int j = 0; j < row.size(); j++) {
                hist[i][j] = row.get(j);
            }
        }
        // Step 3: Traverse the sorted hist[][] to find maximum area
        int curr_area, max_area = 0;
        for (int i = 0; i < R; i++) {
            for (int j = 0; j < C; j++) {
                // Now since the histograms are arranged in decreasing heights, for a given
                // hist[i][j] with height H, there will always be a histogram of at least
                // height H before it.
                curr_area = (j + 1) * hist[i][j];
                max_area = Math.max(curr_area, max_area);
            }
        }
        return max_area;
    }
}
```
