【搜索】迭代加深搜索-入门

一.定义

迭代加深搜索是一种用于解决问题的算法，它通过逐步增加搜索深度来寻找解决方案。在迭代加深搜索中，从起始状态开始，每次增加搜索深度，直到找到解决方案为止。

迭代加深搜索的主要优点是它可以在时间和空间上更有效地利用资源。它可以在搜索空间较小的情况下快速找到解决方案，而在搜索空间较大的情况下，则可以通过逐步增加搜索深度来避免过多的搜索。

迭代加深搜索的基本思想是深度优先搜索，但是在每次搜索时限制搜索深度。如果在当前深度下找到了解决方案，那么就返回该解决方案。否则，增加搜索深度并重新开始搜索。

迭代加深搜索的缺点是它可能会导致重复搜索相同的状态，因为在每次增加搜索深度时，搜索树的一部分可能被重新搜索。此外，迭代加深搜索可能会导致搜索时间过长，因为它需要不断地增加搜索深度，直到找到解决方案为止。

二.主要步骤

迭代加深搜索的主要步骤如下：

1. 设置搜索深度为1，从起始状态开始搜索。

2. 如果找到解决方案，则返回该解决方案。

3. 如果没有找到解决方案，增加搜索深度并重新开始搜索。

4. 重复步骤2和3，直到找到解决方案为止或者达到预设的搜索深度限制。

在每次搜索时，迭代加深搜索会记录已经访问过的状态，以避免重复搜索相同的状态。此外，为了提高搜索效率，可以使用一些启发式方法，如剪枝和排序等。

迭代加深搜索的时间复杂度为O(b^d)，其中b是分支因子，d是搜索深度。由于每次搜索时都需要重新搜索之前的状态，因此空间复杂度为O(bd)。但是，由于迭代加深搜索可以在每次搜索时限制搜索深度，因此在实际应用中，它可以在时间和空间上更有效地利用资源。

 

三.经典例题 

题目描述： 

 输入一个正数n，要求找到一个最短序列满足以下4个条件:
(1):A0 = 1 
(2): Am = n 
(3): A0 < A1 < A2 < ... < Am-1 < Am (4): k (1<=k<=m) ，存在i和j，(0<=i, j<=k-1) Ak=Ai+Aj。找出长度最小的m，并输出一组答案即可。

输入：

共一行一个整数n

输出：

共一行，一个整数m

样例输入：

4

样例输出：

1 2 4

四.核心代码（具体见注释）

 

// 深度优先搜索函数
bool dfs(int depth) {
    if (depth > max_depth) { // 如果当前搜索深度超过最大搜索深度
        if (fib[max_depth] == target) { // 判断是否找到目标和
            return true; // 找到目标和，返回true
        } else {
            return false; // 没有找到目标和，返回false
        }
    }
    bool visited[1001] = {0}; // 已访问状态数组
    for (int i = depth - 1; i >= 1; i--) { // 枚举所有可能的斐波那契数对
        for (int j = depth - 1; j >= 1; j--) {
            if (fib[i] + fib[j] <= fib[depth - 1]) {
                break; // 剪枝
            }
            if (!visited[fib[i] + fib[j]]) {
                visited[fib[i] + fib[j]] = true;
                fib[depth] = fib[i] + fib[j];
                if (dfs(depth + 1)) {
                    return true; // 找到目标和，返回true
                }
            }
        }
    }
    return false; // 没有找到目标和，返回false
}

五.【AC】代码

#include<iostream>
using namespace std;

int fib[1001], max_depth = 1, target; // 斐波那契数列数组、最大搜索深度、目标和

// 深度优先搜索函数
bool dfs(int depth) {
    if (depth > max_depth) { // 如果当前搜索深度超过最大搜索深度
        if (fib[max_depth] == target) { // 判断是否找到目标和
            return true; // 找到目标和，返回true
        } else {
            return false; // 没有找到目标和，返回false
        }
    }
    bool visited[1001] = {0}; // 已访问状态数组
    for (int i = depth - 1; i >= 1; i--) { // 枚举所有可能的斐波那契数对
        for (int j = depth - 1; j >= 1; j--) {
            if (fib[i] + fib[j] <= fib[depth - 1]) {
                break; // 剪枝
            }
            if (!visited[fib[i] + fib[j]]) {
                visited[fib[i] + fib[j]] = true;
                fib[depth] = fib[i] + fib[j];
                if (dfs(depth + 1)) {
                    return true; // 找到目标和，返回true
                }
            }
        }
    }
    return false; // 没有找到目标和，返回false
}

int main() {
    cin >> target; // 读入目标和
    if (target == 1) { // 特判
        cout << 1;
        return 0;
    }
    fib[0] = 0; // 赋初值
    fib[1] = 1;
    while (true) {
        max_depth++; // 增加搜索深度
        if (dfs(2)) { // 开始搜索
            for (int i = 1; i <= max_depth; i++) { // 输出斐波那契数列
                cout << fib[i] << " ";
            }
            return 0;
        }
    }
    return 0;
}