Поиск в глубину

 

Рассматривая поиск в глубину, удобно представлять себе ориентированный граф как образ дерева. Более точно, пусть есть ориентированный граф, одна из вершин которого выделена. Будем предполагать, что все вершины доступны из выделенной по ориентированным путям. Построим дерево, которое можно было бы назвать << универсальным накрытием>> нашего графа. Его корнем будет выделенная вершина графа. Из корня выходят те же стрелки, что и в графе -- их концы будут сыновьями корня. Из них в дереве выходят те же стрелки, что и в графе и так далее. Разница между графом и деревом в том, что пути в графе, ведущие в одну и ту же вершину, в дереве << расклеены>>. В других терминах: вершина дерева -- это путь в графе, выходящий из корня. Ее сыновья -- это пути, продолженные на одно ребро. Заметим, что дерево бесконечно, если в графе есть ориентированные циклы.

Имеется естественное отображение дерева в граф (вершин в вершины). При этом каждая вершина графа имеет столько прообразов, сколько путей в нее ведет. Поэтому обход дерева (посещение его вершин в том или ином порядке) одновременно является и обходом графа -- только каждая вершина посещается многократно.

Будем предполагать, что для каждой вершины графа выходящие из нее ребра упорядочены (например, пронумерованы). Тем самым для каждой вершины дерева выходящие из нее ребра также упорядочены. Будем обходить дерево так: сначала корень, а потом поддеревья (в порядке ведущих в них ребер). Такой обход дерева рассматривался нами в главе 7. Ему соответствует обход графа. Если выкинуть из этого обхода повторные посещения уже посещенных вершин, то получится то, что называется << поиск в глубину>>.

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


$\scriptstyle{\blacktriangleright}$ 9.2.2. Написать программу поиска в глубину.

[Указание. Возьмем программу обхода дерева (корень $\rightarrow$ левое поддерево $\rightarrow$ правое поддерево) из главы 7 или из главы 8 и используем ее применительно к обстоятельствам. Главное изменение: не надо посещать вершины повторно. Так что если мы попали в уже посещенную вершину, то можно с ней ничего не делать. (Если путь не минимален среди ведущих в данную вершину, то и все его продолжения не минимальны -- их просматривать не надо).]$\blacktriangleleft$

Замечание. Напомним, что в главе 8 упоминались две возможности устранения рекурсии в программе обхода дерева (с.[*]). Оба варианта можно использовать для поиска в глубину.


Поиск в глубину лежит в основе многих алгоритмов на графах, порой в несколько модифицированном виде.


$\scriptstyle{\blacktriangleright}$ 9.2.3. Неориентированный граф называется двудольным, если его вершины можно раскрасить в два цвета так, что концы любого ребра -- разного цвета. Составить алгоритм проверки, является ли заданный граф двудольным, в котором число действий не превосходит $C\cdot{}$(число ребер+ число вершин).

  

[Указание. (а) Каждую связную компоненту можно раскрашивать отдельно. (б) Выбрав цвет одной вершины и обходя ее связную компоненту, мы определяем единственно возможный цвет остальных.]$\blacktriangleleft$

Замечание. В этой задаче безразлично, производить поиск в ширину или в глубину.


$\scriptstyle{\blacktriangleright}$ 9.2.4. Составить нерекурсивный алгоритм топологической
сортировки ориентированного графа без циклов. (Рекурсивный алгоритм смотри на с. [*].)

  

Решение. Предположим, что граф имеет вершины с номерами ${\hbox{\tt 1}}\ldots{\hbox{\tt n}}$, для каждой вершины i известно число num[i] выходящих из нее ребер и номера вершин \begin{displaymath} {\hbox{\tt dest[i][1]}},\ \ldots,\ {\hbox{\tt dest[i][num[i]]}},\end{displaymath}в которые эти ребра ведут. Будем условно считать, что ребра перечислены << слева направо>>: левее то ребро, у которого номер меньше. Нам надо напечатать все вершины в таком порядке, чтобы конец любого ребра был напечатан перед его началом. Мы предполагаем, что в графе нет ориентированных циклов -- иначе такое невозможно.

Для начала добавим к графу вершину 0, из которой ребра ведут в вершины ${\hbox{\tt 1}},\ldots,{\hbox{\tt n}}$. Если ее удастся напечатать с соблюдением правил, то тем самым все вершины будут напечатаны.

Алгоритм хранит путь, выходящий из нулевой вершины и идущий по ребрам графа. Переменная l отводится для длины этого пути. Путь образован вершинами ${\hbox{\tt vert[1]}}\ldots{\hbox{\tt vert[l]}}$ и ребрами, имеющими номера ${\hbox{\tt edge[1]}}\ldots{\hbox{\tt edge[l]}}$. Номер edge[s] относится к нумерации ребер, выходящих из вершины ${\hbox{\tt vert[s]}}$. Тем самым для всех s должны выполняться неравенство \begin{displaymath} {\hbox{\tt edge[s]}}\leqslant{\hbox{\tt num[vert[s]]}}\end{displaymath}и равенство \begin{displaymath} {\hbox{\tt vert[s+1]}} = {\hbox{\tt dest}}\,{\hbox{\tt [vert[s]]}}\,{\hbox{\tt [edge[s]]}}.\end{displaymath}Заметим, что конец последнего ребра нашего пути (то есть вершина dest[vert[l]][edge[l]], не включается в массив vert. Кроме того, для последнего ребра мы делаем исключение, разрешая ему указывать << в пустоту>>, т. е. разрешаем edge[l] равняться num[vert[l]]+1.

В процессе работы алгоритм будет печатать номера вершин, при этом соблюдая требование << вершина напечатана только после тех вершин, в которые из нее ведут ребра>>. Кроме того, будет выполняться такое требование (И):

вершины пути, кроме последней (${\hbox{\tt vert[1]}}\ldots{\hbox{\tt vert[l]}}$) не напечатаны, но свернув с пути налево, мы немедленно упираемся в напечатанную вершину

Вот что получается: 
        l:=1; vert[1]:=0; edge[1]:=1;
        while not( (l=1) and (edge[1]=n+1)) do begin
        | if edge[l]=num[vert[l]]+1 then begin
        | | {путь кончается в пустоте, поэтому все вершины,
        | |     следующие за vert[l], напечатаны - можно
        | |     печатать vert[l]}
        | | writeln (vert[l]);
        | | l:=l-1; edge[l]:=egde[l]+1;
        | end else begin
        | |  {edge[l] <= num[vert[l]], путь кончается в
        | |     вершине}
        | |  lastvert:= dest[vert[l]][edge[l]]; {последняя}
        | |  if lastvert напечатана then begin
        | |  | edge[l]:=edge[l]+1;
        | |  end else begin
        | |  | l:=l+1; vert[l]:=lastvert; edge[l]:=1;
        | |  end;
        | end;
        end;
        {путь сразу же ведет в пустоту, поэтому все вершины
         левее, то есть 1..n, напечатаны}`


$\scriptstyle{\blacktriangleright}$ 9.2.5. Доказать, что если в графе нет циклов, то этот алгоритм заканчивает работу.

Решение. Пусть это не так. Каждая вершина может печататься только один раз, так что с некоторого момента вершины не печатаются. В графе без циклов длина пути ограничена (вершина не может входить в путь дважды), поэтому подождав еще, мы можем дождаться момента, после которого путь не удлиняется. После этого может разве что увеличиваться edge[l] -- но и это не беспредельно.$\scriptstyle\blacktriangleleft$


$\scriptstyle{\blacktriangleright}$ 9.2.6.  Доказать, что время работы этого алгоритма не превосходит O( число вершин + число ребер) .$\scriptstyle\blacktriangleleft$


$\scriptstyle{\blacktriangleright}$ 9.2.7.  Как модифицировать алгоритм так, чтобы он отыскивал один из циклов, если таковые имеются, и производил топологическую сортировку, если циклов нет?$\scriptstyle\blacktriangleleft$

12pt

pvv
1/8/1999