【LeetCode 算法】Walking Robot Simulation 模拟行走机器人 - 二分

Walking Robot Simulation 模拟行走机器人

问题描述：

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

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

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

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

$$\begin{gathered} 1<=commands.length<=10^4 \\ commands[i]isoneofthevaluesinthelist[-2,-1,1,2,3,4,5,6,7,8,9] \\ 0<=obstacles.length<=10^4 \\ -3\ast 10^4<=xi,yi<=3\ast 10^4 \\ 答案保证小于2^{31} \end{gathered}$$

分析

模拟问题属于看上去很简单，但是做起来处处是坑。

这个问题中，可以移动的范围可以看做是一个二维直角坐标系。起始点是原点[0,0],这个移动范围是不受边界限制的，它不同于一般的矩阵，有行列大小限制。

加速可以使用二分

当然也可以使用二分，在移动的过程中使用二分来快速判断是否会遇到obstacle，整体时间复杂度$O(N+M\ast ClogX)$

代码

二分

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\ast ClogX)$

空间复杂度$O(M)$

Tag

Array

Simulation