问题描述：
曾经用简单的深度优先搜索方法、递归的形式对马踏棋盘进行搜索，运行效率不甚理想。（博客见马踏棋盘之递归实现）。
所以现在用贪心算法将其优化了一下。
问题解析：
主要的思想没有变，还是用深度优先搜索，只是在选下一个结点的时候做了贪心算法优化，其思路如下：
从起始点开始，根据“马”的走法，它的下一步的可选择数是有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<stdio.h>
#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<H;i++)
{
k=9;
for(j=0;j<8;j++)
{
if(F[j]>-1 && F[j]<k)
{
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("请输入起始点的坐标：
");
printf("x=");
scanf("%d",&i);
printf("y=");
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("
完成！！
");
printf("回溯的次数：%d
",zz);
break;
}
}
}
else
{
dep--;
zz++;
a[n] = 0;
n = s[dep-1];
}
}
}
//输出所有的遍历路径
void Output()
{
int i,j,k;
printf("
输入'1'展示详细遍历，输入'0'退出程序：");
scanf("%d",&count);
if(count)
{
for(i = 0;i < z;i++)
{
printf("
第%d个解：
",i+1);
for(j = 0;j < 8;j++)
{
for(k = 0;k < 8;k++)
printf("%3d",out[i][j][k]);
printf("
");
}
}
}
}
void main()
{
int n;
n = Prepare();
Running(n);
Output();
}运行结果：
测试了一下：50000条路径，耗时17秒！！！效率比普通的深度优先搜索不知道高了多少倍！
备注：
以上代码是四个月前写的，现在才整理出来。打击很大，当初不注意代码的格式和备注，现在看自己写的代码看到头晕脑炸，自食其果！以后必须注重写代码的风格，注意写上必须的备注，连自己写的代码的看不懂，真真可笑。一直看了好久终于看明白各个函数 各个变量的作用了，也改了一些格式，写了一些备注，到现在正的看不下去了。先把文章放出来，缓一阵再回来完善。