大纲
1.迭代加深搜索 2.双向搜索
1.迭代加深搜索
问题描述：在古埃及，人们使用单位分数的和(形如1/a的, a是自然数)表示一切有理数。
埃及分数
在古埃及，人们使用单位分数的和(形如1/a的, a是自然数)表示一切有理数。 如：2/3=1/2+1/6,但不允许2/3=1/3+1/3,因为加数中有相同的。
对于一个分数a/b,表示方法有很多种，但是哪种最好呢？ 首先，加数少的比加数多的好，其次，加数个数相同的，最小的分数越大越好，如果最小的相等，则看次小的，以此类推。
如： 19/45=1/3 + 1/12 + 1/180 19/45=1/3 + 1/15 + 1/45 19/45=1/3 + 1/18 + 1/30, 19/45=1/4 + 1/6 + 1/180 19/45=1/5 + 1/6 + 1/18. 最好的是最后一种，因为1/18比1/180,1/45,1/30,1/180都大。
给出a,b(0<a<b<500),编程计算最好的表达方式。
输入格式
一行，两个整数a和b
输出格式
若干个数，从小到大排序，输出埃及分数的分母
输入输出样列
输入样例1：
19 45
输出样例1：
5 6 18
于一个分数 a/b , 表示方法有很多种，定义最优的表示方法满足以下条件：
① 加数少的比加数多的好。
② 加数个数相同的，最小的分数越大越好，如果最小的相等，则看次小的，依此类推。
最好的是最后一种，因为1/18比1/180,1/45,1/30都大。 给出a,b(0 < a < b < 500), 计算最好的表达式，从小到大输出最好表达式的分母。 使用回溯法求解，该问题解答树的深度不确定，宽度也不确定，导致解答树非常巨大。
迭代加深搜索
迭代加深搜索：首先深度优先搜索d层，若没有找到可行解，再深度优先搜索d+1层，以此类推，直到找到可行解为止。 DFS搜索解答树时，会走到最底层再回头，对于较深的解答树搜索量巨大。 BFS搜索解答树时，会走到最右边再搜索下一层，对于较宽的解答树搜索量和存储空间巨大。 由于加数个数越少越好，所以可以限定解答树的深度maxd，由浅到深进行搜索。 确定了最大深度maxd后，如何搜索？ 到达目的地：已经搜索的层数d == maxd. 待选集合：d层分母最小为d - 1层所选分母+1； 剪枝：设：当前搜索到d层，分母为i, 剩余分数为：cura/curb 如果 (maxd + 1) * (1/i) <= cura/curb则无解。
💯CODE代码
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
typedef long long ll;
ll a, b, maxd, tmp[N], ans[N];
ll gcd (ll x, ll y)
{
return y == 0 ? x : gcd (y, x % y);
}
bool better ()
{
for (int i = maxd; i >= 1; i -- )
if (tmp[i] != ans[i])
return ans[i] == 0 || tmp[i] < ans[i];
}
bool dfs (ll d, ll pre, ll cura, ll curb)
{
if (d == maxd)
{
if (curb % cura != 0) return false;
tmp[d] = curb / cura;
if (better ())
for (int i = 1; i <= d; i ++ ) ans[i] = tmp[i];
return true;
}
bool ok = false;
for (ll i = max (pre, curb / cura) + 1; ; i ++ )
{
if (curb * (maxd - d - 1) <= i * cura) break;
tmp[d] = i;
ll tb = curb * i, ta = cura * i - curb;
ll g = gcd (ta, tb);
if (dfs (d + 1, i, ta / g, tb / g)) ok = true;
}
return ok;
}
int main ()
{
cin >> a >> b;
ll g = gcd (a, b);
a /= g, b /= g;
for (maxd = 1; ; maxd ++)
if (dfs (1, 0, a, b))
{
for (int i = 1; i <= maxd; i ++ ) cout << ans[i] << ' ';
break;
}
}
2.双向搜索
双向搜索：在一些题目中，问题不但具有“初始状态”，也具有明确的“最终状态”，并且 从初始状态开始搜索和从终止状态开始搜索，都能覆盖整个搜索树或者状态空间，在这种情 况下，就可以采用双向搜索：从初始状态和最终状态出发各搜索一半状态，产生两颗深度减 半的搜索树，在中间交会、组合成最终答案。
送礼物
六一儿童节快到了，小D有个任务是给科丁乐的小朋友派送礼物。现在一共有N个礼物，且每个礼物都异常的沉重，但是小D的力气也是很大的，他一次可以搬动重量之和在w(w≤2^31-1)以下的任意多个物品。小D希望一次搬掉尽量多一些物品，请你告诉他在他的力量范围内一次性能搬动的最大重量是多少？
输入格式
第一行，两个整数，分别表示w和N
接下来N行，每行一个整数G[i](G[i]≤2^31-1)，分别表示N个物品的重量
输出格式
一个整数，表示在小D的力量范围内一次性能够搬动的最大重量
输入输出样列
输入样例1：
20 5
7
5
4
18
1
输出样例1：
19
说明
数据规模：
对于20%的数据 N≤26
对于40%的数据 w≤2^26
对于100%的数据 N≤45 w≤2^31-1
该问题是一个背包问题，从N个物品中选出一些，是他们的重量和最接近w 搜索：子集问题，对于任何一个物品都可选可不选，时间复杂度O(2^n) 双向搜索：将礼物分成A, B两部分： ① 首先搜索A部分的礼物，将搜索出的重量在[0, w]之间的所有值保存为数组X，并排序去重。 ② 接着搜索B部分的礼物，对于搜索出的每个<=w的重量t，在X中查找<=w-t的最大值。 优化搜索顺序：将物品重量按照从大到小排序，优先搜索重量较大的（尽快失败）。
#include <bits/stdc++.h>
using namespace std;
typedef vector<long long> :: iterator ITER;
typedef long long ll;
const int N = 50;
ll n, w, G[N], mid, ans;
vector<long long> result;
bool ok = false;
void dfs1 (int cur, long long sum)
{
if (ok) return ;
if (cur > mid)
{
result.push_back (sum);
if (sum == w) ok = true;
return ;
}
dfs1 (cur + 1, sum);
if (sum + G[cur] <= w) dfs1 (cur + 1, sum + G[cur]);
}
void dfs2 (int pre, long long sum)
{
if (ok) return ;
ITER it = upper_bound (result.begin (), result.end (), w - sum);
if (it != result.begin ()) ans = max (ans, sum + * (-- it));
if (ans == w) ok = true;
for (int i = pre + 1; i <= n; i ++ )
if (sum + G[i] <= w)
dfs2 (i, sum + G[i]);
}
bool cmp (const ll& x, const ll& y)
{
return x > y;
}
int main ()
{
cin >> w >> n;
for (int i = 1; i <= n; i ++ ) cin >> G[i];
sort (G + 1, G + n + 1, cmp);
mid = n >> 1;
dfs1 (0, 0);
if (ok)
{
cout << w;
return 0;
}
sort (result.begin (), result.end ());
result.resize (unique (result.begin (), result.end ()) - result.begin ());
dfs2 (mid, 0);
cout << ans;
}
