洛谷 ·八数码难题【BFS & 启发式（IDA*】

初见安~这里是传送门：洛谷P1379。

题目描述

在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为123804765），找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。

输入格式：

输入初始状态，一行九个数字，空格用0表示

输出格式：

只有一行，该行只有一个数字，表示从初始状态到目标状态需要的最少移动次数(测试数据中无特殊无法到达目标状态数据)

输入样例

283104765

输出样例

4

题解

用BFS来做，过程为交换‘0’和上下左右任意方向的数字，直到拼出目标状态。就挺有BFS“不撞南墙不回头”的理念。大致思路是很简单的。

在存储和设置变量上，为了对比目标状态，我们可以为走的每一步后的状态——二维数组，开一个结构体并重定向“==”。但依据BFS的搜索套路，需要一个vis来记录是否走过这一步——即这个状态是否凑出来过。我们可以选择在结构体里顺便标一个号，or用一个set集合去重——但set会有一个内部的自动排序，所以我们还要重定向一个“<”or">"（因为我们实际上用不到）

代码如下——

#include<bits/stdc++.h>
using namespace std;
int sa,sb;
int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
bool in(int a,int b)//检查是否越界
{
    if(a>=0&&a<=2&&b>=0&&b<=2) return true;
    return false;
}
struct node
{
    int a[3][3];//状态
    int d,x,y;//步数及‘0’的位置
    bool operator < (const node &x) const
    {
        for(int i=0;i<3;i++)
            for(int j=0;j<3;j++)
            {
                if(a[i][j]!=x.a[i][j]) return a[i][j]<x.a[i][j];
            }
        return false;
    }
    bool operator == (const node &x) const
    {
        for(int i=0;i<3;i++)
            for(int j=0;j<3;j++)
            {
                if(a[i][j]!=x.a[i][j]) return false;
            }
        return true;
    }
}from,to; 

int bfs()
{
    if(from==to) return 0;
    queue<node> q;
    q.push(from);
    set<node> st;
    st.insert(from);//存入原状态
    while(!q.empty())
    {
        node now=q.front();
        q.pop();
        for(int i=0;i<4;i++)
        {
            int ta=now.x+dir[i][0];
            int tb=now.y+dir[i][1];
            if(in(ta,tb))
            {
                node tmp=now;
                tmp.d++;
                swap(tmp.a[ta][tb],tmp.a[now.x][now.y]);
                if(!st.count(tmp))
                {
                    if(tmp==to) return tmp.d;//达到目标状态，直接返回
                    tmp.x=ta;tmp.y=tb;//没有则存入继续
                    q.push(tmp); 
                    st.insert(tmp);
                }
            }
        }
    }
    return -1;
}

int main()
{
    char x;
    for(int i=0;i<3;i++)
        for(int j=0;j<3;j++)
        {
            cin>>x;
            from.a[i][j]=x-48;
            if(from.a[i][j]==0)//找到了初始的‘0’
            {
                from.x=i;from.y=j;
            }
        }

    to.a[0][0]=1;//直接赋值
    to.a[0][1]=2;
    to.a[0][2]=3;
    to.a[1][0]=8;
    to.a[1][1]=0;
    to.a[1][2]=4;
    to.a[2][0]=7;
    to.a[2][1]=6;
    to.a[2][2]=5;
    cout<<bfs()<<endl;
    return 0;
}

如上述做法用bfs的话效率其实挺低的，总计耗时8300+ms。并且很明显会有很多无用的状态被存进去，被取出来扩展。所以——就可以用到迭代加深的启发式搜索来优化！！！
估价函数就写当前位置和目标状态ans相比不在正常位置上的点的数量，如果估价 + 当前步数 > 我们限定的步数，那就不合法了，否则继续搜。我们甚至可以把估价函数当成一个bool来作为剪枝判定。这样一来就可以优化很多，相当于一个IDA*的板子题了。
下面上代码——

#include<bits/stdc++.h>
using namespace std;
int ans[4][4] = {{0, 0, 0, 0}, {0, 1, 2, 3}, {0, 8, 0, 4}, {0, 7, 6, 5}};
int dir[4][2] = {{0, 1}, {-1, 0}, {1, 0}, {0, -1}};//dir并不是随便的顺序哦
int a[4][4], k = 0;
char s;
bool judge = false;
bool check()//判定是否已经达到了目标状态
{
	for(int i = 1; i <= 3; i++)
		for(int j = 1; j <= 3; j++)
			if(a[i][j] != ans[i][j]) return false;
			
	return true;
}

bool in(int x, int y)//越界判定
{
	return 0 < x && x < 4 && 0 < y && y < 4;
}

bool test(int now)//估价函数
{
	int cnt = 0;
	for(int i = 1; i <= 3; i++)
		for(int j = 1; j <= 3; j++)
			if(ans[i][j] != a[i][j])
			{if(++cnt + now > k) return 0;}//估价不满足了
	return 1;//估价满足条件，这个位置合法
}

void A_star(int now, int x, int y, int pre)
{
	if(now == k) {if(check()) judge = true; return;}
	if(judge) return;
	for(int i = 0; i < 4; i++)
	{
		register int tx = x + dir[i][0], ty = y + dir[i][1];
		if(!in(tx, ty) || pre + i == 3) continue;//后一个判断说明这两步操作互逆了，可以观察dir得到
		swap(a[x][y], a[tx][ty]);//操作
		if(test(now) && !judge) A_star(now + 1, tx, ty, i);
		swap(a[x][y], a[tx][ty]);//回溯
	}
}

int main()
{
	register int x, y;
	for(int i = 1; i <= 3; i++)
		for(int j = 1; j <= 3; j++)
		{
			cin >> s;
			a[i][j] = s - '0';
			if(!a[i][j]) x = i, y = j;
		}
	
	if(check()) {puts("0"); return 0;}//特殊预判
	
	while(++k)
	{
		A_star(0, x, y, -1);
		if(judge) {printf("%d\n", k); return 0;}
	}
}

这样一来总共耗时300+ms，优化了很多很多。
八数码真的是一个非常经典的题目哇！！！

迎评：）
——End——