Ingeniería en Sistemas Computacionales

Materia:
Análisis y Diseño de Algoritmos Avanzado

Unidad U7:
Uso de la estrategia de árboles para la búsqueda

Participación en Foro.

Alumno:
Dirk Hans Krakaur Floranes
A0119461845

Facilitador:
Dr. Luciano Sustaita Roque.

23 de Febrero de 2021
 Análisis y Diseño de Algoritmos Avanzado
Unidad VII: Uso de la estrategia de árboles para la búsqueda
Participación en Foro

Aspecto 1: ¿Cuáles son los beneficios de utilizar la técnica ramificación y poda en el

entorno laboral?

Ramificación y poda, también conocido como BB, B&B o BnB, por sus siglas en ingles
(Branch and Bound) es un algoritmo diseñado para resolver problemas de optimización
discretos y combinatoriales, así como optimización matemática.

Un algoritmo de ramificación y poda consiste en una enumeración sistemática de las

soluciones candidatas mediante la búsqueda de un espacio de solución optimo: se considera
que el conjunto de soluciones candidatas forma un árbol en el que hay que determinar las
mejores soluciones de acuerdo con una serie de parámetros predefinidos

El algoritmo explora las ramas de este árbol, que representan subconjuntos del conjunto de
soluciones. Antes de enumerar las soluciones candidatas de una rama, la rama se
comprueba con límites estimados superiores e inferiores en la solución óptima y se descarta
si no puede producir una solución mejor que la mejor encontrada hasta ahora por el
algoritmo.

El algoritmo depende de una estimación eficiente de los límites mencionados en las ramas
del espacio de búsqueda. Si no hay límites disponibles, el algoritmo degenera en una
búsqueda exhaustiva.

El método fue propuesto por primera vez por Ailsa Land y Alison Doig mientras realizaban
investigaciones en la Escuela de Economía de Londres, patrocinadas por la British
Petroleum en 1960 para la programación discreta, y se ha convertido en la herramienta más
utilizada para resolver problemas de optimización np-complejos.

El nombre Ramificación y poda, surgió cuando se estaba aplicando por primera vez al
problema del agente viajero, mismo que se resolverá más adelante.

www.udavinci.edu.mx
 Análisis y Diseño de Algoritmos Avanzado
Unidad VII: Uso de la estrategia de árboles para la búsqueda
Participación en Foro

Aspecto 2: Explica tres situaciones donde se utilice la estrategia de árboles para

búsqueda.

1.- Asignación de tareas

Se refiera a la asignación de trabajos en tal forma que se reducen al mínimo los costos de
asignación. Puede resolverse de manera eficiente aplicando la estrategia de ramificar y
podar. El problema se plantea de esta forma:

Considere un conjunto de personas P = {P1, P2,.., Pn} ordenado linealmente, donde P1

<P2 <…< Pn. Puede imaginarse que el ordenamiento de las personas es determinado
por algún criterio como estatura, edad, antigüedad, etc. También se considera un
conjunto de trabajos J = {J1, J2,…, Jn}, de los cuales se supone que están
parcialmente ordenados. A cada persona puede asignarse un trabajo. Sean las
personas Pi y Pj, a quienes se asignan los trabajos f(Pi) y f(Pj), respectivamente. Se
requiere que si f(Pi)≤f(Pj), entonces Pi ≤ Pj. La función f puede interpretarse como una
asignación factible que mapea personas en sus trabajos idóneos. También requiere
que si i ≠ j, entonces f(Pi) ≠ f(Pj).

2.- El problema del rompecabezas de 8 piezas

La técnica de ramificación y poda puede aplicarse en el problema del rompecabezas

de ocho piezas, debido a que éste consiste en iniciar con un tablero de 3x3, donde hay 8
piezas enumeradas, así como un espacio que está vacío, y solo se pueden desplazar las
piezas numeradas mediante movimientos en sentido vertical u horizontal, haciendo uso de la
casilla vacía. El propósito del rompecabezas es mostrar las piezas en un orden o
configuración predeterminada. Este problema se puede abordar por la técnica B&B,
expandiendo las opciones mediante un árbol solución y se resuelve cuando se alcanza el
nodo que representa la configuración deseada, es decir, se acota la búsqueda de la solución
proporcionando hacer más eficiente el proceso de resolver dicho problema.

www.udavinci.edu.mx
 Análisis y Diseño de Algoritmos Avanzado
Unidad VII: Uso de la estrategia de árboles para la búsqueda
Participación en Foro

3.- El problema del agente viajero

Este problema también se puede resolver mediante la estrategia de búsqueda de

ramificar y podar, y consta de dos partes: por un lado, hay una forma de dividir el espacio y
por otro, hay formas de pronosticar una cota inferior para una clase de soluciones y de
encontrar una cota superior que ofrezca una solución óptima.

Así mismo, este problema se define gráficamente o en puntos planos, por lo que la
estrategia de ramificar y podar divide la solución en dos grupos: un grupo que incluye un arco
particular y otro grupo que excluye este arco.

Cada división incurre en una cota inferior y el árbol de búsqueda se atravesará con
dicha cota (Lee, Tseng, Chang, Tsai, 2014)

Considerar este problema fue muy útil, pues de acuerdo con la asignación, se tiene
que resolver a continuación

Aspecto 3: Desarrolla el programa que permita resolver el siguiente problema

Se conocen las distancias entre un cierto número de ciudades. Un

viajante debe, a partir de una de ellas, visitar cada ciudad
exactamente una vez y regresar al punto de partida habiendo
recorrido en total la menor distancia posible. Más formalmente,
dado un grafo g conexo y ponderado, y dado uno de sus vértices
v0, queremos encontrar el ciclo Hamiltoniano de costo mínimo
que comienza y termina en v0.

www.udavinci.edu.mx
 Análisis y Diseño de Algoritmos Avanzado
Unidad VII: Uso de la estrategia de árboles para la búsqueda
Participación en Foro

Código Fuente:

/*
* Este programa encuentra una ruta óptima para recorrer ciudades y volver a la inicial.
Por Hans Krakaur, para la clase de Análisis y diseño de algoritmos avanzado,
En la carrera de Ingeniería en Sistemas Computacionales de la Universidad Da Vinci
*/
package foro7algo;

import java.util.Scanner;

public class Foro7_Algoritmos{

public static void main(String[] args) {

RutaOptima();
}
static void RutaOptima()
{
int[][] ruta=new int[15][2];
Datos datos = new Datos();
Scanner entrada=new Scanner(System.in);

System.out.println("Proporcione el número de ciudades a visitar: ");

datos.numCiudades= entrada.nextInt();

obtenerDatos(datos);
buscarRutaOptima(datos, ruta);
imprimirRutaOptima(ruta, datos.numCiudades);

static void obtenerDatos(Datos datos)

{
Scanner entrada=new Scanner(System.in);
int i, j;

System.out.println("Proporcione la distancia en kilometros de las siguientes trayectorias

entre ciudades: ");

for (i = 0; i < (datos.numCiudades); i++)

{
datos.G[i][i] = 0;

for (j = i + 1; j < (datos.numCiudades); j++)

{

www.udavinci.edu.mx
 Análisis y Diseño de Algoritmos Avanzado
Unidad VII: Uso de la estrategia de árboles para la búsqueda
Participación en Foro

System.out.printf("Ciudad %d a Ciudad %d : ", i+1, j+1);

datos.G[i][j]=entrada.nextInt();
datos.G[j][i] = datos.G[i][j];
}
}
}

static void buscarRutaOptima(Datos datos, int[][] r)

{
int i, inicio, indice_del_menor=0;
Scanner entrada=new Scanner(System.in);

System.out.println("¿En cuál ciudad inicia su ruta?");

inicio = entrada.nextInt();

r[0][0] = inicio;

inicio--;

for (i = 0; i < (datos.numCiudades); i++)

{
if(i == 0)
{
indice_del_menor = buscarEnFila(datos, inicio, r);
quitarCiudadesVisitadas(datos, r, indice_del_menor, false);
}
else
{
if (i == (datos.numCiudades) - 2)
{
indice_del_menor = buscarEnFila(datos, indice_del_menor, r);
quitarCiudadesVisitadas(datos, r, indice_del_menor, true);
}
else
{
indice_del_menor = buscarEnFila(datos, indice_del_menor, r);
quitarCiudadesVisitadas(datos, r, indice_del_menor, false);
}
}
}
}

static int buscarEnFila(Datos datos, int inicio, int[][] r)

{
int j, menor = 999999, indice_del_menor=0;

www.udavinci.edu.mx
 Análisis y Diseño de Algoritmos Avanzado
Unidad VII: Uso de la estrategia de árboles para la búsqueda
Participación en Foro

for (j = 0; j < (datos.numCiudades); j++)

{
if ( (datos.G[inicio][j]) != 0 )
{
if ( (datos.G[inicio][j]) < menor )
{
menor = datos.G[inicio][j];
indice_del_menor = j;
}
}
}

guardarCiudad(r ,indice_del_menor);
guardarValor(r, menor);

return indice_del_menor;
}

static void guardarCiudad(int[][] r , int indice_del_menor)

{
int i, numCiudades_visitadas;

i= 0;
numCiudades_visitadas = 0;

while(r[i][0] != 0)
{
i++;
numCiudades_visitadas++;
}

r[numCiudades_visitadas][0] = indice_del_menor + 1;
}

static void guardarValor(int[][] r, int menor)

{
int i, numCiudades_visitadas;

i=0;
numCiudades_visitadas = 0;

while(r[i][1] != 0)
{
i++;

www.udavinci.edu.mx
 Análisis y Diseño de Algoritmos Avanzado
Unidad VII: Uso de la estrategia de árboles para la búsqueda
Participación en Foro

numCiudades_visitadas ++;
}

r[numCiudades_visitadas][1] = menor;
}

static void quitarCiudadesVisitadas(Datos datos, int[][] r, int indice_del_menor, boolean

penultimo)
{
int i, numCiudades_visitadas, aux;

i = 0;
numCiudades_visitadas = 0;

while(r[i][1] != 0)
{
i++;
numCiudades_visitadas++;
}

if (penultimo == true)
{
for (i = numCiudades_visitadas; i >= 1; i--)
{
aux = r[i][0];
aux = aux - 1;
datos.G[indice_del_menor][aux] = 0;
}
}
else
{
for (i = numCiudades_visitadas; i >= 0; i--)
{
aux = r[i][0];
aux = aux - 1;
datos.G[indice_del_menor][aux] = 0;
}
}
}

static void imprimirRutaOptima(int[][] ruta, int n)

{
int i, total;

total = sumarTrayectorias(ruta, n);

www.udavinci.edu.mx
 Análisis y Diseño de Algoritmos Avanzado
Unidad VII: Uso de la estrategia de árboles para la búsqueda
Participación en Foro

System.out.printf("Una ruta óptima sería: ");

for (i = 0; i < n + 1; i++)

{
if (i == n)

System.out.printf(" %d\n", ruta[i][0]);

else
System.out.printf(" %d , ", ruta[i][0]);
}

System.out.printf("Total de kilometros recorridos: ");

for (i = 0; i < n; i++)

{
if (i == n-1)

System.out.printf(" %d = %d\n\n", ruta[i][1],total);

else
System.out.printf(" %d +", ruta[i][1]);
}
}

static int sumarTrayectorias(int[][] r, int n)

{
int i, total=0;

for (i = 0; i < n; i++)

total += r[i][1];

return total;
}
}

class Datos{
int[][] G= new int[15][15];
int numCiudades;
}

/*
Nota: En esta ocasión preferí poner el código fuente en texto, ya que facilita su ejecución en un
compilador si en algún momento fuera necesario.

*/

www.udavinci.edu.mx
 Análisis y Diseño de Algoritmos Avanzado
Unidad VII: Uso de la estrategia de árboles para la búsqueda
Participación en Foro

Pantalla de salida:

Referencias:

Joyanes Aguilar, L. y Zahonero Martínez, I. (2011). Programación en Java: algoritmos,

programación orientada a objetos e interfaz gráfica de usuarios. Distrito Federal: McGraw-Hill
Interamericana.

Lee, R., Tseng, S., Chang, R., & Tsai, Y. (2014). Introducción al diseño y análisis de
algoritmos – Un enfoque estratégico. Ed. Madrid: McGraw-Hill Interamericana.

www.udavinci.edu.mx