病毒在封闭空间中的传播时间

学习会这道题，会大大加深对bfs的理解。

病毒在封闭空间中的传播时间

题目解析

这道题描述了一个基于网格的感染传播问题，其中病毒从一个感染者开始，并按照特定规则传播到整个房间。房间中每个人的感染概率受到其是否佩戴口罩的影响，这影响了病毒传播的速度。目标是确定感染所有人所需的最短时间。

---

问题分解

1. 问题核心
   该问题是一个带权的最短路径问题，类似于广度优先搜索（BFS），但由于病毒传播受到特定规则的约束，这使得其传播速度并不统一，因此需要在标准BFS的基础上加入额外逻辑处理。

2. 房间与座位布局
   房间被建模为一个二维网格，每个位置表示一个座位。网格中每个单元格的值表明该座位上人的状态：

   • 0: 没戴口罩的人，易感染。
   • 1: 戴了口罩的人，感染需要两秒或两名相邻感染者的同时感染。

3. 病毒传播规则

   • 对于未戴口罩的人（0），病毒需要 1 秒即可传播。
   • 对于戴口罩的人（1），病毒需要 2 秒才可感染；或者需要在 1 秒内从两个相邻感染者同时感染。
   • 感染传播只能在相邻（上下左右）的位置进行。

4. 输入描述

   • row_n 和 column_m 分别表示房间的行数和列数。
   • seats 是二维数组，描述了房间中座位的分布和状态。
   • patient 是一个数组，表示初始感染者的起始位置（行、列索引从1开始）。

5. 输出目标 计算病毒感染房间内所有人所需的 最短时间。如果存在无法感染的人，则输出为 -1。

---

解题思路

1. 广度优先搜索（BFS）模型
   BFS 是解决最短路径问题的常见算法。将初始感染者加入队列，逐层处理其周围的邻居节点，逐步扩展感染范围。

   • 队列中的每个元素记录一个座位的坐标 (x, y) 以及病毒传播的当前时间。
   • 每次处理队列中的节点时，尝试向上下左右四个方向传播病毒。

2. 传播规则的实现

   • 未戴口罩的情况
     如果目标位置上的人未戴口罩（值为 0），直接在下一秒内将其感染，并将其加入队列。
   • 戴口罩的情况
     如果目标位置上的人戴了口罩（值为 1），需要两种条件之一满足才能感染：
     • 感染时间累计达到 2 秒。
     • 当前节点周围的感染者数量达到 2 个。

3. 状态标记

   • 使用一个二维数组 check 记录每个位置当前的感染状态和剩余的“防护层”：
     • 未戴口罩的人初始防护值为 1（被感染一次即可）。
     • 戴口罩的人初始防护值为 2（需要两次感染或两名邻居感染）。
   • 使用另一个二维数组 time 记录每个位置的感染时间，初始值为 -1。

4. 边界条件处理

   • 若初始感染者位置超出网格范围，则直接返回 0。
   • 如果最终某些位置仍未被感染（check[x][y] > 0），则输出 -1。

5. 感染时间的计算
   BFS 遍历过程中，每当一个位置被感染时，更新其感染时间为当前传播时间 + 1。遍历完成后，最大感染时间即为结果。

---

测试样例分析

样例1

• 输入: row_n = 4, column_m = 4, seats = [[0, 1, 1, 1], [1, 0, 1, 0], [1, 1, 1, 1], [0, 0, 0, 1]], patient = [2, 2]
• 分析:
  • 初始感染者在位置 (2, 2)。
  • 病毒以 1 秒的速度向未戴口罩的人传播，同时受戴口罩规则的约束。
  • 最终，所有人感染需要 6 秒。

样例2

• 输入: row_n = 3, column_m = 3, seats = [[0, 0, 0], [0, 1, 0], [0, 0, 0]], patient = [2, 2]
• 分析:
  • 中心位置的初始感染者传播病毒，受戴口罩规则影响。
  • 所有位置感染需要 4 秒。

样例3

• 输入: row_n = 5, column_m = 5, seats = [[1, 1, 1, 1, 1], [1, 0, 0, 0, 1], [1, 0, 1, 0, 1], [1, 0, 0, 0, 1], [1, 1, 1, 1, 1]], patient = [3, 3]
• 分析:
  • 边缘带口罩的约束使得传播速度减慢。
  • 所有人感染需要 7 秒。

#include <iostream>
#include <vector>
#include <queue>
#include <tuple>
using namespace std;

int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
int solution(int row_n, int column_m, std::vector<std::vector<int>> seats, std::vector<int> patient) {
    // Please write your code here
    int cnt = 0;
    int m = seats.size();
    int n = seats[0].size();
    if (patient[0] < 0 || patient[0] >= m || patient[1] < 0 || patient[1] >= n) {
        return 0;
    }
    vector<vector<int>> check(m, vector<int>(n));//检查你的保护盾还有几层，check为0就被感染
    vector<vector<int>> time(m, vector<int>(n,-1));
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            check[i][j] = seats[i][j] + 1;//1带口罩2层护盾，0没口照1层护盾
        }
    }
    check[patient[0]][patient[1]] = 0;//初始感染者
    time[patient[0]][patient[1]] = 0;//0秒的初始感染者
    queue<pair<int, int>> q;
    q.push({ patient[0],patient[1] });
    while (q.size()) {
        int sz = q.size();
        while (sz--) {///每一秒中发生的情况
            int flag = 0;
            pair<int, int> k = q.front();
            q.pop();
            int x = k.first;
            int y = k.second;
            for (int i = 0; i < 4; i++) {
                int xx = x + dx[i];
                int yy = y + dy[i];
                if (xx >= 0 && yy >= 0 && xx < m && yy < n && check[xx][yy] != 0) {
                    check[xx][yy]--;
                    if (check[xx][yy] == 0) {
                        time[xx][yy] = cnt + 1;
                        q.push({ xx,yy });
                    }
                    else if (check[xx][yy] > 0) {//如果带了口罩，检测旁边是否有至少2个病毒携带者
                        int nums = 0;
                        for (int j = 0; j < 4; j++) {
                            int xxx = xx + dx[j];
                            int yyy = yy + dy[i];
                            if (xxx >= 0 && yyy >= 0 && xxx < m && yyy < n && check[xxx][yyy] == 0 && time[xxx][yyy]<=cnt&&time[xxx][yyy] != -1)//<=cnt是因为有可能病毒携带者是同一秒(即cnt+1秒)被感染的
                                nums++;
                        }
                        if (nums >= 2) {
                            check[xx][yy] = 0;
                            time[xx][yy] = cnt + 1;
                            q.push({ xx,yy });
                        }
                    }
                    if (check[xx][yy] > 0) {
                        flag = 1;
                    }//如果check还大于0，那就q.push
                }
            }
            if (flag) {
                q.push(k);
            }
        }
        cnt++;
    }
    //删掉的条件上下左右都被感染后才能删,,，如果不删，就要q.push再进去,因为下次不是同一秒了，所以不能sz++，要放到下一秒进行
    //当check值为0时代表被感染
    return cnt-1;
}


int main() {
    //  You can add more test cases here
    std::vector<std::vector<int>> testSeats1 = {{0,1,1,1},{1,0,1,0},{1,1,1,1},{0,0,0,1}};
    std::vector<std::vector<int>> testSeats2 = {{0,1,1,1},{1,0,1,0},{1,1,1,1},{0,0,0,1}};
    std::vector<std::vector<int>> testSeats3 = {{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}};
    std::vector<std::vector<int>> testSeats4 = {{1,1,1,1},{1,1,1,1},{1,1,1,1},{1,1,1,1}};
    std::vector<std::vector<int>> testSeats5 = {{1}};

    std::cout << (solution(4, 4, testSeats1, {2, 2}) == 6) << std::endl;
    std::cout << (solution(4, 4, testSeats2, {2, 5}) == 0) << std::endl;
    std::cout << (solution(4, 4, testSeats3, {2, 2}) == 4) << std::endl;
    std::cout << (solution(4, 4, testSeats4, {2, 2}) == 6) << std::endl;
    std::cout << (solution(1, 1, testSeats5, {0, 0}) == 0) << std::endl;

    return 0;
}