每日力扣-贪心-机器人走路

机器人在一个无限大小的 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

解题思路：最难的地方就是怎么转向和存储障碍物。 dx[]dy[] 的下标 i 代表了当前机器人的方向 i=0,向北 i=1,向东 i=2,向南 i=3,向西 当读取到调整方向的指令时，如 "-1"：“向右转90度”，只要当前方向curdire + 1就可以得到右转方向 "-2"：“向左转90度”，只要当前方向curdire + 3 就可以得到左转方向 (curdire + 3) % 4， 因为不管curdire当前是哪个方向，左转都在其左边，在direx数组的定义中顺势针数3个就是其左边，所以就是加3

解决了方向问题，那机器人走一步算一次最大距离，如果遇到障碍物就break跳出这次走路命令停在障碍物前。

class Solution {
public:
    int robotSim(vector<int>& commands, vector<vector<int>>& obstacles) {
        int dx[4] = {0 , 1 , 0 , -1};
        int dy[4] = {1 , 0 , -1 , 0};
        int x = 0 , y = 0 , re = 0 ,ans = 0;
        unordered_set<pair<int, int>, pair_hash> obstacleSet;
        for (vector<int> obstacle: obstacles)
            obstacleSet.insert(make_pair(obstacle[0], obstacle[1]));
        for(int i = 0 ; i < commands.size() ; i++)
        {
            if(commands[i] == -2)
            {
                re = (re + 3) % 4;
            }
            else if(commands[i] == -1)
            {
                re = (re + 1) % 4;
            }
            else
            {
                for(int j = 0 ; j < commands[i] ; j++)
                {
                    int nx = x + dx[re];
                    int ny = y + dy[re];
                    if(obstacleSet.find(make_pair(nx,ny)) == obstacleSet.end())
                    {
                        x = nx;
                        y = ny;
                        ans = max(ans , x*x + y*y);
                    }
                    else break;
                }
            }
        }
        return ans;
    }
private:
    struct pair_hash
    {
        template <class T1, class T2>
        std::size_t operator () (std::pair<T1, T2> const &pair) const
        {
            std::size_t h1 = std::hash<T1>()(pair.first);
            std::size_t h2 = std::hash<T2>()(pair.second);
    
            return h1 ^ h2;
        }
    };
};