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++ 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 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 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# 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. |
<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 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. ?> |
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:
- 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:
#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. |
#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. |
/*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. |
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# 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 |
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 // 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 );
?> |
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:
- 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.
#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;
} |
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)
}
} |
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)
|
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 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 |
12
Time Complexity: O(n).
Space complexity: O(1).