马踏棋盘python_马踏棋盘之贪心算法优化

问题描述：

曾经用简单的深度优先搜索方法、递归的形式对马踏棋盘进行搜索，运行效率不甚理想。(博客见马踏棋盘之递归实现)。

所以现在用贪心算法将其优化了一下。

问题解析：

主要的思想没有变，还是用深度优先搜索，只是在选下一个结点的时候做了贪心算法优化，其思路如下：

从起始点开始，根据“马”的走法，它的下一步的可选择数是有0—8个的。

我们知道，当下一步的可选择数为0的时候，进行回溯。当下一步的可选择数有1个的时候，我们直接取那一步就行了。但是如果下一步的可选择数有多个的时候呢？

在上一篇博客中，我们是任意取一个的，只要它在棋盘内，且未遍历就可以了。

但其实我们怎么选下一步，对搜索的效率影响是非常大的！

先介绍一下“贪心算法”。百科里面的定义是：贪心算法(又称贪婪算法)，是指在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。它只考虑局部的最优，从而让总体也最优。就我们这个马踏棋盘来说，我们每走一步都取最优的那个选择，从而让整体的算法也最优。

但是我们选择下一步的时候(假设有a、b、c、d四个点可以选择)，怎样选才算是最优呢？

答案是：哪一个选择的下一步少，就选哪一个。

我们选择a、b、c、d之中的某一个点作为下一步，选哪个比较好，就看哪个点的后续下一步比较少。假如我们选了a，马走到a点后的下一步有3个选择；而如果选了b后的下一步有2个；c有1个，d有2个。那么我们的最优选择是：c点！

为什么要这样选呢？网上的解释是：“选择最难走的路，才能走的远”呜。。。好像太抽象了。

我的理解是：有些选择的后续下一步很少，例如c点，如果不先遍历它的话以后可能会很难遍历到它。

甚至极端一点的情况是，如果现在不遍历它(假设c点)，以后都遍历不到了。遍历不成功的时候只能回溯，一直回溯到此刻的点，然后选了c点以后才能完成，这就浪费了大量的时间。

下面放出所有代码，详细的解释后面再补上：

#include

#define H 3///代表对下一步的排序只取出最小的3个，而不是对8个都排序，这样可以节省很多时间

int fx[8] = {-2,-1,1,2,2,1,-1,-2},fy[8] = {1,2,2,1,-1,-2,-2,-1},f[8] = {-15,-6,10,17,15,6,-10,-17};//fx[]和fy[]表示马下一步的二维的八个方向，给二维坐标x和y用；f[]表示一维的，给数组a用。

int dep = 1;dep为递归的深度，代表在当前位置马已经走了多少步

int count,z = 0,zz = 0;///count表示目标要多少种解法，而z计算当前算出了多少种解法，zz记录在运算中回溯的次数

int out[50001][8][8],F[8],a[64];//out[][][]记录所有的遍历路径，a[]用一维数组记录8*8棋盘中马的遍历路径

/*

*Sorint()函数对点n的下一步进行“后续下一步可选择数”的排序，结果保存在b[][]里面

*c表示前驱结点在结点n的哪个位置。

*/

void Sorting(int b[64][H],int n,int c)

{

int i,j,x,y,m1,m2,k,k1,l=1;

if(c!=-1)

c=(c+8-4)%8;

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

{

F[i]=-1;

m1=n+f[i];

x=n/8+fx[i];

y=n%8+fy[i];

if(c!=i && x>=0 && x<8 && y>=0 && y<8 && a[m1]==0)

{

F[i]++;

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

{

m2=m1+f[j];

x+=fx[j];

y+=fy[j];

if(x>=0 && x<8 && y>=0 && y<8 && a[m2]==0)

F[i]++;

}

}

}

b[n][0]=-1;

for(i=1;i

{

k=9;

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

{

if(F[j]>-1 && F[j]

{

k=F[j];k1=j;

}

}

if(k<9)

{

b[n][l++]=k1;

F[k1]=-1;

b[n][0]=1;

}

else

{

b[n][l++]=-1;

break;

}

}

}

//输入起始坐标，对存放遍历路径的数组a进行初始化

int Prepare()

{

int i,j,n;

printf("请输入起始点的坐标：\n");

printf("x=");

scanf("%d",&i);

printf("\by=");

scanf("%d",&j);

printf("你要的解的数目count=");

scanf("%d",&count);

n = i*8+j-9;//将起始点的二维坐标x、y转化成一维坐标n，从而方便数组a[64]的路径记录

for(i = 0;i < 64;i++)//a[64]存放在8*8方格中马的遍历路径，搜索之前先进行清零初始化

a[i] = 0;

a[n] = 1;

return n;

}

//搜索遍历路径

void Running(int n)

{

int i,j,k;

int b[64][H],s[64];///b[][]用来存放下一步的所有后续结点排序

s[0] = n;

Sorting(b,n,-1);

while(dep >= 0)

{

k = b[n][b[n][0]];

if(b[n][0] != -1 && b[n][0] < H && k != -1)

{

b[n][0]++;

n += f[k];

Sorting(b,n,k);

a[n] = ++dep;

s[dep-1] = n;

if(dep == 64)

{

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

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

out[z][i][j] = a[i*8+j];

z++;

if(z == count)

{

printf("\n完成！！\n");

printf("回溯的次数：%d\n",zz);

break;

}

}

}

else

{

dep--;

zz++;

a[n] = 0;

n = s[dep-1];

}

}

}

//输出所有的遍历路径

void Output()

{

int i,j,k;

printf("\n\n输入'1'展示详细遍历，输入'0'退出程序：");

scanf("%d",&count);

if(count)

{

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

{

printf("\n\n\n第%d个解：\n",i+1);

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

{

for(k = 0;k < 8;k++)

printf("%3d",out[i][j][k]);

printf("\n");

}

}

}

}

void main()

{

int n;

n = Prepare();

Running(n);

Output();

}运行结果：

测试了一下：50000条路径，耗时17秒！！！效率比普通的深度优先搜索不知道高了多少倍！

备注：

以上代码是四个月前写的，现在才整理出来。打击很大，当初不注意代码的格式和备注，现在看自己写的代码看到头晕脑炸，自食其果！以后必须注重写代码的风格，注意写上必须的备注，连自己写的代码的看不懂，真真可笑。一直看了好久终于看明白各个函数 各个变量的作用了，也改了一些格式，写了一些备注，到现在正的看不下去了。先把文章放出来，缓一阵再回来完善。