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

原创 2015年11月17日 16:21:33
A - Eight
Time Limit:5000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u
Appoint description: 

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;
}

queueque;

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;
}

queueque;

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_queueque;
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;
}

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

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

ACM模版描述 题解传说中和八皇后一样过分经典的搜索问题,所以网上一查,各种强势题解一大堆,更有丧心病狂者,写了《八数码的八境界》这种深度剖析此问题的 blog,让我不敢再多言此题,毕竟我想不了那么...
  • f_zyj
  • f_zyj
  • 2017年04月04日 17:52
  • 215

[kuangbin带你飞]专题二 搜索进阶 I - A计划(HDU 2102)

题目链接I - A计划 思路: 还是正常的bfs,多了一层而已。在移动时,增加判断,如果下一步为时光传输机且对应的节点为空地,则加入队列,否则continue即可。 代码:#include #...

[kuangbin带你飞]专题二-搜索进阶-D-Escape

ACM模版描述 题解这种问题不难,无非两点,一:看懂题,二:细心。矩阵的搜索一般使用 bfs 比较多,也比较好,这里的标记要用一个三维数组,多出来的一维用来标记时间,记住要用 bool 型,习惯性的...
  • f_zyj
  • f_zyj
  • 2017年04月15日 18:59
  • 182

【 题集 】 【kuangbin带你飞】专题一 简单搜索 更新 ing ......

今天开始做,感觉好吃力,好水好弱、、、     可能接下来是继续,或者换其它的专题了吧、、、 A - 棋盘问题 Description 在一个给定形状的棋盘(形状可能是不规则的)上面摆放棋子,棋...

HDU 2612 find a way (kuangbin带你飞 专题一:简单搜索)

题意:有两个人Y和M,约定好了再kfc碰面,问两个人碰面的最短时间是多少.. 先对Y能达到的所有地方bfs一边记录最短路程存起来,在对Mbfs一边,然后对于kfc这个地方把两个人的最短时间加起来找最...

Dungeon Master([kuangbin带你飞]专题一 简单搜索)

题目大意:题目链接 给个多层的迷宫,求从起点到终点的最短路径,不能到达就输出Trapped! 解体思路: bfs直接搜,没什么好说的,一开始忘记清空队列一只WA,果然我还是菜鸡 ...
  • HAHAAC
  • HAHAAC
  • 2016年10月14日 21:48
  • 94

kuangbin带你飞 专题一 简单搜索 (题解)

POJ 3279  题意:黑白的板,每次选择一个十字形翻转(十字板内黑白互换,若是边界则不管),求最小将原图变为全白的策略。 题解:枚举第一行翻转情况(二进制),2^c,然后验证,由于第一行确定...

[kuangbin带你飞]专题一 简单搜索

简单搜索

HDU 1241 Oil Deposits ([kuangbin带你飞]专题一 简单搜索)

题目连接:题目 ——————题目大意:Description GeoSurvComp地质调查公司负责探测地下石油储藏。 GeoSurvComp现在在一块矩形区域探测石油,并把这个大区域分成了很多小块...
  • HAHAAC
  • HAHAAC
  • 2016年10月16日 14:37
  • 204

FZU 2150 Fire Game ([kuangbin带你飞]专题一 简单搜索)

题目连接:题目 题目大意:就是你又两把火,去烧草场的草,火只能上下左右烧,问烧完的时间,如果不能烧完,则输出-1; 解题思路:这个题算是第一次接触到双向广搜把,我觉得是双向广搜,,,,,,,,,,...
  • HAHAAC
  • HAHAAC
  • 2016年10月16日 21:37
  • 130
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:[kuangbin带你飞]专题二 搜索进阶 A - Eight
举报原因:
原因补充:

(最多只允许输入30个字)