力扣LCP3机器人大冒险

力扣团队买了一个可编程机器人，机器人初始位置在原点(0, 0)。小伙伴事先给机器人输入一串指令command，机器人就会无限循环这条指令的步骤进行移动。指令有两种：
U: 向y轴正方向移动一格
R: 向x轴正方向移动一格。
不幸的是，在 xy 平面上还有一些障碍物，他们的坐标用obstacles表示。机器人一旦碰到障碍物就会被损毁。
给定终点坐标(x, y)，返回机器人能否完好地到达终点。如果能，返回true；否则返回false。
示例 1：
输入：command = "URR", obstacles = [], x = 3, y = 2
输出：true
解释：U(0, 1) -> R(1, 1) -> R(2, 1) -> U(2, 2) -> R(3, 2)。
示例 2：
输入：command = "URR", obstacles = [[2, 2]], x = 3, y = 2
输出：false
解释：机器人在到达终点前会碰到(2, 2)的障碍物。
示例 3：
输入：command = "URR", obstacles = [[4, 2]], x = 3, y = 2
输出：true
解释：到达终点后，再碰到障碍物也不影响返回结果。
限制：
2 <= command的长度 <= 1000
command由U，R构成，且至少有一个U，至少有一个R
0 <= x <= 1e9, 0 <= y <= 1e9
0 <= obstacles的长度 <= 1000
obstacles[i]不为原点或者终点

待会的代码由两部分组成：
最前面的一个robot2方法效果较好，无论对于数据量过大的还是其他的情况，效果都还可以忍受，它的思路是将障碍物位置转化为目的地，因为有些障碍物根本无法到达，所以我们可以很轻松的排除掉一些，其次由于障碍物的数量总是有限的，不值当我们每走一步路就去判断是否撞上了，这样就会减少很多时间。我们将所有障碍物遍历完后，若是能到达障碍物则说明会碰撞上。否则，再遍历真正目的地若是能到达则返回真，不能到达返回假
后面的robot方法是每走一步路就对其是否碰撞进行检测，说实话效果在数据量比较大的时候不是很好。诸君且看吧

package medium;

import java.util.Arrays;

public class robottest {
	//换一个思路，把每个障碍物，看作是目的地，看看其能否到达
	  public boolean robot2(String command, int[][] obstacles, int x, int y) {
		  boolean flag=false;
		  for(int i=0;i<obstacles.length;i++){
              int i1= obstacles[i][0];
              int i2= obstacles[i][1];
              if(i1<=x&&i2<=y)
			      flag=isAcess(command,i1,i2);
              
			  if(flag==true)
				  return false;
		  }
		      flag=isAcess(command, x, y);
	
			  return flag;

	    }
	  public boolean isAcess(String command,int x,int y){
		   int xNum=0;
		   int yNum=0;
		   int[] position=new int[2];
		   while(xNum!=x||yNum!=y){
			   for(int i=0;i<command.length()&&(position[0]!=x||position[1]!=y);i++){
				   char c=command.charAt(i);
				   if(c=='U')
					   position[1]=position[1]+1;
				   else if(c=='R')
					   position[0]=position[0]+1;
			   }
			   xNum=position[0];
			   yNum=position[1];
			   if(xNum>x&&yNum>y)
				   return false;
		   }
		  if(position[0]==x&&position[1]==y){
			  return true;
		  }
		   
		   return false;
	  }



	//对于大数据量效果不好的算法
	   public boolean robot(String command, int[][] obstacles, int x, int y) {
		   int xNum=0;
		   int yNum=0;
		   boolean flag=false;
		   int[] position=new int[2];
	
		   
		   while(xNum!=x&&yNum!=y){
			   for(int i=0;i<command.length()&&(position[0]!=x||position[1]!=y);i++){
				   char c=command.charAt(i);
				   if(c=='U')
					   position[1]=position[1]+1;
				   else if(c=='R')
					   position[0]=position[0]+1;
				   flag=obstacles.length>0?isBone(position,obstacles):false;
				   
				   if(flag)
					   return false;
			   }
			   obstacles=obstacles.length>0?Haveob(obstacles):obstacles;
			   xNum=position[0];
			   yNum=position[1];
			   if(xNum>x&&yNum>y)
				   return false;
		   }
		  if(position[0]==x&&position[1]==y){
			  return true;
		  }
		   
		   return false;

	    }
	private int[][] Haveob(int[][] obstacles) {
		int j=0;
		for(int i=0;i<obstacles.length;i++){
			if(obstacles[i][0]!=-1)
				j++;
		}
		int[][] re=new int[j][2];
		int k=0;
		for(int i=0;i<obstacles.length;i++){
			if(obstacles[i][0]!=-1)
				{
				 re[k][0]=obstacles[i][0];
				 re[k][1]=obstacles[i][1];
				   k++;
				}
		}
		return re;
	}
	private boolean isBone(int[] position, int[][] obstacles) {
		boolean flag=false;
		for(int i=0;i<obstacles.length;i++){
			if(obstacles[i][0]==position[0]&&obstacles[i][1]==position[1])
			{
				flag=true;
				break;
			}
			if(obstacles[i][0]<position[0]||obstacles[i][1]<position[1])
			{
				obstacles[i][0]=-1;
				obstacles[i][1]=-1;
			}
		}
		return flag;
	}
	public static void main(String[] args) {
		robottest r=new robottest();
		String command="UUR";//"RUR";//"URR";"RUR"
	  int[] p={1,1};
	  int[][] s={};//{{9, 5}, {7, 5}, {6, 10}, {8, 9}, {4, 2}, {8, 3}, {3, 2}};//{3, 9}, {7, 1}, {10, 5}, {6, 3}, {4, 3}, {1, 0}, {6, 5}};//{{2,2}};
	 System.out.println(r.robot(command,s,1,4)); 
	 System.out.println(r.robot2(command,s,1,4));
	}

}