Maximum sum possible from given Matrix by performing given operations
Given a matrix arr[][] of dimensions 2 * N, the task is to maximize the sum possible by selecting at most one element from each column such that no two consecutive elements are chosen from the same row.
Examples:
Input: arr[][] = {{1, 50, 21, 5}, {2, 10, 10, 5}}
Output: 67
Explanation: Elements arr[1][0]( = 2), arr[0][1]( = 50), arr[0][2]( = 10) and arr[0][3]( = 5) can be chosen. Therefore, sum = 2 + 50 + 10 + 5 = 67.
Input: arr[][] = {{9, 5, 3, 7, 3}, {50, 8, 1, 50, 5}}
Output: 108
Explanation: Elements arr[1][0]( = 50), arr[0][1]( = 5), arr[1][3]( = 50) and arr[0][4]( = 3) can be chosen. Therefore, sum = 50 + 5 + 50 + 3 = 108.
Dynamic Programming Approach: The problem can be solved using dynamic programming. Follow the steps below to solve the problem:
- Initialize an array dp[][] to store the following transition states:
dp[0][i] = max(dp[1][i+1], dp[0][i+2]) + arr[0][i]
dp[1][i] = max(dp[0][i+1], dp[1][i+2]) + arr[1][i]
where, dp[j][i] stores the maximum possible sum to reach cell arr[j][i] starting from the last column where 0 <= i < N and 0 <= j < 2.
Base case:
dp[0][N-1] = arr[0][N-1]
dp[1][N-1] = arr[1][N-1]
- Traverse from (N – 2)th column to the 0th column and for each row, update dp[j][i] as dp[j][i] = max(dp[(j ^ 1)][i+1], dp[j][i+2]) + arr[j][i] where ^ represents Bitwise XOR.
- After completing the traversal, print max(dp[0][0], dp[1][0]) as the maximum possible sum.
Below is the implementation of the above approach:
C++
#include <iostream>
#include <vector>
using namespace std;
void maxSum(vector<vector< int > > arr,
int n, int m)
{
vector<vector< int > > dp(n);
for ( int i = 0; i < 2; i++) {
dp[i] = vector< int >(m);
for ( int j = 0; j < m; j++) {
dp[i][j] = 0;
}
}
dp[0][m - 1] = arr[0][m - 1];
dp[1][m - 1] = arr[1][m - 1];
for ( int j = m - 2; j >= 0; j--) {
for ( int i = 0; i < 2; i++) {
if (i == 1) {
dp[i][j] = max(
arr[i][j] + dp[0][j + 1],
arr[i][j] + dp[0][j + 2]);
}
else {
dp[i][j] = max(
arr[i][j] + dp[1][j + 1],
arr[i][j] + dp[1][j + 2]);
}
}
}
cout << max(dp[0][0], dp[1][0]);
}
int main()
{
vector<vector< int > > arr
= { { 1, 50, 21, 5 },
{ 2, 10, 10, 5 } };
int N = arr[0].size();
maxSum(arr, 2, N);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG{
static void maxSum( int [][] arr, int n, int m)
{
int [][] dp = new int [n][m + 1 ];
for ( int i = 0 ; i < 2 ; i++)
{
for ( int j = 0 ; j <= m; j++)
{
dp[i][j] = 0 ;
}
}
dp[ 0 ][m - 1 ] = arr[ 0 ][m - 1 ];
dp[ 1 ][m - 1 ] = arr[ 1 ][m - 1 ];
for ( int j = m - 2 ; j >= 0 ; j--)
{
for ( int i = 0 ; i < 2 ; i++)
{
if (i == 1 )
{
dp[i][j] = Math.max(
arr[i][j] + dp[ 0 ][j + 1 ],
arr[i][j] + dp[ 0 ][j + 2 ]);
}
else
{
dp[i][j] = Math.max(
arr[i][j] + dp[ 1 ][j + 1 ],
arr[i][j] + dp[ 1 ][j + 2 ]);
}
}
}
System.out.println(Math.max(dp[ 0 ][ 0 ],
dp[ 1 ][ 0 ]));
}
public static void main(String[] args)
{
int [][] arr = { { 1 , 50 , 21 , 5 },
{ 2 , 10 , 10 , 5 } };
int N = arr[ 0 ].length;
maxSum(arr, 2 , N);
}
}
|
Python3
def maxSum(arr, n, m):
dp = [[ 0 for i in range (m + 1 )]
for i in range ( 2 )]
dp[ 0 ][m - 1 ] = arr[ 0 ][m - 1 ]
dp[ 1 ][m - 1 ] = arr[ 1 ][m - 1 ]
for j in range (m - 2 , - 1 , - 1 ):
for i in range ( 2 ):
if (i = = 1 ):
dp[i][j] = max (arr[i][j] + dp[ 0 ][j + 1 ],
arr[i][j] + dp[ 0 ][j + 2 ])
else :
dp[i][j] = max (arr[i][j] + dp[ 1 ][j + 1 ],
arr[i][j] + dp[ 1 ][j + 2 ])
print ( max (dp[ 0 ][ 0 ], dp[ 1 ][ 0 ]))
if __name__ = = '__main__' :
arr = [ [ 1 , 50 , 21 , 5 ],
[ 2 , 10 , 10 , 5 ] ]
N = len (arr[ 0 ])
maxSum(arr, 2 , N)
|
C#
using System;
class GFG{
static void maxSum( int [, ] arr, int n, int m)
{
int [, ] dp = new int [n, m + 1];
for ( int i = 0; i < 2; i++)
{
for ( int j = 0; j <= m; j++)
{
dp[i, j] = 0;
}
}
dp[0, m - 1] = arr[0, m - 1];
dp[1, m - 1] = arr[1, m - 1];
for ( int j = m - 2; j >= 0; j--)
{
for ( int i = 0; i < 2; i++)
{
if (i == 1)
{
dp[i, j] = Math.Max(
arr[i, j] + dp[0, j + 1],
arr[i, j] + dp[0, j + 2]);
}
else
{
dp[i, j] = Math.Max(
arr[i, j] + dp[1, j + 1],
arr[i, j] + dp[1, j + 2]);
}
}
}
Console.WriteLine(Math.Max(dp[0, 0],
dp[1, 0]));
}
public static void Main()
{
int [, ] arr = { { 1, 50, 21, 5 },
{ 2, 10, 10, 5 } };
int N = arr.GetLength(1);
maxSum(arr, 2, N);
}
}
|
Javascript
<script>
function maxSum(arr, n, m)
{
let dp = new Array(n);
for ( var i = 0; i < dp.length; i++) {
dp[i] = new Array(2);
}
for (let i = 0; i < 2; i++)
{
for (let j = 0; j <= m; j++)
{
dp[i][j] = 0;
}
}
dp[0][m - 1] = arr[0][m - 1];
dp[1][m - 1] = arr[1][m - 1];
for (let j = m - 2; j >= 0; j--)
{
for (let i = 0; i < 2; i++)
{
if (i == 1)
{
dp[i][j] = Math.max(
arr[i][j] + dp[0][j + 1],
arr[i][j] + dp[0][j + 2]);
}
else
{
dp[i][j] = Math.max(
arr[i][j] + dp[1][j + 1],
arr[i][j] + dp[1][j + 2]);
}
}
}
document.write(Math.max(dp[0][0],
dp[1][0]));
}
let arr = [[ 1, 50, 21, 5 ],
[ 2, 10, 10, 5 ]];
let N = arr[0].length;
maxSum(arr, 2, N);
</script>
|
Time Complexity: O(N), where N is the number of columns.
Auxiliary Space: O(N)
Efficient Approach: Follow the steps below to optimize the above approach
- Initialize two variables r1 and r2 to store the maximum sum for 1st and 2nd rows respectively.
- Traverse over the length of the row, i.e. 0 to N – 1 and for each element arr[i], update r1 as r1 = max(r1, r2 + arr[0][i]) and r2 as r2 = max(r2, r1 + arr[1][i]).
- After traversing, print max(r1, r2) as the maximum sum.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void maxSum(vector<vector< int > > arr, int n)
{
int r1 = 0, r2 = 0;
for ( int i = 0; i < n; i++)
{
int temp = r1;
r1 = max(r1, r2 + arr[0][i]);
r2 = max(r2, temp + arr[1][i]);
}
cout << max(r1, r2);
}
int main()
{
vector<vector< int >> arr = { { 1, 50, 21, 5 },
{ 2, 10, 10, 5 } };
int n = arr[0].size();
maxSum(arr, n);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG{
static void maxSum( int [][] arr, int n)
{
int r1 = 0 , r2 = 0 ;
for ( int i = 0 ; i < n; i++)
{
int temp = r1;
r1 = Math.max(r1, r2 + arr[ 0 ][i]);
r2 = Math.max(r2, temp + arr[ 1 ][i]);
}
System.out.println(Math.max(r1, r2));
}
public static void main(String args[])
{
int [][] arr = { { 1 , 50 , 21 , 5 },
{ 2 , 10 , 10 , 5 } };
int n = arr[ 0 ].length;
maxSum(arr, n);
}
}
|
Python
def maxSum(arr, n):
r1 = r2 = 0
for i in range (n):
r1, r2 = max (r1, r2 + arr[ 0 ][i]), max (r2, r1 + arr[ 1 ][i])
print ( max (r1, r2))
arr = [[ 1 , 50 , 21 , 5 ], [ 2 , 10 , 10 , 5 ]]
n = len (arr[ 0 ])
maxSum(arr, n)
|
C#
using System;
class GFG{
static void maxSum( int [, ] arr, int n)
{
int r1 = 0, r2 = 0;
for ( int i = 0; i < n; i++)
{
int temp = r1;
r1 = Math.Max(r1, r2 + arr[0, i]);
r2 = Math.Max(r2, temp + arr[1, i]);
}
Console.WriteLine(Math.Max(r1, r2));
}
public static void Main()
{
int [, ] arr = { { 1, 50, 21, 5 },
{ 2, 10, 10, 5 } };
int n = arr.GetLength(1);
maxSum(arr, n);
}
}
|
Javascript
<script>
function maxSum(arr , n) {
var r1 = 0, r2 = 0;
for (i = 0; i < n; i++) {
var temp = r1;
r1 = Math.max(r1, r2 + arr[0][i]);
r2 = Math.max(r2, temp + arr[1][i]);
}
document.write(Math.max(r1, r2));
}
var arr = [ [ 1, 50, 21, 5 ],
[ 2, 10, 10, 5 ] ];
var n = arr[0].length;
maxSum(arr, n);
</script>
|
Time Complexity: O(N), where N is the number of columns.
Auxiliary Space: O(1)
Last Updated :
23 Nov, 2021
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...