Algoritmo de Dijkstra El algoritmo de Dijkstra, tambin llamado algoritmo de caminos mnimos, es un algoritmo para la determinacin del camino ms corto

dado un vrtice origen al resto de vrtices en un grafo con pesos en cada arista. Su nombre se refiere a Edsger Dijkstra, quien lo describi por primera vez en 1959. La idea subyacente en este algoritmo consiste en ir explorando todos los caminos ms cortos que parten del vrtice origen y que llevan a todos los dems vrtices; cuando se obtiene el camino ms corto desde el vrtice origen, al resto de vrtices que componen el grafo, el algoritmo se detiene. El algoritmo es una especializacin de la bsqueda de costo uniforme, y como tal, no funciona en grafos con aristas de costo negativo (al elegir siempre el nodo con distancia menor, pueden quedar excluidos de la bsqueda nodos que en prximas iteraciones bajaran el costo general del camino al pasar por una arista con costo negativo). Algoritmo Teniendo un grafo dirigido ponderado de N nodos no aislados, sea x el nodo inicial, un vector D de tamao N guardar al final del algoritmo las distancias desde x al resto de los nodos. 1. Inicializar todas las distancias en D con un valor infinito relativo ya que son desconocidas al principio, exceptuando la de x que se debe colocar en 0 debido a que la distancia de x a x sera 0. 2. Sea a = x (tomamos a como nodo actual). 3. Recorremos todos los nodos adyacentes de a, excepto los nodos marcados, llamaremos a estos vi. 4. Si la distancia desde x hasta vi guardada en D es mayor que la distancia desde x hasta a, sumada a la distancia desde a hasta vi; esta se sustituye con la segunda nombrada, esto es: si (Di > Da + d(a, vi)) entonces Di = Da + d(a, vi) 5. Marcamos como completo el nodo a. 6. Tomamos como prximo nodo actual el de menor valor en D (puede hacerse almacenando los valores en una cola de prioridad) y volvemos al paso 3 mientras existan nodos no marcados. Una vez terminado completamente lleno. al algoritmo, D estar

CDIGO EN JAVA public class DijkstraEngine { public int[] execute(int[][] graph, int node) { final boolean settledNodes[] = new boolean[graph.length]; final int shortestDistances[] = new int[graph.length]; settledNodes[0] = true; for (int i = 1; i < shortestDistances.length; i++) { if (graph[node][i] != 0) shortestDistances[i] = graph[node][i]; else shortestDistances[i] = Integer.MAX_VALUE; } for (int i = 0; i < (shortestDistances.length - 1); i++){ final int next = minVertex(shortestDistances, settledNodes); settledNodes[next] = true; for (int j = 0; j < graph[0].length; j++) { final int d = shortestDistances[next] + graph[next][j]; if ( shortestDistances[j] > d) shortestDistances[j] = shortestDistances[next] + graph[next][j]; } } return shortestDistances; } private static int minVertex (int [] shortestDistances, boolean [] settledNodes) { int x = Integer.MAX_VALUE; int y = -1; for (int i = 0; i < shortestDistances.length; i++) { if (!settledNodes[i] && shortestDistances[i] < x) { y = i; x = shortestDistances[i]; } } return y; } } Algoritmo de Prim

El algoritmo de Prim es un algoritmo perteneciente a la teora de los grafos para encontrar un rbol recubridor mnimo en un grafo conexo, no dirigido y cuyas aristas estn etiquetadas. En otras palabras, el algoritmo encuentra un subconjunto de aristas que forman un rbol con todos los vrtices, donde el peso total de todas las aristas en el rbol es el mnimo posible. Si el grafo no es conexo, entonces el algoritmo encontrar el rbol recubridor mnimo para uno de los componentes conexos que forman dicho grafo no conexo.
CDIGO EN JAVA

int d = wt.intValue (); if (!table[n1].known && table[n1].distance>d) { table [n1].distance = d; table [n1].predecessor = n0; queue.enqueue ( new Association (new Int (d), v1)); } } } } Graph result = new GraphAsLists (n); for (int v = 0; v < n; ++v) result.addVertex (v); for (int v = 0; v < n; ++v) if (v != s) result.addEdge (v, table [v].predecessor); return result; } } Algoritmo de Kruskal El algoritmo de Kruskal es un algoritmo de la teora de grafos para encontrar un rbol recubridor mnimo en un grafo conexo y ponderado. Es decir, busca un subconjunto de aristas que, formando un rbol, incluyen todos los vrtices y donde el valor total de todas las aristas del rbol es el mnimo. Si el grafo no es conexo, entonces busca un bosque expandido mnimo (un rbol expandido mnimo para cada componente conexa). El algoritmo de Kruskal es un ejemplo de algoritmo voraz. Un ejemplo de rbol expandido mnimo. Cada punto representa un vrtice, el cual puede ser un rbol por s mismo. Se usa el Algoritmo para buscar las distancias ms cortas (rbol expandido) que conectan todos los puntos o vrtices. Funciona de la siguiente manera:

public class Algorithms { public static Graph PrimsAlgorithm (Graph g, int s) { int n = g.getNumberOfVertices (); Entry[] table = new Entry [n]; for (int v = 0; v < n; ++v) table [v] = new Entry (); table [s].distance = 0; PriorityQueue queue = new BinaryHeap (g.getNumberOfEdges()); queue.enqueue ( new Association (new Int (0), g.getVertex (s))); while (!queue.isEmpty ()) { Association assoc = (Association) queue.dequeueMin(); Vertex v0 = (Vertex) assoc.getValue (); int n0 = v0.getNumber (); if (!table [n0].known) { table [n0].known = true; Enumeration p = v0.getEmanatingEdges (); while (p.hasMoreElements ()) { Edge edge = (Edge) p.nextElement (); Vertex v1 = edge.getMate (v0); int n1 = v1.getNumber (); Int wt = (Int) edge.getWeight ();

se crea un bosque B (un conjunto de rboles), donde cada vrtice del grafo es un rbol separado se crea un conjunto C que contenga a todas las aristas del grafo mientras C es no vaco o eliminar una arista de peso mnimo de C

si esa arista conecta dos rboles diferentes se aade al bosque, combinando los dos rboles en un solo rbol en caso contrario, se desecha la arista

} g,Arco N) public boolean HayCiclo(Grafo aVerificar,Nodo terminal,String {

Al acabar el algoritmo, el bosque tiene un solo componente, el cual forma un rbol de expansin mnimo del grafo. CDIGO EN JAVA public class AlgoritmoKruskal { @SuppressWarnings("unchecked") public Grafo aplicarKruskal(Grafo grafo) { Grafo rbol=new Grafo(); ArrayList<String> nodos=grafo.getNombres(); for(int j=0;j<nodos.size();j++) { odo(nodos.get(j)); } rbol.ingresarN

ArrayList<Enlace> aux=terminal.getEnlaces(); if(aux.size()==0) return false; if(terminal.existeEnlac e(aVerificar.getInicial())!=-1) return true; for(int i=0;i<aux.size();i++) { nodo=aux.get(i); ino().equals(N)==false) Enlace if(nodo.getDest if( Hay Ciclo(g,aVerificar,g.getNodo(nodo.getDe stino()),terminal.getNombre())) return true; } } } return false;

ArrayList<Arco> L=(ArrayList<Arco>)grafo.getAristas().c lone(); Arco pro=L.get(0); rbol.adicionarEnlace(p ro.getInicial(), pro.getTerminal(), pro.getPeso()); L.remove(pro); while(L.size()!=0) { pro=L.get(0); if(HayCiclo(rb ol, pro,rbol.getNodo(pro.getTerminal()) , pro.getTerminal())==false) rbol.a dicionarEnlace(pro.getInicial(), pro.getTerminal(), pro.getPeso()); } L.remove(pro);

return rbol;