两阶段启发式算法求解带时间窗车辆路径问题（附Java代码）

1. 文档阅读说明

本文档是作者利用Java编程语言编写的启发式算法求解带时间窗车辆路径问题。包括两大部分：一是带时间窗车辆路径问题描述；二是编程算法求解代码及说明（并附录Solomon经典案例求解结果）。

2. VRPTW定义

标准的带时间窗车辆路径问题定义如下：

1. 车辆从某一车场出发，服务后返回该车场；
2. 每个顾客有且被一辆车服务一次；
3. 服务有时间窗限制，车辆可早到，但不允许晚到；
4. 车辆有最大旅行时间和容量限制；
5. 所使用的车辆数不超过最大可使用车辆数量。

基于上述问题，本文档在IntelliJ IDEA平台利用Java语言进行编程，求解该车辆路径问题。主要利用贪心策略求解。核心程序的各个部分如下所示：

3. Java数据读取（附Java代码）

1. 原始数据格式：以Solomon数据案例C101_25为例：

C101_25

VEHICLE
NUMBER CAPACITY
10 200

CUSTOMER
CUST NO. XCOORD. YCOORD. DEMAND READY TIME DUE DATE SERVICE TIME

0 35.00 35.00 0.00 0.00 230.00 0.00
1 41.00 49.00 10.00 161.00 171.00 10.00
2 35.00 17.00 7.00 50.00 60.00 10.00
3 55.00 45.00 13.00 116.00 126.00 10.00
……
上述是Solomon经典案例的某一个案例的原始数据，各行代表的意思如下：
第一行：案例编号
第二行：空行（注意读取数据时需要跳过，下同）
第三行：车辆信息
第四行：车辆数量 每辆车装载能力
第五行：空行
第六行：客户信息
第七行：客户编码 X坐标 Y坐标 需求量 开始服务时间 结束服务时间 服务时间
第八行之后：按照第七行顺序所列的具体客户信息

2. 读取该数据的说明如下：

算法运行的前提是需要输入客户、车辆等的数据，那么如何读取这些数据呢？下面以读取Solomon数据案例C101_25为例进行说明。代码及其代码说明如下

public class Reader {
   
    public static Instance readInstance(File file) throws FileNotFoundException {
   
        Scanner scanner = new Scanner(file);
        String line = scanner.nextLine().trim();
        line = scanner.nextLine().trim();
        line = scanner.nextLine().trim();
        line = scanner.nextLine().trim();
        line = scanner.nextLine().trim();

        String [] parts = line.split("\\s+");
        int nrVehicles = Integer.parseInt(parts[0]);
        int capacity = Integer.parseInt(parts[1]);

        line = scanner.nextLine().trim();
        line = scanner.nextLine().trim();
        line = scanner.nextLine().trim();
        line = scanner.nextLine().trim();
        //line = scanner.nextLine().trim();
        int nrCustomers = 101;//根据客户数量进行修改
        int duration;
        int [] customerID = new int [nrCustomers];
        int [][] coordinates = new int [nrCustomers][2];
        int [] demands = new int [nrCustomers];
        int [][] timeWindows = new int [nrCustomers][2];
        int [] serviceTime = new int [nrCustomers];

        int justy = 0;
        for (int i = 0;i < nrCustomers;i++){
   
            line = scanner.nextLine().trim();
            parts = line.split("\\s+");
            
            if (justy==0){
   
                int cusID = Integer.parseInt(parts[0])-1;
                int x_coor = (int)Double.parseDouble(parts[1]);
                int y_coor = (int)Double.parseDouble(parts[2]);
                int demand = (int)Double.parseDouble(parts[3]);
                int start_Time =(int) Double.parseDouble(parts[4]);
                int end_Time =(int) Double.parseDouble(parts[5]);
                int service_Time =(int) Double.parseDouble(parts[6]);

                customerID [i] = cusID;
                coordinates[i][0] = x_coor;
                coordinates[i][1] = y_coor;
                demands[i] = demand;
                timeWindows[i][0] = start_Time;
                timeWindows[i][1] = end_Time;
                serviceTime [i] = service_Time;
            }else {
   
                int cusID = Integer.parseInt(parts[0]);
                int x_coor = Integer.parseInt(parts[1]);
                int y_coor = Integer.parseInt(parts[2]);
                int demand = Integer.parseInt(parts[3]);
                int start_Time = Integer.parseInt(parts[4]);
                int end_Time = Integer.parseInt(parts[5]);
                int service_Time = Integer.parseInt(parts[6]);

                customerID [i] = cusID;
                coordinates[i][0] = x_coor;
                coordinates[i][1] = y_coor;
                demands[i] = demand;
                timeWindows[i][0] = start_Time;
                timeWindows[i][1] = end_Time;
                serviceTime [i] = service_Time;
            }
        }
        duration = timeWindows[0][1];

        double [][] distanceMatrix = new double [nrCustomers][nrCustomers];
        double [][] travelTimes = new double [nrCustomers][nrCustomers];
        
        for (int i=0;i<nrCustomers;i++){
   
            for (int j=0;j<nrCustomers;j++){
   
                if (i!=j) {
   
                   if (i<j) {
   
                       double x = Math.pow((coordinates[i][0] - coordinates[j][0]), 2);
                       double y = Math.pow((coordinates[i][1] - coordinates[j][1]), 2);
                       distanceMatrix[i][j] = Math.sqrt(x + y);

                       distanceMatrix[i][j] = (int) (distanceMatrix[i][j] * 100);
                       distanceMatrix[i][j] =  distanceMatrix[i][j] / 100;

                       travelTimes[i][j] = distanceMatrix[i][j];
                   }else {
   
                       distanceMatrix[i][j] = distanceMatrix[j][i];
                       travelTimes[i][j] = travelTimes[j][i];
                   }
                }else{
   
                    distanceMatrix[i][j] = 0;
                    travelTimes[i][j] = 0;
                }
            }
        }
        return new Instance(file.getName(),nrCustomers,nrVehicles,duration,capacity,customerID,demands,timeWindows,distanceMatrix,travelTimes,coordinates,serviceTime);
    }
}

注意：在上面的读取数据代码中，String [] parts = line.split(“\s+”); 语句需要注意你的数据间隔 是 “空格” 还是**“Tab”** 键。这两个视觉效果是一样的。不过计算机能分辨差异。当初小编初学时曾在这坑里蹲了一天。没发现错在哪里。

4. 两阶段启发式算法（附Java代码）

4.1. 基于随机贪心策略的初始解生成（附Java代码）

在读取数据之后，就可以根据这些数据进行初始解的产生，本文档利用随机贪心策略生成初始解。在介绍随机贪心策略之前，先介绍下贪心策略生成初始解方法。

在贪心策略中，一般将未被访问的客户逐个插入路径中，并对每个插入成本进行排序，选择引起成本增加最少的客户，将其插入路径中。

但是我们在实验中发现，上述策略得到的初始解较差，主要是贪心策略是一种短视的策略。因此我们利用随机贪心策略。即在排序后，保留N个最小成本的插入策略，从这N个插入策略中随机选择一个策略，并将对应客户插入路径中。利用此方法得到的初始解，经过验证比单纯的贪心策略好很多，甚至对一些30个客户的案例都能直接得到最优解。

具体Java代码如下：

package heuristicAlgorithm;
import model