长度为K且给定总和的唯一子序列

当需要从一个序列中选出长度为K的子序列，并且这个子序列的所有元素之和等于给定的总和时，可以使用搜索、动态规划等算法进行解决。

暴力搜索

暴力搜索是一种直接遍历所有可能情况的算法。具体实现步骤如下：

1. 从第一个数字开始，枚举选出的第一个数字的位置。
2. 在之后的数字中，枚举选出的第二个数字的位置。
3. 以此类推，直到选出K个数字为止。
4. 对选出的数字求和，判断其是否等于给定的总和。
5. 如果相等，则记录下这个序列，并继续搜索后面的序列；如果不相等，则直接舍弃。
6. 最后，将所有记录的序列返回。

该算法每次需要枚举序列中的所有元素，所以时间复杂度为 $O(n^k)$，其中n是序列的长度，k是选出的子序列的长度。

动态规划

在暴力搜索的基础上，可以使用动态规划进行优化。具体实现步骤如下：

1. 定义一个二维数组dp，其中dp[i][j]表示在序列的前i个数字中，选出长度为j的子序列，其元素之和等于给定总和时，所能取得的所有可能的子序列。
2. 初始化dp数组，当j=1时，dp[i][j]等于序列中第i个数字的值；当i=j时，dp[i][j]等于前i个数字中选出的所有数字之和；当i<j时，dp[i][j]等于空序列。
3. 逐步填充dp数组，对于每个dp[i][j]，分别考虑两种情况：
   • 包含序列中的第i个数字，此时dp[i][j]可以由dp[i-1][j-1]加上序列中第i个数字得到。
   • 不包含序列中的第i个数字，此时dp[i][j]可以由dp[i-1][j]得到。
4. 最终，dp[n][k]中保存的就是所有元素之和等于给定总和的长度为k的子序列。

该算法每次只需要填充一半的dp数组，时间复杂度为 $O(nk)$。

代码实现

暴力搜索

def find_subsequence(nums, s, k):
    res = []
    n = len(nums)
    def dfs(start, cur):
        nonlocal res
        if len(cur) == k and sum(cur) == s:
            res.append(cur[:])
            return
        if start >= n or len(cur) >= k or sum(cur) + sum(nums[start:]) < s:
            return
        dfs(start+1, cur)
        cur.append(nums[start])
        dfs(start+1, cur)
        cur.pop()
    dfs(0, [])
    return res

动态规划

def find_subsequence(nums, s, k):
    n = len(nums)
    dp = [[[] for _ in range(k+1)] for _ in range(n+1)]
    for i in range(1, n+1):
        dp[i][1] = [[nums[i-1]]]
        for j in range(2, min(i, k)+1):
            for seq in dp[i-1][j]:
                dp[i][j].append(seq)
            for seq in dp[i-1][j-1]:
                if sum(seq) + nums[i-1] <= s:
                    dp[i][j].append(seq + [nums[i-1]])
    return dp[n][k]