dp子序列问题+时间复杂度分析

最新推荐文章于 2024-09-09 00:00:00 发布

小泽爱刷题

最新推荐文章于 2024-09-09 00:00:00 发布

阅读量1k

点赞数 13

文章标签： python

本文链接：https://blog.csdn.net/m0_48938554/article/details/141939403

版权

动态规划子序列问题，

把大的问题细化到一个点，先研究在这个小的点上如何解决问题，然后再通过递归/迭代的方式扩展到整个问题。算法题到最后就是聪明的穷举，如何聪明的拆分问题。

对于两个字符串求子序列的问题，都是用两个指针 i 和 j 分别在两个字符串上移动，大概率是动态规划思路。

不要看 s1 和 s2 两个字符串，而是要具体到每一个字符，思考每个字符该做什么。

int dp(int i, int j) {
    dp(i + 1, j + 1); // #1
    dp(i, j + 1);     // #2
    dp(i + 1, j);     // #3
}

抽象出dp函数得递归框架，由这个逻辑就可以看到里面存在重复子问题，所以可以使用memo备忘录来解决。

是的，选择的过程就是基于状态转移方程来做出的。在动态规划中，状态转移方程定义了如何从一个状态转移到另一个状态，并且确定在每一步中需要做出的选择。这些选择直接决定了如何计算当前状态的结果。

如何选择依据状态转移方程？

定义状态：首先，需要明确每个状态表示什么。通常，状态定义了问题的某一个特定情况或部分。例如，在最长公共子序列问题中，状态可以定义为 dp(s1, i, s2, j)，表示从 s1[i..] 和 s2[j..] 开始的最长公共子序列的长度。
制定状态转移方程：状态转移方程描述了如何从当前状态转移到其他状态。它指定了在当前状态下的所有可能的选择，并计算这些选择的结果。选择的结果会影响最终的解。例如：
- 相等的情况：如果当前字符相等，我们选择将这两个字符包含在公共子序列中，然后递归计算剩余的子序列。状态转移方程是：
  [
  dp[i][j] = 1 + dp[i+1][j+1]
  ]
- 不相等的情况：如果当前字符不相等，我们有两个选择：跳过 s1[i] 或者跳过 s2[j]。状态转移方程是：
  [
  dp[i][j] = \max(dp[i+1][j], dp[i][j+1])
  ]
确定选择：在每个状态下，根据状态转移方程的不同选择，计算每种选择的结果，选择能够使目标函数最大化或最小化的选择。这种选择就是通过状态转移方程来做出的。

示例解析

对于最长公共子序列（LCS）问题的状态转移方程：

当 s1[i] == s2[j] 时，我们选择将这两个字符包含在公共子序列中，因此：
[
dp[i][j] = 1 + dp[i+1][j+1]
]
这里选择将这两个字符包含在公共子序列中，并递归计算剩余的部分。
当 s1[i] != s2[j] 时，我们选择跳过一个字符，计算可能的子问题：
[
dp[i][j] = \max(dp[i+1][j], dp[i][j+1])
]
这里选择在两个选项中选择较大的值，以确保我们找到最长的公共子序列。

总结

在动态规划中，选择的过程就是依据状态转移方程来进行的。状态转移方程告诉我们在当前状态下有可能的选择以及如何计算这些选择的结果。通过这样的选择，我们可以将复杂的问题拆解成更小的子问题，并通过这些子问题的解构建出原问题的解。

子序列问题本身就相对子串、子数组更困难一些，因为前者是不连续的序列，而后两者是连续的，就算穷举你都不一定会，更别说求解相关的算法问题了。

子序列是不连续的，而子串，子数组都是连续的序列。

一般来说，这类问题都是让你求一个最长子序列，因为最短子序列就是一个字符嘛，没啥可问的。一旦涉及到子序列和最值，那几乎可以肯定，考察的是动态规划技巧，时间复杂度一般都是 O(n^2)。

为啥这个问题要这样定义二维的 dp 数组呢？提到，找状态转移需要归纳思维，说白了就是如何从已知的结果推出未知的部分。而这样定义能够进行归纳，容易发现状态转移关系。所以有时候即使是一串序列，用二维数组来定义也是可以，用来构建子问题，从而解决原问题例如最长回文子序列就是用dp[i] [j】构建代表我们对 dp 数组的定义是：在子串 s[i..j] 中，最长回文子序列的长度为 dp[i][j]。一定要记住这个定义才能理解算法。找状态转移需要归纳思维，说白了就是如何从已知的结果推出未知的部分。而这样定义能够进行归纳，容易发现状态转移关系。归纳思维，方便从已知的结果推未知的结果。

动态规划遍历方向，

如果仔细观察的话可以发现其中的原因，你只要把住两点就行了：

1、遍历的过程中，所需的状态必须是已经计算出来的。

2、遍历结束后，存储结果的那个位置必须已经被计算出来。

也就是说要注意base case，以及最终答案，在数组中的位置，从而决定出遍历方向。

class Solution:
    def longestPalindromeSubseq(self, s: str) -> int:
        n = len(s) #dp数组的定义就是s[i,j]这个字符串中，最长子序列的长度， 总子序列长度与部分子序列长度具有最优子结构这一特征。
        dp = [[0] * n for _ in range(n)]
        for i in range(n):
            dp[i][i] = 1
        for i in range(n - 1, -1, -1):
            for j in range(i + 1, n):
                if s[i] == s[j]:
                    dp[i][j] = dp[i + 1][j - 1] + 2
                else:
                    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]) 
        return dp[0][n - 1]

哈希表在 Python 中就是通过内置的 字典（dict） 来实现的，哈希集合就是 Python 中的 集合（set）。

1. 哈希表（字典）

字典（dict） 是哈希表的实现，使用哈希函数将键映射到特定位置来存储键值对。
每个键都是唯一的，键可以通过哈希函数映射到表中的索引，从而快速访问对应的值。
操作如插入、查找、删除的平均时间复杂度是 O(1)。

2. 哈希集合（集合）

集合（set） 是哈希集合的实现，它存储的是唯一的元素，通过哈希函数管理这些元素。
集合不允许重复元素，并且操作如插入、查找、删除同样在平均情况下可以在 O(1) 时间内完成。

对比：

字典（dict） 存储的是键值对，每个键都通过哈希函数定位到哈希表中的某个槽位，并且每个键是唯一的。
集合（set） 只存储唯一的元素，没有键值对，元素通过哈希函数管理。

它们的底层实现类似，都是基于哈希函数来快速进行元素的插入、查找和删除。

哈希集合（Hash Set）

哈希集合（set）是一种无序的、可变的集合，它使用哈希表来存储元素。集合中的元素是唯一的，不能重复。Python 中的 set 类型就是哈希集合的实现。

特点：
- 存储的是唯一的元素，没有键值对，只有值。
- 插入、查找和删除的时间复杂度平均为 O(1)，最坏情况是 O(n)（与哈希表类似）。
- 集合内的元素是无序的。
- 不允许重复元素。

在 Python 3.7 及以后版本中，字典（dict） 是有序的。这意味着插入元素的顺序会被保留，当你遍历字典时，元素会按插入的顺序返回。

具体情况：

Python 3.6：在 CPython 实现中，字典的顺序在大多数情况下是保留的，但这被认为是实现的“副作用”，并未在语言规范中正式定义。
Python 3.7+：字典的顺序性成为了语言规范的一部分。从这时起，所有 Python 实现都需要保证字典是有序的，即按插入顺序返回键值对。

示例：

# Python 3.7+ 中的字典是有序的
my_dict = {'a': 1, 'b': 2, 'c': 3}

for key in my_dict:
    print(key, my_dict[key])

输出将按插入顺序：

a 1
b 2
c 3

如果你使用的是 Python 3.7 或更高版本，可以依赖字典的插入顺序。好用。

二叉堆（Binary Heap）是一种特殊的完全二叉树，通常用于实现优先级队列（Priority Queue）。二叉堆有两种类型：最大堆（Max-Heap）和最小堆（Min-Heap）。在二叉堆中，每个节点都有一个值，且这个值与其子节点之间存在特定的顺序关系。

二叉堆的特点：

完全二叉树：二叉堆必须是一棵完全二叉树，即除了最后一层之外，每一层的节点都是满的，最后一层的节点从左到右依次排列。
堆的性质：
- 最大堆：每个节点的值都大于等于其子节点的值。即根节点是树中最大的元素。
- 最小堆：每个节点的值都小于等于其子节点的值。即根节点是树中最小的元素。

二叉堆的作用：

二叉堆主要用于实现优先级队列，在这种队列中，每次总是处理优先级最高或最低的元素。它可以高效地进行以下操作：

获取最大/最小值：在最大堆中，根节点总是最大的元素；在最小堆中，根节点总是最小的元素。获取根节点只需 O(1) 时间。
插入元素：插入一个新元素到堆中的时间复杂度为 O(log n)。
删除最大/最小值：删除根节点（即最大堆的最大值或最小堆的最小值）的时间复杂度为 O(log n)，因为需要重新调整堆的结构来保持堆的性质。

二叉堆的应用：

优先级队列：比如在任务调度中，任务有不同的优先级，二叉堆能够保证每次取出优先级最高或最低的任务。
堆排序（Heapsort）：通过将数据插入堆中并不断取出最大（或最小）元素来实现排序，堆排序的时间复杂度为 O(n log n)，且是原地排序算法。
Dijkstra算法和A*算法：这些最短路径算法在处理优先级队列时使用最小堆来优化性能。

二叉堆的实现方式：

通常，二叉堆不是通过真正的二叉树来实现，而是使用数组进行实现。原因在于完全二叉树的结构使得可以通过数组下标快速找到父节点和子节点：

给定索引 i 的节点：
- 父节点的索引为 (i - 1) // 2
- 左子节点的索引为 2 * i + 1
- 右子节点的索引为 2 * i + 2

Python 中的二叉堆实现：

在 Python 中，heapq 模块提供了一个最小堆的实现：

import heapq

# 创建一个空堆
min_heap = []

# 插入元素
heapq.heappush(min_heap, 10)
heapq.heappush(min_heap, 4)
heapq.heappush(min_heap, 15)

# 获取并移除最小元素
smallest = heapq.heappop(min_heap)
print(smallest)  # 输出：4

# 只获取最小元素，不移除
smallest_peek = min_heap[0]
print(smallest_peek)  # 输出：10

最大堆的实现：

heapq 模块默认是最小堆。如果需要最大堆，可以在插入元素时将值取反，以实现最大堆的效果。

max_heap = []
heapq.heappush(max_heap, -10)
heapq.heappush(max_heap, -4)
heapq.heappush(max_heap, -15)

# 获取并移除最大元素
largest = -heapq.heappop(max_heap)
print(largest)  # 输出：10

总结：

二叉堆是一种高效的完全二叉树，用于实现优先级队列。
最大堆和最小堆分别维护最大或最小元素在根节点。
常用于实现优先级队列、堆排序以及优化图算法等。

计算算法的时间复杂度，无非就是看这个算法做了些啥事儿，花了多少时间。而递归算法做的事情就是遍历一棵递归树，在树上的每个节点所做一些事情罢了。

所以：

递归算法的时间复杂度 = 递归的次数 x 函数本身的时间复杂度

递归算法的空间复杂度 = 递归堆栈的深度 + 算法申请的存储空间

或者再说得直观一点：

递归算法的时间复杂度 = 递归树的节点个数 x 每个节点的时间复杂度

递归算法的空间复杂度 = 递归树的高度 + 算法申请的存储空间

函数递归的原理是操作系统维护的函数堆栈，所以递归栈的空间消耗也需要算在空间复杂度之内，这一点不要忘了。

递归的次数 x 函数本身的时间复杂度 = 递归树节点个数 x 每个节点的时间复杂度 = 状态个数 x 计算每个状态的时间复杂度 = 子问题个数 x 解决每个子问题的时间复杂度 = O(N) * O(K) = O(NK)

空间复杂度还包括堆栈的深度，也就是包括递归树的深度

排列问题，回溯算法超级暴力，时间复杂度和空间复杂度都很高。

比如一个题目给你输入一个数组，其长度能够达到 10^6 这个量级，那么我们肯定可以知道这道题的时间复杂度大概要小于 O(N^2)，得优化成 O(NlogN) 或者 O(N) 才行。因为如果你写的算法是 O(N^2) 的，最大的复杂度会达到 10^12 这个量级，在大部分判题系统上都是跑不过去的。

为了把复杂度控制在 O(NlogN) 或者 O(N)，我们的选择范围就缩小了，可能符合条件的做法是：对数组进行排序处理、前缀和、双指针、一维 dp 等等，从这些思路切入就比较靠谱。像嵌套 for 循环、二维 dp、回溯算法这些思路，基本可以直接排除掉了。

再举个更直接的例子，如果你发现题目给的数据规模很小，比如数组长度 N 不超过 20 这样的，那么我们可以断定这道题大概率要用暴力穷举算法。

因为判题平台肯定是尽可能扩大数据规模难为你，它一反常态给这么小的数据规模，肯定是因为最优解就是指数/阶乘级别的复杂度。你放心用 [回溯算法] 招呼它就行了，不用想别的算法了。

所以说啊，很多读者看题都不看那个数据规模，上来就闷声写代码，这是不对滴。你先把题目给的所有信息都考虑进去，再写代码，这样才能少走弯路。

总结就是如果给的题目数据范围小，放心使用回溯算法。如果题目给的数据范围很大，那么大概率是用dp或者双指针等时间复杂度很低的算法来解决。

题目数据范围大，对数组进行排序处理、前缀和、双指针、一维 dp 等等，从这些思路切入就比较靠谱。像嵌套 for 循环、二维 dp、回溯算法这些思路，基本可以直接排除掉了。

小泽爱刷题

关注

13
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
dp子序列问题+时间复杂度分析

在动态规划中，选择的过程就是依据状态转移方程来进行的。状态转移方程告诉我们在当前状态下有可能的选择以及如何计算这些选择的结果。通过这样的选择，我们可以将复杂的问题拆解成更小的子问题，并通过这些子问题的解构建出原问题的解。子序列问题本身就相对子串、子数组更困难一些，因为前者是不连续的序列，而后两者是连续的，就算穷举你都不一定会，更别说求解相关的算法问题了。子序列是不连续的，而子串，子数组都是连续的序列。一般来说，这类问题都是让你求一个最长子序列，因为最短子序列就是一个字符嘛，没啥可问的。
复制链接

扫一扫