2258. 逃离火灾(附:二分查找的理解)

今天这篇文章是我用新键盘写的嘿嘿,记录一下!

以下是根据灵茶山艾府up主讲解的笔记:

在二分查找的代码中,要注意left和right区间的开闭,可以分为闭区间、左闭右开区间、左开右开区间,对应可以解决三种问题:>= > <= <,一般解决第一种问题,其他三种可以转换成第一种表达方式,例如>x相当于>=(x+1)<=x相当于(>=x)-1<x相当于(>x)-1,而>x相当于>=(x+1),于是,我们只需要学习>=x的问题怎么解决就可以了。
一定要注意二分查找的区间开闭以及要解决的问题

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
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
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,进行分类讨论

  1. 如果arriveTime小于0,则代表人无法到达安全屋,返回-1
  2. 否则(arriveTime大于0),如果fireTime小于0,则代表火无法到安全屋,人和火是隔开的,于是人的等待时间可无限,返回1e9
  3. 否则,arriveTime大于0且fireTime大于0,即人和火都可以到达安全屋,则:d=fireTime[m-1][n-1]-arriveTime[m-1][n-1]
  4. 如果d小于0,则说明火到达安全屋的时间小于人到达安全屋的时间,火先到达安全屋,则不可停留,返回-1
  5. 否则(d大于等于0),则说明火到达安全屋的时间大于等于人到达安全屋的时间,火后到达或者和人同时到达安全屋
  6. 如果d大于0,则火后到达安全屋,那么判断除了终点之外的格子内(即终点的左边和上边的格子)火和人到达的时间,如果此时人比火先到达,则返回d,否则返回d-1

代码:

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实质上是传递构造函数的参数,直接在内存上构造对象,省去移动的过程。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值