panbaoran913
panbaoran913

[PDPTW]解读Python调用Gurobi求解PDPTW问题（Li & Lim‘s benchmark)之一

参考资料:《使用Python调用Gurobi求解PDPTW问题（Li & Lim’s benchmark》

下一篇：《【PDPTW】python调用guribo求解PDPTW问题（Li & Lim‘s benchmark）之二》

1 .构造图片中的数据

t2=pd.DataFrame([[10,100,1,2, 2,2,2,2,2],
              [0, 0, 0, 0,0,1000, 0,0,0],
              [1, 0,10,10,0,1000,10,0,2],
             [2, 0,20,-10,0,1000,10,1,0],
             [3, 0,30,20,0,1000,20,0,4],
             [4,0,40,-20,0,1000,20,3,0],
             [5,10,40,30,0,1000,30,0,6],
             [6,10,30,-30,0,1000,30,5,0],
             [7,10,20,40,0,1000,40,0,8],
             [8,10,10,40,0,1000,50,7,0],
             [9,0, 0, 0, 0,1000,0, 0, 0]],dtype="int64") 

t2.to_csv("smallcase.txt",index=0,sep="\t",header=0)

代开“smallcase.txt"文件,手动删除第一行所有的2,使得10,100,1后面是回车符号
[PDPTW]解读Python调用Gurobi求解PDPTW问题（Li & Lim‘s benchmark)之一_第1张图片

对比一下,构造的数据与原数据loc101.txt的格式相同.注意我这里设置的数据类型也是整型而不是浮点型.
2. 数据含义
第一行:代表车辆的信息
10 100 1表示,车辆的个数为10,其容量为100,车速为1.
25 200 1表示,车辆的个数为25,其容量为200,车速为1.
除首行外:

‘TaskNo’ ,‘X’, ‘Y’ ‘Demand’ ‘ET’ ‘LT’ ‘ST’ ‘PI’ ‘DI’
1 0 10 10.0 0.0 1000.0 10.0 0.0 2.0
2 0 20 -10.0 0.0 1000.0 10.0 1.0 0.0

为了防止误会,这里的“TaskNo"在这里说成node的ID.

  • 在节点1.其(x,y)=(0,10),有一个(取货)装载10辆车的需求任务.在节点1的最早服务时间为EarliestTime=ET=0,最晚的服务时间为LatestTime=LT=1000.在节点1的服务时间消耗为ServiceTime=ST=10. 并将取货和送货地点联系起来. Di是送货节点的id.(Pi是取货节点的ID).
  • 在节点2.其(x,y)=(0,20),有一个(送货)卸载10辆车的需求任务.在节点2的最早服务时间为EarliestTime=ET=0,最晚的服务时间为LatestTime=LT=1000.在节点2的服务时间消耗为ServiceTime=ST=10. 并将取货和送货地点联系起来. Di是送货节点的id.(Pi是取货节点的ID).
  • 即这两条可以合并为一个取送货的问题.从节点1取货10运送到节点2卸货10.在lc101.txt中8行和10行就可以这样对应起来.
  • 在第一行和最后一行,其需求任务为0的节点设置为Depot,一个为出发depot,另一个为返回depot.

一、读取数据

  • 车辆信息
  • depot和节点的(x,y)坐标信息、demand信息、服务窗口时间信息、服务时间信息,
  • 任务索引(比如从8送到10)
ef read_txt_data(DataPath):
    # 读取车辆信息
    VehiclesInfo=pd.read_table(DataPath,nrows=1,names=['K','C','S'])
    Vehicles={}
    for i in range(VehiclesInfo.iloc[0,0]):
        Vehicles[i]=[VehiclesInfo.iloc[0,1],VehiclesInfo.iloc[0,2]] # 键i=车辆的序号，值为[车辆容量、速度]
    #print(Vehicles)
    
    # 读取Depot和任务信息
    ColumnNames=['TaskNo','X','Y','Demand','ET','LT','ST','PI','DI']
    # [任务标号,x坐标,y坐标,需求任务]
    TaskData=pd.read_table(DataPath,skiprows=[0],names=ColumnNames,index_col='TaskNo')
    
    # 提取Depot和取送货点（Customer）的位置坐标 Locations
    nrows=TaskData.shape[0]
    Locations={}
    for i in range(nrows):
        if i not in Locations.keys(): 
            Locations[i]=[TaskData.iloc[i,0],TaskData.iloc[i,1]] # 键为depot或客户编号，值为相应的坐标（x，y）
    
    # 提取Depot和取送货点的Demand
    Demand={}
    for i in range(nrows):
        if i not in Demand.keys(): 
            Demand[i]=TaskData.iloc[i,2]
    #print('Demand',Demand)
    
    # 提取Depot和取送货点的最早和最晚取送货时间及时间窗
    TimeWindow={}
    EarliestTime=TaskData.sort_values(by='ET').iloc[0,3]
    LatestTime=TaskData.sort_values(by='LT',ascending=False).iloc[0,4]
    for i in range(nrows):
        if i not in TimeWindow.keys(): 
            TimeWindow[i]=[TaskData.iloc[i,3],TaskData.iloc[i,4]]
    
    # 提取Depot和取送货点的服务时间ServiceTime
    ServiceTime={}
    for i in range(nrows):
        if i not in ServiceTime.keys(): 
            ServiceTime[i]=TaskData.iloc[i,5]
    
    # 提取运输Request
    # 对于取货任务，PICKUP索引为0，而同一行的DELIVERY索引给出相应送货任务的索引
    Request={}
    count = 0 # 记录运输需求的数量
    for i in range(1,nrows-1):
        if TaskData.iloc[i,6] == 0:
            Request[count]=[i,TaskData.iloc[i,7]]   # 将取送货点组合在一起，键为count，值为[取货点，送货点]
            count += 1
    
    return Vehicles,Locations,Demand,TimeWindow,ServiceTime,Request,nrows,EarliestTime,LatestTime

二、计算距离矩阵(位置距离,时间距离)

  1. 定义距离的公式(欧式距离)
def calculate_euclid_distance(x1, y1, x2, y2):
    """  计算Euclid距离.

    具体描述：计算两点(x1, y1), (x2, y2)之间的Euclid距离.
    """
    EuclidDistance = math.sqrt((x2-x1)**2 + (y2-y1)**2)
    return EuclidDistance
  1. 构建距离矩阵
def construct_distance_matrix(Locations):
    # 构建距离矩阵
    DistanceMatrix = {}
    for i in Locations.keys():
        for j in Locations.keys():
                if i != j:
                    DistanceMatrix[i, j] = calculate_euclid_distance(Locations[i][0], Locations[i][1], 
                                                                     Locations[j][0], Locations[j][1])
            
    # 尝试获取字典DistanceMatrix中最大的值
    key=max(DistanceMatrix, key=DistanceMatrix.get)
    LongestDistance=DistanceMatrix[key] 
    return DistanceMatrix,LongestDistance
  1. 构建时间矩阵
def construct_time_matrix(Vehilces,DistanceMatrix):
    # Vehilces是一个list性质的
    # DistanceMatrix是一个字典
    TimeMatrix={}
    for k in range(len(Vehilces)):
        for i in Locations.keys():
            for j in Locations.keys():
                if i != j:
                    TimeMatrix[i, j, k] = DistanceMatrix[i, j] / Vehilces[k][1]
    return TimeMatrix

三、建立pdptw问题的模型

3.1 公式约束

[PDPTW]解读Python调用Gurobi求解PDPTW问题（Li & Lim‘s benchmark)之一_第2张图片
[PDPTW]解读Python调用Gurobi求解PDPTW问题（Li & Lim‘s benchmark)之一_第3张图片
目标函数（11）使总路由成本最小化。
约束（12）规定每个顶点必须被精确地服务一次。
等式（13）和（14）保证每辆车从车辆段出发，并在其路线结束时返回车辆段。请注意，这并不意味着必须使用每辆车。车辆只能使用弧线 （ 0 ， n + n ~ + 1 ） （0，n+\tilde{n}+1） （0，n+n~+1），即不离开车辆段。
（15）确保了流量守恒。
时间变量用于消除（16）中的子时间，假定 （ t i j k + d i ) > 0 , ∀ ( i , j ) ∈ A （t^k_{ij}+d_i)>0,\forall (i,j)\in A （tijk​+di​)>0,∀(i,j)∈A.
约束条件（17）和（18）保证车辆在整个行程中不超过其容量。应注意，该公式需要引入额外的决策变量 Q i k Q^k_i Qik​，对应于车辆k在顶点i处的总负载。这些变量不需要用于公式化基本VRP，但对于将其扩展到提货和交货问题是必不可少的。在VRP公式中，有时使用类似于（17）的不等式来确保路线连通性（由上述公式中的（16）完成）。此外，在（17）中，仅PDVRP（PDTSP）需要相等。对于所有其他VRPPD类型，可以用“≥”代替。
（16）和（17）中给出的非线性约束可以使用大M公式进行线性化（参见Cordeau 2006）。
(23)(24)时间窗口和最大路由持续时间限制

[PDPTW]解读Python调用Gurobi求解PDPTW问题（Li & Lim‘s benchmark)之一_第4张图片
大M转换法:

  • Q i k ≤ m a x ( C k , C k + q j ) Q_i^k \leq max(C^k,C^k+q_j) Qik​≤max(Ck,Ck+qj​):离开i点时的负载量 Q i k Q_i^k Qik​,在 q j < 0 q_j<0 qj​<0时即要装载的时候,不能超过 C k − ∣ q j ∣ C^k-\vert q_j\vert Ck−∣qj​∣. 所以大M法为: Q i k ≤ Q j k + q j + M ( 1 − x i j k ) Q_i^k\leq Q_j^k+q_j+M(1-x^k_{ij}) Qik​≤Qjk​+qj​+M(1−xijk​)
  • 同理,换为: Q i k ≥ Q j k − q j − M ( 1 − x i j k ) Q_i^k \geq Q_j^k-q_j -M(1-x_{ij}^k) Qik​≥Qjk​−qj​−M(1−xijk​)

3.2 学习gurobipy中的Model()

一般来说，求解一个数学规划模型的时候，通常会按照如下步骤解决问题:
设置变量—addVar()。
更新变量空间—update()。
设定目标函数—setObjective()。
设定约束条件—addConstr()。
执行最优化—optimize()。

Gurobi model object.  Commonly used methods on this object are:
  getConstrs(): Get a list of constraints in the model
  getJSONSolution(): Get a JSON-string representation of the current solution(s) to the model
  getParamInfo(paramname): Get information on a model parameter.
  getVars(): Get a list of variables in the model
  optimize(): Optimize the model.
  printAttr(attrname, filter): Print attribute values.
  printQuality(): Print solution quality statistics.
  printStats(): Print model statistics.
  read(filename): Read model data (MIP start, basis, etc.) from a file
  reset(): Discard any resident solution information.
  resetParams(): Reset all parameters to their default values.
  setParam(paramname, newval): Set a model parameter to a new value.
  write(filename): Write model data to a file.

Additional methods on this object are:
addConstr(), addGenConstrMax(), addGenConstrMin(), addGenConstrAbs(),
addGenConstrAnd(), addGenConstrOr(), addGenConstrNorm(),
addGenConstrIndicator(), aaddGenConstrPWL(), addGenConstrPoly(),
addGenConstrExp(), addGenConstrExpA(), addGenConstrLog(),
addGenConstrLogA(), addGenConstrPow(), addGenConstrSin(),
addGenConstrCos(), addGenConstrTan(), addGenConstrLogistic(),
addRange(), addSOS(), addVar(), chgCoeff(), computeIIS(), copy(), fixed(),
getCoeff(), getCol(), getRow(), message(), presolve(), relax(), terminate(),
update()

参考资料:《Gurobi使用(一)——操作指南》

addVar()
x = model.addVar(lb=0.0, ub=gurobipy.GRB.INFINITY, vtype=gurobipy.GRB.CONTINUOUS, name="")

lb=0.0:变量的下界，默认为0.0。
ub=gurobipy.GRB.INFINITY:变量的上界，默认为无穷大。
vtype=gurobipy.GRB.CONTINUOUS:变量的类型，默认为连续型号。变为GRB.BINARY则是0-1变量，变为GRB.INTEGER则为整数变量。
name=“”:变量名，默认为空。

3.3 建立PDPTW的Model()

1. 添加变量: x i j k , B i k , Q i k x_{ij}^k, B_i^k,Q_i^k xijk​,Bik​,Qik​
# 创建模型
 model = Model()#gurobipy中的Model()
 # 变量下标存放字典
 xindex = {}     # 存储变量xijk的下标ijk，表示车辆k是否经过弧ij
 qindex = {}     # 存储变量qik的下标ik，表示车辆k即将离开i时的载货量
 bindex = {}     # 存储变量bik的下标ik，表示车辆k开始服务i的时间
 for k in Vehicles.keys():
     for i in range(nrows):
         qindex[i,k] = 0
         bindex[i,k] = 0
         for j in range(nrows):
             if i != j:
                 xindex[i,j,k] = 0
 
 x = model.addVars(xindex.keys(), vtype=GRB.BINARY, name='x')  # 变量x_{ijk},GRB.BINARY表示{0,1}变量
 q = model.addVars(qindex.keys(), vtype=GRB.INTEGER, name='q')  # 变量q_{ik},GRB.INTEGER为整数变量
 b = model.addVars(bindex.keys(), vtype=GRB.CONTINUOUS, name='b')  # 变量b_{ik},GRB.CONTINUOUS为连续变量
2. 添加约束条件

约束(1)
除了depot外，每个节点只被服务一次.这里depot的id=0.P是连线的起点,D时连线的终点.
∀ i ∈ P ∪ D = { 1 , 2 , ⋯   , n , n + 1 , ⋯   , n + n } \forall i \in P\cup D=\{1,2,\cdots,n,n+1,\cdots,n+n\} ∀i∈P∪D={1,2,⋯,n,n+1,⋯,n+n}
∑ k ∈ K ∑ j : ( i , j ) ∈ A x i j k = 1 \sum_{k\in K}\sum_{j:(i,j)\in A}x^k_{ij}=1 k∈K∑​j:(i,j)∈A∑​xijk​=1

for i in range(1, nrows-1):
        model.addConstr(x.sum(i,'*','*') == 1)  # 星号*的用法

约束(2)和(3)
每辆车必须从depot出发，最后回到depot.其中起点的个数为n,终点的个数为 n ~ \tilde{n} n~
∀ k ∈ K \forall k \in K ∀k∈K
∑ j : ( 0 , j ) ∈ A x 0 , j k = 1 \sum_{j:(0,j)\in A}x_{0,j}^k=1 j:(0,j)∈A∑​x0,jk​=1
∑ i : ( i , n + n ~ + 1 ) ∈ A x i , n + n ~ + 1 k = 1 \sum_{i:(i,n+\tilde{n}+1)\in A} x^k_{i, n+\tilde{n}+1}=1 i:(i,n+n~+1)∈A∑​xi,n+n~+1k​=1

for k in Vehicles.keys():
    model.addConstr(x.sum(0,'*',k) == 1)       # 车辆k从depot出发
    model.addConstr(x.sum('*',nrows-1,k) == 1)       # 车辆k回到depot

约束(4)
Flow conservation 流平衡约束.车辆到达节点i的次数==车辆从节点i离开的次数(要么0要么1)
∀ k ∈ K \forall k \in K ∀k∈K
∀ j ∈ P ∪ D \forall j \in P\cup D ∀j∈P∪D
∑ j : ( i , j ) ∈ A x i j k − ∑ i : ( j , i ) ∈ A x j i k = 0 \sum_{j:(i,j)\in A}x^k_{ij}-\sum_{i:(j,i)\in A}x_{ji}^k=0 j:(i,j)∈A∑​xijk​−i:(j,i)∈A∑​xjik​=0

for k in Vehicles.keys():
    for i in range(1, nrows-1):                              
    # 车辆k在P和D的流平衡约束
        model.addConstr(x.sum(i,'*',k) == x.sum('*',i,k))

约束(5)
用时间变量来消除子回路约束. xindex[i,j,k]
∀ k ∈ K \forall k \in K ∀k∈K, ∀ ( i , j ) ∈ A \forall (i,j)\in A ∀(i,j)∈A

x i j k = 1 → B j k ≥ B i k + d i + t i j k x_{ij}^k=1 \to B_j^k \geq B_i^k+d_i+t_{ij}^k xijk​=1→Bjk​≥Bik​+di​+tijk​
大M线性化为
B j k + M ( 1 − x i j k ) ≥ B i k + d i + t i j k B_j^k+M(1-x_{ij}^k) \geq B_i^k+d_i+t_{ij}^k Bjk​+M(1−xijk​)≥Bik​+di​+tijk​

# 需要用大M法来线性化该约束，M定义为 2*(LatestTime+LongestDistance)
for i in xindex.keys():
    model.addConstr(b[i[1],i[2]] + 2 * (1 - x[i]) * (LatestTime+LongestDistance) >=
                    b[i[0],i[2]] + ServiceTime[i[0]] + TimeMatrix[i])

约束(6)
载货量平衡约束，需要用大M法来线性化该约束
∀ k ∈ K \forall k \in K ∀k∈K, ∀ ( i , j ) ∈ A \forall (i,j)\in A ∀(i,j)∈A
x i j k = 1 → Q j k = Q i k + q j x_{ij}^k=1 \to Q_j^k=Q_i^k+q_j xijk​=1→Qjk​=Qik​+qj​
大M线性化为:
Q j k + M ( 1 − x i j k ) ≥ Q i k + q j Q_j^k+M(1-x_{ij}^k) \geq Q_i^k +q_j Qjk​+M(1−xijk​)≥Qik​+qj​

# M定义为 100*车辆最大载量
for i in xindex.keys():
    model.addConstr(q[i[1],i[2]] + (1- x[i]) * (100*Vehicles[i[2]][0])>=
                    q[i[0],i[2]]+Demand[i[1]])

约束(7)
车辆载量约束
∀ i ∈ V , k ∈ K \forall i \in V, k\in K ∀i∈V,k∈K
m a x { 0 , q i } ≤ Q i k ≤ m i n { C k , C k + q i k } max\{0,q_i\} \leq Q_i^k \leq min\{C^k,C^k+q_i^k\} max{0,qi​}≤Qik​≤min{Ck,Ck+qik​}
转化为4个单向的条件约束
Q i k ≥ 0 Q_i^k \geq 0 Qik​≥0
Q i k ≥ q i Q_i^k \geq q_i Qik​≥qi​
Q i k ≤ C k Q_i^k \leq C^k Qik​≤Ck
Q i k ≤ C k + q i k Q_i^k \leq C^k+q_i^k Qik​≤Ck+qik​

for i in qindex.keys():
   model.addConstr(q[i]>=0)
   model.addConstr(q[i]>=Demand[i[0]])
   model.addConstr(q[i]<=Vehicles[i[1]][0])
   model.addConstr(q[i]<=Vehicles[i[1]][0]+Demand[i[0]])

约束(8)
添加depot的时间窗口约束,添加节点的时间窗口约束.这里的V包含depot和节点.depot的id为0.
∀ i ∈ V , ∀ k ∈ K \forall i \in V, \forall k \in K ∀i∈V,∀k∈K,
e i ≤ B i q ≤ l i e_i \leq B_i^q \leq l_i ei​≤Biq​≤li​

for k in range(len(Vehicles)):
     # 两个depot的时间窗约束
     model.addConstr(b[0,k] >= TimeWindow[0][0])
     model.addConstr(b[0,k] <= TimeWindow[0][1])
     model.addConstr(b[nrows-1,k] >= TimeWindow[nrows-1][0])
     model.addConstr(b[nrows-1,k] <= TimeWindow[nrows-1][1])

Request:{0: [1, 2], 1: [3, 4], 2: [5, 6], 3: [7, 8]}
在这里时设置了已经明确由 1 → 2 1 \to 2 1→2, 3 → 4 3\to 4 3→4这种线路的的节点的要满足时间窗口的要求.

    for k in range(len(Vehicles)):
        for r in range(len(Request)):
            # 运输请求i两个节点的左时间窗
            #Request:{0: [1, 2], 1: [3, 4], 2: [5, 6], 3: [7, 8]}
            #TW{0: [0, 1000], 1: [0, 1000], 2: [0, 1000], 3: [0, 1000],..}
            model.addConstr(b[Request[r][0],k]>=TimeWindow[Request[r][0]] [0])
            model.addConstr(b[Request[r][1],k]>=TimeWindow[Request[r][1]][0])
            # 运输请求i两个节点的右时间窗
            model.addConstr(b[Request[r][0],k]<=TimeWindow[Request[r][0]][1])
            model.addConstr(b[Request[r][1],k]<=TimeWindow[Request[r][1]][1])

为什么不对所有的节点设置时间窗口 呢?,这里我也没搞明白.为了方便理解,我将原市循环的 ( i , j ) → ( k , r ) (i,j) \to (k,r) (i,j)→(k,r)

# 按三引号内部的方式写，会导致错误KeyError: (0, 0)
for i in bindex.keys():
    model.addConstr(b[i] >= TimeWindow[i][0])
    model.addConstr(b[i] <= TimeWindow[i][1])

如果当前路径中要求存在一些特殊固定的路线.如:Request的时候,则做一些特殊的约束.

约束(9)
弧(i,j)必须由同一辆车经过(先取货再送货).假设这些弧集为特定的集合 A ~ \tilde{A} A~
∀ k ∈ K \forall k \in K ∀k∈K, ∀ ( i , j ) ∈ A ~ \forall (i,j)\in \tilde{A} ∀(i,j)∈A~
∑ j : ( i , j ) ∈ A ~ x i j k = ∑ i : ( i , j ) ∈ A ~ x i j k \sum_{j:(i,j)\in \tilde{A}}x_{ij}^k=\sum_{i:(i,j)\in \tilde{A}}x_{ij}^k j:(i,j)∈A~∑​xijk​=i:(i,j)∈A~∑​xijk​

    for r in range(len(Request)):
        for k in range(len(Vehicles)):
            model.addConstr(x.sum(Request[r][0],'*',k)==x.sum('*',Request[r][1],k))

约束(10)
弧(i,j)必须i在前,j在后.有顺序性
∀ k ∈ K \forall k \in K ∀k∈K, ∀ ( i , j ) ∈ A ~ \forall (i,j)\in \tilde{A} ∀(i,j)∈A~
B i k ≤ B j k B^k_i \leq B_j^k Bik​≤Bjk​

for r in range(len(Request)):
     for k in range(len(Vehicles)):
         model.addConstr(b[Request[r][0],k]<=b[Request[r][1],k])
3. 添加目标函数
    # 目标函数（3）:最小化车辆总的行驶距离
DistanceCost = 0
for k in range(len(Vehicles)):
    for i in range(len(Locations)):
        for j in range(len(Locations)):
            if i != j:
                DistanceCost += (DistanceMatrix[i,j] * x[i,j,k])
model.setObjective(DistanceCost, GRB.MINIMIZE)
4. 更新model
model.update()
model.__data = x,b,q

训练

start = time.time()
DataPath="smallcase.txt"
Vehicles,Locations,Demand,TimeWindow,ServiceTime,Request,nrows,EarliestTime,LatestTime = read_txt_data(DataPath)
# 构建距离矩阵
DistanceMatrix,LongestDistance = construct_distance_matrix(Locations)
# 构建通行时间矩阵
TimeMatrix = construct_time_matrix(Vehicles,DistanceMatrix)

# 建立与优化模型
model,xindex = build_pdptw_model(Vehicles,Locations,Demand,TimeWindow,ServiceTime,Request,nrows,EarliestTime,LatestTime,DistanceMatrix,LongestDistance,TimeMatrix)
model.params.TimeLimit = 1000    # 设定模型求解时间
model.write('PDPTW_%s.lp' % DataPath)
model.write('PDPTW_%s.mps' % DataPath)
model.setParam(GRB.Param.LogFile, 'PDPTW_%s.log' % DataPath)
model.optimize()
x,b,q = model.__data
# 输出方式2
for k in range(len(Vehicles)):
    for i in range(nrows):
        for j in range(nrows):
            if i != j:
                if (x[i,j,k].x - 0.5 > 0):
                    print('tour for vehicle %s:' % k)
                    print('%s-->%s' % (i,j))

print("Optimal solution:",model.ObjVal)

# 计算程序运行时间
end = time.time()
print('程序运行时间：')
print(end-start)

结果：

车辆 {0: [100, 1], 1: [100, 1], 2: [100, 1], 3: [100, 1], 4: [100, 1], 5: [100, 1], 6: [100, 1], 7: [100, 1], 8: [100, 1], 9: [100, 1]}
Demand {0: 0, 1: 10, 2: -10, 3: 20, 4: -20, 5: 30, 6: -30, 7: 40, 8: 40, 9: 0}
时间窗口 {0: [0, 1000], 1: [0, 1000], 2: [0, 1000], 3: [0, 1000], 4: [0, 1000], 5: [0, 1000], 6: [0, 1000], 7: [0, 1000], 8: [0, 1000], 9: [0, 1000]}
任务 {0: [1, 2], 1: [3, 4], 2: [5, 6], 3: [7, 8]}
Set parameter Username
Academic license - for non-commercial use only - expires 2023-12-26
Set parameter TimeLimit to value 1000
Set parameter LogFile to value "PDPTW_smallcase.txt.log"
Gurobi Optimizer version 10.0.0 build v10.0.0rc2 (win64)

CPU model: Intel(R) Core(TM) i7-8550U CPU @ 1.80GHz, instruction set [SSE2|AVX|AVX2]
Thread count: 4 physical cores, 8 logical processors, using up to 8 threads

Optimize a model with 2588 rows, 1100 columns and 9060 nonzeros
Model fingerprint: 0xd148a0cd
Variable types: 100 continuous, 1000 integer (900 binary)
Coefficient statistics:
  Matrix range     [1e+00, 1e+04]
  Objective range  [1e+01, 4e+01]
  Bounds range     [1e+00, 1e+00]
  RHS range        [1e+00, 1e+04]
Presolve removed 740 rows and 50 columns
Presolve time: 0.03s
Presolved: 1848 rows, 1050 columns, 11628 nonzeros
Variable types: 100 continuous, 950 integer (850 binary)

Root relaxation: objective 8.000000e+01, 60 iterations, 0.00 seconds (0.00 work units)

    Nodes    |    Current Node    |     Objective Bounds      |     Work
 Expl Unexpl |  Obj  Depth IntInf | Incumbent    BestBd   Gap | It/Node Time

     0     0   80.00000    0   11          -   80.00000      -     -    0s
     0     0   80.00000    0   21          -   80.00000      -     -    0s
H    0     0                      94.1421356   80.00000  15.0%     -    0s
     0     0   80.00000    0   25   94.14214   80.00000  15.0%     -    0s
     0     0   80.00000    0   11   94.14214   80.00000  15.0%     -    0s
     0     0   80.00000    0   16   94.14214   80.00000  15.0%     -    0s
     0     0   80.00000    0   14   94.14214   80.00000  15.0%     -    0s
     0     0   80.00000    0   19   94.14214   80.00000  15.0%     -    0s
     0     0   80.00000    0   16   94.14214   80.00000  15.0%     -    0s
     0     0   80.00000    0   11   94.14214   80.00000  15.0%     -    0s
     0     0   80.62902    0   16   94.14214   80.62902  14.4%     -    0s
     0     0   80.69077    0   16   94.14214   80.69077  14.3%     -    0s
     0     2   80.84309    0   16   94.14214   80.84309  14.1%     -    0s

Cutting planes:
  Learned: 1
  Gomory: 1
  Implied bound: 39
  MIR: 13
  StrongCG: 3
  RLT: 5
  Relax-and-lift: 3

Explored 68 nodes (2136 simplex iterations) in 0.57 seconds (0.36 work units)
Thread count was 8 (of 8 available processors)

输出结果：

Best objective 9.414213562373e+01, best bound 9.414213562373e+01, gap 0.0000%
tour for vehicle 0:
0-->9
tour for vehicle 1:
0-->9
tour for vehicle 2:
0-->9
tour for vehicle 3:
0-->9
tour for vehicle 4:
0-->9
tour for vehicle 5:
0-->1
tour for vehicle 5:
1-->2
tour for vehicle 5:
2-->3
tour for vehicle 5:
3-->4
tour for vehicle 5:
4-->5
tour for vehicle 5:
5-->6
tour for vehicle 5:
6-->7
tour for vehicle 5:
7-->8
tour for vehicle 5:
8-->9
tour for vehicle 6:
0-->9
tour for vehicle 7:
0-->9
tour for vehicle 8:
0-->9
tour for vehicle 9:
0-->9
Optimal solution: 94.14213562373095
程序运行时间：
0.7380778789520264

Process finished with exit code 0

下一篇：《【PDPTW】python调用guribo求解PDPTW问题（Li & Lim‘s benchmark）之二》

你可能感兴趣的:(车辆路径规划问题,python,人工智能,guribi,VRPTW)

  • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
  • 关于沟通这件事，项目经理不需要每次都面对面进行 流程大师兄
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
  • 2020-01-25 晴岚85
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • 小丽成长记（四十三） 玲玲54321
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • 如何在 Fork 的 GitHub 项目中保留自己的修改并同步上游更新？github_fork_update iBaoxing github
    如何在Fork的GitHub项目中保留自己的修改并同步上游更新？在GitHub上Fork了一个项目后，你可能会对项目进行一些修改，同时原作者也在不断更新。如果想要在保留自己修改的基础上，同步原作者的最新更新，很多人会不知所措。本文将详细讲解如何在不丢失自己改动的情况下，将上游仓库的更新合并到自己的仓库中。问题描述假设你在GitHub上Fork了一个项目，并基于该项目做了一些修改，随后你发现原作者对
  • 本周第二次约练 2cfbdfe28a51
    中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • python os.environ 江湖偌大 python深度学习
    os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • 怎么起诉借钱不还的人？怎样起诉欠款不还的人？ 影子爱学习
    怎么起诉借钱不还的人？怎样起诉欠款不还的人？如果遇到难以解决的法律问题，我们可以匹配专业律师。例如：婚姻家庭（离婚纠纷）、刑事辩护、合同纠纷、债权债务、房产（继承）纠纷、交通事故、劳动争议、人身损害、公司相关法律事务（法律顾问）等咨询推荐手机/微信:15633770876【全国案件皆可】借钱不还起诉对方需要哪些资料起诉欠钱不还的，一般需要的材料包括以下这些：借据、收据、欠条、付款凭证等证据，以及向
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 pythonos.environ
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
  • 2020.11.19 隆非凡
    日精进，今日体验：在维修过程中遇到的问题，把源头找到，在进行下一步开始。不要停留在一个点上，合理调整心态，把当下事做好。
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • 18-115 一切思考不能有效转化为行动，都TM是扯淡！ 成长时间线
    7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
  • 山东大学小树林支教调研团青青仓木队——翟晓楠 山东大学青青仓木队
    过了半年，又一次启程，又一次回到支教的初心之地。比起上一次的试探与不安，我更多了一丝稳重与熟练。心境、处境也都随着半个学期的过去而变得不同，半个学期中，身体上的，心理上的，太多的逆境让我变得步履维艰，曲曲折折，弯弯绕绕，我仿佛打不起精神，没有胃口，没有动力。感觉走的不顺畅的时候，支教这个旅程，给了我力量。自告奋勇承担起队长这一职务的我，从组织时的复杂和困难的经历，协调各种问题，从无到有，和校长和队
  • 【夜读】提升生活品质的8个建议 茳淮秀水
    停止攀比很多人之所以感觉疲惫，部分原因是来自于跟别人攀比。殊不知，攀比得到的满足只是片刻的，过后往往会感到空虚。过分在意别人的评价，丢失的是自己原有的审美，扰乱的是自己最初的节奏。不妨活得洒脱些，自己内心丰盈了，快乐就能更持久。停止自责想改变自己，先从接纳自己开始。越是过分自责，就越难改变现状，因为如果把精力全耗在自责上，就没有精力用来改变了。遇到问题，我们要用正确的心态去面对。与其一味自责，不如
  • 蘩漪：新女性？利己主义者 赮_红雨
    蘩漪是曹禺《雷雨》笔下的女性形象。对于她的喜爱，曹禺在之前的访谈中，就已经表达得很清楚了，蘩漪是他所倾心的女子的“代替者”。在这个女性身上有着曹禺最精心的描写，但同时她的身上又存在着一些时代的问题。图片发自App首先，繁漪是追求自由和幸福的新女性形象。她是精神悲剧的核心人物，她对周朴园的反抗，具有典型意义。她是位资产阶级家庭出身的小姐，受过五四新思潮的影响，她任性、傲慢，追求人格独立、个性自由和爱
  • 如果做到轻松在股市赚钱？只要坚持这三个原则。 履霜之人
    大A股里向来就有七亏二平一赚的说法，能赚钱的都是少数人。否则股市就成了慈善机构，人人都有钱赚，谁还要上班？所以说亏钱是正常的，或者说是应该的。那么那些赚钱的人又是如何做到的呢？普通人能不能找到捷径去分一杯羹呢？方法是有的，但要做到需要你有极高的自律。第一，控制仓位，散户最大的问题是追涨杀跌，只要涨起来，就把钱往股票上砸，然后被套，隔天跌的受不了，又一刀切，全部割肉。来来回回间，遍体鳞伤。所以散户首
  • 探索OpenAI和LangChain的适配器集成：轻松切换模型提供商 nseejrukjhad langchaineasyui前端python
    #探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
  • 使用Faiss进行高效相似度搜索 llzwxh888 faisspython
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库python
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
  • 利用LangChain的StackExchange组件实现智能问答系统 nseejrukjhad langchainmicrosoft数据库python
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
  • 想明白这个问题，你才能写下去 文自拾
    春节放假的时候，又有一天梦见她，第二天她冒着漫天大雪，傻傻地跑来见我。她说，见见傻傻的我，天很冷，心很暖。她回去后，我写了一篇文章，题目叫——从此梦中只有你。我们没在一起的很长一段时间里，她都在我的心底，一次次出现在我的梦里。我对她说，在一起之前，是胆小且闷骚，在一起之后，我变得不要脸了。不要脸的——去爱你。那文章没写完，火车上，给她看了。我有点小失望，花了好几个小时写，她分分钟就看完，很希望她逐
  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • 集合框架 天子之骄 java数据结构集合框架
       集合框架 集合框架可以理解为一个容器，该容器主要指映射(map)、集合(set)、数组(array)和列表(list)等抽象数据结构。 从本质上来说，Java集合框架的主要组成是用来操作对象的接口。不同接口描述不同的数据类型。   简单介绍：   Collection接口是最基本的接口，它定义了List和Set，List又定义了LinkLi
  • Table Driven（表驱动）方法实例 bijian1013 javaenumTable Driven表驱动
    实例一： /** * 驾驶人年龄段 * 保险行业，会对驾驶人的年龄做年龄段的区分判断 * 驾驶人年龄段：01-[18,25);02-[25,30);03-[30-35);04-[35,40);05-[40,45);06-[45,50);07-[50-55);08-[55,+∞) */ public class AgePeriodTest { //if...el
  • Jquery 总结 cuishikuan javajqueryAjaxWebjquery方法
    1.$.trim方法用于移除字符串头部和尾部多余的空格。如：$.trim('   Hello   ') // Hello2.$.contains方法返回一个布尔值，表示某个DOM元素（第二个参数）是否为另一个DOM元素（第一个参数）的下级元素。如：$.contains(document.documentElement, document.body); 3.$
  • 面向对象概念的提出 麦田的设计者 java面向对象面向过程
            面向对象中，一切都是由对象展开的，组织代码，封装数据。   在台湾面向对象被翻译为了面向物件编程，这充分说明了，这种编程强调实体。       下面就结合编程语言的发展史，聊一聊面向过程和面向对象。      c语言由贝尔实
  • linux网口绑定 被触发 linux
    刚在一台IBM Xserver服务器上装了RedHat Linux Enterprise AS 4，为了提高网络的可靠性配置双网卡绑定。 一、环境描述 我的RedHat Linux Enterprise AS 4安装双口的Intel千兆网卡，通过ifconfig -a命令看到eth0和eth1两张网卡。 二、双网卡绑定步骤： 2.1 修改/etc/sysconfig/network
  • XML基础语法 肆无忌惮_ xml
    一、什么是XML？ XML全称是Extensible Markup Language，可扩展标记语言。很类似HTML。XML的目的是传输数据而非显示数据。XML的标签没有被预定义，你需要自行定义标签。XML被设计为具有自我描述性。是W3C的推荐标准。   二、为什么学习XML？ 用来解决程序间数据传输的格式问题 做配置文件 充当小型数据库   三、XML与HTM
  • 为网页添加自己喜欢的字体 知了ing 字体 秒表 css
    @font-face { font-family: miaobiao;//定义字体名字 font-style: normal; font-weight: 400; src: url('font/DS-DIGI-e.eot');//字体文件 } 使用： <label style="font-size:18px;font-famil
  • redis范围查询应用-查找IP所在城市 矮蛋蛋 redis
    原文地址： http://www.tuicool.com/articles/BrURbqV 需求 根据IP找到对应的城市 原来的解决方案 oracle表（ip_country）： 查询IP对应的城市： 1.把a.b.c.d这样格式的IP转为一个数字，例如为把210.21.224.34转为3524648994 2. select city from ip_
  • 输入两个整数， 计算百分比 alleni123 java
    public static String getPercent(int x, int total){ double result=(x*1.0)/(total*1.0); System.out.println(result); DecimalFormat df1=new DecimalFormat("0.0000%");
  • 百合——————>怎么学习计算机语言 百合不是茶 java 移动开发
        对于一个从没有接触过计算机语言的人来说，一上来就学面向对象，就算是心里上面接受的了，灵魂我觉得也应该是跟不上的，学不好是很正常的现象，计算机语言老师讲的再多，你在课堂上面跟着老师听的再多，我觉得你应该还是学不会的，最主要的原因是你根本没有想过该怎么来学习计算机编程语言，记得大一的时候金山网络公司在湖大招聘我们学校一个才来大学几天的被金山网络录取，一个刚到大学的就能够去和
  • linux下tomcat开机自启动 bijian1013 tomcat
    方法一： 修改Tomcat/bin/startup.sh 为: export JAVA_HOME=/home/java1.6.0_27 export CLASSPATH=$CLASSPATH:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar:. export PATH=$JAVA_HOME/bin:$PATH export CATALINA_H
  • spring aop实例 bijian1013 javaspringAOP
    1.AdviceMethods.java package com.bijian.study.spring.aop.schema; public class AdviceMethods { public void preGreeting() { System.out.println("--how are you!--"); } } 2.beans.x
  • [Gson八]GsonBuilder序列化和反序列化选项enableComplexMapKeySerialization bit1129 serialization
    enableComplexMapKeySerialization配置项的含义  Gson在序列化Map时，默认情况下，是调用Key的toString方法得到它的JSON字符串的Key，对于简单类型和字符串类型，这没有问题，但是对于复杂数据对象，如果对象没有覆写toString方法，那么默认的toString方法将得到这个对象的Hash地址。   GsonBuilder用于
  • 【Spark九十一】Spark Streaming整合Kafka一些值得关注的问题 bit1129 Stream
    包括Spark Streaming在内的实时计算数据可靠性指的是三种级别： 1. At most once，数据最多只能接受一次，有可能接收不到 2. At least once, 数据至少接受一次，有可能重复接收 3. Exactly once  数据保证被处理并且只被处理一次，   具体的多读几遍http://spark.apache.org/docs/lates
  • shell脚本批量检测端口是否被占用脚本 ronin47
    #!/bin/bash cat ports |while read line do#nc -z -w 10 $line nc -z -w 2 $line 58422>/dev/null2>&1if[ $?-eq 0]then echo $line:ok else echo $line:fail fi done 这里的ports 既可以是文件
  • java-2.设计包含min函数的栈 bylijinnan java
    具体思路参见：http://zhedahht.blog.163.com/blog/static/25411174200712895228171/ import java.util.ArrayList; import java.util.List; public class MinStack { //maybe we can use origin array rathe
  • Netty源码学习-ChannelHandler bylijinnan javanetty
    一般来说，“有状态”的ChannelHandler不应该是“共享”的，“无状态”的ChannelHandler则可“共享” 例如ObjectEncoder是“共享”的, 但 ObjectDecoder 不是 因为每一次调用decode方法时，可能数据未接收完全（incomplete）， 它与上一次decode时接收到的数据“累计”起来才有可能是完整的数据，是“有状态”的 p
  • java生成随机数 cngolon java
    方法一： /** * 生成随机数 * @author [email protected] * @return */ public synchronized static String getChargeSequenceNum(String pre){ StringBuffer sequenceNum = new StringBuffer(); Date dateTime = new D
  • POI读写海量数据 ctrain 海量数据
    import java.io.FileOutputStream; import java.io.OutputStream; import org.apache.poi.xssf.streaming.SXSSFRow; import org.apache.poi.xssf.streaming.SXSSFSheet; import org.apache.poi.xssf.streaming
  • mysql 日期格式化date_format详细使用 daizj mysqldate_format日期格式转换日期格式化
    日期转换函数的详细使用说明  DATE_FORMAT(date,format) Formats the date value according to the format string. The following specifiers may be used in the format string. The&n
  • 一个程序员分享8年的开发经验 dcj3sjt126com 程序员
      在中国有很多人都认为IT行为是吃青春饭的，如果过了30岁就很难有机会再发展下去!其实现实并不是这样子的，在下从事.NET及JAVA方面的开发的也有8年的时间了，在这里在下想凭借自己的亲身经历，与大家一起探讨一下。 明确入行的目的 很多人干IT这一行都冲着“收入高”这一点的，因为只要学会一点HTML, DIV+CSS，要做一个页面开发人员并不是一件难事，而且做一个页面开发人员更容
  • android欢迎界面淡入淡出效果 dcj3sjt126com android
    很多Android应用一开始都会有一个欢迎界面，淡入淡出效果也是用得非常多的，下面来实现一下。 主要代码如下： package com.myaibang.activity; import android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.os.CountDown
  • linux 复习笔记之常见压缩命令 eksliang tar解压linux系统常见压缩命令linux压缩命令tar压缩
    转载请出自出处:http://eksliang.iteye.com/blog/2109693 linux中常见压缩文件的拓展名 *.gz gzip程序压缩的文件 *.bz2 bzip程序压缩的文件 *.tar tar程序打包的数据，没有经过压缩 *.tar.gz tar程序打包后，并经过gzip程序压缩 *.tar.bz2 tar程序打包后，并经过bzip程序压缩 *.zi
  • Android 应用程序发送shell命令 gqdy365 android
    项目中需要直接在APP中通过发送shell指令来控制lcd灯，其实按理说应该是方案公司在调好lcd灯驱动之后直接通过service送接口上来给APP，APP调用就可以控制了，这是正规流程，但我们项目的方案商用的mtk方案，方案公司又没人会改，只调好了驱动，让应用程序自己实现灯的控制，这不蛋疼嘛！！！！ 发就发吧！ 一、关于shell指令： 我们知道，shell指令是Linux里面带的
  • java 无损读取文本文件 hw1287789687 读取文件无损读取读取文本文件charset
    java 如何无损读取文本文件呢？ 以下是有损的 @Deprecated public static String getFullContent(File file, String charset) { BufferedReader reader = null; if (!file.exists()) { System.out.println("getFull
  • Firebase 相关文章索引 justjavac firebase
    Awesome Firebase 最近谷歌收购Firebase的新闻又将Firebase拉入了人们的视野，于是我做了这个 github 项目。 Firebase 是一个数据同步的云服务，不同于 Dropbox 的「文件」，Firebase 同步的是「数据」，服务对象是网站开发者，帮助他们开发具有「实时」（Real-Time）特性的应用。 开发者只需引用一个 API 库文件就可以使用标准 RE
  • C++学习重点 lx.asymmetric C++笔记
    1.c++面向对象的三个特性：封装性，继承性以及多态性。   2.标识符的命名规则：由字母和下划线开头，同时由字母、数字或下划线组成；不能与系统关键字重名。   3.c++语言常量包括整型常量、浮点型常量、布尔常量、字符型常量和字符串性常量。   4.运算符按其功能开以分为六类：算术运算符、位运算符、关系运算符、逻辑运算符、赋值运算符和条件运算符。 &n
  • java bean和xml相互转换 q821424508 javabeanxmlxml和bean转换java bean和xml转换
    这几天在做微信公众号 做的过程中想找个java bean转xml的工具，找了几个用着不知道是配置不好还是怎么回事，都会有一些问题， 然后脑子一热谢了一个javabean和xml的转换的工具里，自己用着还行，虽然有一些约束吧 ， 还是贴出来记录一下      顺便你提一下下，这个转换工具支持属性为集合、数组和非基本属性的对象。   packag
  • C 语言初级 位运算 1140566087 位运算c
    第十章 位运算   1、位运算对象只能是整形或字符型数据，在VC6.0中int型数据占4个字节   2、位运算符： 运算符 作用 ~ 按位求反 << 左移 >> 右移 & 按位与 ^ 按位异或 | 按位或 他们的优先级从高到低；   3、位运算符的运算功能： a、按位取反： ~01001101 = 101
  • 14点睛Spring4.1-脚本编程 wiselyman spring4
    14.1 Scripting脚本编程 脚本语言和java这类静态的语言的主要区别是:脚本语言无需编译,源码直接可运行; 如果我们经常需要修改的某些代码,每一次我们至少要进行编译,打包,重新部署的操作,步骤相当麻烦; 如果我们的应用不允许重启,这在现实的情况中也是很常见的; 在spring中使用脚本编程给上述的应用场景提供了解决方案,即动态加载bean; spring支持脚本
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他