![En el primer ejemplo tenemos una serie de elementos únicos,
cada uno con un volumen ocupado, y cada elemento nos da cierta
ganancia. Disponemos de una capacidad limitada, por lo que debemos
seleccionar aquellos que nos den la mayor ganancia posible.
Si tenemos n elementos disponibles, numerados de 0 a n-1 y dos arreglos,
uno p[n] que indica el peso de cada elemento y g[n] que indica la ganancia
que nos da el elemento, M indica la carga máxima que podemos llevar,
finalmente el código queda de la siguiente manera:
int carga ( int* g, int* p, int* sol, int M) {
int pos = 0; // Posicion actual en la recorrida de elementos.
int ganancia = 0; // Ganancia parcial acumulada.
int m_ganancia = 0; // Mejor ganancia encontrada
int disponible = M; // Espacio disponible restante.
int restante = 0; // Ganancia restante disponible
int * parcial = new int[n]; // Marcaremos con 1 si llevamos al i, o con 0 en caso contrario
for (int i=0; i<n; i++) {
parcial[i] = 0; // Inicializamos en cero los eltos elegido.
restante += g[i]; // Ganancia de los elementos restantes, para la poda.
}
Back(g, p, parcial, ganancia, m_ganancia, disponible, restante, pos, sol);
delete[] parcial;
return m_ganancia;
}](https://image.slidesharecdn.com/backtracking-210331005138/85/Backtracking-Metodo-de-Vuelta-Atras-7-320.jpg){kind=tracking}
![En el tercer ejemplo tenemos un tablero de ajedrez de tamaño NxN, y se
trata de colocar en él N reinas de manera que no se amenacen según las
normas del ajedrez.
proc NReinas (↕[1 . . . i ]: TSolución, ↓N: N, ↑ok: B)
variables j : N
inicio
si i=N entonces ok=CIERTO
en otro caso
ok=FALSO
j=1
mientras ¬ok ^ (j≤N) hacer
si EsFactible (R, j) entonces
R[i + 1]= j
NReinas (R, N, ok)
finsi
j=j+1
finmientras
finsi
fin
func EsFactible (↓R[1 . . . i ]: TSolución, ↓j : N): B
variables factible: B
inicio
factible=CIERTO
k=1
mientras factible ^ (k≤i) hacer
si (j=R[k])/(i+1−k= |j−R[k]|)
entonces
factible=FALSO
finsi
k=k+1
finmientras
devolver factible](https://image.slidesharecdn.com/backtracking-210331005138/85/Backtracking-Metodo-de-Vuelta-Atras-9-320.jpg){kind=tracking}
![Consiste en buscar todas las soluciones del problema, de esta manera
tendremos que recorrer el árbol de estados por completo; tal algoritmo
sería:
proc Bactracking Enum(↕X[1 . . . i ]: TSolución, ↑num: N)
variables L: ListaComponentes
inicio
si EsSolución (X) entonces num num+1
EscribeSolución (X)
en otro caso
L Candidatos (X)
mientras ¬Vacía (L) hacer
X[i + 1] Cabeza (L); L Resto (L)
BacktrackingEnum (X, num)
finmientras
finsi
fin](https://image.slidesharecdn.com/backtracking-210331005138/85/Backtracking-Metodo-de-Vuelta-Atras-10-320.jpg){kind=tracking}
Backtracking (Método de Vuelta Atrás)
- 1. Estructura de Datos II SAIA A Alumno: Enmanuel Carvalho Profesora: Yakirana Barrios
- 2. La más antigua referencia al Backtracking, es la historia de Ariadna en la antigua mitología griega; en dicha historia el padre de Ariadna, que era el rey Minos de Creta proyectaba su poder sobre su isla y por conquista sobre Atenas, el tributo que pedía el rey a los atenienses consistía en obligar a grupos de jóvenes que entraran a su laberinto donde habitaba el Minotauro para que de esta manera murieran a manos del mismo. Sin embargo Ariadna se enamoró de héroe ateniense Teseo, el cual fue dispuesto a entrar al laberinto, la princesa le regaló un ovillo de hilo dorado para que no se perdiera en el laberinto, la intención era que Teseo desenrollara el ovillo a medida que avanzara por el laberinto, de manera que si llegaba a un callejón sin salida tenía que volver atrás y enrollar el hilo hasta llegar al punto donde había escogido dicho camino para intentar otra ruta, en esta ocasión la técnica del Backtracking funcionó, Teseo puto asesinar al Minotauro y escapar del laberinto. Por otra parte el termino «Backtrack» fue acuñado por primera vez por el matemático estadounidense D. H. Lehmer en 1950
- 3. La idea principal de backtracking se refleja muy parecido a un recorrido en profundidad dentro de un grafo dirigido, dicho grafo suele ser un árbol, o en su defecto no contiene ciclos; sea cual sea su estructura, existe sólo implícitamente, lo que se busca principalmente del recorrido es encontrar soluciones para algún problema, lográndose construyendo soluciones parciales a medida que progresa el recorrido; estas soluciones parciales limitan las regiones en las que se puede encontrar una solución completa, finalmente el recorrido culmina con éxito si, procediendo de esta forma, se puede definir por completo una solución. El algoritmo en cuestión puede detenerse o seguir buscando soluciones alternativas; el recorrido no finaliza con éxito si en alguna de las etapas la solución parcial construida hasta el momento no se puede completar. En dicho caso el recorrido vuelve atrás exactamente igual que en un recorrido en profundidad, eliminando sobre la marcha los elementos que se hubieran añadido en cada fase.
- 4. Existen diversos problemas que deben satisfacer un determinado tipo de restricciones, los mismos son problemas completos, en donde el orden de los elementos de la solución ejerce importancia; dichos problemas consisten en un conjunto de variables a la que a cada una se le asigna un valor que está sujeto a las restricciones del problema. Como dijimos anteriormente, la técnica backtracking va creando todas las posibles combinaciones de elementos para obtener una posible solución, su virtud principal es que en la mayoría de las implementaciones nos podemos ahorrar combinaciones innecesarias, estableciendo funciones de acotación o poda y reduciendo así el tiempo de ejecución.
- 5. Una variedad de heurísticas son ampliamente utilizadas para que de esta manera el proceso sea mas eficiente, al poder procesar las variables en cualquier orden, por lo general es más rápido intentar ser lo más restrictivo posible con las primeras; dicho proceso poda el árbol de búsqueda antes de que se tome la decisión y se llame a la subrutina recursiva. Muchas implementaciones mas innovadoras utilizan una función de cotas, que examina si es posible o no encontrar una solución a partir de una solución parcial. Por otra parte se comprueba si la solución parcial que falla puede elevar significativamente la eficiencia del algoritmo. Con la implementación de estas funciones de cota, se debe ser muy minucioso en su uso de manera que sean poco eficientes computacionalmente, ya que lo más común es que se ejecuten para cada nodo o paso del algoritmo, debemos tener también en cuenta que las cotas eficaces se crean de forma parecida a las funciones heurísticas.
- 6. Un ejemplo típico en el que se puede aplicar método de vuelta atrás son los laberintos, en los cuales debemos escoger el camino correcto para así poder llegar a la meta, si elegimos un camino incorrecto debemos Volver atrás y escoger otro camino aleatorio que nos lleve hasta el final. El Sudoku es otro ejemplo, en el cual debemos rellenar las 9 casillas de los 9 bloques que originalmente trae el juego con 9 números distintos del 1 al 9 en cada fila y columna, en caso de que se cometa algún error y se repita un numero en alguna fila o columna debemos Volver atrás.
- 7. En el primer ejemplo tenemos una serie de elementos únicos, cada uno con un volumen ocupado, y cada elemento nos da cierta ganancia. Disponemos de una capacidad limitada, por lo que debemos seleccionar aquellos que nos den la mayor ganancia posible. Si tenemos n elementos disponibles, numerados de 0 a n-1 y dos arreglos, uno p[n] que indica el peso de cada elemento y g[n] que indica la ganancia que nos da el elemento, M indica la carga máxima que podemos llevar, finalmente el código queda de la siguiente manera: int carga ( int* g, int* p, int* sol, int M) { int pos = 0; // Posicion actual en la recorrida de elementos. int ganancia = 0; // Ganancia parcial acumulada. int m_ganancia = 0; // Mejor ganancia encontrada int disponible = M; // Espacio disponible restante. int restante = 0; // Ganancia restante disponible int * parcial = new int[n]; // Marcaremos con 1 si llevamos al i, o con 0 en caso contrario for (int i=0; i<n; i++) { parcial[i] = 0; // Inicializamos en cero los eltos elegido. restante += g[i]; // Ganancia de los elementos restantes, para la poda. } Back(g, p, parcial, ganancia, m_ganancia, disponible, restante, pos, sol); delete[] parcial; return m_ganancia; }
- 8. En el segundo tenemos un conjunto finito U y una familia de subconjuntos {Tj} de U definimos una matriz A donde cada fila se corresponde con un elemento ui de U y cada U pertenece a Tj y∈columna de A con un subconjunto Tj . Ponemos aij=1 si ui aij=0 en caso contrario. Interpretamos que xj=1 significa que elegimos Tj y 0 en caso contrario. Se trata de averiguar si es factible Ax=1 donde A y x son binarias y las componentes de 1 son unos. S0= un vector de ceros (raíz del árbol) Cada nodo S del árbol es una sucesión x cuyas primeras k componentes le han sido asignados un 1 o un 0 y el resto de componentes son ceros. Reemplazamos S por 2 subproblemas Si (i=1,2) poniendo xk+1 =1 y xk+1=0 respectivamente; el código nos queda: if Ax=1 STOP if Ax>1 DROP Si if Ax<1 add Si to A
- 9. En el tercer ejemplo tenemos un tablero de ajedrez de tamaño NxN, y se trata de colocar en él N reinas de manera que no se amenacen según las normas del ajedrez. proc NReinas (↕[1 . . . i ]: TSolución, ↓N: N, ↑ok: B) variables j : N inicio si i=N entonces ok=CIERTO en otro caso ok=FALSO j=1 mientras ¬ok ^ (j≤N) hacer si EsFactible (R, j) entonces R[i + 1]= j NReinas (R, N, ok) finsi j=j+1 finmientras finsi fin func EsFactible (↓R[1 . . . i ]: TSolución, ↓j : N): B variables factible: B inicio factible=CIERTO k=1 mientras factible ^ (k≤i) hacer si (j=R[k])/(i+1−k= |j−R[k]|) entonces factible=FALSO finsi k=k+1 finmientras devolver factible
- 10. Consiste en buscar todas las soluciones del problema, de esta manera tendremos que recorrer el árbol de estados por completo; tal algoritmo sería: proc Bactracking Enum(↕X[1 . . . i ]: TSolución, ↑num: N) variables L: ListaComponentes inicio si EsSolución (X) entonces num num+1 EscribeSolución (X) en otro caso L Candidatos (X) mientras ¬Vacía (L) hacer X[i + 1] Cabeza (L); L Resto (L) BacktrackingEnum (X, num) finmientras finsi fin
- 11. La técnica de Ramificación y poda o conocida en ingles como Branch & Bound se deriva del Backtracking, generalmente se interpreta como un árbol de soluciones en la cual cada rama nos lleva a una posible solución posterior a la actual. Debemos tomar en cuenta que la característica que diferencia esta técnica con respecto a otras anteriores es que el algoritmo se ocupa de detectar en qué ramificación las soluciones dadas ya no están siendo óptimas, para podar así como su nombre lo indica esa rama del árbol que no nos está siendo de utilidad y no seguir malgastando recursos y procesos en casos que se alejan de la solución óptima. La meta general es encontrar el valor mínimo de una función f(x) donde fijamos x rangos sobre un determinado conjunto S de posibles soluciones.