Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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:

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.

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 <bits/stdc++.h>
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<vector<int> > restoreGem(
    vector<int>& r, vector<int>& c)
{
    // Initialize a matrix
    vector<vector<int> > 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<vector<int> > 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<vector<int> > 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




<script>
// javascript program of 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[]
function restoreGem(r, c)
{
   
    // Initialize a matrix
    let dp = new Array(r.length);
     
    // Loop to create 2D array using 1D array
    for (var i = 0; i < dp.length; i++) {
        dp[i] = new Array(2);
    }
 
    // Traverse each cell (i, j) of the matrix
    for (let i = 0; i < r.length; i++)
    {
        for (let j = 0; j < c.length; j++)
        {
 
            // Assign the minimum of the
            // row or column value
            let 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;
}
 
function prletMatrix(ans, N, M)
{
 
    // Prlet the matrix obtained
    for (let i = 0; i < N; i++)
    {
        for (let j = 0; j < M; j++)
        {
            document.write(ans[i][j] + " ");
        }
        document.write("<br/>");
    }
}
 
    // Driver Code
     
    let rowSum = [ 5, 7, 10 ];
    let colSum = [ 8, 6, 8 ];
 
    let ans
        = restoreGem(rowSum, colSum);
 
    prletMatrix(ans, rowSum.length,
                colSum.length);
 
</script>
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
Recommended Articles
Page :

Start Your Coding Journey Now!