Skip to content
Related Articles
Maximum sum of elements from each row in the matrix
• Difficulty Level : Easy
• Last Updated : 09 Apr, 2021

Given a matrix, find the maximum sum we can have by selecting just one element from every row. Condition is element selected from nth row must be strictly greater than element from (n-1)th row, else no element must be taken from row. Print the sum if possible else print -1.
Examples :

```Input :
1 2 3
1 2 3
7 8 9
Output : 14 (2 + 3 + 9) (values we
are adding are strictly increasing)

Input :
4 2 3
3 2 1
1 2 2
Output : -1
(No subsequent increasing elements
can be picked from consecutive rows)```

Approach :- One can simply run the loop from last row, get the greatest element from there say it prev_max, and keep record for the minimum difference among the elements of the row just above it, if any element found with positive difference, then add it to prev_max else print -1. Continue the same process for every row.

## C++

 `// CPP Program to find row-wise maximum element``// sum considering elements in increasing order.``#include ``#define N 3``using` `namespace` `std;` `// Function to perform given task``int` `getGreatestSum(``int` `a[][N])``{``    ``// Getting the maximum element from last row``    ``int` `prev_max = 0;``    ``for` `(``int` `j = 0; j < N; j++)``        ``if` `(prev_max < a[N - 1][j])``            ``prev_max = a[N - 1][j];` `    ``// Comparing it with the elements of above rows``    ``int` `sum = prev_max;``    ``for` `(``int` `i = N - 2; i >= 0; i--) {` `        ``// Maximum of current row.``        ``int` `curr_max = INT_MIN;``        ``for` `(``int` `j = 0; j < N; j++)``            ``if` `(prev_max > a[i][j] && a[i][j] > curr_max)``                ``curr_max = a[i][j];` `        ``// If we could not an element smaller``        ``// than prev_max.``        ``if` `(curr_max == INT_MIN)``            ``return` `-1;` `        ``prev_max = curr_max;``        ``sum += prev_max;``    ``}``    ``return` `sum;``}` `// Driver code``int` `main()``{``    ``int` `a = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };``    ``cout << getGreatestSum(a) << endl;``    ``int` `b = { { 4, 5, 6 }, { 4, 5, 6 }, { 4, 5, 6 } };``    ``cout << getGreatestSum(b) << endl;``    ``return` `0;``}`

## Java

 `// Java Program to find row-wise maximum``// element sum considering elements in``// increasing order.``class` `GFG {` `    ``static` `final` `int` `N = ``3``;` `    ``// Function to perform given task``    ``static` `int` `getGreatestSum(``int` `a[][])``    ``{` `        ``// Getting the maximum element from``        ``// last row``        ``int` `prev_max = ``0``;` `        ``for` `(``int` `j = ``0``; j < N; j++)``            ``if` `(prev_max < a[N - ``1``][j])``                ``prev_max = a[N - ``1``][j];` `        ``// Comparing it with the elements``        ``// of above rows``        ``int` `sum = prev_max;` `        ``for` `(``int` `i = N - ``2``; i >= ``0``; i--) {` `            ``// Maximum of current row.``            ``int` `curr_max = -``2147483648``;` `            ``for` `(``int` `j = ``0``; j < N; j++)``                ``if` `(prev_max > a[i][j] && a[i][j] > curr_max)``                    ``curr_max = a[i][j];` `            ``// If we could not an element smaller``            ``// than prev_max.``            ``if` `(curr_max == -``2147483648``)``                ``return` `-``1``;` `            ``prev_max = curr_max;``            ``sum += prev_max;``        ``}` `        ``return` `sum;``    ``}` `    ``// Driver Program to test above function``    ``public` `static` `void` `main(String arg[])``    ``{` `        ``int` `a[][] = { { ``1``, ``2``, ``3` `},``                      ``{ ``4``, ``5``, ``6` `},``                      ``{ ``7``, ``8``, ``9` `} };``        ``System.out.println(getGreatestSum(a));` `        ``int` `b[][] = { { ``4``, ``5``, ``6` `},``                      ``{ ``4``, ``5``, ``6` `},``                      ``{ ``4``, ``5``, ``6` `} };``        ``System.out.println(getGreatestSum(b));``    ``}``}` `// This code is contributed by Anant Agarwal.`

## Python3

 `# Python Program to find``# row-wise maximum element``# sum considering elements``# in increasing order.` `N ``=` `3` `# Function to perform given task``def` `getGreatestSum(a):` `    ``# Getting the maximum``    ``# element from last row``    ``prev_max ``=` `0``    ``for` `j ``in` `range``(N):``        ``if` `(prev_max < a[N ``-` `1``][j]):``            ``prev_max ``=` `a[N ``-` `1``][j]` `    ``# Comparing it with the``    ``# elements of above rows``    ``sum` `=` `prev_max``    ``for` `i ``in` `range``(N ``-` `2``, ``-``1``, ``-``1``):` `        ``# Maximum of current row.``        ``curr_max ``=` `-``2147483648``        ``for` `j ``in` `range``(N):``            ``if` `(prev_max > a[i][j] ``and` `a[i][j] > curr_max):``                ``curr_max ``=` `a[i][j]` `        ``# If we could not an element smaller``        ``# than prev_max.``        ``if` `(curr_max ``=``=` `-``2147483648``):``            ``return` `-``1` `        ``prev_max ``=` `curr_max``        ``sum` `=` `sum` `+` `prev_max``    ` `    ``return` `sum` `# Driver code` `a ``=` `[ [ ``1``, ``2``, ``3` `],``    ``[ ``4``, ``5``, ``6` `],``    ``[ ``7``, ``8``, ``9` `] ]` `print``(getGreatestSum(a))` `b ``=` `[ [ ``4``, ``5``, ``6` `],``    ``[ ``4``, ``5``, ``6` `],``    ``[ ``4``, ``5``, ``6` `] ]` `print``(getGreatestSum(b))``    ` `# This code is contributed``# by Anant Agarwal.`

## C#

 `// C# Program to find row-wise maximum``// element sum considering elements in``// increasing order.``using` `System;` `class` `GFG {` `    ``static` `int` `N = 3;` `    ``// Function to perform given task``    ``static` `int` `getGreatestSum(``int``[, ] a)``    ``{` `        ``// Getting the maximum element from``        ``// last row``        ``int` `prev_max = 0;` `        ``for` `(``int` `j = 0; j < N; j++)``            ``if` `(prev_max < a[N - 1, j])``                ``prev_max = a[N - 1, j];` `        ``// Comparing it with the elements``        ``// of above rows``        ``int` `sum = prev_max;` `        ``for` `(``int` `i = N - 2; i >= 0; i--) {` `            ``// Maximum of current row.``            ``int` `curr_max = -2147483648;` `            ``for` `(``int` `j = 0; j < N; j++)``                ``if` `(prev_max > a[i, j] && a[i, j] > curr_max)``                    ``curr_max = a[i, j];` `            ``// If we could not an element smaller``            ``// than prev_max.``            ``if` `(curr_max == -2147483648)``                ``return` `-1;` `            ``prev_max = curr_max;``            ``sum += prev_max;``        ``}` `        ``return` `sum;``    ``}` `    ``// Driver Program``    ``public` `static` `void` `Main()``    ``{` `        ``int``[, ] a = { { 1, 2, 3 },``                      ``{ 4, 5, 6 },``                      ``{ 7, 8, 9 } };``        ``Console.WriteLine(getGreatestSum(a));` `        ``int``[, ] b = { { 4, 5, 6 },``                      ``{ 4, 5, 6 },``                      ``{ 4, 5, 6 } };``        ``Console.WriteLine(getGreatestSum(b));``    ``}``}` `// This code is contributed by vt_m.`

## PHP

 `= 0; ``\$i``--)``    ``{` `        ``// Maximum of current row.``        ``\$curr_max` `= PHP_INT_MIN;``        ``for` `( ``\$j` `= 0; ``\$j` `< ``\$N``; ``\$j``++)``            ``if` `(``\$prev_max` `> ``\$a``[``\$i``][``\$j``] ``and``                ``\$a``[``\$i``][``\$j``] > ``\$curr_max``)``                ``\$curr_max` `= ``\$a``[``\$i``][``\$j``];` `        ``// If we could not an element``        ``// smaller than prev_max.``        ``if` `(``\$curr_max` `== PHP_INT_MIN)``            ``return` `-1;` `        ``\$prev_max` `= ``\$curr_max``;``        ``\$sum` `+= ``\$prev_max``;``    ``}``    ``return` `\$sum``;``}` `// Driver code``\$a` `= ``array``(``array``(1, 2, 3),``        ``array``(4, 5, 6),``        ``array``(7, 8, 9));``            ` `echo` `getGreatestSum(``\$a``), ``"\n"``;``\$b` `= ``array``(``array``(4, 5, 6),``        ``array``(4, 5, 6),``        ``array``(4, 5, 6));``            ` `echo` `getGreatestSum(``\$b``), ``"\n"``;` `// This code is contributed by anuj_67.``?>`

## Javascript

 ``

Output :

```18
15```

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 industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up