Largest Submatrix With Rearrangements - Practice Coding Problems

Largest Submatrix With Rearrangements - Problem

Imagine you have a binary matrix (containing only 0s and 1s) and you're tasked with finding the largest rectangular area filled entirely with 1s. The twist? You can rearrange the columns in any order to maximize this area!

Given a binary matrix of size m × n, you need to:

Rearrange columns optimally
Find the largest submatrix where every element is 1
Return the area of this largest submatrix

This problem combines matrix manipulation with optimization - you'll need to think about how column reordering can help create larger contiguous blocks of 1s.

Input & Output

example_1.py — Basic Rectangle Formation

$ Input: matrix = [[0,0,1],[1,1,1],[1,0,1]]

› Output: 4

💡 Note: Rearrange columns to [1,2,0] to get [[1,1,0],[1,1,1],[1,1,1]]. The largest submatrix of 1s has area 4 (2×2 rectangle in bottom-right).

example_2.py — Optimal Column Ordering

$ Input: matrix = [[1,0,1,0,1]]

› Output: 3

💡 Note: Rearrange columns to group all 1s together: [1,1,1,0,0]. The largest submatrix has area 3 (1×3 rectangle).

example_3.py — All Zeros Edge Case

$ Input: matrix = [[0,0],[0,0]]

› Output: 0

💡 Note: No matter how we rearrange columns, there are no 1s to form a submatrix. The maximum area is 0.

Visualization

Tap to expand

Analyze Each Level: For row i, calculate height of consecutive blocks ending at that row2. Sort by Height: Arrange towers in descending order of their heights for current level3. Calculate Areas: For position j, rectangle width = j+1, height = towers[j].height4. Find Maximum: Track the largest area across all levels and positionsExample Calculation for Bottom Row:Heights: [3, 1, 3, 1] → After sorting: [3, 3, 1, 1]Position 0: width=1, height=3 → area = 1×3 = 3Position 1: width=2, height=3 → area = 2×3 = 6 ✓ (maximum)Position 2: width=3, height=1 → area = 3×1 = 3🎯 Key Insight: Greedy sorting finds optimal arrangement without trying all permutations!Time Complexity: O(mn log n) vs O(n!) brute force

Understanding the Visualization

Identify Block Towers

Each column represents a tower where 1s are solid blocks and 0s create gaps

Calculate Tower Heights

For each level, measure how many consecutive blocks each tower contributes

Arrange Optimally

Sort towers by height to create the largest possible rectangular foundation

Find Maximum Area

Calculate the area of the largest rectangle that can be built

Key Takeaway

🎯 Key Insight: By treating the problem as a histogram rectangle optimization and using greedy sorting, we can find the optimal column arrangement in O(mn log n) time instead of the exponential time required by brute force approaches.

Time & Space Complexity

Time Complexity

⏱️

O(n! × m²n)

n! permutations, each requiring O(m²n) to find largest rectangle

⚠ Quadratic Growth

Space Complexity

O(mn)

Space for storing matrix copies and rectangle calculation

⚡ Linearithmic Space

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 10⁵
m × n ≤ 10⁵
matrix[i][j] is either 0 or 1

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal approach transforms this problem into finding the largest rectangle in a histogram. For each row, calculate the height of consecutive 1s ending at that row, sort these heights in descending order, then greedily calculate maximum rectangles. This achieves O(mn log n) time complexity compared to the factorial complexity of trying all column permutations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Arrangements)	O(n! × m²n)	O(mn)	Generate all possible column arrangements and find max rectangle for each
Greedy Histogram Approach (Optimal)	O(mn log n)	O(n)	Convert to histogram problem and use greedy sorting for optimal solution

Brute Force (Try All Arrangements) — Algorithm Steps

Generate all possible column permutations
For each permutation, scan the matrix
Find largest rectangle of 1s in current arrangement
Track the maximum area found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible column arrangements

Rearrange Matrix

For each permutation, rearrange the matrix columns

Find Rectangle

Calculate largest rectangle of 1s in current arrangement

Track Maximum

Keep track of the maximum area found so far

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int maxArea;

void findLargestRectangle(int** matrix, int* cols, int m, int n) {
    // Create rearranged matrix
    int** rearranged = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        rearranged[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            rearranged[i][j] = matrix[i][cols[j]];
        }
    }
    
    // Find largest rectangle
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (rearranged[i][j] == 1) {
                int minWidth = n;
                for (int row = i; row < m; row++) {
                    int width = 0;
                    for (int col = j; col < n; col++) {
                        if (rearranged[row][col] == 1) width++;
                        else break;
                    }
                    if (width == 0) break;
                    if (width < minWidth) minWidth = width;
                    int height = row - i + 1;
                    int area = height * minWidth;
                    if (area > maxArea) maxArea = area;
                }
            }
        }
    }
    
    // Free memory
    for (int i = 0; i < m; i++) free(rearranged[i]);
    free(rearranged);
}

void permute(int** matrix, int* cols, int m, int n, int start) {
    if (start == n) {
        findLargestRectangle(matrix, cols, m, n);
        return;
    }
    
    for (int i = start; i < n; i++) {
        // Swap
        int temp = cols[start];
        cols[start] = cols[i];
        cols[i] = temp;
        
        permute(matrix, cols, m, n, start + 1);
        
        // Swap back
        temp = cols[start];
        cols[start] = cols[i];
        cols[i] = temp;
    }
}

int largestSubmatrix(int** matrix, int matrixSize, int* matrixColSize) {
    int m = matrixSize, n = matrixColSize[0];
    maxArea = 0;
    
    int* cols = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) cols[i] = i;
    
    permute(matrix, cols, m, n, 0);
    
    free(cols);
    return maxArea;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × m²n)

n! permutations, each requiring O(m²n) to find largest rectangle

⚠ Quadratic Growth

Space Complexity

O(mn)

Space for storing matrix copies and rectangle calculation

⚡ Linearithmic Space

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 10⁵
m × n ≤ 10⁵
matrix[i][j] is either 0 or 1

68.3K Views

Medium-High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Arrangements) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler