无限网格上的机器人从点 (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) 处
提示:
0 <= commands.length <= 10000
0 <= obstacles.length <= 10000
-30000 <= obstacle[i][0] <= 30000
-30000 <= obstacle[i][1] <= 30000
- 答案保证小于
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;
}
};