马踏棋盘问题

马踏棋盘问题

问题描述

马踏棋盘主要的解决方案有两种：一种是基于深度优先搜索的方法，另一种是基于贪婪算法的方法。第一种基于深度优先搜索的方法是比较常用的算法，深度优先搜索算法也是数据结构中的经典算法之一，主要是回溯的算法思想，可采用递归实现。贪婪的算法则是一步一步依据当前最优的策略，依靠每一步的局部最优，达到最终目标。但是他不一定能够得到最优解。

关于马踏棋盘的基本过程：国际象棋的棋盘为8*8的方格棋盘。现将”马”放在任意指定的方格中，按照”马”走棋的规则将”马”进行移动(如图所示，如果将空格标成点，就是象棋中的马走“日”字)。要求每个方格只能进入一次，最终使得”马”走遍棋盘的64个方格。如图所示，任意一个位置，“马”最多有8个方向可以跳动，所以每次都要依据这最多8个方向进行选择。

回溯法

深度优先搜索属于图算法的一种，英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次. (类似于树中的前序遍历，回溯法的思想)。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MATRIX 8
#define TRUE 1
#define ERROR 0
typedef int status ;

int tag = 1;
/*查找下一步方向*/
status nextStep(int (*chess)[MATRIX],int *x,int *y,int step){
switch(step)
{
case 0:
if(*y+2<=MATRIX-1 && *x-1>=0 && chess[*x-1][*y+2]==0)
{
*y+=2;
*x-=1;
return TRUE;
}
break;
case 1:
if(*y+2<=MATRIX-1 && *x+1<=MATRIX-1 && chess[*x+1][*y+2]==0)
{
*y+=2;
*x+=1;
return TRUE;
}
break;
case 2:
if(*y+1<=MATRIX-1 && *x+2<=MATRIX-1 && chess[*x+2][*y+1]==0)
{
*y+=1;
*x+=2;
return TRUE;
}
break;
case 3:
if(*y-1>=0 && *x+2<=MATRIX-1 && chess[*x+2][*y-1]==0)
{
*y-=1;
*x+=2;
return TRUE;
}
break;
case 4:
if(*y-2>=0 && *x+1<=MATRIX-1 && chess[*x+1][*y-2]==0)
{
*y-=2;
*x+=1;
return TRUE;
}
break;
case 5:
if(*y-2>=0 && *x-1>=0 && chess[*x-1][*y-2]==0)
{
*y-=2;
*x-=1;
return TRUE;
}
break;
case 6:
if(*y-1>=0 && *x-2>=0 && chess[*x-2][*y-1]==0)
{
*y-=1;
*x-=2;
return TRUE;
}
break;
case 7:
if(*y+1<=MATRIX-1 && *x-2>=0 && chess[*x-2][*y+1]==0)
{
*y+=1;
*x-=2;
return TRUE;
}
break;
default:
break;
}
return ERROR;

}

/*DFS棋盘*/
void traverseChess(int (*chess)[MATRIX],int x,int y){

int count = 0;  //最多8个方向计数
int x1 = x,y1 = y;
if(x1<MATRIX && y1<MATRIX && chess[x1][y1] == 0){
chess[x1][y1] = tag;
tag ++;
}

if(tag > MATRIX * MATRIX){
printf("oK!!task has accomplished...\n");
return;
}

for(count = 0;count<8;count++){  //总共有8个可能的方向
nextStep(chess,&x1,&y1,count);
if(chess[x1][y1]==0)traverseChess(chess,x1,y1);  //递归
}
}
/*打印棋盘*/
void print_chess(int (*chess)[MATRIX]){
int i = 0,j = 0;
printf("\nThe MATRIX is as follow\n");
for(i = 0;i<MATRIX;i++){
for(j = 0;j < MATRIX;j++){
printf("%2d\t",chess[i][j]);
}
printf("\n");
}
}
void main(){

int i ,j;
clock_t start ,end;
int chess[MATRIX][MATRIX];
for(i = 0; i<MATRIX;i++){
for(j = 0;j < MATRIX;j++){
chess[i][j] = 0;  //初始化
}
}
start = clock();
traverseChess(chess,4,0,1);  //开始遍历
end = clock();
print_chess(chess);  //打印棋盘
printf("共耗时:%f\n",(double)(end-start)/CLOCKS_PER_SEC);

}

贪心算法

贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。

贪心算法不是对所有问题都能得到整体最优解，关键是贪心策略的选择，选择的贪心策略必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。

在处理马踏棋盘问题时，每次在至多8个可选的方向中，首先通过验证其中一个方向可以成功。贪心算法同样是试探至多的八个可能的出口，但是八个出口的排序并非按照前述的顺时针，而是按照每个可能出口的进一步出口数的递增排序，所以每次先试探的总是进一步出口较少的出口，能够给之后的出口更多的选择，因此贪心算法是比较高效的，而且它不回溯。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

#define ROWS    8
#define COLS    8

/*cursor i move chess*/
const int iktmove[8] = {-2,-1,1,2,2,1,-1,-2};
/*cursor j move chess*/
const int jktmove[8] = {1,2,2,1,-1,-2,-2,-1};

int chess[ROWS][COLS];

/*inital the chess*/
void chess_init(int chess[][COLS],int rows,int cols)
{
int i, j;
for(i = 0; i < rows ; ++ i)
for (j = 0; j < cols ; ++ j)
{
chess[i][j] = 0;
}
}
/*print the chess*/
void print_chess(int chess[][COLS])
{
int i,j;
for(i = 0; i < ROWS; ++ i)
{
for(j = 0; j < COLS; ++ j)
printf("%d\t",chess[i][j]);
printf("\n\n");
}
}
/*find the index of min non-zeros*/
int minindex(int a[],int cols)
{
int i = 0,index = 0;
int min = a[0];
for(i = 0 ; i< cols; ++ i)
{
if(a[i] >0)
{
min = a[i];
index = i;
break;
}
}
for(i = index + 1; i < cols ; ++ i)
{
if(a[i] > 0 && min > a[i])
{
min = a[i];
index = i;
}
}
if(a[index] > 0)
return index;
return -1;
}

/**/
void greedy_chess(int chess[][COLS],int rows,int cols,int start_i,int start_j)
{
int i,npos,m,min,j,nnpos;

int nexti[8] = {0,0,0,0,0,0,0,0};
int nextj[8] = {0,0,0,0,0,0,0,0};
int exit[8] = {0,0,0,0,0,0,0,0};

/*init*/
chess_init(chess,rows,cols);
/*first step*/
chess[start_i][start_j] = 1;
/*n>1 step*/
for(m = 1; m < 64; ++ m)
{
/*steps d*/
npos = 0;
for(i = 0; i < 8; ++ i)
{
/*ignore the point which doesn't satisfy the conditions*/
if( start_i + iktmove[i] < 0 ||
start_i + iktmove[i] >= rows ||
start_j + jktmove[i] < 0 ||
start_j + jktmove[i] >= cols ||
chess[start_i + iktmove[i]][start_j+jktmove[i]] > 0)
{
continue;
}
/*save the point which satisfy the conditions*/
nexti[npos] = start_i + iktmove[i];
nextj[npos] = start_j + jktmove[i];
/*statistics how many point satisfy conditions*/
npos ++;
}
/*steps e*/
if(npos == 0)
{
printf("Can not finish the game!!\n,The steps of game can be %d\n",m);
return;
}
/*steps e*/
if(npos == 1)
{
min = 0;
start_i = nexti[min];
start_j = nextj[min];
chess[start_i][start_j] = m+1;
}
/*steps f*/
if(npos > 1)
{
for(i = 0; i < npos ; ++ i)
{
nnpos = 0;
for(j = 0; j < 8; ++ j)
{
if( nexti[i] + iktmove[j] >= 0 &&
nexti[i] + iktmove[j] < rows &&
nextj[i] + jktmove[j] >= 0 &&
nextj[i] + jktmove[j] < cols &&
chess[nexti[i] + iktmove[j]][nextj[i] + jktmove[j]] == 0)
{
nnpos ++;
}
}
exit[i] = nnpos;
}
if((min = minindex(exit,npos)) >= 0)
{
start_i = nexti[min];
start_j = nextj[min];
chess[start_i][start_j] = m+1;
}
else
{
printf("Can not finish the game!!\n,The steps of game can be %d\n",m);
return;
}
}
}
}

void main()
{
clock_t start,end;
start = clock();
greedy_chess(chess,ROWS,COLS,5,1);
end = clock();
print_chess(chess);
printf("time consumed:%f\n",(double)(end-start)/CLOCKS_PER_SEC);

}