Algorithm 动态规划-具有3个序列，并找到最大值

这个问题需要一些帮助

到目前为止，我提出的解决方案是：

把B当作输入，然后向后看，取B的最后一个值，从后面看A，找到与B匹配的东西。然后取B的第一个值，从前面看A，找到与B匹配的第一个值。保存这两个值

然后在2个上限和下限之间进行比较，找出任何大于第一步中找到的值。使其满足要求。因此，在B=（x，y）问题中给出的例子中，x必须在y之前，所以即使有最大的x，但在最后一个y之后，我们也不能选择它

我相信它会在O（MxN）时间内运行，但我非常不确定，这就是为什么我问你们

---

谢谢你们的时间，希望你们能帮助我

您的解决方案听起来根本不像动态规划

这个问题基本上要求找到一个最大和，其中公共子序列在

a

和

B

之间，和来自

p

应该可以针对您的问题调整LCS解决方案。由于必须从代码> P<／代码>中求和，考虑经典的回溯算法，一旦生成了 LCS矩阵，就得到实际的LCS：

backtrack(LCS, A, B, i, j):
    if i == 0 or j == 0
        return ""

    if A[i] == B[j]:
        return backtrack(LCS, A, B, i-1, j-1) + A[i]
    else if LCS[i-1, j] > LCS[i, j-1]:
        return backtrack(LCS, A, B, i-1, j)
    return backtrack(LCS, A, B, i, j-1)

现在您需要找到最大和：

backtrack(LCS, A, B, i, j, s=0):
    if i == 0 or j == 0
        return s

    if A[i] == B[j]:
        return backtrack(LCS, A, B, i-1, j-1, s + P[i])
    else if LCS[i-1, j] > LCS[i, j-1]:
        return backtrack(LCS, A, B, i-1, j, s)
    else if LCS[i-1, j] < LCS[i, j-1]:
        return backtrack(LCS, A, B, i, j-1, s)
    else:
        return max(backtrack(LCS, A, B, i-1, j, s),
                   backtrack(LCS, A, B, i, j-1, s))

回溯（LCS，A，B，i，j，s=0）：
如果i==0或j==0
返回s
如果A[i]==B[j]：
返回回程（LCS、A、B、i-1、j-1、s+P[i]）
否则，如果LCS[i-1，j]>LCS[i，j-1]：
返回回程（LCS、A、B、i-1、j、s）
否则，如果LCS[i-1，j]

为了实现高效，您可能必须应用备忘录。还可以计算LCS矩阵旁边的和矩阵（甚至可以代替和矩阵）