为高尔夫比赛砍树

为高尔夫比赛砍树

你被请来给一个要举办高尔夫比赛的树林砍树。树林由一个 m x n 的矩阵表示， 在这个矩阵中：
0 表示障碍，无法触碰
1 表示地面，可以行走
比 1 大的数 表示有树的单元格，可以行走，数值表示树的高度
每一步，你都可以向上、下、左、右四个方向之一移动一个单位，如果你站的地方有一棵树，那么你可以决定是否要砍倒它。
你需要按照树的高度从低向高砍掉所有的树，每砍过一颗树，该单元格的值变为 1（即变为地面）。
你将从 (0, 0) 点开始工作，返回你砍完所有树需要走的最小步数。 如果你无法砍完所有的树，返回 -1 。
可以保证的是，没有两棵树的高度是相同的，并且你至少需要砍倒一棵树。

首先对矩阵中的树按照树的高度进行排序,依次求出相邻的树之间的最短距离
利用广度优先搜索,按照层次遍历,处理队列中的节点(网格位置)
visited记录在某个时间点已经添加到队列中的节点,这些节点已被处理或在等待处理的队列中
对于下一个要处理的每个节点,查看他们的四个方向上相邻的点
如果相邻的点没有被遍历过且不是障碍,将其加入到队列中,直到找到终点为止,返回当前的步数即可
最终返回所有的步数之和即为最终结果。

	int[][] direction = new int[][]{{1, 0}, {-1, 0}, {0, -1}, {0, 1}};//上下左右四个方向

    public int cutOffTree(List<List<Integer>> forest) {
        int row = forest.size();
        int col = forest.get(0).size();
        List<int[]> list = new ArrayList<>();
        //将所有的非零节点(代表树)存下来
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (forest.get(i).get(j) > 1) list.add(new int[]{i, j});
            }
        }

        //对矩阵中的树按照树的高度进行排序
        Collections.sort(list, (a, b) -> forest.get(a[0]).get(a[1]) - forest.get(b[0]).get(b[1]));

        int start_x = 0, start_y = 0, ans = 0;

        for (int i = 0; i < list.size(); i++) {
            int step = DFS(forest, start_x, start_y, list.get(i)[0], list.get(i)[1]);//依次求出相邻的树之间的最短距离
            if (step == -1) return -1;
            ans += step;
            start_x = list.get(i)[0];
            start_y = list.get(i)[1];
        }
        return ans;
    }

    private int DFS(List<List<Integer>> forest, int start_x, int start_y, int end_x, int end_y) {
        if (start_x == end_x && start_y == end_y) return 0;
        int row = forest.size();
        int col = forest.get(0).size();

        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{start_x, start_y});
        boolean[][] visited = new boolean[row][col];
        visited[start_x][start_y] = true;
        int step = 0;

        while (!queue.isEmpty()) {
            step++;
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                int[] poll = queue.poll();
                int poll_x = poll[0], poll_y = poll[1];
                for (int j = 0; j < 4; j++) {//对于下一个要处理的每个节点,查看他们的四个方向上相邻的点
                    int cur_x = poll_x + direction[j][0];
                    int cur_y = poll_y + direction[j][1];
                    //如果相邻的点没有被遍历过且不是障碍,将其加入到队列中
                    if (cur_x >= 0 && cur_x < row && cur_y >= 0 && cur_y < col) {
                        if (!visited[cur_x][cur_y] && forest.get(cur_x).get(cur_y) > 0) {
                            if (cur_x == end_x && cur_y == end_y) return step;
                            queue.add(new int[]{cur_x, cur_y});//不能一步到达就将中间的这些节点加进来
                            visited[cur_x][cur_y] = true;
                        }
                    }
                }
            }
        }
        return -1;
    }