Question

我已经实现了我的三个序列的最长公共子序列的版本，并且找不到错误。但Coursera分级员说我上次测试失败了。这意味着该算法几乎可以纠正，但在特定情况下输出错误的答案。但是它是什么情况呢？

约束：列表的长度不小于1且不大于100.列表中的数字是从-10 ^ 9到10 ^ 9的整数。

import sys


def lcs3(a, b, c):
    start_b = 0
    start_c = 0
    result = []
    for i in range(len(a)):
        for j in range(start_b, len(b)):
            if a[i] == b[j]:
                for k in range(start_c, len(c)):
                    if b[j] == c[k]:
                        start_b = j+1
                        start_c = k+1
                        result.append(a[i])
                        break
                if b[j] == c[k]:
                    break
    return len(result)


def lcs3_reversed(a,b, c):
    # check reversed sequence which can be with different order
    a_rev = a[::-1]
    b_rev = b[::-1]
    c_rev = c[::-1]
    result = lcs3(a, b, c)
    result_reversed = lcs3(a_rev, b_rev, c_rev)
    if result == result_reversed:
        return result
    else:
        return result_reversed


if __name__ == '__main__':
    input = sys.stdin.read()
    data = list(map(int, input.split()))
    an = data[0]
    data = data[1:]
    a = data[:an]
    data = data[an:]
    bn = data[0]
    data = data[1:]
    b = data[:bn]
    data = data[bn:]
    cn = data[0]
    data = data[1:]
    c = data[:cn]
    print(lcs3_reversed(a, b, c))

更新：添加了 lcs3_reversed 功能，以解决您所描述的情况。无论如何都无法通过测试用例。

输出应包含公共子序列的长度。例如，输入：

输出 2 ，因为这3个列表的公共部分是（1,3）。

失败案例的运行时间为0.04秒，看起来列表相当长，因为我自己的大多数测试都运行得更快。

感谢您的帮助！

Update2：我尝试过另一个版本。首先，我们找到2个列表的最长公共子序列，然后在我们的结果和第3个列表上再次使用它。

def lcs2(a, b):
    start_b = 0
    result = []
    for i in range(len(a)):
        for j in range(start_b, len(b)):
            if a[i] == b[j]:
                start_b = j+1
                result.append(a[i])
                break
    return result


def lcs2_reversed(a, b):
    # check reversed sequence which can be with different order
    a_rev = a[::-1]
    b_rev = b[::-1]
    result_reversed = lcs2(a_rev, b_rev)[::-1]
    return result_reversed

def lcs3_reversed(a, b, c):
    lcs2_str = lcs2(a, b)
    lcs2_rev = lcs2_reversed(a, b)
    lcs3_str_str = lcs2(lcs2_str, c)
    lcs3_rev_rev = lcs2_reversed(lcs2_rev, c)
    lenghts = [len(lcs3_str_str), len(lcs3_rev_rev)]
    return max(lenghts)

if __name__ == '__main__':
    an = input()
    a = input().split()
    bn = input()
    b = input().split()
    cn = input()
    c = input().split()
    print(max(lcs3_reversed(a, b, c), lcs3_reversed(a, c, b), lcs3_reversed(b, a, c),
              lcs3_reversed(b, c, a), lcs3_reversed(c, a, b), lcs3_reversed(c, b, a)))

此外，我尝试了所有订单组合，但没有帮助......再次，我无法通过最后一个测试用例。

Answer 1

你的例子打破了：

a = [1,2,7,3,7]
b = [2,1,2,3,7]
c = [1,2,3,1,7]

序列应为[1,2,3,7]（如果我理解正确的练习），但问题是a的最后一个元素与b和{{的最后一个元素匹配1}}，表示c和start_b设置为最后一个元素，因此循环结束。

三个序列的最长公共子序列

1 个答案: