Здравствуйте! Прошу помощи в следующем вопросе:

Нужна помощь в доработке кода в соответствии с заданием - Упорядочить работы сетевого графика, рассчитать ранний (EET) и поздний(LET) срок наступления события, найти критические пути и проверить граф на отсутствие петель и циклов
Тестовый пример
i j ῖ(продолжител работы)
15 8 2
14 6 1
10 2 2
17 8 2
3 14 3
2 15 3
10 14 5
2 6 4
10 3 4
6 8 4
3 6 2
6 17 1
3 17 6

Приложение:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ModelApp
{
public class Activity
{
public int Number { get; set; } // номер события
public double EET { get; set; } // ранний срок наступоения события
public double LET { get; set; } // поздний срок наступления события
public double Reserv { get; set; } // резерв времени

// расчетные величины
public int order;
public int p_count; // эту переменную использует топологическая сортировка
public List<Activity> predecessors; // список работ-предшественников
public List<Activity> successors; // список работ-последователей

// продолжительность работы
public int duration;

public Activity(int dur, int number, Activity a)
{
this.Number = number;
EET = LET = Reserv = 0;
duration = dur;
this.successors.Add(a);
a.predecessors.Add(this);
}

// Удаляет отношение предшествования между двумя работами (a->b)
public void DelRelation(Activity a)
{
this.successors.Remove(a);
a.predecessors.Remove(this);
}
}

public class Network
{
public List<Activity> activities;

public Network()
{
this.activities = new List<Activity>();
}

// расчет коэффициента сложности сети (отношение кол-ва отношений предшествования и кол-ва работа проекта)
public double NetworkComplexity()
{
int r = 0, l = 0;

for (int i = 0; i < this.activities.Count; i++) // этот цикл перебирает все работы проекта
{
r += this.activities[i].successors.Count; // на этом этапе к переменной r прибавляется кол-во прямых последователей текущей работы
l += this.activities[i].predecessors.Count;
}
if (r == l)
return ((double)r / this.activities.Count);
else return -1;
}

// топологическая сортировка
public List<Activity> orderedActivities;
private int order;
public void TopologicalSort()
{
// выделение памяти/очистка списка упорядоченных работ

if (this.orderedActivities == null)
this.orderedActivities = new List<Activity>(this.activities.Count);
else
this.orderedActivities.Clear();

// Удаление существующей информации в используемых переменных

this.order = 0;

for (int i = 0; i < this.activities.Count; i++)
{
this.activities[i].order = -1;
this.activities[i].p_count = 0;
}

// Упорядочить все первые (у которых нет предшественников) работы проекта

foreach (Activity a in this.activities)
{
if (a.predecessors.Count == 0)
this.OrderActivity(a);
}
}

private void OrderActivity(Activity a)
{
a.order = this.order;
this.order++;
this.orderedActivities.Add(a);

// этот цикл осуществляет перебор всех прямых последователей "s" работы "a"
foreach (Activity s in a.successors)
{
s.p_count++;

if (a.p_count == s.predecessors.Count)
{
// рекурсивный вызов
this.OrderActivity(s);
}
}
}

public int FindMax(List<Activity> list)
{
if (list.Count == 0)
{
throw new InvalidOperationException("Empty list");
}
int max = int.MinValue;
foreach (Activity type in list)
{
if (type.EET + type.duration > max)
{
max = (int)type.EET + type.duration;
}
}
return max;
}

public int FindMin(List<Activity> list)
{
if (list.Count == 0)
{
throw new InvalidOperationException("Empty list");
}
int min = int.MaxValue;
foreach (Activity type in list)
{
if (type.LET - type.duration < min)
{
min = (int)type.LET - type.duration;
}
}
return min;
}

// метод критического пути
public double duration;
public void CPM()
{
this.duration = 0;

// обнуление предыдущих результатов
for (int i = 0; i < this.orderedActivities.Count; i++)
this.orderedActivities[i].EET = 0;

// ti раннее начальное равно 0

//
// Прямой расчет сети
//
for (int i = 1; i < this.orderedActivities.Count; i++)
{
Activity a = this.orderedActivities[i];
// tj раннее = min по i среди (ti раннее + duration)
a.EET = FindMax(a.predecessors);
}

//
// Обратный расчет сети
//
this.BackwardPass();
}

public void BackwardPass()
{
//
//Обратный расчет сети
//
foreach (Activity a in this.activities)
a.LET = this.duration;

// tj позднее последнее = tj раннее последнее
this.orderedActivities[this.activities.Count - 1].LET = this.orderedActivities[this.activities.Count - 1].EET;

for (int i = this.activities.Count - 2; i >= 0; i--)
{
Activity a = this.orderedActivities[i];
// ti позднее = min по j среди (tj позднее - duration)
a.LET = FindMin(a.successors);
}

}

public List<Activity> CriticalPath; // вершины критического пути
public int CriticalDuration;

public void CountSLK()
{
List<Activity> CriticalPath = new List<Activity>();
foreach (Activity activity in this.activities)
{
if ((activity.EET - activity.LET == 0))
CriticalPath.Add(activity);
}
CriticalDuration = (int)this.orderedActivities[this.activities.Count - 1].EET;
}

}

}