题目描述

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

1、X[1]=1

2、X[m]=n

3、X[1]<X[2]<…<X[m-1]<X[m]

4、对于每个 kk（2≤k≤m2≤k≤m）都存在两个整数 ii 和 jj （1≤i,j≤k−11≤i,j≤k−1，ii 和 jj 可相等），使得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

题解

一、爆搜

第一项是1，第二项是2，从第三项开始，每项都是前面任意两项之和，即第k项最多有(k - 1)*k/2种可能。因此存在一种极端的情况，每一项都是前一项加一，那么这样搜索的层数就有近100层，每层要搜索的是k的2次方级别，肯定会超时的。

二、迭代加深优化

1、 1 2 4 8 16 32 64 128；从这个序列中我们可以看到最快需要6次就可以达到100，这说明搜索到答案需要的递归的层次并不多，因此我们可以用迭代加深的方法每次定义一个最大的迭代次数max_depth，如果在这个max_depth中没找到答案，那么max_depth+1, 直到找到答案。

2、在搜索过程中，填入第k项的数优先选择最大的，这样可以更快的接近答案，节约时间。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;

const int N = 110;

int n, path[N];

bool dfs(int u, int depth)
{
    if(u > depth) return false;
    if (path[u - 1] == n) return true;

    //排除等效冗余
    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 (s > n || s <= path[u - 1]) continue;
            path[u] = s;
            st[s] = true;
            if (dfs(u + 1, depth)) return true;
        }
    return false;

}


int main()
{
    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;
}