# 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
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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++ implementation to find the smallest sum ` `// contiguous subarray ` `#include ` ` `  `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 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); ` `    ``cout << ``"Smallest sum: "` `         ``<< smallestSumSubarr(arr, n); ` `    ``return` `0;      ` `}  `

 `// 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 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.maxsize ` `     `  `    ``# to store the minimum value encountered so far ` `    ``min_so_far ``=` `sys.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 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# 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 `

 ` 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)

This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.