【C/C++】675. 为高尔夫比赛砍树持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第17天，点

持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第17天，点击查看活动详情

题目链接：675. 为高尔夫比赛砍树

题目描述

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

0 表示障碍，无法触碰
1 表示地面，可以行走
比 1 大的数 表示有树的单元格，可以行走，数值表示树的高度每一步，你都可以向上、下、左、右四个方向之一移动一个单位，如果你站的地方有一棵树，那么你可以决定是否要砍倒它。

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

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

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

提示:

m == forest.length
n == forest[i].length
$1 \leqslant m, n \leqslant 50$
$0 \leqslant forest[i][j] \leqslant 10^9$

示例 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) 位置的树，可以直接砍去，不用算步数。

整理题意

题目给定一个二维数组 forest 表示一张大小为 m x n 的图，图中有三种东西：

0 表示障碍，无法通过；
1 表示平地，可以通过；
大于 1 的表示树木的高度，也是可以通过的。题目要求我们从低到高砍树，问最短路径是多少。

需要注意的是我们必须从 (0, 0) 点出发；无法砍完所有的树，返回 -1 。

解题思路分析

首先观察题目数据范围，二维数组大小最大为 50 * 50，数据范围较小，可以尝试暴力做法：依次从低到高求每两棵树之间的最短距离，求最短路的方法通常为 广度优先搜索。最后将两两之间最短距离相加后即得从低到高砍树的最短路径。

具体实现

首先遍历二维数组记录每棵树的高度以及坐标（采用结构体数组进行存储）。
对树的高度进行从低到高排序（结构体排序）。
从高到低依次搜索每两棵树之间的最短距离，累加求和。
期间如果无法到达某棵树时，直接返回 -1，表示无法砍完所有的树。
如果能够砍完所有的树，返回最后累加的路径即为最终所求的最短路径答案。

复杂度分析

时间复杂度： $O(m^2 \times n^2)$ ，其中 n 为矩阵的行数，m 为矩阵的列数。矩阵中最多有 m × n 颗树，对树的高度进行排序，时间复杂度为 $O(m \times n \times \log (m \times n))$ ，利用广度优先搜索两颗树之间的最短距离需要的时间为 $O(m \times n)$ ，因此总的时间复杂为 $O(m \times n \times \log (m \times n) + m^2 \times n^2) = O(m^2 \times n^2)$ 。
空间复杂度：空间复杂度： $O(m \times n)$ ，其中 n 为矩阵的行数，m 为矩阵的列数。矩阵中最多有 m × n 颗树，对树的高度进行排序，所需要的栈空间为 $O(\log (m \times n))$ ，利用广度优先搜索队列中最多有 $O(m \times n)$ 个元素，标记已遍历过的元素需要的空间为 $O(m \times n)$ ，因此总的空间复杂度为 $O(m \times n)$ 。

代码实现

class Solution {
private:
    struct node{
        int val;
        int x, y;
    };
    int dx[4] = {0, 1, 0, -1};
    int dy[4] = {1, 0, -1, 0};
public:
    int cutOffTree(vector<vector<int>>& forest) {
        int n = forest.size();
        int m = forest[0].size();
        vector<node> vec;
        vec.clear();
        //遍历二维数组对每棵树的高度和坐标进行记录
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(forest[i][j] > 1){
                    node now;
                    now.val = forest[i][j];
                    now.x = i, now.y = j;
                    vec.push_back(now);
                }
            }
        }
        //对树的高度进行排序
        sort(vec.begin(), vec.end(), [&](node A, node B){
            return A.val < B.val;
        });
        //总共所需最小步数
        int ans = 0;
        bool vis[n][m];
        memset(vis, 0, sizeof(vis));
        queue<pair<int, int>> que;
        while(que.size()) que.pop();
        //压入起点
        vis[0][0] = 1;
        que.push(make_pair(0, 0));
        int k = vec.size();
        //对每棵树进行广度优先搜索求最短路
        for(int i = 0; i < k; i++){
            //走到forest[vec[i].x][vec[i].y]所需步数
            int step = 0;
            int flag = 0;
            //bfs求最短路
            while(que.size()){
                int num = que.size();
                //逐层遍历，一层就是下一步能够到达的点
                for(int v = 0; v < num; v++){
                    pair<int, int> now = que.front();
                    //判断是否到达下一颗树位置
                    if(now.first == vec[i].x && now.second == vec[i].y){
                        ans += step;
                        flag = 1;
                        break;
                    }
                    que.pop();
                    auto check = [&](int x, int y)->bool{
                        if(x < 0 || x >= n || y < 0 || y >= m) return false;
                        if(forest[x][y] == 0 || vis[x][y]) return false;
                        return true;
                    };
                    //判断当前点附近是否可以继续走
                    for(int j = 0; j < 4; j++){
                        int nx = dx[j] + now.first;
                        int ny = dy[j] + now.second;
                        //将可以走的、符合条件的点压入队列，
                        if(check(nx, ny)){
                            //提前判断是否到达下一颗树，进行优化
                            if(now.first == vec[i].x && now.second == vec[i].y){
                                ans += step + 1;
                                flag = 1;
                                break;
                            }
                            vis[nx][ny] = 1;
                            que.push(make_pair(nx, ny));
                        }
                    }
                    //判断是否以及达到
                    if(flag) break;
                }
                //判断是否到达
                if(flag) break;
                step++;
            }
            //无法到达时需要返回 -1，也就是无法砍完所有的树
            if(!flag) return -1;
            //清空队列和标记
            while(que.size()) que.pop();
            memset(vis, 0, sizeof(vis));
            //将当前位置压入队列继续搜索下一颗树
            que.push(make_pair(vec[i].x, vec[i].y));
        }
        return ans;
    }
};

总结

该题的思路很容易想到，难点在于代码实现部分，因为需要多次 BFS 求最短路，在代码实现时需要注意很多细节，包括清空队列和标记等操作。
测试结果：

结束语

生活往往不是一冲到底，而要根据情况时时调整状态。需要等待时，能静得下心；必须冲刺时，也鼓得起劲。张弛有度、不疾不徐，才能行稳致远。