Skip to content
Related Articles

Related Articles

Improve Article

Maximum sum obtained by dividing Array into several subarrays as per given conditions

  • Difficulty Level : Basic
  • Last Updated : 06 Jul, 2021

Given an array arr[] of size N, the task is to calculate the maximum sum that can be obtained by dividing the array into several subarrays(possibly one), where each subarray starting at index i and ending at index j (j>=i) contributes arr[j]-arr[i] to the sum.

Examples:

Input: arr[]= {1, 5, 3}, N=3
Output: 
4
Explanation: The array can be divided into 2 subarrays:

  • {1, 5} -> sum contributed by the subarray = 5-1 = 4
  • {3} -> sum contributed by the subarray = 3-3 = 0

Therefore, the answer is 4.(It can be shown that there is no other way of dividing this array in multiple subarrays such that the answer is greater than 4).

Input: arr[] = {6, 2, 1}, N=3
Output:
0



Naive Approach: The naive approach is to consider all possible ways of dividing arr into 1 or more subarrays and calculating the maximum sum obtained for each.

Time Complexity: O(N*2N)
Auxiliary Space: O(1)

Observation: The observations necessary to solve the problem are below:

  1. The array should be divided into several(possibly one) subarrays such that each subarray is the longest increasing subarray. For example, if arr[]={3,5,7,9,1}, it is optimal to consider {3,5,7,9} as a subarray as it would contribute 9-3=6 to the sum. Breaking it up further decreases the sum which is not optimal.
  2. Every element of a non-increasing subarray should be considered as single element subarrays so that they contribute 0 to the sum. Otherwise, they would be contributing a negative value. For example, if arr[i]>arr[i+1], it is optimal to consider two subarrays of length 1 containing arr[i] and arr[i+1] separately, so that they contribute (arr[i]-arr[i]) +(arr[i+1]-arr[i+1]) =0 to the answer. If they were considered together, they would contribute arr[i+1]-arr[i] which is a negative number, thus decreasing the sum.

Efficient Approach: Follow the steps below to solve the problem:

  1. Initialize a variable Sum to 0.
  2. Traverse arr from 1 to N-1, using the variable i, and do the following:
    1. If arr[i]>arr[i-1], add arr[i]-arr[i-1] to Sum. This works because the sum of differences of adjacent elements in a sorted array is equal to the difference of the elements at extreme ends. Here, only the increasing subarrays are considered as arr[i]>arr[i-1].

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the required answer
int maximumSum(int arr[], int N)
{
    // Stores maximum sum
    int Sum = 0;
    for (int i = 1; i < N; i++) {
 
        // Adding the difference of elements at ends of
        // increasing subarray to the answer
        if (arr[i] > arr[i - 1])
            Sum += (arr[i] - arr[i - 1]);
    }
    return Sum;
}
// Driver Code
int main()
{
    // Input
    int arr[] = { 1, 5, 3 };
    int N = (sizeof(arr) / (sizeof(arr[0])));
 
    // Functio calling
    cout << maximumSum(arr, N);
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
 
class GFG{
     
// Function to find the required answer
public static int maximumSum(int arr[], int N)
{
     
    // Stores maximum sum
    int Sum = 0;
    for(int i = 1; i < N; i++)
    {
         
        // Adding the difference of elements at ends
        // of increasing subarray to the answer
        if (arr[i] > arr[i - 1])
            Sum += (arr[i] - arr[i - 1]);
    }
    return Sum;
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Input
    int arr[] = { 1, 5, 3 };
    int N = arr.length;
 
    // Function calling
    System.out.println(maximumSum(arr, N));
}
}
 
// This code is contributed by Potta Lokesh

Python3




# Python program for the above approach
 
# Function to find the required answer
def maximumSum(arr, N):
   
    # Stores maximum sum
    Sum = 0;
    for i in range(1,N):
       
        # Adding the difference of elements at ends of
        # increasing subarray to the answer
        if (arr[i] > arr[i - 1]):
            Sum += (arr[i] - arr[i - 1])
     
    return Sum;
     
# Driver Code
 
#Input
arr = [ 1, 5, 3 ];
N = len(arr)
 
# Functio calling
print(maximumSum(arr, N));
 
# This code is contributed by SoumikMondal

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to find the required answer
static int maximumSum(int []arr, int N)
{
     
    // Stores maximum sum
    int Sum = 0;
    for(int i = 1; i < N; i++)
    {
         
        // Adding the difference of elements at
        // ends of increasing subarray to the answer
        if (arr[i] > arr[i - 1])
            Sum += (arr[i] - arr[i - 1]);
    }
    return Sum;
}
 
// Driver Code
public static void Main()
{
     
    // Input
    int []arr = { 1, 5, 3 };
    int N = arr.Length;
 
    // Functio calling
    Console.Write(maximumSum(arr, N));
}
}
 
// This code is contributed by SURENDRA_GANGWAR

Javascript




<script>
 
// JavaScript program for the above approach
 
// Function to find the required answer
function maximumSum(arr, N)
{
     
    // Stores maximum sum
    let Sum = 0;
    for(let i = 1; i < N; i++)
    {
         
        // Adding the difference of elements at ends
        // of increasing subarray to the answer
        if (arr[i] > arr[i - 1])
            Sum += (arr[i] - arr[i - 1]);
    }
    return Sum;
}
 
// Driver Code
 
// Input
let arr = [ 1, 5, 3 ];
let N = arr.length;
 
// Function calling
document.write(maximumSum(arr, N));
 
// This code is contributed by Potta Lokesh
 
</script>
Output
4

Time Complexity: O(N)
Auxiliary Space: O(1)

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :