1077 Eight

Eight

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 37738		Accepted: 15932		Special Judge

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 a description of a configuration of the 8 puzzle. The 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.

Sample Input

 2  3  4  1  5  x  7  6  8 

Sample Output

ullddrurdllurdruldr

Source

South Central USA 1998

 

参考 https://blog.csdn.net/dolfamingo/article/details/77855498 自己写了一遍

年轻人的第一道A* 答案可能多解

我的这个程序输入样例输入得到的输出是 ldruullddrurdllurrd

跟样例输出不一样 搞的我郁闷了半天

 

注意方向的选取 还有位置的选择

它是

1 2 3

4 5 6

7 8 9

 

康拓展开

可参考原理讲解: https://blog.csdn.net/c18219227162/article/details/50301513

类似哈希 给定一个排列组合的数  如123456789 怎么去判定有没有遍历过这个数 可以用康拓展开 八数码问题有9位 直接开1e9的数组可能爆内存 并且有很多数字是用不到的 因为每个数字只出现一次 可能会有123456789 但是绝对不会出现123456788 以此类推 这样浪费了很多空间

由此引出康拓展开 由这个数是第几小的数来作表示 对N个不同的数的排列组合 一共有N!种排列组合 他们的大小都不一样 所以只需要N!的空间就足够存放所有的状态

要注意自己定义的康拓的范围

其中 递增顺序排列是最小的数 即123456789  987654321是最大的数

我这里写的是goal = 1,  所以 cantor是返回v+1避免出现0, 要是 goal = 0, 则cantor返回v就行了 以此类推

记忆方法: 只要记住顺序排列是最小的 它的v是最小的 在以下代码片中要让return v+1 等于1 容易知道下划线部分应该填  ar[j] < ar[i]

int contor(int ar[]) {
    int v = ;
    for (int i = ; i < ; i++) {
        int num = ;
        for (int j = i + ; j < ; j++) {
            if (_______) num++;
        }
        v += num * fac[ - i];
    }
    return v + 1;
}

 

还有个注意点是曼哈顿距离不算x点

短即是正义 我短我骄傲

 #include <stdio.h>
 #include <queue>
 #include <algorithm>
 using namespace std;
 int fac[];
 int dx[] = {-, , , };
 int dy[] = {,  , , -};
 char d[] = {'u','d','r','l'};
 const int goal = , maxv = 4e5;
 bool vis[maxv];
 int pre[maxv];
 char dir[maxv];
 int dish(int ar[]) {
     int dis = ;
     for (int i = ; i < ; i++) {
         if (ar[i] == ) continue;
         int v = ar[i] - ;
         int rx = i / , ry = i % ;
         int x = v / , y = v % ;
         dis += abs(x - rx) + abs(ry - y);
     }
     return dis;
 }
 int contor(int ar[]) {
     int v = ;
     for (int i = ; i < ; i++) {
         int num = ;
         for (int j = i + ; j < ; j++)  if (ar[j] < ar[i]) num++;

         v += num * fac[ - i];
     }
     return v + ;
 }
 struct node {
     int g, h, f, sta, xpos;
     int s[];
     void init() {
         g++; h=dish(s); f=h+g; sta=contor(s);
     }
     bool operator < (const node x)const {
         return f > x.f;
     }
 };
 priority_queue<node> q;
 bool Astar(node now) {
     fill(vis, vis + maxv, );
     while (!q.empty()) q.pop();
     now.g = -;
     now.init();
     q.push(now);
     pre[now.sta] = -;
     vis[now.sta] = ;
     while (!q.empty()){
         now = q.top(); q.pop();
         if (now.sta == goal) return true;
         int xpos = now.xpos;
         int x = xpos / , y = xpos % ;
         for (int i = ; i < ; i++) {
             int tx = x + dx[i];
             int ty = y + dy[i];
             if (tx <  || ty <  || tx >=  || ty >= ) continue;
             int newp = tx *  + ty;
             node tp = now;
             tp.xpos = newp;
             swap(tp.s[newp], tp.s[xpos]);
             tp.init();

             if (vis[tp.sta]) continue;
             vis[tp.sta] = ;
             pre[tp.sta] = now.sta;
             dir[tp.sta] = d[i];
             q.push(tp);
         }
     }
     return false;
 }
 void Print(int sta) {
     if (pre[sta] == -) return;
     Print(pre[sta]);
     printf("%c", dir[sta]);
 }
 int main() {
     fac[] = ;
     for (int i = ; i < ; i++) fac[i] = i * fac[i - ];
     char str[];
     while (gets(str)) {
         int cnt = ;
         node now;
         for (int i = ; str[i]; i++) {
             if (str[i] == ' ') continue;
             if (str[i] == 'x') {
                 now.xpos = cnt;
                 now.s[cnt++] = ;
             }
             else
                 now.s[cnt++] = str[i] - '';
         }
         if (Astar(now)) Print(goal);
         else printf("unsolvable");
         printf("\n");
     }
     return ;
 }