BFS算法清除矩阵上大于1的点

一块足够大的地方散布着许多石头，为了方便活动，必须把这些石头挪开。假设整个场地是一块矩形的地图，地图坐标的横纵坐标均为非负整数。以链表形式表示的场地中各个坐标点的情况。

0：代表无法从这个点通过

1：代表这个点可以顺利通过

N(大于1)：代表这个点上有一个可以去除的石头，而且石头的大小是N

如果（0,0）上有石头可以直接移除，每移除一个石头，该石头所在坐标就可以通行即值变为1。

你需要编写一个程序计算出从坐标（0,0）出发，按照石头大小，从小到大依次移除场地中的石头，返回最小的步数，如果无法移除所有的石头就返回-1。

import java.awt.Point;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.stream.Collectors;

public class TeamBuilding {

    public int getMinimumSteps (List<List<Integer>> stones){
		int dx, dy, gx = 0, gy = 0;
    	int[][] deep;
        int M = stones.size();
		int N = stones.get(0).size();

        dx=0;
        dy=0;
        deep = new int[M][N];
               
        int [][]a = new int [M][N];
        for (int i = 0; i < stones.size(); i++){
            for (int j = 0; j <	stones.get(0).size(); j++) {
            	a[i][j]= stones.get(i).get(j); 
            }
        }
        Boolean ite = true;     
        int sum = 0;
        while (ite) {
        	int min=1000000;
	        for (int i = 0; i < stones.size(); i++){
	            for (int j = 0; j <	stones.get(0).size(); j++) {
	            	if(a[i][j]<min & a[i][j]>1){
	            		min = a[i][j];
	            		gx = i;
	            		gy = j;
	            	}
	            }
	        }
	        if(min==1000000){
	        	ite = false;
	        	break;
	        }
	       
	        Queue<Point> q = new LinkedList<Point>();
	        int[] tx = { -1, 1, 0, 0 };
	        int[] ty = { 0, 0, 1, -1 };
	        q.offer(new Point(dx, dy));

	        for (int i = 0; i < M; i++)
	            for (int j = 0; j < N; j++)
	                deep[i][j] = -1;
	        deep[dx][dy] = 0;
	    	a[gx][gy]=1;
	        while (q.size() > 0) {
	            Point p = q.poll();
	            if (p.x == gx && p.y == gy)
	                break;
	            for (int i = 0; i < 4; i++) {
	                int x = p.x + tx[i];
	                int y = p.y + ty[i];	//p为当前位置；
	                if (x >= 0 && x < M && y >= 0 && y < N && a[x][y] >= 1 && deep[x][y] == -1) {
	                    deep[x][y] = deep[p.x][p.y] + 1;
	                    q.offer(new Point(x, y));
	                }
	            } 
	        }
	        dx = gx;
	        dy = gy;
	        
	        int len = deep[gx][gy];
	        if (len==-1){
            	return -1;
            }
	        sum = sum+len;
        }
        return sum;
    }
}