Merge pull request #26 from guidantas21/main

Merge da branch randomize_construction

Author: GSherterton

include/ASP.hpp

@@ -17,7 +17,7 @@ class ASP {
     Flight m_dummy_flight;
 
 public:
-    enum class Neighborhood : uint8_t { IntraSwap, InterSwap, IntraMove, InterMove };
+    enum class Neighborhood : uint8_t { IntraSwap, InterSwap, IntraMove, InterMove, WorstFlight };
     std::vector<Flight> flights;
 
     // Constructive heuristics
@@ -37,6 +37,7 @@ class ASP {
     bool best_improvement_inter_swap(Solution &solution);
     bool best_improvement_intra_move(Solution &solution);
     bool best_improvement_inter_move(Solution &solution);
+    bool move_worst_flight(Solution &Solution);
 
     // Methaheuristics
 
@@ -49,7 +50,7 @@ class ASP {
     // Perturbations
 
     void random_inter_block_swap(Solution &solution);
-    void best_improvement_free_space(Solution &solution);
+    bool best_improvement_free_space(Solution &solution);
 
 
     ASP(Instance &instance);

src/GILS.cpp

@@ -100,28 +100,38 @@ Solution ASP::GILS_RVND(const size_t max_iterations, const size_t max_ils_iterat
     Solution best_found;
     best_found.objective = std::numeric_limits<uint32_t>::max();
 
-    for (size_t iteration = 0; iteration < max_iterations; ++iteration) {
-        std::cout << iteration << std::endl;
+    std::cout << ">> GILS-RVND\n";
+
+    for (size_t iteration = 1; iteration <= max_iterations; ++iteration) {
+
+        std::cout << "\n[" << iteration << "/" << max_iterations << "]" << '\t';
+
+        std::cout << "Best found: " << best_found.objective << '\n';
+
+        Solution solution = rand_lowest_release_time_insertion(flights);
 
-        Solution solution = lowest_release_time_insertion(flights);
-        
         Solution local_best = solution;
 
+        std::cout << "\tInitial solution: " << solution.objective << '\n';
+
         RVND(solution);
 
         size_t ils_iteration = 1;
 
         while (ils_iteration <= max_ils_iterations) {
-            size_t max_pertubation_iters =
+            auto max_pertubation_iters =
                 1 + static_cast<size_t>(std::ceil(alpha * static_cast<double>(m_instance.get_num_runways() / 2)));
 
-            for (size_t perturbation_iteration = 0; perturbation_iteration < max_pertubation_iters;
+            for (size_t perturbation_iteration = 1; perturbation_iteration < max_pertubation_iters;
                  ++perturbation_iteration) {
 
                 // if (perturbation_iteration < max_pertubation_iters / 2 ) random_inter_block_swap(solution);
                 // else best_improvement_free_space(solution);
 
-                best_improvement_free_space(solution);
+                if (not best_improvement_free_space(solution)) {
+                    random_inter_block_swap(solution);
+                    break;
+                }
             }
             RVND(solution);
 
@@ -131,11 +141,14 @@ Solution ASP::GILS_RVND(const size_t max_iterations, const size_t max_ils_iterat
             }
             ++ils_iteration;
         }
-
+        std::cout << "\tLocal best solution: " << local_best.objective;
         if (local_best.objective < best_found.objective) {
             best_found = local_best;
+            std::cout << "\t(New best solution!)";
         }
+        std::cout << '\n';
     }
+    std::cout << "\nBest found: " << best_found.objective << '\n';
     return best_found;
 }
 

src/RVND.cpp

@@ -3,7 +3,7 @@
 
 void ASP::RVND(Solution &solution) { // NOLINT
     std::vector<Neighborhood> neighborhoods{Neighborhood::IntraSwap, Neighborhood::InterSwap, Neighborhood::IntraMove,
-                                            Neighborhood::InterMove};
+                                            Neighborhood::InterMove, Neighborhood::WorstFlight};
 
     bool improved = false;
     size_t current_neighborhood = 0;
@@ -23,6 +23,9 @@ void ASP::RVND(Solution &solution) { // NOLINT
         case Neighborhood::InterMove:
             improved = best_improvement_inter_move(solution);
             break;
+        case Neighborhood::WorstFlight:
+            improved = move_worst_flight(solution);
+            break;
         }
         if (improved) {
             neighborhoods = {Neighborhood::IntraSwap, Neighborhood::InterSwap, Neighborhood::IntraMove,

src/construction.cpp

@@ -189,38 +189,38 @@ Solution ASP::lowest_release_time_insertion(std::vector<Flight> &flights) {
     return solution;
 }
 
-size_t choose_runway(std::vector<size_t> start_time){
+size_t choose_runway(std::vector<size_t> start_time) {
     std::vector<float> values;
     float soma = 0;
 
     // std::cout << "\nIniciando escolha:\n";
 
-    //inverte os valores
-    for(size_t i = 0; i < start_time.size(); i++){
-        values.push_back((float)1/start_time[i]);
+    // inverte os valores
+    for (size_t i = 0; i < start_time.size(); i++) {
+        values.push_back((float)1 / start_time[i]);
         soma += values[i];
         // std::cout << "Start time: " << start_time[i] << std::endl;
     }
 
-    //calcula as probabilidades
-    for(size_t i = 0; i < values.size(); i++){
-        values[i] = floor((values[i]/soma)*100);
+    // calcula as probabilidades
+    for (size_t i = 0; i < values.size(); i++) {
+        values[i] = floor((values[i] / soma) * 100);
         // std::cout << "Probabilidade: " << values[i] << std::endl;
     }
 
-    //calcula os intervalos
+    // calcula os intervalos
     soma = 0;
-    for(size_t i = 0; i < values.size(); i++){
+    for (size_t i = 0; i < values.size(); i++) {
         values[i] = soma + values[i];
         soma = values[i];
         // std::cout << "Intervalo: " << values[i] << std::endl;
     }
 
-    //escolho um numero
+    // escolho um numero
     size_t numero = rand() % (int)soma + 1;
 
-    for(size_t i = 0; i < values.size(); i++){
-        if(numero <= values[i]){
+    for (size_t i = 0; i < values.size(); i++) {
+        if (numero <= values[i]) {
             // std::cout << "Choosed: " << i << std::endl;
             return i;
         }
@@ -292,10 +292,11 @@ Solution ASP::rand_lowest_release_time_insertion(std::vector<Flight> &flights) {
             (start_time[choosed_runway] - current_flight.get_release_time()) * current_flight.get_delay_penalty();
         solution.runways[choosed_runway].prefix_penalty.push_back(
             solution.runways[choosed_runway]
-                .prefix_penalty[solution.runways[choosed_runway].sequence.size()] // the prefix of the last flight in the
-                                                                               // runwawy
+                .prefix_penalty[solution.runways[choosed_runway].sequence.size()] // the prefix of the last flight in
+                                                                                  // the runwawy
             + current_flight_penalty); // O prefix penalty dele é o prefix penalty do anterior mais o penalty dele
-        solution.runways[choosed_runway].sequence.emplace_back(candidate_list.back()); // Coloca ele no final daquela pista
+        solution.runways[choosed_runway].sequence.emplace_back(
+            candidate_list.back()); // Coloca ele no final daquela pista
 
         Flight &candidate = candidate_list.back().get(); // Facilitar a escrita
 
@@ -315,102 +316,3 @@ Solution ASP::rand_lowest_release_time_insertion(std::vector<Flight> &flights) {
 
     return solution;
 }
-
-// Solution ASP::rand_lowest_release_time_insertion(std::vector<Flight> &flights) {
-//     Solution solution(m_instance);
-
-//     // Initialization of the candidate list
-//     std::vector<std::reference_wrapper<Flight>> candidate_list;
-//     candidate_list.reserve(m_instance.get_num_flights());
-
-//     for (size_t i = 0; i < m_instance.get_num_flights(); ++i) {
-//         candidate_list.emplace_back(flights[i]);
-//     }
-//     std::vector<size_t> candidates_position(m_instance.get_num_flights());
-
-//     // Ordering of the candidate list by release time
-//     std::sort(candidate_list.begin(), candidate_list.end(), [](const auto flight_a, const auto flight_b) {
-//         return flight_a.get().get_release_time() > flight_b.get().get_release_time();
-//     });
-
-//     size_t qtd_runways = m_instance.get_num_runways();
-
-//     // Put the "runway.size()"'s lowests release time flights
-//     for (size_t runway_i = 0; runway_i < m_instance.get_num_runways(); ++runway_i) {
-//         size_t idx =  (rand() % std::min(qtd_runways, candidate_list.size())) + (candidate_list.size() - std::min(qtd_runways, candidate_list.size())); //index of the selected flight in candidate list
-
-//         solution.runways[runway_i].sequence.emplace_back(candidate_list[idx]); // Coloca ele no final daquela pista
-//         solution.runways[runway_i].prefix_penalty.push_back(0); // O penalty dele é zero pois é o primeiro
-
-//         Flight &candidate = candidate_list[idx].get(); // Facilitar a escrita
-
-//         // Atualiza seus valores
-//         candidate.position = 0;
-//         candidate.runway = runway_i;
-//         candidate.start_time = candidate.get_release_time();
-
-//         // Apaga ele da lista de candidatos
-//         for(size_t i = idx; i < candidate_list.size()-1; i++){
-//             candidate_list[i] = candidate_list[i+1];
-//         }
-//         candidate_list.pop_back();
-//     }
-
-//     // Insert all the flights in the solution
-//     size_t best_runway;
-//     size_t lowest_start_time;
-//     size_t start_time;
-//     while (!candidate_list.empty()) {
-
-//         // Search the best runway which the start time be the lowest possible
-//         best_runway = 0;
-//         lowest_start_time = std::numeric_limits<size_t>::max();
-
-//         size_t idx =  (rand() % std::min(qtd_runways, candidate_list.size())) + (candidate_list.size() - std::min(qtd_runways, candidate_list.size())); //index of the selected flight in candidate list
-//         const Flight &current_flight = candidate_list[idx].get(); // the flight who will be insert
-
-//         for (size_t runway_i = 0; runway_i < m_instance.get_num_runways(); ++runway_i) {
-//             const Flight &prev_flight =
-//                 solution.runways[runway_i].sequence.back().get(); // the actual last flight in the runway
-
-//             const uint32_t earliest = prev_flight.start_time + prev_flight.get_runway_occupancy_time() +
-//                                       m_instance.get_separation_time(prev_flight.get_id(), current_flight.get_id());
-
-//             start_time = std::max(earliest, current_flight.get_release_time());
-
-//             if (start_time < lowest_start_time) {
-//                 lowest_start_time = start_time;
-//                 best_runway = runway_i;
-//             }
-//         }
-
-//         uint32_t current_flight_penalty =
-//             (lowest_start_time - current_flight.get_release_time()) * current_flight.get_delay_penalty();
-//         solution.runways[best_runway].prefix_penalty.push_back(
-//             solution.runways[best_runway]
-//                 .prefix_penalty[solution.runways[best_runway].sequence.size()] // the prefix of the last flight in the
-//                                                                                // runwawy
-//             + current_flight_penalty); // O prefix penalty dele é o prefix penalty do anterior mais o penalty dele
-//         solution.runways[best_runway].sequence.emplace_back(candidate_list[idx]); // Coloca ele no final daquela pista
-
-//         Flight &candidate = candidate_list[idx].get(); // Facilitar a escrita
-
-//         // Atualiza seus valores
-//         candidate.position = solution.runways[best_runway].sequence.size() - 1;
-//         candidate.runway = best_runway;
-//         candidate.start_time = lowest_start_time;
-
-//         solution.runways[best_runway].penalty += current_flight_penalty;
-//         solution.objective += current_flight_penalty;
-
-//         // Apaga ele da lista de candidatos
-//         for(size_t i = idx; i < candidate_list.size()-1; i++){
-//             candidate_list[i] = candidate_list[i+1];
-//         }
-//         candidate_list.pop_back();
-//     }
-
-//     assert(solution.test_feasibility(m_instance));
-
-//     return solution;
-// }