def plan(graph, cars, answer_path):
cur_carlist = {}
for index, row in enumerate(cars.iterrows()):
if index > 100:
row[1]['planTime'] += (index - 100) // 40 + 1
single_answer = list()
cur_carlist[index] = Class.Cars(row[1]['id'], row[1]['from'], row[1]['to'], row[1]['speed'],\
row[1]['planTime'], collections.defaultdict(set))
# 对当前车辆进行路径规划（+planTime的延迟）
path = path_plan(graph, cur_carlist, index)
single_answer.append(row[1]['id'])
single_answer.append(row[1]['planTime'])
for i in path:
single_answer.append(i)
single_answer = tuple(single_answer)
answer = str(single_answer)
ans_str = answer.replace("[","(").replace("],",")\n").replace("((","(").\
replace("]]",")\n").replace(" ", '')
with open(answer_path, 'a') as f:
f.write(ans_str + '\n')
def plan(graph, pre_cars, our_cars, pre_path, answer_path):
cur_carlist = {}
pre = 0
flow_size = 70 # 每个时间步可进入网络的流量 包括预置车在内 预置车也将被分片
# t = [0] * 6000 # 分配6000个时间片，记录时刻t已分配的车辆数
add = 0 # 记录每个时间片应该后移的时间片数
# pre_carnum = pre_cars[pre_cars['planTime']==1].shape(0) # 初始化 需要注意pre_cars可能不是从planTime=1开始
# if pre_carnum > flow_size:
# flow_size = 0
# else:
# flow_size -= pre_carnum
now = 1 # 记录当前调度所处时间步（非系统时间）
for index, car in enumerate(our_cars.iterrows()):
'''
判断普通车流量
'''
if flow_size == 0:
# add += 1 # 如果这时planTime=4 +1的话 又需要重新载入预置车辆了 怎么办？
now += 1 # 时间片后移一个
# flow_size重置
flow_size = 60
else:
flow_size -= 1 # 流量窗口减一
'''
载入预置车
'''
if pre < now:
# 统计此时刻预置车辆的数量(注意这里的时间now可能不是连续的)
pre_carnum = len(pre_cars[pre_cars['planTime'] == now])
if pre_carnum >= 70: # 预置车过多
'''
将时间片后移（整体后移）
例如，planTime=1时有80辆预置车要出发，则时间步后移一个单位到planTime=2，且planTime=1的时刻多出的20辆车将占用20个流量窗口
（尽管实际调度时这80辆车都是在planTime=1时出发的）
'''
add += pre_carnum // 70 # 此时间步需要后移的步数
# 载入预置车后，重置流量窗口
now += add
flow_size = 70 - (pre_carnum % 70) # 剩余流量窗口
else:
flow_size -= pre_carnum # 剩余流量窗口
# 加载上一次时间步pre到当前时间步now的预置车辆网络状态
load_traffic(graph, pre_cars, pre_path, pre, now)
pre = now
if car[1]['planTime'] > now:
print(s)
car[1]['planTime'] = now
single_answer = list()
# if car[1][' preset'] == 0: # 非预置车辆
cur_carlist[index] = Class.Cars(car[1]['id'], car[1]['from'], car[1]['to'], car[1]['speed'],\
car[1]['planTime'], collections.defaultdict(set), car[1][' priority'], car[1][' preset'])
path = path_plan(graph, cur_carlist, index)
single_answer.append(car[1]['id'])
single_answer.append(car[1]['planTime'])
for i in path:
single_answer.append(i)
single_answer = tuple(single_answer)
answer = str(single_answer)
ans_str = answer.replace("[","(").replace("],",")\n").replace("((","(").\
replace("]]",")\n").replace(" ", '')
with open(answer_path, 'a') as f:
f.write(ans_str + '\n')
def plan(graph, pre_cars, our_cars, pre_path, answer_path):
cur_carlist = {}
pre = 0
# flow_size, cur_size = 140, 140 # 每个时间步可进入网络的流量 包括预置车在内 预置车也将被分片
flow_size, cur_size = 20, 20
# t = [0] * 6000 # 分配6000个时间片，记录时刻t已分配的车辆数
add = 0 # 记录每个时间片应该后移的时间片数
# pre_carnum = pre_cars[pre_cars['planTime']==1].shape(0) # 初始化 需要注意pre_cars可能不是从planTime=1开始
# if pre_carnum > flow_size:
# flow_size = 0
# else:
# flow_size -= pre_carnum
# car_statistics = dict()
car_statistics = []
now = 1 # 记录当前调度所处时间步（非系统时间）
# 预置车最晚的出发时间
pre_last = max(pre_cars['planTime'])
for index, car in enumerate(our_cars.iterrows()):
'''
判断普通车流量
'''
if cur_size <= 0:
# add += 1 # 如果这时planTime=4 +1的话 又需要重新载入预置车辆了 怎么办？
now += 1 # 时间片后移一个
# cur_size重置
cur_size = flow_size
else:
cur_size -= 1 # 流量窗口减一
'''
载入预置车
'''
if now > pre_last + 5:
flow_size = 50 # 后面的普通车
# if graph.road_value_t.get(now, None):
# _, _, car_nums = Analysis.traffic_analysis(graph, now-1)
# # if car_nums >= 8000:
# # cur_size -= 1
# if car_nums >= 8500:
# cur_size -= 2
if pre < now:
# 统计此时刻预置车辆的数量(注意这里的时间now可能不是连续的)
pre_carnum = len(pre_cars[pre_cars['planTime'] == now])
if pre_carnum >= flow_size: # 预置车过多
'''
将时间片后移（整体后移）
例如，planTime=1时有80辆预置车要出发，则时间步后移一个单位到planTime=2，且planTime=1的时刻多出的20辆车将占用20个流量窗口
（尽管实际调度时这80辆车都是在planTime=1时出发的）
'''
add += pre_carnum // flow_size # 此时间步需要后移的步数
# 载入预置车后，重置流量窗口
now += add
cur_size = flow_size - (pre_carnum % flow_size) # 剩余流量窗口
else:
cur_size -= pre_carnum # 剩余流量窗口
# 加载上一次时间步pre到当前时间步now的预置车辆网络状态
load_traffic(graph, pre_cars, pre_path, pre, now, pre_last)
pre = now
# 当前时刻网络状态评估
# bug：now在上面可能被更新，但这个时期的流量还未更新
# if graph.road_value_t.get(now, None):
# _, _, car_nums = Analysis.traffic_analysis(graph, now)
# # if car_nums >= 8000:
# # cur_size -= 1
# if car_nums >= 9600: # 改进，如果在上一时刻发现car_nums也大 则这里应该继续减少
# cur_size -= 1
# if car_nums >= 10000:
# cur_size -= 5
# # else:
# # cur_size = 65
# # car_statistics[index] = [now, car_nums]
if car[1]['planTime'] > now:
now = car[1]['planTime']
car[1]['planTime'] = now
single_answer = list()
# if car[1][' preset'] == 0: # 非预置车辆
cur_carlist[index] = Class.Cars(car[1]['id'], car[1]['from'], car[1]['to'], car[1]['speed'],\
car[1]['planTime'], collections.defaultdict(set), car[1][' priority'], car[1][' preset'])
path = path_plan(graph, cur_carlist, index)
single_answer.append(car[1]['id'])
single_answer.append(car[1]['planTime'])
for i in path:
single_answer.append(i)
single_answer = tuple(single_answer)
answer = str(single_answer)
ans_str = answer.replace("[","(").replace("],",")\n").replace("((","(").\
replace("]]",")\n").replace(" ", '')
with open(answer_path, 'a') as f:
f.write(ans_str + '\n')
def plan(graph, cars, answer_path):
car_statistics = []
cur_carlist = {}
nu = [
1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000, 5500, 6000, 6500, 7000,
7500, 8000, 8500, 9000, 9500, 10000
]
for index, row in enumerate(cars.iterrows()):
if index > 100:
# if index >
row[1]['planTime'] += (index - 100) // 15 + 1
# elif index > nu[0] and index < nu[1]:
# row[1]['planTime'] += (index-nu[1])//20 + 1
# elif index > nu[2] and index < nu[3]:
# row[1]['planTime'] += (index-nu[0])//20 + 1
# elif index > nu[4] and index < nu[5]:
# row[1]['planTime'] += (index-nu[0])//20 + 1
# elif index > nu[6] and index < nu[7]:
# row[1]['planTime'] += (index-nu[0])//20 + 1
# elif index > nu[8] and index < nu[9]:
# row[1]['planTime'] += (index-nu[0])//20 + 1
# elif index > nu[10] and index < nu[11]:
# row[1]['planTime'] += (index-nu[0])//20 + 1
# elif index > nu[12] and index < nu[13]:
# row[1]['planTime'] += (index-nu[0])//20 + 1
# elif index > nu[14] and index < nu[15]:
# row[1]['planTime'] += (index-nu[0])//20 + 1
# elif index > nu[16] and index < nu[17]:
# row[1]['planTime'] += (index-nu[0])//20 + 1
# else:
# row[1]['planTime'] += (index-nu[0])//15 + 1
# elif index >= 500:
# row[1]['planTime'] += (index-100)//20 + 1
single_answer = list()
cur_carlist[index] = Class.Cars(row[1]['id'], row[1]['from'], row[1]['to'], row[1]['speed'],\
row[1]['planTime'], collections.defaultdict(set))
# 当前网络状况评估
# print('%d - %d' % (row[1]['from'], row[1]['to']))
f_nums, r_nums, car_nums = Analysis.traffic_analysis(
graph, row[1]['planTime'])
# print(f_nums, r_nums, car_nums) # 发现上面plan函数里更新path_value有错
# if index == 1:
# print(s)
car_statistics.append([index, row[1]['planTime'], car_nums])
# np.savetxt('analysis.txt', car_statistics)
# 对当前车辆进行路径规划（+planTime的延迟）
path = path_plan(graph, cur_carlist, index)
single_answer.append(row[1]['id'])
single_answer.append(row[1]['planTime'])
for i in path:
single_answer.append(i)
single_answer = tuple(single_answer)
answer = str(single_answer)
ans_str = answer.replace("[","(").replace("],",")\n").replace("((","(").\
replace("]]",")\n").replace(" ", '')
with open(answer_path, 'a') as f:
f.write(ans_str + '\n')
np.savetxt('analysis.txt', car_statistics)
