This is an **interactive problem**.

There is a robot in a hidden grid, and you are trying to get it from its starting cell to the target cell in this grid. The grid is of size `m x n`, and each cell in the grid is either empty or blocked. It is **guaranteed** that the starting cell and the target cell are different, and neither of them is blocked.

You want to find the minimum distance to the target cell. However, you **do not know** the grid's dimensions, the starting cell, nor the target cell. You are only allowed to ask queries to the `GridMaster` object.

Thr `GridMaster` class has the following functions:

*   `boolean canMove(char direction)` Returns `true` if the robot can move in that direction. Otherwise, it returns `false`.
*   `void move(char direction)` Moves the robot in that direction. If this move would move the robot to a blocked cell or off the grid, the move will be **ignored**, and the robot will remain in the same position.
*   `boolean isTarget()` Returns `true` if the robot is currently on the target cell. Otherwise, it returns `false`.

Note that `direction` in the above functions should be a character from `{'U','D','L','R'}`, representing the directions up, down, left, and right, respectively.

Return _the **minimum distance** between the robot's initial starting cell and the target cell. If there is no valid path between the cells, return_ `-1`.

**Custom testing:**

The test input is read as a 2D matrix `grid` of size `m x n` where:

*   `grid[i][j] == -1` indicates that the robot is in cell `(i, j)` (the starting cell).
*   `grid[i][j] == 0` indicates that the cell `(i, j)` is blocked.
*   `grid[i][j] == 1` indicates that the cell `(i, j)` is empty.
*   `grid[i][j] == 2` indicates that the cell `(i, j)` is the target cell.

There is exactly one `-1` and `2` in `grid`. Remember that you will **not** have this information in your code.

**Example 1:**

**Input:** grid = \[\[1,2\],\[-1,0\]\]
**Output:** 2
**Explanation:** One possible interaction is described below:
The robot is initially standing on cell (1, 0), denoted by the -1.
- master.canMove('U') returns true.
- master.canMove('D') returns false.
- master.canMove('L') returns false.
- master.canMove('R') returns false.
- master.move('U') moves the robot to the cell (0, 0).
- master.isTarget() returns false.
- master.canMove('U') returns false.
- master.canMove('D') returns true.
- master.canMove('L') returns false.
- master.canMove('R') returns true.
- master.move('R') moves the robot to the cell (0, 1).
- master.isTarget() returns true. 
We now know that the target is the cell (0, 1), and the shortest path to the target cell is 2.

**Example 2:**

**Input:** grid = \[\[0,0,-1\],\[1,1,1\],\[2,0,0\]\]
**Output:** 4
**Explanation:** The minimum distance between the robot and the target cell is 4.

**Example 3:**

**Input:** grid = \[\[-1,0\],\[0,2\]\]
**Output:** -1
**Explanation:** There is no path from the robot to the target cell.

**Constraints:**

*   `1 <= n, m <= 500`
*   `m == grid.length`
*   `n == grid[i].length`
*   `grid[i][j]` is either `-1`, `0`, `1`, or `2`.
*   There is **exactly one** `-1` in `grid`.
*   There is **exactly one** `2` in `grid`.

이것은 **대화형 문제**입니다.

숨겨진 격자 안에 로봇이 있고, 로봇을 시작 셀에서 이 격자의 목표 셀로 이동시키려고 합니다. 그리드의 크기는 'm x n'이며, 그리드의 각 셀은 비어 있거나 막혀 있습니다. 시작 셀과 목표 셀이 서로 다르며 둘 중 어느 것도 차단되지 않는 것이 **보장**됩니다.

목표 셀까지의 최소 거리를 찾고자 합니다. 그러나 그리드의 크기, 시작 셀, 대상 셀을 **알 수 없습니다. 그리드 마스터` 객체에 대해서만 쿼리할 수 있습니다.

그리드 마스터` 클래스에는 다음과 같은 함수가 있습니다:

* `boolean canMove(char direction)` 로봇이 해당 방향으로 이동할 수 있으면 `true`를 반환합니다. 그렇지 않으면 `false`를 반환합니다.
* `void move(char direction)` 로봇을 해당 방향으로 이동시킵니다. 이 이동으로 로봇이 막힌 셀이나 그리드 밖으로 이동하면 이동이 **무시**되고 로봇은 같은 위치에 유지됩니다.
* 로봇이 현재 목표 셀에 있으면 `true`를 반환합니다. 그렇지 않으면 `false`를 반환합니다.

위 함수의 '방향'은 각각 상, 하, 좌, 우 방향을 나타내는 `{'U','D','L','R'}`의 문자이어야 합니다.

로봇의 초기 시작 셀과 목표 셀 사이의 **최소 거리**를 반환합니다. 셀 사이에 유효한 경로가 없으면 `-1`을 반환합니다.

**사용자 지정 테스트:**

테스트 입력은 `m x n` 크기의 2D 행렬 `그리드`로 읽습니다:

* `grid[i][j] == -1`은 로봇이 셀 `(i, j)`(시작 셀)에 있음을 나타냅니다.
* `grid[i][j] == 0`은 셀 `(i, j)`이 차단되었음을 나타냅니다.
* `grid[i][j] == 1`은 `(i, j)` 셀이 비어 있음을 나타냅니다.
* `grid[i][j] == 2`는 셀 `(i, j)`가 대상 셀임을 나타냅니다.

그리드`에는 정확히 하나의 `-1`과 `2`가 있습니다. 코드에는 이 정보가 **없다는 것을** 기억하세요.

**예제 1:**

**Input:** grid = \[\[1,2\],\[-1,0\]\]
**출력:** 2
**설명:** 한 가지 가능한 상호작용이 아래에 설명되어 있습니다:
로봇은 처음에 -1로 표시된 셀 (1, 0)에 서 있습니다.
- master.canMove('U')는 참을 반환합니다.
- master.canMove('D')는 false를 반환합니다.
- master.canMove('L')은 false를 반환합니다.
- master.canMove('R')은 false를 반환합니다.
- master.move('U')는 로봇을 셀 (0, 0)로 이동합니다.
- master.isTarget()은 false를 반환합니다.
- master.canMove('U')는 false를 반환합니다.
- master.canMove('D')는 참을 반환합니다.
- master.canMove('L')은 false를 반환합니다.
- master.canMove('R')은 참을 반환합니다.
- master.move('R')는 로봇을 셀 (0, 1)로 이동합니다.
- master.isTarget()은 참을 반환합니다.
이제 목표가 셀 (0, 1)이고 목표 셀까지의 최단 경로가 2라는 것을 알 수 있습니다.

**예제 2:**

**Input:** grid = \[\[0,0,-1\],\[1,1,1\],\[2,0,0\]\]
**출력:** 4
**설명:** 로봇과 목표 셀 사이의 최소 거리는 4입니다.

**예제 3:**

**입력:** 그리드 = \[\[-1,0\],\[0,2\]\]
**출력:** -1
**설명:** 로봇에서 목표 셀까지의 경로가 없습니다.

**제약 조건:**

* `1 <= n, m <= 500`
* `m == 그리드.길이`
* `n == grid[i].length`
* `grid[i][j]`는 `-1`, `0`, `1` 또는 `2` 중 하나입니다.
* 그리드`에 `-1`이 **정확히 하나 있습니다.
* 그리드`에 `정확히 하나` `2`가 있습니다.
