Tutorialspoint.dev

Smallest sum contiguous subarray

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 diiferent 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++

// C++ implementation to find the smallest sum
// contiguous subarray
#include <bits/stdc++.h>
  
using namespace std;
  
// function to find the smallest sum contiguous subarray
int 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 above
int 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

// Java implementation to find the smallest sum
// contiguous subarray
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(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

# Python program to find the smallest sum
# contiguous subarray
import sys
  
# function to find the smallest sum 
# contiguous subarray
def smallestSumSubarr(arr, n):
    # to store the minimum value that is ending
    # up to the current index
    min_ending_here = sys.maxint
      
    # to store the minimum value encountered so far
    min_so_far = sys.maxint
      
    # 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 code
arr = [3, -4, 2, -3, -1, 7, -5]
n = len(arr)
print "Smallest sum: ", smallestSumSubarr(arr, n)
  
# This code is contributed by Sachin Bisht

C#

// C# implementation to find the 
// smallest sum contiguous subarray
using 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
// PHP 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
    $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
?>


Output:

Smallest sum: -6

Time Complexity: O(n)

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



This article is attributed to GeeksforGeeks.org

leave a comment

code

0 Comments

load comments

Subscribe to Our Newsletter