Find Valid Matrix Given Row and Column Sums

Find Valid Matrix Given Row and Column Sums - Problem

Imagine you're working as a data analyst for a company that tracks sales across different regions and product categories. You have the total sales for each region (row sums) and the total sales for each product category (column sums), but the original detailed sales matrix has been lost!

Your task is to reconstruct any valid sales matrix that matches these constraints. You need to find a matrix of non-negative integers where:

Each row sums to the corresponding value in rowSum
Each column sums to the corresponding value in colSum
All matrix elements are ≥ 0 (you can't have negative sales!)

The good news? It's guaranteed that at least one valid solution exists, so you don't need to worry about impossible cases. You just need to find any matrix that works!

Goal: Return a 2D matrix of size rowSum.length × colSum.length that satisfies all the given row and column sum constraints.

Input & Output

example_1.py — Basic Case

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

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

💡 Note: We need a 2×2 matrix where row sums are [3,8] and column sums are [4,7]. The greedy approach places 3 at (0,0), then 0 at (0,1), then 1 at (1,0), and finally 7 at (1,1). This satisfies all constraints.

example_2.py — Single Element

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

› Output: [[5]]

💡 Note: With only one cell, the value must equal both the row sum and column sum, which are the same (5).

example_3.py — Multiple Solutions

$ Input: rowSum = [2,2], colSum = [2,2]

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

💡 Note: There are multiple valid solutions like [[0,2],[2,0]] or [[1,1],[1,1]], but our greedy approach produces [[2,0],[0,2]].

Constraints

1 ≤ rowSum.length, colSum.length ≤ 500
0 ≤ rowSum[i], colSum[i] ≤ 10⁸
sum(rowSum) == sum(colSum)
It's guaranteed that at least one matrix exists

Visualization

Tap to expand

Understanding the Visualization

Setup Budget Constraints

Each department has a total budget (rowSum), each project needs total funding (colSum)

Greedy Allocation

For each department-project pair, allocate the minimum of what department has left and what project needs

Update Remaining

Subtract allocated amount from both department budget and project requirement

Verify Solution

Check that all departments spent their exact budget and all projects got exact funding needed

Key Takeaway

🎯 Key Insight: The greedy approach works because taking min(row_remaining, col_remaining) at each step ensures we never over-allocate while maximizing progress toward satisfying both constraints simultaneously.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 f Meta 8

The optimal greedy approach works by iteratively filling each cell with the minimum of remaining row sum and column sum. This ensures we never violate constraints and always produce a valid matrix in O(m×n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(m×n)	O(m×n)	Fill each cell with minimum of remaining row sum and column sum

Greedy Approach (Optimal) — Algorithm Steps

Create result matrix and copy row/column sums to track remaining values
Iterate through each cell in the matrix
For each cell (i,j), set value to min(remaining_row_sum[i], remaining_col_sum[j])
Subtract the placed value from both remaining row and column sums
Continue until all cells are filled

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty matrix and track remaining sums

Fill (0,0)

Place min(3,4) = 3, update remaining: row[0]=0, col[0]=1

Fill (0,1)

Place min(0,7) = 0, remaining unchanged

Complete

Continue until all cells filled and sums satisfied

Code -

solution.c — C

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

int** restoreMatrix(int* rowSum, int rowSumSize, int* colSum, int colSumSize, int* returnSize, int** returnColumnSizes) {
    int m = rowSumSize, n = colSumSize;
    *returnSize = m;
    *returnColumnSizes = (int*)malloc(m * sizeof(int));
    
    // Allocate result matrix
    int** result = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        result[i] = (int*)calloc(n, sizeof(int));
        (*returnColumnSizes)[i] = n;
    }
    
    // Create copies to track remaining sums
    int* remainingRow = (int*)malloc(m * sizeof(int));
    int* remainingCol = (int*)malloc(n * sizeof(int));
    
    for (int i = 0; i < m; i++) remainingRow[i] = rowSum[i];
    for (int j = 0; j < n; j++) remainingCol[j] = colSum[j];
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // Place minimum of what row needs and what column needs
            int val = (remainingRow[i] < remainingCol[j]) ? remainingRow[i] : remainingCol[j];
            result[i][j] = val;
            
            // Update remaining sums
            remainingRow[i] -= val;
            remainingCol[j] -= val;
        }
    }
    
    free(remainingRow);
    free(remainingCol);
    return result;
}

int main() {
    int rowSum[] = {3, 8};
    int colSum[] = {4, 7};
    int returnSize;
    int* returnColumnSizes;
    
    int** result = restoreMatrix(rowSum, 2, colSum, 2, &returnSize, &returnColumnSizes);
    
    for (int i = 0; i < returnSize; i++) {
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
        free(result[i]);
    }
    
    free(result);
    free(returnColumnSizes);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We visit each cell in the matrix exactly once, where m is number of rows and n is number of columns

✓ Linear Growth

Space Complexity

O(m×n)

Space needed for the result matrix plus O(m+n) for tracking remaining sums

⚡ Linearithmic Space

28.5K 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

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler