引言

本文主要讲了， $DFS$ 的另外两种优化，分别是迭代加深和双向 $DFS$ ，思路还是非常清晰明了的，只要会写 $DFS$ 那么这些剪枝和优化其实还是非常的容易的，优化还是建立在你会写暴搜的基础上的，写着写着就会了，加油！

---

概念

迭代加深：如果一个深度搜不到答案，那就将深度加一，继续开始搜，直至搜出答案为止，这种方法适用于答案在比较浅的层，但其他分支可能会很深。有人可能会说这样来回重复搜不会浪费时间吗？因为如果把前 $n-1$ 层都搜一遍，也没有第 $n$ 层的结点个数多，而且一般这种搜索树都是多叉的，时间复杂度都是指数级别的，所以这样搜会更高效。

双向DFS：从开头和结尾一起搜，如下图所示，会更加的高效。

---

一、加成序列

标签：搜索、迭代加深

思路：由于 $1,2,4,8,16,32,64,128$ ，所以可知答案所处在的深度很浅，又由于有些分支会很深，所以我们可以采用迭代加深的方法来优化。就是将层数由小到大逐步变大，如果最后一个数为 $n$ ，那就结束迭代。优化思路：从大到小来枚举数的大小，开一个判重数组来进行冗余性剪枝，然后就是根据条件进行可行性剪枝。

题目描述：

满足如下条件的序列 X（序列中元素被标号为 1、2、3…m）被称为“加成序列”：

X[1]=1
X[m]=n
X[1]<X[2]<…<X[m−1]<X[m]
对于每个 k（2≤k≤m）都存在两个整数 i 和 j （1≤i,j≤k−1，i 和 j 可相等），使得 X[k]=X[i]+X[j]。

你的任务是：给定一个整数 n，找出符合上述条件的长度 m 最小的“加成序列”。

如果有多个满足要求的答案，只需要找出任意一个可行解。

输入格式
输入包含多组测试用例。

每组测试用例占据一行，包含一个整数 n。

当输入为单行的 0 时，表示输入结束。

输出格式
对于每个测试用例，输出一个满足需求的整数序列，数字之间用空格隔开。

每个输出占一行。

数据范围
1≤n≤100
输入样例：
5
7
12
15
77
0
输出样例：
1 2 4 5
1 2 4 6 7
1 2 4 8 12
1 2 4 5 10 15
1 2 4 8 9 17 34 68 77

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 110;

int n;
int path[N];

bool dfs(int u, int k)
{
	if(u == k) return path[u-1] == n;
	
	bool st[N] = {0};  // 冗余性剪枝
	for(int i = u - 1; i >= 0; --i)  // 优化搜索顺序
	{
		for(int j = i; j >= 0; --j)
		{
			int s = path[i] + path[j];
			if(st[s] || s <= path[u-1] || s > n) continue;  // 可行性剪枝
			
			st[s] = true;
			path[u] = s;
			if(dfs(u+1,k)) return true;
		}
	}
	return false;
}

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	path[0] = 1;
	while(cin >> n, n)
	{	
		int depth = 1;
		while(!dfs(1,depth)) depth++;
		
		for(int i = 0; i < depth; ++i)
		{
			cout << path[i] << " ";
		}
		cout << endl;
	}
	
	return 0;
}

---

二、送礼物

标签：搜索、双向搜索

思路：这个其实就是一个指数型枚举，一个物品要么选，要么不选，然后根据条件找到最大方案数，但是时间复杂度为 $2^{46}\approx 10^{12}$ ，肯定超时了，但我们可以先枚举一半，把这一半的方案存下来，然后再枚举另一半， 从表中查找小于等于 $W$ 的最大值，时间复杂度约为 $20^6$ ，这样就可以过了。然后关于一些剪枝的细节见代码。

题目描述：

达达帮翰翰给女生送礼物，翰翰一共准备了 N 个礼物，其中第 i 个礼物的重量是 G[i]。

达达的力气很大，他一次可以搬动重量之和不超过 W 的任意多个物品。

达达希望一次搬掉尽量重的一些物品，请你告诉达达在他的力气范围内一次性能搬动的最大重量是多少。

输入格式
第一行两个整数，分别代表 W 和 N。

以后 N 行，每行一个正整数表示 G[i]。

输出格式
仅一个整数，表示达达在他的力气范围内一次性能搬动的最大重量。

数据范围
1≤N≤46,1≤W,G[i]≤231−1
输入样例：
20 5
7
5
4
18
1
输出样例：
19

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 50, M = 1 << 25;

int n, m;
int w[N];
int weights[M], cnt;
LL ans;
int k;

void dfs1(int u, int s)
{
	if(u == k)
	{
		weights[cnt++] = s;
		return;
	}
	
	if((LL)s + w[u] <= m) dfs1(u+1,s+w[u]);
	dfs1(u+1,s);
}

void dfs2(int u, int s)
{
	if(u == n)
	{
		int l = 0, r = cnt - 1;
		while(l < r)
		{
			int mid = l + r + 1 >> 1;
			if(weights[mid] + (LL)s <= m) l = mid;
			else r = mid - 1;
		}
		
		if((LL)s + weights[r] <= m)ans = max(ans, (LL)s + weights[r]);
		return;
	}
	
	if((LL)s + w[u] <= m) dfs2(u+1, s+w[u]);
	dfs2(u+1,s);
}

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> m >> n;
	for(int i = 0; i < n; ++i) cin >> w[i];
	
	sort(w, w + n, greater<int>());  // 优化搜索顺序
	
	k = n / 2;
	dfs1(0,0);
	
	sort(weights, weights+cnt);
	cnt = unique(weights, weights + cnt) - weights;  // 冗余性剪枝
	
	dfs2(k, 0);
	
	cout << ans << endl;
	
	return 0;
}