# 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 : 12Contiguous Increasing subarray {1, 4, 7} = 12Input : arr[] = {38, 7, 8, 10, 12}Output : 38`
Recommended Practice

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(n2).

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 nLet result be the required sumint 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 ``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

 ``

## PHP

 ` ``\$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 ``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 ``#include ` `// 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

 `= 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 ``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).

Previous
Next