Merge branch 'algoritmo_busqueda' into Interfaz

camino.py

+from enum import Enum
+
+class Bloque(Enum):
+    Edificio = 0
+    Calle_Izquierda_Derecha = 1
+    Calle_Arriba_Abajo = 2
+    Calle_Arriba_Derecha = 3
+    Calle_Derecha_Abajo = 4
+    Calle_Abajo_Izquierda = 5
+    Calle_Izquierda_Arriba = 6
+    Calle_Izquierda_Arriba_Derecha = 7
+    Calle_Arriba_Derecha_Abajo = 8
+    Calle_Derecha_Abajo_Izquierda = 9
+    Calle_Abajo_Izquierda_Arriba = 10
+    Calle_Arriba_Derecha_Abajo_Izquierda = 11
+
+class Direccion(Enum):
+    Arriba = 0
+    Derecha = 1
+    Abajo = 2
+    Izquierda = 3
+
+class Casilla:
+
+    def __init__(self,x:int,y:int,codigo_bloque:str):
+        self.x = x
+        self.y = y
+        self.bloque = Bloque(int(codigo_bloque))
+
+    def __str__(self):
+        return f'x : {self.x} | y : {self.y} | {self.bloque}'
+    
+    
+    
+
+    
+
+
+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 = []
+    direcOptima = []
+    sol = [posicionInicial]
+    direcciones = []
+
+    def caminoVueltraAtras(direccion,posicion):
+        global distOptima
+        
+        #print(sol)
+
+        def factible(direc,pos):
+
+            def movimientoAceptado(direccion : Direccion, bloque : int, bloqueSiguiente : int):
+
+                def moviAcept(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
+                    
+                direcSiguiente = Direccion((direccion.value + 2) % 4)
+                if(moviAcept(direccion,bloque) and moviAcept(direcSiguiente,bloqueSiguiente)):
+                    return True
+                return False
+            #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])):
+                #print(f"Descartado Fuera de Rango {direccion} : {pos}")
+                return False
+            
+            if(matriz[pos[0]][pos[1]] == 0):
+                #print(f"Descartado Edificio {direccion} : {pos}")
+                return False           
+
+            if(not movimientoAceptado(direc,matriz[sol[-1][0]][sol[-1][1]],matriz[pos[0]][pos[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
+
+
+        if(factible(direccion,posicion)):          
+
+            
+            sol.append(posicion)
+            direcciones.append(direccion)
+            
+            pos = sol[-1]
+            #bq = mAdy[pos[0]][pos[1]]
+            #mAdy[pos[0]][pos[1]] = 0
+
+            if(pos != posicionFinal):
+                caminoVueltraAtras(Direccion.Arriba,(pos[0]-1,pos[1]))
+                caminoVueltraAtras(Direccion.Abajo,(pos[0]+1,pos[1]))
+                caminoVueltraAtras(Direccion.Derecha,(pos[0],pos[1]+1))
+                caminoVueltraAtras(Direccion.Izquierda,(pos[0],pos[1]-1))
+            else:
+                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()
+                    direcOptima.clear()
+                    for i in range(len(direcciones)):
+                        solOptima.append(sol[i])
+                        direcOptima.append(direcciones[i])                    
+                    solOptima.append(sol[-1])
+
+
+            #mAdy[pos[0]][pos[1]] = bq
+
+            sol.pop()
+            direcciones.pop()
+        
+
+    caminoVueltraAtras(Direccion.Arriba,(posicionInicial[0]-1,posicionInicial[1]))
+    caminoVueltraAtras(Direccion.Abajo,(posicionInicial[0]+1,posicionInicial[1]))
+    caminoVueltraAtras(Direccion.Derecha,(posicionInicial[0],posicionInicial[1]+1))
+    caminoVueltraAtras(Direccion.Abajo,(posicionInicial[0],posicionInicial[1]-1))
+
+    # Devuelve el recogido realizado tanto en posiciones como en direcciones
+    #return solOptima,direcOptima
+
+    return direcOptima
+
+
+    
+
+
+
+
+
+    
+
+
+#02 02 00 01 05 
+#03 07 05 00 02 
+#00 04 11 09 06 
+#01 10 03 10 00 
+#00 02 00 08 01 
+#01 10 01 10 00 
+#01 06 01 07 01
+
+matriz = [["02","02","00","01","05"],
+          ["03","07","05","00","02"],
+          ["00","04","11","09","06"],
+          ["01","10","03","10","00"],
+          ["00","02","00","08","01"],
+          ["01","10","01","10","00"],
+          ["01","06","01","07","01"]]
+
+#mAdy = matrizAdyacencia(matriz)
+
+#pos = mAdy[6][0]
+#mAdy[6][0] = 2
+
+sol = encontrarCamino(matriz,(5,2),(6,0))
+
+#mAdy[6][0] = pos
+
+for s in sol:
+    print(s) 
\ No newline at end of file

pedidos.py

+from math import pow,sqrt
+from sys import maxsize
+
+
+class Posicion:
+
+        def __init__(self,x : int,y : int):
+            self.x = x
+            self.y = y
+
+        def __str__(self) -> str:
+            return f'({self.x},{self.y})'
+
+
+class Pedido:
+
+    def __init__(self,x_ini : int,y_ini : int, x_fin : int,y_fin : int) :
+        self.inicio = Posicion(x_ini,y_ini)
+        self.final = Posicion(x_fin,y_fin)
+
+    def __str__(self) -> str:
+        return f'({self.inicio},{self.final})'
+
+    
+        
+
+
+
+
+def ordenarPedidos(posicionActual : Posicion,lista : list):
+
+    def imprimir(lista : list):
+        for elem in lista:
+            print(elem)
+
+    def imprimirPosiciones(lP : list):
+        pos = ""
+        for p in lP:
+            pos = pos + str(p) + ":"
+        print(pos)
+
+
+    def distanciaPosicionPedido(pos: Posicion,ped : Pedido):
+        return sqrt(pow(pos.x - ped.inicio.x,2) + pow(pos.y - ped.inicio.y,2))
+
+    def distanciaPosiciones(pos1 : Posicion, pos2 : Posicion):
+        return sqrt(pow(pos1.x - pos2.x,2) + pow(pos1.y - pos2.y,2))
+
+
+    def transformarAPedidos(lista : list):
+        listaPedidos = []
+        for elem in lista:
+            listaPedidos.append(Pedido(elem[0][0],elem[0][1],elem[1][0],elem[1][1]))
+        return listaPedidos
+
+
+
+    pedidos = transformarAPedidos(lista=lista)
+    n_Posiciones = len(pedidos) * 2
+
+    listaPosiciones = []
+    matriz = []
+    for i in range(n_Posiciones):
+        m = []
+        for j in range(n_Posiciones):
+            m.append(maxsize)
+        matriz.append(m)
+
+    mindist = maxsize
+    minPos : int
+    for p in pedidos:
+        posIni = len(listaPosiciones)
+        listaPosiciones.append(p.inicio)
+        posFin = posIni + 1
+        listaPosiciones.append(p.final)
+        matriz[posIni][posFin] = 0
+        #matriz[posFin][posIni] = 0
+
+        dist = distanciaPosicionPedido(pos=posicionActual,ped=p)
+        #print("Posicion Actual : ",posicionActual," Pedido : ",p.inicio,p.final," Valor : ",dist)
+        if(dist < mindist):
+            mindist = dist
+            minPos = posIni
+
+    
+    listaPedidos = [listaPosiciones[minPos]]
+    
+    for i in range(n_Posiciones):
+        for j in range(n_Posiciones):
+            # a mod 2 --> 0 : inicio , 1 : final
+            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])
+            
+    #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):
+        pos = minPos
+        mindist = maxsize
+        minPos = -1
+        for i in range(n_Posiciones):
+            if(matriz[pos][i] < mindist and not listaPosiciones[i] in listaPedidos):
+                mindist = matriz[pos][i]
+                minPos = i
+        listaPedidos.append(listaPosiciones[minPos])
+
+    #imprimirPosiciones(listaPedidos)
+
+    return listaPedidos
+
+    
+
+        
+   
+
+posicionInicio = Posicion(6,0)
+
+listaPed = []
+listaPed.append(((6,4),(0,3)))
+listaPed.append(((0,1),(3,0)))
+
+#listap = transformarAPedidos(posicionInicio,listaPed)
+
+
+peds = ordenarPedidos(posicionActual=posicionInicio,lista=listaPed)
+for p in peds:
+    print(p)
+#print(transformarAPedidos(listaPed))
\ No newline at end of file