<think>我们要求使用
记忆化搜索（Memoization）来实现最长递增子序列（LIS）问题。
记忆化搜索是动态规划的一种实现方式，它使用递归和缓存（通常是一个数组）来避免重复计算。
在LIS问题中，我们定义状态`dp[i]`为以第`i`个元素结尾的最长递增子序列的长度。在
记忆化搜索中，我们将递归地计算每个`dp[i]`，并将结果存储起来，以便后续直接使用，避免重复计算。
记忆化搜索的步骤：
1. 定义一个数组`memo`，用于存储已经计算过的状态。初始化为-1（或0，但通常用-1表示未计算）。
2. 对于每个位置`i`，递归地计算以`i`结尾的LIS长度。计算过程中，我们遍历`i`之前的所有位置`j`（`j`从0到`i-1`），如果`nums[j] < nums[i]`，则`dp[i] = max
(dp[i], dp[j] + 1
)`，否则为1（即只有自身）。
3. 在递归函数中，首先检查`memo[i]`是否已经计算过，如果是，则直接返回；否则，进行计算，并将结果存入`memo[i]`。
注意：由于递归
深度可能较大，对于较大的序列，递归可能导致栈溢出。但这里我们主要关注
记忆化搜索的实现方法。
另外，我们还需要一个递归函数，比如命名为`lisEndingAt
(int index
)`，它返回以`index`结尾的最长递增子序列的长度。
最后，我们遍历整个序列，对每个位置调用`lisEndingAt`，并取最大值作为整个序列的LIS长度。
下面我们用
C++实现这一过程。</think>###
C++ 最长上升子序列的
记忆化搜索实现
记忆化搜索（Memoization）是动态规划的一种优化技术，通过缓存子问题的解避免重复计算。对于最长上升子序列（LIS）问题，
记忆化搜索解法的时间复杂度为 $O
(n^2
)$，空间复杂度为 $O
(n
)$。以下是详细实现：
####
算法核心思想
1. **状态定义**：`memo[i]` 表示以 `nums[i]` 结尾的最长上升子序列长度
2. **递归关系**：
$$ \text{memo}[i] = 1 + \max_{\substack{j < i \\ \text{nums}[j] < \text{nums}[i]}} \text{memo}[j] $$
3. **终止条件**：当 `i == 0` 时，长度为 1（单个元素）
4. **
记忆化**：使用数组缓存计算结果，避免重复递归
####
C++ 代码实现
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;
//
记忆化搜索函数
int lisEndingAt
(int i, vector<int>& nums, vector<int>& memo
) {
// 如果已计算过，直接返回缓存结果
if
(memo[i] != -1
) return memo[i];
// 基础情况：单个元素的LIS长度为1
if
(i == 0
) return memo[i] = 1;
int maxLength = 1;
// 遍历所有可能的前驱元素
for
(int j = 0; j < i; j++
) {
// 确保严格递增
if
(nums[j] < nums[i]
) {
int subLength = lisEndingAt
(j, nums, memo
);
maxLength = max
(maxLength, 1 + subLength
);
}
}
// 缓存结果并返回
return memo[i] = maxLength;
}
int lengthOfLIS
(vector<int>& nums
) {
if
(nums.empty
()) return 0;
int n = nums.size
();
vector<int> memo
(n, -1
); // 初始化记忆数组
int maxLen = 1;
// 计算每个位置结尾的LIS长度
for
(int i = 0; i < n; i++
) {
maxLen = max
(maxLen, lisEndingAt
(i, nums, memo
));
}
return maxLen;
}
int main
() {
vector<int> nums = {10, 9, 2, 5, 3, 7, 101, 18};
cout << "最长上升子序列长度: " << lengthOfLIS
(nums
) << endl;
// 输出: 4
(对应序列 [2,5,7,101] 或 [2,3,7,101]
)
return 0;
}
```
#### 关键点解析
1. **
记忆化数组**：`memo` 数组初始化为 -1，表示未计算状态
2. **递归方向**：从序列末尾向前递归（`i` 从大到小）
3. **状态转移**：
- 当 `nums[j] < nums[i]` 时，更新当前最大长度
- 每次递归只计算以当前位置结尾的 LIS
4. **结果整合**：主函数遍历所有位置，取最大值作为最终结果
#### 时间复杂度分析
- **最优情况**：$O
(n
)$（完全逆序序列）
- **最坏情况**：$O
(n^2
)$（完全升序序列）
- **平均情况**：$O
(n^2
)$
####
算法改进建议
1. **尾递归优化**：可改写为迭代形式避免递归栈溢出
2. **二分
搜索优化**：结合贪心策略可达到 $O
(n \log n
)$ 时间复杂度[^1]
3. **路径追踪**：添加 `prev` 数组记录转移路径，可输出具体序列
扫一扫
941
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
