SCOI2005 骑士精神（Knight） 启发式搜索 迭代加深

NKOJ2561 SCOI2005 骑士精神（Knight）

问题描述

在一个5×5的棋盘上有12个白色的骑士和12个黑色的骑士， 且有一个空位。在任何时候一个骑士都能按照骑士的走法（它可以走到和它横坐标相差为1，纵坐标相差为2或者横坐标相差为2，纵坐标相差为1的格子）移动到空位上。
给定一个初始的棋盘，怎样才能经过移动变成如下目标棋盘：

为了体现出骑士精神，他们必须以最少的步数完成任务。

输入格式

第一行有一个正整数T(T<=10)，表示一共有N组数据。接下来有T个5×5的矩阵，0表示白色骑士，1表示黑色骑士，*表示空位。两组数据之间没有空行。

输出格式

对于每组数据都输出一行。如果能在15步以内（包括15步）到达目标状态，则输出步数，否则输出－1。

样例输入

2
10110
01*11
10111
01001
00000
01011
110*1
01110
01010
00100

样例输出

7
-1

---

首先，要求在限定步数内走的最小值，显然使用迭代加深。

然而，直接爆搜的话，理论上最多有$8^{15}$种状态，这样是肯定会TLE的，考虑剪枝。

由于每次操作只能改变两个元素的位置，而且必须对空白格进行操作。因此，执行$n$次操作最多使得$n+1$个格子达到正确的状态。根据这个容易写出估价函数G()表示不在正确位置上的元素个数，那么当$dep>G()+cur-1$时，显然不可能搜出解了。

本来我还写了个优先队列的A*，结果发现还不如直接转移来得快。

---

代码：

#include<stdio.h>
#include<algorithm>
using namespace std;

bool Find;
char Map[10][10],Tmp[10][10];
int dep;

int pos[5][5]={{1,1,1,1,1},{0,1,1,1,1},{0,0,2,1,1},{0,0,0,0,1},{0,0,0,0,0}};
int dx[8]={-2,-2,-1,-1,1,1,2,2},dy[8]={1,-1,2,-2,2,-2,1,-1};

int G()
{
    int i,j,cnt=0;

    for(i=0;i<5;i++)
    for(j=0;j<5;j++)if(Map[i][j]-'0'!=pos[i][j])cnt++;

    return cnt;
}

void DFS(int cur)
{
    if(Find)return;
    if(cur==dep)
    {
        if(G()==0)Find=true;
        return;
    }
    if(cur+G()-1>dep)return;

    int i,j,k,tx,ty,x,y;

    for(i=0;i<5;i++)
    for(j=0;j<5;j++)if(Map[i][j]=='2')x=i,y=j;

    for(k=0;k<8;k++)
    {
        tx=x+dx[k];ty=y+dy[k];
        if(tx>=0&&ty>=0&&tx<5&&ty<5)
        {
            swap(Map[tx][ty],Map[x][y]);
            DFS(cur+1);
            swap(Map[tx][ty],Map[x][y]);
        }
    }
}

int main()
{
    int T,i,j;
    scanf("%d",&T);
    while(T--)
    {
        for(i=0;i<5;i++)scanf("%s",&Map[i][0]);

        for(i=0;i<5;i++)
        for(j=0;j<5;j++)if(Map[i][j]=='*')Map[i][j]='2';

        if(G()==0)
        {
            puts("0");
            continue;
        }

        Find=false;
        for(dep=1;dep<=15;dep++)
        {
            DFS(0);
            if(Find){printf("%d\n",dep);break;}
        }
        if(!Find)puts("-1");
    }
}