public List <List <int> > Execute(bool withSwap = false)
        {
            ResetDataset();
            ResetCapacityAndTime();

            var initialResult = new List <List <int> >();

            for (int z = 0; z < vehicleCount && !dataset.All(item => item.IsDone); z++)
            {
                initialResult.Add(greedyAlgorithm.Run(vehicleCapacity, currentVehicleCapasity, z));
            }
            var bestSolution = GRASPHelper.CopySolution(initialResult);
            var currentRoute = GRASPHelper.CopySolution(initialResult);

            int iterator = 0;

            while (iterator < Parameters.MAX_GRASP_ITERATION)
            {
                if (iterator != 0)
                {
                    ResetDataset();
                    ResetCapacityAndTime();
                    currentRoute.Clear();
                    for (int z = 0; z < vehicleCount && !dataset.All(item => item.IsDone); z++)
                    {
                        currentRoute.Add(greedyAlgorithm.Run(vehicleCapacity, currentVehicleCapasity, z));
                    }
                }

                var tmp_route = localSearchTwoOpt.Run(dataset, currentRoute, evaluator, distanceCalculator, penaltyCalculator);

                if (withSwap)
                {
                    tmp_route = GRASPHelper.CopySolution(localSearchSwap.Run(dataset, currentRoute, evaluator, distanceCalculator, penaltyCalculator));
                }

                double oldQuality     = evaluator.EvaluateGlobalRoute(dataset, bestSolution, distanceCalculator, penaltyCalculator);
                double currentQuality = evaluator.EvaluateGlobalRoute(dataset, tmp_route, distanceCalculator, penaltyCalculator);

                if (currentQuality < oldQuality)
                {
                    bestSolution = GRASPHelper.CopySolution(tmp_route);
                    currentRoute = GRASPHelper.CopySolution(tmp_route);
                }
                iterator++;
            }

            return(bestSolution);
        }
Beispiel #2
0
        public List <List <int> > Run(List <Instance> dataset, List <List <int> > currentRoute,
                                      IEvaluator evaluator, IDistanceCalculator distanceCalculator, IPenaltyCalculator penaltyCalculator)
        {
            int k = 0;

            while (k < Parameters.MAX_LOCAL_SEARCH_TWO_OPT_ITERATION)
            {
                var oldRouteBeforeLocalSearch = GRASPHelper.CopySolution(currentRoute);
                for (int g = 0; g < currentRoute.Count; g++)
                {
                    for (int i = 1; i < currentRoute[g].Count - 2; i++)
                    {
                        for (int j = i + 1; j < currentRoute[g].Count; j++)
                        {
                            double oldRouteQuality = evaluator.EvaluateRoute(dataset, currentRoute[g], distanceCalculator, penaltyCalculator);

                            var newRoute = twoOptSwap(currentRoute[g], i, j);

                            double newRouteQuality = evaluator.EvaluateRoute(dataset, newRoute, distanceCalculator, penaltyCalculator);

                            if (newRouteQuality < oldRouteQuality && evaluator.CanExistWithCurrentTimeWindows(dataset, newRoute, distanceCalculator))
                            {
                                currentRoute[g] = newRoute;
                            }
                        }
                    }
                }

                if (evaluator.isRoutesSame(currentRoute, oldRouteBeforeLocalSearch))
                {
                    break;
                }
                k++;
            }

            return(currentRoute);
        }
        public List <List <int> > Run(List <Instance> dataset, List <List <int> > currentRoute,
                                      IEvaluator evaluator, IDistanceCalculator distanceCalculator, IPenaltyCalculator penaltyCalculator)
        {
            int k = 0;

            while (k < Parameters.MAX_LOCAL_SEARCH_SWAP_ITERATION)
            {
                var    oldRouteBeforeLocalSearchCopy = GRASPHelper.CopySolution(currentRoute);
                double oldQuality = evaluator.EvaluateGlobalRoute(dataset, oldRouteBeforeLocalSearchCopy, distanceCalculator, penaltyCalculator);

                bool WasIpmroved = false;
                for (int g = 0; g < currentRoute.Count && !WasIpmroved; g++)
                {
                    if (currentRoute[g].Count <= 2)
                    {
                        continue;
                    }

                    for (int z = 0; z < currentRoute.Count && !WasIpmroved; z++)
                    {
                        if (g == z)
                        {
                            continue;
                        }

                        //current route
                        for (int i = 1; i < currentRoute[g].Count && !WasIpmroved; i++)
                        {
                            int pointFromDiffRoute = currentRoute[g][i];
                            //next route
                            for (int j = 1; j < currentRoute[z].Count && !WasIpmroved; j++)
                            {
                                var tmp_copy = GRASPHelper.CopySolution(oldRouteBeforeLocalSearchCopy);

                                tmp_copy[z].Insert(j, pointFromDiffRoute);

                                if (!evaluator.CanExistWithCurrentTimeWindows(dataset, tmp_copy[z], distanceCalculator))
                                {
                                    continue;
                                }

                                tmp_copy[g].RemoveAt(i);
                                double localQuality = evaluator.EvaluateGlobalRoute(dataset, tmp_copy, distanceCalculator, penaltyCalculator);

                                if (localQuality < oldQuality)
                                {
                                    currentRoute = tmp_copy;
                                    WasIpmroved  = true;
                                }
                            }
                        }
                    }
                }

                if (!WasIpmroved)
                {
                    break;
                }
                k++;
            }

            return(currentRoute);
        }