A*(A - Star) - Eight - HDU - 1043

A*(A - Star) - Eight - HDU - 1043

题意：

$给定一个3\times 3的方阵，包含数字1$~$$\begin{gathered} 8，以及字{符}^{\prime }{x}^{\prime }(表示空位)， \\ 每次操作通过上下左右移动数字{到}^{\prime }{x}^{\prime }所在的空位上，使得最终呈现一个有序的9宫格。 \end{gathered}$$

$要通过最少的操作次数使得9宫格复位，输出一个最少操作方案。$

$若不能使9宫格有序，则输{出}^{\prime \prime }unsolvabl{e}^{\prime \prime }.$

${}^{\prime }{u}^{\prime }表示{将}^{\prime }{x}^{\prime }向上移动{，}^{\prime }{d}^{\prime }表示{将}^{\prime }{x}^{\prime }向下移动{，}^{\prime }{r}^{\prime }表示{将}^{\prime }{x}^{\prime }向右移动{，}^{\prime }{l}^{\prime }表示{将}^{\prime }{x}^{\prime }向左移动。$

Sample Input

2  3  4  1  5  x  7  6  8

Sample Output

ullddrurdllurdruldr

Time limit： 5000 ms
Memory limit： 32768 kB
Special judge ： Yes

---

分析:

$与——$《POJ 1077 - 八数码》$题意一致，仅仅是需要输出具体操作方案。$

$有一个重要的性质：若序列中的逆序对数量是奇数，则无法使得九宫格有序。$

$设启发函数f(st)表示从状态st到终点状态需要的最少操作次数。$

$d[st]表示从起始状态到当前状态st已经进行的操作次数。$

$$\begin{gathered} 对于每次操作，我们优先选择d[st]+f(st)更小的状态进行操作， \\ 当终点状态end第一次出队时，就得到最少操作的一种方案。 \end{gathered}$$

具体落实：

$①、因为要求出具体方案，定义哈希表pre，把每一种状态与前驱状态和从前驱状态转移而来的操作对应起来。$

$②、距离数组d，存储从起始状态到当前状态已经进行的操作次数。$

$③、小根堆heap，以d[st]+f(st)为第一关键字，堆中元素是一个估计距离和对应状态的一个二元组。$

$$\begin{gathered} ④、先将初始状态入堆，每次从堆中取出堆顶元素进行扩展， \\ 若某个状态未搜索过，或者重复搜索到当前状态时距离更优，就把该状态入堆。 \end{gathered}$$

$⑤、当第一次从堆顶得到终点状态，提前退出循环，根据pre表倒推具体操作。$

$⑥、f函数的具体实现：对当前状态的每一个数字，计算该数字当前位置与其在终点状态中的位置的曼哈顿距离。$

注意：$本题是多组测试数组！！！$

代码：

#include<iostream>
#include<cstring>
#include<vector>
#include<algorithm>
#include<queue>
#include<unordered_map>

#define P pair<int,string>

using namespace std;

int f(string start)
{
    int res=0;
    for(int i=0;i<9;i++)
        if(start[i]!='x')
        {
            int t=start[i]-'1';
            res+=abs(i/3-t/3)+abs(i%3-t%3);
        }
    return res;
}

string bfs(string start)
{
    int dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
    char op[4]={'u','d','l','r'};
    string end="12345678x";
    
    unordered_map<string,pair<string,char>> pre;
    unordered_map<string,int> d;
    priority_queue<P,vector<P>,greater<P>> heap;
    
    d[start]=0;
    heap.push(make_pair(f(start),start));

    while(heap.size())
    {
        P t=heap.top();
        heap.pop();
        string state=t.second;
        int step=d[state];
        
        if(state==end) break;
        
        int x,y;
        for(int i=0;i<9;i++)
            if(state[i]=='x')
            {
                x=i/3,y=i%3;
                break;
            }
            
        string source=state;
        for(int i=0;i<4;i++)
        {
            int a=x+dir[i][0],b=y+dir[i][1];
            if(a>=0&&a<3&&b>=0&&b<3)
            {
                swap(state[x*3+y],state[a*3+b]);
                if(!d.count(state)||d[state]>step+1)
                {
                    d[state]=step+1;
                    heap.push(make_pair(d[state]+f(state),state));
                    pre[state]=make_pair(source,op[i]);
                }
                swap(state[x*3+y],state[a*3+b]);
            }
        }
    }
    
    string res;
    while(start!=end)
    {
        res+=pre[end].second;
        end=pre[end].first;
    }
    reverse(res.begin(),res.end());
    return res;
}

int main()
{
    string c;
    while(cin>>c)
    {
    	string seq,start;
        start+=c;
        if(c!="x") seq+=c;     //用于计算逆序对数量
    	for(int i=0;i<8;i++)
    	{
    		cin>>c;
    		start+=c;
        	if(c!="x") seq+=c;
    	}
    	
	    int cnt=0;
	    for(int i=0;i<7;i++)
	        for(int j=i+1;j<8;j++)
	            if(seq[i]>seq[j])
	                cnt++;
	            
	    if(cnt%2) cout<<"unsolvable"<<endl;
	    else cout<<bfs(start)<<endl;
    }
    
    return 0;
}