UNIVERSIDAD DE LAS FUERZAS ARMADAS-ESPE SEDE SANTO

DOMINGO
DEPARTAMENTO DE CIENCIAS DE LA COMPUTACIÓN - DCCO-SS

CARRERA DE INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

PERIODO : octubre 2021 – febrero 2022

ASIGNATURA : Estructura de datos

TEMA : Back Tracking

NOMBRES : Luis Vásquez

NIVEL-PARALELO : Tercero “A”

DOCENTE : Ing. Luis Ortiz

FECHA DE ENTREGA : 8 de febrero de 2022

SANTO DOMINGO - ECUADOR

2022
Índice

1 Introducción ................................................................................................................................................ 2
2 Sistemas de Objetivos .............................................................................................................................. 2
2.1 Objetivo General: .............................................................................................................................. 2
2.2 Objetivos Específicos: ..................................................................................................................... 2
3 Desarrollo ..................................................................................................................................................... 3
4 Conclusiones ............................................................................................................................................... 5
5 Recomendación .......................................................................................................................................... 6
6 Bibliografía/ Referencias/ páginas web........................................................................................... 6

1 Introducción
Back tracking (Vuelta atrás) es una técnica de programación para hacer búsqueda
sistemática a través de todas las configuraciones posibles dentro de un espacio de
búsqueda. Para lograr esto, los algoritmos de tipo back tracking construyen posibles
soluciones candidatas de manera sistemática. En general, dado una solución candidata s:

1. Verifican si s es solución. Si lo es, hacen algo con ella (depende del problema).
2. Construyen todas las posibles extensiones de s, e invocan la mayoría de las veces

recursivamente al algoritmo con todas ellas. A veces los algoritmos de tipo back tracking
se usan para encontrar una solución, pero otras veces interesa que las revisen todas (por
ejemplo, para encontrar la más corta). Supondremos que una solución se puede modelar
como un vector 𝑎 = (𝑎1, 𝑎2 , . . . , 𝑎𝑛 ), donde cada elemento 𝑎𝑖 esta tomado de un conjunto
ordenado finito 𝑆𝑖 .

• Representamos a una solución candidata como un vector 𝑎 = (𝑎1 , . . . , 𝑎𝑘 ).

• Las soluciones candidatas se extenderán agregando un elemento al final.

2 Sistemas de Objetivos

2.1 Objetivo General:

1. Resolver el ejercicio de sumatoria de subconjuntos planteado a través de la

algoritmia del Back Tracking.

2.2 Objetivos Específicos:

1. Realizar práctica y análisis de la técnica Back Tracking.

2. Crear las distintas funciones que permitan validar la Solución.
3 Desarrollo
Resolver el siguiente ejercicio utilizando la algoritmia de Back Tracking:
Dado 𝑛 números de un conjunto que cumplen 𝑛 ∈ ℝ+ , donde los subconjuntos son 𝑤𝑖 e
𝑖 ∈ (0, 𝑛 − 1) y un numero 𝑀 se trata de encontrar todos los subconjuntos de 𝑤𝑖 cuya
suma sea 𝑀
Ejemplo:
𝑛=4
(𝑤0 , 𝑤1 , 𝑤2 , 𝑤3 ) = (11, 13, 24, 7)
Subconjuntos buscados: (11, 13, 7) 𝑦 (24, 7).
Las soluciones se las pueden representar como (𝑥0 , 𝑥1 , … 𝑥𝑘 ) donde 𝑘 ∈ (0, 𝑛 − 1)
Restricciones:

• Si 𝑖 ≠ 𝑗 entonces 𝑥𝑖 ≠ 𝑥𝑗 (No debe haber dos 𝑥𝑖 iguales)

• La suma de los correspondientes 𝑤𝑖 debe dar como resultado 𝑀
• Como (1, 2, 4) y (1, 4, 2) representan una misma solución hay que añadir una
restricción adicional para que solo se imprima una solución.

Solucion:
Para validar las restricciones se crearon dos funciones, una que nos permitirá validar si
dicha solución encontrada ya existe, y otra función que nos permite retorna un valor
entero correspondiente al sumatorio de una lista de enteros, esta ultima función servirá
para validar si ya hemos encontrado la solución, luego de ello se creó una función llamada
BackTracking la cual está Diseñada para llamarse asimismo hasta encontrar las
soluciones.

Funciones Validadoras:
public static int Suma(List<int> sol)
{
int sum = 0;
foreach (int item in sol)
{
sum = sum + item;
}
return sum;
}

public static Boolean existeSolucion(List<int> solucion, List<List<int>> soluciones)

{
foreach (List<int> items in soluciones)
{
if (solucion.Count == items.Count)
{
 Boolean ver = true;
foreach (int item in items)
{
ver = solucion.Contains(item) && ver;
}
if (ver)
{
return ver;
}
}
}
return false;
}

Función para imprimir el solución:

public static void prinList(List<int> lista)
{
Console.Write("[ ");
for (int i = 0; i < lista.Count; i++)
{
if (i == lista.Count - 1)
{
Console.Write(lista[i] + " ]");
}
else
{
Console.Write(lista[i] + ", ");
}
}
Console.WriteLine();
}

Función encarga de la recursividad del Back Tracking

public static void BackTracking(int k, List<int> solucionActual, List<int>
elementos, int M, List<List<int>> soluciones)
{
//Se valida que se haya llegado a una solución no obtenida antes
if (Suma(solucionActual) == M && !existeSolucion(solucionActual, soluciones))
{
Console.WriteLine("Solución: ");
prinList(solucionActual);
soluciones.Add(solucionActual.ToList());
}
else
{
for (int i = k; i < elementos.Count; i++)
{
//Se valida el proximo elemento a sumar sea menor o igual a M
if (Suma(solucionActual) + elementos[i] <= M)
{
solucionActual.Add(elementos[i]);
BackTracking(k + 1, solucionActual, elementos, M, soluciones);
solucionActual.Remove(elementos[i]); //PODA
}
}
}
}
TEST DE FUNCIONALIDAD:
public static void Main(string[] args)
{
Console.BackgroundColor = ConsoleColor.DarkBlue;
Console.Clear();
Console.WriteLine("BackTrancking!");
//Conjunto de elementos:
List<int> w = new List<int>() { 11, 13, 24, 7 };
//Resultado al que se pretende llegar sumando los subconjuntos:
int M = 31;
//Lista donde se guardará la solución actual:
List<int> solucionActual = new List<int>();
//Lista donde se guardarán todas las soluciones:
List<List<int>> soluciones = new List<List<int>>();
//Indice K:
int k = 0;
//Llamda a la función encargada del BackTrack:
BackTracking(k, solucionActual, w, M, soluciones);
}

Ejecución:

4 Conclusiones

• Una de las formas de entender la algoritmia del BackTracking en ejecución es a

través de un árbol de decisiones donde cada nodo es una llamada a la función
recursiva encargada del BackTracking, y las aristas son las decisiones que se
pueden tomar, de esta manera los recorridos del árbol que cumplan con la
condiciones y restricciones impuestas serán las posibles soluciones.

• La técnica de BackTracking está muy asociada a la recursividad, o más

propiamente, a la estructura recursiva de la mayoría de tipos de datos: listas,
árboles, etc. Esta técnica consiste básicamente en: Enumerar sistemáticamente las
alternativas que existen en cada momento para dar con la solución a un problema.
Se prueba una alternativa, guardando memoria del resto de alternativas. Si no
 damos con la solución, podemos dar marcha atrás (BackTracking) y probar otra
alternativa.

5 Recomendación

• Antes de sumergirnos a programar primero debemos plantearnos dos preguntas:

¿Qué debemos hacer? y ¿Cómo debemos hacerlo? Y tampoco está de más hacer el
boceto de un diagrama de flujo, así reducimos la pérdida de tiempo a la hora de
programar.
• Registrarse en https://es.stackoverflow.com/ ya que aquí encontraras muchos
programadores expertos que te pueden echar una mano en caso de no saber cómo
escribir tu código o como solucionar algún problema.

6 Bibliografía/ Referencias/ páginas web

Laboratorio 3.2: Back Tracking. (s. f.). Recuperado 8 de febrero de 2022, de

https://classroom.google.com/u/0/c/NDEyNDQxNTExNzI1/a/NDU0NTg0NzQx

MTky/details?hl=es