Mizux · September 30, 2021 17:44 · Mizux · Jul 26, 2021
diff --git a/cvrptw_pd.py b/cvrptw_pd.py
 #!/usr/bin/env python3
 """Capacitated Vehicle Routing Problem"""
 from six.moves import xrange
 from ortools.constraint_solver import pywrapcp
 from ortools.constraint_solver import routing_enums_pb2
 import networkx as nx
 import matplotlib.pyplot as plt
 import random
 import math
 import pandas as pd
 from csv import reader

 # Problem Data Definition #


 class Vehicle():
    def __init__(self):
        self._capacity = 9000
        # self.id = id
        self.routes = []
        self.time_min = []
        self.time_max = []
        self.load = []
        self.cm3 = []
        self._speed = 0.31  #mile/min

    @property
    def capacity(self):
        """Gets vehicle capacity"""
        return self._capacity

    def routes(self):
        return self.routes

    def speed(self):
        return self._speed


 class DataProblem():
    """Stores the data for the problem"""
    def __init__(self):
        """Initializes the data for the problem"""
        print("Data Model:")
        self._vehicle = Vehicle()
        self._num_vehicles = num_vehicles()
        self._locations = []
        self._demands = []
        self._time_windows = []
        self._cm3 = []
        self._locationID = []
        self._pickups_deliveries = []

        df = pd.read_csv("order_info_7.23.csv", encoding="utf-8")
        last_id = df.shape[0] + 1

        # df = df[df['提货日期'] == 1]
        # df = df[df['ID'] != 65]  # 广西异常地址

        global start_node
        global end_node
        total_length = len(df["装货地址维度"].tolist())
        start_node = 0
        # end_node = total_length + 1
        end_node = start_node
        # print(df)

        # set lat/lon incl. first and last node
        p_lat = df["装货地址维度"].tolist()
        p_lon = df["装货地址经度"].tolist()
        d_lat = df["卸货地址维度"].tolist()
        d_lon = df["卸货地址经度"].tolist()
        lat = p_lat + d_lat
        lon = p_lon + d_lon
        dummy_lat = df["卸货地址维度"].tolist()[0]
        dummy_lon = df["卸货地址经度"].tolist()[0]
        lat.insert(0, dummy_lat)
        lon.insert(0, dummy_lon)
        # lat.append(dummy_lat)
        # lon.append(dummy_lon)
        self._locations = list(zip(lat, lon))
        # print("locations: ", self._locations)
        # print("length locations: ", len(self._locations))

        #set first and last node for each vehicle
        self._starts = [0] * num_vehicles()
        self._ends = [0] * num_vehicles()
        #self._ends = [len(lat) - 1] * num_vehicles()
        # print("start node: ", self._starts)
        # print("end node: ", self._ends)

        # set time window incl. first and last node
        p_earliest = df['最早装货时间'].tolist()
        p_latest = df['最晚装货时间'].tolist()
        d_earliest = [480] * len(p_earliest)
        d_latest = [1320] * len(p_latest)
        earliest = p_earliest + d_earliest
        latest = p_latest + d_latest
        earliest.insert(0, 0)
        latest.insert(0, 1320)
        # earliest.append(480)
        # latest.append(1320)
        self._time_windows = list(zip(earliest, latest))
        print("time windows: ", self._time_windows)

        #set weight and cm3 incl. first and last node
        self.p_demands = df["毛重(KGS)"].tolist()
        self.p_cm3 = df["体积(CBM)"].tolist()
        self.d_demands = [0 - x for x in self.p_demands]
        self.d_cm3 = [0 - x for x in self.p_cm3]
        self._demands = self.p_demands + self.d_demands
        self._cm3 = self.p_cm3 + self.d_cm3
        self._demands.insert(0, start_node)
        self._cm3.insert(0, start_node)
        # self._demands.append(0)
        # self._cm3.append(0)
        print("weight: ", self._demands)
        # print("cm3: ", self._cm3)
        print("cm3 length: ", len(self._cm3))
        print("pickup demand: ", self._demands[26])
        print("delivery demand: ", self._demands[64])

        # get index of a certain day
        self._locationID = df["ID"].tolist()
        self._locationID.insert(0, 0)
        # self._locationID.append(last_id)
        # print("ID list: ", self._locationID)
        merge = self._locationID + self._locationID[1:]
        self._locationID = merge
        print("ID list: ", self._locationID)
        self.map = pd.DataFrame(merge).reset_index()
        self.map.columns = ['模型地址编号', '订单地址编号']
        self.map["实际地址编号"] = self.map["模型地址编号"]
        self.map["地址类型"] = 0
        last_loadid = self._locationID[-1]
        self.map.loc[self.map['模型地址编号'] <= last_loadid, '地址类型'] = "装货"
        self.map.loc[self.map['模型地址编号'] > last_loadid, '地址类型'] = "卸货"
        self.map.loc[self.map['模型地址编号'] == 0, '地址类型'] = "起点"
        print("\nmodel_node_index vs actual_node_index vs ordersheet_index\n",
              self.map.to_string(index=False))

        #set pickup & delivery pairs
        pickups = self.map[self.map['地址类型'] == "装货"]["模型地址编号"].tolist()
        deliveries = self.map[self.map['地址类型'] == "卸货"]["模型地址编号"].tolist()
        for i, n in enumerate(pickups):
            temp = [n, deliveries[i]]
            self._pickups_deliveries.append(temp)
        print("pickups_deliveries: ", self._pickups_deliveries)

    @property
    def getvehicle(self):
        """Gets a vehicle"""
        return self._vehicle

    @property
    def num_vehicles(self):
        """Gets number of vehicles"""
        return self._num_vehicles

    @property
    def locations(self):
        """Gets locations"""
        return self._locations

    @property
    def num_locations(self):
        """Gets number of locations"""
        return len(self.locations)

    @property
    def depot(self):
        """Gets depot location index"""
        return self._depot

    @property
    def demands(self):
        """Gets demands at each location"""
        return self._demands

    @property
    def cm3(self):
        """Gets cm3 at each location"""
        return self._cm3

    @property
    def time_per_demand_unit(self):
        """Gets the time (in min) to load a demand"""
        return 120

    @property
    def time_windows(self):
        """Gets (start time, end time) for each locations"""
        return self._time_windows

    @property
    def starts(self):
        """Gets start location for each truck"""
        return self._starts

    @property
    def ends(self):
        """Gets end location for each truck"""
        return self._ends


 ## Problem Constraints
 class CreateDistanceEvaluator(object):  # pylint: disable=too-few-public-methods
    """Creates callback to return distance between points."""
    def __init__(self, data, manager):
        """Initializes the distance matrix."""
        self._distances = {}
        self.manager = manager
        self.dist_matrix = []

        # precompute distance between location to have distance callback in O(1)
        total_matrix = []
        with open("dist_matrix_7.23.csv", 'r') as read_obj:
            csv_reader = reader(read_obj)
            list_of_rows = list(csv_reader)
            for n in list_of_rows:
                n = [int(i) for i in n]
                total_matrix.append(n)
            # print("total matrix: ", len(total_matrix))

        print("location num: ", data.num_locations)
        for from_node in xrange(data.num_locations):
            convert_from = data._locationID[from_node]
            temp = []
            for to_node in xrange(data.num_locations):
                convert_to = data._locationID[to_node]
                if from_node == to_node:
                    temp.append(0)
                else:
                    if from_node in data.starts or to_node in data.starts:
                        temp.append(0)
                    else:
                        dist = int(total_matrix[convert_from - 1][convert_to - 1] / 1000)
                        temp.append(dist)

            self.dist_matrix.append(temp)
        #print("dist matrix: ", self.dist_matrix)
        #print("dist matrix: ", len(self.dist_matrix))

    def distance_evaluator(self, from_index, to_index):
        """Returns the Harversine Distance between the two nodes"""
        from_node = self.manager.IndexToNode(from_index)
        to_node = self.manager.IndexToNode(to_index)
        value = self.dist_matrix[from_node][to_node]
        #print(f"dist({from_node},{to_node}): {value}")
        return value

    def define_total_cost(self, data, routing, manager):
        for vehicle_idx in range(data.num_vehicles):

            def vehicle_cost_callback(from_index, to_index, i=vehicle_idx):
                from_node = manager.IndexToNode(from_index)
                to_node = manager.IndexToNode(to_index)
                value = int(cost_vector()[i] * self.dist_matrix[from_node][to_node])
                #print(f"v: {i}, cost({from_node},{to_node}): {value}")
                return 10 #value

            cost_callback_index = routing.RegisterTransitCallback(vehicle_cost_callback)
            routing.SetArcCostEvaluatorOfVehicle(cost_callback_index, vehicle_idx)


 class CreateDemandEvaluator(object):
    """Creates callback to get demands at each location."""
    def __init__(self, data, manager):
        """Initializes the demand array."""
        self._demands = data.demands
        self._manager = manager

    def demand_evaluator(self, from_index):
        """Returns the demand of the current node"""
        from_node = self._manager.IndexToNode(from_index)
        value = int(self._demands[from_node])
        #print(f"demand({from_node}): {value}")
        return value


 class CreateCM3Evaluator(object):
    """Creates callback to get cm3 at each location."""
    def __init__(self, data, manager):
        """Initializes the demand array."""
        self._cm3 = data.cm3
        self._manager = manager

    def cm3_evaluator(self, from_index):
        """Returns the cm3 of the current node"""
        from_node = self._manager.IndexToNode(from_index)
        value = int(self._cm3[from_node])
        #print(f"cm3({from_node}): {value}")
        return value


 class CreateTimeEvaluator(object):
    """Creates callback to get total times between locations."""
    def __init__(self, data, manager):
        """Initializes the total time matrix."""
        self._total_time = {}
        self._manager = manager
        self.time_matrix = []

        total_matrix = []
        with open("time_matrix_7.23.csv", 'r') as read_obj:
            csv_reader = reader(read_obj)
            list_of_rows = list(csv_reader)
            for n in list_of_rows:
                n = [int(i) for i in n]
                total_matrix.append(n)
            # print("total matrix: ", len(total_matrix))

        for from_node in xrange(data.num_locations):
            self._total_time[from_node] = {}
            convert_from = data._locationID[from_node]
            temp = []
            for to_node in xrange(data.num_locations):
                self._total_time[from_node][to_node] = 0
                convert_to = data._locationID[to_node]
                if from_node == to_node:
                    temp.append(0)
                else:
                    if from_node in data.starts or to_node in data.starts:
                        self._total_time[from_node][to_node] = 0
                        temp.append(0)
                    else:
                        travel_time = total_matrix[convert_from - 1][convert_to - 1] / 60
                        service_time = self.service_time(data, from_node)
                        total_time = int(travel_time + service_time)
                        temp.append(total_time)
                        self._total_time[from_node][to_node] = total_time
            self.time_matrix.append(temp)
        #print("time matrix: ", self.time_matrix)
        #print("time matrix: ", len(self.time_matrix))

    @staticmethod
    def service_time(data, node):
        """Gets the service time for the specified location."""
        # return data.demands[node] * data.time_per_demand_unit  #function of volume at this node
        return data.time_per_demand_unit  #constant service time for all nodes

    def time_evaluator(self, from_index, to_index):
        """Returns the total time between the two nodes"""
        from_node = self._manager.IndexToNode(from_index)
        to_node = self._manager.IndexToNode(to_index)
        value = self._total_time[from_node][to_node]
        #print(f"time({from_node},{to_node}): {value}")
        return value


 def add_distance_dimension(routing, transit_callback_index, data, manager):
    """Add Global Span constraint"""
    distance = "Distance"
    maximum_distance = 800
    routing.AddDimension(
        transit_callback_index,
        0,  # null slack
        maximum_distance,  # maximum distance per vehicle
        True,  # start cumul to zero
        distance)
    # distance_dimension = routing.GetDimensionOrDie(distance)
    # Try to minimize the max distance among vehicles.
    # /!\ It doesn't mean the standard deviation is minimized
    # distance_dimension.SetGlobalSpanCostCoefficient(100)


 def add_capacity_constraints(routing, data, demand_callback_index, manager):
    """Adds capacity constraint"""
    capacity = "Capacity"
    routing.AddDimensionWithVehicleCapacity(
        demand_callback_index,
        0,  # null capacity slack
        capacity_vector(),  # vector vehicle_capacity
        True,  # start cumul to zero
        capacity)


 def allow_dropping(routing, data, manager):
    # Allow to drop nodes.
    global penalty
    penalty = 1_000_000
    for node in range(0, manager.GetNumberOfNodes()):
        if node in data.starts or node in data.ends: # starts node can't be dropped
            continue
        print(f"allow drop: {node}")
        routing.AddDisjunction([manager.NodeToIndex(node)], penalty)


 def setup_PDP(routing, data, manager):
    # Define Transportation Requests.
    distance_dimension = routing.GetDimensionOrDie("Distance")
    for pickup, delivery in data._pickups_deliveries:
        #print(f"Add PDP [{pickup},{delivery}]")
        pickup_index = manager.NodeToIndex(pickup)
        delivery_index = manager.NodeToIndex(delivery)
        routing.AddPickupAndDelivery(pickup_index, delivery_index)
        routing.solver().Add(
            routing.VehicleVar(pickup_index) == routing.VehicleVar(delivery_index))
        routing.solver().Add(
            distance_dimension.CumulVar(pickup_index) <=
            distance_dimension.CumulVar(delivery_index))


 def add_cm3_constraints(routing, data, demand_callback_index):
    """Adds capacity constraint"""
    cm3 = "cm3"
    routing.AddDimensionWithVehicleCapacity(
        demand_callback_index,
        0,  # null capacity slack
        cm3_vector(),  # vector vehicle_capacity
        True,  # start cumul to zero
        cm3)


 def add_time_window_constraints(routing, data, time_callback_index, manager):
    """Add Global Span constraint"""
    time = "Time"
    # horizon = 2000
    horizon = 1320
    routing.AddDimension(
        time_callback_index,
        480,  # allow waiting time
        horizon,  # maximum time per vehicle
        False,  # don't force start cumul to zero since we are giving TW to start nodes
        time)
    time_dimension = routing.GetDimensionOrDie(time)
    # print("len time_window: ", data.time_windows)

    # set time window for each customer location's visiting time
    for location_idx, time_window in enumerate(data.time_windows):
        if location_idx in data.starts or location_idx in data.ends:
            continue
        index = manager.NodeToIndex(location_idx)
        time_dimension.CumulVar(index).SetRange(time_window[0], time_window[1])
        routing.AddToAssignment(time_dimension.SlackVar(index))

    # set time window for each vehicle's start and end location
    for vehicle_id in xrange(data.num_vehicles):
        index = routing.Start(vehicle_id)
        index_end = routing.End(vehicle_id)
        # Instantiate route start and end times to produce feasible times.
        routing.AddVariableMinimizedByFinalizer(time_dimension.CumulVar(index))
        routing.AddVariableMinimizedByFinalizer(time_dimension.CumulVar(index_end))
        # set a constraint on the start or the end node for each vehicle, which is not included in above
        time_dimension.CumulVar(index).SetRange(
            data.time_windows[start_node][0], data.time_windows[start_node][1])
        time_dimension.CumulVar(index_end).SetRange(
            data.time_windows[end_node][0], data.time_windows[end_node][1])
        routing.AddToAssignment(time_dimension.SlackVar(index))


 ###########
 # Printer #
 ###########

 vlist = []
 load_list = []
 time_list_min = []
 time_list_max = []


 class ConsolePrinter():
    """Print solution to console"""
    def __init__(self, data, manager, routing, assignment):
        """Initializes the printer"""
        self._data = data
        self._manager = manager
        self._routing = routing
        self._assignment = assignment

    @property
    def data(self):
        """Gets problem data"""
        return self._data

    @property
    def routing(self):
        """Gets routing model"""
        return self._routing

    @property
    def assignment(self):
        """Gets routing model"""
        return self._assignment

    @property
    def manager(self):
        """Gets routing model"""
        return self._manager

    def print(self):
        """Prints assignment on console"""
        dropped_nodes = []
        global drop_count
        drop_count = 0
        for node in range(self.routing.Size()):
            if self.routing.IsStart(node) or self.routing.IsEnd(node):
                continue
            if self.assignment.Value(self.routing.NextVar(node)) == node:
                dropped_nodes.append(
                    mapID(self._data.map, self.manager.IndexToNode(node)))
                drop_count += 1

        if len(dropped_nodes) > 0:
            print("dropped nodes: ", dropped_nodes)
            print(f'Objective: {self.assignment.ObjectiveValue()}')
            print(
                f'Objective excl. penalties: {self.assignment.ObjectiveValue() - drop_count*penalty}\n'
            )
        else:
            print(f'Objective: {self.assignment.ObjectiveValue()}\n')

        # Inspect solution.
        dist_dimension = self.routing.GetDimensionOrDie('Distance')
        capacity_dimension = self.routing.GetDimensionOrDie('Capacity')
        cm3_dimension = self.routing.GetDimensionOrDie('cm3')
        time_dimension = self.routing.GetDimensionOrDie('Time')
        total_dist = 0
        total_time = 0
        global vlist
        global new_vlist
        global load_list
        global time_list_min
        global time_list_max
        for vehicle_id in xrange(self._data.num_vehicles):
            index = self.routing.Start(vehicle_id)
            plan_output = f'Route for vehicle {vehicle_id}:\n'
            #plan_output = f'车辆ID {vehicle_id}, 线路规划明细:\n'
            route_dist = 0
            route_time = 0
            this_vehicle = Vehicle()
            while not self.routing.IsEnd(index):
                node_index = self.manager.IndexToNode(index)
                # print(node_index)
                this_vehicle.routes.append(
                    mapID(self._data.map, self.manager.IndexToNode(index)))
                # print(this_vehicle.routes)
                # print(self._data.vehicle.routes)
                # print(self._data.vehicle.routes.append(temp_id))
                next_node_index = self.manager.IndexToNode(
                    self.assignment.Value(self.routing.NextVar(index)))
                # route_dist += distance(
                #   self._data.locations[node_index][0],
                #   self._data.locations[node_index][1],
                #   self._data.locations[next_node_index][0],
                #   self._data.locations[next_node_index][1])
                load_var = capacity_dimension.CumulVar(index)
                cm3_var = cm3_dimension.CumulVar(index)
                # print("load_var: ", load_var)
                route_load = self.assignment.Value(load_var)
                # route_load += self._data.demands[node_index]
                cm3_load = self.assignment.Value(cm3_var)
                dist_var = dist_dimension.CumulVar(index)
                route_dist = self.assignment.Value(dist_var)
                time_var = time_dimension.CumulVar(index)
                time_min = self.assignment.Min(time_var)
                time_max = self.assignment.Max(time_var)
                this_vehicle.load.append(route_load)
                this_vehicle.cm3.append(cm3_load)
                this_vehicle.time_min.append(time_min)
                this_vehicle.time_max.append(time_max)
                slack_var = time_dimension.SlackVar(index)
                slack_min = self.assignment.Min(slack_var)
                slack_max = self.assignment.Max(slack_var)
                plan_output += ' {0} Load({1}) Time({2},{3}) Slack({4},{5}) ->'.format(
                #plan_output += ' 地址:{0} 装载量({1}) 最早与最晚到达时间({2},{3}) 呆滞停留时间({4},{5}) ->'.format(
                    # node_index,
                    mapID(self._data.map, node_index),
                    route_load,
                    time_min,
                    time_max,
                    slack_min,
                    slack_max)
                index = self.assignment.Value(self.routing.NextVar(index))
                # print("start printing", plan_output)

            node_index = self.manager.IndexToNode(index)
            load_var = capacity_dimension.CumulVar(index)
            cm3_var = cm3_dimension.CumulVar(index)
            # print("truck type: ", str(load_var).split("..")[1][:-1])
            route_load = self.assignment.Value(load_var)
            cm3_load = self.assignment.Value(cm3_var)
            dist_var = dist_dimension.CumulVar(index)
            time_var = time_dimension.CumulVar(index)
            route_dist = self.assignment.Value(dist_var)
            route_time = self.assignment.Value(time_var)
            time_min = self.assignment.Min(time_var)
            time_max = self.assignment.Max(time_var)
            # total_dist += route_dist
            # total_time += route_time
            # plan_output += '汇总:\n'
            plan_output += ' {0} Load({1}) Time({2},{3})\n'.format(
            #plan_output += ' 地址:{0} 装载量({1}) 最早与最晚到达时间({2},{3})\n'.format(
                mapID(self._data.map, node_index), route_load, time_min, time_max)
            plan_output += '车型: {0} \n'.format(
                GetTruckType(int(str(load_var).split("..")[1][:-1])))
            plan_output += '总里程: {0} km\n'.format(int(route_dist))
            plan_output += '总装载公斤: {0}\n'.format(route_load)
            plan_output += '总装载立方: {0}\n'.format(cm3_load)
            plan_output += '总耗时: {0} min\n'.format(route_time - 480)
            vlist.append(this_vehicle.routes)
            total_dist += route_dist
            total_time += route_time
            print(plan_output)

            this_vehicle.routes.append(mapID(self._data.map, end_node))
            this_vehicle.load.append(route_load)
            this_vehicle.cm3.append(cm3_load)
            this_vehicle.time_min.append(time_min)
            this_vehicle.time_max.append(time_max)
            # vlist.append(this_vehicle.routes)
            load_list.append(this_vehicle.load)
            time_list_min.append(this_vehicle.time_min)
            time_list_max.append(this_vehicle.time_max)

        # print(vlist)
        print('总里程（所有线路）: {0} km'.format(int(total_dist)))
        print('总时长（所有线路）: {0} min'.format(int(total_time)))
        temp = vlist.copy()
        new_vlist = RemoveStartDepot(temp)
        # print('vlist: ', vlist)
        # print('new vlist: ', new_vlist)


 def mapID(df, id):
    actual_id = df.loc[df['模型地址编号'] == id, '实际地址编号'].iloc[0]
    # print("model id: ", id, " -> actual id: ",actual_id)
    return actual_id


 def mapID_reverse(df, id):
    model_id = df.loc[df['实际地址编号'] == id, '模型地址编号'].iloc[0]
    # print("model id: ", id, " -> actual id: ",actual_id)
    return model_id


 def RemoveStartDepot(temp):
    new = []
    for i in temp:
        x = i[1:]
        new.append(x)
    return new


 def PickupColor(count):
    default_cl = [
        "red", "blue", "yellowgreen", "orange", "hotpink", "orchid", "black",
        "purple", "slateblue", "olive", "steelblue", "magenta", "cadetblue",
        "teal", "lightseagreen", "deepskyblue", "olivedrab", "darkkhaki",
        "sandybrown", "tomato"
    ]
    if count <= len(default_cl) - 1:
        color = default_cl[count]
    else:
        #     temp=random.choice(list(matplotlib.colors.cnames.items()))[0]
        #     while "white" in temp or "gray" in temp and temp in default_cl:
        #         temp = random.choice(list(matplotlib.colors.cnames.items()))[0]
        #         continue
        #     cl=temp
        rand = lambda: random.randint(70, 170)
        color = '#%02X%02X%02X' % (rand(), rand(), rand())
    return color


 def DrawNetwork(data):
    G = nx.DiGraph()
    locations = DataProblem()._locations
    # print(locations)
    x = 0
    # for vehicle_id in vlist:
    for vehicle_id in new_vlist:
        n = 0
        e = []
        node = []
        cl = PickupColor(x)
        for i in vehicle_id:
            k = mapID_reverse(data.map, i)
            # G.add_node(i, pos=(locations[i][1], locations[i][0]))
            G.add_node(i, pos=(locations[k][1], locations[k][0]))
            node.append(i)
            if n > 0:
                u = (vehicle_id[n - 1], vehicle_id[n])
                # u = (new[n - 1], new[n])
                e.append(u)
                node.append(i)
                G.add_edge(vehicle_id[n - 1], vehicle_id[n])
            n += 1
        nx.draw(G,
                nx.get_node_attributes(G, 'pos'),
                nodelist=node,
                edgelist=e,
                with_labels=True,
                node_color=cl,
                width=2,
                edge_color=cl,
                style='dashed',
                font_color='w',
                font_size=12,
                font_family='sans-serif')
        x += 1
    # let's color the node 0 in black
    # nx.draw_networkx_nodes(G, locations, nodelist=[0], node_color='k')
    plt.axis('on')
    # plt.show()


 ########
 # Main #
 ########


 def test():
    data = DataProblem()


 def main():
    """Entry point of the program"""
    # Instantiate the data problem.
    data = DataProblem()

    # Create Routing Model Manager
    # manager = pywrapcp.RoutingIndexManager(data.num_locations, data.num_vehicles, data.starts, data.ends)
    manager = pywrapcp.RoutingIndexManager(data.num_locations, data.num_vehicles, data.starts, data.ends)
    # manager = pywrapcp.RoutingIndexManager(data.num_locations, data.num_vehicles, data.depot)
    print(f"DEBUG: {dir(manager)}")
    print(f"number of locations: {manager.GetNumberOfNodes()}")
    print(f"number of vehicles: {manager.GetNumberOfVehicles()}")
    print(f"starts: {data.starts}")
    assert manager.GetNumberOfVehicles() == len(data.starts)
    print(f"ends: {data.ends}")
    assert manager.GetNumberOfVehicles() == len(data.ends)
    #exit(42)

    # Create Routing Model
    routing = pywrapcp.RoutingModel(manager)

    # Add Distance constraint
    dist_evaluator = CreateDistanceEvaluator(data, manager)
    dist_evaluator.define_total_cost(data, routing, manager)

    distance_callback_index = routing.RegisterTransitCallback(dist_evaluator.distance_evaluator)
    add_distance_dimension(routing, distance_callback_index, data, manager)

    # Add Capacity constraint
    demand_evaluator = CreateDemandEvaluator(data, manager).demand_evaluator
    demand_callback_index = routing.RegisterUnaryTransitCallback(demand_evaluator)
    add_capacity_constraints(routing, data, demand_callback_index, manager)

    # Add Cubic Meters constraint
    cm3_evaluator = CreateCM3Evaluator(data, manager).cm3_evaluator
    cm3_callback_index = routing.RegisterUnaryTransitCallback(cm3_evaluator)
    add_cm3_constraints(routing, data, cm3_callback_index)

    # Add Time Window constraint
    time_evaluator = CreateTimeEvaluator(data, manager).time_evaluator
    time_callback_index = routing.RegisterTransitCallback(time_evaluator)
    add_time_window_constraints(routing, data, time_callback_index, manager)

    # Allow dropping nodes if solution infeasible
    #allow_dropping(routing, data, manager)

    # Allow setup pickups and deliveries pairs
    setup_PDP(routing, data, manager)

    # Setting first solution heuristic (cheapest addition).
    search_parameters = pywrapcp.DefaultRoutingSearchParameters()
    # 1).First Solution Heuristic
    #search_parameters.first_solution_strategy = (
    #    routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)
    search_parameters.first_solution_strategy = (
        routing_enums_pb2.FirstSolutionStrategy.PARALLEL_CHEAPEST_INSERTION)

    #search_parameters.log_search = True
    #search_parameters.time_limit.seconds = 20
    #search_parameters.time_limit.seconds = 120
    # 2).Guided Local Search Heuristics
    search_parameters.local_search_metaheuristic = (
        routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)
    search_parameters.log_search = True
    search_parameters.time_limit.seconds = 20
    # 3).Simulated Annealing Heuristics
    # search_parameters.local_search_metaheuristic = (
    #     routing_enums_pb2.LocalSearchMetaheuristic.SIMULATED_ANNEALING)
    # search_parameters.time_limit_ms = 1800000
    # 4).TABU_SEARCH Heuristics
    # search_parameters.local_search_metaheuristic = (
    #  routing_enums_pb2.LocalSearchMetaheuristic.TABU_SEARCH)
    # search_parameters.log_search = True
    # search_parameters.time_limit.seconds = 60

    # Solve the problem.
    # assignment = routing.SolveWithParameters(search_parameters)
    solution = routing.SolveWithParameters(search_parameters)
    if solution:
        print("Solution found !\n")
        #print("该方案有最优解！\n")
        printer = ConsolePrinter(data, manager, routing, solution)
        printer.print()
        DrawNetwork(data)
        # Reporting(data)
        plt.show()
    else:
        print("No Solution found !\n")
        #print("该方案无解！请修改车辆数！\n")


 def num_vehicles():
    global t1
    global t2
    global t3
    global t4
    global t5
    global t6
    global t7
    global t8

    #which_button_is_selected = "自动"
    which_button_is_selected = "test"
    if which_button_is_selected == "test":
        t1 = 36
        t2 = 36
        t3 = 36
        t4 = 36
        t5 = 36
        t6 = 36
        t7 = 36
        t8 = 36
    if which_button_is_selected == "手动":
        t1 = 3
        t2 = 3
        t3 = 3
        t4 = 3
        t5 = 3
        t6 = 3
        t7 = 3
        t8 = 3
    if which_button_is_selected == "自动":
        t1 = 50
        t2 = 50
        t3 = 50
        t4 = 50
        t5 = 50
        t6 = 50
        t7 = 50
        t8 = 50
    # print("total trucks: ", t1+t2+t3+t4+t5)
    return t1 + t2 + t3 + t4 + t5 + t6 + t7 + t8


 def capacity_vector():
    return [1500] * t1 + [1800] * t2 + [4000] * t3 + [6500] * t4 + [
        7000
    ] * t5 + [8500] * t6 + [9500] * t7 + [12000] * t8


 def cm3_vector():
    return [10] * t1 + [16] * t2 + [28] * t3 + [34] * t4 + [40] * t5 + [
        45
    ] * t6 + [50] * t7 + [55] * t8


 def cost_vector():
    return [7] * t1 + [8] * t2 + [9.38] * t3 + [10.42] * t4 + [10.67] * t5 + [
        12
    ] * t6 + [13] * t7 + [14.55] * t8


 def GetTruckType(item):
    if item == 1500:
        return "3T车型"
    if item == 1800:
        return "5T车型"
    if item == 4000:
        return "8T车型"
    if item == 6500:
        return "10T车型"
    if item == 7000:
        return "12T车型"
    if item == 8500:
        return "15T车型"
    if item == 9500:
        return "18T车型"
    if item == 12000:
        return "20T车型"


 if __name__ == '__main__':
    main()
    # test()
diff --git a/diff.md b/diff.md
diff --git a/zz.md b/zz.md