最长严格双调子序列的长度

最长严格双调子序列（LBS）是指一个序列中的最长子序列，这个子序列在前面是严格上升的，在后面是严格下降的。下面是一个例子：

序列：1 3 2 4 7 5 8 6 9
LBS：   1 3 7 8 9 6

LBS 问题可以通过动态规划算法来解决。我们可以先考虑一个较为简单的问题：最长上升子序列（LIS）。定义 $dp[i]$ 表示以第 $i$ 个数为结尾的最长上升子序列的长度。则状态转移方程为：

dp[i] = max(dp[j] + 1)  (1 <= j <= i-1, a[j] < a[i])

其中 $a[i]$ 表示原序列的第 $i$ 个数字。我们可以通过遍历 $j$ 并判断 $a[j]$ 是否小于 $a[i]$ 来进行转移。

LBS 问题与 LIS 问题不同的是，LBS 问题需要求出前半部分的最长上升子序列和后半部分的最长下降子序列，然后将这两部分拼接起来。可以从 $dp[i]$ 中拆分出前半部分和后半部分：

dp1[i] 表示以第 i 个数为结尾的最长上升子序列的长度
dp2[i] 表示以第 i 个数为开头的最长下降子序列的长度

那么状态转移方程为：

dp1[i] = max(dp1[j] + 1)  (1 <= j <= i-1, a[j] < a[i])
dp2[i] = max(dp2[j] + 1)  (i+1 <= j <= n, a[i] > a[j])

其中 $n$ 是原序列的长度。可以看到，转移方程中需要两重循环，时间复杂度为 $O(n^2)$。不过可以使用一些优化来加快计算速度，例如利用二分查找优化寻找 $dp2$ 值的过程。最终的时间复杂度为 $O(n\log n)$。

以下是 Python 代码实现：

def lbs(arr):
    n = len(arr)
    dp1 = [1] * n
    dp2 = [1] * n

    # 计算最长上升子序列
    for i in range(1, n):
        for j in range(i):
            if arr[j] < arr[i]:
                dp1[i] = max(dp1[i], dp1[j] + 1)

    # 计算最长下降子序列
    for i in range(n - 2, -1, -1):
        for j in range(n - 1, i, -1):
            if arr[i] > arr[j]:
                dp2[i] = max(dp2[i], dp2[j] + 1)

    # 计算最长严格双调子序列
    lbs_len = 0
    for i in range(n):
        lbs_len = max(lbs_len, dp1[i] + dp2[i] - 1)
        
    return lbs_len

具体使用方法可以参考以下示例：

arr = [1, 3, 2, 4, 7, 5, 8, 6, 9]
print(lbs(arr))  # 输出 6

以上就是最长严格双调子序列的算法及 Python 实现。