void CVRPSolver::attemptVehicleExchange(CSolutionInfo& solutionInfo) { ++m_iGeneratedSolutionCount; ++m_iStepsSinceLastSolution; CMoveInfo curMove; CMoveInfo bestMove; int bestFreeCapacity = 0; std::pair<int, int> bestSwapIndex; int totalTour = static_cast<int>(solutionInfo.getTourCount()); for (int i = 0; i < totalTour; ++i) { CTourInfo firstTour = solutionInfo.getTour(i); int firstTourLoad = firstTour.getVehicleInfo().getCurrentLoad(); int firstVehicleCapacity = firstTour.getVehicleInfo().getCapacity(); for (int j = i + 1; j < totalTour; ++j) { CTourInfo secondTour = solutionInfo.getTour(j); curMove.setInitialTour(firstTour, secondTour); int FirstTourRemainingCapacity = firstVehicleCapacity - secondTour.getVehicleInfo().getCurrentLoad(); int SecondTourRemainingCapacity = secondTour.getVehicleInfo().getCapacity() - firstTourLoad; // int prevFreeCapacity = max(secondTour.getRemainingCapacity(), firstTour.getRemainingCapacity() ); int curFreeCapacity = (std::max)(FirstTourRemainingCapacity, SecondTourRemainingCapacity); if ((FirstTourRemainingCapacity > 0) && (SecondTourRemainingCapacity > 0) && // curFreeCapacity > curFreeCapacity autological compare evaluates to false (error on MAC) (curFreeCapacity > bestFreeCapacity)) { CVehicleInfo tempVehicle = m_vVehicleInfos[firstTour.getVehicleId()]; firstTour.setVehicleInfo(m_vVehicleInfos[secondTour.getVehicleId()]); secondTour.setVehicleInfo(tempVehicle); curMove.setModifiedTour(firstTour, secondTour); if (!isTabuMove(curMove)) { bestMove = curMove; bestFreeCapacity = curFreeCapacity; bestSwapIndex = std::make_pair(i, j); } curMove.getInitialTour(firstTour, secondTour); } } } if (bestFreeCapacity > 0) { CTourInfo tempTour; bestMove.getModifiedTourAt(0, tempTour); solutionInfo.replaceTourAt(bestSwapIndex.first, tempTour); bestMove.getModifiedTourAt(1, tempTour); solutionInfo.replaceTourAt(bestSwapIndex.second, tempTour); updateTabuCount(bestMove); updateFinalSolution(solutionInfo); } }
void CVRPSolver::attemptFeasibleNodeExchange(CSolutionInfo& solutionInfo) { ++m_iGeneratedSolutionCount; ++m_iStepsSinceLastSolution; CMoveInfo bestMove, curMove; int totalTour = solutionInfo.getTourCount(); for (int i = 0; i < totalTour; ++i) { CTourInfo curTour = solutionInfo.getTour(i); std::vector<int> vecOrderId = curTour.getOrderVector(); curMove.setInitialTour(curTour); int totalCustomer = curTour.getServedOrderCount(); std::pair<int, int> bestSwapIndex; double lowestCost = DOUBLE_MAX; for (int j = 0; j < totalCustomer; ++j) { for (int k = j + 1; k < totalCustomer; ++k) { COrderInfo firstCustomer = m_vOrderInfos[m_mapOrderIdToIndex[vecOrderId[j]]]; COrderInfo secondCustomer = m_vOrderInfos[m_mapOrderIdToIndex[vecOrderId[k]]]; if (curTour->isFeasibleReplace(j, pSecondCustomer) && pCurTour->isFeasibleReplace(k, pFirstCustomer)) { pCurTour->removeCustomer(j, false); pCurTour->addCustomer(pSecondCustomer, j); pCurTour->removeCustomer(k, false); pCurTour->addCustomer(pFirstCustomer, k); pCurMove->setModifiedTour(pCurTour); if (isTabuMove(pCurMove)) { pCurMove->getInitialTour(pCurTour); continue; } double curTourCost = pCurTour->getTourData()->calcCost(pCurTour->getAssignedVehicle()); if (curTourCost < lowestCost) { *pBestMove = *pCurMove; lowestCost = curTourCost; bestSwapIndex = std::make_pair(j, k); } pCurMove->getInitialTour(pCurTour); } } } if (lowestCost!= DOUBLE_MAX) { m_pCurrentSolution->replaceTourAt(i, pBestMove->getModifiedTourAt(0)); this->updateTabuCount(pBestMove); this->evaluateCurrentSolution(); } } delete pCurMove; delete pBestMove; }
bool CVRPSolver::updateFinalSolution(CSolutionInfo& curSolution) { bool callUpdate = false; if (curSolution.getOrderServed() > m_solutionFinal.getOrderServed()) { callUpdate = true; } else if (curSolution.getOrderServed() == m_solutionFinal.getOrderServed()) { if (curSolution.getTotalCost() < m_solutionFinal.getTotalCost()) { callUpdate = true; } else if (curSolution.getTotalCost() == m_solutionFinal.getTotalCost()) { if (curSolution.getTotalTravelTime() < m_solutionFinal.getTotalTravelTime()) { callUpdate = true; } else if (curSolution.getTotalTravelTime() == m_solutionFinal.getTotalTravelTime()) { if (curSolution.getTotalDistance() < m_solutionFinal.getTotalDistance()) { callUpdate = true; } } } } if (callUpdate) { // m_iStepsSinceLastSolution = 0; m_solutionFinal = curSolution; // clear map and delete objects // m_mpTabuCount.clear(); // for (std::map< CVRPTWMove*, int >::iterator it = m_mpMoveFrequency.begin();it!= m_mpMoveFrequency.end();++it) // { // delete (*it).first; // } // m_mpMoveFrequency.clear(); return true; } return false; }
void CVRPSolver::applyBestMoveInCurrentSolution(CSolutionInfo& curSolution, CMoveInfo& bestMove) { ++m_iGeneratedSolutionCount; ++m_iStepsSinceLastSolution; updateTabuCount(bestMove); int totalTour = static_cast<int>(bestMove.getModifiedTourCount()); for (int i = 0; i < totalTour; ++i) { CTourInfo tourInfo; bool bIsValid = bestMove.getModifiedTourAt(i, tourInfo); if (bIsValid) curSolution.replaceTour(tourInfo); } updateFinalSolution(curSolution); }
void CVRPSolver::insertUnservedOrders(CSolutionInfo& curSolution) { ++m_iGeneratedSolutionCount; ++m_iStepsSinceLastSolution; bool insertAvailable = true; CMoveInfo curMove; int totalUnservedOrder = static_cast<int>(m_vOrderInfos.size() - curSolution.getOrderServed()); while (insertAvailable && totalUnservedOrder > 0) { int insertTourId = -1; insertAvailable = false; int totalTour = static_cast<int>(curSolution.getTourInfoVector().size()); std::pair<int, int> PotentialInsert; // first = insert_index, second = removed_customer_index; std::pair<int, double> bestInsert = std::make_pair(-1, DOUBLE_MAX); // first = customer_insert_index, second = cost; for (int j = 0; j < totalTour; ++j) { CTourInfo curTour = curSolution.getTour(j); curMove.setInitialTour(curTour); for (int i = 0; i < totalUnservedOrder; ++i) { int ordIndex = m_mapOrderIdToIndex[curSolution.getUnservedOrderAt(i)]; COrderInfo curOrder = m_vOrderInfos[ordIndex]; std::pair<int, double> curInsert = getPotentialInsert(curTour, curOrder); insertOrder(curTour, i, curInsert.first); curMove.setModifiedTour(curTour); curMove.getInitialTour(curTour); // check if current move is tabu. if (isTabuMove(curMove)) { continue; } if (curInsert.second < bestInsert.second) { insertTourId = j; insertAvailable = true; bestInsert = curInsert; PotentialInsert = std::make_pair(curInsert.first, i); } } } if (insertAvailable) { totalUnservedOrder--; curMove.setInitialTour(curSolution.getTour(insertTourId)); addOrderAtTour(curSolution, insertTourId, PotentialInsert.first, PotentialInsert.second); curMove.setModifiedTour(curSolution.getTour(insertTourId)); this->updateTabuCount(curMove); this->updateFinalSolution(curSolution); // this->evaluateCurrentSolution(); } } }
int find_vrp_solution(vrp_vehicles_t *vehicles, size_t vehicle_count, vrp_orders_t *orders, size_t order_count, vrp_cost_element_t *costmatrix, size_t cost_count, int depot_id, vrp_result_element_t **results, size_t *result_count, char **err_msg) { int res; std::string strError; try { PGR_LOG("Before load order"); loadOrders(orders, static_cast<int>(order_count), depot_id); PGR_LOG("After load order"); loadVehicles(vehicles, static_cast<int>(vehicle_count)); PGR_LOG("After load vehicles"); loadDistanceMatrix(costmatrix, static_cast<int>(cost_count), depot_id); PGR_LOG("After load distance matrix"); res = solver.solveVRP(strError); PGR_LOG("After VRP Solve"); } catch(std::exception& e) { *err_msg = (char *) e.what(); return -1; } catch(...) { *err_msg = (char *) "Caught unknown exception!"; return -1; } if (res < 0) { return res; } else { try { CSolutionInfo solution; CTourInfo ctour; // bool bOK = solver.getSolution(solution, strError); auto totalRoute = solution.getTourInfoVector().size(); size_t totRows = 0; for (size_t i = 0; i < totalRoute; i++) { totRows += (solution.getTour(static_cast<int>(i)).getServedOrderCount() + 2); } *results = (vrp_result_element_t *) malloc(totRows * sizeof(vrp_result_element_t)); *result_count = totRows; int cnt = 0; for (size_t i = 0; i < totalRoute; i++) { ctour = solution.getTour(static_cast<int>(i)); std::vector<int> vecOrder = ctour.getOrderVector(); auto totalOrder = vecOrder.size(); // For start depot (*results)[cnt].order_id = ctour.getStartDepot(); (*results)[cnt].order_pos = 0; (*results)[cnt].vehicle_id = ctour.getVehicleId(); (*results)[cnt].arrival_time = -1; (*results)[cnt].depart_time = ctour.getStartTime(0); cnt++; // For each order for (size_t j = 0; j < totalOrder; j++) { (*results)[cnt].order_id = vecOrder[j]; (*results)[cnt].order_pos = static_cast<int>(j) + 1; (*results)[cnt].vehicle_id = ctour.getVehicleId(); (*results)[cnt].depart_time = ctour.getStartTime(static_cast<int>(j) + 1); (*results)[cnt].arrival_time = ctour.getStartTime(static_cast<int>(j) + 1) - solver.getServiceTime(vecOrder[j]); cnt++; } // For return depot (*results)[cnt].order_id = ctour.getEndDepot(); (*results)[cnt].order_pos = static_cast<int>(totalOrder) + 1; (*results)[cnt].vehicle_id = ctour.getVehicleId(); (*results)[cnt].arrival_time = ctour.getStartTime(static_cast<int>(totalOrder) + 1); (*results)[cnt].depart_time = -1; cnt++; } } catch(std::exception& e) { *err_msg = (char *) e.what(); return -1; } catch(...) { *err_msg = (char *) "Caught unknown exception!"; return -1; } } return EXIT_SUCCESS; }
bool CVRPSolver::addOrderAtTour(CSolutionInfo &solutionInfo, int tourIndex, int insertIndex, int orderIndex) { return(insertOrder(solutionInfo.getTour(tourIndex), m_vOrderInfos[orderIndex].getOrderId(), insertIndex)); }
CSolutionInfo CVRPSolver::generateInitialSolution() { CSolutionInfo initialSolution; PGR_LOG("Inside gen ini sol"); std::vector<int> vecOrders, vecVehicles; for (unsigned int i = 0; i < m_vOrderInfos.size(); i++) { vecOrders.push_back(m_vOrderInfos[i].getOrderId()); } for (unsigned int i = 0; i < m_vVehicleInfos.size(); i++) { vecVehicles.push_back(m_vVehicleInfos[i].getId()); } initialSolution.init(vecOrders, static_cast<int>(vecOrders.size()), vecVehicles); int iUnusedVehicles = static_cast<int>(initialSolution.getUnusedVehicleCount()); int iUnservedOrders = static_cast<int>(initialSolution.getUnservedOrderCount()); // m_viUnservedOrderIndex.size(); PGR_LOG("before while"); while (iUnusedVehicles && iUnservedOrders) { CTourInfo curTour; int vehicleIndex = rand() % iUnusedVehicles--; int vehicleInd = m_mapVehicleIdToIndex[initialSolution.getUnusedVehicleAt(vehicleIndex)]; curTour.setVehicleInfo(m_vVehicleInfos[vehicleInd]); // m_viUnusedVehicleIndex[vehicleIndex] initialSolution.removeVehicle(vehicleIndex); curTour.setStartDepot(m_vDepotInfos[0].getDepotId()); curTour.setEndDepot(m_vDepotInfos[0].getDepotId()); // use a random seed to start to tour. (we can use better approach in future) bool insertAvailable = true; while (insertAvailable) { insertAvailable = false; std::pair<int, int> PotentialInsert; // first = insert_index, second = removed_order_index; std::pair<int, double> bestInsert = std::make_pair(-1, DOUBLE_MAX); // first = order_insert_index, second = cost; for (int i = 0; i < iUnservedOrders; ++i) { int orderInd = m_mapOrderIdToIndex[initialSolution.getUnservedOrderAt(i)]; COrderInfo curOrder = m_vOrderInfos[orderInd]; std::pair<int, double> curInsert = getPotentialInsert(curTour, curOrder); if (curInsert.second < bestInsert.second) { insertAvailable = true; bestInsert = curInsert; PotentialInsert = std::make_pair(curInsert.first, i); } } if (insertAvailable) { if (insertOrder(curTour, initialSolution.getUnservedOrderAt(PotentialInsert.second), PotentialInsert.first)) { iUnservedOrders--; initialSolution.removeOrder(PotentialInsert.second); } } } initialSolution.addTour(curTour); } return initialSolution; }