文章目录
Walking Robot Simulation 模拟行走机器人
问题描述：
机器人在一个无限大小的 XY 网格平面上行走，从点 (0, 0) 处开始出发，面向北方。该机器人可以接收以下三种类型的命令 commands ：
-2 ：向左转 90 度
-1 ：向右转 90 度
1 < = x < = 9 1 <= x <= 9 1<=x<=9 ：向前移动 x 个单位长度
在网格上有一些格子被视为障碍物 obstacles 。第 i 个障碍物位于网格点 o b s t a c l e s i = ( x i , y i ) obstaclesi = (x_i, y_i) obstaclesi=(xi,yi)。
机器人无法走到障碍物上，它将会停留在障碍物的前一个网格方块上，但仍然可以继续尝试进行该路线的其余部分。
返回从原点到机器人所有经过的路径点（坐标为整数）的最大欧式距离的平方。（即，如果距离为 5 ，则返回 25 ）
1 < = c o m m a n d s . l e n g t h < = 1 0 4 c o m m a n d s i i s o n e o f t h e v a l u e s i n t h e l i s t − 2 , − 1 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 0 < = o b s t a c l e s . l e n g t h < = 1 0 4 − 3 ∗ 1 0 4 < = x i , y i < = 3 ∗ 1 0 4 答案保证小于 2 31 1 <= commands.length <= 10^4\\ commandsi is one of the values in the list -2,-1,1,2,3,4,5,6,7,8,9\\ 0 <= obstacles.length <= 10^4\\ -3 * 10^4 <= xi, yi <= 3 * 10^4\\ 答案保证小于 2^{31} 1<=commands.length<=104commandsiisoneofthevaluesinthelist−2,−1,1,2,3,4,5,6,7,8,90<=obstacles.length<=104−3∗104<=xi,yi<=3∗104答案保证小于231
分析
模拟问题属于看上去很简单，但是做起来处处是坑。
这个问题中，可以移动的范围可以看做是一个二维直角坐标系。起始点是原点0,0,这个移动范围是不受边界限制的，它不同于一般的矩阵，有行列大小限制。
加速可以使用二分
当然也可以使用二分，在移动的过程中使用二分来快速判断是否会遇到obstacle，整体时间复杂度 O ( N + M ∗ C l o g X ) O(N+M*ClogX) O(N+M∗ClogX)
代码
二分
java
class Solution {
int INF = Integer.MAX_VALUE;
public int robotSim(int[] commands, int[][] obstacles) {
Map<Integer,List<Integer>> mapx = new HashMap();
Map<Integer,List<Integer>> mapy = new HashMap();
for(int [] obs :obstacles){
int x = obs[0],y = obs[1];
List<Integer> xlist = mapx.getOrDefault(x,new ArrayList());
List<Integer> ylist = mapy.getOrDefault(y,new ArrayList());
xlist.add(y);
ylist.add(x);
mapx.put(x,xlist);
mapy.put(y,ylist);
}
for(int k : mapx.keySet()){
List<Integer> list = mapx.get(k);
Collections.sort(list);
mapx.put(k,list);
}
for(int k : mapy.keySet()){
List<Integer> list = mapy.get(k);
Collections.sort(list);
mapy.put(k,list);
}
int d = 0; // direction
int[][] dir = new int[][]{{0,1},{1,0},{0,-1},{-1,0}};// N,E,S,W
int n = commands.length;
int idx = 0,cx = 0,cy = 0,ans=0;
while(idx<n){
int c = commands[idx];
if(c<0){
if(c==-2) d = (d+3)%4;
else d = (d+1)%4;
}
else{
int nx = cx+ dir[d][0]*c;
int ny = cy+ dir[d][1]*c;
int obs = INF;
if(d%2==0){
// N S
if(d==0){
if(mapx.containsKey(cx)){
obs = find1(mapx.get(cx),cy);
}
if(obs!=INF&&obs<=ny){
ny = obs-1;
}
}
else{
if(mapx.containsKey(cx)){
obs = find2(mapx.get(cx),cy);
}
if(obs!=INF&&obs>=ny){
ny = obs+1;
}
}
}
else{
// E W
if(d==1){
if(mapy.containsKey(cy)){
obs = find1(mapy.get(cy),cx);
}
if(obs!=INF&&obs<=nx){
nx = obs-1;
}
}
else{
if(mapy.containsKey(cy)){
obs = find2(mapy.get(cy),cx);
}
if(obs!=INF&&obs>=nx){
nx = obs+1;
}
}
}
int res = nx*nx + ny*ny;
ans = Math.max(ans,res);
cx = nx; cy = ny;
}
idx++;
}
return ans;
}
// find first > tar
public int find1(List<Integer> list,int tar){
if(list.size()==0
||list.get(list.size()-1)<tar) return INF;
if(list.get(0)>tar) return list.get(0);
int n = list.size();
// 0~n-1
int l = 0,r = n-1,mid = 0;
while(l<r){
mid = l+(r-l)/2;
if(list.get(mid)>tar) r = mid;
else l = mid+1;
}
return list.get(l)>tar?list.get(l):INF;
}
// find first < tar
public int find2(List<Integer> list,int tar){
if(list.size()==0
||list.get(0)>tar) return INF;
int n = list.size();
if(list.get(n-1)<tar) return list.get(n-1);
// 0~n-1
int l = 0,r = n-1,mid = 0;
while(l<r){
mid = l+(r-l+1)/2;
if(list.get(mid)>=tar) r = mid-1;
else l = mid;
}
return list.get(l)<tar?list.get(l):INF;
}
}时间复杂度 O ( N + M ∗ C l o g X ) O(N+M*ClogX) O(N+M∗ClogX)
空间复杂度 O ( M ) O(M) O(M)
Tag
Array
Simulation