Solution of *The Maze*: https://discuss.leetcode.com/topic/77471/easy-understanding-java-bfs-solution

Solution of *The Maze III*: https://discuss.leetcode.com/topic/77474/similar-to-the-maze-ii-easy-understanding-java-bfs-solution

We need to use `PriorityQueue`

instead of standard queue, and record the minimal length of each point.

```
public class Solution {
class Point {
int x,y,l;
public Point(int _x, int _y, int _l) {x=_x;y=_y;l=_l;}
}
public int shortestDistance(int[][] maze, int[] start, int[] destination) {
int m=maze.length, n=maze[0].length;
int[][] length=new int[m][n]; // record length
for (int i=0;i<m*n;i++) length[i/n][i%n]=Integer.MAX_VALUE;
int[][] dir=new int[][] {{-1,0},{0,1},{1,0},{0,-1}};
PriorityQueue<Point> list=new PriorityQueue<>((o1,o2)->o1.l-o2.l); // using priority queue
list.offer(new Point(start[0], start[1], 0));
while (!list.isEmpty()) {
Point p=list.poll();
if (length[p.x][p.y]<=p.l) continue; // if we have already found a route shorter
length[p.x][p.y]=p.l;
for (int i=0;i<4;i++) {
int xx=p.x, yy=p.y, l=p.l;
while (xx>=0 && xx<m && yy>=0 && yy<n && maze[xx][yy]==0) {
xx+=dir[i][0];
yy+=dir[i][1];
l++;
}
xx-=dir[i][0];
yy-=dir[i][1];
l--;
list.offer(new Point(xx, yy, l));
}
}
return length[destination[0]][destination[1]]==Integer.MAX_VALUE?-1:length[destination[0]][destination[1]];
}
}
```

**Modified 2017/3/27**:

*Why using PriorityQueue?*

We can consider this question as a shortest-route graph problem, that is, each stoppable point is a vertical, where every possible path between two nodes is an edge.

In this way, we can using Dijkstra algorithm to solve this problem, and that's why we use `PriorityQueue`

.