关于深搜优化的一点想法

本文探讨了在解决大规模问题时如何避免暴力搜索导致的超时问题。通过深入理解深度优先搜索(DFS)的遍历顺序,例如A-B-D-E-G-C-F,当对象数量超过一定阈值(如30),传统DFS可能导致程序超时。为提高效率,文章介绍了剪枝策略,特别是记忆化搜索,以减少重复计算。在全排列问题的实例中,展示了如何使用记忆化搜索实现DFS,并给出了C++代码实现。剪枝技术对于优化算法性能至关重要,特别是在处理大规模数据时。

概述图
如上图。在遍历一个图时采用搜到底再回头的想法,遍历顺序为 A − > B − > D − > E − > G − > C − > F A->B->D->E->G->C->F A>B>D>E>G>C>F。时间复杂度为 O ( 2 n ) O(2^n) O(2n)

在竞赛中,一般程序运行时间为 1 s 1s 1s 2 s 2s 2s,那么我们按 2 s 2s 2s 来计算,计算机每秒可以运算约 1 0 9 10^9 109 次,那么在规定时间内就可以运算 log ⁡ 2 2 × 1 0 9 ≈ 30 \log_2{2 \times 10^9} \thickapprox 30 log22×10930 次。也就是说,当对象大于等于 30 30 30 个时,程序会超时。

当题目中的对象太大时,就不能直接暴力搜索了,需要在搜索的过程中进行取舍,也就是 剪枝
剪枝有以下几个方法:

1.记忆化搜索

其实记忆化搜索就是所谓的 DFS,就是将已经搜索过的、不需要再搜索的打上标记,下一次搜索的时候直接跳过这种情况,可以大大优化程序效率。

例:全排列问题

给你 n n n 个数,生成这 n n n 个数的全排列。

样例:

输入:
3
1 2 3
输出:
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

标程:
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <float.h>
#include <ctype.h>
#include <map>
#include <stdbool.h>
using namespace std;

int n;
int a[1005], b[1005];

void dfs(int t) {
	if(t == n+1) {
		for(int i = 1; i <= n; i++)
			printf("%5d", a[i]);
		printf("\n");
		return ;
	}
	for(int i = 1; i <= n; i++) {
		if(b[i]) continue;
		a[t] = i, b[i] = 1;	// 这就是记忆化(也叫搜索与回溯)
		dfs(t+1);
		a[t] = 0,b[i] = 0;
	}
}

int main() {
	scanf("%d", &n);
	dfs(1);
	return 0;
}
<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` 数组记录转移路径,可输出具体序列
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值