专栏导读
本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。
一、题目描述
停车场有一横排车位，0代表没有停车，1代表有车。至少停了一辆车在车位上，也至少有一个空位没有停车。
为了防剐蹭，需为停车人找到一个车位，使得距停车人的车最近的车辆的距离是最大的，返回此时的最大距离。
二、输入描述
1、一个用半角逗号分割的停车标识字符串，停车标识为0或1，0为空位，1为已停车。
2、停车位最多100个。
三、输出描述
输出一个整数记录最大距离。
四、测试用例
测试用例1
1、输入
1,0,0,0,1
2、输出
2
3、说明
停车场状态 [1, 0, 0, 0, 1]。
若停在索引1 (0): 左侧车(索引0)距离1, 右侧车(索引4)距离3。最近距离是 min(1,3) = 1。
若停在索引2 (0): 左侧车(索引0)距离2, 右侧车(索引4)距离2。最近距离是 min(2,2) = 2。
若停在索引3 (0): 左侧车(索引0)距离3, 右侧车(索引4)距离1。最近距离是 min(3,1) = 1。 这些最近距离中的最大值是2。
测试用例2
1、输入
0,0,1,0,0
2、输出
2
3、说明
停车场状态 [0, 0, 1, 0, 0]。
若停在索引0 (0): 最近的车在索引2, 距离为 2-0 = 2。
若停在索引1 (0): 最近的车在索引2, 距离为 2-1 = 1。
若停在索引3 (0): 最近的车在索引2, 距离为 3-2 = 1。
若停在索引4 (0): 最近的车在索引2, 距离为 4-2 = 2。 这些最近距离中的最大值是2。
五、解题思路
1、核心思路
题目要求找到一个空车位，使得如果我们选择停在这个空位上，那么这个新停的车距离它左右两边最近的已有车辆的距离是最大的。换句话说，对于每一个空车位，我们计算它到左边最近车的距离和到右边最近车的距离，取这两者中的较小值（这就是如果我们停在这个空位，能保证的最小安全距离）。然后，在所有空位计算出的这些“最小安全距离”中，找到一个最大的值。
2、详细步骤
- 输入处理:
- 通过 Scanner 读取控制台输入的一行字符串。
- 使用 String.split(“,”) 方法将字符串按逗号分割，得到每个车位状态的字符串表示。
- 将这些字符串转换为整数 0 或 1，并存储到 spots 数组中。
- 遍历寻找最优空位:
- 初始化一个变量 maxOverallMinDistance = 0，用来记录最终要输出的最大距离。
- 遍历 spots 数组中的每一个车位（索引 i）。
- 判断是否为空位: 如果 spots[i] 为 0，则这是一个可以考虑的空位。
- 为这个空位 i 初始化一个 currentSpotMinDistToCar = Integer.MAX_VALUE，表示如果停在这里，它到最近车的距离。
- 向左查找: 从 i-1 开始向左遍历，找到第一个值为 1 的车位（即左边最近的车）。计算距离 distLeft = i - (左车索引)。如果左边没有车，distLeft 保持为一个极大值（或标记为无穷大）。
- 向右查找: 从 i+1 开始向右遍历，找到第一个值为 1 的车位（即右边最近的车）。计算距离 distRight = (右车索引) - i。如果右边没有车，distRight 保持为一个极大值。
- 确定当前空位的最小距离:
- 如果左右都有车，currentSpotMinDistToCar = Math.min(distLeft, distRight)。
- 如果只有左边有车，currentSpotMinDistToCar = distLeft。
- 如果只有右边有车，currentSpotMinDistToCar = distRight。 (根据题目“至少停了一辆车”，一个空位至少能在一侧找到车，所以 currentSpotMinDistToCar 一定会被有效赋值。)
- 更新全局最大值: maxOverallMinDistance = Math.max(maxOverallMinDistance, currentSpotMinDistToCar)。
- 输出结果: 打印 maxOverallMinDistance。
六、Python算法源码
# 读取控制台输入的一行字符串
line = input()
# 使用逗号作为分隔符，将输入字符串分割成字符串列表
parts = line.split(',')
# 获取停车位的总数
n = len(parts)
# 创建一个整型列表用于存储每个停车位的状态 (0或1)
spots = [0] * n
# 将字符串列表中的每个元素转换为整数，并存入spots列表
for i in range(n):
spots[i] = int(parts[i].strip()) # strip()确保去除可能存在的空格
max_overall_min_distance = 0 # 初始化最终结果：最大化的“最近车辆距离”
# 遍历每一个停车位，寻找空位 (0)
for i in range(n):
if spots[i] == 0: # 如果当前车位是空的
# 初始化当前空位到最近车辆的最小距离 (用一个很大的数代表无穷远)
current_spot_min_dist_to_car = float('inf')
# 1. 查找左边最近的已停车车辆 (1)
dist_left = float('inf') # 初始化到左边车的距离为极大值
for j in range(i - 1, -1, -1): # 从当前空位的左侧开始向左搜索 (range(start, stop, step))
if spots[j] == 1: # 如果找到一辆车
dist_left = i - j # 计算距离
break # 找到最近的即可，停止搜索
# 2. 查找右边最近的已停车车辆 (1)
dist_right = float('inf') # 初始化到右边车的距离为极大值
for j in range(i + 1, n): # 从当前空位的右侧开始向右搜索
if spots[j] == 1: # 如果找到一辆车
dist_right = j - i # 计算距离
break # 找到最近的即可，停止搜索
# 确定当前空位的“最近车辆距离”
# 由于题目保证至少有一辆车，所以 dist_left 和 dist_right 不会同时为 'inf'
if dist_left != float('inf') and dist_right != float('inf'):
# 如果左右两边都有车，取较小的距离
current_spot_min_dist_to_car = min(dist_left, dist_right)
elif dist_left != float('inf'):
# 如果只有左边有车
current_spot_min_dist_to_car = dist_left
elif dist_right != float('inf'):
# 如果只有右边有车
current_spot_min_dist_to_car = dist_right
# 更新全局的“最大化的最近车辆距离”
if current_spot_min_dist_to_car > max_overall_min_distance:
max_overall_min_distance = current_spot_min_dist_to_car
# 输出最终计算得到的最大距离
print(max_overall_min_distance)
七、JavaScript算法源码
// Node.js中用于读取标准输入的模块
const readline = require('readline');
// 创建readline接口实例
const rl = readline.createInterface({
input: process.stdin, // 从标准输入读取
output: process.stdout, // 输出到标准输出 (虽然这里不用它直接输出提示)
terminal: false // 表明不是一个 TTY 终端交互，适合管道输入
});
rl.on('line', (line) => { // 当读取到一行输入时触发
const parts = line.split(','); // 使用逗号作为分隔符，将输入字符串分割成字符串数组
const n = parts.length; // 获取停车位的总数
const spots = new Array(n); // 创建一个数组用于存储每个停车位的状态
// 将字符串数组中的每个元素转换为整数，并存入spots数组
for (let i = 0; i < n; i++) {
spots[i] = parseInt(parts[i].trim(), 10); // trim()去除空格, 10表示十进制解析
}
let maxOverallMinDistance = 0; // 初始化最终结果：最大化的“最近车辆距离”
// 遍历每一个停车位，寻找空位 (0)
for (let i = 0; i < n; i++) {
if (spots[i] === 0) { // 如果当前车位是空的 (使用 === 进行严格比较)
let currentSpotMinDistToCar = Infinity; // 初始化当前空位到最近车辆的最小距离
// 1. 查找左边最近的已停车车辆 (1)
let distLeft = Infinity; // 初始化到左边车的距离为无穷大
for (let j = i - 1; j >= 0; j--) { // 从当前空位的左侧开始向左搜索
if (spots[j] === 1) { // 如果找到一辆车
distLeft = i - j; // 计算距离
break; // 找到最近的即可，停止搜索
}
}
// 2. 查找右边最近的已停车车辆 (1)
let distRight = Infinity; // 初始化到右边车的距离为无穷大
for (let j = i + 1; j < n; j++) { // 从当前空位的右侧开始向右搜索
if (spots[j] === 1) { // 如果找到一辆车
distRight = j - i; // 计算距离
break; // 找到最近的即可，停止搜索
}
}
// 确定当前空位的“最近车辆距离”
// 由于题目保证至少有一辆车，所以 distLeft 和 distRight 不会同时为 Infinity
if (distLeft !== Infinity && distRight !== Infinity) {
// 如果左右两边都有车，取较小的距离
currentSpotMinDistToCar = Math.min(distLeft, distRight);
} else if (distLeft !== Infinity) {
// 如果只有左边有车
currentSpotMinDistToCar = distLeft;
} else if (distRight !== Infinity) {
// 如果只有右边有车
currentSpotMinDistToCar = distRight;
}
// 更新全局的“最大化的最近车辆距离”
if (currentSpotMinDistToCar > maxOverallMinDistance) {
maxOverallMinDistance = currentSpotMinDistToCar;
}
}
}
console.log(maxOverallMinDistance); // 输出最终计算得到的最大距离
rl.close(); // 关闭readline接口
});
八、C算法源码
#include <stdio.h> // 引入标准输入输出库 (printf, fgets, sscanf)
#include <string.h> // 引入字符串处理库 (strtok, strlen)
#include <stdlib.h> // 引入标准库 (atoi)
#include <limits.h> // 引入整型限制库 (INT_MAX)
#define MAX_SPOTS 100 // 定义停车位最大数量
int main() {
char line[MAX_SPOTS * 2 + 1]; // 输入行缓冲区，考虑到逗号和数字字符，以及末尾的\0
int spots[MAX_SPOTS]; // 存储停车位状态的数组
int n = 0; // 停车位实际数量
// 读取一整行输入，fgets 比 scanf("%s", line) 更安全，可以防止缓冲区溢出
if (fgets(line, sizeof(line), stdin) != NULL) {
// 移除 fgets 可能读入的换行符
size_t len = strlen(line);
if (len > 0 && line[len - 1] == '\n') {
line[len - 1] = '\0';
}
// 使用 strtok 分割字符串
char *token = strtok(line, ","); // 获取第一个token
while (token != NULL && n < MAX_SPOTS) { // 循环直到没有token或达到数组上限
spots[n++] = atoi(token); // 将token转换为整数并存入数组，然后n自增
token = strtok(NULL, ","); // 获取下一个token
}
} else {
return 1; // 读取失败则退出
}
int max_overall_min_distance = 0; // 初始化最终结果：最大化的“最近车辆距离”
// 遍历每一个停车位，寻找空位 (0)
for (int i = 0; i < n; i++) {
if (spots[i] == 0) { // 如果当前车位是空的
int current_spot_min_dist_to_car = INT_MAX; // 初始化当前空位到最近车辆的最小距离为极大值
// 1. 查找左边最近的已停车车辆 (1)
int dist_left = INT_MAX; // 初始化到左边车的距离为极大值
for (int j = i - 1; j >= 0; j--) { // 从当前空位的左侧开始向左搜索
if (spots[j] == 1) { // 如果找到一辆车
dist_left = i - j; // 计算距离
break; // 找到最近的即可，停止搜索
}
}
// 2. 查找右边最近的已停车车辆 (1)
int dist_right = INT_MAX; // 初始化到右边车的距离为极大值
for (int j = i + 1; j < n; j++) { // 从当前空位的右侧开始向右搜索
if (spots[j] == 1) { // 如果找到一辆车
dist_right = j - i; // 计算距离
break; // 找到最近的即可，停止搜索
}
}
// 确定当前空位的“最近车辆距离”
// 由于题目保证至少有一辆车，所以 dist_left 和 dist_right 不会同时为 INT_MAX
if (dist_left != INT_MAX && dist_right != INT_MAX) {
// 如果左右两边都有车，取较小的距离
current_spot_min_dist_to_car = (dist_left < dist_right) ? dist_left : dist_right;
} else if (dist_left != INT_MAX) {
// 如果只有左边有车
current_spot_min_dist_to_car = dist_left;
} else if (dist_right != INT_MAX) {
// 如果只有右边有车
current_spot_min_dist_to_car = dist_right;
}
// 更新全局的“最大化的最近车辆距离”
if (current_spot_min_dist_to_car > max_overall_min_distance && current_spot_min_dist_to_car != INT_MAX) {
// 确保 current_spot_min_dist_to_car 被有效赋值过
max_overall_min_distance = current_spot_min_dist_to_car;
}
}
}
printf("%d\n", max_overall_min_distance); // 输出最终计算得到的最大距离
return 0; // 程序正常结束
}
九、C++算法源码
#include <iostream> // 引入输入输出流库 (std::cin, std::cout)
#include <vector> // 引入动态数组库 (std::vector)
#include <string> // 引入字符串库 (std::string)
#include <sstream> // 引入字符串流库 (std::stringstream)
#include <algorithm> // 引入算法库 (std::min, std::max)
#include <limits> // 引入数值极限库 (std::numeric_limits)
int main() {
std::string line; // 用于存储从控制台读取的一行输入
std::cin >> line; // 从标准输入读取一行到line变量
std::vector<int> spots; // 创建一个整型动态数组用于存储停车位状态
std::stringstream ss(line); // 创建一个字符串流，用输入行初始化
std::string segment; // 用于存储按逗号分割后的每一小段字符串
// 使用getline配合stringstream按逗号分割字符串
while (std::getline(ss, segment, ',')) {
spots.push_back(std::stoi(segment)); // 将分割出的字符串转换为整数并添加到vector末尾
}
int n = spots.size(); // 获取停车位的总数
int max_overall_min_distance = 0; // 初始化最终结果：最大化的“最近车辆距离”
// 遍历每一个停车位，寻找空位 (0)
for (int i = 0; i < n; ++i) { // C++中常用 ++i
if (spots[i] == 0) { // 如果当前车位是空的
// 初始化当前空位到最近车辆的最小距离为整型最大值
int current_spot_min_dist_to_car = std::numeric_limits<int>::max();
// 1. 查找左边最近的已停车车辆 (1)
int dist_left = std::numeric_limits<int>::max(); // 初始化到左边车的距离为极大值
for (int j = i - 1; j >= 0; --j) { // 从当前空位的左侧开始向左搜索
if (spots[j] == 1) { // 如果找到一辆车
dist_left = i - j; // 计算距离
break; // 找到最近的即可，停止搜索
}
}
// 2. 查找右边最近的已停车车辆 (1)
int dist_right = std::numeric_limits<int>::max(); // 初始化到右边车的距离为极大值
for (int j = i + 1; j < n; ++j) { // 从当前空位的右侧开始向右搜索
if (spots[j] == 1) { // 如果找到一辆车
dist_right = j - i; // 计算距离
break; // 找到最近的即可，停止搜索
}
}
// 确定当前空位的“最近车辆距离”
// 由于题目保证至少有一辆车，所以 dist_left 和 dist_right 不会同时为极大值
bool has_left_car = (dist_left != std::numeric_limits<int>::max());
bool has_right_car = (dist_right != std::numeric_limits<int>::max());
if (has_left_car && has_right_car) {
// 如果左右两边都有车，取较小的距离
current_spot_min_dist_to_car = std::min(dist_left, dist_right);
} else if (has_left_car) {
// 如果只有左边有车
current_spot_min_dist_to_car = dist_left;
} else if (has_right_car) {
// 如果只有右边有车
current_spot_min_dist_to_car = dist_right;
}
// else current_spot_min_dist_to_car 保持极大值, 但这不应发生
// 更新全局的“最大化的最近车辆距离”
if (current_spot_min_dist_to_car > max_overall_min_distance && current_spot_min_dist_to_car != std::numeric_limits<int>::max()) {
// 确保 current_spot_min_dist_to_car 被有效赋值过
max_overall_min_distance = current_spot_min_dist_to_car;
}
}
}
std::cout << max_overall_min_distance << std::endl; // 输出最终计算得到的最大距离
return 0; // 程序正常结束
}
🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2025 B卷 200分）
🏆本文收录于，华为OD机试真题（Python/JS/C/C++）
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。
扫一扫
1639
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
