Eight HDU 1043 AND POJ 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, 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

 

整理了好长时间，终于解决了。  刚开始一直纠结康拓展开式，后来通过资料查找，进一步的了解。

    康拓展开式

 

//判断这个数在其各个数字全排列中从小到大排第几位
// X = an*(n-1)! + an-1*(n-2)! + ... + a2*1! + a1*0!; 

int cator(int t[])                            //康拓展开式
{
	int sum = 0;
	for(int i = 0; i < 9; i++)
	{
		int num = 0;
		for(int j = i+1; j < 9; j++)
			if(t[i] > t[j])
				num++;
		sum += num*fac[8-i];  //((n-1)-i)	  
	}
	return sum; 
}

    逆运算

 

int n;            //表示有几位数 
int book[110];
int fac[] = {1,1,2,6,24,120,720,5040,40320,362880};   //第 i！的数值 

// k = an*(n-1)! + an-1*(n-2) + ... + a2*1! + a1*0!;

void reverse_cator(int k,char s[])
{
    memset(book,0,sizeof(0)); 
    int j;
    for(int i = 0;i < n; i++)
    {
        int t = k/fac[n-i-1];      //表示的是 an; 
        for(j = 1; j <= n; j++)
            if(!vis[j])
            {
                if(t == 0)
                    break;
                --t;
            }
            
        s[i] = j+'0';
        vis[j] = 1;
        k = k%fac[n-1-i];        //继续往下找 
    }
}

 

刚开始做的是POJ 1077这道题，这道题是单租数据输入，可以从起始位置找终点位置，A了。

 

后来发现HDU 1043，本来想着可以秀一把了，可谁知竟然相同的代码，竟然来了个Compilation Error。

很绝望，后来得知1043这题是多组数据输入，然后就换种思路，开始从最终位置出发，找到所有的点，并保存其路径。在这里，应注意运用数组实现邻接表。

 

//逆向搜索,从终点往前搜索 
#include<stdio.h>
#include<queue>
#include<string.h>
#include<iostream> 
#include<algorithm>
using namespace std;

int a[]={-1,1,0,0};
int b[]={0,0,-1,1};

char str[]={"durl"};     //由于从终点往前找，故方向相反 

int fac[]={1,1,2,6,24,120,720,5040,40320,362880};

int book[370000]; 		

struct note			//存储路径 
{	
	int head;		//表示的是 
	char st;			//存储方向 
	
}f[370000];

struct node
{
	int x0;
	int num;			//s[]在全排列中从大到小第几位 
	int s[10];		    // 存储数康拓展开式	所求的数值 
};

//判断这个数在其各个数字全排列中从小到大排第几位
// X = an*(n-1)! + an-1*(n-2)! + ... + a2*1! + a1*0!; 

int cator(int t[])                            //康拓展开式
{
	int sum = 0;
	for(int i = 0; i < 9; i++)
	{
		int num = 0;
		for(int j = i+1; j < 9; j++)
			if(t[i] > t[j])
				num++;
		sum += num*fac[8-i];  //((n-1)-i)	  
	}
	return sum; 
}

void bfs()
{
	memset(book,0,sizeof(book));
	queue<node>Q;
	node now,tmp;
	for(int i = 0; i < 8; i++)
		now.s[i] = i+1;
	now.s[8] = 0;
	now.x0 = 8;
	now.num = 0;
	f[0].head = 0;
	Q.push(now);
	while(!Q.empty())
	{
		now = Q.front();
		Q.pop();
		int x = now.x0/3;
		int y = now.x0%3; 
		for(int i = 0;i < 4; i++)
		{
			int tx = x + a[i];
			int ty = y + b[i];
			if(tx < 0 || ty < 0 || tx > 2 || ty > 2 )
				continue;
			tmp = now;
			tmp.x0 = tx*3 + ty;
			swap(tmp.s[tmp.x0],tmp.s[now.x0]);
			tmp.num = cator(tmp.s);
			if(!book[tmp.num])
			{
				book[tmp.num] = 1;
				f[tmp.num].head = now.num;		//此时的数连接着上一个状态 now.head 
				f[tmp.num].st =  str[i];
				Q.push(tmp);
			}
		}
	}
	return ;
}

int main()
{
	char c;
	int t[10];  
	bfs();
	while(cin >> c)            //cin不吸收空格回车等字符
	{
		if(c == 'x')
			t[0] = 0;
		else
			t[0] = c-'0';
		for(int i = 1; i < 9; i++)
		{
			cin >> c;
			if(c == 'x')
				t[i] = 0;
			else
				t[i] = c-'0';
		}
		int n = cator(t);
		//printf("%d\n",n);
		if(book[n])
		{
			while(n)
			{
				printf("%c",f[n].st);
				n = f[n].head;			//下一个状态 
			}
			printf("\n");
		}
		else
			printf("unsolvable\n"); 
	}
	return 0;
}

在这里，要注意的是

   1  我们是从后往前找的，所有方向应该正好相反（上下左右的坐标，  保存的字符应该是下上右左）

   2  数据有多重答案，所有不要一直纠结自已的运行结果和测试数据不一样啊。

在这里，把字符'x'变成0或者9都可以

重在尝试哦，说不定自己就对了呢