Related Articles

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

• Last Updated : 03 May, 2021

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.`

## 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)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up