GRAFOS

ESTRUCTURAS DE DATOS

COMPONENTES CONEXAS

De un grafo no dirigido

Componentes
conexas: entre ellas
son conexas

Se pude saber si es conexo

Si no lo es se pueden conocer sus

Componentes Conexas

Conjunto W, de vrtices del grafo

En el cual hay camino desde cualquier V1 a cualquier V2

Donde V1 y V2 pertenecen a W

CONEXO
A

B
C

E
D

B
C

E
D

No
CONEXO

ALGORTIMO:
DETERMINAR
CONEXIN
Si entre todos los vrtices, hay camino

Un recorrido desde cualquier vrtice

Visitara a TODOS los vrtices del grafo

Si no

Tendremos una componente conexa

Conjunto de vrtices recorrido

Para descubrir otras

Repetir recorrido desde un vrtice no visitado

Hasta que todos los vrtices hayan sido visitados

EJEMPLO
A

E
D

Recorrido desde E
C

B
C

Recorrido desde E
B

Conjunto recorridos =
Conjunto de Vertices
Es CONEXO

Componen
te Conexa
W1

Recorrido desde B Componen

te Conexa
B
A
W2

IMPLEMENTACION

No olvidar: Luego
de recorrer,
obtendremos un
conjunto de vertices
LRecorrido

bool ComponentesConexas(Grafo G, LSE *LComponentes){

Vertice *V;
LSE *LRecorrido;
Las componentes
while(TRUE){
forman una Lista
V = BuscarVerticeNoVisitado(G);
de Listas
if(!V) break;
LRecorrido = RecorrerAnchura(G,*V);
LSE_InsertarNodoFin(LComponentes,
LSE_CrearNodo(LRecorrido));
}
if(LComponentes->header == LComponentes->last) return TRUE;
return FALSE;
}

COMPONENTES
FUERTEMENTE
CONEXAS
De un grafo DIRIGIDO

Se puede saber si es FUERTEMENTE CONEXO

Si no lo es se pueden conocer sus

Componentes Fuertemente Conexas

Conjunto W, de vertices del grafo
En el cual hay camino desde cualquier V1 a cualquier V2
Donde V1 y V2 pertenecen a W

No
CONEXO
C

B
H

4
Componente
s

5
6

F
S

CONEXO

ALGORITMO

Dado un Vo, se desea conocer

Si D interseccion A = V entonces

Los vertices a los que se puede llegar (D)

Los vertices que llegan a Vo (A)
Hay camino entre cualquier par de vertices
Fuertemente conexo

Si no

Tendremos una componente conexa

Conjunto de vertices recorrido

Para descubrir otras

Repetir recorrido desde vertice que no sea elemento de una C.F.C.

Hasta que todos los vertices esten en C.F.C

EJEMPLO

B
H

F
S
C

W=DA

B
H

W <> V,
Componente F.C.

F
S

1) Recorrer desde
H (Descendientes)

1) Recorrer desde B
(Descendientes)
D= B

D= H

2) Invertir
Direcciones
3) Recorrer desde B
(Ascendientes)
A= B

W2 =
{H}

W1 = {B, C, S}

3) Recorrer desde
H (Ascendientes)
S

A= H

W3 = {F}

1) Recorrer desde
F (Descendientes)
S

D= F

3) Recorrer desde
F (Ascendientes)
A= FH

PUNTOS DE
ARTICULACION
En un grafo no dirigido conexo

Existen vertices que si se eliminan

Desconectan al Grafo

Lo dividen en componentes conexas

Estos vertices clave

Si un grafo no tiene P.A.

Son puntos de articulacion

Es biconexo

La conectividad de un grafo

Es el numero de nodos que se necesitan eliminar

Para dejar a un grafo desconectado

EJEMPLO
A

B
C

Puntos de
Articulacion

E
F

ARBOL DE EXPANSION

Para poder calcular los P.A. de un grafo

Hay que obtener el arbol de expansion

Este se obtiene

A partir del Recorrido en Profundidad

Ejemplo

C
F

C
D

E
F

Arco en Retroceso:
Cuando se quiere
visitar un nodo que
ya ha sido visitado y
no es el padre

COMO REPRESENTAR EL
ARBOL DE EXPANSION

Un arbol en expansion

Si no tomamos en cuenta los

Arcos en Retroceso

La representacion depende del Grafo

No es un arbol binario
Cada Vertice puede tener 0, 1 o n hijos
Si sabemos que CADA VERTICESOLO TIENE UN PADRE

Matriz de Ady -> Usar un arreglo o

Lista de Ady -> Una lista

La representacion mostrar

Quien es el padre de cada nodo

ARBOL DE EXPANSION
CON MATRIZ DE ADY.

Los vertices del grafo

Se encuentran en un arreglo

Cada indice del arreglo

Representa un vertice

Ej: A 0, B 1, etc

Al representar el arbol de expansion

El padre(indice) de cada nodo

Puede almacenarse en un arreglo

typedef struct TVertices{

Generico V[MAX];
int nvertices;
}Vertices;

Que tambien represente a los vertices

int Padres[MAX];

0 1

A B

ARBOL DE EXP. CON LISTA

DE ADYACENCIA
B

Se encuentran en una lista

Cada nodo

Los vertices del grafo

Representa un vertice

Al representar el arbol de expansion

De cada nodo de esta lista

Solo nos interesa conocer al padre

Se puede aadir un dato al nodo vertice

Un enlace con el padre

typedef struct Vertice{

Generico Informacion;
Vertice *padre;
Lista *LArcos;
}Vertice;

B
C
D
E
F

ALGORITMO: ENCONTRAR
P.A.

A cada vertice numerarlo

1 ,1

A es P.A.

De acuerdo al recorrido
Se obtiene Num(v)

2 ,2

A c/vertice, calcular Bajo(v)

Minimo entre

Num(v) se calcula
a medida que se
genera el Arbol
de Expansion

Para calcular
Bajo(v), se
necesita bajar
hasta conocer los
Bajos(hijos de v)

Min(1, --, 2)

P.A. son

La raiz si tiene >= 2 hijos

Vertices para los cuales

Algun Bajo(hijo de v) >= Num(v)

Min(3, --, 3)
4 ,3

Min(2, --, --)

Num(v)
Num(arco_retroceso de v)
Bajo(hijos de v)

C es P.A.

3,3

Min(4, ---, 3)

F
5 ,3
E

Min(5, ---, 3)

6 ,3
B

Min(6, 3,
----)

CAMBIOS EN EL ARBOL

Tanto Num(v) como Bajo(v)

Deben ser parte ahora de la estructura

Del arbol

typedef struct TVertices{

typedef struct Vertice{

Generico V[MAX];

Generico Informacion;

int Padres[MAX];

int Num, Bajo;

int Num[MAX];

Vertice *padre;

int Bajo[MAX];

Lista *LArcos;

int nvertices;
}Vertices;

}Vertice;

COMO IMPLEMENTAR??

Primero

Que representacion se usara?

Si es M.A.

Si es L.A.

Usar Arbol de Expansion como un tipo aparte

Usar Grafo para trabajar con Arbol de Exp.

Luego

Recorrer el grafo

Para llenar Num y enlazar a los padres

Calcular Bajo

Y con esta informacion decidir cual es punto de art.

IMPLEMENTACION
CALCULAR NUM y PADRES
//Al recorrer, llenar Num y enlazar con los padres
void RecorrerParaArbol(Grafo G, Vertice *V, int *vez){
int i;
Al vertice de origen, marcar como
vistado y contarlo, hay que llevar
LSE_nodo *p;
rastreo del aumento del contador
V->visitado = TRUE;
*vez++;
((Vertice *)(p->G))->Num = *vez;
for(p = V->LA->header; p!=NULL; p= p->sig){
if(!((Vertice *)(p->G))->Visitado){
RecorrerParaArbol(G, p->G, vez);
((Vertice *)p->G)->padre = V;
}
}

IMPLEMENTACION
CALCULAR BAJO

//Para calcular el Bajo de Vorigen, calcular Bajo de los hijos(en

recorrido9
//Es decir, recorrer otra vez el grafo para poder bajar x el mismo
void CalcularBajo(Grafo G, Vertice *V ){ Antes de llamar a esta funcion, el
grafo debe de volver a quedar como si
int i;
no se hubiese recorrido antes
LSE_nodo *p;
Vertice *Ad;
V->visitado = TRUE;
Calcular el
V->Bajo = V->Num;
bajo del hijo,
for(p = V->LA->header; p!=NULL; p= p->sig){
si es menor
Ad = Generico_ObtenerVertice(p->G);
que el actual,
if(!Ad->Visitado){
cambiarlo
CalcularBajo(G, Ad);
Si ya fue
if(Ad->Bajo < V->Bajo) V->Bajo = A->Bajo;
visitado y no es
}else if(V->padre!=Ad)
el padre: arco
if(Ad->Num < V->Bajo) V->Bajo = Aden retroceso
>Num;
}

EJERCICIO

Escriba una funcion que dado un Grafo permita

conocer los puntos de Articulacion del mismo

Recuerde que los P.A. son vertices