Эта книга не про IT, это больше популярное чтиво о том, как работает физика в конструкциях. Язык и объяснения невероятно простые. Если бы так физику преподавали в школе, я бы точно получал одни пятерки! Потрясающие графики и фотографии, рисунки и силуэты, описания базовых принципов растяжения и деформации и много другое! Просто зачитываюсь в свободное время и наслаждаюсь, как можно просто писать о таких сложных вещах!
Есть еще несколько других интересных книг, но расскажу о них позже, если вам зайдет такой формат в постах.
Так же буду рад получить от вас другие рекомендации, что еще моно почитать!
#books
Есть еще несколько других интересных книг, но расскажу о них позже, если вам зайдет такой формат в постах.
Так же буду рад получить от вас другие рекомендации, что еще моно почитать!
#books
👍9❤1🔥1
Алгоритмы. Обход в глубину (DFS)
После небольшой паузы мы продолжаем разбирать различные алгоритмы.
Обход в глубину (DFS) — это один из фундаментальных алгоритмов на графах, и его легче всего понять через аналогию с исследованием пещеры. Представь, что ты стоишь в системе туннелей с множеством разветвлений. Твоя стратегия заключается в том, чтобы выбрать первый попавшийся проход и идти по нему до тех пор, пока не упрешься в тупик. Только тогда ты возвращаешься назад к последнему перекрестку, где еще есть неисследованные пути, и пробуешь следующий туннель. Эта логика, где глубина проникновения важнее ширины охвата, и лежит в основе алгоритма DFS.
Рассмотрим небольшой граф. Предположим, у нас есть узлы, соединенные между собой: A связан с B и C; B связан с A, D и E; C связан с A и F; D связан только с B; E связан с B и F, а F, в свою очередь, связан с C и E. Если начать обход с узла A, DFS будет двигаться следующим образом: сначала мы попадаем в A, затем углубляемся в B, оттуда — в D. Достигнув D, мы понимаем, что это тупик (сосед B уже посещен), поэтому возвращаемся обратно в B и идем по следующему пути в E. Из E переходим в F, который тоже оказывается тупиком (все соседи посещены или ведут назад). После возврата в E и затем в B, мы наконец возвращаемся в A и идем в C, но обнаруживаем, что C уже был посещен через F. Итоговый порядок посещения узлов будет таким: A, B, D, E, F, C.
В этом заключается ключевое отличие DFS от другого известного алгоритма — поиска в ширину (BFS). BFS работает подобно кругам на воде: сначала исследуются все соседние узлы, затем их соседи, распространяясь равномерно во все стороны. DFS же напоминает нить Ариадны в лабиринте: он всегда идет до конца по выбранному пути и лишь затем возвращается.
Для реализации DFS можно использовать два основных подхода, которые делают одно и то же, но разными средствами: рекурсию и явный стек. Рекурсивный метод полагается на стек вызовов самой программы. Когда мы пишем функцию, которая вызывает саму себя для обработки соседей, язык программирования автоматически запоминает точку возврата. Однако здесь есть важная особенность Python: не стоит задавать значение аргумента
Пример 1
Чтобы лучше понять, как работает рекурсия, можно проследить её выполнение по шагам. Входя в узел A, мы помечаем его как посещенный и записываем в результат. Затем смотрим на соседа B, который еще не посещен, и вызываем функцию для B. Внутри вызова для B повторяется та же логика: добавляем B в путь и идем к его первому непосещенному соседу D. В D тупик, и функция возвращает результат обратно. Далее в B очередь доходит до следующего соседа — E. Из E попадаем в F, а из F — в C. Когда все пути исчерпаны, результаты склеиваются и возвращаются наверх.
Пример 2
Второй способ реализации — итеративный с использованием явного стека. Стек работает по принципу «последним пришел — первым вышел» (LIFO). Это как стопка тарелок: новую тарелку кладут сверху, и первую берут тоже сверху. В коде мы сами управляем этим стеком, помещая туда узлы для последующей обработки. Важный нюанс: чтобы порядок обхода совпадал с рекурсивной версией, соседей часто добавляют в обратном порядке. Если просто положить соседей в стек по порядку, то из-за механизма LIFO первым будет извлечен последний сосед, и обход пойдет в другую сторону.
Пример 3
После небольшой паузы мы продолжаем разбирать различные алгоритмы.
Обход в глубину (DFS) — это один из фундаментальных алгоритмов на графах, и его легче всего понять через аналогию с исследованием пещеры. Представь, что ты стоишь в системе туннелей с множеством разветвлений. Твоя стратегия заключается в том, чтобы выбрать первый попавшийся проход и идти по нему до тех пор, пока не упрешься в тупик. Только тогда ты возвращаешься назад к последнему перекрестку, где еще есть неисследованные пути, и пробуешь следующий туннель. Эта логика, где глубина проникновения важнее ширины охвата, и лежит в основе алгоритма DFS.
Рассмотрим небольшой граф. Предположим, у нас есть узлы, соединенные между собой: A связан с B и C; B связан с A, D и E; C связан с A и F; D связан только с B; E связан с B и F, а F, в свою очередь, связан с C и E. Если начать обход с узла A, DFS будет двигаться следующим образом: сначала мы попадаем в A, затем углубляемся в B, оттуда — в D. Достигнув D, мы понимаем, что это тупик (сосед B уже посещен), поэтому возвращаемся обратно в B и идем по следующему пути в E. Из E переходим в F, который тоже оказывается тупиком (все соседи посещены или ведут назад). После возврата в E и затем в B, мы наконец возвращаемся в A и идем в C, но обнаруживаем, что C уже был посещен через F. Итоговый порядок посещения узлов будет таким: A, B, D, E, F, C.
Граф:
A
/ \
B C
/ \ \
D E F
\ /
(F связан с E и C)
DFS от A пойдёт так:
A → B → D (тупик, назад) → E → F (тупик, назад) → назад → C (уже посещён через F)
Порядок посещения: A, B, D, E, F, C
В этом заключается ключевое отличие DFS от другого известного алгоритма — поиска в ширину (BFS). BFS работает подобно кругам на воде: сначала исследуются все соседние узлы, затем их соседи, распространяясь равномерно во все стороны. DFS же напоминает нить Ариадны в лабиринте: он всегда идет до конца по выбранному пути и лишь затем возвращается.
Граф: BFS (в ширину): DFS (в глубину):
A Уровень за уровнем Ветка за веткой
/ \ A A
B C B, C B, D, E, F, C
/ \ \ D, E, F
D E F
Для реализации DFS можно использовать два основных подхода, которые делают одно и то же, но разными средствами: рекурсию и явный стек. Рекурсивный метод полагается на стек вызовов самой программы. Когда мы пишем функцию, которая вызывает саму себя для обработки соседей, язык программирования автоматически запоминает точку возврата. Однако здесь есть важная особенность Python: не стоит задавать значение аргумента
visited по умолчанию как пустое множество (set()), так как изменяемые объекты создаются один раз и будут переиспользованы во всех вызовах функции. Вместо этого нужно создавать его внутри функции, если оно не передано.Пример 1
Чтобы лучше понять, как работает рекурсия, можно проследить её выполнение по шагам. Входя в узел A, мы помечаем его как посещенный и записываем в результат. Затем смотрим на соседа B, который еще не посещен, и вызываем функцию для B. Внутри вызова для B повторяется та же логика: добавляем B в путь и идем к его первому непосещенному соседу D. В D тупик, и функция возвращает результат обратно. Далее в B очередь доходит до следующего соседа — E. Из E попадаем в F, а из F — в C. Когда все пути исчерпаны, результаты склеиваются и возвращаются наверх.
Пример 2
Второй способ реализации — итеративный с использованием явного стека. Стек работает по принципу «последним пришел — первым вышел» (LIFO). Это как стопка тарелок: новую тарелку кладут сверху, и первую берут тоже сверху. В коде мы сами управляем этим стеком, помещая туда узлы для последующей обработки. Важный нюанс: чтобы порядок обхода совпадал с рекурсивной версией, соседей часто добавляют в обратном порядке. Если просто положить соседей в стек по порядку, то из-за механизма LIFO первым будет извлечен последний сосед, и обход пойдет в другую сторону.
Пример 3
Процесс итеративного обхода можно наглядно представить в виде таблицы, где видно, как меняется содержимое стека на каждом шаге. Начинаем со стеком, содержащим A. Извлекаем A, помечаем его и добавляем в результат, а затем кладем в стек его соседей C и B в обратном порядке (чтобы B оказался сверху). Затем извлекаем B, затем D, и так далее, пока стек не опустеет.
Этот код, по сути, является готовой реализацией итеративного DFS, где стек берет на себя работу, которую в рекурсивной версии выполняет стек вызовов. Каждая часть здесь важна: множество
Одна из классических задач, решаемых с помощью DFS, — поиск циклов в графе. Цикл — это ситуация, когда, двигаясь по графу, мы возвращаемся в узел, который уже встречали на текущем пути. Важно отличать просто посещенный узел от узла, находящегося в текущем стеке рекурсии. Ведь если мы видим уже посещенный узел, который не является частью текущего пути, это может быть просто пересечение, а не цикл. Поэтому в алгоритме используются два множества:
Алгоритм запускает проверку из каждой вершины, чтобы учесть возможную несвязность графа. Если в процессе обхода мы наталкиваемся на соседа, который уже есть в
Пример 4
Как именно это работает, можно увидеть на примере графа с циклом. Начиная с A, мы идем в B, затем в D. В узле D видим соседа B, который уже есть в
Пример 5
Еще одно важное практическое применение DFS — поиск пути в лабиринте. Здесь выбор между DFS и BFS зависит от конкретной задачи. Если нам нужно просто найти любой путь к выходу, DFS часто оказывается предпочтительнее. Он идет по одному пути до упора и, если лабиринт не слишком разветвлен, может найти выход довольно быстро. При этом DFS использует меньше памяти, так как хранит лишь текущий путь.
Пример 6
Однако если стоит задача найти кратчайший путь, DFS не подходит. Он может углубиться в длинную ветку и найти путь, который окажется далеко не самым коротким, в то время как существует более прямой маршрут. В такой ситуации BFS гарантированно найдет кратчайший путь, хотя и потребует больше памяти для хранения всех узлов текущего уровня.
Шаг | Стек (вершина →) | Берём | visited | result
----|--------------------|-------|-----------------|------------------
0 | [A] | A | {A} | [A]
1 | [C, B] | B | {A,B} | [A,B]
2 | [C, E, D] | D | {A,B,D} | [A,B,D]
3 | [C, E] | E | {A,B,D,E} | [A,B,D,E]
4 | [C, F] | F | {A,B,D,E,F} | [A,B,D,E,F]
5 | [C, E*, C] | C | {A,B,D,E,F,C} | [A,B,D,E,F,C]
(* E уже в visited — пропустим при извлечении)
Финальный результат: [A, B, D, E, F, C] ✓
Этот код, по сути, является готовой реализацией итеративного DFS, где стек берет на себя работу, которую в рекурсивной версии выполняет стек вызовов. Каждая часть здесь важна: множество
visited отслеживает уже обработанные узлы, список stack хранит узлы, которые предстоит обработать, а цикл while работает, пока есть что извлекать.Одна из классических задач, решаемых с помощью DFS, — поиск циклов в графе. Цикл — это ситуация, когда, двигаясь по графу, мы возвращаемся в узел, который уже встречали на текущем пути. Важно отличать просто посещенный узел от узла, находящегося в текущем стеке рекурсии. Ведь если мы видим уже посещенный узел, который не является частью текущего пути, это может быть просто пересечение, а не цикл. Поэтому в алгоритме используются два множества:
visited для всех узлов, которые когда-либо посещались, и rec_stack для узлов, в которых мы находимся прямо сейчас в процессе рекурсивного спуска.Граф БЕЗ цикла: Граф С циклом:
A A
/ \ / \
B C B C
| |\ /
D | X
|/ \
D E
Алгоритм запускает проверку из каждой вершины, чтобы учесть возможную несвязность графа. Если в процессе обхода мы наталкиваемся на соседа, который уже есть в
rec_stack, это означает обнаружение цикла.Пример 4
Как именно это работает, можно увидеть на примере графа с циклом. Начиная с A, мы идем в B, затем в D. В узле D видим соседа B, который уже есть в
rec_stack. Это и есть сигнал о наличии цикла.Пример 5
Еще одно важное практическое применение DFS — поиск пути в лабиринте. Здесь выбор между DFS и BFS зависит от конкретной задачи. Если нам нужно просто найти любой путь к выходу, DFS часто оказывается предпочтительнее. Он идет по одному пути до упора и, если лабиринт не слишком разветвлен, может найти выход довольно быстро. При этом DFS использует меньше памяти, так как хранит лишь текущий путь.
Пример 6
Однако если стоит задача найти кратчайший путь, DFS не подходит. Он может углубиться в длинную ветку и найти путь, который окажется далеко не самым коротким, в то время как существует более прямой маршрут. В такой ситуации BFS гарантированно найдет кратчайший путь, хотя и потребует больше памяти для хранения всех узлов текущего уровня.
Лабиринт: DFS может пойти так: BFS пойдёт так:
S S→A→C→E→EXIT S→A (длина 1)
/ \ (длина 4) S→B (длина 1)
A B Хотя существует S→A→C, S→B→EXIT
| | S→B→EXIT Найдёт S→B→EXIT
C EXIT (длина 2)! (длина 2) первым
\ /
E
|
EXIT
DFS нашёл путь длиной 4, хотя есть путь длиной 2.
BFS всегда находит кратчайший путь.
Сравнивая эти два подхода для лабиринта, можно выделить несколько критериев. Для задачи нахождения любого выхода оба алгоритма работают, но DFS требует меньше памяти. Для поиска кратчайшего пути BFS гарантирует результат, а DFS — нет. В глубоких лабиринтах рекурсивный DFS рискует переполнить стек, тогда как итеративный и BFS безопасны. В широких лабиринтах BFS может потребить много памяти, а DFS остается эффективным.
Что касается вычислительной сложности, то и для DFS, и для BFS она одинакова. Временная сложность составляет O(V + E), где V — количество вершин (узлов), а E — количество ребер. Это объясняется тем, что алгоритм посещает каждую вершину ровно один раз и просматривает каждое ребро также один раз. Пространственная сложность в худшем случае составляет O(V) — память нужна для хранения множества посещенных узлов и, в случае итеративной реализации, стека.
Подводя итог, можно сказать, что DFS — это алгоритм, который идет вглубь до упора, а затем возвращается. Его можно реализовать элегантно через рекурсию или более контролируемо через явный стек. Он применяется для поиска любого пути, обнаружения циклов, топологической сортировки и обхода деревьев, но не гарантирует нахождения кратчайшего маршрута.
#algorithm
Что касается вычислительной сложности, то и для DFS, и для BFS она одинакова. Временная сложность составляет O(V + E), где V — количество вершин (узлов), а E — количество ребер. Это объясняется тем, что алгоритм посещает каждую вершину ровно один раз и просматривает каждое ребро также один раз. Пространственная сложность в худшем случае составляет O(V) — память нужна для хранения множества посещенных узлов и, в случае итеративной реализации, стека.
Подводя итог, можно сказать, что DFS — это алгоритм, который идет вглубь до упора, а затем возвращается. Его можно реализовать элегантно через рекурсию или более контролируемо через явный стек. Он применяется для поиска любого пути, обнаружения циклов, топологической сортировки и обхода деревьев, но не гарантирует нахождения кратчайшего маршрута.
#algorithm
❤6👍2
Фиксы SoliditySet
Спасибо всем, кто сообщал мне о проблемах на платформе и подсказывал лучшие решения для тех или иных случаев. Сегодня был выполнен очередной фикс:
1. Были исправлены некоторые не работающие ссылки;
2. Обновлено отображение на мобильных экранах: немного удобнее использовать на планшетах;
3. К нумерации уроков были добавлены заголовки уроков;
4. Подсказки и ответы для модуля 5 (практика поиска уязвимостей) были скрыты под спойлером. (Тут я еще думаю как сделать это красивее...).
5. Исправлен порядок вывода некоторых уроков.
6. Откорректированы мелкие недочеты.
Спасибо, что помогаете сделать платформу лучше! В марте я планирую добавить несколько новых уроков, и если все пойдет как надо: новый раздел с переводами зарубежных статей.
#solidityset
Спасибо всем, кто сообщал мне о проблемах на платформе и подсказывал лучшие решения для тех или иных случаев. Сегодня был выполнен очередной фикс:
1. Были исправлены некоторые не работающие ссылки;
2. Обновлено отображение на мобильных экранах: немного удобнее использовать на планшетах;
3. К нумерации уроков были добавлены заголовки уроков;
4. Подсказки и ответы для модуля 5 (практика поиска уязвимостей) были скрыты под спойлером. (Тут я еще думаю как сделать это красивее...).
5. Исправлен порядок вывода некоторых уроков.
6. Откорректированы мелкие недочеты.
Спасибо, что помогаете сделать платформу лучше! В марте я планирую добавить несколько новых уроков, и если все пойдет как надо: новый раздел с переводами зарубежных статей.
#solidityset
👍9❤1
Алгоритмы. Алгоритм Дейкстры
Рассматривая этот алгоритм, я все никак не мог привыкнуть читать его как Дейкстры. Каждый раз в голове крутился образ персонажа из Ведьмака - шпиона Диикстры. При этом на английском языке они пишутся одинаково - Dijkstra. Но забудем об этом и вернемся к нашему алгоритму.
Представьте карту городов, соединённых дорогами. Каждый город можно представить как вершину графа, каждая дорога — как ребро, а расстояние между городами — как вес ребра. Например, рассмотрим такой граф:
Если мы хотим добраться из A в D по кратчайшему пути, то на глаз ответ не всегда очевиден. Именно для решения таких задач и существует алгоритм Дейкстры, который находит кратчайшие пути от одной вершины до всех остальных во взвешенном графе с неотрицательными весами рёбер.
Прежде чем углубляться, стоит уточнить ключевые понятия. Граф — это набор точек (вершин), соединённых линиями (рёбрами). Вес ребра — это число, стоящее на ребре и обозначающее стоимость перехода (расстояние, время, цена и т.п.). Взвешенный граф — это граф, где у каждого ребра есть вес. Кратчайший путь — это маршрут с минимальной суммой весов рёбер. Алгоритм Дейкстры относится к классу жадных алгоритмов: на каждом шаге он выбирает локально лучший вариант, то есть вершину с наименьшим известным расстоянием от старта.
Идею алгоритма можно объяснить простыми словами: вы стоите в начальной точке и хотите узнать расстояния до всех остальных городов. Вы постепенно открываете для себя новые города, всегда переходя сначала в тот, до которого сейчас ближе всего. При этом, попадая в новый город, вы проверяете, не стали ли теперь известные пути до его соседей короче. Этот процесс повторяется, пока не будут обработаны все вершины. Иными словами, на каждом шаге мы идём в ближайший ещё не посещённый город и обновляем расстояния до его соседей.
Рассмотрим работу алгоритма на конкретном примере. Пусть дан граф:
Рёбра и их веса:
- A–B: 1
- A–C: 4
- B–C: 2
- B–D: 5
- C–D: 1
Начальная вершина — A. В начальный момент мы знаем расстояние только до самой себя (ноль), а до всех остальных вершин расстояние полагаем бесконечным. Состояние можно описать так:
Извлекаем из очереди вершину A с расстоянием 0. Рассматриваем её соседей: до B можно добраться за 0+1=1, что меньше бесконечности, поэтому обновляем расстояние до B. До C можно добраться за 0+4=4, обновляем C. После этого состояния становятся такими:
Теперь из очереди выбираем вершину с наименьшим расстоянием — это B (расстояние 1). Из B можно пойти к A (но расстояние 1+1=2 больше уже известного 0, поэтому пропускаем), к C (1+2=3, что меньше текущего 4, обновляем C до 3) и к D (1+5=6, обновляем D с бесконечности до 6). После этого:
Обратите внимание: в очереди теперь есть два элемента для вершины C: (3, C) и (4, C_old). Это старая запись, которая будет проигнорирована позже.
Следующая ближайшая вершина — C с расстоянием 3. Проверяем соседей: до A (3+4=7 > 0), до B (3+2=5 > 1), до D (3+1=4 < 6) — обновляем D до 4. После обновления:
Наконец, извлекаем D с расстоянием 4. Её соседи уже посещены или не дают улучшений. Алгоритм завершается. Итоговые расстояния:
- A = 0
- B = 1
- C = 3
- D = 4
Кратчайшие пути из A:
- A → A : 0
- A → B : A → B (вес 1)
- A → C : A → B → C (1 + 2 = 3)
- A → D : A → B → C → D (1 + 2 + 1 = 4)
Рассматривая этот алгоритм, я все никак не мог привыкнуть читать его как Дейкстры. Каждый раз в голове крутился образ персонажа из Ведьмака - шпиона Диикстры. При этом на английском языке они пишутся одинаково - Dijkstra. Но забудем об этом и вернемся к нашему алгоритму.
Представьте карту городов, соединённых дорогами. Каждый город можно представить как вершину графа, каждая дорога — как ребро, а расстояние между городами — как вес ребра. Например, рассмотрим такой граф:
A ──1── B
│ │
4 2
│ │
C ──────D
1
Если мы хотим добраться из A в D по кратчайшему пути, то на глаз ответ не всегда очевиден. Именно для решения таких задач и существует алгоритм Дейкстры, который находит кратчайшие пути от одной вершины до всех остальных во взвешенном графе с неотрицательными весами рёбер.
Прежде чем углубляться, стоит уточнить ключевые понятия. Граф — это набор точек (вершин), соединённых линиями (рёбрами). Вес ребра — это число, стоящее на ребре и обозначающее стоимость перехода (расстояние, время, цена и т.п.). Взвешенный граф — это граф, где у каждого ребра есть вес. Кратчайший путь — это маршрут с минимальной суммой весов рёбер. Алгоритм Дейкстры относится к классу жадных алгоритмов: на каждом шаге он выбирает локально лучший вариант, то есть вершину с наименьшим известным расстоянием от старта.
Идею алгоритма можно объяснить простыми словами: вы стоите в начальной точке и хотите узнать расстояния до всех остальных городов. Вы постепенно открываете для себя новые города, всегда переходя сначала в тот, до которого сейчас ближе всего. При этом, попадая в новый город, вы проверяете, не стали ли теперь известные пути до его соседей короче. Этот процесс повторяется, пока не будут обработаны все вершины. Иными словами, на каждом шаге мы идём в ближайший ещё не посещённый город и обновляем расстояния до его соседей.
Рассмотрим работу алгоритма на конкретном примере. Пусть дан граф:
A ──1── B
│ ╱ │
4 2 5
│ ╱ │
C ──1── D
Рёбра и их веса:
- A–B: 1
- A–C: 4
- B–C: 2
- B–D: 5
- C–D: 1
Начальная вершина — A. В начальный момент мы знаем расстояние только до самой себя (ноль), а до всех остальных вершин расстояние полагаем бесконечным. Состояние можно описать так:
Расстояния: A=0, B=∞, C=∞, D=∞
Посещены: {}
Очередь: [(0, A)]
Извлекаем из очереди вершину A с расстоянием 0. Рассматриваем её соседей: до B можно добраться за 0+1=1, что меньше бесконечности, поэтому обновляем расстояние до B. До C можно добраться за 0+4=4, обновляем C. После этого состояния становятся такими:
Расстояния: A=0, B=1, C=4, D=∞
Посещены: {A}
Очередь: [(1, B), (4, C)]
Теперь из очереди выбираем вершину с наименьшим расстоянием — это B (расстояние 1). Из B можно пойти к A (но расстояние 1+1=2 больше уже известного 0, поэтому пропускаем), к C (1+2=3, что меньше текущего 4, обновляем C до 3) и к D (1+5=6, обновляем D с бесконечности до 6). После этого:
Расстояния: A=0, B=1, C=3, D=6
Посещены: {A, B}
Очередь: [(3, C), (4, C_old), (6, D)]
Обратите внимание: в очереди теперь есть два элемента для вершины C: (3, C) и (4, C_old). Это старая запись, которая будет проигнорирована позже.
Следующая ближайшая вершина — C с расстоянием 3. Проверяем соседей: до A (3+4=7 > 0), до B (3+2=5 > 1), до D (3+1=4 < 6) — обновляем D до 4. После обновления:
Расстояния: A=0, B=1, C=3, D=4
Посещены: {A, B, C}
Очередь: [(4, D), (4, C_old), (6, D_old)]
Наконец, извлекаем D с расстоянием 4. Её соседи уже посещены или не дают улучшений. Алгоритм завершается. Итоговые расстояния:
- A = 0
- B = 1
- C = 3
- D = 4
Кратчайшие пути из A:
- A → A : 0
- A → B : A → B (вес 1)
- A → C : A → B → C (1 + 2 = 3)
- A → D : A → B → C → D (1 + 2 + 1 = 4)
Теперь разберём реализацию алгоритма на языке Python с использованием модуля heapq, который предоставляет приоритетную очередь. Приоритетная очередь отличается от обычной тем, что всегда возвращает элемент с наименьшим ключом (в нашем случае — расстоянием). Это как раз соответствует жадному выбору ближайшей вершины.
Поясним некоторые детали реализации. Строка
Важно понимать, почему используется именно приоритетная очередь. Если бы мы каждый раз искали минимум простым перебором, сложность стала бы квадратичной. Благодаря этому мы получаем эффективность: каждая операция извлечения минимума и вставки стоит O(log V), где V — число вершин.
Сложность алгоритма Дейкстры с приоритетной очередью составляет O((V + E) log V), где V — количество вершин, E — количество рёбер. Для большинства реальных задач, таких как прокладка маршрутов на карте или в сетях, это приемлемо быстро.
Однако у алгоритма Дейкстры есть важное ограничение: он работает только с неотрицательными весами рёбер. Почему это так? Дело в том, что алгоритм основан на гарантии: когда вершина извлекается из очереди с минимальным расстоянием, это расстояние уже окончательное и не может быть улучшено позже. Если бы существовали отрицательные рёбра, то путь через другую вершину, ещё не обработанную, мог бы дать меньшее расстояние, даже если текущая вершина уже «закрыта». Рассмотрим простой пример:
Дейкстра из A сначала установит расстояния: B=2, C=4. Затем извлечёт B (расстояние 2) и пометит его как финальное. При обработке B он обновит C: 2 + (−5) = −3, и это станет новым расстоянием до C. Однако теперь уже поздно пересматривать пути через другие вершины, потому что B уже обработан. В этом конкретном случае мы всё же получим правильный ответ, но в более сложных графах с отрицательными весами могут возникнуть ситуации, когда оптимальный путь требует пересмотра уже обработанных вершин, что невозможно в рамках алгоритма Дейкстры. Более того, отрицательные веса могут создавать циклы с отрицательной суммой, которые делают понятие кратчайшего пути вообще неопределённым (можно бесконечно уменьшать стоимость, обходя цикл).
Если в графе присутствуют отрицательные веса, следует использовать алгоритм Беллмана–Форда. Он не полагается на жадный выбор и не делает предположений о финальности расстояний. Вместо этого алгоритм выполняет V−1 проходов по всем рёбрам, каждый раз пытаясь улучшить расстояния. Вот его простая реализация:
import heapq # Модуль для приоритетной очереди (мин-куча)
def dijkstra(graph, start):
# 1. Инициализация: все расстояния = бесконечность
distances = {node: float("infinity") for node in graph}
distances[start] = 0 # До стартовой вершины — 0
# 2. Приоритетная очередь: (расстояние, вершина)
# heapq всегда отдаёт элемент с МИНИМАЛЬНЫМ расстоянием первым
priority_queue = [(0, start)]
while priority_queue:
# 3. Извлекаем вершину с наименьшим расстоянием
current_distance, current_node = heapq.heappop(priority_queue)
# 4. Устаревшая запись? Пропускаем
# (в очереди могут быть старые версии с большим расстоянием)
if current_distance > distances[current_node]:
continue
# 5. Обходим соседей
for neighbor, weight in graph[current_node].items():
distance = current_distance + weight
# 6. Нашли более короткий путь? Обновляем!
if distance < distances[neighbor]:
distances[neighbor] = distance
heapq.heappush(priority_queue, (distance, neighbor))
return distances
Поясним некоторые детали реализации. Строка
if current_distance > distances[current_node]: continue необходима для отбрасывания устаревших записей в очереди. Когда мы обновляем расстояние до вершины (например, C с 4 на 3), старая запись (4, C) остаётся в куче. Когда она позже извлекается, мы проверяем, что её расстояние больше текущего известного, и просто пропускаем её. Это экономит время и корректирует работу алгоритма.Важно понимать, почему используется именно приоритетная очередь. Если бы мы каждый раз искали минимум простым перебором, сложность стала бы квадратичной. Благодаря этому мы получаем эффективность: каждая операция извлечения минимума и вставки стоит O(log V), где V — число вершин.
Сложность алгоритма Дейкстры с приоритетной очередью составляет O((V + E) log V), где V — количество вершин, E — количество рёбер. Для большинства реальных задач, таких как прокладка маршрутов на карте или в сетях, это приемлемо быстро.
Однако у алгоритма Дейкстры есть важное ограничение: он работает только с неотрицательными весами рёбер. Почему это так? Дело в том, что алгоритм основан на гарантии: когда вершина извлекается из очереди с минимальным расстоянием, это расстояние уже окончательное и не может быть улучшено позже. Если бы существовали отрицательные рёбра, то путь через другую вершину, ещё не обработанную, мог бы дать меньшее расстояние, даже если текущая вершина уже «закрыта». Рассмотрим простой пример:
A ──2── B ──(−5)── C
A ─────────4───── C
Дейкстра из A сначала установит расстояния: B=2, C=4. Затем извлечёт B (расстояние 2) и пометит его как финальное. При обработке B он обновит C: 2 + (−5) = −3, и это станет новым расстоянием до C. Однако теперь уже поздно пересматривать пути через другие вершины, потому что B уже обработан. В этом конкретном случае мы всё же получим правильный ответ, но в более сложных графах с отрицательными весами могут возникнуть ситуации, когда оптимальный путь требует пересмотра уже обработанных вершин, что невозможно в рамках алгоритма Дейкстры. Более того, отрицательные веса могут создавать циклы с отрицательной суммой, которые делают понятие кратчайшего пути вообще неопределённым (можно бесконечно уменьшать стоимость, обходя цикл).
Если в графе присутствуют отрицательные веса, следует использовать алгоритм Беллмана–Форда. Он не полагается на жадный выбор и не делает предположений о финальности расстояний. Вместо этого алгоритм выполняет V−1 проходов по всем рёбрам, каждый раз пытаясь улучшить расстояния. Вот его простая реализация:
def bellman_ford(graph, start):
distances = {node: float("infinity") for node in graph}
distances[start] = 0
for _ in range(len(graph) - 1): # V-1 итераций
for node in graph:
for neighbor, weight in graph[node].items():
if distances[node] + weight < distances[neighbor]:
distances[neighbor] = distances[node] + weight
return distances
Сложность Беллмана–Форда выше — O(V·E), но он способен обнаруживать отрицательные циклы и, соответственно, определять, что задача не имеет решения. Сравним два подхода:
- Дейкстра: работает только с неотрицательными весами, быстрее (O((V+E) log V)).
- Беллман–Форд: работает с любыми весами, медленнее (O(V·E)), может обнаруживать отрицательные циклы.
В реальной жизни алгоритм Дейкстра широко применяется. Например, в GPS-навигаторах (Google Maps, Яндекс.Карты) города или перекрёстки — это вершины, дороги — рёбра, а весом может быть время в пути. Алгоритм находит маршрут с минимальным временем. В интернете протоколы маршрутизации, такие как OSPF, используют алгоритм Дейкстры для определения кратчайшего пути передачи пакетов данных (вершины — роутеры, рёбра — каналы связи, вес — задержка или пропускная способность). В игровых движках NPC (неигровые персонажи) находят путь по карте с препятствиями. В системах поиска авиабилетов вершинами выступают аэропорты, рёбрами — рейсы, а весом — стоимость или время, что позволяет находить самые дешёвые или быстрые маршруты с пересадками.
#algorithm
👍3
Разбор репо с Copilot
Пока не успеваю написать следующий пост про алгоритмы, хочу поделиться с вами прикольным способом изучать репо. Вероятно, многие из вас уже знают об этом, но другим этот вариант может быть будет полезен.
P.S. Вероятнее всего, будет работать с изменением локации через сторонние сервисы.
Когда вы заходите на страницу проекта на GitHub через компьютер или ноутбук, то в правом верхнем углу есть иконка Copilot - ИИ агента от Microsoft. При нажатии на эту кнопку открывается страница с чатом, где пользователь может задавать свои вопросы по архитектуре и коду проекта. Для ответов используется достойная модель Claude Haiku 4.5 (но можно выбрать и другие).
Самое прикольное то, что бот имеет доступ к коммитам репо, т.е. вы можете использовать его для изучения изменений в коде.
Лимиты, скорее всего, есть, при этом мне его хватало всегда для достаточно хорошего разбора архитектуры.
При изучении Solidity это может стать очень удобным инструментом для изучения кода протокола в общем и целом, а также его конкретных частей кода.
Таким способом я сейчас изучаю опенсорсные проекты с агентами (тот же нашумевший OpenClaw).
#copilot
Пока не успеваю написать следующий пост про алгоритмы, хочу поделиться с вами прикольным способом изучать репо. Вероятно, многие из вас уже знают об этом, но другим этот вариант может быть будет полезен.
P.S. Вероятнее всего, будет работать с изменением локации через сторонние сервисы.
Когда вы заходите на страницу проекта на GitHub через компьютер или ноутбук, то в правом верхнем углу есть иконка Copilot - ИИ агента от Microsoft. При нажатии на эту кнопку открывается страница с чатом, где пользователь может задавать свои вопросы по архитектуре и коду проекта. Для ответов используется достойная модель Claude Haiku 4.5 (но можно выбрать и другие).
Самое прикольное то, что бот имеет доступ к коммитам репо, т.е. вы можете использовать его для изучения изменений в коде.
Лимиты, скорее всего, есть, при этом мне его хватало всегда для достаточно хорошего разбора архитектуры.
При изучении Solidity это может стать очень удобным инструментом для изучения кода протокола в общем и целом, а также его конкретных частей кода.
Таким способом я сейчас изучаю опенсорсные проекты с агентами (тот же нашумевший OpenClaw).
#copilot
👍8
Алгоритмы. Жадные алгоритмы
Представьте себе, что вы стоите перед шведским столом и хотите утолить голод максимально быстро и эффективно. Вместо того чтобы тщательно продумывать последовательность блюд, вы просто каждый раз выбираете то, что кажется самым сытным в данный момент. Эта интуитивная стратегия, когда вы делаете лучший выбор прямо сейчас, не заглядывая далеко в будущее, и лежит в основе жадных алгоритмов. Формально, жадный алгоритм — это подход, при котором на каждом шаге решения принимается локально оптимальный выбор, то есть наилучший из доступных вариантов на текущий момент, в надежде, что итоговое решение окажется глобально оптимальным, то есть наилучшим для всей задачи в целом.
Важно понимать, что жадные алгоритмы работают безошибочно далеко не для всех задач. Их успех гарантирован только для тех задач, которые обладают особым свойством, о котором мы поговорим ниже.
Чтобы лучше понять механику, нужно разобраться с двумя ключевыми понятиями. Локально оптимальный выбор — это лучший вариант, который виден непосредственно на данном шаге, без учета долгосрочных последствий. Представьте, что вы идете по лесу и на каждом перекрестке выбираете ту тропинку, которая кажется короче, не зная всего маршрута заранее. Глобально оптимальное решение — это наилучший результат по итогу всей задачи, например, самый короткий путь из точки А в точку Б, известный по полной карте местности. Задача поддается жадному алгоритму, если она обладает свойством жадного выбора (Greedy Choice Property). Это означает, что локально оптимальный выбор на каждом шаге гарантированно приведет к глобально оптимальному итогу.
Классическим примером применения жадной стратегии является задача о сдаче (Coin Change). Представьте, что вам нужно набрать заданную сумму минимальным количеством монет, имея неограниченный запас монет определенных номиналов. Жадный подход здесь предельно прост: на каждом шаге нужно брать наибольшую монету, которая не превышает оставшуюся сумму. Рассмотрим это на примере: у нас есть сумма 63 и монеты номиналом 1, 2, 5, 10 и 25. Логика работы будет следующей: мы начинаем с самой крупной монеты (25) и проверяем, можем ли мы ее взять. Остаток после первого шага — 38, мы снова берем 25, получая остаток 13. Далее 25 уже не подходит, поэтому берем 10 (остаток 3), затем 2 (остаток 1) и, наконец, 1. В итоге мы получаем набор из пяти монет [25, 25, 10, 2, 1]. Эту логику реализует следующий код:
Пример 1
В этом коде сначала монеты сортируются по убыванию, чтобы начинать с самых крупных. Затем в цикле для каждого номинала мы, пока это возможно, вычитаем его из оставшейся суммы и добавляем в результат. Если в конце сумма обнуляется, мы возвращаем список монет; в противном случае задача не имеет решения с данным набором номиналов.
Однако крайне важно помнить, что жадный алгоритм для размена монет работает не всегда. Классический пример провала — набор номиналов
Представьте себе, что вы стоите перед шведским столом и хотите утолить голод максимально быстро и эффективно. Вместо того чтобы тщательно продумывать последовательность блюд, вы просто каждый раз выбираете то, что кажется самым сытным в данный момент. Эта интуитивная стратегия, когда вы делаете лучший выбор прямо сейчас, не заглядывая далеко в будущее, и лежит в основе жадных алгоритмов. Формально, жадный алгоритм — это подход, при котором на каждом шаге решения принимается локально оптимальный выбор, то есть наилучший из доступных вариантов на текущий момент, в надежде, что итоговое решение окажется глобально оптимальным, то есть наилучшим для всей задачи в целом.
Шаг 1 → выбрать лучшее из доступного
Шаг 2 → снова выбрать лучшее из доступного
Шаг 3 → снова выбрать лучшее из доступного
...
Конец → надеемся, что итог — оптимальный
Важно понимать, что жадные алгоритмы работают безошибочно далеко не для всех задач. Их успех гарантирован только для тех задач, которые обладают особым свойством, о котором мы поговорим ниже.
Чтобы лучше понять механику, нужно разобраться с двумя ключевыми понятиями. Локально оптимальный выбор — это лучший вариант, который виден непосредственно на данном шаге, без учета долгосрочных последствий. Представьте, что вы идете по лесу и на каждом перекрестке выбираете ту тропинку, которая кажется короче, не зная всего маршрута заранее. Глобально оптимальное решение — это наилучший результат по итогу всей задачи, например, самый короткий путь из точки А в точку Б, известный по полной карте местности. Задача поддается жадному алгоритму, если она обладает свойством жадного выбора (Greedy Choice Property). Это означает, что локально оптимальный выбор на каждом шаге гарантированно приведет к глобально оптимальному итогу.
Классическим примером применения жадной стратегии является задача о сдаче (Coin Change). Представьте, что вам нужно набрать заданную сумму минимальным количеством монет, имея неограниченный запас монет определенных номиналов. Жадный подход здесь предельно прост: на каждом шаге нужно брать наибольшую монету, которая не превышает оставшуюся сумму. Рассмотрим это на примере: у нас есть сумма 63 и монеты номиналом 1, 2, 5, 10 и 25. Логика работы будет следующей: мы начинаем с самой крупной монеты (25) и проверяем, можем ли мы ее взять. Остаток после первого шага — 38, мы снова берем 25, получая остаток 13. Далее 25 уже не подходит, поэтому берем 10 (остаток 3), затем 2 (остаток 1) и, наконец, 1. В итоге мы получаем набор из пяти монет [25, 25, 10, 2, 1]. Эту логику реализует следующий код:
Пример 1
В этом коде сначала монеты сортируются по убыванию, чтобы начинать с самых крупных. Затем в цикле для каждого номинала мы, пока это возможно, вычитаем его из оставшейся суммы и добавляем в результат. Если в конце сумма обнуляется, мы возвращаем список монет; в противном случае задача не имеет решения с данным набором номиналов.
Однако крайне важно помнить, что жадный алгоритм для размена монет работает не всегда. Классический пример провала — набор номиналов
[1, 3, 4] для суммы 6. Жадный алгоритм, следуя своей логике, сначала возьмет монету 4, затем две монеты по 1, получив в итоге три монеты [4, 1, 1]. В то время как оптимальное решение — это всего две монеты: [3, 3]. Почему так происходит? Потому что жадный алгоритм, "увидев" самую крупную монету 4, жадно взял её, не предусмотрев, что это помешает использовать более выгодную комбинацию из двух троек. Набор номиналов [1, 3, 4] не обладает свойством жадного выбора, в отличие от, скажем, стандартных монет США [1, 5, 10, 25]. Другой наглядный пример — набор [1, 6, 10] для суммы 12. Жадный подход даст три монеты [10, 1, 1], хотя оптимальных решения — две монеты по 6. Таким образом, жадный алгоритм для задачи о сдаче дает верный результат только для так называемых канонических систем номиналов, подобных реальным валютам. Для произвольных наборов монет необходимо применять другие методы, например, динамическое программирование.Другая известная задача, где жадный подход блестяще работает, — это задача о выборе заявок (Activity Selection Problem). Представьте, что у вас есть множество мероприятий, каждое из которых имеет время начала и окончания. Вам нужно выбрать максимальное количество непересекающихся мероприятий, то есть таких, которые не накладываются друг на друга по времени. Жадная стратегия здесь заключается в сортировке всех мероприятий по времени окончания. Логика проста: чем раньше заканчивается текущее мероприятие, тем больше времени остается для всех последующих. Рассмотрим мероприятия: А (1-4), В (2-6), С (5-8), D (7-9) и Е (3-5). Отсортировав их по времени конца, получим последовательность: А(1-4), Е(3-5), В(2-6), С(5-8), D(7-9). Первым мы всегда берем мероприятие, которое заканчивается раньше всех — это А. Его конец в 4. Далее мы пропускаем все мероприятия, которые начинаются раньше или в момент 4 (это Е и В), так как они пересекаются с А. Следующее подходящее — С, начинающееся в 5, что позже 4, поэтому мы берем его. После С с концом в 8, мероприятие D (начало в 7) пересекается с ним и не подходит. В итоге получаем набор из двух мероприятий
Пример 2
Еще одним ярким примером жадного подхода является алгоритм Хаффмана, используемый для сжатия данных. Идея сжатия заключается в том, чтобы представить символы не фиксированным количеством бит (например, 8), а переменным: частым символам давать короткие коды, а редким — длинные. Возьмем строку
Пример 3
В итоге, можно сказать, что жадный алгоритм — это мощный и элегантный метод, идея которого заключается в принятии последовательных локально оптимальных решений. Он блестяще работает для таких задач, как размен монет в канонической системе, выбор непересекающихся заявок или сжатие данных по Хаффману. Однако главное правило его применения — это предварительная проверка или доказательство того, что задача обладает свойством жадного выбора. В противном случае алгоритм, будучи примененным формально, скорее всего, даст неверный или неоптимальный результат, как это произошло с нетривиальными наборами монет.
#algorithm
[A, C], что является максимально возможным количеством. Этот подход работает, потому что задача обладает свойством жадного выбора: мероприятие с самым ранним окончанием всегда входит в какое-либо оптимальное расписание. Это можно строго доказать, показав, что если в оптимальном решении первым стоит не самое раннее мероприятие, его можно заменить на самое раннее, не ухудшив результат. Реализуется алгоритм следующим образом:Пример 2
Еще одним ярким примером жадного подхода является алгоритм Хаффмана, используемый для сжатия данных. Идея сжатия заключается в том, чтобы представить символы не фиксированным количеством бит (например, 8), а переменным: частым символам давать короткие коды, а редким — длинные. Возьмем строку
"aaaaabbc", где 'a' встречается 5 раз, 'b' — 2, а 'c' — 1. При стандартном кодировании каждый символ занял бы 3 бита, и вся строка — 24 бита. Оптимальное кодирование может быть таким: a='0' (1 бит), b='10' (2 бита), c='11' (2 бита). Тогда строка займет всего 5*1 + 2*2 + 1*2 = 11 бит. Алгоритм Хаффмана строит дерево кодирования, где путь от корня до символа определяет его код (0 — переход к левому потомку, 1 — к правому). Его жадная стратегия заключается в следующем: на каждом шаге два символа (или группы символов) с наименьшими частотами объединяются в один узел-родитель, чья частота равна сумме частот потомков. Начнем с отдельных узлов: [a:5], [b:2], [c:1]. На первом шаге выбираем самые редкие — b и c — и объединяем их в узел [bc:3] с двумя потомками. Теперь у нас есть узлы [a:5] и [bc:3]. Снова выбираем два с наименьшей частотой (a и bc) и объединяем их в корень дерева [abc:8]. После этого, двигаясь от корня к листьям и присваивая левым ветвям 0, а правым — 1, мы получим коды: a=0, b=10, c=11. Это жадный алгоритм, так как на каждом шаге мы, не думая о будущей структуре дерева, делаем локально наилучший выбор — объединяем два самых непопулярных элемента, что в итоге и гарантирует минимальную общую длину кода.Пример 3
В итоге, можно сказать, что жадный алгоритм — это мощный и элегантный метод, идея которого заключается в принятии последовательных локально оптимальных решений. Он блестяще работает для таких задач, как размен монет в канонической системе, выбор непересекающихся заявок или сжатие данных по Хаффману. Однако главное правило его применения — это предварительная проверка или доказательство того, что задача обладает свойством жадного выбора. В противном случае алгоритм, будучи примененным формально, скорее всего, даст неверный или неоптимальный результат, как это произошло с нетривиальными наборами монет.
#algorithm
❤2👍2