Find Valid Matrix Given Row and Column Sums

Find Valid Matrix Given Row and Column Sums - Problem

You are given two arrays rowSum and colSum of non-negative integers where rowSum[i] is the sum of the elements in the i-th row and colSum[j] is the sum of the elements of the j-th column of a 2D matrix.

In other words, you do not know the elements of the matrix, but you do know the sums of each row and column.

Find any matrix of non-negative integers of size rowSum.length x colSum.length that satisfies the rowSum and colSum requirements.

Return a 2D array representing any matrix that fulfills the requirements. It's guaranteed that at least one matrix that fulfills the requirements exists.

Input & Output

Example 1 — Basic Case

$ Input: rowSum = [3,8], colSum = [4,7]

› Output: [[0,3],[4,4]]

💡 Note: Row 0: 0+3=3 ✓, Row 1: 4+4=8 ✓, Col 0: 0+4=4 ✓, Col 1: 3+4=7 ✓

Example 2 — Square Matrix

$ Input: rowSum = [5,7,10], colSum = [8,6,8]

› Output: [[0,5,0],[6,1,0],[2,0,8]]

💡 Note: Each row sum and column sum matches the requirements. Greedy approach fills optimally.

Example 3 — Single Row

$ Input: rowSum = [14], colSum = [9,5]

› Output: [[9,5]]

💡 Note: Single row case: 9+5=14 ✓, columns sum to [9] and [5] respectively.

Constraints

1 ≤ rowSum.length, colSum.length ≤ 500
0 ≤ rowSum[i], colSum[i] ≤ 10⁸
sum(rowSum) == sum(colSum)

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is using a greedy approach where each cell gets the minimum of its remaining row and column sums. This guarantees a valid solution while being optimal. Best approach is Greedy Algorithm with Time: O(m×n), Space: O(m×n).

Common Approaches

✓ Math

⏱️ Time: N/A Space: N/A

Optimized

⏱️ Time: N/A Space: N/A

Brute Force - Try All Combinations

⏱️ Time: O((max_sum)^(m×n)) Space: O(m×n)

Try every possible value for each cell from 0 to min(rowSum[i], colSum[j]), then recursively fill the remaining cells. This explores all possible combinations until finding a valid matrix.

Greedy Approach

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

At each position (i,j), place the minimum value between the remaining row sum and column sum. This ensures we satisfy constraints optimally without needing to backtrack.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int matrix[1000][1000];
static int remaining_row[1000];
static int remaining_col[1000];

bool backtrack(int row, int col, int m, int n) {
    if (row == m) {
        for (int j = 0; j < n; j++) {
            if (remaining_col[j] != 0) return false;
        }
        return true;
    }
    if (col == n) {
        return remaining_row[row] == 0 && backtrack(row + 1, 0, m, n);
    }
    
    int max_val = remaining_row[row] < remaining_col[col] ? remaining_row[row] : remaining_col[col];
    
    for (int val = 0; val <= max_val; val++) {
        matrix[row][col] = val;
        remaining_row[row] -= val;
        remaining_col[col] -= val;
        
        if (backtrack(row, col + 1, m, n)) {
            return true;
        }
        
        remaining_row[row] += val;
        remaining_col[col] += val;
    }
    
    return false;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    
    // Skip whitespace and find '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Handle empty array
    while (*p == ' ') p++;
    if (*p == ']') return;
    
    // Parse numbers
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse number
        char* endptr;
        arr[(*size)++] = (int)strtol(p, &endptr, 10);
        p = endptr;
    }
}

int main() {
    char line1[10000], line2[10000];
    
    // Read two lines
    if (!fgets(line1, sizeof(line1), stdin)) return 1;
    if (!fgets(line2, sizeof(line2), stdin)) return 1;
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    int rowSum[1000], colSum[1000];
    int m, n;
    
    // Parse arrays
    parseArray(line1, rowSum, &m);
    parseArray(line2, colSum, &n);
    
    // Initialize remaining arrays
    for (int i = 0; i < m; i++) {
        remaining_row[i] = rowSum[i];
    }
    for (int j = 0; j < n; j++) {
        remaining_col[j] = colSum[j];
    }
    
    // Initialize matrix
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            matrix[i][j] = 0;
        }
    }
    
    // Solve using backtracking
    backtrack(0, 0, m, n);
    
    // Output result in JSON format
    printf("[");
    for (int i = 0; i < m; i++) {
        if (i > 0) printf(",");
        printf("[");
        for (int j = 0; j < n; j++) {
            if (j > 0) printf(",");
            printf("%d", matrix[i][j]);
        }
        printf("]");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~15 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