Write an efficient program to find the sum of the contiguous subarray within a one-dimensional array of numbers that has the largest sum.
Kadane’s Algorithm:
Initialize:
max_so_far = INT_MIN
max_ending_here = 0
Loop for each element of the array
(a) max_ending_here = max_ending_here + a[i]
(b) if(max_so_far < max_ending_here)
max_so_far = max_ending_here
(c) if(max_ending_here < 0)
max_ending_here = 0
return max_so_far
Explanation:
The simple idea of Kadane’s algorithm is to look for all positive contiguous segments of the array (max_ending_here is used for this). And keep track of the maximum sum contiguous segment among all positive segments (max_so_far is used for this). Each time we get a positive-sum compare it with max_so_far and update max_so_far if it is greater than max_so_far

Lets take the example:
{-2, -3, 4, -1, -2, 1, 5, -3}
max_so_far = INT_MIN
max_ending_here = 0
for i=0, a[0] = -2
max_ending_here = max_ending_here + (-2)
Set max_ending_here = 0 because max_ending_here < 0
and set max_so_far = -2
for i=1, a[1] = -3
max_ending_here = max_ending_here + (-3)
Since max_ending_here = -3 and max_so_far = -2, max_so_far will remain -2
Set max_ending_here = 0 because max_ending_here < 0
for i=2, a[2] = 4
max_ending_here = max_ending_here + (4)
max_ending_here = 4
max_so_far is updated to 4 because max_ending_here greater
than max_so_far which was -2 till now
for i=3, a[3] = -1
max_ending_here = max_ending_here + (-1)
max_ending_here = 3
for i=4, a[4] = -2
max_ending_here = max_ending_here + (-2)
max_ending_here = 1
for i=5, a[5] = 1
max_ending_here = max_ending_here + (1)
max_ending_here = 2
for i=6, a[6] = 5
max_ending_here = max_ending_here + (5)
max_ending_here = 7
max_so_far is updated to 7 because max_ending_here is
greater than max_so_far
for i=7, a[7] = -3
max_ending_here = max_ending_here + (-3)
max_ending_here = 4
Note: The above algorithm only works if and only if at least one positive number should be present otherwise it does not work i.e if an Array contains all negative numbers it doesn’t work.
Program:
C++
#include<iostream>
#include<climits>
using namespace std;
int maxSubArraySum( int a[], int size)
{
int max_so_far = INT_MIN, max_ending_here = 0;
for ( int i = 0; i < size; i++)
{
max_ending_here = max_ending_here + a[i];
if (max_so_far < max_ending_here)
max_so_far = max_ending_here;
if (max_ending_here < 0)
max_ending_here = 0;
}
return max_so_far;
}
int main()
{
int a[] = {-2, -3, 4, -1, -2, 1, 5, -3};
int n = sizeof (a)/ sizeof (a[0]);
int max_sum = maxSubArraySum(a, n);
cout << "Maximum contiguous sum is " << max_sum;
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class Kadane
{
public static void main (String[] args)
{
int [] a = {- 2 , - 3 , 4 , - 1 , - 2 , 1 , 5 , - 3 };
System.out.println( "Maximum contiguous sum is " +
maxSubArraySum(a));
}
static int maxSubArraySum( int a[])
{
int size = a.length;
int max_so_far = Integer.MIN_VALUE, max_ending_here = 0 ;
for ( int i = 0 ; i < size; i++)
{
max_ending_here = max_ending_here + a[i];
if (max_so_far < max_ending_here)
max_so_far = max_ending_here;
if (max_ending_here < 0 )
max_ending_here = 0 ;
}
return max_so_far;
}
}
|
Python
from sys import maxint
def maxSubArraySum(a,size):
max_so_far = - maxint - 1
max_ending_here = 0
for i in range ( 0 , size):
max_ending_here = max_ending_here + a[i]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if max_ending_here < 0 :
max_ending_here = 0
return max_so_far
a = [ - 2 , - 3 , 4 , - 1 , - 2 , 1 , 5 , - 3 ]
print "Maximum contiguous sum is" , maxSubArraySum(a, len (a))
|
C#
using System;
class GFG
{
static int maxSubArraySum( int []a)
{
int size = a.Length;
int max_so_far = int .MinValue,
max_ending_here = 0;
for ( int i = 0; i < size; i++)
{
max_ending_here = max_ending_here + a[i];
if (max_so_far < max_ending_here)
max_so_far = max_ending_here;
if (max_ending_here < 0)
max_ending_here = 0;
}
return max_so_far;
}
public static void Main ()
{
int [] a = {-2, -3, 4, -1, -2, 1, 5, -3};
Console.Write( "Maximum contiguous sum is " +
maxSubArraySum(a));
}
}
|
PHP
<?php
function maxSubArraySum( $a , $size )
{
$max_so_far = PHP_INT_MIN;
$max_ending_here = 0;
for ( $i = 0; $i < $size ; $i ++)
{
$max_ending_here = $max_ending_here + $a [ $i ];
if ( $max_so_far < $max_ending_here )
$max_so_far = $max_ending_here ;
if ( $max_ending_here < 0)
$max_ending_here = 0;
}
return $max_so_far ;
}
$a = array (-2, -3, 4, -1,
-2, 1, 5, -3);
$n = count ( $a );
$max_sum = maxSubArraySum( $a , $n );
echo "Maximum contiguous sum is " ,
$max_sum ;
?>
|
Javascript
<script>
function maxSubArraySum(a, size)
{
var maxint = Math.pow(2, 53)
var max_so_far = -maxint - 1
var max_ending_here = 0
for ( var i = 0; i < size; i++)
{
max_ending_here = max_ending_here + a[i]
if (max_so_far < max_ending_here)
max_so_far = max_ending_here
if (max_ending_here < 0)
max_ending_here = 0
}
return max_so_far
}
var a = [ -2, -3, 4, -1, -2, 1, 5, -3 ]
document.write( "Maximum contiguous sum is" ,
maxSubArraySum(a, a.length))
</script>
|
OutputMaximum contiguous sum is 7
Time Complexity: O(n)
Auxiliary Space: O(1)
Another approach:
C++
int maxSubarraySum( int arr[], int size)
{
int max_ending_here = 0, max_so_far = INT_MIN;
for ( int i = 0; i < size; i++) {
if (arr[i] <= max_ending_here + arr[i]) {
max_ending_here += arr[i];
}
else {
max_ending_here = arr[i];
}
if (max_ending_here > max_so_far)
max_so_far = max_ending_here;
}
return max_so_far;
}
|
Java
static int maxSubArraySum( int a[], int size)
{
int max_so_far = a[ 0 ], max_ending_here = 0 ;
for ( int i = 0 ; i < size; i++)
{
max_ending_here = max_ending_here + a[i];
if (max_ending_here < 0 )
max_ending_here = 0 ;
else if (max_so_far < max_ending_here)
max_so_far = max_ending_here;
}
return max_so_far;
}
|
Python
def maxSubArraySum(a,size):
max_so_far = a[ 0 ]
max_ending_here = 0
for i in range ( 0 , size):
max_ending_here = max_ending_here + a[i]
if max_ending_here < 0 :
max_ending_here = 0
elif (max_so_far < max_ending_here):
max_so_far = max_ending_here
return max_so_far
|
C#
static int maxSubArraySum( int [] a, int size)
{
int max_so_far = a[0], max_ending_here = 0;
for ( int i = 0; i < size; i++) {
max_ending_here = max_ending_here + a[i];
if (max_ending_here < 0)
max_ending_here = 0;
else if (max_so_far < max_ending_here)
max_so_far = max_ending_here;
}
return max_so_far;
}
|
PHP
<?php
function maxSubArraySum(& $a , $size )
{
$max_so_far = $a [0];
$max_ending_here = 0;
for ( $i = 0; $i < $size ; $i ++)
{
$max_ending_here = $max_ending_here + $a [ $i ];
if ( $max_ending_here < 0)
$max_ending_here = 0;
else if ( $max_so_far < $max_ending_here )
$max_so_far = $max_ending_here ;
}
return $max_so_far ;
?>
|
Javascript
<script>
function maxSubarraySum(arr, size)
{
let max_ending_here = 0, max_so_far = Number.MIN_VALUE;
for (let i = 0; i < size; i++) {
if (arr[i] <= max_ending_here + arr[i]) {
max_ending_here += arr[i];
}
else {
max_ending_here = arr[i];
}
if (max_ending_here > max_so_far) {
max_so_far = max_ending_here;
}
}
return max_so_far;
}
</script>
|
Algorithmic Paradigm: Dynamic Programming
Following is another simple implementation suggested by Mohit Kumar. The implementation handles the case when all numbers in the array are negative.
C++
#include<iostream>
using namespace std;
int maxSubArraySum( int a[], int size)
{
int max_so_far = a[0];
int curr_max = a[0];
for ( int i = 1; i < size; i++)
{
curr_max = max(a[i], curr_max+a[i]);
max_so_far = max(max_so_far, curr_max);
}
return max_so_far;
}
int main()
{
int a[] = {-2, -3, 4, -1, -2, 1, 5, -3};
int n = sizeof (a)/ sizeof (a[0]);
int max_sum = maxSubArraySum(a, n);
cout << "Maximum contiguous sum is " << max_sum;
return 0;
}
|
Java
import java.io.*;
class GFG {
static int maxSubArraySum( int a[], int size)
{
int max_so_far = a[ 0 ];
int curr_max = a[ 0 ];
for ( int i = 1 ; i < size; i++)
{
curr_max = Math.max(a[i], curr_max+a[i]);
max_so_far = Math.max(max_so_far, curr_max);
}
return max_so_far;
}
public static void main(String[] args)
{
int a[] = {- 2 , - 3 , 4 , - 1 , - 2 , 1 , 5 , - 3 };
int n = a.length;
int max_sum = maxSubArraySum(a, n);
System.out.println( "Maximum contiguous sum is "
+ max_sum);
}
}
|
Python
def maxSubArraySum(a,size):
max_so_far = a[ 0 ]
curr_max = a[ 0 ]
for i in range ( 1 ,size):
curr_max = max (a[i], curr_max + a[i])
max_so_far = max (max_so_far,curr_max)
return max_so_far
a = [ - 2 , - 3 , 4 , - 1 , - 2 , 1 , 5 , - 3 ]
print "Maximum contiguous sum is" , maxSubArraySum(a, len (a))
|
C#
using System;
class GFG
{
static int maxSubArraySum( int []a, int size)
{
int max_so_far = a[0];
int curr_max = a[0];
for ( int i = 1; i < size; i++)
{
curr_max = Math.Max(a[i], curr_max+a[i]);
max_so_far = Math.Max(max_so_far, curr_max);
}
return max_so_far;
}
public static void Main ()
{
int []a = {-2, -3, 4, -1, -2, 1, 5, -3};
int n = a.Length;
Console.Write( "Maximum contiguous sum is "
+ maxSubArraySum(a, n));
}
}
|
PHP
<?php
function maxSubArraySum( $a , $size )
{
$max_so_far = $a [0];
$curr_max = $a [0];
for ( $i = 1; $i < $size ; $i ++)
{
$curr_max = max( $a [ $i ],
$curr_max + $a [ $i ]);
$max_so_far = max( $max_so_far ,
$curr_max );
}
return $max_so_far ;
}
$a = array (-2, -3, 4, -1,
-2, 1, 5, -3);
$n = sizeof( $a );
$max_sum = maxSubArraySum( $a , $n );
echo "Maximum contiguous sum is " .
$max_sum ;
?>
|
Javascript
<script>
function maxSubArraySum(a,size)
{
let max_so_far = a[0];
let curr_max = a[0];
for (let i = 1; i < size; i++)
{
curr_max = Math.max(a[i], curr_max+a[i]);
max_so_far = Math.max(max_so_far, curr_max);
}
return max_so_far;
}
let a = [-2, -3, 4, -1, -2, 1, 5, -3];
let n = a.length;
document.write( "Maximum contiguous sum is " ,maxSubArraySum(a, n));
</script>
|
OutputMaximum contiguous sum is 7
Time complexity: O(n), where n is the size of the array.
Auxiliary Space: O(1)
To print the subarray with the maximum sum, we maintain indices whenever we get the maximum sum.
C++
#include<iostream>
#include<climits>
using namespace std;
int maxSubArraySum( int a[], int size)
{
int max_so_far = INT_MIN, max_ending_here = 0,
start =0, end = 0, s=0;
for ( int i=0; i< size; i++ )
{
max_ending_here += a[i];
if (max_so_far < max_ending_here)
{
max_so_far = max_ending_here;
start = s;
end = i;
}
if (max_ending_here < 0)
{
max_ending_here = 0;
s = i + 1;
}
}
cout << "Maximum contiguous sum is "
<< max_so_far << endl;
cout << "Starting index " << start
<< endl << "Ending index " << end << endl;
}
int main()
{
int a[] = {-2, -3, 4, -1, -2, 1, 5, -3};
int n = sizeof (a)/ sizeof (a[0]);
int max_sum = maxSubArraySum(a, n);
return 0;
}
|
Java
class GFG {
static void maxSubArraySum( int a[], int size)
{
int max_so_far = Integer.MIN_VALUE,
max_ending_here = 0 ,start = 0 ,
end = 0 , s = 0 ;
for ( int i = 0 ; i < size; i++)
{
max_ending_here += a[i];
if (max_so_far < max_ending_here)
{
max_so_far = max_ending_here;
start = s;
end = i;
}
if (max_ending_here < 0 )
{
max_ending_here = 0 ;
s = i + 1 ;
}
}
System.out.println( "Maximum contiguous sum is "
+ max_so_far);
System.out.println( "Starting index " + start);
System.out.println( "Ending index " + end);
}
public static void main(String[] args)
{
int a[] = { - 2 , - 3 , 4 , - 1 , - 2 , 1 , 5 , - 3 };
int n = a.length;
maxSubArraySum(a, n);
}
}
|
Python3
from sys import maxsize
def maxSubArraySum(a,size):
max_so_far = - maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range ( 0 ,size):
max_ending_here + = a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0 :
max_ending_here = 0
s = i + 1
print ( "Maximum contiguous sum is %d" % (max_so_far))
print ( "Starting Index %d" % (start))
print ( "Ending Index %d" % (end))
a = [ - 2 , - 3 , 4 , - 1 , - 2 , 1 , 5 , - 3 ]
maxSubArraySum(a, len (a))
|
C#
using System;
class GFG
{
static void maxSubArraySum( int []a,
int size)
{
int max_so_far = int .MinValue,
max_ending_here = 0, start = 0,
end = 0, s = 0;
for ( int i = 0; i < size; i++)
{
max_ending_here += a[i];
if (max_so_far < max_ending_here)
{
max_so_far = max_ending_here;
start = s;
end = i;
}
if (max_ending_here < 0)
{
max_ending_here = 0;
s = i + 1;
}
}
Console.WriteLine( "Maximum contiguous " +
"sum is " + max_so_far);
Console.WriteLine( "Starting index " +
start);
Console.WriteLine( "Ending index " +
end);
}
public static void Main()
{
int []a = {-2, -3, 4, -1,
-2, 1, 5, -3};
int n = a.Length;
maxSubArraySum(a, n);
}
}
|
PHP
<?php
function maxSubArraySum( $a , $size )
{
$max_so_far = PHP_INT_MIN;
$max_ending_here = 0;
$start = 0;
$end = 0;
$s = 0;
for ( $i = 0; $i < $size ; $i ++)
{
$max_ending_here += $a [ $i ];
if ( $max_so_far < $max_ending_here )
{
$max_so_far = $max_ending_here ;
$start = $s ;
$end = $i ;
}
if ( $max_ending_here < 0)
{
$max_ending_here = 0;
$s = $i + 1;
}
}
echo "Maximum contiguous sum is " .
$max_so_far . "\n" ;
echo "Starting index " . $start . "\n" .
"Ending index " . $end . "\n" ;
}
$a = array (-2, -3, 4, -1, -2, 1, 5, -3);
$n = sizeof( $a );
$max_sum = maxSubArraySum( $a , $n );
?>
|
Javascript
<script>
function maxSubArraySum(a , size) {
var max_so_far = Number.MIN_VALUE, max_ending_here = 0, start = 0, end = 0, s = 0;
for (i = 0; i < size; i++) {
max_ending_here += a[i];
if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
start = s;
end = i;
}
if (max_ending_here < 0) {
max_ending_here = 0;
s = i + 1;
}
}
document.write( "Maximum contiguous sum is " + max_so_far);
document.write( "<br/>Starting index " + start);
document.write( "<br/>Ending index " + end);
}
var a = [ -2, -3, 4, -1, -2, 1, 5, -3 ];
var n = a.length;
maxSubArraySum(a, n);
</script>
|
OutputMaximum contiguous sum is 7
Starting index 2
Ending index 6
Kadane’s Algorithm can be viewed both as greedy and DP. As we can see that we are keeping a running sum of integers and when it becomes less than 0, we reset it to 0 (Greedy Part). This is because continuing with a negative sum is way worse than restarting with a new range. Now it can also be viewed as a DP, at each stage we have 2 choices: Either take the current element and continue with the previous sum OR restart a new range. Both choices are being taken care of in the implementation.
Time Complexity: O(n)
Auxiliary Space: O(1)
Now try the below question
Given an array of integers (possibly some elements negative), write a C program to find out the *maximum product* possible by multiplying ‘n’ consecutive integers in the array where n ≤ ARRAY_SIZE. Also, print the starting point of the maximum product subarray.
Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above.