Найти путь, содержащий наибольшее количество вершин графа

program TaskA;
 
type
  work = record  //Содержит всю информацию о курсе
    name: string;
    t_start: integer;
    t_end: integer;
    state: integer; //-1:До этого курса нельзя посетить никакой другой
                        //0:Курс в середине расписания
                        //1:Настолько продолжительный, что начинается одним из первых, а кончается одним из последних
                        //2:Один из последних курсов
  end;
 
var
  a: array of work;
  matr: array [,] of integer; 
  streak: array of array of integer;  //Хвост для уже посчитанных вершин 
  i, j, k, len: integer;
  answer, current: array of integer;
 
 
procedure swap(var a, b: integer); //Меняет местами переменные
var
  c: integer;
begin
  c := a;
  a := b;
  b := c;
end;
 
procedure swap(var a, b: string);
var
  c: string;
begin
  c := a;
  a := b;
  b := c;
end;
 
procedure swap(var a, b: work);
begin
  swap(a.t_start, b.t_start);
  swap(a.t_end, b.t_end);
  swap(a.name, b.name);
  swap(a.state, b.state);
end;
 
procedure print_array(a: array of integer);  //Печатает массив
begin
  for var i := 0 to a.Length - 2 do
    write(a[i], ' ');
  writeln(a[a.Length - 1]);
end;
 
function merge_array(i: integer; a: array of integer): array of integer;  //Склеивает число и массив
begin
  setlength(result, a.Length + 1);
  result[0] := i;
  for var j := 1 to a.Length do
    result[j] := a[j - 1];
end;
 
function merge_array(a, b: array of integer): array of integer;  //Склеивает 2 массива
begin
  setlength(result, a.Length + b.Length);
  for var i := 0 to a.Length - 1 do
    result[i] := a[i];
  for var i := a.Length to a.Length + b.Length - 1 do
    result[i] := b[i - a.Length];
end;
 
function search(var i: integer; c: array of integer): array of integer;  //Основная рекурсивная функция
var
  j, k: integer;
  r, m, t: array of integer;
begin
  if c = nil
    then
    setlength(c, 1)
  else
    setlength(c, c.length + 1); //с - пройденый путь
  m := c;
  m[m.length - 1] := i;
  if a[i].state <= 0 then //Если вершина не последняя
    if streak[i][0] = -1 then  //Если для данной вершины ещё не расчитан "хвост" (Изначально все ячейки streak = -1)
    begin
      for j := i + 1 to len - 1 do
        if matr[i, j] >= 0 then  //Перебор всех вершин
        begin
          t := c;
          r := search(j, t);  //Рекурсия
          if r.length > m.length then  //Проверка нового решения
          begin
            m := r; 
            k := j
          end;
        end;
      if streak[k][0] = -1 //Если "хвост" найденой оптимальной вершины не определён (Из-за рекурсии это возможно
                                // только для конечных вершин)
        then streak[i][0] := k //То "хвост" состоит из номера найденой вершины
      else streak[i] := merge_array(k, streak[k]);  //Иначе склеиваем найденую вершину и её "хвост"
    end else
    begin
      m := merge_array(m, streak[i])//Если "хвост" уже был расчитан ранее, то просто склеиваем его и пройденый путь
    end;
  result := m;
end;
 
function random_work: work; //Возвращает случайный курс
begin
  result.name := inttostr(random(1000));
  result.t_start := random(1080);
  result.t_end := result.t_start + random(1081 - result.t_start);
end;
 
begin
  {INPUT}  
  randomize;                                 
  readln(len); 
  setlength(a, len);
  for i := 0 to len - 1 do
    a[i] := random_work;
  {SORTING} //Сортировка курсов по времени начала 
  for i := 0 to len - 2 do
    for j := i + 1 to len - 1 do
      if a[i].t_start > a[j].t_start 
        then swap(a[j], a[i]);
  a[0].state := -1;  //Первый этап расчёта типа курса
  j := a[0].t_end;
  for i := 1 to len - 1 do
    if a[i].t_start < j then
    begin
      if a[i].t_end < j 
        then j := a[i].t_end;
      a[i].state := -1;
    end else
      a[i].state := 0;
  {MATRIX} //Инициализация матрицы: Для каждого курса (i) с каждым последующим (j)...
  setlength(matr, len, len);
  for i := 0 to len - 1 do
  begin
    for j := i + 1 to len - 1 do
      if a[i].t_end < a[j].t_start
        then 
        matr[i, j] := a[j].t_start - a[i].t_end //Присваивается перерыв между ними, 
                                                         //если после i допустимо и оптимально идти на j
      else 
        matr[i, j] := -1;  //-1, если невозможно
    for j := i + 2 to len - 1 do
      for k := i + 1 to j - 1 do
        if (matr[i, k] <> -1) and (a[k].t_end <= a[j].t_start)
          then matr[i, j] := -2; //-2, если можно, но не оптимально (между 2 курсами можно посетить ещё один)
    k := 1;
    for j := i + 1 to len - 1 do
      if matr[i, j] > -1 
        then k := 0;
    a[i].state := a[i].state + k * 2; //Второй этап расчёта типа курса
  end;
  setlength(streak, len);
  for i := 0 to len - 1 do
  begin
    setlength(streak[i], 1);
    streak[i][0] := -1;
  end;
  {SEARCH} //Собственно, search                                        
  k := 0;                                       
  while (abs(a[k].state) = 1) and (k <= len) do //Для всех начальных курсов
  begin
    current := search(k, current);
    current := merge_array(k, streak[k]);
    if (answer = nil) or (current.length > answer.length)
      then answer := current;
    inc(k);
    current := nil;
  end;
  print_array(answer);
end.