1马的遍历

最新推荐文章于 2022-08-03 13:36:32 发布
最新推荐文章于 2022-08-03 13:36:32 发布
阅读量211 收藏
点赞数 1
分类专栏： 马的遍历 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57575155/article/details/122268396
版权


#include<string>
#include<conio.h>
#include<stdio.h>
#include <graphics.h>    // 引用 EasyX 图形库
#define MAXSIZE 100//用于马所遍历的点最大值
using namespace std;
int X,Y,mx,my,x,y,hx,hy,zcx,zcy,zxx,zyy;
wchar_t ix[10];    
wchar_t iy[10];
int flag=0;
int count=1;
char zx[1];
char zy[1];
char s[] = "马的遍历";
char t[]="马：";
char T[]="遍历结束";
int getmouse(int c);
int nn,mm;
int dir[8][2]={{-2,1},{-1,2},{1,2},{2,1},{2,-1},{1,-2},{-1,-2},{-2,-1}};  //八个方向
int nexti[8],nextj[8];
int board[10][10];
int exists[8];  //记录当前点的下一个点的出路数 
int getpoint(int hx,int hy);


typedef struct
{
    int x,y;
    
}biaoji;//马的坐标 用于自动遍历

  typedef struct
{
biaoji di[8];
   
}biao;//存储马八个方向

void initial(biao &L ){
      for(int i=0;i<8;i++){
    L.di[i].x=0;
    L.di[i].y=0;
      }
  }//初始化八个坐标坐标的方向为0
int tag(biao &L,int mx, int my){
      flag++;
     
      
      board[mx][my] =flag;
      int j,i;
      i=0;
      for(j=0;j<8;j++){
        
          if(board[mx+dir[j][0]][my+dir[j][1]]==0&&0<mx+dir[j][0]&&mx+dir[j][0]<x+1&&0<my+dir[j][1]&&my+dir[j][1]<y+1){
               i++;
                L.di[j].x=mx+dir[j][0];
                L.di[j].y=my+dir[j][1];
          }
          
        
          }
     
 if(i==0){ getpoint(0,0);return 1;}//无位置走则带入0 0结束

 return 0;

  }//标记八个反向的坐标（走过则不予标记board[x][y]数组中存走的第几次数，x，y表示其中马的坐标）

int judge(biao &L,int x,int y){
      
      for(int j=0;j<8;j++){
         
          if(L.di[j].x==x&&L.di[j].y==y)
              return 1;
             
          
  }
 
return 0;
}
      
void paint(){
       char qx[1];
       char qy[1];
       X=(x)*100+40;
       Y=(y-1)*100+40;

    
       initgraph(X,Y+50);
       setbkcolor(YELLOW);
       cleardevice();
       settextstyle(25, 0, "黑体");
       setlinestyle(PS_SOLID,2); //设置线的样式
       setlinecolor(BLACK);//设置线的颜色
       settextcolor(BLACK);//设置字体的颜色
       outtextxy((X-140)/2,0,s);//设置字体的位置
       outtextxy(X-110,10,"遍历顺序");
        
      
      
       for(int i=0;i<=((Y-40)/100);i++){
       line(20,100*i+70,X-120,100*i+70); 
       sprintf(qx,"%d",i+1);
       outtextxy(2,100*i+65,qx);
       }//滑动y轴划线

       for(int j=0;j<=((X-140)/100);j++){
       line(100*j+20,70,100*j+20,Y+30);
       sprintf(qy,"%d",j+1);
       outtextxy(100*j+15,40,qy);
       }//滑动x轴划线 
      

}//画棋盘


int getpoint(int hx,int hy){
    if(hx==0&&hy==0)    {
        outtextxy(X-110,Y,"未遍历完全");
    _getch();
    return 1;
    }    settextstyle(15, 0, "黑体");
         if(flag||count)  clearcircle(20+(zcx-1)*100,70+(zcy-1)*100,10);
         if(flag+1) outtextxy(0,0,"返回");
        count++;
          
           setfillcolor(BLACK);
           fillcircle(20+(hx-1)*100,70+(hy-1)*100,10);
           
          sprintf(zx,"%d",hx);
          sprintf(zy,"%d",hy);
          settextcolor(BLACK);//设置字体的颜色
          
          if(15*(count)+50<Y){
          outtextxy(X-110,15*(count)+50,t);//设置字体的位置
          outtextxy(X-90,15*(count)+50,zy[0]);//设置字体的位置
          outtextxy(X-75,15*(count)+50,zx[0]);//设置字体的位置
          }
    if(15*(count)+50>=Y){
          outtextxy(X-60,15*(count)+115-Y,t);//设置字体的位置
          outtextxy(X-40,15*(count)+115-Y,zy[0]);//设置字体的位置
          outtextxy(X-25,15*(count)+115-Y,zx[0]);//设置字体的位置
          }
    settextstyle(22, 0, "黑体");
    if(count==x*y){ 
        outtextxy(X-110,Y,"已完全遍历");
        _getch();
    }
    else{    
        outtextxy(X-110,Y,"正在遍历中");
    }
    
    

        Sleep(1000);
       
        
        zcx=hx;
        zcy=hy;
    return 0;     

}    //获取棋盘点的位置
    


int input1(){
    int v=0;
    initgraph(480, 480);
    setbkcolor(YELLOW);
    cleardevice();
    
    //设置字体颜色 还有测试显示字体
    settextcolor(BLACK);
    settextstyle(25, 0, "黑体");
    outtextxy(200, 50, "自动遍历");
    outtextxy(100,100, "棋盘大小");
    outtextxy(100, 180, "起始坐标");
   
    outtextxy(0, 0, "-------------------------------------");
    outtextxy(0, 300, "-------------------------------------") ;
       
    string str1,str2,str3,str4;   //头文件 string 
    //str1用来放c的总内容 str2每次存放“显示内容：”+str1，方便输出
    

    char c;  //定义字符c接收键盘输入
    while(v!=5){
        c=_getch();
       
        if (c== '\b') 
        {   v--;
          if(v<2)
               str1 = str1.substr(0, str1.size()-1);
               
           else
              str3 = str3.substr(0, str3.size() - 1);       
        }//如果c是退格符，str1删掉一个
 
        else{
        if(c!=' ')//是否是空格
              v++;

            if(v<=2){ 
                    
            str1 += (int)c; 
            
             if(v==1)
                  hx=(int)c; 
             else if(v==2)
                     hy=(int)c;
        }//判断在第几行输入 

           else{
             
            str3+=(int)c; 
            
            if(v==3)
               my=(int)c; 
             else if(v==4)
               mx=(int)c;}
       } 

    
    
    
         str2 = "棋盘大小:" + str1;
        str4 = "起始坐标:" + str3;
        cleardevice();
        outtextxy(0, 0, "------------------------------------");
       
        outtextxy(0, 300, "------------------------------------");
        outtextxy(200, 50, "自动遍历");
        
        outtextxy(100, 100, str2.c_str()); 
        outtextxy(100, 180, str4.c_str()); 
        if(v==4){
            outtextxy(0, 400, "------------按任意键进入----------");
            v++;
           _getch();
         }
        
    }closegraph();

return 0;


}

int input2(){
    int v=0;
    initgraph(480, 480);
    setbkcolor(YELLOW);
    cleardevice();
    
    //设置字体颜色 还有测试显示字体
    settextcolor(BLACK);
    settextstyle(25, 0, "黑体");
    outtextxy(200, 50, "手动遍历");
    outtextxy(100,100, "棋盘大小");
    
   
    outtextxy(0, 0, "-------------------------------------");
    outtextxy(0, 300, "-------------------------------------") ;
       
    string str1,str2;  //头文件 string 
    //str1用来放c的总内容 str2每次存放“显示内容：”+str1，方便输出
    

    char c;  //定义字符c接收键盘输入
    while(v!=3){
        c=_getch();
       
        if (c== '\b') 
        {   v--;
            str1 = str1.substr(0, str1.size()-1);
               
        }//如果c是退格符，str1删掉一个
 
        else{
          if(c!=' ')//是否是空格
              v++;
                    
            str1 += (int)c; 
            
             if(v==1)
                  hx=(int)c; 
             else
                     hy=(int)c;
        }//判断在第几行输入 

         
    
         str2 = "棋盘大小:" + str1;
       
        cleardevice();
        outtextxy(0, 0, "------------------------------------");
       
        outtextxy(0, 300, "------------------------------------");
        outtextxy(200, 50, "手动遍历");
        
        outtextxy(100, 100, str2.c_str()); 
        
        if(v==2){
            outtextxy(0, 400, "------------按任意键进入----------");
            v++;
           _getch();
         }
        
    }closegraph();

return 0;


}

int slove(int x,int y)
{
    getpoint(y,x);
    memset(board,0,sizeof(board));
    memset(exists,0,sizeof(exists));
    memset(nexti,0,sizeof(nexti));
    memset(nextj,0,sizeof(nextj));//初始化数组
    int cnt,t,minx,tmp;
    board[x][y] = 1;
    for(int i=2;i<=nn*mm;++i){

        for(int k=0;k<8;++k){
            exists[k] = 0;  //初始化出路的个数为0
        }
        t = 0;  
        for(int j=0;j<8;++j){
            int nx = x + dir[j][0];
            int ny = y + dir[j][1];
            if(nx<1||nx>nn||ny<1||ny>mm) continue;
            if(board[nx][ny] == 0){ //如果这个方向可走，则记录方向
                nexti[t] = nx;
                nextj[t] = ny;
                t++;
            }
        }
        cnt = t;  //cnt记录的是从当前点向8个方向走，可以落子的点的个数
        if(cnt == 0)  { getpoint(0,0) ;return 0    ;}  //从这一步无路可走
        
        else if(cnt == 1){  //只有一个可以走的方向,则这个方向就是最少出路的方向
             minx=0;
        }

        else{
            for(k=0;k<cnt;++k){
                for(int j=0;j<8;++j){
                    int nx = nexti[k]+dir[j][0];
                    int ny = nextj[k]+dir[j][1];
                    if(nx<1||nx>nn||ny<1||ny>mm) continue;
                    if(board[nx][ny]==0){
                        exists[k]++;  //记录下个位置的出路数据
                    }
                }
            }

            tmp = exists[0];
            minx = 0;

            for(k=1;k<cnt;++k){
                if(exists[k] < tmp){
                    tmp = exists[k];
                    minx = k;
                 }
            }
        }
        x = nexti[minx];
        y = nextj[minx];
        getpoint(y,x);    
        board[x][y] = i;
    }
    return 1;
}

int getmouse(int c){

    MOUSEMSG m; 

    switch(c){
    case 1:         
    
         while(1){
             m = GetMouseMsg();
            if(m.x>=190&&m.x<=240&&m.y>=300&&m.y<=340){
                setlinecolor(BLUE);
                  rectangle(190,300,240,340);
                   if (m.uMsg == WM_LBUTTONDOWN) {        //如果按下鼠标左键实现相应功能.
                   closegraph();
                   return 1;
            }
            }

            else if(m.x>=260&&m.x<=310&&m.y>=300&&m.y<=340){
                        setlinecolor(BLUE);
                        rectangle(260,300,310,340);
                if (m.uMsg == WM_LBUTTONDOWN) {        //如果按下鼠标左键实现相应功能.
                   exit(0);
            }
        } 
            else
             {
                setlinecolor(YELLOW);
                   rectangle(190,300,240,340);
                   rectangle(260,300,310,340);
    }
    }break;
    

    case 2:        biao L;
                initial(L);
    memset(board,0,sizeof(board));
    
        while(1){
a:              m = GetMouseMsg();
                if(m.x<40&&m.y<20&&m.uMsg == WM_LBUTTONDOWN){
                return 1;
                }
               if (m.uMsg == WM_LBUTTONDOWN&&m.x<=X-120){//如果按下鼠标左键实现相应功能.
            if(flag!=0){
                 if(!judge(L,m.x/100+1,m.y/100+1)||zxx==m.x/100+1&&zyy==m.y/100+1)goto a;
                 }
            
                 getpoint(m.x/100+1,m.y/100+1);
                 zxx=m.x/100+1;
                 zyy=m.y/100+1;
                  initial(L);
                 if(tag(L,m.x/100+1,m.y/100+1)) return 0;

                 }
             
     
        
           }break;

    case 3:
        while(1){
                m = GetMouseMsg();
             if(m.x>=110&&m.x<=360&&m.y>=150&&m.y<=220){
                         setlinecolor(BLUE);
                        rectangle(110,150,360,220);
             if (m.uMsg == WM_LBUTTONDOWN) {        //如果按下鼠标左键实现相应功能.
                    closegraph();
                    return 2;
             }
             }
             else if(m.x>=110&&m.x<=360&&m.y>=300&&m.y<=370){
                        setlinecolor(BLUE);
                        rectangle(110,300,360,370);
             if (m.uMsg == WM_LBUTTONDOWN) {        //如果按下鼠标左键实现相应功能.
                    closegraph();
                    return 1;
             }
             }
         else
        {
            setlinecolor(YELLOW);
               rectangle(110,150,360,220);
              rectangle(110,300,360,370);
        }
        }break;
    }
return 1;

}
void gameover(){

    initgraph(480, 480);
    setbkcolor(YELLOW);

    cleardevice();
    

    settextcolor(BLACK);
    settextstyle(60, 0, "黑体");
    
    outtextxy(130, 100, "游戏结束");
    settextstyle(40, 0, "黑体");
    outtextxy(160, 200, "是否继续?");
    outtextxy(190, 300, "是");
    outtextxy(260, 300, "否");
        getmouse(1);

}
int show(){
initgraph(480,480);
setbkcolor(YELLOW);
cleardevice();
settextcolor(BLACK);    
settextstyle(60, 0, "黑体");
outtextxy(110,0,"马的遍历");
settextstyle(40, 0, "黑体");
outtextxy(130,150,"手动遍历");
outtextxy(130,300,"自动遍历");
return getmouse(3);

}


int main(){  

A:   count=0;flag=0;
    switch(show()){
    case 1:input1(); x=hx-48;
        y=hy-48;
        mm=x;
        nn=y;
        mx=mx-48;
        my=my-48;
        paint();
        slove(mx,my);
        gameover();
        goto A;break;
    case 2:input2(); 
        x=hx-48;
        y=hy-48;
        paint();  
        if(getmouse(2)) goto A;
        else{gameover();
            goto A;}
 }

    
      return 1;
    
}
//需要下载easyx库

 

qq_57575155
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
汉诺塔问题
Junds0的博客
05-21 469
当n>1时：当把n-1块从 A 上拿走后，此时第 n 块便可以从 A 移动到 C ，因为第 n 块最大，所以这时 C 上只能有这最大的第 n 块，其余的 n-1 块都在B上。目的是将最左边杆上的盘全部移到中间的杆上，条件是一次只能移动一个盘，且不允许大盘放在小盘的上面。这是一个著名的问题，几乎所有的教材上都有这个问题。第一次是将 n-1 块从 A 移动到 B，第二次是将 n-1 块从 B 移动到C，根据对称性可知，这两次移动的次数是相等的，且与将 n-1 块从 A 移动到 C 的次数也是相等的。
马的遍历C++
FCBerlin的博客
09-04 1496
题目描述 有一个 n*m 的棋盘 (1<n,m<=400)，在某个点上有一个马，要求你计算出马到达棋盘上任意一个点最少要走几步。 输入格式 一行四个数据，棋盘的大小和马的坐标。 输出格式 一个 n*m 的矩阵，代表马到达某个点要走几步（两两用1个空格隔开，行末不能有尾空格）。 不能到达则输出 -1 样例输入 3 3 1 1 样例输出 0 3 2 3 -1 1 2 1 4 代码如下： #include<bit.
回溯法之马的遍历问题(递归)
weixin_43827397的博客
08-07 4278
马的遍历问题：在n*m的棋盘上，马只能走日字。马从位置(x,y)处出发，把棋盘的每一点都走一次，且只走一次，找出所有路径。 问题分析：行n，列m，马在不出边界的情况下有8个方向可以行走（走日字），如当前坐标为(x,y),则行走后的坐标可以为： (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-2,y+1) 回溯法算法设计： 搜索空间是nM个点，约束条件是不出边界且每个点只经过一次，节点的扩展规则如上所述。 搜
C++知识精讲2——马的遍历（搜索与回溯）
Yu仙笙的博客
08-03 1550
C++知识精讲的第2篇，马的遍历。把知识点带入到实战，免费阅读，注释精讲知识点，希望大家前来阅读。如果喜欢此专栏请订阅持续关注。
马的遍历（算法设计与分析）
online4817的博客
05-25 1170
马的遍历
马的遍历（回溯法）
weixin_53731572的博客
06-04 1516
马的遍历，回溯算法
马的遍历课程设计
04-15
在本课程设计中，主题是“马的遍历”，这是一个基于棋盘的游戏问题，其中的目标是让马在标准的8x8国际象棋棋盘上按照特定规则移动，尽可能访问到每个位置。在这个项目中，开发者使用了贪婪算法来解决这个问题。 ...
象棋 马的遍历
04-24
【问题描述】 在N*N棋盘上，任意一个位置放置一个棋子马，要能...1) 有兴趣的同学可在棋盘上设置一个或多个憋马腿的棋子，尝试遍历过程如何完善。 本代码代码原创，用C语言写成，使用贪心算法，实现了蹩马腿功能。
马遍历棋盘
11-06
### 马遍历棋盘：ACM算法深入解析 #### 核心概念与背景 在计算机科学领域，特别是算法设计与分析中，“马遍历棋盘”问题是一个经典的图论与搜索算法应用实例。该问题源于国际象棋中骑士（马）的移动规则：马走“日...
数据结构课程设计《马的遍历问题》.pdf
09-30
"数据结构课程设计《马的遍历问题》" 本文旨在解决马的遍历问题，设计一个算法来遍历中国象棋棋盘上的一匹马，要求输出所走过的每个位置的坐标，并能够动态地标注行走过程。 问题描述 马的遍历问题是中国象棋棋盘...
马遍历棋盘 马走遍棋盘
05-09
1. 回溯法：首先，我们选择一个起始位置，然后尝试移动马到一个未访问过的位置。如果新的位置有效且未被访问过，我们就标记这个位置为已访问，并继续移动。如果马走遍了所有位置，那么我们找到了一个解决方案；否则...
马的遍历-搜索
luyi博客
03-05 5571
题目描述 中国象棋半张棋盘如图（a）所示。马自左下角往右上角跳。今规定只许往右跳，不许往左跳。比如图（a）中所示为一种跳行路线，并将所经路线打印出来。打印格式为：0,0-&gt;2,1-&gt;3,3-&gt;1,4-&gt;3,5-&gt;2,7-&gt;4,8… 废话不多说，直接上代码 #include&lt;iostream&gt; using namespace std; in...
马的遍历（棋盘游戏）
BlingBling_An_的博客
06-23 3502
广度优先搜索（Breadth First Search, BFS）类似树的按层次遍历。 原则是：尽可能地先横向搜索；特点是：先访问的顶点其邻接点亦先被访问。 ①从顶点v出发，置visited[v]=true，将v入队； ②只要队列不为空，重复将队头u出队，检查u的所有邻接点w，如果visited[u]=false，则将其入队并置visited[u]=true ...
回溯法-马的遍历问题
qq_52922190的博客
05-29 2330
问题描述： 在中国象棋中，马只能走“日” 字。现有一5*4棋盘，马从位置(x,y)处出发，把棋盘的每一格都走一次，且只走一次。找出所有路径。 问题分析： 行n，列m，马在不出边界的情况下有8个方向可以行走（走日字），如当前坐标为(x,y),则行走后的坐标可以为： (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-2,y+1) 算法设计： 搜索空间是整个棋盘n*m个棋盘上点 约束条....
马的遍历
Liston_YDQ的博客
07-29 664
题目描述 在n*m(n表示行，m表示列）的棋盘上，马起始位置为x,y（注意：左上角第一个位置为1,1），问：马有多少种走的方法，将棋盘所有的位置全部走一遍，并且每个位置经过且仅经过一次。马跳“日”字。 输入 第一行：n，m（中间空格隔开）（n,m<7） 第二行：x，y（中间空格隔开） 输出 可能的方法数 样例输入 5 4 1 1 样例输出 32 #include<bits/stdc++.h> using namespace std; int n,m,vis[10][10]; int xx
马的遍历（贪心）
gubojun的专栏
01-24 1444
/** * function:马的遍历。在8x8方格的棋盘上，从任意指定的方格出发， * 为马寻找一条走遍棋盘每一格并且只经过一次的一条路径。 * author:顾博君 * time:2013-1-23 */ /* * 采用Warnsdoff策略求解。找出出口最少的点。 * --------------------- | | 4 | | 3 |
“马的遍历”问题的贪婪法解决算法
caozuiba
07-18 183
/**//*标题：&lt;&lt;系统设计师&gt;&gt;应试编程实例-[递推算法程序设计]作者：成晓旭时间：2002年09月14日(18:20:00-20:18:00)实现“装箱”问题的贪婪算法实现函数时间：2002年09月14日(22:00:00-23:18:00)实现“装箱”问题的贪婪算法实现函数时间：2002年09月14日(18:20:38-22:18:00)实现“人民币找零”问题...
P1443 马的遍历
墨海灬流弈的博客
01-27 312
题目描述 有一个n*m的棋盘(1<n,m<=400)，在某个点上有一个马,要求你计算出马到达棋盘上任意一个点最少要走几步。 输入格式 一行四个数据，棋盘的大小和马的坐标 输出格式 一个n*m的矩阵，代表马到达某个点最少要走几步（左对齐，宽5格，不能到达则输出-1） 输入输出样例 输入 #1 3 3 1 1 输出 #1 0 3 2 3 -1 1 2 1 4 题目意思： 给定n*m的数组，和马的初始位置x,y，求马能走哪个点以及走到那个点
p1443 马的遍历
最新发布
10-29
利用两个队列记录起始结点入队，遍历起始节点所有走过的八种情况，符合条件的将a[][]数组该点的值进行更换 a[xx][yy]=a[q1.peek()][q2.peek()]+1; ； 并将该点入队，随后标记该点已经访问。当八种情况全部遍历判断后...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值