国际空间研究组织 | ISRO CS 2014 |问题 47

该题目是ISRO CS 2014年的计算机科学考试中的第47个问题。问题描述如下：

给定一个字符串S，找到该字符串中长度最长的回文子序列。例如，如果输入字符串为"BBABCBCAB"，则输出的最长回文子序列为"BABCBAB"。

现在，你需要编写一个函数来解决这个问题，函数必须返回该字符串中最长的回文子序列，并且以markdown格式返回其代码片段。

函数签名

def longest_palindrome_subsequence(S: str) -> str:

参数说明

• S: 一个字符串类型的参数，表示输入的字符串。假设字符串长度不超过1000。

返回值

该函数应该返回三个字符串类型的参数，分别表示最长的回文子序列、子序列的长度及其起始位置。

示例

S = "BBABCBCAB"
longest_palindrome_subsequence(S)

输出：

('BABCAB', 6, 1)

代码实现

def longest_palindrome_subsequence(S: str) -> str:
    if S == S[::-1]:
        return (S, len(S), 0)
    n = len(S)
    L = [[0 for _ in range(n)] for _ in range(n)]
    for i in range(n):
        L[i][i] = 1
    for c in range(2, n + 1):
        for i in range(n - c + 1):
            j = i + c - 1
            if S[i] == S[j] and c == 2:
                L[i][j] = 2
            elif S[i] == S[j]:
                L[i][j] = L[i + 1][j - 1] + 2
            else:
                L[i][j] = max(L[i][j - 1], L[i + 1][j])
    result = ""
    i, j = 0, n - 1
    while i < j:
        if S[i] == S[j]:
            result = result + S[i]
            i, j = i + 1, j - 1
        elif L[i][j - 1] > L[i + 1][j]:
            j = j - 1
        else:
            i = i + 1
    if i == j:
        result = result + S[i]
    return (result, L[0][n - 1], S.index(result))

该函数具体实现如下：

1. 如果输入字符串本身就是回文，则直接返回，否则初始化$L$矩阵为$(n×n)$的0矩阵，然后按顺序给$L[i][i]$元素赋值为1，表示单个字符是回文子序列，接着按顺序计算$L[i][j]$的所有值。
2. 对于$L[i][j]$，如果$S[i]$和$S[j]$相等并且子字符串的长度为2，则$L[i][j]$的值等于2，因为两个相等的字符本身就是回文子序列。
3. 如果两个字符$S[i]$和$S[j]$相等，则$L[i][j]$的值等于$L[i+1][j-1]+2$，因为删除两个字符并找到的子序列长度为$L[i+1][j-1]$，需要再加上原来两个字符的长度2。注意，当$i>j$时，$L[i][j]$根本不是回文子序列，因此$L[i][j]$的值始终为0。
4. 最后，使用相似的方法找到计算结果和最长的回文子序列的起始位置。

最后代码的markdown代码片段为：

```python
def longest_palindrome_subsequence(S: str) -> str:
    if S == S[::-1]:
        return (S, len(S), 0)
    n = len(S)
    L = [[0 for _ in range(n)] for _ in range(n)]
    for i in range(n):
        L[i][i] = 1
    for c in range(2, n + 1):
        for i in range(n - c + 1):
            j = i + c - 1
            if S[i] == S[j] and c == 2:
                L[i][j] = 2
            elif S[i] == S[j]:
                L[i][j] = L[i + 1][j - 1] + 2
            else:
                L[i][j] = max(L[i][j - 1], L[i + 1][j])
    result = ""
    i, j = 0, n - 1
    while i < j:
        if S[i] == S[j]:
            result = result + S[i]
            i, j = i + 1, j - 1
        elif L[i][j - 1] > L[i + 1][j]:
            j = j - 1
        else:
            i = i + 1
    if i == j:
        result = result + S[i]
    return (result, L[0][n - 1], S.index(result))