IDA*学习日记 + 例题（poj3460 poj2286）

IDA* 是A*中的预估函数和迭代加深DFS的结合

对于不同深度限制的DFS，假如当前深度+未来预估步数>深度限制，那么直接回溯。

和A*一样，IDA*的预估函数也要求小于等于实际需要迭代次数

 

poj 3460 Booksort 

http://poj.org/problem?id=3460

题意：

给定n本书，编号为1-n，在初始状态下，书是任意排列的，在每一次操作中，可以抽取其中连续的一段，再把这段插入到其他某个位置。

我们的目标状态是把书按照1-n的顺序依次排列，求最少需要多少次操作

 

先（极度）粗劣的算一下一共有多少种情况：

每个地方都可以放不同的书，那么大概应该是n^n种情况，而n<=15，直接暴力搜索是不可以接受的

 

对于某个排列的书籍，假如 第i本书的编号 + 1 不等于第i+1本书的编号，就说明这两者之间一定需要重新排列。

对于每一次排列，我们取编号从L到R的书籍，插入编号为K的书籍后面，这样对于一次操作，我们可以改变3个地方的节点前后关系：

L-1 ~ L

R~R+1

K~K+1

 

因此对于预估函数，用cnt表示所有 第i本书编号+1不等于第i+1本书的编号 的数量，然后返回cnt/3（上取整），作为预估值

#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<cstdio>
using namespace std;
const int maxn = 17;
int num[maxn];
int depth, n;
int sto[maxn][maxn];
int perdict() {
	int cnt = 0;
	for (int i = 1; i < n; i++) {
		if (num[i + 1] != num[i] + 1)
			cnt++;
	}
	return (cnt + 2) / 3;
}
bool check() {
	for (int i = 1; i <= n; i++)
		if (num[i] != i)
			return 0;
	return 1;
}
void num_swap(int fro, int to, int len) {
	int a[maxn];
	memset(a, 0, sizeof(a));
	int ind = 1;
	for (int i = 1; i < fro; i++) a[ind++] = num[i];
	for (int i = fro + len; i <= to; i++) a[ind++] = num[i];
	for (int i = fro; i < fro + len; i++) a[ind++] = num[i];
	for (int i = to + 1; i <= n; i++) a[ind++] = num[i];
	for (int i = 1; i <= n; i++) num[i] = a[i];
}
bool IDA(int now) {
	if (now + perdict() > depth)
		return 0;
	if (check()) 
		return 1;
	for (int len = 1; len <= n; len++) { //枚举长度
		for (int i = 1; i + len - 1 <= n; i++) { //枚举起点
			int j = i + len - 1;
			for (int k = j + 1; k <= n; k++) { //枚举放入的点，放到k点之后
				memcpy(sto[now], num, sizeof(num)); //保存副本
				num_swap(i, k, len); 
				if (IDA(now + 1)) 
					return 1;
				memcpy(num, sto[now], sizeof(sto[now]));
			}
		}
	}
	return 0;
}
int main() {
	int t; cin >> t;
	while (t--) {
		cin >> n;
		for (int i = 1; i <= n; i++) {
			scanf("%d", num + i);
		}
		int ans = -1;
		for (depth = 0; depth < 5; depth++) {
			if (IDA(0)) {
				ans = depth;
				break;
			}
		}
		if (ans >= 0) {
			cout << ans << endl;
		}
		else cout << "5 or more" << endl;
	}
	return 0;
}

 

 

 

 

poj 2286  The Rotation Game

http://poj.org/problem?id=2286

题意：

有一个“#”形的棋盘，上面有1,2,3三种数字各8个。

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

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

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

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

 

这道题的预估函数好想很多，就是中间那个区域最多的相同数字的个数

假如需要输出最小字典序，那么在搜索的时候就按从A~H的顺序搜索就行了

（就是写的时候稍显麻烦）

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#define ll long long 
#define ull unsigned long long 
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 9;
int ori[maxn][maxn], num[maxn][maxn];
int depth = 0, ans, ind;
int sto[10000];
int flag[4];
int perdict() {
	memset(flag, 0, sizeof(flag));
	int mx = 0;
	for (int i = 3; i <= 5; i++) {
		for (int j = 3; j <= 5; j++) {
			if (i == 4 && j == 4) continue;
			flag[num[i][j]]++;
		}
	}
	return 8 - max(flag[1], max(flag[2], flag[3]));
}
bool check() {
	int flag = num[3][3];
	for (int i = 3; i <= 5; i++) {
		if (flag != num[3][i] || flag != num[i][3])
			return 0;
		if (flag != num[5][i] || flag != num[i][5])
			return 0;
	}
	return 1;
}
void mov(int x) {
	static int sto;
	if (x == 0) {
		sto = num[1][3];
		for (int i = 1; i < 7; i++)
			num[i][3] = num[i + 1][3];
		num[7][3] = sto;
	}
	else if (x == 1) {
		sto = num[1][5];
		for (int i = 1; i < 7; i++)
			num[i][5] = num[i + 1][5];
		num[7][5] = sto;
	}
	else if (x == 2) {
		sto = num[3][7];
		for (int i = 7; i > 1; i--)
			num[3][i] = num[3][i - 1];
		num[3][1] = sto;
	}
	else if (x == 3) {
		sto = num[5][7];
		for (int i = 7; i > 1; i--)
			num[5][i] = num[5][i - 1];
		num[5][1] = sto;
	}
	else if (x == 4) {
		sto = num[7][5];
		for (int i = 7; i > 1; i--)
			num[i][5] = num[i - 1][5];
		num[1][5] = sto;
	}
	else if (x == 5) {
		sto = num[7][3];
		for (int i = 7; i > 1; i--)
			num[i][3] = num[i - 1][3];
		num[1][3] = sto;
	}
	else if (x == 6) {
		sto = num[5][1];
		for (int i = 1; i < 7; i++)
			num[5][i] = num[5][i + 1];
		num[5][7] = sto;
	}
	else if (x == 7) {
		sto = num[3][1];
		for (int i = 1; i < 7; i++)
			num[3][i] = num[3][i + 1];
		num[3][7] = sto;
	}
}

int turn(int x) {
	if (x == 0) return 5;
	else if (x == 1) return 4;
	else if (x == 2) return 7;
	else if (x == 3) return 6;
	else if (x == 4) return 1;
	else if (x == 5) return 0;
	else if (x == 6) return 3;
	else return 2;
}
bool IDA(int now_depth) {
	if (check()) {
		ans = now_depth;
		return 1;
	}
	if (now_depth + perdict() > depth)
		return 0;
	for (int i = 0; i < 8; i++) { //分别对应A~G
		if (ind&&sto[ind] == turn(i)) continue; //不要拧回去了
		sto[++ind] = i;
		mov(i);
		if (IDA(now_depth + 1))
			return 1;
		mov(turn(i));
		ind--;
	}
	return 0;
}
int main() {
	int t;
	while (cin >> t, t) {
		ind = 0;
		int beg = 0;
		for (int i = 1; i <= 7; i++) {
			for (int j = 1; j <= 7; j++) {
				if (i == 3 || i == 5 || j == 3 || j == 5) {
					if (beg == 0) {
						beg = 1;
						num[i][j] = ori[i][j] = t;
					}
					else {
						scanf("%d", &ori[i][j]);
						num[i][j] = ori[i][j];
					}
				}
			}
		}
		if (check()) {
			cout << "No moves needed" << endl;
			cout << num[3][3] << endl;
			continue;
		}
		for (depth = 1; depth; depth++) {
			ind = 0;
			if (IDA(0)) {
				break;
			}
		}
		for (int i = 1; i <= ind; i++)
			cout << (char)(sto[i] + 'A');
		cout << endl;
		cout << num[3][3] << endl;
	}
	return 0;
}