POJ 1077 Eight

Eight

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 23815		Accepted: 10518		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

 

解题:这题比杭电那题要容易一点，本代码可以过poj的，但是过不了hdu的1043，正在学习IDA*以及如何破解1043.本题代码是来自某牛人的博客！学习IDA*时看了很多关于八数码的代码，只有这份代码，思路清晰，代码量少，拿来学习研究IDA*那是极好的。

 

#include<iostream>
#include<cstdio>
#include<cstdlib>
using namespace std;
#define SIZE 3
char board[SIZE][SIZE];
int goal_state[9][2] = {{0,0}, {0,1}, {0,2},{1,0}, {1,1}, {1,2}, {2,0}, {2,1}, {2,2}};
int h(char board[][SIZE]) {
    int cost = 0;
    for(int i=0; i<SIZE; ++i)
        for(int j=0; j<SIZE; ++j) {
            if(board[i][j] != SIZE*SIZE) {
                cost += abs(i - goal_state[board[i][j]-1][0]) +
                        abs(j - goal_state[board[i][j]-1][1]);
            }
        }
    return cost;
}
int step[4][2] = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};//u, l, r, d
char op[4] = {'u', 'l', 'r', 'd'};
char solution[1000];
int bound;
bool ans;
int DFS(int x, int y, int dv, char pre_move) {
    int hv = h(board);
    if(hv + dv > bound) return dv + hv;
    if(hv == 0) {ans = true;return dv;}
    int next_bound = 1e9;
    for(int i = 0; i < 4; ++i) {
        if(i + pre_move == 3) continue;
        int nx = x + step[i][0];
        int ny = y + step[i][1];
        if(0 <= nx && nx < SIZE && 0 <= ny && ny < SIZE) {
            solution[dv] = i;
            swap(board[x][y], board[nx][ny]);
            int new_bound = DFS(nx, ny, dv+1, i);
            if(ans) return new_bound;
            next_bound = min(next_bound, new_bound);
            swap(board[x][y], board[nx][ny]);
        }
    }
    return next_bound;
}
void IDA_star(int sx, int sy) {
    ans = false;
    bound = h(board);
    while(!ans && bound <= 100) bound = DFS(sx, sy, 0, -10);
}
int main() {
    int sx, sy;
    char c;
    for(int i=0; i<SIZE; ++i)
        for(int j=0; j<SIZE; ++j) {
            cin>>c;
            if(c == 'x') {
                board[i][j] = SIZE * SIZE;
                sx = i;
                sy = j;
            } else board[i][j] = c - '0';
        }
    IDA_star(sx, sy);
    if(ans) {
        for(int i = 0; i < bound; ++i)
            cout<<op[solution[i]];
    } else cout<<"unsolvable";
    return 0;
}