You are controlling a robot in a 2D grid-based game. The grid is represented as a m x n matrix where:

0 represents an empty space the robot can move through

1 represents an obstacle that the robot cannot pass

The robot starts at a given position start = [startRow, startCol] and must reach a finish point at position destination = [destinationRow, destinationCol].

The robot can move one step at a time in any of the 4 directions: up, down, left, or right. The robot can stop at any empty cell (it does not need to hit a wall to stop).

Your task is to compute the minimum number of steps the robot must take to reach the finish point. If the robot cannot reach the finish point, return -1.

Follow-up: Try solving this problem using the A* Search algorithm.

Example 1:

Input: Maze = 
[[0, 0, 0, 0, 1], 
 [0, 1, 1, 0, 0], 
 [1, 0, 0, 1, 0], 
 [0, 0, 0, 1, 0], 
 [0, 0, 0, 0, 0]
], 
Start: [0, 1], Destination: [2, 1]
Output: 12 (Number of steps = number of positions - 1)
Explanation: The robot must take a long winding path around the walls to reach the destination.  
One possible path: Start: [0, 1]-> [0, 2]-> [0, 3]-> [1, 3]-> [1, 4]-> [2, 4]-> [3, 4]-> [4, 4]-> [4, 3]-> [4, 2]-> [3, 2]-> [2, 2]-> [2, 1]

Example 2:

Input: Maze = 
[[0, 0, 0, 1, 0], 
 [0, 1, 1, 0, 1], 
 [1, 0, 0, 0, 0], 
 [0, 0, 0, 1, 0], 
 [0, 0, 0, 0, 0]
], 
Start: [1, 0], Destination: [4, 4]
Output: -1
Explanation: Although the destination is in an open space, it is completely cut off by walls from the robot's reachable area.

Example 3:

Input: Maze = 
[[0, 1, 1, 1, 1], 
 [0, 1, 0, 0, 0], 
 [1, 1, 0, 0, 0], 
 [0, 0, 1, 0, 0], 
 [1, 0, 0, 0, 0]
], 
Start: [4, 3], Destination: [2, 4]
Output: 3
Explanation: 
One possible path to reach the finish point is: [4, 3]-> [3, 3]-> [2, 3]-> [2, 4]

Example 4:

Input: maze = 
[[0, 0, 1, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 1, 0],
 [1, 1, 0, 1, 1],
 [0, 0, 0, 0, 0]
], 
start = [0, 4], destination = [2, 0]

Output: 6 (Steps)
Explanation: Path:(0,4) → (1,4) → (1,3) → (1,2) → (1,1) → (1,0) → (2,0)

Constraints:

m == maze.length

n == maze[0].length, and every row has length n

1 <= m, n <= 100

maze[i][j] is 0 or 1.

start.length == 2

destination.length == 2

0 <= startRow, destinationRow < m

0 <= startCol, destinationCol < n

Both start and destination are on empty cells (0)

The start and destination positions are not the same

There are at least 2 open spaces in the maze

97. Robot Pathfinding (A*)