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

T_T250
192 阅读6分钟

题目解析

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

问题分解

  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 秒。

`import java.util.LinkedList; import java.util.Queue;

public class Main { static int[] dx = {0, 0, 1, -1}; static int[] dy = {1, -1, 0, 0};

public static int solution(int row_n, int column_m, int[][] seats, int[] patient) {
    int cnt = 0;
    int m = seats.length;
    int n = seats[0].length;

    if (patient[0] < 0 || patient[0] >= m || patient[1] < 0 || patient[1] >= n) {
        return 0;
    }

    int[][] check = new int[m][n];
    int[][] time = new int[m][n];

    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            check[i][j] = seats[i][j] + 1; // 带口罩+1层防护盾
            time[i][j] = -1;
        }
    }

    check[patient[0]][patient[1]] = 0; // 初始感染者
    time[patient[0]][patient[1]] = 0; // 初始感染者时间为0秒

    Queue<int[]> q = new LinkedList<>();
    q.offer(new int[]{patient[0], patient[1]});

    while (!q.isEmpty()) {
        int sz = q.size();
        while (sz-- > 0) { // 每一秒的传播情况
            int[] k = q.poll();
            int x = k[0];
            int y = k[1];
            boolean flag = false;

            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.offer(new int[]{xx, yy});
                    } else if (check[xx][yy] > 0) {
                        int nums = 0;
                        for (int j = 0; j < 4; j++) {
                            int xxx = xx + dx[j];
                            int yyy = yy + dy[j];
                            if (xxx >= 0 && yyy >= 0 && xxx < m && yyy < n && check[xxx][yyy] == 0 && time[xxx][yyy] <= cnt && time[xxx][yyy] != -1) {
                                nums++;
                            }
                        }
                        if (nums >= 2) {
                            check[xx][yy] = 0;
                            time[xx][yy] = cnt + 1;
                            q.offer(new int[]{xx, yy});
                        }
                    }

                    if (check[xx][yy] > 0) {
                        flag = true;
                    }
                }
            }
            if (flag) {
                q.offer(k);
            }
        }
        cnt++;
    }

    return cnt - 1;
}

public static void main(String[] args) {
    // 测试用例
    int[][] testSeats1 = {{0,1,1,1},{1,0,1,0},{1,1,1,1},{0,0,0,1}};
    int[][] testSeats2 = {{0,1,1,1},{1,0,1,0},{1,1,1,1},{0,0,0,1}};
    int[][] testSeats3 = {{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}};
    int[][] testSeats4 = {{1,1,1,1},{1,1,1,1},{1,1,1,1},{1,1,1,1}};
    int[][] testSeats5 = {{1}};

    System.out.println(solution(4, 4, testSeats1, new int[]{2, 2}) == 6);
    System.out.println(solution(4, 4, testSeats2, new int[]{2, 5}) == 0);
    System.out.println(solution(4, 4, testSeats3, new int[]{2, 2}) == 4);
    System.out.println(solution(4, 4, testSeats4, new int[]{2, 2}) == 6);
    System.out.println(solution(1, 1, testSeats5, new int[]{0, 0}) == 0);
}

} `

算法复杂度分析

  1. 时间复杂度

    • 每个座位最多访问一次，且每次最多处理 4 个方向，时间复杂度为 O(rown×columnm)O(rown​×columnm​)。

  2. 空间复杂度

    • 需要使用额外的二维数组记录状态和时间，空间复杂度为 O(rown×columnm)O(rown​×columnm​)。

总结

通过广度优先搜索，结合口罩规则的逻辑条件，问题得到了高效的解决。感染传播的动态规则在算法中被精确模拟，并能适应多种场景和输入条件。

avatar
文章
阅读
粉丝