经典游戏算法之骑士走棋盘

问题描述:中国象棋中,马可以走遍棋盘上的任何角落.国际象棋中,也同样有这样的说法:骑士可以走遍棋盘上的每个格子.现在的问题是:在一个8x8的棋盘上,从任意位置开始,骑士如何可以不重复地走完所有的位置?

 

骑士在每一步都有8种可能的下一步走法(边界上除外),为了提高效率,可以选择所要走的下一步为下一步要选择时所能走的步数最少的一步.

 

函数说明:

bool travel(int board[][SIZE],int x,int y);        //遍历函数,传入数组表示棋盘,x,y表示骑士的初始位置坐标

具体步骤:

首先记录当前位置走的次序,然后遍历棋盘,得到可能的下一跳数目,通过min函数找到最合适的下一跳,记录下一跳位置走的次序.如果能够遍历完成,返回true表示骑士不重复的走完棋盘.

int possible(int board[][SIZE],int *nexti,int *nextj,int x,int y);//计算下一步的可能方向,传入数组表示棋盘,数组记录多个下一步可能方向,x,y为当前骑士位置坐标

具体步骤:

将所有的下一跳以坐标表示,若当前位置上下一跳的元素值为0表示未走过为一种可能方向,下一跳数组记录下一跳坐标,计数器累加,返回计数器

int min(int board[][SIZE],int *nexti,int *nextj,int count);  //从多个可能方向中找出下一方向数最少的方向

具体步骤:

在所有的可能的方向中遍历,分别计算下一跳的数目,取其中最小数目的方向,返回值表示下一跳数组的下标

 

C++代码:

#include <iostream>
#include <iomanip>
#define SIZE 8
using namespace std;
bool travel(int board[][SIZE],int x,int y);
int possible(int board[][SIZE],int *nexti,int *nextj,int x,int y);
int min(int board[][SIZE],int *nexti,int *nextj,int count);
void printBoard(int borad[][SIZE]);
int main()
{
int start_x;
int start_y;
cout<<"输入初始位置"<<endl;
cin>>start_x>>start_y;
int board[SIZE][SIZE]={0};
if(travel(board,start_x,start_y))cout<<"遍历成功!"<<endl;
else cout<<"遍历失败!"<<endl;
printBoard(board);
}
bool travel(int board[][SIZE],int x,int y)
{
board[x][y]=1;                   //当前位置为第1次走的位置
int nexti[SIZE]={0};
int nextj[SIZE]={0};             //下一跳初始化
int i=x;
int j=y;
int MAX=SIZE*SIZE;
int count=0;
for(int m=2;m<=MAX;m++)          //遍历棋盘
{
count=possible(board,nexti,nextj,i,j);//得到可能的下一跳数目
if(count==0)return false;    //无可走方向,遍历失败
int min_Direction=min(board,nexti,nextj,count);//在多个可能方向中查找下一跳方向最少的方向
i=nexti[min_Direction];      //下一跳位置坐标
j=nextj[min_Direction];
board[i][j]=m;               //当前位置为第m次走的位置
}
return true;
}
int possible(int board[][SIZE],int *nexti,int *nextj,int x,int y)
{
int mvi[SIZE]={-2,-1,1,2,2,1,-1,-2};    //下一跳可能的八个方向(x坐标y坐标)
int mvj[SIZE]={1,2,2,1,-1,-2,-2,-1};
int count=0;
for(int i=0;i<SIZE;++i)
{
int tmpx=x+mvi[i];
int tmpy=y+mvj[i];
if(tmpx<0||tmpy<0||tmpx>SIZE-1||tmpy>SIZE-1)continue; //越界,不是可行方向
if(board[tmpx][tmpy]==0)                  //未走过,找到一个可能方向
{
nexti[count]=tmpx;
nextj[count]=tmpy;
count++;
}
}
return count;                              //返回可能的方向数
}
int min(int board[][SIZE],int *nexti,int *nextj,int count)
{
int mvx[SIZE]={-2,-1,1,2,2,1,-1,-2};
int mvy[SIZE]={1,2,2,1,-1,-2,-2,-1};
int exist[SIZE]={0};                   //记录该方向的下一跳方向的数目
int min_direction=-1;                  //初始化最小方向数的方向
if(count==1)min_direction=0;           //只有一个可行方向
else
{
for(int i=0;i<count;++i)           //在所有可行方向中遍历
{
for(int j=0;j<SIZE;++j)        //计算每一个方向下一跳的数目
{
int tmpx=nexti[i]+mvx[j];
int tmpy=nextj[i]+mvy[j];
if(tmpx<0||tmpy<0||tmpx>SIZE-1||tmpy>SIZE-1)continue;
if(board[tmpx][tmpy]==0)
{
exist[i]++;
}
}
}
int min=exist[0];                 //取其中最小数目的方向
min_direction=0;
for(int i=1;i<count;++i)          //此处count开始错为SIZE,一直未查出错误
//exist数组只有count位不为0
{
if(exist[i]<min)
{
min=exist[i];
min_direction=i;
}
}
}
return min_direction;
}
void printBoard(int board[][SIZE])
{
for(int i=0;i<SIZE;++i)
{
for(int j=0;j<SIZE;++j)
{
cout<<setw(2)<<board[i][j]<<"  ";
}
cout<<endl;
}
}