凯H 2023-06-04 21:18 采纳率: 77.8%
浏览 168
已结题

用C语言随机生成一个迷宫

#include<stdio.h>
#include <stdlib.h>
#include <time.h>

//定义迷宫大小
#define ROW 10
#define COL 10

//定义节点状态
#define WALL 0
#define PATH 1

//初始化迷宫
int maze[ROW][COL] = { {0} };

//生成迷宫
int createMaze(int row, int col)
{
    //设置起点和终点
    maze[0][0] = PATH;
    maze[row - 1][col - 1] = PATH;

    //设置当前位置和方向
    int x = 0, y = 0, dir = 0;

    //定义四个方向上的偏移量
    int dx[4] = { 0, 1, 0, -1 };
    int dy[4] = { -1, 0, 1, 0 };

    //随机生成路径
    while (1)
    {
        //寻找当前节点的邻居节点
        int neighbor[4] = { 0 };
        int count = 0;
        int i;
        for (i = 0; i < 4; i++)
        {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (nx >= 0 && nx < row && ny >= 0 && ny < col && maze[nx][ny] == WALL)
            {
                neighbor[count++] = i;
            }
        }
        //如果当前节点没有可访问的邻居节点,则回溯
        if (count == 0)
        {
            int flag = 0;
            for (i = 0; i < 4; i++)
            {
                int nx = x + dx[i];
                int ny = y + dy[i];
                if (nx >= 0 && nx < row && ny >= 0 && ny < col && maze[nx][ny] == PATH)
                {
                    neighbor[count++] = i;
                    flag = 1;
                }
            }
            if (flag == 0) break;
        }

        //随机选择一个邻居节点
        int index = neighbor[rand() % count];
        x += dx[index];
        y += dy[index];
        maze[x][y] = PATH;
    }
    return 0;
}

//打印迷宫
int printMaze(int row, int col)
{
    int i, j;
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            if (maze[i][j] == WALL)
                printf("■");
            if (maze[i][j] == PATH)
                printf("  ");
        }
        printf("\n");
    }
    return 0;
}
int main()
{
    srand(time(NULL)); //初始化随机数生成器
    createMaze(ROW, COL);
    printMaze(ROW, COL);
    return 0;
}

运行后只出现黑窗,无内容

  • 写回答

10条回答 默认 最新

  • CF2301_77400554X 2023-06-04 21:46
    关注

    引用chatgpt部分指引作答:
    运行结果:

    img


    我注意到在生成迷宫的代码中,当回溯到起点时,程序会陷入无限循环。这是因为在回溯时,没有将当前节点标记为已访问。为了解决这个问题,你可以在回溯时将当前节点标记为已访问(即将maze[x][y]的值设为PATH),以避免重复回溯到同一个节点。下面是修改后的代码:

    #include<stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
    //定义迷宫大小
    #define ROW 10
    #define COL 10
    
    //定义节点状态
    #define WALL 0
    #define PATH 1
    #define VISITED 2
    
    //初始化迷宫
    int maze[ROW][COL] = { {0} };
    
    //生成迷宫
    int createMaze(int row, int col)
    {
        //设置起点和终点
        maze[0][0] = PATH;
        maze[row - 1][col - 1] = PATH;
    
        //设置当前位置和方向
        int x = 0, y = 0, dir = 0;
    
        //定义四个方向上的偏移量
        int dx[4] = { 0, 1, 0, -1 };
        int dy[4] = { -1, 0, 1, 0 };
    
        //随机生成路径
        while (1)
        {
            //将当前节点标记为已访问
            maze[x][y] = VISITED;
    
            //寻找当前节点的邻居节点
            int neighbor[4] = { 0 };
            int count = 0;
            int i;
            for (i = 0; i < 4; i++)
            {
                int nx = x + dx[i];
                int ny = y + dy[i];
                if (nx >= 0 && nx < row && ny >= 0 && ny < col && maze[nx][ny] == WALL)
                {
                    neighbor[count++] = i;
                }
            }
            //如果当前节点没有可访问的邻居节点,则回溯
            if (count == 0)
            {
                int flag = 0;
                for (i = 0; i < 4; i++)
                {
                    int nx = x + dx[i];
                    int ny = y + dy[i];
                    if (nx >= 0 && nx < row && ny >= 0 && ny < col && maze[nx][ny] == PATH)
                    {
                        neighbor[count++] = i;
                        flag = 1;
                    }
                }
                if (flag == 0) break;
            }
    
            //随机选择一个邻居节点
            int index = neighbor[rand() % count];
            x += dx[index];
            y += dy[index];
            maze[x][y] = PATH;
        }
        return 0;
    }
    
    //打印迷宫
    int printMaze(int row, int col)
    {
        int i, j;
        for (i = 0; i < row; i++)
        {
            for (j = 0; j < col; j++)
            {
                if (maze[i][j] == WALL)
                    printf("■");
                if (maze[i][j] == PATH)
                    printf("  ");
            }
            printf("\n");
        }
        return 0;
    }
    
    int main()
    {
        srand(time(NULL)); //初始化随机数生成器
        createMaze(ROW, COL);
        printMaze(ROW, COL);
        return 0;
    }
    

    现在,代码应该可以成功生成并打印迷宫了。

    本回答被题主选为最佳回答 , 对您是否有帮助呢?
    评论
  • 这一次有糖 2023-06-04 21:22
    关注

    测试看看

    #include<stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #include <string.h>
    
    //定义迷宫大小
    #define ROW 10
    #define COL 10
    
    //定义节点状态
    #define WALL 0
    #define PATH 1
    
    //初始化迷宫
    int maze[ROW][COL] = { {0} };
    
    //生成迷宫
    int createMaze(int row, int col)
    {
        //设置起点和终点
        maze[0][0] = PATH;
        maze[row - 1][col - 1] = PATH;
    
        //设置当前位置和方向
        int x = 0, y = 0;
    
        //定义四个方向上的偏移量
        int dx[4] = { 0, 1, 0, -1 };
        int dy[4] = { -1, 0, 1, 0 };
    
        //记录已访问的节点
        int visited[row][col];
        memset(visited, 0, sizeof(visited));
    
        //随机生成路径
        while (1)
        {
            //寻找当前节点的邻居节点
            int neighbor[4] = { 0 };
            int count = 0;
            int i;
            for (i = 0; i < 4; i++)
            {
                int nx = x + dx[i];
                int ny = y + dy[i];
                if (nx >= 0 && nx < row && ny >= 0 && ny < col && maze[nx][ny] == WALL && !visited[nx][ny])
                {
                    neighbor[count++] = i;
                }
            }
    
            //如果当前节点没有可访问的未访问邻居节点,则回溯
            if (count == 0)
            {
                int flag = 0;
                for (i = 0; i < 4; i++)
                {
                    int nx = x + dx[i];
                    int ny = y + dy[i];
                    if (nx >= 0 && nx < row && ny >= 0 && ny < col && maze[nx][ny] == PATH && !visited[nx][ny])
                    {
                        neighbor[count++] = i;
                        flag = 1;
                    }
                }
                if (flag == 0) break;
            }
    
            //随机选择一个邻居节点
            int index = neighbor[rand() % count];
            int nx = x + dx[index];
            int ny = y + dy[index];
            visited[nx][ny] = 1;
            x = nx;
            y = ny;
            maze[x][y] = PATH;
        }
        return 0;
    }
    
    //打印迷宫
    int printMaze(int row, int col)
    {
        int i, j;
        for (i = 0; i < row; i++)
        {
            for (j = 0; j < col; j++)
            {
                if (maze[i][j] == WALL)
                    printf("■");
                if (maze[i][j] == PATH)
                    printf("  ");
            }
            printf("\n");
        }
        return 0;
    }
    
    int main()
    {
        srand((unsigned int)time(NULL)); //初始化随机数生成器
        createMaze(ROW, COL);
        printMaze(ROW, COL);
        return 0;
    }
    
    
    
    评论 编辑记录
  • P2441M 2023-06-04 21:33
    关注

    主要是没有正确回溯

    //生成迷宫
    int createMaze(int row, int col)
    {
        //设置起点和终点
        maze[0][0] = PATH;
        maze[row - 1][col - 1] = PATH;
    
        //设置当前位置和方向
        int x = 0, y = 0;
    
        //定义四个方向上的偏移量
        int dx[4] = { 0, 1, 0, -1 };
        int dy[4] = { -1, 0, 1, 0 };
    
        //记录已访问的节点
        int visited[row][col];
        memset(visited, 0, sizeof(visited));
    
        //随机生成路径
        while (1)
        {
            //寻找当前节点的邻居节点
            int neighbor[4] = { 0 };
            int count = 0;
            int i;
            for (i = 0; i < 4; i++)
            {
                int nx = x + dx[i];
                int ny = y + dy[i];
                if (nx >= 0 && nx < row && ny >= 0 && ny < col && maze[nx][ny] == WALL && !visited[nx][ny])
                {
                    neighbor[count++] = i;
                }
            }
    
            //如果当前节点没有可访问的未访问邻居节点,则回溯
            if (count == 0)
            {
                int flag = 0;
                for (i = 0; i < 4; i++)
                {
                    int nx = x + dx[i];
                    int ny = y + dy[i];
                    if (nx >= 0 && nx < row && ny >= 0 && ny < col && maze[nx][ny] == PATH && !visited[nx][ny])
                    {
                        neighbor[count++] = i;
                        flag = 1;
                    }
                }
                if (flag == 0) break;
            }
    
            //随机选择一个邻居节点
            int index = neighbor[rand() % count];
            int nx = x + dx[index];
            int ny = y + dy[index];
            visited[nx][ny] = 1;
            x = nx;
            y = ny;
            maze[x][y] = PATH;
        }
        return 0;
    }
    
    评论
  • David1055259499 2023-06-04 21:36
    关注

    来自GPT的回答:

    这个问题可能是由于迷宫的尺寸太小而导致的。在你的代码中,迷宫的尺寸被定义为10x10(ROW=10,COL=10),而每个迷宫单元格的宽度为2个字符(一个空格表示路径,一个字符表示墙壁)。
    
    如果你的命令提示符窗口尺寸太小,无法容纳10x10的迷宫,你可能无法看到迷宫的完整输出。你可以尝试增大命令提示符窗口的尺寸,或者缩小迷宫的尺寸。
    
    另外,你可以尝试在每行打印迷宫后,使用fflush(stdout)来刷新输出缓冲区,以确保迷宫立即显示在命令提示符窗口中。修改后的代码如下所示:
    
    c
    Copy code
    //打印迷宫
    int printMaze(int row, int col)
    {
        int i, j;
        for (i = 0; i < row; i++)
        {
            for (j = 0; j < col; j++)
            {
                if (maze[i][j] == WALL)
                    printf("■");
                if (maze[i][j] == PATH)
                    printf("  ");
            }
            printf("\n");
            fflush(stdout); // 刷新输出缓冲区
        }
        return 0;
    }
    这样,每打印一行迷宫后,就会立即将其显示在命令提示符窗口中。
    
    如果你还是无法看到完整的迷宫,请尝试调整窗口的尺寸或缩小迷宫的尺寸(例如,将迷宫的尺寸改为5x5),以便适应命令提示符窗口的大小。
    
    
    评论
  • 精神小黑猫 2023-06-04 21:37
    关注

    因为现在一直处于 代码31行的这个while循环中

    评论
  • 申龙斌 2023-06-04 22:19
    关注

    这段代码在生成迷宫时存在一个错误。在回溯时,当当前节点没有可访问的邻居节点时,代码会尝试在已经是路径的节点中选择一个邻居节点,这是不正确的。

    在回溯时,应该回溯到上一个未访问的节点,而不是已经是路径的节点。修改代码中的回溯部分如下:

    //如果当前节点没有可访问的邻居节点,则回溯
    if (count == 0)
    {
        int flag = 0;
        for (i = 0; i < 4; i++)
        {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (nx >= 0 && nx < row && ny >= 0 && ny < col && maze[nx][ny] == WALL)
            {
                neighbor[count++] = i;
                flag = 1;
            }
        }
        if (flag == 0) {
            // 回溯到上一个未访问的节点
            maze[x][y] = WALL;
            x -= dx[dir];
            y -= dy[dir];
            continue;
        }
    }
    

    通过这样的修改,回溯时将正确地回到上一个未访问的节点,并且生成的迷宫将是正确的。

    评论
  • cyjbj 2023-06-05 09:07
    关注

    你需要的10*10迷宫,可以用一组10个10维的向量来做,向量内容为0或1随机数即可

    评论
  • juer_0001 2023-06-05 09:13
    关注

    参考gpt:
    这段代码实现了一个简单的随机生成迷宫并打印出来的功能。根据你的描述,代码运行后只出现一个黑窗口而没有任何内容显示。

    这个问题可能是因为代码中的迷宫打印部分存在一些问题。你可以尝试修改printMaze函数来解决这个问题。在代码中,墙用"■"字符表示,路径用两个空格表示。

    请将以下代码替换掉原来的printMaze函数部分:

    
    //打印迷宫
    int printMaze(int row, int col)
    {
        int i, j;
        for (i = 0; i < row; i++)
        {
            for (j = 0; j < col; j++)
            {
                if (maze[i][j] == WALL)
                    printf("■");
                if (maze[i][j] == PATH)
                    printf("  ");
            }
            printf("\n");
        }
        return 0;
    }
    

    如果问题仍然存在,请确保你的编译器和环境设置正确,并且能够正确地运行C语言程序。如果你使用的是IDE,可以尝试在IDE的设置中查找是否有相关的配置选项,例如确保输出窗口能够正确显示程序的输出。

    另外,请确保你已经正确包含了所需的头文件(例如stdio.h、stdlib.h和time.h),并且编译器能够找到这些头文件。如果有其他的编译器警告或错误信息,请检查并修复这些问题。

    希望这些信息对你有所帮助,如果还有其他问题,请随时提问。

    评论
  • 还有头发的程序员- 2023-06-05 10:11
    关注

    试试这个

    #include<stdio.h> 
    #include<stdlib.h>
    #include<time.h>
    #include<conio.h>
     
    struct Node
    {
        int data;
        int flag;
    };
     
    struct Path
    {
        int xpath;
        int ypath;
        int pox;    //在队列中的下标 
    };
     
    //全局变量
    int n, m;     //迷宫的行和列 
    Node* maze;   //迷宫存放 
    Path* que;
    int top = -1;
    int front = -1;
    int rear = -1;
     
    void create()
    {
        int i, j;
        printf("输入迷宫(随机生成)的行和列:");
        scanf("%d%d", &n, &m);
        maze = new Node[n * m];
        srand(time(NULL));
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < m; j++)
            {
                int temp = rand() % 4;
                if (temp != 1) maze[i * m + j].data = 1;
                else maze[i * m + j].data = 0;
                maze[i * m + j].flag = 0;
            }
        }
        maze[0].data = 8;  //设置起点 
        maze[n * m - 1].data = 1;
        printf("生成迷宫:\n");
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < m; j++)
            {
                printf("%d", maze[i * m + j].data);
            }
            printf("\n");
        }
    }
    int judge_head()
    {
        int k = 1;
        if (que[front].xpath == n - 1 && que[front].ypath == m - 1)
        {
            printf("找到迷宫的通路!\n");
            int x = que[front].xpath;
            int y = que[front].ypath;
            int t = que[front].pox;    //前一个坐标在队列的下标 
            while (x != 0 || y != 0)
            {
                maze[x * m + y].data = 8;
                x = que[t].xpath;
                y = que[t].ypath;
                t = que[t].pox;
                k++;
            }
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < m; j++)
                {
                    printf("%d", maze[i * m + j].data);
                }
                printf("\n");
            }
            printf("路径长度为:%d\n", k);
            return 1;
        }
        return 0;
    }
    void push_road(int x, int y)
    {
        if (maze[x * m + y].data == 1 && maze[x * m + y].flag == 0)
        {
            que[(++rear) % (n * m)].xpath = x;
            que[rear % (n * m)].ypath = y;
            que[rear % (n * m)].pox = front;   //设置上一个坐标在队列中的位置 
            maze[x * m + y].flag = 1;
        }
    }
    /*搜索路径*/
    void seek_road()   /*先实现一个路径先*/
    {
        //path = new Path[n*m];
        int x1, y1;
        que = new Path[n * m];                  //利用广度优先实现最短路径
        que[0].xpath = 0;
        que[0].ypath = 0;
        que[0].pox = 0;
        maze[0].flag = 1;
        rear++;
        while (front != rear)
        {
            int x = que[(++front) % (n * m)].xpath;  //获取队头的坐标,然后将其四周的通路进队,知道操作完队尾元素 
            int y = que[front % (n * m)].ypath;
            //    path[++top] = que[front];
            if (judge_head()) return;
            if (y + 1 < m)
                push_road(x, y + 1);
            if (x + 1 < n)
                push_road(x + 1, y);
            if (y - 1 >= 0)
                push_road(x, y - 1);
            if (x - 1 >= 0)
                push_road(x - 1, y);
        }
        printf("没有通路!\n");
    }
    int main()
    {
        create();
        seek_road();
        return 0;
    }
    
    
    评论
  • 2301_78031898 2023-06-05 12:53
    关注
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
    #define ROWS 10
    #define COLS 20
    
    int maze[ROWS][COLS];
    
    void init_maze() {
        int i, j;
        for (i = 0; i < ROWS; i++) {
            for (j = 0; j < COLS; j++) {
                maze[i][j] = 1;
            }
        }
    }
    
    void print_maze() {
        int i, j;
        for (i = 0; i < ROWS; i++) {
            for (j = 0; j < COLS; j++) {
                if (maze[i][j] == 0) {
                    printf(" ");
                } else {
                    printf("#");
                }
            }
            printf("\n");
        }
    }
    
    void generate_maze(int row, int col) {
        maze[row][col] = 0;
        int direction[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
        int rand_dir[4];
        int i, temp;
        for (i = 0; i < 4; i++) {
            rand_dir[i] = i;
        }
        for (i = 0; i < 4; i++) {
            int r = rand() % 4;
            temp = rand_dir[i];
            rand_dir[i] = rand_dir[r];
            rand_dir[r] = temp;
        }
        for (i = 0; i < 4; i++) {
            int next_row = row + direction[rand_dir[i]][0] * 2;
            int next_col = col + direction[rand_dir[i]][1] * 2;
            if (next_row >= 0 && next_row < ROWS && next_col >= 0 && next_col < COLS) {
                if (maze[next_row][next_col] == 1) {
                    maze[row + direction[rand_dir[i]][0]][col + direction[rand_dir[i]][1]] = 0;
                    generate_maze(next_row, next_col);
                }
            }
        }
    }
    
    int main() {
        srand(time(NULL));
        init_maze();
        generate_maze(1, 1);
        print_maze();
        return 0;
    }
    
    
    评论
查看更多回答(9条)

报告相同问题?

问题事件

  • 系统已结题 6月13日
  • 已采纳回答 6月5日
  • 创建了问题 6月4日

悬赏问题

  • ¥60 PCDN如何使用宽带的电视业务通道拨号叠加带宽?
  • ¥15 遇到这种校园宽带网络应该怎么样解决?
  • ¥30 AXI VIP验证多余打印问题
  • ¥15 利用加权最小二乘法求某品牌手机价格指标,已按照总销量计算出权重,各类型号手机价格已知,如何求得价格指标?
  • ¥15 如何自制一个硬件钱包,有兴趣的朋友一起交流
  • ¥15 (关键词-聊天软件)
  • ¥15 求大家看看这个编程的编法没有思路啊
  • ¥20 WSL打开图形化程序子窗口无法点击
  • ¥15 Jupyter Notebook 数学公式不渲染
  • ¥20 ERR_CACHE_MISS 确认重新提交表单