华为OD机试-- 计算疫情扩散时间

题目描述

在一个地图中(地图由n*n个区域组成)有部分区域被感染病菌感染区域每天都会把周围(上下左右)的4个区域感染请根据给定的地图计算多少天以后，全部区域都会被感染如果初始地图上所有区域全部都被感染，或者没有被感染区域，返回-1 输入描述 行N*N个数字(只包合0.1，不会有其他数字)表示一个地图，数字间用分割，0表示未 感染区域，1表示已经感染区域每N个数字表示地图中一行，输入数据共表示N行N列的 区域地图 例如输入1,0,1,0,0,0,1,0,1，表示地图 1,0,1 0,0,0 1,0,1 输出描述 个整数，表示经过多少天以后，全部区域都被感染1<=N<200

输出描述

1个整数，表示经过多少天以后，全部区域都被感染1<=N<200

输入检查

输入

1,0,1

0,0,0

1,0,1

输出

2

解析

这是一个典型的广度优先搜索（BFS）问题。我们可以将地图中的每个区域看作一个节点，如果两个节点相邻并且至少有一个节点已经被感染，那么这两个节点就可以形成一个感染链。我们需要找到从初始感染点出发，能够感染所有节点的最短路径。

步骤如下

1. 首先，我们需要找到初始感染点。我们可以通过遍历地图来实现这一点。如果找到一个未被感染的节点，那么它就是一个初始感染点。
2. 然后，我们使用广度优先搜索（BFS）来寻找感染链。我们从初始感染点开始，将其标记为已访问，并将其加入到队列中。然后，我们开始循环，每次从队列中取出一个节点，检查其四个方向的节点。如果某个方向的节点未被感染，并且与当前节点相邻，那么我们就将这个方向的节点加入到队列中，并将当前节点标记为该方向节点的父节点。同时，我们将该方向的节点标记为已访问。我们重复这个过程，直到队列为空或者找到了所有的感染链。
3. 最后，我们需要计算经过多少天以后，全部区域都会被感染。我们可以通过计算每个节点的累计感染数来实现这一点。如果某个节点的累计感染数等于总节点数，那么说明所有节点都已经被感染，返回-1。否则，返回当前天数。

代码

java

import java.util.*;

public class Solution {
    private static final int[][] DIRECTIONS = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    private int n;
    private int[][] map;
    private boolean[] visited;
    private int days;

    public int infected(int[][] map) {
        this.n = map.length;
        this.map = map;
        this.visited = new boolean[n * n];
        this.days = 0;
        Queue<int[]> queue = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (map[i][j] == 1 && !visited[i * n + j]) {
                    visited[i * n + j] = true;
                    queue.offer(new int[]{i, j});
                }
            }
        }
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                int[] pos = queue.poll();
                for (int[] direction : DIRECTIONS) {
                    int x = pos[0] + direction[0];
                    int y = pos[1] + direction[1];
                    if (x >= 0 && x < n && y >= 0 && y < n && map[x][y] == 1 && !visited[x * n + y]) {
                        visited[x * n + y] = true;
                        queue.offer(new int[]{x, y});
                    }
                }
            }
            days++;
        }
        return days - 1;
    }
}

pyhton

def infected(map):
    n = len(map)
    visited = [[False] * n for _ in range(n)]
    days = 0
    queue = []
    for i in range(n):
        for j in range(n):
            if map[i][j] == 1 and not visited[i][j]:
                visited[i][j] = True
                queue.append([i, j])
    while queue:
        size = len(queue)
        for i in range(size):
            pos = queue.pop(0)
            for direction in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
                x = pos[0] + direction[0]
                y = pos[1] + direction[1]
                if 0 <= x < n and 0 <= y < n and map[x][y] == 1 and not visited[x][y]:
                    visited[x][y] = True
                    queue.append([x, y])
        days += 1
    return days - 1 if all(all(row) for row in visited) else -1

C++

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

int infected(vector<vector<int>>& map) {
    int n = map.size();
    vector<vector<bool>> visited(n, vector<bool>(n, false));
    int days = 0;
    queue<pair<int, int>> q;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (map[i][j] == 1 && !visited[i][j]) {
                visited[i][j] = true;
                q.push({i, j});
            }
        }
    }
    while (!q.empty()) {
        int size = q.size();
        for (int i = 0; i < size; i++) {
            pair<int, int> pos = q.front();
            q.pop();
            for (int direction[] : {{0, 1}, {0, -1}, {1, 0}, {-1, 0}}) {
                int x = pos.first + direction[0];
                int y = pos.second + direction[1];
                if (0 <= x && x < n && 0 <= y && y < n && map[x][y] == 1 && !visited[x][y]) {
                    visited[x][y] = true;
                    q.push({x, y});
                }
            }
        }
        days++;
    }
    return days - 1;
}

int main() {
    vector<vector<int>> map = {{1, 0, 1}, {0, 0, 0}, {1, 0, 1}};
    cout << infected(map) << endl;
    return 0;
}