Largest Sum Contiguous Subarray

05 Jul, 2022
Write an efficient program to find the sum of the contiguous subarray within a one-dimensional array of numbers that has the largest sum. 
 
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
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++
Java
Python
C#
PHP
Javascript
// C++ program to print largest contiguous array sum#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;}  /*Driver program to test maxSubArraySum*/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;}
import java.io.*;// Java program to print largest contiguous array sumimport 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 program to find maximum contiguous subarray   # Function to find the maximum contiguous subarrayfrom sys import maxintdef 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   # Driver function to check the above function   a = [-2, -3, 4, -1, -2, 1, 5, -3]  print "Maximum contiguous sum is", maxSubArraySum(a,len(a))   #This code is contributed by _Devesh Agrawal_
// C# program to print largest // contiguous array sumusing 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;    }          // Driver code     public static void Main ()    {        int [] a = {-2, -3, 4, -1, -2, 1, 5, -3};        Console.Write("Maximum contiguous sum is " +                                maxSubArraySum(a));    }  }  // This code is contributed by Sam007_
<?php// PHP program to print largest// contiguous array sum  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;}  // Driver code$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;  // This code is contributed by anuj_67.?>
<script>  // JavaScript program to find maximum // contiguous subarray   // Function to find the maximum // contiguous subarrayfunction 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}   // Driver codevar a = [ -2, -3, 4, -1, -2, 1, 5, -3 ]document.write("Maximum contiguous sum is",                maxSubArraySum(a, a.length))   // This code is contributed by AnkThon  </script>
Maximum contiguous sum is 7
Time Complexity: O(n)Auxiliary Space: O(1)
Another approach:
C++
Java
Python
C#
PHP
Javascript
int maxSubarraySum(int arr[], int size){    int max_ending_here = 0, max_so_far = INT_MIN;    for (int i = 0; i < size; i++) {                // include current element to previous subarray only        // when it can add to a bigger number than itself.        if (arr[i] <= max_ending_here + arr[i]) {            max_ending_here += arr[i];        }                // Else start the max subarray from current element        else {            max_ending_here = arr[i];        }        if (max_ending_here > max_so_far)            max_so_far = max_ending_here;    }    return max_so_far;} // contributed by Vipul Raj
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;                   /* Do not compare for all           elements. Compare only            when max_ending_here > 0 */        else if (max_so_far < max_ending_here)             max_so_far = max_ending_here;               }     return max_so_far; }   // This code is contributed by ANKITRAI1
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                  # Do not compare for all elements. Compare only           # when  max_ending_here > 0        elif (max_so_far < max_ending_here):            max_so_far = max_ending_here                  return max_so_far
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;          /* Do not compare for all        elements. Compare only        when max_ending_here > 0 */        else if (max_so_far < max_ending_here)            max_so_far = max_ending_here;    }    return max_so_far;}  // This code is contributed// by ChitraNayal
<?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;      /* Do not compare for all elements.        Compare only when max_ending_here > 0 */    else if ($max_so_far < $max_ending_here)        $max_so_far = $max_ending_here;}return $max_so_far;  // This code is contributed// by ChitraNayal?>
<script>        // JavaScript Program to implement        // the above approach          function maxSubarraySum(arr, size)        {            let max_ending_here = 0, max_so_far = Number.MIN_VALUE;            for (let i = 0; i < size; i++) {                  // include current element to previous subarray only                // when it can add to a bigger number than itself.                if (arr[i] <= max_ending_here + arr[i]) {                    max_ending_here += arr[i];                }                  // Else start the max subarray from current element                else {                    max_ending_here = arr[i];                }                if (max_ending_here > max_so_far) {                    max_so_far = max_ending_here;                }            }            return max_so_far;        }          // This code is contributed by Potta Lokesh    </script>
Algorithmic Paradigm: Dynamic ProgrammingFollowing is another simple implementation suggested by Mohit Kumar. The implementation handles the case when all numbers in the array are negative. 
C++
Java
Python
C#
PHP
Javascript
#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;}  /* Driver program to test maxSubArraySum */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 program to print largest contiguous// array sumimport 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;    }      /* Driver program to test maxSubArraySum */    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);    }}  // This code is contributed by Prerna Saini
# Python program to find maximum contiguous subarray  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  # Driver function to check the above function a = [-2, -3, 4, -1, -2, 1, 5, -3]print"Maximum contiguous sum is" , maxSubArraySum(a,len(a))  #This code is contributed by _Devesh Agrawal_
// C# program to print largest // contiguous array sumusing 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;    }      // Driver code     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));    }  }  // This code is contributed by Sam007_
<?phpfunction 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;}  // Driver Code$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;  // This code is contributed // by Akanksha Rai(Abby_akku)?>
<script>// C# program to print largest // contiguous array sum  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;}  // Driver code   let a = [-2, -3, 4, -1, -2, 1, 5, -3];let n = a.length; document.write("Maximum contiguous sum is ",maxSubArraySum(a, n));      </script>
Maximum 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++
Java
Python3
C#
PHP
Javascript
// C++ program to print largest contiguous array sum#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;}  /*Driver program to test maxSubArraySum*/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 program to print largest // contiguous array sumclass 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);    }      // Driver code    public static void main(String[] args)    {        int a[] = { -2, -3, 4, -1, -2, 1, 5, -3 };        int n = a.length;        maxSubArraySum(a, n);    }}  // This code is contributed by  prerna saini
# Python program to print largest contiguous array sum  from sys import maxsize  # Function to find the maximum contiguous subarray# and print its starting and end indexdef 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))  # Driver program to test maxSubArraySuma = [-2, -3, 4, -1, -2, 1, 5, -3]maxSubArraySum(a,len(a))
// C# program to print largest // contiguous array sumusing 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);    }      // Driver code    public static void Main()    {        int []a = {-2, -3, 4, -1,                    -2, 1, 5, -3};        int n = a.Length;        maxSubArraySum(a, n);    }}  // This code is contributed// by anuj_67.
<?php // PHP program to print largest // contiguous array sum  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";}  // Driver Code$a = array(-2, -3, 4, -1, -2, 1, 5, -3);$n = sizeof($a);$max_sum = maxSubArraySum($a, $n);  // This code is contributed// by ChitraNayal?>
<script>// javascript program to print largest // contiguous array sum    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);    }      // Driver code              var a = [ -2, -3, 4, -1, -2, 1, 5, -3 ];        var n = a.length;        maxSubArraySum(a, n);  // This code is contributed by Rajput-Ji </script>
Maximum 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.
vt_m
ankthon
Akanksha_Rai
ukasp
ankurchaudhary627
subhammahato348
vipul995
mohit kumar 29
surinderdawra388
Rajput-Ji
lokeshpotta20
as5853535
misrapratyush20080
surindertarika1234
simmytarika5
nguyenhoangtam
pranjaypoddar
parthsahu95
o1613051
tarakki100
akashish__
24*7 Innovation Labs
Accolite
Amazon
Amazon-Question
D-E-Shaw
FactSet
Flipkart
Hike
Housing.com
MakeMyTrip
MetLife
Microsoft
Morgan Stanley
Ola Cabs
Oracle
OYO Rooms
Payu
Samsung
Snapdeal
subarray
subarray-sum
Teradata
Visa
Visa-Question
VMWare
Walmart
Zoho
Arrays
Dynamic Programming
VMWare
Zoho
Flipkart
Morgan Stanley
Accolite
Amazon
Microsoft
OYO Rooms
Samsung
Snapdeal
24*7 Innovation Labs
D-E-Shaw
FactSet
Hike
Housing.com
MakeMyTrip
MetLife
Ola Cabs
Oracle
Payu
Teradata
Visa
Walmart
Arrays
Dynamic Programming
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.