class Producto:
def init(self, nombre, categoria, probabilidad_conversion):
self.nombre = nombre
self.categoria = categoria
self.probabilidad_conversion = probabilidad_conversion

def __repr__(self):
    return f"{self.nombre} ({self.categoria})"

class AStarRecommendation:
def init(self, productos):
self.productos = productos

def heuristica(self, producto):
    """
    Mientras mayor sea la probabilidad de conversión,
    menor será el costo estimado.
    """
    return 1 - producto.probabilidad_conversion

def calcular_costo(self, producto_actual, producto_vecino):
    """
    Si los productos son de la misma categoría, el costo es menor.
    También se considera la probabilidad de conversión.
    """
    if producto_actual.categoria == producto_vecino.categoria:
        costo_categoria = 0.2
    else:
        costo_categoria = 0.6

    costo_conversion = 1 - producto_vecino.probabilidad_conversion

    return costo_categoria + costo_conversion

def obtener_vecinos(self, producto_actual):
    """
    Grafo simplificado: cada producto se conecta con todos los demás.
    """
    return [
        producto for producto in self.productos
        if producto.nombre != producto_actual.nombre
    ]

def encontrar_mejor_camino(self, inicio, objetivo):
    abiertos = [inicio]
    vino_de = {}

    costo_g = {producto.nombre: float("inf") for producto in self.productos}
    costo_f = {producto.nombre: float("inf") for producto in self.productos}

    costo_g[inicio.nombre] = 0
    costo_f[inicio.nombre] = self.heuristica(inicio)

    while abiertos:
        actual = min(abiertos, key=lambda producto: costo_f[producto.nombre])

        if actual.nombre == objetivo.nombre:
            return self.reconstruir_camino(vino_de, actual)

        abiertos.remove(actual)

        for vecino in self.obtener_vecinos(actual):
            nuevo_costo = costo_g[actual.nombre] + self.calcular_costo(actual, vecino)

            if nuevo_costo < costo_g[vecino.nombre]:
                vino_de[vecino.nombre] = actual
                costo_g[vecino.nombre] = nuevo_costo
                costo_f[vecino.nombre] = nuevo_costo + self.heuristica(vecino)

                if vecino not in abiertos:
                    abiertos.append(vecino)

    return None

def reconstruir_camino(self, vino_de, actual):
    camino = [actual]

    while actual.nombre in vino_de:
        actual = vino_de[actual.nombre]
        camino.insert(0, actual)

    return camino

Productos de ejemplo

productos = [
Producto("Notebook Gamer", "Computadores", 0.85),
Producto("Mouse Inalámbrico", "Accesorios", 0.70),
Producto("Teclado Mecánico", "Accesorios", 0.78),
Producto("Monitor 27 pulgadas", "Monitores", 0.82),
Producto("Audífonos Bluetooth", "Audio", 0.65),
Producto("Notebook Oficina", "Computadores", 0.90)
]

Crear sistema de recomendación

sistema = AStarRecommendation(productos)

Producto inicial y producto objetivo

producto_inicio = productos[0] # Notebook Gamer
producto_objetivo = productos[5] # Notebook Oficina

Ejecutar algoritmo A*

mejor_camino = sistema.encontrar_mejor_camino(producto_inicio, producto_objetivo)

Mostrar resultado

print("Mejor camino de recomendación:")

if mejor_camino:
for producto in mejor_camino:
print(
f"{producto.nombre} | "
f"Categoría: {producto.categoria} | "
f"Conversión: {producto.probabilidad_conversion}"
)
else:
print("No se encontró un camino.")

En este ejercicio se creó una clase Producto con los atributos nombre, categoría y probabilidad de conversión. Luego se implementó la clase AStarRecommendation, que utiliza un grafo simplificado donde cada producto se conecta con los demás.

El algoritmo A* busca el mejor camino entre un producto inicial y uno objetivo, considerando un costo y una heurística. La heurística se basa en la probabilidad de conversión: mientras mayor sea la posibilidad de compra, menor será el costo estimado. Además, el costo entre productos considera si pertenecen a la misma categoría, favoreciendo recomendaciones más relacionadas.

De esta manera, el sistema puede recomendar productos más relevantes, priorizando aquellos que tienen mayor relación con los intereses del usuario y mayor probabilidad de conversión.