CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-07-07 19:46:29 +08:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2026-03-29 02:26:00 +08:00
parent 63276d36d9
commit 37523d4ceb
118 changed files with 74250 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files

488
ru/docs/chapter_divide_and_conquer/binary_search_recur.md Normal file
View File

@@ -0,0 +1,488 @@
---
comments: true
---
# 12.2   Поисковая стратегия divide and conquer
Мы уже знаем, что алгоритмы поиска делятся на две большие категории.
- **Полный перебор**: реализуется через обход структуры данных, временная сложность равна $O(n)$ .
- **Адаптивный поиск**: использует особую организацию данных или априорную информацию, временная сложность может достигать $O(\log n)$ и даже $O(1)$ .
На практике **алгоритмы поиска с временной сложностью $O(\log n)$ обычно реализуются на основе стратегии divide and conquer**, например двоичный поиск и деревья.
- На каждом шаге двоичный поиск раскладывает задачу (поиск целевого элемента в массиве) на более мелкую задачу (поиск целевого элемента в одной половине массива), и этот процесс продолжается, пока массив не станет пустым или пока не будет найден целевой элемент.
- Деревья являются типичными представителями идей divide and conquer; в таких структурах данных, как двоичное дерево поиска, AVL-дерево и куча, временная сложность различных операций равна $O(\log n)$ .
Стратегия divide and conquer для двоичного поиска выглядит следующим образом.
- **Задача раскладывается на части**: двоичный поиск рекурсивно разбивает исходную задачу (поиск в массиве) на подзадачу (поиск в одной половине массива), и это достигается сравнением среднего элемента с целевым значением.
- **Подзадачи независимы**: в двоичном поиске на каждом шаге обрабатывается только одна подзадача, и она не зависит от других подзадач.
- **Решения подзадач не нужно объединять**: двоичный поиск нацелен на поиск конкретного элемента, поэтому объединять решения подзадач не требуется. Как только подзадача решена, одновременно считается решенной и исходная задача.
По сути divide and conquer повышает эффективность поиска потому, что при полном переборе за один шаг удается исключить только один вариант, **тогда как при поиске на основе divide and conquer за один шаг можно исключить половину вариантов**.
### 1.   Реализация двоичного поиска на основе divide and conquer
В предыдущих главах двоичный поиск реализовывался через итерацию. Теперь реализуем его с помощью divide and conquer, то есть через рекурсию.
!!! question
Дан отсортированный массив `nums` длины $n$ , в котором все элементы уникальны. Найдите элемент `target` .
С точки зрения divide and conquer обозначим подзадачу, соответствующую интервалу поиска $[i, j]$ , через $f(i, j)$ .
Начиная с исходной задачи $f(0, n-1)$ , выполняем двоичный поиск по следующим шагам.
1. Вычислить середину $m$ интервала поиска $[i, j]$ и с ее помощью исключить половину интервала.
2. Рекурсивно решить подзадачу вдвое меньшего размера; это может быть либо $f(i, m-1)$ , либо $f(m+1, j)$ .
3. Повторять шаг `1.` и шаг `2.` , пока не будет найден `target` или пока интервал не станет пустым.
На рисунке 12-4 показан процесс применения divide and conquer для поиска элемента $6$ в массиве.
![Процесс двоичного поиска в стиле divide and conquer](binary_search_recur.assets/binary_search_recur.png){ class="animation-figure" }
<p align="center"> Рисунок 12-4 &nbsp; Процесс двоичного поиска в стиле divide and conquer </p>
В реализации кода мы объявляем рекурсивную функцию `dfs()` для решения задачи $f(i, j)$ :
=== "Python"
```python title="binary_search_recur.py"
def dfs(nums: list[int], target: int, i: int, j: int) -> int:
"""Бинарный поиск: задача f(i, j)"""
# Если интервал пуст, целевой элемент отсутствует, вернуть -1
if i > j:
return -1
# Вычислить индекс середины m
m = (i + j) // 2
if nums[m] < target:
# Рекурсивная подзадача f(m+1, j)
return dfs(nums, target, m + 1, j)
elif nums[m] > target:
# Рекурсивная подзадача f(i, m-1)
return dfs(nums, target, i, m - 1)
else:
# Целевой элемент найден, вернуть его индекс
return m
def binary_search(nums: list[int], target: int) -> int:
"""Бинарный поиск"""
n = len(nums)
# Решить задачу f(0, n-1)
return dfs(nums, target, 0, n - 1)
```
=== "C++"
```cpp title="binary_search_recur.cpp"
/* Бинарный поиск: задача f(i, j) */
int dfs(vector<int> &nums, int target, int i, int j) {
// Если интервал пуст, целевой элемент отсутствует, вернуть -1
if (i > j) {
return -1;
}
// Вычислить индекс середины m
int m = (i + j) / 2;
if (nums[m] < target) {
// Рекурсивная подзадача f(m+1, j)
return dfs(nums, target, m + 1, j);
} else if (nums[m] > target) {
// Рекурсивная подзадача f(i, m-1)
return dfs(nums, target, i, m - 1);
} else {
// Целевой элемент найден, вернуть его индекс
return m;
}
}
/* Бинарный поиск */
int binarySearch(vector<int> &nums, int target) {
int n = nums.size();
// Решить задачу f(0, n-1)
return dfs(nums, target, 0, n - 1);
}
```
=== "Java"
```java title="binary_search_recur.java"
/* Бинарный поиск: задача f(i, j) */
int dfs(int[] nums, int target, int i, int j) {
// Если интервал пуст, целевой элемент отсутствует, вернуть -1
if (i > j) {
return -1;
}
// Вычислить индекс середины m
int m = (i + j) / 2;
if (nums[m] < target) {
// Рекурсивная подзадача f(m+1, j)
return dfs(nums, target, m + 1, j);
} else if (nums[m] > target) {
// Рекурсивная подзадача f(i, m-1)
return dfs(nums, target, i, m - 1);
} else {
// Целевой элемент найден, вернуть его индекс
return m;
}
}
/* Бинарный поиск */
int binarySearch(int[] nums, int target) {
int n = nums.length;
// Решить задачу f(0, n-1)
return dfs(nums, target, 0, n - 1);
}
```
=== "C#"
```csharp title="binary_search_recur.cs"
/* Бинарный поиск: задача f(i, j) */
int DFS(int[] nums, int target, int i, int j) {
// Если интервал пуст, целевой элемент отсутствует, вернуть -1
if (i > j) {
return -1;
}
// Вычислить индекс середины m
int m = (i + j) / 2;
if (nums[m] < target) {
// Рекурсивная подзадача f(m+1, j)
return DFS(nums, target, m + 1, j);
} else if (nums[m] > target) {
// Рекурсивная подзадача f(i, m-1)
return DFS(nums, target, i, m - 1);
} else {
// Целевой элемент найден, вернуть его индекс
return m;
}
}
/* Бинарный поиск */
int BinarySearch(int[] nums, int target) {
int n = nums.Length;
// Решить задачу f(0, n-1)
return DFS(nums, target, 0, n - 1);
}
```
=== "Go"
```go title="binary_search_recur.go"
/* Бинарный поиск: задача f(i, j) */
func dfs(nums []int, target, i, j int) int {
// Если интервал пуст, это означает отсутствие целевого элемента, вернуть -1
if i > j {
return -1
}
// Вычислить средний индекс
m := i + ((j - i) >> 1)
// Сравнить середину и целевой элемент
if nums[m] < target {
// Если меньше, рекурсивно обрабатывать правую половину массива
// Рекурсивная подзадача f(m+1, j)
return dfs(nums, target, m+1, j)
} else if nums[m] > target {
// Если больше, рекурсивно обработать левую половину массива
// Рекурсивная подзадача f(i, m-1)
return dfs(nums, target, i, m-1)
} else {
// Целевой элемент найден, вернуть его индекс
return m
}
}
/* Бинарный поиск */
func binarySearch(nums []int, target int) int {
n := len(nums)
return dfs(nums, target, 0, n-1)
}
```
=== "Swift"
```swift title="binary_search_recur.swift"
/* Бинарный поиск: задача f(i, j) */
func dfs(nums: [Int], target: Int, i: Int, j: Int) -> Int {
// Если интервал пуст, целевой элемент отсутствует, вернуть -1
if i > j {
return -1
}
// Вычислить индекс середины m
let m = (i + j) / 2
if nums[m] < target {
// Рекурсивная подзадача f(m+1, j)
return dfs(nums: nums, target: target, i: m + 1, j: j)
} else if nums[m] > target {
// Рекурсивная подзадача f(i, m-1)
return dfs(nums: nums, target: target, i: i, j: m - 1)
} else {
// Целевой элемент найден, вернуть его индекс
return m
}
}
/* Бинарный поиск */
func binarySearch(nums: [Int], target: Int) -> Int {
// Решить задачу f(0, n-1)
dfs(nums: nums, target: target, i: nums.startIndex, j: nums.endIndex - 1)
}
```
=== "JS"
```javascript title="binary_search_recur.js"
/* Бинарный поиск: задача f(i, j) */
function dfs(nums, target, i, j) {
// Если интервал пуст, целевой элемент отсутствует, вернуть -1
if (i > j) {
return -1;
}
// Вычислить индекс середины m
const m = i + ((j - i) >> 1);
if (nums[m] < target) {
// Рекурсивная подзадача f(m+1, j)
return dfs(nums, target, m + 1, j);
} else if (nums[m] > target) {
// Рекурсивная подзадача f(i, m-1)
return dfs(nums, target, i, m - 1);
} else {
// Целевой элемент найден, вернуть его индекс
return m;
}
}
/* Бинарный поиск */
function binarySearch(nums, target) {
const n = nums.length;
// Решить задачу f(0, n-1)
return dfs(nums, target, 0, n - 1);
}
```
=== "TS"
```typescript title="binary_search_recur.ts"
/* Бинарный поиск: задача f(i, j) */
function dfs(nums: number[], target: number, i: number, j: number): number {
// Если интервал пуст, целевой элемент отсутствует, вернуть -1
if (i > j) {
return -1;
}
// Вычислить индекс середины m
const m = i + ((j - i) >> 1);
if (nums[m] < target) {
// Рекурсивная подзадача f(m+1, j)
return dfs(nums, target, m + 1, j);
} else if (nums[m] > target) {
// Рекурсивная подзадача f(i, m-1)
return dfs(nums, target, i, m - 1);
} else {
// Целевой элемент найден, вернуть его индекс
return m;
}
}
/* Бинарный поиск */
function binarySearch(nums: number[], target: number): number {
const n = nums.length;
// Решить задачу f(0, n-1)
return dfs(nums, target, 0, n - 1);
}
```
=== "Dart"
```dart title="binary_search_recur.dart"
/* Бинарный поиск: задача f(i, j) */
int dfs(List<int> nums, int target, int i, int j) {
// Если интервал пуст, целевой элемент отсутствует, вернуть -1
if (i > j) {
return -1;
}
// Вычислить индекс середины m
int m = (i + j) ~/ 2;
if (nums[m] < target) {
// Рекурсивная подзадача f(m+1, j)
return dfs(nums, target, m + 1, j);
} else if (nums[m] > target) {
// Рекурсивная подзадача f(i, m-1)
return dfs(nums, target, i, m - 1);
} else {
// Целевой элемент найден, вернуть его индекс
return m;
}
}
/* Бинарный поиск */
int binarySearch(List<int> nums, int target) {
int n = nums.length;
// Решить задачу f(0, n-1)
return dfs(nums, target, 0, n - 1);
}
```
=== "Rust"
```rust title="binary_search_recur.rs"
/* Бинарный поиск: задача f(i, j) */
fn dfs(nums: &[i32], target: i32, i: i32, j: i32) -> i32 {
// Если интервал пуст, целевой элемент отсутствует, вернуть -1
if i > j {
return -1;
}
let m: i32 = i + (j - i) / 2;
if nums[m as usize] < target {
// Рекурсивная подзадача f(m+1, j)
return dfs(nums, target, m + 1, j);
} else if nums[m as usize] > target {
// Рекурсивная подзадача f(i, m-1)
return dfs(nums, target, i, m - 1);
} else {
// Целевой элемент найден, вернуть его индекс
return m;
}
}
/* Бинарный поиск */
fn binary_search(nums: &[i32], target: i32) -> i32 {
let n = nums.len() as i32;
// Решить задачу f(0, n-1)
dfs(nums, target, 0, n - 1)
}
```
=== "C"
```c title="binary_search_recur.c"
/* Бинарный поиск: задача f(i, j) */
int dfs(int nums[], int target, int i, int j) {
// Если интервал пуст, целевой элемент отсутствует, вернуть -1
if (i > j) {
return -1;
}
// Вычислить индекс середины m
int m = (i + j) / 2;
if (nums[m] < target) {
// Рекурсивная подзадача f(m+1, j)
return dfs(nums, target, m + 1, j);
} else if (nums[m] > target) {
// Рекурсивная подзадача f(i, m-1)
return dfs(nums, target, i, m - 1);
} else {
// Целевой элемент найден, вернуть его индекс
return m;
}
}
/* Бинарный поиск */
int binarySearch(int nums[], int target, int numsSize) {
int n = numsSize;
// Решить задачу f(0, n-1)
return dfs(nums, target, 0, n - 1);
}
```
=== "Kotlin"
```kotlin title="binary_search_recur.kt"
/* Бинарный поиск: задача f(i, j) */
fun dfs(
nums: IntArray,
target: Int,
i: Int,
j: Int
): Int {
// Если интервал пуст, целевой элемент отсутствует, вернуть -1
if (i > j) {
return -1
}
// Вычислить индекс середины m
val m = (i + j) / 2
return if (nums[m] < target) {
// Рекурсивная подзадача f(m+1, j)
dfs(nums, target, m + 1, j)
} else if (nums[m] > target) {
// Рекурсивная подзадача f(i, m-1)
dfs(nums, target, i, m - 1)
} else {
// Целевой элемент найден, вернуть его индекс
m
}
}
/* Бинарный поиск */
fun binarySearch(nums: IntArray, target: Int): Int {
val n = nums.size
// Решить задачу f(0, n-1)
return dfs(nums, target, 0, n - 1)
}
```
=== "Ruby"
```ruby title="binary_search_recur.rb"
=begin
File: binary_search_recur.rb
Created Time: 2024-05-13
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Бинарный поиск: задача f(i, j) ###
def dfs(nums, target, i, j)
# Если интервал пуст, целевой элемент отсутствует, вернуть -1
return -1 if i > j
# Вычислить индекс середины m
m = (i + j) / 2
if nums[m] < target
# Рекурсивная подзадача f(m+1, j)
return dfs(nums, target, m + 1, j)
elsif nums[m] > target
# Рекурсивная подзадача f(i, m-1)
return dfs(nums, target, i, m - 1)
else
# Целевой элемент найден, вернуть его индекс
return m
end
end
=begin
File: binary_search_recur.rb
Created Time: 2024-05-13
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Бинарный поиск: задача f(i, j) ###
def dfs(nums, target, i, j)
# Если интервал пуст, целевой элемент отсутствует, вернуть -1
return -1 if i > j
# Вычислить индекс середины m
m = (i + j) / 2
if nums[m] < target
# Рекурсивная подзадача f(m+1, j)
return dfs(nums, target, m + 1, j)
elsif nums[m] > target
# Рекурсивная подзадача f(i, m-1)
return dfs(nums, target, i, m - 1)
else
# Целевой элемент найден, вернуть его индекс
return m
end
end
# ## Бинарный поиск ###
def binary_search(nums, target)
n = nums.length
# Решить задачу f(0, n-1)
dfs(nums, target, 0, n - 1)
end
```
??? pythontutor "Визуализация кода"
<div style="height: 549px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=def%20dfs%28nums%3A%20list%5Bint%5D%2C%20target%3A%20int%2C%20i%3A%20int%2C%20j%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%D0%91%D0%B8%D0%BD%D0%B0%D1%80%D0%BD%D1%8B%D0%B9%20%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%3A%20%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0%20f%28i%2C%20j%29%22%22%22%0A%20%20%20%20%23%20%D0%95%D1%81%D0%BB%D0%B8%20%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D0%B2%D0%B0%D0%BB%20%D0%BF%D1%83%D1%81%D1%82%2C%20%D1%86%D0%B5%D0%BB%D0%B5%D0%B2%D0%BE%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%BE%D1%82%D1%81%D1%83%D1%82%D1%81%D1%82%D0%B2%D1%83%D0%B5%D1%82%2C%20%D0%B2%D0%B5%D1%80%D0%BD%D1%83%D1%82%D1%8C%20-1%0A%20%20%20%20if%20i%20%3E%20j%3A%0A%20%20%20%20%20%20%20%20return%20-1%0A%20%20%20%20%23%20%D0%92%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B8%D1%82%D1%8C%20%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%20%D1%81%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%D0%BD%D1%8B%20m%0A%20%20%20%20m%20%3D%20%28i%20%2B%20j%29%20%2F%2F%202%0A%20%20%20%20if%20nums%5Bm%5D%20%3C%20target%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%A0%D0%B5%D0%BA%D1%83%D1%80%D1%81%D0%B8%D0%B2%D0%BD%D0%B0%D1%8F%20%D0%BF%D0%BE%D0%B4%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0%20f%28m%2B1%2C%20j%29%0A%20%20%20%20%20%20%20%20return%20dfs%28nums%2C%20target%2C%20m%20%2B%201%2C%20j%29%0A%20%20%20%20elif%20nums%5Bm%5D%20%3E%20target%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%A0%D0%B5%D0%BA%D1%83%D1%80%D1%81%D0%B8%D0%B2%D0%BD%D0%B0%D1%8F%20%D0%BF%D0%BE%D0%B4%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0%20f%28i%2C%20m-1%29%0A%20%20%20%20%20%20%20%20return%20dfs%28nums%2C%20target%2C%20i%2C%20m%20-%201%29%0A%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%A6%D0%B5%D0%BB%D0%B5%D0%B2%D0%BE%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%BD%D0%B0%D0%B9%D0%B4%D0%B5%D0%BD%2C%20%D0%B2%D0%B5%D1%80%D0%BD%D1%83%D1%82%D1%8C%20%D0%B5%D0%B3%D0%BE%20%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%0A%20%20%20%20%20%20%20%20return%20m%0A%0Adef%20binary_search%28nums%3A%20list%5Bint%5D%2C%20target%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%D0%91%D0%B8%D0%BD%D0%B0%D1%80%D0%BD%D1%8B%D0%B9%20%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%22%22%22%0A%20%20%20%20n%20%3D%20len%28nums%29%0A%20%20%20%20%23%20%D0%A0%D0%B5%D1%88%D0%B8%D1%82%D1%8C%20%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D1%83%20f%280%2C%20n-1%29%0A%20%20%20%20return%20dfs%28nums%2C%20target%2C%200%2C%20n%20-%201%29%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20target%20%3D%206%0A%20%20%20%20nums%20%3D%20%5B1%2C%203%2C%206%2C%208%2C%2012%2C%2015%2C%2023%2C%2026%2C%2031%2C%2035%5D%0A%0A%20%20%20%20%23%20%D0%91%D0%B8%D0%BD%D0%B0%D1%80%D0%BD%D1%8B%D0%B9%20%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%20%28%D0%B4%D0%B2%D1%83%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%BD%D0%B5%20%D0%B7%D0%B0%D0%BC%D0%BA%D0%BD%D1%83%D1%82%D1%8B%D0%B9%20%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D0%B2%D0%B0%D0%BB%29%0A%20%20%20%20index%20%3D%20binary_search%28nums%2C%20target%29%0A%20%20%20%20print%28%22%D0%98%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%20%D1%86%D0%B5%D0%BB%D0%B5%D0%B2%D0%BE%D0%B3%D0%BE%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%206%20%3D%20%22%2C%20index%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=6&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
<div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=def%20dfs%28nums%3A%20list%5Bint%5D%2C%20target%3A%20int%2C%20i%3A%20int%2C%20j%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%D0%91%D0%B8%D0%BD%D0%B0%D1%80%D0%BD%D1%8B%D0%B9%20%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%3A%20%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0%20f%28i%2C%20j%29%22%22%22%0A%20%20%20%20%23%20%D0%95%D1%81%D0%BB%D0%B8%20%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D0%B2%D0%B0%D0%BB%20%D0%BF%D1%83%D1%81%D1%82%2C%20%D1%86%D0%B5%D0%BB%D0%B5%D0%B2%D0%BE%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%BE%D1%82%D1%81%D1%83%D1%82%D1%81%D1%82%D0%B2%D1%83%D0%B5%D1%82%2C%20%D0%B2%D0%B5%D1%80%D0%BD%D1%83%D1%82%D1%8C%20-1%0A%20%20%20%20if%20i%20%3E%20j%3A%0A%20%20%20%20%20%20%20%20return%20-1%0A%20%20%20%20%23%20%D0%92%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B8%D1%82%D1%8C%20%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%20%D1%81%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%D0%BD%D1%8B%20m%0A%20%20%20%20m%20%3D%20%28i%20%2B%20j%29%20%2F%2F%202%0A%20%20%20%20if%20nums%5Bm%5D%20%3C%20target%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%A0%D0%B5%D0%BA%D1%83%D1%80%D1%81%D0%B8%D0%B2%D0%BD%D0%B0%D1%8F%20%D0%BF%D0%BE%D0%B4%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0%20f%28m%2B1%2C%20j%29%0A%20%20%20%20%20%20%20%20return%20dfs%28nums%2C%20target%2C%20m%20%2B%201%2C%20j%29%0A%20%20%20%20elif%20nums%5Bm%5D%20%3E%20target%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%A0%D0%B5%D0%BA%D1%83%D1%80%D1%81%D0%B8%D0%B2%D0%BD%D0%B0%D1%8F%20%D0%BF%D0%BE%D0%B4%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0%20f%28i%2C%20m-1%29%0A%20%20%20%20%20%20%20%20return%20dfs%28nums%2C%20target%2C%20i%2C%20m%20-%201%29%0A%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%A6%D0%B5%D0%BB%D0%B5%D0%B2%D0%BE%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%BD%D0%B0%D0%B9%D0%B4%D0%B5%D0%BD%2C%20%D0%B2%D0%B5%D1%80%D0%BD%D1%83%D1%82%D1%8C%20%D0%B5%D0%B3%D0%BE%20%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%0A%20%20%20%20%20%20%20%20return%20m%0A%0Adef%20binary_search%28nums%3A%20list%5Bint%5D%2C%20target%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%D0%91%D0%B8%D0%BD%D0%B0%D1%80%D0%BD%D1%8B%D0%B9%20%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%22%22%22%0A%20%20%20%20n%20%3D%20len%28nums%29%0A%20%20%20%20%23%20%D0%A0%D0%B5%D1%88%D0%B8%D1%82%D1%8C%20%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D1%83%20f%280%2C%20n-1%29%0A%20%20%20%20return%20dfs%28nums%2C%20target%2C%200%2C%20n%20-%201%29%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20target%20%3D%206%0A%20%20%20%20nums%20%3D%20%5B1%2C%203%2C%206%2C%208%2C%2012%2C%2015%2C%2023%2C%2026%2C%2031%2C%2035%5D%0A%0A%20%20%20%20%23%20%D0%91%D0%B8%D0%BD%D0%B0%D1%80%D0%BD%D1%8B%D0%B9%20%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%20%28%D0%B4%D0%B2%D1%83%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%BD%D0%B5%20%D0%B7%D0%B0%D0%BC%D0%BA%D0%BD%D1%83%D1%82%D1%8B%D0%B9%20%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D0%B2%D0%B0%D0%BB%29%0A%20%20%20%20index%20%3D%20binary_search%28nums%2C%20target%29%0A%20%20%20%20print%28%22%D0%98%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%20%D1%86%D0%B5%D0%BB%D0%B5%D0%B2%D0%BE%D0%B3%D0%BE%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%206%20%3D%20%22%2C%20index%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=6&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">Во весь экран ></a></div>

595
ru/docs/chapter_divide_and_conquer/build_binary_tree_problem.md Normal file
View File

File diff suppressed because one or more lines are too long

101
ru/docs/chapter_divide_and_conquer/divide_and_conquer.md Normal file
View File

@@ -0,0 +1,101 @@
---
comments: true
---
# 12.1 &nbsp; Алгоритмы "разделяй и властвуй"
<u>Разделяй и властвуй (divide and conquer)</u> - это очень важная и широко используемая стратегия построения алгоритмов. Обычно она реализуется через рекурсию и включает два этапа: "разделение" и "решение".
1. **Разделение (этап декомпозиции)**: рекурсивно разбить исходную задачу на две или более подзадачи, пока не будет достигнута наименьшая подзадача.
2. **Решение (этап объединения)**: начиная с уже известных решений наименьших подзадач, снизу вверх объединять решения подзадач и тем самым получать решение исходной задачи.
Как показано на рисунке 12-1, "сортировка слиянием" является одним из типичных примеров применения стратегии "разделяй и властвуй".
1. **Разделение**: рекурсивно разделить исходный массив (исходную задачу) на два подмассива (подзадачи), пока в подмассиве не останется только один элемент (наименьшая подзадача).
2. **Решение**: снизу вверх объединять упорядоченные подмассивы (решения подзадач), чтобы получить упорядоченный исходный массив (решение исходной задачи).
![Стратегия divide and conquer в сортировке слиянием](divide_and_conquer.assets/divide_and_conquer_merge_sort.png){ class="animation-figure" }
<p align="center"> Рисунок 12-1 &nbsp; Стратегия divide and conquer в сортировке слиянием </p>
## 12.1.1 &nbsp; Как определить задачу divide and conquer
Чтобы понять, подходит ли задача для решения методом divide and conquer, обычно можно ориентироваться на следующие критерии.
1. **Задача раскладывается на части**: исходную задачу можно разбить на более мелкие и похожие подзадачи, причем такое разбиение можно применять рекурсивно.
2. **Подзадачи независимы**: подзадачи не пересекаются, не зависят друг от друга и могут решаться независимо.
3. **Решения подзадач можно объединить**: решение исходной задачи получается объединением решений подзадач.
Очевидно, что сортировка слиянием удовлетворяет всем трем критериям.
1. **Задача раскладывается на части**: массив (исходная задача) рекурсивно делится на два подмассива (подзадачи).
2. **Подзадачи независимы**: каждый подмассив можно сортировать отдельно (то есть каждую подзадачу можно решать независимо).
3. **Решения подзадач можно объединить**: два упорядоченных подмассива (решения подзадач) можно объединить в один упорядоченный массив (решение исходной задачи).
## 12.1.2 &nbsp; Повышение эффективности с помощью divide and conquer
**Стратегия divide and conquer не только позволяет эффективно решать алгоритмические задачи, но и часто повышает эффективность самих алгоритмов**. Именно поэтому быстрая сортировка, сортировка слиянием и пирамидальная сортировка обычно работают быстрее, чем сортировка выбором, пузырьком и вставками.
Тогда возникает естественный вопрос: **почему divide and conquer повышает эффективность алгоритма и какова логика этого на более глубоком уровне**? Иными словами, почему разбиение большой задачи на несколько подзадач, решение этих подзадач и последующее объединение их решений оказывается эффективнее, чем прямое решение исходной задачи? Этот вопрос можно рассмотреть с двух сторон: через число операций и через параллельные вычисления.
### 1. &nbsp; Оптимизация числа операций
Рассмотрим "сортировку пузырьком": для массива длины $n$ ей требуется $O(n^2)$ времени. Предположим, что мы разделим массив на два подмассива в середине, как показано на рисунке 12-2. Тогда само разбиение потребует $O(n)$ времени, сортировка каждого подмассива займет $O((n / 2)^2)$ времени, а объединение двух подмассивов потребует еще $O(n)$ времени. Общая временная сложность будет равна:
$$
O(n + (\frac{n}{2})^2 \times 2 + n) = O(\frac{n^2}{2} + 2n)
$$
![Сортировка пузырьком до и после разбиения массива](divide_and_conquer.assets/divide_and_conquer_bubble_sort.png){ class="animation-figure" }
<p align="center"> Рисунок 12-2 &nbsp; Сортировка пузырьком до и после разбиения массива </p>
Теперь рассмотрим следующее неравенство, в котором левая и правая части обозначают общее число операций до разбиения и после него:
$$
\begin{aligned}
n^2 & > \frac{n^2}{2} + 2n \newline
n^2 - \frac{n^2}{2} - 2n & > 0 \newline
n(n - 4) & > 0
\end{aligned}
$$
**Это означает, что при $n > 4$ число операций после разбиения становится меньше, а значит, сортировка должна работать быстрее**. При этом важно заметить, что временная сложность после разбиения все еще остается квадратичной, то есть $O(n^2)$ ; уменьшается лишь константный множитель.
Если пойти дальше и **продолжать делить каждый подмассив пополам**, пока в нем не останется только один элемент, то мы фактически получим "сортировку слиянием", чья временная сложность равна $O(n \log n)$ .
Можно пойти еще дальше и спросить: **что если задать несколько точек разделения** и равномерно разбить исходный массив на $k$ подмассивов? Такая ситуация очень похожа на "блочную сортировку", которая особенно хорошо подходит для сортировки очень больших объемов данных и теоретически может достигать временной сложности $O(n + k)$ .
### 2. &nbsp; Оптимизация параллельных вычислений
Мы знаем, что подзадачи, порождаемые divide and conquer, являются независимыми, **а значит, их обычно можно решать параллельно**. Иначе говоря, divide and conquer не только может уменьшить временную сложность алгоритма, **но и хорошо сочетается с параллельной оптимизацией на уровне системы**.
Параллельная оптимизация особенно эффективна в среде с несколькими ядрами или несколькими процессорами, потому что система может одновременно обрабатывать разные подзадачи, лучше загружая вычислительные ресурсы и тем самым заметно сокращая общее время работы.
Например, в показанной ниже "блочной сортировке" большой объем данных равномерно распределяется по блокам. Тогда сортировку каждого блока можно поручить отдельным вычислительным единицам, а после завершения просто объединить результаты.
![Параллельные вычисления в блочной сортировке](divide_and_conquer.assets/divide_and_conquer_parallel_computing.png){ class="animation-figure" }
<p align="center"> Рисунок 12-3 &nbsp; Параллельные вычисления в блочной сортировке </p>
## 12.1.3 &nbsp; Типичные применения divide and conquer
С одной стороны, divide and conquer можно использовать для решения многих классических алгоритмических задач.
- **Поиск ближайшей пары точек**: сначала множество точек делится на две части, затем ищется ближайшая пара в каждой части, а затем ближайшая пара, пересекающая границу между двумя частями.
- **Умножение больших чисел**: например, алгоритм Карацубы, который раскладывает умножение больших чисел на несколько умножений и сложений меньших чисел.
- **Умножение матриц**: например, алгоритм Штрассена, который раскладывает умножение больших матриц на несколько умножений и сложений матриц меньшего размера.
- **Задача о Ханойской башне**: задача о Ханойской башне решается рекурсивно и является типичным примером применения divide and conquer.
- **Подсчет инверсий**: если в последовательности предыдущее число больше следующего, то такая пара образует инверсию. Эту задачу можно решить с помощью идей divide and conquer, опираясь на сортировку слиянием.
С другой стороны, divide and conquer очень широко применяется при проектировании алгоритмов и структур данных.
- **Двоичный поиск**: двоичный поиск делит отсортированный массив на две части по индексу середины, а затем, в зависимости от результата сравнения целевого значения со средним элементом, исключает одну из половин и повторяет ту же операцию на оставшемся интервале.
- **Сортировка слиянием**: она уже была рассмотрена в начале этого раздела, поэтому не будем повторяться.
- **Быстрая сортировка**: в ней выбирается опорное значение, после чего массив делится на два подмассива: один содержит элементы меньше опорного, а другой - больше. Затем такая же операция повторяется для обеих частей, пока в подмассиве не останется один элемент.
- **Блочная сортировка**: ее основная идея заключается в распределении данных по нескольким блокам, сортировке элементов внутри каждого блока и последующем последовательном извлечении элементов из блоков для построения отсортированного массива.
- **Деревья**: например, двоичные деревья поиска, AVL-деревья, красно-черные деревья, B-деревья, B+ деревья и т.д. Их операции поиска, вставки и удаления можно рассматривать как применение divide and conquer.
- **Кучи**: куча является особым видом полного бинарного дерева, а такие операции, как вставка, удаление и упорядочивание, по сути содержат идеи divide and conquer.
- **Хеш-таблицы**: хотя хеш-таблицы напрямую не используют divide and conquer, некоторые способы разрешения коллизий косвенно опираются на эту стратегию. Например, длинные цепочки в методе цепочек могут преобразовываться в красно-черные деревья для повышения эффективности поиска.
Нетрудно заметить, что **divide and conquer - это "тихая" алгоритмическая идея**, скрыто присутствующая внутри самых разных алгоритмов и структур данных.

610
ru/docs/chapter_divide_and_conquer/hanota_problem.md Normal file
View File

@@ -0,0 +1,610 @@
---
comments: true
---
# 12.4 &nbsp; Задача о Ханойской башне
В задачах сортировки слиянием и построения двоичного дерева мы делили исходную задачу на две подзадачи, каждая из которых имела размер, равный примерно половине исходной задачи. Однако для задачи о Ханойской башне используется другая стратегия разбиения.
!!! question
Даны три стержня, обозначенные как `A` , `B` и `C` . В начальном состоянии на стержне `A` находятся $n$ дисков, расположенных сверху вниз в порядке от меньшего к большему. Нужно переместить эти $n$ дисков на стержень `C` , сохранив их исходный порядок (как показано на рисунке 12-10). Во время перемещения дисков необходимо соблюдать следующие правила.
1. Диск можно снять только с вершины одного стержня и положить только на вершину другого стержня.
2. За один раз можно перемещать только один диск.
3. Меньший диск всегда должен лежать на большем.
![Пример задачи о Ханойской башне](hanota_problem.assets/hanota_example.png){ class="animation-figure" }
<p align="center"> Рисунок 12-10 &nbsp; Пример задачи о Ханойской башне </p>
**Обозначим задачу о Ханойской башне размера $i$ как $f(i)$** . Например, $f(3)$ означает задачу перемещения 3 дисков со стержня `A` на стержень `C` .
### 1. &nbsp; Рассмотрим базовые случаи
Как показано на рисунке 12-11, для задачи $f(1)$ , то есть когда имеется только один диск, достаточно просто переместить его напрямую со стержня `A` на стержень `C` .
=== "<1>"
![Решение задачи размера 1](hanota_problem.assets/hanota_f1_step1.png){ class="animation-figure" }
=== "<2>"
![hanota_f1_step2](hanota_problem.assets/hanota_f1_step2.png){ class="animation-figure" }
<p align="center"> Рисунок 12-11 &nbsp; Решение задачи размера 1 </p>
Как показано на рисунке 12-12, для задачи $f(2)$ , то есть когда есть два диска, **поскольку меньший диск все время должен лежать на большем, приходится использовать `B` как вспомогательный стержень**.
1. Сначала переместить верхний маленький диск с `A` на `B` .
2. Затем переместить большой диск с `A` на `C` .
3. Наконец, переместить маленький диск с `B` на `C` .
=== "<1>"
![Решение задачи размера 2](hanota_problem.assets/hanota_f2_step1.png){ class="animation-figure" }
=== "<2>"
![hanota_f2_step2](hanota_problem.assets/hanota_f2_step2.png){ class="animation-figure" }
=== "<3>"
![hanota_f2_step3](hanota_problem.assets/hanota_f2_step3.png){ class="animation-figure" }
=== "<4>"
![hanota_f2_step4](hanota_problem.assets/hanota_f2_step4.png){ class="animation-figure" }
<p align="center"> Рисунок 12-12 &nbsp; Решение задачи размера 2 </p>
Процесс решения задачи $f(2)$ можно кратко описать так: **переместить два диска с `A` на `C` с помощью `B`** . Здесь `C` называется целевым стержнем, а `B` - буферным стержнем.
### 2. &nbsp; Разбиение на подзадачи
Для задачи $f(3)$ , то есть когда имеется три диска, ситуация становится немного сложнее.
Поскольку решения $f(1)$ и $f(2)$ уже известны, можно подойти к задаче с точки зрения divide and conquer и **рассматривать два верхних диска на `A` как единое целое**, выполняя шаги, показанные на рисунке 12-13. Так три диска успешно перемещаются с `A` на `C` .
1. Сделать `B` целевым стержнем, а `C` буферным, и переместить два диска с `A` на `B` .
2. Переместить оставшийся один диск с `A` напрямую на `C` .
3. Сделать `C` целевым стержнем, а `A` буферным, и переместить два диска с `B` на `C` .
=== "<1>"
![Решение задачи размера 3](hanota_problem.assets/hanota_f3_step1.png){ class="animation-figure" }
=== "<2>"
![hanota_f3_step2](hanota_problem.assets/hanota_f3_step2.png){ class="animation-figure" }
=== "<3>"
![hanota_f3_step3](hanota_problem.assets/hanota_f3_step3.png){ class="animation-figure" }
=== "<4>"
![hanota_f3_step4](hanota_problem.assets/hanota_f3_step4.png){ class="animation-figure" }
<p align="center"> Рисунок 12-13 &nbsp; Решение задачи размера 3 </p>
По своей сути **мы разбиваем задачу $f(3)$ на две подзадачи $f(2)$ и одну подзадачу $f(1)$** . Если последовательно решить эти три подзадачи, исходная задача тоже будет решена. Это показывает, что подзадачи независимы и что их решения можно объединить.
Таким образом, можно сформулировать показанную на рисунке 12-14 стратегию divide and conquer для задачи о Ханойской башне: исходная задача $f(n)$ разбивается на две подзадачи $f(n-1)$ и одну подзадачу $f(1)$ , которые затем решаются в следующем порядке.
1. Переместить $n-1$ дисков с `A` на `B` с помощью `C` .
2. Переместить оставшийся $1$ диск напрямую с `A` на `C` .
3. Переместить $n-1$ дисков с `B` на `C` с помощью `A` .
Для двух подзадач $f(n-1)$ **можно применять тот же способ рекурсивного разбиения**, пока не будет достигнута наименьшая подзадача $f(1)$ . А решение для $f(1)$ уже известно и требует всего одного перемещения.
![Стратегия divide and conquer для решения задачи о Ханойской башне](hanota_problem.assets/hanota_divide_and_conquer.png){ class="animation-figure" }
<p align="center"> Рисунок 12-14 &nbsp; Стратегия divide and conquer для решения задачи о Ханойской башне </p>
### 3. &nbsp; Реализация кода
В коде мы объявляем рекурсивную функцию `dfs(i, src, buf, tar)` , которая перемещает $i$ верхних дисков со стержня `src` на целевой стержень `tar` с помощью буферного стержня `buf` :
=== "Python"
```python title="hanota.py"
def move(src: list[int], tar: list[int]):
"""Переместить один диск"""
# Снять диск с вершины src
pan = src.pop()
# Положить диск на вершину tar
tar.append(pan)
def dfs(i: int, src: list[int], buf: list[int], tar: list[int]):
"""Решить задачу Ханойской башни f(i)"""
# Если в src остался только один диск, сразу переместить его в tar
if i == 1:
move(src, tar)
return
# Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar
dfs(i - 1, src, tar, buf)
# Подзадача f(1): переместить оставшийся один диск из src в tar
move(src, tar)
# Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src
dfs(i - 1, buf, src, tar)
def solve_hanota(A: list[int], B: list[int], C: list[int]):
"""Решить задачу Ханойской башни"""
n = len(A)
# Переместить верхние n дисков из A в C с помощью B
dfs(n, A, B, C)
```
=== "C++"
```cpp title="hanota.cpp"
/* Переместить один диск */
void move(vector<int> &src, vector<int> &tar) {
// Снять диск с вершины src
int pan = src.back();
src.pop_back();
// Положить диск на вершину tar
tar.push_back(pan);
}
/* Решить задачу Ханойской башни f(i) */
void dfs(int i, vector<int> &src, vector<int> &buf, vector<int> &tar) {
// Если в src остался только один диск, сразу переместить его в tar
if (i == 1) {
move(src, tar);
return;
}
// Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar
dfs(i - 1, src, tar, buf);
// Подзадача f(1): переместить оставшийся один диск из src в tar
move(src, tar);
// Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src
dfs(i - 1, buf, src, tar);
}
/* Решить задачу Ханойской башни */
void solveHanota(vector<int> &A, vector<int> &B, vector<int> &C) {
int n = A.size();
// Переместить верхние n дисков из A в C с помощью B
dfs(n, A, B, C);
}
```
=== "Java"
```java title="hanota.java"
/* Переместить один диск */
void move(List<Integer> src, List<Integer> tar) {
// Снять диск с вершины src
Integer pan = src.remove(src.size() - 1);
// Положить диск на вершину tar
tar.add(pan);
}
/* Решить задачу Ханойской башни f(i) */
void dfs(int i, List<Integer> src, List<Integer> buf, List<Integer> tar) {
// Если в src остался только один диск, сразу переместить его в tar
if (i == 1) {
move(src, tar);
return;
}
// Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar
dfs(i - 1, src, tar, buf);
// Подзадача f(1): переместить оставшийся один диск из src в tar
move(src, tar);
// Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src
dfs(i - 1, buf, src, tar);
}
/* Решить задачу Ханойской башни */
void solveHanota(List<Integer> A, List<Integer> B, List<Integer> C) {
int n = A.size();
// Переместить верхние n дисков из A в C с помощью B
dfs(n, A, B, C);
}
```
=== "C#"
```csharp title="hanota.cs"
/* Переместить один диск */
void Move(List<int> src, List<int> tar) {
// Снять диск с вершины src
int pan = src[^1];
src.RemoveAt(src.Count - 1);
// Положить диск на вершину tar
tar.Add(pan);
}
/* Решить задачу Ханойской башни f(i) */
void DFS(int i, List<int> src, List<int> buf, List<int> tar) {
// Если в src остался только один диск, сразу переместить его в tar
if (i == 1) {
Move(src, tar);
return;
}
// Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar
DFS(i - 1, src, tar, buf);
// Подзадача f(1): переместить оставшийся один диск из src в tar
Move(src, tar);
// Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src
DFS(i - 1, buf, src, tar);
}
/* Решить задачу Ханойской башни */
void SolveHanota(List<int> A, List<int> B, List<int> C) {
int n = A.Count;
// Переместить верхние n дисков из A в C с помощью B
DFS(n, A, B, C);
}
```
=== "Go"
```go title="hanota.go"
/* Переместить один диск */
func move(src, tar *list.List) {
// Снять диск с вершины src
pan := src.Back()
// Положить диск на вершину tar
tar.PushBack(pan.Value)
// Убрать верхний диск из src
src.Remove(pan)
}
/* Решить задачу Ханойской башни f(i) */
func dfsHanota(i int, src, buf, tar *list.List) {
// Если в src остался только один диск, сразу переместить его в tar
if i == 1 {
move(src, tar)
return
}
// Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar
dfsHanota(i-1, src, tar, buf)
// Подзадача f(1): переместить оставшийся один диск из src в tar
move(src, tar)
// Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src
dfsHanota(i-1, buf, src, tar)
}
/* Решить задачу Ханойской башни */
func solveHanota(A, B, C *list.List) {
n := A.Len()
// Переместить верхние n дисков из A в C с помощью B
dfsHanota(n, A, B, C)
}
```
=== "Swift"
```swift title="hanota.swift"
/* Переместить один диск */
func move(src: inout [Int], tar: inout [Int]) {
// Снять диск с вершины src
let pan = src.popLast()!
// Положить диск на вершину tar
tar.append(pan)
}
/* Решить задачу Ханойской башни f(i) */
func dfs(i: Int, src: inout [Int], buf: inout [Int], tar: inout [Int]) {
// Если в src остался только один диск, сразу переместить его в tar
if i == 1 {
move(src: &src, tar: &tar)
return
}
// Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar
dfs(i: i - 1, src: &src, buf: &tar, tar: &buf)
// Подзадача f(1): переместить оставшийся один диск из src в tar
move(src: &src, tar: &tar)
// Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src
dfs(i: i - 1, src: &buf, buf: &src, tar: &tar)
}
/* Решить задачу Ханойской башни */
func solveHanota(A: inout [Int], B: inout [Int], C: inout [Int]) {
let n = A.count
// Хвост списка соответствует вершине столбца
// Переместить верхние n дисков из src в C с помощью B
dfs(i: n, src: &A, buf: &B, tar: &C)
}
```
=== "JS"
```javascript title="hanota.js"
/* Переместить один диск */
function move(src, tar) {
// Снять диск с вершины src
const pan = src.pop();
// Положить диск на вершину tar
tar.push(pan);
}
/* Решить задачу Ханойской башни f(i) */
function dfs(i, src, buf, tar) {
// Если в src остался только один диск, сразу переместить его в tar
if (i === 1) {
move(src, tar);
return;
}
// Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar
dfs(i - 1, src, tar, buf);
// Подзадача f(1): переместить оставшийся один диск из src в tar
move(src, tar);
// Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src
dfs(i - 1, buf, src, tar);
}
/* Решить задачу Ханойской башни */
function solveHanota(A, B, C) {
const n = A.length;
// Переместить верхние n дисков из A в C с помощью B
dfs(n, A, B, C);
}
```
=== "TS"
```typescript title="hanota.ts"
/* Переместить один диск */
function move(src: number[], tar: number[]): void {
// Снять диск с вершины src
const pan = src.pop();
// Положить диск на вершину tar
tar.push(pan);
}
/* Решить задачу Ханойской башни f(i) */
function dfs(i: number, src: number[], buf: number[], tar: number[]): void {
// Если в src остался только один диск, сразу переместить его в tar
if (i === 1) {
move(src, tar);
return;
}
// Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar
dfs(i - 1, src, tar, buf);
// Подзадача f(1): переместить оставшийся один диск из src в tar
move(src, tar);
// Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src
dfs(i - 1, buf, src, tar);
}
/* Решить задачу Ханойской башни */
function solveHanota(A: number[], B: number[], C: number[]): void {
const n = A.length;
// Переместить верхние n дисков из A в C с помощью B
dfs(n, A, B, C);
}
```
=== "Dart"
```dart title="hanota.dart"
/* Переместить один диск */
void move(List<int> src, List<int> tar) {
// Снять диск с вершины src
int pan = src.removeLast();
// Положить диск на вершину tar
tar.add(pan);
}
/* Решить задачу Ханойской башни f(i) */
void dfs(int i, List<int> src, List<int> buf, List<int> tar) {
// Если в src остался только один диск, сразу переместить его в tar
if (i == 1) {
move(src, tar);
return;
}
// Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar
dfs(i - 1, src, tar, buf);
// Подзадача f(1): переместить оставшийся один диск из src в tar
move(src, tar);
// Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src
dfs(i - 1, buf, src, tar);
}
/* Решить задачу Ханойской башни */
void solveHanota(List<int> A, List<int> B, List<int> C) {
int n = A.length;
// Переместить верхние n дисков из A в C с помощью B
dfs(n, A, B, C);
}
```
=== "Rust"
```rust title="hanota.rs"
/* Переместить один диск */
fn move_pan(src: &mut Vec<i32>, tar: &mut Vec<i32>) {
// Снять диск с вершины src
let pan = src.pop().unwrap();
// Положить диск на вершину tar
tar.push(pan);
}
/* Решить задачу Ханойской башни f(i) */
fn dfs(i: i32, src: &mut Vec<i32>, buf: &mut Vec<i32>, tar: &mut Vec<i32>) {
// Если в src остался только один диск, сразу переместить его в tar
if i == 1 {
move_pan(src, tar);
return;
}
// Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar
dfs(i - 1, src, tar, buf);
// Подзадача f(1): переместить оставшийся один диск из src в tar
move_pan(src, tar);
// Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src
dfs(i - 1, buf, src, tar);
}
/* Решить задачу Ханойской башни */
fn solve_hanota(A: &mut Vec<i32>, B: &mut Vec<i32>, C: &mut Vec<i32>) {
let n = A.len() as i32;
// Переместить верхние n дисков из A в C с помощью B
dfs(n, A, B, C);
}
```
=== "C"
```c title="hanota.c"
/* Переместить один диск */
void move(int *src, int *srcSize, int *tar, int *tarSize) {
// Снять диск с вершины src
int pan = src[*srcSize - 1];
src[*srcSize - 1] = 0;
(*srcSize)--;
// Положить диск на вершину tar
tar[*tarSize] = pan;
(*tarSize)++;
}
/* Решить задачу Ханойской башни f(i) */
void dfs(int i, int *src, int *srcSize, int *buf, int *bufSize, int *tar, int *tarSize) {
// Если в src остался только один диск, сразу переместить его в tar
if (i == 1) {
move(src, srcSize, tar, tarSize);
return;
}
// Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar
dfs(i - 1, src, srcSize, tar, tarSize, buf, bufSize);
// Подзадача f(1): переместить оставшийся один диск из src в tar
move(src, srcSize, tar, tarSize);
// Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src
dfs(i - 1, buf, bufSize, src, srcSize, tar, tarSize);
}
/* Решить задачу Ханойской башни */
void solveHanota(int *A, int *ASize, int *B, int *BSize, int *C, int *CSize) {
// Переместить верхние n дисков из A в C с помощью B
dfs(*ASize, A, ASize, B, BSize, C, CSize);
}
```
=== "Kotlin"
```kotlin title="hanota.kt"
/* Переместить один диск */
fun move(src: MutableList<Int>, tar: MutableList<Int>) {
// Снять диск с вершины src
val pan = src.removeAt(src.size - 1)
// Положить диск на вершину tar
tar.add(pan)
}
/* Решить задачу Ханойской башни f(i) */
fun dfs(i: Int, src: MutableList<Int>, buf: MutableList<Int>, tar: MutableList<Int>) {
// Если в src остался только один диск, сразу переместить его в tar
if (i == 1) {
move(src, tar)
return
}
// Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar
dfs(i - 1, src, tar, buf)
// Подзадача f(1): переместить оставшийся один диск из src в tar
move(src, tar)
// Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src
dfs(i - 1, buf, src, tar)
}
/* Решить задачу Ханойской башни */
fun solveHanota(A: MutableList<Int>, B: MutableList<Int>, C: MutableList<Int>) {
val n = A.size
// Переместить верхние n дисков из A в C с помощью B
dfs(n, A, B, C)
}
```
=== "Ruby"
```ruby title="hanota.rb"
=begin
File: hanota.rb
Created Time: 2024-05-13
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Переместить один диск ###
def move(src, tar)
# Снять диск с вершины src
pan = src.pop
# Положить диск на вершину tar
tar << pan
end
=begin
File: hanota.rb
Created Time: 2024-05-13
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Переместить один диск ###
def move(src, tar)
# Снять диск с вершины src
pan = src.pop
# Положить диск на вершину tar
tar << pan
end
# ## Решить задачу Ханойской башни f(i) ###
def dfs(i, src, buf, tar)
# Если в src остался только один диск, сразу переместить его в tar
if i == 1
move(src, tar)
return
end
# Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar
dfs(i - 1, src, tar, buf)
# Подзадача f(1): переместить оставшийся один диск из src в tar
move(src, tar)
# Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src
dfs(i - 1, buf, src, tar)
end
=begin
File: hanota.rb
Created Time: 2024-05-13
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Переместить один диск ###
def move(src, tar)
# Снять диск с вершины src
pan = src.pop
# Положить диск на вершину tar
tar << pan
end
# ## Решить задачу Ханойской башни f(i) ###
def dfs(i, src, buf, tar)
# Если в src остался только один диск, сразу переместить его в tar
if i == 1
move(src, tar)
return
end
# Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar
dfs(i - 1, src, tar, buf)
# Подзадача f(1): переместить оставшийся один диск из src в tar
move(src, tar)
# Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src
dfs(i - 1, buf, src, tar)
end
# ## Решить задачу Ханойской башни ###
def solve_hanota(_A, _B, _C)
n = _A.length
# Переместить верхние n дисков из A в C с помощью B
dfs(n, _A, _B, _C)
end
```
??? pythontutor "Визуализация кода"
<div style="height: 549px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=def%20move%28src%3A%20list%5Bint%5D%2C%20tar%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20%22%22%22%D0%9F%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%BE%D0%B4%D0%B8%D0%BD%20%D0%B4%D0%B8%D1%81%D0%BA%22%22%22%0A%20%20%20%20%23%20%D0%A1%D0%BD%D1%8F%D1%82%D1%8C%20%D0%B4%D0%B8%D1%81%D0%BA%20%D1%81%20%D0%B2%D0%B5%D1%80%D1%88%D0%B8%D0%BD%D1%8B%20src%0A%20%20%20%20pan%20%3D%20src.pop%28%29%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D0%BE%D0%B6%D0%B8%D1%82%D1%8C%20%D0%B4%D0%B8%D1%81%D0%BA%20%D0%BD%D0%B0%20%D0%B2%D0%B5%D1%80%D1%88%D0%B8%D0%BD%D1%83%20tar%0A%20%20%20%20tar.append%28pan%29%0A%0A%0Adef%20dfs%28i%3A%20int%2C%20src%3A%20list%5Bint%5D%2C%20buf%3A%20list%5Bint%5D%2C%20tar%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20%22%22%22%D0%A0%D0%B5%D1%88%D0%B8%D1%82%D1%8C%20%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D1%83%20%D0%A5%D0%B0%D0%BD%D0%BE%D0%B9%D1%81%D0%BA%D0%BE%D0%B9%20%D0%B1%D0%B0%D1%88%D0%BD%D0%B8%20f%28i%29%22%22%22%0A%20%20%20%20%23%20%D0%95%D1%81%D0%BB%D0%B8%20%D0%B2%20src%20%D0%BE%D1%81%D1%82%D0%B0%D0%BB%D1%81%D1%8F%20%D1%82%D0%BE%D0%BB%D1%8C%D0%BA%D0%BE%20%D0%BE%D0%B4%D0%B8%D0%BD%20%D0%B4%D0%B8%D1%81%D0%BA%2C%20%D1%81%D1%80%D0%B0%D0%B7%D1%83%20%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%B5%D0%B3%D0%BE%20%D0%B2%20tar%0A%20%20%20%20if%20i%20%3D%3D%201%3A%0A%20%20%20%20%20%20%20%20move%28src%2C%20tar%29%0A%20%20%20%20%20%20%20%20return%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%B4%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0%20f%28i-1%29%3A%20%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%B8%D0%B5%20i-1%20%D0%B4%D0%B8%D1%81%D0%BA%D0%BE%D0%B2%20%D0%B8%D0%B7%20src%20%D0%B2%20buf%20%D1%81%20%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E%20tar%0A%20%20%20%20dfs%28i%20-%201%2C%20src%2C%20tar%2C%20buf%29%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%B4%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0%20f%281%29%3A%20%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%BE%D1%81%D1%82%D0%B0%D0%B2%D1%88%D0%B8%D0%B9%D1%81%D1%8F%20%D0%BE%D0%B4%D0%B8%D0%BD%20%D0%B4%D0%B8%D1%81%D0%BA%20%D0%B8%D0%B7%20src%20%D0%B2%20tar%0A%20%20%20%20move%28src%2C%20tar%29%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%B4%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0%20f%28i-1%29%3A%20%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%B8%D0%B5%20i-1%20%D0%B4%D0%B8%D1%81%D0%BA%D0%BE%D0%B2%20%D0%B8%D0%B7%20buf%20%D0%B2%20tar%20%D1%81%20%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E%20src%0A%20%20%20%20dfs%28i%20-%201%2C%20buf%2C%20src%2C%20tar%29%0A%0A%0Adef%20solve_hanota%28A%3A%20list%5Bint%5D%2C%20B%3A%20list%5Bint%5D%2C%20C%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20%22%22%22%D0%A0%D0%B5%D1%88%D0%B8%D1%82%D1%8C%20%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D1%83%20%D0%A5%D0%B0%D0%BD%D0%BE%D0%B9%D1%81%D0%BA%D0%BE%D0%B9%20%D0%B1%D0%B0%D1%88%D0%BD%D0%B8%22%22%22%0A%20%20%20%20n%20%3D%20len%28A%29%0A%20%20%20%20%23%20%D0%9F%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%B8%D0%B5%20n%20%D0%B4%D0%B8%D1%81%D0%BA%D0%BE%D0%B2%20%D0%B8%D0%B7%20A%20%D0%B2%20C%20%D1%81%20%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E%20B%0A%20%20%20%20dfs%28n%2C%20A%2C%20B%2C%20C%29%0A%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%A5%D0%B2%D0%BE%D1%81%D1%82%20%D1%81%D0%BF%D0%B8%D1%81%D0%BA%D0%B0%20%D1%81%D0%BE%D0%BE%D1%82%D0%B2%D0%B5%D1%82%D1%81%D1%82%D0%B2%D1%83%D0%B5%D1%82%20%D0%B2%D0%B5%D1%80%D1%88%D0%B8%D0%BD%D0%B5%20%D1%81%D1%82%D0%BE%D0%BB%D0%B1%D1%86%D0%B0%0A%20%20%20%20A%20%3D%20%5B5%2C%204%2C%203%2C%202%2C%201%5D%0A%20%20%20%20B%20%3D%20%5B%5D%0A%20%20%20%20C%20%3D%20%5B%5D%0A%20%20%20%20print%28%22%D0%98%D1%81%D1%85%D0%BE%D0%B4%D0%BD%D0%BE%D0%B5%20%D1%81%D0%BE%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5%3A%22%29%0A%20%20%20%20print%28f%22A%20%3D%20%7BA%7D%22%29%0A%20%20%20%20print%28f%22B%20%3D%20%7BB%7D%22%29%0A%20%20%20%20print%28f%22C%20%3D%20%7BC%7D%22%29%0A%0A%20%20%20%20solve_hanota%28A%2C%20B%2C%20C%29%0A%0A%20%20%20%20print%28%22%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%20%D0%B7%D0%B0%D0%B2%D0%B5%D1%80%D1%88%D0%B5%D0%BD%D0%B8%D1%8F%20%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%89%D0%B5%D0%BD%D0%B8%D1%8F%20%D0%B4%D0%B8%D1%81%D0%BA%D0%BE%D0%B2%3A%22%29%0A%20%20%20%20print%28f%22A%20%3D%20%7BA%7D%22%29%0A%20%20%20%20print%28f%22B%20%3D%20%7BB%7D%22%29%0A%20%20%20%20print%28f%22C%20%3D%20%7BC%7D%22%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=12&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
<div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=def%20move%28src%3A%20list%5Bint%5D%2C%20tar%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20%22%22%22%D0%9F%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%BE%D0%B4%D0%B8%D0%BD%20%D0%B4%D0%B8%D1%81%D0%BA%22%22%22%0A%20%20%20%20%23%20%D0%A1%D0%BD%D1%8F%D1%82%D1%8C%20%D0%B4%D0%B8%D1%81%D0%BA%20%D1%81%20%D0%B2%D0%B5%D1%80%D1%88%D0%B8%D0%BD%D1%8B%20src%0A%20%20%20%20pan%20%3D%20src.pop%28%29%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D0%BE%D0%B6%D0%B8%D1%82%D1%8C%20%D0%B4%D0%B8%D1%81%D0%BA%20%D0%BD%D0%B0%20%D0%B2%D0%B5%D1%80%D1%88%D0%B8%D0%BD%D1%83%20tar%0A%20%20%20%20tar.append%28pan%29%0A%0A%0Adef%20dfs%28i%3A%20int%2C%20src%3A%20list%5Bint%5D%2C%20buf%3A%20list%5Bint%5D%2C%20tar%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20%22%22%22%D0%A0%D0%B5%D1%88%D0%B8%D1%82%D1%8C%20%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D1%83%20%D0%A5%D0%B0%D0%BD%D0%BE%D0%B9%D1%81%D0%BA%D0%BE%D0%B9%20%D0%B1%D0%B0%D1%88%D0%BD%D0%B8%20f%28i%29%22%22%22%0A%20%20%20%20%23%20%D0%95%D1%81%D0%BB%D0%B8%20%D0%B2%20src%20%D0%BE%D1%81%D1%82%D0%B0%D0%BB%D1%81%D1%8F%20%D1%82%D0%BE%D0%BB%D1%8C%D0%BA%D0%BE%20%D0%BE%D0%B4%D0%B8%D0%BD%20%D0%B4%D0%B8%D1%81%D0%BA%2C%20%D1%81%D1%80%D0%B0%D0%B7%D1%83%20%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%B5%D0%B3%D0%BE%20%D0%B2%20tar%0A%20%20%20%20if%20i%20%3D%3D%201%3A%0A%20%20%20%20%20%20%20%20move%28src%2C%20tar%29%0A%20%20%20%20%20%20%20%20return%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%B4%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0%20f%28i-1%29%3A%20%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%B8%D0%B5%20i-1%20%D0%B4%D0%B8%D1%81%D0%BA%D0%BE%D0%B2%20%D0%B8%D0%B7%20src%20%D0%B2%20buf%20%D1%81%20%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E%20tar%0A%20%20%20%20dfs%28i%20-%201%2C%20src%2C%20tar%2C%20buf%29%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%B4%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0%20f%281%29%3A%20%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%BE%D1%81%D1%82%D0%B0%D0%B2%D1%88%D0%B8%D0%B9%D1%81%D1%8F%20%D0%BE%D0%B4%D0%B8%D0%BD%20%D0%B4%D0%B8%D1%81%D0%BA%20%D0%B8%D0%B7%20src%20%D0%B2%20tar%0A%20%20%20%20move%28src%2C%20tar%29%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%B4%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0%20f%28i-1%29%3A%20%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%B8%D0%B5%20i-1%20%D0%B4%D0%B8%D1%81%D0%BA%D0%BE%D0%B2%20%D0%B8%D0%B7%20buf%20%D0%B2%20tar%20%D1%81%20%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E%20src%0A%20%20%20%20dfs%28i%20-%201%2C%20buf%2C%20src%2C%20tar%29%0A%0A%0Adef%20solve_hanota%28A%3A%20list%5Bint%5D%2C%20B%3A%20list%5Bint%5D%2C%20C%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20%22%22%22%D0%A0%D0%B5%D1%88%D0%B8%D1%82%D1%8C%20%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D1%83%20%D0%A5%D0%B0%D0%BD%D0%BE%D0%B9%D1%81%D0%BA%D0%BE%D0%B9%20%D0%B1%D0%B0%D1%88%D0%BD%D0%B8%22%22%22%0A%20%20%20%20n%20%3D%20len%28A%29%0A%20%20%20%20%23%20%D0%9F%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%B8%D0%B5%20n%20%D0%B4%D0%B8%D1%81%D0%BA%D0%BE%D0%B2%20%D0%B8%D0%B7%20A%20%D0%B2%20C%20%D1%81%20%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E%20B%0A%20%20%20%20dfs%28n%2C%20A%2C%20B%2C%20C%29%0A%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%A5%D0%B2%D0%BE%D1%81%D1%82%20%D1%81%D0%BF%D0%B8%D1%81%D0%BA%D0%B0%20%D1%81%D0%BE%D0%BE%D1%82%D0%B2%D0%B5%D1%82%D1%81%D1%82%D0%B2%D1%83%D0%B5%D1%82%20%D0%B2%D0%B5%D1%80%D1%88%D0%B8%D0%BD%D0%B5%20%D1%81%D1%82%D0%BE%D0%BB%D0%B1%D1%86%D0%B0%0A%20%20%20%20A%20%3D%20%5B5%2C%204%2C%203%2C%202%2C%201%5D%0A%20%20%20%20B%20%3D%20%5B%5D%0A%20%20%20%20C%20%3D%20%5B%5D%0A%20%20%20%20print%28%22%D0%98%D1%81%D1%85%D0%BE%D0%B4%D0%BD%D0%BE%D0%B5%20%D1%81%D0%BE%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5%3A%22%29%0A%20%20%20%20print%28f%22A%20%3D%20%7BA%7D%22%29%0A%20%20%20%20print%28f%22B%20%3D%20%7BB%7D%22%29%0A%20%20%20%20print%28f%22C%20%3D%20%7BC%7D%22%29%0A%0A%20%20%20%20solve_hanota%28A%2C%20B%2C%20C%29%0A%0A%20%20%20%20print%28%22%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%20%D0%B7%D0%B0%D0%B2%D0%B5%D1%80%D1%88%D0%B5%D0%BD%D0%B8%D1%8F%20%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%89%D0%B5%D0%BD%D0%B8%D1%8F%20%D0%B4%D0%B8%D1%81%D0%BA%D0%BE%D0%B2%3A%22%29%0A%20%20%20%20print%28f%22A%20%3D%20%7BA%7D%22%29%0A%20%20%20%20print%28f%22B%20%3D%20%7BB%7D%22%29%0A%20%20%20%20print%28f%22C%20%3D%20%7BC%7D%22%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=12&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">Во весь экран ></a></div>
Как показано на рисунке 12-15, задача о Ханойской башне формирует дерево рекурсии высоты $n$ , в котором каждый узел представляет подзадачу и соответствует одному открытому вызову `dfs()` ; **поэтому временная сложность равна $O(2^n)$ , а пространственная сложность равна $O(n)$** .
![Дерево рекурсии задачи о Ханойской башне](hanota_problem.assets/hanota_recursive_tree.png){ class="animation-figure" }
<p align="center"> Рисунок 12-15 &nbsp; Дерево рекурсии задачи о Ханойской башне </p>
!!! quote
Задача о Ханойской башне происходит из древней легенды. В одном из храмов древней Индии монахи имели три высоких алмазных стержня и $64$ золотых диска разного размера. Монахи непрерывно перекладывали диски и верили, что в тот момент, когда последний диск будет правильно перенесен, мир подойдет к концу.
Однако даже если бы монахи перемещали по одному диску в секунду, им понадобилось бы примерно $2^{64} \approx 1.84×10^{19}$ секунд, то есть около $585$ миллиардов лет, что намного превышает текущую оценку возраста Вселенной. Поэтому, если легенда и верна, нам, вероятно, пока не о чем беспокоиться.

22
ru/docs/chapter_divide_and_conquer/index.md Normal file
View File

@@ -0,0 +1,22 @@
---
comments: true
icon: material/set-split
---
# Глава 12. &nbsp; Разделяй и властвуй
![Разделяй и властвуй](../assets/covers/chapter_divide_and_conquer.jpg){ class="cover-image" }
!!! abstract
Сложная задача раскладывается слой за слоем, и каждое новое разбиение делает ее проще.
Принцип "разделяй и властвуй" показывает важный факт: если начать с простого, многое перестает быть сложным.
## Содержание главы
- [12.1 &nbsp; Алгоритмы разделяй и властвуй](divide_and_conquer.md)
- [12.2 &nbsp; Стратегия поиска разделяй и властвуй](binary_search_recur.md)
- [12.3 &nbsp; Задача построения двоичного дерева](build_binary_tree_problem.md)
- [12.4 &nbsp; Задача о Ханойской башне](hanota_problem.md)
- [12.5 &nbsp; Резюме](summary.md)

17
ru/docs/chapter_divide_and_conquer/summary.md Normal file
View File

@@ -0,0 +1,17 @@
---
comments: true
---
# 12.5 &nbsp; Резюме
### 1. &nbsp; Ключевые выводы
- Divide and conquer - это распространенная стратегия проектирования алгоритмов, которая включает два этапа: разделение (декомпозицию) и решение (объединение), и обычно реализуется с помощью рекурсии.
- Критерии применимости этой стратегии к задаче включают: возможность разложения задачи, независимость подзадач и возможность объединения их решений.
- Сортировка слиянием является типичным применением divide and conquer: она рекурсивно делит массив на два равных по длине подмассива, пока не останется массив из одного элемента, после чего начинает поэтапное объединение.
- Введение стратегии divide and conquer часто позволяет повысить эффективность алгоритма. С одной стороны, стратегия уменьшает число операций; с другой - после разбиения она способствует параллельной оптимизации на уровне системы.
- Divide and conquer не только помогает решать многие алгоритмические задачи, но и широко используется при проектировании структур данных и алгоритмов, поэтому его можно встретить буквально повсюду.
- По сравнению с полным перебором адаптивный поиск работает эффективнее. Алгоритмы поиска со сложностью $O(\log n)$ обычно реализуются на основе стратегии divide and conquer.
- Двоичный поиск - еще одно типичное применение divide and conquer, в котором отсутствует шаг объединения решений подзадач. Мы можем реализовать двоичный поиск рекурсивно, через divide and conquer.
- В задаче построения двоичного дерева исходная задача построения дерева может быть разбита на две подзадачи: построение левого и правого поддеревьев, а реализуется это через разбиение индексных интервалов прямого и симметричного обходов.
- В задаче о Ханойской башне задача размера $n$ разбивается на две подзадачи размера $n-1$ и одну подзадачу размера $1$ . После последовательного решения этих трех подзадач исходная задача также оказывается решенной.