算法小程序：逃离大迷宫

最新推荐文章于 2022-05-15 10:38:40 发布
最新推荐文章于 2022-05-15 10:38:40 发布
阅读量1.6k 收藏 2
点赞数 1
分类专栏： 数据结构算法 文章标签： 逃离大迷宫 算法小程序 迷宫
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haqiang555/article/details/102453735
版权

问题描述

在一个 10^6 x 10^6 的网格中，每个网格块的坐标为 (x, y)，其中 0 <= x, y < 10^6。
我们从源方格 source 开始出发，意图赶往目标方格 target。每次移动，我们都可以走到网格中在四个方向上相邻的方格，只要该方格不在给出的封锁列表 blocked 上。
只有在可以通过一系列的移动到达目标方格时才返回 true。否则，返回 false。
示例 1：

输入：blocked = [[0,1],[1,0]], source = [0,0], target = [0,2]
输出：false
解释：
从源方格无法到达目标方格，因为我们无法在网格中移动。

示例 2：

输入：blocked = [], source = [0,0], target = [999999,999999]
输出：true
解释：
因为没有方格被封锁，所以一定可以到达目标方格。

提示：

0 <= blocked.length <= 200
blocked[i].length == 2
0 <= blocked[i][j] < 10^6
source.length == target.length == 2
0 <= source[i][j], target[i][j] < 10^6
source != target

链接：https://leetcode-cn.com/problems/escape-a-large-maze

解题思路

刚开始看到这道题的时候，第一个想法就是动态递归的方法，每走一步，把往后的所有步骤列举出来，最后判断可行不可行。但是这种递归方法很容易栈溢出，大概棋盘20x20往后就溢出了，题目给的10^6 x 10^6实在太大，递归方法不可行。

将递归转换成非递归方法。

  1. 每走一步，标记状态放进栈中，一直到走不通；
  2. 走不通后开始倒退，将退出的格子从栈中移除，并且标记为不可走;
  3. 然后继续判断上下左右是否可行，不可行继续往后退，直到找到可行的路，重复第一步。

这样，可以一直执行，且内存消耗也不大。
但是，缺点是比较耗时，因为它一直是试探性的往前走。
提示有一个要求0 <= blocked.length <= 200，所以利用这个条件，则围成个三角形可以围住最多的点,即(200*200)/2-200/2=19900个点(三角形面积+斜边超出部分的面积),从起点S走了超出19900步没有被围住，所以，只需要多加一个判断条件即可
但是，认为是可以抵达终点T是不对的,因为障碍点可能围住了终点T,所以也得需要判断从终点T是否也可到达起点S
下面是用java实现的逃离大迷宫算法

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

/**
 * Created by amettursun on 2019/7/5.
 */
public class 逃离大迷宫 {
    /**
     * 在一个 10^6 x 10^6 的网格中，每个网格块的坐标为 (x, y)，其中 0 <= x, y < 10^6。
     我们从源方格 source 开始出发，意图赶往目标方格 target。每次移动，我们都可以走到网格中在四个方向上相邻的方格，只要该方格不在给出的封锁列表 blocked 上。
     只有在可以通过一系列的移动到达目标方格时才返回 true。否则，返回 false。
     */
    // 记录行走路径
    public static Stack<int[]> trace = new Stack<>();
    // 设置棋盘大小6x6
    public  static int scope = 6;
    public static void main(String[] args) {
    	// 设置棋盘阵型
        int[][] blocked = {{3,2},{4,2},{5,3},{4,4},{2,5}};
        // 起点
        int[] source = new int[]{0,0};
        //终点
        int[] target = new int[]{5,5};
        System.out.println("^ v ^");
        // 判断是否走得通
        boolean escapePossible = isEscapePossible(blocked, source, target);
        System.out.println( escapePossible);
        if (escapePossible){
            trace.stream().forEach(t->{
                System.out.print("{"+t[0]+","+t[1]+"}-->");
            });
        }

    }


    public static Map<String, Integer> dealData(int[][]blocked){
        Map<String, Integer> graph= new HashMap<>();
        for (int i = 0; i < blocked.length; i++) {
            int x = blocked[i][0];
            int y = blocked[i][1];
            String key = x+""+y;
            graph.put(key,1);
        }
        return graph;
    }
    // 判断是否超出范围
    public static boolean outOfScope(int x, int y,Map<String, Integer> graph){
        return x>=0 && y>=0 && x<scope && y<scope && getGraph(graph,x+""+y)==0;
    }

    public static boolean isEscapePossible(int[][] blocked, int[] source, int[] target){
//        Stack<int[]> trace = new Stack<>();
        Stack<int[]> trace2 = new Stack<>();
        // 正向和逆向，都走一遍
        return isEscapePossible2(blocked, source, target, trace) && isEscapePossible2(blocked, target, source, trace2);
    }

    public static boolean isEscapePossible2(int[][] blocked, int[] source, int[] target, Stack<int[]> trace){
        Map<String, Integer> graph = dealData(blocked);
        // 上下左右轮询，一直到taget和source是同一个点为止
        trace.add(source.clone());
        while (true){
            int x = source[0];
            int y = source[1];
            // 出口
            if (x == target[0] && y==target[1]){
                return true;
            }
            if (trace != null && trace.size() > 19900)
                return true;
            // 上
            if (goAhead(graph,source, 1)){
                // 移动成功，将路径加入到stack里面, 移动source
                trace.add(source.clone());
                continue;
            }else if (goAhead(graph,source, 2)){
                // 下
                trace.add(source.clone());
                continue;
            }else if (goAhead(graph,source, 3)){
                // 左
                trace.add(source.clone());
                continue;
            }else if (goAhead(graph,source, 4)){
                // 右
                trace.add(source.clone());
                continue;
            }else {
                // 失败，回撤
                int[] ints = rollBack(trace, graph);
                if (ints != null)
                    source = ints.clone();
                else
                    source = null;
            }
            // 退回到起点, 走投无路
            if (trace.size() ==0 && source == null){
                return false;
            }
        }
    }

    // 如果能走，则走到下一步，返回true，否则返回false
    public static boolean goAhead(Map<String, Integer> graph,int[]source, int director){
        // 1.上 2.下 3.左 4.右
        int x = source[0];
        int y = source[1];
        switch (director){
            case 1:{
                if (outOfScope(x-1, y,graph)){
                    blockGraph(graph,source,1);
                    source[0] = x-1;
                    source[1] = y;
                    return true;
                }else
                    return false;
            }
            case 2:{
                if (outOfScope(x+1, y,graph)){
                    blockGraph(graph,source,1);
                    source[0] = x+1;
                    source[1] = y;
                    return true;
                }else
                    return false;
            }
            case 3:{
                if (outOfScope(x, y-1,graph)){
                    blockGraph(graph,source,1);
                    source[0] = x;
                    source[1] = y-1;
                    return true;
                }else
                    return false;
            }
            case 4:{
                if (outOfScope(x, y+1,graph)){
                    blockGraph(graph,source,1);
                    source[0] = x;
                    source[1] = y+1;
                    return true;
                }else
                    return false;
            }
            default:return false;
        }
    }

    // 返回source位置
    public static int[] rollBack(Stack<int[]> stack, Map<String, Integer> graph){
        try {
            int[] pop = stack.pop();
            int x = pop[0];
            int y = pop[1];
            blockGraph(graph,pop,1);
            return stack.lastElement();
        }catch (Exception e){
            return null;
        }
    }
    // 打开该图格子0，或block该格子1
    public static void blockGraph(Map<String, Integer> graph, int[] position, int action){
        String key = position[0] +""+ position[1];
        if (action == 0){
            graph.put(key,0);
        }
        else {
            graph.put(key,1);
        }
    }
    public static int getGraph(Map<String, Integer> graph, String key){
        Integer integer = graph.get(key);
        if (integer != null)
            return integer;
        else return 0;
    }
}

运行结果

测试棋盘为6x6，格子设置如下6x6棋盘迷宫
可以走通，并且打印走通路线
走通路线
如果把其中{2,5}棋子的位置改为{3,5}，得出的结果为走不通

lenKee
关注
专栏目录
hdu - 逃离迷宫 - BFS
Daioo 随笔
07-20 421
Problem Description　　给定一个m × n (m行, n列)的迷宫，迷宫中有两个位置，gloria想从迷宫的一个位置走到另外一个位置，当然迷宫中有些地方是空地，gloria可以穿越，有些地方是障碍，她必须绕行，从迷宫的一个位置，只能走到与它相邻的4个位置中,当然在行走过程中，gloria不能走到迷宫外面去。令人头痛的是，gloria是个没什么方向感的人，因此，她在行走过程中，不能转
图文详解两种算法：深度优先遍历（DFS）和广度优先遍历（BFS）
WANGHAOXIN364的博客
03-26 3895
图文详解两种算法：深度优先遍历（DFS）和广度优先遍历（BFS） 阅读本文前，请确保你已经掌握了递归、栈和队列的基本知识，如想掌握搜索的代码实现，请确保你能够用代码实现栈和队列的基本操作。 深度优先遍历(Depth First Search, 简称 DFS) 与广度优先遍历(Breath First Search，简称 BFS)是图论中两种非常重要的算法，也是进行更高的算法阶段学习的最后一道门槛。搜索算法频繁出现在算法竞赛题中，尤其是深度优先搜索，在竞赛中，它是用来进行保底拿分的神器！ 本文将..
逃离迷宫
admin__的博客
07-24 501
题目： 给定一个m × n (m行, n列)的迷宫，迷宫中有两个位置，gloria想从迷宫的一个位置走到另外一个位置，当然迷宫中有些地方是空地，gloria可以穿越，有些地方是障碍，她必须绕行，从迷宫的一个位置，只能走到与它相邻的4个位置中,当然在行走过程中，gloria不能走到迷宫外面去。令人头痛的是，gloria是个没什么方向感的人，因此，她在行走过程中，不能转太多弯了，否则她会晕倒的。我们...
1036. 逃离大迷宫
Umbrella Corporation
07-10 6472
在一个 10^6 x 10^6 的网格中，每个网格块的坐标为(x, y)，其中0 <= x, y < 10^6。 我们从源方格source开始出发，意图赶往目标方格target。每次移动，我们都可以走到网格中在四个方向上相邻的方格，只要该方格不在给出的封锁列表blocked上。 只有在可以通过一系列的移动到达目标方格时才返回true。否则，返回 false。 ...
Java小案例-（逃离迷宫）
08-19 297
Java小案例-（逃离迷宫） 一，迷宫需求描述： 1，用户输入迷宫图（限制方形）：字母1位墙，0为通，e为出口，m为入口，*为已访问的位置，用外围1围住迷宫 2，运行轨迹右，左，下，上 3，判断该迷宫是否能从入口走到出口，并将搜索过程输出 二，迷宫实现： 1，迷宫元素类MazeCell： package smalldemo.maze; class MazeCel...
逃离ACM迷宫（BFS）
justDoIt
07-27 700
逃离ACM迷宫（BFS）题目链接 题目描述如下图所示的是一个由程序设计题目组成的ACM迷宫。迷宫的左上角是入口，右下角是出口。迷宫中每一个格子都有一个程序设计题目，挑战者要AC该题目后才能通过，大于0的数字表示AC该题目所需的最短时间。数字如果是0表示是陷阱，进去了就出不来。现在的问题是：求挑战者从入口到出口所需的最短时间。 解题思路： 1、由于状态转换太多，利用DFS容易超时，因此运用BF
【入门算法】寻路系统：BFS&DFS
AC不动机的博客
01-06 948
应一些朋友的请求，我就准备起笔写这篇博客了，因为本人非常懒（大概是和女朋友相处多了就被同化了 ），就不画一大堆图片来解释说明了，尽量只靠文字解决。最后补上一句几乎固定的话：如果喜欢本文，记得点赞哦；如果对我的博客较为满意的话，可以点一下左边的关注哦 还是和以前的习惯一样，先上OJ题 逃离迷宫 题目描述 王子深爱着公主。但是一天，公主被妖怪抓走了，并且被关到了迷宫。经过了常人难以想像的努力，王子到了...
迷宫逃脱：Tempter of the Bone 代码解析
通过这样的算法，我们能够有效地解决这个编程挑战，帮助小狗成功逃离迷宫，或者确定它无法逃脱。这是一个典型的路径搜索问题，对ACM（国际大学生程序设计竞赛）参赛者来说，理解和解决此类问题是非常重要的技能。
【BFS】逃离地牢（C++）
liuzich的博客
08-23 827
Description 贝茜被困在了一个三维立体的地牢里，这个地牢是一个立方体，由通道和岩石组成。贝茜只能往东、南、西、北、上、下六个方向走，且每走一步要花费1个单位的时间。现在将地牢的详细布局给你？你能逃出地牢么？如果能的话，最少要花多少时间呢？ Input 第一行包括三个数L R C，分别表示地牢的长宽高。（长宽高不会超过30） 接下来输入L个R*C的矩阵，两个矩阵之间用一个空行隔开，描述地牢...
leetcode:逃离大迷宫
小楼一夜听春雨
01-11 293
难点： 1.太大了，不能用这么大的visited矩阵 2.只能判断有没有被包围 3.别细问，问就是c + v 给大家看看官方答案，我没看懂，看懂了的教我一下哈 代码： class Solution: def isEscapePossible(self, blocked: List[List[int]], source: List[int], target: List[int]) -> bool: """ BLOCKED: 在包围圈中 .
python 边界像素个数_逃离迷宫算法——使用Python最短路径算法实现
weixin_39818727的博客
12-19 297
(转载作者请注明出处)废话不多说，直接上货....迷宫通常是人类的简单难题，但是关于迷宫也提出了一些很大的编程问题，例如:我们可以使用最短路径技术(例如使用Dijkstra的算法和OpenCV)来解决。完整的源代码可在本文下方点击再看并留言邮箱可获取一、Dijkstra算法Dijkstra的算法是较流行的基本图论算法之一，它用于查找有向图上节点之间的最短路径，并且我们通过从源节点和节点之...
C语言算法题：郑厂长系列故事――逃离迷宫
WZRbeliever的博客
05-15 189
一、题目 郑厂长没变 　　还是那个假厂长真码农 　　改变的是业余爱好 　　他现在不研究象棋，改玩游戏了！ 　　 　　最近，郑厂长爱上了逃离迷宫这个游戏，他日日夜夜的玩，就是想达到自己的目标：1000万，因为这个数字和他在腾讯的年收入一样多。 　　不过，在他跑到9999999时，游戏屏幕上突然出现了好多箱子，郑厂长必须要消除所有这些箱子才能继续玩游戏。这些箱子排成一行，每个箱子上都有个数字，每个数字代表这个箱子需要被点击的次数才会消失。每个箱子被点击时对应数字会减1，并且他右边箱子的数字也会同时减1，当箱子
逃出迷宫完整算法C++
飞翔在北京的博客
10-13 1035
迷宫图案，白色代表通道，黑色代表墙。  迷宫入口坐标(1,1),出口坐标(8,8)   0 1 2 3 4 5 6 7 8 9   0■■■■■■■■■■   1■□□■□□□■□■   2■□□■□□□■□■   3■□□□□■■□□■   4■□■■■□□□□■   5■□□□■□□□□■   6■□■□□□■□□■   7■□■■■□■■□■   8■■□□□□□□□■
LeetCode1036. 逃离大迷宫(BFS)
m0_51630248的博客
01-12 348
1036. 逃离大迷宫 在一个 106 x 106 的网格中，每个网格上方格的坐标为 (x, y) 。 现在从源方格 source = [sx, sy] 开始出发，意图赶往目标方格 target = [tx, ty] 。数组 blocked 是封锁的方格列表，其中每个 blocked[i] = [xi, yi] 表示坐标为 (xi, yi) 的方格是禁止通行的。 每次移动，都可以走到网格中在四个方向上相邻的方格，只要该方格 不 在给出的封锁列表 blocked 上。同时，不允许走出网格。 只有在可.
【Leetcode】1036. 逃离大迷宫
qq_36552817的博客
02-07 392
题目：1036 题意：在一个 10^6 x 10^6 的网格中，每个网格块的坐标为(x, y)，其中0 <= x, y < 10^6。我们从源方格source开始出发，意图赶往目标方格target。每次移动，我们都可以走到网格中在四个方向上相邻的方格，只要该方格不在给出的封锁列表blocked上。只有在可以通过一系列的移动到达目标方格时才返回true。否则，返回 fa...
leetcode——【逃离大迷宫】
super_carry的博客
01-12 227
题目 思路 方法一：有限步数的BFS 对于空间中一点，n个障碍点在最理想的情况下最多可包围n(n-1)/2个点，因此可得到思路： 1.对起点进行广度优先搜索，在n(n-1)/2点内找到了终点，则返回true；若遍历的点小于n(n-1)/2，则返回false；若在n(n-1)/2点内未找到终点，进行下一步； 2.对终点进行广度优先搜索，在n(n-1)/2点内找到了起点，则返回true；若遍历的点小于n(n-1)/2，则返回false；若在n(n-1)/2点内未找到起点，返回true。 方法二：离散化+BFS
leetcode 逃离大迷宫
weixin_42496727的博客
01-16 3704
题目链接 思路：数学+深搜 分析：在一个巨大的网格中，只有一部分障碍阻挡，是否能从一个点到另一个点，首先可以知道，这个巨大的网格中总的格子数相比于障碍是远大于的关系，而且，这个题目网格数是106 *106首先不可能单纯的深搜，因为格子数太多了。 这里障碍的个数，最多两百，那么可以从这里着手，首先，从一个点到另一个点，只有一个条件。 两个点是否有任何一个被障碍围住，如果有，则不可能到达，如果没有，则可到达。 那么现在的问题在于，如何判定一个点是否被障碍围住？ 方案一： 现在的问题有点类似于给你一个200米的篱
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值