UNIVERSIDAD NACIONAL MAYOR DE

SAN MARCOS
(Universidad del Perú, Decana de
América)

FACULTAD DE INGENIERIA DE SISTEMAS E INFORMÁTICA

E.A.P. INGENIERIA DE SISTEMAS

MATEMÁTICAS DISCRETAS - G3

BACKTRACKING

PROFESOR: Quinto Pazce, Daniel Alfonso

INTEGRANTES:

 Condori Quispe, Ronald Martín 15200113

 Fernandez Tuni, Juan Mateo 15200167
 Huayllacayan Loarte, Jose Antonio 15200022
 Huiza Navarro, Hans Edu 15200023
 Medina Flores, Juan Diego Valentino 15200129
 Mejía Supo, Jeferson Armando 15200131
 Molina Soto, Lesli Lisbeth 15200132
 Quispe Cruz , Alex Bruno 15200034
 Quispe Huamani, Arnold Elpidio 15200176
 Rios Mendoza, Erick Junior 15200145
 Tacca Moran, Jean Franco 14200040
 [Algorítmica II] [UNMSM]

ÍNDICE
INTRODUCCIÓN ............................................................................................................................. 3
ESTUDIOS PREVIOS........................................................................................................................ 4
NATURALEZA Y APLICACIÓN ......................................................................................................... 6
PROBLEMA GENERAL ................................................................................................................... 6
DESARROLLO DEL ALGORITMO ..................................................................................................... 8
CONCLUSIÓN ............................................................................................................................... 12

2
 [Algorítmica II] [UNMSM]

INTRODUCCIÓN

 Estrategia para encontrar soluciones a problemas con restricciones

definidos sobre espacios discretos (de elevado tamaño).
 Construye soluciones parciales progresivamente, las cuales deben cumplir
las restricciones del problema.
 El recorrido (en profundidad) tiene éxito si, procediendo de esta forma, se
puede definir por completo una solución (en una hoja de un árbol de
recursión). Puede detenerse al encontrar una solución o seguir hasta
encontrar todas.
 Si en alguna etapa la solución parcial construida hasta el momento no se
puede completar, se vuelve atrás deshaciendo la solución parcial, hasta un
punto donde puede seguir explorando posibles soluciones.
 Es un método de “fuerza bruta” pero “inteligente”

BÚSQUEDA EN RETROCESO

algoritmo BackTracking(ent k:entero;

entsal X:vector[1..n]de valor)
{Pre: X[1..k-1] es completable}
variable v:valor
para todo v en Ci hacer
X[k]:=v;
si completable(X,k) entonces
si Sol(X,k) entonces
guardar(X,k)
fsi;
si k<n entonces
BackTracking(k+1,X)
fsi;
fsi
fpara

La llamada inicial es:

...
BackTracking(1,X);
...

3
 [Algorítmica II] [UNMSM]

ESTUDIOS PREVIOS

Vuelta atrás (Backtracking) es una estrategia para encontrar soluciones a

problemas que satisfacen restricciones. El término "backtrack" fue acuñado por
primera vez por el matemático estadounidense D. H. Lehmer en la década de
1950.

El backtracking fue concebida por Lehmer como una estrategia usada para
encontrar soluciones a problemas que poseen solución completa Estos
problemas consisten en un conjunto (o lista) de variables a la que a cada una
se le debe asignar un valor sujeto a las restricciones del problema. La técnica
va creando todas las posibles combinaciones de elementos para obtener una
solución. Su principal virtud es que en la mayoría de las implementaciones se
puede evitar combinaciones, estableciendo funciones de acotación (o poda)
reduciendo el tiempo de ejecución.

La idea inicial de backtracking se asemeja a un recorrido en profundidad dentro

de un grafo dirigido. El grafo en cuestión suele ser un árbol, o por lo menos no
contiene ciclos. Sea cual sea su estructura, existe sólo implícitamente.
El objetivo del recorrido es encontrar soluciones para algún problema. Esto se
consigue 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.

El recorrido tiene éxito si, procediendo de esta forma, se puede definir por
completo una solución. En este caso el algoritmo puede bien detenerse (si lo
único que se necesita es una solución del problema) o bien seguir buscando
soluciones alternativas (si deseamos examinarlas todas).
Por otra parte, el recorrido no tiene éxito si en alguna etapa la solución parcial
construida hasta el momento no se puede completar.

En tal 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. Cuando vuelve a un nodo que tiene uno o más vecinos
sin explorar, prosigue el recorrido de una solución.

4
 [Algorítmica II] [UNMSM]

El backtracking está muy relacionado con la búsqueda combinatoria. De

manera más exacta podemos indicar que los problemas a considerar son los
siguientes:

1. Problemas de Decisión:

Búsqueda de las soluciones que satisfacen ciertas restricciones.

2. Problemas de Optimización:

Búsqueda de la mejor solución en base a una función objetivo.

Podemos visualizar el funcionamiento de una técnica de backtracking como la

exploración en profundidad de un grafo.Cada vértice del grafo es un posible
estado de la solución del problema. Cada arco del grafo representa la
transición entre dos estados de la solución (la toma de una decisión).

Los problemas que deben satisfacer un determinado tipo de restricciones son

problemas completos, donde el orden de los elementos de la solución no
importa. Estos problemas consisten en un conjunto (o lista) de variables a la
que a cada una se le debe asignar un valor sujeto a las restricciones del
problema

5
 [Algorítmica II] [UNMSM]

NATURALEZA Y APLICACIÓN
Esencialmente, la idea es encontrar la mejor combinación posible en un
momento determinado, por eso, se dice que este tipo de algoritmo es
una búsqueda en profundidad. Durante la búsqueda, si se encuentra una
alternativa incorrecta, la búsqueda retrocede hasta el paso anterior y toma la
siguiente alternativa. Cuando se han terminado las posibilidades, se vuelve a la
elección anterior y se toma la siguiente opción (hijo [si nos referimos a un
árbol]). Si no hay más alternativas la búsqueda falla. De esta manera, se crea
un árbol implícito, en el que cada nodo es un estado de la solución (solución
parcial en el caso de nodos interiores o solución total en el caso de los nodos
hoja).

Normalmente, se suele implementar este tipo de algoritmos como un

procedimiento recursivo. Así, en cada llamada al procedimiento se toma una
variable y se le asignan todos los valores posibles, llamando a su vez al
procedimiento para cada uno de los nuevos estados. La diferencia con
la búsqueda en profundidad es que se suelen diseñar funciones de cota, de
forma que no se generen algunos estados si no van a conducir a ninguna
solución, o a una solución peor de la que ya se tiene. De esta forma se ahorra
espacio en memoria y tiempo de ejecución

Vuelta atrás se usa en la implementación de los lenguajes de

programación tales como Lenguaje de programación Planner y Prolog.
Además, se usa en los análisis sintácticos de los compiladores. Su uso
en inteligencia artificial ha sido muy importante, dando lugar a nuevos tipos de
búsquedas como el A estrella.

PROBLEMA GENERAL

 Se trata generalmente de problemas de optimización, con o sin

restricciones.
 La solución es expresable en forma de secuencia de decisiones.

6
 [Algorítmica II] [UNMSM]

 Existe una función denominada factible que permite averiguar si una

secuencia de decisiones, la solución en curso actual, viola o no las
restricciones.
 Existe una función, denominada solución, que permite determinar si una
secuencia de decisiones factible es solución al problema planteado.

Backtracking es un esquema que de forma sistemática y organizada, genera y

recorre un espacio que contiene todas las posibles secuencias de decisiones.

Este espacio se denomina el espacio de búsqueda del problema, el espacio de

soluciones.

7
 [Algorítmica II] [UNMSM]

DESARROLLO DEL ALGORITMO

Se desarrollará el algoritmo mediante el ejemplo del laberinto.

REPRESENTACIÓN DEL LABERINTO

En el caso estudiado de un laberinto cuadrado es más que evidente que una
representación matricial es acertada. Pero cuando queremos recorrer el
laberinto esta representación no es de utilidad, en base a esto surge la
necesidad de ver otra representación para el análisis del problema. Si
observamos con atención la geometría del camino del laberinto y lo sacamos
de su estructura podemos ver que este es análogo a un árbol.

8
 [Algorítmica II] [UNMSM]

El algoritmo de backtracking no especifica una forma de representar o

almacenar el camino que se está recorriendo dado que la utilidad de este es
encontrar la salida solamente. Para este caso, se consideró que es importante
tener una representación almacenada del resultado de la función que resuelve
el laberinto, dado que esto nos permitirá recorrer una y otra vez el laberinto sin
volver a ejecutar la función. Para ello se utilizó un árbol multicamino, el cual
permite 3 grados de libertad, que van a permitir movernos en 3 direcciones a
partir de la posición en la que estamos parados. La estructura del nodo del
árbol está compuesta por las coordenadas X e Y las cuales representa el nodo
en el laberinto, un puntero al nodo padre el cual permitirá recorrer el camino de
forma inversa, y 3 punteros a los posibles nodos hijos. En el programa el tipo
nodo se define como:

Implementación del Algoritmo

En esta implementación tenemos que recorrer un laberinto, que como ya vimos
antes puede ser análogamente representado como un árbol, en el cual
debemos explorar los caminos y volver hacia atrás cuando nos encontramos
sin salida, hasta llegar a un punto en que podamos tomar un camino alternativo
aun no explorado y recorrer este; en el proceso se repite sucesivamente hasta
llegar al punto deseado.

Dónde:

k: En el seudocódigo, es el número de elemento del arreglo, en el caso del

laberinto caso va a representar la ubicación en el árbol.

9
 [Algorítmica II] [UNMSM]

Es_Solucion() Retorna verdadero o falso si el argumento es una solución

posible, en nuestro caso solo será verdadero cuando se llegue al fin del
laberinto.

Procesar_Solucion(): Depende del problema, en este caso sería terminar la

búsqueda, ya que se encontró la solución.

Encontrar_Sucesores(): Es una función que, dado un candidato, genera todos

los candidatos que son extensiones de este, es decir los caminos que puedo
tomar a partir de esta celda.

Terminar: es una variable global booleana inicialmente es falsa, que establece

la condición de terminar la búsqueda dado determinados casos (ej.: Número
máximo de iteraciones).

Algoritmo implementado en el programa:

En los casos planteados se toma como posición inicial las coordenadas (1,1)
siendo esta la que representa al inicio del laberinto, por ende, se toma como
final del laberinto a la esquina opuesta, al llegar a esta la función se deja de
llamarse recursivamente y retorna el ultimo nodo. La función
cargar_posibles_caminos es vital para el funcionamiento del programa, esta se
encarga de verificar en qué dirección se puede seguir caminando en base a la
posición actual y al paso anterior que realizamos. Cada vez que una celda
vecina esta libre y se puede avanzar hacia ella, esta función asigna memoria y
crea un nuevo nodo en función de los datos actuales y lo almacena en una de
las ramas del nodo actual.

10
 [Algorítmica II] [UNMSM]

Una vez cargados los caminos posibles, cada rama del nodo actual representa
un camino que seguir, entonces se evalúan una a una mediante la misma
función de backtracking. El hecho que la función retorne el último elemento del
árbol, el cual representa el fin del laberinto hace posible que a partir de este se
recorra el árbol de forma inversa y se pueda construir un nuevo árbol de forma
muy simple eliminando los demás nodos que no pertenecen a la solución.

Naturaleza del problema y su aplicación

La función de un cajero de banco es fundamental para un correcto

funcionamiento de la institución bancaria ya que estos aseguran de que cada
transacción sea realizada de forma adecuada, teniendo en cuenta la seguridad
para garantizar que la solicitud del usuario se realice sin ningún problema.

Por ello este proyecto para cajero tiene la función para entregar dinero con
menos número de billetes y monedas que posea el cajero, para que el usuario
no tenga que llevar tantos billetes y/o monedas consigo, siendo más eficiente
su función satisfaciendo las necesidades del usuario.

Así que para la elaboración de este proyecto tenemos el empleo del

“Backtracking”, ya que con la ayuda de este podemos encontrar la menor
cantidad de billetes y/o monedas del banco haciendo retrocesos hasta
encontrar la restricción requerida; es decir, el billete y/o moneda requerida
hasta completar el monto pedido por el usuario.

11
 [Algorítmica II] [UNMSM]

Este proyecto se puede usar para los cajeros automáticos que vemos hoy en
día en diferentes zonas de ciudades en cada país e incluso en diferentes
supermercados y así poder llevar más dinero en pocos billetes y/o monedas
volviéndose más cómodo y menos pesado su uso

Como ya hemos dicho anteriormente en algunas ocasión es los algoritmos de

backtracking no son eficientes , ya que se basan en el método de prueba y
error, y en muchas ocasiones para conseguir solución se tiene que recorrer
todo el árbol de búsqueda o gran parte de él. También tendremos que achacar
que la recursividad contribuye a su ineficiencia, por la memoria que gasta
durante las diferentes llamadas recursivas.
Ahora bien hay que decir que la eficiencia depende de:
El número de nodos del árbol de búsqueda que se visitan para conseguir la
solución →v(n).
El trabajo realizado en cada nodo, esto es, el coste de la función de solución
completa o ver si la solución es aceptable hasta el momento. Este coste lo
podemos expresar como →p(n), ya que generalmente será polinómico.
El coste en general será: O(p(n)v(n)), este coste será exponencial en el peor
caso.

CONCLUSIÓN
El backtracking es un esquema algorítmico que nos va a permitir resolver una
gran variedad de tipos de problemas, pero, por término medio, es sumamente
costoso (en cuanto a complejidades temporales se refiere) debido al tamaño
que adoptan sus espacios de búsqueda. Aplicándole una serie de mejoras
podremos conseguir que dicho espacio mengue para reducir en lo posible las
altas complejidades que suelen tener.

12