给定两个序列X={x1,x2,…,xm}和Y={y1,y2,…,yn}，求所有最长公共子序列。

这是一个经典的问题，可以使用动态规划来解决。

首先定义一个二维数组dp，其中dp[i][j]表示序列X的前i个元素和序列Y的前j个元素的最长公共子序列的长度。

然后，我们可以考虑状态转移方程：

当xi=yj时，dp[i][j] = dp[i-1][j-1] + 1，即当前位置的最长公共子序列长度等于左上角位置的最长公共子序列长度加1。

当xi≠yj时，dp[i][j] = max(dp[i-1][j], dp[i][j-1])，即当前位置的最长公共子序列长度等于上方位置和左方位置的最长公共子序列长度的最大值。

最后，我们可以通过回溯的方式，得到所有的最长公共子序列。

具体实现可以参考以下代码：

def find_lcs(X, Y):
    m, n = len(X), len(Y)
    dp = [[0] * (n+1) for _ in range(m+1)]
    for i in range(1, m+1):
        for j in range(1, n+1):
            if X[i-1] == Y[j-1]:
                dp[i][j] = dp[i-1][j-1] + 1
            else:
                dp[i][j] = max(dp[i-1][j], dp[i][j-1])
    lcs_len = dp[m][n]
    res = []
    def backtrack(i, j, lcs):
        nonlocal res
        if lcs == lcs_len:
            res.append(list(reversed(lcs)))
            return
        if X[i-1] == Y[j-1]:
            lcs.append(X[i-1])
            backtrack(i-1, j-1, lcs)
            lcs.pop()
        else:
            if dp[i-1][j] >= dp[i][j-1]:
                backtrack(i-1, j, lcs)
            if dp[i][j-1] >= dp[i-1][j]:
                backtrack(i, j-1, lcs)
    backtrack(m, n, [])
    return res

时间复杂度为O(mn)，空间复杂度为O(mn)。