http://www.cnblogs.com/wonderKK/tag/马踏棋盘/

马踏棋盘（递归算法）

#include <iostream.h>
int board [8][8]={0};
int Htry1[8]={-2,-1,1,2,2,1,-1,-2};
int Htry2[8]={1,2,2,1,-1,-2,-2,-1};
bool chech[8][8]={0};//标记位置是否已经被占用
int n=1;//就算已走的步数


void findway(int i,int j)
{
for(int z=0;z<8;z++)
{
if(i+Htry1[z]>=0&&i+Htry1[z]<8&&
j+Htry2[z]>=0&&j+Htry2[z]<8&&
!chech [i+Htry1[z]][j+Htry2[z]]//检查要走的下个位置是否可行
    )
{

n++;
board[i+Htry1[z]][j+Htry2[z]]=n;
chech[i+Htry1[z]][j+Htry2[z]]=true;
if(n==64||n==-1)goto next;
findway(i+Htry1[z],j+Htry2[z]);
if(n==64||n==-1)goto next;
}
}
n--;
board[i][j]=0;
chech[i][j]=false;




next:return ;
}


int main()
{
int i,j;


int z,y;
  cout<<"请输入马的初始位置";
  cin>>i;
  cin>>j;
  chech[i][j]=true;
  board[i][j]=1;


findway(i,j);
for(z=0;z<8;z++)
  {
for(y=0;y<8;y++)
 cout<<board [z][y]<<"";
 cout<<endl;
  }
return 1;
}

马踏棋盘（非递归）

#include <iostream.h>


struct point
{
int x,y;//马的位置
int dir;//这一次马行走的方向
};


struct stack
{
point p[64];//存储马的位置，方便回溯
};
int board [8][8];
int Htry1[8]={-2,-1,1,2,2,1,-1,-2};
int Htry2[8]={1,2,2,1,-1,-2,-2,-1};
bool chech[8][8]={0};//标记位置是否已经被占用
int main()
{
int i,j;
int top=0;
int z;
  cout<<"请输入马的初始位置";
  cin>>i;
  cin>>j;
  stack sta;
  sta.p[top].x=i;
  sta.p[top].y=j;
  board [i][j]=top;
  chech [i][j]=true;
int nx;
int ny;


for(int u=0;u<64;u++)
 sta.p[u].dir=0;//把每个结点的dir清零
  for(z=0;;)
  {

if(sta.p[top].x+Htry1[z]>=0&&sta.p[top].x+Htry1[z]<8&&
sta.p[top].y+Htry2[z]>=0&&sta.p[top].y+Htry2[z]<8&&
!chech [sta.p[top].x+Htry1[z]][sta.p[top].y+Htry2[z]]//检查要走的下个位置是否可行
 )
 {
nx=sta.p[top].x+Htry1[z];
ny=sta.p[top].y+Htry2[z];
 sta.p[top].dir=z;
 top++;
 sta.p[top].x=nx;
 sta.p[top].y=ny;
 board [nx][ny]=top;
 chech [nx][ny]=true;
z=-1;
 }
else if(z==7)//如果不可行，而且是最好一次检查
 { chech [sta.p[top].x][sta.p[top].y]=false;
top--;
while(1)
{
z=sta.p[top].dir;
if(z!=7)
break;
else
{ chech [sta.p[top].x][sta.p[top].y]=false;
top--;
}
}
 }
if(top==-1||top==63)break;//如果回溯到-1，或者栈满，则退出循环
 z++;


  }
for(i=0;i<8;i++)
  {
for(j=0;j<8;j++)
 cout<<board [i][j]<<"";
 cout<<endl;
  }
return 1;
}

马踏棋盘的贪心算法

【问题描述】
马的遍历问题。在８×８方格的棋盘上，从任意指定方格出发，为马寻找一条走遍棋盘每一格并且只经过一次的一条路径。
【初步设计】
首先这是一个搜索问题，运用深度优先搜索进行求解。算法如下：
１、    输入初始位置坐标x,y；
２、    步骤 c:
　　　如果c>64输出一个解，返回上一步骤c–
(x,y) ← c
计算(x,y)的八个方位的子结点，选出那此可行的子结点
循环遍历所有可行子结点，步骤c++重复2
显然（２）是一个递归调用的过程，大致如下：

void dfs(int x,int y,int count)
{
int i,tx,ty;
if(count>N*N)
    {
        output_solution();//输入一个解
    return;
    }
for(I=0;i<8;++i)
    {
        tx=hn[i].x;//hn[]保存八个方位子结点
    ty=hn[i].y;
        s[tx][ty]=count;
    dfs(tx,ty,count+1);//递归调用
        s[tx][ty]=0;
    }
}

这样做是完全可行的，它输入的是全部解，但是马遍历当８×８时解是非常之多的，用天文数字形容也不为过，这样一来求解的过程就非常慢，并且出一个解也非常慢。

怎么才能快速地得到部分解呢？

【贪心算法】

其实马踏棋盘的问题很早就有人提出，且早在1823年，J.C.Warnsdorff就提出了一个有名的算法。在每个结点对其子结点进行选取时，优先选择‘出口’最小的进行搜索，‘出口’的意思是在这些子结点中它们的可行子结点的个数，也就是‘孙子’结点越少的越优先跳，为什么要这样选取，这是一种局部调整最优的做法，如果优先选择出口多的子结点，那出口少的子结点就会越来越多，很可能出现‘死’结点（顾名思义就是没有出口又没有跳过的结点），这样对下面的搜索纯粹是徒劳，这样会浪费很多无用的时间，反过来如果每次都优先选择出口少的结点跳，那出口少的结点就会越来越少，这样跳成功的机会就更大一些。这种算法称为为贪心算法，也叫贪婪算法或启发示算法，它对整个求解过程的局部做最优调整，它只适用于求较优解或者部分解，而不能求最优解。这样的调整方法叫贪心策略，至于什么问题需要什么样的贪心策略是不确定的，具体问题具体分析。实验可以证明马遍历问题在运用到了上面的贪心策略之后求解速率有非常明显的提高，如果只要求出一个解甚至不用回溯就可以完成，因为在这个算法提出的时候世界上还没有计算机，这种方法完全可以用手工求出解来，其效率可想而知。

在前面的算法基础之上，增添一些程序加以实现：

函数１：计算结点出口多少

int ways_out(int x,int y)
{
int i,count=0,tx,ty;
if(x<0||y<0||x>=N||y>=N||s[x][y]>0)
return -1;//-1表示该结点非法或者已经跳过了
    for(i=0;i<8;++i)
    {
        tx=x+dx[i];
        ty=y+dy[i];
if(tx<0||ty<0||tx>=N||ty>=N)
continue;
if(s[tx][ty]==0)
            ++count;
    }
return count;
}

函数２：按结点出口进行排序

void sortnode(h_node *hn,int n)//采用简单排序法，因为子结点数最多只有8
{
int i,j,t;
    h_node temp;
for(i=0;i<n;++i)
    {
for(t=i,j=i+1;j<n;++j)
if(hn[j].waysout<hn[t].waysout)
            t=j;
if(t>i)
        {
            temp=hn[i];
            hn[i]=hn[t];
            hn[t]=temp;
        }
    }
}

函数３：修改后的搜索函数

void dfs(int x,int y,int count)
{
int i,tx,ty;
    h_node hn[8];
if(count>N*N)
    {
        output_solution();
return;
    }
for(i=0;i<8;++i)//求子结点和出口
    {
        hn[i].x=tx=x+dx[i];
        hn[i].y=ty=y+dy[i];
        hn[i].waysout=ways_out(tx,ty);
    }
    sortnode(hn,8);
for(i=0;hn[i].waysout<0;++i);//不考虑无用结点
    for(;i<8;++i)
    {
        tx=hn[i].x;
        ty=hn[i].y;
        s[tx][ty]=count;
        dfs(tx,ty,count+1);
        s[tx][ty]=0;
    }
}

函数４：主调函数

void main()
{
int i,j,x,y;
for(i=0;i<N;++i)//初始化
        for(j=0;j<N;++j)
            s[i][j]=0;
    printf("Horse jump while N=%d\nInput the position to start:",N);
    scanf("%d%d",&x,&y);//输入初始位置
    while(x<0||y<0||x>=N||y>=N)
    {
    printf("Error! x,y should be in 0~%d",N-1);
    scanf("%d%d",&x,&y);
    }
    s[x][y]=1;
    dfs(x,y,2);//开始搜索
}