day2【动态规划】最长的递增子序列

最新推荐文章于 2024-08-14 09:28:32 发布

张大帅比

最新推荐文章于 2024-08-14 09:28:32 发布

阅读量300

点赞数

分类专栏：运筹优化文章标签：动态规划算法数据结构

本文链接：https://blog.csdn.net/Atticus_zhang/article/details/129835094

版权

运筹优化专栏收录该内容

8 篇文章 0 订阅

订阅专栏

给定一个数组，找出其中最长的递增子序列。
例如，输入如下数组：

nums = [1, 5, 2, 4, 3]

返回最长的递增子序列长度是3

1 枚举法/暴力搜索

1.1 思路

枚举法的思路是依次从第一个数出发，依次遍历这个数可以到达（符合递增规则）的下一个数。
算法分为两个部分：
① 计算最长递增序列长度 $L TS$ ，循环数组中的每个数，分别计算从位置 $i$ 出发能够得到的最长递增子序列长度记为 $L [i]$ ， $L TS$ = $max\{L[i]\}$
② 计算对于每个位置 $i$ 的 $L [i]$ ，依次遍历之后的位置 $j$ ，先判断位置 $j$ 是否可以到达（是否满足递增条件），然后计算所有可达到 $j$ 的 $L [j]$ ， $L [i]$ = 最大的 $L [j]$ $+$ $1$

1.2 代码

计算最长递增序列长度 $L TS$

def length_of_LIS(nums):
    return max(L(nums, i) for i in range(len(nums)))

计算对于每个位置 $i$ 的 $L [i]$

def L(nums, i):
    if i == len(nums) - 1:
        return 1
    max_len = 1
    for j in range(i + 1, len(nums)):
        if nums[j] > nums[i]:
            max_len = max(max_len, L(nums, j) + 1)
    return max_len

1.3 时间复杂度

枚举法无疑是非常慢的。首先，数组中每个数可以取也可以不取，因此所有排列组合有 $2^n$ 种子序列，复杂度是 $O(2^n)$ ；其次，对于每种子序列都需要遍历一遍，复杂度是 $O (n)$ ；所以整个算法的时间复杂度是 $O(n2^n)$

2 记忆化搜索/剪枝

2.1 思路

在枚举的过程种，存在很多重复计算。如图
在这里插入图片描述
图中， $4$ 和 $3$ 被计算了两次。如果能够将 $4$ 和 $3$ 的计算结果 $L [4]$ 和 $L [3]$ 存储下来，将提高算法效率，达到以空间换时间的效果。

这种方法也被称为，记忆化搜索或者剪枝。

2.2 代码

将穷举法中的第二部分修改一下，用字典memo存储计算过的值。

# memo用于存储计算过的 L[i]
memo = {}

def L(nums, i):
    if i in memo:
        return memo[i]
    if i == len(nums) - 1:
        return 1
    max_len = 1
    for j in range(i + 1, len(nums)):
        if nums[j] > nums[i]:
            max_len = max(max_len, L(nums, j) + 1)
    # 将当前计算的 L[i] 保存
    memo[i] = max_len
    return max_len

3 改写成迭代形式

3.1 思路

前面已经提到可以通过缓存计算过的值提高效率。
下面重新整理一下思路。

将从第 $i$ 个数出发的最长递增子序列长度记为 $d p [i]$ ，
将第 $i$ 个数出发能到达的下一个数 $j$ 的集合记为 $f e a s ib l e [i]$ ，
状态转移函数可以表示为，
$L [i]$ = $max\{dp[j] + 1\},j\in feasible[i]$

$L TS$ = $max\{L[i]\},i\in n$

其中， $L$ 就是缓存下来的结果。

根据该问题的特点，从最后一个位置出发的最长递增序列长度一定是 $1$ ，因此，可以倒着遍历数组依次求出每个位置的最长递增序列长度。

3.2 代码

完整的代码如下

from Tools.TimeTools import time_function

@time_function
def length_of_LIS(nums):
    n = len(nums)
    L = [1] * n
    for i in reversed(range(n)):
        for j in range(i + 1, n):
            if nums[j] > nums[i]:
                L[i] = max(L[i], L[j] + 1)
    return max(L)

nums = [1, 5, 2, 4, 3]
print(length_of_LIS(nums))

为了统计算法运行的时间，这里写了个统计时间的装饰器，代码放在最后。

4 总结

动态规划基本思路：

4.1 枚举

首先，可以先将所有的答案枚举出来，并画出递归树，尝试用一个递归函数求解；

4.2 剪枝

如果发现枚举中出现大量的重复计算，可以尝试用哈希表将数据缓存下来，之后遍历到相同的节点就直接查表，避免重复计算；

4.3 非递归

最后，将计算的过程表示出来，观察公式求解的顺序，并尝试将递归形式改写成更简洁高效的迭代形式

5 统计时间装饰器代码

import time


def time_function(function, *args):
    """
    统计函数执行时间的装饰器
    """

    def wrapper(*args):
        start_time = time.time()
        result = function(*args)
        end_time = time.time()
        print(f"函数 {function.__name__} 运行时间为：{(end_time - start_time):.6f} 秒")
        return result

    return wrapper


@time_function
def my_algorithm(arg1, arg2):
    # 执行某些算法操作
    pass