今天这篇文章是我用新键盘写的嘿嘿，记录一下！
以下是根据灵茶山艾府up主讲解的笔记:
在二分查找的代码中，要注意left和right区间的开闭，可以分为闭区间、左闭右开区间、左开右开区间 ，对应可以解决三种问题：>= > <= <，一般解决第一种问题，其他三种可以转换成第一种表达方式，例如>x相当于>=(x+1)，<=x相当于(>=x)-1，<x相当于(>x)-1，而>x相当于>=(x+1)，于是，我们只需要学习>=x的问题怎么解决就可以了。
一定要注意二分查找的区间开闭以及要解决的问题
python
def sort(nums: List[int], target: int) -> int:
left = 0
right = len(nums) - 1 # 闭区间[left, right]
while left <= right: # 区间不为空
# 在C++或Java编程语言中，要注意left和right相加溢出问题
# mid = (left + (right - left)) // 2
mid = (left + right) // 2
if nums[mid] < target:
left = mid + 1 # [mid+1, right]
else:
right = mid - 1 # [left, mid-1]
return left
python
def sort(nums: List[int], target: int) -> int:
left = 0
right = len(nums) # 左闭右开区间[left, right）
while left < right: # 区间不为空
mid = (left + right) // 2
if nums[mid] < target:
left = mid + 1 # [mid+1, right）
else:
right = mid # [left, mid）
return left # right
python
def sort(nums: List[int], target: int) -> int:
left = -1
right = len(nums) # 开区间（left, right）
while left + 1 < right: # 区间不为空
mid = (left + right) // 2
if nums[mid] < target:
left = mid # （mid, right）
else:
right = mid # （left, mid）
return right这道题我最开始的解题思路比较接近第二种方法，即使用广度优先搜索，比较火的路径和人的路径之间的差
但是思考得不够全面，于是按照题解有如下思路：
首先算出人到每个格子的最短时间arriveTime和火到每个格子的时间fireTime，进行分类讨论
- 如果
arriveTime小于0，则代表人无法到达安全屋，返回-1 - 否则（
arriveTime大于0），如果fireTime小于0，则代表火无法到安全屋，人和火是隔开的，于是人的等待时间可无限，返回1e9 - 否则，
arriveTime大于0且fireTime大于0，即人和火都可以到达安全屋，则：d=fireTime[m-1][n-1]-arriveTime[m-1][n-1] - 如果d小于0，则说明火到达安全屋的时间小于人到达安全屋的时间，火先到达安全屋，则不可停留，返回
-1 - 否则（d大于等于0），则说明火到达安全屋的时间大于等于人到达安全屋的时间，火后到达或者和人同时到达安全屋
- 如果d大于0，则火后到达安全屋，那么判断除了终点之外的格子内（即终点的左边和上边的格子）火和人到达的时间，如果此时人比火先到达，则返回
d，否则返回d-1。
代码：
cpp
class Solution {
public:
constexpr static int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
constexpr static int INF = 1e9;
int maximumMinutes(vector<vector<int>>& grid) {
int m = grid.size(), n = grid[0].size();
// 每个格子着火的时间
vector<vector<int>> fireTime(m, vector<int>(n, INF));
// bfs计算每个格子着火的时间
bfs(grid, fireTime);
// 起点到终点的最短时间
int arriveTime = getArriveTime(grid, fireTime, 0);
// 分类讨论
// 1. 安全屋不可达
if (arriveTime < 0) {
return -1;
}
// 2. 安全屋可达，火不可达
if (fireTime[m-1][n-1] == INF) {
return INF;
}
// 3. 人和火均可达，火比人提前到达的时间 ans
int ans = fireTime[m-1][n-1] - arriveTime;
// 4. ans < 0 则火比人先到达，返回-1
// 5. ans >= 0 则火比人后到达，则判断停留ans分钟后，人是否比火先到达安全屋左边和上边的格子
// 6. 若可以，返回ans；否则返回ans-1
return getArriveTime(grid, fireTime, ans) >= 0 ? ans : (ans - 1);
}
void bfs(vector<vector<int>> &grid, vector<vector<int>> &fireTime){
int m = grid.size(), n = grid[0].size();
queue<pair<int, int>> q;
// init
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (grid[i][j] == 1){
q.emplace(i, j);
fireTime[i][j] = 0;
}
}
}
int time = 1;
while (!q.empty()) {
int sz = q.size();
for (int i = 0; i < sz; i++) {
auto [cx, cy] = q.front();
q.pop();
for (int j = 0; j < 4; j++) {
int nx = cx + dirs[j][0];
int ny = cy + dirs[j][1];
if (nx >= 0 && ny >= 0 && nx < m && ny < n) {
if (grid[nx][ny] == 2 || fireTime[nx][ny] != INF) {
continue;
}
q.emplace(nx, ny);
fireTime[nx][ny] = time;
}
}
}
time++;
}
}
int getArriveTime(vector<vector<int>> &grid, vector<vector<int>> &fireTime, int stayTime){
int m = grid.size(), n = grid[0].size();
queue<tuple<int, int, int>> q;
vector<vector<bool>> visit(m, vector<bool>(n, false));
q.emplace(0, 0, stayTime);
visit[0][0] = true;
while (!q.empty()) {
auto [cx, cy, time] = q.front(); // 注意这里的time是当前格子所需要停留的时间
q.pop();
for (int j = 0; j < 4; j++) {
int nx = cx + dirs[j][0];
int ny = cy + dirs[j][1]; // nx和ny表示标格子，还没到达，如果到达time需要+1
if (nx >= 0 && ny >= 0 && nx < m && ny < n) {
if (grid[nx][ny] == 2 || visit[nx][ny]) {
continue;
}
if (nx == m - 1 && ny == n - 1) { // 因此这里到达终点需要time+1
return time + 1;
}
if (fireTime[nx][ny] > time + 1) { // 到达目标节点的火需要的时间和人需要的时间
visit[nx][ny] = true;
q.emplace(nx, ny, time + 1);
}
}
}
}
return -1;
}
};另外，队列的入队操作q.emplace相比于q.push实质上是传递构造函数的参数，直接在内存上构造对象，省去移动的过程。