论文复现丨多车场带货物权重车辆路径问题:改进邻域搜索算法

本文主要是介绍论文复现丨多车场带货物权重车辆路径问题:改进邻域搜索算法,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

引言

本系列文章是路径优化问题学习过程中一个完整的学习路线。问题从简单的单车场容量约束CVRP问题到多车场容量约束MDCVRP问题,再到多车场容量+时间窗口复杂约束MDCVRPTW问题,复杂度是逐渐提升的。

如果大家想学习某一个算法,建议从最简单的TSP问题开始学习,一个阶梯一个阶梯走。

如果不是奔着学习算法源码的思路,只想求解出个结果,请看历史文章,有ortools、geatpy、scikit-opt等求解器相关文章,点击→路径优化历史文章,可直接跳转。

本系列文章汇总:

  • 1、路径优化历史文章
  • 2、路径优化丨带时间窗和载重约束的CVRPTW问题-改进遗传算法:算例RC108
  • 3、路径优化丨带时间窗和载重约束的CVRPTW问题-改进和声搜索算法:算例RC108
  • 4、路径优化丨复现论文-网约拼车出行的乘客车辆匹配及路径优化
  • 5、多车场路径优化丨遗传算法求解MDCVRP问题
  • 6、论文复现详解丨多车场路径优化问题:粒子群+模拟退火算法求解
  • 7、路径优化丨复现论文外卖路径优化GA求解VRPTW
  • 8、多车场路径优化丨蚁群算法求解MDCVRP问题
  • 9、路径优化丨复现论文多车场带货物权重车辆路径问题:改进邻域搜索算法

问题描述

多车场带货物权重车辆路径问题可描述为:多个车场、每个中心有若干车辆、存在若干需求点、车辆从车场往返服务需求点。其中:车辆存在载重约束,数量约束。本文假设:

  • (1)需求点需求量已知,多个车场的车辆能满足服务要求;

  • (2)需求点位置已知,不考虑在需求点的服务时间;

  • (3)所有车辆型号和载重相同;

  • (4)配送车辆从车场出发,最终返回车场。一个需求点只能被访问 一次。

    详细描述见参考文献

数学模型

模型

具体模型见参考文献,目标函数是车辆运行距离和载重的乘积。

在这里插入图片描述

数据

数据是RC101,100个需求点,拆分后留下坐标和需求量:
在这里插入图片描述

设计为3车场:
在这里插入图片描述

数据见网站:http://web.cba.neu.edu/~msolomon/rc101.htm

数据处理

pandas 读取对应列就行,比较简单。

def read():path = './data.xlsx'df = pd.read_excel(path, sheet_name = '需求点坐标')df1 = pd.read_excel(path, sheet_name = '车场')customer_x = df.iloc[:, 0].tolist()customer_y = df.iloc[:, 1].tolist()customer_demand = df.iloc[:, 2].tolist()center_x = df1.iloc[:, 0].tolist()center_y = df1.iloc[:, 1].tolist()return customer_x, customer_y, customer_demand, center_x, center_y

算法设计–编码解码

编码

论文的编码是用0到99的数表示100个点的位置,按照论文的编码生成方法:
在这里插入图片描述

计算各个车场到需求点的距离与需求点的比值,排序后依次挑选作为R条路径的起点,推文的车辆是15,R设为15,车辆0-5,5-10,10-15分别对应车场1,2,3 ,依次挑选各车场个车辆的初始点。

挑选完初始点后,再次计算gc值,挑选各车辆的剩余需求点,起点是对应车辆上一次访问的点,还需考虑载重约束:

def creat_init(self):cust_point = [i for i in range(len(self.x))]road_car = [[] for i in range(self.car_num)]idx1 = 0center_idx = 0abdan_id = []while cust_point:                               # 如果需求点Tabu集合非空if road_car[idx1] == []:                    # 如果某路径是空,起点是对应车场,文章车辆0-5,5-10,10-15分别对应车场1,2,3                               begin_x1, begin_y1 = self.x1[center_idx], self.y1[center_idx]else:                                       # 如何路径非空,起点是路径最后一个点,即上次访问的点begin_x1, begin_y1 = self.x[road_car[idx1][-1]], self.y[road_car[idx1][-1]]dist = [np.sqrt((self.x[k] - begin_x1)**2 + (self.y[k] - begin_y1)**2) for k in cust_point]gc = np.array(dist)/np.array(self.demand)[cust_point]# 距离及gc值计算id_all = np.array(cust_point)[gc.argsort()] # gc排序,得到对应从小到大的点idx3 = 0while sum(np.array(self.demand)[road_car[idx1] + [id_all[idx3]]]) > self.load:# 挑选的点必须满足载重约束,否则继续挑idx3 += 1if idx3 == len(id_all):                 # 如果所有剩余点都挑选完成,还不满足载重约束,认为该车辆的路径已经完成abdan_id.append(idx1)               # 记录该路径的索引,下次不用考虑breakif idx1 not in abdan_id:                    # 如果路径不是完成的路径,说明上面的while有结果idx2 = idx3road_car[idx1].append(id_all[idx2])     # 记录结果(挑选到的点)cust_point.remove(id_all[idx2])         # 移除Tabu集合对应点idx1 += 1if idx1 == self.every_num:                  # 如果车辆数达到5辆(每个车场5辆),车场更新center_idx += 1if idx1 == self.car_num:                    # 车辆计数归0             idx1 = 0return road_car

解码

上述方法生成的初始解:

[[68, 87, 54, 1, 5, 7, 71], [67, 69, 3, 45, 4, 2, 99], [79, 65, 85, 73, 74, 59, 60], [95, 53, 80, 37, 39, 38, 89], [64, 82, 98, 8, 14, 46, 41], [93, 70, 35, 34, 36, 40, 92], [49, 25, 26, 27, 31, 42, 43], [66, 18, 48, 24, 76, 6, 51], [91, 63, 22, 20, 77, 72, 61], [55, 75, 88, 47, 78, 44, 84], [83, 50, 17, 57, 15, 0], [21, 23, 19, 58, 16, 97], [94, 10, 9, 11, 13, 81], [33, 30, 28, 29, 32, 62], [90, 56, 96, 86, 12, 52]]

一个车辆的解码如下:

1、 根据路径索引读出各点的坐标和需求;

2、 计算第一个点到第二个点的距离(车场到第一个点的载重0,开销为0不考虑),载重取第一个点的载重(后面的载重依次累加),更新开销;

3、每辆车遍历到最后一个点时,计算点到车场的距离,载重取累积到最后一个点的载重,开销更新,解码结束:

代码如下:

def f_caculate(self, road_car):f_all = [0 for i in range(self.car_num)]for k in range(len(road_car)):road = road_car[k]                         # 每一辆车的路径load = 0center_idx = k//self.every_num             # 车场for j in range(1, len(road)):start, end = road[j - 1], road[j]      # 从第一个点开始,车场到第一个点载重是0,开销不考虑load += self.demand[start]begin_x, begin_y = self.x[start], self.y[start]end_x, end_y = self.x[end], self.y[end]f = np.sqrt((end_x - begin_x)**2 + (end_y - begin_y)**2)*load # 开销f_all[k] += f  start = road[-1]                          # 最后一个点回到车场的开销begin_x, begin_y = self.x[start], self.y[start]end_x, end_y = self.x1[center_idx], self.y1[center_idx]load += self.demand[start]f = np.sqrt((end_x - begin_x)**2 + (end_y - begin_y)**2)*loadf_all[k] += freturn f_all

邻域搜索算子设计

一、one-point move算子

在这里插入图片描述

同路径:选择一个点随机插入该路径的任意位置

不同路径:选择一个点随机插入不同路径的任意位置

需注意的是:同路径不用考虑载重约束,不同路径需考虑载重约束,每个算子有while,为避免陷入死循环,设置10次没有新解生成就返回原解。所有算子不同路径考虑载重,最多10次迭代。

代码:

def one_point_move(self, road_car):count = 0while True:idx1 = random.randint(0, self.car_num-1)          # 选择一个路径if road_car[idx1]:a = random.choice(road_car[idx1])                 # 对应路径的一个需求点breakif count == 10:breakcount += 1road_car[idx1].remove(a)                          # 移除对应需求点demand_all = [sum(np.array(self.demand)[de]) for de in road_car] # 各条路径的载重计算location = [i for i in range(self.car_num) if demand_all[i] + self.demand[a] <= self.load]count = 0                                                       # 提取可加入改点的所有路径(载重可接受)while True and location:idx2 = random.choice(location)                    # 选择一个可接受路径if len(road_car[idx2])>0:insert_id = random.randint(0, len(road_car[idx2]) - 1) # 随机选择一个插入位置road_car[idx2].insert(insert_id, a)               # 需求点插入breakif count == 10:breakcount += 1return road_car

二、2-exchange算子

随机选择两条不同路径的两个点进行交换,不同路径考虑载重约束。

代码:

def exchange_2(self, road_car):signal = 1count = 0while signal:loc = random.sample(range(self.car_num),2)         # 不同的2条路径if len(road_car[loc[0]])>0 and len(road_car[loc[1]])>0:id1 = random.randint(0, len(road_car[loc[0]]) - 1) # 第一条路径选择一个点id2 = random.randint(0, len(road_car[loc[1]]) - 1) # 第二条路径选择一个点de1 = np.array(self.demand)[road_car[loc[0]]]      # 对应路径的载重(路径所有点)de2 = np.array(self.demand)[road_car[loc[1]]]d1 = self.demand[id1]                              # 第一个点的需求量                   d2 = self.demand[id2]                              # 第二个点的需求量if sum(de1)-d1 + d2 <= self.load and sum(de2)-d2 + d1 <= self.load:  # 如果2条路径交换后载重满足road_car[loc[0]][id1], road_car[loc[1]][id2] = road_car[loc[1]][id2], road_car[loc[0]][id1]signal = 0                                     # 更新并跳出循环if count == 10:breakcount += 1return road_car

三、2-opt算子
在这里插入图片描述

为了简化,把a,b,c,d看做位置索引,那么b = a+1,d = c+1

不同路径:路径一a前面的与d后面的合并成新路径,路径二c前面的与b后面的合并成新路径

同一路径:路径a前面与逆序bc路径相连,再与d后面路径相连。

同一路径不考虑载重约束,不同路径要考虑

代码:

def opt_2(self, road_car):signal = 1count = 0while signal:idx1 = random.randint(0, self.car_num - 1)         # 随机选择路径索引1idx2 = random.randint(0, self.car_num - 1)         # 随机选择路径索引1if len(road_car[idx1]) > 1 and len(road_car[idx2]) >1:a = random.randint(0, len(road_car[idx1]) - 2)     # 路径1生成索引a,-2是保证b存在b = a + 1                                          # b是a+1c = random.randint(0, len(road_car[idx2]) - 2)     # 生成索引b,-2是保证d存在d = c + 1                                          # d 是b+1if idx1 == idx2:                                   # 如果同一路径if a > c:                                      # 如果a 索引大于ca, b, c, d = c, d, a, b                    # 交换a,b 和 c,dro = road_car[idx1]                           r = ro[b:c+1]                                  # b到c的路径if r:                                          # 如果存在,逆序r.reverse()road = ro[:a+1] + r + ro[d:]                   # 重新连接得到新路径road_car[idx1] = road                          # 更新路径signal = 0else:                                              # 如果是不同路径ro1, ro2 = road_car[idx1], road_car[idx2]road1 = ro1[:a+1] + ro2[d:]                    # 对应路径截取相连road2 = ro2[:c+1] + ro1[b:]if sum(np.array(self.demand)[road1]) <= self.load and sum(np.array(self.demand)[road2]) <= self.load:road_car[idx1] = road1                     # 如果满足载重,更新2条路径road_car[idx2] = road2signal = 0if count == 10:breakcount += 1return road_car

四、point-arc exchange算子

在这里插入图片描述

生成不同的路径,分别挑选点b 和点i,j,考虑载重约束同时进行交换

代码:

def point_arc_exchange(self, road_car):signal = 1count = 0while signal:loc = random.sample(range(self.car_num), 2)        # 生成不相同的2条路径索引id1, id2 = loc[0], loc[1]road1, road2 = road_car[id1], road_car[id2]if len(road1)>0 and len(road2)>1:idx1 = random.randint(0, len(road1) - 1)           # 第一条路径随机生成位置b = road1[idx1]                                    # 取对应位置的点idx2 = random.randint(0, len(road2) - 2)           # 第而条路径随机生成位置,-2是为了idx2 + 1可行i, j = road2[idx2], road2[idx2 + 1]                # 取2个点i,jroad1.insert(idx1, i)                              # 插入点iroad1.insert(idx1 + 1, j)                          # 插入点jroad1.remove(b)                                    # 路径1移除broad2.insert(idx2, b)                              # 路径2插入b                    road2.remove(i)                                    # 移除iroad2.remove(j)                                    # 移除jif sum(np.array(self.demand)[road1]) <= self.load and sum(np.array(self.demand)[road2]) <= self.load:road_car[id1] = road1                          # 如果2条路径都满足载重约束,更新,跳出循环road_car[id2] = road2signal = 0if count == 10:breakcount += 1return road_car

五、or-opt算子
在这里插入图片描述

选择不同路径,在载重约束下把一条路径的一段路线插入另一段。

def or_opt(self, road_car):count = 0while 1:idx1 = random.randint(0, self.car_num-1)            # 选择一条路径索引road1 = road_car[idx1]if len(road1) <= 2:breakloc =random.sample(range(len(road1)),2)             # 路径生成2个位置loc.sort()                                          # 升序uv = road1[loc[0]:loc[1]]                           # 截取插入的编码demand_all = [sum(np.array(self.demand)[de]) for de in road_car]location = [i for i in range(self.car_num) if demand_all[i] + sum(np.array(self.demand)[uv])<= self.load and i != idx1]                     # 载重约束生成可插入的车辆路径(不包括上面路径)if location:                                        # 如果可插入路径非空idx2 = random.choice(location)road2 = road_car[idx2]road1 = road1[:loc[0]] + road1[loc[1]:]         # 路径1截取剩下的路线if len(road2)>0:id2 = random.randint(0, len(road2) - 1)         # 路径2的插入位置road2 = road2[:id2] + uv + road2[id2:]          # 路径2更新road_car[idx1] = road1road_car[idx2] = road2breakif count == 10:breakcount += 1return road_car

六、cross-exchange算子

)

不同路径之间,分别生成b,c和f,g,在载重约束下互相交换

代码:

def cross_exchange(self, road_car):signal = 1count = 0while signal:loc = random.sample(range(self.car_num),2)          # 生成不重复的2个路径索引loc.sort()                                          # 升序id1, id2 = loc[0], loc[1]road1, road2 = road_car[id1], road_car[id2]if len(road1)>1 and len(road2)> 1 :                 # 保证b,c,f,g都存在idx1 = random.randint(0, len(road1) - 2)        # 第一个路径生成b和c,-2是保证idx1 + 1可行b = road1[idx1]c = road1[idx1 + 1]idx2 = random.randint(0, len(road2) - 2)         # 第二个路径生成f和g,-2是保证idx2 + 1可行f = road2[idx2]g = road2[idx2 + 1]road1.insert(idx1, f)                            # 互相交换road1.insert(idx1 + 1, g)road1.remove(b)road1.remove(c)road2.insert(idx2, b)road2.insert(idx2 + 1, c)road2.remove(f)road2.remove(g)if sum(np.array(self.demand)[road1]) <= self.load and sum(np.array(self.demand)[road2]) <= self.load:road_car[id1] = road1                           # 2条路径都满足约束时更新,并跳出循环                      road_car[id2] = road2signal = 0if count == 10:breakcount += 1return road_car

七、3-opt算子
在这里插入图片描述

挑选3条边,做2次2-opt操作:

def opt_3(self, road_car):count = 0while True:idx = random.randint(0, self.car_num-1)                     # 选择一条路径索引if len(road_car[idx]) >= 4:                                         # 保证a,b,c,d都存在loc = random.sample(range(len(road_car[idx]) - 1),3)    # 生成不重复的3个路径索引loc.sort()                                              # 升序road = road_car[idx]                                    # 依次当作a,b,c,d,e,f的位置索引id_a, id_b = loc[0], loc[0] + 1id_c, id_d = loc[1], loc[1] + 1id_e, id_f = loc[2], loc[2] + 1r1 = road[id_b:id_c + 1]                                # r1非空时逆序,即id_b不等于id_cif r1:r1.reverse()r2 = road[id_d:id_e + 1]                                # r2非空时逆序,即id_d不等于id_e  if r2:r2.reverse()                  road = road[:id_a + 1] + r1 + r2 + road[id_f:]          # 重构road_car[idx] = roadbreakif count == 10:breakcount += 1return road_car

邻域搜索算法设计

在这里插入图片描述

k次扰动主要是利用邻域搜索算法对初始解进行寻优,接受gbest(1+ range)的解:

ges\image-20240407190756731.png)

def algorithm1(self,road_car, gbest, ran, T_roadcar, answer):road_car1 = self.mo.one_point_move(road_car)              # 第一个算子得到新路径f = sum(self.cd.f_caculate(road_car1))                    # 新路径的开销if f < gbest*(1 + ran):                                   # 结束解的范围T_roadcar.append(copy.deepcopy(road_car1))            # 记录解,copy是防止变量的相互引用,引起路径的变化answer.append(f)                                      # 记录开销,road_car1 = self.mo.exchange_2(road_car1)                 # 下面同上f = sum(self.cd.f_caculate(road_car1))if f < gbest*(1 + ran):T_roadcar.append(copy.deepcopy(road_car1))answer.append(f)road_car1 = self.mo.opt_2(road_car1)f = sum(self.cd.f_caculate(road_car1))if f < gbest*(1 + ran):T_roadcar.append(copy.deepcopy(road_car1))answer.append(f)road_car1 = self.mo.point_arc_exchange(road_car1)f = sum(self.cd.f_caculate(road_car1))if f < gbest*(1 + ran):T_roadcar.append(copy.deepcopy(road_car1))answer.append(f)road_car1 = self.mo.or_opt(road_car1)f = sum(self.cd.f_caculate(road_car1))if f < gbest*(1 + ran):T_roadcar.append(copy.deepcopy(road_car1))answer.append(f)road_car1 = self.mo.cross_exchange(road_car1)f = sum(self.cd.f_caculate(road_car1))if f < gbest*(1 + ran):T_roadcar.append(copy.deepcopy(road_car1))answer.append(f)road_car1 = self.mo.opt_3(road_car1)f = sum(self.cd.f_caculate(road_car1))if f < gbest*(1 + ran):T_roadcar.append(copy.deepcopy(road_car1))answer.append(f)return T_roadcar, answer

步骤3的邻域搜索:接受更好的解

步骤2得到一组解时,步骤3分别寻优,寻优时把algorithm1(self,road_car, gbest, ran, T_roadcar, answer)的

road_car设置为各个解的路径,gbest设置为各个解的开销,ran设置为0

其余步骤同上面算法步骤相同。代码太冗杂,运行速度慢,没再考虑perturb2 。

def msil(self):f = self.cd.f_caculate(self.road_car_init)gbest = sum(f)result = [[], []]for I in range(self.Max_I):                         # 算法步骤6if I == 0:road_car = copy.deepcopy(self.road_car_init)print(f'第{I}次迭代的最小开销是:{gbest}')result[0].append(I)result[1].append(gbest)H = 0T_roadcar, answer = [], []while H < self.Max_H:road_car2 = copy.deepcopy(road_car)          # 备份road_car,否则下面算子操作会引起road_car变化k = random.randint(self.car_num, self.car_num*2)for kk in range(k):                          # k次扰动,对应算法步骤2T_roadcar,answer = self.algorithm1(road_car,gbest,self.ran,T_roadcar,answer)T_roadcarx = copy.deepcopy(T_roadcar)road_car = road_car2                         # road_car再赋值signal = 0if answer:                                   # 如果扰动得到一组新解count = 0for car_ro in T_roadcarx:                # 每个新解寻优fx = answer[count]T_roadcar1, answer1 = [], []T_roadcar1, answer1 = self.algorithm1(car_ro,fx,0,T_roadcar1,answer1)if T_roadcar1:                       # 如果新解得到改进,一个解的算法步骤3结束if min(answer1) < gbest:         # 比较改进的解和gbestgbest = min(answer1)idx = answer1.index(min(answer1))road_car = T_roadcar1[idx]signal = 1                   # 如果比gbest还优秀,更新gbest并赋值signal为1count += 1if signal == 1:                              # gbest更新时H赋值1否则H++,对应算法步骤5H = 1else:H += 1print(f'第{I+1}次迭代的最小开销是:{gbest}')result[0].append(I)result[1].append(gbest)return road_car, result

结果

代码运行环境
windows系统,python3.6.0,第三方库及版本号如下:

numpy==1.18.5
matplotlib==3.2.1

第三方库需要在安装完python之后,额外安装,以前文章有讲述过安装第三方库的解决办法。

主函数

设计主函数如下:

import data
import numpy as np
from MSILS_OPER import msils_O
from code_decode import co_de
from MSILS import msilis
import paintx, y, demand, x1, y1 = data.read()         # 数据
load = 130                                 # 载重
car_num = 15                               # 总车辆               
every_num = 5                              # 每个车场车辆parm_data = [x, y, demand, x1, y1]
parm_ = [load, car_num, every_num]mo = msils_O(parm_data, parm_)             # 邻域算子模块
cd = co_de(parm_data, parm_)               # 编码解码模块
road_car = cd.creat_init()                 # 初始路径Max_H = 5                                  # 算法参数,见推文
ran = 0.2
Max_I = 10                                 # 迭代次数                    parm_ms = [mo, cd, road_car, car_num, Max_H, ran, Max_I]
ms = msilis(parm_ms)                       # 邻域算法模块
road_car, result = ms.msil()               # 结果paint.draw_all(cd, road_car, x, y, x1, y1,every_num,car_num)# 路径图
paint.draw_change(result)                  # 开销变化图

运行结果

结果如下:

在这里插入图片描述

总路径图:
在这里插入图片描述

车场1
在这里插入图片描述

车场2
在这里插入图片描述

车场3
在这里插入图片描述

成本随迭代次数的变化图如下:
在这里插入图片描述

还有优化空间,增大迭代次数试试。

结论

本推文主要是对参考论文进行复现,也有自己的小设计,但基本是复现原文,具体算法步骤见文献,不做过多介绍。

数据采用rc101,可修改数据

参考文献:
[1]王新玉,唐加福,邵帅.多车场带货物权重车辆路径问题邻域搜索算法[J].系统工程学报,2020,35(06):806-815.DOI:10.13383/j.cnki.jse.2020.06.008.

代码

为了方便,把代码浓缩在3个代码里,excel数据生成后每次运行main.py无需再运行data_collect().txt_to_xlsx() 。

演示视频:

论文复现丨多车场带货物权重车辆路径问题:改进邻域搜索算法

文末

完整算法+数据:
完整算法源码+数据:见下方微信公众号:关注后回复:调度

# 微信公众号:学长带你飞
# 主要更新方向:1、柔性车间调度问题求解算法
#              2、学术写作技巧
#              3、读书感悟
# @Author  : Jack Hao

这篇关于论文复现丨多车场带货物权重车辆路径问题:改进邻域搜索算法的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/968624

相关文章

好题——hdu2522(小数问题:求1/n的第一个循环节)

好喜欢这题,第一次做小数问题,一开始真心没思路,然后参考了网上的一些资料。 知识点***********************************无限不循环小数即无理数,不能写作两整数之比*****************************(一开始没想到,小学没学好) 此题1/n肯定是一个有限循环小数,了解这些后就能做此题了。 按照除法的机制,用一个函数表示出来就可以了,代码如下

hdu1043(八数码问题,广搜 + hash(实现状态压缩) )

利用康拓展开将一个排列映射成一个自然数,然后就变成了普通的广搜题。 #include<iostream>#include<algorithm>#include<string>#include<stack>#include<queue>#include<map>#include<stdio.h>#include<stdlib.h>#include<ctype.h>#inclu

hdu2544(单源最短路径)

模板题: //题意:求1到n的最短路径,模板题#include<iostream>#include<algorithm>#include<cstring>#include<stack>#include<queue>#include<set>#include<map>#include<stdio.h>#include<stdlib.h>#include<ctype.h>#i

购买磨轮平衡机时应该注意什么问题和技巧

在购买磨轮平衡机时,您应该注意以下几个关键点: 平衡精度 平衡精度是衡量平衡机性能的核心指标,直接影响到不平衡量的检测与校准的准确性,从而决定磨轮的振动和噪声水平。高精度的平衡机能显著减少振动和噪声,提高磨削加工的精度。 转速范围 宽广的转速范围意味着平衡机能够处理更多种类的磨轮,适应不同的工作条件和规格要求。 振动监测能力 振动监测能力是评估平衡机性能的重要因素。通过传感器实时监

缓存雪崩问题

缓存雪崩是缓存中大量key失效后当高并发到来时导致大量请求到数据库,瞬间耗尽数据库资源,导致数据库无法使用。 解决方案: 1、使用锁进行控制 2、对同一类型信息的key设置不同的过期时间 3、缓存预热 1. 什么是缓存雪崩 缓存雪崩是指在短时间内,大量缓存数据同时失效,导致所有请求直接涌向数据库,瞬间增加数据库的负载压力,可能导致数据库性能下降甚至崩溃。这种情况往往发生在缓存中大量 k

poj 1734 (floyd求最小环并打印路径)

题意: 求图中的一个最小环,并打印路径。 解析: ans 保存最小环长度。 一直wa,最后终于找到原因,inf开太大爆掉了。。。 虽然0x3f3f3f3f用memset好用,但是还是有局限性。 代码: #include <iostream>#include <cstdio>#include <cstdlib>#include <algorithm>#incl

AI hospital 论文Idea

一、Benchmarking Large Language Models on Communicative Medical Coaching: A Dataset and a Novel System论文地址含代码 大多数现有模型和工具主要迎合以患者为中心的服务。这项工作深入探讨了LLMs在提高医疗专业人员的沟通能力。目标是构建一个模拟实践环境,人类医生(即医学学习者)可以在其中与患者代理进行医学

6.1.数据结构-c/c++堆详解下篇(堆排序,TopK问题)

上篇:6.1.数据结构-c/c++模拟实现堆上篇(向下,上调整算法,建堆,增删数据)-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小): 2.2 C语言代码(手写堆) 2.3 C++代码(使用优先级队列 priority_queue)

论文翻译:arxiv-2024 Benchmark Data Contamination of Large Language Models: A Survey

Benchmark Data Contamination of Large Language Models: A Survey https://arxiv.org/abs/2406.04244 大规模语言模型的基准数据污染:一项综述 文章目录 大规模语言模型的基准数据污染:一项综述摘要1 引言 摘要 大规模语言模型(LLMs),如GPT-4、Claude-3和Gemini的快

【VUE】跨域问题的概念,以及解决方法。

目录 1.跨域概念 2.解决方法 2.1 配置网络请求代理 2.2 使用@CrossOrigin 注解 2.3 通过配置文件实现跨域 2.4 添加 CorsWebFilter 来解决跨域问题 1.跨域概念 跨域问题是由于浏览器实施了同源策略,该策略要求请求的域名、协议和端口必须与提供资源的服务相同。如果不相同,则需要服务器显式地允许这种跨域请求。一般在springbo