最长子序列，使得每对之间的绝对差最大为1

当你需要找到一个序列中最长的一个子序列，使得其中任意两个元素的绝对差都不超过1时，可以使用以下算法：

算法概述

1. 将给定序列排序
2. 利用动态规划求解最长递增子序列，同时保留唯一的最长递增子序列的所有解，即对于元素i，最长递增子序列的长度是LIS[i]，最长递增子序列是LIS_SEQ[i]。
3. 对于一个元素i，其最长子序列的长度即为max(LIS[i], LIS[i-1]+1, LIS[i+1]+1)。
4. 最终的最长子序列即为所有元素的最长子序列中最长的一个。

代码实现

def longest_sequence(arr):
    # 将数组排序
    arr.sort()
    # 初始化LIS和LIS_SEQ
    LIS = [1] * len(arr)
    LIS_SEQ = [[i] for i in arr]
    # 寻找最长递增子序列
    for i in range(1, len(arr)):
        for j in range(i):
            if arr[i] - arr[j] <= 1 and LIS[j] + 1 > LIS[i]:
                LIS[i] = LIS[j] + 1
                LIS_SEQ[i] = LIS_SEQ[j] + [arr[i]]
    # 计算最长子序列
    max_seq = []
    for i in range(len(arr)):
        seq = LIS_SEQ[i]
        if i > 0 and arr[i] - arr[i - 1] == 1:
            seq = LIS_SEQ[i - 1] + seq
        if i < len(arr) - 1 and arr[i + 1] - arr[i] == 1:
            seq = seq + LIS_SEQ[i + 1][1:]
        if len(seq) > len(max_seq):
            max_seq = seq
    return max_seq

示例

arr = [1, 2, 4, 5, 7, 8, 10]
seq = longest_sequence(arr)
print(seq)  # [1, 2, 4, 5, 7, 8]

算法分析

时间复杂度

排序的时间复杂度为O(nlogn)，动态规划求最长递增子序列的时间复杂度为O(n^2)，计算最长子序列的时间复杂度为O(n)，因此总时间复杂度为O(n^2)。

空间复杂度

动态规划需要使用一个n长度的数组LIS，同时需要一个n长度的列表LIS_SEQ来保存最长递增子序列，因此空间复杂度为O(n)。

总结

该算法通过将给定序列排序，动态规划求最长递增子序列，并结合相邻元素的值进行判断，计算出全局最长子序列的长度。其时间复杂度为O(n^2)，与常规的求最长子序列的算法相同，但该算法在题目所给的要求下，可以得到最优解。