文章目录
- [1. 题目描述](#1. 题目描述)
- [2. 我的尝试](#2. 我的尝试)
- [3. 题解](#3. 题解)
-
- [1. BFS](#1. BFS)
1. 题目描述
2. 我的尝试
cpp
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
方法一：广度优先遍历[1](#1)
首先对矩阵中的树按照树的高度进行排序，我们依次求出相邻的树之间的最短距离。利用广度优先搜索，按照层次遍历，处理队列中的节点（网格位置）。visited 记录在某个时间点已经添加到队列中的节点，这些节点已被处理或在等待处理的队列中。对于下一个要处理的每个节点，查看他们的四个方向上相邻的点，如果相邻的点没有被遍历过且不是障碍，将其加入到队列中，直到找到终点为止，返回当前的步数即可。最终返回所有的步数之和即为最终结果
cpp
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 × n 2 ) O(m^2 \times n^2) O(m2×n2)，其中 m m m 为矩阵的行数， n n n 为矩阵的列数。矩阵中最多有 m × n m \times n m×n 颗树，对树的高度进行排序，时间复杂度为 O ( m × n × log ( m × n ) ) O(m \times n \times \log (m \times n)) O(m×n×log(m×n))，利用广度优先搜索两颗树之间的最短距离需要的时间为 O ( m × n ) O(m \times n) O(m×n)，因此总的时间复杂为 O ( m × n × log ( m × n ) + m 2 × n 2 ) = O ( m 2 × n 2 ) O(m \times n \times \log (m \times n) + m^2 \times n^2) = O(m^2 \times n^2) O(m×n×log(m×n)+m2×n2)=O(m2×n2)。
-
空间复杂度： O ( m × n ) O(m \times n) O(m×n)，其中 m m m 为矩阵的行数， n n n 为矩阵的列数。矩阵中最多有 m × n m \times n m×n 颗树，对树的高度进行排序，所需要的栈空间为 O ( log ( m × n ) ) O(\log (m \times n)) O(log(m×n))，利用广度优先搜索队列中最多有 O ( m × n ) O(m \times n) O(m×n) 个元素，标记已遍历过的元素需要的空间为 O ( m × n ) O(m \times n) O(m×n)，因此总的空间复杂度为 O ( m × n ) O(m \times n) O(m×n)。