Tema 5 Vuelta Atrás Nunca quemes un puente después de cruzarlo. Puede que algún día lo tengas que volver a cruzar.

Introducción Se emplea en muchos problemas de optimización donde la búsqueda responde a una estrategia que respete ciertas restricciones. Realiza un estudio exhaustivo de un conjunto conocido a priori de posibles soluciones, en las que tratamos de encontrar una o todas las soluciones, y por tanto, la óptima. Vuelta Atrás (VA) proporciona una manera sistemática de generar todas las posibles soluciones, siempre que dichas soluciones sean susceptibles de resolverse en etapas..

VA se asemeja a un recorrido en profundidad dentro de un árbol de búsqueda, cuya existencia sólo es implícita, ya que sólo haremos uso de su organización (árbol), en que cada nodo de nivel k representa una parte de la solución formada por k etapas que se suponen ya realizadas. Sus hijos son las prolongaciones al añadir una nueva etapa. Para examinar el conjunto de posibles soluciones, basta con recorrer el árbol construyendo soluciones parciales a medida que se avanza en el recorrido. Si el recorrido tiene éxito  Solución (hoja del árbol). Se puede continuar buscando otras soluciones o la mejor de todas ellas o bien parar la búsqueda.

El recorrido no tiene éxito si en alguna de las etapas, la solución parcial construida no se puede completar  Nodo fracaso. En este caso VA retrocederá en el recorrido a uno o más caminos no explorados que puedan conducir a una solución. Es un proceso de “prueba y error”, en el que se va trabajando por etapas, construyendo gradualmente la solución. Esta forma de trabajo “de probar”, crece en cada etapa de forma exponencial por lo que para ciertos problemas debe ser evitado este método de resolución.

La eficiencia de un algoritmo VA proviene de considerar el menor conjunto de nodos que pueden llegar a ser soluciones. Las condiciones a comprobar sobre cada nodo a fin de detectar nodos fracaso deben ser tal que permitan ahorrar tiempo al delimitar el tamaño del árbol a explorar. Esta evaluación requiere un tiempo extra, por lo que deben ser evaluaciones sencillas que no requieren más tiempo en su cálculo que el que nos llevaría analizar la parte del árbol que se puede evitar. Las evaluaciones más costosas se reservan para casos desesperados en que el árbol generado es muy grande.

Búsqueda de soluciones sobre un árbol En general para poder aplicar el método, la solución a nuestro problema debe poder expresarse como una n-tupla (x 1,x 2,...,x n ) donde los x i representan elecciones de algún conjunto finito S i. Es decir, cada componente x i se elige en cada etapa de entre un conjunto finito de valores. Cada etapa es un nivel en el árbol.

Para generar el árbol de búsqueda Descomponer en etapas la solución. Dar significado a cada x i de la n-tupla solución. Dar las opciones posibles en cada etapa, y así estará definida la estructura del árbol a recorrer. El problema consiste, muchas veces, en encontrar los valores de un vector que maximiza, minimiza o satisface una función objetivo.

Ejemplo Ordenar una lista de enteros A(1..n)  función Objetivo: A[x i ]  A[x i+1 ] 1  i  n Los conjuntos finitos S i serán los enteros de 1 a n. La tupla solución sería tal que x i contendría el índice i-ésimo del menor elemento. A[3,1,4,2]  Solución [2,4,1,3] índices de la lista ordenada, lo que significa que el primer elemento es el que se encuentra en la posición 2, y el siguiente el que se encuentra en la posición 4 y así sucesivamente.

En los algoritmos voraces se construye la solución, calculándola a trozos. En P.Dinámica, la solución se construye a partir del P.Optimalidad, que se debe cumplir. Existen numerosos problemas que no pueden resolverse con las técnicas anteriores. Solo queda hacer un estudio exhaustivo del conjunto de posibles soluciones, si es conocido a priori. Vuelta atrás es aplicable a problemas de: Localización: interesa la existencia de una solución o encontrar todas las soluciones. Optimización: interesa la mejor de todas las soluciones.

Forma de trabajo bajo Vuelta Atrás Exploración del conjunto de posibles soluciones de manera metódica y ordenada, intentando dividir dichas soluciones en etapas. Se realiza una descomposición representada en forma de árbol. Donde, Árbol (estructura conceptual no real): Nodo: representa un fragmento de solución que está formada por las k etapas previas ya resueltas. Sucesores: posibles prolongaciones del nodo al añadir una nueva etapa. Para recorrer el conjunto de posibles soluciones basta con recorrer este árbol.

Diferencias con devorador La elección de un sucesor en una etapa no implica su elección definitiva Diferencias con P.Dinámica Son más sutiles En PD cuando todos los subproblemas se resuelven directamente, el estudio directo de todos los casos es en realidad Vuelta Atrás. En PD se almacenan los resultados para no tener que recalcular y en Vuelta Atrás no se puede hacer, pues son muchísimos los casos.

Representación en árbol del proceso de resolución: Los algoritmos VA se aplican a problemas cuyas soluciones se pueden encontrar mediante una búsqueda sistemática, en árbol, entre todas las soluciones posibles.

Pasos Organizar el espacio de soluciones posibles en forma de árbol, para facilitar la búsqueda. Fijar la descomposición en etapas a realizar. Recorrer el árbol: Nodo Solución  Identificar nodos que puedan dar lugar soluciones. Nodo Problema  nodos que pueden dar lugar fragmentos de solución Nodo Fracaso  nodos cuyos descendientes no van a ser solución.

Pasos....  l encontrar un nodo fracaso, retroceder a su antecesor. Si un nodo problema, al explorar se ve que es fracaso, retroceder igualmente. Si un nodo solución se comprueba que no lo es, retroceder igualmente. Para demostrar qué tipo de nodo es cada nodo se realiza el test de chequeo. Los tests de chequeo van a determinar la eficiencia de un algoritmo VA.

Pautas a seguir en los tests de chequeo Buena elección del conjunto de posibles soluciones  la menor posible. Intentar aplicar el test solución antes de llegar a un nodo solución  detectar lo antes posible si estamos en un nodo fracaso, sin explorar su descendencia pues es trabajo inútil. El test debe ser aplicable con la menor cantidad de información. El test debe ser ligero para que no necesite tiempo extra, que supondría una complicación si además no detecta muchos nodos fracaso. Regla General: test sencillos. Los tests sofisticados solo para situaciones desesperadas con árboles gigantescos

Problema de las cuatro (ocho) reinas Consiste en colocar 4 reinas de ajedrez en un tablero 4x4 de forma que no se ataquen Podemos suponer que la reina i, siempre estará en la fila i, con lo que las soluciones serán 4-tuplas [x 1,x 2,x 3,x 4 ] donde x i indica la columna de la reina i. En cada etapa se deben decidir los valores de las x i de la n-tupla. Se puede generalizar a un tablero de nxn

Restricciones para minimizar las posibilidades de cada etapa Si no se supone que la reina i está en la fila i  C 16 4 = 1820 posibles colocaciones S i ={1,2,3,4}, 1  i  4, el espacio de posibles soluciones PR 4 =(4 4 )=256 Exigiendo que: - No puede haber dos reinas en la misma columna - No puede haber dos reinas en la misma diagonal - Entonces espacio de soluciones 4!=24

Si (x,y) posición de reina a  (x’,y’) de reina b No están en diagonal si  x-x’  y-y’  Demostración: En las diagonales de izquierda a derecha, la diferencia entre fila y columna es constante para cada diagonal En las diagonales de derecha a izquierda, la suma de fila y columna es constante para cada diagonal Entonces dos reinas están en diagonal si: x-y=x’-y’  x-x’=y-y’  x+y=x’+y’  x-x’=y’-y Por tanto,  x-x’  =  y-y’  Luego si  x-x’    y-y’  no estarán en la misma diagonal.

Si lo aplicamos al problema de las ocho reinas: C 64 8 = PR 8 = 8 8 = P 8 = 8! = Aplicando las restricciones, en cada etapa k vamos a generar las k-tuplas con posibilidades de ser solución o parte de ella A los nodos del árbol de longitud k en la n- tupla, que se va construyendo y que verifica que es posible solución  k-prometedores Si no se verifica, es un nodo Fracaso;  generamos el árbol (...)

[1,-,-,-] 1 [2,4,1,3] 15 [1,4,3,-] 9 [1,3,4,-] 5 [1,3,2,-] 4 [2,4,-,-] 13 [2,3,-,-] 12 [2,1,-,-] 11 [1,2,-,-] 2 [1,3,-,-] 3 [1,4,-,-] 6 [2,-,-,-] 10 [1,4,2,-] 7 [-,-,-,-] 0 [2,4,1,-] 14 [1,4,2,3] 8 ESTRUCTURA DEL ÁRBOL DE EXPANSIÓN 4x4

Comentarios al árbol construido Se han construido 15 nodos hasta llegar a la solución. Los nodos 2 y 3 son dos nodos fracaso. El 2 porque no cumple una restricción (están en diagonal las reinas 1 y 2). el nodo 3 es debido a sus descendientes, ya que los nodos 4 y 5 son fracaso. En ambos casos es absurdo proseguir buscando por ese camino, por lo que se retrocede en el árbol para buscar por otra opción.

Comentarios al árbol construido.. Al encontrar un nodo hoja se comprobarán las restricciones, y si son ciertas se habría dado con una solución, y no se puede continuar a partir de ellos por ser nodos de nivel n y no se pueden expandir. El nodo 8 podría ser solución, ya que se han colocado las 4 reinas, se tiene la 4-tupla, pero no se cumplen los objetivos [1,4,2,3] porque las reinas 3 y 4 con posiciones [-,-,2,3] están en la misma diagonal. Se trata por tanto de un nodo fracaso.

Esquema general de los algoritmos de VA Inicialización Repetir Estudiar un nodo (test de solución y de fracaso) Si es una solución se puede continuar buscando otra o se puede finalizar Si es un nodo fracaso, se hace VA y si no lo es se buscan sus descendientes Hasta que no queden más nodos por explorar

VA iterativo (BackIter(1)) Función BackIter(n:etapa) k=1 ; T=0etapa, tupla solución Mientras k>0 {Si T[1,...,k] solución Retornar T[1,....,k] Sino { Si T[1,...,k] es Fracaso O k>n { k=k-1 Vuelta Atrás T[k]=SiguienteSucesor(T,k) } Sino { búsqueda de descendientes k=k+1 T[k]=SiguienteSucesor(T,k) } } } Retornar Fracaso

VA recursivo (BackRecur(1,0)) Funcion BackRecur (i: etapa, T: estado) Si T[1,...,i] es Solución Retornar T[1,...,i] Sino Si T[1,...,i] es Fracaso O i=n+1 Retornar Fracaso Sino Para k Sucesores(i,T) T[i+1]=k x=BackRecur(i+1,T) Si x NoFracaso Retornar x Solución FinPara Retorna Fracaso //no hay solución Finsi Asigna a la solución de la nueva etapa T[i+1] el sucesor k como solución

Eficiencia de los algoritmos de VA Es escasa y puede depender de diversos factores: * Número de elementos por etapa. * Tiempo en generar sucesores. * Tiempo en aplicar los test de Solución o de Fracaso.

Mejor caso : Suponiendo que el número de elementos (sucesores) por etapa es k=cte. y que los test son de orden cte., así como la generación de sucesores también constante. Entonces el número de etapas será el tamaño del problema. Tiempo empleado por la versión recursiva O(1) n=1 T(n) = O(1)+k  T(n-1)n>1 sucesores =cte.

Solución a la recurrencia T(n)- k  T(n-1)=1 raíces: k, 1 (x-k)(x-1) T(n)=c 1 k n + c 2 1 n T(n)  (k n ) Que se trata de un tiempo muy desfavorable aunque hemos supuesto las mejores condiciones

Algoritmo de VA Iter para las n reinas Pocedure Reinas(n: nº de reinas) x[1]=0 ; k=1etapa a colocar la reina k Mientras k>0 x[k]=x[k]+1siguiente sucesor Mientras x[k]<=n Y NO Colocada(k) x[k]=x[k]+1 FinMientras Si x[k]<=n Si k=n Retornar x Sino k=k+1; x[k]=0 Finsi Sino k=k-1 Finsi FinMientras

Colocada(k) : devolverá Cierto si la reina de la fila k no ataca a ninguna de las reinas anteriores por columnas o diagonales. Función Colocada(k: nº de reina) Para i=1 hasta k-1 Si x[i]=x[k] O |x[i]-x[k]| = |i-k| Retornar Falso FinSi FinPara Retornar Cierto Se encuentran dos reinas en misma columna o en diagonal

Eficiencia Nº de posibles permutaciones: n! porque cuando tenga colocada una reina habrá 3 posibilidades, cuando tenga 2 habrá 2 posibilidades, etc.. Comprobación de restricciones: O(k) k=nº de reinas a colocar T(n) =  (n·n!) =  (n!)  NP-completo para caso peor y caso medio

VA recursivo para las n reinas Funcion Reinas (k: etapa, T: estado) Si k>n entonces Terminar; T[k]=0 Repetir T[k]=T[k]+1 Si Colocada(k) { Si k  n Reinas(k+1, T) Sino Retornar T Solución Terminar } Hasta T[k] = n

Esquema general para encontrar todas las soluciones Para encontrar todas las soluciones, se altera ligeramente el esquema dado. Una vez que se consigue una solución, se continua buscando hasta agotar todas las posibilidades

Todas las soluciones para las n reinas Procedure ReinasTodas(k:etapa, T:estado) Si k>n entonces terminar T[k] = 0 Repetir T[k] = T[k] +1 Si Colocada(k) { Si k  n ReinasTodas(k+1, T) Sino Retornar T } Hasta (T[k]=n)

VA en problemas de optimización Se buscan todas las soluciones y tras compararlas, se elige la mejor Se escogerá VA cuando sea imposible aplicar otra técnica. Problemas a resolver con VA Tipo combinatorio: problemas cuyas soluciones (si existen) son subconjuntos o permutaciones de un conjunto dado Tipo permutación: en la etapa i se decide cuál es el iésimo elemento y los sucesores Tipo subconjunto: dos enfoques

Tipo subconjunto: dos enfoques: Estudio de la solución. Todos los nodos representan soluciones posibles aplicando el tipo permutación Estudio de los elementos. En cada etapa se fija un elemento y se decide si se incluye o no en la Solución Árbol binario  Nodo Solución(=Hojas) El problema de las n-Reinas es de tipo Permutación Problema optimización  Tipo Subconjunto. Según el caso concreto del problema se resolverá como Estudio solución o Estudio de los elementos, que normalmente es el más adecuado.

Grafos coloreados G es un grafo no dirigido, m un entero positivo Dos problemas a resolver: 1. Descubrir si es posible colorear los nodos de G, usando m colores de manera que 2 nodos adyacentes no tengan el mismo color  Decisión de coloración m. 2. Optimización de coloración m: encontrar el m más pequeño para colorear G con la restricción anterior; m=nº cromático del grafo El grafo es plano si se puede dibujar en un plano sin que se crucen dos arcos

Problema Decisión de coloración de 4-colores para grafos planos. Dado un mapa, ¿Se pueden colorear las regiones de forma que 2 regiones adyacentes no tengan el mismo color, utilizando 4 colores? El mapa se transforma en un grafo  cada región es un nodo, si 2 regiones son adyacentes se unen con un arco

Ejemplo Durante años se supo que con 5 colores se podía colorear cualquier mapa. Después de tiempo y con potentes ordenadores se demostró que con 4 colores bastaba

Problema a resolver Determinar todas las formas diferentes que resultan de colorear un grafo utilizando m colores, con la restricción de que los nodos adyacentes utilicen colores diferentes. Grafo [1..n,1..n] no dirigido, siendo n el nº de nodos Grafo[i,j] = true si (i,j) es un arco de G Grafo[i,j] = false si (i,j) no es un arco de G 1..m : colores

Solución al problema Solución: [x(1),x(2),..., x(n)] Donde tenemos n elementos, uno por nodo y x(i) indica el color del nodo i Árbol obtenido al aplicar VA recursivo Grado m: cada nivel i tiene m sucesores, donde n son los posibles valores de x(i) Altura n+1: los nodos del nivel n+1 son las hojas

Iniciamos el grafo con la adyacencia de los arcos, y X[0,0,0,...,0] Colorear(1)  (...) Funcion Colorear(k:cardinal) k  etapa x[k]=0 nodo a colorear Repetir x[k]=x[k]+1 Si Aceptable(k) Si k<n Colorear(k+1) Sino ComunicarSolucion(x) Finsi Hasta x[k]=m End Colorear Tendría que comprobar que en x se tienen los m colores para comunicarlo como tal, si no es así continuar.

La función Aceptable comprueba la restricción del problema, o sea, que dos vértices o nodos del grafo adyacentes no pueden tener el mismo color. Procedure Aceptable(k:cardinal):booleano Para j=1 hasta k-1 Si g[k,j] Y x[k]=x[j] devolver Falso Fin_para Devolver Verdad End Aceptable

La solución del problema viene dada por x=[x 1, x 2,....,x n ] donde x i es el color del vértice i; k es cada etapa en la que se va asignando un color entre 1 y m al vértice k-ésimo. A x(1),..x(k-1) se les ha asignado valores en el rango 1..m, tal que vértices adyacentes tienen distintos enteros (1..m). Un valor para x(k)  {0,..m}, asignándole el número de color más alto mientras se mantenga la restricción de los vértices adyacentes, particularmente para k. Si ese valor no existe x(k)=0.

Ejemplo: con 4 nodos Generamos el árbol con Coloreado. Cada camino hasta una hoja representa una coloración del grafo usando un máximo de 3 colores. Sólo existen 12 soluciones usando exactamente 3 colores

Nodo1 Nodo2 Nodo3 Nodo4 No han utilizado exactamente 3 colores

Problema de la mochila (0/1) N objetos y mochila de capacidad máxima M. El objeto O i  tiene un peso w i y un valor v i x i : fracción del objeto i, que será x i =0 si no se introduce el objeto, o x i =1 si es introducido. Si se introduce x i  beneficio v i x i Objetivo: llenar la mochila maximizando la ganancia total y sin sobrepasar M, escogiendo objetos de mayor valor: es decir, Max  v i x i tal que  w i x i  M donde w i y x i son positivos.

Etapa k  n-k elementos a incluir, si caben. Para evitar una explosión combinatoria del número de casos, para cada nodo estimaremos si el beneficio máximo en dicho nodo, a obtener es mayor o menor que el beneficio seguro de una solución ya estudiada  si es menor será un nodo fracaso. Cuestiones 1. Ordenar los objetos por densidad de beneficio vi/wi. 2. Para un nodo: resta capacidad a la mochila y una serie de objetos a estudiar. 3. Estimación del beneficio máximo: aplicamos un planteamiento VORAZ al subproblema que queda por resolver

Determinación de Nodo fracaso  función COTA Funcion Cota (q :Peso; v :Valor; k :Etapa; M :Capacidad) v1=v ; p1=qBeneficio y peso acumulado Para i=k+1 hasta n p1=p1+P[i]peso del Objeto i Si p1<M v1=v1+V[i] Sino Retornar (v1+(1-(p1-M)/P[i])*V[i]) Finsi Fin_para Retornar v1 FinCota Para la estimación del beneficio a conseguir, se permite fraccionar

Algoritmo VA de la mochila Beneficio=-1  Inicialmente Para cada nodo, si el beneficio estimado es mayor que el calculado hasta el momento  se estudia generando sus sucesores, sino no se estudia. Esto es una especie de poda de la rama. Un nodo está completo cuando es fracaso o se hayan estudiado todos sus sucesores Se termina cuando está completo el primer nodo Procedure Mochila (...)

Procedure Mochila (M:capacid, n:Objtos, X:soluc) b=-1 beneficio final p=v=0 peso acumulado y valor acumulado k=1 número de objetos a considerar Repetir Mientras k<=n Y p+P[k]<=M introducimos k { v=v+V[k] ; p=p+P[k] Y[k]=1 solución parcial, se incluye obj. k k=k+1 } se pasa al siguiente objeto Si k>n se termina de estudiar el nodo b=v ; X=Y solución final Sino sacar el último objeto si no se puede Y[k]=0 incluir el siguiente objeto Finsi

Finsi si se cumple dar VA Mientras Cota(p,v,k,M) <=b Mientras k  0 Y Y[k]  1 k=k-1 Fin_mientras Si k=0 Retornar b final del algoritmo Sino { Y[k]=0 p=p-P[k] v=v-V[k] } Fin_mientras k=k+1 Siempre Fin Mochila

Complejidad La complejidad temporal no mejora respecto a PD, aunque es mejor la constante multiplicativa. La complejidad espacial disminuye:  PD necesita una tabla.  VA solamente necesita un vector Y. La función COTA permite realizar la poda del árbol para los nodos que no lleven a la solución óptima, haciendo que el coste no sea exponencial

Ejemplo: Mochila con una capacidad W=7 y 3 objetos a introducir en las condiciones: b=-1; p=v=0; k=1; Y[0,0,0] v=9; p=3; Y[1]=1 k=2; Y[2]=0 Cota(3,9,2,7)= O1O1 O2O2 O3O3 V alor 9104 P eso 352 V/P322 [0,0,0] [1,0,0]

El laberinto Laberinto  Tablero nxn. lab[n,n] con 0 (transitable) o  (no transitable). [1,1] y [n,n] son transitables (inicio y final). Cada nodo representa el camino recorrido hasta el momento. En cada casilla del laberinto, indicaremos el orden en el que ha sido visitada Cuando se produce la VA, hay que liberar las casillas ocupadas por el nodo del que volvemos, marcándolos de nuevo a 0. Función Laberinto (...)  busca la 1ª solución.

Funcion Laberinto(k:etpa; fil,col  ; exito:boolean) ord=0; éxito=falso ord  hacia donde se mueve Repetir ord=ord+1; fil=fil+movF[ord]; col=col+movC[ord] Si (fil  1 Y fil  n Y col  1 Y col  n Y lab[fil,col]=0 ) { lab[fil,col]=kmarca como ocupada Si (fil=n Y col=n) exito=Verdad Sino { Laberinto(k+1, fil, col, exito) Si (NO exito) lab[fil,col]=0; } } Sino {fil=fil-movF[ord] col=col-movC[ord] } Hasta exito O orden=4 FinLaberinto Éxito nos dirá si existe solución que se encontrará en lab

Los arrays movF y movC contienen los posibles movimientos y se inicializan con la siguiente función: Funcion MovimientosPosibles; movF[1]=1; movC[1]=0; /*sur*/ movF[2]=0; movC[2]=1; /*este*/ movF[3]=0; movC[3]=-1; /*oeste*/ movF[4]=-1; movC[4]=0; /*norte*/ Fin No hace falta que sea una función, basta con que se inicialice antes de empezar con la llamada Laberinto(2,1,1)

El orden en que se realizan los movimientos es importante; si la casilla destino es la [n,n] y se parte de la [1,1] siempre se tratará de ir hacía la meta, por lo que primero se intenta el sur, luego el este... Si se quiere cambiar el orden en que se construyen los nodos del árbol de expansión, se tendría que modificar la función MovimientosPosibles, invocándola al comienzo del Programa Principal; desde éste mismo se debe realizar la primera llamada a la función Laberinto(). El orden tendría más importancia si se quisiera encontrar la solución más corta. Para esto, el algoritmo debe encontrar todas las soluciones (y no una sola) y quedarse con la mejor.

Funcion Laberinto2(k:etapa ; fil,col) ord=0 Repetir ord=ord+1;fil=fil+movF[ord];col=col+movC[ord] Si (fil  1 Y fil  n Y col  1 Y col  n Y lab[fil,col]=0) lab[fil,col]=k Si (fil=n) Y (col=n) { recorridominimo=k solucion=lab } Sino { Si (k<recorridominimo) Laberinto2(k+1,fil,col)}; PODA lab[fil,col]=0 fil=fil-movF[ord]; col=col-movC[ord] Hasta orden=4 FinLaberinto2

Aunque las podas se realizan en algoritmos de RyP, las cotas para podar se utilizan en cualquier tipo de árbol de expansión. Para no disparar de forma exponencial el árbol de expansión. Disponiendo de un valor alcanzable, se pueden rechazar todos los nodos cuyos valores superen este valor, sean soluciones parciales o totales. En Laberinto2 se ha usado una cota. Se encuentra la primera solución con un determinado valor asociado al número de movimientos hasta encontrar la salida.Es el valor a minimizar.

Las podas evitan realizar trabajo innecesario. La variable recorridominimo es la cota, que se inicializa en el programa principal a  y se invoca a Laberinto2 recorridominimo=  Lab[1,1]=1 Laberinto2(2,1,1) Para los algoritmos de VA, normalmente de complejidad exponencial, se debe aprovechar toda la información disponible sobre el problema o sus soluciones y restricciones para hacerlo lo más eficiente posible.

La asignación de tareas en VA N trabajadores y n tareas. Se desea asignar una tarea a cada persona con un coste asociado tarifa[i,j] (persona i, realiza la tarea j) minimizando el coste de las n tareas. X=[x 1,x 2,...,x n ]  x i : tarea asignada a persona i. En cada etapa se irá asignando una tarea a una persona, comenzando por la persona 1. Restricción: para asignar una tarea a una persona, la tarea no debe haber sido asignada a nadie. Variable mínimo: almacena el mejor valor alcanzado hasta el momento (menor coste) Función Tareas (...)

Funcion Tareas (k:etapa) x[k]=0 Repetir x[k]=x[k]+1 Si Aceptable(k) { Si k<n Tareas(k+1); Sino { c=Coste( ) Nodo hoja Si mínimo>c { mejor=X mínimo=c } } Hasta x[k]=n FinTareas Comprueba las restricciones Calcula el coste de la solución que se ésta generando

Funcion Aceptable(k:etapa): Booleano Para i=1 hasta k-1 Si x[k]=x[i] devolver Falso devolver Verdad FinAceptable Funcion Coste( ):entero suma=0 Para i=1 hasta n suma=suma+Tarifa[i,x[i]) devolver suma FinCoste

En Programa Principal : :::::::::: Tarea(1) DarSolucion(minimo) :::::::::::: Posible mejora Realizar la poda del árbol de expansión eliminando los nodos que no van a llevar a la solución óptima.La variable mínimo puede ser la cota, de manera que se irá almacenando en ella el valor obtenido por la mejor solución, en vez de cuando se llegue a una solución y así se podrá realizar la poda cuanto antes. Función Tareas2 (...)  Mejora

Funcion Tareas2(k:etapa; costeacum: entero) x[k]=0 Repetir x[k]=x[k]+1 coste=costeacum+Tarifa[k,x[k]] Si (Aceptable(k) Y coste  minimo) {Si k<n Tareas2(k+1,coste); Sino { mejor=X minimo=coste } } Sino Pasa a la siguiente opción Hasta x[k]=n FinTareas2 Valor menor, hasta el momento