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 = 0;
    for (int i = 0; i < 9; i++) {
        int num = 0;
        for (int j = i + 1; j < 9; j++) {
            if (_______) num++;
        }
        v += num * fac[8 - i];
    }
    return v + 1;
}

 

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

短即是正义 我短我骄傲

#include <stdio.h>
#include <queue>
#include <algorithm>
using namespace std;
int fac[10];
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0,  0, 1, -1};
char d[4] = {'u','d','r','l'};
const int goal = 1, maxv = 4e5;
bool vis[maxv];
int pre[maxv];
char dir[maxv];
int dish(int ar[]) {
    int dis = 0;
    for (int i = 0; i < 9; i++) {
        if (ar[i] == 9) continue;
        int v = ar[i] - 1;
        int rx = i / 3, ry = i % 3;
        int x = v / 3, y = v % 3;
        dis += abs(x - rx) + abs(ry - y);
    }
    return dis;
}
int contor(int ar[]) {
    int v = 0;
    for (int i = 0; i < 9; i++) {
        int num = 0;
        for (int j = i + 1; j < 9; j++)  if (ar[j] < ar[i]) num++;
        
        v += num * fac[8 - i];
    }
    return v + 1;
}
struct node {
    int g, h, f, sta, xpos;
    int s[9];
    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, 0);
    while (!q.empty()) q.pop();
    now.g = -1;
    now.init();
    q.push(now);
    pre[now.sta] = -1;
    vis[now.sta] = 1;
    while (!q.empty()){
        now = q.top(); q.pop();
        if (now.sta == goal) return true;
        int xpos = now.xpos;
        int x = xpos / 3, y = xpos % 3;
        for (int i = 0; i < 4; i++) {
            int tx = x + dx[i];
            int ty = y + dy[i];
            if (tx < 0 || ty < 0 || tx >= 3 || ty >= 3) continue;
            int newp = tx * 3 + ty;
            node tp = now;
            tp.xpos = newp;
            swap(tp.s[newp], tp.s[xpos]);
            tp.init();
            
            if (vis[tp.sta]) continue;
            vis[tp.sta] = 1;
            pre[tp.sta] = now.sta;
            dir[tp.sta] = d[i];
            q.push(tp);
        }
    }
    return false;
}
void Print(int sta) {
    if (pre[sta] == -1) return;
    Print(pre[sta]);
    printf("%c", dir[sta]);
}
int main() {
    fac[0] = 1;
    for (int i = 1; i < 10; i++) fac[i] = i * fac[i - 1];
    char str[30];
    while (gets(str)) {
        int cnt = 0;
        node now;
        for (int i = 0; str[i]; i++) {
            if (str[i] == ' ') continue;
            if (str[i] == 'x') {
                now.xpos = cnt;
                now.s[cnt++] = 9;
            }
            else
                now.s[cnt++] = str[i] - '0';
        }
        if (Astar(now)) Print(goal);
        else printf("unsolvable");
        printf("\n");
    }
    return 0;
}