cscvrptw.cs

// Copyright 2010-2021 Google LLC
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

using System;
using System.Collections.Generic;
using Google.OrTools.ConstraintSolver;

/// <summary>
///   Sample showing how to model and solve a capacitated vehicle routing
///   problem with time windows using the swig-wrapped version of the vehicle
///   routing library in src/constraint_solver.
/// </summary>
public class CapacitatedVehicleRoutingProblemWithTimeWindows
{
    /// <summary>
    ///   A position on the map with (x, y) coordinates.
    /// </summary>
    class Position
    {
        public Position()
        {
            this.x_ = 0;
            this.y_ = 0;
        }

        public Position(int x, int y)
        {
            this.x_ = x;
            this.y_ = y;
        }

        public int x_;
        public int y_;
    }

    /// <summary>
    ///    A time window with start/end data.
    /// </summary>
    class TimeWindow
    {
        public TimeWindow()
        {
            this.start_ = -1;
            this.end_ = -1;
        }

        public TimeWindow(int start, int end)
        {
            this.start_ = start;
            this.end_ = end;
        }

        public int start_;
        public int end_;
    }

    /// <summary>
    /// Manhattan distance implemented as a callback. It uses an array of
    ///   positions and computes the Manhattan distance between the two
    ///   positions of two different indices.
    /// </summary>
    class Manhattan
    {
        public Manhattan(RoutingIndexManager manager, Position[] locations, int coefficient)
        {
            this.manager_ = manager;
            this.locations_ = locations;
            this.coefficient_ = coefficient;
        }

        public long Call(long first_index, long second_index)
        {
            if (first_index >= locations_.Length || second_index >= locations_.Length)
            {
                return 0;
            }
            int first_node = manager_.IndexToNode(first_index);
            int second_node = manager_.IndexToNode(second_index);
            return (Math.Abs(locations_[first_node].x_ - locations_[second_node].x_) +
                    Math.Abs(locations_[first_node].y_ - locations_[second_node].y_)) *
                   coefficient_;
        }

        private readonly RoutingIndexManager manager_;
        private readonly Position[] locations_;
        private readonly int coefficient_;
    };

    /// <summary>
    ///   A callback that computes the volume of a demand stored in an
    ///   integer array.
    /// </summary>
    class Demand
    {
        public Demand(RoutingIndexManager manager, int[] order_demands)
        {
            this.manager_ = manager;
            this.order_demands_ = order_demands;
        }

        public long Call(long index)
        {
            if (index < order_demands_.Length)
            {
                int node = manager_.IndexToNode(index);
                return order_demands_[node];
            }
            return 0;
        }

        private readonly RoutingIndexManager manager_;
        private readonly int[] order_demands_;
    };

    /// Locations representing either an order location or a vehicle route
    /// start/end.
    private Position[] locations_;
    /// Quantity to be picked up for each order.
    private int[] order_demands_;
    /// Time window in which each order must be performed.
    private TimeWindow[] order_time_windows_;
    /// Penalty cost "paid" for dropping an order.
    private int[] order_penalties_;
    /// Capacity of the vehicles.
    private int vehicle_capacity_ = 0;
    /// Latest time at which each vehicle must end its tour.
    private int[] vehicle_end_time_;
    /// Cost per unit of distance of each vehicle.
    private int[] vehicle_cost_coefficients_;
    /// Vehicle start and end indices. They have to be implemented as int[] due
    /// to the available SWIG-ed interface.
    private int[] vehicle_starts_;
    private int[] vehicle_ends_;

    /// Random number generator to produce data.
    private Random random_generator = new Random(0xBEEF);

    /// <summary>
    ///    Constructs a capacitated vehicle routing problem with time windows.
    /// </summary>
    private CapacitatedVehicleRoutingProblemWithTimeWindows()
    {
    }

    /// <summary>
    ///   Creates order data. Location of the order is random, as well
    ///   as its demand (quantity), time window and penalty.  ///
    ///   </summary>
    /// <param name="number_of_orders"> number of orders to build. </param>
    /// <param name="x_max"> maximum x coordinate in which orders are located.
    /// </param>
    /// <param name="y_max"> maximum y coordinate in which orders are located.
    /// </param>
    /// <param name="demand_max"> maximum quantity of a demand. </param>
    /// <param name="time_window_max"> maximum starting time of the order time
    /// window. </param>
    /// <param name="time_window_width"> duration of the order time window.
    /// </param>
    /// <param name="penalty_min"> minimum pernalty cost if order is dropped.
    /// </param>
    /// <param name="penalty_max"> maximum pernalty cost if order is dropped.
    /// </param>
    private void BuildOrders(int number_of_orders, int number_of_vehicles, int x_max, int y_max, int demand_max,
                             int time_window_max, int time_window_width, int penalty_min, int penalty_max)
    {
        Console.WriteLine("Building orders.");
        locations_ = new Position[number_of_orders + 2 * number_of_vehicles];
        order_demands_ = new int[number_of_orders];
        order_time_windows_ = new TimeWindow[number_of_orders];
        order_penalties_ = new int[number_of_orders];
        for (int order = 0; order < number_of_orders; ++order)
        {
            locations_[order] = new Position(random_generator.Next(x_max + 1), random_generator.Next(y_max + 1));
            order_demands_[order] = random_generator.Next(demand_max + 1);
            int time_window_start = random_generator.Next(time_window_max + 1);
            order_time_windows_[order] = new TimeWindow(time_window_start, time_window_start + time_window_width);
            order_penalties_[order] = random_generator.Next(penalty_max - penalty_min + 1) + penalty_min;
        }
    }

    /// <summary>
    /// Creates fleet data. Vehicle starting and ending locations are
    /// random, as well as vehicle costs per distance unit.
    /// </summary>
    ///
    /// <param name="number_of_orders"> number of orders</param>
    /// <param name="number_of_vehicles"> number of vehicles</param>
    /// <param name="x_max"> maximum x coordinate in which orders are located.
    /// </param>
    /// <param name="y_max"> maximum y coordinate in which orders are located.
    /// </param>
    /// <param name="end_time"> latest end time of a tour of a vehicle. </param>
    /// <param name="capacity"> capacity of a vehicle. </param>
    /// <param name="cost_coefficient_max"> maximum cost per distance unit of a
    /// vehicle (minimum is 1)</param>
    private void BuildFleet(int number_of_orders, int number_of_vehicles, int x_max, int y_max, int end_time,
                            int capacity, int cost_coefficient_max)
    {
        Console.WriteLine("Building fleet.");
        vehicle_capacity_ = capacity;
        vehicle_starts_ = new int[number_of_vehicles];
        vehicle_ends_ = new int[number_of_vehicles];
        vehicle_end_time_ = new int[number_of_vehicles];
        vehicle_cost_coefficients_ = new int[number_of_vehicles];
        for (int vehicle = 0; vehicle < number_of_vehicles; ++vehicle)
        {
            int index = 2 * vehicle + number_of_orders;
            vehicle_starts_[vehicle] = index;
            locations_[index] = new Position(random_generator.Next(x_max + 1), random_generator.Next(y_max + 1));
            vehicle_ends_[vehicle] = index + 1;
            locations_[index + 1] = new Position(random_generator.Next(x_max + 1), random_generator.Next(y_max + 1));
            vehicle_end_time_[vehicle] = end_time;
            vehicle_cost_coefficients_[vehicle] = random_generator.Next(cost_coefficient_max) + 1;
        }
    }

    /// <summary>
    ///   Solves the current routing problem.
    /// </summary>
    private void Solve(int number_of_orders, int number_of_vehicles)
    {
        Console.WriteLine("Creating model with " + number_of_orders + " orders and " + number_of_vehicles +
                          " vehicles.");
        // Finalizing model
        int number_of_locations = locations_.Length;

        RoutingIndexManager manager =
            new RoutingIndexManager(number_of_locations, number_of_vehicles, vehicle_starts_, vehicle_ends_);
        RoutingModel model = new RoutingModel(manager);

        // Setting up dimensions
        const int big_number = 100000;
        Manhattan manhattan_callback = new Manhattan(manager, locations_, 1);
        model.AddDimension(model.RegisterTransitCallback(manhattan_callback.Call), big_number, big_number, false,
                           "time");
        RoutingDimension time_dimension = model.GetDimensionOrDie("time");

        Demand demand_callback = new Demand(manager, order_demands_);
        model.AddDimension(model.RegisterUnaryTransitCallback(demand_callback.Call), 0, vehicle_capacity_, true,
                           "capacity");
        RoutingDimension capacity_dimension = model.GetDimensionOrDie("capacity");

        // Setting up vehicles
        Manhattan[] cost_callbacks = new Manhattan[number_of_vehicles];
        for (int vehicle = 0; vehicle < number_of_vehicles; ++vehicle)
        {
            int cost_coefficient = vehicle_cost_coefficients_[vehicle];
            Manhattan manhattan_cost_callback = new Manhattan(manager, locations_, cost_coefficient);
            cost_callbacks[vehicle] = manhattan_cost_callback;
            int manhattan_cost_index = model.RegisterTransitCallback(manhattan_cost_callback.Call);
            model.SetArcCostEvaluatorOfVehicle(manhattan_cost_index, vehicle);
            time_dimension.CumulVar(model.End(vehicle)).SetMax(vehicle_end_time_[vehicle]);
        }

        // Setting up orders
        for (int order = 0; order < number_of_orders; ++order)
        {
            time_dimension.CumulVar(order).SetRange(order_time_windows_[order].start_, order_time_windows_[order].end_);
            long[] orders = { manager.NodeToIndex(order) };
            model.AddDisjunction(orders, order_penalties_[order]);
        }

        // Solving
        RoutingSearchParameters search_parameters =
            operations_research_constraint_solver.DefaultRoutingSearchParameters();
        search_parameters.FirstSolutionStrategy = FirstSolutionStrategy.Types.Value.AllUnperformed;

        Console.WriteLine("Search...");
        Assignment solution = model.SolveWithParameters(search_parameters);

        if (solution != null)
        {
            String output = "Total cost: " + solution.ObjectiveValue() + "\n";
            // Dropped orders
            String dropped = "";
            for (int order = 0; order < number_of_orders; ++order)
            {
                if (solution.Value(model.NextVar(order)) == order)
                {
                    dropped += " " + order;
                }
            }
            if (dropped.Length > 0)
            {
                output += "Dropped orders:" + dropped + "\n";
            }
            // Routes
            for (int vehicle = 0; vehicle < number_of_vehicles; ++vehicle)
            {
                String route = "Vehicle " + vehicle + ": ";
                long order = model.Start(vehicle);
                if (model.IsEnd(solution.Value(model.NextVar(order))))
                {
                    route += "Empty";
                }
                else
                {
                    for (; !model.IsEnd(order); order = solution.Value(model.NextVar(order)))
                    {
                        IntVar local_load = capacity_dimension.CumulVar(order);
                        IntVar local_time = time_dimension.CumulVar(order);
                        route += order + " Load(" + solution.Value(local_load) + ") " + "Time(" +
                                 solution.Min(local_time) + ", " + solution.Max(local_time) + ") -> ";
                    }
                    IntVar load = capacity_dimension.CumulVar(order);
                    IntVar time = time_dimension.CumulVar(order);
                    route += order + " Load(" + solution.Value(load) + ") " + "Time(" + solution.Min(time) + ", " +
                             solution.Max(time) + ")";
                }
                output += route + "\n";
            }
            Console.WriteLine(output);
        }
    }

    public static void Main(String[] args)
    {
        CapacitatedVehicleRoutingProblemWithTimeWindows problem = new CapacitatedVehicleRoutingProblemWithTimeWindows();
        int x_max = 20;
        int y_max = 20;
        int demand_max = 3;
        int time_window_max = 24 * 60;
        int time_window_width = 4 * 60;
        int penalty_min = 50;
        int penalty_max = 100;
        int end_time = 24 * 60;
        int cost_coefficient_max = 3;

        int orders = 100;
        int vehicles = 20;
        int capacity = 50;

        problem.BuildOrders(orders, vehicles, x_max, y_max, demand_max, time_window_max, time_window_width, penalty_min,
                            penalty_max);
        problem.BuildFleet(orders, vehicles, x_max, y_max, end_time, capacity, cost_coefficient_max);
        problem.Solve(orders, vehicles);
    }
}