# Maximize sum of K elements selected from a Matrix such that each selected element must be preceded by selected row elements

• Last Updated : 15 Dec, 2021

Given a 2D array arr[][] of size N * M, and an integer K, the task is to select K elements with maximum possible sum such that if an element arr[i][j] is selected, then all the elements from the ith row present before the jth column needs to be selected.

Examples:

Input: arr[][] = {{10, 10, 100, 30}, {80, 50, 10, 50}}, K = 5
Output: 250
Explanation:
Selecting first 3 elements from the first row, sum = 10 + 10 + 100 = 120
Selecting first 2 elements from the second row, sum = 80 + 50 = 130
Therefore, the maximum sum = 120 + 130 = 250.

Input: arr[][] = {{30, 10, 110, 13}, {810, 152, 12, 5}, {124, 24, 54, 124}}, K = 6
Output: 1288
Explanation:
Selecting first 2 elements from the second row, sum = 810 + 152 = 962
Selecting all 4 elements from the third row, sum = 124 + 24 + 54 + 124 = 326
Therefore, the maximum sum = 962 + 326 = 1288

Naive Approach: The simplest approach to solve the problem is to generate all possible subsets of size K from the given matrix based on specified constraint and calculate the maximum sum possible from these subsets.

Time Complexity: O((N*M)!/(K!)*(N*M – K)!)
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized by using Dynamic Programming. The idea is to find the maximum sum of selecting i elements till the jth row of the 2D array arr[][]. The auxiliary array dp[i][j + 1] stores the maximum sum of selecting i elements till jth row of matrix arr[][]. Follow the steps below to solve the problem:

• Initialize a dp[][] table of size (K+1)*(N+1) and initialize dp[i] as 0, as no elements have sum equal to 0.
• Initialize dp[i] as 0, as there are no elements to be selected.
• Iterate over the range [0, K] using two nested loops and [0, N] using the variables i and j respectively:
• Initialize a variable, say sum as 0, to keep track of the cumulative sum of elements in the jth row of arr[][].
• Initialize maxSum as dp[i][j], if no item needs to be selected from jth row of arr[][].
• Iterate with k as 1 until k > M or k > i:
• Increment sum += buy[j][k – 1].
• Store the maximum of existing maxSum and (sum + dp[i – k][j]) in maxSum.
• Store dp[i][j + 1] as the value of maxSum.
• Print the value dp[K][N] as the maximum sum of K elements till (N – 1)th row of matrix arr[][].

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to return the maximum``// of two elements``int` `max(``int` `a, ``int` `b)``{``    ``return` `a > b ? a : b;``}` `// Function to find the maximum sum``// of selecting K elements from``// the given 2D array arr[][]``int` `maximumsum(``int` `arr[], ``int` `K,``               ``int` `N, ``int` `M)``{``    ``int` `sum = 0, maxSum;``    ``int` `i, j, k;` `    ``// dp table of size (K+1)*(N+1)``    ``int` `dp[K + 1][N + 1];` `    ``// Initialize dp[i] = 0``    ``for` `(i = 0; i <= N; i++)``        ``dp[i] = 0;` `    ``// Initialize dp[i] = 0``    ``for` `(i = 0; i <= K; i++)``        ``dp[i] = 0;` `    ``// Selecting i elements``    ``for` `(i = 1; i <= K; i++) {` `        ``// Select i elements till jth row``        ``for` `(j = 0; j < N; j++) {` `            ``// dp[i][j+1] is the maximum``            ``// of selecting i elements till``            ``// jth row` `            ``// sum = 0, to keep track of``            ``// cumulative elements sum``            ``sum = 0;``            ``maxSum = dp[i][j];` `            ``// Traverse arr[j][k] until``            ``// number of elements until k>i``            ``for` `(k = 1; k <= M && k <= i; k++) {` `                ``// Select arr[j][k - 1]th item``                ``sum += arr[j][k - 1];` `                ``maxSum``                    ``= max(maxSum,``                          ``sum + dp[i - k][j]);``            ``}` `            ``// Store the maxSum in dp[i][j+1]``            ``dp[i][j + 1] = maxSum;``        ``}``    ``}` `    ``// Return the maximum sum``    ``return` `dp[K][N];``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { { 10, 10, 100, 30 },``                     ``{ 80, 50, 10, 50 } };` `    ``int` `N = 2, M = 4;``    ``int` `K = 5;` `    ``// Function Call``    ``cout << maximumsum(arr, K, N, M);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``   ` `class` `GFG{``   ` `// Function to return the maximum``// of two elements``static` `int` `max(``int` `a, ``int` `b)``{``    ``return` `a > b ? a : b;``}`` ` `// Function to find the maximum sum``// of selecting K elements from``// the given 2D array arr[][]``static` `int` `maximumsum(``int` `arr[][], ``int` `K,``                      ``int` `N, ``int` `M)``{``    ``int` `sum = ``0``, maxSum;``    ``int` `i, j, k;`` ` `    ``// dp table of size (K+1)*(N+1)``    ``int``[][] dp = ``new` `int``[K + ``1``][N + ``1``];`` ` `    ``// Initialize dp[i] = 0``    ``for``(i = ``0``; i <= N; i++)``        ``dp[``0``][i] = ``0``;`` ` `    ``// Initialize dp[i] = 0``    ``for``(i = ``0``; i <= K; i++)``        ``dp[i][``0``] = ``0``;`` ` `    ``// Selecting i elements``    ``for``(i = ``1``; i <= K; i++)``    ``{``        ` `        ``// Select i elements till jth row``        ``for``(j = ``0``; j < N; j++)``        ``{``            ` `            ``// dp[i][j+1] is the maximum``            ``// of selecting i elements till``            ``// jth row`` ` `            ``// sum = 0, to keep track of``            ``// cumulative elements sum``            ``sum = ``0``;``            ``maxSum = dp[i][j];`` ` `            ``// Traverse arr[j][k] until``            ``// number of elements until k>i``            ``for``(k = ``1``; k <= M && k <= i; k++)``            ``{``                ` `                ``// Select arr[j][k - 1]th item``                ``sum += arr[j][k - ``1``];`` ` `                ``maxSum = Math.max(maxSum,``                                  ``sum + dp[i - k][j]);``            ``}`` ` `            ``// Store the maxSum in dp[i][j+1]``            ``dp[i][j + ``1``] = maxSum;``        ``}``    ``}`` ` `    ``// Return the maximum sum``    ``return` `dp[K][N];``}``   ` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[][] =  { { ``10``, ``10``, ``100``, ``30` `},``                     ``{ ``80``, ``50``, ``10``, ``50` `} };`` ` `    ``int` `N = ``2``, M = ``4``;``    ``int` `K = ``5``;`` ` `    ``// Function Call``    ``System.out.print(maximumsum(arr, K, N, M));``}``}` `// This code is contributed by susmitakundugoaldanga`

## Python3

 `# Python program for the above approach``import` `math;` `# Function to return the maximum``# of two elements``def` `max``(a, b):``    ``if``(a > b):``        ``return` `a;``    ``else``:``        ``return` `b;` `# Function to find the maximum sum``# of selecting K elements from``# the given 2D array arr``def` `maximumsum(arr, K, N, M):``    ``sum` `=` `0``;``    ``maxSum ``=` `0``;` `    ``# dp table of size (K+1)*(N+1)``    ``dp ``=` `[[``0` `for` `i ``in` `range``(N ``+` `1``)] ``for` `j ``in` `range``(K ``+` `1``)]` `    ``# Initialize dp[i] = 0``    ``for` `i ``in` `range``(``0``, N ``+` `1``):``        ``dp[``0``][i] ``=` `0``;` `    ``# Initialize dp[i] = 0``    ``for` `i ``in` `range``(``0``, K ``+` `1``):``        ``dp[i][``0``] ``=` `0``;` `    ``# Selecting i elements``    ``for`  `i ``in` `range``(``1``, K ``+` `1``):` `        ``# Select i elements till jth row``        ``for`  `j ``in` `range``(``0``, N):` `            ``# dp[i][j+1] is the maximum``            ``# of selecting i elements till``            ``# jth row` `            ``# sum = 0, to keep track of``            ``# cumulative elements sum``            ``sum` `=` `0``;``            ``maxSum ``=` `dp[i][j];` `            ``# Traverse arr[j][k] until``            ``# number of elements until k>i``            ``for` `k ``in` `range``(``1``, i ``+` `1``):``                ``if``(k > M):``                    ``break``;``                    ` `                ``# Select arr[j][k - 1]th item``                ``sum` `+``=` `arr[j][k ``-` `1``];` `                ``maxSum ``=` `max``(maxSum, ``sum` `+` `dp[i ``-` `k][j]);` `            ``# Store the maxSum in dp[i][j+1]``            ``dp[i][j ``+` `1``] ``=` `maxSum;` `    ``# Return the maximum sum``    ``return` `dp[K][N];` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[[``10``, ``10``, ``100``, ``30``], [``80``, ``50``, ``10``, ``50``]];` `    ``N ``=` `2``;``    ``M ``=` `4``;``    ``K ``=` `5``;` `    ``# Function Call``    ``print``(maximumsum(arr, K, N, M));`  `    ``# This code is contributed by 29AjayKumar`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{``   ` `// Function to return the maximum``// of two elements``static` `int` `max(``int` `a, ``int` `b)``{``    ``return` `a > b ? a : b;``}`` ` `// Function to find the maximum sum``// of selecting K elements from``// the given 2D array [,]arr``static` `int` `maximumsum(``int` `[,]arr, ``int` `K,``                      ``int` `N, ``int` `M)``{``    ``int` `sum = 0, maxSum;``    ``int` `i, j, k;``    ` `    ``// dp table of size (K+1)*(N+1)``    ``int``[,] dp = ``new` `int``[K + 1, N + 1];`` ` `    ``// Initialize dp[0,i] = 0``    ``for``(i = 0; i <= N; i++)``        ``dp[0, i] = 0;`` ` `    ``// Initialize dp[i,0] = 0``    ``for``(i = 0; i <= K; i++)``        ``dp[i, 0] = 0;`` ` `    ``// Selecting i elements``    ``for``(i = 1; i <= K; i++)``    ``{``        ` `        ``// Select i elements till jth row``        ``for``(j = 0; j < N; j++)``        ``{``            ` `            ``// dp[i,j+1] is the maximum``            ``// of selecting i elements till``            ``// jth row`` ` `            ``// sum = 0, to keep track of``            ``// cumulative elements sum``            ``sum = 0;``            ``maxSum = dp[i, j];`` ` `            ``// Traverse arr[j,k] until``            ``// number of elements until k>i``            ``for``(k = 1; k <= M && k <= i; k++)``            ``{``                ` `                ``// Select arr[j,k - 1]th item``                ``sum += arr[j, k - 1];`` ` `                ``maxSum = Math.Max(maxSum,``                                  ``sum + dp[i - k, j]);``            ``}`` ` `            ``// Store the maxSum in dp[i,j+1]``            ``dp[i, j + 1] = maxSum;``        ``}``    ``}`` ` `    ``// Return the maximum sum``    ``return` `dp[K, N];``}``   ` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[,]arr =  { { 10, 10, 100, 30 },``                    ``{ 80, 50, 10, 50 } };`` ` `    ``int` `N = 2, M = 4;``    ``int` `K = 5;`` ` `    ``// Function Call``    ``Console.Write(maximumsum(arr, K, N, M));``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output:

`250`

Time Complexity: O(K*N*M)
Auxiliary Space: O(K*N)

My Personal Notes arrow_drop_up