Grafos acíclicos

Lógica matemática

Luis Hernando Benavides Mahecha

Unilibre - Pereira
Risaralda - Pereira
2018
 Grafos aciclicos
Lógica matematica

Luis Hernando Benavides Mahecha

Profesor : Carlos Alberto Ocampo Sepúlveda

Unilibre - Pereira
Risaralda - Pereira
2018
Tabla de contenido
INTRODUCCIÓN .............................................................................................................................. 4
Antecedentes del algoritmo ........................................................................................................ 4
Autores.............................................................................................................................................. 6
Eric W. Weisstein ....................................................................................................................... 6
MathWorld, ScienceWorld y Wolfram Research ............................................................ 6
Paul Erdős .................................................................................................................................... 7
Alfréd Rényi ................................................................................................................................. 7
Descripción del algoritmo ............................................................................................................ 8
Terminología................................................................................................................................ 8
Técnicas del algoritmo.............................................................................................................. 8
Algoritmo de aciclicidad......................................................................................................... 10
Los métodos Erdös-Rĕny ...................................................................................................... 11
Ramas de estudio................................................................................................................. 12
Teorema 1 ............................................................................................................................... 12
Teorema 2 ............................................................................................................................... 12
Algoritmo de Dijkstra .................................................................................................................. 12
Teoría del camino mas corto................................................................................................. 13
Algoritmo .................................................................................................................................... 13
Complejidad ............................................................................................................................... 13
Pseudocódigo ........................................................................................................................... 14
Implementación en Java ........................................................................................................... 14
Otra versión en C++ del algoritmo de Dijkstra ...................................................................... 15
Aplicación de los DAGs en el problema de la planificación de tareas en los SCHD . 18
Bibliografía ........................................................................................................................................ 19
INTRODUCCIÓN
Los grafos son estructuras que representan las relaciones, las interdependencias y las
características entre los objetos, y son utilizados en diferentes áreas de la investigación
científica .En el área de la computación paralela y distribuida, se utilizan para desagregar
las distintas tareas que conforman la solución de un problema, y la forma en que se
distribuyen estas tareas entre los procesadores mediante los algoritmos de planificación y
asignación de tareas ; los grafos también permiten mostrar las dependencias, las
restricciones de precedencia, los enlaces de comunicación, los costos de cálculo y los
costos de comunicación de las tareas que constituyen la aplicación a ser ejecutada dentro
del sistema de cómputo .

Antecedentes del algoritmo

En la literatura no se han encontrado trabajos que sigan una metodología de investigación
como la que se propone en este trabajo: producir DAGs con métodos de generación
aleatorios, extraer las características de los DAGs, evaluar estas características para
obtener los resultados de cada una de ellas y, realizar un análisis previo a la planificación
de los DAGs en un sistema de cómputo heterogéneo distribuido.
Lo que se ha encontrado en la literatura son tres tipos de trabajos que conforman nuestra
investigación: primero, trabajos que destacan la importancia de las características de los
DAGs en la planificación de tareas [4,7], segundo, trabajos que utilizan los DAGs como
estructuras paralelas para la planificación de tareas en los SCHD [5,6,7] y, tercero, trabajos
de investigación que desarrollan algoritmos para la generación aleatoria de DAGs
[1,3,8,9,10,11].
En base al enfoque que se realiza en la investigación aquí propuesta, se mencionan y
resumen brevemente los trabajos que destacan la importancia de las características de los
DAGs, y seis de los trabajos que, por su importancia práctica en la literatura, se han
propuesto para desarrollar los algoritmos que generan los DAGs.
Algunos de los trabajos que destacan la importancia de observar las características y los
parámetros de los DAGs son [4,7]. En [4], las características definidas y observadas son:
 la ruta más larga (The longest path) definido como la trayectoria con longitud
máxima, es decir, la trayectoria con el número más grande de nodos en un grafo,
 la distribución de aristas dirigidas (Distribution of the Out-degree) que se define
como número de aristas dirigidas en el grafo que comienzan en el vértice v,
 el número de aristas (Number of edges), que representa la cantidad de aristas de
los grafos generados.
En [7], los parámetros que son observables de los DAGs son la anchura y la densidad, y se
definen de la siguiente manera: la anchura del grafo determina el máximo paralelismo en el
DAG, esto es, el número de tareas en el nivel más largo. La densidad del grafo, indica el
numero de aristas entre dos niveles del DAG.
Los trabajos de investigación que desarrollan algoritmos para la generación aleatoria de
DAGs son [1,3,8,9,10,11]. En las siguientes subsecciones se describen estos seis trabajos
que se han propuesto en la literatura, para la generación aleatoria de grafos. La descripción
aquí realizada permite contrastar los parámetros utilizados en cada uno de ellos, entender
la función de probabilidad utilizada y detectar las características de los DAGs generados.
Cabe mencionar que, métodos tales como: Erdös-Rĕnyi, nivel por nivel, Fan-in/Fan-out y
Random Order ya han sido utilizado para el problema de la planificación de tareas en
sistemas heterogéneos distribuidos, los resultados obtenidos con estos métodos pueden
verse en [7]. Pero es de señalarse que, en este trabajo únicamente se generan los DAGs,
y no se realiza un análisis previo de éstos, ni una extracción de características antes de la
planificación de las tareas.
El objetivo de investigar y analizar los métodos generadores de DAGS es debido a que,
hasta donde los autores tienen conocimiento, no existe un procedimiento de generación de
grafos aleatorios estándar, que representen programas paralelos a ser procesados por el
SCHD, con una independencia absoluta de las métricas de desempeño que son utilizadas
en los SCHD [4].
Por lo anterior expuesto, en este trabajo utilizamos dos métodos para la generación
aleatoria de grafos, diferentes a los ya expuestos y utilizados en la literatura para la
planificación de tareas, pero buscando también que los grafos generados, posean
características semejantes a las que tienen los grafos de las aplicaciones paralelas del
mundo real, como los expuestos en [4]; y la característica que se elige para observarse en
los DAGs generados con los dos métodos, en este trabajo de investigación, es la anchura
del grafo.
Autores
Los autores existen , con respecto los siguientes autores después del primero son autores
de métodos de grafos acíclicos

Eric W. Weisstein
Eric W. Weisstein (Bloomington, Indiana, 18 de marzo de 1969) es
un enciclopedista estadounidense, creador y mantenedor de la enciclopedia en
línea MathWorld, así como de Eric Weisstein's World of Science (ScienceWorld).
Actualmente trabaja para Wolfram Research, Inc.

MathWorld, ScienceWorld y Wolfram Research

En 1995, Weisstein convirtió un documento de Microsoft Word de más de 200 páginas a
formato hipertexto, y lo subió a su espacio web en Caltech bajo el título Eric's Treasure
Trove of Sciences. Este documento contenía un compendio de información que Weisstein
había obtenido a través de sus estudios. Cuando Weisstein se transfirió a la Universidad de
Virginia para continuar sus estudios de astronomía, continuó refinando su enciclopedia
personal. En noviembre de 1998, hizo un trato con CRC Press para publicar su enciclopedia
en formato de libro, titulado CRC Concise Encyclopedia of Mathematics. Un año después,
en 1999, Weisstein aceptó la posición de enciclopedista en Wolfram Research, Inc.
http://mathworld.wolfram.com/AcyclicDigraph.html

Un dígrafo acíclico es un gráfico dirigido que no contiene ciclos dirigidos, también

conocido como gráfico acíclico dirigido o "DAG". Cada dígrafo acíclico finito tiene al
menos un nodo de grado 0. Los números de dígrafos acíclicos en , 2, ... vértices son
1, 2, 6, 31, 302, 5984, ... (OEIS A003087 ).

Los números de dígrafos acíclicos etiquetados en 2, ... nodos son 1, 3, 25, 543,
29281, ... (OEIS A003024 ). La conjetura de Weisstein propuso que las matrices
de valores propios positivos estaban en correspondencia uno a uno con dígrafos acíclicos
marcados en los nodos, y esto fue comprobado posteriormente por McKay et
al. (2004). Los recuentos de ambos están, por lo tanto, dados por la hermosa ecuación de
recurrencia.
con (Harary y Palmer 1973, p. 19; Robinson 1973, pp. 239-273).

Paul Erdős
Paul Erdős, nacido Pául Erdős (IPA: ˈɛrdøːʃ; Budapest, 26 de marzo de 1913-Varsovia, 20
de septiembre de 1996), fue un matemático húngaroinmensamente prolífico y famoso por
su excentricidad que, con cientos de colaboradores, trabajó en problemas
sobre combinatoria, teoría de grafos, teoría de números, análisis clásico, teoría de
aproximación, teoría de conjuntos y probabilidad.
Su vida fue documentada en la película N es un número: El retrato de Paul Erdős, hecha
mientras él todavía estaba vivo, y el libro El hombre que solo amaba a los números (1998).
Murió de un ataque al corazón el 20 de septiembre de 1996, a la edad de 83 años, mientras
asistía a una conferencia en Varsovia (Polonia).

Alfréd Rényi
Rényi nació en Budapest de padres Artur Rényi y Barbara Alexander, su padre era un
ingeniero mecánico, mientras que su madre era hija de un filósofo y crítico literario, Bernát
Alexander. El maestro de la escuela le impidió matricularse en la universidad en el año 1939
debido a las leyes anti-judías vigentes en ese momento, pero logró matricularse en
la Universidad de Budapest en 1940 y terminó sus estudios en 1944. En este punto fue
encarcelado en un campamento de trabajo, escapó, y concluyó su Ph.D. en 1947 en
la University of Szeged, bajo la asesoría de Frigyes Riesz.3 Se casó con Katalin Schulhof,
ella misma matemática, en 1946; Zsuzsa, su hija, nació en 1948. Después de un breve
puesto de asistente de cátedra en Budapest, fue nombrado Profesor Extraordinario en
la Universidad de Debrecen en 1949.

Rényi probó, empleando algunos métodos, que existe un número tal que cada número
es la suma de un número primo y un número escrito como producto de los números primos

de la descomposición de . Véase también la conjetura de Goldbach. Hizo progresos

en la Teoría de la información introduciendo un concepto denominado el espectro de
las entropías Rényi de orden α, dando un paso de generalización a la teoría de la entropía
de Shannon y la divergencia de Kullback-Leibler. Las entropías de Rényi dan información
fundamental a los índices de diversidad y proporcionan conexiones con las dimensiones
fractales.
Escribió 32 documentos en colaboración con Paul Erdős,4 el más conocido de los cuales
está presenta el modelo de Erdős-Rényi sobre generación de grafos aleatorios
Descripción del algoritmo
En ciencias de la computación y matemáticas un grafo acíclico
dirigido o DAG (del inglés Directed Acyclic Graph), es un grafo dirigido que no tiene ciclos;
esto significa que para cada vértice v, no hay un camino directo que empiece y termine en v.
Los DAG aparecen en modelos donde no tiene sentido que un vértice tenga un camino
directo a él mismo; por ejemplo, si un arco u→v indica que v es parte de u, crear un
ciclo v→u indicaría que u es subconjunto de sí mismo y de v, lo cual es imposible.
Informalmente un DAG "fluye" en solo una dirección.
Cada DAG da lugar a un ordenamiento parcial ≤ sobre sus vértices,
donde u ≤ v exactamente cuando existe un camino directo desde u a v. Muchos DAG
pueden generar el mismo ordenamiento parcial de los vértices siendo el de menor número
de arcos denominado la reducción transitiva y el que mayor número de arcos la Clausura
transitiva. En particular, la clausura transitiva es el orden de accesibilidad ≤.

Terminología
Una fuente es un vértice sin flujos (relaciones) de entrada, mientras que
un sifón o sumidero es un vértice sin flujos (relaciones) de salida.
Un DAG finito tiene por lo menos una fuente y un sifón.
La profundidad de un vértice, en un DAG finito, es la longitud del camino más largo que
existe desde una fuente a dicho vértice, la altura de un vértice es la longitud más larga del
camino que exista desde el vértice a un sifón.
La longitud de una DAG finito es la longitud (número de arcos) del camino directo más largo.
Dicha longitud es igual a la máxima altura de todas las fuentes e igual a la máxima
profundidad de todos los sifones.

Técnicas del algoritmo

Algunas de las técnicas más conocidas en la utilización de la minería de datos son árboles
de decisión, las reglas de producción y las redes neuronales. Los grafos sirven para
representar relaciones entre objetos de datos.
Una de las formas de representación del conocimiento y de los métodos de razonamiento
utilizan las redes bayesianas. Estas redes bayesianas aprenden sobre las relaciones de
dependencia y causalidad, combinan el conocimiento con los datos y pueden manejar
relaciones entre distintas bases de datos.
La figura 2.13 muestra la estructura básica de Bayes en donde se comienza por una
estructura de árbol con sus variables predictorias para posteriormente conectar la variable
X con cada una de las variables predictorias R.
Figura 2.13 Representación básica del modelo de Bayes.
Como se puede apreciar, las redes bayesianas son modelos que describen las relaciones
entre variables, estas pueden ser aplicadas a casi cualquier tipo de problema.
La conformación de una red bayesiana nos da información sobre las dependencias
probabilísticas entre las variables y también sobre las independencias condicionales de una
variable o variables. Dichas independencias simplifican la representación del conocimiento.
La aplicabilidad de las redes bayesianas para llevar a cabo la minería de datos sobre un
conjunto de bases de datos permite articular de manera simbólica los patrones de relación
que la red bayesiana genera. A la relación binaria entre los elementos de un conjunto se le
denomina grafo.
Un grafo acíclico dirigido es una red bayesiana en el que cada nodo representa una variable
y cada arco una dependencia probabilística, en la cual se especifica la probabilidad
condicional de cada variable dados sus padres. Esta variable a la que apunta el arco es
dependiente de la que está en el origen de éste.
En un grafo acíclico dirigido todas las conexiones están identificadas por un único camino
simple que no repite vértices. Esto es, un vértice sólo se visita si han sido visitados todos
sus predecesores.
El camino es simple si todos los nodos que forman el camino son distintos.
La aplicación de los grafos acíclicos dirigidos permite la representación del recorrido o
navegación entre las redes de un determinado proyecto (transporte, comunicaciones, bases
de datos, etc.), en donde cada vértice representan las tareas y las aristas las relaciones
temporales entre ellas. Ver figura 2.14.

Figura 2.14 Representación de un grafo acíclico dirigido.

Como un primer aspecto que incorpora la teoría bayesiana es el control de la longitud o
profundidad del camino recorrido por el grafo.
El recorrido de un grafo es uno de los problemas deducibles de las aplicaciones que pueden
resolverse mediante diversos algoritmos existentes. Estos algoritmos de distancia pueden
tomar decisiones sobre la navegación, los recorridos y sus ponderaciones de acuerdo a
políticas de reducción en su longitud o en base al número de saltos necesarios.
Normalmente el orden de los algoritmos utilizados para la navegación del grafo esta definido
por el número de saltos que se efectúan durante su recorrido : X=X+1, siendo su parámetro
de representación una búsqueda binaria.
En la aplicación de la teoría de grafos acíclicos dirigidos hacia la generación, transmisión y
distribución del conocimiento y su representación, se pueden identificar rápidamente cuales
son los materiales más relevantes debido a que son aquellos de los cuales son ocupados
por muchas referencias, generando con ello muchos arcos hacia los documentos de mayor
relevancia.
La figura 2.15 muestra la representación gráfica de los arcos en un grafo acíclico dirigido.
En la transmisión del conocimiento se observa que un material con más referencias (A)
genera la mayor cantidad de arcos hacia las nuevas referencias, el material más nuevo (E)
no cuenta con arcos debido a que no ha sido utilizado como referencia por otros materiales.

Figura 2.15 Recorrido de arcos en un grafo acíclico dirigido

Algoritmo de aciclicidad
El algoritmo se basa en los siguientes resultados:
· Si eliminamos un hoja y la arista incidente en ella, el subgrafo que nos queda sigue
teniendo los
mismos ciclos que antes (una hoja no puede formar parte de un ciclo).
·Si el grafo es conexo, y elimínanos una hoja el subgrafo resultante sigue siendo conexo.
Luego sobre un grafo conexo, el método del algoritmo es el siguiente:
-Si tiene más de un vértice y no tiene una hoja, no es cíclico. Si tiene una hoja, la eliminamos
del grafo.
-Si el subgrupo resultante tiene más de un vértice y no tiene hojas, no es cíclico y tampoco
lo es el inicial. Si tiene una hoja, la eliminamos.
Sucesivamente, hasta que nos quede un solo vértice de grado 0, en cuyo caso es cíclico,
o
hasta obtener un subgrupo de más de un vértice y sin hojas, en cuyo caso tiene ciclos.

Los métodos Erdös-Rĕny

Los métodos Erdös-Rĕnyi son dos modelos matemáticos simples, elegantes y generales
[3], considerados los métodos más populares para la generación aleatoria de grafos [4]. El
primer modelo, denotado como Γ v,e elige un grafo uniformemente al azar del conjunto de
grafos con v vértices y e aristas [8]. La característica principal de este método es la
generación de grafos aleatorios, con un número fijo de aristas [4]
El segundo método, denotado como Γ v,p elige un grafo uniformemente al azar del conjunto
de grafos con v vértices, donde cada arista tiene la misma probabilidad p de existir [8]. De
este método se pueden destacar las siguientes propiedades [4]:
 Cuando el valor de v es lo suficientemente grande, el número de aristas en los
grafos generados tiende a .
 Existe una alta probabilidad de generar un subgrafo débilmente conectado con la
mayoría de los vértices, si np tiende a una constante mayor que 1 y no existe ningún
otro componente conectado con más de 0(logn) nodos.

 Si entonces es altamente probable que el grafo generado no tendrá

vértices aislados.
Este método al basarse por medio de la aleatoriedad
En Matemáticas se denomina grafo aleatorio a un grafo que es generado por algún tipo
de proceso aleatorio. La teoría de los grafos aleatorios cae en la intersección entre la teoría
de grafos y la teoría de probabilidades y se fundamenta en el estudio de ciertas
propiedades de los grafos aleatorios. Uno de los modelos matemáticos más aplicados en
la generación de redes aleatorias es modelo Erdös–Rényi.
Ramas de estudio
Una de las ramas más estudiadas en el área de las redes aleatorias es el de la teoría de la
percolación (nivel de percolación) relacionado con el estudio de la fiabilidad en las redes de
comunicación.3 Un campo de estudio inicial fue el de redes sociales, estudios sobre la
topología de redes evolutivas como puede ser internet, etc. Se ha visto que algunas de las
redes actuales crecen según modelos predefinidos en su distribuciones de grado, como
puede ser la redes libres de escala.
Teoremas
Algunos teoremas se deducen del modelo, por ejemplo, si G(n; p) es un grafo aleatorio con
n vértices donde cada enlace tiene una posibilidad p de existir:

Teorema 1
Dado un G(n, p) con un valor p constante e independiente de n, entonces el grafo seguro
que posee casi seguro un diámetro igual a 2.

Teorema 2

Para un grafo G(n, p) aleatorio se establece que . Si c > 1 entonces casi todos los
grafos no poseen vértices aislados y si c < 1 casi todos los grafos tienen al menos un vértice
aislado.

Pero la forma mas directa de poder basarnos en los grafos acíclicos es basándonos por
medio de otros como va a ser el siguiente :

Algoritmo de Dijkstra
El algoritmo de Dijkstra, también llamado algoritmo de caminos mínimos, es
un algoritmo para la determinación del camino más corto, dado un vérticeorigen, hacia el
resto de los vértices en un grafo que tiene pesos en cada arista. Su nombre alude a Edsger
Dijkstra, científico de la computación de los Países Bajos que lo describió por primera vez
en 1959.[cita requerida]
La idea subyacente en este algoritmo consiste en ir explorando todos los caminos más
cortos que parten del vértice origen y que llevan a todos los demás vértices; cuando se
obtiene el camino más corto desde el vértice origen hasta el resto de los vértices que
componen el grafo, el algoritmo se detiene. Se trata de una especialización de la búsqueda
de costo uniforme y, como tal, no funciona en grafos con aristas de coste negativo (al elegir
siempre el nodo con distancia menor, pueden quedar excluidos de la búsqueda nodos que
en próximas iteraciones bajarían el costo general del camino al pasar por una arista con
costo negativo).
Una de sus aplicaciones más importantes reside en el campo de la telemática. Gracias a
él, es posible resolver grafos con muchos nodos, lo que sería muy complicado resolver sin
dicho algoritmo, encontrando así las rutas más cortas entre un origen y todos los destinos
en una red
Teoría del camino mas corto
En la teoría de grafos, el problema del camino más corto es el problema que consiste en
encontrar un camino entre dos vértices (o nodos) de tal manera que la suma de los pesos
de las aristas que lo constituyen es mínima. Un ejemplo de esto es encontrar el camino más
rápido para ir de una ciudad a otra en un mapa. En este caso, los vértices representarían
las ciudades y las aristas las carreteras que las unen, cuya ponderación viene dada por el
tiempo que se emplea en atravesarlas.

Algoritmo
Teniendo un grafo dirigido ponderado de N nodos no aislados, sea x el nodo inicial. Un
vector D de tamaño N guardará al final del algoritmo las distancias desde x hasta el 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 sería 0.
2. Sea a = x (Se toma a como nodo actual.)
3. Se recorren todos los nodos adyacentes de a, excepto los nodos marcados. Se les
llamará nodos no marcados vi.
4. Para el nodo actual, se calcula la distancia tentativa desde dicho nodo hasta sus
vecinos con la siguiente fórmula: dt(vi) = Da + d(a,vi). Es decir, la distancia tentativa
del nodo ‘vi’ es la distancia que actualmente tiene el nodo en el vector D más la
distancia desde dicho nodo ‘a’ (el actual) hasta el nodo vi. Si la distancia tentativa
es menor que la distancia almacenada en el vector, se actualiza entonces el vector
con esta distancia tentativa. Es decir, si dt(vi) < Dvi → Dvi = dt(vi)
5. Se marca como completo el nodo a.
6. Se toma como próximo nodo actual el de menor valor en D (puede hacerse
almacenando los valores en una cola de prioridad) y se regresa al paso 3, mientras
existan nodos no marcados.
Una vez terminado al algoritmo, D estará completamente lleno.

Complejidad
Orden de complejidad del algoritmo:
O(|V|2+|A|) = O(|V|2), sin utilizar cola de prioridad, :O((|A|+|V|) log |V|) = O(|A| log |V|)
utilizando cola de prioridad (por ejemplo, un montículo de Fibonacci). Por otro lado, si se
utiliza un montículo de Fibonacci, sería O(|V| log |V|+|A|).
La complejidad computacional del algoritmo de Dijkstra se puede calcular contando las
operaciones realizadas:
 El algoritmo consiste en n-1 iteraciones, como máximo. En cada iteración, se añade
un vértice al conjunto distinguido.
 En cada iteración, se identifica el vértice con la menor etiqueta entre los que no
están en Sk. El número de estas operaciones está acotado por n-1.
  Además, se realizan una suma y una comparación para actualizar la etiqueta de
cada uno de los vértices que no están en Sk.
Luego, en cada iteración se realizan a lo sumo 2(n-1) operaciones.
Entonces:
Teorema: El algoritmo de Dijkstra realiza O(n2) operaciones (sumas y comparaciones) para
determinar la longitud del camino más corto entre dos vértices de un grafo ponderado
simple, conexo y no dirigido con n vértices.
En general:
Tiempo de ejecución = O(|A|.𝑻_𝒅𝒌+|v|.𝑻_𝒅𝒎)
|A|: Número de aristas
𝑻_𝒅𝒌: Complejidad de disminuir clave
|V|: Numero de vértices
𝑻_𝒅𝒎: Complejidad de extraer mínimo

Pseudocódigo

DIJKSTRA (Grafo G, nodo_fuente s)

para u ∈ V[G] hacer
distancia[u] = INFINITO
padre[u] = NULL
visto[u] = false
distancia[s] = 0
adicionar (cola, (s, distancia[s]))
mientras que cola no es vacía hacer
u = extraer_mínimo(cola)
visto[u] = true
para todos v ∈ adyacencia[u] hacer
si distancia[v] > distancia[u] + peso (u, v) hacer
distancia[v] = distancia[u] + peso (u, v)
padre[v] = u
adicionar(cola,(v, distancia[v]))

Implementación en Java

0 /**
1 * Realizar el algoritmo de Dijkstra sobre el grafo
2 * @param origen nodo inicial
3 * @param destino nodo destino
 4 * @return camino ArrayList con el camino a seguir.
5 */
6 public ArrayList<Integer> dijkstra(int origen, int destino) {
7 ArrayList<Integer> camino= new ArrayList<Integer>();
8 int distancia=Grafo.INFINITO;
9 int nodo=origen;
10 boolean fin=true;
11 camino.add(nodo);
12 while(fin) {
13 if(this.floydC[nodo][destino]<distancia) {
14 /*El metodo siguiente(nodo, destino), nos
devuelve
15 el siguiente nodo a visitar*/
16 nodo=this.siguiente(nodo, destino);
17 camino.add(nodo);
18 }
19
20 if(nodo==destino) {
21 fin=false;
22 }
23 }
24
25 return camino;
26 }

Otra versión en C++ del algoritmo de Dijkstra

//Declarando variables
#define MAX_NODOS 1024 /* número máximo de nodos */
#define INFINITO 1000000000 /* un número mayor que cualquier ruta máxima
*/
int n,i,k,minimo, dist[MAX_NODOS][MAX_NODOS]; /* dist[i][j] es la
distancia de i a j */

struct nodo { /* Indica eL estado del nodo,la ruta y quien lo precede a

dicho nodo */
int predecesor; /* nodo previo */
int longitud; /* longitud del origen a este nodo */
 bool etiqueta; /*verdadero para un nodo permanente y falso para
nodo tentativo*/
} nodo[MAX_NODOS];

void inicializacion(){
for (p = &nodo[0]; p < &nodo[n]; p++) { /* estado de
inicialización*/
p->predecesor = -1;
p->longitud = INFINITO;
p->etiqueta = false;
}
}
void relajar(){
for (int i = 0; i <n; i++){ /* este grafo tiene n nodos
*/
if (dist[k][i] != 0 && nodo[i].etiqueta == false) {
if (nodo[k].longitud + dist[k][i] <
nodo[i].longitud) {
nodo[i].predecesor = k;
nodo[i].longitud = nodo[k].longitud +
dist[k][i];
}
}
}
}
void extraer_minimo(){ /* Encuentra los nodo etiquetados
tentativamente y determina el menor entre estos nodos tentativos. */
k = 0;
minimo = INFINITO;
for (i = 0; i < n; i++){
if (nodo[i].etiqueta == false && nodo[i].longitud <
minimo) {
minimo = nodo[i].longitud;
k = i;
}
}
}

void camino_corto(int s, int t, int camino[]) {

inicializacion();
 nodo[t].longitud = 0; nodo[t].etiqueta = true;
k = t; /* k es el nodo de trabajo inicial */
do{ /* ¿hay una ruta mejor desde k? */
relajar();
extraer_minimo();
nodo[k].etiqueta = true;
} while (k != s);
/* Copia la ruta en el arreglo de salida y procede a ir
imprimiendolo. */
i = 0; k = s;
cout<< "La ruta es: ";
do {
cout<< k<< " ";
camino[i] = k;
k = nodo[k].predecesor;
i++;
} while (k >= 0);
cout <<"La ruta minima es: "<<minimo<<endl ;
}
int main(){
int nodo_final,nodo_inicial,arista;
//solicita o ingresa directamente los valores de
nodo_final,nodo_inicial
//Llenar de 0 la matriz
for (int i=0; i<n; i++){
for( int j=0; j<n; j++){
dist[i][j]=0;
}
}
// Llenar la matriz dist[i][j]
/*............................
............................*/
//Por ultimo llamar a la función camino corto
camino_corto(nodo_final,nodo_inicial,camino)
return 0;
}
Aplicación de los DAGs en el problema de la planificación
de tareas en los SCHD
Sin pérdida de generalidad y considerando las definiciones existentes en la literatura en
esta sección, se define la forma en que los DAGs se aplican al problema de la planificación
y la asignación de tareas en un SCHD.
Un DAG consiste en v nodos n1 , n2 , …, nv que pueden ser ejecutados en cualquiera de los
procesadores disponibles de un SCHD. Un nodo en el DAG representa una tarea, la cual,
es un conjunto de instrucciones que deben ser ejecutadas secuencialmente sin derecho
preferente en el mismo procesador. Un nodo tiene una o más entradas. Cuando todas las
entradas están disponibles, el nodo se activa para su ejecución. Después de su ejecución,
éste genera sus salidas. Un nodo sin padres es llamado un nodo de entrada, y un nodo sin
hijos es llamado un nodo de salida. El peso en un nodo es llamado el costo de cálculo
(computation cost) de un nodo ni y es denotado por w(ni).
El grafo también tiene e aristas dirigidos que representan un orden parcial entre las tareas.
El orden parcial introduce una restricción de precedencia del DAG, e implica que si ni →nj ,
entonces, nj es un hijo el cual no puede iniciar hasta que su padre ni finalice y envía sus
datos a ni . El peso, en una arista es llamado el costo de comunicación (communication
cost) de la arista y es denotado por c (ni , nj ). En este costo se incurre si, ni y nj son
planificados en diferentes procesadores y es considerado cero, si ni y nj se planifican en el
mismo procesador. Para la estandarización, especificamos que un DAG tiene solo un único
nodo de entrada y un solo nodo de salida.
Bibliografía
https://es.wikipedia.org/wiki/Grafo_ac%C3%ADclico_dirigido

https://es.wikipedia.org/wiki/%C3%81rbol_(teor%C3%ADa_de_grafos)

https://es.wikipedia.org/wiki/Eric_W._Weisstein

http://mathworld.wolfram.com/AcyclicDigraph.html

http://www.redalyc.org/jatsRepo/944/94455712004/html/index.html

http://www.ma.uva.es/~antonio/Industriales/Apuntes_05-06/LabM/A_Grafos2006-2(1).pdf

https://esistemasoperativos.mforos.com/2087245/11047186-ejemplo-de-grafo-aciclico/

http://www.eumed.net/tesis-doctorales/2007/cavl/Grafos%20aciclicos%20dirigidos.htm

http://personales.unican.es/gomezd/teaching/algs/ciclos.pdf

https://es.wikipedia.org/wiki/Problema_del_camino_m%C3%A1s_corto#Grafos_ac%C3%ADclicos
_dirigidos

https://slideplayer.es/slide/4188034/

https://es.wikipedia.org/wiki/Modelo_Erd%C3%B6s%E2%80%93R%C3%A9nyi

https://es.wikipedia.org/wiki/Paul_Erd%C5%91s

https://es.wikipedia.org/wiki/Alfr%C3%A9d_R%C3%A9nyi

https://es.wikipedia.org/wiki/Grafo_aleatorio

https://es.wikipedia.org/wiki/Algoritmo_de_Dijkstra

https://es.wikipedia.org/wiki/Problema_del_camino_m%C3%A1s_corto#Grafos_ac%C3%ADclicos
_dirigidos