sicily 1153

题目

Constraints

Time Limit: 1 secs, Memory Limit: 32 MB , Special Judge

Description

和题目C同样的任务，这里只是把棋盘扩大到标准的国际象棋。对这样一个8 * 8的棋盘用同样的方法编号如下：

1     2     3       4     5     6       7     8

9     10       11    12       13    14       15    16

17    18       19    20       21    22       23    24

25    26       27    28       29    30       31    32

33    34       35    36       37    38       39    40

41    42       43    44       45    46       47    48

49    50       51    52       53    54       55    56

57    58       59    60       61    62       63    64

Input

输入有若干行。每行一个整数N(1<=N<=64)，表示马的起点。最后一行用-1表示结束，不用处理。

Output

对输入的每一个起点，求一条周游线路。对应地输出一行，有64个整数，从起点开始按顺序给出马每次经过的棋盘方格的编号。相邻的数字用一个空格分开。

Sample Input

4-1

分析

这道题和1152是一样的，只是数据规模变大了，如果使用1152的DFS就会超时。所以，要对1152的方法进行优化。

先定义一个值：k值，对于一个位置如果它下一步可到达的位置有5个，那么就说它的k值为5。

优化：对于一个位置要对它的下一个位置进行DFS，我们优先选择那些k值小的位置。因为，它的K值小，所以走改路径的可能性就大，需要回溯的可能性就小，从而减小搜索空间。

实现

void adjust()		//对walkable进行调整，对每一个位置，如果他的可到达位置少则存储在前面
{
	for(int i = 0 ;i<64;++i)
	{
		//下面是一个简单的冒泡排序
		for(int j = 0 ;j<walkable[i].size()-1;++j)
		{
			for(int k = j+1;k<walkable[i].size();++k)
			{
				if(walkable[walkable[i][k]].size() < walkable[walkable[i][j]].size())
				{
					int temp = walkable[i][k];
					walkable[i][k] = walkable[i][j];
					walkable[i][j] = temp;
				}
			}
		}
	}
}

对于64个位置上的可走位置，我用一个冒泡排序对他们进行k值的从小到大排序，那么在递归的过程中也就是按这个顺序进行DFS的了。

完整代码

#include "stdafx.h"
#include <iostream>
#include <string.h>
#include <vector>
using namespace std;

int route[64]; //定义一个全局数组用来在递归bfs过程中保存结果
int direction[8][2] = {{1,-2},{2,-1},{2,1},{1,2},{-1,2},{-2,1},{-2,-1},{-1,-2}};//马可以走的八个方向
bool visit[64]; //用一个数组标记走过的位置
bool flag;	//用来在递归找到一条路径时设置为true，递归返回是就可以直接返回不在迭代
vector<int> walkable[64];//用来保存64个位置马可以可以走的下一个位置

void ini_walkable()			//初始化walkable
{
	for(int i = 0 ;i<64;++i)
	{
		for(int j = 0 ;j<8;++j)
		{
			int x = i/8;
			int y = i%8;
			x += direction[j][0];
			y += direction[j][1];

			if( x>=0 && x<8 && y>=0 && y<8)
			{
				walkable[i].push_back(x*8+y);
			}
		}
	}
}

void adjust()		//对walkable进行调整，对每一个位置，如果他的可到达位置少则存储在前面
{
	for(int i = 0 ;i<64;++i)
	{
		//下面是一个简单的冒泡排序
		for(int j = 0 ;j<walkable[i].size()-1;++j)
		{
			for(int k = j+1;k<walkable[i].size();++k)
			{
				if(walkable[walkable[i][k]].size() < walkable[walkable[i][j]].size())
				{
					int temp = walkable[i][k];
					walkable[i][k] = walkable[i][j];
					walkable[i][j] = temp;
				}
			}
		}
	}
}

void walk_around(int k,int position)
{
	if(k == 63)
	{
		flag = true;
		return;
	}
	else
	{
		for(int i = 0;i<walkable[position].size();++i)
		{
			if(!visit[walkable[position][i]])
			{
				route[++k] = walkable[position][i];
				visit[walkable[position][i]] = true;
				walk_around(k,walkable[position][i]);
				
				if(flag)
					return ;
				
				--k;
				visit[walkable[position][i]] = false;
			}

			
		}
	}
}
 

int main()
{
	ini_walkable();
	adjust();
	int n;
	cin>>n;
	while(n!=-1)
	{
		memset(visit,false,sizeof(visit));
		memset(route,-1,sizeof(route));
		
		flag = false;

		route[0] = n-1;
		visit[n-1] = true;
		walk_around(0,n-1);
		
		for(int i = 0 ;i<63;++i)
		{
			cout<<route[i]+1<<' ';
		}
		cout<<route[63]+1<<endl;
		
		cin>>n;
	}
	return 0;
}