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

program DijkstraAlgorithm;
uses crt;
const V=6; inf=100000;
type vektor=array[1..V] of integer;
var start: integer;
const GR: array[1..V, 1..V] of integer=(
(0, 1, 4, 0, 2, 0),
(0, 0, 0, 9, 0, 0),
(4, 0, 0, 7, 0, 0),
(0, 9, 7, 0, 0, 2),
(0, 0, 0, 0, 0, 8),
(0, 0, 0, 0, 0, 0));
{алгоритм Дейкстры}
procedure Dijkstra(GR: array[1..V, 1..V] of integer; st: integer);
var count, index, i, u, m, min: integer;
distance: vektor;
visited: array[1..V] of boolean;
begin
m:=st;
for i: integer :=1 to V do
begin
distance[i]:=inf; visited[i]:=false;
end;
distance[st]:=0;
for count: integer :=1 to V-1 do //й
begin
min:=inf;
for i: integer :=1 to V do
if (not visited[i]) and (distance[i]<=min) then
begin
min:=distance[i]; index:=i;
end;
u:=index;
visited[u]:=true;
for i: integer :=1 to V do
if (not visited[i]) and (GR[u, i]<>0) and (distance[u]<>inf) and
(distance[u]+GR[u, i]<distance[i]) then
distance[i]:=distance[u]+GR[u, i];
end;
write('Стоимость пути из начальной вершины до остальных: '); writeln;
for i: integer :=1 to V do
if distance[i]<>inf then
writeln(m,' > ', i,' = ', distance[i])
else writeln(m,'>', i,' = ', 'маршрут недоступен');
end;
{основной блок программы}
begin
clrscr;
write('Начальная вершина >> '); read(start);
Dijkstra(GR, start);
end.

program DijkstraAlgorithm;
uses crt;
const V=6; inf=100000;
type vektor=array[1..V] of integer;
     test=array[1..V, 1..V] of integer;
var start: integer;
const GR: array[1..V, 1..V] of integer=(
(0, 1, 4, 0, 2, 0),
(0, 0, 0, 9, 0, 0),
(4, 0, 0, 7, 0, 0),
(0, 9, 7, 0, 0, 2),
(0, 0, 0, 0, 0, 8),
(0, 0, 0, 0, 0, 0));
{алгоритм Дейкстры}
procedure Dijkstra(GR: test; st: integer);

const Inf = 99; //бесконечность
 
procedure Deikstr(s: integer; a: array[,] of integer);
//s - искомая вершина (необходимо найти путь от s до остальных)
begin    
 var n := a.Size[0] - 1;
 var visited:= |false| * (n+1); //массив посещённости вершин
 visited[s] := TRUE; //вершина S посещена
 var D :=  a.Row(s); //массив кратчайших расстояний
 var P := |s| * (n+1);//массив предков, который поможет определить маршрут. 
//p[i] будет содержать предпоследнюю вершину кратчайшего маршрута от s до i
 (D[s], p[s]) := (0, inf);
 
 loop n-2 do //на каждом шаге находим миним. решение и пытаемся его улучшить
 begin 
  var (min, v) := (Inf, 0);
    
  for var j := 1 to N do
   if (not visited[j]) and (D[j] < min) then (min, v) := (D[j], j); 
                                  //(мин.расстояние, найденная вершина)
    
  for var k := 1 to N do
   if (D[k] > D[v] + A[v, k]) and (D[v] < inf) and (A[v, k] < inf) then
      (D[k], p[k]) := ( D[v] + A[v, k],  v ); // Если расстояние больше 
        // чем сумма расстояния до тек.вершины и длины ребра, то уменьшаем его
   
  visited[v] := TRUE; // и она отмечается посещенной
 end;
  
 for var f := 1 to n do 
 begin
  if f = s then continue;  
  $'{s}->{f}'.Print;
  if (d[f]= inf) or (p[f] = inf) then begin $'путь не сущствует'.Println; continue; end
  else $'({d[f]}):'.PadRight(6).Print;
  var (st, z) := ('', p[f]); 
  var c := a[p[f], f]; //Расстояние
   
  while z <> inf do
  begin
   st := z.ToString + ' -('+ c + ')> ' + st; //заносим в маршрут
   if p[z] <> inf then c := a[p[z], z]; // Расстояние
   z := p[z]; //переходим к следующей вершине
  end;
 
  st += f.ToString; //в маршрут записываем начальную вершину
  Writeln(st);  
 end;
end;
 
procedure GenGr(a: array[,] of integer; n, m: integer);
begin
  var c := 0;
  while c <> m do
  begin
   var i := Random(1,n-1);
   var j := Random(i+1,n);
   if a[i, j] = 0 then begin a[i,j] := Random(1, 9); a[j,i] := a[i,j]; inc(c);end;
  end; 
  a.MatrSlice(1,n,1,n).Println(2);
  a.Transform(n -> n = 0 ? inf : n);   
end;
 
begin
  var n, m, s: integer;
  
  repeat $'Всего вершин (не более 10):'.Print
  until ReadlnString.TryToInteger(n) and (n in 2..10);  
  var mMax := n*(n-1) div 2;
  repeat $'Всего ребер (не более {mMax}):'.Print
  until ReadlnString.TryToInteger(m) and (m in 0..mMax);
  repeat $'Точка старта (1..{n}):'.Print
  until ReadlnString.TryToInteger(s) and (s in 1..n);
 
  var a := new integer[n+1, n+1];
  GenGr(a, n, m);  // Генерируем матрицу смежности с выводом
  Deikstr(s, a);
end.