3.6.2. Алгоритм Дейкстры

Дано.Ориентированный граф G=<V,E>, s - вершина источник;

матрица смежности A (A:array[1..n,1..n] of integer); для любых u, vÎV вес дуги неотрицательный (A[u,v]³0).Результат.Массив кратчайших расстояний - D.

В данном алгоритме формируется множество вершин T, для которых еще не вычислена оценка расстояние и, это главное, минимальное значение в D по множеству вершин, принадлежащих T, считается окончательной оценкой для вершины, на которой достигается этот минимум. С точки зрения здравого смысла этот факт достаточно очевиден. Другой “заход” в эту вершину возможен по пути, содержащему большее количество дуг, а так как веса неотрицательны, то и оценка пути будет больше. В книгах [11], [12] можно найти доказательство этого факта.

Пример

Его матрица смежности:

¥3 7¥¥¥

1 ¥2¥¥1

A= ¥1¥4 4¥

¥¥¥¥1 5

¥¥1¥¥3

¥¥¥2¥¥

В таблице приведена последовательность шагов (итераций) работы алгоритма. На первом шаге минимальное значение D достигается на второй вершине. Она исключается из множества T, и улучшение оценки до оставшихся вершин (3,4,5,6) ищется не по всем вершинам, а только от второй.

№ итерации	D[1]	D[2]	D[3]	D[4]	D[5]	D[6]	T
1	0	3	7	¥	¥	¥	[2,3,4,5,6]
2	0	3	5	¥	11	4	[3,4,5,6]
3	0	3	5	6	¥	4	[3,4,5]
4	0	3	5	6	9	4	[4,5]
5	0	3	5	6	7	4	[5]

procedure Distance;

{A, D, s - глобальные}

var v,u: integer;T:set of 1..N;

begin{инициализация D}

for vÎV do D[v]:=A[s,v];

D[s]:=0; T:=[1..N]-[s];

{основной цикл}

while T<>[ ] do begin

u:=<то значение l, при котором достигается min(D[l])>;

T:=T-[u]; lÎT

for vÎT do D[v]:=min(D[v],D[u]+A[u,v]);

end;

end;

Время работы алгоритма пропорционально N².

3.6.3. Пути в бесконтурном графе

Дано.Ориентированный граф G=<V,E> без контуров, веса дуг произвольны.Результат.Массив кратчайших расстояний(длин) D от фиксированной вершины до всех остальных.Утверждение.В произвольном бесконтурном графе вершины можно перенумеровать так, что для каждой дуги <i,j> номер вершины i будет меньше номера вершины j.

Пример.

Введем следующие структуры данных:

• массив NumIn, NumIn[i] определяет число дуг, входящих в вершину с номером i;

• массив Num, Num[i] определяет новый номер вершины i;

• массив Stack, для хранения номеров вершин, в которые заходит нулевое количество дуг. Работа с массивом осуществляется по принципу стека;

• переменная nm, текущий номер вершины.

  Суть алгоритма. Вершина i, имеющая нулевое значение NumIn, заносится в Stack, ей присваивается текущее значение nm(запоминается в Num), и изменяются значения элементов NumIn для всех вершин, связанных с i. Процесс продолжается до тех пор, пока Stack не пуст. Трассировка работы алгоритма для нашего примера приведена в таблице.

№ итерации	NumIn	Num	Stack	Nm
начальная	[2,2,2,1,0,1]	[0,0,0,0,0,0]	[5]	0
1	[2,2,1,0,0,1]	[0,0,0,0,1,0]	[4]	1
2	[1,2,0,0,0,1]	[0,0,0,2,1,0]	[3]	2
3	[0,2,0,0,0,0]	[0,0,3,2,1,0]	[6,1]	3
4	[0,1,0,0,0,0]	[0,0,3,2,1,4]	[1]	4
5	[0,0,0,0,0,0]	[5,0,3,2,1,4]	[2]	5
6	[0,0,0,0,0,0]	[5,6,3,2,1,4]	[ ]	6

procedure Change_Num;

{A, Num - глобальные структуры данных}

var NumIn,Stack:array[1..N] of integer;

i,j,u,nm,yk:integer;

begin

{инициализация данных}

FillChar(NumIn,SizeOf(NumIn),0);

for i:=1 to N do

for j:=1 to N do if A[i,j]<>0 then Inc(NumIn[j]);

nm:=0;yk:=0;

for iÎV do if NumIn[i]=0 then begin Inc(yk);Stack[yk]:=i; end;

{основной цикл}

while yk<>0 do begin

u:=Stack[yk];Dec[yk];Inc(nm);Num[u]:=nm;

for i:=1 to n do

if A[u,i]<>0 then begin Dec(NumIn[i]);

if NumIn[i]=0 then begin

Inc(yk); Stack[yk]:=i; end;

end;

end;

end;

Итак, пусть для графа G выполнено условие утверждения и нам необходимо найти кратчайшие пути (их длины) от первой вершины до всех остальных . Пусть мы находим оценку для вершины с номером i. Достаточно просмотреть вершины, из которых идут дуги в вершину с номером i. Они имеют меньшие номера, и оценки для них уже известны. Остается выбрать меньшую из них.

procedure Distance;

{D, A - глобальные]

var i,j:integer;

begin

D[1]:=0;

for i:=2 to N do D[i]:=¥;

{основной цикл}

for i:=2 to N do

for j:=1 to i-1 do if A[j,i]<>¥then D[i]:=min(D[i],D[j]+A[j,i]);

end;

Время работы алгоритма пропорционально N².