【大话数据结构C语言】43 图的应用 - 马踏棋盘算法

举报
CodeAllen 发表于 2021/10/29 23:50:18 2021/10/29
【摘要】 欢迎关注我的公众号是【CodeAllen】,关注回复【1024】获取资源 程序员技术交流①群:736386324 ,程序员技术交流②群:371394777     题目要求: 国际象棋的棋盘为8*8的方格棋盘,现将“马”放在任意指定的方格中,按照“马”走棋的规则将“马”进行移动。要求...

欢迎关注我的公众号是【CodeAllen】,关注回复【1024】获取资源
程序员技术交流①群:736386324 ,程序员技术交流②群:371394777    

题目要求:
国际象棋的棋盘为8*8的方格棋盘,现将“马”放在任意指定的方格中,按照“马”走棋的规则将“马”进行移动。要求每个方格只能进入一次,最终使得“马”走遍棋盘64个方格。
 
马的走法就是以下几种

 
对于在n*n的棋盘上,当n>=5且为偶数的时候,以任意点作点都有解

 
 
回溯法:
之前我们谈过回溯法,还是那句话,指导思想很简单,就是一条路走到黑,碰壁了再回来一条路走到黑......一般和递归可以很好的搭配使用,还有 深度优先搜索(DFS)
哈密尔顿路径:
图G中的哈密尔顿路径指的是经过图G中每个顶点,且只经过一次的一条轨迹。如果这条轨迹是一条闭合的路径(从起点出发不重复地遍历所有点后仍能回到起始点),那么这条路径称为哈密尔顿回路。
 
 
 
 
TravelChessBoard.c

   
  1. #include <stdio.h>
  2. #include <time.h>
  3. #define X 8
  4. #define Y 8
  5. int chess[X][Y];
  6. // 找到基于(x,y)位置的下一个可走的位置
  7. int nextxy(int *x, int *y, int count)
  8. {
  9.     switch(count)
  10.     {
  11.         case 0:
  12.             if( *x+2<=X-1 && *y-1>=0 && chess[*x+2][*y-1]==0 )
  13.             {
  14.                 *x = *x + 2;
  15.                 *y = *y - 1;
  16.                 return 1;
  17.             }
  18.             break;
  19.         case 1:
  20.             if( *x+2<=X-1 && *y+1<=Y-1 && chess[*x+2][*y+1]==0 )
  21.             {
  22.                 *x = *x + 2;
  23.                 *y = *y + 1;
  24.                 return 1;
  25.             }
  26.             break;
  27.         case 2:
  28.             if( *x+1<=X-1 && *y-2>=0 && chess[*x+1][*y-2]==0 )
  29.             {
  30.                 *x = *x + 1;
  31.                 *y = *y - 2;
  32.                 return 1;
  33.             }
  34.             break;
  35.         case 3:
  36.             if( *x+1<=X-1 && *y+2<=Y-1 && chess[*x+1][*y+2]==0 )
  37.             {
  38.                 *x = *x + 1;
  39.                 *y = *y + 2;
  40.                 return 1;
  41.             }
  42.             break;
  43.         case 4:
  44.             if( *x-2>=0 && *y-1>=0 && chess[*x-2][*y-1]==0 )
  45.             {
  46.                 *x = *x - 2;
  47.                 *y = *y - 1;
  48.                 return 1;
  49.             }
  50.             break;
  51.         case 5:
  52.             if( *x-2>=0 && *y+1<=Y-1 && chess[*x-2][*y+1]==0 )
  53.             {
  54.                 *x = *x - 2;
  55.                 *y = *y + 1;
  56.                 return 1;
  57.             }
  58.             break;
  59.         case 6:
  60.             if( *x-1>=0 && *y-2>=0 && chess[*x-1][*y-2]==0 )
  61.             {
  62.                 *x = *x - 1;
  63.                 *y = *y - 2;
  64.                 return 1;
  65.             }
  66.             break;
  67.         case 7:
  68.             if( *x-1>=0 && *y+2<=Y-1 && chess[*x-1][*y+2]==0 )
  69.             {
  70.                 *x = *x - 1;
  71.                 *y = *y + 2;
  72.                 return 1;
  73.             }
  74.             break;
  75.         default:
  76.             break;
  77.     }
  78.     return 0;
  79. }
  80. void print()
  81. {
  82.     int i, j;
  83.     for( i=0; i < X; i++ )
  84.     {
  85.         for( j=0; j < Y; j++ )
  86.         {
  87.             printf("%2d\t", chess[i][j]);
  88.         }
  89.         printf("\n");
  90.     }
  91.     printf("\n");
  92. }
  93. // 深度优先遍历棋盘
  94. // (x,y)为位置坐标
  95. // tag是标记变量,每走一步,tag+1
  96. int TravelChessBoard(int x, int y, int tag)
  97. {
  98.     int x1=x, y1=y, flag=0, count=0;
  99.     
  100.     chess[x][y] = tag;
  101.     // 如果tag==X*Y,则完成整个棋盘的遍历
  102.     if( tag == X*Y )
  103.     {
  104.         print();
  105.         return 1;
  106.     }
  107.     flag = nextxy(&x1, &y1, count);
  108.     while0==flag && count < 7 )
  109.     {
  110.         count++;
  111.         flag = nextxy(&x1, &y1, count);
  112.     }
  113.     while( flag )
  114.     {
  115.         ifTravelChessBoard(x1, y1, tag+1) )
  116.         {
  117.             return 1;
  118.         }
  119.         x1 = x;
  120.         y1 = y;
  121.         count++;
  122.         flag = nextxy(&x1, &y1, count);
  123.         while0==flag && count < 7 )
  124.         {
  125.             count++;
  126.             flag = nextxy(&x1, &y1, count);
  127.         }
  128.     }
  129.     if0 == flag )
  130.     {
  131.         chess[x][y] = 0;
  132.     }
  133.     return 0;
  134. }
  135. int main()
  136. {
  137.     int i, j;
  138.     clock_t start, finish;
  139.     start = clock();
  140.     for( i=0; i < X; i++ )
  141.     {
  142.         for( j=0; j < Y; j++ )
  143.         {
  144.             chess[i][j] = 0;
  145.         }
  146.     }
  147.     if( !TravelChessBoard(201) )
  148.     {
  149.         printf("抱歉,马踏棋盘失败\n");
  150.     }
  151.     finish = clock();
  152.     printf("\n本次计算一共耗时: %f秒\n\n", (double)(finish-start)/CLOCKS_PER_SEC);
  153.     return 0;
  154. }

 

文章来源: allen5g.blog.csdn.net,作者:CodeAllen的博客,版权归原作者所有,如需转载,请联系作者。

原文链接:allen5g.blog.csdn.net/article/details/116573252

【版权声明】本文为华为云社区用户转载文章,如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。