private static void RunAlgorithmsWithLocalSearch(IGraph graph, ISolver solver, string coordinatesPath, string resultsPath)
        {
            var edgeFinder     = new EdgeFinder();
            var graspEdgeFiner = new GraspEdgeFinder(3);

            var localSearchSolver = new TspLocalSearchSolver(graph);

            var localSearchALgorithm = new LocalSearchAlgorithm(Steps, edgeFinder);

            var generatedPaths = solver.Solve(new NearestNeighborAlgorithm(Steps, edgeFinder));

            localSearchSolver.Solve(localSearchALgorithm, generatedPaths);
            LocalSearchResultPrinter(localSearchSolver, "NN_LS", coordinatesPath, resultsPath).Print("NN with local search opt");

            generatedPaths = solver.Solve(new GreedyCycleAlgorithm(Steps, edgeFinder));
            localSearchSolver.Solve(localSearchALgorithm, generatedPaths);
            LocalSearchResultPrinter(localSearchSolver, "GC_LS", coordinatesPath, resultsPath).Print("GC with local search opt");

            generatedPaths = solver.Solve(new NearestNeighborAlgorithm(Steps, graspEdgeFiner));
            localSearchSolver.Solve(localSearchALgorithm, generatedPaths);
            LocalSearchResultPrinter(localSearchSolver, "NNG_LS", coordinatesPath, resultsPath).Print("NN Grasp with local search opt");

            generatedPaths = solver.Solve(new GreedyCycleAlgorithm(Steps, graspEdgeFiner));
            localSearchSolver.Solve(localSearchALgorithm, generatedPaths);
            LocalSearchResultPrinter(localSearchSolver, "GCG_LS", coordinatesPath, resultsPath).Print("GC GRASP with local search opt");

            generatedPaths = solver.Solve(new RandomPathAlgorithm(Steps, edgeFinder));
            localSearchSolver.Solve(localSearchALgorithm, generatedPaths);
            LocalSearchResultPrinter(localSearchSolver, "Random_LS", coordinatesPath, resultsPath).Print("RANDOM with local search opt");
        }
        public static void Main(string[] args)
        {
            var buildConfig = BuildConfiguration();
            var config      = buildConfig.GetSection(nameof(AppConfiguration));

            var dataPath         = config["data"];
            var resultPath       = config["results"];
            var graphEdges       = System.IO.Path.Combine(dataPath, config["graphEdges"]);
            var graphCoordinates = System.IO.Path.Combine(dataPath, config["graphCoordinates"]);

            var dataLoader = new GraphLoader(graphEdges, 100);
            var graph      = dataLoader.Load();

            var calculationStrategies = new ISimilarityCalculationStrategy[]
            { new EdgeSimillarityStrategy(), new NodeSimilarityStrategy() };

            var simpleSolver      = new TspSolver(graph);
            var localSearchSolver = new TspLocalSearchSolver(graph);
            var edgeFinder        = new GraspEdgeFinder(3);

            var evolutinarySolver = new EvolutionarySolver(graph,
                                                           new Recombinator(new SimilarityFinder(calculationStrategies), Steps, graph),
                                                           new Selector(), 41000);
            var localSearch = new LocalSearchAlgorithm(Steps, edgeFinder);

            var stats = new BasicSolverStatistics();

            var bestCost = int.MaxValue;
            ISolverStatistics bestStatistics = new BasicSolverStatistics();

            for (var i = 0; i < 10; i++)
            {
                var generatedPaths = simpleSolver.Solve(new RandomPathAlgorithm(Steps, edgeFinder));
                generatedPaths = localSearchSolver.Solve(localSearch, generatedPaths);

                evolutinarySolver.Solve(localSearch, generatedPaths);

                if (evolutinarySolver.SolvingStatistics.BestPath.Cost < bestCost)
                {
                    bestCost       = evolutinarySolver.SolvingStatistics.BestPath.Cost;
                    bestStatistics = evolutinarySolver.SolvingStatistics;
                }

                stats.UpdateSolvingResults(evolutinarySolver.SolvingStatistics.BestPath, evolutinarySolver.SolvingStatistics.MeanSolvingTime);
            }

            var statsPrinter = new FilePrinter(resultPath, "evo_stats.res");

            statsPrinter.Print(stats.ToString());

            var output = new StringBuilder();

            output.AppendLine($"{"Id".PadRight(4)}\tCost\tTime");
            for (var i = 0; i < bestStatistics.Costs.Count; i++)
            {
                output.AppendLine($"{i.ToString().PadRight(4)}\t{bestStatistics.Costs[i].ToString().PadRight(4)}\t{bestStatistics.SolvingTimes[i].Milliseconds:D}");
            }

            var evoResultsPrinter = new FilePrinter(resultPath, "evolutionary_results.res");

            evoResultsPrinter.Print(output.ToString());

            Console.WriteLine("Evolutionary solver ended his work!");
            //SimilaritySolver(resultPath, graph, calculationStrategies, edgeFinder);
        }
        private static void SimilaritySolver(string resultPath, IGraph graph, ISimilarityCalculationStrategy[] calculationStrategies, GraspEdgeFinder edgeFinder)
        {
            var similaritySolver = new PathSimilaritySolver(graph,
                                                            new InitializationSolver(new TspSolver(graph), new RandomPathAlgorithm(Steps, edgeFinder)),
                                                            calculationStrategies);

            similaritySolver.Solve(new LocalSearchAlgorithm(Steps, edgeFinder));

            foreach (var similairityValue in similaritySolver.SimilairityValues)
            {
                var resultString = new StringBuilder();
                var title        = similairityValue.Key;
                var filePrinter  = new FilePrinter(resultPath, $"{title.Replace(' ', '_').Replace('|', '_')}_results.res");

                resultString.AppendLine($"{nameof(SimilaritySolverResult.Cost)} {nameof(SimilaritySolverResult.SimilarityValue)}");

                foreach (var similaritySolverResult in similairityValue.Value)
                {
                    resultString.AppendLine($"{similaritySolverResult.Cost} {similaritySolverResult.SimilarityValue:F}");
                }

                resultString.AppendLine();
                filePrinter.Print(resultString.ToString());
            }

            Console.WriteLine("SUCCES!!!");
        }