Related Articles
Maximum sum possible from given Matrix by performing given operations
• Last Updated : 16 Nov, 2020

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( = 2), arr( = 50), arr( = 10) and arr( = 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( = 50), arr( = 5), arr( = 50) and arr( = 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[i] = max(dp[i+1], dp[i+2]) + arr[i]
dp[i] = max(dp[i+1], dp[i+2]) + arr[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[N-1] = arr[N-1]
dp[N-1] = arr[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, dp) as the maximum possible sum.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `#include ` `using` `namespace` `std;`   `// Function to print the maximum sum` `void` `maxSum(vector > arr,` `            ``int` `n, ``int` `m)` `{`   `    ``// Dp table` `    ``vector > dp(n);`   `    ``// Intializing dp array with 0s` `    ``for` `(``int` `i = 0; i < 2; i++) {` `        ``dp[i] = vector<``int``>(m);` `        ``for` `(``int` `j = 0; j < m; j++) {` `            ``dp[i][j] = 0;` `        ``}` `    ``}`   `    ``// Base case` `    ``dp[m - 1] = arr[m - 1];` `    ``dp[m - 1] = arr[m - 1];`   `    ``// Traverse each column` `    ``for` `(``int` `j = m - 2; j >= 0; j--) {`   `        ``// Update answer for both rows` `        ``for` `(``int` `i = 0; i < 2; i++) {` `            ``if` `(i == 1) {` `                ``dp[i][j] = max(` `                    ``arr[i][j] + dp[j + 1],` `                    ``arr[i][j] + dp[j + 2]);` `            ``}` `            ``else` `{` `                ``dp[i][j] = max(` `                    ``arr[i][j] + dp[j + 1],` `                    ``arr[i][j] + dp[j + 2]);` `            ``}` `        ``}` `    ``}`   `    ``// Print the maximum sum` `    ``cout << max(dp, dp);` `}`   `// Driver Code` `int` `main()` `{`   `    ``// Given array` `    ``vector > arr` `        ``= { { 1, 50, 21, 5 },` `            ``{ 2, 10, 10, 5 } };`   `    ``// Number of Columns` `    ``int` `N = arr.size();`   `    ``// Function calls` `    ``maxSum(arr, 2, N);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG{`   `// Function to print the maximum sum` `static` `void` `maxSum(``int``[][] arr, ``int` `n, ``int` `m)` `{` `    `  `    ``// Dp table` `    ``int``[][] dp = ``new` `int``[n][m + ``1``];`   `    ``// Intializing dp array with 0s` `    ``for``(``int` `i = ``0``; i < ``2``; i++) ` `    ``{` `        ``for``(``int` `j = ``0``; j <= m; j++)` `        ``{` `            ``dp[i][j] = ``0``;` `        ``}` `    ``}`   `    ``// Base case` `    ``dp[``0``][m - ``1``] = arr[``0``][m - ``1``];` `    ``dp[``1``][m - ``1``] = arr[``1``][m - ``1``];`   `    ``// Traverse each column` `    ``for``(``int` `j = m - ``2``; j >= ``0``; j--)` `    ``{`   `        ``// Update answer for both rows` `        ``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``]);` `            ``}` `        ``}` `    ``}`   `    ``// Print the maximum sum` `    ``System.out.println(Math.max(dp[``0``][``0``], ` `                                ``dp[``1``][``0``]));` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    `  `    ``// Given array` `    ``int``[][] arr = { { ``1``, ``50``, ``21``, ``5` `},` `                    ``{ ``2``, ``10``, ``10``, ``5` `} };`   `    ``// Number of Columns` `    ``int` `N = arr[``0``].length;`   `    ``// Function calls` `    ``maxSum(arr, ``2``, N);` `}` `}`   `// This code is contributed by akhilsaini`

## Python3

 `# Python3 program for the above approach`   `# Function to prthe maximum sum` `def` `maxSum(arr, n, m):`   `    ``# Dp table` `    ``dp ``=` `[[``0` `for` `i ``in` `range``(m ``+` `1``)] ` `             ``for` `i ``in` `range``(``2``)]`   `    ``# Intializing dp array with 0s` `    ``# for (i = 0 i < 2 i++) {` `    ``#     dp[i] = vector(m)` `    ``#     for (j = 0 j < m j++) {` `    ``#         dp[i][j] = 0` `    ``#     }` `    ``# }`   `    ``# Base case` `    ``dp[``0``][m ``-` `1``] ``=` `arr[``0``][m ``-` `1``]` `    ``dp[``1``][m ``-` `1``] ``=` `arr[``1``][m ``-` `1``]`   `    ``# Traverse each column` `    ``for` `j ``in` `range``(m ``-` `2``, ``-``1``, ``-``1``):`   `        ``# Update answer for both rows` `        ``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 the maximum sum` `    ``print``(``max``(dp[``0``][``0``], dp[``1``][``0``]))`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``# Given array` `    ``arr ``=` `[ [ ``1``, ``50``, ``21``, ``5` `],` `            ``[ ``2``, ``10``, ``10``, ``5` `] ]`   `    ``# Number of Columns` `    ``N ``=` `len``(arr[``0``])`   `    ``# Function calls` `    ``maxSum(arr, ``2``, N)`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach` `using` `System;`   `class` `GFG{`   `// Function to print the maximum sum` `static` `void` `maxSum(``int``[, ] arr, ``int` `n, ``int` `m)` `{` `    `  `    ``// Dp table` `    ``int``[, ] dp = ``new` `int``[n, m + 1];`   `    ``// Intializing dp array with 0s` `    ``for``(``int` `i = 0; i < 2; i++)` `    ``{` `        ``for``(``int` `j = 0; j <= m; j++)` `        ``{` `            ``dp[i, j] = 0;` `        ``}` `    ``}`   `    ``// Base case` `    ``dp[0, m - 1] = arr[0, m - 1];` `    ``dp[1, m - 1] = arr[1, m - 1];`   `    ``// Traverse each column` `    ``for``(``int` `j = m - 2; j >= 0; j--)` `    ``{` `        `  `        ``// Update answer for both rows` `        ``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]);` `            ``}` `        ``}` `    ``}`   `    ``// Print the maximum sum` `    ``Console.WriteLine(Math.Max(dp[0, 0],` `                               ``dp[1, 0]));` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `    `  `    ``// Given array` `    ``int``[, ] arr = { { 1, 50, 21, 5 }, ` `                    ``{ 2, 10, 10, 5 } };`   `    ``// Number of Columns` `    ``int` `N = arr.GetLength(1);` `    `  `    ``// Function calls` `    ``maxSum(arr, 2, N);` `}` `}`   `// This code is contributed by akhilsaini`

Output:

```67

```

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

1. Initialize two variables r1 and r2 to store the maximum sum for 1st and 2nd rows respectively.
2. 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[i]) and r2 as r2 = max(r2, r1 + arr[i]).
3. After traversing, print max(r1, r2) as the maximum sum.

Below is the implementation of the above approach:

## C++

 `// C++ code for the above approach` `#include ` `using` `namespace` `std;`   `// Function to print the maximum sum` `// possible by selecting at most one` `// element from each column such that` `// no consecutive pairs are selected` `// from a single row` `void` `maxSum(vector > arr, ``int` `n)` `{` `    `  `    ``// Initialize variables` `    ``int` `r1 = 0, r2 = 0;` `    `  `    ``// Traverse each column` `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{` `        `  `        ``// r1, r2 = max(r1, r2 + arr[i]),` `        ``// max(r2, r1 + arr[i])` `        ``int` `temp = r1;` `        `  `        ``r1 = max(r1, r2 + arr[i]);` `        ``r2 = max(r2, temp + arr[i]);` `    ``}`   `    ``// Print answer` `    ``cout << max(r1, r2);` `}`   `// Driver Code` `int` `main()` `{` `    ``vector> arr = { { 1, 50, 21, 5 }, ` `                                ``{ 2, 10, 10, 5 } };`   `    ``// Numberof columns` `    ``int` `n = arr.size();`   `    ``maxSum(arr, n);`   `    ``return` `0;` `}`   `// This code is contributed by akhilsaini`

## Java

 `// Java code for the above approach` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG{`   `// Function to print the maximum sum` `// possible by selecting at most one` `// element from each column such that` `// no consecutive pairs are selected` `// from a single row` `static` `void` `maxSum(``int``[][] arr, ``int` `n)` `{` `    `  `    ``// Initialize variables` `    ``int` `r1 = ``0``, r2 = ``0``;`   `    ``// Traverse each column` `    ``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]);` `    ``}`   `    ``// Print answer` `    ``System.out.println(Math.max(r1, r2));` `}`   `// Driver Code` `public` `static` `void` `main(String args[])` `{` `    ``int``[][] arr = { { ``1``, ``50``, ``21``, ``5` `},` `                    ``{ ``2``, ``10``, ``10``, ``5` `} };`   `    ``// Numberof columns` `    ``int` `n = arr[``0``].length;`   `    ``maxSum(arr, n);` `}` `}`   `// This code is contributed by akhilsaini`

## Python

 `# Python code for the above approach`   `# Function to print the maximum sum` `# possible by selecting at most one` `# element from each column such that` `# no consecutive pairs are selected` `# from a single row`   `def` `maxSum(arr, n):`   `    ``# Initialize variables` `    ``r1 ``=` `r2 ``=` `0`   `    ``# Traverse each column` `    ``for` `i ``in` `range``(n):` `        ``r1, r2 ``=` `max``(r1, r2 ``+` `arr[``0``][i]), ``max``(r2, r1 ``+` `arr[``1``][i])`   `        ``# Print answer` `    ``print``(``max``(r1, r2))`     `# Driver Code`   `arr ``=` `[[``1``, ``50``, ``21``, ``5``], [``2``, ``10``, ``10``, ``5``]]`   `# Numberof columns` `n ``=` `len``(arr[``0``])`   `maxSum(arr, n)`

## C#

 `// C# code for the above approach` `using` `System;`   `class` `GFG{`   `// Function to print the maximum sum` `// possible by selecting at most one` `// element from each column such that` `// no consecutive pairs are selected` `// from a single row` `static` `void` `maxSum(``int``[, ] arr, ``int` `n)` `{` `    `  `    ``// Initialize variables` `    ``int` `r1 = 0, r2 = 0;`   `    ``// Traverse each column` `    ``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]);` `    ``}`   `    ``// Print answer` `    ``Console.WriteLine(Math.Max(r1, r2));` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `    ``int``[, ] arr = { { 1, 50, 21, 5 },` `                    ``{ 2, 10, 10, 5 } };`   `    ``// Numberof columns` `    ``int` `n = arr.GetLength(1);`   `    ``maxSum(arr, n);` `}` `}`   `// This code is contributed by akhilsaini`

Output:

```67

```

Time Complexity: O(N), where N is the number of columns.
Auxiliary Space: O(1)

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :