Largest Submatrix With Rearrangements of Columns Allowed
Last Updated :
17 Sep, 2024
Given a matrix with 0 and 1’s, find the largest rectangle of all 1’s in the matrix. The rectangle can be formed by swapping any pair of columns of given matrix.
Example:
Input: mat[][] =
{ {0, 1, 0, 1, 0},
{0, 1, 0, 1, 1},
{1, 1, 0, 1, 0} };
Output: 6
The largest rectangle’s area is 6. The rectangle can be formed by swapping column 2 with 3 The matrix after swapping will be
0 0 1 1 0
0 0 1 1 1
1 0 1 1 0
Input: mat[][] =
{ {0, 1, 0, 1, 0},
{0, 1, 1, 1, 1},
{1, 1, 1, 0, 1},
{1, 1, 1, 1, 1} };
Output: 9
The idea is to use an auxiliary matrix to store count of consecutive 1’s in every column. Once we have these counts, we sort all rows of auxiliary matrix in non-increasing order of counts. Finally traverse the sorted rows to find the maximum area.
Note : After forming the auxiliary matrix each row becomes independent, hence we can swap or sort each row independently.It is because we can only swap columns, so we have made each row independent and find the max area of rectangle possible with row and column.
Below are detailed steps for first example mentioned above.
Step 1: First of all, calculate no. of consecutive 1’s in every column. An auxiliary array hist[][] is used to store the counts of consecutive 1’s. So for the above first example, contents of hist[R][C] would be
0 1 0 1 0
0 2 0 2 1
1 3 0 3 0
Time complexity of this step is O(R*C)
Step 2: Sort the rows in non-increasing fashion. After sorting step the matrix hist[][] would be
1 1 0 0 0
2 2 1 0 0
3 3 1 0 0
This step can be done in O(R * (R + C)). Since we know that the values are in range from 0 to R, we can use counting sort for every row.
The sorting is actually the swapping of columns. If we look at the 3rd row under step 2:
3 3 1 0 0
The sorted row corresponds to swapping the columns so that the column with the highest possible rectangle is placed first, after that comes the column that allows the second highest rectangle and so on. So, in the example there are 2 columns that can form a rectangle of height 3. That makes an area of 3*2=6. If we try to make the rectangle wider the height drops to 1, because there are no columns left that allow a higher rectangle on the 3rd row.
Step 3: Traverse each row of hist[][] and check for the max area. Since every row is sorted by count of 1’s, current area can be calculated by multiplying column number with value in hist[i][j]. This step also takes O(R * C) time.
Below is the implementation based of above idea.
C++
#include <bits/stdc++.h>
using namespace std;
// Returns area of the largest rectangle of 1's
int maxArea(vector<vector<bool>>& mat) {
int R = mat.size();
int C = mat[0].size();
// Auxiliary matrix to store count of consecutive 1's in every column.
vector<vector<int>> hist(R, vector<int>(C, 0));
// Step 1: Fill the auxiliary array hist[][]
for (int i = 0; i < C; i++) {
// First row in hist is a copy of the first row in mat
hist[0][i] = mat[0][i];
// Fill remaining rows of hist
for (int j = 1; j < R; j++)
hist[j][i] = (mat[j][i] == 0) ? 0 : hist[j - 1][i] + 1;
}
// Step 2: Sort columns of hist[][] in non-increasing order
for (int i = 0; i < R; i++) {
vector<int> count(R + 1, 0);
// Counting occurrence
for (int j = 0; j < C; j++)
count[hist[i][j]]++;
// Traverse the count array from right side
int col_no = 0;
for (int j = R; j >= 0; j--) {
if (count[j] > 0) {
for (int k = 0; k < count[j]; k++) {
hist[i][col_no] = j;
col_no++;
}
}
}
}
// 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++) {
// Since values are in decreasing order,
// The area ending with cell (i, j) can be obtained by
// multiplying column number with value of hist[i][j]
curr_area = (j + 1) * hist[i][j];
max_area = max(max_area, curr_area);
}
}
return max_area;
}
// Driver program
int main() {
vector<vector<bool>> mat = { { 0, 1, 0, 1, 0 },
{ 0, 1, 0, 1, 1 },
{ 1, 1, 0, 1, 0 } };
cout << "Area of the largest rectangle is " << maxArea(mat);
return 0;
}
// C program to find the largest rectangle of 1's with swapping
// of columns allowed.
#include <stdio.h>
#include <stdbool.h>
#define R 3
#define C 5
// Returns area of the largest rectangle of 1's
int maxArea(bool mat[R][C])
{
// An auxiliary array to store count of consecutive 1's
// in every column.
int hist[R + 1][C + 1];
// Step 1: Fill the auxiliary array hist[][]
for (int i = 0; i < C; i++) {
// First row in hist[][] is copy of first row in mat[][]
hist[0][i] = mat[0][i];
// Fill remaining rows of hist[][]
for (int j = 1; j < R; j++)
hist[j][i] = (mat[j][i] == 0) ? 0 : hist[j - 1][i] + 1;
}
// Step 2: Sort columns of hist[][] in non-increasing order
for (int i = 0; i < R; i++) {
int count[R + 1] = { 0 };
// counting occurrence
for (int j = 0; j < C; j++)
count[hist[i][j]]++;
// Traverse the count array from right side
int col_no = 0;
for (int j = R; j >= 0; j--) {
if (count[j] > 0) {
for (int k = 0; k < count[j]; k++) {
hist[i][col_no] = j;
col_no++;
}
}
}
}
// 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++) {
// Since values are in decreasing order,
// The area ending with cell (i, j) can
// be obtained by multiplying column number
// with value of hist[i][j]
curr_area = (j + 1) * hist[i][j];
if (curr_area > max_area)
max_area = curr_area;
}
}
return max_area;
}
// Driver program
int main()
{
bool mat[R][C] = { { 0, 1, 0, 1, 0 },
{ 0, 1, 0, 1, 1 },
{ 1, 1, 0, 1, 0 } };
printf("Area of the largest rectangle is %d", maxArea(mat));
return 0;
}
public class GfG {
// Returns the area of the largest rectangle of 1's
public static int maxArea(int[][] mat) {
int R = mat.length;
int C = mat[0].length;
// Auxiliary matrix to store the count of
// consecutive 1's in every column.
int[][] hist = new int[R][C];
// Step 1: Fill the auxiliary array hist[][]
for (int i = 0; i < C; i++) {
// First row in hist is a copy of the first row in mat
hist[0][i] = mat[0][i];
// Fill remaining rows of hist
for (int j = 1; j < R; j++) {
hist[j][i] = (mat[j][i] == 0) ? 0 : hist[j - 1][i] + 1;
}
}
// Step 2: Sort columns of hist[][] in
// non-increasing order
for (int i = 0; i < R; i++) {
int[] count = new int[R + 1];
// Counting occurrence
for (int j = 0; j < C; j++) {
count[hist[i][j]]++;
}
// Traverse the count array from the right side
int col_no = 0;
for (int j = R; j >= 0; j--) {
if (count[j] > 0) {
for (int k = 0; k < count[j]; k++) {
hist[i][col_no] = j;
col_no++;
}
}
}
}
// Step 3: Traverse the sorted hist[][] to find the maximum area
int curr_area, max_area = 0;
for (int i = 0; i < R; i++) {
for (int j = 0; j < C; j++) {
// The area ending with cell (i, j)
curr_area = (j + 1) * hist[i][j];
max_area = Math.max(max_area, curr_area);
}
}
return max_area;
}
// Driver program
public static void main(String[] args) {
int[][] mat = {
{ 0, 1, 0, 1, 0 },
{ 0, 1, 0, 1, 1 },
{ 1, 1, 0, 1, 0 }
};
System.out.println("Area of the largest rectangle is " + maxArea(mat));
}
}
def maxArea(mat):
R = len(mat)
C = len(mat[0])
# Auxiliary matrix to store count of consecutive 1's in every column.
hist = [[0] * C for _ in range(R)]
# Step 1: Fill the auxiliary array hist[][]
for i in range(C):
# First row in hist is a copy of the first row in mat
hist[0][i] = mat[0][i]
# Fill remaining rows of hist
for j in range(1, R):
hist[j][i] = hist[j - 1][i] + 1 if mat[j][i] == 1 else 0
# Step 2: Sort columns of hist[][] in non-increasing order
for i in range(R):
count = [0] * (R + 1)
# Counting occurrence
for j in range(C):
count[hist[i][j]] += 1
# Traverse the count array from the right side
col_no = 0
for j in range(R, -1, -1):
if count[j] > 0:
for k in range(count[j]):
hist[i][col_no] = j
col_no += 1
# Step 3: Traverse the sorted hist[][] to find the maximum area
max_area = 0
for i in range(R):
for j in range(C):
# The area ending with cell (i, j)
curr_area = (j + 1) * hist[i][j]
max_area = max(max_area, curr_area)
return max_area
# Driver code
mat = [
[0, 1, 0, 1, 0],
[0, 1, 0, 1, 1],
[1, 1, 0, 1, 0]
]
print("Area of the largest rectangle is", maxArea(mat))
using System;
class GfG
{
// Returns the area of the largest rectangle of 1's
public static int MaxArea(int[,] mat)
{
int R = mat.GetLength(0);
int C = mat.GetLength(1);
// Auxiliary matrix to store count of consecutive 1's in every column.
int[,] hist = new int[R, C];
// Step 1: Fill the auxiliary array hist[][]
for (int i = 0; i < C; i++)
{
// First row in hist is a copy of the first row in mat
hist[0, i] = mat[0, i];
// Fill remaining rows of hist
for (int j = 1; j < R; j++)
{
hist[j, i] = (mat[j, i] == 0) ? 0 : hist[j - 1, i] + 1;
}
}
// Step 2: Sort columns of hist[][] in non-increasing order
for (int i = 0; i < R; i++)
{
int[] count = new int[R + 1];
// Counting occurrence
for (int j = 0; j < C; j++)
{
count[hist[i, j]]++;
}
// Traverse the count array from the right side
int col_no = 0;
for (int j = R; j >= 0; j--)
{
if (count[j] > 0)
{
for (int k = 0; k < count[j]; k++)
{
hist[i, col_no] = j;
col_no++;
}
}
}
}
// Step 3: Traverse the sorted hist[][] to find the maximum area
int max_area = 0;
for (int i = 0; i < R; i++)
{
for (int j = 0; j < C; j++)
{
// The area ending with cell (i, j)
int curr_area = (j + 1) * hist[i, j];
max_area = Math.Max(max_area, curr_area);
}
}
return max_area;
}
// Driver code
static void Main()
{
int[,] mat = {
{ 0, 1, 0, 1, 0 },
{ 0, 1, 0, 1, 1 },
{ 1, 1, 0, 1, 0 }
};
Console.WriteLine("Area of the largest rectangle is " + MaxArea(mat));
}
}
function maxArea(mat) {
const R = mat.length;
const C = mat[0].length;
// Auxiliary matrix to store count of consecutive 1's in every column.
let hist = Array.from({ length: R }, () => Array(C).fill(0));
// Step 1: Fill the auxiliary array hist[][]
for (let i = 0; i < C; i++) {
// First row in hist is a copy of the first row in mat
hist[0][i] = mat[0][i];
// Fill remaining rows of hist
for (let j = 1; j < R; j++) {
hist[j][i] = (mat[j][i] === 1) ? hist[j - 1][i] + 1 : 0;
}
}
// Step 2: Sort columns of hist[][] in non-increasing order
for (let i = 0; i < R; i++) {
let count = Array(R + 1).fill(0);
// Counting occurrence
for (let j = 0; j < C; j++) {
count[hist[i][j]]++;
}
// Traverse the count array from the right side
let col_no = 0;
for (let j = R; j >= 0; j--) {
if (count[j] > 0) {
for (let k = 0; k < count[j]; k++) {
hist[i][col_no] = j;
col_no++;
}
}
}
}
// Step 3: Traverse the sorted hist[][] to find the maximum area
let max_area = 0;
for (let i = 0; i < R; i++) {
for (let j = 0; j < C; j++) {
// The area ending with cell (i, j)
let curr_area = (j + 1) * hist[i][j];
max_area = Math.max(max_area, curr_area);
}
}
return max_area;
}
// Driver code
let mat = [
[0, 1, 0, 1, 0],
[0, 1, 0, 1, 1],
[1, 1, 0, 1, 0]
];
console.log("Area of the largest rectangle is " + maxArea(mat));
OutputArea of the largest rectangle is 6
Time complexity of above solution is O(R * (R + C)) where R is number of rows and C is number of columns in input matrix. Extra space: O(R * C)
Similar Reads
Count of square submatrices with average at least K
Given a matrix arr[][] of size NxM and an integer K, the task is to find the count of square submatrices in the given matrix with the average of elements greater than or equal to K. Examples: Input: K = 4, arr[][] = {{2, 2, 3}, {3, 4, 5}, {4, 5, 5}}Output: 7Explanation: The following square submatri
12 min read
Submatrix with corners as 1
Given a binary matrix containing only 0s and 1s. The task is to check whether there exists a rectangle or square submatrix of size at least 2 × 2 such that all four corners of that submatrix are 1.This means we must find four positions in the matrix (top-left, top-right, bottom-left, and bottom-righ
12 min read
Largest row-wise and column-wise sorted sub-matrix
Given an N * M matrix mat[][], the task is to find the area-wise largest rectangular sub-matrix such that each column and each row of the sub-matrix is strictly increasing. Examples: Input: mat[][] = {{1, 2, 3}, {4, 5, 6}, {1, 2, 3}} Output: 6 Largest sub-matrix will be {{1, 2, 3}, {4, 5, 6}}. Numbe
13 min read
Largest sub-matrix with all equal elements
Given a binary matrix of size N * M, the task is to find the largest area sub-matrix such that all elements in it are same i.e. either all are 0 or all are 1. Print the largest possible area of such matrix. Examples: Input: mat[][] = { {1, 1, 0, 1, 0, 0, 0, 0}, {0, 1, 1, 1, 1, 0, 0, 1}, {1, 0, 0, 1,
15+ min read
Interchange elements of first and last columns in matrix
Given a square matrix, the task is to interchange the elements of the first and last columns and show the resulting matrix Examples: Input: 8 9 7 6 4 7 6 5 3 2 1 8 9 9 7 7 Output: 6 9 7 8 5 7 6 4 8 2 1 3 7 9 7 9 Input: 9 7 5 1 2 3 4 1 5 6 6 5 1 2 3 1 Output: 1 7 5 9 1 3 4 2 5 6 6 5 1 2 3 1 Recommend
6 min read
Generate a matrix with each row and column of given sum
Given two arrays rowSum[] and colSum[] of size n and m respectively, the task is to construct a matrix of dimensions n × m such that the sum of matrix elements in every ith row is rowSum[i] and the sum of matrix elements in every jth column is colSum[j]. Note: The resultant matrix can have only non-
15 min read
Largest square sub-matrix with equal row, column, and diagonal sum
Given a matrix mat[][] of dimensions N*M, the task is to find the size of the largest square submatrix such that the sum of all rows, columns, diagonals in that submatrix are equal. Examples: Input: N = 3, M = 4, mat[][] = [[5, 1, 3, 1], [9, 3, 3, 1], [1, 3, 3, 8]]Output: 2Explanation:The submatrix
11 min read
Largest possible square submatrix with maximum AND value
Given an integer matrix mat [ ][ ] dimensions, the task is to find the largest possible square matrix from the given matrix with maximum AND value. AND value of a matrix is defined as the value obtained after performing bitwise AND operation on all elements of the matrix. Examples: Input: mat [ ][ ]
13 min read
Largest Submatrix With Sum 0
Given a 2D matrix of dimension n x m, the task is to find the area of largest submatrix whose sum is 0. Examples: Input: mat[][] = [[9, 7, 16, 5], [1, -6, -7, 3], [1, 8, 7, 9], [7, -2, 0, 10]]Output: 6Explanation: Input: mat[][] = [[1, 2, 3], [-3, -2, -1], [1, 7, 5]]Output: 6Explanation: Input: mat[
8 min read
Length of largest common subarray in all the rows of given Matrix
Given a matrix mat[][] of size N×M where each row of the matrix is a permutation of the elements from [1, M], the task is to find the maximum length of the subarray present in each row of the matrix. Examples: Input: mat[][] = {{1, 2, 3, 4, 5}, {2, 3, 4, 1, 5}, {5, 2, 3, 4, 1}, {1, 5, 2, 3, 4}}Outpu
10 min read