[学习][SCOI2005][bzoj1085]迭代加深 骑士精神

迭代加深的简介
嗯，我只能解释成搜一层不行搜两层、搜两层不行搜三层，依次往下搜，还是看看其他人的吧：
如果你准备开始搜索一个国际象棋的局面了，你要搜索多深呢？事先预测搜索将进行多少时间，这有些困难，因为完成D层搜索所需要的时间取决于很多不确定的因素。在复杂的中局局面里，你可能不会搜索得很深，而在残局中你可能会搜索得非常深，在某些王兵残局里你可能会搜索100多层。
　　有一个思想，就是一开始只搜索一层，如果搜索的时间比分配的时间少，那么搜索两层，然后再搜索三层，等等，直到你用完时间为止。
　　这足以保证很好地运用时间了。如果你可以很快搜索到一个深度，那么你在接下来的时间可以搜索得更深，或许你可以完成。如果局面比你想象的复杂，那么你不必搜索得太深，但是至少有合理的着法可以走了，因为你不太可能连1层搜索也完不成。
　　这个思想称为“迭代加深”(Iterative Deepening)，因为你在迭代搜索，每次都比一次前一次加深1层。 （来自Bruce Moreland）
　　
迭代加深的实现
正如我所说，搜一层不行搜两层，搜两层不行搜三层，依次往下搜，这样多次dfs，第一次找到的答案肯定是最小的，看似好像更慢（其实很多时候确实更慢，比如说要搜遍全图的时候[这不是废话吗……]，所以个人觉得这是个没什么用的思想），实际上它空间上接近dfs而时间上优于dfs（因为本来就是dfs），时间上接近bfs而空间上优于bfs（因为都是搜到答案就停），算是两个的折中，非常符合大中华的中庸之道（理论确实如划去部分，但是基本上都不可能单独用，随便出个答案深度大点的就卡TLE了）。

例题
题目背景
SCOI2005 DAY2 T1
bzoj1085

题目描述
在一个 5×5 的棋盘上有12个白色的骑士和 12 个黑色的骑士， 且有一个空位。在任何时候一个骑士都能按照骑士的走法（它可以走到和它横坐标相差为 1 ，纵坐标相差为 2 或者横坐标相差为 2 ，纵坐标相差为 1 的格子）移动到空位上。

给定一个初始的棋盘，怎样才能经过移动变成如下目标棋盘：

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

输入格式
第一行有一个正整数 T（T≤10），表示一共有 T 组数据。

接下来有 T 个 5×5 的矩阵，0 表示白色骑士，1 表示黑色骑士，* 表示空位。两组数据之间没有空行。

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

样例数据
输入

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

输出

7
-1

备注
【样例说明】
样例中第二个数据的初始情况对应该图：

分析：迭代加深模板（而且这道题存在-1的情况，也就是迭代加深会被卡TLE，所以还是要用A*优化），也可以直接用A*剪枝，详见[练习][SCOI2005][bzoj1085]搜索优化（A*） 骑士精神。

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
#include<queue>
#include<set>
using namespace std;

int getint()
{
    int sum=0,f=1;
    char ch;
    for(ch=getchar();!isdigit(ch)&&ch!='-';ch=getchar());
    if(ch=='-')
    {
        f=-1;
        ch=getchar();
    }
    for(;isdigit(ch);ch=getchar())
        sum=(sum<<3)+(sum<<1)+ch-48;
    return sum*f;
}

const char ori[6][6]={0, 0 , 0 , 0 , 0 , 0 ,
                      0,'1','1','1','1','1',
                      0,'0','1','1','1','1',
                      0,'0','0','*','1','1',
                      0,'0','0','0','0','1',
                      0,'0','0','0','0','0'};
int T,bjx,bjy,ans;
char map[6][6];
bool bjans;
const int fx[9]={0,1,1,-1,-1,2,2,-2,-2};
const int fy[9]={0,2,-2,2,-2,1,-1,1,-1};

int Ax()
{
    int res=-1;
    for(int i=1;i<=5;++i)
        for(int j=1;j<=5;++j)
            if(map[i][j]!=ori[i][j])
                res++;

    return res;
}

void dfs(int dep,int x,int y)
{
    int rest=Ax();
    if(rest==-1)
    {
        ans=min(ans,dep);
        bjans=1;
        return;
    }

    if(rest+dep>ans)
        return;

    for(int i=1;i<=8;++i)
    {
        int newx=x+fx[i];
        int newy=y+fy[i];
        if(newx>=1&&newx<=5&&newy>=1&&newy<=5)
        {
            swap(map[newx][newy],map[x][y]);
            dfs(dep+1,newx,newy);
            if(bjans==1)//由于迭代加深只要搜到了答案就是最优的，所以可以直接退出dfs了
                return;
            swap(map[newx][newy],map[x][y]);
        }
    }
}

int main()
{
    freopen("spirit.in","r",stdin);
    freopen("spirit.out","w",stdout);

    T=getint();
    while(T--)
    {
        for(int i=1;i<=5;++i)
        {
            for(int j=1;j<=5;++j)
            {
                map[i][j]=getchar();
                if(map[i][j]=='*')
                    bjx=i,bjy=j;
            }

            getchar();
        }

        ans=Ax(),bjans=0;//先算出至少走多少步（A*函数算）
        while(ans<=15)//只要没出答案就加一层
        {
            dfs(0,bjx,bjy);
            if(bjans==1)
                break;
            ans++;
        }

        if(bjans)
            cout<<ans<<'\n';
        else
            cout<<-1<<'\n';
    }
    return 0;
}

本题结。