commit

Симлекс_метод/Симлекс_метод.sln → Нахождение критического пути/Нахождение критического пути.sln

@@ -3,7 +3,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
 VisualStudioVersion = 17.1.32228.430
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Симлекс_метод", "Симлекс_метод\Симлекс_метод.csproj", "{0240FD22-C9B9-407F-A2C6-2709EE7AA9CC}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Нахождение критического пути", "Нахождение критического пути\Нахождение критического пути.csproj", "{A281D4A3-B352-40B7-879E-D09FD908E5E5}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -11,15 +11,15 @@ Global
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{0240FD22-C9B9-407F-A2C6-2709EE7AA9CC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{0240FD22-C9B9-407F-A2C6-2709EE7AA9CC}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{0240FD22-C9B9-407F-A2C6-2709EE7AA9CC}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{0240FD22-C9B9-407F-A2C6-2709EE7AA9CC}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A281D4A3-B352-40B7-879E-D09FD908E5E5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A281D4A3-B352-40B7-879E-D09FD908E5E5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A281D4A3-B352-40B7-879E-D09FD908E5E5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A281D4A3-B352-40B7-879E-D09FD908E5E5}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {1238EDE8-E81E-44E8-863E-24531C2FACE3}
+		SolutionGuid = {E1D80D16-1DBD-4177-B662-7F3940B5DBA9}
 	EndGlobalSection
 EndGlobal

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

@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Нахождение_критического_пути
+{
+    internal class Decision
+    {
+        public int[,] work; // Список дуг (работ) и их продолжительность
+        public string[] path; // Список путей
+        public int[] F; // Продолжительность для каждого пути
+        public int maxF; // Максимальная продолжительность
+        public int start;
+        public void ShowVhodData()
+        {
+            Console.WriteLine("Входные данные:");
+            Console.WriteLine("Работа | Продолжительность");
+            for (int i = 0; i < work.GetLength(0); i++)
+            {
+                Console.WriteLine(work[i,0] + " -- " + work[i, 1] + "\t\t" + work[i,2]);
+            }
+        }
+        public int GetStart() // Метод для поиска начальной точки (eсли нет таких дуг, которые бы входили в данную точку, то она начальная)
+        {
+            int start = 0; // Начальная точка
+            for(int i = 0; i < work.GetLength(0); i++)
+            {
+                start = work[i,0];
+                int k = 0; // Количество дуг, которые заканчиваются данной точкой
+                for(int j = 0; j < work.GetLength(0); j++)
+                {
+                    if(work[j,1] == start) // Если дуга заканчивается этой точкой
+                    {
+                        k++;
+                    }
+                }
+                if(k == 0) // Если нет таких дуг, которые бы входили в данную точку, то она начальная
+                {
+                    break;
+                }
+            }
+            return start;
+        }
+        public void CalculatePathes() // Формирование путей и подсчёт F
+        {
+            path = new string[0];
+            F = new int[0];
+            for (int i = 0; i < work.GetLength(0); i++)
+            {
+                if(work[i,0] == start)
+                {
+                    Array.Resize(ref path, path.Length + 1);
+                    path[path.Length - 1] = Convert.ToString(start) + " - " + Convert.ToString(work[i, 1]);
+                    Array.Resize(ref F, F.Length + 1);
+                    F[F.Length - 1] = GetDuration(0, work[i, 0], work[i, 1], work);
+                    GetNextPath(work[i, 1]); // Переход к следующей точки
+                }
+            }
+        }
+        public int GetDuration(int F, int str, int end, int[,] w) // Метод для подсчёта продолжительности работ (str - начальная точка, end - конечная)
+        {
+            int summa = 0; // Сумма продолжительности, которую нужно будет прибавить к существующей
+            for(int i = 0; i < work.GetLength(0); i++)
+            {
+                if(w[i,0] == str && w[i, 1] == end)
+                {
+                    summa = w[i, 2];
+                }
+            }
+            return F + summa;
+        }
+        public void GetNextPath(int str) // Определение следующей точки
+        {
+            int k = 0; // Количество точек в которые можно попасть из исходной
+            string lastPath = ""; // Переменная, котрая хранит предыдущий путь перед ветвлением
+            int lastF = 0; // Переменная, котрая хранит предыдущее значение F перед ветвлением
+            for (int i = 0; i < work.GetLength(0); i++)
+            {
+                if (work[i, 0] == str && k > 0) // Если начальная точка встречается 2 и более раз
+                {
+                    Array.Resize(ref path, path.Length + 1);
+                    path[path.Length - 1] = lastPath + " - " + Convert.ToString(work[i, 1]);
+                    Array.Resize(ref F, F.Length + 1);
+                    F[F.Length - 1] = GetDuration(lastF, work[i, 0], work[i, 1], work);
+                    GetNextPath(work[i, 1]); // Снова проверяем наличие следующего пути
+                    k++;
+                }
+                if (work[i, 0] == str && k == 0)
+                {
+                    lastPath = path[path.Length - 1]; // Запоминаем предыдущее значение
+                    lastF = F[F.Length - 1]; // Запоминаем предыдущее значение
+                    path[path.Length - 1] = path[path.Length - 1] + " - " + Convert.ToString(work[i, 1]);
+                    F[F.Length - 1] = GetDuration(F[F.Length - 1], work[i, 0], work[i, 1], work);
+                    GetNextPath(work[i, 1]); // Снова проверяем наличие следующего пути
+                    k++;
+                }
+            }
+        }
+        public int FindCriticalPath() // Метод для нахождения макcимальной F
+        {
+            int max = 0;
+            for(int i = 0; i < F.Length; i++)
+            {
+                if(max <= F[i])
+                {
+                    max = F[i];
+                }
+            }
+            return max;
+        }
+    }
+}

Симлекс_метод/Симлекс_метод/FileWork.cs → Нахождение критического пути/Нахождение критического пути/FileWork.cs

@@ -6,12 +6,12 @@ using System.Text;
 using System.Threading.Tasks;
 using System.Windows.Forms;
 
-namespace Симлекс_метод
+namespace Нахождение_критического_пути
 {
     internal class FileWork
     {
-        public string pathStart; // Путь к исходному файлу
-        public string pathEnd; // Путь к конечному файлу
+        public static string pathStart; // Путь к исходному файлу
+        public static string pathEnd; // Путь к конечному файлу
         public void VvodNameFile()
         {
             char otv; // Переменная для диалога
@@ -86,7 +86,7 @@ namespace Симлекс_метод
                 }
             }
         }
-        public void GetData(ref int n, ref int m, ref double[,] main, ref double[] res, ref double[] dohod)
+        public int[,] GetData() // Взятие входных данных из файла
         {
             var lines = File.ReadAllLines(pathStart);
             string[][] text = new string[lines.Length][];
@@ -94,31 +94,24 @@ namespace Симлекс_метод
             {
                 text[i] = lines[i].Split(';');
             }
-            m = text.Length - 2;
-            n = text[text.Length-1].Length - 2;
-            main = new double[m, n];
-            dohod = new double[n];
+            int[,] work = new int[text.Length-1,text[text.Length-1].Length];
             int k = 0;
             foreach (string[] line in text)
             {
-                int j = 0;
+                int p = 0;
                 foreach (string s in line)
                 {
-                    if(k > 1 && j == 1)
+                    if(k != 0)
                     {
-                        Array.Resize(ref res, res.Length + 1);
-                        res[res.Length - 1] = Convert.ToInt32(s);
+                        work[k-1,p] = Convert.ToInt32(s);
                     }
-                    if (k > 1 && j > 1)
-                    {
-                        main[k-2,j-2] = Convert.ToInt32(s);
-                    }
-                    j++;
+                    p++;
                 }
                 k++;
             }
+            return work;
         }
-        public bool Proverka()
+        public bool Proverka() // Проверка входных данных
         {
             var lines = File.ReadAllLines(pathStart);
             string[][] text = new string[lines.Length][];
@@ -129,57 +122,68 @@ namespace Симлекс_метод
             int k = 0;
             foreach (string[] line in text)
             {
-                int j = 0;
+                int p = 0;
                 foreach (string s in line)
                 {
-                    if (k > 1 && j == 1)
+                    try
                     {
-                        try
+                        if (k != 0)
                         {
-                            if (Convert.ToDouble(s) < 0)
+                            if(p == 1 && line[p] == line[p - 1])
                             {
-                                Console.WriteLine("Запасы сырья не могут быть отрицательными!!! Исправьте входные данные");
+                                Console.WriteLine("Начало и конец работы не могут совпадать!");
                                 return true;
                             }
-                        }
-                        catch
-                        {
-                            Console.WriteLine("Во входных данных присутствуют некоректные данные, исправьте их и попробуйте снова");
-                            return true;
-                        }
-                    }
-                    if (k > 1 && j > 1)
-                    {
-                        try
-                        {
-                            if (Convert.ToDouble(s) < 0)
+                            if (p == 2 && Convert.ToInt32(s) < 0)
                             {
-                                Console.WriteLine("Расход сырья не может быть отрицательным!!! Исправьте входные данные");
+                                Console.WriteLine("Продолжительность не может быть меньше 0!");
+                                return true;
+                            }
+                            int kolvo = 0; // Количество таких же работ
+                            foreach (string[] line1 in text)
+                            {
+                                if(line1[0] == line[0] && line1[1] == line[1])
+                                {
+                                    kolvo++;
+                                }
+                            }
+                            if(kolvo != 1)
+                            {
+                                Console.WriteLine("В таблице работ не может быть одинаковых работ");
                                 return true;
                             }
                         }
-                        catch
-                        {
-                            Console.WriteLine("Во входных данных присутствуют некоректные данные, исправьте их и попробуйте снова");
-                            return true;
-                        }
+                        p++;
+                    }
+                    catch
+                    {
+                        Console.WriteLine("Во входных данных присутствуют некоректные данные, исправьте их и попробуйте снова");
+                        return true;
                     }
-                    j++;
                 }
                 k++;
             }
             return false;
         }
-        public void Conclusion(double r, double[] a, double[,] b)
+        public void OutputResult(int maxF, int[] F, string[] path)
         {
-            File.AppendAllText(pathEnd, "Результат:;", Encoding.UTF8);
+            File.AppendAllText(pathEnd, "Результат:", Encoding.UTF8);
             File.AppendAllText(pathEnd, Environment.NewLine);
-            for (int i = 0; i < r; i++)
+            for (int i = 0; i < path.Length; i++)
             {
-                File.AppendAllText(pathEnd, $"x{i + 1} =;{a[i]};");
+                File.AppendAllText(pathEnd, "Путь " + (i + 1) + ";" + path[i] + ";F = ;" + F[i], Encoding.UTF8);
                 File.AppendAllText(pathEnd, Environment.NewLine);
             }
-            File.AppendAllText(pathEnd, $"F =;{Math.Round(Math.Abs(b[b.GetLength(0) - 1, b.GetLength(1) - 1]), 3)};");
+            for (int i = 0; i < path.Length; i++)
+            {
+                if(maxF == F[i])
+                {
+                    File.AppendAllText(pathEnd, "Критический путь равен " + F[i] + " дней;", Encoding.UTF8);
+                    File.AppendAllText(pathEnd, Environment.NewLine);
+                    File.AppendAllText(pathEnd, "Критический путь:;" + path[i], Encoding.UTF8);
+                    File.AppendAllText(pathEnd, Environment.NewLine);
+                }
+            }
         }
     }
 }

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

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+
+namespace Нахождение_критического_пути
+{
+    internal class Program
+    {
+        [STAThread]
+        static void Main(string[] args)
+        {
+            Decision decision = new Decision();
+            FileWork fileWork = new FileWork();
+            while (true)
+            {
+                fileWork.VvodNameFile();
+                if (fileWork.Proverka() == true)
+                {
+                    Console.ReadKey();
+                    break;
+                }
+                decision.work = fileWork.GetData();
+                decision.ShowVhodData();
+                decision.start = decision.GetStart();
+                decision.CalculatePathes();
+                decision.maxF = decision.FindCriticalPath();
+                fileWork.SaveNameFile();
+                fileWork.OutputResult(decision.maxF, decision.F, decision.path);
+                char otv; // Переменная для диалога с пользователем
+                while (true)
+                {
+                    try
+                    {
+                        Console.Write("\nПовторить программу?\nДа(Y)/Нет(N)\nОтвет: ");
+                        otv = Convert.ToChar(Console.ReadLine());
+                        break;
+                    }
+                    catch
+                    {
+                        Console.WriteLine("Введены некорректные данные!");
+                    }
+                }
+                if (!(otv.Equals('Y') || otv.Equals('y') || otv.Equals('н') || otv.Equals('Н')))
+                {
+                    break;
+                }
+                else if (!(otv.Equals('N') || otv.Equals('N') || otv.Equals('Т') || otv.Equals('т')))
+                {
+                    Console.Clear();
+                }
+            }
+        }
+    }
+}

Симлекс_метод/Симлекс_метод/Properties/AssemblyInfo.cs → Нахождение критического пути/Нахождение критического пути/Properties/AssemblyInfo.cs

@@ -5,11 +5,11 @@ using System.Runtime.InteropServices;
 // Общие сведения об этой сборке предоставляются следующим набором
 // набора атрибутов. Измените значения этих атрибутов для изменения сведений,
 // связанные с этой сборкой.
-[assembly: AssemblyTitle("Симлекс_метод")]
+[assembly: AssemblyTitle("Нахождение критического пути")]
 [assembly: AssemblyDescription("")]
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("Симлекс_метод")]
+[assembly: AssemblyProduct("Нахождение критического пути")]
 [assembly: AssemblyCopyright("Copyright ©  2022")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
@@ -20,7 +20,7 @@ using System.Runtime.InteropServices;
 [assembly: ComVisible(false)]
 
 // Следующий GUID представляет идентификатор typelib, если этот проект доступен из модели COM
-[assembly: Guid("0240fd22-c9b9-407f-a2c6-2709ee7aa9cc")]
+[assembly: Guid("a281d4a3-b352-40b7-879e-d09fd908e5e5")]
 
 // Сведения о версии сборки состоят из указанных ниже четырех значений:
 //

Нахождение критического пути/Нахождение критического пути/obj/Debug/Нахождение критического пути.csproj.CoreCompileInputs.cache

@@ -0,0 +1 @@
+7cdd9f2a5206aea1f9c7998a2ee21e7ff095b67b

Нахождение критического пути/Нахождение критического пути/obj/Debug/Нахождение критического пути.csproj.FileListAbsolute.txt

@@ -0,0 +1,8 @@
+C:\Users\Егор\Desktop\PP\Нахождение критического пути\Нахождение критического пути\bin\Debug\Нахождение критического пути.exe.config
+C:\Users\Егор\Desktop\PP\Нахождение критического пути\Нахождение критического пути\bin\Debug\Нахождение критического пути.exe
+C:\Users\Егор\Desktop\PP\Нахождение критического пути\Нахождение критического пути\bin\Debug\Нахождение критического пути.pdb
+C:\Users\Егор\Desktop\PP\Нахождение критического пути\Нахождение критического пути\obj\Debug\Нахождение критического пути.csproj.AssemblyReference.cache
+C:\Users\Егор\Desktop\PP\Нахождение критического пути\Нахождение критического пути\obj\Debug\Нахождение критического пути.csproj.SuggestedBindingRedirects.cache
+C:\Users\Егор\Desktop\PP\Нахождение критического пути\Нахождение критического пути\obj\Debug\Нахождение критического пути.csproj.CoreCompileInputs.cache
+C:\Users\Егор\Desktop\PP\Нахождение критического пути\Нахождение критического пути\obj\Debug\Нахождение критического пути.exe
+C:\Users\Егор\Desktop\PP\Нахождение критического пути\Нахождение критического пути\obj\Debug\Нахождение критического пути.pdb

Симлекс_метод/Симлекс_метод/Симлекс_метод.csproj → Нахождение критического пути/Нахождение критического пути/Нахождение критического пути.csproj

@@ -4,10 +4,10 @@
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{0240FD22-C9B9-407F-A2C6-2709EE7AA9CC}</ProjectGuid>
+    <ProjectGuid>{A281D4A3-B352-40B7-879E-D09FD908E5E5}</ProjectGuid>
     <OutputType>Exe</OutputType>
-    <RootNamespace>Симлекс_метод</RootNamespace>
-    <AssemblyName>Симлекс_метод</AssemblyName>
+    <RootNamespace>Нахождение_критического_пути</RootNamespace>
+    <AssemblyName>Нахождение критического пути</AssemblyName>
     <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
@@ -35,6 +35,7 @@
   <ItemGroup>
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
     <Reference Include="System.Windows.Forms" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
@@ -44,10 +45,10 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Decision.cs" />
     <Compile Include="FileWork.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Simplex.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />

Симлекс_метод/Симлекс_метод/Program.cs

@@ -1,78 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Windows.Forms;
-
-namespace Симлекс_метод
-{
-    internal class Program
-    {
-        [STAThread]
-        static void Main(string[] args)
-        {
-            while (true)
-            {
-                char otv;
-                FileWork fileWork = new FileWork();
-                Simplex simplex = new Simplex();
-                fileWork.VvodNameFile(); // Выбор файла, где хранятся входные данные
-                if (fileWork.Proverka() == true) // Проверка воходных данных на корректность
-                {
-                    Console.ReadKey();
-                    break;
-                }
-                simplex.main = new double[0, 0];
-                simplex.res = new double[0];
-                simplex.dohod = new double[0];
-                simplex.n = 0;
-                simplex.m = 0;
-                fileWork.GetData(ref simplex.n, ref simplex.m, ref simplex.main, ref simplex.res, ref simplex.dohod);
-                simplex.Vvod(ref simplex.dohod);
-                simplex.temp = simplex.main.GetLength(1) + 1; // Дополнительная переменная в СО
-                simplex.dop = simplex.temp; // Дополнительная переменная для вывода в граничных условиях
-                simplex.MatModel(); // Вывод математической модели
-                simplex.KanModel(); // Вывод кананической модели
-                // Сборка первой симплекс таблицы
-                simplex.Table = new double[simplex.main.GetLength(0) + 1, simplex.main.GetLength(1) + simplex.main.GetLength(0) + 1]; // Массив симплекс-таблицы
-                simplex.temp = simplex.main.GetLength(1);
-                simplex.FirstTable();
-                //Вывод промежуточных результатов
-                simplex.x = new double[0]; // Значение x в симплекс таблицах
-                simplex.intermediate(ref simplex.x, 0);
-                simplex.GetSolition(); // Нахождение всех промежуточных результатов
-                simplex.finalResults(simplex.main.GetLength(1));
-                Console.ReadKey();
-                Console.Clear();
-                fileWork.SaveNameFile(); // Выюор файла для сохранения
-                fileWork.Conclusion(simplex.main.GetLength(1), simplex.x, simplex.Table);
-                while (true)
-                {
-                    try
-                    {
-                        Console.Write("\nПовторить программу?\nДа(Y)/Нет(N)\nОтвет: ");
-                        otv = Convert.ToChar(Console.ReadLine());
-                        break;
-                    }
-                    catch
-                    {
-                        Console.WriteLine("Введены некорректные данные!");
-                    }
-                }
-                if (!(otv.Equals('Y') || otv.Equals('y') || otv.Equals('н') || otv.Equals('Н')))
-                {
-                    break;
-                }
-                else if (!(otv.Equals('N') || otv.Equals('N') || otv.Equals('Т') || otv.Equals('т')))
-                {
-                    Console.Clear();
-                }
-                else
-                {
-                    Console.Clear();
-                }
-            }
-        }
-    }
-}

Симлекс_метод/Симлекс_метод/Simplex.cs

@@ -1,341 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Симлекс_метод
-{
-    internal class Simplex
-    {
-        public double[,] main; // Расход сырья на единицу продуции
-        public double[] res; // Запасы сырья
-        public  double[] dohod; // Доход от реализации единицы продукции
-        public int n; // Количество продукции
-        public int m ; // Количество ресурсов
-        public int temp; // Дополнительная переменная в СО
-        public int dop; // Дополнительная переменная для вывода в граничных условиях
-        public double[,] Table; // Массив симплекс-таблицы
-        public double[] x; // Значение x в симплекс таблицах
-        public void Vvod(ref double[] dohod) // Ввод прибыли от продукции
-        {
-            for (int i = 0; i < dohod.Length; i++)
-            {
-                while (true)
-                {
-                    try
-                    {
-                        while (true)
-                        {
-                            Console.Write($"Введите прибыль с реалзации продукта №{i + 1}: ");
-                            double h = Convert.ToDouble(Console.ReadLine());
-                            if (h >= 0)
-                            {
-                                dohod[i] = h;
-                                break;
-                            }
-                            else
-                            {
-                                Console.WriteLine("Прибыль должна быть больше нуля\nПовторите ввод");
-                            }
-                        }
-                        break;
-                    }
-                    catch
-                    {
-                        Console.WriteLine("Необходимо ввести целое число!\nПовторите ввод");
-                    }
-                }
-            }
-        }
-        public void MatModel() // Вывод математической модели
-        {
-            Console.WriteLine("Математическая модель:");
-            Console.Write("\tF = ");
-            for (int i = 0; i < dohod.Length; i++)
-            {
-                if (i != dohod.Length - 1)
-                {
-                    Console.Write($"{dohod[i]}x{i + 1} + ");
-                }
-                else
-                {
-                    Console.Write($"{dohod[i]}x{i + 1} -> max\n");
-                }
-            }
-            for (int i = 0; i < main.GetLength(0); i++)
-            {
-                Console.Write("\t");
-                for (int j = 0; j < main.GetLength(1); j++)
-                {
-                    if (j != main.GetLength(1) - 1)
-                    {
-                        Console.Write($"{main[i, j]}x{j + 1} + ");
-                    }
-                    else
-                    {
-                        Console.Write($"{main[i, j]}x{j + 1} <= {res[i]}");
-                    }
-                }
-                Console.WriteLine();
-            }
-            Console.Write($"\tx");
-            for (int i = 0; i < main.GetLength(1); i++)
-            {
-                if (i != main.GetLength(1) - 1)
-                {
-                    Console.Write($"{i + 1},");
-                }
-                else
-                {
-                    Console.Write($"{i + 1}");
-                }
-            }
-            Console.WriteLine($" >= 0\n");
-        }
-        public void KanModel() // Вывод кананической модели
-        {
-            Console.WriteLine("Каноническая задача минимизации, составленная по условию задачи:");
-            Console.Write("\tF' = -(");
-            for (int i = 0; i < dohod.Length; i++)
-            {
-                if (i != dohod.Length - 1)
-                {
-                    Console.Write($"{dohod[i]}x{i + 1} + ");
-                }
-                else
-                {
-                    Console.Write($"{dohod[i]}x{i + 1}) -> min\n");
-                }
-            }
-            for (int i = 0; i < main.GetLength(0); i++)
-            {
-                Console.Write("\t");
-                for (int j = 0; j < main.GetLength(1); j++)
-                {
-                    if (j != main.GetLength(1) - 1)
-                    {
-                        Console.Write($"{main[i, j]}x{j + 1} + ");
-                    }
-                    else
-                    {
-                        Console.Write($"{main[i, j]}x{j + 1} + x{temp++} = {res[i]}");
-                    }
-                }
-                Console.WriteLine();
-            }
-            Console.Write($"\tx");
-            for (int i = 0; i < main.GetLength(1); i++)
-            {
-                if (i == main.GetLength(1) - 1)
-                {
-                    Console.Write($"{i + 1}");
-                }
-                else
-                {
-                    Console.Write($"{i + 1},");
-                }
-            }
-            Console.Write($" >= 0; x");
-            while (dop != temp)
-            {
-                if (dop + 1 != temp)
-                {
-                    Console.Write($"{dop},");
-                }
-                else
-                {
-                    Console.Write($"{dop}");
-                }
-                dop++;
-            }
-            Console.WriteLine(" - любое\n");
-        }
-        public void finalResults(double r) // Вывод оканчательных результатов
-        {
-            Console.WriteLine("\nОкончательные результаты:");
-            for (int i = 0; i < r; i++)
-            {
-                Console.WriteLine($"x{i + 1} = {x[i]}");
-            }
-            Console.WriteLine($"F = {Math.Round(Math.Abs(Table[Table.GetLength(0) - 1, Table.GetLength(1) - 1]), 3)}");
-        }
-        public void solve(int r, int c) // Преобразование столбца к единичному
-        {
-            double var = Table[r, c]; // Разрешающий элемент
-            for (int j = 0; j < Table.GetLength(1); j++) // Разделение строки с разрешающим элементом на разрешающий элемент
-            {
-                Table[r, j] = (double)(Table[r, j] / var);
-            }
-            double del; // Переменная для хранеия элемента в строке, которую юудем занулять
-            for (int i = 0; i < Table.GetLength(0); i++)
-            {
-                del = Table[i, c];
-                for (int j = 0; j < Table.GetLength(1); j++) // Зануляем эелемент на главном столбце
-                {
-                    if (i != r) // Если это не разрешающая строка
-                    {
-                        var = Table[r, j];
-                        var *= -del;
-                        Table[i, j] += var;
-                    }
-                }
-            }
-        }
-
-        public int decisiveRow(double[,] a, int b) // Нахождение разрешающей строки
-        {
-            double[,] a1 = new double[a.GetLength(0), a.GetLength(1)];
-            for (int i = 0; i < a1.GetLength(0); i++)
-            {
-                for (int j = 0; j < a1.GetLength(1); j++)
-                {
-                    a1[i, j] = Convert.ToDouble(a[i, j]);
-                }
-            }
-            double min = double.MaxValue;
-            int temp = 0;
-            for (int i = 0; i < a1.GetLength(0) - 1; i++)
-            {
-                if (a1[i, a1.GetLength(1) - 1] != 0 && a1[i, b] > 0)
-                {
-                    if ((a1[i, a1.GetLength(1) - 1] / a1[i, b]) < min)
-                    {
-                        min = a1[i, a1.GetLength(1) - 1] / a1[i, b];
-                        temp = i;
-                    }
-                }
-            }
-            return temp;
-        }
-
-        public int decisiveColumn(double[,] a) // Нахождение разрешающего столбца
-        {
-            double max = double.MinValue;
-            int temp = 0;
-            for (int j = 0; j < a.GetLength(1); j++)
-            {
-                if (a[a.GetLength(0) - 1, j] >= 0)
-                {
-                    if (a[a.GetLength(0) - 1, j] > max)
-                    {
-                        max = a[a.GetLength(0) - 1, j];
-                        temp = j;
-                    }
-                }
-            }
-            return temp;
-        }
-
-        public void FirstTable() // Формирование первой симплекс таблицы
-        {
-            for (int i = 0; i < main.GetLength(0); i++)
-            {
-                for (int j = 0; j < main.GetLength(1); j++)
-                {
-                    if (j != main.GetLength(1) - 1)
-                    {
-                        Table[i, j] = main[i, j];
-                    }
-                    else
-                    {
-                        Table[i, j] = main[i, j];
-                        Table[i, temp++] = 1;
-                    }
-                }
-            }
-            for (int i = 0; i < res.Length; i++) // Вывод в столбец свободных членов
-            {
-                Table[i, Table.GetLength(1) - 1] = res[i];
-            }
-            for (int i = 0; i < dohod.Length; i++) // Вывод в строку оценок
-            {
-                Table[Table.GetLength(0) - 1, i] = dohod[i];
-            }
-        }
-        public void intermediate(ref double[] b, int o) // Вывод симплекс-таблицы и промежуточных результатов
-        {
-            Array.Resize(ref b, 0);
-            if (o == 0)
-            {
-                Console.WriteLine($"\n1-ая симплекс-таблица:");
-            }
-            else
-            {
-                Console.WriteLine($"\n{o + 1}-я Симплекс-таблица:");
-            }
-            for (int i = 0; i < Table.GetLength(0); i++) // Вывод симлекс-таблицы
-            {
-                for (int j = 0; j < Table.GetLength(1); j++)
-                {
-                    Console.Write($"{Table[i, j]:f3} ");
-                }
-                Console.WriteLine();
-            }
-            Console.WriteLine("\nРезультаты таблицы:");
-            for (int j = 0; j < Table.GetLength(1) - 1; j++) // Зполнение дополниетельной переменной значениями x
-            {
-                int temp = 0; // Количество 0 в столбце
-                int temp1 = 0; // Количество 1 в столбце
-                for (int i = 0; i < Table.GetLength(0) - 1; i++) // Подсчёт количества 0 и 1 в столбце
-                {
-                    if (Table[i, j] == 0)
-                        temp++;
-                    if (Table[i, j] == 1)
-                        temp1++;
-                }
-                if (temp == Table.GetLength(0) - 2 && temp1 == 1) // Если столбец единичный
-                {
-                    for (int i = 0; i < Table.GetLength(0) - 1; i++)
-                    {
-                        if (Table[i, j] == 1)
-                        {
-                            temp = i;
-                        }
-                    }
-                    Array.Resize(ref b, b.Length + 1);
-                    b[b.Length - 1] = Math.Round(Table[temp, Table.GetLength(1) - 1],3);
-                }
-                else // Если столбец не единичный
-                {
-                    Array.Resize(ref b, b.Length + 1);
-                    b[b.Length - 1] = 0;
-                }
-            }
-            for (int i = 0; i < b.Length; i++) // Вывод значений x
-            {
-                Console.WriteLine($"x{i + 1} = {b[i]}");
-            }
-            Console.WriteLine($"F' = {Math.Round(Table[Table.GetLength(0) - 1, Table.GetLength(1) - 1], 3)}");
-            Console.WriteLine($"F = {Math.Round(Math.Abs(Table[Table.GetLength(0) - 1, Table.GetLength(1) - 1]), 3)}");
-        }
-        public void GetSolition()
-        {
-            int check = 0; // Переменная для проверки что все элементы в строке оценок < 0
-            int c, r; // Разрешающий столбец и строка
-            int o = 0;
-            while (true)
-            {
-                c = decisiveColumn(Table); // Нахождение разрешающего столбца
-                r = decisiveRow(Table, c); // Нахождение разрешающей строки
-                Console.WriteLine($"Разрешающий столбец: {c + 1}");
-                Console.WriteLine($"Разрешающая строка: {r + 1}");
-                solve(r, c); // Преобразование симплекс-таблицы
-                intermediate(ref x, o + 1); // Вывод промежуточных результатов
-                for (int j = 0; j < Table.GetLength(1) - 1; j++)
-                {
-                    if (Table[Table.GetLength(0) - 1, j] <= 0)
-                    {
-                        check++; ;
-                        break;
-                    }
-                }
-                if (check == Table.GetLength(0) - 1)
-                {
-                    break;
-                }
-                o++;
-            }
-        }
-    }
-}

Симлекс_метод/Симлекс_метод/bin/Debug/Вход.csv

@@ -1,6 +0,0 @@
-Вид сырья;Запас сырья;Расход сырья на единицу продукции вида;
-;;П1;П2
-S1;4;2;3
-S2;6;2;1
-S3;3;0;3
-S4;2;3;0

Симлекс_метод/Симлекс_метод/obj/Debug/Симлекс_метод.csproj.CoreCompileInputs.cache

@@ -1 +0,0 @@
-4de3fa2c229c47890321ab3fbfc7473bd5f7abb3

Симлекс_метод/Симлекс_метод/obj/Debug/Симлекс_метод.csproj.FileListAbsolute.txt

@@ -1,16 +0,0 @@
-C:\Users\Егор\Desktop\Подготовка к экзамену\Симлекс_метод\Симлекс_метод\bin\Debug\Симлекс_метод.exe.config
-C:\Users\Егор\Desktop\Подготовка к экзамену\Симлекс_метод\Симлекс_метод\bin\Debug\Симлекс_метод.exe
-C:\Users\Егор\Desktop\Подготовка к экзамену\Симлекс_метод\Симлекс_метод\bin\Debug\Симлекс_метод.pdb
-C:\Users\Егор\Desktop\Подготовка к экзамену\Симлекс_метод\Симлекс_метод\obj\Debug\Симлекс_метод.csproj.AssemblyReference.cache
-C:\Users\Егор\Desktop\Подготовка к экзамену\Симлекс_метод\Симлекс_метод\obj\Debug\Симлекс_метод.csproj.SuggestedBindingRedirects.cache
-C:\Users\Егор\Desktop\Подготовка к экзамену\Симлекс_метод\Симлекс_метод\obj\Debug\Симлекс_метод.csproj.CoreCompileInputs.cache
-C:\Users\Егор\Desktop\Подготовка к экзамену\Симлекс_метод\Симлекс_метод\obj\Debug\Симлекс_метод.exe
-C:\Users\Егор\Desktop\Подготовка к экзамену\Симлекс_метод\Симлекс_метод\obj\Debug\Симлекс_метод.pdb
-C:\Users\Егор\Desktop\PP\Симлекс_метод\Симлекс_метод\bin\Debug\Симлекс_метод.exe.config
-C:\Users\Егор\Desktop\PP\Симлекс_метод\Симлекс_метод\bin\Debug\Симлекс_метод.exe
-C:\Users\Егор\Desktop\PP\Симлекс_метод\Симлекс_метод\bin\Debug\Симлекс_метод.pdb
-C:\Users\Егор\Desktop\PP\Симлекс_метод\Симлекс_метод\obj\Debug\Симлекс_метод.csproj.AssemblyReference.cache
-C:\Users\Егор\Desktop\PP\Симлекс_метод\Симлекс_метод\obj\Debug\Симлекс_метод.csproj.SuggestedBindingRedirects.cache
-C:\Users\Егор\Desktop\PP\Симлекс_метод\Симлекс_метод\obj\Debug\Симлекс_метод.csproj.CoreCompileInputs.cache
-C:\Users\Егор\Desktop\PP\Симлекс_метод\Симлекс_метод\obj\Debug\Симлекс_метод.exe
-C:\Users\Егор\Desktop\PP\Симлекс_метод\Симлекс_метод\obj\Debug\Симлекс_метод.pdb