[LeetCode]874. 模拟行走机器人

机器人在一个无限大小的 XY 网格平面上行走，从点 (0, 0) 处开始出发，面向北方。该机器人可以接收以下三种类型的命令 commands ：

-2 ：向左转 90 度
-1 ：向右转 90 度
1 <= x <= 9 ：向前移动 x 个单位长度
在网格上有一些格子被视为障碍物 obstacles 。第 i 个障碍物位于网格点  obstacles[i] = (xi, yi) 。

机器人无法走到障碍物上，它将会停留在障碍物的前一个网格方块上，但仍然可以继续尝试进行该路线的其余部分。

返回从原点到机器人所有经过的路径点（坐标为整数）的最大欧式距离的平方。（即，如果距离为 5 ，则返回 25 ）

 
注意：

北表示 +Y 方向。
东表示 +X 方向。
南表示 -Y 方向。
西表示 -X 方向。
 

示例 1：

输入：commands = [4,-1,3], obstacles = []
输出：25
解释：
机器人开始位于 (0, 0)：
1. 向北移动 4 个单位，到达 (0, 4)
2. 右转
3. 向东移动 3 个单位，到达 (3, 4)
距离原点最远的是 (3, 4) ，距离为 32 + 42 = 25
示例 2：

输入：commands = [4,-1,4,-2,4], obstacles = [[2,4]]
输出：65
解释：机器人开始位于 (0, 0)：
1. 向北移动 4 个单位，到达 (0, 4)
2. 右转
3. 向东移动 1 个单位，然后被位于 (2, 4) 的障碍物阻挡，机器人停在 (1, 4)
4. 左转
5. 向北走 4 个单位，到达 (1, 8)
距离原点最远的是 (1, 8) ，距离为 12 + 82 = 65
 

提示：

1 <= commands.length <= 104
commands[i] is one of the values in the list [-2,-1,1,2,3,4,5,6,7,8,9].
0 <= obstacles.length <= 104
-3 * 104 <= xi, yi <= 3 * 104
答案保证小于 231

这是道简单的题，我用的数据结构要多些，这道题也有些意思。感觉，做游戏应该会经常用到

A了很久，一直不对，没注意题目是说最大欧拉距离，注意最大，不是最终的位置。

    public int robotSim(int[] commands, int[][] obstacles) {
        if (commands == null || obstacles == null)
            return 0;
        XYPosition position = new XYPosition(0, 1);
        int x = 0;
        int y = 0;
        int res = 0;
        for (int index = 0; index < commands.length; index++) {
            int command = commands[index];
            if (command < 0)
                caculatePosition(position, command);
            else {
                if (position.xFlag != 0) {
                    for (int i = 0; i < Math.abs(command); i++) {
                        int next = x + position.xFlag;
                        if (isObstacles(next, y, obstacles))
                            break;
                        x = next;
                    } // for
                } else {
                    for (int i = 0; i < Math.abs(command); i++) {
                        int next = y + position.yFlag;
                        if (isObstacles(x, next, obstacles))
                            break;
                        y = next;
                    }
                } //else
            } //else
            res = Math.max(res, x * x + y * y);
        }
        return res;
    }

    private boolean isObstacles (int x, int y, int[][] obstacles) {
        for (int i = 0; i < obstacles.length; i++) {
            if (obstacles[i][0] == x && obstacles[i][1] == y)
                return true;
        }
        return false;
    }

    private void caculatePosition(XYPosition position, int command) {
        // east
        if (position.xFlag == 1 && position.yFlag == 0) {
            // turn left
            if (command == -2) {
                position.yFlag = 1;
            } else {
                // turn right
                position.yFlag = -1;
            }
            position.xFlag = 0;
        } else if (position.xFlag == 0 && position.yFlag == -1) {
            // south
            // turn left
            if (command == -2) {
                position.xFlag = 1;
            } else {
                position.xFlag = -1;
            }
            position.yFlag = 0;
        } else if (position.xFlag == -1 && position.yFlag == 0) {
            // west
            // turn left
            if (command == -2) {
                position.yFlag = -1;
            } else {
                position.yFlag = 1;
            }
            position.xFlag = 0;
        } else if (position.xFlag == 0 && position.yFlag == 1) {
            // north
            // turn left
            if (command == -2) {
                position.xFlag = -1;
            } else {
                position.xFlag = 1;
            }
            position.yFlag = 0;
        }
    }

    class XYPosition {
        public int xFlag;
        public int yFlag;

        public XYPosition(int xFlag, int yFlag) {
            this.xFlag = xFlag;
            this.yFlag = yFlag;
        }
    }