[kuangbin带你飞]专题二 搜索进阶 A - Eight

A - Eight

Time Limit:5000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u

Submit  Status  Practice  HDU 1043

Appoint description:  System Crawler  (2015-11-10)

Description

The 15-puzzle has been around for over 100 years; even if you don't know it by that name, you've seen it. It is constructed with 15 sliding tiles, each with a number from 1 to 15 on it, and all packed into a 4 by 4 frame with one tile missing. Let's call the missing tile 'x'; the object of the puzzle is to arrange the tiles so that they are ordered as: 

 1  2  3  4
 5  6  7  8
 9 10 11 12
13 14 15  x

where the only legal operation is to exchange 'x' with one of the tiles with which it shares an edge. As an example, the following sequence of moves solves a slightly scrambled puzzle: 

 1  2  3  4     1  2  3  4     1  2  3  4     1  2  3  4
 5  6  7  8     5  6  7  8     5  6  7  8     5  6  7  8
 9  x 10 12     9 10  x 12     9 10 11 12     9 10 11 12
13 14 11 15    13 14 11 15    13 14  x 15    13 14 15  x
 r->            d->            r->

The letters in the previous row indicate which neighbor of the 'x' tile is swapped with the 'x' tile at each step; legal values are 'r','l','u' and 'd', for right, left, up, and down, respectively. 

Not all puzzles can be solved; in 1870, a man named Sam Loyd was famous for distributing an unsolvable version of the puzzle, and 
frustrating many people. In fact, all you have to do to make a regular puzzle into an unsolvable one is to swap two tiles (not counting the missing 'x' tile, of course). 

In this problem, you will write a program for solving the less well-known 8-puzzle, composed of tiles on a three by three 
arrangement. 

 

Input

You will receive, several descriptions of configuration of the 8 puzzle. One description is just a list of the tiles in their initial positions, with the rows listed from top to bottom, and the tiles listed from left to right within a row, where the tiles are represented by numbers 1 to 8, plus 'x'. For example, this puzzle 

1 2 3 
x 4 6 
7 5 8 

is described by this list: 

1 2 3 x 4 6 7 5 8 

 

Output

You will print to standard output either the word ``unsolvable'', if the puzzle has no solution, or a string consisting entirely of the letters 'r', 'l', 'u' and 'd' that describes a series of moves that produce a solution. The string should include no spaces and start at the beginning of the line. Do not print a blank line between cases. 

 

Sample Input

       

        2  3  4  1  5  x  7  6  8 
       

 

Sample Output

       

        ullddrurdllurdruldr 
       

 

搜索中经典的八数码问题。

参考：八数码的八境界

方法一：直接用bfs

用bfs就要考虑判重的问题。总共有9个（把x看成0)，我们很容易想到直接把他看成9位数就可以了，但是在编程我们会发现数组开的太大了无法编译。

这些状态可以看成九个数的全排列，用排列组合我们可以求出所有的状态个数9!=362880，就可以用康拓展示。

要注意用0初始化时，不能用0表示上一状态，不然输出时会产生死循环

但是会TLE

详见代码

///TLE
#include
  
   
#include
   
    
#include
    
     
#include
     
      
using namespace std;

int fac[10];
int flag_star;
struct {
    int flag;//指向上一个状态
    char dir;//从上一个状态到这一状态的方向
}vis[362881];//判重
int a[10];

struct node
{
    int a[10];
    int x;
};

int Hash(int a[])//求康拓展示
{
    int ans = 0;
    for(int i = 0; i < 9; i++)
    {
        int tmp = 0;
        for(int j = i+1; j < 9; j++)
        {
            if(a[i] > a[j]) tmp++;
        }
        ans += tmp*fac[8-i];
    }
    return ans;
}

queue
      
       que;

void prin(int n)//输出方向
{
    if(n != flag_star)
    {
        prin(vis[n].flag);
        printf("%c", vis[n].dir);
    }
}

int dir[5][2] = { {1, 0}, {-1, 0}, {0, 1}, {0, -1} };
char str[5] = "durl";

void swap(int &x, int &y)
{
    int t = x;
    x = y;
    y = t;
}

int bfs(node star)
{
    while(!que.empty()) que.pop();
    que.push(star);
    while(!que.empty())
    {
        node tmp = que.front(); que.pop();
        int flag = Hash(tmp.a);
        for(int i = 0; i < 4; i++)
        {
            int x = tmp.x/3 + dir[i][0];
            int y = tmp.x%3 + dir[i][1];
            if(0 <= x && x < 3 && 0 <= y && y < 3)
            {
                int t = tmp.x;
                swap(tmp.a[x*3+y], tmp.a[tmp.x]);
                tmp.x = x*3+y;
                int flag_ = Hash(tmp.a);
                if( vis[ flag_ ].flag == -1)
                {
                    vis[ flag_ ].flag = flag;
                    vis[ flag_ ].dir = str[i];
                    if(flag_ == 46233) return flag_;
                    que.push(tmp);
                }
                tmp.x = t;
                swap(tmp.a[x*3+y], tmp.a[tmp.x]);
            }
        }
    }
    return 362881;
}

int main(void)
{
    int i;
    char c[10];
    fac[1] = 1;
    for(i = 2; i < 10; i++)
        fac[i] = fac[i-1]*i;
    while(~scanf("%s", c))
    {
        for(i = 0; i < 362881; i++) vis[i].flag = -1;
        node star;//输入
        if(c[0] == 'x') {star.a[0] = 0; star.x = 0;}
        else star.a[0] = c[0] - '0';
        for(i = 1 ; i < 9; i++)
        {
            scanf("%s", c);
            if(c[0] == 'x') {star.a[i] = 0; star.x = i;}
            else star.a[i] = c[0] - '0';
        }
        flag_star = Hash(star.a);//得到初始状态
        if(flag_star == 46233) {printf("\n"); continue;}//特判 如果初始状态就是目标
        int tmp = bfs(star);
        if(tmp == 362881) printf("unsolvable");
        else prin(tmp);
        printf("\n");
    }
    return 0;
}

      
     
    
   
  

方法二：反向bfs打表

方法一超时，因为有多个输入。我们可以用bfs反向打表，事先以目标为起点搜出所有可以到达的状态。

//bfs+hash(康拓展示)
#include
  
   
#include
   
    
#include
    
     
#include
     
      
using namespace std;

int fac[10];
int flag_star;
struct {
    int flag;//标记是否访问过
    char dir;//移动方向
}vis[362881];
int a[10];

struct node
{
    int a[10];  //状态
    int x;      //x所在的位置
};

int Hash(int a[])//康拓展示
{
    int ans = 0;
    for(int i = 0; i < 9; i++)
    {
        int tmp = 0;
        for(int j = i+1; j < 9; j++)
        {
            if(a[i] > a[j]) tmp++;
        }
        ans += tmp*fac[8-i];
    }
    return ans;
}

queue
      
       que;

void prin(int n)
{
    if(n != 46233)
    {
        printf("%c", vis[n].dir);
        prin(vis[n].flag);
    }
}

int dir[5][2] = { {1, 0}, {-1, 0}, {0, 1}, {0, -1} };
char str[5] = "udlr";

void swap(int &x, int &y)
{
    int t = x;
    x = y;
    y = t;
}

int bfs()
{
    node star;
    for(int i = 0; i < 8; i++) star.a[i] = i+1; star.a[8] = 0;
    star.x = 8;
    while(!que.empty()) que.pop();
    que.push(star);
    while(!que.empty())
    {
        node tmp = que.front(); que.pop();
        int flag = Hash(tmp.a);
//        printf("flag=%d tmp.x=%d\n", flag, tmp.x);
        for(int i = 0; i < 4; i++)
        {
            int x = tmp.x/3 + dir[i][0];
            int y = tmp.x%3 + dir[i][1];
            if(0 <= x && x < 3 && 0 <= y && y < 3)
            {
                int t = tmp.x;
                swap(tmp.a[x*3+y], tmp.a[tmp.x]);
                tmp.x = x*3+y;
                int flag_ = Hash(tmp.a);
                if( vis[ flag_ ].flag == -1)//没有访问过就可以移动(判重)
                {
                    vis[ flag_ ].flag = flag;
                    vis[ flag_ ].dir = str[i];
                    que.push(tmp);
                }
                //还原
                tmp.x = t;
                swap(tmp.a[x*3+y], tmp.a[tmp.x]);
            }
        }
    }
    return 0;
}

int main(void)
{
    int i;
    char c[10];
    fac[1] = 1;
    for(i = 2; i < 10; i++)
        fac[i] = fac[i-1]*i;
    for(i = 0; i < 362881; i++) vis[i].flag = -1;
    bfs();
    while(~scanf("%s", c))
    {
        node star;
        if(c[0] == 'x') {star.a[0] = 0; star.x = 0;}
        else star.a[0] = c[0] - '0';
        for(i = 1 ; i < 9; i++)
        {
            scanf("%s", c);
            if(c[0] == 'x') {star.a[i] = 0; star.x = i;}
            else star.a[i] = c[0] - '0';
        }
        flag_star = Hash(star.a);
        if(flag_star == 46233) {printf("\n"); continue;}
        if(vis[flag_star].flag == -1) printf("unsolvable");
        else prin(flag_star);
        printf("\n");
    }
    return 0;
}

      
     
    
   
  

方法三：a*算法

最关键的部分是估价函数和判断逆序是否为偶数的剪枝

估价函数，是根据与目标解的曼哈顿距离，也就是每个数字与目标位置的曼哈顿距离之和。

#include
  
   
#include
   
    
#include
    
     
#include
     
      
#include
      
       
using namespace std;

struct node     //状态
{
    int a[10];
    int f, h, g;
    int x;      //x在的位置

//    bool operator<(const node n1)const{     //优先队列第一关键字为h,第二关键字为g
//        return h!=n1.h?h>n1.h:g>n1.g;
//    }
    friend bool operator < (node a, node b)
    {
        return a.f > b.f;
    }
};

priority_queue
       
        que; int fac[10]; //46233 struct { int father; char dir; }vis[362881]; int get_h(int a[]) { int h = 0; for(int i = 0; i < 8; i++) { if(a[i]) h += fabs((a[i]-1)/3 - i/3) + fabs((a[i]-1)%3 - i%3); } return h; } int Hash(int a[]) { int ans = 0; for(int i = 0; i < 9; i++) { int tmp = 0; for(int j = i+1; j < 9; j++) { if(a[i] > a[j]) tmp++; } ans += tmp*fac[8-i]; } return ans+1; } void prin(int n) { // printf("n=%d\n", n); if(vis[n].father!=-1) { prin(vis[n].father); printf("%c", vis[n].dir); } } void SWAP(int &x, int &y) { int t = x; x = y; y = t; } int dir[4][2] = { {1, 0}, {-1, 0}, {0, -1}, {0, 1} }; char dd[] = "dulr"; bool is(int a[]) { int ans = 0; for(int i = 0; i < 9; i++) { if(a[i]) for(int j = i+1; j < 9; j++) { if(a[i] > a[j] && a[j]) ans++; } } return !(ans&1); } void debug(int a[]) { for(int i = 0; i < 3; i++) { for(int j = 0; j < 3; j++) { printf("%d ", a[i*3+j]); } printf("\n"); } printf("\n"); } int bfs(node star) { while(!que.empty()) que.pop(); que.push( star ); star.h = get_h( star.a ); star.g = 0; star.f = star.g + star.h; vis[ Hash( star.a ) ].father = -1; while(!que.empty()) { node tmp = que.top(); que.pop(); int father = Hash(tmp.a); // printf("father=%d\n", father); debug(tmp.a); for(int i = 0; i < 4; i++) { int x = dir[i][0] + tmp.x/3; int y = dir[i][1] + tmp.x%3; if(0 <= x && x < 3 && 0 <= y && y < 3) { node s = tmp; s.x = x*3+y; SWAP( s.a[ tmp.x ], s.a[ s.x ] ); s.g++; s.h = get_h( s.a ); s.f = s.h + s.g; int son = Hash(s.a); // printf("tmp.x =%d s.x=%d\n", tmp.x, s.x); // printf("son=%d\n", son); debug(s.a); if(son == 46234) { vis[ son ].father = father; vis[ son ].dir = dd[i]; prin(46234);printf("\n"); return 0; } if(!vis[ son ].father && is(s.a)) { vis[ son ].father = father; vis[ son ].dir = dd[i]; que.push( s ); } } } } return 1; } int main(void) { int i; fac[1] = 1; for(i = 2; i < 10; i++) fac[i] = fac[i-1]*i; node star; char in[2]; // freopen("ou.txt", "w", stdout); while(~scanf("%s", in)) { memset(vis, 0, sizeof(vis)); if(in[0] == 'x') { star.a[0] = 0; star.x = 0; } else star.a[0] = in[0] - '0'; for(i = 1; i < 9; i++) { scanf("%s", in); if(in[0] == 'x') { star.a[i] = 0; star.x = i; } else star.a[i] = in[0] - '0'; } if(!is(star.a)) { printf("unsolvable\n");continue; } if(Hash(star.a) == 46234) {printf("\n"); continue;} if(bfs(star)) { printf("unsolvable\n"); } } return 0; }