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))
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
