java 马踏棋盘_马踏棋盘的实现

马踏棋盘是经典的程序设计问题之一，主要的解决方案有两种：一种是基于深度优先搜索的方法，另一种是基于贪婪算法的方法。第一种基于深度优先搜索的方法是比较常用的算法，深度优先搜索算法也是数据结构中的经典算法之一，主要是采用递归的思想，一级一级的寻找，最后找到合适的解。而基于贪婪的算法则是依据贪婪算法的思想设置一种标准，然后依据标准进行选择，从而得到解，但是他不一定能够得到最优解。

关于马踏棋盘的基本过程：国际象棋的棋盘为8*8的方格棋盘。现将"马"放在任意指定的方格中，按照"马"走棋的规则将"马"进行移动。要求每个方格只能进入一次，最终使得"马"走遍棋盘的64个方格。

深度优先搜索属于图算法的一种，英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次. (来自百度)本文引用地址：http://www.eepw.com.cn/article/201612/324536.htm

贪心算法(又称贪婪算法)是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。贪心算法不是对所有问题都能得到整体最优解，但对范围相当广泛的许多问题他能产生整体最优解或者是整体最优解的近似解。(来自百度)

其中基于深度优先搜索的算法就是依据当前点找到下一个可能的点，然后对这个点进行深度优先搜索，然后依次递归，当出现条件不满足时，退回来，采用其他的路劲进行搜索，最后肯定能够得到对应的结果。实现的基本过程如下：

/*deepsearch to solve the horse chessproblem*/

#include#include#include#define ROWS 8

#define COLS 8

int chess[ROWS][COLS];

/*eight directions of x moved*/

const int x_move[] = {-2,-1,1,2,2,1,-1,-2};

/*eight directions of y moved*/

const int y_move[] = {1,2,2,1,-1,-2,-2,-1};

void print_matrix()

{

int i = 0,j = 0;

for (i = 0; i < ROWS; ++ i)

{

for (j = 0; j < COLS; ++ j)

{

printf("%d",chess[i][j]);

}

printf("");

}

}

/*find the next point*/

intnextxy(int *x,int *y,int count)

{

if(count > 7 && count < 0)

return -1;

switch(count)

{

case 0:

/*check the conditions*/

if(*x + x_move[0] < ROWS &&

*x + x_move[0]>= 0 &&

*y + y_move[0]< COLS &&

*y + y_move[0]>= 0 &&

chess[*x + x_move[0]][*y + y_move[0]] == 0)

{

*x += x_move[0];

*y += y_move[0];

break;

}

else/*failed*/

return 0;

case 1:

if(*x + x_move[1] < ROWS &&

*x + x_move[1]>= 0 &&

*y + y_move[1]< COLS &&

*y + y_move[1]>= 0 &&

chess[*x + x_move[1]][*y + y_move[1]] == 0)

{

*x += x_move[1];

*y += y_move[1];

break;

}

else

return 0;

case 2:

if(*x + x_move[2] < ROWS &&

*x + x_move[2]>= 0 &&

*y + y_move[2]< COLS &&

*y + y_move[2]>= 0 &&

chess[*x + x_move[2]][*y + y_move[2]] == 0)

{

*x += x_move[2];

*y += y_move[2];

break;

}

else

return 0;

case 3:

if(*x + x_move[3] < ROWS &&

*x + x_move[3]>= 0 &&

*y + y_move[3]< COLS &&

*y + y_move[3]>= 0 &&

chess[*x + x_move[3]][*y + y_move[3]] == 0)

{

*x += x_move[3];

*y += y_move[3];

break;

}

else

return 0;

case 4:

if(*x + x_move[4] < ROWS &&

*x + x_move[4]>= 0 &&

*y + y_move[4]< COLS &&

*y + y_move[4]>= 0 &&

chess[*x + x_move[4]][*y + y_move[4]] == 0)

{

*x += x_move[4];

*y += y_move[4];

break;

}

else

return 0;

case 5:

if(*x + x_move[5] < ROWS &&

*x + x_move[5]>= 0 &&

*y + y_move[5]< COLS &&

*y + y_move[5]>= 0 &&

chess[*x + x_move[5]][*y + y_move[5]] == 0)

{

*x += x_move[5];

*y += y_move[5];

break;

}

else

return 0;

case 6:

if(*x + x_move[6] < ROWS &&

*x + x_move[6]>= 0 &&

*y + y_move[6]< COLS &&

*y + y_move[6]>= 0 &&

chess[*x + x_move[6]][*y + y_move[6]] == 0)

{

*x += x_move[6];

*y += y_move[6];

break;

}

else

return 0;

case 7:

if(*x + x_move[7] < ROWS &&

*x + x_move[7]>= 0 &&

*y + y_move[7]< COLS &&

*y + y_move[7]>= 0 &&

chess[*x + x_move[7]][*y + y_move[7]] == 0)

{

*x += x_move[7];

*y += y_move[7];

break;

}

else

return 0;

default:

return 0;

}

return 1;

}

int deepsearch(int x,int y, int j)

{

/*save the value x,y*/

int x1 = x, y1 = y;

int tag = 0, i = 0;

/*save j on chess[x][y]*/

chess[x][y] = j;

/*recursion exit condition*/

if(j == COLS*ROWS)

{

return 1;

}

/*find the next point in eight directions*/

tag = nextxy(&x1,&y1,i);

/*find the nextx,nexty */

while (tag == 0 && i < 7)

{

i ++;

tag =nextxy(&x1,&y1, i);

}

/*the nextxy be found*/

while(tag)

{

if(deepsearch(x1,y1,j+1))

return 1;

/*if failed, a new finding process */

x1 = x; y1 = y;

i ++;

tag = nextxy(&x1,&y1,i);

while (tag == 0 && i < 7)

{

i ++;

tag = nextxy(&x1,&y1,i);

}

}

/*no direction can findnextpoint*/

if(tag == 0)

chess[x][y] = 0;

return 0;

}

void main()

{

clock_t start = clock();

deepsearch(2,0,1);

print_matrix();

int seconds = (clock()-start)/CLOCKS_PER_SEC;

printf("%d",seconds);

return;

}