по дейкстру найти расстояние по которому можно провезти максимальный груз

program DijkstraAlgorithm1;
uses crt;
const V = 7; inf = -1;
type vektor=array[1..1000] of integer;
var
   cities :array[1..V] of STRING;
   start: integer;
   f1 : TEXT;
   f2 : TEXT;
   choisesecond : integer;
   choisefirst : integer;
   count : integer;
   GR: array[1..V, 1..V] of integer;
{_________________________________________________________________}
procedure Dijkstra(GR: array[1..V, 1..V] of integer; st: integer; temp2: integer);  //st номер начааьной вершины
var count, index, i, u, m, max: integer;
    distance: vektor;    { distance, будут храниться найденные кратчайшие пути}
    visited: array[1..V] of boolean;   {для хранения информации о посещенных вершинах}
begin
     m := st;//в перменную m записываем началную вершину
     for i := 1 to V do
         begin
              distance[i] := inf; { записываем число заыедомо большее любого другого числа}
              visited[i] := false;   {массив visited сначала инициализируем как false }
         end;
     distance[st] := 0; // выбираем начальную вершину т е пункт из которого будем искать путь , присваиваем значение 0
     for count := 1 to V-1 do   //*просматриваем все оставшиеся вершины  т е все вершины  "- " 1
         begin
              max := inf;        // присваиваем  maximum -1
              for i:=1 to V do                                  //просматриваем все без исключения вершины
                  begin
                       if (not visited[i]) and (distance[i] >= max) then       // находим минимальное расстояние до не посещенной вершины
                          begin
                               max := distance[i];  //minim присваиваем новое значение
                               index := i;  // i присваиваем index
                          end;
                  end;
                  WRITELN(max);
                  u := index;
                  visited[u] := true;  //   отмечаем её как посещённую  и активной становится та вершина путь из s до которой максиммален
                  for i := 1 to V do  
                  BEGIN                                   
                      WRITELN( GR[u, i]);
                      WRITELN(distance[i]);
                      if  (GR[u, i] <> 0) and (distance[u] > inf) and  //если вершина просматриваемая не посещённая и есть путь и из u в вершину i
                             (distance[u]  < distance[i] + GR[u, i]  ) then  // и расстояние не равно -1 и расстояние из начальной
                                 BEGIN
                                          distance[i] := distance[u] + GR[u, i];
                                          WRITELN(distance[i]);
                                 END;
                      WRITELN(distance[i]);
                  END;
         end;
         write('МАКСИМАЛЬНЫЙ ВЕС ГРУЗА   :'); writeln;
        { for i:=1 to V do      }
        if distance[temp2] <> inf then
           writeln('из ',cities[m],' в ', cities[temp2],' = ', distance[temp2])
        else
            writeln('из ',cities[m],' в ', cities[temp2],' = ', 'маршрут недоступен');
end;
{_________________________________________________________________}
 
//////////////////////////////////////////////////
{выбираем строку}
FUNCTION ParseString(str :string): string;
VAR
   i : integer;
   fl : integer;
   tempstr : string;
   BEGIN
        tempstr := '';
        i := 0;
        fl := 0;
        WHILE (i <= length(str)) DO
              BEGIN
                   IF (str[i] = ' ') THEN
                      fl := fl + 1;
                   IF (fl = 1) THEN
                      tempstr := tempstr + str [i];
                   i := i + 1;
              END;
        ParseString := tempstr;
        exit;
   END;
{эта процедура возвращает целое число из строки }
FUNCTION Preobraz(st : char):integer;
  BEGIN
       Preobraz := ord(st) - 48;
       exit;
  END;
//выбираем идентификатор города и возвращаем
FUNCTION ParseDigit(stroka :string): integer;
Var
   i : integer;
   chis : integer;
BEGIN
     chis := 0;
     for i := 1 To Length(stroka) DO
         BEGIN
              if ( stroka[i] <> ' ') then
                 BEGIN
                      chis := chis*10 +  Preobraz(stroka[i]);
                 END
              ELSE
                  BEGIN
                      ParseDigit := chis ;
                      exit;
                  END;
         END;
END;
FUNCTION ReadCountCity : integer;
VAR
   str : string;
   temp : integer;
   temp2 : integer;
BEGIN
      temp := 0;
      WHILE NOT EOF(f1) DO
         BEGIN
              READLN(f1, str);    {...считываем построчно в переменную st }
              str := ParseString(str);
              WRITELN(str);
              temp := temp + 1;
              cities[temp] := str;
         END;
         ReadCountCity := temp;
END;
PROCEDURE MatrInZero;
  var
     i : integer;
     j : integer;
BEGIN
     FOR i := 1 TO V Do
         FOR j := 1 TO V DO
             GR[i,j] := 0;
 
END;
PROCEDURE PrintCities;
VAR
   i : integer;
   j : integer;
BEGIN
     for i := 1 to count DO
     BEGIN
         WRITE(i,'   ');
         WRITELN(cities[i]);
     END;
END;
/// работаем с заполнением матрицы
///
FUNCTION ParseDigitconnect(str : string ; t : integer) : integer ;
 
Var
   i : integer;
   flag :integer;
   chis : integer;
BEGIN
     flag := 0;
     chis := 0;
     for i := 1 To Length(str) DO
         BEGIN
              if ((str[i] <> ' ' )) then
                 BEGIN
                      if (( flag = t)) then
                         chis := chis*10 +  Preobraz(str[i]);
                 END
              ELSE
                  BEGIN
                       flag := flag + 1;
                  END;
         END;
     ParseDigitconnect := chis ;
     exit;
 END;
 
///
PROCEDURE READINMATRIX;
VAR
   i : integer;
   first : integer;
   second : integer;
   value : integer;
   str : string;
   BEGIN
        first := 0;
        second := 0;
        value := 0;
        WHILE NOT EOF(f2) DO
         BEGIN
              READLN(f2, str);    {...считываем построчно в переменную st }
              first := ParseDigitconnect(str,0);
              second := ParseDigitconnect(str,1);
              value := ParseDigitconnect(str,2);
              WRITELN(GR[first,second]);
              GR[first,second] := value;
              WRITELN(GR[first,second]);
         END;
   END;
{печатаем матрицу}
PROCEDURE PrintMatrix;
VAR
   i : integer;
   j : integer;
   BEGIN
        for i := 1 TO V Do
            BEGIN
                 for j := 1 TO V DO
                     WRITE(GR[i,j]);
            WRITELN();
            END;
   END;
/////////////////////////////////////////////////
{основная программа}
begin
clrscr;
try     {для перехвата ошибки при невозможности открыть анализируемый файл }
          ASSIGN(f1, 'city.txt'); // Связываем файл INPUT.TXT с файловой пер. input
          RESET(f1);
          ASSIGN(f2, 'connect.txt'); // Связываем файл INPUT.TXT с файловой пер. input
          RESET(f2);
       except
          writeln ('Невозможно открыть input.txt');     //вывод ошибки если она есть
          writeln;
          Halt;
       end;
count := ReadCountCity;     //количество городов
WRITELN('выберите начальный и конечный город из имеющихся :');
PrintCities;
PrintMatrix;
READINMATRIX;
READLN(choisefirst);
READLN(choisesecond);
if ((choisefirst < 1 ) OR (choisefirst > count)) THEN
   BEGIN
        WRITELN('ERROR !!! вы ввели некорректные данные');
        EXIT;
   END;
if ((choisesecond < 1 ) OR (choisesecond > count)) THEN
   BEGIN
        WRITELN('ERROR !!! вы ввели некорректные данные');
        EXIT;
   END;
PrintMatrix;
Dijkstra(GR, choisefirst,choisesecond);
close(f1);
Close(f2);
end.