Minimum sum subsequence such that at least one of every four consecutive elements is picked

Given an array arr[] of positive integers. The task is to find minimum sum subsequence from the array such that at least one value among all groups of four consecutive elements is picked. 

Examples :  

Input: arr[] = {1, 2, 3, 4, 5, 6, 7, 8}
Output: 6
6 is sum of output subsequence {1, 5}
Note that we have following subarrays of four
consecutive elements
{(1, 2, 3, 4), 
 (2, 3, 4, 5),
 (3, 4, 5, 6)
 (4, 5, 6, 7)
 (5, 6, 7, 8)}
Our subsequence {1, 5} has an element from
all above groups of four consecutive elements.
And this subsequence is minimum sum such
subsequence.
Input : arr[] = {1, 2, 3, 3, 4, 5, 6, 1}
Output : 4
The subsequence is {3, 1}. Here we consider
second three.
Input: arr[] = {1, 2, 3, 2, 1}
Output: 2
The subsequence can be {1, 1} or {2}
Input: arr[] = {6, 7, 8}
Output: 6
Input: arr[] = {6, 7}
Output: 6

The idea is similar to LIS problem. We store minimum sum subsequence ending with every element of arr[]. We finally return minimum of last four values.

dp[i] stores minimum sum subsequence (with at least
one of every four consecutive elements) of arr[0..i] 
such that arr[i] is part of the solution. Note that 
this may not be the best solution for subarray
arr[0..i].
We can recursively compute dp[i] using below formula
dp[i] = arr[i] + min(dp[i-1], dp[i-2], dp[i-3], dp[i-4])
Finally we return minimum of dp[n-1], dp[n-2], 
dp[n-4] and dp[n-3]
OR 
///Idea is simple store values of first 4 numbers in four variables 
let arr[] = {5,6,7,8,9}
a=5;
b=6;
c=7;
d=8;
now Imagine if size is only five then what are  the possible sets we can have?
{5,6,7,8} and {6,7,8,9}
if you can simply analyse these both the first three numbers in set two are common and 
the first number in set 1 is  different and last number in set 2 is also different
now what is the minimum sum we can have 
 (min(6,7,8) ,(5+9) ) why minimum of (6,7,8) because they are common 
 why (5+9) because we have to choose one element each from both sets ;
 
 This is code implementation 
class Solution{
    public:
    int minSum(int arr[], int n){
        //Write your code here
        if(n<=4)
            return *min_element(arr, arr+n);
        int a, b, c, d, e, ans;
        a = arr[0];
        b = arr[1];
        c = arr[2];
        d = arr[3];
        for(int i=4; i<n; i++){
            e = arr[i] + min({a, b, c, d});
            a = b;
            b = c;
            c = d;
            d = e;
        }
        return min({a, b, c, d, e});
    }
};
copied from :chessnoobdj;
///

Below is the implementation of above idea.

4

Time Complexity: O(n)
Auxiliary Space: O(n)

Alternate Solution : 

First of all, think that we have only four elements then our result is at least four given elements. Now, in the case, if we have more than four elements then we must maintain an array sum[] where sum[i] includes the possible minimal sum up to i-th element and also i-th element must be a part of the solution. 

While computing sum[i], our base condition is that arr[i] must be a part of sum[i] and then we must have an element from last four elements. So, we can recursively compute sum[i] as sum of arr[i] and minimum (sum[i-1], sum[i-2], sum[i-3], sum[i-4]). Since there are overlapping subproblems in the recursive structure of our problem, we can use Dynamic Programming to solve this problem. And for the final result we must compute minimum of last four values of sum[] array as result must contain an element from last four elements. 

Minimum sum = 4

Time Complexity: O(n)
Auxiliary Space: O(n)

Efficient approach : Space Optimization O(1)

To optimize the space complexity of the above approach we will using variables only, we can use four variables to keep track of the minimum sum subsequence for the previous four elements.

Implementation Steps:

• Implement the minSum function that takes an integer array arr and its size n as parameters.
• Handle the base cases for n equals 1, 2, 3, and 4 by returning the minimum values from the array.
• Initialize four variables (prev1, prev2, prev3, and prev4) with the first four elements of the array.
• Iterate from index 4 to n-1 and calculate the minimum sum subsequence for each element. Update the prev1, prev2, prev3, and prev4 variables in each iteration.
• After the loop, return the minimum value among the last four elements: min(min(prev1, prev2), min(prev3, prev4)).

Implementation:

Output

Minimum sum = 4

Time Complexity: O(n)
Auxiliary Space: O(1)

Thanks to Shivam Pradhan for providing this alternate solution.
This article is contributed by Roshni Agarwal. If you like neveropen 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 neveropen main page and help other Geeks.