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 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
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int smallestSumSubarr( int arr[], int n)
{
int min_ending_here = INT_MAX;
int min_so_far = INT_MAX;
for ( int i=0; i<n; i++)
{
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;
}
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
import java.io.*;
class GFG {
static int smallestSumSubarr( int arr[], int n)
{
int min_ending_here = 2147483647 ;
int min_so_far = 2147483647 ;
for ( int i = 0 ; i < n; i++)
{
if (min_ending_here > 0 )
min_ending_here = arr[i];
else
min_ending_here += arr[i];
min_so_far = Math.min(min_so_far,
min_ending_here);
}
return min_so_far;
}
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));
}
}
|
Python3
maxsize = int ( 1e9 + 7 )
def smallestSumSubarr(arr, n):
min_ending_here = maxsize
min_so_far = maxsize
for i in range (n):
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
arr = [ 3 , - 4 , 2 , - 3 , - 1 , 7 , - 5 ]
n = len (arr)
print ( "Smallest sum: " , smallestSumSubarr(arr, n))
|
C#
using System;
class GFG {
static int smallestSumSubarr( int [] arr, int n)
{
int min_ending_here = 2147483647;
int min_so_far = 2147483647;
for ( int i = 0; i < n; i++) {
if (min_ending_here > 0)
min_ending_here = arr[i];
else
min_ending_here += arr[i];
min_so_far = Math.Min(min_so_far,
min_ending_here);
}
return min_so_far;
}
public static void Main()
{
int [] arr = { 3, -4, 2, -3, -1, 7, -5 };
int n = arr.Length;
Console.Write( "Smallest sum: " +
smallestSumSubarr(arr, n));
}
}
|
Javascript
<script>
function smallestSumSubarr(arr, n)
{
let min_ending_here = 2147483647;
let min_so_far = 2147483647;
for (let i = 0; i < n; i++) {
if (min_ending_here > 0)
min_ending_here = arr[i];
else
min_ending_here += arr[i];
min_so_far = Math.min(min_so_far,
min_ending_here);
}
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>
|
PHP
<?php
function smallestSumSubarr( $arr , $n )
{
$min_ending_here = 999999;
$min_so_far = 999999;
for ( $i = 0; $i < $n ; $i ++)
{
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 ;
}
$arr = array (3, -4, 2, -3, -1, 7, -5);
$n = count ( $arr ) ;
echo "Smallest sum: "
.smallestSumSubarr( $arr , $n );
?>
|
Time Complexity: O(n)
Auxiliary Space: O(1)
New Approach:- Here, Another approach to solve this problem is to use a prefix sum array. The prefix sum array is an auxiliary array that stores the sum of all the elements up to a certain index in the original array. We can use this prefix sum array to find the smallest sum contiguous subarray by finding the minimum difference between two prefix sum elements.
Algorithm:
smallestSumSubarr(arr, n)
Initialize prefixSum array with 0 at index 0
for i = 1 to n
prefixSum[i] = prefixSum[i-1] + arr[i-1]
Initialize min_sum = INT_MAX
for i = 0 to n-1
for j = i+1 to n
min_sum = min(min_sum, prefixSum[j] - prefixSum[i])
return min_sum
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int smallestSumSubarr( int arr[], int n)
{
int prefixSum[n + 1];
prefixSum[0] = 0;
for ( int i = 1; i <= n; i++) {
prefixSum[i] = prefixSum[i - 1] + arr[i - 1];
}
int min_sum = INT_MAX;
for ( int i = 0; i < n; i++) {
for ( int j = i + 1; j <= n; j++) {
min_sum
= min(min_sum, prefixSum[j] - prefixSum[i]);
}
}
return min_sum;
}
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
import java.util.Arrays;
public class Main {
public static int smallestSumSubarr( int [] arr, int n) {
int [] prefixSum = new int [n + 1 ];
prefixSum[ 0 ] = 0 ;
for ( int i = 1 ; i <= n; i++) {
prefixSum[i] = prefixSum[i - 1 ] + arr[i - 1 ];
}
int min_sum = Integer.MAX_VALUE;
for ( int i = 0 ; i < n; i++) {
for ( int j = i + 1 ; j <= n; j++) {
min_sum = Math.min(min_sum, prefixSum[j] - prefixSum[i]);
}
}
return min_sum;
}
public static void main(String[] args) {
int [] arr = { 3 , - 4 , 2 , - 3 , - 1 , 7 , - 5 };
int n = arr.length;
System.out.println( "Smallest sum: " + smallestSumSubarr(arr, n));
}
}
|
Python3
def smallestSumSubarr(arr, n):
prefixSum = [ 0 ] * (n + 1 )
prefixSum[ 0 ] = 0
for i in range ( 1 , n + 1 ):
prefixSum[i] = prefixSum[i - 1 ] + arr[i - 1 ]
min_sum = float ( 'inf' )
for i in range (n):
for j in range (i + 1 , n + 1 ):
min_sum = min (min_sum, prefixSum[j] - prefixSum[i])
return min_sum
arr = [ 3 , - 4 , 2 , - 3 , - 1 , 7 , - 5 ]
n = len (arr)
print ( "Smallest sum:" , smallestSumSubarr(arr, n))
|
C#
using System;
class GFG {
static int smallestSumSubarr( int [] arr, int n)
{
int [] prefixSum= new int [n+1];
prefixSum[0] = 0;
for ( int i = 1; i <= n; i++) {
prefixSum[i] = prefixSum[i - 1] + arr[i - 1];
}
int min_sum = 2147483647;
for ( int i = 0; i < n; i++) {
for ( int j = i + 1; j <= n; j++) {
min_sum
= Math.Min(min_sum, prefixSum[j] - prefixSum[i]);
}
}
return min_sum;
}
public static void Main()
{
int [] arr = { 3, -4, 2, -3, -1, 7, -5 };
int n = arr.Length;
Console.Write( "Smallest sum: " +
smallestSumSubarr(arr, n));
}
}
|
Javascript
function smallestSumSubarr(arr, n) {
let prefixSum = new Array(n + 1);
prefixSum[0] = 0;
for (let i = 1; i <= n; i++) {
prefixSum[i] = prefixSum[i - 1] + arr[i - 1];
}
let min_sum = Infinity;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j <= n; j++) {
min_sum = Math.min(min_sum, prefixSum[j] - prefixSum[i]);
}
}
return min_sum;
}
let arr = [3, -4, 2, -3, -1, 7, -5];
let n = arr.length;
console.log( "Smallest sum: " + smallestSumSubarr(arr, n));
|
Output:-
Smallest sum: -6
Time Complexity: O(n^2)
Auxiliary Space: O(n)
Last Updated :
27 Jul, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...