TEORIA DE GRAFOS

Integrantes: Dukakis Muoz Mara Valdivia C.I 20286789 C.I 1504188

SIN-501

DEFINICION DE ARBOL

Un rbol es un grafo simple unidireccional G que satisface alguna de las siguientes condiciones equivalentes:

G es conexo y no tiene ciclos . G no tiene ciclos y, si se aade alguna arista se forma un ciclo. G es conexo y si se le quita alguna arista deja de ser conexo. Dos vrtices cualesquiera de G estn conectados por nico camino simple.

un

Si G tiene muchos vrtices, n, entonces las definiciones anteriores son tambin equivalentes a cualquiera de las siguientes condiciones:

G es conexo y tiene n 1 aristas. G es conexo y sin ciclos. Cualesquiera 2 vrtices estn unidos por una nica trayectoria.

DEFINICION DE ARBOL GENERADO

Llamaremos rbol generador de un grafo conexo a cualquier subgrafo con el mismo nmero de vrtices que sea rbol (los subgrafos que mantienen todos los vrtices suelen denominarse subgrafos parciales). Un rbol generador mnimo de un grafo conexo pesado es un rbol generador con mnima suma de pesos. Es decir, un rbol generador representa la mnima estructura necesaria para mantener la conexin entre los vrtices. Y as se usa en la prctica: si nicamente interesa mantener la conexin del grafo, puedo eliminar todas las aristas innecesarias con el consiguiente ahorro.
ALGORITMO PARA GENERAR ARBOLES DE PESO MINIMO

Algoritmo en Pseudocdigo Ejemplo y cdigo pas a paso Tengamos el siguiente grafo no dirigido:

Como podemos ver en la imagen anterior la definicin de nuestro grafo en cdigo sera:
1 struct Edge{ 2 int origen; 3 4 5 6

//Vrtice origen

int destino; //Vrtice destino int peso; //Peso entre el vrtice origen y destino Edge(){} //Arreglo de aristas para el uso en kruskal

7 }arista[ MAX ];

Primeramente usaremos el mtodo MakeSet de unin-find para inicializar cada componente, obteniendo las siguientes componentes conexas iniciales:

Ahora el siguiente paso es ordenar las aristas del grafo en orden ascendente:

Para el ordenamiento podemos usar las libreras predefinidas de Java y C++ como estamos ordenando estructuras necesitamos un comparador, en este caso estamos ordenando por peso por lo tanto dentro de la estructura antes definida agregamos:
1 struct Edge{ 2 //Comparador por peso, me servir al momento de ordenar lo realizara en orden ascendente 4 //Cambiar signo a > para obtener el rbol de expansin mxima 3 5 6 bool operator<( const Edge &e ) const { return peso < e.peso;
//Arreglo de aristas para el uso en kruskal

7 } 8 }arista[ MAX ];

Ordenamos el arreglo de aristas mediante lo siguiente:

1 std::sort(

arista , arista + E );

//Ordenamos las aristas por su comparador

Lo siguiente ser recorrer todas las aristas ya ordenadas y verificar si sus vrtices estn o no en la misma componente. La primera arista a verificar es la que une a los vrtices 8 y 7, verificamos si estn en la misma componente, para ello hacemos Find(8) , Find(7):

Como podemos observar en la tabla y en la misma imagen no estn en la misma componente conexa, por tanto esta arista es vlida para el MST as que unimos los vrtices por el mtodo de Unin ( 8 , 7 ).

Continuamos con la siguiente arista:

Observamos la tabla de Union-Find y vemos que Find(3) != Find(9). Entonces es posible realizar la unin de ambas componentes:

Continuamos con la siguiente arista:

En la imagen podemos observar que ambos vrtices no estn en la misma componente, por tanto realizamos la Unin( 6 , 7 ):

Continuamos con la siguiente arista, los vrtices 1 y 2 no estn en la misma componente conexa:

Realizamos la Union(1,2):

Continuamos con la siguiente arista:

Al observar la imagen los vrtices 3 y 6 estn en distinta componentes conexas. Entonces realizamos la Unin(3,6) y actualizamos la tabla de Union-Find.

Continuamos con la siguiente arista:

En este caso si observamos la imagen los vrtices 7 y 9 estn en la misma componente conexa; asimismo en la tabla de Union-Find el elemento raz del vrtice 7 es el mismo que el del vrtice 9 por ello afirmamos que estn el a misma componente conexa, por lo tanto no habr que realizar la unin de ambos vrtices. Con esto evitamos tener ciclos en el rbol de expansin mnima. Continuamos con la siguiente arista:

Al observar la imagen los vrtices 3 y 4 no estn en la misma componente conexa por lo tanto realizamos la Unin (3,4) en el grafo:

Continuamos con la siguiente arista:

Los vrtices 8 y 9 estn en la misma componente conexa por lo tanto no realizamos Unin de vrtices. Continuemos con la siguiente arista:

Los vrtices 1 y 8 estn diferentes componentes. Realizamos la Unin (1,8) en el grafo:

Continuamos con la siguiente arista:

Los vrtices 2 y 3 estn en la misma componente conexa por lo tanto no realizamos Unin de componentes. Continuamos con la siguiente arista:

Los vrtices 4 y 7 no estn en la misma componente conexa, realizamos Unin (4,5) en el grafo:

Como podemos observar ya estn todos los vrtices del grafo conectados as que al momento de continuar viendo las dems aristas ordenadas siempre tendremos e l caso de que ya estn en la misma componente conexa por lo tanto el rbol de Expansin Mnima para el grafo es el siguiente:

El peso total del rbol de expansin mnima para el grafo mostrado es 39. En cdigo simplemente es iterar sobre el arreglo de aristas ingresado y ordenado obteniendo sus respectivos datos. Para verificar si estn o no en la misma componente usamos el mtodo sameComponent explicado en el tutorial de Union-Find: for( int i = 0 ; i < E ; ++i ){ //Recorremos las aristas ya ordenadas por peso 02 origen = arista[ i ].origen; //Vrtice origen de la arista actual 03 destino = arista[ i ].destino; //Vrtice destino de la arista actual 04 peso = arista[ i ].peso; //Peso de la arista actual 05 //Verificamos si estn o no en la misma componente conexa 06 if( !sameComponent( origen , destino ) ){ //Evito ciclos 01

07 08 09 sola 10 } 11 }

total += peso; //Incremento el peso total del MST MST[ numAristas++ ] = arista[ i ]; //Agrego al MST la arista actual Union( origen , destino ); //Unin de ambas componentes en una

Verificacin de MST Para que sea un MST vlido el nmero de aristas debe ser igual al nmero de vrtices 1. Esto se cumple debido a que el MST debe poseer todos los vrtices del grafo ingresado y adems no deben existir ciclos. Si vemos el ejemplo antes explicado tenemos en el MST:

Nmero de Aristas = 8 Nmero de Vrtices = 9

Cumple con lo dicho -> 9 1 = 8 por tanto tenemos un MST vlido. Veamos otro ejemplo teniendo como grafo ingresado lo siguiente:

Como podemos observar el grafo ingresado posee 2 componentes conexas, al aplicar kruskal obtendremos los siguientes MST:

En la imagen podemos observar el MST luego de aplicar kruskal, sin embargo no es un MST vlido porque no tiene 1 componente conexa que posea todos los vrtices, comprobemos:

Nmero de Aristas = 7 Nmero de Vrtices = 9

No cumple lo dicho inicialmente 9 1 != 7 por lo tanto tenemos un MST invalido. En cdigo basta con un if: //Si el MST encontrado no posee todos los vrtices mostramos mensaje de error //Para saber si contiene o no todos los vrtices basta con que el 2 numero 3 //de aristas sea igual al nmero de vrtices - 1 4 if( V - 1 != numAristas ){ 1 puts("No existe MST valido para el grafo ingresado, el grafo debe ser conexo."); 6 return; 7} 5

ALGORITMO PARA GENERAR EL CAMINO MAS CORTO EN UN ARBOL, DESDE UN PUNTO DE INICIO HASTA UN PUNTO DE DESTINO

ShotestPaths (int v, flota cost[][SIZE], float dist[], int n) /*dist[j], donde i <= j <=n es el conjunto de las distancias del camino mas corto del vrtice v al vrtice j en una grfica G con n vrtices. Dist[v] es el conjunto de ceros. G est representada por una matriz adyacente de distancias cost[1...n][1...n]*/ { int u; bool S[SIZE]; for(int i=1; i<=n; i++){ //Se inicializa S.// S[i]=false; dist[i]=cost[v][i]; } S[v]=true; dist[v]=0.0; //Se pone v en S // for(int num=2; num<n; num++){ /*Se determinan n-1 caminos de v. Elegimos u de entre estos vrtices que no estan en S cuya distancia dist[u] es la mnima*/ S[u]=true; //Ponemos u en S// For(int w=1; w<=n; w++) //actualizamos distancias// If((S[w]=false) && (dist[w] > dist[u] + cost[u][w]))

Dist[w]= dist[u] + cost[u][w]; } }