Camino finalizado, pedidos INCHECK

casilla.py → camino.py

 from enum import Enum
 from enum import Enum
-from sys import maxsize
-
 
 
 class Bloque(Enum):
 class Bloque(Enum):
     Edificio = 0
     Edificio = 0
@@ -16,32 +14,12 @@ class Bloque(Enum):
     Calle_Abajo_Izquierda_Arriba = 10
     Calle_Abajo_Izquierda_Arriba = 10
     Calle_Arriba_Derecha_Abajo_Izquierda = 11
     Calle_Arriba_Derecha_Abajo_Izquierda = 11
 
 
-
 class Direccion(Enum):
 class Direccion(Enum):
     Arriba = 0
     Arriba = 0
     Derecha = 1
     Derecha = 1
     Abajo = 2
     Abajo = 2
     Izquierda = 3
     Izquierda = 3
 
 
-
-def movimientoAceptado(direccion : Direccion, bloquePosterio : Bloque):
-    if(direccion == Direccion.Arriba):
-
-        arriba = [2,4,5,8,9,11]
-        if(bloquePosterio.value == 2 or bloquePosterio.value == 4 or bloquePosterio.value == 5 
-           or bloquePosterio.value == 8 or bloquePosterio.value == 9 or bloquePosterio.value == 11):
-            return True
-        return False
-    if(direccion == Direccion.Abajo):
-        if(bloquePosterio.value == 2 or bloquePosterio.value == 3
-           or bloquePosterio.value == 6 or bloquePosterio.value == 7
-           or bloquePosterio.value == 10 or bloquePosterio.value == 11):
-            return True
-        return False
-    if(direccion == Direccion.Izquierda):
-        if(bloquePosterio.value == 1)
-
-
 class Casilla:
 class Casilla:
 
 
     def __init__(self,x:int,y:int,codigo_bloque:str):
     def __init__(self,x:int,y:int,codigo_bloque:str):
@@ -54,67 +32,154 @@ class Casilla:
     
     
     
     
     
     
-def convertirMatrizCasillas(matriz):
-    matCas = []
-    for i in range(len(matriz)):
-        fila = []
-        for j in range(len(matriz[0])):
-            fila.append(Casilla(i,j,matriz[i][j]))
-        matCas.append(fila)
-
-    return matCas
+
     
     
 
 
-distOptima = 100
+
 def encontrarCamino(matriz,posicionInicial, posicionFinal):
 def encontrarCamino(matriz,posicionInicial, posicionFinal):
+    #distOptima : int = maxsize
+    def matrizAdyacencia(matriz):
+
+        def convertirMatrizCasillas(matriz):
+            matCas = []
+            for i in range(len(matriz)):
+                fila = []
+                for j in range(len(matriz[0])):
+                    fila.append(Casilla(i,j,matriz[i][j]))
+                matCas.append(fila)
+
+            return matCas
+
+        def dentroTablero(coord):
+            if(coord[0] < len(matriz) and coord[0] >= 0 and coord[1] < len(matriz[0]) and coord[1] >= 0):
+                return True
+            return False
+        
+        matrizCasillas = convertirMatrizCasillas(matriz=matriz)
+
+        matrizAdy = []
+        for i in range(len(matriz)):
+            fila = []
+            for j in range(len(matriz[0])):
+                fila.append(matrizCasillas[i][j].bloque.value)
+            matrizAdy.append(fila)
+
+        return matrizAdy
+
+
+    matriz = matrizAdyacencia(matriz)
+
     solOptima = []
     solOptima = []
     direcOptima = []
     direcOptima = []
-    sol = []
+    sol = [posicionInicial]
     direcciones = []
     direcciones = []
 
 
     def caminoVueltraAtras(direccion,posicion):
     def caminoVueltraAtras(direccion,posicion):
         global distOptima
         global distOptima
-
-        def factible(pos):
+        
+        #print(sol)
+
+        def factible(direc,pos):
+
+            def movimientoAceptado(direccion : Direccion, bloque : int):
+                #print(direccion.name, bloque)
+                if(direccion == Direccion.Arriba):
+
+                    #arriba = [2,4,5,8,9,10,11]
+                    arriba = [2,3,6,7,8,10,11]
+                    if(bloque in arriba):
+                        return True
+                    return False
+                if(direccion == Direccion.Abajo):
+                    #abajo = [2,3,6,7,8,10,11]
+                    abajo = [2,4,5,8,9,10,11]
+                    if(bloque in abajo):
+                        return True
+                    return False
+                    #if(bloquePosterio.value == 2 or bloquePosterio.value == 3
+                    #   or bloquePosterio.value == 6 or bloquePosterio.value == 7
+                    #   or bloquePosterio.value == 10 or bloquePosterio.value == 11):
+                    #    return True
+                    #return False
+                if(direccion == Direccion.Izquierda):
+                    #izquierda = [1,3,4,7,8,9,11]
+                    izquierda = [1,5,6,7,9,10,11]
+                    if(bloque in izquierda):
+                        return True
+                    return False
+                if(direccion == Direccion.Derecha):
+                    #derecha = [1,6,7,9,10,11]
+                    derecha = [1,3,4,7,8,9,11]
+                    if(bloque in derecha):
+                        return True
+                    return False
             #pos = sol[-1]
             #pos = sol[-1]
             
             
+            if(pos == posicionInicial):                
+                #print(f"Descartado Inicio {direccion} : {pos}")
+                return False
+                
+            if(pos in sol):
+                #print(f"Descartado Usada {direccion} : {pos}")
+                return False
+
             if(pos[0] < 0 or pos[0] >= len(matriz) or pos[1] < 0 or pos[1] >= len(matriz[0])):
             if(pos[0] < 0 or pos[0] >= len(matriz) or pos[1] < 0 or pos[1] >= len(matriz[0])):
+                #print(f"Descartado Fuera de Rango {direccion} : {pos}")
                 return False
                 return False
             
             
             if(matriz[pos[0]][pos[1]] == 0):
             if(matriz[pos[0]][pos[1]] == 0):
+                #print(f"Descartado Edificio {direccion} : {pos}")
                 return False           
                 return False           
 
 
-            if(len(sol)+1 >= distOptima):
-                return False            
+            if(not movimientoAceptado(direc,matriz[sol[-1][0]][sol[-1][1]])):
+                #print(f"Descartado Movimiento no aceptado {direccion} : {sol[-1]}")
+                return False
+
+            #if(len(sol)+1 >= distOptima):
+            if(len(solOptima) > 0):
+                if(len(sol)+1 >= len(solOptima)):
+                    #print(f"Descartado Muy Largo {direccion} : {pos}")
+                    return False            
 
 
             return True
             return True
 
 
 
 
-        if(factible(posicion)):          
+        if(factible(direccion,posicion)):          
 
 
             
             
             sol.append(posicion)
             sol.append(posicion)
             direcciones.append(direccion)
             direcciones.append(direccion)
             
             
             pos = sol[-1]
             pos = sol[-1]
-            bq = mAdy[pos[0]][pos[1]]
-            mAdy[pos[0]][pos[1]] = 0
+            #bq = mAdy[pos[0]][pos[1]]
+            #mAdy[pos[0]][pos[1]] = 0
 
 
             if(pos != posicionFinal):
             if(pos != posicionFinal):
                 caminoVueltraAtras(Direccion.Arriba,(pos[0]-1,pos[1]))
                 caminoVueltraAtras(Direccion.Arriba,(pos[0]-1,pos[1]))
                 caminoVueltraAtras(Direccion.Abajo,(pos[0]+1,pos[1]))
                 caminoVueltraAtras(Direccion.Abajo,(pos[0]+1,pos[1]))
                 caminoVueltraAtras(Direccion.Derecha,(pos[0],pos[1]+1))
                 caminoVueltraAtras(Direccion.Derecha,(pos[0],pos[1]+1))
-                caminoVueltraAtras(Direccion.Abajo,(pos[0],pos[1]-1))
+                caminoVueltraAtras(Direccion.Izquierda,(pos[0],pos[1]-1))
             else:
             else:
-                if(len(sol) < distOptima):
-                    distOptima = len(sol)
+                if(len(solOptima) > 0):
+                    if(len(sol) < len(solOptima)):
+                        #distOptima = len(sol)
+                        solOptima.clear()
+                        direcOptima.clear()
+                        for i in range(len(direcciones)):
+                            solOptima.append(sol[i])
+                            direcOptima.append(direcciones[i])                    
+                        solOptima.append(sol[-1])
+                else:
+                    #distOptima = len(sol)
                     solOptima.clear()
                     solOptima.clear()
                     direcOptima.clear()
                     direcOptima.clear()
-                    for i in range(len(sol)):
+                    for i in range(len(direcciones)):
                         solOptima.append(sol[i])
                         solOptima.append(sol[i])
-                        direcOptima.append(direcciones[i])
+                        direcOptima.append(direcciones[i])                    
+                    solOptima.append(sol[-1])
 
 
-            mAdy[pos[0]][pos[1]] = bq
+
+            #mAdy[pos[0]][pos[1]] = bq
 
 
             sol.pop()
             sol.pop()
             direcciones.pop()
             direcciones.pop()
@@ -125,32 +190,16 @@ def encontrarCamino(matriz,posicionInicial, posicionFinal):
     caminoVueltraAtras(Direccion.Derecha,(posicionInicial[0],posicionInicial[1]+1))
     caminoVueltraAtras(Direccion.Derecha,(posicionInicial[0],posicionInicial[1]+1))
     caminoVueltraAtras(Direccion.Abajo,(posicionInicial[0],posicionInicial[1]-1))
     caminoVueltraAtras(Direccion.Abajo,(posicionInicial[0],posicionInicial[1]-1))
 
 
-    return solOptima,direcOptima
+    # Devuelve el recogido realizado tanto en posiciones como en direcciones
+    #return solOptima,direcOptima
+
+    return direcOptima
 
 
 
 
     
     
 
 
 
 
-def matrizAdyacencia(matriz):
 
 
-    def dentroTablero(coord):
-        if(coord[0] < len(matriz) and coord[0] >= 0 and coord[1] < len(matriz[0]) and coord[1] >= 0):
-            return True
-        return False
-    
-    matrizCasillas = convertirMatrizCasillas(matriz=matriz)
-
-    matrizAdy = []
-    for i in range(len(matriz)):
-        fila = []
-        for j in range(len(matriz[0])):
-            if(matrizCasillas[i][j].bloque.value == 0):
-                fila.append(0)
-            else:
-                fila.append(1)
-        matrizAdy.append(fila)
-
-    return matrizAdy
 
 
 
 
     
     
@@ -172,11 +221,13 @@ matriz = [["02","02","00","01","05"],
           ["01","10","01","10","00"],
           ["01","10","01","10","00"],
           ["01","06","01","07","01"]]
           ["01","06","01","07","01"]]
 
 
-mAdy = matrizAdyacencia(matriz)
+#mAdy = matrizAdyacencia(matriz)
+
+#pos = mAdy[6][0]
+#mAdy[6][0] = 2
 
 
-mAdy[6][0] = 2
+sol = encontrarCamino(matriz,(5,2),(0,3))
 
 
-sol = encontrarCamino(mAdy,(6,0),(4,4))
+#mAdy[6][0] = pos
 
 
-print(sol[0])
-print(sol[1])
+print(sol)
\ No newline at end of file
\ No newline at end of file

busqueda.py → pedidos.py

@@ -27,7 +27,7 @@ class Pedido:
 
 
 
 
 
 
-def ordenar(posicionActual : Posicion,lista : list):
+def ordenarPedidos(posicionActual : Posicion,lista : list):
 
 
     def imprimir(lista : list):
     def imprimir(lista : list):
         for elem in lista:
         for elem in lista:
@@ -77,7 +77,7 @@ def ordenar(posicionActual : Posicion,lista : list):
         #matriz[posFin][posIni] = 0
         #matriz[posFin][posIni] = 0
 
 
         dist = distanciaPosicionPedido(pos=posicionActual,ped=p)
         dist = distanciaPosicionPedido(pos=posicionActual,ped=p)
-        print("Posicion Actual : ",posicionActual," Pedido : ",p.inicio,p.final," Valor : ",dist)
+        #print("Posicion Actual : ",posicionActual," Pedido : ",p.inicio,p.final," Valor : ",dist)
         if(dist < mindist):
         if(dist < mindist):
             mindist = dist
             mindist = dist
             minPos = posIni
             minPos = posIni
@@ -91,18 +91,18 @@ def ordenar(posicionActual : Posicion,lista : list):
             if( matriz[i][j] != 0 and matriz[j][i] != 0 and i != j and i%2 == 1 and j%2 == 0):
             if( matriz[i][j] != 0 and matriz[j][i] != 0 and i != j and i%2 == 1 and j%2 == 0):
                 matriz[i][j] = distanciaPosiciones(listaPosiciones[i],listaPosiciones[j])
                 matriz[i][j] = distanciaPosiciones(listaPosiciones[i],listaPosiciones[j])
             
             
-    pos = ""
-    for p in listaPosiciones:
-        pos = pos + str(p) + ":"
-    print(pos)
-    for m in matriz:
-        s = ""
-        for mj in m:
-            if(mj != maxsize):
-                s = f'{s}, {mj}'
-            else:
-                s = f'{s}, inf'
-        print(s)
+    #pos = ""
+    #for p in listaPosiciones:
+    #    pos = pos + str(p) + ":"
+    #print(pos)
+    #for m in matriz:
+    #    s = ""
+    #    for mj in m:
+    #        if(mj != maxsize):
+    #            s = f'{s}, {mj}'
+    #        else:
+    #            s = f'{s}, inf'
+    #    print(s)
 
 
     
     
     while(len(listaPedidos) != n_Posiciones):
     while(len(listaPedidos) != n_Posiciones):
@@ -115,7 +115,9 @@ def ordenar(posicionActual : Posicion,lista : list):
                 minPos = i
                 minPos = i
         listaPedidos.append(listaPosiciones[minPos])
         listaPedidos.append(listaPosiciones[minPos])
 
 
-    imprimirPosiciones(listaPedidos)
+    #imprimirPosiciones(listaPedidos)
+
+    return listaPedidos
 
 
     
     
 
 
@@ -131,5 +133,7 @@ listaPed.append(((0,1),(3,0)))
 #listap = transformarAPedidos(posicionInicio,listaPed)
 #listap = transformarAPedidos(posicionInicio,listaPed)
 
 
 
 
-ordenar(posicionActual=posicionInicio,lista=listaPed)
+peds = ordenarPedidos(posicionActual=posicionInicio,lista=listaPed)
+for p in peds:
+    print(p)
 #print(transformarAPedidos(listaPed))
 #print(transformarAPedidos(listaPed))
\ No newline at end of file