UNIVERSIDAD NACIONAL DEL ALTIPLANO

FACULTAD DE
INGENIERA MECNICA ELCTRICA, ELECTRNICA Y SISTEMAS
ESCUELA PROFESIONAL DE INGENIERA DE SISTEMAS

TRABAJO ENCARGADO DE
BUSQUEDA EN PROFUNDIDAD
CURSO

: LABORATORIO DE INTELIGENCIA ARTIFICIAL

ALUMNA

: APAZA QUISPE, Thalia Melania

SEMESTRE

: 8vo semestre

Puno Per
2012

BUSQUEDA EN PROFUNDIDAD (DEPTH-FIRST SEARCH)

1. MARCO TEORICO
Depth-First Search, o sea, recorrido en profundidad. A partir de un
vrtice, comienza por alguno de sus vecinos, luego un vecino de este,
y as sucesivamente hasta llegar a un vrtice que ya no tiene vecinos
sin visitar. Sigue entonces por algn vecino del ltimo vrtice visitado
que aun tiene vecinos sin visitar.
Igual que en BFS, si al analizar quedan vrtices sin visitar, se repite a
partir de un vrtice no visitado.

2. PROPIEDADES

Al igual que BFS, este algoritmo puede modificarse para calcular

las componentes conexas de un grafo y/o su cantidad.
El grafo en si puede no estar totalmente almacenado, pero tener
una descripcin implcita que permita generar bajo demanda los
vecinos de un vrtice. Un ejemplo tpico de este caso es cuando
el grafo es el rbol de posibilidades de un problema de bsqueda
exhaustiva. El recorrido DFS es el que se utiliza habitualmente
para hacer backtracking, ya que permite encontrar algunas
soluciones rpido y usarlas para podar" (es decir, no recorrer)
ciertas ramas del rbol.

3. CDIGO FUENTE
3.1.
DESCRIPCIN

Este pequeo ejemplo utiliza la bsqueda en profundidad para hallar

los posibles caminos de un grafo desde un nodo origen hacia un nodo
destino mediante el Backtraking.

3.1.1.

BUSQUEDA EN PROFUNDIDAD

Esta bsqueda en profundidad se hace mediante una bsqueda

recursiva.
void dfs( int u ){
( first )? printf("%d" , u ) : printf("->%d" , u );
first = false;
visitado[ u ] = true;
for( int v = 0 ; v < ady[ u ].size(); ++v ){
if( !visitado[ ady[ u ][ v ] ] ){
dfs( ady[ u ][ v ] );
}
}
}

3.1.2.

BACKTRAKING

void dfs_allPath( int u , int fin ){

visitado[ u ] = true;
if( u == fin ){
first = true;
for( int i = 1 ; i <= V ; ++i ){
if( !visitado[ i ] )continue;
( first ) ? printf("%d" , i ) : printf("->%d" , i );
first = false;
}
printf("\n");
}
for( int v = 0 ; v < ady[ u ].size(); ++v ){
if( !visitado[ ady[ u ][ v ] ] ){

dfs_allPath( ady[ u ][ v ] , fin );

}
}
visitado[ u ] = false;
}

3.2. Cdigo fuente

#include <stdio.h>
#include <vector>
using namespace std;
#define MAX 500
vector<int> ady[ MAX ]; //lista de adyacencia
bool visitado[ MAX ]; //para nodos visitados
int V;
///Ver todo el recorrido del grafo de acuerdo al orden ingresado en la lista de
adyacencia
bool first;
void dfs( int u ){
( first )? printf("%d" , u ) : printf("->%d" , u );
first = false;
visitado[ u ] = true;
for( int v = 0 ; v < ady[ u ].size(); ++v ){
if( !visitado[ ady[ u ][ v ] ] ){
dfs( ady[ u ][ v ] );
}
}
}
///Ver todos las rutas posibles partiendo de nodo inicial y llegando a uno final, usamos
backtracking
void dfs_allPath( int u , int fin ){
visitado[ u ] = true;
if( u == fin ){
//si se llego al final imprimimos ese path
first = true;
for( int i = 1 ; i <= V ; ++i ){
if( !visitado[ i ] )continue;
( first ) ? printf("%d" , i ) : printf("->%d" , i );
first = false;
}
printf("\n");
}
for( int v = 0 ; v < ady[ u ].size(); ++v ){
if( !visitado[ ady[ u ][ v ] ] ){
dfs_allPath( ady[ u ][ v ] , fin );
}
}
//parte para backtracking, aquellos nodos hoja ya que no poseen adyacentes o ya
fueron visitados
visitado[ u ] = false;
//marcamos como no visitado para usarlo
posteriormente en otro path
}
int main(){
printf("********************************************************* \n");
printf("***Algoritmo: Depth First Search Recursivo - Backtracking \n");
printf("***Algoritmo: Busqueda en profundidad \n");
printf("***Autor: APAZA QUISPE Thalia Melania \n");
printf("********************************************************* \n");
printf("\n");
int E , x , y, inicial , final;

printf("Ingrese el numero de vertices y el numero de aristas \n");

scanf("%d %d" , &V , &E );
//Numero de vertices y numero de aristas
printf("Ingrese el origen y destino de cada nodo \n");
for(int i = 1 ; i <= E ; ++i ){
scanf("%d %d" , &x , &y ); //Origen y destino
ady[ x ].push_back( y );
ady[ y ].push_back( x );
}
first = true;
//Veremos todo el recorrido del grafo iniciando en el vertice ingresado
printf("Nodo raiz: ");
scanf("%d" , &inicial );
memset( visitado , 0 ,sizeof( visitado ) );
printf("Recorrido DFS de todo el grafo\n");
dfs( inicial );
printf("\n\n\n");
//Veremos posibles rutas de nodo inicial a uno final
memset( visitado , 0 , sizeof( visitado ) );
//inicializar a no visitado
printf("Posibles Rutas de inicial a final usando Backtracking\n");
printf("Nodo Final: ");
scanf("%d" , &final );
dfs_allPath( inicial , final );
//posibles rutas de nodo inicial a final
system("PAUSE");
return EXIT_SUCCESS;
}

4. EJEMPLO

5. EJEMPLO COMPILADO