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

// C# program to find minimum sum subsequence
// of an array such that one of every four
// consecutive elements is picked.
using System;

class GFG {

    // Returns sum of minimum sum subsequence
    // such that one of every four consecutive
    // elements is picked from arr[].
    static int minSum(int[] arr, int n)
    {
        // dp[i] is going to store minimum sum
        // subsequence 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]
        int[] dp = new int[n];

        // If there is single value, we get the
        // minimum sum equal to arr[0]
        if (n == 1)
            return arr[0];

        // If there are two values, we get the
        // minimum sum equal to the minimum of
        // two values
        if (n == 2)
            return Math.Min(arr[0], arr[1]);

        // If there are three values, return
        // minimum of the three elements of
        // array
        if (n == 3)
            return Math.Min(arr[0], Math.Min(arr[1], arr[2]));

        // If there are four values, return minimum
        // of the four elements of array
        if (n == 4)
            return Math.Min(Math.Min(arr[0], arr[1]),
                            Math.Min(arr[2], arr[3]));

        dp[0] = arr[0];
        dp[1] = arr[1];
        dp[2] = arr[2];
        dp[3] = arr[3];

        for (int i = 4; i < n; i++)
            dp[i] = arr[i] + Math.Min(Math.Min(dp[i - 1], dp[i - 2]), 
                             Math.Min(dp[i - 3], dp[i - 4]));

        // Return the minimum of last 4 index
        return Math.Min(Math.Min(dp[n - 1], dp[n - 2]),
                        Math.Min(dp[n - 4], dp[n - 3]));
    }

    // Driver code
    static public void Main()
    {
        int[] arr = { 1, 2, 3, 3, 4, 5, 6, 1 };
        int n = arr.Length;
        Console.WriteLine(minSum(arr, n));
    }
}

// This code is contributed by vt_m.

// C# program to calculate
// minimum possible sum for given constraint
using System;
using System.Linq;

class GFG 
{

// function to calculate min sum using dp
static int minSum(int []ar, int n)
{
    // if elements are less than or equal to 4
    if (n <= 4)
        return ar.Min();

    // save start four element as it is
    int []sum = new int[n];
    sum[0] = ar[0];
    sum[1] = ar[1];
    sum[2] = ar[2];
    sum[3] = ar[3];
    int []tempArr;
    
    // compute sum[] for all rest elements
    for (int i = 4; i < n; i++)
    {
        //sum[i] = ar[i] + (*min_element(sum + i - 4, sum + i));
        tempArr = new int[4];
        Array.Copy(sum, i - 4, tempArr, 0, 4);
        sum[i] = ar[i] + tempArr.Min();
    }
    
    // Since one of the last 4 elements must be
    // present
    tempArr = new int[4];
    Array.Copy(sum,n-4,tempArr,0,4);
    return tempArr.Min();
}

// Driver Code
public static void Main(String[] args)
{
    int []ar = { 2, 4, 1, 5, 2, 3, 6, 1, 2, 4 };
    int n = ar.Length;
    Console.WriteLine("Minimum sum = " + 
                         minSum(ar, n));
}
}

// This code is contributed by Rajput-Ji

using System;
class GFG
{
    // Returns sum of minimum sum subsequence
    // such that one of every four consecutive
    // elements is picked from arr[].
    static int MinSum(int[] arr, int n)
    {
        // If there is a single value, we get the
        // minimum sum equal to arr[0]
        if (n == 1)
            return arr[0];
        // If there are two values, we get the
        // minimum sum equal to the minimum of
        // two values
        if (n == 2)
            return Math.Min(arr[0], arr[1]);
        // If there are three values, return
        // the minimum of the three elements of
        // the array
        if (n == 3)
            return Math.Min(arr[0], Math.Min(arr[1], arr[2]));
        // If there are four values, return the minimum
        // of the four elements of the array
        if (n == 4)
            return Math.Min(Math.Min(arr[0], arr[1]),
                            Math.Min(arr[2], arr[3]));
        // Initialize variables to store the minimum sum
        // subsequences for the previous four elements
        int prev1 = arr[0];
        int prev2 = arr[1];
        int prev3 = arr[2];
        int prev4 = arr[3];
        for (int i = 4; i < n; i++)
        {
            // Calculate the minimum sum subsequence for
            // the current element by taking the minimum of
            // the previous four elements and adding the
            // current element
            int current = arr[i] + Math.Min(Math.Min(prev1, prev2),Math.Min(prev3, prev4));
            // Update the variables for the next iteration
            prev1 = prev2;
            prev2 = prev3;
            prev3 = prev4;
            prev4 = current;
        }
        // Return the minimum of the last four elements
        return Math.Min(Math.Min(prev1, prev2),
                        Math.Min(prev3, prev4));
    }
    // Driver code
    static void Main()
    {
        int[] arr = { 1, 2, 3, 3, 4, 5, 6, 1 };
        int n = arr.Length;
        Console.WriteLine("Minimum sum = " + MinSum(arr, n));
    }
}