import heapq
class Curso:
def __init__(self, id_curso, nome, conversao):
self.id = id_curso
self.nome = nome
self.conversao = conversao
# Método necessário para o heapq comparar objetos caso haja empate nos custos
def __lt__(self, outro):
return self.conversao > outro.conversao
class RecomendacaoTrilha:
def __init__(self, conexoes):
# Aqui o grafo não é totalmente conectado. Recebemos as conexões lógicas prontas.
self.grafo = conexoes
def heuristica(self, curso):
# Multiplicamos por -1 pois o heapq do Python retorna o menor valor por padrão
return -curso.conversao
def a_star(self, inicio, objetivo):
fila = []
# Tupla: (Custo Total f, Custo Real g, Nó Atual)
heapq.heappush(fila, (0 + self.heuristica(inicio), 0, inicio))
caminhos = {}
custo_acumulado = {inicio: 0}
while fila:
_, g, atual = heapq.heappop(fila)
if atual == objetivo:
break
for vizinho in self.grafo.get(atual, []):
novo_custo_g = g + 1
# Se achamos um caminho mais curto para o vizinho, atualizamos
if vizinho not in custo_acumulado or novo_custo_g < custo_acumulado[vizinho]:
custo_acumulado[vizinho] = novo_custo_g
f = novo_custo_g + self.heuristica(vizinho)
heapq.heappush(fila, (f, novo_custo_g, vizinho))
caminhos[vizinho] = atual
return self._reconstruir_caminho(caminhos, inicio, objetivo)
def _reconstruir_caminho(self, caminhos, inicio, objetivo):
atual = objetivo
trilha = [atual]
while atual in caminhos:
atual = caminhos[atual]
trilha.append(atual)
trilha.reverse()
return trilha
# Criando os produtos focados em infraestrutura e segurança
c1 = Curso("C1", "Introdução ao Ubuntu", 0.9)
c2 = Curso("C2", "Configuração do WSL2", 0.8)
c3 = Curso("C3", "Automação com Shell Script", 0.7)
c4 = Curso("C4", "Criptografia com OpenSSL", 0.6)
c5 = Curso("C5", "Fundamentos de Cibersegurança", 0.85)
# Definindo conexões lógicas (Afinidade de conteúdo)
conexoes = {
c1: [c2, c3],
c2: [c3, c4],
c3: [c5],
c5: [c4]
}
sistema = RecomendacaoTrilha(conexoes)
resultado = sistema.a_star(c1, c4)
print("--- Abordagem 1 ---")
for curso in resultado:
print(curso.nome)