Eight八位数问题

 Problem 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

 

 

Source

South Central USA 1998 (Sepcial Judge Module By JGShining)

 

 

Recommend

JGShining

 

多加两组测试数据，包括特殊情况：

2 3 4 1 5 x 7 6 8
1 2 3 4 5 6 7 8 x
7 6 8 x 2 3 4 1 5
输出：

ullddrurdllurdruldr

 

unsolvable

 

分析：

此题要用到双向广度优先收索算法和全排列的hash映射。

首先，介绍下全排列的hash原理：

我们经常使用的数的进制为“常数进制”，即始终逢p进1。例如，p进制数K可表示为
    K = a0*p^0 + a1*p^1 + a2*p^2 + ... + an*p^n （其中0 <= ai <= p-1），
它可以表示任何一个自然数。

对于这种常数进制表示法，以及各种进制之间的转换大家应该是很熟悉的了，但大家可能很少听说变进制数。这里我要介绍一种特殊的变进制数，它能够被用来实现全排列的Hash函数，并且该Hash函数能够实现完美的防碰撞和空间利用（不会发生碰撞，且所有空间被完全使用，不多不少）。这种全排列Hash函数也被称为全排列数化技术。下面，我们就来看看这种变进制数。

我们考查这样一种变进制数：第1位逢2进1，第2位逢3进1，……，第n位逢n+1进1。它的表示形式为
    K = a1*1! + a2*2! + a3*3! + ... + an*n! （其中0 <= ai <= i），
也可以扩展为如下形式（因为按定义a0始终为0），以与p进制表示相对应：
    K = a0*0! + a1*1! + a2*2! + a3*3! + ... + an*n! （其中0 <= ai <= i）。
（后面的变进制数均指这种变进制数，且采用前一种表示法）

先让我们来考查一下该变进制数的进位是否正确。假设变进制数K的第i位ai为i+1，需要进位，而ai*i!=(i+1)*i!=1*(i+1)!，即正确的向高位进1。这说明该变进制数能够正确进位，从而是一种合法的计数方式。

接下来我们考查n位变进制数K的性质：
（1）当所有位ai均为i时，此时K有最大值
    MAX[K] = 1*1! + 2*2! + 3*3! + ... + n*n!
           = 1! + 1*1! + 2*2! + 3*3! + ... + n*n! - 1
           = (1+1)*1! + 2*2! + 3*3! + ... + n*n! - 1
           = 2! + 2*2! + 3*3! + ... + n*n! - 1
           = ...
           = (n+1)!-1
    因此，n位K进制数的最大值为(n+1)!-1。
（2）当所有位ai均为0时，此时K有最小值0。
因此，n位变进制数能够表示0到(n+1)!-1的范围内的所有自然数，共(n+1)!个。

在一些状态空间搜索算法中，我们需要快速判断某个状态是否已经出现，此时常常使用Hash函数来实现。其中，有一类特殊的状态空间，它们是由全排列产生的，比如N数码问题。对于n个元素的全排列，共产生n!个不同的排列或状态。下面将讨论如何使用这里的变进制数来实现一个针对全排列的Hash函数。

从数的角度来看，全排列和变进制数都用到了阶乘。如果我们能够用0到n!-1这n!个连续的变进制数来表示n个元素的所有排列，那么就能够把全排列完全地数化，建立起全排列和自然数之间一一对应的关系，也就实现了一个完美的Hash函数。那么，我们的想法能否实现呢？答案是肯定的，下面将进行讨论。

假设我们有b0,b1,b2,b3,...,bn共n+1个不同的元素，并假设各元素之间有一种次序关系 b0<b1<b2<...<bn。对它们进行全排列，共产生(n+1)!种不同的排列。对于产生的任一排列 c0,c1,c2,..,cn，其中第i个元素ci（1 <= i <= n）与它前面的i个元素构成的逆序对的个数为di（0 <= di <= i），那么我们得到一个逆序数序列d1,d2,...,dn（0 <= di <= i）。这不就是前面的n位变进制数的各个位么？于是，我们用n位变进制数M来表示该排列：
   M = d1*1! + d2*2! + ... + dn*n!
因此，每个排列都可以按这种方式表示成一个n位变进制数。下面，我们来考查n位变进制数能否与n+1个元素的全排列建立起一一对应的关系。

由于n位变进制数能表示(n+1)!个不同的数，而n+1个元素的全排列刚好有(n+1)!个不同的排列，且每一个排列都已经能表示成一个n位变进制数。如果我们能够证明任意两个不同的排列产生两个不同的变进制数，那么我们就可以得出结论：
★ 定理1 n+1个元素的全排列的每一个排列对应着一个不同的n位变进制数。

对于全排列的任意两个不同的排列p0,p1,p2,...,pn（排列P）和q0,q1,q2,...,qn（排列Q），从后往前查找第一个不相同的元素，分别记为pi和qi（0 < i <= n）。
（1）如果qi > pi，那么,
如果在排列Q中qi之前的元素x与qi构成逆序对，即有x > qi，则在排列P中pi之前也有相同元素x > pi（因为x > qi且qi > pi），即在排列P中pi之前的元素x也与pi构成逆序对，所以pi的逆序数大于等于qi的逆序数。又qi与pi在排列P中构成pi的逆序对，所以pi的逆序数大于qi的逆序数。
（2）同理，如果pi > qi，那么qi的逆序数大于pi的逆序数。
因此，由（1）和（2）知，排列P和排列Q对应的变进制数至少有第i位不相同，即全排列的任意两个不同的排列具有不同的变进制数。至此，定理1得证。

计算n个元素的一个排列的变进制数的算法大致如下（时间复杂度为O(n^2)）：
template <typename T>
size_t PermutationToNumber(const T permutation[], int n)
{
    // n不能太大，否则会溢出（如果size_t为32位，则n <= 12）
    size_t result = 0;
    for (int j = 1; j < n; ++j) {
        int count = 0;
        for (int k = 0; k < j; ++k) {
            if (permutation[k] > permutation[j])
                ++count;
        }
        // factorials[j]保存着j!
        result += count * factorials[j];
    }

    return result;
}

说明：
（1）由于n!是一个很大的数，因此一般只能用于较小的n。
（2）有了计算排列的变进制数的算法，我们就可以使用一个大小为n!的数组来保存每一个排列的状态，使用排列的变进制数作为数组下标，从而实现状态的快速检索。如果只是标记状态是否出现，则可以用一位来标记状态。

本文来自CSDN博客，转载出处：http://blog.csdn.net/inter999/archive/2009/04/09/4059693.aspx
 

扩展节点的分析：

通过逆序数的奇数偶数来判断。因为在空白移动过程中，数码的逆序数不改变。左右移动，数码序列不变。上下移动，数码序列中某个数字则移动了两位。问题的实质就是：如果是N*N的数码盘的话，左右移动，数码序列不变；上下移动则数码序列变动N-1位。若N为奇数则在变动过程中其逆序数不会改变。而八数码问题为3*3矩阵，3为奇数，故逆序数不作改变。故可通过判断当前状态S的逆序数以及目标状态SD的数字序列的逆序数的奇偶性是否相同来判断该问题是否可解。（参考：http://blog.csdn.net/lingling1989r/archive/2010/04/23/5522501.aspx）

 参考代码：

 

 #include <iostream>using namespace std;#define MAX362880// 9!#define START_HASH1#define END_HASH2struct node{int v[9];int pos;int last;int dirflag;}stateS[MAX/2], stateE[MAX/2];int hash[MAX];int dir[4][2] = {{-1, 0},{1, 0},{0, -1},{0, 1}};bool init(){int i;char val;for(i = 0; i < 9; ++i){if (cin>>val){if (val == 'x'){stateS[0].v[i] = 0;stateS[0].pos = i;}elsestateS[0].v[i] = val-'0';}elsereturn false;}stateS[0].last = 0;stateS[0].dirflag = -1;for(i = 0; i < 9; ++i){if (i == 8){stateE[0].v[i] = 0;stateE[0].pos = i;}elsestateE[0].v[i] = i+1;}stateE[0].last = 0;stateE[0].dirflag = -1;memset(hash, 0, sizeof(hash));return true;}bool inbound(int x, int y){if (x < 0 || x >= 3)return false;if (y < 0 || y >= 3)return false;return true;}void swap(int& v1, int& v2){int v = v1;v1 = v2;v2 = v;}int gethashno(const node& val){int sum = 0, n = 1, a, i, j;for(i = 1; i < 9; ++i){n *= i;a = 0;for(j = 0; j < i; ++j){if (val.v[i] < val.v[j])++a;}sum += a*n;}return sum;}bool isok(const node& val)// 当前状态（除0外）的逆序数为奇数时，它无法达到目标状态{int sum = 0, i, j;for(i = 1; i < 9; ++i){if (val.v[i] == 0)continue;for(j = 0; j < i; ++j){if (val.v[j] == 0)continue;if (val.v[i] < val.v[j])++sum;}}if (sum % 2 == 0) return true;return false;}bool expend(node& tmp, int i){int x, y, pos1;x = tmp.pos/3 + dir[i][0];y = tmp.pos%3 + dir[i][1];if (!inbound(x, y))return false;pos1 = 3*x+y;swap(tmp.v[tmp.pos], tmp.v[pos1]);tmp.pos = pos1;return true;}bool equalnode(const node& nod1, const node& nod2){// if (nod1.pos != nod2.pos)// return false;int i;for (i = 0; i < 9; ++i){if (nod1.v[i] != nod2.v[i])return false;}return true;}bool repeat(const node& tmp, node state[], long tail){long i;for (i = 0; i <= tail; ++i){if (equalnode(tmp, state[i]))return true;}return false;}bool findtail(const node& tmp, node state[], long& tail){long i;for (i = tail; i >= 0; --i){if (equalnode(tmp, state[i])){tail = i;return true;}}return false;}void printpath(node state1[], long tail1, node state2[], long tail2){int p[MAX/2], k = 0, i;while (tail1 > 0){p[k++] = tail1;tail1 = state1[tail1].last;}// p[k] = 0;for (i = k-1; i >= 0; --i){switch (state1[p[i]].dirflag){case 0:cout<<"u";break;case 1:cout<<"d";break;case 2:cout<<"l";break;case 3:cout<<"r";break;}}while (tail2 > 0){switch (state2[tail2].dirflag){case 0:cout<<"d";break;case 1:cout<<"u";break;case 2:cout<<"r";break;case 3:cout<<"l";break;}tail2 = state2[tail2].last;}cout<<endl;}void bfs(){long heads, tails, i;long heade, taile, hashno;node tmp;heads = tails = 0;heade = taile = 0;if (equalnode(stateS[0], stateE[0])){cout<<endl;return;}if (!isok(stateS[0])){cout<<"unsolvable"<<endl;return;}hash[gethashno(stateS[0])] = START_HASH;hash[gethashno(stateE[0])] = END_HASH;while ((heads <= tails && tails < MAX/2) && (heade <= taile && taile < MAX/2)){if (heads <= tails && tails < MAX/2){for (i = 0; i < 4; ++i){tmp = stateS[heads];if (expend(tmp, i)/* && !repeat(tmp, stateS, tails)*/){hashno = gethashno(tmp);if (hash[hashno] == END_HASH){tmp.dirflag = i;tmp.last = heads;stateS[++tails] = tmp;findtail(tmp, stateE, taile);printpath(stateS, tails, stateE, taile);return;}else if (hash[hashno] != START_HASH){hash[hashno] = START_HASH;tmp.dirflag = i;tmp.last = heads;stateS[++tails] = tmp;}}}++heads;}if (heade <= taile && taile < MAX/2){for (i = 3; i >= 0; --i){tmp = stateE[heade];if (expend(tmp, i)/* && !repeat(tmp, stateE, taile)*/){hashno = gethashno(tmp);if (hash[hashno] == START_HASH){tmp.dirflag = i;tmp.last = heade;stateE[++taile] = tmp;findtail(tmp, stateS, tails);printpath(stateS, tails, stateE, taile);return;}else if (hash[hashno] != END_HASH){hash[hashno] = END_HASH;tmp.dirflag = i;tmp.last = heade;stateE[++taile] = tmp;}}}++heade;}}}int main(){while(true){if (!init())break;bfs();} return 0;}