Fatal编程技术网
  • c/
  • C 有人能帮我用递归解决这个问题吗？

C 有人能帮我用递归解决这个问题吗？

c function recursion

C 有人能帮我用递归解决这个问题吗？,c,function,recursion,chess,C,Function,Recursion,Chess,问题是：有两匹马，白色和黑色，它们的动作就像普通象棋中的马一样。我们的目标是找出黑白马是否能相遇（位置相同）。每匹马的活动都有限制 -用户首先必须输入测试用例的数量 -第二个用户输入是黑马ex:A1的起始坐标和白马ex:H8的起始坐标 -最终用户输入是每匹马移动的限制。例如，如果用户输入3，则每匹白马和黑马有3次移动机会 -如果黑色和白色可以满足，则输出为“是”或“否”>>>>是，如果不能满足，则输出为否 我被要求用递归来解决这个问题，但我被卡住了 下面是一些例子： 输入： 2（案件数量） A1

问题是：有两匹马，白色和黑色，它们的动作就像普通象棋中的马一样。我们的目标是找出黑白马是否能相遇（位置相同）。每匹马的活动都有限制

-用户首先必须输入测试用例的数量

-第二个用户输入是黑马ex:A1的起始坐标和白马ex:H8的起始坐标

-最终用户输入是每匹马移动的限制。例如，如果用户输入3，则每匹白马和黑马有3次移动机会

-如果黑色和白色可以满足，则输出为“是”或“否”>>>>是，如果不能满足，则输出为否

我被要求用递归来解决这个问题，但我被卡住了

下面是一些例子：

输入：

2（案件数量）

A1 H8（坐标）

3（限制移动）

A1 H8（第二种情况的坐标）

1（限制第二种情况的移动）

输出：

案例1：是

案例2：否

有人能发现问题或逻辑缺陷吗

#include <stdio.h>

int counter=0;
int count[10][10] = {{}};
void moveblack(int black_x,int black_y,int limitblack,int map[10][10],int limit){
//  printf("\n%d,%d\n",black_x,black_y);
//  printf("\n%d\n",limitblack);
//  limitblack++;

    if(limitblack > limit){
        limitblack =0;
        return;
    }
    count[black_y][black_x]++;
    map[black_y][black_x] = 1;
    if(black_x > 8 || black_y > 8 || black_x < 1 || black_y < 1){
        return;
    }
    else{
        //BLACK MOVE
        if(map[black_y+2][black_x+1] == 0){
            moveblack(black_x+1,black_y+2,limitblack+1,map,limit);  
        }
        if(map[black_y+2][black_x-1] == 0){
            moveblack(black_x-1,black_y+2,limitblack+1,map,limit);  
        }
        if(map[black_y-2][black_x+1] == 0){
            moveblack(black_x+1,black_y-2,limitblack+1,map,limit);  
        }   
        if(map[black_y-2][black_x-1] == 0){
            moveblack(black_x-1,black_y-2,limitblack+1,map,limit);  
        }
        if(map[black_y+1][black_x+2] == 0){
            moveblack(black_x+2,black_y+1,limitblack+1,map,limit);  
        }
        if(map[black_y+1][black_x-2] == 0) {
            moveblack(black_x-2,black_y+1,limitblack+1,map,limit);  
        }
        if(map[black_y-1][black_x+2] == 0){
            moveblack(black_x+2,black_y-1,limitblack+1,map,limit);  
        }   
        if(map[black_y-1][black_x-2] == 0){
            moveblack(black_x-2,black_y-1,limitblack+1,map,limit);  
        }
    }   
}
void movewhite(int white_x, int white_y,int limitwhite,int map[10][10],int limit){
//  limitwhite++;
    count[white_y][white_x]++;
    map[white_y][white_x] = 1;
    if(white_x > 8 || white_y > 8 || white_x < 1 || white_y < 1 ){
        return;
    }
    if(limitwhite > limit){
        limitwhite =0;
        return;
    }
    else{
        //WHITE MOVE
        if(map[white_y+2][white_x+1]==0){
            movewhite(white_x+1,white_y+2,limitwhite+1,map,limit);
        }
        if(map[white_y+2][white_x-1]==0){
            movewhite(white_x-1,white_y+2,limitwhite+1,map,limit);
        }   
        if(map[white_y-2][white_x+1]==0){
            movewhite(white_x+1,white_y-2,limitwhite+1,map,limit);
        }   
        if(map[white_y-2][white_x-1]==0){
            movewhite(white_x-1,white_y-2,limitwhite+1,map,limit);
        }   
        if(map[white_y+1][white_x+2]==0){
            movewhite(white_x+2,white_y+1,limitwhite+1,map,limit);
        }   
        if(map[white_y+1][white_x-2]==0){
            movewhite(white_x-2,white_y+1,limitwhite+1,map,limit);
        }   
        if(map[white_y-1][white_x+2]==0){
            movewhite(white_x+2,white_y-1,limitwhite+1,map,limit);
        }   
        if(map[white_y-1][white_x-2]==0){
            movewhite(white_x-2,white_y-1,limitwhite+1,map,limit);
        }               
    }   
}
int main()
{
    int tc;
    scanf("%d",&tc); // amount of test case
    for(int t=1;t<=tc;t++){
        int limit,map[10][10]={{}};
        scanf("%d",&limit); // amount of limit each horse have
        int limitblack = 0, limitwhite = 0;
        char black[3],white[3];
        int black1,white1;
        int black_x,black_y,white_x,white_y;
        getchar();
        scanf("%s %s",&black,&white); //coordinates ex A1 H8 or G6 B5 
        black_x = black[0] - ('A'-1); // scale 1-8
    //  printf("\n%d\n",black_x);
        black_y = (black[1]-'0');
    //  printf("\n%d\n",black_y);
        white_x = white[0] - ('A'-1); // scale 1-8
        white_y = (white[1]-'0');
//      printf("%d,%d\n",black_x,black_y);
//      printf("%d,%d\n",white_x,white_y);
         //Set Chess board as 0, prevent revisiting in recursion
        for(int i=8;i>=1;i--){
            for(int j=1;j<=8;j++){
                map[i][j] = 0;
            }
        }
        //CHECK
//      for(int i=8;i>=1;i--){
//          for(int j=1;j<=8;j++){
//              if(i==black_x && j==black_y){
//                  printf("B");
//              }
//              else if(i==white_x && j==white_y){
//                  printf("W");
//              } else {
//                  printf("%d",map[i][j]);
//              }
//              
//          }
//          printf("\n");
//      }       
        moveblack(black_x,black_y,limitblack,map,limit);
        movewhite(white_x,white_y,limitwhite,map,limit);

        for(int i=1;i<=8;i++){
            for(int j=1;j<=8;j++){
                if(count[i][j]>=2){
                    counter++;
                }
            }
        }

        if(counter > 0){
            printf("Case #%d: YES\n",t);
        } 
        else if (counter == 0) {
            printf("Case #%d: NO\n",t);
        }
        counter=0;  
    }
    return 0;
}


#包括
int计数器=0；
整数计数[10][10]={{}；
void moveblack（int black_x，int black_y，int limitblack，int map[10][10]，int limit）{
//printf（“\n%d，%d\n”，黑色x，黑色y）；
//printf（“\n%d\n”，黑色）；
//黑色++；
如果（限制黑色>限制）{
limitblack=0；
回来
}
计数[black_y][black_x]++；
map[black_y][black_x]=1；
如果（黑色x>8 | |黑色y>8 | |黑色x<1 | |黑色y<1）{
回来
}
否则{
//黑棋
if（map[black_y+2][black_x+1]==0）{
移动黑色（黑色x+1，黑色y+2，限制黑色+1，地图，限制）；
}
if（map[black_y+2][black_x-1]==0）{
移动黑色（黑色x-1、黑色y+2、限制黑色+1、地图、限制）；
}
if（map[black_y-2][black_x+1]==0）{
移动黑色（黑色x+1，黑色y-2，限制黑色+1，地图，限制）；
}   
if（map[black_y-2][black_x-1]==0）{
移动黑色（黑色x-1、黑色y-2、限制黑色+1、地图、限制）；
}
if（map[black_y+1][black_x+2]==0）{
移动黑色（黑色x+2，黑色y+1，限制黑色+1，地图，限制）；
}
if（map[black_y+1][black_x-2]==0）{
移动黑色（黑色x-2、黑色y+1、限制黑色+1、地图、限制）；
}
if（map[black_y-1][black_x+2]==0）{
移动黑色（黑色x+2，黑色y-1，限制黑色+1，地图，限制）；
}   
if（map[black_y-1][black_x-2]==0）{
移动黑色（黑色x-2、黑色y-1、限制黑色+1、地图、限制）；
}
}   
}
void movewhite（int-white_x，int-white_y，int-limitwhite，int-map[10][10]，int-limit）{
//limitwhite++；
计数[white_y][white_x]++；
map[white_y][white_x]=1；
如果（白色x>8 |白色y>8 |白色x<1 |白色y<1）{
回来
}
如果（限制白色>限制）{
limitwhite=0；
回来
}
否则{
//白棋
if（map[white_y+2][white_x+1]==0）{
移动白色（白色x+1、白色y+2、限制白色+1、地图、限制）；
}
if（map[white_y+2][white_x-1]==0）{
移动白色（白色x-1、白色y+2、限制白色+1、地图、限制）；
}   
if（map[white_y-2][white_x+1]==0）{
移动白色（白色x+1、白色y-2、限制白色+1、地图、限制）；
}   
if（map[white_y-2][white_x-1]==0）{
移动白色（白色x-1、白色y-2、限制白色+1、地图、限制）；
}   
if（map[white_y+1][white_x+2]==0）{
移动白色（白色x+2、白色y+1、限制白色+1、地图、限制）；
}   
if（map[white_y+1][white_x-2]==0）{
移动白色（白色x-2、白色y+1、限制白色+1、地图、限制）；
}   
if（map[white_y-1][white_x+2]==0）{
移动白色（白色x+2，白色y-1，限制白色+1，地图，限制）；
}   
if（map[white_y-1][white_x-2]==0）{
移动白色（白色x-2、白色y-1、限制白色+1、地图、限制）；
}               
}   
}
int main（）
{
int tc；
scanf（“%d”，&tc）；//测试用例的数量
对于（int t=1；t=1；i--）{
对于（int j=1；j=1；i--）{

//对于（int j=1；j在进行下一个递归调用时，您不会更新
limit\u black
limit\u white


moveblack(black_x+1,black_y+2,limitblack,map,limit);
//....



应为：limitblack+1


moveblack(black_x+1,black_y+2,limitblack+1,map,limit);
// update other calls accordingly.


在基本情况下，您将
limitblack/limitWhite
与
limit
进行比较，这将防止无限递归


if(limitwhite > limit){
        limitwhite =0;
        return;
}


您也可以在递归开始时移动它


if(limitwhite > limit){
        limitwhite =0;
        return;
}


有人能发现问题或逻辑缺陷吗


#include <stdio.h>

int counter=0;
int count[10][10] = {{}};
void moveblack(int black_x,int black_y,int limitblack,int map[10][10],int limit){
//  printf("\n%d,%d\n",black_x,black_y);
//  printf("\n%d\n",limitblack);
//  limitblack++;

    if(limitblack > limit){
        limitblack =0;
        return;
    }
    count[black_y][black_x]++;
    map[black_y][black_x] = 1;
    if(black_x > 8 || black_y > 8 || black_x < 1 || black_y < 1){
        return;
    }
    else{
        //BLACK MOVE
        if(map[black_y+2][black_x+1] == 0){
            moveblack(black_x+1,black_y+2,limitblack+1,map,limit);  
        }
        if(map[black_y+2][black_x-1] == 0){
            moveblack(black_x-1,black_y+2,limitblack+1,map,limit);  
        }
        if(map[black_y-2][black_x+1] == 0){
            moveblack(black_x+1,black_y-2,limitblack+1,map,limit);  
        }   
        if(map[black_y-2][black_x-1] == 0){
            moveblack(black_x-1,black_y-2,limitblack+1,map,limit);  
        }
        if(map[black_y+1][black_x+2] == 0){
            moveblack(black_x+2,black_y+1,limitblack+1,map,limit);  
        }
        if(map[black_y+1][black_x-2] == 0) {
            moveblack(black_x-2,black_y+1,limitblack+1,map,limit);  
        }
        if(map[black_y-1][black_x+2] == 0){
            moveblack(black_x+2,black_y-1,limitblack+1,map,limit);  
        }   
        if(map[black_y-1][black_x-2] == 0){
            moveblack(black_x-2,black_y-1,limitblack+1,map,limit);  
        }
    }   
}
void movewhite(int white_x, int white_y,int limitwhite,int map[10][10],int limit){
//  limitwhite++;
    count[white_y][white_x]++;
    map[white_y][white_x] = 1;
    if(white_x > 8 || white_y > 8 || white_x < 1 || white_y < 1 ){
        return;
    }
    if(limitwhite > limit){
        limitwhite =0;
        return;
    }
    else{
        //WHITE MOVE
        if(map[white_y+2][white_x+1]==0){
            movewhite(white_x+1,white_y+2,limitwhite+1,map,limit);
        }
        if(map[white_y+2][white_x-1]==0){
            movewhite(white_x-1,white_y+2,limitwhite+1,map,limit);
        }   
        if(map[white_y-2][white_x+1]==0){
            movewhite(white_x+1,white_y-2,limitwhite+1,map,limit);
        }   
        if(map[white_y-2][white_x-1]==0){
            movewhite(white_x-1,white_y-2,limitwhite+1,map,limit);
        }   
        if(map[white_y+1][white_x+2]==0){
            movewhite(white_x+2,white_y+1,limitwhite+1,map,limit);
        }   
        if(map[white_y+1][white_x-2]==0){
            movewhite(white_x-2,white_y+1,limitwhite+1,map,limit);
        }   
        if(map[white_y-1][white_x+2]==0){
            movewhite(white_x+2,white_y-1,limitwhite+1,map,limit);
        }   
        if(map[white_y-1][white_x-2]==0){
            movewhite(white_x-2,white_y-1,limitwhite+1,map,limit);
        }               
    }   
}
int main()
{
    int tc;
    scanf("%d",&tc); // amount of test case
    for(int t=1;t<=tc;t++){
        int limit,map[10][10]={{}};
        scanf("%d",&limit); // amount of limit each horse have
        int limitblack = 0, limitwhite = 0;
        char black[3],white[3];
        int black1,white1;
        int black_x,black_y,white_x,white_y;
        getchar();
        scanf("%s %s",&black,&white); //coordinates ex A1 H8 or G6 B5 
        black_x = black[0] - ('A'-1); // scale 1-8
    //  printf("\n%d\n",black_x);
        black_y = (black[1]-'0');
    //  printf("\n%d\n",black_y);
        white_x = white[0] - ('A'-1); // scale 1-8
        white_y = (white[1]-'0');
//      printf("%d,%d\n",black_x,black_y);
//      printf("%d,%d\n",white_x,white_y);
         //Set Chess board as 0, prevent revisiting in recursion
        for(int i=8;i>=1;i--){
            for(int j=1;j<=8;j++){
                map[i][j] = 0;
            }
        }
        //CHECK
//      for(int i=8;i>=1;i--){
//          for(int j=1;j<=8;j++){
//              if(i==black_x && j==black_y){
//                  printf("B");
//              }
//              else if(i==white_x && j==white_y){
//                  printf("W");
//              } else {
//                  printf("%d",map[i][j]);
//              }
//              
//          }
//          printf("\n");
//      }       
        moveblack(black_x,black_y,limitblack,map,limit);
        movewhite(white_x,white_y,limitwhite,map,limit);

        for(int i=1;i<=8;i++){
            for(int j=1;j<=8;j++){
                if(count[i][j]>=2){
                    counter++;
                }
            }
        }

        if(counter > 0){
            printf("Case #%d: YES\n",t);
        } 
        else if (counter == 0) {
            printf("Case #%d: NO\n",t);
        }
        counter=0;  
    }
    return 0;
}



是的，您的实现中存在几个逻辑缺陷。
首先：您正在使用
count
数组检查两匹马是否访问了同一索引。如果同一匹黑马访问该索引两次/多次会怎么样。

第二：您的递归在下一步中没有携带完全访问的阶段。您应该传递referent而不是passby value

应该是：


void moveblack(int black_x,int black_y,int limitblack,(--> pointer of that map array)int map[10][10],int limit)


此外，索引检查不正确：
如果
white\u y=1
和
white\u x=1


 map[white_y-1][white_x-2]==0


这将产生分段错误


还有其他缺陷。但现在我想这已经足够了。
你能编辑这个问题，给出一些示例输入，你得到了什么，以及你期望得到什么吗？请不要把它放在评论中。现在清楚了吗？我仍然想要一些示例输入。当你运行程序时，你输入了什么？什么输入得到了3342542？这里，给出了示例输入和输出请查看您的解决方案停止无限循环，有些测试用例是正确的，但有些仍然是错误的。我认为递归中存在问题？？您是否发现了任何逻辑缺陷？？每次您执行第一个测试用例时都会出现问题，但第二个测试用例不会有问题。您能帮我找到这方面的逻辑缺陷吗？@ArdianD安