Largest Submatrix With Rearrangements

Largest Submatrix With Rearrangements - Problem

You are given a binary matrix matrix of size m × n, and you are allowed to rearrange the columns of the matrix in any order.

Return the area of the largest submatrix within matrix where every element of the submatrix is 1 after reordering the columns optimally.

A submatrix is a contiguous rectangular area within the matrix. The area is calculated as width × height.

Input & Output

Example 1 — Basic Rearrangement

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

› Output: 2

💡 Note: Rearrange columns to [[1,1,0],[1,0,1]] or similar. The largest submatrix of 1s has area 2 (either 2×1 or 1×2).

Example 2 — Larger Matrix

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

› Output: 2

💡 Note: After optimal rearrangement, we can get a 2×1 or 1×2 submatrix of all 1s.

Example 3 — All Zeros

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

› Output: 0

💡 Note: No 1s in the matrix, so the largest submatrix of 1s has area 0.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to transform this into a histogram problem for each row. Calculate consecutive 1s heights, sort columns optimally, then find maximum rectangle. Best approach uses greedy column sorting. Time: O(m × n log n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Arrangements

⏱️ Time: O(n! × m² × n²) Space: O(m × n)

For each possible arrangement of columns, check all possible submatrices to find the one with maximum area containing only 1s. This involves generating all permutations of columns and then checking every submatrix.

Greedy - Row by Row Heights

⏱️ Time: O(m × n log n) Space: O(n)

For each row, calculate the height of consecutive 1s ending at that row for each column. Then sort columns by their heights in descending order and find the maximum rectangle area using histogram approach.

Brute Force - Try All Arrangements — Algorithm Steps

Generate all possible column permutations
For each arrangement, check all submatrices
Keep track of maximum area found

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Matrix

Input matrix with columns that can be rearranged

Try Permutations

Generate all possible column arrangements

Find Maximum

Check all submatrices in each arrangement

Code -

solution.c — C

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

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void generatePermutations(int* arr, int start, int size, int** perms, int* count) {
    if (start == size) {
        for (int i = 0; i < size; i++) {
            perms[*count][i] = arr[i];
        }
        (*count)++;
        return;
    }
    
    for (int i = start; i < size; i++) {
        swap(&arr[start], &arr[i]);
        generatePermutations(arr, start + 1, size, perms, count);
        swap(&arr[start], &arr[i]);
    }
}

int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

int solution(int** matrix, int m, int n) {
    if (m == 0 || n == 0) return 0;
    
    int maxArea = 0;
    int* columns = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) columns[i] = i;
    
    int totalPerms = factorial(n);
    int** perms = (int**)malloc(totalPerms * sizeof(int*));
    for (int i = 0; i < totalPerms; i++) {
        perms[i] = (int*)malloc(n * sizeof(int));
    }
    
    int count = 0;
    generatePermutations(columns, 0, n, perms, &count);
    
    for (int p = 0; p < count; p++) {
        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][perms[p][j]];
            }
        }
        
        for (int r1 = 0; r1 < m; r1++) {
            for (int c1 = 0; c1 < n; c1++) {
                for (int r2 = r1; r2 < m; r2++) {
                    for (int c2 = c1; c2 < n; c2++) {
                        int allOnes = 1;
                        for (int i = r1; i <= r2 && allOnes; i++) {
                            for (int j = c1; j <= c2; j++) {
                                if (rearranged[i][j] == 0) {
                                    allOnes = 0;
                                    break;
                                }
                            }
                        }
                        if (allOnes) {
                            int area = (r2 - r1 + 1) * (c2 - c1 + 1);
                            if (area > maxArea) maxArea = area;
                        }
                    }
                }
            }
        }
        
        for (int i = 0; i < m; i++) free(rearranged[i]);
        free(rearranged);
    }
    
    for (int i = 0; i < totalPerms; i++) free(perms[i]);
    free(perms);
    free(columns);
    
    return maxArea;
}

int parseMatrix(char* input, int*** matrix, int* m, int* n) {
    char* p = input;
    
    // Skip to first '['
    while (*p && *p != '[') p++;
    if (!*p) return 0;
    p++; // skip '['
    
    // Count rows
    *m = 0;
    char* temp = p;
    while (*temp) {
        if (*temp == '[') (*m)++;
        temp++;
    }
    
    if (*m == 0) return 0;
    
    // Allocate matrix
    *matrix = (int**)malloc(*m * sizeof(int*));
    
    int row = 0;
    while (*p && row < *m) {
        // Skip to '[' for this row
        while (*p && *p != '[') p++;
        if (!*p) break;
        p++; // skip '['
        
        // Count columns in first row to get n
        if (row == 0) {
            *n = 0;
            char* temp2 = p;
            while (*temp2 && *temp2 != ']') {
                if (isdigit(*temp2)) (*n)++;
                temp2++;
            }
        }
        
        // Allocate row
        (*matrix)[row] = (int*)malloc(*n * sizeof(int));
        
        // Parse numbers in this row
        int col = 0;
        while (*p && *p != ']' && col < *n) {
            if (isdigit(*p)) {
                (*matrix)[row][col] = *p - '0';
                col++;
            }
            p++;
        }
        
        // Skip past ']'
        while (*p && *p != ']') p++;
        if (*p) p++;
        
        row++;
    }
    
    return 1;
}

int main() {
    char input[10000];
    if (!fgets(input, sizeof(input), stdin)) {
        return 1;
    }
    
    int** matrix;
    int m, n;
    
    if (!parseMatrix(input, &matrix, &m, &n)) {
        printf("0\n");
        return 0;
    }
    
    int result = solution(matrix, m, n);
    printf("%d\n", result);
    
    // Free matrix
    for (int i = 0; i < m; i++) {
        free(matrix[i]);
    }
    free(matrix);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × m² × n²)

n! permutations, each requiring O(m² × n²) submatrix checks

⚡ Linearithmic

Space Complexity

O(m × n)

Storage for matrix and temporary arrangements

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

890 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Arrangements — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler