【经典算法】老鼠走迷宫问题

最新推荐文章于 2024-08-03 18:54:56 发布
最新推荐文章于 2024-08-03 18:54:56 发布
阅读量8.8k 收藏 65
点赞数 12
分类专栏： 算法 文章标签： 算法 老鼠走迷宫 递归 C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sky619351517/article/details/81147817
版权

老鼠走迷宫问题及其多个变种

一、说明
老鼠走迷宫问题的递归实现，是对递归思想的一种应用。
二、问题描述
给定一个二维数组，数组中2表示墙壁，0表示通路，由此数组可展示为一个迷宫图。给定入口位置和出口位置，判断之间是否存在通路并显示出走出迷宫的道路。
三、源码实现

/****************************************************************************************************** 
 *   function：老鼠走迷宫问题的递归解法，四周只有一个入口点，一个出口点 
 *   author：yahai.zhang 
 *   time: 2018.7.21
 *   File Name：老鼠走迷宫.c
 ******************************************************************************************************/ 
#include <stdio.h>
#include <stdlib.h>

#define ROW_MAX 21
#define COLUMN_MAX 36

int visit(int, int);
int startI = 0, startJ = 1;     // 入口点 
int endI = 20, endJ = 34;       // 出口点 
int success = 0;

int maze[ROW_MAX][COLUMN_MAX] = {
    {2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2},
    {2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2},
    {2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 0, 0, 2, 0, 2, 0, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 0, 0, 2, 0, 2, 0, 2},
    {2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2},
    {2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2},
    {2, 0, 0, 0, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2},
    {2, 2, 2, 2, 2, 0, 0, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 2, 2, 2, 0, 0, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2},
    {2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2},
    {2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2},
    {2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2},
    {2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2},
    {2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 0, 0, 0, 0, 2, 2},
    {2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2},
    {2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2},
    {2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 0, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 0, 2},
    {2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2},
    {2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2},
    {2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2},
    {2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2},
    {2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 0, 0, 0, 2},
    {2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2}
};

int main(void) {
    printf("==========================BEGIN===========================\n"); 
    int i, j;
    printf("显示迷宫：\n");
    for(i = 0; i < ROW_MAX; i++) {
        for(j = 0; j < COLUMN_MAX; j++)
            if(maze[i][j] == 2)
                printf("█");
            else
                printf("  ");
        printf("\n");
    }
    if(visit(startI, startJ) == 0)
        printf("\n没有找到出口！\n");
    else {
        printf("\n显示路径：入口（%d， %d）, 出口（%d， %d）\n", startI, startJ, endI, endJ);
        for(i = 0; i < ROW_MAX; i++) {
            for(j = 0; j < COLUMN_MAX; j++) {
                if(maze[i][j] == 2)
                    printf("█");
                else if(maze[i][j] == 1)
                    printf("◇");
                else
                    printf("  ");
            }
            printf("\n");
        }
    }
    printf("\n==========================END===========================\n"); 
    return 0;
}
int visit(int i, int j) {
    maze[i][j] = 1;
    if(i == endI && j == endJ)
        success = 1;
    if(success != 1 && maze[i][j+1] == 0) 
        visit(i, j+1);
    if(success != 1 && maze[i+1][j] == 0) 
        visit(i+1, j);
    if(success != 1 && maze[i][j-1] == 0) 
        visit(i, j-1);
    if(success != 1 && maze[i-1][j] == 0) 
        visit(i-1, j);
    if(success != 1)
        maze[i][j] = 0;
    return success;
}

四、运行及结果
这里写图片描述
这里写图片描述
五、程序分析
该老鼠走迷宫主要依靠visit函数的递归实现，但是该实现存在以下几点不足：

  • 迷宫只能存在一个入口和一个出口，否则程序运行出现问题
  • 且入口点必须在边界点
  • 出口点也必须在边界

六、程序改进

/****************************************************************************************************** 
 *   function：老鼠走迷宫问题的递归解法，四周只有多个入口点，多个出口点 
 *   author：yahai.zhang 
 *   time: 2018.7.21
 *   File Name：老鼠走迷宫.c
 ******************************************************************************************************/ 
#include <stdio.h>
#include <stdlib.h>

#define ROW_MAX 21
#define COLUMN_MAX 36

int visit(int, int);
int startI = 0, startJ = 1;     // 入口点 
int endI = 20, endJ = 34;       // 出口点 
int success = 0;

int maze[ROW_MAX][COLUMN_MAX] = {
    {2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2},
    {2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2},
    {2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 0, 0, 2, 0, 2, 0, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 0, 0, 2, 0, 2, 0, 2},
    {2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2},
    {2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2},
    {2, 0, 0, 0, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2},
    {2, 2, 2, 2, 2, 0, 0, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 2, 2, 2, 0, 0, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2},
    {2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2},
    {2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2},
    {2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 0},
    {2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2},
    {2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 0, 0, 0, 0, 2, 2},
    {2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 0},
    {2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2},
    {2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 0, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 0, 2},
    {2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2},
    {2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2},
    {2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2},
    {2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2},
    {2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 0, 0, 0, 2},
    {2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2}
};

int main(void) {
    printf("==========================BEGIN===========================\n"); 
    int i, j;
    printf("显示迷宫：\n");
    for(i = 0; i < ROW_MAX; i++) {
        for(j = 0; j < COLUMN_MAX; j++)
            if(maze[i][j] == 2)
                printf("█");
            else
                printf("  ");
        printf("\n");
    }
    printf("\n输入起点:");
    scanf("%d %d", &startI, &startJ);
    printf("输入终点:");
    scanf("%d %d", &endI, &endJ);
    if(visit(startI, startJ) == 0)
        printf("\n没有找到出口！\n");
    else {
        printf("\n显示路径：入口（%d， %d）, 出口（%d， %d）\n", startI, startJ, endI, endJ);
        for(i = 0; i < ROW_MAX; i++) {
            for(j = 0; j < COLUMN_MAX; j++) {
                if(maze[i][j] == 2)
                    printf("█");
                else if(maze[i][j] == 1)
                    printf("◇");
                else
                    printf("  ");
            }
            printf("\n");
        }
    }
    printf("\n==========================END===========================\n"); 
    return 0;
}
int visit(int i, int j) {
    maze[i][j] = 1;
    if(i == endI && j == endJ)
        success = 1;
    if(success != 1 && j <= endJ && maze[i][j+1] == 0) 
        visit(i, j+1);
    if(success != 1 && i <= endI && maze[i+1][j] == 0) 
        visit(i+1, j);
    if(success != 1 && j >= 0 && maze[i][j-1] == 0) 
        visit(i, j-1);
    if(success != 1 && i >= 0 && maze[i-1][j] == 0) 
        visit(i-1, j);
    if(success != 1)
        maze[i][j] = 0;
    return success;
}

七、运行及结果
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
八、分析及改进
改进后，存在以下优点：

  • 迷宫可以存在多个入口和多个出口
  • 且入口点可以随意指定，出口位置随意指定
  • 实现了任意两点的路径规划

在实际情况中，一般不知道出口的位置，所以在程序的运行过程中不该指定出口位置

九、程序改进

仅指定入口地址

/****************************************************************************************************** 
 *   function：老鼠走迷宫问题的递归解法，四周只有多个入口点，多个出口点，仅指定入口地址 
 *   author：yahai.zhang 
 *   time: 2018.7.21
 *   File Name：老鼠走迷宫.c
 ******************************************************************************************************/ 
#include <stdio.h>
#include <stdlib.h>

#define ROW_MAX 21
#define COLUMN_MAX 36

int visit(int, int);
int startI = 0, startJ = 1;     // 入口点 
int endI = 20, endJ = 34;       // 出口点 
int success = 0;

int maze[ROW_MAX][COLUMN_MAX] = {
    {2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2},
    {2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2},
    {2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 0, 0, 2, 0, 2, 0, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 0, 0, 2, 0, 2, 0, 2},
    {2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2},
    {2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2},
    {2, 0, 0, 0, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2},
    {2, 2, 2, 2, 2, 0, 0, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 2, 2, 2, 0, 0, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2},
    {2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2},
    {2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2},
    {2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 0},
    {2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2},
    {2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 0, 0, 0, 0, 2, 2},
    {2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 0},
    {2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2},
    {2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 0, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 0, 2},
    {2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2},
    {2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2},
    {2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2},
    {2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2},
    {2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 0, 0, 0, 2},
    {2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}
};

int main(void) {
    printf("==========================BEGIN===========================\n"); 
    int i, j;
    printf("显示迷宫：\n");
    for(i = 0; i < ROW_MAX; i++) {
        for(j = 0; j < COLUMN_MAX; j++)
            if(maze[i][j] == 2)
                printf("█");
            else
                printf("  ");
        printf("\n");
    }
    printf("\n输入起点:");
    scanf("%d %d", &startI, &startJ);

    if(visit(startI, startJ) == 0)
        printf("\n没有找到出口！\n");
    else {
        printf("\n显示路径：\n");
        for(i = 0; i < ROW_MAX; i++) {
            for(j = 0; j < COLUMN_MAX; j++) {
                if(maze[i][j] == 2)
                    printf("█");
                else if(maze[i][j] == 1)
                    printf("◇");
                else
                    printf("  ");
            }
            printf("\n");
        }
    }

    printf("\n==========================END===========================\n"); 
    return 0;
}
int visit(int i, int j) {
    maze[i][j] = 1;
    if ( i == ROW_MAX || j == COLUMN_MAX)
        success = 1;

    if ((i == endI && j == endJ) )
        success = 1;
    if(success != 1 && j <= endJ && maze[i][j+1] == 0) 
        visit(i, j+1);
    if(success != 1 && i <= endI && maze[i+1][j] == 0) 
        visit(i+1, j);
    if(success != 1 && j >= 0 && maze[i][j-1] == 0) 
        visit(i, j-1);
    if(success != 1 && i >= 0 && maze[i-1][j] == 0) 
        visit(i-1, j);
    if(success != 1)
        maze[i][j] = 0;

    return success;
}

十、运行结果
这里写图片描述
这里写图片描述

珞珈琉璃
关注
  • 12
    点赞
  • 踩
  • 65
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C/C++ rat maze老鼠迷宫算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-22 2445
Rat Maze算法的优点是可以找到从起点到终点的所有可能路径，并且它是一个完整的搜索算法。它可以解决任意大小的迷宫问题。算法的基本思想是使用递归回溯来探索迷宫中的所有路径，直到找到从起点到终点的路径或者所有可能的路径都被探索完。Rat Maze（老鼠迷宫）算法是一种解决迷宫问题的搜索算法。它模拟了一只老鼠在一个迷宫中寻找出口的过程。Rat Maze算法的缺点是由于使用了递归回溯，当迷宫比较大或者存在很多可能路径时，算法的执行时间会较长。
经典算法五--老鼠走迷宫
qq_46000102的博客
07-24 916
说明： 老鼠走迷宫是递回求解的基本题型，我们在二维阵列中使用2表示迷宫墙壁，使用1表示老鼠行走的路径，试以程式求出由入口至出口的路径。 代码：
老鼠走迷宫（Mouse）
橡树心的专栏
02-29 567
[b]问题说明：[/b] 老鼠走迷宫是循环求解的基本类型，我们在二维数组中用2来表示迷宫的墙壁，使用1来表示老鼠的行走路径，并用程序求出从入口到出口的距离。 [code="java"] public class Mouse { private int startI, startJ; // 入口 private int endI, endJ; //...
c语言老鼠走迷宫课程设计,C语言算法之老鼠走迷宫
weixin_29282577的博客
05-20 544
1.Algorithm Gossip: 老鼠走迷官(一)说明：老鼠走迷宫是递回求解的基本题型，我们在二维阵列中使用2表示迷宫墙壁，使用1来表示老鼠的行走路径，试以程式求出由入口至出口的路径。解法：老鼠的走法有上、左、下、右四个方向，在每前进一格之后就选一个方向前进，无法前进时退回选择下一个可前进方向，如此在阵列中依序测试四个方向，直到走到出口为止，这是递回的基本题。代码：#include#incl...
c语言递归算法老鼠走迷宫详解,递归算法求老鼠走迷宫（C语言）
weixin_34711121的博客
05-23 512
/*说明老鼠走迷宫是递回求解的基本题型，我们在二维阵列中使用2表示迷宫墙壁，使用1来表示老鼠的行走路径，试以程式求出由入口至出口的路径。解法老鼠的走法有上、左、下、右四个方向，在每前进一格之后就选一个方向前进，无法前进时退回选择下一个可前进方向，如此在阵列中依序测试四个方向，直到走到出口为止，这是递回的基本题，请直接看程式应就可以理解。*/#include #include int visit(i...
老鼠走迷宫php算法,C语言经典算法 - 老鼠走迷官（一）
weixin_39832448的博客
03-26 80
C语言经典算法 - 老鼠走迷官(一)说明老鼠走迷宫是递回求解的基本题型，我们在二维阵列中使用2表示迷宫墙壁，使用1来表示老鼠的行走路径，试以程式求出由入口至出口的路径。解法老鼠的走法有上、左、下、右四个方向，在每前进一格之后就选一个方向前进，无法前进时退回选择下一个可前进方向，如此在阵列中依序测试四个方向，直到走到出口为止，这是递回的基本题，请直接看程式应就可以理解。#include #inclu...
米奇小老鼠走迷宫问题代码以及注释
weixin_62848414的博客
02-22 329
数据结构与算法中小老鼠走迷宫问题代码...
java老鼠走迷宫算法_老鼠走迷宫java算法
weixin_35545345的博客
02-13 822
说明老鼠走迷宫是递回求解的基本题型，我们在二维阵列中使用2表示迷宫墙壁，使用1来表示老鼠的行走路径，试以程式求出由入口至出口的路径。解法老鼠的走法有上、左、下、右四个方向，在每前进一格之后就选一个方向前进，无法前进时退回选择下一个可前进方向，如此在阵列中依序测试四个方向，直到走到出口为止，这是递回的基本题，请直接看程式应就可以理解。package test;public class Mouse {...
c语言递归算法老鼠走迷宫详解,C++利用递归实现走迷宫
weixin_39613089的博客
05-23 610
本文实例为大家分享了C++利用递归实现走迷宫的具体代码，供大家参考，具体内容如下要求：1、将地图的数组保存在文件中，从文件中读取行列数2.、动态开辟空间保存地图3.、运行结束后再地图上标出具体的走法说明：1、文件中第一行分别放置的是地图的行数和列数2、其中1表示墙，即路不通，0表示路，即通路3、程序运行结束后用2标记走过的路径4、当走到“死胡同”时用3标记此路为死路5、每到一个点，按照 左 上 右...
老鼠走迷宫C++
05-20
【标题】"老鼠走迷宫C++"是一个编程项目，主要目标是使用C++语言来模拟老鼠在迷宫中寻找出路的过程，并可视化显示老鼠走过的路径。这个项目可以帮助学习者深入理解C++编程语言，同时涉及到算法设计和数据结构的应用...
老鼠走迷宫 算法 实例
08-02
说明：老鼠走迷宫是递回求解的基本题型，我们在二维阵列中使用2表示迷宫墙壁，使用1来表示老鼠的行走路径，试以程式求出由入口至出口的路径。 解法：老鼠的走法有上、左、下、右四个方向，在每前进一格之后就选一个...
migong.rar_老鼠走迷宫
09-23
本项目“migong.rar”提供了一个名为“老鼠走迷宫”的C++程序，旨在帮助学习者深入理解如何利用堆栈和数组来解决这类问题。下面将详细解析这个程序的核心概念和技术。 首先，我们要明白迷宫问题的本质。迷宫可以被...
电老鼠走迷宫算法.doc
05-26
### 电老鼠走迷宫算法解析 #### 一、引言 随着科技的进步与智能机器人的发展，电脑鼠（Micromouse）作为一种结合了感知、判断与行走功能的小型机器人，已经成为教学与科研的重要工具之一。它能够在复杂的环境中...
migong.rar_老鼠走迷宫_迷宫
09-21
标题 "migong.rar_老鼠走迷宫_迷宫" 提到的是一个关于“老鼠走迷宫”的主题，这通常涉及到计算机科学中的路径搜索算法。迷宫问题是一个经典的图论和算法问题，它要求找到从起点到终点的最短路径。在实际应用中，这种...
[知识点]-[最短路]
m0_52398496的博客
07-31 578
【代码】[知识点]-[最短路]
【算法】递归实现二分查找（优化）以及非递归实现二分查找
2302_78914800的博客
07-31 250
1.首先确定该数组中间的下标 mid = (left + right) / 2;2.递归完整个数组，依然没有找到，即 left > right 就阶结束递归。2.然后让需要查找的数 findVal 和 arr[mid] 比较。
2023 RoboCom CAIP本科组决赛-RC-u3 兰州拉面派餐系统
m0_68536532的博客
08-03 235
2023 RoboCom CAIP本科组决赛-RC-u3 兰州拉面派餐系统具体实现(不使用优先队列+使用优先队列)
算法日记day 28（贪心之分发饼干|摆动序列|最大子数组和|买卖股票最佳时机）
最新发布
m0_74980681的博客
08-03 510
在判断是否摆动时，需要判断当前节点与左右邻节点的差值是否为一正一负，满足条件才是属于摆动，其中存在一种特殊情况，如：（1,2,2,4,5）属于单调摆动，这种情况总共只有2个摆动，即为边界的两次摆动，因此采用双指针摆动时不能实时更新两个指针的位置，应为一个指针负责判断差值，当差值存在时才能更新另一个指针的位置。可以采用双指针的方法，先将两数组从小到大排序，判断饼干数组中的值是否大于等于胃口数组的值，如果是结果加1，然后饼干数组向前遍历，继续判断，直到饼干数组全部遍历完毕，输出结果数组。，这个孩子会得到满足。
经典算法实现集锦：从迷宫到背包问题
"该资源包含了27个经典的算法实现，涵盖了诸如老鼠走迷宫、排列组合、河内塔、背包问题等多方面的算法问题。通过这些算法，读者可以深入理解并掌握不同类型的算法思想和解决策略。" 在编程和计算机科学领域，经典...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值