public int shortestPathBinaryMatrix(int[][] grid) {
    if(grid == null || grid.length == 0) return -1;



    Queue<Point> queue =new LinkedList<>();
    int rowNum[] = {-1, 0, 0, 1, -1, -1, 1, 1};
    int colNum[] = {0, -1, 1, 0, -1, 1, 1, -1};


    int ROW = grid.length;
    int COL = grid[0].length;



    if(grid[0][0] == 1 || grid[ROW -1][COL - 1] == 1) {
      return -1;
    }
    int [][] distances = new int[ROW][COL];
    distances[0][0] = 1;
    boolean [][] visited = new boolean[ROW][COL];

    queue.offer(new Point(0, 0, 0));
    visited[0][0] = true;

    while(!queue.isEmpty()) {
      Point pt = queue.peek();
      if(pt.x == ROW -1 && pt.y == COL -1) {
        return pt.distance;
      }

      queue.poll();

      for(int i = 0; i < 8; i++) {
        int row = pt.x + rowNum[i];
        int col = pt.y + colNum[i];

        if(isValid(row, col, ROW, COL) && grid[row][col] != 1 && !visited[row][col]) {
          if(distances[row][col] < distances[pt.x][pt.y] + 1) {
            visited[row][col] = true;
            distances[row][col] = distances[pt.x][pt.y] + 1;
            Point adjPoint = new Point(row, col, distances[row][col]);
            queue.offer(adjPoint);
          }

        }
      }
    }

    return visited[ROW-1][COL-1] ? distances[ROW-1][COL-1] : -1;
    }

     private boolean isValid(int row, int col, int ROW, int COL) {
    return ((row >= 0) && (row < ROW) && (col >= 0) && (col < COL));

  }

    private class Point {
    int x;
    int y;
    int distance;

    public Point(int x, int y) {
      this.x = x;
      this.y = y;
    }

    public Point(int x, int y, int distance) {
      this.x = x;
      this.y = y;
      this.distance = distance;
    }
  }