递归:以俄罗斯跳棋为例

先介绍一下俄罗斯跳棋,其界面如下:

走法:盘面开局32个棋子,中间为空;走子时隔一子对称跳,被隔棋子被吃掉。谁能走成最后剩下一子的局面,即为赢。

我是从一个朋友得知俄罗斯跳棋的。总是赢不了,最后只能靠计算机帮忙了。可以自我安慰的是,周围的人还没有一个只靠自己就能赢的。不算丢脸,呵呵。

很明显这个问题类似八皇后问题,用递归解比较简洁。解答程序主要部分为Russia()函数,Next()是用作寻找下一步的函数。解答程序如下:

//俄罗斯跳棋

#include <stdio.h>
#include <stdlib.h>
int ChessBoard[7][7]={-10,-10,1,1,1,-10,-10,
                                  -10,-10,1,1,1,-10,-10,
                                  1,1,1,1,1,1,1,
                                  1,1,1,0,1,1,1,
                                  1,1,1,1,1,1,1,
                                  -10,-10,1,1,1,-10,-10,
                                  -10,-10,1,1,1,-10,-10}; //为1处即棋盘

int step[4][31];//记录每一步:x y delta(x) delta(y)

int delta[2]; // 临时数组 记录delta(x) delta(y) 共有四个方向
       
int Next(int x,int y); //下一步

int Russia(int x,int y,int Count)// 主循环

{

       int i,j;

       int Result=0;

 

          if(Count==31)

              return 1;

       else if(Next(x,y)==1)

       {  

                  step[0][Count]=x;

            step[1][Count]=y;

                     step[2][Count]=delta[0];

                     step[3][Count]=delta[1];

                     ChessBoard[x][y]=0;

                     ChessBoard[x+delta[0]/2][y+delta[1]/2]=0;

                     ChessBoard[x+delta[0]][y+delta[1]]=1;

 

                     for(i=0;i<7;i++)

                     for(j=0;j<7;j++)

                     {

               if(ChessBoard[i][j]==1) Result+=Russia(i,j,Count+1);                 

                     if(Result>0) break;                 

                     }                           

                    

if(Result>0)

{

                     printf("  %d  ",Count);

                     return 1;

}

                     else

                     {                              

               if((x!=step[0][Count])&&y!=step[1][Count]) exit(1);                 

               ChessBoard[x][y]=1;

               ChessBoard[x+step[2][Count]/2][y+step[3][Count]/2]=1;

               ChessBoard[x+step[2][Count]][y+step[3][Count]]=0;

               step[0][Count]=0;

               step[1][Count]=0;

               step[2][Count]=0;

               step[3][Count]=0;

                  return 0;

                     }

       }

       else

       return 0;

}

int Next(int x,int y)//下一步
{
 if(((x+2)<7)&&ChessBoard[x+2][y]==0&&ChessBoard[x+1][y]==1){
  delta[0]=2;
  delta[1]=0;
  return 1;
 }
 if(((y-2)>0)&&ChessBoard[x][y-2]==0&&ChessBoard[x][y-1]==1){
  delta[0]=0;
  delta[1]=-2;
  return 1;
 }
 
 if(((x-2)>0)&&ChessBoard[x-2][y]==0&&ChessBoard[x-1][y]==1){
  delta[0]=-2;
  delta[1]=0;
  return 1;
 }
 if(((y+2)<7)&&ChessBoard[x][y+2]==0&&ChessBoard[x][y+1]==1){
  delta[0]=0;
  delta[1]=2;
  return 1;
 }
    return 0;
}

void main()
{  
 int i,j;

    for(j=0;j<31;j++)
       for(i=0;i<4;i++)
        step[i][j]=0;
  
 Russia(3,5,0);
 
 for(j=0;j<31;j++){
  for(i=0;i<4;i++){
   
  printf("  %d,  ",step[i][j]);
   
  }
  printf(" /n");
 }
}

需要程序及源代码,可以在如下网址下载:

http://turbulence.myshow.cn之“网络硬盘”-“/我的作品/历史上最难的小游戏/”

希望能对大家理解递归有所帮助。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
递归算法是一种自己调用自己的算法,求解n的阶乘的递归算法如下: ```python def factorial_recursive(n): if n == 0: return 1 else: return n * factorial_recursive(n-1) ``` 使用递归算法求解n的阶乘的优点是代码简洁易懂。在处理问题时,能够直接体现问题的本质,更符合人类的思维方式。但递归算法也存在一些缺点。首先,递归会导致方法的调用次数增加,从而增加了方法的内存消耗。对于大规模的计算,可能会导致栈溢出。其次,递归算法的时间复杂度较高,因为递归算法需要反复调用自身,导致了重复计算,效率较低。当n较大时,递归算法的效果明显不如非递归算法。 非递归算法是通过循环迭代来求解n的阶乘的,代码如下: ```python def factorial_non_recursive(n): result = 1 for i in range(1, n+1): result *= i return result ``` 非递归算法的优点是效率高,不会产生额外的方法调用,在计算大规模n的阶乘时,性能更好。但非递归算法的缺点是代码相对繁琐,可读性较差,不容易理解。 综上所述,递归算法和非递归算法各有优劣。递归算法可读性好,但可能会产生栈溢出和重复计算;非递归算法效率高,但代码相对繁琐。在实际应用中,应根据具体情况选择合适的算法递归算法适用于问题本质明确且规模较小的情况,而非递归算法更适用于问题规模较大的情况。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值