迭代加深

迭代加深：

170. 加成序列

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

1. $X[1]=1$
2. $X[m]=n$
3. $X[1]<X[2]<\dots <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

思路：

• 由于数据范围为 $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\le N\le 46$,
$1\le W,G[i]\le 2^{31}-1$

输入样例：

20 5
7
5
4
18
1

输出样例：

19

思路：

• 将所有物品按照重量从大到小排序
• 先将前 $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\le n\le 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\times 14+14\times 13+...+2\times 1}{2}=560$，考虑在 $4$ 步内解决，最多有 $560^4\approx 10^{10}$ 个状态，会超时
• 考虑使用 双向BFS 或者 IDA* 来优化
• 估价函数：

  • 估价函数需要满足：不大于实际步数

  • 在最终状态下，每本书后面的书的编号应该比当前书多 $1$

  • 

  • 每次移动最多会断开三个相连的位置，再重新加入三个相连的位置，因此最多会将 $3$ 个错误的连接修正，所以如果当前有 $tot$ 个连接，那么最少需要 $\lceil \frac{tot}{3}\rceil$ 次操作。

  • 因此当前状态 $s$ 的估价函数可以设计成 $f(s)=\lceil \frac{tot}{3}\rceil$。

#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$ 个数进行设计，求得出现次数做多的那个数的个数 $cnt$，至少最少还需要移动 $8-cnt$ 才能到达最终结果，因此估计函数设计为 $f()=8-cnt$

#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/