Shortest Sum Contiguous Subarray

Subarray is basically a part of an array or it is an array within another array. Subarray contains contiguous elements whereas the supersequence does not contain the contiguous elements. Here, we will find the sum of the contiguous subarray which is minimum.

Suppose we have given an array containing 'n' integers. The main aim is to find the sum of the elements of the contiguous array which is minimum.

Let's understand through some examples.

Example 1:

arr = {3, 2, 5, 5, 3, 2, 10}
Number of elements in the array is 7.
The smallest sum of the contiguous subarray: 2

Example 2:

arr = {-4, 5, -1, -6, 8}
Number of elements in the array is 5
The smallest sum of the contiguous subarray: -7

There are multiple techniques to solve this problem. The first solution to this problem is brute force approach. In this approach, we find all the possible arrays and then search for the subarray which has the minimum sum.

Algorithm of brute force

min = ∞
for (int i=0; i<n; i++) 
{
   int sum;
   for (int j=i; j<n;j++)
   {
       sum = sum+b[j];
   }
if(sum < min)
{
   min = sum;
}
}
return min;

The above algorithm generates the time complexity of O(n²). The time complexity is high so we will use another approach to solve the problem. We will use Kaden's algorithm to solve the problem.

Algorithm for the efficient approach

minimum_sum = INFINITY
sum = 0
for i in 1 to size_of_array:
sum = min(array[i], array[i] + sum)
minimum_sum = min(ans, sum)
print(minimum_sum)

The time complexity of the above algorithm is O(n). It is the best possible time complexity because we need to go the elements only once.

Implementation in C

#include <stdio.h>
#include <limits.h>
// Find the minimum sum subarray of a given size `k`
void minimum_subarray(int arr[], int n, int k)
{
    // base case
    if (n == 0 || n <= k) {
        return;
    } 
    // stores the sum of elements in the current sum
    int current_sum = 0;
    // stores the sum of minimum sum subarray found so far
    int minimum_sum = INT_MAX;
    // stores ending index of the minimum sum subarray found so far
    int last = 0; 
    for (int i = 0; i < n; i++)
    {
        // add the current element to the current_sum
        current_sum += arr[i];        
        if (i + 1 >= k)
        {
            // update the minimum sum with a current sum value
            if (minimum_sum > current_sum)
            {
                minimum_sum = current_sum;
                last = i;
            }
            // remove a leftmost element from the array
            current_sum -= arr[i + 1 - k];
        }
    }
    printf("The minimum sum subarray is (%d, %d)", last - k + 1, last);
}
int main(void)
{
    int arr[] = { 10, 4, 2, 5, 6, 3, 8, 1 };
    int k = 3; 
    int n = sizeof(arr)/sizeof(arr[0]);
   minimum_subarray(arr, n, k);
    return 0;
}

Output