Largest sum contiguous increasing subarray

Given an array of n positive distinct integers. The problem is to find the largest sum of contiguous increasing subarray in O(n) time complexity.

Examples :

Input : arr[] = {2, 1, 4, 7, 3, 6}
Output : 12
Contiguous Increasing subarray {1, 4, 7} = 12
Input : arr[] = {38, 7, 8, 10, 12}
Output : 38

A simple solution is to generate all subarrays and compute their sums. Finally return the subarray with maximum sum. Time complexity of this solution is O(n²).

An efficient solution is based on the fact that all elements are positive. So we consider longest increasing subarrays and compare their sums. To increasing subarrays cannot overlap, so our time complexity becomes O(n).

Algorithm:

Let arr be the array of size n
Let result be the required sum
int largestSum(arr, n) 
    result = INT_MIN  // Initialize result
    i = 0
    while i < n
        // Find sum of longest increasing subarray
        // starting with i
        curr_sum = arr[i];
    while i+1 < n && arr[i] < arr[i+1]
              curr_sum += arr[i+1];
          i++; 
        // If current sum is greater than current
        // result.
        if result < curr_sum
            result = curr_sum; 
        i++;
    return result

Below is the implementation of above algorithm.

C++

// C++ implementation of largest sum
// contiguous increasing subarray
#include <bits/stdc++.h>
using namespace std;

// Returns sum of longest
// increasing subarray.
int largestSum(int arr[], int n)
{
    // Initialize result
    int result = INT_MIN;

    // Note that i is incremented
    // by inner loop also, so overall
    // time complexity is O(n)
    for (int i = 0; i < n; i++) {
        // Find sum of longest
        // increasing subarray
        // starting from arr[i]
        int curr_sum = arr[i];
        while (i + 1 < n && arr[i + 1] > arr[i]) {
            curr_sum += arr[i + 1];
            i++;
        }

        // Update result if required
        if (curr_sum > result)
            result = curr_sum;
    }

    // required largest sum
    return result;
}

// Driver Code
int main()
{
    int arr[] = { 1, 1, 4, 7, 3, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "Largest sum = " << largestSum(arr, n);
    return 0;
}

Java

// Java implementation of largest sum
// contiguous increasing subarray

class GFG {
    // Returns sum of longest
    // increasing subarray.
    static int largestSum(int arr[], int n)
    {
        // Initialize result
        int result = -9999999;

        // Note that i is incremented
        // by inner loop also, so overall
        // time complexity is O(n)
        for (int i = 0; i < n; i++) {
            // Find sum of longest
            // increasing subarray
            // starting from arr[i]
            int curr_sum = arr[i];
            while (i + 1 < n && arr[i + 1] > arr[i]) {
                curr_sum += arr[i + 1];
                i++;
            }

            // Update result if required
            if (curr_sum > result)
                result = curr_sum;
        }

        // required largest sum
        return result;
    }

    // Driver Code
    public static void main(String[] args)
    {
        int arr[] = { 1, 1, 4, 7, 3, 6 };
        int n = arr.length;
        System.out.println("Largest sum = "
                           + largestSum(arr, n));
    }
}

Python3

# Python3 implementation of largest
# sum contiguous increasing subarray

# Returns sum of longest
# increasing subarray.


def largestSum(arr, n):

    # Initialize result
    result = -2147483648

    # Note that i is incremented
    # by inner loop also, so overall
    # time complexity is O(n)
    for i in range(n):

        # Find sum of longest increasing
        # subarray starting from arr[i]
        curr_sum = arr[i]
        while (i + 1 < n and
               arr[i + 1] > arr[i]):

            curr_sum += arr[i + 1]
            i += 1

        # Update result if required
        if (curr_sum > result):
            result = curr_sum

    # required largest sum
    return result


# Driver Code
arr = [1, 1, 4, 7, 3, 6]
n = len(arr)
print("Largest sum = ", largestSum(arr, n))

# This code is contributed by Anant Agarwal.

C#

// C# implementation of largest sum
// contiguous increasing subarray
using System;

class GFG {

    // Returns sum of longest
    // increasing subarray.
    static int largestSum(int[] arr, int n)
    {

        // Initialize result
        int result = -9999999;

        // Note that i is incremented by
        // inner loop also, so overall
        // time complexity is O(n)
        for (int i = 0; i < n; i++) {

            // Find sum of longest increasing
            // subarray starting from arr[i]
            int curr_sum = arr[i];
            while (i + 1 < n && arr[i + 1] > arr[i]) {
                curr_sum += arr[i + 1];
                i++;
            }

            // Update result if required
            if (curr_sum > result)
                result = curr_sum;
        }

        // required largest sum
        return result;
    }

    // Driver code
    public static void Main()
    {
        int[] arr = { 1, 1, 4, 7, 3, 6 };
        int n = arr.Length;
        Console.Write("Largest sum = "
                      + largestSum(arr, n));
    }
}

// This code is contributed
// by Nitin Mittal.

Javascript

<script>

// Javascript implementation of largest sum
// contiguous increasing subarray

// Returns sum of longest
// increasing subarray.
function largestSum(arr, n)
{
    // Initialize result
    var result = -1000000000;

    // Note that i is incremented
    // by inner loop also, so overall
    // time complexity is O(n)
    for (var i = 0; i < n; i++)
    {
        // Find sum of longest
        // increasing subarray
        // starting from arr[i]
        var curr_sum = arr[i];
        while (i + 1 < n &&
               arr[i + 1] > arr[i])
        {
            curr_sum += arr[i + 1];
            i++;
        }

        // Update result if required
        if (curr_sum > result)
            result = curr_sum;
    }

    // required largest sum
    return result;
}

// Driver Code
var arr = [1, 1, 4, 7, 3, 6];
var n = arr.length;
document.write( "Largest sum = "
      + largestSum(arr, n));

// This code is contributed by itsok.
</script>

PHP

<?php
// PHP implementation of largest sum
// contiguous increasing subarray

// Returns sum of longest
// increasing subarray.
function largestSum($arr, $n)
{
    $INT_MIN = 0;

    // Initialize result
    $result = $INT_MIN;

    // Note that i is incremented
    // by inner loop also, so overall
    // time complexity is O(n)
    for ($i = 0; $i < $n; $i++)
    {
        // Find sum of longest
        // increasing subarray
        // starting from arr[i]
        $curr_sum = $arr[$i];
        while ($i + 1 < $n &&
               $arr[$i + 1] > $arr[$i])
        {
            $curr_sum += $arr[$i + 1];
            $i++;
        }

        // Update result if required
        if ($curr_sum > $result)
            $result = $curr_sum;
    }

    // required largest sum
    return $result;
}

// Driver Code
{
    $arr = array(1, 1, 4, 7, 3, 6);
    $n = sizeof($arr) / sizeof($arr[0]);
    echo "Largest sum = " ,
          largestSum($arr, $n);
    return 0;
}

// This code is contributed by nitin mittal.
?>

Output

Largest sum = 12

Time Complexity : O(n)

Largest sum contiguous increasing subarray Using Recursion: 

Recursive Algorithm to solve this problem:

Here is the step-by-step algorithm of the problem:

1. The function “largestSum” takes array “arr” and it size is “n”.
2. If  “n==1” ,then return arr[0]th element.
3. If “n != 1” , then a recursive call the function “largestSum”   to find the largest sum of the subarray “arr[0…n-1]” excluding the last element “arr[n-1]”.
4.  By iterating over the array in reverse order beginning with the second last element, compute the sum of the increasing subarray ending at “arr[n-1]”. If one element is smaller than the next, it should be added to the current sum. Otherwise, the loop should be broken.
5. Then, return the maximum of the largest sum i.e., ” return max(max_sum, curr_sum);” .
   

Here is the implementation of above algorithm:

C++

#include <bits/stdc++.h>
using namespace std;

// Recursive function to find the largest sum
// of contiguous increasing subarray
int largestSum(int arr[], int n)
{
    // Base case
    if (n == 1)
        return arr[0];

    // Recursive call to find the largest sum
    int max_sum = max(largestSum(arr, n - 1), arr[n - 1]);

    // Compute the sum of the increasing subarray
    int curr_sum = arr[n - 1];
    for (int i = n - 2; i >= 0; i--) {
        if (arr[i] < arr[i + 1])
            curr_sum += arr[i];
        else
            break;
    }

    // Return the maximum of the largest sum so far
    // and the sum of the current increasing subarray
    return max(max_sum, curr_sum);
}

// Driver Code
int main()
{
    int arr[] = { 1, 1, 4, 7, 3, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "Largest sum = " << largestSum(arr, n);
    return 0;
}

// This code is contributed by Vaibhav Saroj.

C

#include <limits.h>
#include <stdio.h>

// Returns sum of longest increasing subarray
int largestSum(int arr[], int n)
{
    // Initialize result
    int result = INT_MIN;

    // Note that i is incremented
    // by inner loop also, so overall
    // time complexity is O(n)
    for (int i = 0; i < n; i++) {
        // Find sum of longest
        // increasing subarray
        // starting from arr[i]
        int curr_sum = arr[i];
        while (i + 1 < n && arr[i + 1] > arr[i]) {
            curr_sum += arr[i + 1];
            i++;
        }

        // Update result if required
        if (curr_sum > result)
            result = curr_sum;
    }

    // required largest sum
    return result;
}

// Driver code
int main()
{
    int arr[] = { 1, 1, 4, 7, 3, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("Largest sum = %d\n", largestSum(arr, n));
    return 0;
}

// This code is contributed by Vaibhav Saroj.

Java

/*package whatever //do not write package name here */
import java.util.*;

public class Main {
    // Recursive function to find the largest sum
    // of contiguous increasing subarray
    public static int largestSum(int arr[], int n)
    {
        // Base case
        if (n == 1)
            return arr[0];

        // Recursive call to find the largest sum
        int max_sum
            = Math.max(largestSum(arr, n - 1), arr[n - 1]);

        // Compute the sum of the increasing subarray
        int curr_sum = arr[n - 1];
        for (int i = n - 2; i >= 0; i--) {
            if (arr[i] < arr[i + 1])
                curr_sum += arr[i];
            else
                break;
        }

        // Return the maximum of the largest sum so far
        // and the sum of the current increasing subarray
        return Math.max(max_sum, curr_sum);
    }

    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 1, 1, 4, 7, 3, 6 };
        int n = arr.length;
        System.out.println("Largest sum = "
                           + largestSum(arr, n));
    }
}

// This code is contributed by Vaibhav Saroj.

Python

def largestSum(arr, n):
    # Base case
    if n == 1:
        return arr[0]

    # Recursive call to find the largest sum
    max_sum = max(largestSum(arr, n-1), arr[n-1])

    # Compute the sum of the increasing subarray
    curr_sum = arr[n-1]
    for i in range(n-2, -1, -1):
        if arr[i] < arr[i+1]:
            curr_sum += arr[i]
        else:
            break

    # Return the maximum of the largest sum so far
    # and the sum of the current increasing subarray
    return max(max_sum, curr_sum)


# Driver code
arr = [1, 1, 4, 7, 3, 6]
n = len(arr)
print("Largest sum =", largestSum(arr, n))

# This code is contributed by Vaibhav Saroj.

C#

// C# program for above approach
using System;

public static class GFG {
    // Recursive function to find the largest sum
    // of contiguous increasing subarray
    public static int largestSum(int[] arr, int n)
    {
        // Base case
        if (n == 1)
            return arr[0];

        // Recursive call to find the largest sum
        int max_sum
            = Math.Max(largestSum(arr, n - 1), arr[n - 1]);

        // Compute the sum of the increasing subarray
        int curr_sum = arr[n - 1];
        for (int i = n - 2; i >= 0; i--) {
            if (arr[i] < arr[i + 1])
                curr_sum += arr[i];
            else
                break;
        }

        // Return the maximum of the largest sum so far
        // and the sum of the current increasing subarray
        return Math.Max(max_sum, curr_sum);
    }

    // Driver code
    public static void Main()
    {
        int[] arr = { 1, 1, 4, 7, 3, 6 };
        int n = arr.Length;
        Console.WriteLine("Largest sum = "
                        + largestSum(arr, n));
    }
}

// This code is contributed by Utkarsh Kumar

Javascript

function largestSum(arr, n) {
  // Base case
  if (n == 1)
    return arr[0];

  // Recursive call to find the largest sum
  let max_sum = Math.max(largestSum(arr, n-1), arr[n-1]);

  // Compute the sum of the increasing subarray
  let curr_sum = arr[n-1];
  for (let i = n-2; i >= 0; i--) {
    if (arr[i] < arr[i+1])
      curr_sum += arr[i];
    else
      break;
  }

  // Return the maximum of the largest sum so far
  // and the sum of the current increasing subarray
  return Math.max(max_sum, curr_sum);
}

// Driver Code
let arr = [1, 1, 4, 7, 3, 6];
let n = arr.length;
console.log("Largest sum = " + largestSum(arr, n));

PHP

<?php

// Recursive function to find the largest sum
// of contiguous increasing subarray
function largestSum($arr, $n) {
    // Base case
    if ($n == 1)
        return $arr[0];

    // Recursive call to find the largest sum
    $max_sum = max(largestSum($arr, $n-1), $arr[$n-1]);

    // Compute the sum of the increasing subarray
    $curr_sum = $arr[$n-1];
    for ($i = $n-2; $i >= 0; $i--) {
        if ($arr[$i] < $arr[$i+1])
            $curr_sum += $arr[$i];
        else
            break;
    }

    // Return the maximum of the largest sum so far
    // and the sum of the current increasing subarray
    return max($max_sum, $curr_sum);
}

// Driver Code
$arr = array(1, 1, 4, 7, 3, 6);
$n = count($arr);
echo "Largest sum = " . largestSum($arr, $n);

?>

Output

Largest sum = 12

Time Complexity: O(n^2).
Space complexity: O(n).

Largest sum contiguous increasing subarray Using  Kadane’s algorithm :-

To get the largest sum subarray, Kadane’s approach is employed, however it presupposes that the array contains both positive and negative values. In this instance, we must change the algorithm so that it only works on contiguous rising subarrays.

The following is how we can modify Kadane’s algorithm to find the largest sum contiguous increasing subarray:

1. Initialize two variables: max_sum and curr_sum to the first element of the array.
2. Loop through the array starting from the second element.
3. if the current element is greater than the previous element, add it to the curr_sum. Otherwise, reset curr_sum to the current element.
4. If curr_sum is greater than max_sum, update max_sum.
5. After the loop, max_sum will contain the largest sum contiguous increasing subarray.
   

C++

#include <iostream>
using namespace std;

int largest_sum_contiguous_increasing_subarray(int arr[], int n) {
    int max_sum = arr[0];
    int curr_sum = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] > arr[i-1]) {
            curr_sum += arr[i];
        }
        else {
            curr_sum = arr[i];
        }
        if (curr_sum > max_sum) {
            max_sum = curr_sum;
        }
    }
    return max_sum;
}

int main() {
    int arr[] = { 1, 1, 4, 7, 3, 6 };
    int n = sizeof(arr)/sizeof(arr[0]);
    cout << largest_sum_contiguous_increasing_subarray(arr, n) << endl; // Output: 44 (1+2+3+5+7+8+9+10)
    return 0;
}

Java

public class Main {
    public static int largestSumContiguousIncreasingSubarray(int[] arr,
                                                             int n) {
        int maxSum = arr[0];
        int currSum = arr[0];
        for (int i = 1; i < n; i++) {
            if (arr[i] > arr[i-1]) {
                currSum += arr[i];
            }
            else {
                currSum = arr[i];
            }
            if (currSum > maxSum) {
                maxSum = currSum;
            }
        }
        return maxSum;
    }

    public static void main(String[] args) {
        int[] arr = { 1, 1, 4, 7, 3, 6 };
        int n = arr.length;
        System.out.println(largestSumContiguousIncreasingSubarray(arr,
                                 n)); // Output: 44 (1+2+3+5+7+8+9+10)
    }
}

Python3

def largest_sum_contiguous_increasing_subarray(arr, n):
    max_sum = arr[0]
    curr_sum = arr[0]
    for i in range(1, n):
        if arr[i] > arr[i-1]:
            curr_sum += arr[i]
        else:
            curr_sum = arr[i]
        if curr_sum > max_sum:
            max_sum = curr_sum
    return max_sum

arr = [1, 1, 4, 7, 3, 6]
n = len(arr)
print(largest_sum_contiguous_increasing_subarray(arr, n)) #output 12 (1+4+7)

C#

using System;

class GFG {
    // Function to find the largest sum of a contiguous
    // increasing subarray
    static int
    LargestSumContiguousIncreasingSubarray(int[] arr, int n)
    {
        int maxSum = arr[0]; // Initialize the maximum sum
                             // and current sum
        int currSum = arr[0];

        for (int i = 1; i < n; i++) {
            if (arr[i]
                > arr[i - 1]) // Check if the current
                              // element is greater than the
                              // previous element
            {
                currSum
                    += arr[i]; // If increasing, add the
                               // element to the current sum
            }
            else {
                currSum
                    = arr[i]; // If not increasing, start a
                              // new increasing subarray
                              // from the current element
            }

            if (currSum
                > maxSum) // Update the maximum sum if the
                          // current sum is greater
            {
                maxSum = currSum;
            }
        }

        return maxSum;
    }

    static void Main()
    {
        int[] arr = { 1, 1, 4, 7, 3, 6 };
        int n = arr.Length;
        Console.WriteLine(
            LargestSumContiguousIncreasingSubarray(arr, n));
    }
}

// This code is contributed by akshitaguprzj3

Javascript

// Javascript code for above approach

    // Function to find the largest sum of a contiguous
    // increasing subarray
    function LargestSumContiguousIncreasingSubarray(arr, n)
    {
        let maxSum = arr[0]; // Initialize the maximum sum
                            // and current sum
        let currSum = arr[0];

        for (let i = 1; i < n; i++) {
            if (arr[i]
                > arr[i - 1]) // Check if the current
                            // element is greater than the
                            // previous element
            {
                currSum
                    += arr[i]; // If increasing, add the
                            // element to the current sum
            }
            else {
                currSum
                    = arr[i]; // If not increasing, start a
                            // new increasing subarray
                            // from the current element
            }

            if (currSum
                > maxSum) // Update the maximum sum if the
                        // current sum is greater
            {
                maxSum = currSum;
            }
        }

        return maxSum;
    }

        let arr = [ 1, 1, 4, 7, 3, 6 ];
        let n = arr.length;
        console.log(LargestSumContiguousIncreasingSubarray(arr, n));


// This code is contributed by Pushpesh Raj

Output

12

Time Complexity: O(n).
Space complexity: O(1).