Largest sum contiguous increasing subarray
Last Updated :
22 Aug, 2023
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(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 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++
#include <bits/stdc++.h>
using namespace std;
int largestSum( int arr[], int n)
{
int result = INT_MIN;
for ( int i = 0; i < n; i++) {
int curr_sum = arr[i];
while (i + 1 < n && arr[i + 1] > arr[i]) {
curr_sum += arr[i + 1];
i++;
}
if (curr_sum > result)
result = curr_sum;
}
return result;
}
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
class GFG {
static int largestSum( int arr[], int n)
{
int result = - 9999999 ;
for ( int i = 0 ; i < n; i++) {
int curr_sum = arr[i];
while (i + 1 < n && arr[i + 1 ] > arr[i]) {
curr_sum += arr[i + 1 ];
i++;
}
if (curr_sum > result)
result = curr_sum;
}
return result;
}
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
def largestSum(arr, n):
result = - 2147483648
for i in range (n):
curr_sum = arr[i]
while (i + 1 < n and
arr[i + 1 ] > arr[i]):
curr_sum + = arr[i + 1 ]
i + = 1
if (curr_sum > result):
result = curr_sum
return result
arr = [ 1 , 1 , 4 , 7 , 3 , 6 ]
n = len (arr)
print ( "Largest sum = " , largestSum(arr, n))
|
C#
using System;
class GFG {
static int largestSum( int [] arr, int n)
{
int result = -9999999;
for ( int i = 0; i < n; i++) {
int curr_sum = arr[i];
while (i + 1 < n && arr[i + 1] > arr[i]) {
curr_sum += arr[i + 1];
i++;
}
if (curr_sum > result)
result = curr_sum;
}
return result;
}
public static void Main()
{
int [] arr = { 1, 1, 4, 7, 3, 6 };
int n = arr.Length;
Console.Write( "Largest sum = "
+ largestSum(arr, n));
}
}
|
Javascript
<script>
function largestSum(arr, n)
{
var result = -1000000000;
for ( var i = 0; i < n; i++)
{
var curr_sum = arr[i];
while (i + 1 < n &&
arr[i + 1] > arr[i])
{
curr_sum += arr[i + 1];
i++;
}
if (curr_sum > result)
result = curr_sum;
}
return result;
}
var arr = [1, 1, 4, 7, 3, 6];
var n = arr.length;
document.write( "Largest sum = "
+ largestSum(arr, n));
</script>
|
PHP
<?php
function largestSum( $arr , $n )
{
$INT_MIN = 0;
$result = $INT_MIN ;
for ( $i = 0; $i < $n ; $i ++)
{
$curr_sum = $arr [ $i ];
while ( $i + 1 < $n &&
$arr [ $i + 1] > $arr [ $i ])
{
$curr_sum += $arr [ $i + 1];
$i ++;
}
if ( $curr_sum > $result )
$result = $curr_sum ;
}
return $result ;
}
{
$arr = array (1, 1, 4, 7, 3, 6);
$n = sizeof( $arr ) / sizeof( $arr [0]);
echo "Largest sum = " ,
largestSum( $arr , $n );
return 0;
}
?>
|
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:
- The function “largestSum” takes array “arr” and it size is “n”.
- If “n==1” ,then return arr[0]th element.
- 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]”.
- 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.
- 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;
int largestSum( int arr[], int n)
{
if (n == 1)
return arr[0];
int max_sum = max(largestSum(arr, n - 1), arr[n - 1]);
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 max(max_sum, curr_sum);
}
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;
}
|
C
#include <limits.h>
#include <stdio.h>
int largestSum( int arr[], int n)
{
int result = INT_MIN;
for ( int i = 0; i < n; i++) {
int curr_sum = arr[i];
while (i + 1 < n && arr[i + 1] > arr[i]) {
curr_sum += arr[i + 1];
i++;
}
if (curr_sum > result)
result = curr_sum;
}
return result;
}
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;
}
|
Java
import java.util.*;
public class Main {
public static int largestSum( int arr[], int n)
{
if (n == 1 )
return arr[ 0 ];
int max_sum
= Math.max(largestSum(arr, n - 1 ), arr[n - 1 ]);
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 Math.max(max_sum, curr_sum);
}
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));
}
}
|
Python
def largestSum(arr, n):
if n = = 1 :
return arr[ 0 ]
max_sum = max (largestSum(arr, n - 1 ), arr[n - 1 ])
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 max (max_sum, curr_sum)
arr = [ 1 , 1 , 4 , 7 , 3 , 6 ]
n = len (arr)
print ( "Largest sum =" , largestSum(arr, n))
|
C#
using System;
public static class GFG {
public static int largestSum( int [] arr, int n)
{
if (n == 1)
return arr[0];
int max_sum
= Math.Max(largestSum(arr, n - 1), arr[n - 1]);
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 Math.Max(max_sum, curr_sum);
}
public static void Main()
{
int [] arr = { 1, 1, 4, 7, 3, 6 };
int n = arr.Length;
Console.WriteLine( "Largest sum = "
+ largestSum(arr, n));
}
}
|
Javascript
function largestSum(arr, n) {
if (n == 1)
return arr[0];
let max_sum = Math.max(largestSum(arr, n-1), arr[n-1]);
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 Math.max(max_sum, curr_sum);
}
let arr = [1, 1, 4, 7, 3, 6];
let n = arr.length;
console.log( "Largest sum = " + largestSum(arr, n));
|
PHP
<?php
function largestSum( $arr , $n ) {
if ( $n == 1)
return $arr [0];
$max_sum = max(largestSum( $arr , $n -1), $arr [ $n -1]);
$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 max( $max_sum , $curr_sum );
}
$arr = array (1, 1, 4, 7, 3, 6);
$n = count ( $arr );
echo "Largest sum = " . largestSum( $arr , $n );
?>
|
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:
- Initialize two variables: max_sum and curr_sum to the first element of the array.
- Loop through the array starting from the second element.
- if the current element is greater than the previous element, add it to the curr_sum. Otherwise, reset curr_sum to the current element.
- If curr_sum is greater than max_sum, update max_sum.
- 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;
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));
}
}
|
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))
|
C#
using System;
class GFG {
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;
}
static void Main()
{
int [] arr = { 1, 1, 4, 7, 3, 6 };
int n = arr.Length;
Console.WriteLine(
LargestSumContiguousIncreasingSubarray(arr, n));
}
}
|
Javascript
function LargestSumContiguousIncreasingSubarray(arr, n)
{
let maxSum = arr[0];
let currSum = arr[0];
for (let 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;
}
let arr = [ 1, 1, 4, 7, 3, 6 ];
let n = arr.length;
console.log(LargestSumContiguousIncreasingSubarray(arr, n));
|
Time Complexity: O(n).
Space complexity: O(1).
Share your thoughts in the comments
Please Login to comment...