1. 题目描述

Leetcode 675 为高尔夫比赛砍树

2. 我的尝试

typedef priority_queue<int, vector<int>, greater<int>> heap;

class Solution {
public:
    int m;
    int n;

    int bfs(vector<vector<int>>& forest, vector<int> &h) {
        queue<pair<int, int>> q;
        int res = 0;
        int i = 0;
        int j = 0;
        int di[] = {0, -1, 0, 1};
        int dj[] = {-1, 0, 1, 0};
        const int N = 55;
        int d[N][N];
        bool st[N][N];

        q.push({0, 0});

        for (auto &t : h) {
            memset(d, 0x3f, sizeof d);
            memset(st, 0, sizeof st);
            d[i][j] = 0;

            while (q.size()) {
                i = q.front().first;
                j = q.front().second;
                q.pop();
//                 st[i][j] = true;

                if (forest[i][j] == t) {
                    res += d[i][j];
                    q = queue<pair<int, int>>();
                    q.push({i, j});
                    break;
                }

                for (int k = 0; k < 4; k ++) {
                    int x = i + di[k];
                    int y = j + dj[k];
                    if (0 <= x && x < m && 0 <= y && y < n && forest[x][y] && !st[x][y]) {
                        q.push({x, y});
                        st[x][y] = true;
                        d[x][y] = min(d[x][y], d[i][j] + 1);
                    }
                }
            }

            if (q.empty())
                return -1;
        }
        return res;
    }

    int cutOffTree(vector<vector<int>>& forest) {
        m = forest.size();
        n = forest[0].size();
//         priority_queue<int, vector<int>, greater<int>> h;
        vector<int> h;

        for (auto &v : forest)
            for (auto &x : v)
                if (x > 1)
                    h.push_back(x);

        sort(h.begin(), h.end());

        return bfs(forest, h);
    }
};

3. 题解

1. BFS

方法一：广度优先遍历¹

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

class Solution {
public:
    int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    int bfs(vector<vector<int>>& forest, int sx, int sy, int tx, int ty) {
        if (sx == tx && sy == ty) {
            return 0;
        }

        int row = forest.size();
        int col = forest[0].size();
        int step = 0;
        queue<pair<int, int>> qu;
        vector<vector<bool>> visited(row, vector<bool>(col, false));         
        qu.emplace(sx, sy);
        visited[sx][sy] = true;
        while (!qu.empty()) {
            step++;
            int sz = qu.size();
            for (int i = 0; i < sz; ++i) {
                auto [cx, cy] = qu.front();
                qu.pop();
                for (int j = 0; j < 4; ++j) {
                    int nx = cx + dirs[j][0];
                    int ny = cy + dirs[j][1];
                    if (nx >= 0 && nx < row && ny >= 0 && ny < col) {
                        if (!visited[nx][ny] && forest[nx][ny] > 0) {
                            if (nx == tx && ny == ty) {
                                return step;
                            }
                            qu.emplace(nx, ny);
                            visited[nx][ny] = true;
                        }
                    }
                }
            }
        }
        return -1;
    }

    int cutOffTree(vector<vector<int>>& forest) {
        vector<pair<int, int>> trees;
        int row = forest.size();
        int col = forest[0].size();
        for (int i = 0; i < row; ++i) {
            for (int j = 0; j < col; ++j) {
                if (forest[i][j] > 1) {
                    trees.emplace_back(i, j);
                }
            }
        }
        sort(trees.begin(), trees.end(), [&](const pair<int, int> & a, const pair<int, int> & b) {
            return forest[a.first][a.second] < forest[b.first][b.second];
        });

        int cx = 0;
        int cy = 0;
        int ans = 0;
        for (int i = 0; i < trees.size(); ++i) {
            int steps = bfs(forest, cx, cy, trees[i].first, trees[i].second);
            if (steps == -1) {
                return -1;
            }
            ans += steps;
            cx = trees[i].first;
            cy = trees[i].second;
        }
        return ans;
    }
};

• 时间复杂度：$O(m^2\times n^2)$，其中 $m$ 为矩阵的行数，$n$ 为矩阵的列数。矩阵中最多有 $m\times 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)$，其中 $m$ 为矩阵的行数，$n$ 为矩阵的列数。矩阵中最多有 $m\times n$ 颗树，对树的高度进行排序，所需要的栈空间为 $O(\log (m\times n))$，利用广度优先搜索队列中最多有 $O(m\times n)$ 个元素，标记已遍历过的元素需要的空间为 $O(m\times n)$，因此总的空间复杂度为 $O(m\times n)$。

---

1. 官方题解 ↩︎