/// <summary>
/// Executes a solver procedure.
/// </summary>
/// <param name="problem"></param>
/// <returns></returns>
internal override MaxTimeSolution Solve(MaxTimeProblem problem)
{
float lambda = _lambda;
var vrpRouter =
new CheapestInsertionSolverWithImprovements(problem.Max.Value, problem.DeliveryTime.Value, 10, 0.10f, true, _thresholdPercentage, true, 0.75f);
MaxTimeSolution originalSolution = vrpRouter.Solve(
problem);
for (int roundX = 0; roundX < originalSolution.Count; roundX++)
{ // keep looping on rounds.
for (int roundY = 0; roundY < roundX; roundY++)
{ // keep looping on rounds with a smaller index not equal to the current round.
if (roundX != roundY)
{ // routes are different.
if (this.Overlaps(problem, originalSolution.Route(roundX), originalSolution.Route(roundY)))
{ // only check routes that overlap.
double tau = double.MinValue;
var penalizations = new Dictionary <Edge, int>();
//bool improvement = true;
//while (improvement)
//{ // keep looping until no more improvement is found.
// improvement = false;
while (true)
{ // keep trying to improve until the tau limit is exceeded.
// calculate the route sizes before.
double route1ActualBefore = problem.Time(originalSolution.Route(roundX));
double route2ActualBefore = problem.Time(originalSolution.Route(roundY));
// copy orignal solution.
var solution = (originalSolution.Clone() as MaxTimeSolution);
// apply penalties.
foreach (KeyValuePair <Edge, int> penalty in penalizations)
{
problem.Penalize(penalty.Key, (double)penalty.Value * lambda);
}
// apply the inter-route improvements.
int countBefore = solution.Route(roundX).Count + solution.Route(roundY).Count;
int countAfter;
if (this.ImproveInterRoute(problem, solution, roundX, roundY, problem.Max.Value))
{ // the improve inter route succeeded.
if (!solution.IsValid())
{
throw new Exception();
}
//improvement_inter = true;
countAfter = solution.Route(roundX).Count + solution.Route(roundY).Count;
if (countBefore != countAfter)
{
throw new Exception();
}
// apply the intra-route improvements.
solution[roundX] = this.ImproveIntraRoute(problem, solution.Route(roundX), solution[roundX]);
solution[roundY] = this.ImproveIntraRoute(problem, solution.Route(roundY), solution[roundY]);
// recalculate weights.
solution[roundX] = problem.Time(solution.Route(roundX));
solution[roundY] = problem.Time(solution.Route(roundY));
}
// check customer counts.
countAfter = solution.Route(roundX).Count + solution.Route(roundY).Count;
if (countBefore != countAfter)
{
throw new Exception();
}
// undo the penalizations.
problem.ResetPenalizations();
// check against the orginal objective function.
double route1ActualAfter = problem.Time(solution.Route(roundX));
double route2ActualAfter = problem.Time(solution.Route(roundY));
if (route1ActualAfter + route2ActualAfter < route1ActualBefore + route2ActualBefore - 0.001 &&
route1ActualAfter < problem.Max.Value && route2ActualAfter < problem.Max.Value)
{ // there is improvement!
originalSolution = solution;
//improvement = true;
OsmSharp.Logging.Log.TraceEvent("OsmSharp.Routing.VRP.NoDepot.MaxTime.VNS.GuidedVNS", TraceEventType.Information,
"IMPROVEMENT: {0}->{1}",
route1ActualBefore + route2ActualBefore, route1ActualAfter + route2ActualAfter);
}
// select arc to be penalized.
IRoute route1 = originalSolution.Route(roundX);
IRoute route2 = originalSolution.Route(roundY);
double u = double.MinValue;
var penalizingEdge = new Edge();
double totalP = 0;
foreach (Edge edge in route1.Edges())
{
int edgeP;
if (!penalizations.TryGetValue(edge, out edgeP))
{
edgeP = 0;
}
totalP = totalP + edgeP;
double edgeU = ((lambda * (double)edgeP) + problem.WeightMatrix[edge.From][edge.To]) /
((double)edgeP + 1.0);
if (u <= edgeU)
{
penalizingEdge = edge;
u = edgeU;
}
}
foreach (Edge edge in route2.Edges())
{
int edgeP;
if (!penalizations.TryGetValue(edge, out edgeP))
{
edgeP = 0;
}
totalP = totalP + edgeP;
double edgeU = ((lambda * (double)edgeP) + problem.WeightMatrix[edge.From][edge.To]) /
((double)edgeP + 1.0);
if (u <= edgeU)
{
penalizingEdge = edge;
u = edgeU;
}
}
// actually penalize the edge.
int p;
if (!penalizations.TryGetValue(penalizingEdge, out p))
{
p = 1;
}
else
{
p++;
}
penalizations[penalizingEdge] = p;
// evaluate or set tau.
if (tau > double.MinValue)
{ // evaluate if penalizations should end.
if (tau <= lambda * totalP)
{ // the penalization should end!
break;
}
}
else
{ // first edge being penalized.
tau = lambda * problem.WeightMatrix[penalizingEdge.From][penalizingEdge.To] / 10;
}
}
}
}
}
}
return(originalSolution);
}
/// <summary>
/// Executes a solver procedure.
/// </summary>
/// <param name="problem"></param>
/// <returns></returns>
internal override MaxTimeSolution Solve(MaxTimeProblem problem)
{
// create the solution.
var solution = new MaxTimeSolution(problem.Size);
// keep placing customer until none are left.
var customers = new List <int>(problem.Customers);
customers.RemoveAt(0);
double max = problem.Max.Value - (problem.Max.Value * _deltaPercentage);
// keep a list of cheapest insertions.
IInsertionCosts costs = new BinaryHeapInsertionCosts();
double percentage = _thresholdPercentage;
while (customers.Count > 0)
{
//// try and distribute the remaining customers if there are only a few left.
//if (customers.Count < problem.Size * percentage)
//{
// bool succes = true;
// while (succes && customers.Count > 0)
// {
// succes = false;
// CheapestInsertionResult best = new CheapestInsertionResult();
// best.Increase = float.MaxValue;
// int best_idx = -1;
// for (int route_idx = 0; route_idx < solution.Count; route_idx++)
// {
// IRoute route = solution.Route(route_idx);
// CheapestInsertionResult result =
// CheapestInsertionHelper.CalculateBestPlacement(problem, route, customers);
// if (best.Increase > result.Increase)
// {
// best = result;
// best_idx = route_idx;
// }
// }
// IRoute best_route = solution.Route(best_idx);
// double route_time = problem.Time(best_route);
// if (route_time + best.Increase < max)
// { // insert the customer.
// best_route.InsertAfter(best.CustomerBefore, best.Customer);
// customers.Remove(best.Customer);
// this.Improve(problem, solution, max, best_idx);
// succes = true;
// }
// }
//}
// select a customer using some heuristic.
int customer = this.SelectSeed(problem, problem.MaxTimeCalculator, solution, customers);
customers.Remove(customer);
// start a route r.
IRoute currentRoute = solution.Add(customer);
solution[solution.Count - 1] = 0;
while (customers.Count > 0)
{
// calculate the best placement.
CheapestInsertionResult result;
if (_useSeedCost)
{ // use the seed cost; the cost to the seed customer.
result = CheapestInsertionHelper.CalculateBestPlacement(problem, currentRoute, customers,
customer, 0.7);
// calculate the 'real' increase.
result.Increase = (problem.WeightMatrix[result.CustomerBefore][result.Customer] +
problem.WeightMatrix[result.Customer][result.CustomerAfter]) -
problem.WeightMatrix[result.CustomerBefore][result.CustomerAfter];
}
else
{ // just use cheapest insertion.
result = CheapestInsertionHelper.CalculateBestPlacement(problem, currentRoute, customers, costs);
}
// calculate the new weight.
solution[solution.Count - 1] = problem.Time(solution.Route(solution.Count - 1));
double potentialWeight = problem.MaxTimeCalculator.CalculateOneRouteIncrease(solution[solution.Count - 1],
result.Increase);
// cram as many customers into one route as possible.
if (potentialWeight < max)
{
// insert the customer, it is
customers.Remove(result.Customer);
currentRoute.InsertAfter(result.CustomerBefore, result.Customer);
// free some memory in the costs list.
costs.Remove(result.CustomerBefore, result.CustomerAfter);
// update the cost of the route.
solution[solution.Count - 1] = potentialWeight;
// improve if needed.
if (((problem.Size - customers.Count) % _k) == 0)
{ // an improvement is decided.
// apply the inter-route improvements.
var copy = (solution.Clone() as MaxTimeSolution);
int countBefore = solution.Route(solution.Count - 1).Count;
solution[solution.Count - 1] = this.ImproveIntraRoute(problem,
solution.Route(solution.Count - 1), solution[solution.Count - 1]);
if (!solution.IsValid())
{
throw new Exception();
}
int countAfter = solution.Route(solution.Count - 1).Count;
if (countAfter != countBefore)
{
throw new Exception();
}
// also to the inter-improvements.
currentRoute = this.Improve(problem, solution, max, solution.Count - 1);
}
}
else
{// ok we are done!
this.Improve(problem, solution, max, solution.Count - 1);
// break the route.
break;
}
}
}
// remove empty routes.
for (int routeIdx = solution.Count - 1; routeIdx >= 0; routeIdx--)
{
if (solution.Route(routeIdx).IsEmpty)
{
solution.Remove(routeIdx);
}
}
return(solution);
}
/// <summary>
/// Applies inter-improvements by exchanging parts of the route(s).
/// </summary>
/// <param name="problem"></param>
/// <param name="solution"></param>
/// <param name="route1_idx"></param>
/// <param name="route2_idx"></param>
/// <param name="max"></param>
/// <returns></returns>
public bool Improve(MaxTimeProblem problem, MaxTimeSolution solution,
int route1_idx, int route2_idx, double max)
{
int max_window = 40;
IRoute route1 = solution.Route(route1_idx);
IRoute route2 = solution.Route(route2_idx);
int route1_customers = route1.Count;
int route2_customers = route2.Count;
double[] route1_cumul = problem.TimeCumul(route1);
double[] route2_cumul = problem.TimeCumul(route2);
// build all edge weights.
List <Edge> route1_edges = new List <Edge>(route1.Edges());
List <Edge> route2_edges = new List <Edge>(route2.Edges());
double[] route1_weights = new double[route1_edges.Count];
for (int idx = 0; idx < route1_edges.Count; idx++)
{
Edge edge = route1_edges[idx];
route1_weights[idx] = problem.WeightMatrix[edge.From][edge.To];
}
double[] route2_weights = new double[route2_edges.Count];
for (int idx = 0; idx < route2_edges.Count; idx++)
{
Edge edge = route2_edges[idx];
route2_weights[idx] = problem.WeightMatrix[edge.From][edge.To];
}
List <EdgePair> route2_pairs = new List <EdgePair>();
for (int i_idx = 0; i_idx < route2_edges.Count - 2; i_idx++)
{
Edge i = route2_edges[i_idx];
double i_weight = route2_weights[i_idx];
double weight_before_i = route2_cumul[i_idx];
int k_idx_max = route2_edges.Count;
if (k_idx_max > i_idx + 2 + max_window)
{
k_idx_max = i_idx + 2 + max_window;
}
for (int k_idx = i_idx + 2; k_idx < k_idx_max; k_idx++)
{
Edge k = route2_edges[k_idx];
double k_weight = route2_weights[k_idx];
double weight_after_k = route2_cumul[route2_cumul.Length - 1] - route2_cumul[k_idx + 1];
double weight_between_route = route2_cumul[k_idx] - route2_cumul[i_idx + 1];
route2_pairs.Add(new EdgePair()
{
First = i,
FirstWeight = i_weight,
Second = k,
SecondWeight = k_weight,
Between = new List <int>(route2.Between(i.To, k.From)),
WeightTotal = i_weight + k_weight,
WeightAfter = weight_after_k,
WeightBefore = weight_before_i,
WeightBetween = weight_between_route,
CustomersBetween = k_idx - i_idx
});
}
}
// build all edge pairs.
for (int i_idx = 0; i_idx < route1_edges.Count - 2; i_idx++)
{
Edge i = route1_edges[i_idx];
double i_weight = route1_weights[i_idx];
double weight_before_i = route1_cumul[i_idx];
int k_idx_max = route1_edges.Count;
if (k_idx_max > i_idx + 2 + max_window)
{
k_idx_max = i_idx + 2 + max_window;
}
for (int k_idx = i_idx + 2; k_idx < k_idx_max; k_idx++)
{
Edge k = route1_edges[k_idx];
double k_weight = route1_weights[k_idx];
double weight_after_k = route1_cumul[route1_cumul.Length - 1] - route1_cumul[k_idx + 1];
double weight_between_route = route1_cumul[k_idx] - route1_cumul[i_idx + 1];
EdgePair pair1 = new EdgePair()
{
First = i,
FirstWeight = i_weight,
Second = k,
SecondWeight = k_weight,
Between = new List <int>(route1.Between(i.To, k.From)),
WeightTotal = i_weight + k_weight,
WeightAfter = weight_after_k,
WeightBefore = weight_before_i,
WeightBetween = weight_between_route,
CustomersBetween = k_idx - i_idx
};
foreach (EdgePair pair2 in route2_pairs)
{
double existing_weight = pair1.WeightTotal + pair2.WeightTotal;
//double new_weight = 0;
// get first route new.
double new_weight = problem.WeightMatrix[pair1.First.From][pair2.First.To];
//new_weight = first_route1_new;
if (new_weight > existing_weight - 0.001)
{
continue;
}
double first_route2_new = problem.WeightMatrix[pair2.First.From][pair1.First.To];
new_weight = new_weight + first_route2_new;
if (new_weight > existing_weight - 0.001)
{
continue;
}
double second_route1_new = problem.WeightMatrix[pair1.Second.From][pair2.Second.To];
new_weight = new_weight + second_route1_new;
if (new_weight > existing_weight - 0.001)
{
continue;
}
double second_route2_new = problem.WeightMatrix[pair2.Second.From][pair1.Second.To];
new_weight = new_weight + second_route2_new;
if (new_weight < existing_weight - 0.001)
{ // there is a decrease in total weight; check bounds.
double route1_weight = pair1.WeightBefore + pair2.WeightBetween + pair1.WeightAfter;
double route2_weight = pair2.WeightBefore + pair1.WeightBetween + pair2.WeightAfter;
// calculate the maximum.
int route1_customers_between = pair1.CustomersBetween;
int route2_customers_between = pair1.CustomersBetween;
route1_weight = problem.Time(route1_weight,
route1_customers - route1_customers_between + route2_customers_between);
route2_weight = problem.Time(route2_weight,
route2_customers - route2_customers_between + route1_customers_between);
if (route1_weight < max && route2_weight < max)
{
MaxTimeSolution solution_copy = solution.Clone() as MaxTimeSolution;
List <int> route1_between = pair1.Between;
List <int> route2_between = pair2.Between;
route1.ReplaceEdgeFrom(pair1.First.From, pair1.Second.To);
route2.ReplaceEdgeFrom(pair2.First.From, pair2.Second.To);
int previous = pair1.First.From;
for (int idx = 0; idx < route2_between.Count; idx++)
{
route1.ReplaceEdgeFrom(previous, route2_between[idx]);
previous = route2_between[idx];
}
route1.ReplaceEdgeFrom(previous, pair1.Second.To);
previous = pair2.First.From;
for (int idx = 0; idx < route1_between.Count; idx++)
{
route2.ReplaceEdgeFrom(previous, route1_between[idx]);
previous = route1_between[idx];
}
route2.ReplaceEdgeFrom(previous, pair2.Second.To);
if (!solution.IsValid())
{
throw new Exception();
}
return(true);
}
}
}
}
}
return(false);
}
/// <summary>
/// Applies inter-improvements by exchanging parts of the route(s).
/// </summary>
/// <param name="problem"></param>
/// <param name="solution"></param>
/// <param name="route1_idx"></param>
/// <param name="route2_idx"></param>
/// <param name="max"></param>
/// <returns></returns>
public bool Improve(MaxTimeProblem problem, MaxTimeSolution solution,
int route1_idx, int route2_idx, double max)
{
int max_window = 50;
IRoute route1 = solution.Route(route1_idx);
IRoute route2 = solution.Route(route2_idx);
int route1_customers = route1.Count;
int route2_customers = route2.Count;
double[] route1_cumul = problem.TimeCumul(route1);
double[] route2_cumul = problem.TimeCumul(route2);
// build all edge weights.
List<Edge> route1_edges = new List<Edge>(route1.Edges());
List<Edge> route2_edges = new List<Edge>(route2.Edges());
double[] route1_weights = new double[route1_edges.Count];
for (int idx = 0; idx < route1_edges.Count; idx++)
{
Edge edge = route1_edges[idx];
route1_weights[idx] = problem.WeightMatrix[edge.From][edge.To];
}
double[] route2_weights = new double[route2_edges.Count];
for (int idx = 0; idx < route2_edges.Count; idx++)
{
Edge edge = route2_edges[idx];
route2_weights[idx] = problem.WeightMatrix[edge.From][edge.To];
}
List<EdgePair> route2_pairs = new List<EdgePair>();
for (int i_idx = 0; i_idx < route2_edges.Count - 2; i_idx++)
{
Edge i = route2_edges[i_idx];
double i_weight = route2_weights[i_idx];
double weight_before_i = route2_cumul[i_idx];
int k_idx_max = route2_edges.Count;
if (k_idx_max > i_idx + 2 + max_window)
{
k_idx_max = i_idx + 2 + max_window;
}
for (int k_idx = i_idx + 2; k_idx < k_idx_max; k_idx++)
{
Edge k = route2_edges[k_idx];
double k_weight = route2_weights[k_idx];
double weight_after_k = route2_cumul[route2_cumul.Length - 1] - route2_cumul[k_idx + 1];
double weight_between_route = route2_cumul[k_idx] - route2_cumul[i_idx + 1];
route2_pairs.Add(new EdgePair()
{
First = i,
FirstWeight = i_weight,
Second = k,
SecondWeight = k_weight,
Between = new List<int>(route2.Between(i.To, k.From)),
WeightTotal = i_weight + k_weight,
WeightAfter = weight_after_k,
WeightBefore = weight_before_i,
WeightBetween = weight_between_route,
CustomersBetween = k_idx - i_idx
});
}
}
// build all edge pairs.
for (int i_idx = 0; i_idx < route1_edges.Count - 2; i_idx++)
{
Edge i = route1_edges[i_idx];
double i_weight = route1_weights[i_idx];
double weight_before_i = route1_cumul[i_idx];
int k_idx_max = route1_edges.Count;
if (k_idx_max > i_idx + 2 + max_window)
{
k_idx_max = i_idx + 2 + max_window;
}
for (int k_idx = i_idx + 2; k_idx < k_idx_max; k_idx++)
{
Edge k = route1_edges[k_idx];
double k_weight = route1_weights[k_idx];
double weight_after_k = route1_cumul[route1_cumul.Length - 1] - route1_cumul[k_idx + 1];
double weight_between_route = route1_cumul[k_idx] - route1_cumul[i_idx + 1];
EdgePair pair1 = new EdgePair()
{
First = i,
FirstWeight = i_weight,
Second = k,
SecondWeight = k_weight,
Between = new List<int>(route1.Between(i.To, k.From)),
WeightTotal = i_weight + k_weight,
WeightAfter = weight_after_k,
WeightBefore = weight_before_i,
WeightBetween = weight_between_route,
CustomersBetween = k_idx - i_idx
};
foreach (EdgePair pair2 in route2_pairs)
{
double existing_weight = pair1.WeightTotal + pair2.WeightTotal;
//double new_weight = 0;
// get first route new.
double new_weight = problem.WeightMatrix[pair1.First.From][pair2.First.To];
//new_weight = first_route1_new;
if (new_weight > existing_weight - 0.001)
{
continue;
}
double first_route2_new = problem.WeightMatrix[pair2.First.From][pair1.First.To];
new_weight = new_weight + first_route2_new;
if (new_weight > existing_weight - 0.001)
{
continue;
}
double second_route1_new = problem.WeightMatrix[pair1.Second.From][pair2.Second.To];
new_weight = new_weight + second_route1_new;
if (new_weight > existing_weight - 0.001)
{
continue;
}
double second_route2_new = problem.WeightMatrix[pair2.Second.From][pair1.Second.To];
new_weight = new_weight + second_route2_new;
if (new_weight < existing_weight - 0.001)
{ // there is a decrease in total weight; check bounds.
double route1_weight = pair1.WeightBefore + pair2.WeightBetween + pair1.WeightAfter;
double route2_weight = pair2.WeightBefore + pair1.WeightBetween + pair2.WeightAfter;
// calculate the maximum.
int route1_customers_between = pair1.CustomersBetween;
int route2_customers_between = pair1.CustomersBetween;
route1_weight = problem.Time(route1_weight,
route1_customers - route1_customers_between + route2_customers_between);
route2_weight = problem.Time(route2_weight,
route2_customers - route2_customers_between + route1_customers_between);
if (route1_weight < max && route2_weight < max)
{
MaxTimeSolution solution_copy = solution.Clone() as MaxTimeSolution;
List<int> route1_between = pair1.Between;
List<int> route2_between = pair2.Between;
route1.ReplaceEdgeFrom(pair1.First.From, pair1.Second.To);
route2.ReplaceEdgeFrom(pair2.First.From, pair2.Second.To);
int previous = pair1.First.From;
for (int idx = 0; idx < route2_between.Count; idx++)
{
route1.ReplaceEdgeFrom(previous, route2_between[idx]);
previous = route2_between[idx];
}
route1.ReplaceEdgeFrom(previous, pair1.Second.To);
previous = pair2.First.From;
for (int idx = 0; idx < route1_between.Count; idx++)
{
route2.ReplaceEdgeFrom(previous, route1_between[idx]);
previous = route1_between[idx];
}
route2.ReplaceEdgeFrom(previous, pair2.Second.To);
if (!solution.IsValid())
{
throw new Exception();
}
return true;
}
}
}
}
}
return false;
}