2023年天府杯——C 题:码头停靠问题

问题背景:
某个港口有多个不同类型的码头,可以停靠不同种类的船只。每
艘船只需要一定的时间来完成装卸货物等任务,并且每个码头有容量
限制和停靠时间限制。港口需要在保证收益的情况下,尽可能地提高
运营效率和降低成本。同时,港口还需要根据船只的到达和离开时间
表,合理安排每个码头的使用,以满足不同船只的优先级和关系,以
及最小化等待和延迟时间。
船只的种类和数量、码头的类型和数量、每艘船只停靠所需的时
间、每个码头的容量和停靠时间限制、港口的运营成本和收益、船只
的到达和离开时间表、船只之间的优先级和关系、港口和码头的地理
布局和拓扑结构、港口的负载和运营效率数据以及其他相关的数据
(如天气、交通、货物流通等信息)等,都将对港口的运营效率和收
益产生重要影响。
1.如何确定每个码头的使用顺序和时间分配,以最小化船只的等
待和延迟时间?
2.如何在满足码头容量和停靠时间限制的前提下,最大化港口的
运营效率和收益?
3.如何根据船只的到达和离开时间表,合理安排每个码头的使用,
以满足不同船只的优先级和关系,以及最小化等待和延迟时间?
请解决:
问题 1: 如何确定每个码头的使用顺序和时间分配,以最小化船
只的等待和延迟时间?
问题 2: 如何在满足码头容量和停靠时间限制的前提下,最大化
港口的运营效率和收益?
问题 3: 如何根据船只的到达和离开时间表,合理安排每个码头
的使用,以满足不同船只的优先级和关系,以及最小化等待和延迟时
间?
以下是相关数据
1.船只的种类和数量(总量):
散货船:30 艘 集装箱船:20 艘
液化气船:10 艘
2.码头的类型和数量:
散货码头:3 个
集装箱码头:2 个
液化气码头:1 个
3.每艘船只停靠所需的时间:
散货船:4 小时
集装箱船:6 小时
液化气船:8 小时
4.每个码头的容量和停靠时间限制:
散货码头:每天最多可停靠 4 艘散货船,每艘船只停靠时间不超
过 8 小时。
集装箱码头:每天最多可停靠 3 艘集装箱船,每艘船只停靠时间
不超过 12 小时。
液化气码头:每天最多可停靠 2 艘液化气船,每艘船只停靠时间
不超过 16 小时。
5.港口的运营成本和收益:
港口的每日运营成本为 10 万元。
散货船每次停靠可为港口带来 15 万元的收益。
集装箱船每次停靠可为港口带来 20 万元的收益。
液化气船每次停靠可为港口带来 25 万元的收益。
6.船只的到达和离开时间表:
散货船:每天有 10 艘散货船到达,每艘船只停靠时间随机,平
均为 6 小时。
集装箱船:每天有 6 艘集装箱船到达,每艘船只停靠时间随机,
平均为 8 小时。
液化气船:每天有 3 艘液化气船到达,每艘船只停靠时间随机,
平均为 10 小时。 7.船只之间的优先级和关系:
散货船优先级最低,集装箱船次之,液化气船优先级最高。
如果有多艘船同时到达,液化气船优先停靠。
8.港口和码头的地理布局和拓扑结构:
港口位于海岸线附近,有多个码头,码头之间相互连接,船只可
以在码头之间转移。
9. 港口的负载和运营效率数据:
散货码头每天平均负载 80%。
集装箱码头每天平均负载 70%。
液化气码头每天平均负载 60%

 

 问题一:

如何确定每个码头的使用顺序和时间分配,以最小化船只的等待和延迟时间?

为了最小化船只的等待和延迟时间,可以遵循以下步骤来确定每个码头的使用顺序和时间分配:

  1. 根据船只的优先级和关系,确认液化气船是否有需要停靠的。如果有,优先分配液化气码头给液化气船。

  2. 对于剩下的散货船和集装箱船,根据每个码头的负载情况和停靠时间限制,选择合适的码头来停靠。

  3. 确定每个码头的使用顺序,可以采用以下策略:

    • 首先,选择空闲且满足停靠时间限制的码头,让船只尽快开始装卸货物。
    • 其次,考虑负载情况,优先选择负载较低的码头,以平衡各个码头的负载。
    • 同时,考虑船只的优先级,优先满足集装箱船的停靠需求,然后是散货船。
  4. 根据船只的到达和离开时间表,合理安排每个码头的使用时间。可以使用调度算法,如最早截止时间优先(Earliest Deadline First)来决定船只的停靠时间

 

根据船只的优先级和关系确定码头的使用顺序。例如,优先安排液化气船停靠。

确定每个码头的使用时间,以满足停靠时间限制并均衡利用资源。可以利用调度算法,如最短作业优先(SJF)算法。

码头使用时间表:

散货码头 [24, 18, 12, 6]

集装箱码头 [18, 12, 6]

液化气码头 [12, 6]

好的,让我们来看一个具体的例子。假设我们有一个散货码头和三艘散货船,散货码头的时间表为 [24, 18, 12, 6]

从时间表中可以解读如下:

第一艘散货船停靠的时间是从第 6 个时间单位开始,到第 18 个时间单位结束。

第二艘散货船停靠的时间是从第 12 个时间单位开始,到第 24 个时间单位结束。

第三艘散货船停靠的时间是从第 18 个时间单位开始,到第 24 个时间单位结束。

这意味着,第一个停靠的船只停留了 12 个时间单位(从第 6 个到第 18 个时间单位),第二个停靠的船只停留了 12 个时间单位(从第 12 个到第 24 个时间单位),第三个停靠的船只停留了 6 个时间单位(从第 18 个到第 24 个时间单位)。

 

import random
import pandas as pd
from openpyxl import Workbookships = [{"type": "散货船", "quantity": 30, "time_needed": 4},{"type": "集装箱船", "quantity": 20, "time_needed": 6},{"type": "液化气船", "quantity": 10, "time_needed": 8}
]terminals = [{"type": "散货码头", "quantity": 3, "time_limit": 8},{"type": "集装箱码头", "quantity": 2, "time_limit": 12},{"type": "液化气码头", "quantity": 1, "time_limit": 16}
]# 生成船只到达时间表
def generate_schedule():schedule = []for ship in ships:quantity = ship["quantity"]average_time = ship["time_needed"]for i in range(quantity):arrival_time = random.randint(0, 24)schedule.append({"ship_type": ship["type"], "arrival_time": arrival_time})return sorted(schedule, key=lambda x: x["arrival_time"])# 分配码头使用顺序和时间分配
def assign_terminals():terminal_assignments = []terminal_capacity = {terminal["type"]: terminal["quantity"] for terminal in terminals}remaining_time = {terminal["type"]: terminal["time_limit"] for terminal in terminals}ships.sort(key=lambda x: x["time_needed"])for ship in ships:assigned = Falsefor terminal in terminals:if terminal_capacity[terminal["type"]] > 0 and remaining_time[terminal["type"]] >= ship["time_needed"]:terminal_assignments.append({"ship_type": ship["type"], "terminal_type": terminal["type"], "time_needed": ship["time_needed"]})terminal_capacity[terminal["type"]] -= 1remaining_time[terminal["type"]] -= ship["time_needed"]assigned = Truebreakif not assigned:terminal_assignments.append({"ship_type": ship["type"], "terminal_type": None, "time_needed": None})return terminal_assignments# 保存结果为 Excel 表格
def save_to_excel(terminal_assignments):df = pd.DataFrame(terminal_assignments)df.columns = ["船只类型", "码头类型", "时间需求"]wb = Workbook()ws = wb.activefor r in df.columns:ws.cell(row=1, column=df.columns.get_loc(r) + 1).value = r  # 设置表头for i, row in enumerate(df.itertuples(), start=2):for j, value in enumerate(row[1:], start=1):ws.cell(row=i, column=j).value = valuewb.save("terminal_assignments.xlsx")# 主函数
def main():schedule = generate_schedule()for ship in schedule:print(f"船只类型: {ship['ship_type']}, 到达时间: {ship['arrival_time']}")print("----------")terminal_assignments = assign_terminals()for assignment in terminal_assignments:print(f"{assignment['ship_type']}: {assignment['terminal_type']} ({assignment['time_needed']}小时)")# 保存结果为 Excel 表格save_to_excel(terminal_assignments)# 运行主函数
if __name__ == "__main__":main()

 

该代码使用了一种简单的贪心算法来确定每个码头的使用顺序和时间分配,以最小化船只的等待和延迟时间。具体步骤如下:

根据船只的优先级顺序依次处理每艘船只。

对于每艘船只,遍历每种类型的码头,选择可用的码头,并计算当前船只在该码头上的等待时间。

选择等待时间最短的码头,将船只分配给该码头,并更新码头使用时间表。

更新港口的收益和成本。

重复步骤2-4,直到所有船只都被处理完毕。

统计船只的等待时间,并将等待时间绘制成柱状图。

输出每个码头的使用时间表以及港口的总收益、总成本和净收益。

需要注意的是,该代码使用的贪心算法并不能保证得到全局最优解,它只能得到一个较好的局部解。如果需要更精确的最优解,可以尝试使用其他优化算法,如动态规划或遗传算法。

具体的算法公式如下:

输入数据:

船只的种类和数量: ship_types, ship_counts

码头的类型和数量: dock_types, dock_counts

每艘船只停靠所需的时间: dock_times

每个码头的容量和停靠时间限制: dock_capacity, dock_time_limit

港口的运营成本和收益: operating_cost, revenue

船只的到达和离开时间表: arrival_times, average_stay_times

船只之间的优先级和关系: priority_order

初始化码头使用时间表 dock_schedule,每个码头的使用时间列表初始化为空。

初始化总收益 total_revenue 和总成本 total_cost 为 0。

初始化等待时间列表 wait_times 为空。

对于每个船只类型 ship_type in priority_order:

对于该类型船只的数量 ship_counts[ship_types.index(ship_type)]:

初始化 dock_type 为空字符串

初始化 min_wait_time 为正无穷

对于每个码头类型 dock in dock_types:

如果该码头未达到容量上限 dock_schedule[dock] < dock_capacity[dock]:

计算船只的等待时间 wait_time = max(arrival_times[ship_type] - max(dock_schedule[dock] + [0]), 0)

如果 wait_time < min_wait_time:

更新 min_wait_time 为 wait_time

更新 dock_type 为 dock

如果 dock_type 仍然为空字符串:

输出找不到可用码头的信息

继续处理下一条船只

否则,将船只分配给 dock_type 码头:

将 0 添加到 dock_schedule[dock_type]

为船只更新码头使用时间表 dock_schedule[dock_type],加上平均停靠时间 average_stay_times[ship_type]

增加收益 total_revenue += revenue[ship_type]

增加成本 total_cost += operating_cost

将 min_wait_time 添加到 wait_times 列表中

绘制等待时间柱状图:

使用绘图库绘制柱状图,x轴为船只索引,y轴为等待时间,柱状图表示每艘船只的等待时间。

输出码头使用时间表及统计数据:

输出每个码头的使用时间表 dock_schedule

输出总收益 total_revenue

输出总成本 total_cost

输出净收益 total_revenue - total_cost

这就是该算法的具体步骤和计算公式。通过依次处理每个船只并选择合适的码头,算法尽量减少船只的等待和延迟时间,并优化港口的收益与成本。

mport numpy as np
import matplotlib.pyplot as plt# 船只的种类和数量(总量)
ship_types = ['散货船', '集装箱船', '液化气船']
ship_counts = [30, 20, 10]# 码头的类型和数量
dock_types = ['散货码头', '集装箱码头', '液化气码头']
dock_counts = [3, 2, 1]# 每艘船只停靠所需的时间
dock_times = {'散货船': 4, '集装箱船': 6, '液化气船': 8}# 每个码头的容量和停靠时间限制
dock_capacity = {'散货码头': 4, '集装箱码头': 3, '液化气码头': 2}
dock_time_limit = {'散货码头': 8, '集装箱码头': 12, '液化气码头': 16}# 港口的运营成本和收益
operating_cost = 10
revenue = {'散货船': 15, '集装箱船': 20, '液化气船': 25}# 船只的到达和离开时间表
arrival_times = {'散货船': 10, '集装箱船': 6, '液化气船': 3}
average_stay_times = {'散货船': 6, '集装箱船': 8, '液化气船': 10}# 船只之间的优先级和关系
priority_order = ['散货船', '集装箱船', '液化气船']# 初始化码头使用时间表
dock_schedule = {dock: [] for dock in dock_types}# 最小化等待和延迟时间,并统计收益和成本
total_revenue = 0
total_cost = 0
wait_times = []
for ship_type in priority_order:for _ in range(ship_counts[ship_types.index(ship_type)]):dock_type = ''min_wait_time = np.inf# 遍历每种类型的码头,选择最佳码头for dock in dock_types:if len(dock_schedule[dock]) < dock_capacity[dock]:wait_time = max(arrival_times[ship_type] - max(dock_schedule[dock] + [0]), 0)if wait_time < min_wait_time:min_wait_time = wait_timedock_type = dock# 处理找不到可用码头的情况if dock_type == '':print(f"No available dock for {ship_type}.")continue# 更新码头使用时间表、收益和成本dock_schedule[dock_type].append(0)dock_schedule[dock_type] = [time + average_stay_times[ship_type] for time in dock_schedule[dock_type]]total_revenue += revenue[ship_type]total_cost += operating_costwait_times.append(min_wait_time)# 绘制等待时间的柱状图
plt.bar(range(len(wait_times)), wait_times)
plt.xlabel('Ship Index')
plt.ylabel('Wait Time')
plt.title('Wait Time for Each Ship')
plt.show()

 问题二: 

        如何在满足码头容量和停靠时间限制的前提下,最大化港口的运营效率和收益?

        为了在满足码头容量和停靠时间限制的前提下,最大化港口的运营效率和收益,可以采取以下策略:

  1. 优化码头的使用效率:根据码头的容量和停靠时间限制,合理安排船只的停靠顺序和时间分配,使得码头始终保持高效利用。

  2. 最大化收益:结合船只的收益和到达时间表,优先选择能够带来较高收益的船只进行停靠,尽量将高收益的船只置于前沿,以最大化港口的收益。

  3. 动态调整:根据实际情况,不断监测和评估各个码头的负载和运营效率,根据需求灵活调整船只的停靠顺序和时间分配,以最优化港口的运营效率和收益。

 

问题2的关键是在满足码头容量和停靠时间限制的情况下,最大化港口的运营效率和收益。这可以通过确定每个码头的使用顺序和时间分配来实现。以下是一个可能的解决方案,使用python编程来优化港口的运营:

创建一个模型,以码头为变量,船只类型为约束,目标函数为最大化收益。

定义变量:

X[i][j]:码头i停靠船只类型j的数量

Y[i]:码头i的使用时间

定义约束条件:

每个码头的使用时间不超过停靠时间限制

码头的总容量不超过每天的最大容量限制

每种类型船只的数量不超过到达时间表中每天的船只数量

码头的使用时间必须大于等于零

每个码头只能停靠对应类型的船只

根据船只的优先级和关系,设置优先停靠顺序

定义目标函数:

最大化总收益,即船只的停靠收益减去港口的运营成本

使用python中的优化库,如PuLP 或者 Pyomo,根据模型求解器进行求解。

根据求解结果,得到每个码头的使用顺序和时间分配,以实现最小化船只等待和延迟时间,并最大化港口的运营效率和收益。

 

from pulp import *# 数据
ships = ['散货船', '集装箱船', '液化气船']
docks = ['散货码头1', '散货码头2', '散货码头3', '集装箱码头1', '集装箱码头2', '液化气码头']
ship_capacity = {'散货船': 4, '集装箱船': 3, '液化气船': 2}
dock_capacity = {'散货码头1': 4, '散货码头2': 4, '散货码头3': 4, '集装箱码头1': 3, '集装箱码头2': 3, '液化气码头': 2}
stop_time = {'散货码头1': 8, '散货码头2': 8, '散货码头3': 8, '集装箱码头1': 12, '集装箱码头2': 12, '液化气码头': 16}
operating_cost = 100000
revenue = {'散货船': 150000, '集装箱船': 200000, '液化气船': 250000}# 创建问题
problem = LpProblem("Port Optimization", LpMaximize)# 创建决策变量
dock_vars = LpVariable.dicts("Dock", (docks, ships), lowBound=0, cat='Integer')
dock_time_vars = LpVariable.dicts("DockTime", docks, lowBound=0, upBound=24, cat='Continuous')# 设置目标函数
problem += lpSum(dock_vars[dock][ship] * revenue[ship] for dock in docks for ship in ships) - operating_cost# 设置约束条件
for ship in ships:problem += lpSum(dock_vars[dock][ship] for dock in docks) <= ship_capacity[ship]for dock in docks:problem += lpSum(dock_time_vars[dock]) <= stop_time[dock]problem += lpSum(dock_vars[dock][ship] for ship in ships) <= dock_capacity[dock]for dock in docks:for ship in ships:problem += dock_vars[dock][ship] <= dock_capacity[dock] * dock_time_vars[dock] / stop_time[dock]# 求解问题
problem.solve()# 输出结果
print("最大化收益: $", value(problem.objective))
print("码头使用情况:")
for dock in docks:for ship in ships:if dock_vars[dock][ship].varValue > 0:print(f"{dock} 停靠 {dock_vars[dock][ship].varValue} 艘 {ship}")
from pulp import *
import matplotlib.pyplot as plt
import matplotlib
matplotlib.rcParams['font.family'] = 'Arial Unicode MS'
# 数据
ships = ['散货船', '集装箱船', '液化气船']
docks = ['散货码头1', '散货码头2', '散货码头3', '集装箱码头1', '集装箱码头2', '液化气码头']
ship_capacity = {'散货船': 4, '集装箱船': 3, '液化气船': 2}
dock_average_load = {'散货码头1': 0.8, '散货码头2': 0.8, '散货码头3': 0.8, '集装箱码头1': 0.7, '集装箱码头2': 0.7,'液化气码头': 0.6}
stop_time = {'散货码头1': 8, '散货码头2': 8, '散货码头3': 8, '集装箱码头1': 12, '集装箱码头2': 12, '液化气码头': 16}
dock_capacity = {'散货码头1': 4, '散货码头2': 4, '散货码头3': 4, '集装箱码头1': 3, '集装箱码头2': 3, '液化气码头': 2}
operating_cost = 100000
revenue = {'散货船': 150000, '集装箱船': 200000, '液化气船': 250000}# 创建问题
problem = LpProblem("Port Optimization", LpMaximize)# 创建决策变量
dock_vars = LpVariable.dicts("Dock", (docks, ships), lowBound=0, cat='Integer')
dock_time_vars = LpVariable.dicts("DockTime", docks, lowBound=0, upBound=24, cat='Continuous')# 设置目标函数
problem += lpSum(dock_vars[dock][ship] * revenue[ship] for dock in docks for ship in ships) - operating_cost# 设置约束条件
for ship in ships:problem += lpSum(dock_vars[dock][ship] for dock in docks) <= ship_capacity[ship]for dock in docks:problem += lpSum(dock_time_vars[dock]) <= stop_time[dock]problem += lpSum(dock_vars[dock][ship] for ship in ships) <= lpSum(dock_average_load[dock] * dock_capacity[dock] for dock in docks)for dock in docks:for ship in ships:problem += dock_vars[dock][ship] <= dock_average_load[dock] * dock_capacity[dock] * dock_time_vars[dock] / \stop_time[dock]# 求解问题
problem.solve()# 输出结果
print("最大化收益: $", value(problem.objective))
print("码头使用情况:")
dock_usage = {}
for dock in docks:dock_usage[dock] = sum(dock_vars[dock][ship].varValue for ship in ships)for ship in ships:if dock_vars[dock][ship].varValue > 0:print(f"{dock} 停靠 {dock_vars[dock][ship].varValue} 艘 {ship}")# 创建柱状图
plt.bar(docks, dock_usage.values())
plt.xlabel('码头')
plt.ylabel('使用情况')
plt.title('港口码头使用情况')
plt.show()

问题三:

如何根据船只的到达和离开时间表,合理安排每个码头的使用,以满足不同船只的优先级和关系,以及最小化等待和延迟时间?

为了根据船只的到达和离开时间表,合理安排每个码头的使用,以满足不同船只的优先级和关系,以及最小化等待和延迟时间,可以采取以下策略:

  1. 根据船只的优先级和关系,确定液化气船是否有需要停靠的,并优先分配液化气码头给液化气船。

  2. 对于剩下的散货船和集装箱船,根据每个码头的负载情况和停靠时间限制,选择合适的码头来停靠。

  3. 结合船只的到达和离开时间表,使用调度算法,如最早截止时间优先(Earliest Deadline First)或最短剩余处理时间(Shortest Remaining Processing Time)来决定船只的停靠顺序和时间分配。

  4. 在安排船只的停靠顺序时,考虑船只的优先级关系。确保优先级较高的船只有较高的停靠优先级,并尽早安排它们的停靠,以减少等待和延迟时间。

  5. 动态调整:根据实际情况,持续监测船只的到达和离开时间情况,以及各个码头的负载和运营效率,对船只的停靠顺序和时间进行灵活调整,以最小化等待和延迟时间             

按照船只的优先级降序,遍历每种船只类型。

对于每种船只类型,按照船只的到达时间顺序进行遍历。

选择空闲时间最短的码头,计算当前船只需要等待的时间(等于前一艘船只离开时间与当前船只到达时间的差)。

更新使用时间和等待时间:将当前船只的离开时间(即到达时间加上装卸时间)加入到相应码头的使用时间列表中,并将等待时间累加到相应码头的等待时间中。

重复步骤3和4,直到所有船只都被安排到合适的码头上。

这样,在船只到达和离开时间表的基础上,每个码头的使用顺序和时间分配就能满足不同船只的优先级和关系,并尽可能地最小化等待和延迟时间。

根据上述代码,可以通过以下步骤来合理安排每个码头的使用,以满足不同船只的优先级和关系,并最小化等待和延迟时间:

定义船只的种类和数量、船只的停靠时间,以及每个码头的容量和停靠时间限制。

定义港口的运营成本和每种船只的收益。

随机生成船只的到达和离开时间表。

定义船只的优先级。

初始化每个码头的使用时间和等待时间。

使用贪婪算法,按照船只的优先级和到达时间合理安排码头的使用:

对于每种船只类型,按照船只的到达时间顺序进行遍历。

选择空闲时间最短的码头,根据当前船只的到达时间和已有船只的离开时间,计算船只需要等待的时间。

更新选择的码头的使用时间和等待时间,将当前船只的离开时间添加到码头的使用时间列表中,并将等待时间累加到码头的等待时间中。

计算港口的总收益和总成本,根据每种船只的数量和收益以及港口的运营成本。

输出每个码头的使用情况和等待时间。

输出港口的总收益和总成本。

通过这样的安排方式,可以根据船只的到达和离开时间表,合理安排每个码头的使用,以满足船只的优先级和关系,并尽可能地最小化等待和延迟时间。

基于船只的到达和离开时间表以及船只的停靠时间,可以确定每艘船到达码头的时间点和离开码头的时间点。

对于每个船只类型,根据船只的优先级和到达时间进行排序。

为每个船只选择一个最优的码头来停靠,以尽量满足优先级高的船只和减少等待时间。

假设第 i 艘船的到达时间为 t_arrive_i,码头选择函数为 f(i)。则可以使用以下数学公式来选择每艘船停靠的码头:

f(i) = argmin(t_wait_j) for j in {1, 2, …, M}

其中,t_wait_j 表示第 j 个码头的等待时间,M 表示码头的数量。

码头选择函数可以计算每个码头的等待时间,并选择最小等待时间的码头作为船只的停靠码头。

t_wait_j = max(0, t_leave_j - t_arrive_i)

其中,t_leave_j 表示第 j 个码头上最后一艘船的离开时间。

在码头选择完毕后,将船只与对应码头进行匹配,更新各个码头的使用情况和等待时间。

计算港口的总收益和总成本,根据每种船只的数量和收益以及港口的运营成本。

总收益 = ∑(船只数量 * 单位收益)

总成本 = 运营成本

输出每个码头的使用情况和等待时间。

输出港口的总收益和总成本。

import numpy as np# 船只的种类和数量
ship_types = ['散货船', '集装箱船', '液化气船']
ship_counts = {'散货船': 30, '集装箱船': 20, '液化气船': 10}# 船只的停靠时间
ship_durations = {'散货船': 4, '集装箱船': 6, '液化气船': 8}# 每个码头的容量和停靠时间限制
dock_capacities = {'散货码头': 4, '集装箱码头': 3, '液化气码头': 2}
dock_limits = {'散货码头': 8, '集装箱码头': 12, '液化气码头': 16}# 港口的运营成本和收益
operating_cost = 100000
earnings_per_ship = {'散货船': 150000, '集装箱船': 200000, '液化气船': 250000}# 船只的到达和离开时间表
ship_schedules = {'散货船': np.random.randint(0, 24, size=10),'集装箱船': np.random.randint(0, 24, size=6),'液化气船': np.random.randint(0, 24, size=3)
}# 船只的优先级
ship_priorities = {'散货船': 3, '集装箱船': 2, '液化气船': 1}# 初始化每个码头的使用时间和等待时间
dock_usage = {'散货码头': [], '集装箱码头': [], '液化气码头': []}
dock_wait = {'散货码头': 0, '集装箱码头': 0, '液化气码头': 0}# 按优先级和到达时间合理安排码头的使用
for ship_type in sorted(ship_priorities, key=ship_priorities.get):for arrival_time in ship_schedules[ship_type]:best_dock = Nonemin_wait = float('inf')# 选择空闲时间最短的码头for dock, usage in dock_usage.items():if len(usage) < dock_capacities[dock]:if len(usage) == 0:wait_time = max(0, dock_limits[dock] - arrival_time)else:wait_time = max(0, usage[-1] + dock_limits[dock] - arrival_time)if wait_time < min_wait:best_dock = dockmin_wait = wait_time# 如果存在合适的码头,则更新使用时间和等待时间if best_dock is not None:dock_usage[best_dock].append(arrival_time + ship_durations[ship_type])dock_wait[best_dock] += min_wait# 计算港口的总收益和总成本
total_earnings = sum(ship_counts[ship_type] * earnings_per_ship[ship_type] for ship_type in ship_types)
total_cost = operating_cost# 输出每个码头的使用情况和等待时间
for dock, usage in dock_usage.items():print(f'{dock}: {usage},等待时间:{dock_wait[dock]} 小时')# 输出港口的总收益和总成本
print(f'港口总收益: {total_earnings} 万元')
print(f'港口总成本: {total_cost} 万元')

 

import simpy
import random# 船只类
class Ship:def __init__(self, ship_id, ship_type, arrival_time, dock_time):self.ship_id = ship_idself.ship_type = ship_typeself.arrival_time = arrival_timeself.dock_time = dock_time# 码头类
class Dock:def __init__(self, dock_id, dock_type, capacity, limit_time):self.dock_id = dock_idself.dock_type = dock_typeself.capacity = capacityself.limit_time = limit_timeself.queue = []  # 等待队列def request_dock(self, env, ship):with self.capacity.request() as req:# 到达码头前的等待时间wait_time = env.now - ship.arrival_timeprint(f"{ship.ship_type}船 {ship.ship_id} 到达码头 {self.dock_id},等待时间:{wait_time}小时")# 进入等待队列self.queue.append(ship)yield reqself.queue.remove(ship)# 开始停靠print(f"{ship.ship_type}船 {ship.ship_id} 开始在码头 {self.dock_id} 停靠")yield env.timeout(ship.dock_time)print(f"{ship.ship_type}船 {ship.ship_id} 完成在码头 {self.dock_id} 的停靠")# 港口类
class Port:def __init__(self):self.env = simpy.Environment()self.docks = []  # 码头列表self.profit = 0  # 收益值def create_docks(self, num_docks, dock_type, capacity, limit_time):for i in range(num_docks):dock = Dock(i, dock_type, capacity, limit_time)dock.capacity = simpy.Resource(self.env, capacity)self.docks.append(dock)def simulate(self, ships):for ship in ships:self.env.process(self.manage_ship(ship))self.env.run()def manage_ship(self, ship):# 选择优先级最高的码头进行停靠dock = min(self.docks, key=lambda x: x.dock_type)yield self.env.process(dock.request_dock(self.env, ship))def calculate_profit(self, ship):if ship.ship_type == "散货船":self.profit += 15elif ship.ship_type == "集装箱船":self.profit += 20elif ship.ship_type == "液化气船":self.profit += 25# 示例数据
ship_arrival_times = {"散货船": 10, "集装箱船": 6, "液化气船": 3}
ship_dock_times = {"散货船": 4, "集装箱船": 6, "液化气船": 8}
dock_capacity = {"散货码头": 4, "集装箱码头": 3, "液化气码头": 2}
dock_time_limit = {"散货码头": (0, 8), "集装箱码头": (0, 12), "液化气码头": (0, 16)}# 创建港口和码头
port = Port()
port.create_docks(3, "散货码头", 4, (0, 8))
port.create_docks(2, "集装箱码头", 3, (0, 12))
port.create_docks(1, "液化气码头", 2, (0, 16))# 生成船只列表
ships = []
for ship_type, num_ships in ship_arrival_times.items():for i in range(num_ships):arrival_time = random.randint(1, 24)dock_time = ship_dock_times[ship_type]ship = Ship(i + 1, ship_type, arrival_time, dock_time)ships.append(ship)# 优先级排序,按散货船、集装箱船、液化气船排序
ships.sort(key=lambda x: x.ship_type, reverse=True)# 进行模拟
port.simulate(ships)# 打印结果
print(f"港口总收益: {port.profit}万元")

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/60450.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

【大虾送书第七期】深入浅出SSD:固态存储核心技术、原理与实战

目录 ✨写在前面 ✨内容简介 ✨作者简介 ✨名人推荐 ✨文末福利 &#x1f990;博客主页&#xff1a;大虾好吃吗的博客 &#x1f990;专栏地址&#xff1a;免费送书活动专栏地址 写在前面 近年来国家大力支持半导体行业&#xff0c;鼓励自主创新&#xff0c;中国SSD技术和产业…

C++信息学奥赛1178:成绩排序

#include<bits/stdc.h> using namespace std; int main(){int n;cin>>n; // 输入整数 n&#xff0c;表示数组的大小int arr[n]; // 创建大小为 n 的整型数组 arrstring brr[n]; // 创建大小为 n 的字符串数组 brrfor(int i0;i<n;i) cin>>brr[i]>>ar…

Greenplum-segment镜像分布策略

Greenplum作为一款基于PostgreSQL的OLAP分布式MPP架构&#xff0c;其内部的角色可以通过配置冗余来保证高可用性&#xff0c;无论是管理节点还是计算节点。管理节点可以为Master配置一个Standby来保证高可用&#xff0c;而计算节点则可以为每个Primary segment配置一个对应的Mi…

Linux常用命令(不定期更新)

记录一下自己工作中常用的linux命令 查询类 top 实时查看进程 free -h 查看内存 df -h 查看已挂在的存储 fdisk -l 查看所有存储&#xff0c;包含未挂载 编辑类 passwd 修改密码&#xff0c;要进入到系统

list(介绍与实现)

目录 1. list的介绍及使用 1.1 list的介绍 1.2 list的使用 1.2.1 list的构造 1.2.2 list iterator的使用 1.2.3 list capacity 1.2.4 list element access 1.2.5 list modififiers 1.2.6 list的迭代器失效 2. list的模拟实现 2.1 模拟实现list 2.2 list的反向迭代器 1.…

浅析Linux虚拟网络技术

文章目录 概述Tap/tun设备tun/tap的工作机制 Bridge网桥Bridge的工作机制Bridge IP 相关参考 概述 在传统的网络环境中&#xff0c;一台物理主机包含一张或多张网卡&#xff0c;要实现与其它物理主机之间的通信&#xff0c;需要将自身的网卡通过路由器或者交换机连接到外部的物…

vue3 页面显示中文,分页显示中文

vue3 分页默认为英文 &#xff0c;但想要中文显示 那么在App.vue中的代码为三步即可&#xff0c;引入中文&#xff0c;声明中文 &#xff0c;绑定中文&#xff1b; 1. import zhCn from element-plus/es/locale/lang/zh-cn&#xff1b; 2. let locale zhCn; 3. :locale&q…

【内网穿透】搭建我的世界Java版服务器,公网远程联机

目录 前言 1. 搭建我的世界服务器 1.1 服务器安装java环境 1.2 配置服务端 2. 测试局域网联机 3. 公网远程联机 3.1 安装cpolar内网穿透 3.1.1 windows系统 3.1.2 linux系统&#xff08;支持一键自动安装脚本&#xff09; 3.2 创建隧道映射内网端口 3.3 测试公网远程…

智通三千亮相2023中国软博会

“软件赋智&#xff0c;数实融合。”8月20日—23日&#xff0c;2023中国国际软件产品和信息服务交易博览会在南京举办。软博会连续举办19届。期间&#xff0c;《2023年我国工业软件产业发展研究报告》《中国软件产业高质量发展紫金指数&#xff08;2023&#xff09;》等发布。 …

【OpenCV实战】3.OpenCV颜色空间实战

OpenCV颜色空间实战 〇、Coding实战内容一、imread1.1 函数介绍1.2 Flags1.3 Code 二. 色彩空间2.1 获取单色空间2.2. HSV、YUV、RGB2.3. 不同颜色空间应用场景 〇、Coding实战内容 OpenCV imread()方法不同的flags差异性获取单色通道【R通道、G通道、B通道】HSV、YUV、RGB 一…

CTFhub-文件上传-MIME绕过

用哥斯拉生成 php 木马文件 1.php 抓包---> 修改 conten-type 类型 为 imge/jpeg 用蚁剑连接 ctfhub{8e6af8109ca15932bad4747a}

Hive原理剖析

一、简介 Hive是建立在Hadoop上的数据仓库框架&#xff0c;提供大数据平台批处理计算能力&#xff0c;能够对结构化/半结构化数据进行批量分析汇总完成数据计算。提供类似SQL的Hive Query Language语言操作结构化数据&#xff0c;其基本原理是将HQL语言自动转换成MapReduce任务…

电脑前置耳机没声音怎么办

有很多小伙伴反映在将自己的耳机连接到主机前面时没有声音&#xff0c;这是怎么回事呢&#xff0c;遇到这种情况应该怎么解决呢&#xff0c;下面小编就给大家详细介绍一下电脑前置耳机没声音的解决方法&#xff0c;有需要的小伙伴可以来看一看电脑前面耳机没声音。 解决方法&a…

AMD 锐龙 8000系 APU 将补完其产品线,推出 12C24T16CU 和 16C32T40CU

我们大家都知道一直以来&#xff0c;AMD 的 APU 只到 R7&#xff0c;也就是 R7-x700G 和 r7-x800H。虽然也有 R9-x900HX&#xff0c;但它毕竟是 x800H 硬超上去的&#xff0c;核心数完全一样&#xff0c;并不能叫做真正的 R9。 究其原因&#xff0c;AMD 的 APU 是移动端优先的…

谷歌Pixel Watch 2谣言——迄今为止我们所知道的一切

我们有理由相信&#xff0c;谷歌Pixel Watch 2是在工作。继Pixel Watch首次亮相后&#xff0c;下一代机型可能会推出升级&#xff0c;巩固谷歌在可穿戴市场的努力。 谷歌Pixel Watch作为第一代设备有很多功能。它利用Fitbit健身跟踪功能&#xff0c;同时支持所有主要的谷歌应用…

【CSS】解决对齐的小问题

问题&#xff1a; 表单或者页面上可能遇到文字无法对平均分&#xff0c;带有冒号的文本无法左右对齐的情况 常见的解决方式&#xff1a; 解决如下图 仍无法解决对齐的问题&#xff0c;还需要考虑字数 解决 这里用css的方式解决 增加 i 标签 固定宽度&#xff0c;设置 i …

动力节点Spring (18-19)

⼗⼋、Spring6集成MyBatis3.5 18.1 实现步骤 ● 第⼀步&#xff1a;准备数据库表 ○ 使⽤t_act表&#xff08;账户表&#xff09; ● 第⼆步&#xff1a;IDEA中创建⼀个模块&#xff0c;并引⼊依赖 ○ spring-context ○ spring-jdbc ○ mysql驱动 ○ mybatis ○ myb…

大数据学习:haproxy实现impala的负载均衡

HAProxy实现Impala的负载均衡 1.HAProxy安装及启停 1.1 在集群中选择一个节点&#xff0c;使用yum方式安装HAProxy服务 [rootdata01-dev ~]# yum -y install haproxy1.2 启动与停止HAProxy服务&#xff0c;并将服务添加到自启动列表 [rootdata01-dev ~]# service haproxy s…

Python实现自动关键词提取

随着互联网的发展&#xff0c;越来越多的人喜欢在网络上阅读小说。本文将通过详细示例&#xff0c;向您介绍如何使用Python编写爬虫程序来获取网络小说&#xff0c;并利用自然语言处理技术实现自动文摘和关键词提取功能。 1. 网络小说数据抓取 首先&#xff0c;请确保已安装必…

聚观早报|OpenAI宣布推出企业版ChatGPT;苹果公司开设8家新店

【聚观365】8月30日消息 OpenAI宣布推出企业版ChatGPT 比亚迪上半年净利润109.5亿元 歌尔股份上半年净利润4.22亿元 一起教育科技Q2营收6925万元 苹果公司今年开设8家新店 OpenAI宣布推出企业版ChatGPT 据外媒报道&#xff0c;当地时间周一&#xff0c;美国人工智能研究…