左右旋转相同的数字的最长子序列

左右旋转相同的数字的最长子序列指的是一个数字序列可以在左右旋转的情况下，找到一个连续的子序列使得这个子序列中的数字与它的旋转相同，并且这个子序列的长度是最长的。

例如，数字序列 [1, 2, 3, 4, 5]，在左右旋转后可以得到 [2, 3, 4, 5, 1]，[3, 4, 5, 1, 2]，[4, 5, 1, 2, 3]，[5, 1, 2, 3, 4]，[1, 5, 4, 3, 2]，[5, 4, 3, 2, 1] 等等。

其中最长的左右旋转相同的数字的子序列为 [1, 2, 3, 4, 5]。

解决方法

暴力枚举

对于长度为 n 的数字序列，我们可以枚举其所有可能的子序列，然后对于每个子序列，我们都进行一次左右旋转比较，时间复杂度为 O(n^3)。

代码实现（Python）：

def is_same(seq1, seq2):
    if len(seq1) != len(seq2):
        return False
    for i in range(len(seq1)):
        if seq1[i] != seq2[i]:
            return False
    return True

def find_longest_subsequence(nums):
    n = len(nums)
    longest = []
    for i in range(n):
        for j in range(i+1, n+1):
            sub_seq = nums[i:j]
            for k in range(1, n):
                rotated_seq = nums[k:] + nums[:k]
                if is_same(sub_seq, rotated_seq):
                    if len(sub_seq) > len(longest):
                        longest = sub_seq
    return longest

哈希表

我们可以使用哈希表记录每个数字在原序列中的下标，然后在枚举子序列时，只需要记录子序列中最小的数字的下标，然后计算其与每个数字的差值，判断这些差值是否相同。若相同，则说明这个子序列与它的旋转相同。

时间复杂度为 O(n^2)。

代码实现（Python）：

def find_longest_subsequence(nums):
    n = len(nums)
    index = {num: i for i, num in enumerate(nums)}
    longest = []
    for i in range(n):
        for j in range(i+1, n+1):
            sub_seq = nums[i:j]
            min_index = min([index[num] for num in sub_seq])
            diffs = [(index[num] - min_index) % n for num in sub_seq]
            if len(set(diffs)) == 1 and len(sub_seq) > len(longest):
                longest = sub_seq
    return longest

快慢指针

我们可以使用快慢指针来寻找子序列。

我们用两个指针 i 和 j，每次向右移动 j，判断区间 [i, j] 是否与它的旋转相同。若相同，就尝试向右移动 j，使得长度更长，否则向右移动 i。

时间复杂度为 O(n)。

代码实现（Python）：

def find_longest_subsequence(nums):
    n = len(nums)
    longest = []
    for i in range(n):
        j = i
        while j < n and nums[j] == nums[(j + 1) % n]:
            j += 1
        k = j + 1
        while k < n and ((k - i) % n) < ((j - i + 1) % n) and nums[k] == nums[(k + 1) % n]:
            k += 1
        if ((k - i) % n) > ((j - i + 1) % n):
            sub_seq = nums[i:k+1]
            if len(sub_seq) > len(longest):
                longest = sub_seq
        else:
            j += 1
    return longest

总结

左右旋转相同的数字的最长子序列是一个比较有趣且实用的问题，我们可以用暴力枚举、哈希表、快慢指针等多种方法来解决这个问题。在这些方法中，哈希表和快慢指针具有较好的时间复杂度和实用性，可以在实际应用中使用。