Gabriel Martin Montiel

91823

K049

ALGORITMOS Y ESTRUCTURA DE DATOS

Mtro. Margarito Esquivel García

4. Teoría de grafos
El Tephé, Ixmiquilpan, Hidalgo, México.
Teoría de grafos

La figura muestra un mapa con 4 distritos A, B, C y D. Se trata de pintar cada distrito con
un color de forma que, dos regiones con un borde común (que no sea un punto) tengan
distintos colores y queremos hacer esto usando un mínimo de colores.

1.- Encuentra una representación en términos de vértices y aristas de un grafo a partir del
mapa dado.

Vértices:

A B C D

Representación del Grafo:

A B

C D
El resultado es un grafo plano no dirigido, en el que sus vértices están unidos por las aristas
de la siguiente manera:

G: {(A,B)(A,C)(A,D)(B,C)(B,D)(C,D)}
2.- Investiga un algoritmo que aplicado a grafos te permita ir coloreando los vértices de tal
forma que no coincidan en color, con el color de los vértices que estén unidos a ellos a
través de aristas.

Algoritmo voraz (Greedy)

Los algoritmos voraces (Greedy) se utilizan típicamente para resolver problemas de

optimización:
• Minimizar o maximizar, bajo determinadas condiciones, el valor de una función del tipo:
f(x1, x2,…,xn) = c1x1 + c2x2 +…+ cnxn.

La solución se va construyendo en etapas:

• En cada etapa se añade un nuevo elemento a la solución parcial. El que nos parece
el mejor candidato en ese momento.
• Las decisiones tomadas nunca se revisan. Voracidad: se consume el mejor
elemento lo antes posible.
• Al final de cada etapa se verifica si la solución parcial ya constituye una solución
total para el problema.

Colorear grafo

El algoritmo voraz comienza la coloración de los vértices según orden de éstos en la matriz
de adyacencias del grafo. La coloración se realiza siguiendo los siguientes pasos.

• Paso inicial. Ordenamos los vértices del grafo. (el resultado del algoritmo dependerá
del orden elegido). Esto es, disponemos los vértices del grafo en una lista (v1, v2, .
. . , vn) .
Ahora asignaremos colores a los vértices siguiendo el orden elegido.

1. A v1 le asignamos el primer color disponible; color a.

2. ¿Cómo coloreamos v2? Si es vecino de v1 le asignamos el color b; si no lo es, le
asignamos el color a.
3. Para colorear v3, comprobamos si es vecino de v1 o v2; y no podremos utilizar el
color o colores que hayamos utilizado en los que sean sus vecinos.
4. k-ésimo paso. ¿Cómo coloreamos el vértice vk, teniendo en cuenta que ya hemos
coloreado los k−1 anteriores? En la lista de colores obviamos los colores usados en
 los vecinos de vk que ya hayan sido coloreados; de los colores que quedan, elegimos
para vk el primero disponible.
5. Se imprime la solución.

3.- Explica el algoritmo de coloración que hayas utilizado, en conjunto con la corrida a mano
de la coloración del grafo, la cual representa al mapa dado en la actividad.

Aplicando el algoritmo voraz al problema del mapa, donde tenemos cuatro vértices
(A,B,C,D), conectados por aristas entre todos y cada uno de ellos, tenemos:

Grafo:

A B

C D
Vértices ordenados:

A B C D

1) Al vértice A, le asignamos el color 1.

2) Como el vértice B está unido con una arista a A no podemos utilizar el color a, así
que le asignamos otro color; color 2.
 A B
3) Ahora colorearemos el vértice C, y ya que este está conectado tanto con el vértice
A y el vértice B, le asignamos otro color: color 3.
Los colores se verifican del primero al último que se asignó.

A B

4) Por último tenemos el vértice D, verificamos si se le puede asignar el color 1, 2 o

3, pero al estar conectado por aristas a cada uno de ellos, se le asigna un nuevo
color; color 4.

A B

C D

Quedando como resultado un grafo de 4 colores, 1 para cada vértice.

Código
package grafos;
import java.util.*;
import java.util.LinkedList;
public class Grafos {
public static void main(String[] args) {

class Graph {

private final int V; // Número de vértices.

private final LinkedList<Integer> adj[]; //Lista de adyacencia.

//Constructor.
Graph(int v)
{
V = v;
adj = new LinkedList[v];
for (int i=0; i<v; ++i)
adj[i] = new LinkedList();
}

//Función para añadir aristas.

void addEdge(int v,int w)
{
adj[v].add(w);
adj[w].add(v); //Grafo no dirigido.
}

// Asignar colores (desde 0) a todos los vértices,

// e imprimir la asignación de colores.
void greedyColoring()
{
int result[] = new int[V];

// Asignar el primer color al primer vértice.

result[0] = 0;

// Se inicializan los vértices V-1 restantes como no asignados.

for (int u = 1; u < V; u++)
result[u] = -1; // No se asigna color a u.

// Se usa una matriz temporal para almacenar

// los colores disponibles.
// El valor verdadero de [cr] disponible significaría
// que el color cr se asigna a uno de sus vértices adyacentes.
boolean available[] = new boolean[V];
for (int cr = 0; cr < V; cr++)
available[cr] = false;

// Asignar colores a los vértices V-1 restantes.

for (int u = 1; u < V; u++)
{
// Se procesan todos los vértices adyacentes
// y se indican sus colores como no disponibles.
Iterator<Integer> it = adj[u].iterator() ;
while (it.hasNext())
{
int i = it.next();
if (result[i] != -1)
 available[result[i]] = true;
}

// Econtrar el primer color disponible.

int cr;
for (cr = 0; cr < V; cr++)
if (available[cr] == false)
break;

result[u] = cr; // Se asigna el primer color encontrado.

// Restablecer los valores a false para la siguiente iteración.

it = adj[u].iterator() ;
while (it.hasNext())
{
int i = it.next();
if (result[i] != -1)
available[result[i]] = false;
}
}

// Imprimir el resultado.
for (int u = 0; u < V; u++)
System.out.println("Vértice " + u + " ---> Color "
+ result[u]);
}

// Método principal.
{
Graph g1 = new Graph(4);
 g1.addEdge(0, 1);
g1.addEdge(0, 2);
g1.addEdge(0, 3);
g1.addEdge(1, 2);
g1.addEdge(1, 3);
g1.addEdge(2, 3);
System.out.println("Coloración de grafo 1");
g1.greedyColoring();
}

}
}
}
 Bibliografía
https://es.wikipedia.org/wiki/Teor%C3%ADa_de_grafos
http://www.uap.edu.pe/intranet/fac/material/02/20111DI020102202020103011/20111DI02
010220202010301124923.pdf