模拟行走机器人

class Solution {
    public int robotSim(int[] commands, int[][] obstacles) {
        int[] pos = new int[]{0, 0};
        int[][] dirs = {{0, 1}, {1, 0}, {0, -1},{-1, 0}};
        int index = 0;
        Map<Integer, Set<Integer>> map = new HashMap<>();
        for (int[] obstacle : obstacles) {
            Set<Integer> set = map.getOrDefault(obstacle[0], new HashSet<>());
            set.add(obstacle[1]);
            map.put(obstacle[0], set);
        }
        int ans = 0;
        for (int i = 0; i < commands.length; i++) {
            if (commands[i] == -1) {
                index = (index + 1) % 4;
            } else if (commands[i] == -2){
                index = (index - 1 + 4) % 4;
            } else {
                int[] dir = dirs[index];
                int x = pos[0];
                int y = pos[1];
                int command = commands[i];
                for (int j = 0; j < command; j++) {
                    x += dir[0];
                    y += dir[1];
                    if (map.getOrDefault(x, new HashSet<>()).contains(y)) {
                        x -= dir[0];
                        y -= dir[1];
                        break;
                    }
                }
                pos[0] = x;
                pos[1] = y;
                int temp = (int) (Math.pow(pos[0], 2) + Math.pow(pos[1], 2));
                ans = Math.max(ans, temp);
            }
            // System.out.println(pos[0] + "   " + pos[1] + "  " + index);
        }
        return ans;
    }
}

二进制矩阵中的最短路径

class Solution {
    public int shortestPathBinaryMatrix(int[][] grid) {
        Deque<int[]> queue = new ArrayDeque<>();
        int m = grid.length;
        int n = grid[0].length;
        boolean[][] visited = new boolean[m][n]; 
        int[][] dirs = {{-1, -1}, {1, 1}, {0, 1}, {0, -1}, {-1, 0}, {1, 0}, {-1, 1}, {1, -1}};
        if (grid[0][0] == 0) {
            queue.offer(new int[]{0, 0});
            visited[0][0] = true;
            int i = 1;
            while (!queue.isEmpty()) {
                int size = queue.size();
                while (size-- > 0) {
                    int[] g = queue.poll();
                    if (g[0] == m - 1 && g[1] == n - 1 && grid[g[0]][g[1]] == 0) {
                        return i;
                    }
                    for (int[] dir : dirs) {
                        int x = g[0];
                        int y = g[1];
                        x += dir[0];
                        y += dir[1];
                        if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 0 && !visited[x][y]) {
                            visited[x][y] = true;
                            queue.offer(new int[]{x, y});
                        }
                    }
                }
                ++i;
            }
        }
        return -1;
    }
}