迷宫算法,step by step

看到迷宫算法的题目,自己先写了个代码,感觉肯定是有错误的。先看一下我的代码。接下来分析一下错误。其实也不算是错误,就是不完备吧。
<span style="font-family: Arial, Helvetica, sans-serif;">
</span>
<span style="font-family: Arial, Helvetica, sans-serif;">
</span>
<span style="font-family: Arial, Helvetica, sans-serif;">
</span>
<span style="font-family: Arial, Helvetica, sans-serif;">#include <iostream></span>
#include <stdio.h>
#include <conio.h>
int maze[9][9]={
               {2,2,2,0,2,2,2,0,0},
               {2,0,0,0,0,0,2,0,0},
               {2,0,2,2,2,2,2,2,2},
               {0,0,0,0,0,0,0,0,0},
               {2,0,2,2,2,2,0,2,2},
               {2,0,2,2,0,0,0,2,2},
               {2,0,2,2,0,2,2,0,2},
               {2,2,2,0,0,0,0,0,0},
               {2,0,2,2,2,2,2,2,2}
   };

void show(){
    for(int i=0; i< 9; i++){
        for(int j = 0; j< 9 ; j++){
            printf("%d, "  ,maze[i][j]);
        }
        printf("\n\r");
    }
}

bool find_next_way(int x, int y ){
    bool flag1 = true;
    bool flag2 = true;
    bool flag;
    show();
    printf("%d, %d\n\r", x, y);
    if(x==0 || x == 9 || y == 0 || y== 9){
        printf("over\n");
        return true;
    }
    if(maze[x][y] == 2){
        printf("wall\n\r");
        return false;
    }else if( maze[x][y] == 0){
        maze[x][y] = 1;
        flag1 = find_next_way(x+1, y);
        flag2 = find_next_way(x, y+1);
        maze[x][y] = 0;
    }else if (maze[x][y] == 1){
        return true;
    }else{

    }
    flag = (flag1 || flag2);
    if(flag == true){
        maze[x][y] = 5;
    }
    return flag;
}

int main( void )
{
    find_next_way(1,1);
    show();
}

其实,刚开始想不通如何将结果保存显示出来,后来想通了直接通过边界出判断时候,将所有标志位1的地方记录下来,就是一条通路了。不过仍然有个bug,就是用户不进去,从入口出就出去了。

#include <iostream>

#include <stdio.h>
#include <conio.h>
int maze[9][9]={
               {2,2,2,0,2,2,2,0,0},
               {2,0,0,0,0,0,2,0,0},
               {2,0,2,2,2,2,2,2,2},
               {0,0,0,0,0,0,0,0,0},
               {2,0,2,2,2,2,0,2,2},
               {2,0,2,2,0,0,0,2,2},
               {2,0,2,2,0,2,2,0,2},
               {2,2,2,0,0,0,0,0,0},
               {2,0,2,2,2,2,2,2,2}
   };

void show(){
    for(int i=0; i< 9; i++){
        for(int j = 0; j< 9 ; j++){
            printf("%d, "  ,maze[i][j]);
        }
        printf("\n\r");
    }
}

bool find_next_way(int x, int y ){
    bool flag1 = true;
    bool flag2 = true;
    bool flag3 = true;
    bool flag4 = true;
    bool flag;

    //printf("%d, %d\n\r", x, y);
    if(x==-1 || x == 9 || y == -1 || y== 9){
        printf("over\n");
        show();
        return true;
    }
    if(maze[x][y] == 2){
       // printf("wall\n\r");
        return false;
    }else if( maze[x][y] == 0){
        maze[x][y] = 1;
        flag1 = find_next_way(x+1, y);
        flag2 = find_next_way(x, y+1);
        flag3 = find_next_way(x-1, y);
        flag4 = find_next_way(x, y-1);
        maze[x][y] = 0;
    }else if (maze[x][y] == 1){
        return true;
    }else{

    }
    flag = (flag1 || flag2);
    if(flag == true){
    //    maze[x][y] = 5;
    }
    return flag;
}

int main( void )
{
    find_next_way(0,3);

 //   show();
}

其实这样的话,标志变量也不需要了。

#include <iostream>

#include <stdio.h>
#include <conio.h>
int maze[9][9]={
               {2,2,2,0,2,2,2,0,0},
               {2,0,0,0,0,0,2,0,0},
               {2,0,2,2,2,2,2,2,2},
               {0,0,0,0,0,0,0,0,0},
               {2,0,2,2,2,2,0,2,2},
               {2,0,2,2,0,0,0,2,2},
               {2,0,2,2,0,2,2,0,2},
               {2,2,2,0,0,0,0,0,0},
               {2,0,2,2,2,2,2,2,2}
   };

void show(){
    for(int i=0; i< 9; i++){
        for(int j = 0; j< 9 ; j++){
            printf("%d, "  ,maze[i][j]);
        }
        printf("\n\r");
    }
}

bool find_next_way(int x, int y ){


    //printf("%d, %d\n\r", x, y);
    if(x==-1 || x == 9 || y == -1 || y== 9){
        printf("over\n");
        show();
        return true;
    }
    if(maze[x][y] == 2){
       // printf("wall\n\r");
        return false;
    }else if( maze[x][y] == 0){
        maze[x][y] = 1;
         find_next_way(x+1, y);
         find_next_way(x, y+1);
         find_next_way(x-1, y);
         find_next_way(x, y-1);
        maze[x][y] = 0;
    }else if (maze[x][y] == 1){
        return true;
    }else{

    }

    return true;
}

int main( void )
{
    find_next_way(0,3);

 //   show();
}


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
迷宫探路机器人最短路径算法可以使用广度优先搜索(BFS)算法来实现。具体实现过程如下: 1. 将起点加入队列,并将其标记为已访问。 2. 不断从队列中取出元素,向其周围未访问的位置进行探索。 3. 如果探索到终点,则返回当前路径的长度。 4. 否则,将周围未访问的位置加入队列,并标记为已访问。 5. 重复2-4步骤,直到队列为空。 在实现中,可以使用一个二维数组来表示迷宫地图,0表示空地,1表示障碍物。同时,可以使用一个二维数组来记录每个位置是否已经被访问过。在搜索过程中,需要记录每个位置的前驱节点,以便在搜索完成后能够还原最短路径。 以下是Python实现代码示例: ``` from collections import deque def bfs(maze, start, end): # 记录每个位置是否已经被访问过 visited = [[False] * len(maze[0]) for _ in range(len(maze))] visited[start[0]][start[1]] = True # 记录每个位置的前驱节点 pre = [[None] * len(maze[0]) for _ in range(len(maze))] pre[start[0]][start[1]] = start queue = deque([(start[0], start[1], 0)]) while queue: x, y, step = queue.popleft() for dx, dy in [(0, 1), (0, -1), (1, 0), (-1, 0)]: nx, ny = x + dx, y + dy if 0 <= nx < len(maze) and 0 <= ny < len(maze[0]) and not visited[nx][ny] and maze[nx][ny] == 0: visited[nx][ny] = True pre[nx][ny] = (x, y) if (nx, ny) == end: path = [(nx, ny)] while path[-1] != start: path.append(pre[path[-1][0]][path[-1][1]]) return step + 1, path[::-1] queue.append((nx, ny, step + 1)) return -1, [] ``` 其中,maze为迷宫地图,start为起点坐标,end为终点坐标。函数返回最短路径的长度和路径上的所有坐标。如果无法到达终点,则返回-1和空列表。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值