xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-08-14 04:30:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2023-12-28 17:18:37 +08:00
parent 8d49c46234
commit d1f1473539
67 changed files with 604 additions and 609 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/chapter_greedy/fractional_knapsack_problem.md
+2 -2
View File
@@ -464,7 +464,7 @@ comments: true
[class]{}-[func]{fractionalKnapsack}
```
在最差情况下，需要遍历整个物品列表，**因此时间复杂度为 $O(n)$** ，其中 $n$ 为物品数量。
除排序之外，在最差情况下，需要遍历整个物品列表，**因此时间复杂度为 $O(n)$** ，其中 $n$ 为物品数量。
由于初始化了一个 `Item` 对象列表，**因此空间复杂度为 $O(n)$** 。
@@ -476,7 +476,7 @@ comments: true
对于该解中的其他物品，我们也可以构建出上述矛盾。总而言之，**单位价值更大的物品总是更优选择**，这说明贪心策略是有效的。
如图 15-6 所示，如果将物品重量和物品单位价值分别看作一张二维图表的横轴和纵轴，则分数背包问题可转化为“求在有限横轴区间下的最大围成面积”。这个类比可以帮助我们从几何角度理解贪心策略的有效性。
如图 15-6 所示，如果将物品重量和物品单位价值分别看作一张二维图表的横轴和纵轴，则分数背包问题可转化为“求在有限横轴区间下围成的最大面积”。这个类比可以帮助我们从几何角度理解贪心策略的有效性。
![分数背包问题的几何表示](fractional_knapsack_problem.assets/fractional_knapsack_area_chart.png){ class="animation-figure" }
docs/chapter_greedy/greedy_algorithm.md
+10 -8
View File
@@ -15,7 +15,7 @@ comments: true
!!! question
给定 $n$ 种硬币，第 $i$ 种硬币的面值为 $coins[i - 1]$ ，目标金额为 $amt$ ，每种硬币可以重复选取，问能够凑出目标金额的最少硬币数量。如果无法凑出目标金额则返回 $-1$ 。
给定 $n$ 种硬币，第 $i$ 种硬币的面值为 $coins[i - 1]$ ，目标金额为 $amt$ ，每种硬币可以重复选取，问能够凑出目标金额的最少硬币数量。如果无法凑出目标金额，则返回 $-1$ 。
本题采取的贪心策略如图 15-1 所示。给定目标金额，**我们贪心地选择不大于且最接近它的硬币**，不断循环该步骤，直至凑出目标金额为止。
@@ -23,7 +23,7 @@ comments: true
<p align="center"> 图 15-1 &nbsp; 零钱兑换的贪心策略 </p>
实现代码如下所示。你可能会不由地发出感叹：So clean ！贪心算法仅用约十行代码就解决了零钱兑换问题：
实现代码如下所示：
=== "Python"
@@ -289,7 +289,9 @@ comments: true
[class]{}-[func]{coinChangeGreedy}
```
## 15.1.1 &nbsp; 贪心的优点与局限性
你可能会不由地发出感叹：So clean ！贪心算法仅用约十行代码就解决了零钱兑换问题。
## 15.1.1 &nbsp; 贪心算法的优点与局限性
**贪心算法不仅操作直接、实现简单，而且通常效率也很高**。在以上代码中，记硬币最小面值为 $\min(coins)$ ，则贪心选择最多循环 $amt / \min(coins)$ 次，时间复杂度为 $O(amt / \min(coins))$ 。这比动态规划解法的时间复杂度 $O(n \times amt)$ 提升了一个数量级。
@@ -299,9 +301,9 @@ comments: true
- **反例 $coins = [1, 20, 50]$**：假设 $amt = 60$ ，贪心算法只能找到 $50 + 1 \times 10$ 的兑换组合，共计 $11$ 枚硬币，但动态规划可以找到最优解 $20 + 20 + 20$ ，仅需 $3$ 枚硬币。
- **反例 $coins = [1, 49, 50]$**：假设 $amt = 98$ ，贪心算法只能找到 $50 + 1 \times 48$ 的兑换组合，共计 $49$ 枚硬币，但动态规划可以找到最优解 $49 + 49$ ，仅需 $2$ 枚硬币。
![贪心无法找出最优解的示例](greedy_algorithm.assets/coin_change_greedy_vs_dp.png){ class="animation-figure" }
![贪心算法无法找出最优解的示例](greedy_algorithm.assets/coin_change_greedy_vs_dp.png){ class="animation-figure" }
<p align="center"> 图 15-2 &nbsp; 贪心无法找出最优解的示例 </p>
<p align="center"> 图 15-2 &nbsp; 贪心算法无法找出最优解的示例 </p>
也就是说，对于零钱兑换问题，贪心算法无法保证找到全局最优解，并且有可能找到非常差的解。它更适合用动态规划解决。
@@ -329,9 +331,9 @@ comments: true
有一篇论文给出了一个 $O(n^3)$ 时间复杂度的算法，用于判断一个硬币组合能否使用贪心算法找出任意金额的最优解。
Pearson, David. A polynomial-time algorithm for the change-making problem. Operations Research Letters 33.3 (2005): 231-234.
Pearson, D. A polynomial-time algorithm for the change-making problem[J]. Operations Research Letters, 2005, 33(3): 231-234.
## 15.1.3 &nbsp; 贪心解题步骤
## 15.1.3 &nbsp; 贪心算法解题步骤
贪心问题的解决流程大体可分为以下三步。
@@ -348,7 +350,7 @@ comments: true
然而，正确性证明也很可能不是一件易事。如若没有头绪，我们通常会选择面向测试用例进行代码调试，一步步修改与验证贪心策略。
## 15.1.4 &nbsp; 贪心典型例题
## 15.1.4 &nbsp; 贪心算法典型例题
贪心算法常常应用在满足贪心选择性质和最优子结构的优化问题中，以下列举了一些典型的贪心算法问题。
docs/chapter_greedy/max_capacity_problem.md
+13 -13
View File
@@ -48,11 +48,11 @@ $$
<p align="center"> 图 15-10 &nbsp; 向内移动短板后的状态 </p>
由此便可推出本题的贪心策略：初始化两指针分列容器两端，每轮向内收缩短板对应的指针，直至两指针相遇。
由此便可推出本题的贪心策略：初始化两指针，使其分列容器两端，每轮向内收缩短板对应的指针，直至两指针相遇。
图 15-11 展示了贪心策略的执行过程。
1. 初始状态下，指针 $i$ 和 $j$ 分列与数组两端。
1. 初始状态下，指针 $i$ 和 $j$ 分列数组两端。
2. 计算当前状态的容量 $cap[i, j]$ ，并更新最大容量。
3. 比较板 $i$ 和 板 $j$ 的高度，并将短板向内移动一格。
4. 循环执行第 `2.` 步和第 `3.` 步，直至 $i$ 和 $j$ 相遇时结束。
@@ -97,7 +97,7 @@ $$
```python title="max_capacity.py"
def max_capacity(ht: list[int]) -> int:
"""最大容量：贪心"""
# 初始化 i, j 分列数组两端
# 初始化 i, j，使其分列数组两端
i, j = 0, len(ht) - 1
# 初始最大容量为 0
res = 0
@@ -119,7 +119,7 @@ $$
```cpp title="max_capacity.cpp"
/* 最大容量：贪心 */
int maxCapacity(vector<int> &ht) {
// 初始化 i, j 分列数组两端
// 初始化 i, j，使其分列数组两端
int i = 0, j = ht.size() - 1;
// 初始最大容量为 0
int res = 0;
@@ -144,7 +144,7 @@ $$
```java title="max_capacity.java"
/* 最大容量：贪心 */
int maxCapacity(int[] ht) {
// 初始化 i, j 分列数组两端
// 初始化 i, j，使其分列数组两端
int i = 0, j = ht.length - 1;
// 初始最大容量为 0
int res = 0;
@@ -169,7 +169,7 @@ $$
```csharp title="max_capacity.cs"
/* 最大容量：贪心 */
int MaxCapacity(int[] ht) {
// 初始化 i, j 分列数组两端
// 初始化 i, j，使其分列数组两端
int i = 0, j = ht.Length - 1;
// 初始最大容量为 0
int res = 0;
@@ -194,7 +194,7 @@ $$
```go title="max_capacity.go"
/* 最大容量：贪心 */
func maxCapacity(ht []int) int {
// 初始化 i, j 分列数组两端
// 初始化 i, j，使其分列数组两端
i, j := 0, len(ht)-1
// 初始最大容量为 0
res := 0
@@ -219,7 +219,7 @@ $$
```swift title="max_capacity.swift"
/* 最大容量：贪心 */
func maxCapacity(ht: [Int]) -> Int {
// 初始化 i, j 分列数组两端
// 初始化 i, j，使其分列数组两端
var i = 0, j = ht.count - 1
// 初始最大容量为 0
var res = 0
@@ -244,7 +244,7 @@ $$
```javascript title="max_capacity.js"
/* 最大容量：贪心 */
function maxCapacity(ht) {
// 初始化 i, j 分列数组两端
// 初始化 i, j，使其分列数组两端
let i = 0,
j = ht.length - 1;
// 初始最大容量为 0
@@ -270,7 +270,7 @@ $$
```typescript title="max_capacity.ts"
/* 最大容量：贪心 */
function maxCapacity(ht: number[]): number {
// 初始化 i, j 分列数组两端
// 初始化 i, j，使其分列数组两端
let i = 0,
j = ht.length - 1;
// 初始最大容量为 0
@@ -296,7 +296,7 @@ $$
```dart title="max_capacity.dart"
/* 最大容量：贪心 */
int maxCapacity(List<int> ht) {
// 初始化 i, j 分列数组两端
// 初始化 i, j，使其分列数组两端
int i = 0, j = ht.length - 1;
// 初始最大容量为 0
int res = 0;
@@ -321,7 +321,7 @@ $$
```rust title="max_capacity.rs"
/* 最大容量：贪心 */
fn max_capacity(ht: &[i32]) -> i32 {
// 初始化 i, j 分列数组两端
// 初始化 i, j，使其分列数组两端
let mut i = 0;
let mut j = ht.len() - 1;
// 初始最大容量为 0
@@ -347,7 +347,7 @@ $$
```c title="max_capacity.c"
/* 最大容量：贪心 */
int maxCapacity(int ht[], int htLength) {
// 初始化 i, j 分列数组两端
// 初始化 i, j，使其分列数组两端
int i = 0;
int j = htLength - 1;
// 初始最大容量为 0
docs/chapter_greedy/max_product_cutting_problem.md
+1 -1
View File
@@ -60,7 +60,7 @@ $$
1. 输入整数 $n$ ，从其不断地切分出因子 $3$ ，直至余数为 $0$、$1$、$2$ 。
2. 当余数为 $0$ 时，代表 $n$ 是 $3$ 的倍数，因此不做任何处理。
3. 当余数为 $2$ 时，不继续划分，保留之。
3. 当余数为 $2$ 时，不继续划分，保留。
4. 当余数为 $1$ 时，由于 $2 \times 2 > 1 \times 3$ ，因此应将最后一个 $3$ 替换为 $2$ 。
### 2. &nbsp; 代码实现
docs/chapter_greedy/summary.md
+1 -1
View File
@@ -13,4 +13,4 @@ comments: true
- 求解贪心问题主要分为三步：问题分析、确定贪心策略、正确性证明。其中，确定贪心策略是核心步骤，正确性证明往往是难点。
- 分数背包问题在 0-1 背包的基础上，允许选择物品的一部分，因此可使用贪心算法求解。贪心策略的正确性可以使用反证法来证明。
- 最大容量问题可使用穷举法求解，时间复杂度为 $O(n^2)$ 。通过设计贪心策略，每轮向内移动短板，可将时间复杂度优化至 $O(n)$ 。
- 在最大切分乘积问题中，我们先后推理出两个贪心策略：$\geq 4$ 的整数都应该继续切分、最优切分因子为 $3$ 。代码中包含幂运算，时间复杂度取决于幂运算实现方法，通常为 $O(1)$ 或 $O(\log n)$ 。
- 在最大切分乘积问题中，我们先后推理出两个贪心策略：$\geq 4$ 的整数都应该继续切分，最优切分因子为 $3$ 。代码中包含幂运算，时间复杂度取决于幂运算实现方法，通常为 $O(1)$ 或 $O(\log n)$ 。