/// <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>
/// Executes a solver procedure.
/// </summary>
/// <param name="problem"></param>
/// <returns></returns>
internal override MaxTimeSolution Solve(MaxTimeProblem problem)
{
MaxTimeCalculator calculator = new MaxTimeCalculator(problem);
// get the seed customers.
ICollection<int> seeds = _seed_selector.SelectSeeds(
problem, _k);
double[] weights = new double[seeds.Count];
// start the seed routes.
List<int> selectable_customers = problem.Customers;
MaxTimeSolution routes = new MaxTimeSolution(
problem.Size, true);
foreach (int seed in seeds)
{
routes.Add(seed);
selectable_customers.Remove(seed);
}
if (!routes.IsValid())
{
throw new Exception();
}
// keep a list of cheapest insertions.
IInsertionCosts costs = new BinaryHeapInsertionCosts();
// keep looping until all customers have been placed.
while (selectable_customers.Count > 0)
{
// try and place into every route.
CheapestInsertionResult best_result = new CheapestInsertionResult();
best_result.Increase = float.MaxValue;
int best_route_idx = -1;
CheapestInsertionResult best_result_above_max = new CheapestInsertionResult();
best_result_above_max.Increase = float.MaxValue;
int best_route_above_max_idx = -1;
for (int route_idx = 0; route_idx < routes.Count; route_idx++)
{
IRoute current_route = routes.Route(route_idx);
// choose the next customer.
CheapestInsertionResult result =
CheapestInsertionHelper.CalculateBestPlacement(problem, current_route, selectable_customers, costs);
if (result.Customer == result.CustomerAfter)
{
throw new Exception();
}
// get the current weight
double weight = weights[route_idx];
if (result.Increase < best_result.Increase)
{
if (weight + result.Increase + calculator.DeliveryTime < problem.Max.Value)
{ // route will still be inside bounds.
best_result = result;
best_route_idx = route_idx;
}
else
{ // route will become above max.
if (result.Increase < best_result_above_max.Increase)
{
best_result_above_max = result;
best_route_above_max_idx = route_idx;
}
}
}
}
// do the placement if a placement is found without max violation.
// else do the placement in the above max route.
CheapestInsertionResult placement_result = new CheapestInsertionResult();
placement_result.Increase = double.MaxValue;
int placement_result_idx = -1;
if (best_route_idx >= 0)
{ // best placement found.
placement_result = best_result;
placement_result_idx = best_route_idx;
}
else
{ // best placement found but only above max.
placement_result = best_result_above_max;
placement_result_idx = best_route_above_max_idx;
}
// do the actual placement.
weights[placement_result_idx] = calculator.CalculateOneRouteIncrease(
weights[placement_result_idx], placement_result.Increase);
selectable_customers.Remove(placement_result.Customer);
//routes.Route(placement_result_idx).InsertAfterAndRemove(
// placement_result.CustomerBefore, placement_result.Customer, placement_result.CustomerAfter);
routes.Route(placement_result_idx).InsertAfter(
placement_result.CustomerBefore, placement_result.Customer);
if (!routes.IsValid())
{
throw new Exception();
}
}
return routes;
}
internal override MaxTimeSolution Solve(MaxTimeProblem problem)
{
MaxTimeCalculator calculator = new MaxTimeCalculator(
problem);
// generate a ATSP solution.
IRoute tsp_solution = _tsp_solution;
if (tsp_solution == null)
{
tsp_solution = _tsp_solver.Solve(new TSPProblem(problem));
}
// generate subtours from this solution.
MaxTimeSolution solution = new MaxTimeSolution(problem.Size, true);
// select a random start point.
int start = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(problem.Size);
// start the first tour.
int placed = 0;
int previous = -1;
// place the first customer.
double weight = 0;
double total_weight = 0;
IRoute route = solution.Add(start);
previous = start;
while (placed < problem.Size)
{
// get the next customer from the tsp solution.
int next = tsp_solution.GetNeigbours(previous)[0];
// get the weight to the current start.
double weight_to_next = problem.WeightMatrix[previous][next];
double weight_to_start = problem.WeightMatrix[next][start];
total_weight = calculator.CalculateOneRouteIncrease(
weight, weight_to_next + weight_to_start);
weight = calculator.CalculateOneRouteIncrease(
weight, weight_to_next);
if (total_weight > problem.Max.Value)
{ // start a new route.
route = solution.Add(next);
weight = 0;
}
else
{ // just insert the next customer.
route.InsertAfter(previous, next);
//route.InsertAfterAndRemove(previous, next, -1);
}
// set the previous.
previous = next;
placed++;
}
if (!solution.IsValid())
{
throw new Exception();
}
StringBuilder builder = new StringBuilder();
builder.Append("[");
total_weight = 0;
for (int idx = 0; idx < solution.Count; idx++)
{
//IRoute route = routes.Route(idx);
route = solution.Route(idx);
weight = calculator.CalculateOneRoute(route);
builder.Append(" ");
builder.Append(weight);
builder.Append(" ");
total_weight = total_weight + weight;
}
builder.Append("]");
builder.Append(total_weight);
builder.Append(": ");
builder.Append(calculator.Calculate(solution));
Console.WriteLine(builder.ToString());
return(solution);
}
/// <summary>
/// Calculates a solution.
/// </summary>
/// <param name="problem"></param>
/// <returns></returns>
internal override MaxTimeSolution Solve(MaxTimeProblem problem)
{
// create the calculator.
MaxTimeCalculator calculator = new MaxTimeCalculator(problem);
// create the solution.
MaxTimeSolution solution = new MaxTimeSolution(problem.Size, true);
double max = problem.Max.Value;
// keep placing customer until none are left.
List<int> customers = new List<int>(problem.Customers);
// create n routes.
for (int customer = 0; customer < customers.Count; customer++)
{
solution.Add(customer);
solution[solution.Count - 1] = calculator.CalculateOneRouteIncrease(
0, 0);
}
// creates a result.
MergeResult result = new MergeResult();
result.Weight = double.MaxValue;
// loop over all route pairs and merge the smallest merge.
while (result != null)
{ // keep looping until there is no result anymore.
result = new MergeResult();
result.Weight = double.MaxValue;
for (int route1_idx = 1; route1_idx < solution.Count; route1_idx++)
{ // keep looping over all routes.
for (int route2_idx = 0; route2_idx < solution.Count; route2_idx++)
{ // keep looping over all routes.
if (route1_idx == route2_idx)
{ // only consider different routes.
break;
}
// calculate the merge result.
MergeResult current_result = this.TryMerge(problem, solution,
route1_idx, route2_idx, problem.Max.Value);
// evaluate the current result.
if (current_result != null && current_result.Weight < result.Weight)
{ // current result is best.
result = current_result;
}
}
}
// evaluate the result.
if (result.Weight < double.MaxValue)
{ // there is a result; apply it!
IRoute source = solution.Route(result.RouteSourceId);
IRoute target = solution.Route(result.RouteTargetId);
//string source_string = source.ToString();
//string target_string = target.ToString();
if (target.Count > 1 && target.First == target.GetNeigbours(result.CustomerTargetSource)[0])
{
//throw new Exception();
}
// create an enumeration of all customers of source in the correct order.
IEnumerable<int> source_between = new List<int>(
source.Between(result.CustomerSourceSource, result.CustomerSourceTarget));
// insert after the complete source.
int previous = result.CustomerTargetSource;
int next = target.GetNeigbours(result.CustomerTargetSource)[0];
foreach (int source_customer in source_between)
{
// insert.
target.ReplaceEdgeFrom(previous, source_customer);
previous = source_customer; // update previous.
}
target.ReplaceEdgeFrom(previous, next);
// remove the source route.
solution.Remove(result.RouteSourceId);
solution.RemoveWeight(result.RouteTargetId);
// calculate the weight of the new route.
solution[result.RouteTargetId] = solution[result.RouteTargetId] + result.Weight +
solution[result.RouteSourceId];
if (!solution.IsValid())
{
throw new Exception();
}
}
else
{ // set the result null.
result = null;
}
}
return solution;
}
/// <summary>
/// Executes a solver procedure.
/// </summary>
/// <param name="problem"></param>
/// <returns></returns>
internal override MaxTimeSolution Solve(MaxTimeProblem problem)
{
// create the calculator.
MaxTimeCalculator calculator = new MaxTimeCalculator(problem);
// create the solution.
MaxTimeSolution solution = new MaxTimeSolution(problem.Size, true);
// keep placing customer until none are left.
List<int> customers = new List<int>(problem.Customers);
while (customers.Count > 0)
{
// select a customer using some heuristic.
int customer_idx = OsmSharp.Tools.Math.Random.StaticRandomGenerator.Get().Generate(customers.Count);
int customer = customers[customer_idx];
customers.Remove(customer);
// start a route r.
double current_route_weight = 0;
IRoute current_route = solution.Add(customer);
//Console.WriteLine("Starting new route with {0}", customer);
while (customers.Count > 0)
{
// calculate the best placement.
CheapestInsertionResult result =
CheapestInsertionHelper.CalculateBestPlacement(problem, current_route, customers);
// calculate the new weight.
double potential_weight = calculator.CalculateOneRouteIncrease(current_route_weight, result.Increase);
// cram as many customers into one route as possible.
if (potential_weight < problem.Max.Value)
{
// insert the customer, it is
customers.Remove(result.Customer);
//current_route.InsertAfterAndRemove(result.CustomerBefore, result.Customer, result.CustomerAfter);
current_route.InsertAfter(result.CustomerBefore, result.Customer);
current_route_weight = potential_weight;
//// improve if needed.
////if (improvement_probalitity > OsmSharp.Tools.Math.Random.StaticRandomGenerator.Get().Generate(1))
//if (((problem.Size - customers.Count) % _k) == 0)
//{ // an improvement is descided.
// current_route_weight = this.ImproveIntraRoute(problem,
// current_route, current_route_weight);
//}
}
else
{// ok we are done!
//// apply the intra-route heuristics.
//for (int route_idx = 0; route_idx < solution.Count - 1; route_idx++)
//{ // apply the intra-route heurstic between the new and all existing routes.
// this.ImproveInterRoute(problem, solution.Route(route_idx), current_route);
//}
//// apply the inter-route heuristics.
//for (int route_idx = 0; route_idx < solution.Count; route_idx++)
//{ // apply heurstic for each route.
// IRoute route = solution.Route(route_idx);
// this.ImproveIntraRoute(problem, current_route, current_route_weight);
//}
// break the route.
break;
}
}
}
return solution;
}
/// <summary>
/// Executes a solver procedure.
/// </summary>
/// <param name="problem"></param>
/// <returns></returns>
internal override MaxTimeSolution Solve(MaxTimeProblem problem)
{
// create the calculator.
MaxTimeCalculator calculator = new MaxTimeCalculator(problem);
// create the solution.
MaxTimeSolution solution = new MaxTimeSolution(problem.Size, true);
// keep placing customer until none are left.
List <int> customers = new List <int>(problem.Customers);
while (customers.Count > 0)
{
// select a customer using some heuristic.
int customer_idx = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(customers.Count);
int customer = customers[customer_idx];
customers.Remove(customer);
// start a route r.
double current_route_weight = 0;
IRoute current_route = solution.Add(customer);
//Console.WriteLine("Starting new route with {0}", customer);
while (customers.Count > 0)
{
// calculate the best placement.
CheapestInsertionResult result =
CheapestInsertionHelper.CalculateBestPlacement(problem, current_route, customers);
// calculate the new weight.
double potential_weight = calculator.CalculateOneRouteIncrease(current_route_weight, result.Increase);
// cram as many customers into one route as possible.
if (potential_weight < problem.Max.Value)
{
// insert the customer, it is
customers.Remove(result.Customer);
//current_route.InsertAfterAndRemove(result.CustomerBefore, result.Customer, result.CustomerAfter);
current_route.InsertAfter(result.CustomerBefore, result.Customer);
current_route_weight = potential_weight;
//// improve if needed.
////if (improvement_probalitity > OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(1))
//if (((problem.Size - customers.Count) % _k) == 0)
//{ // an improvement is descided.
// current_route_weight = this.ImproveIntraRoute(problem,
// current_route, current_route_weight);
//}
}
else
{// ok we are done!
//// apply the intra-route heuristics.
//for (int route_idx = 0; route_idx < solution.Count - 1; route_idx++)
//{ // apply the intra-route heurstic between the new and all existing routes.
// this.ImproveInterRoute(problem, solution.Route(route_idx), current_route);
//}
//// apply the inter-route heuristics.
//for (int route_idx = 0; route_idx < solution.Count; route_idx++)
//{ // apply heurstic for each route.
// IRoute route = solution.Route(route_idx);
// this.ImproveIntraRoute(problem, current_route, current_route_weight);
//}
// break the route.
break;
}
}
}
return(solution);
}
/// <summary>
/// Executes a solver procedure.
/// </summary>
/// <param name="problem"></param>
/// <returns></returns>
internal override MaxTimeSolution Solve(MaxTimeProblem problem)
{
// create the solution.
MaxTimeSolution solution = new MaxTimeSolution(problem.Size, true);
// keep placing customer until none are left.
List<int> customers = new List<int>(problem.Customers);
double max = problem.Max.Value - (problem.Max.Value * _delta_percentage);
// keep a list of cheapest insertions.
IInsertionCosts costs = new BinaryHeapInsertionCosts();
double percentage = _threshold_percentage;
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.
if (customers.Count > 0)
{
// select a customer using some heuristic.
int customer = -1;
if (_use_seed)
{ // use a seeding heuristic.
customer = this.SelectSeed(problem, problem.MaxTimeCalculator, solution, customers);
}
else
{ // just select a random customer.
customer = customers[Math.Random.StaticRandomGenerator.Get().Generate(customers.Count)];
}
customers.Remove(customer);
// start a route r.
IRoute current_route = solution.Add(customer);
solution[solution.Count - 1] = 0;
while (customers.Count > 0)
{
//OsmSharp.IO.Output.OutputStreamHost.WriteLine("{0}/{1} placed!",
// customers.Count, problem.Size);
// calculate the best placement.
CheapestInsertionResult result;
if (_use_seed_cost)
{ // use the seed cost; the cost to the seed customer.
result = CheapestInsertionHelper.CalculateBestPlacement(problem, current_route, customers,
customer, _lambda);
// 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, current_route, customers, costs);
}
// calculate the new weight.
solution[solution.Count - 1] = problem.Time(solution.Route(solution.Count - 1));
double potential_weight = problem.MaxTimeCalculator.CalculateOneRouteIncrease(solution[solution.Count - 1],
result.Increase);
// cram as many customers into one route as possible.
if (potential_weight < max)
{
// insert the customer, it is
customers.Remove(result.Customer);
current_route.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] = potential_weight;
// improve if needed.
if (((problem.Size - customers.Count) % _k) == 0)
{ // an improvement is descided.
// apply the inter-route improvements.
int count_before = solution.Route(solution.Count - 1).Count;
solution[solution.Count - 1] = this.ImproveIntraRoute(problem,
current_route, solution[solution.Count - 1]);
if (!solution.IsValid())
{
throw new Exception();
}
int count_after = solution.Route(solution.Count - 1).Count;
// also to the inter-improvements.
current_route = 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;
}
}
//else
//{// ok we are done!
// solution[solution.Count - 1] = this.ImproveIntraRoute(problem,
// current_route, solution[solution.Count - 1]);
// if (!solution.IsValid())
// {
// throw new Exception();
// }
// int count_after = solution.Route(solution.Count - 1).Count;
// this.Improve(problem, solution, max, solution.Count - 1);
// // break the route.
// break;
//}
}
}
// remove empty routes.
for (int route_idx = solution.Count - 1; route_idx >= 0; route_idx--)
{
if (solution.Route(route_idx).IsEmpty)
{
solution.Remove(route_idx);
}
}
return solution;
}
/// <summary>
/// Executes a solver procedure.
/// </summary>
/// <param name="problem"></param>
/// <returns></returns>
internal override MaxTimeSolution Solve(MaxTimeProblem problem)
{
// create the solution.
MaxTimeSolution solution = new MaxTimeSolution(problem.Size, true);
// keep placing customer until none are left.
List <int> customers = new List <int>(problem.Customers);
double max = problem.Max.Value - (problem.Max.Value * _delta_percentage);
// keep a list of cheapest insertions.
IInsertionCosts costs = new BinaryHeapInsertionCosts();
double percentage = _threshold_percentage;
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.
if (customers.Count > 0)
{
// select a customer using some heuristic.
int customer = -1;
if (_use_seed)
{ // use a seeding heuristic.
customer = this.SelectSeed(problem, problem.MaxTimeCalculator, solution, customers);
}
else
{ // just select a random customer.
customer = customers[Math.Random.StaticRandomGenerator.Get().Generate(customers.Count)];
}
customers.Remove(customer);
// start a route r.
IRoute current_route = solution.Add(customer);
solution[solution.Count - 1] = 0;
while (customers.Count > 0)
{
//OsmSharp.IO.Output.OutputStreamHost.WriteLine("{0}/{1} placed!",
// customers.Count, problem.Size);
// calculate the best placement.
CheapestInsertionResult result;
if (_use_seed_cost)
{ // use the seed cost; the cost to the seed customer.
result = CheapestInsertionHelper.CalculateBestPlacement(problem, current_route, customers,
customer, _lambda);
// 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, current_route, customers, costs);
}
// calculate the new weight.
solution[solution.Count - 1] = problem.Time(solution.Route(solution.Count - 1));
double potential_weight = problem.MaxTimeCalculator.CalculateOneRouteIncrease(solution[solution.Count - 1],
result.Increase);
// cram as many customers into one route as possible.
if (potential_weight < max)
{
// insert the customer, it is
customers.Remove(result.Customer);
current_route.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] = potential_weight;
// improve if needed.
if (((problem.Size - customers.Count) % _k) == 0)
{ // an improvement is descided.
// apply the inter-route improvements.
int count_before = solution.Route(solution.Count - 1).Count;
solution[solution.Count - 1] = this.ImproveIntraRoute(problem,
current_route, solution[solution.Count - 1]);
if (!solution.IsValid())
{
throw new Exception();
}
int count_after = solution.Route(solution.Count - 1).Count;
// also to the inter-improvements.
current_route = 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;
}
}
//else
//{// ok we are done!
// solution[solution.Count - 1] = this.ImproveIntraRoute(problem,
// current_route, solution[solution.Count - 1]);
// if (!solution.IsValid())
// {
// throw new Exception();
// }
// int count_after = solution.Route(solution.Count - 1).Count;
// this.Improve(problem, solution, max, solution.Count - 1);
// // break the route.
// break;
//}
}
}
// remove empty routes.
for (int route_idx = solution.Count - 1; route_idx >= 0; route_idx--)
{
if (solution.Route(route_idx).IsEmpty)
{
solution.Remove(route_idx);
}
}
return(solution);
}
internal override MaxTimeSolution Solve(MaxTimeProblem problem)
{
MaxTimeCalculator calculator = new MaxTimeCalculator(
problem);
// generate a ATSP solution.
IRoute tsp_solution = _tsp_solution;
if (tsp_solution == null)
{
tsp_solution = _tsp_solver.Solve(new TSPProblem(problem));
}
// generate subtours from this solution.
MaxTimeSolution solution = new MaxTimeSolution(problem.Size, true);
// select a random start point.
int start = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(problem.Size);
// start the first tour.
int placed = 0;
int previous = -1;
// place the first customer.
double weight = 0;
double total_weight = 0;
IRoute route = solution.Add(start);
previous = start;
while (placed < problem.Size)
{
// get the next customer from the tsp solution.
int next = tsp_solution.GetNeigbours(previous)[0];
// get the weight to the current start.
double weight_to_next = problem.WeightMatrix[previous][next];
double weight_to_start = problem.WeightMatrix[next][start];
total_weight = calculator.CalculateOneRouteIncrease(
weight, weight_to_next + weight_to_start);
weight = calculator.CalculateOneRouteIncrease(
weight, weight_to_next);
if (total_weight > problem.Max.Value)
{ // start a new route.
route = solution.Add(next);
weight = 0;
}
else
{ // just insert the next customer.
route.InsertAfter(previous, next);
//route.InsertAfterAndRemove(previous, next, -1);
}
// set the previous.
previous = next;
placed++;
}
if (!solution.IsValid())
{
throw new Exception();
}
StringBuilder builder = new StringBuilder();
builder.Append("[");
total_weight = 0;
for (int idx = 0; idx < solution.Count; idx++)
{
//IRoute route = routes.Route(idx);
route = solution.Route(idx);
weight = calculator.CalculateOneRoute(route);
builder.Append(" ");
builder.Append(weight);
builder.Append(" ");
total_weight = total_weight + weight;
}
builder.Append("]");
builder.Append(total_weight);
builder.Append(": ");
builder.Append(calculator.Calculate(solution));
OsmSharp.Logging.Log.TraceEvent("TSPPlacementSolver", TraceEventType.Information, builder.ToString());
return solution;
}
/// <summary>
/// Executes a solver procedure.
/// </summary>
/// <param name="problem"></param>
/// <returns></returns>
internal override MaxTimeSolution Solve(MaxTimeProblem problem)
{
MaxTimeCalculator calculator = new MaxTimeCalculator(problem);
// get the seed customers.
ICollection <int> seeds = _seed_selector.SelectSeeds(
problem, _k);
double[] weights = new double[seeds.Count];
// start the seed routes.
List <int> selectable_customers = problem.Customers;
MaxTimeSolution routes = new MaxTimeSolution(
problem.Size, true);
foreach (int seed in seeds)
{
routes.Add(seed);
selectable_customers.Remove(seed);
}
if (!routes.IsValid())
{
throw new Exception();
}
// keep a list of cheapest insertions.
IInsertionCosts costs = new BinaryHeapInsertionCosts();
// keep looping until all customers have been placed.
while (selectable_customers.Count > 0)
{
// try and place into every route.
CheapestInsertionResult best_result = new CheapestInsertionResult();
best_result.Increase = float.MaxValue;
int best_route_idx = -1;
CheapestInsertionResult best_result_above_max = new CheapestInsertionResult();
best_result_above_max.Increase = float.MaxValue;
int best_route_above_max_idx = -1;
for (int route_idx = 0; route_idx < routes.Count; route_idx++)
{
IRoute current_route = routes.Route(route_idx);
// choose the next customer.
CheapestInsertionResult result =
CheapestInsertionHelper.CalculateBestPlacement(problem, current_route, selectable_customers, costs);
if (result.Customer == result.CustomerAfter)
{
throw new Exception();
}
// get the current weight
double weight = weights[route_idx];
if (result.Increase < best_result.Increase)
{
if (weight + result.Increase + calculator.DeliveryTime < problem.Max.Value)
{ // route will still be inside bounds.
best_result = result;
best_route_idx = route_idx;
}
else
{ // route will become above max.
if (result.Increase < best_result_above_max.Increase)
{
best_result_above_max = result;
best_route_above_max_idx = route_idx;
}
}
}
}
// do the placement if a placement is found without max violation.
// else do the placement in the above max route.
CheapestInsertionResult placement_result = new CheapestInsertionResult();
placement_result.Increase = double.MaxValue;
int placement_result_idx = -1;
if (best_route_idx >= 0)
{ // best placement found.
placement_result = best_result;
placement_result_idx = best_route_idx;
}
else
{ // best placement found but only above max.
placement_result = best_result_above_max;
placement_result_idx = best_route_above_max_idx;
}
// do the actual placement.
weights[placement_result_idx] = calculator.CalculateOneRouteIncrease(
weights[placement_result_idx], placement_result.Increase);
selectable_customers.Remove(placement_result.Customer);
//routes.Route(placement_result_idx).InsertAfterAndRemove(
// placement_result.CustomerBefore, placement_result.Customer, placement_result.CustomerAfter);
routes.Route(placement_result_idx).InsertAfter(
placement_result.CustomerBefore, placement_result.Customer);
if (!routes.IsValid())
{
throw new Exception();
}
}
return(routes);
}
/// <summary>
/// Calculates a solution.
/// </summary>
/// <param name="problem"></param>
/// <returns></returns>
internal override MaxTimeSolution Solve(MaxTimeProblem problem)
{
// create the calculator.
MaxTimeCalculator calculator = new MaxTimeCalculator(problem);
// create the solution.
MaxTimeSolution solution = new MaxTimeSolution(problem.Size, true);
double max = problem.Max.Value;
// keep placing customer until none are left.
List <int> customers = new List <int>(problem.Customers);
// create n routes.
for (int customer = 0; customer < customers.Count; customer++)
{
solution.Add(customer);
solution[solution.Count - 1] = calculator.CalculateOneRouteIncrease(
0, 0);
}
// creates a result.
MergeResult result = new MergeResult();
result.Weight = double.MaxValue;
// loop over all route pairs and merge the smallest merge.
while (result != null)
{ // keep looping until there is no result anymore.
result = new MergeResult();
result.Weight = double.MaxValue;
for (int route1_idx = 1; route1_idx < solution.Count; route1_idx++)
{ // keep looping over all routes.
for (int route2_idx = 0; route2_idx < solution.Count; route2_idx++)
{ // keep looping over all routes.
if (route1_idx == route2_idx)
{ // only consider different routes.
break;
}
// calculate the merge result.
MergeResult current_result = this.TryMerge(problem, solution,
route1_idx, route2_idx, problem.Max.Value);
// evaluate the current result.
if (current_result != null && current_result.Weight < result.Weight)
{ // current result is best.
result = current_result;
}
}
}
// evaluate the result.
if (result.Weight < double.MaxValue)
{ // there is a result; apply it!
IRoute source = solution.Route(result.RouteSourceId);
IRoute target = solution.Route(result.RouteTargetId);
//string source_string = source.ToString();
//string target_string = target.ToString();
if (target.Count > 1 && target.First == target.GetNeigbours(result.CustomerTargetSource)[0])
{
//throw new Exception();
}
// create an enumeration of all customers of source in the correct order.
IEnumerable <int> source_between = new List <int>(
source.Between(result.CustomerSourceSource, result.CustomerSourceTarget));
// insert after the complete source.
int previous = result.CustomerTargetSource;
int next = target.GetNeigbours(result.CustomerTargetSource)[0];
foreach (int source_customer in source_between)
{
// insert.
target.ReplaceEdgeFrom(previous, source_customer);
previous = source_customer; // update previous.
}
target.ReplaceEdgeFrom(previous, next);
// remove the source route.
solution.Remove(result.RouteSourceId);
solution.RemoveWeight(result.RouteTargetId);
// calculate the weight of the new route.
solution[result.RouteTargetId] = solution[result.RouteTargetId] + result.Weight +
solution[result.RouteSourceId];
if (!solution.IsValid())
{
throw new Exception();
}
}
else
{ // set the result null.
result = null;
}
}
return(solution);
}
/// <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;
}
public void TestDepotDynamicAsymmetricMultiRouteExchanges()
{
// create two routes.
// 0->11->12->13->14->15->0
// 0->21->22->23->24->25->0
var multiRoute = new MaxTimeSolution(0);
IRoute route1 = multiRoute.Add();
var customers = new List <int>(route1);
Assert.AreEqual(1, customers.Count);
Assert.AreEqual(0, customers[0]);
route1.InsertAfter(0, 11);
Assert.AreEqual("0->11", route1.ToString());
route1.InsertAfter(11, 12);
route1.InsertAfter(12, 13);
route1.InsertAfter(13, 14);
route1.InsertAfter(14, 15);
IRoute route2 = multiRoute.Add();
customers = new List <int>(route2);
Assert.AreEqual(1, customers.Count);
Assert.AreEqual(0, customers[0]);
route2.InsertAfter(0, 21);
Assert.AreEqual("0->21", route2.ToString());
route2.InsertAfter(21, 22);
route2.InsertAfter(22, 23);
route2.InsertAfter(23, 24);
route2.InsertAfter(24, 25);
customers = new List <int>(route1);
Assert.AreEqual(6, customers.Count);
Assert.AreEqual(0, customers[0]);
Assert.AreEqual(11, customers[1]);
Assert.AreEqual(12, customers[2]);
Assert.AreEqual(13, customers[3]);
Assert.AreEqual(14, customers[4]);
Assert.AreEqual(15, customers[5]);
customers = new List <int>(route2);
Assert.AreEqual(6, customers.Count);
Assert.AreEqual(0, customers[0]);
Assert.AreEqual(21, customers[1]);
Assert.AreEqual(22, customers[2]);
Assert.AreEqual(23, customers[3]);
Assert.AreEqual(24, customers[4]);
Assert.AreEqual(25, customers[5]);
// replace the entire first route.
route1.ReplaceEdgeFrom(0, 0);
route2.ReplaceEdgeFrom(25, 11);
route2.ReplaceEdgeFrom(11, 12);
route2.ReplaceEdgeFrom(12, 13);
route2.ReplaceEdgeFrom(13, 14);
route2.ReplaceEdgeFrom(14, 15);
Assert.IsTrue(multiRoute.IsValid());
// create two routes.
// 0->11->12->13->14->15->0
// 0->21->22->23->24->25->0
multiRoute = new MaxTimeSolution(0);
route1 = multiRoute.Add();
customers = new List <int>(route1);
Assert.AreEqual(1, customers.Count);
Assert.AreEqual(0, customers[0]);
route1.InsertAfter(0, 11);
Assert.AreEqual("0->11", route1.ToString());
route1.InsertAfter(11, 12);
route1.InsertAfter(12, 13);
route1.InsertAfter(13, 14);
route1.InsertAfter(14, 15);
route2 = multiRoute.Add();
customers = new List <int>(route2);
Assert.AreEqual(1, customers.Count);
Assert.AreEqual(0, customers[0]);
route2.InsertAfter(0, 21);
Assert.AreEqual("0->21", route2.ToString());
route2.InsertAfter(21, 22);
route2.InsertAfter(22, 23);
route2.InsertAfter(23, 24);
route2.InsertAfter(24, 25);
// exchange parts.
var part1 = new List <int>(route1.Between(11, 13));
var part2 = new List <int>(route2.Between(23, 25));
route1.ReplaceEdgeFrom(0, 14);
route2.ReplaceEdgeFrom(22, 0);
int previous = 0;
for (int idx = 0; idx < part2.Count; idx++)
{
route1.ReplaceEdgeFrom(previous, part2[idx]);
previous = part2[idx];
}
route1.ReplaceEdgeFrom(previous, 14);
previous = 22;
for (int idx = 0; idx < part1.Count; idx++)
{
route2.ReplaceEdgeFrom(previous, part1[idx]);
previous = part1[idx];
}
route2.ReplaceEdgeFrom(previous, 0);
Assert.IsTrue(multiRoute.IsValid());
customers = new List <int>(route1);
Assert.AreEqual(6, customers.Count);
Assert.AreEqual(0, customers[0]);
Assert.AreEqual(23, customers[1]);
Assert.AreEqual(24, customers[2]);
Assert.AreEqual(25, customers[3]);
Assert.AreEqual(14, customers[4]);
Assert.AreEqual(15, customers[5]);
customers = new List <int>(route2);
Assert.AreEqual(6, customers.Count);
Assert.AreEqual(0, customers[0]);
Assert.AreEqual(21, customers[1]);
Assert.AreEqual(22, customers[2]);
Assert.AreEqual(11, customers[3]);
Assert.AreEqual(12, customers[4]);
Assert.AreEqual(13, customers[5]);
// create two routes.
// 0->11->12->13->14->15->0
// 0->21->22->23->24->25->0
multiRoute = new MaxTimeSolution(0);
route1 = multiRoute.Add();
customers = new List <int>(route1);
Assert.AreEqual(1, customers.Count);
Assert.AreEqual(0, customers[0]);
route1.InsertAfter(0, 11);
Assert.AreEqual("0->11", route1.ToString());
route1.InsertAfter(11, 12);
route1.InsertAfter(12, 13);
route1.InsertAfter(13, 14);
route1.InsertAfter(14, 15);
route2 = multiRoute.Add();
customers = new List <int>(route2);
Assert.AreEqual(1, customers.Count);
Assert.AreEqual(0, customers[0]);
route2.InsertAfter(0, 21);
Assert.AreEqual("0->21", route2.ToString());
route2.InsertAfter(21, 22);
route2.InsertAfter(22, 23);
route2.InsertAfter(23, 24);
route2.InsertAfter(24, 25);
route1.ReplaceEdgeFrom(12, 15);
route1.ReplaceEdgeFrom(14, 11);
route1.ReplaceEdgeFrom(0, 13);
customers = new List <int>(route1);
Assert.AreEqual(6, customers.Count);
Assert.AreEqual(0, customers[0]);
Assert.AreEqual(13, customers[1]);
Assert.AreEqual(14, customers[2]);
Assert.AreEqual(11, customers[3]);
Assert.AreEqual(12, customers[4]);
Assert.AreEqual(15, customers[5]);
route1.ToString();
}