LeetCode——675 为高尔夫比赛砍树(JAVA)

你被请来给一个要举办高尔夫比赛的树林砍树。树林由一个 m x n的矩阵表示， 在这个矩阵中：

• 0表示障碍，无法触碰
• 1表示地面，可以行走
• 比 1 大的数表示有树的单元格，可以行走，数值表示树的高度

每一步，你都可以向上、下、左、右四个方向之一移动一个单位，如果你站的地方有一棵树，那么你可以决定是否要砍倒它。

你需要按照树的高度从低向高砍掉所有的树，每砍过一颗树，该单元格的值变为 1（即变为地面）。

你将从 (0, 0)点开始工作，返回你砍完所有树需要走的最小步数。 如果你无法砍完所有的树，返回 -1。

可以保证的是，没有两棵树的高度是相同的，并且你至少需要砍倒一棵树。

示例 1：

输入：forest = [[1,2,3],[0,0,4],[7,6,5]]
输出：6
解释：沿着上面的路径，你可以用 6 步，按从最矮到最高的顺序砍掉这些树。

示例 2：

输入：forest = [[1,2,3],[0,0,0],[7,6,5]]
输出：-1
解释：由于中间一行被障碍阻塞，无法访问最下面一行中的树。

示例 3：

输入：forest = [[2,3,4],[0,0,5],[8,7,6]]
输出：6
解释：可以按与示例 1 相同的路径来砍掉所有的树。
(0,0) 位置的树，可以直接砍去，不用算步数。

提示：

• m == forest.length
• n == forest[i].length
• 1 <= m, n <= 50
• 0 <= forest[i][j] <= 109

思路

这题如果能理解到即便路过树，也不一定非要砍这个想法的话，实现起来还是不难的，就是容易被示例误导（可能会理解为必须一笔画砍完所有树，然而这并不是本题的意思）

主要思路就是跟题解一样，先对树的高度排序，并记录下对应的坐标点，然后从(0, 0)位置开始，逐个用BFS计算坐标的最短路，最后的答案就是最短路之和。

比如：
现在有这样的一些树：

[[4, 2, 3],
 [0, 0, 1],
 [7, 6, 5]]

那么按照树高排序之后的坐标点是就是：(0, 1)，(0, 2)，(0, 0)，(2, 2)，(2, 1)，(2, 0)。那么，其实就是用BFS去分别计算(0, 0)到(0, 1)的最短路，计算(0, 1)到(0, 2)的最短路，(0, 2)到(0, 0)的最短路……一直这样计算到最后。这里之所以从(0, 0)开始又回到(0, 0)，可以理解为，我初始位置在4这棵树，但是我并不去砍它，而是要走到(0, 1)这个位置砍2这棵树。

需要注意的地方：
1.树的高度是>1的，因此，如果在矩阵中碰到1，应该识别为普通的路，而不是一颗树；
2.因为是对每两个点之间做BFS求最短路径，所以，每次BFS用到的队列和visit数组都应该被初始化

代码

class Solution {
    List<List<Integer>> f;
    boolean[][] visited;
    int[] dx = {0, 0, 1, -1};
    int[] dy = {1, -1, 0, 0};
    public boolean canReach(int x, int y, int m, int n){
        if(x<0 || x>=m || y<0 || y>=n) return false;
        if(visited[x][y]) return false;
        if(f.get(x).get(y)==0) return false;
        return true;
    }
    public int bfs(int sx, int sy, int ex, int ey){
        int ret = 0;
        Queue<int[]> q = new LinkedList<>();
        visited = new boolean[f.size()][f.get(0).size()];
        q.offer(new int[]{sx, sy});
        visited[sx][sy] = true;
        while(!q.isEmpty()){
            ret++;
            int size = q.size();
            for(int k=0;k<size;k++){
                int[] top = q.peek();
                q.poll();
                for(int i=0;i<4;i++){
                    int nextX = top[0]+dx[i];
                    int nextY = top[1]+dy[i];
                    if(canReach(nextX, nextY, f.size(), f.get(0).size())){
                        if(nextX==ex && nextY==ey) return ret;
                        q.offer(new int[]{nextX, nextY});
                        visited[nextX][nextY] = true;
                    }
                }
            }
        }
        return -1;
    }
    public int cutOffTree(List<List<Integer>> forest) {
        if(forest.get(0).get(0)==0) return -1;
        f = forest;
        int m = f.size();
        int n = f.get(0).size();
        List<int[]> list = new ArrayList<>();
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(f.get(i).get(j)>1) list.add(new int[]{i, j});
            }
        }
        Comparator<int[]> comparator = new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if(f.get(o1[0]).get(o1[1])<f.get(o2[0]).get(o2[1])) return -1;
                else if(f.get(o1[0]).get(o1[1])>f.get(o2[0]).get(o2[1])) return 1;
                else return 0;
            }
        };
        list.sort(comparator);
        int ret = 0;
        int sx = 0;
        int sy = 0;
        for(int i=0;i<list.size();i++){
            if(sx==list.get(i)[0] && sy==list.get(i)[1]) continue;
            int tmp = bfs(sx, sy, list.get(i)[0], list.get(i)[1]);
            if(tmp==-1) return -1;
            ret += tmp;
            sx = list.get(i)[0];
            sy = list.get(i)[1];
        }
        return ret;
    }
}