给一个正整数数组nums，再给一个正整数X，求数组中相加和等于X的子序列，子序列不要求连续，不要求顺序。请用动态规划写代码实现

这是一个经典的背包问题，可以使用动态规划来解决。具体来说，我们可以定义一个二维数组`dp`，其中`dp[i][j]`表示在前`i`个元素中能否找到一个子序列使得其和为`j`。那么对于每个元素，我们有两种选择，即加入子序列或不加入子序列，因此可以使用以下状态转移方程：

dp[i][j] = dp[i-1][j] or dp[i-1][j-nums[i-1]]

其中，`dp[i-1][j]`表示不加入第`i`个元素的情况，`dp[i-1][j-nums[i-1]]`表示加入第`i`个元素的情况。最终，如果`dp[n][target]`为`True`，则说明能找到一个子序列使得其和为`target`。

以下是Python代码实现：

def find_subsequence(nums, target):
    n = len(nums)
    dp = [[False] * (target + 1) for _ in range(n + 1)]
    for i in range(n + 1):
        dp[i][0] = True
    
    for i in range(1, n + 1):
        for j in range(1, target + 1):
            dp[i][j] = dp[i-1][j]
            if j >= nums[i-1]:
                dp[i][j] = dp[i][j] or dp[i-1][j-nums[i-1]]
    
    res = []
    if dp[n][target]:
        i, j = n, target
        while i > 0 and j > 0:
            if dp[i-1][j]:
                i -= 1
            else:
                res.append(nums[i-1])
                j -= nums[i-1]
                i -= 1
    return res

在上述代码中，`n`表示数组的长度，`dp`为动态规划数组，初始化时将`dp[i][0]`都设置为`True`。接着，使用两层循环来遍历数组元素和目标值，根据状态转移方程更新`dp`数组。最后，如果`dp[n][target]`为`True`，则说明能找到一个子序列使得其和为`target`，此时通过回溯法来找出符合条件的子序列。

调用上述函数可以得到一个符合条件的子序列列表，例如：

nums = [1, 2, 3, 4, 5]
target = 7
res = find_subsequence(nums, target)
print(res)  # output: [2, 5]

这个例子中，数组`nums`中有一个子序列的和等于7，即[2, 5]。