Python多目标优化：智能座位分配与资源调度策略

def evaluate_seating_arrangement(current_arrangement, participant_data, row_priority_data, previous_arrangement=None):
    """
    评估一个座位安排方案的优劣。
    current_arrangement: 字典，键为参与者ID，值为分配的座位对象。
    participant_data: 字典，包含所有参与者的偏好信息。
    row_priority_data: 字典，包含每排的优先级信息。
    previous_arrangement: (可选) 上一周的安排或初始安排，用于计算移动成本。
    """
    score_preference_satisfaction = 0  # 偏好满足度 (最大化)
    score_row_priority_fill = 0        # 行优先级填充度 (最大化)
    penalty_empty_seats = 0            # 空座位惩罚 (最小化，转换为最大化则为负值)
    penalty_relocation_cost = 0        # 移动成本惩罚 (最小化，转换为最大化则为负值)

    all_available_seats = get_all_seats() # 假设有一个函数获取所有座位

    # 1. 计算偏好满足度
    for participant_id, assigned_seat in current_arrangement.items():
        preferences = participant_data.get(participant_id, {}).get('preferences', [])
        if any(assigned_seat.row_id == p['row_id'] and assigned_seat.seat_num == p['seat_num'] for p in preferences if 'seat_num' in p):
            score_preference_satisfaction += 10 # 精确座位偏好
        elif any(assigned_seat.row_id == p['row_id'] for p in preferences if 'seat_num' not in p):
            score_preference_satisfaction += 5  # 行偏好

    # 2. 计算行优先级填充度
    filled_seats_by_row = {}
    for seat in current_arrangement.values():
        filled_seats_by_row[seat.row_id] = filled_seats_by_row.get(seat.row_id, 0) + 1

    for row_id, priority_info in row_priority_data.items():
        priority_weight = priority_info.get('weight', 1) # 优先级高的权重更高
        filled_count = filled_seats_by_row.get(row_id, 0)
        score_row_priority_fill += filled_count * priority_weight

    # 3. 计算空座位惩罚
    occupied_seat_count = len(current_arrangement)
    total_seat_count = len(all_available_seats)
    penalty_empty_seats = (total_seat_count - occupied_seat_count) * 2 # 每个空座位扣2分

    # 4. 计算移动成本 (如果提供了previous_arrangement)
    if previous_arrangement:
        for participant_id, prev_seat in previous_arrangement.items():
            current_seat = current_arrangement.get(participant_id)
            if current_seat and current_seat != prev_seat:
                penalty_relocation_cost += 3 # 每次移动扣3分

    # 返回一个元组，通常是需要最大化的目标
    # 注意：惩罚项需要转换为负值，以便在最大化时减少其影响
    return (score_preference_satisfaction,
            score_row_priority_fill,
            -penalty_empty_seats,
            -penalty_relocation_cost)

from deap import base, creator, tools, algorithms

# 1. 定义适应度 (Fitness) 和个体 (Individual)
# weights=(1.0, 1.0, -1.0, -1.0) 表示第一个和第二个目标最大化，第三个和第四个目标最小化
creator.create("FitnessMulti", base.Fitness, weights=(1.0, 1.0, -1.0, -1.0))
# Individual 是一个列表，其 fitness 属性是 FitnessMulti 实例
creator.create("Individual", list, fitness=creator.FitnessMulti)

# 2. 初始化工具箱
toolbox = base.Toolbox()

# 注册属性生成器 (例如，一个随机座位分配)
# 注意：实际中，你需要一个更复杂的函数来生成一个有效的初始座位分配
toolbox.register("attr_seat_assignment", lambda: generate_random_valid_assignment(participant_data, all_available_seats))

# 注册个体生成器
toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.attr_seat_assignment)

# 注册种群生成器
toolbox.register("population", tools.initRepeat, list, toolbox.individual)

# 注册评估函数 (即我们上面定义的 evaluate_seating_arrangement)
toolbox.register("evaluate", evaluate_seating_arrangement,
                 participant_data=participant_data,
                 row_priority_data=row_priority_data,
                 previous_arrangement=None) # 初始运行时不考虑previous_arrangement

# 注册遗传操作
toolbox.register("mate", tools.cxTwoPoint) # 交叉操作
toolbox.register("mutate", tools.mutFlipBit, indpb=0.05) # 变异操作
toolbox.register("select", tools.selNSGA2) # 选择操作，使用NSGA-II

# 3. 运行NSGA-II算法
def main_nsga2_run(population_size=100, generations=50):
    pop = toolbox.population(n=population_size)
    hof = tools.HallOfFame(1) # 存储最佳个体
    stats = tools.Statistics(lambda ind: ind.fitness.values)
    stats.register("avg", lambda values: sum(values) / len(values))
    stats.register("min", min)
    stats.register("max", max)

    # 运行NSGA-II算法
    pop, log = algorithms.eaMuPlusLambda(pop, toolbox, mu=population_size, lambda_=population_size,
                                         cxpb=0.7, mutpb=0.2, ngen=generations, stats=stats,
                                         halloffame=hof, verbose=True)
    return pop, log, hof

# 实际调用 (需要先定义 participant_data, all_available_seats, row_priority_data)
# if __name__ == "__main__":
#     # 假设这里已经初始化了 participant_data, all_available_seats, row_priority_data
#     final_pop, logbook, best_solution = main_nsga2_run()
#     print("Best solution found:", best_solution[0].fitness.values)
#     # best_solution[0] 就是一个包含最佳座位分配的Individual对象