Question

我正在尝试在LeetCode上解决this problem，内容为：

在the most upvoted Java solution之后，我提出了以下建议的解决方案：

import functools


class Solution:
    def longestPalindromeSubseq(self, s):
        return longest_palindromic_subsequence(s)


@functools.lru_cache(maxsize=None)
def longest_palindromic_subsequence(s):
    if not s:
        return 0
    if len(s) == 1:
        return 1
    if s[0] == s[-1]:
        return 2 + longest_palindromic_subsequence(s[1:-1])
    return max(
        longest_palindromic_subsequence(s[0:-1]),
        longest_palindromic_subsequence(s[1:]))

问题在于，对于一个似乎有许多重复字符的输入字符串，超出了时间限制：

从引用的讨论中可以理解，没有functools.lru_cache时，该算法的时间复杂度为O（2 ^ N），因为在每次将字符串长度减少一个字符时，都会进行两次递归调用

但是，讨论指出，记住的解决方案为O（N ^ 2），不应超过时间限制。我真的看不到记忆如何减少时间的复杂性，在这里似乎并非如此。

让我进一步困惑的是，如果解决方案由许多重复的字符组成，那么它实际上应该在O（N）次内运行，因为每次第一个和最后一个字符都相同时，只会进行一次递归调用。

有人可以向我解释为什么该测试失败吗？

Answer 1

Python中的字符串切片为O(n)（n是切片的长度），而Java的子字符串为O(1)，因为它仅在同一基础char[]上创建视图。但是，您可以通过简单地对具有两个移动索引的同一字符串进行操作来从等式中取出切片。此外，当第一个和最后一个不相同时，可以将索引移过相同字母的块：

@functools.lru_cache(maxsize=None)
def longest_palindromic_subsequence(s, start=None, end=None):
    if start is None:
        start = 0
    if end is None:
        end = len(s) - 1
    if end < start:
        return 0
    if end == start:
        return 1
    if s[start] == s[end]:
        return 2 + longest_palindromic_subsequence(s, start+1, end-1)

    # you can move indexes until you meet a different letter!
    start_ = start
    end_ = end
    while s[start_] == s[start]: 
        start_ += 1
    while s[end_] == s[end]: 
        end_ -= 1

    return max(
        longest_palindromic_subsequence(s, start, end_),
        longest_palindromic_subsequence(s, start_, end))

记忆应该有很大帮助。接受输入"abcde"。在return max(...)部分中，最终将对"bcd"进行两次递归调用，并为进一步的嵌入式子字符串进行更多调用。

LeetCode的最长回文子序列问题“已超过时间限制”

1 个答案: