DFS之迭代加深、双向DFS、IDA*

ZZTC

已于 2025-01-09 21:32:43 修改

阅读量642

点赞数 27

分类专栏：算法文章标签：深度优先迭代加深算法

于 2025-01-09 21:29:32 首次发布

本文链接：https://blog.youkuaiyun.com/qq_73628657/article/details/145043007

版权

算法专栏收录该内容

23 篇文章

订阅专栏

迭代加深

迭代加深：

170. 加成序列

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

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

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

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

输入格式

输入包含多组测试用例。

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

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

输出格式

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

每个输出占一行。

数据范围

$1 \leq n \leq 100$

输入样例：

输出样例：

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

思路：

由于数据范围为 $100$ ，因此整棵树最大的高度为 $100$ ，但是由于需要满足某一个数需要等于前两个数的和，因此最大序列 $1 、 2 、 4 、 8 、 16 、 32 、 64 、 128$ ，高度也为 $8$ 左右，因此答案的深度较浅，可以使用迭代加深算法

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 105;
int n, path[N];

bool dfs(int u, int max_depth){
    if(u > max_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] || st[s]) continue;
            st[s] = true;
            path[u] = s;
            if(dfs(u + 1, max_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;
}

双向DFS

171. 送礼物

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

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

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

输入格式

第一行两个整数，分别代表 $W$ 和 $N$ 。

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

输出格式

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

数据范围

$1 \leq N \leq 46$ ,
$1≤W,G[i]≤2^{31}−1$

输入样例：

输出样例：

思路：

将所有物品按照重量从大到小排序
先将前 $K$ 件物品能凑出的所有重量打表。然后排序并判重
搜索剩下的 $N - K$ 件物品的选择方式，然后在表中二分出不超过 $W$ 的最大值

#include<iostream>
#include<algorithm>
using namespace std;
typedef long long LL;
const int N = 46;
int n, m;
int w[N];
int weights[1 << 25], cnt = 1, k, ans;

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

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] <= m - s) l = mid;
            else r = mid - 1;
        }
        ans = max(ans, weights[l] + s);
        return;
    }
    dfs2(u + 1, s);
    if((LL)s + w[u] <= m) dfs2(u + 1, s + w[u]);
}

int main(){
    cin >> m >> n;
    for (int i = 0; i < n; i++) cin >> w[i];
    sort(w, w + n);
    reverse(w, w + n);
    k = n / 2;
    dfs1(0, 0);
    sort(weights, weights + cnt);
    cnt = unique(weights, weights + cnt) - weights;
    dfs2(k, 0);
    cout << ans << endl;
    return 0;
}

IDA*

IDA* 和 A* 算法思路相似，提供一个估价函数，同时估价函数小于等于真实值，估算当前点到最终结果还需要走多少 depth，如果当前值加上估计值已经大于了最终的计算答案 max_depth，说明当前值加上再走最少的值都会超过答案，则提前退出了。

180. 排书

给定 $n$ 本书，编号为 $1 \sim n$ 。

在初始状态下，书是任意排列的。

在每一次操作中，可以抽取其中连续的一段，再把这段插入到其他某个位置。

我们的目标状态是把书按照 $1 \sim n$ 的顺序依次排列。

求最少需要多少次操作。

输入格式

第一行包含整数 $T$ ，表示共有 $T$ 组测试数据。

每组数据包含两行，第一行为整数 $n$ ，表示书的数量。

第二行为 $n$ 个整数，表示 $1 \sim n$ 的一种任意排列。

同行数之间用空格隔开。

输出格式

每组数据输出一个最少操作次数。

如果最少操作次数大于或等于 $5$ 次，则输出 5 or more。

每个结果占一行。

数据范围

$1 \leq n \leq 15$

输入样例：

3
6
1 3 4 6 2 5
5
5 4 3 2 1
10
6 8 5 3 4 7 2 9 1 10

输出样例：

2
3
5 or more

思路：

遍历长度，对每一段长度为 $i (i \in [1, n))$ 进行遍历，长度为 $i$ 的时候，选法有 $n - i + 1$ 中，然后对于这一段长度还剩下 $n - i$ 个数据，有 $n - i + 1$ 个可插入的空位，除去自身原来那个位置的话，还剩余 $n - i$ 个空位可以选择，因此对于长度为 $i$ 的情况就有 $(n - i + 1) (n - i)$ 种方式，取 $n = 15$ 的时候，总计 $\sum_{i=1}^{14}(n-i+1)(n-i)=\frac{15×14+14×13+...+2×1}{2}=560$ ，考虑在 $4$ 步内解决，最多有 $560^4≈10^{10}$ 个状态，会超时
考虑使用 双向BFS 或者 IDA* 来优化
估价函数：
- 估价函数需要满足：不大于实际步数
- 在最终状态下，每本书后面的书的编号应该比当前书多 $1$
- 每次移动最多会断开三个相连的位置，再重新加入三个相连的位置，因此最多会将 $3$ 个错误的连接修正，所以如果当前有 $t o t$ 个连接，那么最少需要 $⌈\frac{tot}{3}⌉$ 次操作。
- 因此当前状态 $s$ 的估价函数可以设计成 $f(s)=⌈\frac{tot}{3}⌉$ 。

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 15;
int n;
int q[N];
int w[5][N];

int f(){
    int tot = 0;
    for (int i = 0; i + 1 < n; i++){
        if(q[i + 1] != q[i] + 1) tot++;
    }
    return (tot + 2) / 3;
}

bool dfs(int depth, int max_depth){
    if(depth + f() > max_depth) return false;
    if(f() == 0) return true;
    for (int len = 1; len < n; len++){
        for (int l = 0; l + len - 1 < n; l++){
            int r = l + len - 1;
            for (int k = r + 1; k < n; k++){
                memcpy(w[depth], q, sizeof q);
                int y = l;
                for (int x = r + 1; x <= k; x++, y++) q[y] = w[depth][x];
                for (int x = l; x <= r; x++, y++) q[y] = w[depth][x];
                if(dfs(depth + 1, max_depth)) return true;
                memcpy(q, w[depth], sizeof q);
            }
        }
    }
    return false;
}

int main(){
    int t;
    cin >> t;
    while(t--){
        cin >> n;
        for (int i = 0; i < n; i++) cin >> q[i];
        int depth = 0;
        while(depth < 5 && !dfs(0, depth)) depth++;
        if(depth >= 5) cout << "5 or more" << endl;
        else cout << depth << endl;
    }
    return 0;
}

181. 回转游戏（思路重要!!!）

如下图所示，有一个 # 形的棋盘，上面有 $1, 2, 3$ 三种数字各 $8$ 个。

给定 $8$ 种操作，分别为图中的 $A \sim H$ 。

这些操作会按照图中字母和箭头所指明的方向，把一条长为 $7$ 的序列循环移动 $1$ 个单位。

例如下图最左边的 # 形棋盘执行操作 $A$ 后，会变为下图中间的 # 形棋盘，再执行操作 $C$ 后会变成下图最右边的 # 形棋盘。

给定一个初始状态，请使用最少的操作次数，使 # 形棋盘最中间的 $8$ 个格子里的数字相同。

输入格式

输入包含多组测试用例。

每个测试用例占一行，包含 $24$ 个数字，表示将初始棋盘中的每一个位置的数字，按整体从上到下，同行从左到右的顺序依次列出。

输入样例中的第一个测试用例，对应上图最左边棋盘的初始状态。

当输入只包含一个 $0$ 的行时，表示输入终止。

输出格式

每个测试用例输出占两行。

第一行包含所有移动步骤，每步移动用大写字母 $A \sim H$ 中的一个表示，字母之间没有空格，如果不需要移动则输出 No moves needed。

第二行包含一个整数，表示移动完成后，中间 $8$ 个格子里的数字。

如果有多种方案，则输出字典序最小的解决方案。

输入样例：

1 1 1 1 3 2 3 2 3 1 3 2 2 3 1 2 2 2 3 1 2 1 3 3
1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3
0

输出样例：

AC
2
DDHH
2

思路：

首先给棋盘和操作步骤进行编号
题目要求输出字典序最小的解决方案，因此每次从 $A - H$ 进行遍历操作，同时，如果上一步进行了 $A$ 操作，下一次就不能进行 $F$ 操作，不然就恢复原状了
估价函数设计：根据中间 $8$ 个数进行设计，求得出现次数做多的那个数的个数 $c n t$ ，至少最少还需要移动 $8 - c n t$ 才能到达最终结果，因此估计函数设计为 $f () = 8 - c n t$

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 24;

int op[8][7] = {
    {0, 2, 6, 11, 15, 20, 22},
    {1, 3, 8, 12, 17, 21, 23},
    {10, 9, 8, 7, 6, 5, 4},
    {19, 18, 17, 16, 15, 14, 13},
    {23, 21, 17, 12, 8, 3, 1},
    {22, 20, 15, 11, 6, 2, 0},
    {13, 14, 15, 16, 17, 18, 19},
    {4, 5, 6, 7, 8, 9, 10},
};
int opposite[8] = {5, 4, 7, 6, 1, 0, 3, 2};
int center[8] = {6, 7, 8, 11, 12, 15, 16, 17};
int q[N];
int path[100];

int f(){
    int sum[4] = {0};
    for(int i = 0; i < 8; i++) sum[q[center[i]]]++;
    int s = 0;
    for (int i = 1; i <= 3; i++) s = max(sum[i], s);
    return 8 - s;
}

void operate(int x){
    int t = q[op[x][0]];
    for (int i = 0; i < 6; i++) q[op[x][i]] = q[op[x][i + 1]];
    q[op[x][6]] = t;
}

bool dfs(int depth, int max_depth, int last){
    if(depth + f() > max_depth) return false;
    if(f() == 0) return true;
    for (int i = 0; i < 8; i++){
        if(opposite[i] != last){
            operate(i);
            path[depth] = i;
            if(dfs(depth + 1, max_depth, i)) return true;
            operate(opposite[i]);
        }
    }
    return false;
}

int main(){
    while(cin >> q[0], q[0]){
        for (int i = 1; i < N; i++) cin >> q[i];
        int depth = 0;
        while(!dfs(0, depth, -1)) depth++;
        if(!depth) printf("No moves needed");
        else{
            for (int i = 0; i < depth; i++) printf("%c", path[i] + 'A');
        }
        printf("\n%d\n", q[6]);
    }
    return 0;
}

更多内容详见个人博客内容：http://www.52baima.cn/