# 5 Best Ways to Find the Minimum Sum Subsequence from Consecutive Triplets in Python

π‘ Problem Formulation: This article aims to address the challenge of finding the minimum sum subsequence from an array where at least one element must be chosen from every three consecutive elements. For instance, given an input like `[1, 2, 3, 4, 5, 6]`, a desired output would be `10`, since the sum of the subsequence `[1, 4, 5]` is the minimum achievable by following the stated rule.

## Method 1: Dynamic Programming

This method involves using dynamic programming to keep track of the minimum sum achievable at each step while considering the constraint. The function will maintain a table to store the best possible sum for the first `i` elements with considering each group of three consecutive elements.

Here’s an example:

```def min_sum_subsequence(arr):
n = len(arr)
if n == 0: return 0
if n <= 3: return min(arr)
dp = [0] * n
dp[0], dp[1], dp[2] = arr[0], arr[1], arr[2]
for i in range(3, n):
dp[i] = arr[i] + min(dp[i-1], dp[i-2], dp[i-3])
return min(dp[-1], dp[-2], dp[-3])

# Example usage
print(min_sum_subsequence([1,2,3,4,5,6]))```

The output is:

`10`

The function `min_sum_subsequence` maintains a list `dp` where each element `dp[i]` represents the minimum sum we can get by taking an element from the subarray ending at index `i`. At the end, the function returns the minimum of the last three elements in the `dp` array, which gives us the answer for the whole array.

## Method 2: Recursive Approach

In the recursive approach, the problem is broken down into smaller sub-problems. A helper function recursively calculates the minimum sum by considering three possible choices for each group of three consecutive elements. This method has exponential time complexity due to the overlapping sub-problems solved multiple times.

Here’s an example:

```def min_sum_helper(arr, i):
if i < 0: return 0
if i < 3: return min(arr[:i+1])
return arr[i] + min(min_sum_helper(arr, i-1),
min_sum_helper(arr, i-2),
min_sum_helper(arr, i-3))

def min_sum_subsequence(arr):
return min_sum_helper(arr, len(arr) - 1)

# Example usage
print(min_sum_subsequence([1,2,3,4,5,6]))```

The output is:

`10`

This example defines a recursive helper function `min_sum_helper` that takes the array and an index `i` as input and calculates the minimum sum until that index by choosing at least one element from every three consecutive elements. The method is then initialized with the recursive function call starting from the last index of the input array.

## Method 3: Greedy Approach

Using a greedy approach to solve this problem involves making the local optimal choice at each step. For every consecutive triple, one would pick the minimum value to be part of the subsequence. This method can fall short if the local optimum does not lead to a global optimum, but under the given constraints, it serves well.

Here’s an example:

```def min_sum_subsequence(arr):
return sum(min(arr[i:i+3]) for i in range(0, len(arr), 3))

# Example usage
print(min_sum_subsequence([1,2,3,4,5,6]))```

The output is:

`9`

The function `min_sum_subsequence` calculates the sum of the chosen elements by picking the smallest number out of every three consecutive elements in a given list. However, since the function moves by skipping two elements after picking one, this greedy approach does not guarantee the overall minimum subsequence sum, as it doesn’t account for overlaps between triplets.

## Bonus One-Liner Method 4: Advanced List Comprehension

This advanced list comprehension method also employs a greedy strategy but does so in a compressed and elegant manner. It serves as a quick way to write an algorithm that, while not optimal for all cases, performs the sequence summing in a single line of code.

Here’s an example:

`print(sum(min(arr[i:i+3]) for i in range(0, len(arr), 3)))`

The output is:

`9`

This one-liner code snippet takes advantage of Python’s list comprehension and range slicing to compute the sum of the minimum elements from every three consecutive elements. Though slick and concise, this method faces the same limitations as the previous greedy approach, potentially overlooking the optimal global solution.

## Summary/Discussion

• Method 1: Dynamic Programming. Ensures an optimal solution. It can be less efficient for very large arrays due to the use of additional memory for the `dp` array.
• Method 2: Recursive Approach. It’s easy to understand and implement. However, it is not efficient for large arrays due to its exponential time complexity without memoization.
• Method 3: Greedy Approach. It’s the simplest and fastest for smaller arrays. Not always optimal as it doesn’t consider that greedy choices might not lead to an overall minimum sum.
• Method 4: Advanced List Comprehension. This is a concise and expression-based solution. Shares the same limitation as Method 3, where it may not provide an optimal sum for certain sequences.