Teora 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 comn (que no sea un punto) tengan
distintos colores y queremos hacer esto usando un mnimo de colores.

1.- Encuentra una representacin en trminos de vrtices y aristas de un grafo a partir del
mapa dado.

Vrtices:

Representacin del Grafo:

El resultado es un grafo plano no dirigido, en el que sus vrtices estn 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 vrtices de tal
forma que no coincidan en color, con el color de los vrtices que estn unidos a ellos a
travs de aristas.

Algoritmo voraz (Greedy)

Los algoritmos voraces (Greedy) se utilizan tpicamente para resolver problemas de

optimizacin:
Minimizar o maximizar, bajo determinadas condiciones, el valor de una funcin del tipo:
f(x1, x2,,xn) = c1x1 + c2x2 ++ cnxn.

La solucin se va construyendo en etapas:

En cada etapa se aade un nuevo elemento a la solucin 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 solucin parcial ya constituye una solucin
total para el problema.

Colorear grafo

El algoritmo voraz comienza la coloracin de los vrtices segn orden de stos en la

matriz de adyacencias del grafo. La coloracin se realiza siguiendo los siguientes pasos.

Paso inicial. Ordenamos los vrtices del grafo. (el resultado del algoritmo
depender del orden elegido). Esto es, disponemos los vrtices del grafo en una
lista (v1, v2, . . . , vn) .

Ahora asignaremos colores a los vrtices siguiendo el orden elegido.

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

2. Cmo 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. Cmo coloreamos el vrtice vk, teniendo en cuenta que ya hemos
coloreado los k1 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 solucin.

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

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

Grafo:

Vrtices ordenados:

1) Al vrtice A, le asignamos el color 1.

 2) Como el vrtice B est unido con una arista a A no podemos utilizar el color a, as
que le asignamos otro color; color 2.

3) Ahora colorearemos el vrtice C, y ya que este est conectado tanto con el vrtice
A y el vrtice B, le asignamos otro color: color 3.
Los colores se verifican del primero al ltimo que se asign.

4) Por ltimo tenemos el vrtice 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.

Quedando como resultado un grafo de 4 colores, 1 para cada vrtice.

Cdigo java

import java.io.*;

import java.util.*;

import java.util.LinkedList;

class Graph {

private int V; // Nmero de vrtices.

private 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();
}

//Funcin para aadir 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 vrtices,

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

// Asignar el primer color al primer vrtice.

result[0] = 0;

// Se inicializan los vrtices 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 significara
// que el color cr se asigna a uno de sus vrtices adyacentes.
boolean available[] = new boolean[V];
for (int cr = 0; cr < V; cr++)
available[cr] = false;

// Asignar colores a los vrtices V-1 restantes.

 for (int u = 1; u < V; u++)
{
// Se procesan todos los vrtices 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 iteracin.

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("Vrtice " + u + " ---> Color "
+ result[u]);
}

// Mtodo principal.
public static void main(String args[])
{
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("Coloracin de grafo 1");
g1.greedyColoring();