精华内容
下载资源
问答
  • 走迷宫问题

    2008-06-14 21:19:52
    用c语言实现老鼠走迷宫问题,主要用到是的回溯法
  • 主要介绍了Python解决走迷宫问题算法,结合实例形式分析了Python基于二维数组的深度优先遍历算法解决走迷宫问题相关操作技巧,需要的朋友可以参考下
  • 主要介绍了Python基于递归算法实现的走迷宫问题,结合迷宫问题简单分析了Python递归算法的定义与使用技巧,需要的朋友可以参考下
  • 走迷宫问题广度优先算法实现

    千次阅读 2018-10-21 22:56:25
    走迷宫问题 迷宫是许多小方格构成的矩形,在每个小方格中有的是墙(用1表示),有的是路(用0表示)。走迷宫就是从一个小方格沿上、下、左、右四个方向到邻近的方格,当然不能穿墙。 问题描述 实现生成迷宫(从文本...

    走迷宫问题

    迷宫是许多小方格构成的矩形,在每个小方格中有的是墙(用1表示),有的是路(用0表示)。走迷宫就是从一个小方格沿上、下、左、右四个方向到邻近的方格,当然不能穿墙。

    问题描述
    实现生成迷宫(从文本中读取数据生成),输出迷宫(图案方式),探索迷宫路径(最短路径),输出迷宫路径(图案方式)。

    输入的文件内容格式为:

    6 5
    0 1 0 1 1
    0 0 1 1 1
    1 0 0 1 1
    0 1 0 0 1
    1 1 1 0 0
    1 1 1 1 0
    
    开头一行表示地图为6行5列,地图中0表示路,1表示障碍物。现在规定从左上角进入迷宫从右下角出迷宫。
    

    算法分析
    在任意位置,理论上有四个位置可以走,上下左右。现在位于位置0,走一步可以走的位置为:

    也就是当前位置为0,可以走的位置为1,相同道理,走2步可以走的位置为:

    当位于0时,可以探索的位置为周围的四个1,广度优先的算法是根据状态可分为两种状态,当前位置和下一步可以为的位置,当前位置为0,下一步可以为的位置为1,通过队列将下一步位置先保存起来,遍历下一步可以为的4个1位置,再分别根据位于4个1位置时探索下一步的位置。如果当位于0位置找到一个下一步位置1之后再直接进行下一步探索则成了深度优先算法。

    以起始点为出发,将这个点按照某个方向规则走,周围所有可以走的位置依次写入到队列,这个点走完之后,队首出队列,走这个点四周所有可以走的点,按照之前的规则,将周围可走的点依次放入到队列中,重复之前过程,直到队列为空或者走到终点。在这个过程中在借助一个辅助矩阵,存放起点到位置的最短路径。

    源码分析

    //坐标结构
    type point struct {
    	i int
    	j int
    }
    
    //分别代表上左下右
    var dirs = [4]point{
    	{-1, 0},
    	{ 0, -1},
    	{ 1, 0},
    	{ 0, 1},
    }
    
    //读取地图文件
    func readMaze(fileName string) [][]int {
    	file, err := os.Open(fileName)
    	if err != nil {
    		panic("open file fail")
    	}
    
    	var row, col int
    	var changeLine int
    	fmt.Fscanf(file, "%d %d", &row, &col)
    
    	maze := make([][]int, row)
    	for i := range maze {
    		maze[i] = make([]int, col)
    		
    		//读取文件过程中遇到换行读取为0
    		fmt.Fscanf(file, "%d", &changeLine)
    
    		for j := range maze[i] {
    			fmt.Fscanf(file, "%d", &maze[i][j])
    		}
    	}
    
    	return maze
    }
    
    func walkMaze(maze [][]int, start, end point)([][]int,bool) {
    	steps := make([][]int, len(maze))
    
    	for i := range steps {
    		steps[i] = make([]int, len(maze[0]))
    	}
    	
    	//保存四周下一步可以出现位置
    	Q := []point{start}
    
    	for len(Q) > 0 {
    		cur := Q[0]
    		Q = Q[1:]
    
    		for _, dir := range dirs {
    			next := cur.add(dir)
    			//1代表障碍物
    			nextValue, ok := next.at(maze)
    			if !ok || nextValue == 1 {
    				continue
    			}
    			//下一步必须是还没走过的位置
    			nextValue, ok = next.at(steps)
    			if !ok || nextValue != 0 {
    				continue
    			}
    			//不能走到其实位置
    			if next == start {
    				continue
    			}
    		
    			Q = append(Q,next)
    
    			mazeValue, ok := cur.at(steps)
    			if ok {
    				steps[next.i][next.j] = mazeValue + 1
    			}
    
    		}
    	}
    	//当走到终点时,则终点位置会被赋值为走过的步数
    	if steps[len(steps)-1][len(steps[0])-1] == 0 {
    		return steps,false
    	}
    
    	return steps,true
    }
    

    完整源码

    展开全文
  • c++算法实现蟑螂走迷宫问题,对迷宫感兴趣的可以看看
  • 利用Java解决走迷宫问题

    千次阅读 2020-12-18 20:16:36
    利用Java解决走迷宫问题 概述 假设有一个如下图所示的迷宫,灰色部分是墙壁不可走,白色部分是可以走的路,蓝色位置为迷宫的入口,绿色位置为出口。从入口出发,规定只能通过向上、向下、向左和向右方向进行走动,问...

    利用Java解决走迷宫问题

    概述

    假设有一个如下图所示的迷宫,灰色部分是墙壁不可走,白色部分是可以走的路,蓝色位置为迷宫的入口,绿色位置为出口。从入口出发,规定只能通过向上、向下、向左和向右方向进行走动,问如何才能找到一条到达出口的通路。

    在这里插入图片描述

    思路

    • 可以用一个二维矩阵来模拟迷宫地图,0代表灰色部分的墙壁,1代表白色部分可走的路

    • 当每走过一个位置后,把改位置的值标记为-1,如果该位置标记为-1,则不可以重复走

    • 判断当前位置是否有路可走,根据向右、向下、向左、向上的顺序判断该位置的下一步是否有路可走

    • 每走一步,需要把每一步的位置坐标保存起来,记录走过的位置

    • 当走到死胡同,没路可走时,回溯到前面的位置,并判断该位置是否有路可走

    • 如果有路可走,则继续往下走,反之则继续回退到前面一个位置继续查找,直到找到有路可走为止

    在这里插入图片描述

    实现过程

    建立迷宫地图

    public class walkMaze {
        private static int[][] maze =    //建立迷宫地图,0代表可走的路,1代表墙壁不可走
                {{1,1,1,1,1,1,1,1,1,1},
                 {1,0,0,1,0,0,0,1,0,1},
                 {1,0,0,1,0,0,0,1,0,1},
                 {1,0,0,0,0,1,1,0,0,1},
                 {1,0,1,1,1,0,0,0,0,1},
                 {1,0,0,0,1,0,0,0,0,1},
                 {1,0,1,0,0,0,1,0,0,1},
                 {1,0,1,1,1,0,1,1,0,1},
                 {1,1,0,0,0,0,0,0,0,1},
                 {1,1,1,1,1,1,1,1,1,1}};
        private static ArrayList<Point> route = new ArrayList<>();  //走迷宫的路线
        
        //打印输出迷宫地图
         public static void main(String[] args) {
            for (int i = 0; i < maze.length; i++) {
                for (int j = 0; j < maze.length; j++) {
                    System.out.print(maze[i][j]+"  ");
                }
                System.out.println();
            }
        }
    }
    

    判断往右下左上方向是否可以走

     private static boolean isWalk(int[][] maze,Point currentPoint){
         int x = currentPoint.x;
         int y = currentPoint.y;
         //往右走
         if (maze[y][x+1]!=1 && maze[y][x+1]!=-1){
             route.add(new Point(x+1,y));
             return true;
         }
         //往下走
         if (maze[y+1][x]!=1 && maze[y+1][x]!=-1){
             route.add(new Point(x,y+1));
             return true;
         }
         //往左走
         if (maze[y][x-1]!=1 && maze[y][x-1]!=-1){
             route.add(new Point(x-1,y));
             return true;
         }
         //往上走
         if (maze[y-1][x]!=1 && maze[y-1][x]!=-1){
             route.add(new Point(x,y-1));
             return true;
         }
         return false;
     }
    

    走迷宫核心代码

    private static boolean maze(int[][] maze,Point enter){
        //标记入口位置,并将入口位置加入列表中
        maze[enter.y][enter.x]=-1;
        route.add(enter);
        //判断列表是否为空
        while (!route.isEmpty()){
            while (isWalk(maze,enter)){
                //列表中的最后一个元素
                enter = route.get(route.size()-1);
                //判断改位置是否是出口位置
                if (enter.x==8 && enter.y==8){
                    return true;
                }else{
                    //标记已走过的位置
                    maze[enter.y][enter.x]=-1;
                }
            }
            //当走到死胡同的时候,回溯到前面的位置,并判断改位置是否有路可走
            // 如果有路可走,则继续往下走,反之则继续回退到前面一个位置继续查找,直到找到有路可走为止
            //将列表最后一个元素去除,并取出去除后最后的元素
            route.remove(route.size()-1);
            enter = route.get(route.size()-1);
        }
        return false;
    }
    

    测试输出走迷宫路线

    public static void main(String[] args) {
        //走迷宫
        boolean flag = maze(walkMaze.maze, new Point(1, 1));
        if (flag){
            System.out.println("成功找到迷宫的出口!\n路线如下:");
            for (int i = 0; i < route.size(); i++) {
                System.out.print("("+route.get(i).x+","+route.get(i).y+")");
                if (i!=route.size()-1){
                    System.out.print("->");
                }
            }
        }
    }
    

    结果显示

    在这里插入图片描述

    这样就顺利找到了迷宫的出口了,按照代码运行输出的路线坐标去根据迷宫地图去走,最终就可以到达迷宫的出口,顺利走出迷宫。

    在这里插入图片描述

    展开全文
  • 本文实例讲述了Python基于递归算法实现的走迷宫问题。分享给大家供大家参考,具体如下: 什么是递归? 简单地理解就是函数调用自身的过程就称之为递归。 什么时候用到递归? 如果一个问题可以表示为更小规模的迭代...
  • 走迷宫问题代码

    2018-11-03 20:26:41
    该程序作用为对于输入的n*n的迷宫(用1表示障碍,0表示可通行),从入口(1,1)出发,找出一条通往(n,n)的最短路径,若有多条路径长度相同 ,则随机输出其中一条。
  • 【经典算法】老鼠走迷宫问题

    千次阅读 2018-07-21 18:37:00
    老鼠走迷宫问题及其多个变种 说明 老鼠走迷宫问题的递归实现,是对递归思想的一种应用。 问题描述 给定一个二维数组,数组中2表示墙壁,0表示通路,由此数组可展示为一个迷宫图。给定入口位置和出口位置,判断...

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

    一、说明
    老鼠走迷宫问题的递归实现,是对递归思想的一种应用。
    二、问题描述
    给定一个二维数组,数组中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;
    }

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

    展开全文
  • 走迷宫问题——非递归算法

    千次阅读 2016-12-02 21:08:01
    走迷宫问题 非递归算法 已经编译运行通过

    1.顺序栈头文件

    # include<iostream>
    using namespace std;
    struct items{
    	int x,y;
    	char* dir;
    };
    class SeqStack{        //顺序栈类
    private:
    	int maxSize;          //栈中可容纳的最大元素个数
    	int top;            //栈顶指针:栈中的元素个数,值等于栈顶元素的下标
    	items* elements;         //指向栈
    public:
    	SeqStack(int sz=50);  //构造函数:构造一个最大可容纳sz个元素的栈
    	~SeqStack(){delete[] elements;}     //析构函数:释放栈的所有存储空间
    	void Push(const items& x);     //进栈函数:把元素x压进栈里
    	bool Pop(items& x);           //出栈函数:把栈顶元素的值赋给x,并且使栈顶指针退一格;
    	bool isEmpety(){return (top==-1)?true:false;} //判断栈空
    	bool isFull(){ return (top+1==maxSize)?true:false;} //判断栈满
    	friend ostream& operator<<(ostream& ostr,SeqStack& x); //顺序栈输出运算符的重载
    };
    

    2.顺序栈源文件

    # include<iostream>
    # include<assert.h>
    # include"SeqStack.h"
    using namespace std;
    SeqStack::SeqStack(int sz):top(-1),maxSize(sz){     //构造函数:top=-1表示栈空
    	elements=new items[maxSize];       
    	assert(elements!=NULL);  //assrt机制:如果满足()里的条件程序才可继续执行
    }
    void SeqStack::Push(const items& x){     //
    	elements[++top]=x;
    }
    bool SeqStack::Pop(items& x){          //出栈函数
    	if(isEmpety()) return false;
    	x=elements[top--];
        return true;
    }
    ostream& operator<<(ostream& ostr,items& s){   //自定义数据类型items输出重载
    	cout<<"("<<s.x<<"<"<<s.y<<")"<<" "<<s.dir<<endl;
    	return ostr;
    }
    ostream& operator<<(ostream& ostr,SeqStack& x){  //栈输出运算符的重载
    	for(int i=0;i<=x.top;i++)
    		ostr<<x.elements[i]<<endl;
    	return ostr;
    }
    
    3.走迷宫函数和主函数:

    # include<iostream>
    # include"SeqStack.h"
    void Path(int x,int y,items move[8],int Maze[][4],int mark[][4]);
    using namespace std;
    const int m=2,p=2;
    void main(){
    	int i,j;
    	int Maze[m+2][p+2];  //定义迷宫数组
    	int mark[m+2][p+2];  //定义标记数组
    	items move[8]={{-1,0,"N"},{-1,1,"NE"},{0,1,"E"},{1,1,"SE"},
    	{1,0,"S"},{1,-1,"SW"},{0,-1,"W"},{-1,-1,"NW"}}; //定义移动数组
    	for(i=0;i<m+2;i++)
    		for(j=0;j<p+2;j++) cin>>Maze[i][j];//迷宫数组赋值:0,1赋值,能走点赋值0,不能通过的赋值1;
    	for(i=0;i<m+2;i++)
    		for(j=0;j<p+2;j++) mark[i][j]=0;    //标记数组赋值:都赋值0,表示未走
    	mark[1][0]=1; //把mark[0][0]赋值1,表示从[0][0]点出发
    	Path(3,3,move,Maze,mark);//调用SeekPath函数,寻找能走出迷宫的路径
    	system("pause");
    }
    void Path(int x,int y,items move[8],int Maze[][4],int mark[][4]){
    	int i,j,g,h,n=0;
    	char* d;
    	SeqStack st(m*p);     //创建一个栈:储存走出迷宫的路径
    	items tmp;            //把起点和要走的第一个方向压到栈里
    	tmp.x=1;
    	tmp.y=0;
    	tmp.dir="E";
    	st.Push(tmp);
    	while(st.isEmpety()==false){   
    	n=0;
    	st.Pop(tmp);  //栈顶元素出栈,得到出发点:此处分两种情况:1是把起点取出来开始行走;2是走不通时退回上一点再按别的路径行走;
    	i=tmp.x;
    	j=tmp.y;
    	while(n<8){ 
    		g=i+move[n].x;         //从该点尝试按8个方向行走
    		h=j+move[n].y;
    		d=move[n].dir;
    		if(g==x&&h==y){       //如果行走到终点,输出走过的路径
    			cout<<st;
    			cout<<x<<" "<<y<<endl;
    			return;
    		}
    		if(mark[g][h]==0&&Maze[g][h]==0){    //如果该点未走过并且走的通
    			mark[g][h]=1;             //走到该点
    			tmp.x=i;                  //把上一点和要走的方向压入栈里
    			tmp.y=j;
    			tmp.dir=d;
    			st.Push(tmp);
    			i=g;j=h;n=0;             //把该点作为起点,然后把n置0:表示从该点继续按不同方向行走
             }
             else n++;   //走不通的话换一个方向走
    	}
    	}
    	cout<<"no path in Maze"<<endl; //如果栈空,表示退到起点,走不通
    }
    		
    



    展开全文
  • 走迷宫问题栈实现.cpp

    2019-07-01 19:20:25
    最近在leetcode上做到一个运用递归算法解决的...在此拿出三年前写的老鼠走迷宫案例来进行一个简单的分析铺垫,顺便附上完整代码,关于本资源的博客地址:https://blog.csdn.net/qq_34901049/article/details/94403330
  • 这是一个用栈处理问题的例子,它处理的是走迷宫问题
  • 可视化走迷宫问题,使用java可视化进行,可以较好理解深度优先的递归遍历问题
  • 忽然记起大一自学数据结构那段为八皇后、汉诺塔、老鼠走迷宫问题着迷的岁月,好久没有接触这类问题了。在此拿出三年前大一暑假在家乡那个小书桌前花了六个小时才实现的老鼠走迷宫案例来进行一个简单的分析铺垫,顺便...
  • 穷举解决走迷宫问题

    2013-10-18 20:44:15
    今天又碰到了一个走迷宫问题,于是特地花了点时间把该问题解决了。代码如下: package com.bringwu.test.moze; import java.util.ArrayList; import java.util.List; /** * @author bringwu * @date 20
  • 走迷宫问题总结

    2018-07-25 22:12:00
    1、判断一个迷宫是否有出口 ...poll出迷宫问题: 、 如图所示的迷宫,0代表可以,1代表有墙。要求从左上角到右下角是否有一条路可以完。如何判断这个迷宫内是否有路。代码如下: 1 boolea...
  • 青蛙走迷宫问题–滴滴笔试题目:迷宫矩阵(n*m)的每一个元素可以是0或1,1表示可走,0表示走不通,迷宫的入口为(0,0),出口为(0,m-1)。青蛙的体力值为P,向右走消耗1个体力值,向下走不消耗体力值,向上走消耗3个体力...
  • 老鼠走迷宫问题

    千次阅读 2014-09-27 23:56:19
    一只老鼠走进了一个迷宫,如何从其中出去,在此处我们用2表示墙壁或障碍,
  • 走迷宫问题 迷宫是许多小方格构成的矩形,如下图所示,在每个小方格中有的是墙(图 中的“1”)有的是路(图中的“0”)。走迷宫就是从一个小方格沿着上,下,左,右四个方向都临近的方格,当然不能穿墙。设迷宫的...
  • 本文实例讲述了Python基于递归算法实现的走迷宫问题。分享给大家供大家参考,具体如下: 什么是递归? 简单地理解就是函数调用自身的过程就称之为递归。 什么时候用到递归? 如果一个问题可以表示为更小规模的迭代...
  • 用简单递归方法解决老鼠走迷宫问题 在复习递归算法的时候,脑袋里突然浮现出老鼠走迷宫问题,既然想到了,那么接下来就让我们用C++实现它吧,自己争取用易于理解和阅读的方式实现。 1、问题说明: ...
  • 通过自己创建一个迷宫 然后实现迷宫法 c语言 与 数据结构
  • 老鼠走迷宫问题(C++栈实现)

    千次阅读 2015-04-08 15:34:27
    问题描述:用矩阵(二维数组)表示迷宫,其中1表示墙,0表示通路。老鼠在左上角,要走到迷宫右下角。很简单的一个问题,主要...直接贴代码//老鼠走迷宫问题 #include"stack.h" #define X 10class Point { public: int x;
  • DFS(深度优先算法)——走迷宫问题

    千次阅读 2016-11-18 23:21:45
    /*走迷宫问题*/ #include<stdio.h> int maze[50][50]; int fx[4]= {1,-1,0,0}; int fy[4]= {0,0,-1,1}; int n,pos=1; void createGraph() { int i,j; printf("创建邻接矩阵如下:\n"); for(i=1; i<=n; ...
  • 通过alpha-belta剪枝的极大极小值算法实现简单的五子棋+A*算法与IDA*算法解决走迷宫问题

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,133
精华内容 13,253
关键字:

走迷宫问题