POJ 1077 Eight:八数码问题

题目链接:

http://poj.org/problem?id=1077

题目类型: 隐式图搜索

原题:

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

题目大意:

编号为1~8的8个正方形被摆放成3行3列(留有一个格子为空),与空格相邻的编号格子可以移动到空格中。然后要求求出目标状态的方案。

分析与总结:

据说没做过八数码的人生是不完整的。看了lrj的书先做了这道,用到的是所有方法中最朴素,最简单的一种。直接单向bfs+哈希判重。

在poj上可以水过,但在HDU和ZOJ交就不行了。

在做这道题中学到的几样小技巧:

1. 数组直接用memcpy, memcmp对整块内存进行复制或者比较, 速度比用for循环快。

2.用typedef来定义一个新名称可以更加方便。

3.哈希表与编码的应用

还有很多更好更高级的方法,我的人生还待完整……

#include<iostream>
#include<cstring>
#include<cstdio>
#define MAXN 500000
using namespace std;
char input[30];
int state[9], goal[9] = {1,2,3,4,5,6,7,8,0};
int dir[4][2] = {{-1,0},{1,0},{0,-1},{0,1}}; // 上,下,左, 右
char path_dir[5] = "udlr";
int st[MAXN][9];
int father[MAXN], path[MAXN]; // 保存打印路径  

const int MAXHASHSIZE = 1000003;
int head[MAXHASHSIZE], next[MAXN];  

void init_lookup_table() { memset(head, 0, sizeof(head)); }  

typedef int State[9];
int hash(State& s) {
  int v = 0;
  for(int i = 0; i < 9; i++) v = v * 10 + s[i];
  return v % MAXHASHSIZE;  

}  

int try_to_insert(int s) {
  int h = hash(st[s]);
  int u = head[h];
  while(u) {
    if(memcmp(st[u], st[s], sizeof(st[s])) == 0) return 0;
    u = next[u];
  }
  next[s] = head[h];
  head[h] = s;
  return 1;
}  

int bfs(){
    init_lookup_table();
    father[0] = path[0] = -1;
    int front=0, rear=1;
    memcpy(st[0], state, sizeof(state));  

    while(front < rear){
        int *s = st[front];  

        if(memcmp(s, goal, sizeof(goal))==0){
            return front;
        }  

        int j;
        for(j=0; j<9; ++j) if(!s[j])break; // 找出0的位置
        int x=j/3, y=j%3;     // 转换成行,列  

        for(int i=0; i<4; ++i){  

            int dx = x+dir[i][0]; // 新状态的行,列
            int dy = y+dir[i][1];
            int pos = dx*3+dy;    // 目标的位置  

            if(dx>=0 && dx<3 && dy>=0 && dy<3){
                int *newState = st[rear];
                memcpy(newState, s, sizeof(int)*9);
                newState[j] = s[pos];
                newState[pos] = 0;
                if(try_to_insert(rear)){
                    father[rear] = front;  path[rear] = i;
                    rear++;
                }
            }
        }
        front++;
    }
    return -1;
}  

void print_path(int cur){
    if(cur!=0){
        print_path(father[cur]);
        printf("%c", path_dir[path[cur]]);
    }
}  

int main(){  

    while(gets(input)){
        // 转换成状态数组, 'x'用0代替
        for(int pos=0, i=0; i<strlen(input); ++i){
            if(input[i]>='0' && input[i]<='9')
                state[pos++] = input[i]-'0';
            else if(input[i]=='x')
                state[pos++] = 0;
        }
        int ans;
        if((ans=bfs())!=-1){
            print_path(ans);
            printf("\n");
        }
    }
}

以上是小编为您精心准备的的内容,在的博客、问答、公众号、人物、课程等栏目也有的相关内容,欢迎继续使用右上角搜索按钮进行搜索int
, tiles
, c++ 8数码问题
, 哈希
, of
, with
, The
int(3)与int(11)比较
poj、poj1077、poj 1077 a*、爱奇艺、xt1077,以便于您获取更多的相关知识。

时间: 2024-09-27 23:47:48

POJ 1077 Eight:八数码问题的相关文章

uva 652---Eight Poj 1077 ---Eight zoj 1217---Eight (八数码解法2)

点击打开链接uva 652 点击打开链接hdu 1043 点击打开链接zoj 1217                                                              八数码解法2 解题整体思路 :    预处理+哈希判重+打表+输出路径                               我们知道对于八数码问题而言,每一个状态就是每一个格子的编号(我们把空格看成9),那么最多有9!种,那么现在针对每一种状态都有9个数字,难道我们开一个9维数组,

uva 652---Eight Poj 1077 ---Eight zoj 1217---Eight (八数码解法3)

点击打开链接uva 652 点击打开链接hdu 1043 点击打开链接zoj 1217                                                              八数码解法3 解题整体思路 :    双向广搜+哈希判重+输出路径                      (目前只能AC poj 数据水了不解释,其它的OJ一直TLE,求教)                               我们知道对于八数码问题而言,每一个状态就是每一个格

uva 652---Eight Poj 1077 ---Eight zoj 1217---Eight (八数码解法1)

点击打开链接uva 652 点击打开链接hdu 1043 点击打开链接zoj 1217                                                              八数码解法1 解题整体思路 :    单向广搜+哈希判重+输出路径(这种方法效率不高,目前小弟的程序只能过POJ 其它TLE)                               我们知道对于八数码问题而言,每一个状态就是每一个格子的编号(我们把空格看成9),那么最多有9!种,那么

八数码问题及A*算法

一.八数码问题 八数码问题也称为九宫问题.在3×3的棋盘,摆有八个棋子,每个棋子上标有1至8的某一数字,不同棋子上标的数字不相同.棋盘上还有一个空格,与空格相邻的棋子可以移到空格中.要求解决的问题是:给出一个初始状态和一个目标状态,找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤. 所谓问题的一个状态就是棋子在棋盘上的一种摆法.棋子移动后,状态就会发生改变.解八数码问题实际上就是找出从初始状态到达目标状态所经过的一系列中间过渡状态. 八数码问题一般使用搜索法来解. 搜索法有广度优先搜索法

AI八数码问题 Stack Overflow

问题描述 AI课本八数码问题,我是用广度优先搜索,用Ismatch来记录状态是否已经遍历,个人感觉算法基本没错吧!可是编译程序的时候只要步数长一点(5步可以输出)就没有输出,用Debug调试显示是:Stack Overflow.我看了很久的代码,也没有搞懂需要在哪里做优化.希望大家看下给点意见.谢谢#include <stdio.h>#include <string.h>#define M 362881bool IsAnswer = false;bool Ismatch[M];//

九宫问题(八数码)求解过程动态演示

一.题目说明: (九宫问题)在一个3×3的九宫中有1-8这8个数及一个空格随机的摆放在其中的格子里,如图1-1所示.现在要求实现这个问题:将该九宫格调整为如图1-1右图所示的形式.调整的规则是:每次只能将与空格(上.下.或左.右)相邻的一个数字平移到空格中.试编程实现这一问题的求解. (图1-1) 二.题目分析: 九宫问题是人工智能中的经典难题之一,问题是在3×3方格棋盘中,放8格数,剩下的没有放到的为空,每次移动只能是和相邻的空格交换数.程序自动产生问题的初始状态,通过一系列交换动作将其转换成

在Java中使用启发式搜索更快地解决问题

了解一个流行人工智能搜索算法的 Java 实现 通过搜寻可行解决方案空间来解决问题是人工智能中一项名为状态空间搜索 的基本技术. 启发式搜 索 是状态空间搜索的一种形式,利用有关一个问题的知识来更高效地查找解决方案.启发式搜索在各个 领域荣获众多殊荣.在本文中,我们将向您介绍启发式搜索领域,并展示如何利用 Java 编程语言实现 A*,即最广为使用的启发式搜索算法.启发式搜索算法对计算资源和内存提出了较高的要求.我们还将展 示如何避免昂贵的垃圾收集,以及如何利用一个替代的高性能 Java 集合框

UVA 10085:The most distant state

题目链接: http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=110&page=show_problem&problem=1026 类型: 隐式图搜索 原题: The 8-puzzle is a square tray in which eight square tiles are placed. The remaining ninth square is uncove

算法研究:图的深度优先遍历

图的遍历和树的遍历类似,我们希望从图中某一顶点出发访遍图中其余顶点,且使每一个顶点仅被访问一次,这一过程 就叫做图的遍历(Traverse Graph). 图的遍历方法一般有两种,第一种是深度优先遍历(Depth First Search),也 有称为深度优先搜索,简称为DFS.第二种是<广度优先遍历(Breadth  First Search)>,也有称为广度优先搜索, 简称为BFS.我们在<堆栈与深度优先搜索>中已经较为详细地讲述了深度优先搜索的策略,这里不再赘述.我们也可以把