骑士移动问题 实现的三种算法 POJ 2243,ZOJ 1091

   经典的TKP问题,在8*8的棋盘上,问骑士(相当于中国象棋中的马)从一点移动到另一点至少需要走一步。 应该是有三种解法,DFS,BFS,和 floyd 打表求出每两点之间的最短

路,笔者亲测,程序的运行速度应该是floyd > BFS > DFS,下面给出三种代码。

//DFS版本
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
int knight[8][8];
int dx[]={1,1,-1,-1,2,2,-2,-2};
int dy[]={2,-2,2,-2,1,-1,1,-1};
void DFS(int x,int y,int step)
{
    if(x<0 || x>7 || y<0 || y>7 || step>=knight[x][y])
         return ;
    knight[x][y]=step;
    for(int i=0;i<8;i++)
    {
        DFS(x+dx[i],y+dy[i],step+1);
    }
}
int main()
{
    char s[5],t[5];
    while(scanf("%s %s",s,t)!=EOF)
    {
        memset(knight,10,sizeof(knight));
        DFS(s[0]-'a',s[1]-'1',0);
        printf("To get from %s to %s takes %d knight moves.\n",s,t,knight[t[0]-'a'][t[1]-'1']);
    }
    return 0;}
//BFS版本
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
using namespace std;
struct Point
{
    int x;
    int y;
    int step;
}from,to;
int main()
{
    queue<Point> q;
    char s[5],t[5];
    int x[]={1,1,-1,-1,2,2,-2,-2};
    int y[]={2,-2,2,-2,1,-1,1,-1};
    while(scanf("%s %s",s,t)!=EOF)
       {
           while(!q.empty()) q.pop();
           from.x=s[0]-'a';
           from.y=s[1]-'1';
           from.step=0;
           to.x=t[0]-'a';
           to.y=t[1]-'1';
           q.push(from);
           Point tmp;
           while(q.size())
           {
               from=q.front();
               q.pop();
               if(from.x==to.x && from.y==to.y)
                    break;
               for(int i=0;i<8;i++)
               {
                   tmp.x=from.x+x[i];
                   tmp.y=from.y+y[i];
                   tmp.step=from.step+1;
                   if(tmp.x>=0&&tmp.x<8&&tmp.y>=0&&tmp.y<8)
                     q.push(tmp);
               }
           }
        printf("To get from %s to %s takes %d knight moves.\n",s,t,from.step);
       }
       return 0;
}
 
//FLOYD版本
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>
#include <cmath>
using namespace std;
const int maxn = 64;
void floyd(int dis[][64])
{
    for(int i=0;i<64;dis[i][i]=0,i++)
        for(int j=0;j<64;j++)
    {
        int x=abs(i/8-j/8);
        int y=abs(i%8-j%8);
        if((x==1 && y==2) || (x==2 && y==1))
            dis[i][j]=dis[j][i]=1;
    }
    for(int m=0;m<64;m++)
        for(int i=0;i<64;i++)
          for(int j=0;j<64;j++)
             dis[i][j] = min (dis[i][j],dis[i][m]+dis[m][j]);
}
int main()
{
    int dis[maxn][maxn];
    for(int i=0;i<64;i++)
        for(int j=0;j<64;j++)
           dis[i][j]=10;
    floyd(dis);
    char s[5];
    char t[5];
    while(scanf("%s %s",s,t)!=EOF)
    {
        int x = (s[0]-'a')*8+(s[1]-'1');
        int y = (t[0]-'a')*8+(t[1]-'1');
        printf("To get from %s to %s takes %d knight moves.\n",s,t,dis[x][y]);
    }
    return 0;
}






  • 1
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
问题描述:将马随机放在国际象棋的 8X8 棋盘中的某个方格中 马按走棋规则进行移动 要求每个方格上只进入一次 走遍棋盘上全部 64 个方格 编制递归程序 求出马的行走路线 并按求出的行走路线 将数字 1 2 … 64 依次填入 8X8 的方阵输出之 测试数据:由读者指定可自行指定一个马的初始位置 实现提示:每次在多个可走位置中选择一个进行试探 其余未曾试探过的可走位置必须用适当结构妥善管理 以备试探失败时的“回溯”悔棋使用 并探讨每次选择位置的“最佳策略” 以减少回溯的次数 背景介绍: 国际象棋为许多令人着迷的娱乐提供了固定的框架 而这些框架常独立于游戏本身 其中的许多框架都基于骑士奇异的L型移动规则 一个经典的例子是骑士漫游问题 从十八世纪初开始 这个问题就引起了数学家和解密爱好者的注意 简单地说 这个问题要求从棋盘上任一个方格开始按规则移动骑士 使之成功的游历国际象棋棋盘的64个方格 且每个方格都接触且仅接触一次 可以用一种简便的方法表示问题的一个解 即将数字1 64按骑士到达的顺序依次放入棋盘的方格中 一种非常巧妙的解决骑士漫游地方法由J C Warnsdorff于1823年给出 他给出的规则是:骑士总是移向那些具有最少出口数且尚未到达的方格之一 其中出口数是指通向尚未到达方格的出口数量 在进一步的阅读之前 你可以尝试利用Warnsdorff规则手工构造出该问题的一个解 实习任务: 编写一个程序来获得马踏棋盘即骑士漫游问题的一个解 您的程序需要达到下面的要求: 棋盘的规模是8 8; 对于任意给定的初始化位置进行试验 得到漫游问题的解; 对每次实验 按照棋盘矩阵的方式 打印每个格被行径的顺序编号 技术提示: 解决这类问题的关键是考虑数据在计算机中的存储表示 可能最自然的表示方法就是把棋盘存储在一个8 8的二维数组board中 以 x y 为起点时骑士可能进行的八种移动 一般来说 位于 x y 的骑士可能移动到以下方格之一: x 2 y+1 x 1 y+2 x+1 y+2 x+2 y+1 x+2 y 1 x+1 y 2 x 1 y 2 x 2 y 1 但请注意 如果 x y 的位置离某一条边较近 有些可能的移动就会把骑士移到棋盘之外 而这当然是不允许的 骑士的八种可能的移动可以用一个数组MoveOffset方便地表示出来: MoveOffset[0] 2 1 MoveOffset[1] 1 2 MoveOffset[2] 1 2 MoveOffset[3] 2 1 MoveOffset[4] 2 1 MoveOffset[5] 1 2 MoveOffset[6] 1 2 MoveOffset[7] 2 1 于是 位于 x y 的骑士可以移动到 x+MoveOffset[k] x y+MoveOffset[k] y 其中k是0到7之间的某个整数值 并且新方格必须仍位于棋盘上 扩展需求:可以考虑将结果图形化 b 考察所有初始化的情况 测试是否都能够得到解 ">问题描述:将马随机放在国际象棋的 8X8 棋盘中的某个方格中 马按走棋规则进行移动 要求每个方格上只进入一次 走遍棋盘上全部 64 个方格 编制递归程序 求出马的行走路线 并按求出的行走路线 将数字 1 2 … 64 依 [更多]

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值