Skip to content
Related Articles

Related Articles

Maximum sum of elements from each row in the matrix

View Discussion
Improve Article
Save Article
Like Article
  • 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 <bits/stdc++.h>
#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[3][3] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
    cout << getGreatestSum(a) << endl;
    int b[3][3] = { { 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




<?php
// PHP Program to find
// row-wise maximum element
// sum considering elements
// in increasing order.
 
$N = 3;
 
// Function to perform given task
function getGreatestSum( $a)
{
    global $N;
     
    // Getting the maximum
    // element from last row
    $prev_max = 0;
 
    for ($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
    $sum = $prev_max;
    for ($i = $N - 2; $i >= 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




<script>
 
// JavaScript Program to find row-wise maximum
// element sum considering elements in
// increasing orderers
 
let N = 3;
   
    // Function to perform given task
    function getGreatestSum(a)
    {
   
        // Getting the maximum element from
        // last row
        let prev_max = 0;
   
        for (let 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
        let sum = prev_max;
   
        for (let i = N - 2; i >= 0; i--) {
   
            // Maximum of current row.
            let curr_max = -2147483648;
   
            for (let 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 Code
 
        let a = [[ 1, 2, 3 ],
                      [ 4, 5, 6 ],
                      [ 7, 8, 9 ]];
        document.write(getGreatestSum(a) + "<br/>");
   
        let b = [[ 4, 5, 6 ],
                      [ 4, 5, 6 ],
                      [4, 5, 6 ]];
        document.write(getGreatestSum(b));
        
</script>

Output : 

18
15

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!