题目介绍

给定一个数组，求其中最小总和子序列，要求选择的子序列中，每四个连续元素中至少含一个选中。

解题思路

动态规划

根据题意，我们应该尽量选择较小的数来组成子序列。但是又要满足选择的子序列中每四个连续元素中至少含一个选中的要求。因此，可以通过动态规划来解决问题。

我们可以定义一个状态数组 dp，其中 dp[i] 表示以第 i 个元素结尾的子序列中包含的最小数值的和。同时，我们可以定义一个长度为 4 的布尔数组 flag[i]，表示以第 i 个元素结尾的子序列中，是否包含了第 i 个元素。

• 如果 flag[i] 为 true，则说明第 i 个元素必选，那么我们可以转移 dp[i] = dp[i-4] + nums[i]。
• 如果 flag[i] 为 false，则说明第 i 个元素不选，那么我们可以转移 dp[i] = dp[i-1]。

最后，答案即为 dp[n-1]，其中 n 表示数组的长度。

def find_min_sum_sequence(nums):
    n = len(nums)
    dp = [float('inf')] * n  # 初始化状态数组
    flag = [[False]*4 for _ in range(n)]  # 初始化布尔数组

    # 边界条件
    dp[0], dp[1], dp[2], dp[3] = nums[0], nums[1], nums[2], nums[3]
    flag[0][0], flag[1][1], flag[2][2], flag[3][3] = True, True, True, True

    # 动态规划转移
    for i in range(4, n):
        # 当前元素必选
        tmp = dp[i-4] + nums[i]
        if tmp < dp[i]:
            dp[i] = tmp
            flag[i][0] = True

        # 当前元素可选可不选
        tmp = dp[i-1]
        if tmp < dp[i]:
            dp[i] = tmp

        # 更新 flag 数组
        if not flag[i][0]:
            for j in range(1, 4):
                flag[i][j] = flag[i-1][j-1]
        else:
            flag[i][1] = flag[i][2] = flag[i][3] = True

    return dp[n-1]

贪心

除了动态规划之外，我们还可以采用贪心算法进行求解。

首先，我们可以找到每个连续的长度为 4 的子数组中，数值最小的一个数。然后，根据这个数值最小的数，在每个子数组中找到一个位置来保留它。具体来说，我们可以枚举每个数值最小的数，然后根据它的位置来计算出选中该位置的总代价。最后，从这些代价中选择最小的一个即可。

def find_min_sum_sequence(nums):
    n = len(nums)
    nums.append(float('inf'))  # 末尾添加一个极大值，使得最后一个子序列也能被处理

    # 找到每个子序列中数值最小的位置
    min_idx = [0] * n
    for i in range(n-3):
        min_idx[i] = i + nums[i:i+4].index(min(nums[i:i+4]))

    # 枚举每个数值最小的数，并计算选中该位置的总代价
    ans = float('inf')
    for i in range(n):
        cur = i
        cost = 0
        while cur < n:
            cost += nums[cur]
            if cur < n-1:
                cur = min_idx[cur] + 4  # 选择数值最小的位置
            else:
                break

        if cost < ans:
            ans = cost

    return ans

总结

本题需要使用动态规划或者贪心算法进行求解。动态规划需要定义状态数组，并且要考虑如何转移，转移方程中需要判断当前元素选或者不选的情况。贪心算法需要找到每个子数组中数值最小的位置，并且需要枚举数值最小的位置并计算代价。