Reconstruct a 2-Row Binary Matrix - Practice Coding Problems

Reconstruct a 2-Row Binary Matrix - Problem

You're tasked with reconstructing a mysterious 2-row binary matrix from scattered clues! 🕵️‍♂️

Given a matrix with n columns and exactly 2 rows, you know:

📊 Each cell contains only 0 or 1 (binary matrix)
🔢 The sum of the upper row equals upper
🔢 The sum of the lower row equals lower
📋 An array colsum[i] telling you the sum of each column i

Your mission: Reconstruct the original 2×n matrix! If multiple valid solutions exist, return any one. If no solution is possible, return an empty array [].

Example: If upper=2, lower=1, colsum=[1,1,1], one valid matrix could be:
[[1,1,0], [0,0,1]] ✅

Input & Output

example_1.py — Basic Case

$ Input: upper = 2, lower = 1, colsum = [1,1,1]

› Output: [[1,1,0],[0,0,1]]

💡 Note: Upper row sum: 1+1+0=2 ✓, Lower row sum: 0+0+1=1 ✓, Column sums: [1,1,1] ✓

example_2.py — Impossible Case

$ Input: upper = 1, lower = 1, colsum = [2,1,1]

› Output: []

💡 Note: Column 0 needs sum=2 (both cells=1), but this would use up both row quotas, leaving no 1s for columns 1 and 2

example_3.py — All Zeros

$ Input: upper = 0, lower = 0, colsum = [0,0,0]

› Output: [[0,0,0],[0,0,0]]

💡 Note: All sums are 0, so the entire matrix is filled with zeros

Constraints

1 ≤ colsum.length ≤ 10⁵
0 ≤ upper, lower ≤ colsum.length
0 ≤ colsum[i] ≤ 2 (each column can have at most 2 ones in a 2-row matrix)

Visualization

Tap to expand

Understanding the Visualization

Analyze Constraints

You have row quotas (upper=2, lower=1) and column requirements (colsum=[1,1,1])

Greedy Assignment

For each column, if sum=2 both seats occupied; if sum=1 assign to row with remaining quota; if sum=0 both empty

Verify Solution

Check that all row quotas are exactly fulfilled - no over/under assignment

Key Takeaway

🎯 Key Insight: The greedy approach works because each column's constraint immediately determines how to fill it - we just need to track remaining row quotas and assign greedily to ensure all constraints are satisfied.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal greedy approach processes each column sequentially, making immediate decisions based on column sums: assign both cells for colsum[i]=2, prioritize the upper row for colsum[i]=1 when quotas remain, and leave both cells zero for colsum[i]=0. This O(n) time solution naturally handles impossible cases and guarantees a valid reconstruction when one exists.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^(2n))	O(n)	Generate all possible 2×n binary matrices and check which ones satisfy the constraints
Greedy Construction (Optimal)	O(n)	O(n)	Construct the matrix greedily by processing each column based on its sum constraint

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible 2×n binary matrices
For each matrix, calculate row sums and column sums
Check if the sums match the given upper, lower, and colsum constraints
Return the first valid matrix found, or empty array if none exist

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Matrix

Create a 2×3 binary matrix from bit pattern

Check Row Sums

Verify upper and lower row sums match constraints

Check Column Sums

Verify each column sum matches colsum array

Accept or Reject

If all constraints satisfied, return matrix; otherwise try next

Code -

solution.c — C

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

int isValid(int matrix[2][100], int upper, int lower, int* colsum, int n) {
    // Check row sums
    int upperSum = 0, lowerSum = 0;
    for (int j = 0; j < n; j++) {
        upperSum += matrix[0][j];
        lowerSum += matrix[1][j];
    }
    if (upperSum != upper || lowerSum != lower) {
        return 0;
    }
    
    // Check column sums
    for (int j = 0; j < n; j++) {
        if (matrix[0][j] + matrix[1][j] != colsum[j]) {
            return 0;
        }
    }
    
    return 1;
}

int** reconstructMatrix(int upper, int lower, int* colsum, int n) {
    int totalBits = 2 * n;
    
    // Allocate result matrix
    int** result = (int**)malloc(2 * sizeof(int*));
    for (int i = 0; i < 2; i++) {
        result[i] = (int*)malloc(n * sizeof(int));
    }
    
    // Try all possible 2xn binary matrices
    for (int i = 0; i < (1 << totalBits); i++) {
        int matrix[2][100];
        memset(matrix, 0, sizeof(matrix));
        
        // Generate matrix from bit representation
        for (int bit = 0; bit < totalBits; bit++) {
            if (i & (1 << bit)) {
                int row = bit / n;
                int col = bit % n;
                matrix[row][col] = 1;
            }
        }
        
        // Check if matrix satisfies constraints
        if (isValid(matrix, upper, lower, colsum, n)) {
            // Copy to result
            for (int r = 0; r < 2; r++) {
                for (int c = 0; c < n; c++) {
                    result[r][c] = matrix[r][c];
                }
            }
            return result;
        }
    }
    
    // No solution found
    for (int i = 0; i < 2; i++) {
        free(result[i]);
    }
    free(result);
    return NULL;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse input: [upper, lower, [colsum...]]
    int upper, lower;
    int colsum[100];
    int n = 0;
    
    // Simple parsing for demo
    sscanf(line, "[%d, %d,", &upper, &lower);
    
    // Find colsum array (simplified parsing)
    char* start = strchr(line, '[');
    start = strchr(start + 1, '[');
    char* end = strchr(start, ']');
    
    char* token = strtok(start + 1, ", ");
    while (token && token < end) {
        colsum[n++] = atoi(token);
        token = strtok(NULL, ", ");
    }
    
    int** result = reconstructMatrix(upper, lower, colsum, n);
    
    if (result) {
        printf("[");
        for (int i = 0; i < 2; i++) {
            printf("[");
            for (int j = 0; j < n; j++) {
                printf("%d", result[i][j]);
                if (j < n - 1) printf(",");
            }
            printf("]");
            if (i < 1) printf(",");
            free(result[i]);
        }
        printf("]\n");
        free(result);
    } else {
        printf("[]\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(2n))

We need to check all 2^(2n) possible binary matrices, and for each we verify constraints in O(n) time

✓ Linear Growth

Space Complexity

O(n)

Space for storing the current matrix being tested

⚡ Linearithmic Space

28.7K Views

Medium Frequency

~15 min Avg. Time

892 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 Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler