Laboratorio 10

UNIVERSIDAD NACIONAL DE SAN AGUSTIN
FACULTAD DE INGENIERÍA DE PRODUCCIÓN Y SERVICIOS

ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMA
Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Aprobación: 2022/03/01 Código: GUIA-PRLE-001 Página: 1
INFORME DE LABORATORIO
INFORMACIÓN BÁSICA
ASIGNATURA: Análisis y Diseño de Algoritmos
TITULO DE LA
Algoritmos para grafos: Accesibilidad
PRÁCTICA:
NÚMERO DE NRO.
10 AÑO LECTIVO: 2023 B
PRÁCTICA: SEMESTRE:
FECHA DE HORA DE
30/11/2023 23:59
PRESENTACIÓN PRESENTACIÓN
INTEGRANTE (s)
Gabriel Llerena Morón NOTA (0-20)
Jorge Escobedo Ocaña
DOCENTE(s):
René Nieto
RESULTADOS Y PRUEBAS
I. EJERCICIOS RESUELTOS:
1. Permutación de vecinos. Repite los ejemplos C y D anteriores suponiendo que el grafo G está
representado por las siguientes listas de adyacencia:
0: 2 3 4
1:
2: 1 4
3: 4 5
4: 1 5
5: 1
Para decidir si el vértice 5 está al alcance del vértice 0, invocamos la función GRAPHreach() con
argumentos (G,0,5). Cada fila de la tabla siguiente registra el momento en que un arco es
recorrido. A continuación, registra la correspondiente invocación de reachR():
Llamada Invocación de reachR() Estado de visited[]
0 reachR(G, 0) 1-----
0-3 reachR(G, 3) 1--1--
3-4 reachR(G, 4) 1--11-
4-1 reachR(G, 1) 11-11-


4-5 reachR(G, 5) 11-111
3-5 reachR(G, 5) 11-111
0-4 reachR(G, 4) 11-111
0-2 reachR(G, 2) 111111
2-4 reachR(G, 4) 111111
2-1 reachR(G, 1) 111111
El estado final del vector visited[] muestra que todos los vértices están al alcance de 0.
Esta vez, queremos decidir si 3 está al alcance de 2. A continuación se muestra el trazado de la

ejecución de reachR() con argumentos (G,2,3):
Llamada Invocación de reachR() Estado de visited[]
2 reachR(G, 2) --1---
2-4 reachR(G, 4) --1-1-
4-1 reachR(G, 1) -11-1-
4-5 reachR(G, 5) -11-11
5-1 reachR(G, 1) -11-11
2-1 reachR(G, 1) -11-11
En este estado final, podemos observar que los vértices alcanzables desde el vértice 2 son 1, 4 y 5,
pero el vértice 3 no está marcado. Por lo tanto, según esta ejecución, el vértice 3 no está al alcance
del vértice 2.
2. Versión ansiosa de la función. Escriba una variante de la función GRAPHreach() que se detenga
inmediatamente (y devuelva true) al descubrir que t está al alcance de s. (El código de reachR()
para esta variante es más complicado que el de la versión ansiosa discutida anteriormente). Para
hacer el ejercicio más interesante, imprime un camino de s a t antes de devolver true.
#include <iostream>
#include <vector>
#include <stack>

using namespace std;
// Definición de tipo de dato para representar el grafo como lista de adyacencia
typedef vector<vector<int>> Graph;
// Función auxiliar reachR() para la búsqueda en profundidad
bool reachR(const Graph& G, int v, int t, vector<int>& visited, stack<int>& path) {
visited[v] = 1;
path.push(v);
if (v == t) {
// Almacena los elementos de la pila en un vector para imprimir el camino en

orden correcto
vector<int> pathVector(path.size());
int index = path.size() - 1;
while (!path.empty()) {
pathVector[index--] = path.top();
path.pop();
// Imprimir el camino de s a t en orden inverso
cout << "Camino de " << pathVector.front() << " a " << t << ": ";
for (int vertex : pathVector) {
cout << vertex << " ";
cout << endl;
return true;
for (int w : G[v]) {
if (visited[w] == 0) {
if (reachR(G, w, t, visited, path)) {
return true; // Si t está al alcance, detener inmediatamente
}

path.pop(); // Deshacer la selección si no encontramos el camino a t desde este

vértice
return false;
// Función GRAPHreach() (variante ansiosa)
bool GRAPHreachAnxious(const Graph& G, int s, int t) {
int n = G.size();
vector<int> visited(n, 0);
stack<int> path;
return reachR(G, s, t, visited, path);
int main() {
// Construcción del grafo
Graph G = {
{3, 4, 2},
{},
{1, 4},
{4, 5},
{1, 5},
{1}
};
// Vértices de inicio y destino
int start = 0;
int target = 4;
// Verificar si el vértice target está al alcance del vértice start de manera

ansiosa
bool result = GRAPHreachAnxious(G, start, target);
// Imprimir resultado
if (result) {
cout << "El vértice " << target << " está al alcance del vértice " << start
<< ".\n";
} else {

cout << "El vértice " << target << " no está al alcance del vértice " <<
start << ".\n";
}
return 0;
}
Ejecución:
[Running] cd "d:\Yo\Celeste\" && g++ Lab09.cpp -o Lab09 &&
"d:\Yo\Celeste\"Lab09
Camino de 0 a 4: 0 3 4
El vértice 4 está al alcance del vértice 0.
[Done] exited with code=0 in 0.76 seconds
3. Vértice central y vértice popular. Esbozar un algoritmo que decida si un grafo G dado tiene un
vértice r con la siguiente propiedad: todos los vértices de G están al alcance de r. Esbozar un
algoritmo que decida si un grafo G dado tiene un vértice que está al alcance de todos los demás.
Vértice Central:
1. Para cada vértice v en el grafo, calcula la suma de las longitudes de los caminos más cortos
desde v a todos los demás vértices utilizando, por ejemplo, el algoritmo de Dijkstra.
2. Encuentra el vértice r que minimiza esta suma. Si hay más de un vértice que cumple con esto,
selecciona cualquier vértice de ellos.
3. Verifica si la suma calculada para r es finita y mayor que cero. Si es así, entonces r es un vértice
central.
Vértice Popular:
1. Para cada vértice v en el grafo, verifica si todos los demás vértices son alcanzables desde v.
Puedes hacer esto usando la función GRAPHreach que hemos discutido anteriormente.
2. Si encuentras un vértice r desde el cual todos los demás vértices son alcanzables, entonces r es
un vértice popular.
Pseudocódigo:
Algoritmo Vértice Central:

Entrada: Grafo G
Salida: Vértice central r (si existe)

r_min = NULL
min_sum = INFINITO
Para cada vértice v en G:

suma = 0
Para cada vértice u en G:
Calcular la longitud del camino más corto desde v hasta u (por ejemplo, usando Dijkstra)
suma += longitud_del_camino
Si suma < min_sum:
min_sum = suma
r_min = v
Si min_sum es finito y mayor que cero:

Devolver r_min como vértice central
Sino:
No hay vértice central
---
Algoritmo Vértice Popular:

Entrada: Grafo G
Salida: Vértice popular r (si existe)
Para cada vértice v en G:

popular = true
Para cada vértice u en G:
Si v != u y no es alcanzable desde u:
popular = false
Romper el bucle interno
Si popular:
Devolver v como vértice popular
No hay vértice popular
CONCLUSIONES
Los conceptos de búsqueda en grafos, representación de grafos, algoritmos recursivos como DFS y
optimización con Dijkstra son fundamentales para comprender la estructura y conectividad en grafos.
La identificación de vértices centrales y populares proporciona una visión clave de la centralidad y
accesibilidad en un grafo, con aplicaciones directas en campos como redes sociales y logística. Estos

conceptos subrayan la importancia de diseñar algoritmos eficientes para abordar problemas del
mundo real.
METODOLOGÍA DE TRABAJO
REFERENCIAS Y BIBLIOGRAFÍA

Laboratorio 10

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Laboratorio 10

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD NACIONAL DE SAN AGUSTIN

FACULTAD DE INGENIERÍA DE PRODUCCIÓN Y SERVICIOS

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Llamada Invocación de reachR() Estado de visited[]

0-3 reachR(G, 3) 1--1--

3-4 reachR(G, 4) 1--11-

4-1 reachR(G, 1) 11-11-

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

4-5 reachR(G, 5) 11-111

3-5 reachR(G, 5) 11-111

0-4 reachR(G, 4) 11-111

0-2 reachR(G, 2) 111111

2-4 reachR(G, 4) 111111

2-1 reachR(G, 1) 111111

Esta vez, queremos decidir si 3 está al alcance de 2. A continuación se muestra el trazado de la

Llamada Invocación de reachR() Estado de visited[]

2-4 reachR(G, 4) --1-1-

4-1 reachR(G, 1) -11-1-

4-5 reachR(G, 5) -11-11

5-1 reachR(G, 1) -11-11

2-1 reachR(G, 1) -11-11

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

using namespace std;

// Definición de tipo de dato para representar el grafo como lista de adyacencia

typedef vector<vector<int>> Graph;

// Función auxiliar reachR() para la búsqueda en profundidad

bool reachR(const Graph& G, int v, int t, vector<int>& visited, stack<int>& path) {

// Almacena los elementos de la pila en un vector para imprimir el camino en

int index = path.size() - 1;

// Imprimir el camino de s a t en orden inverso

for (int vertex : pathVector) {

cout << vertex << " ";

cout << endl;

for (int w : G[v]) {

if (reachR(G, w, t, visited, path)) {

return true; // Si t está al alcance, detener inmediatamente

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

path.pop(); // Deshacer la selección si no encontramos el camino a t desde este

// Función GRAPHreach() (variante ansiosa)

bool GRAPHreachAnxious(const Graph& G, int s, int t) {

vector<int> visited(n, 0);

return reachR(G, s, t, visited, path);

// Construcción del grafo

// Vértices de inicio y destino

// Verificar si el vértice target está al alcance del vértice start de manera

bool result = GRAPHreachAnxious(G, start, target);

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

El vértice 4 está al alcance del vértice 0.

[Done] exited with code=0 in 0.76 seconds

Algoritmo Vértice Central:

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Para cada vértice v en G:

Si min_sum es finito y mayor que cero:

Algoritmo Vértice Popular:

Para cada vértice v en G:

No hay vértice popular

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

También podría gustarte