2023华为OD机试 （B卷）|200分 疫情扩散时间计算（Java JavaScript C++ Python

2023华为OD机试 （B卷）|200分 疫情扩散时间计算（Java JavaScript C++ Python）
题目描述

• 在一个地图中（地图有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,0,1,0,0,0,1,0,1
输出	2
说明	一天以后，地图中仅剩余中心点未被感染，2天后，全部被感染
输入	1,1,1,1,1,1,1,1,1
输出	-1
说明	全部被感染

Java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        List<Integer> map = new ArrayList<>();
        int pos = 0;
        String token;
        while ((pos = input.indexOf(",")) != -1) { // 将输入字符串转换为一维数组
            token = input.substring(0, pos);
            map.add(Integer.parseInt(token));
            input = input.substring(pos + 1);
        }
        map.add(Integer.parseInt(input));
        System.out.println(getResult(map)); // 输出感染天数
    }

    public static int getResult(List<Integer> map) {
        int n = (int) Math.sqrt(map.size());

        int[][] matrix = new int[n][n]; // 将一维数组转换为二维矩阵

        Queue<int[]> q = new LinkedList<>(); // 用队列存储感染区域

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                matrix[i][j] = map.get(i * n + j); // 将一维数组转换为二维矩阵
                if (matrix[i][j] == 1) q.offer(new int[]{i, j}); // 将感染区域加入队列
            }
        }

        if (q.isEmpty() || q.size() == map.size()) { // 判断特殊情况
            return -1;
        }

        int healthy = map.size() - q.size(); // 记录未感染区域数量

        int[][] offsets = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // 记录四个方向的偏移量

        int day = 0; // 记录感染天数
        while (!q.isEmpty() && healthy > 0) { // 当队列不为空且还有未感染区域时，进行循环
            int[] tmp = q.poll(); // 取出队首元素
            int x = tmp[0], y = tmp[1]; // 获取队首元素的坐标
            day = matrix[x][y] + 1; // 记录感染天数

            for (int[] offset : offsets) { // 遍历四个方向
                int newX = x + offset[0]; // 新的横坐标
                int newY = y + offset[1]; // 新的纵坐标

                if (newX < 0 || newX >= n || newY < 0 || newY >= n) continue; // 判断边界

                if (matrix[newX][newY] == 0) { // 如果该区域未感染
                    healthy--; // 未感染区域数量减一
                    matrix[newX][newY] = day; // 标记该区域已感染
                    q.offer(new int[]{newX, newY}); // 将该区域加入队列
                }
            }
        }

        return day - 1; // 返回感染天数
    }
}

Javascript

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

function getResult(map) {
  const n = Math.sqrt(map.length);

  const matrix = new Array(n).fill().map(() => new Array(n)); // 将一维数组转换为二维矩阵

  const q = []; // 用队列存储感染区域

  for (let i = 0; i < n; i++) {
    for (let j = 0; j < n; j++) {
      matrix[i][j] = map[i * n + j]; // 将一维数组转换为二维矩阵
      if (matrix[i][j] === 1) q.push([i, j]); // 将感染区域加入队列
    }
  }

  if (q.length === 0 || q.length === map.length) { // 判断特殊情况
    return -1;
  }

  let healthy = map.length - q.length; // 记录未感染区域数量

  const offsets = [[-1, 0], [1, 0], [0, -1], [0, 1]]; // 记录四个方向的偏移量

  let day = 0; // 记录感染天数
  while (q.length > 0 && healthy > 0) { // 当队列不为空且还有未感染区域时，进行循环
    const [x, y] = q.shift(); // 取出队首元素
    day = matrix[x][y] + 1; // 记录感染天数

    for (const offset of offsets) { // 遍历四个方向
      const [dx, dy] = offset;
      const newX = x + dx; // 新的横坐标
      const newY = y + dy; // 新的纵坐标

      if (newX < 0 || newX >= n || newY < 0 || newY >= n) continue; // 判断边界

      if (matrix[newX][newY] === 0) { // 如果该区域未感染
        healthy--; // 未感染区域数量减一
        matrix[newX][newY] = day; // 标记该区域已感染
        q.push([newX, newY]); // 将该区域加入队列
      }
    }
  }

  return day - 1; // 返回感染天数
}

rl.on('line', (input) => {
  const map = input.split(',').map(Number);
  console.log(getResult(map));
});

C++
#include
#include
#include
#include
using namespace std;

int getResult(vector& map) {
int n = sqrt(map.size());

vector<vector<int>> matrix(n, vector<int>(n)); // 将一维数组转换为二维矩阵

queue<pair<int, int>> q; // 用队列存储感染区域

for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        matrix[i][j] = map[i * n + j]; // 将一维数组转换为二维矩阵
        if (matrix[i][j] == 1) q.push({i, j}); // 将感染区域加入队列
    }
}

if (q.empty() || q.size() == map.size()) { // 判断特殊情况
    return -1;
}

int healthy = map.size() - q.size(); // 记录未感染区域数量

vector<vector<int>> offsets = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // 记录四个方向的偏移量

int day = 0; // 记录感染天数
while (!q.empty() && healthy > 0) { // 当队列不为空且还有未感染区域时，进行循环
    pair<int, int> tmp = q.front(); // 取出队首元素
    q.pop(); // 弹出队首元素
    int x = tmp.first, y = tmp.second; // 获取队首元素的坐标
    day = matrix[x][y] + 1; // 记录感染天数

    for (vector<int>& offset : offsets) { // 遍历四个方向
        int newX = x + offset[0]; // 新的横坐标
        int newY = y + offset[1]; // 新的纵坐标

        if (newX < 0 || newX >= n || newY < 0 || newY >= n) continue; // 判断边界

        if (matrix[newX][newY] == 0) { // 如果该区域未感染
            healthy--; // 未感染区域数量减一
            matrix[newX][newY] = day; // 标记该区域已感染
            q.push({newX, newY}); // 将该区域加入队列
        }
    }
}

return day - 1; // 返回感染天数

}

int main() {
string input;
getline(cin, input);
vector map;
size_t pos = 0;
string token;
while ((pos = input.find(“,”)) != string::npos) { // 将输入字符串转换为一维数组
token = input.substr(0, pos);
map.push_back(stoi(token));
input.erase(0, pos + 1);
}
map.push_back(stoi(input));
cout << getResult(map) << endl; // 输出感染天数
return 0;
}

python

import math
from queue import Queue

def get_result(map):
    n = int(math.sqrt(len(map)))
    matrix = [[0 for j in range(n)] for i in range(n)]
    q = Queue()
    for i in range(n):
        for j in range(n):
            matrix[i][j] = map[i * n + j]
            if matrix[i][j] == 1:
                q.put((i, j))
    if q.empty() or q.qsize() == len(map):
        return -1
    healthy = len(map) - q.qsize()
    offsets = [[-1, 0], [1, 0], [0, -1], [0, 1]]
    day = 0
    while not q.empty() and healthy > 0:
        tmp = q.get()
        x, y = tmp[0], tmp[1]
        day = matrix[x][y] + 1
        for offset in offsets:
            new_x = x + offset[0]
            new_y = y + offset[1]
            if new_x < 0 or new_x >= n or new_y < 0 or new_y >= n:
                continue
            if matrix[new_x][new_y] == 0:
                healthy -= 1
                matrix[new_x][new_y] = day
                q.put((new_x, new_y))
    return day - 1

input_str = input()
input_list = list(map(int, input_str.split(",")))
print(get_result(input_list))