基于python的升级队列加速决策

a-f大等级是3级

a-c建筑每升1级分别需要8天

d-f建筑每升1级分别需要10天

目前以下建筑队列正在从0级升至1级

建筑A升级需要7天05：16：20

建筑b升级需要06：06：54

建筑c升级需要00：37：00

建筑d升级需要01：51：01

建筑e升级需要09：07：10

建筑f升级需要07：10：10

每30分钟会产生一个随机时间的升级加速包：15，30，45，60，120分钟

基于python计算，每一次随机产生的加速包，用于加速哪一个队列，做出决策优先加速哪一个建筑，最快完成建筑升级。

import random


class Building:
    def __init__(self, name, building_type, initial_remaining):
        self.name = name
        self.type = building_type
        self.level = 0  # 当前等级
        self.stage_remaining = initial_remaining  # 当前阶段剩余时间（秒）
        self.upgrading = initial_remaining > 0  # 是否正在升级

    def apply_accelerator(self, accelerator_seconds):
        if not self.upgrading or self.level >= 3:
            return
        # 应用加速
        self.stage_remaining -= accelerator_seconds
        if self.stage_remaining <= 0:
            self.level += 1
            if self.level >= 3:
                self.upgrading = False
                self.stage_remaining = 0
            else:
                # 开始下一阶段的升级
                if self.type == 'abc':
                    self.stage_remaining = 8 * 86400  # 8天
                else:
                    self.stage_remaining = 10 * 86400  # 10天
                self.upgrading = True
        else:
            self.upgrading = True

    def get_total_remaining_time(self):
        if self.level >= 3:
            return 0
        total = self.stage_remaining
        remaining_stages = 3 - (self.level + 1)
        if remaining_stages <= 0:
            return total
        if self.type == 'abc':
            total += remaining_stages * 8 * 86400
        else:
            total += remaining_stages * 10 * 86400
        return total


# 初始化建筑队列（时间转换为秒）
buildings = [
    Building('A', 'abc', 7 * 86400 + 5 * 3600 + 16 * 60 + 20),  # 7天05:16:20
    Building('B', 'abc', 6 * 86400 + 6 * 3600 + 6 * 60 + 54),  # 6天06:06:54
    Building('C', 'abc', 37 * 60),  # 00:37:00
    Building('D', 'def', 1 * 86400 + 51 * 60 + 1),  # 01:51:01
    Building('E', 'def', 9 * 86400 + 7 * 3600 + 10 * 60),  # 09:07:10
    Building('F', 'def', 7 * 86400 + 10 * 3600 + 10 * 60 + 10),  # 07:10:10
]


def select_best_target(accelerator_seconds, buildings):
    min_max_time = float('inf')
    best_building = None
    current_totals = [b.get_total_remaining_time() for b in buildings]
    current_max = max(current_totals)

    if current_max == 0:
        return None, 0

    for b in buildings:
        if not b.upgrading:
            continue
        # 保存当前状态
        original_level = b.level
        original_stage = b.stage_remaining
        original_upgrading = b.upgrading

        # 模拟应用加速
        temp_b = Building(b.name, b.type, original_stage)
        temp_b.level = original_level
        temp_b.upgrading = original_upgrading
        temp_b.apply_accelerator(accelerator_seconds)

        # 计算新总时间
        simulated_totals = []
        for bb in buildings:
            if bb.name == b.name:
                simulated_totals.append(temp_b.get_total_remaining_time())
            else:
                simulated_totals.append(bb.get_total_remaining_time())
        new_max = max(simulated_totals)

        # 比较最优
        if new_max < min_max_time or (new_max == min_max_time and best_building is None):
            min_max_time = new_max
            best_building = b
        elif new_max == min_max_time:
            if b.get_total_remaining_time() > best_building.get_total_remaining_time():
                best_building = b
    return best_building, min_max_time


# 模拟加速包生成和使用
while True:
    # 随机生成加速包（15/30/45/60/120分钟）
    accelerator = random.choice([15, 30, 45, 60, 120]) * 60  # 转换为秒
    best_building, new_max = select_best_target(accelerator, buildings)

    if not best_building:
        print("所有建筑已升级完成！")
        break

    # 应用加速包
    best_building.apply_accelerator(accelerator)
    print(
        f"使用 {accelerator // 60}分钟加速包到建筑 {best_building.name}，当前最长剩余时间：{new_max // 86400}天 {new_max % 86400 // 3600}小时{(new_max % 3600) // 60}分")

    # 检查是否全部完成
    if all(b.get_total_remaining_time() == 0 for b in buildings):
        print("全部建筑升级完成！")
        break