<—点个赞吧QwQ

宣传一下算法提高课整理

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

1. $X[1]=1$
2. $X[m]=n$
3. $X[1]<X[2]<…<X[m-1]<X[m]$
4. 对于每个 $k$（$2 \le k \le m$）都存在两个整数 $i$ 和 $j$ （$1 \le i,j \le k-1$，$i$ 和 $j$ 可相等），使得 $X[k]=X[i]+X[j]$。

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

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

输入格式

输入包含多组测试用例。

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

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

输出格式

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

每个输出占一行。

数据范围

$1 \le n \le 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

思路

这道题是为迭代加深量身定制的。
迭代加深也叫$\text{IDDFS}$，它是类似$\text{BFS}$的算法，也是一层一层的扩展，只不过一个是$\text{DFS}$，一个是$\text{BFS}$。
那$\text{IDDFS}$到底是怎么一个算法呢？他其实是限定了$\text{DFS}$的搜索深度，这就是为了答案可能在很浅层但是$\text{DFS}$会搜太深以至于$\text{TLE}$。
我们从小到大枚举最大深度的大小，每次都这样寻找答案。
有的人可能就会问：那每次增加一层，不会重复计算很多次吗？
其实，就算搜索树是二叉的，多加的一层节点数仅比前面所有的节点少$1$！更何况$k$叉的搜索树！
回到这道题，这道题如果每次都以$2^n$进行翻倍的话，那么序列是$1,2,4,8,16,32,64,128$，长度最多最多就只有$8$。但如果$1,1,2,2,\cdots,2$永远也搜不到答案。所以这道题很适合$\text{IDDFS}$来做。
这里还可以加一个强剪枝：每一个数最多是前一个数的$2$倍，所以就可以提前判断是否无解。

代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 10010;
int n;
int path[N];
bool dfs (int u,int depth) {
    if (u > depth) return false;
    if (path[u - 1] == n) return true;
    if (path[u - 1] * (1ll << (depth - u + 1)) < n) return false;
    bool st[N] = {};
    for (int i = 0;i <= u - 1;i++) {
        for (int j = 0;j <= i;j++) {
            int sum = path[i] + path[j];
            if (sum > n || sum <= path[u - 1] || st[sum]) continue;
            st[sum] = true;
            path[u] = sum;
            if (dfs (u + 1,depth)) return true;
        }
    }
    return false;
}
int main () {
    path[0] = 1;
    while (scanf ("%d",&n),n) {
        int depth = 1;
        while (!dfs (1,depth)) depth++;
        for (int i = 0;i < depth;i++) printf ("%d%c",path[i],i == depth - 1 ? '\n' : ' ');
    }
    return 0;
}