Алгоритмы на графах
2026-02-26 19:59 Diff
https://ru.hexlet.io/courses/algorithms-graphs/lessons/cycle-search-adjacency-matrix/theory_unit

В этом и других курсах вы могли сталкиваться с различными учебными проектами. Обычно они достаточно реалистичные, но одно различие все таки есть — все учебные проекты небольшие.

Реальные проекты намного больше учебных. Чтобы разработчики не путались в коде, обычно большие проекты состоят из отдельных пакетов. При этом появляются зависимости.

Например, если пакет А импортирует или использует пакет Б, мы говорим: «А зависит от Б». На схеме эту зависимость можно обозначить так:

Чтобы собрать проект, нам нужно загружать или компилировать пакеты в правильном порядке. Если А зависит от Б, то сначала надо загрузить пакет Б, и только потом перейти к пакету А.

Когда пакетов в проекте много, количество зависимостей тоже растет. Вместе они образуют сложный граф зависимостей:

Пакеты из этого графа можно загружать или компилировать в правильном порядке. Судя по графу, возможно три варианта:

  • Д, Б, В, Г, А
  • Д, Г, В, Б, А
  • Д, В, Г, Б, А

У нас есть выбор, потому что ветки Г и Б + В не зависят друг от друга. В любом случае первым пакетом следует Д, потому что он ни от кого не зависит. Последним идет пакет А, потому что от него никто не зависит.

Подобная структура зависимостей часто встречается в программировании. Например, таким образом мы описываем связи между классами, которые задействованы в коде. Это называется внедрение зависимостей (Dependency Injection).

Но есть проблема — часто программисты не описывают граф целиком, а только указывают, от каких узлов зависит очередной узел.

Это приводит к тому, что в графе может появиться циклическая зависимость:

В циклическом графе невозможно определить правильный порядок компиляции пакетов или создания объектов. Справиться с этой сложностью помогают системы сборки и библиотеки внедрения зависимостей. Именно благодаря им программисты находят циклы в описанных графах.

В этом уроке мы научимся искать циклы в ориентированных графах. Задача для неориентированных графов на практике встречается гораздо реже, поэтому мы не станем обсуждать ее подробно. Она решается похожим образом, так что алгоритм можно без труда адаптировать.

Матрица смежности

В прошлых уроках мы познакомились с двумя способами представления графов:

  • Со списками смежности
  • С неявным представлением

Сегодня изучим матрицу смежности — еще одну структуру данных, которую часто применяют при работе с графами.

Все вершины графа мы храним в массиве, так что у каждой вершины появляется уникальный порядковый номер. В большинстве современных языков программирования нумерация элементов начинается с ноля. Поэтому у нас будут вершина 0, вершина 1, вершина 2 и так далее:

Важно, что номера вершин идут подряд без пропусков.

Вместе с массивом мы храним матрицу — двумерный массив. Ее ширина и высота равны количеству вершин. Есть речь идет об обычном невзвешенном графе, элементами массива будут:

  • Либо булевы значения — false и true
  • Либо числа 0 и 1

Вернемся к рисунку выше. На нем мы видим, какие вершины связаны между собой. Эту информацию мы можем записать в матрицу смежности. Помните, что нумерация вершин начинается с 0, поэтому нумерация столбцов и строк сдвигается на единицу.

  • На графе вершина 6 связана с вершиной 2 — записываем true в строку 6 и столбец 2:

  • На графе вершина 2 не связана с вершиной 4 — записываем false в строку 2 и столбец 4:

Перебирая элементы строки, мы можем найти все связанные вершины.

Во взвешенном графе вместо булевых значений мы можем хранить числа:

  • Если вершины не связаны — null
  • Если вершины связаны — число, обозначающее вес ребра

Матрица смежности подходит для хранения ориентированных графов. Для хранения неориентированных графов программисты используют небольшой трюк, делая матрицу симметричной. Для примера представим, что мы хотим связать вершины n и m. В этом случае мы записываем true два раза:

  • В столбец n и строку m
  • В столбец m и строку n

Так мы получаем двустороннюю связь.

Поиск цикла

Обычно нам надо убедиться, что в графе нет циклов. Поэтому мы пытаемся найти хотя бы один любой цикл. Если нам это удается, то мы подсказываем пользователю, из каких вершин он состоит.

Оказывается, для поиска циклов не надо изобретать нового алгоритма — можно адаптировать обход графа в глубину. При обходе мы будем помечать посещенные вершины. В реальной программе каждой вершине будет приписан числовой код, но при объяснении алгоритма принято говорить о «перекрашивании» вершин.

Попробуем найти цикл в таком небольшом графе:

В начале все вершины в графе белые. Такому графу соответствует матрица смежности, изображенная ниже:

Начинать можно с любой вершины. Мы начнем с вершины 0, которой соответствует верхняя строка в матрице.

Перекрашиваем вершину в серый цвет. Это означает, что мы начали с ней работать:

Ищем в первой строке связанные вершины. Они помечены значением true.

Видим, что вершина 0 связана со вторым элементом строки — вершиной 1. Начинаем работать с ней и также перекрашиваем ее в серый цвет:

Чтобы обнаружить связанные вершины, рассмотрим вторую строку сверху. Она соответствует вершине 1. Похожим образом продолжаем перекрашивать вершины. Следующие на очереди — 2 и 3:

Из вершины 3 двигаться некуда. Мы завершаем ее обработку, перекрашиваем в черный цвет и возвращаемся в вершину 2.

У второй вершины есть еще одна необработанная вершина — 4. Перекрашиваем ее в серый цвет:

У вершины 4 также нет связанный вершин. Завершаем ее обработку, перекрашиваем в черный цвет, снова возвращаемся в вершину 2.

Теперь и у вершины 2 обработаны все соседи — значит, ее обработка также завершена. Перекрашиваем ее в черный цвет и возвращаемся в вершину 1:

У вершины 1 есть следующая необработанная вершина — это 5.

В свою очередь у вершины 5 есть необработанная вершина 6:

Вершина 6 связана с вершиной 0, которая окрашена в серый цвет. Это значит, что мы обнаружили цикл.

Далее нужно разобраться, какие вершины входят в цикл. Для этого мы возвращаемся назад, пока не встретим вершину 0. Так мы выясним, что в нашем примере в цикл попадают вершины 6, 5, 1 и 0.

Если мы встречаем черную вершину, это означает, что цикл в нашем графе есть, но он не опасен. Двигаясь по стрелкам, мы не попадаем в замкнутый круг:

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

Реализация

Теперь посмотрим, как такой алгоритм реализуется в коде:

Как и в прошлых уроках, для работы с графом сделаем класс Graph. В конструкторе мы будем получать массив значений в вершинах графа. Размер массива сохраним в поле size для последующего использования. Также сразу создадим квадратную матрицу смежности, заполним ее значением false:

Далее мы создаем связь. По сути, это нахождение элемента в матрице и присвоение ему значения true:

Для поиска циклов нам потребуются константы, чтобы обозначать белый, серый и черный цвет вершин, а также массив цветов всех вершин. В начале работы алгоритма все вершины белые:

Функция возвращает массив вершин, образующих либо цикл, либо значение null при отсутствии циклов.

Основная работа делается во внутренней рекурсивной функции visit(). В качестве параметра она получает порядковый номер вершины. Так как нумерация начинается с нуля, первой вершине соответствует номер 0.

В массиве colors функция отслеживает состояние каждой вершины:

Если вершина чёрная, это означает, что она уже полностью обработана — повторно её проверять не нужно.

Если вершина серая, значит, она уже в стеке вызовов — и это признак обнаружения цикла. В этом случае функция возвращает массив, содержащий текущую вершину, чтобы начать восстановление пути цикла.

В середине мы обрабатываем текущую вершину. Перекрашиваем ее в серый цвет, а после обработки всех связанных вершин — в черный:

Обработка связанных вершин заключается в поочередном рекурсивном вызове функции visit(). Если во время очередного вызова функция возвращает массив, это значит, что мы нашли цикл. Добавляем в массив текущую вершину и возвращаем новое значение.

Когда рекурсия развернется, в массиве окажутся все вершины из цикла. Именно этот массив и получит программист, вызвавший функцию.

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

Выводы

В этом уроке мы обсудили поиск циклов и пришли к выводу, что этот алгоритм нам уже знаком. На самом деле, это адаптированный обход графа в глубину (Depth-first search).

Кроме того, в этом уроке вы узнали, что для хранения ориентированных графов можно использовать матрицу смежности. Так же можно хранить неориентированные графы, связывая каждую пару вершин в прямом и обратном направлении. Чтобы хранить взвешенные графы, в матрице смежности вместо булевых значений можно использовать числа.