Использование обхода в глубину для поиска компонент сильной связности — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
(Псевдокод)
(Псевдокод)
Строка 37: Строка 37:
  
 
==Псевдокод==
 
==Псевдокод==
     <tex>G, H</tex>                               //G  - граф , H - инвертированный
+
     <tex>G, H</tex>                               //G  - граф , H - инвертированный
     <tex>ord, component</tex>                     //список вершин в порядке окончания обработки, номер компоненты, к который относиться вершина
+
     <tex>ord[],</tex>                               //список вершин в порядке окончания обработки,
 +
    <tex> component[]</tex>                        //номер компоненты, к который относиться вершина
 
      
 
      
     '''dfs'''(<tex>v</tex>)                                          //первый поиск в глубину, определяющий порядок обхода
+
     '''dfs'''(<tex>v</tex>)                                           
 
         <tex>color[v] \leftarrow 1</tex>
 
         <tex>color[v] \leftarrow 1</tex>
 
         '''for''' (всех <tex>i</tex> смежных с <tex>v</tex>)
 
         '''for''' (всех <tex>i</tex> смежных с <tex>v</tex>)
Строка 47: Строка 48:
 
         Добавляем вершину <tex>v</tex> в конец списка <tex>ord</tex>
 
         Добавляем вершину <tex>v</tex> в конец списка <tex>ord</tex>
 
      
 
      
     '''dfs2'''(<tex>v</tex>)                                         //второй поиск в глубину, выявляет компоненты сильной связности в графе
+
     '''dfs2'''(<tex>v</tex>)                                        
 
         <tex>component[v] \leftarrow col</tex>
 
         <tex>component[v] \leftarrow col</tex>
 
         '''for''' (всех <tex>i</tex> смежных с <tex>v</tex>)
 
         '''for''' (всех <tex>i</tex> смежных с <tex>v</tex>)
Строка 55: Строка 56:
 
     '''main'''()
 
     '''main'''()
 
         считываем исходные данные, формируем массивы <tex>G</tex> и <tex>H</tex>
 
         считываем исходные данные, формируем массивы <tex>G</tex> и <tex>H</tex>
         '''for''' (по всем вершинам <tex>i</tex> графа <tex>G</tex>)                          //формируем массив ord[]
+
         '''for''' (по всем вершинам <tex>i</tex> графа <tex>G</tex>)                           
 
             '''if''' (вершина <tex>i</tex> не посещена)
 
             '''if''' (вершина <tex>i</tex> не посещена)
 
                 '''dfs'''(i);
 
                 '''dfs'''(i);

Версия 21:30, 23 ноября 2011

Алгоритм

Компоненты сильной связанности можно найти с помощью поиска в глубину в 3 этапа:

  1. Построить граф [math]H[/math] с обратными (инвертированными) рёбрами
  2. Выполнить в [math]H[/math] поиск в глубину и найти [math]f[u][/math] - время окончания обработки вершины [math]u[/math]
  3. Выполнить поиск в глубину в [math]G[/math], перебирая вершины во внешнем цикле в порядке убывания [math]f[u][/math]

Полученные на 3-ем этапе деревья поиска в глубину будут являться компонентами сильной связности графа [math]G[/math].
Так как компоненты сильной связности [math]G[/math] и [math]H[/math] графа совпадают, то первый поиск в глубину для нахождения [math]f[u][/math] можно выполнить на графе [math]G[/math], а второй - на [math]H[/math].

Доказательство корректности алгоритма

Теорема:
Вершины [math]s[/math] и [math]t[/math] взаимно достижимы [math]\Leftrightarrow[/math] после выполнения алгоритма они оказываются в одной компонентe сильной связанности.
Доказательство:
[math]\triangleright[/math]

[math]\Rightarrow[/math]

Если вершины [math]s[/math] и [math]t[/math] были взаимно достижимы в графе [math]G[/math], то во время выполнения третьего шага алгоритма обе вершины окажутся в одном поддереве по свойству обхода в глубина. Следовательно они будут находится в одной компоненте сильной связности.

[math]\Leftarrow[/math]

1) Рассмотрим корень [math]r[/math] дерева второго обхода в глубину, в котором оказались вершины [math]s[/math] и [math]t[/math]. Это значит, что в графе [math]G[/math] существует путь из [math]r[/math] в [math]s[/math] и в [math]t[/math].

2) Вершина [math]r[/math] была рассмотрена вторым обходом в глубину раньше, чем [math]s[/math] и [math]t[/math], значит время выхода из нее при первом обходе в глубину больше, чем время выхода из вершин [math]s[/math] и [math]t[/math]. Из этого мы получаем 2 случая:

а) Обе эти вершины были достижимы из [math]r[/math] в инвертированном графе. А это означает взаимную достижимость вершин [math]s[/math] и [math]r[/math] и взаимную достижимость вершин [math]r[/math] и [math]t[/math]. А складывая пути мы получаем взаимную достижимость вершин [math]s[/math] и [math]t[/math].

б) Между [math]r[/math] и этими вершинами вообще нет пути ни в одну сторону, ни в другую при первом обходе в инверитированном графе. Но последнего быть не может, так как эти вершины были достижимы из [math]r[/math] в графе [math]G[/math], а значит, вершина [math]r[/math] достижима из них в графе [math]H[/math].

Значит, из случая а) и не существования случая б) получаем, что вершины [math]s[/math] и [math]t[/math] взаимно достижимы в обоих графах.
[math]\triangleleft[/math]

Время работы алгоритма

  1. Для того, чтобы инвертировать все ребра в графе, представленном в виде списка потребуется [math]O(V + E)[/math] действий. Для матричного представления графа ненужно выполнять никакие действия для его инвертирования.
  2. Количество ребер в инвертированном равно количеству ребер в изначальном графе, поэтому поиск в глубину будет работать за [math]O(V + E)[/math]
  3. Поиск в глубину в исходном графе выполняется за [math]O(V + E)[/math].

В итоге получаем, что время работы алгоритма [math]O(V + E)[/math].

Псевдокод

   [math]G, H[/math]                                //G  - граф , H - инвертированный
   [math]ord[],[/math]                               //список вершин в порядке окончания обработки,
   [math] component[][/math]                         //номер компоненты, к который относиться вершина
   
   dfs([math]v[/math])                                          
       [math]color[v] \leftarrow 1[/math]
       for (всех [math]i[/math] смежных с [math]v[/math])
           if (вершина [math]i[/math] не посещена)
               dfs([math]G[v][i][/math])
       Добавляем вершину [math]v[/math] в конец списка [math]ord[/math]
   
   dfs2([math]v[/math])                                          
       [math]component[v] \leftarrow col[/math]
       for (всех [math]i[/math] смежных с [math]v[/math])
           if (если вершина [math]i[/math] еще не находится ни в какой компоненте)                       
               dfs2([math]H[v][i][/math]);
   
   main()
       считываем исходные данные, формируем массивы [math]G[/math] и [math]H[/math]
       for (по всем вершинам [math]i[/math] графа [math]G[/math])                           
           if (вершина [math]i[/math] не посещена)
               dfs(i);
       [math]col \leftarrow 1;[/math]
       for (по всем вершинам [math]i[/math] списка [math]ord[][/math] в обратном порядке)                                                        //от сохранённого в ord[], что соответствует уменьшению времени конца обработки f[]
           if (если вершина [math]i[/math] не находится ни в какой компоненте)
               dfs2([math]i[/math]), [math]col[/math]++;

По окончании выполнения алгоритма в [math]component[i][/math] имеем номер компоненты, к которой принадлежит вершина [math]i[/math].

Литература

  • Р.Седжвик. "Фундаментальные алгоритмы на С++. Алгоритмы на графах" - СПб, ДиаСофтЮП, 2002