给定1 < n < 10,的一个序列,可以剪切粘贴任意连续部分,求最少几次操作可以排成1..n
典型的状态空间搜索。
每个序列就是一种状态,通过剪切粘贴互相转移。
1.9!*每次可能的移动数,可能超时。
2.启发函数:统计序列的无效状态(即a[i] + 1 != a[i + 1])的个数h,每次移动最多改变3个无效状态,所以当3 * d + h > 3 * maxd时,可以剪枝。
3.ps:血的教训,状态数组一定要用类或结构体表示。
4.默认已经排好序的不拆开比拆开步数少
5.虽然n = 9时,最笨的9 8 7 6 5 4 3 2 1需要8次,但是一般貌似最多是5次,所以限制了maxd,不限制也可以。
//memcmp按字节比较,根据大小返回<0,0,>0
//应该封装成类,这样还可以传引用,数组不好传
//移动原则
//向后移
//将[i,j]移到k后面
//将连续的作为一个整体
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn = 10;
struct state{
int a[maxn];
}num,tmp;//使用前要初始化
const int dest[maxn] = {1,2,3,4,5,6,7,8,9,10};
int maxd = 1;
int n;
bool heuristic(int d,int cur[maxn])//启发函数
{
int h = 0;
for (int i = 1; i < n; i ++) {
if(cur[i] != cur[i - 1] + 1) h ++;
}
return 3 * d + h <= 3 * maxd;//大于的时候要被剪枝了
}
bool dfs(int d,state s)
{
if (d == maxd) {
if (memcmp(s.a, dest, sizeof(int) * n) == 0) {
return true;
}
}
state nt;
bool succ = false;
for (int i = 0; i < n; i ++) {//将[i,j]移到k后面
for (int j = i;j < n ; j ++) {
while(s.a[j + 1] == s.a[j] + 1 && j + 1 < n) j ++;//将连续的作为一个整体
for (int k = j + 1; k < n; k ++) {
while(s.a[k + 1] == s.a[k] + 1 && k + 1 < n) k ++;//将连续的作为一个整体
memcpy(nt.a, s.a, sizeof(int) * n);
memcpy(nt.a + i, s.a + j + 1, sizeof(int) * (k - j));
memcpy(nt.a + i + k - j, s.a + i, sizeof(int) * (j - i + 1));
if(heuristic(d + 1,nt.a) && dfs(d + 1,nt)) {return succ = true;}
}
}
}
return succ;
}
int IDA()
{
for (maxd = 1; maxd < 6; maxd ++) {
if(heuristic(0,num.a) && dfs(0,num)) return maxd;
}
return 0;
}
int main()
{
int cn = 0;
while (scanf("%d",&n) != EOF && n) {
for (int i = 0; i < n; i ++) {
scanf("%d",&num.a[i]);
}
int ans = IDA();
printf("Case %d: %d\n",++cn,ans);
}
return 0;
}