uva1343(The Rotation Game)=>IDA*

因为8个转轮对应的位置比较没有规律，需要提前将这些位置存在数组中，方便旋转操作和回溯法的归位操作。

利用数组来人为储存没有规律的数字。可以使用IDA*的算法。

IDA*合了bfs步数最少和dfs字典序最小的优点。

本题的移动比较复杂，因此应当事先保存A,B,C,D四个方向的位置，后四个方向可以反推出来。同时还要保存要观察的8个格子的位置。接下来，先判断是否就是目标状态，如果不是，进行迭代加深搜索。

首先要明白迭代加深搜索具体是如何操作的：从小到大依次枚举深度上限maxd。对于每一个深度上限，进行dfs，当递归到maxd时，就要判断是否找到了解，如果找到了，就记录或者输出解。不论是否找到了解，都要开始返回，对于找到了解的情况，可以在函数出口处连续返回。

那么如何及时的返回呢？答案就是寻找“估价函数”并“剪枝”。对于本题，可以发现，每次移动最多只能让目标数字多1个，因此可以将min{diff(1),diff(2),diff(3)}作为估价函数。其中diff(i)是目标格子中不等于数字i的个数。这样以来，如果发现最少要移动的步数h()仍然大于maxd-cur，就需要进行剪枝。

需要注意的是，迭代加深搜索必须在解一定存在的情况下使用，否则会产生无限递归。

代码如下：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<vector>
using namespace std;
const int a[8][7]={
{ 0, 2,6,11,15,20,22}, //按顺序填写个状态:A
{ 1,3,8,12,17,21,23},//B
{10, 9,8,7,6,5,4},//C
{19,18,17,16,15,14,13},//D
{23,21,17,12,8,3,1},//E
{22,20,15,11,6,2,0},//F
{13,14,15,16,17,18,19},//G
{4,5,6,7,8,9,10}//H
};
const int rev[8]={5,4,7,6,1,0,3,2};//用于回溯把数组状态改回
const int center[8]={6,7,8,11,12,15,16,17};//中间八个数字的编号
int st[24],te[24];
bool is_goal(){//看是否是目标状态
for(int i=0;i<8;i++) if(st[center[i] ]!=st[center[0] ]) return false;
return true;
}
inline void move(int i){//移动棋盘
int temp=st[a[i][0]];
for(int j=0;j<6;j++) st[a[i][j]]=st[a[i][j+1]];
st[a[i][6]]=temp;
}
int diff(int val){
int num=0;
for(int i=0;i<8;i++) if(st[center[i]]!=val) num++;
return num;
}
inline int h(){//统计中间八个数字中还有多少个不正确的
return min(min(diff(1),diff(2)),diff(3));
}
char ans[100],kk;
bool dfs(int d,int maxd){
if(is_goal()){
    ans[kk]='\0'; puts(ans);
    printf("%d\n",st[center[0]]);
    return true;
}
if(d+h()>maxd) return false;//估价函数
for(int i=0;i<8;i++){
ans[kk++]='A'+i;
move(i);
if(dfs(d+1,maxd)) return true;
move(rev[i]);//回溯改回棋盘原始状态
kk--;
}
return false;
}
int main()
{
    while(scanf("%d",&te[0])&&te[0]){
        for(int i=1;i<24;i++){
            scanf("%d",&te[i]);
        }
        int maxd;
        for(int i=0;i<24;i++) {st[i]=te[i]; if(te[i]==0)  return 0;}
        if(is_goal()) {
            printf("No moves needed\n%d\n",te[center[0]]);
        }
        else {
        for(int i=0;i<24;i++) st[i]=te[i];
        for(maxd=1;;maxd++){//深度限制
            kk=0;
            if(dfs(0,maxd)) break;
        }
        }
    }
    return 0;
}

稍微解释一下，d是从起点到当前状态的总步数，MAXD是我们提前通过计算证明得到的最短路线总步数的上限，h()是启发函数，是整个算法的关键，我们设计的h()可以预估从当前状态到目标状态至少需要的步数。

这样，上面的关系式就很好理解了。d+ h() > MAXD 意味着当前已经走的步数＋至少还需要的步数 > 我可以走的步数上限，这种状态，必然已经没有继续的必要，回溯。