/*
* Optimize decreasing truck
*
* - Objective: try to remove truck with less duration
* - Secundary objective, acts like a shake operation
*
*/
void
Optimize::decrease_truck() {
bool decreased(false);
for (size_t i = 1; i < fleet.size(); ++i) {
decreased = decrease_truck(i) || decreased;
}
if (decreased) {
delete_empty_truck();
save_if_best();
decrease_truck();
}
save_if_best();
}
Optimize::Optimize(
int kind,
const Solution &old_solution) :
Solution(old_solution),
best_solution(old_solution) {
switch (kind) {
case 0:
sort_by_duration();
break;
case 1:
decrease_truck();
break;
case 2:
move_duration_based();
break;
case 3:
move_wait_time_based();
break;
case 4:
inter_swap();
break;
}
this->fleet = best_solution.fleet;
sort_by_duration();
delete_empty_truck();
}
void
Optimize::decrease_truck(size_t cycle, bool &decreased) {
/* end recursion */
if (cycle == 0) return;
std::ostringstream err_log;
err_log << " --- Cycle " << cycle << "\n";
/* the front truck move to back */
std::rotate(fleet.begin(), fleet.begin() + 1, fleet.end());
err_log << "\n after rotate" << tau();
auto orders(fleet.back().orders_in_vehicle);
while (!orders.empty()) {
/* Step 2: grab an order */
auto order(problem->orders()[*orders.begin()]);
orders.erase(orders.begin());
err_log << "\n truck with order: " << fleet.back().tau();
err_log << "\nOrder" << order << "\n";
/* Step 3: delete the order from the back of the fleet */
pgassertwm(fleet.back().has_order(order), err_log.str());
fleet.back().erase(order);
pgassertwm(!fleet.back().has_order(order), err_log.str());
/* Step 3: cycle the fleet & insert in best truck possible */
/* current truck is tried last */
err_log << " trying ";
auto best_truck(fleet.size() - 1);
auto current_duration(duration());
auto min_delta_duration = (std::numeric_limits<double>::max)();
size_t t_i(0);
for (auto &truck : fleet) {
truck.insert(order);
if (!truck.is_feasable()) {
err_log << "\n" << truck.tau();
} else {
err_log << "\n ******* success " << truck.tau() << "\n";
auto delta_duration = duration()-current_duration;
if (t_i != fleet.size() - 1
&& (delta_duration < min_delta_duration)) {
min_delta_duration = delta_duration;
best_truck = t_i;
}
}
truck.erase(order);
++t_i;
}
fleet[best_truck].insert(order);
save_if_best();
}
if (fleet.back().empty()) {
decreased = true;
fleet.pop_back();
save_if_best();
}
decrease_truck(--cycle, decreased);
}
Optimize::Optimize(
const Solution &old_solution) :
Solution(old_solution),
best_solution(old_solution) {
pgassert(false);
decrease_truck();
inter_swap(fleet.size());
}
/*
* Optimize decreasing truck
*
* - Objective: try to remove truck with less duration
*
* Step 1: Sort the fleet, duration DESC
* Step 2: grab an order from the back of the the fleet
* Step 3: cycle the fleet & insert in best truck possible
*/
void
Optimize::decrease_truck() {
bool decreased(true);
while (decreased) {
decreased = false;
sort_by_duration();
std::reverse(fleet.begin(), fleet.end());
decrease_truck(fleet.size(), decreased);
}
this->fleet = best_solution.fleet;
}
void
Optimize::inter_swap(size_t times) {
msg.log << tau("before sort by size");
sort_by_size();
msg.log << tau("before decrease");
decrease_truck();
msg.log << tau("after decrease");
sort_by_size();
msg.log << tau("after sort by size");
size_t i = 0;
while ((i++ < times) && inter_swap()) {
msg.log << tau("after inter swap");
msg.log << "\n***************************" << i;
std::rotate(fleet.begin(), fleet.begin() + 1, fleet.end());
msg.log << tau("before next cycle");
}
}
