Búsqueda en Profundidad en Python

estoy implementando un método de búsqueda en profundidad en lenguaje Python. Lo estoy utilizando para hallar el camino óptimo entre dos nodos de un grafo, el problema está en que usando mi código, solamente consigo obtener el primer nodo del grafo.

Sé que el algoritmo crea una lista de caminos pendientes y que, hasta que llegue al nodo final, expande el primer camino, pero no consigo obtener todo el camino. Dejo mi código para saber si tengo algún elemento erróneo:

Código:

def busqueda_profundidad(self, origen, fin):
    cp = [[origen]] # camino pendiente
    while cp:
        print(cp)
        if not cp: 
            return False
        if cp[0][0] == fin:
            return list(reversed(cp[0][0]))
        expansion = self.expandir(cp[0][0])
        cp = expansion + cp[1:]

def expandir(self, camino):
    expansion = self.sucesores(camino[0])
    nuevos = []
    for n in expansion:
        if not n in camino:
            nuevos.append([n] + camino)
    return nuevos

def sucesores(self, station):
    """Devuelve la lista de posibles sucesores"""
    return sorted(list(set(self.model[nodo])))
1
задан 27.12.2016, 20:48
1 ответ

Ты не обеспечил достаточным количеством informaci¦n, чтобы находить ошибку в твоем c¦digo, но, если он служит тебе небольшим количеством aquà - у тебя есть soluci¦n.

Ввиду grafo, не управляемого с N узлы, пронумерованные с целыми числами с 0 в N-1:

introducir la descripción de la imagen aquí

с Вашим списком прилегания:

adyacencia = [
    [1, 3, 4],
    [0, 2, 3, 4],
    [1, 4],
    [0, 1],
    [0, 1, 2]]

Общий не перекурсивный implementaci¦n алгоритма:

class Grafo(object):

    def __init__(self, adyacencia):
        self.ady = adyacencia
        self._init_grafo(-1)

    def _init_grafo(self, inicio):
        self.encontrado = [False for n in self.ady]
        self.procesado = [False for n in self.ady]
        self.padre = [-1 for n in self.ady]
        self.inicio = inicio

    def profundidad(self, inicio):
        """Usar busqueda en profundidad desde inicio a todo el grafo"""
        self._init_grafo(inicio)
        q = [inicio]
        self.encontrado[inicio] = True

        while q:
            v = q.pop()
            self.procesado[v] = True

            for vecino in self.ady[v]:
                if not self.encontrado[vecino]:
                    q.append(vecino)
                    self.encontrado[vecino] = True
                    self.padre[vecino] = v

    def construir_camino(self, destino):
        """Devuelve el camino entre los vertices inicio y destino"""
        if self.padre[destino] == -1 or self.inicio == -1:
            return None

        camino = [destino,]
        p = destino
        while p != self.inicio:
            camino.append(self.padre[p])
            p = self.padre[p]

        return camino

, Чтобы это выполнять:

inicio = 3
destino = 2
g = Grafo(adyacencia)
g.profundidad(inicio)
camino = g.construir_camino(destino)

Конечно в mayor¦ - в случаев не необходим вычислять маршрут во все они vértices, и можешь останавливать ее búsqueda как только ты прибыл в судьбу, но будешь должен решать это ты.

0
ответ дан 24.11.2019, 11:51