行走机器人模拟(failed)

无限网格上的机器人从点 (0, 0) 处开始出发，面向北方。该机器人可以接收以下三种类型的命令：

• -2：向左转 90 度
• -1：向右转 90 度
• 1 <= x <= 9：向前移动 x 个单位长度

有一些网格方块被视作障碍物。 

第 i 个障碍物位于网格点  (obstacles[i][0], obstacles[i][1])

如果机器人试图走到障碍物上方，那么它将停留在障碍物的前一个网格方块上，但仍然可以继续该路线的其余部分。

返回从原点到机器人的最大欧式距离的平方。

示例 1：

输入: commands = [4,-1,3], obstacles = []
输出: 25
解释: 机器人将会到达 (3, 4)

示例 2：

输入: commands = [4,-1,4,-2,4], obstacles = [[2,4]]
输出: 65
解释: 机器人在左转走到 (1, 8) 之前将被困在 (1, 4) 处

提示：

1. 0 <= commands.length <= 10000
2. 0 <= obstacles.length <= 10000
3. -30000 <= obstacle[i][0] <= 30000
4. -30000 <= obstacle[i][1] <= 30000
5. 答案保证小于 2 ^ 31

正解

//排行榜第一的答案 by cuiaoxiang
typedef pair<int, int> ii;
const int d[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
class Solution {
public:
    int robotSim(vector<int>& commands, vector<vector<int>>& obstacles) {
        set<ii> A;
        for (auto& it : obstacles) {
            A.insert({it[0], it[1]});
        }
        int dir = 0, x = 0, y = 0;
        int ret = 0;
        for (auto& it : commands) {
            if (it == -2) {
                dir = (dir + 3) % 4;
            } else if (it == -1) {
                dir = (dir + 1) % 4;
            } else {
                for (int k = 0; k < it; ++k) {
                    int nx = x + d[dir][0];
                    int ny = y + d[dir][1];
                    if (A.count({nx, ny})) break;
                    x = nx;
                    y = ny;
                }
            }
//            cout << x << " " << y << " " << dir << endl;
            ret = max(ret, x * x + y * y);
        }
        return ret;
    }
};

我自己头铁想用“低级”方式 但是没有实力 于是就超时了 （思路还是有些借鉴了第一的dalao，一开始因为石头的问题折腾太久）

猜想正解应该就是一步一走+set迭代器对比

（这道题是Easy题 GG）

个人超时答案

class Solution {
public:
    enum{left, forward, right, backward};
    int robotSim(vector<int>& commands, vector<vector<int>>& obstacles)
    {
        int direction = 1, x = 0, y = 0, nx, ny;
        int ret = 0;
        bool flag = false;
        for(int i = 0; i < commands.size(); i++)
        {
            int asd = commands[i] ;

            if(asd == -1) 
                direction = (direction + 1) % 4;
            else if(asd == -2) 
                direction = (direction + 3) % 4;
            else
            {
                switch(direction)
                {
                    case forward:
                        ny = y;
                        for(int j = 0; j < asd; j++)
                        {
                            ny++;
                            for(int k = 0; k < obstacles.size(); k++)
                            {
                                if(x == obstacles[k][0] && ny == obstacles[k][1])
                                {
                                    flag = true;
                                    break;
                                }
                            }
                            if(flag) {flag = false; break;}
                            y++;
                        }
                        ret = max(ret, x*x + y*y);
                        break;
                    case backward:
                        ny = y;
                        for(int j = 0; j < asd; j++)
                        {
                            ny--;
                            for(int k = 0; k < obstacles.size(); k++)
                            {
                                if(x == obstacles[k][0] && ny == obstacles[k][1])
                                {
                                    flag = true;
                                    break;
                                }
                            }
                            if(flag) {flag = false; break;}
                            y--;
                        }
                        ret = max(ret, x*x + y*y);
                        break;
                    case right:
                        nx = x;
                        for(int j = 0; j < asd; j++)
                        {
                            nx++;
                            for(int k = 0; k < obstacles.size(); k++)
                            {
                                if(nx == obstacles[k][0] && y == obstacles[k][1])
                                {
                                    flag = true;
                                    break;
                                }
                            }
                            if(flag) {flag = false; break;}
                            x++;
                        }
                        ret = max(ret, x*x + y*y);
                        break;
                    case left:
                        nx = x;
                        for(int j = 0; j < asd; j++)
                        {
                            nx--;
                            for(int k = 0; k < obstacles.size(); k++)
                            {
                                if(nx == obstacles[k][0] && y == obstacles[k][1])
                                {
                                    flag = true;
                                    break;
                                }
                            }
                            if(flag) {flag = false; break;}
                            x--;
                        }
                        ret = max(ret, x*x + y*y);
                        break;
                }
            }
        }
        return ret;
    }
};