精华内容
下载资源
问答
  • 机器人走迷宫

    2014-05-11 11:45:19
    机器人走迷宫,基于C和C++的程序,可供参考,此为迷宫游戏,有兴趣的可以下载
  • RobotBASIC机器人走迷宫

    2013-11-07 11:00:40
    在RobotBASIC模拟器中模拟机器人走迷宫。迷宫每次自动随机创建,机器人找到目标,并标出路线。
  • 机器人走迷宫竞赛规则.pdf
  • 主要为大家详细介绍了Python使用Tkinter实现机器人走迷宫,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 基于ARM的机器人走迷宫控制系统与算法设计.pdf
  • 初中信息技术课堂中计算思维培养研究——以初中“机器人走迷宫”为例.pdf
  • 有关机器人走迷宫的代码,java。但是这些只是其中的界面部分
  • 标题:机器人走迷宫(适用于走迷宫、最短路径算法) 问题描述: 一块矩形方格,含有障碍和可通行格子,求从某一点到另外一点的最短距离?N*M的矩阵; 其中,1代表障碍,0代表可通行;示例:给定二维矩阵 0 0 1 0 0 ...

    标题:机器人走迷宫(适用于走迷宫、最短路径算法)
    问题描述:

    1. 一块矩形方格,含有障碍和可通行格子,求从某一点到另外一点的最短距离?N*M的矩阵;
      其中,1代表障碍,0代表可通行;示例:给定二维矩阵
      0 0 1 0
      0 1 0 0
      0 0 0 0
      0 0 0 0

    出发点坐标[0, 0],终点坐标[2, 3];
    java编写int solve(int[][] grids, int[] start, int[] end)返回最短距离;

    思路:
    (1)机器人在矩阵范围内可以向上下左右走;
    (2)终点[2, 3]可以由[2,1]或[1, 3]走来;可在起点到点[2,1]的距离、起点到[1, 3]的距离中取最小值,再加1(格子之间距离为1)即可;
    (3)对于算法初学者,自然想到递归;
    当然,递归肯定可以解决问题,但是必须要不能找下去再递归回来,太慢了;时间复杂度O(N^2);
    (4)另外一种方式呢?从起点给你1步,你能走到起点的上下左右(当上下左右在格子中);扩散1步后,再扩散1步。。。是否可以扩散到终点,这个距离就是最短距离;就像气味扩散一样,

    半径是最短距离。能扩散到终点即可,不必求出终点四周的点,再取min值;----算法效率最高;时间复杂度O(N);

    2.若要打印最短路径呢?在历史信息中拉出来,已在代码中注释;

    3.若机器人有一次清理障碍的机会呢?代码如何写?–下回分解

    4.附带经典带权图最短路径的BFS代码;与方格不同的是,带权需要考虑比较权值大小;

    在这里插入图片描述

    Solution.java:
    package robot;

    import java.util.*;

    public class Solution {
    int[][] direct = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    // 方格的dfs
    public int dfs(int[][] grids, int[] start, int[] end, Set<List<Integer>> passedPaths) {
        // 每次递归要new flagPaths, 不然会重用导致程序不正确,切很难定位;兵家大忌;
        Set<List<Integer>> tmpSet = new HashSet<>(passedPaths);
        tmpSet.add(Arrays.asList(start[0], start[1]));
        if ((Math.abs(start[0] - end[0]) == 0 && Math.abs(start[1] - end[1]) == 1)
                || (Math.abs(start[0] - end[0]) == 1 && Math.abs(start[1] - end[1]) == 0)) {
            return 1;
        }
        int minLen = 1000;
        for (int[] item : direct) {
            int nextX = start[0] + item[0];
            int nextY = start[1] + item[1];
            if (nextX >= 0
                    && nextX <= grids.length - 1
                    && nextY >= 0
                    && nextY <= grids[0].length - 1
                    && grids[nextX][nextY] != 1
                    && !tmpSet.contains(Arrays.asList(nextX, nextY))
                    ) {
                // 满足要求才能递归:1、坐标在格子中;2、格子不是障碍;3、不能来回走,从某个点走出来的,不能遍历四个方向造成走回去;
                int len = dfs(grids, new int[]{nextX, nextY}, end, tmpSet);
                System.out.printf("start to end:%d, %d; %d, %d. -- %d.\n", nextX, nextY, end[0], end[1], len);
                minLen = Math.min(len, minLen);
            }
        }
        return minLen + 1;
    }
    

    // 方格的bfs;
    public int bfs(int[][] grids, int[] start, int[] end) {
    // 写是否已经访问的状态;
    int[][] state = new int[grids.length][grids[0].length];
    Queue queue = new LinkedList();
    // 注意:若要打印最短路径,必须将历史信息塞入队列;
    queue.offer(start);
    state[start[0]][start[1]] = 1;
    int count = 0;
    while (!queue.isEmpty()) {
    count++;
    int size = queue.size();
    for (int inx = 0; inx < size; inx++) {
    int[] node = (int[]) queue.poll();
    // 当扩散到终点就拉出来;注意:若要打印最短路径,到达终点时可以拉出来;
    if (node[0] == end[0] && node[1] == end[1]) {
    // 起点塞进来已经加1,故要减去;
    return count - 1;
    }
    for (int[] item : direct) {
    int nextX = node[0] + item[0];
    int nextY = node[1] + item[1];
    if (nextX >= 0 && nextX <= grids.length - 1
    && nextY >= 0 && nextY <= grids[0].length - 1
    && grids[nextX][nextY] != 1 && state[nextX][nextY] != 1) {
    queue.offer(new int[]{nextX, nextY});
    state[nextX][nextY] = 1;
    }
    }
    }
    }
    return -1;
    }

    public int getMinLen(Map<String, List<String>> relMap, Map<List<String>, Integer> valueMap) {
        Map<String, Integer> pathMap = new HashMap<>();
        pathMap.put("a", 0);
        Queue queue = new LinkedList();
        queue.offer("a");
        while (!queue.isEmpty()) {
            String curNode = (String) queue.poll();
            if (curNode.equals("e")){
                break;
            }
            for (String subNode : relMap.get(curNode)) {
                List<String> key = Arrays.asList(curNode, subNode);
                if (null == pathMap.get(subNode)) {
                    pathMap.put(subNode, pathMap.get(curNode) + valueMap.get(key));
                } else {
                    Integer len = pathMap.get(subNode);
                    pathMap.put(subNode, Math.min(len, pathMap.get(curNode) + valueMap.get(key)));
                }
                queue.offer(subNode);
            }
        }
        return pathMap.get("e");
    }
    

    }

    Main.java
    import robot.Solution;

    import java.util.*;

    public class Main {
    public static void main(String[] args){
    int[][] grids = {
    {0, 0, 1, 0},
    {0, 1, 0, 0},
    {0, 0, 0, 0},
    {0, 0, 0, 0}
    };
    int[] start = {0, 0};
    int[] end = {2, 3};
    Set<List> flag = new HashSet<>();
    System.out.println(new Solution().dfs(grids, start, end, flag));
    System.out.println(new Solution().bfs(grids, start, end));

        /**
         * 图:
         * a -> b  权值:4
         * a -> c  权值:8
         * b -> d  权值:10
         * c -> d  权值:2
         * c -> e  权值:1
         * d -> e  权值:15
         */
        // 也可以自己用邻接矩阵;
        Map<String, List<String>> relMap = new HashMap<>();
        relMap.put("a", Arrays.asList("b", "c"));
        relMap.put("b", Arrays.asList("d"));
        relMap.put("c", Arrays.asList("d", "e"));
        relMap.put("d", Arrays.asList("e"));
    
        Map<List<String>, Integer> valueMap = new HashMap<>();
        valueMap.put(Arrays.asList("a", "b"), 4);
        valueMap.put(Arrays.asList("a", "c"), 8);
        valueMap.put(Arrays.asList("b", "d"), 10);
        valueMap.put(Arrays.asList("c", "d"), 2);
        valueMap.put(Arrays.asList("c", "e"), 1);
        valueMap.put(Arrays.asList("d", "e"), 15);
    
        System.out.println(new Solution().getMinLen(relMap, valueMap));
    }
    

    }

    结果:
    5
    5
    9

    展开全文
  • 机器人走迷宫 迷宫由 N W S E 组成 踩到N向上走一格 踩到W 向左走一格 踩到S向下走一格 踩到E 向右走一格 输入迷宫行数 列数 不大于10 机器人初始列数(注意 这个列数是从1开始数的) 判断能否走出迷宫。能走出输出...
  • 标题:机器人走迷宫破壁解法(适用于走迷宫、最短路径算法)-20200412 问题描述: 一块矩形方格,含有障碍和可通行格子,求从某一点到另外一点的最短距离?N*M的矩阵; 其中,1代表障碍,0代表可通行;示例:给定二...

    标题:机器人走迷宫破壁解法(适用于走迷宫、最短路径算法)-20200412
    问题描述:

    1. 一块矩形方格,含有障碍和可通行格子,求从某一点到另外一点的最短距离?N*M的矩阵;
      其中,1代表障碍,0代表可通行;示例:给定二维矩阵
      0 0 1 0
      0 1 0 0
      0 0 0 0
      0 0 0 0

    出发点坐标[0, 0],终点坐标[0, 3];
    假如最多有一次破障碍格子的机会,java编写int solve(int[][] grids, int[] start, int[] end)返回最短距离;BFS

    思路:
    (1)当然可用dfs深度优先遍历;但是,有没有BFS呢?
    dfs的特点:找到每条完整路径再返回,不到黄河心不死;
    bfs:尽量扩散,看是否能走到终点;
    (2)考虑BFS,每次按层遍历,在破壁和不破壁的情况下,最远可以走多远;已经破壁则不能再破壁了;
    (3)那么有人问?到底何时破壁呢?尽早破壁,尽快扩散;基于扩散的点再次扩散;尽早到达最远;
    例如:
    0 0 1 0
    0 1 0 0
    0 0 0 0
    0 0 0 0
    第一层壁不破,更待何时?破除四周的障碍,谁最早到达外层,谁就获胜。因为各自距离是相等的,是无权图。
    第一步:[0, 0]的下一层点集:[0, 1],[1, 0];这是在破壁和不破壁达到的最远点;
    第二步:基于[0, 1],[1, 0],最多可以扩散哪些点?同样,找破壁和不破壁到达节点的并集;已经访问过的就不要再访问了。
    [0, 1]可以访问的点:破壁的才能访问,同时记录状态:已经破壁一次。[0, 2],[1, 1];
    [1, 0]可以访问的[2,0];不破壁的情况下可以访问。
    并集:[0, 2],[1, 1],[2,0];前两个是破壁一次访问的,后一个是非破壁访问的。
    第三步:
    [0, 2]可达[0, 3];其实就是终点,直接可达return;
    [1, 1],[2,0]:不用看了;
    下面看bfs解法;

    dfs思路:
    (1)[0, 0]到[0, 3]的距离最短,[0,0]等价于相邻点[0, 1],[1, 0]分别到终点的距离最小值,再加上邻近的1;对于是否破壁求分支;
    dfs([0,0],[0,3])等价于:
    min(dfs([0,1],[0,3],破壁),dfs([0,1],[0,3],未用破壁), dfs([1,0],[0,3],破壁),dfs([1,0],[0,3],未破壁));
    不需要破壁时就不用;考虑破壁与否和四个方向求最小值;遍历次数太多;

    更复杂场景,若给多次机会,如何解呢?亦是尽早破壁,走得最远;

    package robot;

    import java.util.LinkedList;
    import java.util.Queue;

    public class SolutionUpdate {
    int[][] direct = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    // 方格的bfs;
    public int bfs(int[][] grids, int[] start, int[] end) {
        // 写是否已经访问的状态;
        int[][] state = new int[grids.length][grids[0].length];
        Queue queue = new LinkedList();
        // 入队时标记是否破壁。0:未使用;1:已使用;
        state[start[0]][start[1]] = 1;
        queue.offer(new int[]{start[0], start[1], 0});
        int count = 0;
        while (!queue.isEmpty()) {
            // 扩散开始
            count++;
            // 每次要把扩散一次的节点全部拿出来,才能进行下一步扩散;
            System.out.println("queue size is:" + queue.size());
            int size = queue.size();
            for (int inx = 0; inx < size; inx++) {
                int[] node = (int[]) queue.poll();
                // 当扩散到终点就拉出来;注意:若要打印最短路径,到达终点时可以拉出来;
                if (node[0] == end[0] && node[1] == end[1]) {
                    // 起点塞进来已经加1,故要减去;
                    return count - 1;
                }
                for (int[] item : direct) {
                    int nextX = node[0] + item[0];
                    int nextY = node[1] + item[1];
                    if (nextX >= 0 && nextX <= grids.length - 1
                            && nextY >= 0 && nextY <= grids[0].length - 1
                            && state[nextX][nextY] != 1) {
                        System.out.println("queue size: " + queue.size()+"--;" +node[0] + "," + node[1] + ";" + "--:" + nextX + "," + nextY + "");
                        if (node[2] == 0 && grids[nextX][nextY] == 0) {
                            // 不用破壁
                            queue.offer(new int[]{nextX, nextY, 0});
                            state[nextX][nextY] = 1;
                        } else if (node[2] == 0 && grids[nextX][nextY] == 1) {
                            // 使用破壁
                            queue.offer(new int[]{nextX, nextY, 1});
                            state[nextX][nextY] = 1;
                        } else if (node[2] == 1 && grids[nextX][nextY] == 0) {
                            // 不能再使用破壁;乖乖地按常理走吧。
                            queue.offer(new int[]{nextX, nextY, 0});
                            state[nextX][nextY] = 1;
                        } else {
                            // node[2] == 1 && grids[nextX][nextY] == 1
                            // 不能走
                            state[nextX][nextY] = 1;
                        }
                    }
                }
            }
            System.out.println("----------");
        }
        return -1;
    }
    

    }

    测试类:
    int[][] grids = {
    {0, 0, 1, 0},
    {0, 1, 0, 0},
    {0, 0, 0, 0},
    {0, 0, 0, 0}
    };
    int[] start = {0, 0};
    int[] end = {0, 3};
    结果:
    3

    展开全文
  • #资源达人分享计划#
  • 机器人走迷宫-BFS 题目描述:给一个矩阵,0代表可走位置,1代表障碍物 给定起点和终点和行走规则(上、下、左、右),输出最短路径 探寻最短路径—BFS 首先定义两个辅助函数,valid_actions()和robot_move(): ...

    机器人走迷宫-BFS

    • 题目描述:给一个矩阵,0代表可走位置,1代表障碍物
      在这里插入图片描述
    • 给定起点和终点和行走规则(上、下、左、右),输出最短路径

    探寻最短路径—BFS

    首先定义两个辅助函数,valid_actions()和robot_move():

    • valid_actions():相当于动态规划中智能体的策略(policy)p(a|x)
    • 输入:环境矩阵,当前位置
    • 输出:所有可行动作['up', 'right', 'down', 'left']
    def valid_actions(matrix, cur_point):
        re = []
        rows = len(matrix)
        cols = len(matrix[0])
        if cur_point[1]+1 < cols and matrix[cur_point[0]][cur_point[1]+1] != 1:
            re.append('right')
        if cur_point[0] + 1 < rows and matrix[cur_point[0]+1][cur_point[1]] != 1:
            re.append('down')
        if cur_point[1]-1 >=0 and matrix[cur_point[0]][cur_point[1]-1] != 1:
            re.append('left')
        if cur_point[0]-1 >=0 and matrix[cur_point[0]-1][cur_point[1]] !=1:
            re.append('up')
        return re
    
    • robot_move(): 相当于动态规划中环境的模型(dynamic)p(x_t+1|x_t, a)
    • 输入:当前位置,动作
    • 输出:下一位置
    def robot_move(cur_point, action):
        if action == 'right':
            return (cur_point[0], cur_point[1]+1)
        if action == 'down':
            return (cur_point[0]+1, cur_point[1])
        if action == 'left':
            return (cur_point[0], cur_point[1]-1)
        if action == 'up':
            return (cur_point[0]-1, cur_point[1])
    

    使用BFS探寻最短路径

    • 队列实现:
    • tips:
      • 这里为了记录走过的路径,入队的时候将当前走过的路径和当前位置一同入队。
      • 由于寻找最短路径,因此机器人不能走重复的位置,因此每走过一个点,就修改matrix的对应位置为1
    def main(matrix, start_point, end_point):
        queue = []
        cur_point = start_point
        queue.append((cur_point, [start_point]))
        matrix[cur_point[0]][cur_point[1]] = 1
        while queue:
            cur_point, cur_path = queue.pop(0)
            if cur_point == end_point:
                return cur_path
            else:
                acts = valid_actions(matrix, cur_point)
                if acts: # 如果有路可走
                    for a in acts:
                        next_point = robot_move(cur_point, a)
                        queue.append((next_point, cur_path + [next_point]))  # 将(点的位置)和(当前路径+该点位置)一同入队
                        matrix[next_point[0]][next_point[1]] = 1             # 修改对应位置为走过的点
    

    测试:

    if __name__ == '__main__':
        Matrix = [[0,0,0,1,0],
                  [0,1,0,0,0],
                  [0,1,0,1,1],
                  [0,0,0,0,0]]
        start_point = (0, 0)
        end_point = (0, 4)
    
        shortest_path = main(Matrix, start_point, end_point)
        print(shortest_path)
    
    • 输出:
      在这里插入图片描述
      在这里插入图片描述

    附完整代码:

    def valid_actions(matrix, cur_point):
        re = []
        rows = len(matrix)
        cols = len(matrix[0])
        if cur_point[1]+1 < cols and matrix[cur_point[0]][cur_point[1]+1] != 1:
            re.append('right')
        if cur_point[0] + 1 < rows and matrix[cur_point[0]+1][cur_point[1]] != 1:
            re.append('down')
        if cur_point[1]-1 >=0 and matrix[cur_point[0]][cur_point[1]-1] != 1:
            re.append('left')
        if cur_point[0]-1 >=0 and matrix[cur_point[0]-1][cur_point[1]] !=1:
            re.append('up')
        return re
    def robot_move(cur_point, action):
        if action == 'right':
            return (cur_point[0], cur_point[1]+1)
        if action == 'down':
            return (cur_point[0]+1, cur_point[1])
        if action == 'left':
            return (cur_point[0], cur_point[1]-1)
        if action == 'up':
            return (cur_point[0]-1, cur_point[1])
    def main(matrix, start_point, end_point):
        queue = []
        cur_point = start_point
        queue.append((cur_point, [start_point]))
        matrix[cur_point[0]][cur_point[1]] = 1
        while queue:
            cur_point, cur_path = queue.pop(0)
            if cur_point == end_point:
                return cur_path
            else:
                acts = valid_actions(matrix, cur_point)
                if acts: # 如果有路可走
                    for a in acts:
                        next_point = robot_move(cur_point, a)
                        queue.append((next_point, cur_path + [next_point]))
                        matrix[next_point[0]][next_point[1]] = 1
    if __name__ == '__main__':
        Matrix = [[0,0,0,1,0],
                  [0,1,0,0,0],
                  [0,1,0,1,1],
                  [0,0,0,0,0]]
        start_point = (0, 0)
        end_point = (0, 4)
        shortest_path = main(Matrix, start_point, end_point)
        print(shortest_path)
    
    展开全文
  • 机器人走迷宫 题目来源: http://www.pipioj.online/problem.php?id=1021. 题目描述 有一个愚蠢的机器人走进一个w*h的迷宫,迷宫里有空地和陷阱。他想要访问迷宫的每个方格,但是它很笨,只会按照指令的方向走。当...

    2017年中南大学复试机试题解

    机器人走迷宫

    题目来源: http://www.pipioj.online/problem.php?id=1021.
    题目描述
    有一个愚蠢的机器人走进一个w*h的迷宫,迷宫里有空地和陷阱。他想要访问迷宫的每个方格,但是它很笨,只会按照指令的方向走。当机器人不能走的时候,也就是下一步会遇到陷阱、迷宫边界或者访问过的格子,它会向右转90度(顺时针旋转90度,不能访问已经访问过的方格,且在原地只转一次,移动后可获得又一次旋转机会)。请问这个机器人最多可以经过多少个方格。
    例如:
    5 5
    R****
    *****
    *****
    *****
    *****
    机器人可以经过25个格子,但是
    2 3
    **L
    ***
    机器人只能经过3个格子。

    输入
    对于每组数据,第一行两个数w和h,表示迷宫的行和列(1<=w,h<=10)
    接下来w行每行有h个字符用于描述这个迷宫。迷宫的‘.’表示空地,即为可以走的地方。‘*’表示陷阱,即为不能走的地方。迷宫中有一个英文字母,表示机器人的出发点,字母只有’U’,’D’,’L’,’R’四种。分别表示机器人的初始指令是向上,向下,向左,向右。
    输出
    对于每组数据,输出一个整数,即机器人一共经过多少个方格。
    样例输入
    2 3
    U..
    .*.
    4 4
    R...
    .**.
    .**.
    ....
    样例输出
    4
    12

    #include<cstdio>
    #include<cstring>
    #include<string>
    #include<iostream>
    #include<cmath>
    #include<queue>
    using namespace std;
    
    int l[4]= {1,0,-1,0}; //down,left,up,right
    int r[4]= {0,-1,0,1};
    int main()
    {
        int x,y,pos,m,n,vis[20][20];
        string s[20];
        while(scanf("%d %d",&m,&n)!=EOF)
        {
            memset(vis,0,sizeof(vis));
            for(int i=0; i<m; i++) cin>>s[i];
            for(int i=0; i<m; i++)
            {
                for(int j=0; j<n; j++)
                {
                    if(s[i][j]=='D') {pos=0;x=i;y=j;break;}
                    if(s[i][j]=='L') {pos=1;x=i;y=j;break;}
                    if(s[i][j]=='U') {pos=2;x=i;y=j;break;}
                    if(s[i][j]=='R') {pos=3;x=i;y=j;break;}
                }
            }
            vis[x][y]=1;
            int cnt=0,ans=1;
            while(true)
            {
                int xx=x+l[pos];
                int yy=y+r[pos];
                if(xx>=0&&xx<m&&yy>=0&&yy<n&&s[xx][yy]=='.'&&vis[xx][yy]==0)
                {
                    ans+=1;
                    x=xx;
                    y=yy;
                    cnt=0;
                    vis[x][y]=1;
                }
                else if(cnt==0){
                    pos=(pos+1+4)%4;
                    cnt++;
                }
                else break;
            }
            printf("%d\n",ans);
        }
        return 0;
    }
    
    
    展开全文
  • 1021: 机器人走迷宫 时间限制:1 Sec内存限制:128 MB 题目描述 有一个愚蠢的机器人走进一个w*h的迷宫,迷宫里有空地和陷阱。他想要访问迷宫的每个方格,但是它很笨,只会按照指令的方向走。当机器人不能走的时候,...
  • 1021: 机器人走迷宫

    2020-04-10 15:02:55
    机器人不能的时候,也就是下一步会遇到陷阱、迷宫边界或者访问过的格子,它会向右转90度(顺时针旋转90度,不能访问已经访问过的方格,且在原地只转一次,移动后可获得又一次旋转机会)。请问这个机器人最多可以...
  • 机器人走迷宫 Time Limit: 1000MS Memory limit: 32768K 题目描述 迷宫对大家来说肯定是很熟悉的东西了,多数人都知道要想走出迷宫,在里面乱猜肯定是不行的,比较好的方法是贴着墙的一侧走,比如只贴着...
  • 1021: 机器人走迷宫 时间限制: 1 Sec内存限制: 128 MB提交: 339解决: 71[提交] [状态] [讨论版] [命题人:外部导入] 题目描述 有一个愚蠢的机器人走进一个w*h的迷宫,...
  • 这本是课程的一个作业研究搜索算法,当时研究了一下Tkinter,然后写了个很简单的机器人走迷宫的界面,并且使用了各种搜索算法来进行搜索,如下图: 使用A*寻找最优路径: 由于时间关系,不分析了,我自己贴代码...
  • #资源达人分享计划#
  • 用VC++实现的一个人工智能算法,使用遗传算法来帮助机器人决策迷宫
  • 1010: 机器人走迷宫

    千次阅读 2018-10-13 13:31:49
    实现代码: #include &lt;iostream&gt; #include &lt;stdio.h&gt; #include &lt;string.h&gt; #include &lt;algorithm&gt; #include &.../* run this pro...
  • 针对智能机器人所走迷宫的尺寸与迷宫格的多少,通过ARM控制机器人步进电机的步进角度及转动状态结合红外传感器的检测信号,通过智能算法的设计改变传统的搜索过程使搜索整个迷宫变为搜索到终点即停止搜索,以最大...
  • 机器人走一个迷宫,给出迷宫的x和y(x*y的迷宫)并且迷宫中有障碍物,输入k表示障碍物有k个,并且会将障碍物的坐标挨个输入. 机器人从0,0的位置走到x,y的位置并且只能向x,y增加的方向走,不能回退. 如代码类注释展示的样子...
  • 机器人走迷宫问题

    千次阅读 2014-09-21 09:40:03
    原题:http://www.acmerblog.com/taobao-1246.html 原题是广搜 下面是自己写的深搜:

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,501
精华内容 600
关键字:

机器人走迷宫