总和正好为 K 的最短子序列

在求解算法问题中，有时候需要找到一个满足条件的子序列，而且这个子序列要满足某个特定条件，例如，总和等于 K。我们称这种问题为“总和正好为 K 的最短子序列”问题。

问题描述

给定一个非空的整数序列和一个整数 K，找到这个整数序列中的一个非空子序列，使得该子序列的总和正好等于 K。如果不存在这样的子序列，则返回一个空列表。

为了使时间复杂度尽可能地小，我们要求找到最短的满足条件的子序列。

解决方法

一种简单的方法是暴力枚举所有可能的子序列，然后找出总和正好为 K 的子序列中长度最小的一个子序列。但是，这种方法的时间复杂度为 $O(2^n)$，对于较长的序列来说，无法接受。

我们可以用动态规划来解决这个问题，时间复杂度为 $O(nK)$。具体来说，我们可以维护一个二维数组 dp，其中 dp[i][j] 表示前 i 个数中，总和正好为 j 的最短子序列的长度。则有如下的状态转移方程：

$$ dp[i][j] = \begin{cases} 0 & j = 0 \ 1 & i = 1 \text{ and } j = nums[0] \ dp[i-1][j] & j < nums[i-1] \ \min(dp[i-1][j], dp[i-1][j-nums[i-1]]+1) & j \ge nums[i-1] \ \end{cases} $$

其中，nums 表示给定的整数序列。

最终的解，就是 dp[n][K]，即前 n 个数中，总和正好为 K 的最短子序列的长度。

代码实现

以下是用 Python 语言实现上述算法的代码片段：

def shortestSubsequence(nums: List[int], K: int) -> List[int]:
    n = len(nums)
    dp = [[0] * (K+1) for _ in range(n+1)]
    for i in range(1, n+1):
        for j in range(1, K+1):
            if j == nums[i-1]:
                dp[i][j] = 1
            elif j < nums[i-1]:
                dp[i][j] = dp[i-1][j]
            else:
                left = dp[i-1][j]
                right = dp[i-1][j-nums[i-1]] + 1
                if left == 0 or right == 0:
                    dp[i][j] = max(left, right)
                else:
                    dp[i][j] = min(left, right)
    if dp[n][K] == 0:
        return []
    result = []
    i, j = n, K
    while i > 0 and j > 0:
        if dp[i][j] == dp[i-1][j]:
            i -= 1
        else:
            result.append(nums[i-1])
            j -= nums[i-1]
            i -= 1
    return result[::-1]

其中，nums 表示输入的整数序列，K 表示要求的总和，函数的返回值是一个列表，表示最短子序列。如果找不到满足条件的子序列，则返回一个空列表。