Новосибирск ──┐
Москва      ──┼──▶ Россия
Казань      ──┘
Минск       ─────▶ Беларусь
Астана      ─────▶ Казахстан
 
get(key) -> value
set(key, value)

Для физика

Справочник «имя канала → калибровочный коэффициент»: тысячи каналов и обращение при каждом событии.

class NaiveMap:
    def __init__(self):
        self.pairs = []            # пары (key, value)
 
    def get(self, key):
        for k, v in self.pairs:    # перебор: O(n)
            if k == key:
                return v
        return None
 
    def set(self, key, value):
        for i, (k, _) in enumerate(self.pairs):
            if k == key:
                self.pairs[i] = (key, value)
                return
        self.pairs.append((key, value))

Пояснение

Хеш-таблица хранит те же пары, но ищет ключ только в одной короткой корзине.

ALPHABET = 'абвгдеёжзийклмнопрстуфхцчшщъыьэюя'
 
def letters_hash(key):         # сумма номеров букв
    return sum(ALPHABET.index(c) + 1 for c in key)
 
letters_hash('груша') % 11     # 70 % 11 = 4
letters_hash('яблоко') % 11    # 92 % 11 = 4

метод цепочек:
корзина 3: []
корзина 4: [('груша', 120), ('яблоко', 300)]
корзина 5: []
 
открытая адресация, пробы h, h + 1, …:
ячейка 4: ('груша', 120)
ячейка 5: ('яблоко', 300)    # следующая свободная

Важно

Равномерная раскладка и достаточное число корзин — O(1) в среднем; массовые коллизии — O(n).

α = n / M          коэффициент заполнения
 
P(корзина пуста) = (1 − 1/M)^n ≈ e^(−α)
позиция ключа в цепочке ≈ 1 + α/2
 
порог CPython: dict — 2/3, set — 3/5
перестройка: O(n), рост таблицы кратный

Пояснение

dict и set в CPython: открытая адресация и таблица размером 2^k.

01

Каналы BPM:0042:X, n = 1000…8000

02

Список пар, цепочки при M = 11, перехеширование, dict

03

Случайные 64-битные идентификаторы, M = 1009

04

Перестройки dict и set в CPython

index = defaultdict(list)      # слово → номера записей
for num, text in enumerate(log):
    for word in set(text.split()):
        index[word].append(num)
 
index['клистрон']              # O(1) в среднем

Для физика

Электронный журнал смены установки: все записи о клистроне без перебора тысяч строк.

01

Журнал смены: 3000 записей

02

Индекс слов: построение и память

03

«клистрон»: индекс против перебора

04

Индекс подстрок, N = 125…500

k = j·M + r,   r ∈ [0, M)
bucket(k) = k mod M
 
-13 % 5             # 2 в Python
math.fmod(-13, 5)   # -3.0, как в C
 
ключи 64·k + 5, M = 64: одна корзина
занято M / НОД(64, M) корзин

Важно

Остаток отрицательного числа зависит от языка: номер корзины может стать отрицательным.

bucket(h) = ⌊M · {h·α}⌋
{x} — дробная часть, ⌊x⌋ — целая
 
α = (√5 − 1)/2 ≈ 0,6180339887
 
int(M * ((h * ALPHA) % 1.0))

Пояснение

Кнут предложил α = 1/φ: последовательные ключи рассеиваются по корзинам наиболее равномерно.

h(s) = (s[0]·q^(n−1) + … + s[n−1]) mod R
 
def poly_hash(s, q=31, R=2**32):
    h = 0
    for ch in s:                 # схема Горнера
        h = (h * q + ord(ch)) % R
    return h
 
q = 256:  256⁴ mod 2³² = 0

Важно

Выбор q важен и для длинных строк: при q = 256 все имена run_0000.dat … run_9999.dat получают один хеш.

01

1000 ключей 64·k + 5: деление при M = 64, 128, 1000

02

Простые M = 61 и 1009, умножение при M = 64 и 1024

03

10 000 имён run_0000.dat … run_9999.dat

04

SHA-256, сумма кодов, q = 256 и 31

Детерминизм

один и тот же ключ — всегда один и тот же хеш

Эффективность

вычисление хеша дешевле перебора ключей

Ограниченность

номер корзины в диапазоне от 0 до M − 1

Равномерность

значения равновероятны, корзины заполнены поровну

hash(42)        # 42: int по модулю 2⁶¹ − 1
hash(2**61)     # 1
hash(-1)        # -2: значение -1 занято
hash('груша')   # меняется от запуска к запуску
 
sys.hash_info.algorithm    # 'siphash13'
PYTHONHASHSEED=42 python3 run.py
hash([1, 2])    # TypeError: unhashable type

Важно

Алгоритм, перебирающий set строк, недетерминирован: ответ решения 2 из лекции 17 зависит от запуска.

import hashlib, hmac, os
hashlib.sha256(data).hexdigest()     # 256 бит
hmac.new(key, msg, 'sha256').digest()
 
salt = os.urandom(16)                # хранится с хешем
hashlib.scrypt(pw, salt=salt, n=2**14, r=8, p=1)
hashlib.pbkdf2_hmac('sha256', pw, salt, 600_000)

Важно

Быструю хеш-функцию пароля перебирают со скоростью миллиардов вариантов в секунду.

01

hash('груша') в новых процессах, PYTHONHASHSEED=42

02

Порядок обхода set и dict в пяти процессах

03

Решение 2 задачи о частом символе при соли 0…7

04

SHA-256: лавинность, контрольная сумма, пароли

корень

поддерево B

глубина 0

глубина 1

глубина 2

глубина 3

Для физика

Каталоги файловой системы, группы HDF5, объёмы Geant4, дерево вызовов профилировщика.

class Node:
    def __init__(self, value, left=None, right=None):
        self.value = value      # данные узла
        self.left = left        # левый потомок или None
        self.right = right      # правый потомок или None
 
root = Node(5, Node(3, Node(1), Node(4)), Node(8))

Пояснение

Любое дерево сводится к двоичному: левая ссылка — первый потомок, правая — следующий узел того же родителя.

def preorder(root):          # корень, левое, правое
    if root is None:
        return
    print(root.value)        # in-order: между вызовами
    preorder(root.left)      # post-order: после них
    preorder(root.right)
 
def level_order(root):       # по уровням: очередь
    queue = deque([root] if root else [])
    while queue:
        node = queue.popleft()
        print(node.value)
        if node.left:
            queue.append(node.left)
        if node.right:
            queue.append(node.right)

Пояснение

Время O(n); память O(h) на стек рекурсии у DFS и до O(n) на очередь у BFS.

01

Иерархия объёмов детектора: прямой обход

02

Массы поддеревьев: обратный обход

03

Объёмы по уровням: обход в ширину

04

Дерево главы и E = √(p² + m²)

from scipy.spatial import KDTree
rng = np.random.default_rng(0)
points = rng.random((100_000, 3))   # частицы в кубе
tree = KDTree(points)               # O(N log N)
 
dist, idx = tree.query(points[0], k=10)
near = tree.query_ball_point(points[0], r=0.05)
pairs = tree.query_pairs(r=0.01)    # близкие пары

Пояснение

Барнс — Хат: ячейка с угловым размером s/d < θ заменяется суммарной массой в центре масс.

01

N частиц в единичном кубе: 5000, 10 000, 20 000

02

Все пары ближе r = 0,01: перебор на NumPy

03

Те же пары: KDTree.query_pairs

04

Сверка с ожиданием N²/2 · (4/3)πr³

def find(root, key):              # спуск: O(h)
    while root is not None and root.value != key:
        root = root.left if key < root.value else root.right
    return root
 
def insert(root, key):            # рекурсия главы
    if root is None:
        return Node(key)
    if key < root.value:
        root.left = insert(root.left, key)
    elif key > root.value:
        root.right = insert(root.right, key)
    return root

Пояснение

Отсортированный массив медленно вставляет, хеш-таблица не хранит порядка; дерево поиска обеспечивает и то и другое.

parent, succ = root, root.right   # преемник
while succ.left is not None:
    parent, succ = succ, succ.left

дерево поиска

не дерево поиска: 6 > 5

def is_bst(root, low=-inf, high=inf):
    if root is None:
        return True
    if not low < root.value < high:
        return False
    return (is_bst(root.left, low, root.value)
            and is_bst(root.right, root.value, high))

средняя глубина узла ≈ 2 ln n ≈ 1,39·log₂ n
высота ≈ 4,311 ln n − 1,953 ln ln n

Пояснение

В стандартной библиотеке Python дерева поиска нет: обычно достаточно dict, set и bisect.

Важно

Рекурсивная insert главы на ключах 1, 2, 3, … исчерпывает предел рекурсии уже на тысяче ключей.

01

Случайный порядок, n = 10³…10⁵

02

Ключи по порядку: n = 1000 и 2000

03

Рекурсивная insert главы на ключах 1, 2, 3, …

04

Поиск: дерево, цепочка, bisect, dict

C(n) = Σ C(k − 1)·C(n − k),  k = 1…n,  C(0) = 1
C(n) = C(2n, n) / (n + 1)      # числа Каталана
 
def count_bst(n):
    return comb(2 * n, n) // (n + 1)
 
count_bst(20)                  # 6564120420

Важно

Вычисления — в целых числах: float теряет точность выше 2⁵³.

01

Формула и динамика при n = 0…10

02

Перебор всех деревьев при n = 1…8

03

C₂₀ и факториалы во float

04

Деление целых '/' и граница 2⁵³

[0]

[1]

[2]

[3]

[4]

[5]

Пояснение

Между левым и правым поддеревьями порядка нет: куча — не дерево поиска.

import heapq
h = [5.2, 1.1, 3.7, 0.4]
heapq.heapify(h)              # O(n)
heapq.heappush(h, 2.6)        # O(log n)
heapq.heappop(h)              # 0.4 — минимум
h[0]                          # минимум без извлечения
 
heapq.heappush(mx, -x)        # max-heap: знак минус
heapq.heappush_max(mx, x)     # Python 3.14 и новее
heapq.nlargest(10, energies)  # k лучших

Для физика

Десять самых энергичных событий из миллиона — без сортировки всего набора.

def heap_sort(items):
    n = len(items)
    for start in range((n - 2) // 2, -1, -1):
        sift_down(items, start, n - 1)   # max-heap
    for end in range(n - 1, 0, -1):
        items[0], items[end] = items[end], items[0]
        sift_down(items, 0, end - 1)     # n − 1 раз
 
def sort_key(user):                      # задача 6
    login, solved, penalty = user
    return (-solved, penalty, login)

Пояснение

На практике медленнее быстрой сортировки: просеивание обращается к далёким ячейкам массива.

01

10 самых энергичных событий из 1 000 000

02

heapq.nlargest, куча из 10 элементов и sorted

03

Сравнения: 100 000 вызовов heappush и heapify

04

Пирамидальная сортировка главы и задача 6

Пояснение

Дерево — связный граф без циклов, у него n − 1 рёбер; граф без циклов называется лесом.

matrix = [[0] * n for _ in range(n)]   # не [[0] * n] * n
matrix[u][v] = matrix[v][u] = 1
 
graph = defaultdict(list)              # списки смежности
graph[u].append(v)
graph[v].append(u)
 
edges = [(w, u, v), ...]               # список рёбер

Для физика

Реальные графы разрежены: у атома в молекуле единицы связей, у пикселя не больше восьми соседей.

def dfs(graph, start):              # явный стек
    visited, stack = set(), [start]
    while stack:
        v = stack.pop()
        if v in visited:            # после снятия
            continue
        visited.add(v)              # обработка v
        stack.extend(reversed(graph[v]))
 
def bfs(graph, start):              # очередь
    visited, queue = {start}, deque([start])
    while queue:
        v = queue.popleft()         # обработка v
        for u in graph[v]:
            if u not in visited:
                visited.add(u)      # при постановке
                queue.append(u)

Пояснение

Компоненты связности — обход из каждой ещё не посещённой вершины.

01

Матрица 64 × 64: следы частиц и шумовые пиксели

02

Граф соседства: матрица против списков

03

Кластеры — компоненты связности, BFS

04

Порядок DFS и BFS на графе из шести вершин

Электрические цепи

законы Кирхгофа: m − n + 1 независимых контуров

Модель Изинга

кластеры Свендсена — Ванга и Вольфа

Перколяция

компонента, соединяющая края решётки

Молекулы

кольца — циклы, графовые нейронные сети

Марковские цепи

переходы с вероятностями — взвешенный орграф

Трассировка

кабели, маршруты, план эксперимента

import networkx as nx
lattice = nx.grid_2d_graph(4, 4)          # решётка 4 × 4
nx.number_connected_components(lattice)
nx.shortest_path(lattice, (0, 0), (3, 3))
nx.minimum_spanning_tree(lattice)

Пояснение

Библиотека не подскажет, что задача сводится к компонентам связности: это решает постановка.

01

Решётка L × L, узел занят с вероятностью p

02

BFS сразу из всех занятых узлов верхней строки

03

Доля протекающих решёток из 200 испытаний

04

L = 16, 32, 64; p от 0,50 до 0,70

def dijkstra(graph, start):     # веса w ≥ 0
    dist = {start: 0}
    heap = [(0, start)]
    while heap:
        d, v = heapq.heappop(heap)
        if d > dist[v]:
            continue            # устаревшая запись
        for u, w in graph[v]:
            if d + w < dist.get(u, inf):
                dist[u] = d + w     # релаксация
                heapq.heappush(heap, (d + w, u))
    return dist

Важно

Веса неотрицательны; при отрицательных — алгоритм Беллмана — Форда.

01

12 помещений комплекса, 16 проходов с длиной в метрах

02

BFS: путь с наименьшим числом переходов

03

Дейкстра с heapq: путь наименьшей длины

04

Извлечения из кучи и устаревшие записи

def kahn(graph):                # {u: [v, ...]}
    indeg = {v: 0 for v in graph}
    for u in graph:
        for v in graph[u]:
            indeg[v] += 1
    queue = deque(v for v in graph if indeg[v] == 0)
    order = []
    while queue:
        u = queue.popleft()
        order.append(u)
        for v in graph[u]:
            indeg[v] -= 1
            if indeg[v] == 0:
                queue.append(v)
    if len(order) < len(graph):
        raise ValueError('цикл в зависимостях')
    return order

ts = graphlib.TopologicalSorter(deps)
list(ts.static_order())    # CycleError при цикле

Для физика

Этапы обработки данных эксперимента: калибровка, выравнивание, треки, события.

01

Десять этапов обработки, двенадцать зависимостей

02

DFS главы, проверка рёбер и graphlib

03

Ошибочное ребро треки → выравнивание

04

Два DFS, алгоритм Кана и graphlib на цикле

def kruskal(n, edges):           # edges: [(w, u, v)]
    parent = list(range(n))
    def find(x):                 # корень множества
        while parent[x] != x:
            parent[x] = parent[parent[x]]
            x = parent[x]
        return x
    total = 0
    for w, u, v in sorted(edges):    # по весу
        ru, rv = find(u), find(v)
        if ru != rv:             # не замыкает цикл
            parent[ru] = rv
            total += w
    return total

Для физика

В цепи m − n + 1 независимых контуров — столько ветвей остаётся вне остова.

01

10 крейтов электроники, 45 возможных кабелей

02

Алгоритмы Прима и Краскала

03

Звезда от крейта 0 и максимальное дерево

04

Сетка резисторов 3 × 3: остов и контуры

Пояснение

Задачи глав «Деревья» и «Графы» с автоматической проверкой собраны в тренажёрах Яндекс Контеста.

Для физика

Собственная реализация проверяется сравнением с эталоном: dict, sorted, graphlib, scipy.spatial.

Книга курса: главы «Хеш-функции», «Деревья» и «Графы» части «Алгоритмы и структуры данных», тренажёры задач глав

phys-dev.github.io/soft-dev-book

Кормен Т., Лейзерсон Ч., Ривест Р., Штайн К. Алгоритмы: построение и анализ. – 3-е изд. – Вильямс, 2013; Седжвик Р., Уэйн К., Дондеро Р. Программирование на языке Python: учебный курс. – Вильямс, 2017

Кнут Д. Искусство программирования. Т. 1: Основные алгоритмы. – 3-е изд. – Вильямс, 2018; Т. 3: Сортировка и поиск. – 2-е изд. – Вильямс

Virtanen P. et al. SciPy 1.0 // Nature Methods. – 2020. – Vol. 17; Newman M. E. J., Ziff R. M. // Phys. Rev. Lett. – 2000. – Vol. 85; Devroye L. // J. ACM. – 1986. – Vol. 33

PEP 456: Secure and interchangeable hash algorithm; OWASP Password Storage Cheat Sheet

peps.python.org/pep-0456

Документация Python: hashlib, heapq, bisect, graphlib

docs.python.org/3/library