def action(vehicle: util.Vehicle):
riders = ii.riders
rider = riders[vehicle.picked_up[0]]
from_node = rider.from_node
to_node = rider.to_node
(shortest_path, shortest_time) = ii.floyd_path(from_node, to_node)
time_slack = rider.deadline - rider.appear_slot - shortest_time
if time_slack > 10:
neighbor = st.gen_neighbor(shortest_path, time_slack)
if len(neighbor) >= 2:
best_expected = 0
best_pair = [-1, -1]
for i in range(len(neighbor)):
for j in range(len(neighbor)):
if i == j:
continue
temp_expected = st.cal_expected_revenue(
vehicle, neighbor[i], neighbor[j])
a_d = vehicle.slot + ii.floyd_path(vehicle.location, neighbor[i])[1] + \
ii.floyd_path(neighbor[i], neighbor[j])[1] + ii.floyd_path(neighbor[j], to_node)[1]
if temp_expected > best_expected and a_d <= rider.deadline:
best_expected = temp_expected
best_pair[0], best_pair[1] = neighbor[i], neighbor[j]
if best_pair != [-1, -1]:
vehicle.pre_pickup = best_pair
else:
return
def check_feasible_3(v, s: int, drop:int ,ddl:int, slot:int) -> (list,bool):
ddl_list = []
des = []
multiple_feasible = []
if v.load >= v.cap:
return {}, False
else:
for rider in v.onboard:
ddl_list.append(ii.riders[rider].deadline)
des.append(ii.riders[rider].to_node)
ddl_list.append(ddl)
des.append(drop)
for i in range(len(des)):
for j in range(len(des)):
if j == i:
continue
t_i = slot + ii.floyd_path(s, des[i])[1] / util.average_speed
t_j = t_i + ii.floyd_path(des[i], des[j])[1] / util.average_speed
for k in range(len(des)):
if k == i or k == j:
continue
t_k = t_j + ii.floyd_path(des[j], des[k])[1] / util.average_speed
if t_i <= ddl_list[i] and t_j <= ddl_list[j] and t_k <= ddl_list[k]:
final_des = [des[i], des[j], des[k]]
multiple_feasible.append((final_des, t_k))
if len(multiple_feasible) > 0:
sorted(multiple_feasible, key=lambda x: x[1])
return multiple_feasible[0][0], True
else:
return [], False
def re_replan_route(self, des_list: int):
self.route = ii.floyd_path(self.location, des_list[0])[0]
for i in range(len(des_list) - 1):
route = ii.floyd_path(des_list[i], des_list[i + 1])[0]
if len(route) > 1:
route.pop(0)
self.route += route
return
def cal_final_revenue(v) -> int:
final_revenue = 0
for r in v.picked_up:
ea = ii.riders[r].appear_slot + ii.floyd_path(
ii.riders[r].from_node,
ii.riders[r].to_node)[1] / util.average_speed
a = v.drop_off_slot[r]
print('delay:')
print(a - ea)
revenue = rate * ii.floyd_path(
ii.riders[r].from_node, ii.riders[r].to_node)[1] - beta * (a - ea)
final_revenue += revenue
return final_revenue
def feasible1_check(pre1:int,drop1:int,pre2:int,d:int, ddl: int, time_1:int) -> dict:
feasible_dict = {}
min_i = time_1 + ii.floyd_path(pre1, drop1)[1] / util.average_speed
time_i = time_1 + ii.floyd_path(pre1, drop1)[1] / util.average_speed
time_d = time_i + (ii.floyd_path(drop1, pre2)[1] + ii.floyd_path(pre2,d)[1]) /util.average_speed
feasible_dict[1] = (False if time_d > ddl else True)
time_i = time_1 + (ii.floyd_path(pre1, pre2)[1] + ii.floyd_path(pre2, drop1)[1]) / util.average_speed
time_d = time_i + ii.floyd_path(drop1, d)[1] / util.average_speed
feasible_dict[2] = (False if time_d > ddl or time_i > (min_i + 20) else True)
time_d = time_1 + (ii.floyd_path(pre1, pre2)[1] + ii.floyd_path(pre2, d)[1]) / util.average_speed
time_i = time_d + ii.floyd_path(d, drop1)[1] / util.average_speed
feasible_dict[3] = (False if time_d > ddl or time_i > (min_i + 20) else True)
return feasible_dict
def stage_one(v: util.Vehicle):
stage_2.stage_two(v)
s = ii.riders[v.picked_up[0]].from_node
d = ii.riders[v.picked_up[0]].to_node
slot_t = ii.riders[v.picked_up[0]].deadline
slot_0 = v.slot
slot_list = [slot for slot in range(slot_0, slot_t + 1)]
global hat_P, w_i, f
hat_P = chp.cal_hat_P(slot_list)
w_i = cr.cal_expected_revenue(v, hat_P, slot_list)
for i in gm.nodes:
for t in slot_list:
f[(i, t)] = -1
for t in slot_list:
if t >= slot_t:
f[(d,
t)] = cr.rate * ii.floyd_path(s, d)[1] - cr.beta * (t - slot_0)
nodes = gm.nodes.copy()
nodes.remove(d)
slot_list = list(reversed(slot_list))
for t in slot_list:
for i in nodes:
for j in gm.out[i]:
if t + gm.delta[(i, j)] <= slot_t:
temp = hat_P[(i, t)] * w_i[(i, t)] + (1 - hat_P[
(i, t)]) * (f[(j, t + gm.delta[(i, j)])])
f[(i, t)] = max(f[(i, t)], temp)
v.route = [s]
t = slot_0
Backtrack(v, s, t)
v.route = route.copy()
def gen_neighbor(shortest_path: list, time_slack: int = 10) -> list:
neighbor = []
for i in range(len(shortest_path) - 1):
for j in gen_map.nodes:
if j not in neighbor and i and ii.floyd_path(i,j)[1] <= time_slack / 2:
neighbor.append(j)
dict1 = {}
s = shortest_path[0]
d = shortest_path[-1]
max_dis = ii.floyd_path(s,d)[1]
for i in neighbor:
dict1[i] = ii.floyd_path(s, i)[1]
dict1 = {k:v for k,v in dict1.items() if v < max_dis}
sort_dict = dict(sorted(dict1.items(), key=lambda d: d[1], reverse=False))
neighbor = list(sort_dict.keys())
return neighbor
def update_pick(self,node1:int, des_order:dict):
self.route = []
if len(self.picked_up) == 3:
des_list = list(des_order.items())
self.route = ii.floyd_path(node1, des_list[0][1])[0]
for i in range(len(des_list) - 1):
list_temp = ii.floyd_path(des_list[i][1], des_list[i + 1][1])[0]
if len(list_temp) > 1:
list_temp.pop(0)
self.route += list_temp
return
else:
des_list = list(des_order.items())
shortest_path = ii.floyd_path(node1, des_list[0][1])[0]
slack = ii.riders[des_list[0][0]].deadline - (self.slot + ii.floyd_path(node1, des_list[0][1])[1] / average_speed)
neighbor = strategy.gen_neighbor(shortest_path, slack)
best, best_node, temp = 0, 0 ,0
if len(neighbor) == 0:
self.route = shortest_path
list_temp = ii.floyd_path(des_list[0][1], des_list[1][1])[0]
if len(list_temp) > 1:
list_temp.pop(0)
self.route += list_temp
else:
for node in neighbor:
time = self.slot + ii.floyd_path(node1, node)[1] / average_speed
temp = strategy.cal_best_one(self, node, int(time))
if temp > best:
best_node = node
if best_node == 0:
self.route = shortest_path
list_temp = ii.floyd_path(des_list[0][1], des_list[1][1])[0]
if len(list_temp) > 1:
list_temp.pop(0)
self.route += list_temp
else:
self.route = ii.floyd_path(node1, best_node)[0]
list_temp = ii.floyd_path(best_node, des_list[0][1])[0]
if len(list_temp) > 1:
list_temp.pop(0)
self.route += list_temp
list_temp = ii.floyd_path(des_list[0][1], des_list[1][1])[0]
if len(list_temp) > 1:
list_temp.pop(0)
self.route += list_temp
return
def replan_route(self, type: int):
rider = self.picked_up[-1]
d = ii.riders[self.picked_up[0]].to_node
i = ii.riders[rider].from_node
j = ii.riders[rider].to_node
self.route = []
if type == 1:
self.route = ii.floyd_path(i, j)[0]
temp = ii.floyd_path(j, d)[0]
if len(temp) > 1:
temp.pop(0)
self.route += temp
else:
self.route = ii.floyd_path(i, d)[0]
temp = ii.floyd_path(d, j)[0]
if len(temp) > 1:
temp.pop(0)
self.route += temp
def cal_last_one_revenue(v, drop_list, time, node) -> float:
a_i_list = []
ea_i_list = []
dis_i = []
a_i = time
revenue = 0
order_dict = {}
for i in range(len(drop_list)):
for rider in v.onboard:
if ii.riders[rider].to_node == drop_list[i]:
order_dict[i] = rider
break
if i not in order_dict.keys():
order_dict[i] = -1
order_dict = dict(
sorted(order_dict.items(), key=lambda e: e[0], reverse=False))
for i in range(len(order_dict)):
if order_dict[i] == -1:
a_i_list.append(a_i + ii.floyd_path(node, drop_list[i])[1] /
util.average_speed)
ea_i_list.append(time + ii.floyd_path(node, drop_list[i])[1] /
util.average_speed)
dis_i.append(ii.floyd_path(node, drop_list[i])[1])
if order_dict[i] == v.onboard[0]:
a_i_list.append(a_i + ii.floyd_path(node, drop_list[i])[1] /
util.average_speed)
ea_i_list.append(
ii.riders[v.onboard[0]].appear_slot +
ii.floyd_path(ii.riders[v.onboard[0]].from_node, ii.riders[
v.onboard[0]].to_node)[1] / util.average_speed)
dis_i.append(
ii.floyd_path(ii.riders[v.onboard[0]].from_node,
ii.riders[v.onboard[0]].to_node)[1])
if order_dict == v.onboard[1]:
a_i_list.append(a_i + ii.floyd_path(node, drop_list[i])[1] /
util.average_speed)
ea_i_list.append(
ii.riders[v.onboard[1]].appear_slot +
ii.floyd_path(ii.riders[v.onboard[1]].from_node, ii.riders[
v.onboard[1]].to_node)[1] / util.average_speed)
dis_i.append(
ii.floyd_path(ii.riders[v.onboard[1]].from_node,
ii.riders[v.onboard[1]].to_node)[1])
node = drop_list[i]
for i in range(len(a_i_list)):
r = rate * dis_i[i] - beta * (a_i_list[i] - ea_i_list[i])
revenue += r
return revenue
def cal_best_one(v, node: int, time:int) -> int:
factor = 0
for drop in gen_map.nodes:
ddl = time + ii.floyd_path(node, drop)[1] / util.average_speed + 40
(drop_list, flag) = fc.check_feasible_3(v, node, drop, ddl, time)
if flag:
w = cr.cal_last_one_revenue(v, drop_list, time, node)
factor += cp.P_ij[node][drop][time] * w
factor *= cp.P_i[node][time]
return factor
def feasible2_check(type1: int,pre2, drop2, drop1, ddl_1, d, ddl, time_2 ) -> dict:
ddl_2 = time_2 + ii.floyd_path(pre2, drop2)[1] / util.average_speed + 20
feasible_dict = {}
if type1 == 3:
d,drop1 = drop1,d
ddl, ddl_1 = ddl_1, ddl
time_j = time_2 + ii.floyd_path(pre2, drop2)[1] / util.average_speed
time_i = time_j + ii.floyd_path(drop2, drop1)[1] / util.average_speed
time_d = time_i + ii.floyd_path(drop1, d)[1] / util.average_speed
feasible_dict[3] = (False if time_i > ddl_1 or time_d > ddl else True)
time_i = time_2 + ii.floyd_path(pre2, drop1)[1] / util.average_speed
time_j = time_i + ii.floyd_path(drop1, drop2)[1] / util.average_speed
time_d = time_j + ii.floyd_path(drop2, d)[1] / util.average_speed
feasible_dict[4] = (False if time_i > ddl_1 or time_j > ddl_2 or time_d > ddl else True)
time_i = time_2 + ii.floyd_path(pre2, drop1)[1] / util.average_speed
time_d = time_i + ii.floyd_path(drop1, d)[1] / util.average_speed
time_j = time_d + ii.floyd_path(d, drop2)[1] / util.average_speed
feasible_dict[5] = (False if time_i > ddl_1 or time_j > ddl_2 or time_d > ddl else True)
return feasible_dict
def feasible_pick(v: util.Vehicle, rider: int) -> (list, bool):
ddl_list = []
des = []
slot = v.slot
s = ii.riders[rider].from_node
multiple_feasible = []
if v.load >= v.cap:
return [], False
else:
for rider in v.onboard:
ddl_list.append(ii.riders[rider].deadline)
des.append(ii.riders[rider].to_node)
for i in range(len(des)):
for j in range(len(des)):
if j == i:
continue
t_i = slot + ii.floyd_path(s, des[i])[1] / util.average_speed
t_j = t_i + ii.floyd_path(des[i],
des[j])[1] / util.average_speed
if len(des) == 3:
for k in range(len(des)):
if k == i or k == j:
continue
# final_des = OrderedDict()
t_k = t_j + ii.floyd_path(
des[j], des[k])[1] / util.average_speed
dis = ii.floyd_path(des[j], des[k])[1] + ii.floyd_path(des[i], des[j])[1] + \
ii.floyd_path(s, des[i])[1]
if t_i <= ddl_list[i] and t_j <= ddl_list[
j] and t_k <= ddl_list[k]:
final_des = [des[i], des[j], des[k]]
# final_des[v.onboard[i]] = des[i]
# final_des[v.onboard[j]] = des[j]
# final_des[v.onboard[k]] = des[k]
multiple_feasible.append((final_des, dis))
else:
# final_des = OrderedDict()
dis = ii.floyd_path(des[i], des[j])[1] + ii.floyd_path(
s, des[i])[1]
if t_i <= ddl_list[i] and t_j <= ddl_list[j]:
final_des = [des[i], des[j]]
# final_des[v.onboard[i]] = des[i]
# final_des[v.onboard[j]] = des[j]
multiple_feasible.append((final_des, dis))
if len(multiple_feasible) > 0:
multiple_feasible = sorted(multiple_feasible,
key=lambda x: x[1],
reverse=False)
return multiple_feasible[0][0], True
else:
return [], False
return [], False
def cal_pre2_revenue(v, type2, pre1, pre2, drop2, time2) -> float:
d = ii.riders[v.picked_up[0]].to_node
if type2 == 1:
a_2 = time2 + ii.floyd_path(pre2, drop2)[1] / util.average_speed
a_d = a_2 + ii.floyd_path(drop2, d)[1] / util.average_speed
else:
a_d = time2 + ii.floyd_path(pre2, d)[1] / util.average_speed
a_2 = a_d + ii.floyd_path(d, drop2)[1] / util.average_speed
ea_2 = time2 + ii.floyd_path(pre2, drop2)[1] / util.average_speed
ea_d = v.slot + ii.floyd_path(v.location, d)[1] / util.average_speed
r_2 = rate * ii.floyd_path(pre2, drop2)[1] - beta * (a_2 - ea_2)
r_d = rate * ii.floyd_path(v.location, d)[1] - beta * (a_d - ea_d)
return r_2 + r_d
def feasible1_set(d:int ,ddl: int, pre1: int, time_1: int, pre2: int) -> dict:
order_dict = {}
return_dict = {}
for drop1 in gen_map.nodes:
dis1 = ii.floyd_path(pre1, drop1)[1] + ii.floyd_path(drop1, pre2)[1] + ii.floyd_path(pre2, d)[1]
dis2 = ii.floyd_path(pre1, pre2)[1] + ii.floyd_path(pre2, drop1)[1] + ii.floyd_path(drop1, d)[1]
dis3 = ii.floyd_path(pre1, pre2)[1] + ii.floyd_path(pre2, d)[1] + ii.floyd_path(d, drop1)[1]
order_dict[1], order_dict[2], order_dict[3] = dis1, dis2, dis3
feasible_dict = feasible1_check(pre1,drop1,pre2,d, ddl, time_1)
if True not in feasible_dict.values():
continue
elif False not in feasible_dict.values():
type1 = sorted(order_dict.items(), key = lambda d:d[1],reverse=False)[0][0]
else:
true_key = [k for k,v in feasible_dict.items() if v == True]
true_dict = {k:v for k,v in order_dict.items() if k in true_key}
type1 = sorted(true_dict.items(), key=lambda d: d[1], reverse=False)[0][0]
return_dict[drop1] = type1
return return_dict
def update_first(self):
self.route = [self.location]
from_node = ii.riders[self.picked_up[0]].from_node
self.route.append(from_node)
if len(self.pre_pickup) > 0:
from_node = ii.riders[self.picked_up[-1]].from_node
to_node = self.pre_pickup[0]
self.route += ii.floyd_path(from_node, to_node)[0]
from_node = to_node
if len(self.pre_pickup) > 1:
for i in range(1, len(self.pre_pickup)):
from_node = self.pre_pickup[i-1]
to_node = self.pre_pickup[i]
self.route += ii.floyd_path(from_node, to_node)[0]
from_node = to_node
to_node = ii.riders[self.picked_up[0]].to_node
self.route += ii.floyd_path(from_node, to_node)[0]
temp_route = self.route.copy()
n = 0
nums = len(self.route) - 1
for i in range(nums):
if temp_route[i] == temp_route[i+1]:
self.route.pop(i - n)
n += 1
def gen_ori_riders() -> list:
df = pd.DataFrame(columns=('tpep_pickup_datetime', 'tpep_dropoff_datetime',
'PULocationID', 'DOLocationID', 'day'))
for k in range(50000):
t_p = randint(0, slot_nums - 1)
pickup = choice(nodes)
drop_off = choice(nodes)
d = randint(1, days)
min_travel_time = ii.floyd_path(pickup,
drop_off)[1] / util.average_speed
t_d = t_p + int(min_travel_time)
df.loc[k] = [t_p, t_d, pickup, drop_off, d]
df.to_csv(r'data\self_gen_riders.csv',
index=False,
header=True,
float_format='%d')
def check(v: util.Vehicle, pre, drop, slot) -> (int, bool):
d = ii.riders[v.picked_up[0]].to_node
ddl_d = ii.riders[v.picked_up[0]].deadline
ddl_drop = slot + ii.floyd_path(pre, drop)[1] / util.average_speed + 40
path_1 = ii.floyd_path(pre, drop)[1] + ii.floyd_path(drop, d)[1]
a_d_1 = slot + path_1 / util.average_speed
a_drop_1 = slot + ii.floyd_path(pre, drop)[1] / util.average_speed
path_2 = ii.floyd_path(pre, d)[1] + ii.floyd_path(d, drop)[1]
a_drop_2 = slot + path_2 / util.average_speed
a_d_2 = slot + ii.floyd_path(pre, d)[1] / util.average_speed
if check_feasible(a_d_1, ddl_d, a_drop_1, ddl_drop):
if check_feasible(a_d_2, ddl_d, a_drop_2, ddl_drop):
if a_d_1 + a_drop_1 < a_d_2 + a_drop_2:
return 1, True
else:
return 2, True
else:
return 1, True
else:
if check_feasible(a_d_2, ddl_d, a_drop_2, ddl_drop):
return 2, True
else:
return 0, False
def routing_stage(s, node1: int, node2: int) -> list:
if ii.floyd_path(s, node1)[1] + ii.floyd_path(node1, node2)[1] > ii.floyd_path(s, node2)[1] + \
ii.floyd_path(node2, node1)[1]:
return [node2, node1]
else:
return [node1, node2]
def cal_expected_revenue(vehicle, node1: int, node2: int) -> int:
first_rider = ii.riders[vehicle.picked_up[0]]
time = first_rider.appear_slot
s = first_rider.from_node
d = first_rider.to_node
ddl = first_rider.deadline
pre_pickup = routing_stage(s,node1, node2)
pre1, pre2 = pre_pickup[0], pre_pickup[1]
time_1 = ii.floyd_path(s, pre1)[1] / util.average_speed + time
expected_revenue = cp.P_i[pre1][int(time_1)]
set1_dict = fc.feasible1_set(d, ddl, pre1, time_1, pre2)
temp1 = 0
P, P1, P2, P3 = 0, 0, 0, 0
for drop1,type1 in set1_dict.items():
time_2 = cal_time_2(type1, pre1, drop1, pre2, time_1)
ddl_1 = time_1 + ii.floyd_path(pre1, drop1)[1] / util.average_speed + 20
set2_dict = fc.feasible2_set(type1,d,ddl, drop1, ddl_1, pre2, time_2)
temp2 = 0
infeasible_drop2 = set(gen_map.nodes) ^ set(set2_dict.keys())
term1 = 1 - cp.P_i[pre2][int(time_2)]
w = cr.cal_pre1_revenue(vehicle, type1, pre1, drop1,time_1, pre2, d)
for drop2 in infeasible_drop2:
P1 += cp.P_ij[pre2][drop2][int(time_2)]
term = w * P1 * cp.P_i[pre2][int(time_2)] + term1 * w
P1 = P1 * cp.P_i[pre2][int(time_2)]
for drop2,type2 in set2_dict.items():
w = cr.cal_two_revenue(vehicle, type1,type2, pre1,drop1,time_1, pre2,drop2, time_2, d)
temp2 += w * cp.P_ij[pre2][drop2][int(time_2)]
P2 += cp.P_ij[pre2][drop2][int(time_2)]
temp2 = temp2 * cp.P_i[pre2][int(time_2)]
temp1 += cp.P_ij[pre1][drop1][int(time_1)] * temp2
temp1 += cp.P_ij[pre1][drop1][int(time_1)] * term
P2 = P2 * cp.P_i[pre2][int(time_2)]
P += (P1 + P2 + term1) * cp.P_ij[pre1][drop1][int(time_1)]
expected_revenue *= temp1
P *= cp.P_i[pre1][int(time_1)]
factor2 = 1 - cp.P_i[pre1][int(time_1)]
temp4 = 0
rest = set(gen_map.nodes) ^ set(set1_dict.keys())
for drop1 in rest:
temp4 += cp.P_ij[pre1][drop1][int(time_1)]
factor2 = factor2 + cp.P_i[pre1][int(time_1)] * temp4
P4 = factor2
# factor2 += cp.P_i[pre1][int(time_1)] * cp.P_ij[pre2][drop1][int(time_1)]
time_2 = time_1 + ii.floyd_path(pre1, pre2)[1] / util.average_speed
set2_dict = fc.feasible2_set(1, d, ddl, 0, 0, pre2, time_2)
factor2 *= cp.P_i[pre2][int(time_2)]
temp = 0
P5 = 0
for drop2,type2 in set2_dict.items():
P5 += cp.P_ij[pre2][drop2][int(time_2)]
w = cr.cal_pre2_revenue(vehicle,type2, pre1, pre2, drop2, time_2)
temp += w * cp.P_ij[pre2][drop2][int(time_2)]
P5 *= cp.P_i[pre2][int(time_2)]
P = P + P4 + P5
factor2 *= temp
expected_revenue += factor2
no_ride_sharing_revenue = P * cr.cal_no_revenue(vehicle,pre1, pre2, d)
expected_revenue += no_ride_sharing_revenue
return expected_revenue
def cal_time_2(type1:int, pre1:int,drop1:int,pre2:int,time_1:int) -> int:
if type1 == 1:
time_2 = time_1 + (ii.floyd_path(pre1, drop1)[1] + ii.floyd_path(drop1, pre2)[1]) / util.average_speed
else:
time_2 = time_1 + (ii.floyd_path(pre1, pre2)[1]) / util.average_speed
return time_2
def feasible2_set(type1:int,d:int,ddl:int, drop1: int,ddl_1:int, pre2: int, time_2: int) -> dict:
order_dict = {}
return_dict = {}
if type1 == 1:
for drop2 in gen_map.nodes:
true_dict = {1:True, 2:True}
dis_dict = {}
dis1 = ii.floyd_path(pre2, drop2)[1] + ii.floyd_path(drop2, d)[1]
dis_dict[1] = dis1
if time_2 + dis1 / util.average_speed > ddl:
true_dict[1] = False
dis2 = ii.floyd_path(pre2, d)[1] + ii.floyd_path(d, drop2)[1]
dis_dict[2] = dis2
if time_2 + ii.floyd_path(pre2, d)[1] /util.average_speed > ddl or time_2 + dis2 /util.average_speed > \
time_2 + ii.floyd_path(pre2, drop2)[1] /util.average_speed + 40:
true_dict[2] = False
if True not in true_dict.values():
continue
else:
true_key = [k for k, v in true_dict.items() if v == True]
true_dict = {k: v for k, v in dis_dict.items() if k in true_key}
type2 = sorted(true_dict.items(), key=lambda d: d[1], reverse=False)[0][0]
return_dict[drop2] = type2
return return_dict
elif type1 == 3:
d,drop1 = drop1,d
ddl,ddl_1 = ddl_1,ddl
for drop2 in gen_map.nodes:
dis1 = ii.floyd_path(pre2, drop2)[1] + ii.floyd_path(drop2, drop1)[1] + ii.floyd_path(drop1, d)[1]
dis2 = ii.floyd_path(pre2, drop1)[1] + ii.floyd_path(drop1, drop2)[1] + ii.floyd_path(drop2, d)[1]
dis3 = ii.floyd_path(pre2, drop1)[1] + ii.floyd_path(drop1, d)[1] + ii.floyd_path(d, drop2)[1]
order_dict[3], order_dict[4], order_dict[5] = dis1, dis2, dis3
feasible_dict = feasible2_check(type1, pre2, drop2, drop1, ddl_1, d, ddl, time_2)
if True not in feasible_dict.values():
continue
elif False not in feasible_dict.values():
type2 = sorted(order_dict.items(), key = lambda d:d[1],reverse=False)[0][0]
else:
true_key = [k for k, v in feasible_dict.items() if v == True]
true_dict = {k:v for k, v in order_dict.items() if k in true_key}
type2 = sorted(true_dict.items(), key=lambda d: d[1], reverse=False)[0][0]
return_dict[drop2] = type2
return return_dict
def cal_pickup_revenue(v, slot_list) -> dict:
s = ii.riders[v.picked_up[0]].from_node
d = ii.riders[v.picked_up[0]].to_node
t_0 = ii.riders[v.picked_up[0]].appear_slot
ea_d = t_0 + ii.floyd_path(s, d)[1] / util.average_speed
w_ij = {}
for i in gen_map.nodes:
for j in gen_map.nodes:
for slot in slot_list:
(type, flag) = s2.feasible_dict[(i, j, slot)]
if flag:
if type == 1:
path_1 = ii.floyd_path(i, j)[1] + ii.floyd_path(j,
d)[1]
a_d_1 = slot + path_1 / util.average_speed
w_ij[(i, j, slot)] = rate * ii.floyd_path(
i, j)[1] + rate * ii.floyd_path(s, d)[1]
w_ij[(i, j, slot)] -= beta * (a_d_1 - ea_d)
else:
path_2 = ii.floyd_path(i, d)[1] + ii.floyd_path(d,
j)[1]
a_d_2 = slot + ii.floyd_path(i,
d)[1] / util.average_speed
a_drop_2 = slot + path_2 / util.average_speed
ea_drop_2 = slot + ii.floyd_path(
i, j)[1] / util.average_speed
w_ij[(i, j, slot)] = rate * ii.floyd_path(
s, d)[1] - beta * (a_d_2 - ea_d)
w_ij[(i, j, slot)] += rate * ii.floyd_path(
i, j)[1] / util.average_speed - beta * (a_drop_2 -
ea_drop_2)
return w_ij
def cal_pre1_revenue(v, type1, pre1, drop1, time_1, pre2, d) -> float:
if type1 == 1:
a_1 = time_1 + ii.floyd_path(pre1, drop1)[1] / util.average_speed
a_d = a_1 + (ii.floyd_path(drop1, pre2)[1] +
ii.floyd_path(pre1, drop1)[1]) / util.average_speed
elif type1 == 2:
a_1 = time_1 + (ii.floyd_path(pre1, pre2)[1] +
ii.floyd_path(pre2, drop1)[1]) / util.average_speed
a_d = a_1 + ii.floyd_path(drop1, d)[1] / util.average_speed
else:
a_d = time_1 + (ii.floyd_path(pre1, pre2)[1] +
ii.floyd_path(pre2, d)[1]) / util.average_speed
a_1 = a_d + ii.floyd_path(d, drop1)[1] / util.average_speed
ea_1 = time_1 + ii.floyd_path(pre1, drop1)[1] / util.average_speed
ea_d = v.slot + ii.floyd_path(v.location, d)[1] / util.average_speed
er_1 = rate * ii.floyd_path(pre1, drop1)[1] - beta * (a_1 - ea_1)
er_d = rate * ii.floyd_path(v.location, d)[1] - beta * (a_d - ea_d)
return er_1 + er_d
def cal_two_revenue(v, type1, type2, pre1, drop1, time1, pre2, drop2, time2,
d: int) -> float:
if type2 == 1:
a_1 = time1 + ii.floyd_path(pre1, drop1)[1] / util.average_speed
a_2 = time2 + ii.floyd_path(pre2, drop2)[1] / util.average_speed
a_d = a_2 + ii.floyd_path(drop2, d)[1] / util.average_speed
elif type2 == 2:
a_1 = time1 + ii.floyd_path(pre1, drop1)[1] / util.average_speed
a_d = time2 + ii.floyd_path(pre2, d)[1] / util.average_speed
a_2 = a_d + ii.floyd_path(d, drop2)[1] / util.average_speed
if type1 == 2:
if type2 == 3:
a_2 = time2 + ii.floyd_path(pre2, drop2)[1] / util.average_speed
a_1 = a_2 + ii.floyd_path(drop2, drop1)[1] / util.average_speed
a_d = a_1 + ii.floyd_path(drop1, d)[1] / util.average_speed
elif type2 == 4:
a_1 = time2 + ii.floyd_path(pre2, drop1)[1] / util.average_speed
a_2 = a_1 + ii.floyd_path(drop1, drop2)[1] / util.average_speed
a_d = a_2 + ii.floyd_path(drop2, d)[1] / util.average_speed
elif type2 == 5:
a_1 = time2 + ii.floyd_path(pre2, drop1)[1] / util.average_speed
a_d = a_1 + ii.floyd_path(drop1, d)[1] / util.average_speed
a_2 = a_d + ii.floyd_path(d, drop2)[1] / util.average_speed
elif type1 == 3:
if type2 == 3:
a_2 = time2 + ii.floyd_path(pre2, drop2)[1] / util.average_speed
a_d = a_2 + ii.floyd_path(drop2, d)[1] / util.average_speed
a_1 = a_d + ii.floyd_path(d, drop1)[1] / util.average_speed
elif type2 == 4:
a_d = time2 + ii.floyd_path(pre2, d)[1] / util.average_speed
a_2 = a_d + ii.floyd_path(d, drop2)[1] / util.average_speed
a_1 = a_2 + ii.floyd_path(drop2, drop1)[1] / util.average_speed
elif type2 == 5:
a_d = time2 + ii.floyd_path(pre2, d)[1] / util.average_speed
a_1 = a_d + ii.floyd_path(drop1, d)[1] / util.average_speed
a_2 = a_1 + ii.floyd_path(d, drop2)[1] / util.average_speed
ea_1 = time1 + ii.floyd_path(pre1, drop1)[1] / util.average_speed
er_1 = rate * ii.floyd_path(pre1, drop1)[1] - beta * (a_1 - ea_1)
ea_2 = time2 + ii.floyd_path(pre2, drop2)[1] / util.average_speed
er_2 = rate * ii.floyd_path(pre2, drop2)[1] - beta * (a_2 - ea_2)
ea_d = v.slot + ii.floyd_path(v.location, d)[1] / util.average_speed
er_d = rate * ii.floyd_path(v.location, d)[1] - beta * (a_d - ea_d)
return er_1 + er_2 + er_d
def cal_no_revenue(v, pre1, pre2, d) -> float:
ea_d = v.slot + ii.floyd_path(v.location, d)[1] / util.average_speed
a_d = v.slot + (ii.floyd_path(v.location, pre1)[1] + ii.floyd_path(pre1, pre2)[1] + ii.floyd_path(pre2, d)[1]) \
/ util.average_speed
return rate * (ii.floyd_path(v.location, d)[1]) - beta * (a_d - ea_d)
