最长增长子序列之动态规划解法与二分查找解法（Python code）

问题描述

最长递增子序列（Longest Increasing Subsequence）
给定一个无序的整数数组，找到其中最长上升子序列的长度
对于多种最长上升子序列的组合，输出对应长度即可
例如：

input：[10, 9, 2, 5, 3, 7, 101, 18, 198, 192]

output：5
# [2, 3, 7, 101, 198]

子串一定是连续的，但是子序列不一定是连续的

动态规划

分析

定义 dp[i] 表示以数组 nums[i] 这个数结尾的最长的递增子序列的长度
以上述问题为例，

nums[4] = 3
dp[4] = 2
# 子序列为 [2, 3]， 长度为 2

确定动态规划的初始状态，因为子序列中，至少可以包含自己，所以长度至少为 1

dp = [1 for i in range(len(nums))]

确定动态规划的状态转移，对于第 i 个元素，首先确定 nums[i] 的值，，然后找到之前确定的结尾比 nums[i] 小的序列，然后把 nums[i] 添加到最后，形成一个新的递增子序列，并且长度加 1
对于可能形成的多个新的子序列，只需要取最长的子序列即可

for j in range(i):
	if nums[j] < nums[i]:
		dp[i] = max(dp[i], dp[j]+1)

确定动态规划的终止条件，子序列的最大长度应该是 dp 数组中的最大值

res = max(dp)

代码

def dp_lis(nums):
    dp = [1 for i in range(len(nums))]
    for i in range(len(nums)):
        for j in range(i):
            if nums[j]<nums[i]:
                dp[i] = max(dp[i], dp[j]+1)
    return max(dp)

时间复杂度： O(N²)

二分查找

关于二分查找的详细讲解，可以看这个

代码

def binary_lis(nums):
    len_nums = len(nums)
    top = [0 for i in range(len_nums)]
    piles = 0
    for i in range(len_nums):
        poker = nums[i]
        # binary search of searching left boundary
        left = 0
        right = piles
        while left < right:
            mid = (left+right)//2
            if top[mid] > poker:
                right = mid
            elif top[mid] < poker:
                left = mid + 1
            else:
                right = mid
        # no suitable deck, create a new one
        if left == piles:
            piles += 1
        top[left] = poker
    return piles

nums = [10, 9, 2, 5, 3, 7, 101, 18, 198, 192]
print(binary_lis(nums))

时间复杂度： O(N*logN)