Smallest sum contiguous subarray

03 Feb, 2022
Given an array containing n integers. The problem is to find the sum of the elements of the contiguous subarray having the smallest(minimum) sum.Examples:  
Input : arr[] = {3, -4, 2, -3, -1, 7, -5}
Output : -6
Subarray is {-4, 2, -3, -1} = -6

Input : arr = {2, 6, 8, 1, 4}
Output : 1
 
Naive Approach: Consider all the contiguous subarrays of different sizes and find their sum. The subarray having the smallest(minimum) sum is the required answer.Efficient Approach: It is a variation to the problem of finding the largest sum contiguous subarray based on the idea of Kadane’s algorithm. Algorithm:  
smallestSumSubarr(arr, n)
    Initialize min_ending_here = INT_MAX
    Initialize min_so_far = INT_MAX
    
    for i = 0 to n-1
        if min_ending_here > 0
            min_ending_here = arr[i]        
        else
            min_ending_here += arr[i]
        min_so_far = min(min_so_far, min_ending_here)

    return min_so_far
 
C++
Java
Python3
C#
PHP
Javascript
// C++ implementation to find the smallest sum// contiguous subarray#include <bits/stdc++.h> using namespace std; // function to find the smallest sum contiguous subarrayint smallestSumSubarr(int arr[], int n){    // to store the minimum value that is ending    // up to the current index    int min_ending_here = INT_MAX;         // to store the minimum value encountered so far    int min_so_far = INT_MAX;         // traverse the array elements    for (int i=0; i<n; i++)    {        // if min_ending_here > 0, then it could not possibly        // contribute to the minimum sum further        if (min_ending_here > 0)            min_ending_here = arr[i];                 // else add the value arr[i] to min_ending_here           else            min_ending_here += arr[i];                 // update min_so_far        min_so_far = min(min_so_far, min_ending_here);               }         // required smallest sum contiguous subarray value    return min_so_far;}  // Driver program to test aboveint main(){    int arr[] = {3, -4, 2, -3, -1, 7, -5};    int n = sizeof(arr) / sizeof(arr[0]);    cout << "Smallest sum: "         << smallestSumSubarr(arr, n);    return 0;    }
// Java implementation to find the smallest sum// contiguous subarrayclass GFG {         // function to find the smallest sum contiguous    // subarray    static int smallestSumSubarr(int arr[], int n)    {                 // to store the minimum value that is        // ending up to the current index        int min_ending_here = 2147483647;                 // to store the minimum value encountered        // so far        int min_so_far = 2147483647;                 // traverse the array elements        for (int i = 0; i < n; i++)        {                         // if min_ending_here > 0, then it could            // not possibly contribute to the            // minimum sum further            if (min_ending_here > 0)                min_ending_here = arr[i];                         // else add the value arr[i] to            // min_ending_here            else                min_ending_here += arr[i];                         // update min_so_far            min_so_far = Math.min(min_so_far,                                   min_ending_here);                }                 // required smallest sum contiguous        // subarray value        return min_so_far;    }         // Driver method    public static void main(String[] args)    {                 int arr[] = {3, -4, 2, -3, -1, 7, -5};        int n = arr.length;                 System.out.print("Smallest sum: "                + smallestSumSubarr(arr, n));    }} // This code is contributed by Anant Agarwal.
# Python program to find the smallest sum# contiguous subarraymaxsize=int(1e9+7) # function to find the smallest sum# contiguous subarraydef smallestSumSubarr(arr, n):    # to store the minimum value that is ending    # up to the current index    min_ending_here = maxsize         # to store the minimum value encountered so far    min_so_far = maxsize         # traverse the array elements    for i in range(n):        # if min_ending_here > 0, then it could not possibly        # contribute to the minimum sum further        if (min_ending_here > 0):            min_ending_here = arr[i]                 # else add the value arr[i] to min_ending_here        else:            min_ending_here += arr[i]                  # update min_so_far        min_so_far = min(min_so_far, min_ending_here)         # required smallest sum contiguous subarray value    return min_so_far     # Driver codearr = [3, -4, 2, -3, -1, 7, -5]n = len(arr)print ("Smallest sum: ", smallestSumSubarr(arr, n)) # This code is contributed by Sachin Bisht
// C# implementation to find the// smallest sum contiguous subarrayusing System; class GFG {     // function to find the smallest sum    // contiguous subarray    static int smallestSumSubarr(int[] arr, int n)    {        // to store the minimum value that is        // ending up to the current index        int min_ending_here = 2147483647;         // to store the minimum value encountered        // so far        int min_so_far = 2147483647;         // traverse the array elements        for (int i = 0; i < n; i++) {             // if min_ending_here > 0, then it could            // not possibly contribute to the            // minimum sum further            if (min_ending_here > 0)                min_ending_here = arr[i];             // else add the value arr[i] to            // min_ending_here            else                min_ending_here += arr[i];             // update min_so_far            min_so_far = Math.Min(min_so_far,                                min_ending_here);        }         // required smallest sum contiguous        // subarray value        return min_so_far;    }     // Driver method    public static void Main()    {         int[] arr = { 3, -4, 2, -3, -1, 7, -5 };        int n = arr.Length;         Console.Write("Smallest sum: " +             smallestSumSubarr(arr, n));    }} // This code is contributed by Sam007
<?php// PHP implementation to find the// smallest sum contiguous subarray // function to find the smallest// sum contiguous subarrayfunction smallestSumSubarr($arr, $n){         // to store the minimum    // value that is ending    // up to the current index    $min_ending_here = 999999;         // to store the minimum value    // encountered so far    $min_so_far = 999999;         // traverse the array elements    for($i = 0; $i < $n; $i++)    {                 // if min_ending_here > 0,        // then it could not possibly        // contribute to the minimum        // sum further        if ($min_ending_here > 0)            $min_ending_here = $arr[$i];                 // else add the value arr[i]        // to min_ending_here        else            $min_ending_here += $arr[$i];                 // update min_so_far        $min_so_far = min($min_so_far,                     $min_ending_here);            }         // required smallest sum    // contiguous subarray value    return $min_so_far;}      // Driver Code    $arr = array(3, -4, 2, -3, -1, 7, -5);    $n = count($arr) ;    echo "Smallest sum: "         .smallestSumSubarr($arr, $n); // This code is contributed by Sam007?>
<script>     // JavaScript implementation to find the    // smallest sum contiguous subarray         // function to find the smallest sum    // contiguous subarray    function smallestSumSubarr(arr, n)    {        // to store the minimum value that is        // ending up to the current index        let min_ending_here = 2147483647;           // to store the minimum value encountered        // so far        let min_so_far = 2147483647;           // traverse the array elements        for (let i = 0; i < n; i++) {               // if min_ending_here > 0, then it could            // not possibly contribute to the            // minimum sum further            if (min_ending_here > 0)                min_ending_here = arr[i];               // else add the value arr[i] to            // min_ending_here            else                min_ending_here += arr[i];               // update min_so_far            min_so_far = Math.min(min_so_far,                                min_ending_here);        }           // required smallest sum contiguous        // subarray value        return min_so_far;    }         let arr = [ 3, -4, 2, -3, -1, 7, -5 ];    let n = arr.length;     document.write("Smallest sum: " +                  smallestSumSubarr(arr, n));     </script>
Output:  
Smallest sum: -6
Time Complexity: O(n)This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
Sam007
Nikhil.01a
suresh07
amartyaghoshgfg
subarray
subarray-sum
Arrays
Dynamic Programming
Arrays
Dynamic Programming
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Multidimensional Arrays in Java
Maximum and minimum of an array using minimum number of comparisons
Python | Using 2D arrays/lists the right way
Find the smallest positive integer value that cannot be represented as sum of any subset of a given array
Find a triplet that sum to a given value
Program for Fibonacci numbers
0-1 Knapsack Problem | DP-10
Longest Common Subsequence | DP-4
Subset Sum Problem | DP-25
Longest Increasing Subsequence | DP-3