Нахождение критического пути

Programm
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ModelApp
{
    class Program
    {
        static void Main(string[] args)
        {
            // построение сетевой модели проекта
 
            Network prj = new Network();
 
            Activity a = new Activity("A", 5, 7, 9); prj.activities.Add(a);
            Activity b = new Activity("B", 3, 4, 6); prj.activities.Add(b);
            Activity c = new Activity("C", 4, 6, 9); prj.activities.Add(c);
 
            prj.AddRelation(a, c);
            prj.AddRelation(b, c);
 
            // вывод на экран информации о построенной модели проекта
 
            Console.WriteLine("Описание модели проекта:");
 
            Console.Write("Введены работы:");
            for (int i = 0; i < prj.activities.Count; i++)
                Console.Write(" {0}({1:N0}),", prj.activities[i].name, prj.activities[i].duration);
            Console.WriteLine("");
 
            Console.Write("Отношения предшествования:");
            for (int i = 0; i < prj.activities.Count; i++)
                for (int r = 0; r < prj.activities[i].successors.Count; r++)
                    Console.Write(" {0}->{1},", prj.activities[i].name, prj.activities[i].successors[r].name);
            Console.WriteLine("");
 
            Console.WriteLine("Коэффициент сложности сети: {0}", prj.NetworkComplexity());
 
            prj.TopologicalSort();
 
            Console.Write("Топологическая сортировка:");
            for (int i = 0; i < prj.orderedActivities.Count; i++)
                Console.Write(" {0},", prj.orderedActivities[i].name);
            Console.WriteLine("");
 
            prj.CPM();
            //prj.CountMTS();
            //prj.CountSlacks();
 
            Console.WriteLine("Результаты применения СРМ:");
            Console.WriteLine("Работа\tEST\tEFT\tLST\tLFT\tSLK\tFSLK\tMTS");
            foreach (Activity act in prj.activities)
                Console.WriteLine("{0}\t{1:N0}\t{2:N0}\t{3:N0}\t{4:N0}\t{5}\t{6}\t{7}", act.name, act.EST, act.EFT, act.LST, act.LFT, act.SLK, act.FSLK, act.MTS);
            Console.WriteLine("\nПродолжительность проекта: {0}\n", prj.duration);
 
            prj.Simulation();
 
            Console.WriteLine("Результаты симуляции:");
            Console.WriteLine("\tMean: {0}", prj.mean);
            Console.WriteLine("\tVar: {0}", prj.var);
            Console.WriteLine("\t3S: {0}", 3 * Math.Sqrt(prj.var));
 
            
            // Ожидание нажатия любой клавиши
            Console.WriteLine("\n\rДля завершения работы нажмите любую клавишу...");
            Console.ReadKey();
        }
    }
}
 
 
 
Class
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace ModelApp
{
    // Этот класс описывает свойства (переменные) и методы, которые будут у каждой работы проекта
    // Пример:
    //      Activity a = new Activity("A"); // создается работа с именем А и нулевой продолжительностью
    //      a.duration = 5; // продолжительность работы "a" становится 5 (например, дней)
    class Activity
    {
        // имя работы
        public string name;
 
        // продолжительность работы
        public double duration;
 
        // продолжительности, используемые для метода PERT
        public double optimistic, pessimistic, mostlikely;
        public double mean, var, sigma;
 
        // список работ-предшественников
        public List<Activity> predecessors;
 
        // список работ-последователей
        public List<Activity> successors;
 
        // Это конструктор класса (выполняется при создании работы)
        public Activity(string Name, double Duration = 0)
        {
            this.name = Name;
            this.duration = Duration;
 
            // подготовка списков последователей и предшественников к использованию
 
            this.predecessors = new List<Activity>(5);
            this.successors = new List<Activity>(5);
        }
 
        public Activity(string Name, double Optimistic, double MostLikely, double Pessimistic)
        {
            this.name = Name;
 
            this.optimistic = Optimistic;
            this.mostlikely = MostLikely;
            this.pessimistic = Pessimistic;
 
            this.mean = (this.optimistic + 4 * this.mostlikely + this.pessimistic) / 6;
            this.sigma = (this.pessimistic - this.optimistic) / 6;
            this.var = this.sigma * this.sigma;
 
            this.duration = this.mean;
            
            this.predecessors = new List<Activity>(5);
            this.successors = new List<Activity>(5);
        }
 
        public void SetStochasticDuration(MyRandom rnd)
        {
            this.duration = (int)rnd.Triangle(this.optimistic, this.mostlikely, this.pessimistic);
        }
        //
        // расчетные величины
        //
 
        public int order;
 
        // эти переменные заполняет метод критического пути
        public double EST, EFT, LST, LFT;
        public double SLK, FSLK, MTS;
 
        // эту переменную использует топологическая сортировка
        public int p_count;
    }
 
    // Этот класс описывает сетевую модель проекта
    // Пример:
    //      Network prj = new Network(); // создается проект
    //      Activity a = new Activity("A", 2); // создается работа A с продолжительностью 2 дня
    //      Activity b = new Activity("B", 5); // создается работа B с продолжительностью 5 дня
    //      prj.activities.Add(a); // Работа "а" добавляется в проект
    //      prj.activities.Add(b); // Работа "b" добавляется в проект
    //      prj.AddRelation(a,b); // добавляется отношение предшествования a->b
    class Network
    {
        //
        // описание сетевой модели
        //
 
        // в этом списке находятся все работы проекта       
        public List<Activity> activities;
 
        // Конструкор класса. Готовит список работ проекта к заполнению
        public Network()
        {
            this.activities = new List<Activity>(20);
        }
 
        // Добавляет отношение предшествования между двумя работами (a->b)
        public void AddRelation(Activity a, Activity b)
        {
            a.successors.Add(b);
            b.predecessors.Add(a);
        }
        // Удаляет отношение предшествования между двумя работами (a->b)
        public void DelRelation(Activity a, Activity b)
        {
            a.successors.Remove(b);
            b.predecessors.Remove(a);
        }
 
        //
        // анализ и расчет сетевой модели
        //
 
        // расчет коэффициента сложности сети (отношение кол-ва отношений предшествования и кол-ва работа проекта)
        public double NetworkComplexity()
        {
            int r = 0;
 
            for (int i = 0; i < this.activities.Count; i++) // этот цикл перебирает все работы проекта
                r += this.activities[i].successors.Count;     // на этом этапе к переменной r прибавляется кол-во прямых последователей текущей работы
 
            return ((double)r / this.activities.Count);
        }
 
        // топологическая сортировка
        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 (s.p_count == s.predecessors.Count)
                {
                    // рекурсивный вызов
                    this.OrderActivity(s);
                }
            }
        }
 
        // метод критического пути
        public double duration;
        public void CPM()
        {
            this.duration = 0;
 
            // обнуление предыдущих результатов
            for (int i = 0; i < this.orderedActivities.Count; i++)
                this.orderedActivities[i].EST = 0;
 
            //
            // Прямой расчет сети
            //            
 
            for (int i = 0; i < this.orderedActivities.Count; i++)
            {
                Activity a = this.orderedActivities[i];
 
                a.EFT = a.EST + a.duration;
 
                if (duration < a.EFT)
                    duration = a.EFT;
 
                for (int s = 0; s < a.successors.Count; s++)
                {
                    if (a.successors[s].EST < a.EFT)
                        a.successors[s].EST = a.EFT;
                }
            }
 
            //
            // Обратный расчет сети
            //
            this.BackwardPass();
        }
 
        public void BackwardPass()
        {
            //
            //Обратный расчет сети
            //
            foreach (Activity a in this.activities)
                a.LFT = this.duration;
 
            for (int i = this.activities.Count - 1; i >= 0; i--)
            {
                Activity a = this.orderedActivities[i];
 
                a.LST = a.LFT - a.duration;
 
                foreach (Activity p in a.predecessors)
                {
                    if (p.LFT > a.LFT)
                        p.LFT = a.LST;
                }
 
            }
            
        }
 
        public void CountSLK()
        {
            foreach (Activity a in this.activities)
            {
                a.SLK = a.LST - a.EST;
                a.FSLK = a.SLK;
                foreach (Activity s in a.successors)
                {
                    if (s.EST - s.EFT < a.FSLK)
                        a.FSLK = s.EST - s.EFT;
                }
            }
        }
        
        public double mean, var;
        public void Simulation(int n = 500)
        {
            MyRandom rnd = new MyRandom();
 
            mean = 0;
            var = 0;
 
            int[] res = new int[n];
 
            for (int i = 0; i < n; i++)
            {
                foreach (Activity a in this.activities)
                    a.SetStochasticDuration(rnd);
 
                this.CPM();
                res[i] = (int)this.duration;
                mean += this.duration;
 
            }
            mean /= n;
 
            for (int i = 0; i<n; i++)
             var += (res[i] - mean) * (res[i] - mean);
 
            var /= (n - 1);
 
            
        }
    }
 
    class MyRandom
    {
        public Random rnd;
 
        public MyRandom()
        {
            this.rnd = new Random();
        }
 
        public double Triangle(double a, double m, double b)
        {
            double u = rnd.NextDouble();
            double f = (m - a) / (b - a);
 
            if (u < f)
                return a + Math.Sqrt(u * (b - a) * (m - a));
            else
                return b - Math.Sqrt((1 - u) * (b - a) * (b - m));
        }
    }
}

int SuccessorsNumber()
{ return successors.Aggregate<Activity, int>(0, (sum,a) => sum+a.SuccessorsNumber()) + 1; }