Exemplo n.º 1
0
        public override Solution executeStrategy(Solution toStartFrom)
        {
            var dayArray = Enum.GetValues(typeof(Days));
            Days day = (Days)dayArray.GetValue(random.Next(1, dayArray.Length));
            if (day.Equals(Days.None))
                Console.WriteLine("Day is Days.None at RouteAddStrategy! FIX ME!");

            routeCreated = new Route(day);
            var allClusters = toStartFrom.GetAllClusters();
            int clusterIndex = random.Next(allClusters.Count);

            for (int i = 0; i < 16; i++) //64 -> 16
            {
                clusterIndex = random.Next(allClusters.Count);
                if (allClusters[clusterIndex].AvailableOrdersInCluster.Count == 0)
                    continue;

                int randomIndex = random.Next(allClusters[clusterIndex].AvailableOrdersInCluster.Count);
                Order order = allClusters[clusterIndex].AvailableOrdersInCluster[randomIndex];

                if (!routeCreated.CanAddOrder(order))
                    continue;

                routeCreated.AddOrder(order);
                order.RemoveAvailableOrderFromCluster();
            }

            if (routeCreated.Orders.Count > 1) // Does the route have orders added to it
            {
                toStartFrom.AddRoute(routeCreated);
                strategyHasExecuted = true;
            }

            return toStartFrom;
        }
        public override Solution executeStrategy(Solution toStartFrom)
        {
            Solution toReturn = toStartFrom.GetShallowCopy();

            Day randomDay = toReturn.GetDays()[random.Next(toReturn.GetDays().Length)];

            List<Route> randomRoutes = randomDay.GetRoutes(random.Next(Day.NUMBER_OF_TRUCKS));
            Route randomChosenRoute = randomRoutes[random.Next(randomRoutes.Count)];
            List<Order> orders = randomChosenRoute.Orders;

            int ordersLength = orders.Count;
            int orderIndex1 = random.Next(1, ordersLength);
            int orderIndex2 = -1;
            do
            {
                orderIndex2 = random.Next(1, ordersLength);
            } while (!(orderIndex2 >= 0 && orderIndex2 != orderIndex1));

            Order toSwitch = orders[orderIndex1];
            Order toSwitch2 = orders[orderIndex2];

            Order toAddAfter = orders[orderIndex1 - 1];
            Order toAddAfter2 = orders[orderIndex2 - 1];

            randomChosenRoute.RemoveOrder(toSwitch, toReturn.GetOrdersCounter());
            randomChosenRoute.RemoveOrder(toSwitch2, toReturn.GetOrdersCounter());
            randomChosenRoute.AddOrder(toSwitch, toAddAfter2, toReturn.GetOrdersCounter());
            randomChosenRoute.AddOrder(toSwitch, toAddAfter, toReturn.GetOrdersCounter());

            return toReturn;
        }
        public override Solution executeStrategy(Solution toStartFrom)
        {
            Planning = toStartFrom.GetRandomPlanning();
            if (Planning.Item3.Count == 0)
                return toStartFrom;

            OriginalRoute = Planning.Item3[random.Next(Planning.Item3.Count)];
            if (OriginalRoute == null || OriginalRoute.Orders.Count < 2)
                return toStartFrom;

            int orderIndex = random.Next(OriginalRoute.Orders.Count - 1);
            OrderRemoved = OriginalRoute.Orders[orderIndex];
            OrderBefore = orderIndex == 0 ? null : OriginalRoute.Orders[orderIndex - 1];
            OrderRemoved.AddAvailableOrderBackToCluster();
            OriginalRoute.RemoveOrder(OrderRemoved);

            if (OriginalRoute.Orders.Count == 1)
            { // Basically delete the route (remove it from planning)
                toStartFrom.RemoveRouteFromPlanning(Planning.Item1, Planning.Item2, OriginalRoute);
                toStartFrom.RemoveRoute(OriginalRoute);
            }

            strategyHasExecuted = true;
            return toStartFrom;
        }
Exemplo n.º 4
0
        public override Solution undoStrategy(Solution toStartFrom)
        {
            if (!strategyHasExecuted)
                return toStartFrom;

            toStartFrom.RemoveRouteFromPlanning(Planning.Item1, Planning.Item2, routePlanned);

            return toStartFrom;
        }
        public override Solution undoStrategy(Solution toStartFrom)
        {
            if (!strategyHasExecuted)
                return toStartFrom;

            toStartFrom.AddRouteToPlanning(Planning.Item1, Planning.Item2, routeDeleted);

            return toStartFrom;
        }
        public override Solution executeStrategy(Solution toStartFrom)
        {
            Planning = toStartFrom.GetRandomPlanning();
            RoutesFromSolution = Planning.Item3;

            //save the begin route for rollback
            old_route = RoutesFromSolution[random.Next(RoutesFromSolution.Count)];

            //copy the begin route for the 2-opt and create the route for the 2-opt check
            routeToWorkWith = new Route(Planning.Item1);
            new_route = new Route(Planning.Item1);
            foreach (Order order in old_route.Orders)
            {
                routeToWorkWith.AddOrder(order);
                new_route.AddOrder(order);
            }

            //start doing the opt-2 algorithm on the route list
            double best_traveltime = old_route.TravelTime;
            double new_traveltime = double.MaxValue;

            int improvestep = 0;
            while (improvestep < 50)
            {
                for (int i = 0; i < routeToWorkWith.Orders.Count - 2; i++)
                {
                    for (int k = i + 1; k < routeToWorkWith.Orders.Count - 1; k++)
                    {
                        //swap the 2 coords
                        swapOrders(routeToWorkWith.Orders[i], routeToWorkWith.Orders[k], routeToWorkWith);
                        new_traveltime = routeToWorkWith.TravelTime;
                        if (new_traveltime < best_traveltime)
                        {
                            improvestep = 0;
                            new_route = routeToWorkWith;
                            best_traveltime = new_traveltime;

                            routeToWorkWith = new Route(Planning.Item1);
                            foreach (Order order in new_route.Orders)
                                routeToWorkWith.AddOrder(order);
                        }
                    }
                }

                improvestep++;
            }

            RoutesFromSolution.Remove(old_route);
            RoutesFromSolution.Add(new_route);

            toStartFrom.RemoveItemFromPlanning(Planning.Item1, Planning.Item2);
            toStartFrom.AddNewItemToPlanning(Planning.Item1, Planning.Item2, RoutesFromSolution);

            return toStartFrom;
        }
        public override Solution undoStrategy(Solution toStartFrom)
        {
            if (!strategyHasExecuted)
                return toStartFrom;

                toStartFrom.AddRoute(old_route);
                toStartFrom.RemoveRouteFromPlanning(Planning.Item1, Planning.Item2, new_route);
                toStartFrom.AddRouteToPlanning(Planning.Item1, Planning.Item2, old_route);
                toStartFrom.RemoveRoute(new_route);

            return toStartFrom;
        }
Exemplo n.º 8
0
        public override Solution undoStrategy(Solution toStartFrom)
        {
            if (!strategyHasExecuted)
                return toStartFrom;

            foreach (Order order in routeCreated.Orders)
                order.AddAvailableOrderBackToCluster();

            toStartFrom.RemoveRoute(routeCreated);
            routeCreated.Destroy();

            return toStartFrom;
        }
        public override Solution executeStrategy(Solution toStartFrom)
        {
            Planning = toStartFrom.GetRandomPlanning();
            if (Planning.Item3.Count == 0)
                return toStartFrom;

            int routeIndex = random.Next(Planning.Item3.Count);
            routeDeleted = Planning.Item3[routeIndex];

            toStartFrom.RemoveRouteFromPlanning(Planning.Item1, Planning.Item2, routeDeleted);

            strategyHasExecuted = true;
            return toStartFrom;
        }
        public override Solution undoStrategy(Solution toStartFrom)
        {
            if (!strategyHasExecuted)
                return toStartFrom;

            Route routeRestored = new Route(dayDestroyed);
            foreach (Order order in ordersDestroyed)
            {
                routeRestored.AddOrder(order);
                order.RemoveAvailableOrderFromCluster();
            }
            toStartFrom.AddRoute(routeRestored);

            return toStartFrom;
        }
        public override Solution executeStrategy(Solution toStartFrom)
        {
            if (toStartFrom.AvailableRoutes.Count == 0)
                return toStartFrom;

            int routeIndex = random.Next(toStartFrom.AvailableRoutes.Count);
            Route routeToDestroy = toStartFrom.AvailableRoutes[routeIndex];
            toStartFrom.RemoveRoute(routeToDestroy);
            ordersDestroyed = routeToDestroy.Orders;
            dayDestroyed = routeToDestroy.Day;
            routeToDestroy.Destroy();

            strategyHasExecuted = true;
            return toStartFrom;
        }
        public override Solution undoStrategy(Solution toStartFrom)
        {
            if (!strategyHasExecuted)
                return toStartFrom;

            for (int i = 0; i < 2; i++)
                originalRoutes[i].RemoveOrder(ordersSwapped[(i + 1) % 2]);

            for (int i = 0; i < 2; i++)
                if (ordersBehindOrderMarkedForSwap[i] == null)
                    originalRoutes[i].AddOrderAtStart(ordersSwapped[i]);
                else
                    originalRoutes[i].AddOrderAt(ordersSwapped[i], ordersBehindOrderMarkedForSwap[i]);

            return toStartFrom;
        }
Exemplo n.º 13
0
        public override Solution undoStrategy(Solution toStartFrom)
        {
            if (!strategyHasExecuted)
                return toStartFrom;

            Route[] routesToSwap = new Route[2];
            for (int i = 0; i < 2; i++)
                routesToSwap[i] = Plans[i].Item3[routeIndicesSwapped[i]];

            for (int i = 0; i < 2; i++)
            {
                toStartFrom.RemoveRouteFromPlanning(Plans[i].Item1, Plans[i].Item2, routesToSwap[i]);
                toStartFrom.AddRouteToPlanning(Plans[(i + 1) % 2].Item1, Plans[(i + 1) % 2].Item2, routesToSwap[i]);
            }

            return toStartFrom;
        }
        public override Solution executeStrategy(Solution toStartFrom)
        {
            Planning = toStartFrom.GetRandomPlanning();
            if (Planning.Item3.Count == 0)
                return toStartFrom;

            Route routeToDestroy = Planning.Item3[random.Next(Planning.Item3.Count)];
            ordersDestroyed = routeToDestroy.Orders;
            dayDestroyed = routeToDestroy.Day;

            toStartFrom.RemoveRouteFromPlanning(Planning.Item1, Planning.Item2, routeToDestroy);
            toStartFrom.RemoveRoute(routeToDestroy);
            routeToDestroy.Destroy();

            strategyHasExecuted = true;
            return toStartFrom;
        }
        public override Solution executeStrategy(Solution toStartFrom)
        {
            Plans[0] = toStartFrom.GetRandomPlanning();
            Plans[1] = toStartFrom.GetRandomPlanning();

            if (Plans[0].Item3.Count == 0 || Plans[1].Item3.Count == 0 || Plans[0].Item1 != Plans[1].Item1 || (Plans[0].Equals(Plans[1]) && Plans[0].Item3.Count < 2))
                return toStartFrom;

            for (int i = 0; i < 2; i++)
            {
                originalRoutes[i] = Plans[i].Item3[random.Next(Plans[i].Item3.Count)];
                if (originalRoutes[i].Orders.Count < 2 || (i == 1 && originalRoutes[0].Equals(originalRoutes[1])))
                    return toStartFrom;

                int swapOrderIndex = random.Next(originalRoutes[i].Orders.Count - 1);
                ordersSwapped[i] = originalRoutes[i].Orders[swapOrderIndex];
                ordersBehindOrderMarkedForSwap[i] = swapOrderIndex == 0 ? null : originalRoutes[i].Orders[swapOrderIndex - 1];
            }

            for (int i = 0; i < 2; i++)
            {
                double timeLimit = 0.0d; // Check if route can be swapped traveltime-wise
                foreach (Route route in Plans[i].Item3)
                    if (route != originalRoutes[i])
                        timeLimit += route.TravelTime;

                timeLimit = 43200.0d - timeLimit;

                if (!originalRoutes[i].CanSwapOrderFromDifferentRoutes(ordersSwapped[(i + 1) % 2], ordersSwapped[i], timeLimit))
                    return toStartFrom; // if a route could not be swapped...
            }

            for (int i = 0; i < 2; i++)
                originalRoutes[i].RemoveOrder(ordersSwapped[i]);

            for (int i = 0; i < 2; i++)
                if (ordersBehindOrderMarkedForSwap[i] == null)
                    originalRoutes[i].AddOrderAtStart(ordersSwapped[(i + 1) % 2]);
                else
                    originalRoutes[i].AddOrderAt(ordersSwapped[(i + 1) % 2], ordersBehindOrderMarkedForSwap[i]);

            strategyHasExecuted = true;
            return toStartFrom;
        }
        public override Solution executeStrategy(Solution toStartFrom)
        {
            Plans[0] = toStartFrom.GetRandomPlanning();
            Plans[1] = toStartFrom.GetRandomPlanning();

            if (Plans[0].Item3.Count == 0 || Plans[1].Item3.Count == 0 || (Plans[0].Equals(Plans[1]) && Plans[0].Item3.Count < 2))
                return toStartFrom;

            for (int i = 0; i < 2; i++)
            {
                originalRoutes[i] = Plans[i].Item3[random.Next(Plans[i].Item3.Count)];
                if (originalRoutes[i].Orders.Count < 2 || (i == 1 && originalRoutes[0].Equals(originalRoutes[1])))
                    return toStartFrom;

                int shiftOrderIndex = random.Next(originalRoutes[i].Orders.Count - 1);
                ordersShifted[i] = originalRoutes[i].Orders[shiftOrderIndex];

                if (i == 0)
                    orderInFrontOfTheShiftedOrder = shiftOrderIndex == 0 ? null : originalRoutes[0].Orders[shiftOrderIndex - 1];
            }

            double timeLimit = 0.0d; // Check if route can be swapped traveltime-wise
            foreach (Route route in Plans[1].Item3)
                if (route != originalRoutes[1])
                    timeLimit += route.TravelTime;

            timeLimit = 43200.0d - timeLimit;

            if (originalRoutes[1].CanAddOrderAfter(ordersShifted[0], ordersShifted[1], timeLimit)) // Check if can be shifted
            {
                originalRoutes[0].RemoveOrder(ordersShifted[0]);
                originalRoutes[1].AddOrderAt(ordersShifted[0], ordersShifted[1]);
                strategyHasExecuted = true;

                if (originalRoutes[0].Orders.Count == 1) // if route has only 0order (because other order has been shifted away...)
                {
                    toStartFrom.RemoveRouteFromPlanning(Plans[0].Item1, Plans[0].Item2, originalRoutes[0]);
                    toStartFrom.RemoveRoute(originalRoutes[0]);
                }
            }

            return toStartFrom;
        }
        public override Solution undoStrategy(Solution toStartFrom)
        {
            if (!strategyHasExecuted)
                return toStartFrom;

            if (OriginalRoute.Orders.Count == 1)
            { // If empty
                toStartFrom.AddRoute(OriginalRoute);
                toStartFrom.AddRouteToPlanning(Planning.Item1, Planning.Item2, OriginalRoute);
            }

            OrderRemoved.RemoveAvailableOrderFromCluster();
            if (OrderBefore == null)
                OriginalRoute.AddOrderAtStart(OrderRemoved);
            else
                OriginalRoute.AddOrderAt(OrderRemoved, OrderBefore);

            return toStartFrom;
        }
        public override Solution undoStrategy(Solution toStartFrom)
        {
            if (!strategyHasExecuted)
                return toStartFrom;

            originalRoutes[1].RemoveOrder(ordersShifted[0]);

            if (originalRoutes[0].Orders.Count == 1) // if route has only 0order (because other order has been shifted away and the route has been deleted)
            {
                toStartFrom.AddRoute(originalRoutes[0]);
                toStartFrom.AddRouteToPlanning(Plans[0].Item1, Plans[0].Item2, originalRoutes[0]);
            }

            if (orderInFrontOfTheShiftedOrder != null)
                originalRoutes[0].AddOrderAt(ordersShifted[0], orderInFrontOfTheShiftedOrder);
            else
                originalRoutes[0].AddOrderAtStart(ordersShifted[0]);

            return toStartFrom;
        }
Exemplo n.º 19
0
        public override Solution executeStrategy(Solution toStartFrom)
        {
            if (toStartFrom.AvailableRoutes.Count == 0)
                return toStartFrom; // No routes to plan

            Planning = toStartFrom.GetRandomPlanning();
            routePlanned = toStartFrom.AvailableRoutes[random.Next(toStartFrom.AvailableRoutes.Count)];

            double totalTravelTime = 0.0d;
            foreach (Route route in Planning.Item3)
                totalTravelTime += route.TravelTime;

            if (routePlanned.Day != Planning.Item1 || totalTravelTime + routePlanned.TravelTime > 43200.0d)
                return toStartFrom;

            toStartFrom.AddRouteToPlanning(Planning.Item1, Planning.Item2, routePlanned);
            strategyHasExecuted = true;

            return toStartFrom;
        }
        public override Solution executeStrategy(Solution toStartFrom)
        {
            Planning = toStartFrom.GetRandomPlanning();
            if (Planning.Item3.Count == 0)
                return toStartFrom;

            old_route = Planning.Item3[random.Next(Planning.Item3.Count)];
            if (old_route == null || old_route.Orders.Count < 4)
                return toStartFrom; // Could not find a valid route to shuffle

            new_route = new Route(Planning.Item1);
            foreach (Order order in old_route.Orders)
                new_route.AddOrder(order);

            int firstIndex = random.Next(old_route.Orders.Count - 1);
            int secondIndex = random.Next(old_route.Orders.Count - 1);
            int thirdIndex = random.Next(old_route.Orders.Count - 1);

            while (firstIndex == secondIndex || firstIndex == thirdIndex || secondIndex == thirdIndex)
                return toStartFrom;

            double timeLimit = 0.0d; // Check if route can be swapped traveltime-wise
            foreach (Route route in Planning.Item3)
                if (route != old_route)
                    timeLimit += route.TravelTime;

            timeLimit = 43200.0d - timeLimit;

            if (new_route.CanHalfSwapOrder(old_route.Orders[firstIndex], old_route.Orders[thirdIndex], old_route.Orders[thirdIndex], timeLimit))
            {
                new_route.HalfSwapOrders(old_route.Orders[firstIndex], old_route.Orders[thirdIndex], old_route.Orders[thirdIndex]);
                toStartFrom.AddRoute(new_route);
                toStartFrom.RemoveRouteFromPlanning(Planning.Item1, Planning.Item2, old_route);
                toStartFrom.AddRouteToPlanning(Planning.Item1, Planning.Item2, new_route);
                toStartFrom.RemoveRoute(old_route);

                strategyHasExecuted = true;
            }

            return toStartFrom;
        }
Exemplo n.º 21
0
        public override Solution executeStrategy(Solution toStartFrom)
        {
            for (int i = 0; i < 2; i++)
            {
                Plans[i] = toStartFrom.GetRandomPlanning();
                if (Plans[i].Item3.Count == 0 || (i == 1 && Plans[0].Item1 != Plans[1].Item1)) // Make sure it has routes to swap and is on the same day
                    return toStartFrom;

                routeIndicesSwapped[i] = random.Next(Plans[i].Item3.Count);
                if (i == 1 && routeIndicesSwapped[0] == routeIndicesSwapped[1])
                    return toStartFrom;
            }

            Route[] routesToSwap = new Route[2];
            for (int i = 0; i < 2; i++)
                routesToSwap[i] = Plans[i].Item3[routeIndicesSwapped[i]];

            for (int i = 0; i < 2; i++) // Check if route can be swapped traveltime-wise
            {
                double tempTT = 0.0d;
                foreach (Route route in Plans[i].Item3)
                    if(route != routesToSwap[i])
                        tempTT += route.TravelTime;

                tempTT += routesToSwap[(i + 1) % 2].TravelTime;

                if (tempTT > 43200.0d)
                    return toStartFrom;
            }

            for (int i = 0; i < 2; i++)
            {
                toStartFrom.RemoveRouteFromPlanning(Plans[i].Item1, Plans[i].Item2, routesToSwap[i]);
                toStartFrom.AddRouteToPlanning(Plans[(i + 1) % 2].Item1, Plans[(i + 1) % 2].Item2, routesToSwap[i]);
            }

            strategyHasExecuted = true;
            return toStartFrom;
        }
        public override Solution undoStrategy(Solution toStartFrom)
        {
            // Revert abomination to Patient Zero...
            toStartFrom.RemoveRouteFromPlanning(planningForSelectedRoute.Item1, planningForSelectedRoute.Item2, bestAbominationOffspringRoute);
            toStartFrom.AddRouteToPlanning(planningForSelectedRoute.Item1, planningForSelectedRoute.Item2, originalRoute);

            return toStartFrom;
        }
        public override Solution executeStrategy(Solution toStartFrom)
        {
            planningForSelectedRoute = toStartFrom.GetRandomPlanning();
            originalRoute = planningForSelectedRoute.Item3[random.Next(planningForSelectedRoute.Item3.Count)];
            double originalTravelTime = originalRoute.TravelTime;
            int numOfSlices = random.Next(1, originalRoute.Orders.Count - 2);

            List<int> sliceIndices = new List<int>();
            for (int i = 1; i < numOfSlices; i++)
            {
                bool hasAddedAnIndex = false;
                do
                {
                    int sliceIndex = random.Next(1, numOfSlices);
                    if (!sliceIndices.Contains(sliceIndex))
                    {
                        sliceIndices.Add(sliceIndex);
                        hasAddedAnIndex = true;
                    }
                } while (!hasAddedAnIndex);
            }
            sliceIndices.Sort();

            // COMMENCE THE GENETIC EXPERIMENTS!
            // OPERATION SLICE & SPLICE AN ABOMINATION IS ACTIVE!

            List<Order>[] orderSlices = new List<Order>[sliceIndices.Count];
            for (int i = 0; i < sliceIndices.Count; i++)
            {
                orderSlices[i] = new List<Order>();
                int startIndex = i == 0 ? 0 : sliceIndices[i - 1];

                for (int j = startIndex; j < sliceIndices[i]; j++)
                    orderSlices[i].Add(originalRoute.Orders[j]);
            }

            // Now that you've sliced up the orders in the selected route, it is time for randomizing the slices and putting it back together

            Route firstAbominationRoute = new Route(originalRoute.Day);
            List<int> slicesIndexPutBack = new List<int>();
            for (int i = 0; i < orderSlices.Length - 2; i++)
            {
                bool hasPutBackASlice = false;
                do
                {
                    int sliceIndex = random.Next(1, orderSlices.Length - 1);
                    if (!slicesIndexPutBack.Contains(sliceIndex))
                    {
                        for (int j = 0; j < orderSlices[sliceIndex].Count; j++)
                            if (orderSlices[sliceIndex][j].OrderNumber != 0)
                                firstAbominationRoute.AddOrder(orderSlices[sliceIndex][j]);

                        slicesIndexPutBack.Add(sliceIndex);
                        hasPutBackASlice = true;
                    }
                } while (!hasPutBackASlice);
            }

            // COMMENCE THE GENETIC EXPERIMENTS PHASE TWO!
            // OPERATION DARWIN'S ABOMINATION REPRODUCTION IS NOW OPERATIONAL!

            Route bestBoyAbominationOffspring = originalRoute;
            Route bestGirlAbominationOffspring = firstAbominationRoute;
            Boolean boyAbominationIsTheBest = bestBoyAbominationOffspring.TravelTime >= bestGirlAbominationOffspring.TravelTime;
            int numberOfGenesThatAreTransferred = originalRoute.Orders.Count / 2;
            List<Order> ordersSelectedForGeneticSwap = new List<Order>();

            for (int numOfGenerationsToMake = 64; numOfGenerationsToMake > 0; numOfGenerationsToMake--)
            {
                ordersSelectedForGeneticSwap.Clear();

                int orderIndex = -1;
                do
                {
                    orderIndex = random.Next(orderSlices.Length - 1); // What?
                    Order randomOrder = null;

                    if (boyAbominationIsTheBest)
                        randomOrder = bestBoyAbominationOffspring.Orders[orderIndex];
                    else
                        randomOrder = bestGirlAbominationOffspring.Orders[orderIndex];

                    if (ordersSelectedForGeneticSwap.Contains(randomOrder))
                        continue;

                    ordersSelectedForGeneticSwap.Add(randomOrder);

                } while (ordersSelectedForGeneticSwap.Count * 2 < numberOfGenesThatAreTransferred - 1);

                List<int> indicesToBeSwaped = new List<int>(); // Change into a array [2], to keep track which index belongs where
                foreach (Order order in ordersSelectedForGeneticSwap)
                {
                    indicesToBeSwaped.Add(bestBoyAbominationOffspring.Orders.FindIndex(o => o == order));
                    indicesToBeSwaped.Add(bestGirlAbominationOffspring.Orders.FindIndex(o => o == order));
                }
                indicesToBeSwaped.Sort();

                Route newBoyAbominationOffspring = new Route(originalRoute.Day);
                Route newGirlAbominationOffspring = new Route(originalRoute.Day);

                for (int index = 0; index < originalRoute.Orders.Count - 1; index++)
                {
                    if (indicesToBeSwaped.Contains(index)) // Erm.. What?
                    {
                        newBoyAbominationOffspring.AddOrder(bestGirlAbominationOffspring.Orders[index]);
                        newGirlAbominationOffspring.AddOrder(bestBoyAbominationOffspring.Orders[index]);
                    }
                    else
                    {
                        newBoyAbominationOffspring.AddOrder(bestBoyAbominationOffspring.Orders[index]);
                        newGirlAbominationOffspring.AddOrder(bestGirlAbominationOffspring.Orders[index]);
                    }
                }

                if (newBoyAbominationOffspring.isValid() && !newGirlAbominationOffspring.isValid()) // One is allowed
                    if (bestBoyAbominationOffspring.TravelTime < bestGirlAbominationOffspring.TravelTime)
                        bestGirlAbominationOffspring = newBoyAbominationOffspring;
                    else
                        bestBoyAbominationOffspring = newBoyAbominationOffspring;
                else if (!newBoyAbominationOffspring.isValid() && newGirlAbominationOffspring.isValid()) // Other one allowed
                    if (bestBoyAbominationOffspring.TravelTime < bestGirlAbominationOffspring.TravelTime)
                        bestGirlAbominationOffspring = newGirlAbominationOffspring;
                    else
                        bestBoyAbominationOffspring = newGirlAbominationOffspring;
                else if (!newBoyAbominationOffspring.isValid() && !newGirlAbominationOffspring.isValid()) // Neither is allowed
                {
                    numOfGenerationsToMake--;
                    continue;
                }

                bool newGirlAbominationOffspringIstheBest = newBoyAbominationOffspring.TravelTime <= newGirlAbominationOffspring.TravelTime;
                if (boyAbominationIsTheBest)
                {
                    if (newGirlAbominationOffspringIstheBest)
                    {
                        if (bestGirlAbominationOffspring.TravelTime < newGirlAbominationOffspring.TravelTime)
                        {
                            bestGirlAbominationOffspring = newGirlAbominationOffspring;

                            if (bestBoyAbominationOffspring.TravelTime < newBoyAbominationOffspring.TravelTime)
                            {
                                bestBoyAbominationOffspring = newBoyAbominationOffspring;
                            }
                        }
                    }
                    else
                    {
                        if (bestGirlAbominationOffspring.TravelTime < newBoyAbominationOffspring.TravelTime)
                        {
                            bestGirlAbominationOffspring = newBoyAbominationOffspring;

                            if (bestBoyAbominationOffspring.TravelTime < newGirlAbominationOffspring.TravelTime)
                            {
                                bestBoyAbominationOffspring = newGirlAbominationOffspring;
                            }
                        }
                    }
                }
                else
                {
                    if (newGirlAbominationOffspringIstheBest)
                    {
                        if (bestBoyAbominationOffspring.TravelTime < newGirlAbominationOffspring.TravelTime)
                        {
                            bestBoyAbominationOffspring = newGirlAbominationOffspring;

                            if (bestGirlAbominationOffspring.TravelTime < newBoyAbominationOffspring.TravelTime)
                            {
                                bestGirlAbominationOffspring = newBoyAbominationOffspring;
                            }
                        }
                    }
                    else
                    {
                        if (bestBoyAbominationOffspring.TravelTime < newBoyAbominationOffspring.TravelTime)
                        {
                            bestBoyAbominationOffspring = newBoyAbominationOffspring;

                            if (bestGirlAbominationOffspring.TravelTime < newGirlAbominationOffspring.TravelTime)
                            {
                                bestGirlAbominationOffspring = newGirlAbominationOffspring;
                            }
                        }
                    }
                }

                boyAbominationIsTheBest = bestBoyAbominationOffspring.TravelTime >= bestGirlAbominationOffspring.TravelTime;
                numOfGenerationsToMake--;
            }

            // PHASE 3 - INSERT THE ABOMINATION INTO THE PUBLIC!

            bestAbominationOffspringRoute = boyAbominationIsTheBest ? bestBoyAbominationOffspring : bestGirlAbominationOffspring;

            Console.WriteLine("Original Travel Time:                     {0}", originalTravelTime); // These three lines are temporarily here
            Console.WriteLine("The First Abomination Travel Time:        {0}", firstAbominationRoute.TravelTime);
            Console.WriteLine("Best Abomination Offspring Travel Time:   {0}", bestAbominationOffspringRoute.TravelTime);

            toStartFrom.RemoveRouteFromPlanning(planningForSelectedRoute.Item1, planningForSelectedRoute.Item2, originalRoute);
            toStartFrom.AddRouteToPlanning(planningForSelectedRoute.Item1, planningForSelectedRoute.Item2, bestAbominationOffspringRoute);

            return toStartFrom;
        }
        public override Solution executeStrategy(Solution toStartFrom)
        {
            planningForSelectedRoute = toStartFrom.GetRandomPlanning();
            firstOriginalRoute = planningForSelectedRoute.Item3[random.Next(planningForSelectedRoute.Item3.Count)];
            secondOriginalRoute = planningForSelectedRoute.Item3[random.Next(planningForSelectedRoute.Item3.Count)];

            for (int index = 0; index < 5 && firstOriginalRoute != secondOriginalRoute; index++)
                secondOriginalRoute = planningForSelectedRoute.Item3[random.Next(planningForSelectedRoute.Item3.Count)];

            double firstOriginalTravelTime = firstOriginalRoute.TravelTime;
            double secondOriginalTravelTime = secondOriginalRoute.TravelTime;
            int[] numOfSlices = new int[2] {random.Next(1, firstOriginalRoute.Orders.Count - 2), random.Next(1, secondOriginalRoute.Orders.Count - 2)};
            List<int>[] sliceIndices = new List<int>[2];

            for (int i = 0; i < sliceIndices.Length; i++)
            {
                sliceIndices[i] = new List<int>();
                for (int j = 0; j < numOfSlices[i]; j++)
                {
                    bool hasAddedAnIndex = false;
                    do
                    {
                        int sliceIndex = random.Next(1, numOfSlices[i]);
                        if (!sliceIndices[i].Contains(sliceIndex))
                        {
                            sliceIndices[i].Add(sliceIndex);
                            hasAddedAnIndex = true;
                        }
                    } while (!hasAddedAnIndex);
                }

                sliceIndices[i].Sort();
            }

            // COMMENCE THE GENETIC EXPERIMENTS!
            // OPERATION SLICE & SPLICE AN ABOMINATION IS ACTIVE!

            List<Order>[][] orderSlices = new List<Order>[sliceIndices.Length][];
            for (int index = 0; index < sliceIndices.Length; index++)
            {
                orderSlices[index] = new List<Order>[sliceIndices[index].Count];
                for (int i = 0; i < sliceIndices[index].Count; i++)
                {
                    orderSlices[index][i] = new List<Order>();
                    int startIndex = i == 0 ? 0 : sliceIndices[index][i - 1];

                    for (int j = startIndex; j < sliceIndices[index][i]; j++)
                        if(index == 0)
                            orderSlices[0][i].Add(firstOriginalRoute.Orders[j]);
                        else
                            orderSlices[1][i].Add(secondOriginalRoute.Orders[j]);
                }
            }

            // Now that you've sliced up the orders in the selected route, it is time for randomizing the slices and putting it back together

            firstAbominationRoute = new Route(planningForSelectedRoute.Item1);
            secondAbominationRoute = new Route(planningForSelectedRoute.Item1);
            List<int>[] slicesIndexPutBack = new List<int>[2];
            for (int index = 0; index < sliceIndices.Length; index++)
            {
                slicesIndexPutBack[index] = new List<int>();
                for (int i = 0; i < orderSlices[index].Length - 2; i++)
                {
                    bool hasPutBackASlice = false;
                    do
                    {
                        int sliceIndex = random.Next(1, orderSlices[index].Length - 1);
                        if (!slicesIndexPutBack[index].Contains(sliceIndex))
                        {
                            for (int j = 0; j < orderSlices[index][sliceIndex].Count; j++)
                                if (orderSlices[index][sliceIndex][j].OrderNumber != 0)

                                    if (index == 0)
                                        firstAbominationRoute.AddOrder(orderSlices[index][sliceIndex][j]);
                                    else
                                        secondAbominationRoute.AddOrder(orderSlices[index][sliceIndex][j]);

                            slicesIndexPutBack[index].Add(sliceIndex);
                            hasPutBackASlice = true;
                        }
                    } while (!hasPutBackASlice);
                }
            }

            // COMMENCE THE GENETIC EXPERIMENTS PHASE TWO!
            // OPERATION DARWIN'S ABOMINATION REPRODUCTION IS NOW OPERATIONAL!

            int numOfGenerationsToMake = 64;
            Route bestBoyAbominationOffspring = firstAbominationRoute;
            Route bestGirlAbominationOffspring = secondAbominationRoute;
            int[] numberOfGenesThatAreTransferred = new int[2] { random.Next(firstAbominationRoute.Orders.Count / 4, // 25%
                                                                    firstAbominationRoute.Orders.Count / 2), // 50%
                                                                random.Next(secondAbominationRoute.Orders.Count / 4, // 25%
                                                                    secondAbominationRoute.Orders.Count / 2)}; // 50%

            List<Order>[] ordersSelectedForGeneticSwap = new List<Order>[2] { new List<Order>(), new List<Order>() };

            while (numOfGenerationsToMake > 0)
            {
                for (int i = 0; i < 2; i++)
                {
                    ordersSelectedForGeneticSwap[i].Clear();

                    int orderIndex = -1;
                    do
                    {
                        orderIndex = random.Next(orderSlices[i].Length - 1);
                        Order randomOrder = null;

                        if (i == 0)
                            randomOrder = bestBoyAbominationOffspring.Orders[orderIndex];
                        else
                            randomOrder = bestGirlAbominationOffspring.Orders[orderIndex];

                        if (ordersSelectedForGeneticSwap[i].Contains(randomOrder))
                            continue;

                        ordersSelectedForGeneticSwap[i].Add(randomOrder);

                    } while (ordersSelectedForGeneticSwap[i].Count * 2 < numberOfGenesThatAreTransferred[i] - 1);

                    List<int> indicesToBeSwaped = new List<int>(); // FIX MEE
                    foreach (Order order in ordersSelectedForGeneticSwap[i]) // TODO, not (exclusive) simularities, but just 'random' orders
                    {
                        indicesToBeSwaped.Add(bestBoyAbominationOffspring.Orders.FindIndex(o => o == order));
                        indicesToBeSwaped.Add(bestGirlAbominationOffspring.Orders.FindIndex(o => o == order));
                    }
                    indicesToBeSwaped.Sort();

                Route newBoyAbominationOffspring = new Route(planningForSelectedRoute.Item1);
                Route newGirlAbominationOffspring = new Route(planningForSelectedRoute.Item1);

                for (int index = 0; index < firstOriginalRoute.Orders.Count - 1; index++) // FIX MEE TOOO!!
                {
                    if (indicesToBeSwaped.Contains(index))
                    {
                        newBoyAbominationOffspring.AddOrder(bestGirlAbominationOffspring.Orders[index]);
                        newGirlAbominationOffspring.AddOrder(bestBoyAbominationOffspring.Orders[index]);
                    }
                    else
                    {
                        newBoyAbominationOffspring.AddOrder(bestBoyAbominationOffspring.Orders[index]);
                        newGirlAbominationOffspring.AddOrder(bestGirlAbominationOffspring.Orders[index]);
                    }
                }

                Boolean newGirlAbominationOffspringIstheBest = newBoyAbominationOffspring.TravelTime <= newGirlAbominationOffspring.TravelTime;
                if (true) // if (boyAbominationIsTheBest) Find alternative!
                {
                    if (newGirlAbominationOffspringIstheBest)
                    {
                        if (bestGirlAbominationOffspring.TravelTime < newGirlAbominationOffspring.TravelTime)
                        {
                            bestGirlAbominationOffspring = newGirlAbominationOffspring;

                            if (bestBoyAbominationOffspring.TravelTime < newBoyAbominationOffspring.TravelTime)
                            {
                                bestBoyAbominationOffspring = newBoyAbominationOffspring;
                            }
                        }
                    }
                    else
                    {
                        if (bestGirlAbominationOffspring.TravelTime < newBoyAbominationOffspring.TravelTime)
                        {
                            bestGirlAbominationOffspring = newBoyAbominationOffspring;

                            if (bestBoyAbominationOffspring.TravelTime < newGirlAbominationOffspring.TravelTime)
                            {
                                bestBoyAbominationOffspring = newGirlAbominationOffspring;
                            }
                        }
                    }
                }
                else
                {
                    if (newGirlAbominationOffspringIstheBest)
                    {
                        if (bestBoyAbominationOffspring.TravelTime < newGirlAbominationOffspring.TravelTime)
                        {
                            bestBoyAbominationOffspring = newGirlAbominationOffspring;

                            if (bestGirlAbominationOffspring.TravelTime < newBoyAbominationOffspring.TravelTime)
                            {
                                bestGirlAbominationOffspring = newBoyAbominationOffspring;
                            }
                        }
                    }
                    else
                    {
                        if (bestBoyAbominationOffspring.TravelTime < newBoyAbominationOffspring.TravelTime)
                        {
                            bestBoyAbominationOffspring = newBoyAbominationOffspring;

                            if (bestGirlAbominationOffspring.TravelTime < newGirlAbominationOffspring.TravelTime)
                            {
                                bestGirlAbominationOffspring = newGirlAbominationOffspring;
                            }
                        }
                    }
                }
                }

                numOfGenerationsToMake--;
            }

            // PHASE 3 - INSERT THE ABOMINATION INTO THE PUBLIC!

            firstBestAbominationOffspringRoute = bestBoyAbominationOffspring;
            secondBestAbominationOffspringRoute = bestGirlAbominationOffspring;
            // secondBest?

            Console.WriteLine("First Route: Original Travel Time:                     {0}", firstOriginalTravelTime); // NEEDS FIXING
            Console.WriteLine("First Route: The First Abomination Travel Time:        {0}", firstAbominationRoute.TravelTime); // NEEDS FIXING
            Console.WriteLine("First Route: Best Abomination Offspring Travel Time:   {0}", firstBestAbominationOffspringRoute.TravelTime); // NEEDS FIXING

            Console.WriteLine("Second Route: Original Travel Time:                     {0}", secondOriginalTravelTime); // NEEDS FIXING
            Console.WriteLine("Second Route: The First Abomination Travel Time:        {0}", secondAbominationRoute.TravelTime); // NEEDS FIXING
            Console.WriteLine("Second Route: Best Abomination Offspring Travel Time:   {0}", secondBestAbominationOffspringRoute.TravelTime); // NEEDS FIXING

            planningForSelectedRoute.Item3.Remove(firstOriginalRoute); // NEEDS FIXING?
            planningForSelectedRoute.Item3.Add(firstBestAbominationOffspringRoute); // NEEDS FIXING?
            planningForSelectedRoute.Item3.Remove(secondOriginalRoute); // NEEDS FIXING?
            planningForSelectedRoute.Item3.Add(secondBestAbominationOffspringRoute); // NEEDS FIXING?

            toStartFrom.RemoveItemFromPlanning(planningForSelectedRoute.Item1, planningForSelectedRoute.Item2); // NEEDS FIXING
            toStartFrom.AddNewItemToPlanning(planningForSelectedRoute.Item1, planningForSelectedRoute.Item2, planningForSelectedRoute.Item3); // NEEDS FIXING

            return toStartFrom;
        }
        public override Solution undoStrategy(Solution toStartFrom)
        {
            // Revert abomination to Patient Zero...
            planningForSelectedRoute.Item3.Remove(firstBestAbominationOffspringRoute); // NEEDS FIXING
            planningForSelectedRoute.Item3.Add(firstOriginalRoute); // NEEDS FIXING

            toStartFrom.RemoveItemFromPlanning(planningForSelectedRoute.Item1, planningForSelectedRoute.Item2); // NEEDS FIXING
            toStartFrom.AddNewItemToPlanning(planningForSelectedRoute.Item1, planningForSelectedRoute.Item2, planningForSelectedRoute.Item3); // NEEDS FIXING

            return toStartFrom;
        }
        public override Solution undoStrategy(Solution toStartFrom)
        {
            // Nette manier zou zijn om de tuple weer op te halen gebaseerd op Planning.Item2 en dag.
            RoutesFromSolution.Remove(new_route);
            RoutesFromSolution.Add(old_route);

            toStartFrom.RemoveItemFromPlanning(Planning.Item1, Planning.Item2);
            toStartFrom.AddNewItemToPlanning(Planning.Item1, Planning.Item2, RoutesFromSolution);

            return toStartFrom;
        }
        public override Solution executeStrategy(Solution toStartFrom)
        {
            Planning = toStartFrom.GetRandomPlanning();
            RoutesFromSolution = Planning.Item3;

            //save the begin route for rollback
            old_route = RoutesFromSolution[random.Next(RoutesFromSolution.Count)];

            //copy the begin route for the 2-opt and create the route for the 2-opt check
            for (int i = 0; i < routesToWorkWith.Length; i++)
                routesToWorkWith[i] = new Route(Planning.Item1);

            new_route = new Route(Planning.Item1);
            foreach (Order order in old_route.Orders)
            {
                for (int i = 0; i < routesToWorkWith.Length; i++)
                    routesToWorkWith[i].AddOrder(order);

                new_route.AddOrder(order);
            }

            //start doing the opt-3 algorithm on the route list
            double best_traveltime = old_route.TravelTime;
            double[] new_traveltime = new double[NumberOfRoutesCreated];
            for (int i = 0; i < new_traveltime.Length; i++)
                new_traveltime[i] = double.MaxValue;

            int improvestep = 0;
            while (improvestep < 10)
            {
                for (int i = 0; i < old_route.Orders.Count - 3; i++)
                {
                    for (int j = i + 1; j < old_route.Orders.Count - 2; j++)
                    {
                        for (int k = j + 1; k < old_route.Orders.Count - 1; k++)
                        {
                            //swap the 2 coords
                            Order[] initialRouteI = new Order[NumberOfRoutesCreated];
                            for (int index = 0; index < initialRouteI.Length; index++)
                                initialRouteI[index] = routesToWorkWith[index].Orders[i];

                            Order[] initialRouteJ = new Order[NumberOfRoutesCreated];
                            for (int index = 0; index < initialRouteJ.Length; index++)
                                initialRouteJ[index] = routesToWorkWith[index].Orders[j];

                            Order[] initialRouteK = new Order[NumberOfRoutesCreated];
                            for (int index = 0; index < initialRouteK.Length; index++)
                                initialRouteK[index] = routesToWorkWith[index].Orders[k];

                            for (int index = 0; index < routesToWorkWith.Length; index++)
                            {
                                swapOrders(initialRouteI[index], initialRouteK[index], routesToWorkWith[index]);
                                swapOrders(initialRouteI[index], initialRouteJ[index], routesToWorkWith[index]);
                                new_traveltime[index] = routesToWorkWith[index].TravelTime;
                            }

                            bool hasABetterTime = false;
                            for (int index = 0; index < new_traveltime.Length; index++)
                            {
                                if (new_traveltime[index] < best_traveltime)
                                {
                                    improvestep = 0;
                                    hasABetterTime = true;

                                    new_route = routesToWorkWith[index];
                                    best_traveltime = new_traveltime[index];
                                }
                            }

                            if (hasABetterTime)
                            {
                                for (int index = 0; index < routesToWorkWith.Length; index++)
                                    routesToWorkWith[index] = new Route(Planning.Item1);

                                foreach (Order order in old_route.Orders)
                                    for (int index = 0; index < routesToWorkWith.Length; index++)
                                        routesToWorkWith[index].AddOrder(order);

                            }
                        }
                    }
                }

                improvestep++;
            }

            RoutesFromSolution.Remove(old_route);
            RoutesFromSolution.Add(new_route);

            toStartFrom.RemoveItemFromPlanning(Planning.Item1, Planning.Item2);
            toStartFrom.AddNewItemToPlanning(Planning.Item1, Planning.Item2, RoutesFromSolution);

            return toStartFrom;
        }