### 问题解析
“孙悟空吃
蟠桃”是一道经典的二
分查找算法题，目标是找到孙悟空能在H小时内吃完所有桃子的最小速度K。此问题可以通过二
分查找来优化求解过程[^1]。以下是详细的解题思路和代码实现。
---
### 解题思路
1. **确定搜索范围**
- 最小速度为1（因为速度不能为0），最大速度为所有桃树中最多的
蟠桃数量的最大值。因此，搜索范围为 `[1, max
(peaches
)]`。
2. **验证中间速度是否可行**
- 对于某个速度 `mid`，计算在该速度下需要的时间总和。如果总时间小于等于H，则说明速度 `mid` 是可行的，尝试寻找更小的速度；否则，尝试更大的速度。
3. **二
分查找**
- 使用二
分查找不断缩小搜索范围，直到找到满足条件的最小速度K。
4. **特殊情况处理**
- 如果任何速度都无法满足在H小时内吃完所有桃子，则返回0。
---
### Python代码实现
```python
def min_eating_speed
(peaches, H
):
# 定义检查函数，判断以speed速度是否可以在H小时内吃完所有桃子
def can_finish
(speed
):
hours = 0
for p in peaches:
hours +=
(p + speed
- 1
) // speed # 向上取整
return hours <= H
# 确定二
分查找的左右边界
left, right = 1, max
(peaches
)
result = 0
while left <= right:
mid =
(left + right
) // 2
if can_finish
(mid
):
result = mid
right = mid
- 1 # 尝试寻找更小的速度
else:
left = mid + 1 # 增大速度
return result if result > 0 else 0
# 测试用例
peaches = [3, 6,
7, 11]
H = 8
print
(min_eating_speed
(peaches, H
)) # 输出结果为4
```
---
### Java代码实现
```java
import java.util.Arrays;
public class MonkeyEatingPeaches {
public static int minEatingSpeed
(int[] peaches, int H
) {
// 定义检查函数，判断以speed速度是否可以在H小时内吃完所有桃子
java.util.function.IntPredicate canFinish = speed
-> {
int hours = 0;
for
(int p : peaches
) {
hours +=
(p + speed
- 1
) / speed; // 向上取整
}
return hours <= H;
};
// 确定二
分查找的左右边界
int left = 1, right = Arrays.stream
(peaches
).max
().getAsInt
();
int result = 0;
while
(left <= right
) {
int mid = left +
(right
- left
) / 2;
if
(canFinish.test
(mid
)) {
result = mid;
right = mid
- 1; // 尝试寻找更小的速度
} else {
left = mid + 1; // 增大速度
}
}
return result > 0 ? result : 0;
}
public static void main
(String[] args
) {
int[] peaches = {3, 6,
7, 11};
int H = 8;
System.out.println
(minEatingSpeed
(peaches, H
)); // 输出结果为4
}
}
```
---
### C++代码实现
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int minEatingSpeed
(vector<int>& peaches, int H
) {
// 定义检查函数，判断以speed速度是否可以在H小时内吃完所有桃子
auto canFinish = [&]
(int speed
) -> bool {
long long hours = 0;
for
(auto p : peaches
) {
hours +=
(p + speed
- 1
) / speed; // 向上取整
}
return hours <= H;
};
// 确定二
分查找的左右边界
int left = 1, right = *max_element
(peaches.begin
(), peaches.end
());
int result = 0;
while
(left <= right
) {
int mid = left +
(right
- left
) / 2;
if
(canFinish
(mid
)) {
result = mid;
right = mid
- 1; // 尝试寻找更小的速度
} else {
left = mid + 1; // 增大速度
}
}
return result > 0 ? result : 0;
}
int main
() {
vector<int> peaches = {3, 6,
7, 11};
int H = 8;
cout << minEatingSpeed
(peaches, H
) << endl; // 输出结果为4
return 0;
}
```
---
### JavaScript代码实现
```javascript
function minEatingSpeed
(peaches, H
) {
// 定义检查函数，判断以speed速度是否可以在H小时内吃完所有桃子
function canFinish
(speed
) {
let hours = 0;
for
(let p of peaches
) {
hours += Math.ceil
(p / speed
); // 向上取整
}
return hours <= H;
}
// 确定二
分查找的左右边界
let left = 1, right = Math.max
(...peaches
);
let result = 0;
while
(left <= right
) {
let mid = Math.floor
((left + right
) / 2
);
if
(canFinish
(mid
)) {
result = mid;
right = mid
- 1; // 尝试寻找更小的速度
} else {
left = mid + 1; // 增大速度
}
}
return result > 0 ? result : 0;
}
// 测试用例
let peaches = [3, 6,
7, 11];
let H = 8;
console.log
(minEatingSpeed
(peaches, H
)); // 输出结果为4
```
---
###
本文通过解决孙悟空大闹蟠桃园的难题，计算出第一天有多少桃子：当第n天仅剩一个桃子时，原来一共有4*(2^n)个。
扫一扫
19万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
