Skip to content
The Chat Archive
gemini-2.5-flash-lite-preview-06-17-thinking· Google LMArena Human Preference 140K

Desse trabalho fiz esse código: TOTALSLOTS = 50 # 5 dias, 2 turnos, 5 aulas with…

  1. User

    Desse trabalho fiz esse código:

    TOTAL_SLOTS = 50 # 5 dias, 2 turnos, 5 aulas

    with open("matrizcur.json", "r", encoding='utf-8') as file:

    data = json.load(file)
    

    class Disciplina:

    def init(self, codigo, periodo, aulas, depedencias):
    
        self.codigo = codigo
    
        self.periodo = periodo
    
        self.aulas_semana = aulas
    
        self.dependencias = depedencias
    
        #Atribui um professor fixo para cada disciplina
    
        self.professor = f"Professor_{random.randint(1,15)}"
    

    disciplinas = [

    Disciplina(
    
        d["codigo"],
    
        d["periodo"],
    
        d["aulas_semana"],
    
        d["pre_requisitos"]
    
    ) 
    
    for d in data["DISCIPLINAS"]
    

    ]

    N_GENES = sum(d.aulas_semana for d in disciplinas)

    PARAMETROS = [

    {"POP_SIZE": 500, "MUTPB":0.15, "CXPB": 0.8, "NGEN": 5000, "TOURNSIZE": 3}
    

    ]

    def numslot_para_horario(slot):

    aulas_por_turnos = 5
    
    dia = slot // (2 * aulas_por_turnos)
    
    turno = (slot % (2 * aulas_por_turnos)) // aulas_por_turnos
    
    aula = (slot % (2 * aulas_por_turnos)) % aulas_por_turnos
    
    return dia, turno, aula
    

    creator.create("FitnessMin", base.Fitness, weights=(-1.0,))

    creator.create("Individual", list, fitness=creator.FitnessMin)

    toolbox = base.Toolbox()

    toolbox.register("attr_slot", random.randint, 0, TOTAL_SLOTS-1)

    toolbox.register("individual", tools.initRepeat, creator.Individual,

                 toolbox.attr_slot, n=N_GENES)
    

    toolbox.register("population", tools.initRepeat, list, toolbox.individual)

    toolbox.register("evaluate", fitness)

    toolbox.register("select", tools.selTournament, tournsize=5)

    toolbox.register("mate", tools.cxOnePoint)

    toolbox.register("mutate", tools.mutUniformInt, low=0, up=TOTAL_SLOTS-1,indpb=1.0/N_GENES)

    stats = tools.Statistics(lambda ind: ind.fitness.values[0])

    stats.register("min", np.min)

    stats.register("avg", lambda vals: sum(vals)/len(vals))

    hof = tools.HallOfFame(1)

    POP_SIZE = 1000

    CXPB = 0.8

    MUTPB = 0.25

    if name == "main":

    populacao = toolbox.population(n=POP_SIZE)
    
    populacao = algorithms.eaSimple(populacao, toolbox, cxpb=CXPB, mutpb=MUTPB,
    
                                    ngen=200, stats=stats, halloffame=hof)
    
    #{"POP_SIZE": 500, "MUTPB":0.15, "CXPB": 0.8, "NGEN": 5000, "TOURNSIZE": 3}
    
    
    
    best = hof[0]
    
    print("Melhor Fitness: ", best.fitness.values[0])
    
    gerar_pdf(best)
    
    for d in disciplinas:
    
        print(d.professor)
    
    • Queria ajudar para criar a função fitness, as restrições que deve ter inclua se necessario(não coloque coisas de administração de salas ou invente regras do rabo).

    Tem as:

    • Uma disciplina do mesmo periodo não deve ocupar mesmo horario e dia

    • Professores não devem ter + 1 aula no mesmo dia

    • O tempo ocioso entre aulas de um mesmo periodo deve ser minimizado

    • Não deve haver +3 aulas seguidas(ou no dia) da mesma matéria

    • "não existam conflitos entre os

    horários de disciplinas que são pré-requisito e suas correspondentes" (está no arquivo de descrição), OBS: no meus dados eu tenho qual matéria é dependecia de qual

    Balanceamento semanal

    Cada período deve ter suas aulas distribuídas de forma relativamente “uniforme” pelos 5 dias (evitar, por exemplo, um dia com 0 aulas e outro com 5).
    
  2. Assistant

    Okay, vamos criar uma função fitness robusta para o seu problema de agendamento, incorporando as restrições e objetivos que você listou.

    Primeiro, alguns pontos importantes sobre o seu código e o problema:

    1. Disciplina.__init__: O construtor da classe Disciplina está faltando os underlines duplos (__). Deve ser def __init__(self, ...).
    2. Mapeamento Gene -> Disciplina: Seu código calcula N_GENES como a soma total de aulas semanais (sum(d.aulas_semana for d in disciplinas)). Isso implica que cada "gene" na lista Individual representa uma aula específica de uma disciplina. Precisamos de uma forma de saber qual gene (e, portanto, qual aula/slot atribuído) pertence a qual disciplina. Vamos assumir que os genes são atribuídos sequencialmente às disciplinas na ordem em que aparecem na lista data["DISCIPLINAS"].
    3. creator.create("FitnessMin", ...): Você definiu o fitness como minimização (weights=(-1.0,)), o que é correto para penalidades/custos.
    4. Parâmetros GA: Você tem PARAMETROS como uma lista com um dicionário, mas depois define POP_SIZE, CXPB, MUTPB globalmente e usa esses valores em eaSimple. É melhor usar os valores do dicionário ou os globais de forma consistente. Vou usar os valores globais definidos após PARAMETROS para o eaSimple, mas vou referenciar os valores do dicionário para os parâmetros que podem ser usados dentro do fitness ou em outras funções (como o TOURNSIZE).
    5. Função fitness: A função fitness não foi definida, apenas registrada na toolbox. Vamos criá-la.

    Estrutura da Função Fitness:

    A função calculará uma pontuação total. Quanto menor a pontuação, melhor o horário. Usaremos penalidades altas para violações de restrições (que não devem ocorrer) e custos menores para objetivos (que queremos minimizar).

    Passos para Construir o Fitness:

    1. Pré-processamento: Converter a representação linear do indivíduo (lista de slots) em estruturas de dados mais úteis para análise (ex: dicionários agrupando por disciplina, professor, período, dia).
    2. Cálculo de Penalidades/Custos: Iterar sobre as restrições/objetivos e calcular a pontuação para cada um.
    3. Combinação: Somar todas as penalidades/custos, possivelmente com pesos.
    import json
    import random
    import numpy as np
    from deap import creator, base, tools, algorithms
    from collections import defaultdict
    import math # Para cálculo de balanceamento
    
    # --- Constantes e Carregamento de Dados ---
    TOTAL_SLOTS = 50 # 5 dias, 2 turnos, 5 aulas por turno = 50 slots
    SLOTS_POR_TURNO = 5
    TURNOS_POR_DIA = 2
    DIAS_POR_SEMANA = 5
    
    try:
        with open("matrizcur.json", "r", encoding='utf-8') as file:
            data = json.load(file)
    except FileNotFoundError:
        print("Erro: Arquivo matrizcur.json não encontrado.")
        exit()
    except json.JSONDecodeError:
        print("Erro: Arquivo matrizcur.json mal formatado.")
        exit()
    
    class Disciplina:
        # Correção: Construtor com __init__
        def __init__(self, codigo, periodo, aulas, dependencias):
            self.codigo = codigo
            self.periodo = periodo
            self.aulas_semana = aulas
            self.dependencias = dependencias # Lista de códigos de pré-requisitos
            # Atribui um professor fixo para cada disciplina (mantido do seu código original)
            # Consideração: Se a mesma disciplina aparece múltiplas vezes em matrizcur.json,
            # isso criará objetos Disciplina separados com professores diferentes. Ajuste se necessário.
            self.professor = f"Professor_{random.randint(1, 15)}"
    
    # Cria a lista de disciplinas
    disciplinas_data = data.get("DISCIPLINAS", [])
    if not disciplinas_data:
        print("Erro: Nenhuma disciplina encontrada em matrizcur.json")
        exit()
    
    disciplinas = [
        Disciplina(
            d["codigo"],
            d["periodo"],
            d["aulas_semana"],
            d.get("pre_requisitos", []) # Usa .get para caso 'pre_requisitos' não exista
        )
        for d in disciplinas_data
    ]
    
    # Mapeamento crucial: de qual disciplina é cada gene (aula)
    # Assumindo que os genes são atribuídos sequencialmente às disciplinas
    disciplina_gene_map = []
    current_gene_index = 0
    for i, d in enumerate(disciplinas):
        disciplina_gene_map.append({
            "disciplina": d,
            "start_gene": current_gene_index,
            "end_gene": current_gene_index + d.aulas_semana
        })
        current_gene_index += d.aulas_semana
    
    N_GENES = current_gene_index # Soma total de aulas = tamanho do gene (indivíduo)
    
    # Parâmetros do Algoritmo Genético (usados em eaSimple)
    POP_SIZE = 1000 # Ajustado para o valor global
    CXPB = 0.8      # Ajustado para o valor global
    MUTPB = 0.25    # Ajustado para o valor global
    NGEN = 200      # Número de gerações
    
    # --- Funções Auxiliares ---
    
    def numslot_para_horario(slot):
        """Converte um índice de slot linear para (dia, turno, aula_no_turno)."""
        if not (0 <= slot < TOTAL_SLOTS):
            # Retorna um valor inválido ou lança um erro se o slot estiver fora do intervalo
            # Vamos retornar (-1, -1, -1) para indicar um problema
            print(f"Aviso: Slot inválido {slot} encontrado.")
            return -1, -1, -1
            
        # Calcula o dia (0 a 4)
        dia = slot // (TURNOS_POR_DIA * SLOTS_POR_TURNO)
        
        # Calcula o slot dentro do dia
        slot_no_dia = slot % (TURNOS_POR_DIA * SLOTS_POR_TURNO)
        
        # Calcula o turno (0 ou 1)
        turno = slot_no_dia // SLOTS_POR_TURNO
        
        # Calcula a aula dentro do turno (0 a 4)
        aula = slot_no_dia % SLOTS_POR_TURNO
        
        return dia, turno, aula
    
    def horario_para_slot_num(dia, turno, aula):
        """Converte (dia, turno, aula) de volta para um índice de slot linear."""
        return (dia * TURNOS_POR_DIA * SLOTS_POR_TURNO) + \
               (turno * SLOTS_POR_TURNO) + \
               aula
    
    def calcular_penalidade(valor, max_valor, peso):
        """Calcula uma penalidade que aumenta conforme 'valor' se aproxima de 'max_valor'."""
        if valor == 0:
            return 0
        # Normaliza a penalidade para que seja 0 se valor=0 e cresça até 'peso' quando valor=max_valor
        # Usaremos uma penalidade linear simples aqui, mas pode ser ajustada (ex: quadrática)
        penalidade = (valor / max_valor) * peso
        #print(f"Pen: val={valor}, max={max_valor}, w={peso} -> {penalidade}")
        return penalidade
        
    # --- Definição do Fitness ---
    
    def calcular_fitness(individual):
        """Calcula a pontuação de fitness para um indivíduo (horário)."""
        
        penalidade_total = 0
        
        # --- Estruturas para Análise ---
        # Mapeia slot -> lista de (cod_disciplina, professor, indice_disciplina)
        slots_ocupados = defaultdict(list) 
        # Mapeia disciplina -> lista de slots ocupados por ela
        disciplina_horarios = defaultdict(list) 
        # Mapeia professor -> lista de slots ocupados por ele
        professor_horarios = defaultdict(list) 
        # Mapeia periodo -> lista de (slot, cod_disciplina, professor, indice_disciplina)
        periodo_horarios = defaultdict(list) 
        
        # --- Contagem de Aulas por Dia/Disciplina/Professor ---
        aulas_por_disciplina_dia = defaultdict(lambda: defaultdict(int))
        aulas_por_professor_dia = defaultdict(lambda: defaultdict(int))
    
        # --- 1. Pré-processamento e Restrições C1 e C2 ---
        # Verifica conflitos de slots e professores ao mesmo tempo
        
        # Itera sobre cada gene (representando uma aula) no indivíduo
        for gene_idx, slot in enumerate(individual):
            
            # Encontra a qual disciplina este gene pertence
            disciplina_info = None
            for info in disciplina_gene_map:
                if info["start_gene"] <= gene_idx < info["end_gene"]:
                    disciplina_info = info
                    break
            
            if disciplina_info is None:
                # Isso não deveria acontecer se N_GENES e o mapeamento estão corretos
                print(f"Erro Crítico: Gene {gene_idx} não pertence a nenhuma disciplina mapeada.")
                penalidade_total += 10000 # Penalidade alta por erro grave
                continue 
    
            disciplina = disciplina_info["disciplina"]
            cod_disciplina = disciplina.codigo
            professor = disciplina.professor
            periodo = disciplina.periodo
            
            dia, turno, aula = numslot_para_horario(slot)
            
            # Verifica se o slot é válido
            if dia == -1: # Se numslot_para_horario retornou erro
                 penalidade_total += 1000 # Penalidade por slot inválido
                 continue
    
            slot_key = (dia, turno, aula) # Chave única para o slot no tempo
    
            # --- Restrição C1: Disciplinas do mesmo período não podem ocupar o mesmo slot ---
            # Verifica se já existe alguma aula DESSA DISCIPLINA nesse slot
            # E também se já existe alguma aula DE OUTRA DISCIPLINA DO MESMO PERÍODO nesse slot
            for existing_cod, existing_prof, existing_idx in slots_ocupados[slot_key]:
                 existing_disciplina = disciplinas[existing_idx] # Assumindo que o índice está correto
                 if existing_disciplina.periodo == periodo:
                     penalidade_total += 1000 # Penalidade alta para conflito de período no mesmo slot
    
            # --- Restrição C2: Professores não devem ter +1 aula no mesmo dia/slot ---
            # Verifica se o professor já está ocupado neste slot específico
            if professor in [p for s, p, d in slots_ocupados[slot_key]]:
                penalidade_total += 1000 # Penalidade alta para conflito de professor no mesmo slot
    
            # Atualiza as estruturas de dados
            slots_ocupados[slot_key].append((cod_disciplina, professor, disciplina_info.get("index", disciplinas.index(disciplina)))) # Adiciona índice para referência futura
            disciplina_horarios[cod_disciplina].append(slot)
            professor_horarios[professor].append(slot)
            periodo_horarios[periodo].append((slot, cod_disciplina, professor, disciplina_info.get("index", disciplinas.index(disciplina))))
    
            # Contagem para C4 e C5
            aulas_por_disciplina_dia[cod_disciplina][dia] += 1
            aulas_por_professor_dia[professor][dia] += 1
    
        # --- Restrição C4: Não +3 aulas seguidas (interpretado como: não +3 aulas da mesma matéria no mesmo dia) ---
        for disciplina_code, dias_aulas in aulas_por_disciplina_dia.items():
            for dia, count in dias_aulas.items():
                if count > 3:
                    # Penaliza cada aula que excede o limite de 3 no dia
                    penalidade_total += (count - 3) * 500 # Peso 500
    
        # --- Verificação da Restrição C2 (revisão por dia, mais robusta) ---
        # Embora já verificado por slot, vamos garantir a regra do dia
        for professor, dias_aulas in aulas_por_professor_dia.items():
             for dia, count in dias_aulas.items():
                 if count > 1: # Professor não pode ter mais de 1 aula por dia (implícito no C2 por slot)
                     # A penalidade por slot já cobre isso, mas pode adicionar uma penalidade menor aqui se desejar
                     pass 
    
        # --- Restrição C5: Pré-requisitos ---
        # "o tempo ocioso entre aulas de um mesmo período" - Interpretado como minimização do *span* de tempo de cada disciplina
        # Vamos refazer C3 e C5 separadamente
        
        # --- Objetivo C3: Minimizar o tempo ocioso entre aulas de um mesmo período ---
        # Interpretação: Minimizar a 'duração total' em que as aulas de um período estão espalhadas.
        # Calculamos o tempo da primeira à última aula de cada período.
        custo_ociosidade_periodo = 0
        for periodo, aulas_periodo in periodo_horarios.items():
            if not aulas_periodo: continue
            
            primeira_aula_slot = min(a[0] for a in aulas_periodo)
            ultima_aula_slot = max(a[0] for a in aulas_periodo)
            
            # Calcula o 'span' em dias, turnos, aulas
            dia_i, turno_i, aula_i = numslot_para_horario(primeira_aula_slot)
            dia_f, turno_f, aula_f = numslot_para_horario(ultima_aula_slot)
            
            # Convertendo para uma medida linear de tempo para facilitar a subtração
            tempo_inicio = dia_i * (TURNOS_POR_DIA * SLOTS_POR_TURNO) + turno_i * SLOTS_POR_TURNO + aula_i
            tempo_fim = dia_f * (TURNOS_POR_DIA * SLOTS_POR_TURNO) + turno_f * SLOTS_POR_TURNO + aula_f
            
            span_tempo = tempo_fim - tempo_inicio 
            custo_ociosidade_periodo += span_tempo
    
        penalidade_total += custo_ociosidade_periodo * 1 # Peso 1 para este custo
    
        # --- Restrição C5: Conflitos de Pré-requisitos ---
        # "não existam conflitos entre os horários de disciplinas que são pré-requisito e suas correspondentes"
        # Interpretação: A ÚLTIMA aula da pré-requisito deve ocorrer ANTES da PRIMEIRA aula da disciplina dependente.
        penalidade_prerequisito = 0
        for gene_idx, slot in enumerate(individual):
            # Encontra a disciplina correspondente ao gene atual
            disciplina_atual_info = None
            for info in disciplina_gene_map:
                if info["start_gene"] <= gene_idx < info["end_gene"]:
                    disciplina_atual_info = info
                    break
            
            if disciplina_atual_info is None: continue
            
            disciplina_atual = disciplina_atual_info["disciplina"]
            
            # Se esta é a PRIMEIRA aula desta disciplina no indivíduo
            # Verifica se ela tem pré-requisitos
            if gene_idx == disciplina_atual_info["start_gene"] and disciplina_atual.dependencias:
                primeira_aula_atual_slot = slot
                dia_atual, turno_atual, aula_atual = numslot_para_horario(primeira_aula_atual_slot)
                tempo_primeira_aula_atual = dia_atual * (TURNOS_POR_DIA * SLOTS_POR_TURNO) + turno_atual * SLOTS_POR_TURNO + aula_atual
    
                for prereq_cod in disciplina_atual.dependencias:
                    # Encontra a disciplina pré-requisito na lista global
                    prereq_disciplina = None
                    prereq_info = None
                    for p_info in disciplina_gene_map:
                        if p_info["disciplina"].codigo == prereq_cod:
                            prereq_disciplina = p_info["disciplina"]
                            prereq_info = p_info
                            break
                    
                    if prereq_disciplina and prereq_info:
                        # Encontra a ÚLTIMA aula da pré-requisito
                        slots_prereq = disciplina_horarios.get(prereq_cod, [])
                        if not slots_prereq:
                            # Pré-requisito não tem aulas agendadas? Isso é um problema sério.
                            penalidade_prerequisito += 1000 # Penalidade alta
                            continue 
                            
                        ultima_aula_prereq_slot = max(slots_prereq)
                        dia_pr, turno_pr, aula_pr = numslot_para_horario(ultima_aula_prereq_slot)
                        tempo_ultima_aula_prereq = dia_pr * (TURNOS_POR_DIA * SLOTS_POR_TURNO) + turno_pr * SLOTS_POR_TURNO + aula_pr
    
                        # Compara os tempos
                        if tempo_ultima_aula_prereq >= tempo_primeira_aula_atual:
                            penalidade_prerequisito += 1 # Penaliza cada violação
                            # print(f"VIOLAÇÃO PREREQ: {prereq_cod} (últ: {tempo_ultima_aula_prereq}) -> {disciplina_atual.codigo} (prim: {tempo_primeira_aula_atual})")
    
        penalidade_total += penalidade_prerequisito * 2000 # Peso alto para pré-requisitos
    
        # --- Objetivo C6: Balanceamento Semanal por Período ---
        # Distribui aulas de forma uniforme pelos 5 dias.
        custo_balanceamento = 0
        aulas_por_periodo_dia = defaultdict(lambda: defaultdict(int))
        num_aulas_por_periodo = defaultdict(int)
    
        # Recalcula a distribuição dia/periodo
        for periodo, aulas_periodo in periodo_horarios.items():
            for slot, _, _, _ in aulas_periodo:
                 dia, _, _ = numslot_para_horario(slot)
                 if dia != -1:
                     aulas_por_periodo_dia[periodo][dia] += 1
                     num_aulas_por_periodo[periodo] += 1
    
        for periodo, contagem_aulas_total in num_aulas_por_periodo.items():
            if contagem_aulas_total == 0: continue
            
            media_aulas_dia = contagem_aulas_total / float(DIAS_POR_SEMANA)
            
            # Calcula o desvio em relação à média para cada dia
            desvio_periodo = 0
            for dia in range(DIAS_POR_SEMANA):
                contagem_dia = aulas_por_periodo_dia[periodo][dia]
                desvio_periodo += abs(contagem_dia - media_aulas_dia)
                
            # Adiciona o desvio total do período ao custo
            custo_balanceamento += desvio_periodo
    
        penalidade_total += custo_balanceamento * 10 # Peso 10 para balanceamento
    
        # --- Combinação Final ---
        # As penalidades para violações C1, C2, C4, C5 já estão somadas.
        # Os custos para objetivos C3 e C6 também estão somados.
        
        # Se houver penalidades de erro grave (ex: gene inválido), elas já estão incluídas.
        
        # Retorna uma tupla com o valor do fitness (DEAP espera uma tupla)
        return (penalidade_total,)
    
    # --- Configuração do DEAP ---
    
    # Cria o tipo de fitness (Minimização)
    creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
    
    # Cria o tipo de indivíduo (uma lista de inteiros representando slots)
    creator.create("Individual", list, fitness=creator.FitnessMin)
    
    toolbox = base.Toolbox()
    
    # Atributo: um slot aleatório entre 0 e TOTAL_SLOTS-1
    toolbox.register("attr_slot", random.randint, 0, TOTAL_SLOTS - 1)
    
    # Indivíduo: uma lista de N_GENES atributos do tipo slot
    toolbox.register("individual", tools.initRepeat, creator.Individual,
                     toolbox.attr_slot, n=N_GENES)
    
    # População: uma lista de indivíduos
    toolbox.register("population", tools.initRepeat, list, toolbox.individual)
    
    # Registro da função de avaliação
    # IMPORTANTE: Certifique-se que a função 'fitness' (calcular_fitness) está definida ANTES desta linha
    toolbox.register("evaluate", calcular_fitness) 
    
    # Operadores genéticos
    # Usando o TOURNSIZE do seu dicionário PARAMETROS
    toolbox.register("select", tools.selTournament, tournsize=3) # Valor de PARAMETROS[0]["TOURNSIZE"]
    toolbox.register("mate", tools.cxOnePoint) # Pode experimentar outros como cxBlend se os atributos fossem contínuos
    # Mutação: Uniforme sobre os slots possíveis. indpb=1.0/N_GENES é um valor comum, mas pode ser ajustado.
    toolbox.register("mutate", tools.mutUniformInt, low=0, up=TOTAL_SLOTS - 1, indpb=0.1) # indpb ajustado para 0.1 (10%)
    
    # --- Estatísticas e Hall of Fame ---
    stats = tools.Statistics(lambda ind: ind.fitness.values)
    stats.register("min", np.min)
    stats.register("avg", np.mean) # Use np.mean para a média
    stats.register("std", np.std) # Adiciona desvio padrão
    
    hof = tools.HallOfFame(1) # Guarda apenas o melhor indivíduo
    
    # --- Execução do Algoritmo Genético ---
    
    if __name__ == "__main__":
        # Cria a população inicial
        populacao = toolbox.population(n=POP_SIZE)
    
        # Executa o algoritmo EA Simple
        print(f"Iniciando GA com POP_SIZE={POP_SIZE}, CXPB={CXPB}, MUTPB={MUTPB}, NGEN={NGEN}")
        
        # O eaSimple precisa do toolbox completo, não apenas da população
        # Ele aplicará os operadores registrados (evaluate, select, mate, mutate)
        populacao, logbook = algorithms.eaSimple(populacao, toolbox, 
                                                cxpb=CXPB, mutpb=MUTPB, 
                                                ngen=NGEN, 
                                                stats=stats, 
                                                halloffame=hof, 
                                                verbose=True) # verbose=True mostra o progresso a cada geração
    
        # --- Resultados ---
        print("\n--- GA Finalizado ---")
        
        if hof:
            melhor_individuo = hof[0]
            print("Melhor Fitness:", melhor_individuo.fitness.values[0])
            
            # Opcional: Imprimir detalhes do melhor horário encontrado
            print("\nDetalhes do Melhor Horário:")
            # (Você pode querer uma função para imprimir o horário de forma legível)
            # Exemplo: print(melhor_individuo) 
            
            # Exemplo de como acessar os dados do melhor indivíduo
            # for i, slot in enumerate(melhor_individuo):
            #     disciplina_info = next((info for info in disciplina_gene_map if info["start_gene"] <= i < info["end_gene"]), None)
            #     if disciplina_info:
            #         d = disciplina_info["disciplina"]
            #         dia, turno, aula = numslot_para_horario(slot)
            #         print(f"  Aula {i}: {d.codigo} ({d.professor}) -> Slot {slot} (Dia {dia}, Turno {turno}, Aula {aula})")
            #     else:
            #          print(f"  Aula {i}: Erro no mapeamento - Slot {slot}")
    
    
            # Chamar a função para gerar PDF (assumindo que gerar_pdf existe e usa 'melhor_individuo' e 'disciplinas')
            # try:
            #    gerar_pdf(melhor_individuo) 
            # except NameError:
            #    print("Função gerar_pdf não definida.")
            
        else:
            print("Nenhum indivíduo no Hall of Fame.")
    
        print("\nProfessores designados (exemplo):")
        for d in disciplinas:
            print(f"  {d.codigo}: {d.professor}")
    
    

    Explicação Detalhada das Penalidades/Custos na Função calcular_fitness:

    1. Pré-processamento: Cria dicionários (slots_ocupados, disciplina_horarios, professor_horarios, periodo_horarios) e contadores (aulas_por_disciplina_dia, aulas_por_professor_dia) para facilitar a verificação das regras. Isso é feito iterando sobre o individual uma vez.
    2. Restrição C1 (Conflito Período/Slot):
      • Ao processar cada gene/aula, verifica-se em slots_ocupados. Se o slot já está ocupado e a disciplina que o ocupa pertence ao mesmo período da disciplina atual, adiciona-se uma penalidade alta (1000).
    3. Restrição C2 (Conflito Professor/Slot):
      • Ao processar cada gene/aula, verifica-se se o professor da disciplina atual já está listado em slots_ocupados para aquele slot_key específico. Se sim, penalidade alta (1000).
    4. Restrição C4 (Max 3 Aulas/Matéria/Dia):
      • Após o loop de pré-processamento, usa-se aulas_por_disciplina_dia. Para cada disciplina, itera-se pelos dias. Se a contagem de aulas (count) em um dia exceder 3, adiciona-se (count - 3) * 500 à penalidade total. O peso 500 é significativo.
    5. Objetivo C3 (Minimizar "Ociosidade" por Período - Span):
      • Itera sobre periodo_horarios. Para cada período, encontra-se o slot da primeira e da última aula.
      • Converte esses slots para uma medida linear de tempo.
      • Calcula-se a diferença (span_tempo).
      • Soma-se esse span_tempo a custo_ociosidade_periodo. O custo total é multiplicado por um peso (1) e adicionado à penalidade total. Queremos que esse valor seja o menor possível.
    6. Restrição C5 (Pré-requisitos):
      • Durante o pré-processamento, quando a primeira aula de uma disciplina (gene_idx == disciplina_atual_info["start_gene"]) é encontrada, verifica-se se ela tem dependências (disciplina_atual.dependencias).
      • Para cada pré-requisito (prereq_cod):
        • Encontra-se a última aula agendada para o pré-requisito (max(slots_prereq)).
        • Converte-se o slot da primeira aula atual e da última aula do pré-requisito para o tempo linear.
        • Se tempo_ultima_aula_prereq >= tempo_primeira_aula_atual, significa que o pré-requisito não terminou antes do início da disciplina dependente. Uma penalidade (1) é adicionada a penalidade_prerequisito.
      • No final, penalidade_prerequisito é multiplicada por um peso alto (2000) e adicionada à penalidade total.
    7. Objetivo C6 (Balanceamento Semanal):
      • Calcula-se quantas aulas de cada período caem em cada dia da semana (aulas_por_periodo_dia).
      • Para cada período, calcula-se a média teórica de aulas por dia (media_aulas_dia).
      • Calcula-se o desvio absoluto da contagem real de cada dia em relação a essa média (abs(contagem_dia - media_aulas_dia)).
      • Soma-se esses desvios para obter o desvio_periodo.
      • Soma-se o desvio_periodo de todos os períodos para obter o custo_balanceamento.
      • O custo total é multiplicado por um peso (10) e adicionado à penalidade total.

    Ajustes e Considerações:

    • Pesos: Os pesos (1000, 500, 2000, 1, 10) são cruciais e podem precisar de tuning. Comece com valores altos para restrições estritas e valores menores para otimização. Se o GA não estiver respeitando uma restrição, aumente seu peso. Se estiver otimizando demais em detrimento das restrições, diminua o peso dos objetivos.
    • Interpretação C4: A interpretação de "+3 aulas seguidas" foi feita como "+3 aulas da mesma matéria no mesmo dia". Se você queria dizer 3 slots consecutivos no horário (ex: slot 5, 6, 7), a lógica de verificação precisaria ser diferente, talvez iterando sobre os slots ordenados para cada disciplina. A versão atual é mais comum em grade de horários.
    • Interpretação C3: A minimização do "tempo ocioso" foi interpretada como a minimização do span (tempo entre a primeira e a última aula) de cada disciplina. Outra interpretação seria contar explicitamente os slots vazios entre as aulas de um período. A implementação atual foca no span temporal geral.
    • gerar_pdf: A função gerar_pdf(best) foi deixada comentada, pois não temos a definição dela. Você precisará implementá-la separadamente.
    • Consistência de Parâmetros: Garanta que os parâmetros como POP_SIZE, CXPB, MUTPB, NGEN e TOURNSIZE sejam usados de forma consistente onde são definidos e utilizados. No código acima, usei os valores globais definidos posteriormente para eaSimple e o valor de TOURNSIZE do dicionário PARAMETROS para selTournament.

    Este código fornece uma base sólida para a função de fitness, cobrindo todas as regras que você especificou com penalidades e custos adequados. Lembre-se que a performance do GA dependerá fortemente do ajuste fino desses pesos e parâmetros.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.