 Open in App
Not now

# Generate a matrix with each row and column of given sum

• Last Updated : 28 Feb, 2022

Given two arrays row[] and col[] of size N and M respectively, the task is to construct a matrix of dimensions N × M such that the sum of matrix elements in every ith row is row[i] and the sum of matrix elements in every jth column is col[j].

Examples:

Input: row[] = {5, 7, 10}, col[] = {8, 6, 8}
Output: {{0, 5, 0}, {6, 1, 0}, {2, 0, 8}}
Explanation:
Row 1 has sum equal to 5 and column 1 has sum equal to 8
Row 2 has sum equal to 7 and column 2 has sum equal to 6
Row 3 has sum equal to 10 and column 3 has sum equal to 8

Input: row[] ={1, 0}, col[] = {1}
Output: {{1}, {0}}
Explanation:
Row 1 has sum equal to 1 and column 1 has sum equal to 1
Row 2 has sum 0

Approach: The simplest approach to solve this problem is to use a Greedy Approach. Follow the steps below to solve this problem:

• Initialize a matrix having dimensions N × M.
• Start filling each cell (i, j) of the matrix in the following manner:
• For each cell (i, j), choose the minimum value of row[i], col[j], and place it at cell (i, j). Let it be minm.
• Subtract minm from row[i] and col[j].
• After completing the above steps, print the matrix formed.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to generate a matrix with``// sum of each row equal to sum of r[]``// and sum of each column equal to sum of c[]``vector > restoreGem(``    ``vector<``int``>& r, vector<``int``>& c)``{``    ``// Initialize a matrix``    ``vector > dp(r.size(),``                            ``vector<``int``>(c.size(), 0));` `    ``// Traverse each cell (i, j) of the matrix``    ``for` `(``int` `i = 0; i < r.size(); i++) {``        ``for` `(``int` `j = 0; j < c.size(); j++) {` `            ``// Assign the minimum of the``            ``// row or column value``            ``int` `m = min(r[i], c[j]);``            ``dp[i][j] = m;` `            ``// Subtract the minimum from``            ``// both row and column sum``            ``r[i] -= m;``            ``c[j] -= m;``        ``}``    ``}` `    ``return` `dp;``}` `void` `printMatrix(vector > ans,``                 ``int` `N, ``int` `M)``{` `    ``// Print the matrix obtained``    ``for` `(``int` `i = 0; i < N; i++) {``        ``for` `(``int` `j = 0; j < M; j++) {``            ``cout << ans[i][j] << ``" "``;``        ``}``        ``cout << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``vector<``int``> rowSum = { 5, 7, 10 };``    ``vector<``int``> colSum = { 8, 6, 8 };` `    ``vector > ans``        ``= restoreGem(rowSum, colSum);` `    ``printMatrix(ans, rowSum.size(),``                ``colSum.size());``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``class` `GFG``{` `// Function to generate a matrix with``// sum of each row equal to sum of r[]``// and sum of each column equal to sum of c[]``static` `int``[][] restoreGem(``int``[] r, ``int``[] c)``{``  ` `    ``// Initialize a matrix``    ``int``[][] dp = ``new` `int``[r.length][c.length];` `    ``// Traverse each cell (i, j) of the matrix``    ``for` `(``int` `i = ``0``; i < r.length; i++)``    ``{``        ``for` `(``int` `j = ``0``; j < c.length; j++)``        ``{` `            ``// Assign the minimum of the``            ``// row or column value``            ``int` `m = Math.min(r[i], c[j]);``            ``dp[i][j] = m;` `            ``// Subtract the minimum from``            ``// both row and column sum``            ``r[i] -= m;``            ``c[j] -= m;``        ``}``    ``}``    ``return` `dp;``}` `static` `void` `printMatrix(``int``[][] ans,``                 ``int` `N, ``int` `M)``{` `    ``// Print the matrix obtained``    ``for` `(``int` `i = ``0``; i < N; i++)``    ``{``        ``for` `(``int` `j = ``0``; j < M; j++)``        ``{``            ``System.out.print(ans[i][j] + ``" "``);``        ``}``        ``System.out.println();``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int``[] rowSum = { ``5``, ``7``, ``10` `};``    ``int``[] colSum = { ``8``, ``6``, ``8` `};` `    ``int``[][] ans``        ``= restoreGem(rowSum, colSum);` `    ``printMatrix(ans, rowSum.length,``                ``colSum.length);``}``}` `// This code is contributed by susmitakundugoaldanga.`

## Python3

 `# Python program for the above approach` `# Function to generate a matrix with``# sum of each row equal to sum of r[]``# and sum of each column equal to sum of c[]``def` `restoreGem(r, c):``  ` `    ``# Initialize a matrix``    ``dp ``=` `[]` `    ``# Traverse each cell (i, j) of the matrix``    ``for` `i ``in` `range``(``0``, ``len``(r)):``        ``dp.append([])``        ``for` `j ``in` `range``(``0``, ``len``(c)):``          ` `            ``# Assign the minimum of the``            ``# row or column value``            ``m ``=` `min``(r[i], c[j])``            ``dp[i].append(m)``            ``# Subtract the minimum from``            ``# both row and column sum` `            ``r[i] ``-``=` `m``            ``c[j] ``-``=` `m` `    ``return` `dp` `def` `printMatrix(ans, N, M):` `    ``# Print the matrix obtained``    ``for` `i ``in` `range``(``0``, ``len``(ans)):``        ``for` `j ``in` `range``(``0``, ``len``(ans[i])):``            ``print``(ans[i][j], end``=``" "``)` `        ``print``(``"\n"``)` `# Driver Code``rowSum ``=` `[``5``, ``7``, ``10``]``colSum ``=` `[``8``, ``6``, ``8``]` `ans ``=` `restoreGem(rowSum, colSum)` `printMatrix(ans, ``len``(rowSum),``            ``len``(colSum))` `# This code is contributed by rj13to.`

## C#

 `// C# program for the above approach``using` `System;``public` `class` `GFG``{` `// Function to generate a matrix with``// sum of each row equal to sum of r[]``// and sum of each column equal to sum of c[]``static` `int``[,] restoreGem(``int``[] r, ``int``[] c)``{``  ` `    ``// Initialize a matrix``    ``int``[,] dp = ``new` `int``[r.Length, c.Length];` `    ``// Traverse each cell (i, j) of the matrix``    ``for` `(``int` `i = 0; i < r.Length; i++)``    ``{``        ``for` `(``int` `j = 0; j < c.Length; j++)``        ``{` `            ``// Assign the minimum of the``            ``// row or column value``            ``int` `m = Math.Min(r[i], c[j]);``            ``dp[i,j] = m;` `            ``// Subtract the minimum from``            ``// both row and column sum``            ``r[i] -= m;``            ``c[j] -= m;``        ``}``    ``}``    ``return` `dp;``}` `static` `void` `printMatrix(``int``[,] ans,``                 ``int` `N, ``int` `M)``{` `    ``// Print the matrix obtained``    ``for` `(``int` `i = 0; i < N; i++)``    ``{``        ``for` `(``int` `j = 0; j < M; j++)``        ``{``            ``Console.Write(ans[i, j] + ``" "``);``        ``}``        ``Console.WriteLine();``    ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int``[] rowSum = { 5, 7, 10 };``    ``int``[] colSum = { 8, 6, 8 };` `    ``int``[,] ans``        ``= restoreGem(rowSum, colSum);``    ``printMatrix(ans, rowSum.Length,``                ``colSum.Length);``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

```5 0 0
3 4 0
0 2 8```

Time Complexity: O(N×M)
Auxiliary Space: O(N×M)

My Personal Notes arrow_drop_up