Maximum Sum possible by selecting X elements from a Matrix based on given conditions
Last Updated :
28 Jun, 2022
Given a matrix G[][] of dimensions N × M, consists of positive integers, the task is to select X elements from the matrix having maximum sum considering the condition that G[i][j] can only be selected from the matrix unless all the elements G[i][k] are selected, where 0 ? k < j i.e., the jth element in the current ith row can be selected all its the preceding elements of the current ith row has already been selected.
Examples:
Input: N = 4, M = 4, X = 6, G[][] = {{3, 2, 6, 1}, {1, 9, 2, 4}, {4, 1, 3, 9}, {3, 8, 2, 1}}
Output: 28
Explanation:
Selecting the first element from the 1st row = 3
Selecting the first two elements from the 2nd row = 1 + 9 = 10
Selecting the first element from the 3rd row = 4
Selecting the first two elements from the 4th row = 3 + 8 = 11
Hence, the selected elements are {G[0][0], G[1][0], G[1][1], G[2][0], G[3][0], G[3][1]}
Hence, the sum of the selected elements is = 3 + 10 + 4 + 11 = 28
Input: N = 2, M = 4, X = 4, G[][] = {{10, 10, 100, 30}, {80, 50, 10, 50}}
Output: 200
Naive Approach: The simplest approach to solve this problem is to calculate the sum for all possible M selections and find the maximum sum among them.
Time Complexity: O(NM)
Auxiliary Space: O(1)
Efficient Approach: The above approach can be optimized using Dynamic Programming. The considerable states are:
- Number of rows selected: i.
- Number of elements selected: j.
Initialize a matrix dp[][] such that dp[i][j] stores the maximum possible sum that can be obtained by selecting j elements from the first i rows.
The transition for the dp[][] is as follows:
dp[i][j] = maxx=(0, min(j, m))(dp[i – 1][j – x] + prefsum[i][x])
where prefsum[i][x] is the sum of the first x elements in the ith row of the matrix.
Below is the implementation of above approach:
C++14
#include <bits/stdc++.h>
using namespace std;
int n, m, X;
int maxSum(vector<vector< int >> grid)
{
vector<vector< int >> prefsum(n, vector< int >(m));
for ( int i = 0; i < n; i++)
{
for ( int x = 0; x < m; x++)
{
if (x == 0)
prefsum[i][x] = grid[i][x];
else
prefsum[i][x] = prefsum[i][x - 1] +
grid[i][x];
}
}
vector<vector< int >> dp(n, vector< int >(X + 1, INT_MIN));
for ( int i = 0; i < n; i++)
dp[i][0] = 0;
for ( int i = 1; i <= min(m, X); ++i)
{
dp[0][i] = dp[0][i - 1] +
grid[0][i - 1];
}
for ( int i = 1; i < n; ++i)
{
for ( int j = 1; j <= X; ++j)
{
dp[i][j] = dp[i - 1][j];
for ( int x = 1; x <= min(j, m); x++)
{
dp[i][j] = max(dp[i][j],
dp[i - 1][j - x] +
prefsum[i][x - 1]);
}
}
}
return dp[n - 1][X];
}
int main()
{
n = 4;
m = 4;
X = 6;
vector<vector< int >> grid = { { 3, 2, 6, 1 },
{ 1, 9, 2, 4 },
{ 4, 1, 3, 9 },
{ 3, 8, 2, 1 } };
int ans = maxSum(grid);
cout << (ans);
return 0;
}
|
Java
import java.util.*;
import java.io.*;
class GFG {
static int n, m, X;
public static int maxSum( int [][] grid)
{
int prefsum[][] = new int [n][m];
for ( int i = 0 ; i < n; i++) {
for ( int x = 0 ; x < m; x++) {
if (x == 0 )
prefsum[i][x] = grid[i][x];
else
prefsum[i][x]
= prefsum[i][x - 1 ] + grid[i][x];
}
}
int dp[][] = new int [n][X + 1 ];
for ( int dpp[] : dp)
Arrays.fill(dpp, Integer.MIN_VALUE);
for ( int i = 0 ; i < n; i++)
dp[i][ 0 ] = 0 ;
for ( int i = 1 ; i <= Math.min(m, X); ++i) {
dp[ 0 ][i] = dp[ 0 ][i - 1 ] + grid[ 0 ][i - 1 ];
}
for ( int i = 1 ; i < n; ++i) {
for ( int j = 1 ; j <= X; ++j) {
dp[i][j] = dp[i - 1 ][j];
for ( int x = 1 ; x <= Math.min(j, m);
x++) {
dp[i][j]
= Math.max(dp[i][j],
dp[i - 1 ][j - x]
+ prefsum[i][x - 1 ]);
}
}
}
return dp[n - 1 ][X];
}
public static void main(String[] args)
{
n = 4 ;
m = 4 ;
X = 6 ;
int grid[][] = { { 3 , 2 , 6 , 1 },
{ 1 , 9 , 2 , 4 },
{ 4 , 1 , 3 , 9 },
{ 3 , 8 , 2 , 1 } };
int ans = maxSum(grid);
System.out.println(ans);
}
}
|
Python3
import sys
def maxSum(grid):
prefsum = [[ 0 for x in range (m)]
for y in range (m)]
for i in range (n):
for x in range (m):
if (x = = 0 ):
prefsum[i][x] = grid[i][x]
else :
prefsum[i][x] = (prefsum[i][x - 1 ] +
grid[i][x])
dp = [[ - sys.maxsize - 1 for x in range (X + 1 )]
for y in range (n)]
for i in range (n):
dp[i][ 0 ] = 0
for i in range ( 1 , min (m, X)):
dp[ 0 ][i] = (dp[ 0 ][i - 1 ] +
grid[ 0 ][i - 1 ])
for i in range ( 1 , n):
for j in range ( 1 , X + 1 ):
dp[i][j] = dp[i - 1 ][j]
for x in range ( 1 , min (j, m) + 1 ):
dp[i][j] = max (dp[i][j],
dp[i - 1 ][j - x] +
prefsum[i][x - 1 ])
return dp[n - 1 ][X]
if __name__ = = "__main__" :
n = 4
m = 4
X = 6
grid = [ [ 3 , 2 , 6 , 1 ],
[ 1 , 9 , 2 , 4 ],
[ 4 , 1 , 3 , 9 ],
[ 3 , 8 , 2 , 1 ] ]
ans = maxSum(grid)
print (ans)
|
C#
using System;
class GFG{
static int n, m, X;
public static int maxSum( int [,] grid)
{
int [,]prefsum = new int [n, m];
for ( int i = 0; i < n; i++)
{
for ( int x = 0; x < m; x++)
{
if (x == 0)
prefsum[i, x] = grid[i, x];
else
prefsum[i, x] = prefsum[i, x - 1] +
grid[i, x];
}
}
int [,]dp = new int [n, X + 1];
for ( int i = 1; i < n; i++)
for ( int j = 1; j <= X; ++j)
dp[i, j] = int .MinValue;
for ( int i = 0; i < n; i++)
dp[i, 0] = 0;
for ( int i = 1; i <= Math.Min(m, X); ++i)
{
dp[0, i] = dp[0, i - 1] + grid[0, i - 1];
}
for ( int i = 1; i < n; ++i)
{
for ( int j = 1; j <= X; ++j)
{
dp[i, j] = dp[i - 1, j];
for ( int x = 1; x <= Math.Min(j, m); x++)
{
dp[i, j] = Math.Max(dp[i, j],
dp[i - 1, j - x] +
prefsum[i, x - 1]);
}
}
}
return dp[n - 1, X];
}
public static void Main(String[] args)
{
n = 4;
m = 4;
X = 6;
int [,]grid = { { 3, 2, 6, 1 },
{ 1, 9, 2, 4 },
{ 4, 1, 3, 9 },
{ 3, 8, 2, 1 } };
int ans = maxSum(grid);
Console.WriteLine(ans);
}
}
|
Javascript
<script>
let n, m, X;
function maxSum(grid)
{
let prefsum = new Array(n);
for ( var i = 0; i < prefsum.length; i++) {
prefsum[i] = new Array(2);
}
for (let i = 0; i < n; i++) {
for (let x = 0; x < m; x++) {
if (x == 0)
prefsum[i][x] = grid[i][x];
else
prefsum[i][x]
= prefsum[i][x - 1] + grid[i][x];
}
}
let dp = new Array(n);
for ( var i = 0; i < dp.length; i++) {
dp[i] = new Array(2);
}
for ( var i = 0; i < n; i++) {
for ( var j = 0; j < X+1; j++) {
dp[i][j] = 0;
}
}
for (let i = 0; i < n; i++)
dp[i][0] = 0;
for (let i = 1; i <= Math.min(m, X); ++i) {
dp[0][i] = dp[0][i - 1] + grid[0][i - 1];
}
for (let i = 1; i < n; ++i) {
for (let j = 1; j <= X; ++j) {
dp[i][j] = dp[i - 1][j];
for (let x = 1; x <= Math.min(j, m);
x++) {
dp[i][j]
= Math.max(dp[i][j],
dp[i - 1][j - x]
+ prefsum[i][x - 1]);
}
}
}
return dp[n - 1][X];
}
n = 4;
m = 4;
X = 6;
let grid = [[ 3, 2, 6, 1 ],
[ 1, 9, 2, 4 ],
[ 4, 1, 3, 9 ],
[ 3, 8, 2, 1 ]];
let ans = maxSum(grid);
document.write(ans);
</script>
|
Time Complexity: O(N*M*X)
Auxiliary Space: O(N*M)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...