Maximum sum of elements from each row in the matrix

Last Updated : 13 Dec, 2022

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.

Implementation:

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 get 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# 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

Time complexity: O(N²)
Auxiliary space: O(1)

Types of Asymptotic Notations in Complexity Analysis of Algorithms

Sakshi_Tiwari

Improve

Article Tags :

Practice Tags :

Maximum sum of elements from each row in the matrix

Similar Reads

Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?