Поиск в ширину на графах

0 0

4 0 0 0 0 0 0 4 0 0 1 0 1 1

5 0 0 0 1 0 1 5 1 1 0 1 0 1

6 0 0 0 0 1 0 6 0 0 0 1 1 0

Рис. 2. Матрицы инциденций для графов на рис.1.

(в) добавление ребра не нарушает свойства Р, т. е. P(G)

Примером такого свойства Р является существование цикла (в графе, имеющем, по крайней мере три вершины).

Теорема . Если Р — свойство графа, отвечающее условиям (а), (б), (в), то каждый алгоритм, проверяющий свойство Р (т. е. вычисляющий значение P(G) для данного графа G) на основе матрицы смежности, выполняет в худшем случае Ω(n²) шагов, где n — число вершин графа.

Эта теорема справедлива также для ориентированных гра­фов и для свойств, не зависящих от петель графа, т, е. отве­чающих дополнительному условию

(г) P(G) = P(G') для произвольных ориентированных гра­фов G = < V, E>, G’ = < V, Е> U >, v C V.

Более экономным в отношении памяти (особенно в случае, неплотных графов, когда m гораздо меньше n2) является ме­тод представления графа с помощью списка пар, соответствующих его ребрам. Пара соответствует дуге <х, у>, если граф ориентированный, и ребру {х, y} в случае неориентиро­ванного графа(рис. 3). Очевидно, что объем памяти в этом случае составляет 2т. Неудобством является большое число шагов — порядка т в худшем случае, — необходимое для по­лучения множества вершин, к которым ведут ребра из данной вершины.

Ситуацию можно значительно улучшить, упорядочив мно­жество пар лексикографически и применяя двоичный поиск, но лучшим решением во многих случаях оказывается структура

1	2
1	3
1	5
2	3
2	5
3	4
4	5
4	6
5	6

1	2
1	3
3	2
3	4
5	4
5	6
6	5

Рис.3. Списки ребер соответствующие графам на рис.1.

данных, которую мы будем называть списками инцидентности. Она содержит для каждой вершины v C V список вершин и, таких что v -> u (или v — ив случае неориентированного гра­фа). Точнее, каждый элемент такого списка является записью г, содержащей вершину г. строка и указатель г. след на сле­дующую запись в списке (г. след = nil для последней записи в списке). Начало каждого списка хранится в таблице НАЧАЛО; точнее, HAЧАЛО[v] является указателем на начало спи­ска, содержащего вершины из множества {u: v+u} ({u: v - u} для неориентированного графа). Весь такой список обычно не­формально будем обозначать 3AПИСЬ[v], а цикл, выполняю­щий определенную операцию для каждого элемента и из этого списка в произвольной, но четко установленной последователь­ности, соответствующей очередности элементов в списке, будем записывать «for u C ЗАПИСЬ [v] do ...».

Отметим, что для неориентированных графов каждое ребро {u, v} представлено дважды: через вершину v в списке ЗАПИСЬ[u] и через вершину и в списке ЗАПИСЬ[v]. Во многих алгоритмах структура графа динамически модифицируется добавлением и удалением ребер. В таких случаях полагаем, что в наших списках инцидентности элемент списка ЗАПИСЬ [u], содержащий вершину и, снабжен указателем на элемент спи­ска 3AПИCЬ[v], содержащий вершину и, и что каждый эле­мент списка содержит указатель не только к следующему эле­менту, но и к предыдущему. Тогда удаляя некоторый элемент

(б)

Рис.4. Списки инцидентности ЗПИСЬ[v], v =V, соответствующие графам на рис.1.

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

Аналогичным способом определяем для каждой вершины и неориентированного графа список ПРЕДШ[v], содержащий вершины из множества (u: u -> v).

Число ячеек памяти, необходимое для представления графа с помощью списков инцидентности, будет, очевидно, иметь по­рядок m + n. На рис.4 представлены списки инцидентности, соответствующие графам на рис. 1.

2. Анализ алгоритма.

Рассмотрим метод поиска в графе, называемый поиском в ширину (англ: breadth first search). Прежде чем описать его, отметим, что при поиске в глубину чем позднее будет посещена вершина, тем раньше она будет использована — точнее, так будет при допущении, что вторая вершина посещается перед использованием первой. Это прямое следствие того факта, что просмотренные, но еще не исполь­зованные вершины скапливаются в стеке. Поиск в ширину, грубо говоря, основывается на замене стека очередью. После такой модификации, чем раньше посещается вершина (поме­щается в очередь), тем раньше она используется (удаляется из очереди). Использование вершины происходит с помощью про­смотра сразу всех еще не просмотренных соседей этой вершины. Вся процедура поиска представлена ниже (данная процедура используется также и для просмотра графа, и в псевдокоде, описанном ниже, отсутствуют операторы, которые не используются для поиска).

1 procedure WS (v);

(*поиск в ширину в графе с началом в вершине v;

переменные НОВЫЙ, ЗАПИСЬ — глобальные *)

2 begin

3 ОЧЕРЕДЬ := ; ОЧЕРЕДЬ <= v; НОВЫЙ [v] := ложь

4 while ОЧЕРЕДЬ   do

5 begin р<= ОЧЕРЕДЬ; посетить р;

6 for u  ЗАПИСЬ [р] do

7 if НОВЫЙ [u] then

8 begin ОЧЕРЕДЬ <= u; НОВЫЙ [u]:=ложь

9 end

10 end

11. end

Примечание: в 7-й строке псевдокода кроме условия НОВЫЙ[u] должно также выполниться условие наличия связи (ребра) между v-й и u-й вершинами. Для установки наличия ребра сначала в списке v-й вершины ищется информационное значение и-й вершины. Если оно найдено, то ребро установлено, если нет, то информационное значение v-й вершины ищется в списке и-й вершины, т.е. наоборот. В результате добавления двух лишних циклов поиска общий алгоритм поиска несколько теряет компактность, но на быстродействии в целом это не сказывается.

1 procedure Write_S;

2 begin

3 for v  V do НОВЫЙ[u]:= истина; (* инициализация *)

4 for v  V do

5 if HOBЫЙ[v] then WG(v)

6 end

Способом, аналогичным тому, какой был применен для по­иска в глубину, можно легко показать, что вызов процедуры WS(v) приводит к посещению всех вершин связной компоненты графа, содержащей вершину v, причем каждая вершина про­сматривается в точности один раз. Вычислительная сложность поиска в ширину также имеет порядок О(m + n), так как каждая вершина помещается в очередь и удаляется из очереди в точ­ности один раз, а число итераций цикла 6, очевидно, будет иметь порядок числа ребер графа.

В очереди помещены сначала вершины, находящиеся на расстоянии 0 от v (т. е. сама вершина v), затем поочередно все новые вершины, достижимые из v, т. е. вершины, находя­щиеся на расстоянии 1 от v, и т. д. Под расстоянием здесь мы понимаем длину кратчайшего пути. Предположим теперь, что мы уже рассмотрели все вершины, находящиеся на расстоянии, не превосходящем r, от v, что очередь содержит все вершины, находящиеся от v на расстоянии r, и только эти вершины. Использовав каждую вершину р, находящую­ся в очереди, наша процедура просматривает некоторые новые вершины, и каждая такая новая вершина u находится, оче­видно, на расстоянии г + 1 от v. После использования всех вер­шин из очереди, находящихся на расстоянии r от v, она (оче­редь), очевидно, содержит множество вершин, находящихся на расстоянии r + 1 от v, и легко заметить, что условие индукции выполняется и для расстояния r + 1.

На рис. 5 представлен граф, вершины которого зануме­рованы согласно очередности, в которой они посещаются в про­цессе поиска в глубину.

Как и в случае поиска в глубину, процедуру WS можно использовать без всяких модификаций и тогда, когда списки

1(1)

10(7)

Рис. 5 Нумерация вершин графа (в скобках), соответствующая очередности, в которой они просматриваются в процессе поиска в ширину.

инцидентности ЗАПИСЬ[v], v = V, определяют некоторый ориентированный граф. Очевидно, что тогда посещаются толь­ко те вершины, до которых существует путь от вершины, с ко­торой мы начинаем поиск

3. Спецификация задачи

3.1 Входные и выходные данные

ver – массив вершин графа, заполняемый случайным образом целыми числами в диапазоне от 0 до 1000;

nv - массив флагов проверки вершин;

ocher – массив для организации очереди, заполняемой значениями рассматриваемых информационных вершин графа;

raz – переменная целочисленного типа, определяющая в программе размер создаваемого графа;

schet – счетчик количества сравнений в процедуре поиска;

key – вводимый с клавиатуры ключ поиска;

mgsi – переменная логического типа, разрешающая вывод списка инцидентности графа;

prosm - переменная логического типа, превращающая процедуру поиска WS в процедуру просмотра графа;

find - переменная логического типа, определяемая при нахождении искомой информационной вершины;

craz, menu, mg, sormen – переменные символьного типа для работы с меню программы.

3.2 Используемые процедуры

Make_Graph – процедура создания графа в динамической памяти;

WS - процедура просмотра графа с v-той вершины методом поиска в ширину;

Write_S – процедура инициализации признаков просмотра вершин и управляющая процедурой WS;

Sort - процедура сортировки вершин графа по неубыванию.

4. Текст программы на языке TURBO PASCAL

4.1 Листинг программы.

{$S+} {$R+} {$I+} {$M 65520,0,655360}

program graph;

uses crt,newtimer;

const

maxraz=400;

type index=^list;

list= record

inf: word;

next: index;

end;

connection=array[1..maxraz] of index;

var

el,em,size: pointer;

lst,m: connection;

ver: array[1..maxraz] of word; {массив вершин}

Nw: array[1..maxraz] of boolean;

ocher: array[1..maxraz+1] of integer;

raz: integer;

exch,fil,i,j,l,schet,v,u,p: word;

key,kols,t,tm: longint;

mgsi,mem,sor,prosm,find: boolean;

craz,menu,mg,sormen:char;

{------------------------------------------------------

***Процедура создания графа в динамической памяти***}

procedure Make_Graph(mgsi: boolean);

label Er;

var

n: index;

i,j: word;

kolvo: longint;

spro: boolean;

begin

randomize;

for i:=1 to raz do begin

ver[i]:=random(1000);

end;

kolvo:=0;

for i:=1 to raz do begin

lst[i]:=nil;

for j:=1 to raz do begin

spro:=true;

if j=raz then goto Er;

if j=i then inc(j);

n:=nil;

n:=lst[j];

if lst[j]<>nil then

repeat

if n^.inf=ver[i] then spro:=false;

n:=n^.next;

until (n=nil) or (not(spro));

if (round(random)=1) and spro then

begin

new(m[i]);

inc(kolvo);

m[i]^.inf:=ver[j];

m[i]^.next:=lst[i];

lst[i]:=m[i];

end;

Er:

end;

end;

writeln;

if mgsi then {ВЫВОД СВЯЗЕЙ ВЕРШИН}

for i:=1 to raz do {}

begin {}

write(ver[i],'-'); {}

m[i]:=lst[i]; {}

if m[i]<>nil then {}

repeat {}

write(m[i]^.inf,'═'); {}

m[i]:=m[i]^.next; {}

until m[i]=nil; {}

writeln('§'); writeln; {}

end; {}

writeln('КОЛ-ВО РЕБЕР СОЗДАННОГО ГРАФА: ',kolvo);

end;

{------------------------------------------------------

***Процедура просмотра графа с v-той вершины методом поиска в ширину***}

Procedure WS(v:word; var find: boolean;

var schet: word);

var {v - пор. номер вершины графа}

ik,oo,o9,o3,op: integer;

rebro: boolean;

begin {оо - размер очереди в данном цикле}

ocher[1]:=v; oo:=1; {вставка текущего индекса вершины в начало очереди}

Nw[v]:=False; {флаг на вершину текущего индекса}

while oo>0 do begin {пока есть очередь...}

p:=ocher[1];{удаление 1-го элемента из очереди и присваивание его p}

for op:=1 to oo-1 do ocher[op]:=ocher[op+1]; ocher[oo]:=0;

dec(oo);

inc(schet); {счетчик сравнений}

if not(prosm) and (ver[p]=key) then {if ver[p]=key...}

begin

find:=true;

exit; {поиск окончен}

end;