Escolar Documentos
Profissional Documentos
Cultura Documentos
1. Bellman Ford
Procedimiento
Encontrar los caminos más cortos desde un nodo origen dado con la condición de que éstos
contengan a lo sumo un enlace.
Encontrar los caminos más cortos con la condición de que contengan dos enlaces como máximo.
Y así sucesivamente
s = nodo origen
Lh(n) = coste del camino de mínimo coste desde el nodo s hasta el nodo n con la condición de que
no haya más de h enlaces
Paso 1 [Inicialización]
L0(n)= ∞, para todo n ≠ s
Lh(s) = 0, para todo h
Paso 2 [Actualización]
Para cada sucesivo h ≥ 0:
Para cada n ≠ s, calcular
Lh+1(s) = min j[Lh(j)+w(j,n)]
Conectar n con el nodo predecesor j de mínimo coste
Eliminar todas las conexiones de n con un nodo predecesor diferente obtenido en una iteración
anterior
El camino de s a n finaliza con el enlace de j a n
Para la iteración del paso 2 con h=K, y para cada nodo de destino n, el algoritmo compara las
rutas potenciales de longitud K+1 desde s hasta n con el camino existente al final de la iteración
anterior.
Si el camino más corto previo tiene un coste inferior, se guarda.
h Lh(2) Ruta Lh(3) Ruta Lh(4) Ruta Lh(5) Ruta Lh(6) Ruta
0 ∞ - ∞ - ∞ - ∞ - ∞ -
1 2 1-2 5 1-3 1 1-4 ∞ - ∞ -
2 2 1-2 4 1-4-3 1 1-4 2 1-4-5 10 1-3-6
3 2 1-2 3 1-4-5-3 1 1-4 2 1-4-5 4 1-4-5-6
4 2 1-2 3 1-4-5-3 1 1-4 2 1-4-5 4 1-4-5-6
Según el algoritmo de Bellman-Ford deberemos seguir los nodos V1-V4-V5-V6, por ser los que
menor coste nos ocasionan
#include <stdio.h>
#include <stdlib.h>
#include "matrix.h"
struct Node{
int index;
int cost;
};
class Bellman{
private:
Matrix matrix;
Node nodeMatrix[MaxVertex][MaxVertex];
int row, col;
void update(int r, int c, int first);
public:
void readFile(char* fileName);
void display();
void displayMatrix();
bool findCost(int r, int c);
void doFindCost();
};
int main(){
Bellman B;
B.readFile("nick.txt");
B.display();
B.doFindCost();
//B.displayMatrix();
B.display();
return 0;
}
void Bellman::doFindCost(){
bool findNew;
do{
findNew=false;
for (int r=0; r<row; r++){
for (int c=0; c<col; c++){
if (findCost(r, c)){
display();
printf("array[%d][%d]\n", r, c);
findNew=true;
}
}
display();
}
}
while (findNew);
void Bellman::display(){
for (int i=0; i<row; i++){
printf("\t%c", i+'A');
}
printf("\n------------------------------\n");
for (int r=0; r<row; r++){
printf("%c\t", r+'A');
for (int c=0; c<col; c++){
if (nodeMatrix[r][c].index!=INFINITE){
printf("(%c,%d)\t", nodeMatrix[r][c].index+'A', nodeMatrix[r]
[c].cost);
}
else{
printf("(-,-)\t");
}
}
printf("\n");
}
}
void Bellman::displayMatrix(){
matrix.display();
}
////////***********************///////////////
#include <iostream>
#include <cmath>
#include <fstream>
#include "matrix.h"
Matrix& Matrix::transposition(){
double hold;
int temp;
for (int r =0; r< rowNum; r++){
for (int c=0; c< r; c++){
hold = lst[r][c];
lst[r][c] = lst[c][r];
lst[c][r] = hold;
}
}
temp = rowNum;
rowNum = colNum;
colNum = temp;
return (*this);
}
void Matrix::initialize(){
for (int r=0; r < rowNum; r++){
for (int c=0; c< colNum; c++){
lst[r][c] = r*2+c;
}
}
}
long preFlag;
int number=0;
preFlag = cout.flags();
//temp = cout.precision(4);
//cout.setf(ios::fixed);
cout<<"\nrow\\col";
for (int c=0; c< colNum; c++){
cout<<" "<<c;
}
cout<<"\n\n";
for (int r = 0; r< rowNum; r++){
cout<<r<<"\t ";
number = 0;
for (int c = 0; c< colNum; c++){
cout<<(fabs(lst[r][c])<LIMIT?0:lst[r][c])<<" ";
if (fabs(lst[r][c])>=LIMIT){
number++;
}
}
if (displayNumber){
cout<<number;
}
cout<<endl;
}
//cout.precision(temp);
//cout.flags(preFlag);arreglar
}
Matrix::Matrix(){
rowNum = 5;
colNum = 5;
initialize();
}
//////////////////*******************////////////////////////////////
#ifndef MATRIX_H
#define MATRIX_H
const int MaxRow = 10;
const int MaxCol = 10;
const double LIMIT = 0.01;
class Matrix{
private:
int rowNum;
int colNum;
double lst[MaxRow][MaxCol];
protected:
void initialize();
Matrix& transposition();
};
//#endif
Autor
Richard Ernest Bellman (1920–1984) fue un matemático aplicado, cuya mayor contribución fue
la metodología denominada programación dinámica.
Bellman estudió matemáticas en la universidad de Brooklyn(EE. UU.), donde obtuvo una
diplomatura, y luego en la universidad de Wisconsin, donde obtuvo su licenciatura.
Posteriormente comenzó a trabajar en el laboratorio nacional de Los Álamos(EE. UU.) En el
campo de la física teórica. En 1946 obtuvo su doctorado en la universidad de Princeton(EE. UU.).
También ejerció la docencia en la universidad del sur de California(EE. UU.), fue socio de la
academia americana de las artes y las ciencias (1975) y de la academia nacional americana de
ingeniería (1977). En 1979 el IEEE le otorgó la medalla de honor por su contribución a la teoría
de los sistemas de control y de los procesos de decisión, en especial por su contribución con la
programación dinámica y por la ecuación de Bellman.
Bibliografía
http://www.staroceans.com/
http://www.dzone.com/links/rss/5_commonly_neglected_parts_of_websites.html
https://belenus.unirioja.es/~secarcam/redes/analisis/encaminamiento/algoritmos/bellman-
ford.html
2. Dijkstra
Procedimiento
Encontrar las rutas más cortas entre un nodo origen dado y todos los demás nodos, desarrollando
los caminos en orden creciente de longitud
N = conjunto de nodos en la red
s = nodo origen
T = lista o conjunto de nodos añadidos o incorporados por el algoritmo
w(i, j) = coste del enlace desde el nodo i al nodo j:
w(i, i) = 0
w(i, j) = ∞ si los dos nodos no se encuentran directamente conectados
w(i, j) ≥ 0 si los dos nodos están directamente conectado
L(n) = coste en curso obtenido por el algoritmo para el camino de mínimo coste del nodo s al
nodo n:
Al finalizar el algoritmo, L(n) es el coste del camino de mínimo coste de s a n
Iteración T L(2) Ruta L(3) Ruta L(4) Ruta L(5) Ruta L(6) Ruta
1 {1} 2 1–2 5 1-3 1 1–4 ∞ - ∞ -
2 {1,4} 2 1–2 4 1-4-3 1 1–4 2 1-4–5 ∞ -
3 {1, 2, 4} 2 1–2 4 1-4-3 1 1–4 2 1-4–5 ∞ -
4 {1, 2, 4, 5} 2 1–2 3 1-4-5–3 1 1–4 2 1-4–5 4 1-4-5–6
5 {1, 2, 3, 4, 5} 2 1–2 3 1-4-5–3 1 1–4 2 1-4–5 4 1-4-5–6
6 {1, 2, 3, 4, 5, 6} 2 1-2 3 1-4-5-3 1 1-4 2 1-4–5 4 1-4-5-6
Según el algoritmo de Dijkstra deberemos seguir los nodos V1-V4-V5-V6, por ser los que menor
coste nos ocasionan.
Autor
Dijkstra estudió física teórica en la Universidad de Leiden. Trabajó como investigador para
Burroughs Corporation a principios de los años 1970. En la Universidad de Texas en Austin,
Estados Unidos, ocupó el Schlumberger Centennial Chair in Computer Sciences. Se retiró en
2000.
Entre sus contribuciones a la informática está el algoritmo de caminos mínimos; también
conocido como Algoritmo de Dijkstra. Recibió el Premio Turing en 1972.
Era conocido por su baja opinión de la sentencia GOTO en programación, que culminó en 1968
con el artículo Go To Statement Considered Harmful, visto como un paso importante hacia el
rechazo de la expresión GOTO y de su eficaz reemplazo por estructuras de control tales como el
bucle while. El famoso título del artículo no era obra de Dijkstra, sino de Niklaus Wirth, entonces
redactor de Comunicaciones del ACM. Dijkstra era un aficionado bien conocido de Algol60, y
trabajó en el equipo que desarrolló el primer compilador para este lenguaje. En ese mismo año
creó el primer sistema operativo con estructura jerárquica, de niveles o capas. Fue denominado
THE (Technische Hogeschool, Eindhoven) que se utilizó con fines didácticos.
Desde los años 70, el principal interés de Dijkstra fue la verificación formal. La opinión que
prevalecía entonces era que uno debe primero escribir un programa y seguidamente proporcionar
una prueba matemática de su corrección. Dijkstra objetó que las pruebas que resultan son largas e
incómodas, y que la prueba no da ninguna comprensión de cómo se desarrolló el programa. Un
método alternativo es la derivación de programas, «desarrollar prueba y programa
conjuntamente». Uno comienza con una especificación matemática del programa que se supone
va a hacer y aplica transformaciones matemáticas a la especificación hasta que se transforma en
un programa que pueda ser ejecutado. El programa que resulta entonces es sabido correcto por la
construcción. Mucho de los últimos trabajos de Dijkstra tratan sobre las maneras de hacer fluida
la argumentación matemática.
Dijkstra murió el 6 de agosto de 2002 después de una larga lucha contra el cáncer.
En lenguaje algoritmico
metodo dijkstra(L[n,n])
Entero: D[n], i, j, menor, pos
Logico: S[n]
Para i desde 2 hasta n hacer
S[i]falso
D[i]L[1,j]
fPara
S[1] verdad
Para i desde 2 hasta n-1 hacer
menor Menor(D, S, pos)
S[pos] verdad
Para i desde 2 hasta n hacer
si(no(S[i])) Entonces
D[i] minimo(D[j],D[pos],L[pos, j])
fSi
fPara
fPara
Return(D)
finMetodo
finFuncion
/*
Name: Dijkstra®
Author: ALEJANDRO REYES MARZANO
Description: es una aplicacion de grafos de caminos
minimos
Date: 30/05/09 23:55 PM
Copyright: ©2008-2009 alemsoft corp
*/
#include <iostream.h>
#include <conio.h>
#include <conio.c>
#include <stdlib.h>
#include <fstream.h>
#include <string.h>
#include <cmath>
#include <cstring>
using namespace std;
int destino, origem, vertices = 0;
int custo, *costos = NULL;
int menu();
void crearGrafo(void);
void caminosMinimos(void);
void dijkstra(int vertices, int origen, int destino, int
*costos);
void main(){
textbackground(15);
int op;
do{
op = menu();
switch(op){
case 1: crearGrafo();
break;
case 2: caminosMinimos();
break;
case 0:
break;
}
}while (op!=0);
getche();
}
int menu(){
Alejandro Reyes Marzano Página 15
MATEMATICA DISCRETA FISI UNMSM
int opc,x=20,y=12;
do{
clrscr();
system("cls");
textcolor(78);
gotoxy(x,y+3); cout<<"ELIJA LA OPCION QUE DESEA
REALIZAR:";
gotoxy(x,y+7);
cout<<"ÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ";
gotoxy(x,y+8);
cout<<"ÛÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿Û";
gotoxy(x,y+9); cout<<"Û³ [0]<---- SI DESEA SALIR
³Û";
gotoxy(x,y+10); cout<<"ÛÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
´Û";
gotoxy(x,y+11); cout<<"Û³ [1]<----CREAR GRAFO
³Û";
gotoxy(x,y+12); cout<<"ÛÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
´Û";
gotoxy(x,y+13); cout<<"Û³ [2]<----ALGORITMO DE DIJKSTRA
³Û";
gotoxy(x,y+14); cout<<"ÛÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
´Û";
gotoxy(x,y+15); cout<<"Û³ INGRESE OPCION
³Û";
gotoxy(x,y+16);
cout<<"ÛÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙÛ";
gotoxy(x,y+17);
cout<<"ÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ";
gotoxy(x+27,y+15); cin>>opc;
} while(opc<0 || opc>2);
return opc;
}
void crearGrafo(void){
clrscr();
system("cls");
do{
cout <<"\nINGRESE EL NUMERO DE NODOS MINIMO 2 NODOS: ";
cin>>vertices;
}while (vertices < 2 );
if (!costos)
delete(costos);
costos = new int[vertices * vertices];
for (int i = 0; i <= vertices * vertices; i++){
costos[i] = -1;
}
void caminosMinimos(void){
int i, j;
clrscr();
system("cls");
cout <<" \n\tLISTA DE CAMINOS MINIMOS DEL GRAFO DADO: \n\n";
for (i = 1; i <= vertices; i++) {
for (j = 1; j <= vertices; j++)
dijkstra(vertices, i,j, costos);
cout<<endl;
}
system("PAUSE");
getche();
}
dist[i] = dist[v] +
costos[v*vertices+i];
ant[i] =v;
}
}
}
}while (v != destino - 1 && min != HUGE_VAL);
// Muestra el resultado de la búsqueda
cout << "\tDEL VERTICE " << (char)(origen+96) << " HACIA EL
VERTICE "<<(char)(destino+96)<<" \t";
if (min == HUGE_VAL) {
cout <<"NO EXISTE\n";
cout<<"\tCOSTO: \t0 \n";
}
else {
i = destino;
i = ant[i-1];
while (i != -1) {
tmp[cont] = i+1;
cont++;
i = ant[i];
}
for (i = cont; i > 0; i--) {
cout<< (char)(96+tmp[i-1])<<" ÄÄÄ> ";
}
cout <<(char)(96+ destino);
cout <<"\n\tCOSTO: " << dist[destino-1] <<"\n";
}
delete (dist);
delete (ant);
delete (tmp);
delete (z);
}
Codigo en java
Para la implementacion en java se ha usado diferentes clases de esa manera para facilitar el
manejo con la interfaz grafica.
La clase nodo es una clase que encapsulas las coordenadas x, y como atributo y extiende ña cñase
Point2D de java, que nos servirá para definir la posición de los nodos y los puntos inicial y final
de las aristas
/**
Name: Punto®
Author: ALEJANDRO REYES MARZANO
@Override
public void setLocation(double x, double y) {
this.x = (int) Math.floor(x+0.5);
this.y = (int) Math.floor(y+0.5);
}
@Override
public int hashCode() {
int hash = 7;
hash = 17 * hash + this.x;
hash = 17 * hash + this.y;
return hash;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof Punto) {
Punto pt = (Punto)obj;
return (x == pt.x) && (y == pt.y);
}
return super.equals(obj);
}
La clase Nodo es una clase descendiente de la clase punto de la que hereda todos los atributos y
métodos, además encapsula diferentes atributos de funcionalidad.
/**
Name: Nodo®
Author: ALEJANDRO REYES MARZANO
Description: es una aplicacion de grafos de caminos
minimos
Date: 30/05/09 23:55 PM
Copyright: ©2008-2009 alemsoft corp
*/
package dijkstra;
import java.awt.*;
public Nodo() {
this(0,0);
this.distActual=-1;
this.distFinal=-1;
//color=Color.blue;
}
/**
* @return the distActual
*/
public int getDistActual() {
return distActual;
}
/**
* @param distActual the distActual to set
*/
public void setDistActual(int distActual) {
this.distActual = distActual;
}
/**
* @return the distFinal
*/
public int getDistFinal() {
return distFinal;
}
/**
* @param distFinal the distFinal to set
*/
public void setDistFinal(int distFinal) {
this.distFinal = distFinal;
}
/**
* @return the color
*/
public Color getColor() {
return color;
/**
* @param color the color to set
*/
public void setColor(Color color) {
this.color = color;
}
/**
* @return the cambio
*/
public boolean isCambio() {
return cambio;
}
/**
* @param cambio the cambio to set
*/
public void setCambio(boolean cambio) {
this.cambio = cambio;
}
}
La clase Arista es una clase que encapsula los puntos iniciales ,finales y la posición de la flecha
de orientación del arco del grafo.
/**
Name: Arista®
Author: ALEJANDRO REYES MARZANO
Description: es una aplicacion de grafos de caminos
minimos
Date: 30/05/09 23:55 PM
Copyright: ©2008-2009 alemsoft corp
*/
package dijkstra;
public Arista() {
this.pFinal=new Punto();
this.pInical=new Punto();
this.pFlecha=new Punto();
}
/**
* @return the peso
*/
public int getPeso() {
return peso;
}
/**
* @param peso the peso to set
*/
public void setPeso(int peso) {
this.peso = peso;
}
/**
* @return the pInical
*/
public Punto getPInical() {
return pInical;
}
/**
* @param pInical the pInical to set
*/
public void setPInical(Punto pInical) {
this.pInical = pInical;
}
/**
* @return the pFinal
*/
public Punto getPFinal() {
return pFinal;
}
/**
* @param pFinal the pFinal to set
*/
public void setPFinal(Punto pFinal) {
this.pFinal = pFinal;
}
/**
* @return the pFlecha
*/
public Punto getPFlecha() {
return pFlecha;
}
/**
* @param pFlecha the pFlecha to set
*/
public void setPFlecha(Punto pFlecha) {
this.pFlecha = pFlecha;
}
/**
* @return the direccionX
*/
public float getDireccionX() {
return direccionX;
}
/**
* @param direccionX the direccionX to set
*/
public void setDireccionX(float direccionX) {
this.direccionX = direccionX;
}
/**
* @return the direccionY
*/
public float getDireccionY() {
return direccionY;
}
/**
* @param direccionY the direccionY to set
*/
public void setDireccionY(float direccionY) {
this.direccionY = direccionY;
}
/**
* @return the estado
*/
public boolean isEstado() {
return estado;
}
/**
* @param estado the estado to set
*/
public void setEstado(boolean estado) {
this.estado = estado;
}
}
Esta clase se define como una plantilla que sirve para el manejo de persistencia de los datos.
/**
Name: Archivo®
Author: ALEJANDRO REYES MARZANO
Description: es una aplicacion de grafos de caminos
minimos
Date: 30/05/09 23:55 PM
Copyright: ©2008-2009 alemsoft corp
*/
package dijkstra;
import java.io.*;
La clase Grafo es una clase que encapsula los nodos y las aristas del Grafo definido.
/**
Name: Grafo®
Author: ALEJANDRO REYES MARZANO
Description: es una aplicacion de grafos de caminos
minimos
Date: 30/05/09 23:55 PM
Copyright: ©2008-2009 alemsoft corp
*/
package dijkstra;
public Grafo() {
this.nodos=new Nodo[MAX];
this.aristas=new Arista[MAX][MAX];
this.inic();
}
/** hacer una arista nueva del nodo nodo1 al nodo2 con peso
peso, o
* cambiar el peso de la arista a w, calcular la posicion
* resultante de la flecha*/
getAristas()[nodo1][nodo2].setPFinal(new Punto((int)
(getNodos()[nodo2].x-FACTOR*getAristas()[nodo1]
[nodo2].getDireccionY()),(int)(getNodos()
[nodo2].y+FACTOR*getAristas()[nodo1][nodo2].getDireccionY())));
}
else {
getAristas()[nodo1][nodo2].setPInical(new
Punto(getNodos()[nodo1].x, getNodos()[nodo1].y));
getAristas()[nodo1][nodo2].setPFinal(new
Punto(getNodos()[nodo2].x, getNodos()[nodo2].y));
}
// la distancia de la flecha no es todo el camino a los
puntos de inicio/final
dx = (int)(Math.abs(FACTOR1*getAristas()[nodo1]
[nodo2].getDireccionX()));
dy = (int)(Math.abs(FACTOR1*getAristas()[nodo1]
[nodo2].getDireccionY()));
// calcular nueva posicion en x de la flecha
if (getAristas()[nodo1]
[nodo2].getPInical().x>getAristas()[nodo1][nodo2].getPFinal().x)
{
getAristas()[nodo1][nodo2].setPFlecha(new
Punto(getAristas()[nodo1][nodo2].getPFinal().x + dx +
(Math.abs(getAristas()[nodo1][nodo2].getPFinal().x-getAristas()
[nodo1][nodo2].getPInical().x) - 2*dx )*(FACTOR2-peso)/FACTOR2 ,
0));
}
else {
getAristas()[nodo1][nodo2].setPFlecha(new
Punto(getAristas()[nodo1][nodo2].getPInical().x + dx +
(Math.abs(getAristas()[nodo1][nodo2].getPFinal().x-getAristas()
[nodo1][nodo2].getPInical().x) - 2*dx )*peso/FACTOR2, 0));
}
// calcular nueva posicion en y de la flecha
if (getAristas()[nodo1]
[nodo2].getPInical().y>getAristas()[nodo1][nodo2].getPFinal().y)
{
aristas[nodo1][nodo2].getPFlecha().y=getAristas()
[nodo1][nodo2].getPFinal().y + dy +(Math.abs(getAristas()[nodo1]
[nodo2].getPFinal().y-getAristas()[nodo1][nodo2].getPInical().y)
- 2*dy )*(FACTOR2-peso)/FACTOR2;
}
else {
aristas[nodo1][nodo2].getPFlecha().y=getAristas()
[nodo1][nodo2].getPInical().y + dy +(Math.abs(getAristas()[nodo1]
[nodo2].getPFinal().y-getAristas()[nodo1][nodo2].getPInical().y)
- 2*dy )*peso/FACTOR2;
}
}
/**
* @return the nodos
*/
public Nodo[] getNodos() {
return nodos;
}
/**
* @param nodos the nodos to set
*/
public void setNodos(Nodo[] nodos) {
this.nodos = nodos;
}
/**
* @return the aristas
*/
public Arista[][] getAristas() {
return aristas;
}
/**
* @param aristas the aristas to set
*/
public void setAristas(Arista[][] aristas) {
this.aristas = aristas;
}
La clase DibujoGrafo es una clase que nos permite el manejo gráfico del Grafo, esta clase
extiende la clase Canvas de java que nos proporciona diferentes métodos para los dibujos, es
decir se comporta como un lienzo. Además implementa la interfaz Runnable que permitirá el
manejo de hilos de ejecución para la simulación paso a paso en la ejecución del algoritmo.
/**
Name: DibujoGrafo®
Author: ALEJANDRO REYES MARZANO
Description: es una aplicacion de grafos de caminos
minimos
Date: 30/05/09 23:55 PM
Copyright: ©2008-2009 alemsoft corp
*/
package dijkstra;
import java.awt.*;
public DibujoGrafo() {
public DibujoGrafo(FrameDijkstra f) {
this.f=f;
init();
numHilos=Grafo.DIJKSTRA;
setBackground(cFondo);
}
getGrafo().getNodos()[i].setDistActual(-1);
getGrafo().getNodos()[i].setDistFinal(-1);
for (int j=0; j<Grafo.MAXNODOS;j++)
getGrafo().getAristas()[i][j].setEstado(false);
}
getGrafo().getNodos()[getNodoInicial()].setDistActual(0);
getGrafo().getNodos()[getNodoInicial()].setDistFinal(0);
setPaso(0);
}
@Override
/**es un metodo que se hereda de la interfaz Runnable
* sirve para poner en ejecucion los hilos*/
public void run() {
for(int i=0; i<(getNumeroNodos()-getNodosVacios()); i++){
siguiente();
try {
Thread.sleep(2000);//para controlar la velocidad
en 2 segundos
}
catch (InterruptedException e) {
getF().getJTextAreaEjecucion().setText(e.toString
());//muestra el mensaje de interupcion
}
}
setHilo(null);
}
@Override
/** preparar nueva imagen fuera de la pantalla*/
public final synchronized void update(Graphics g) {
Dimension d=this.size();
if ((getImagenPant() == null) || (d.width !=
getImagenTam().width) ||(d.height != getImagenTam().height)) {
setImagenPant(createImage(d.width, d.height));
setImagenTam(d);
setImagenG(getImagenPant().getGraphics());
}
getImagenG().setColor(getCFondo());
getImagenG().fillRect(0, 0, d.width, d.height);
paint(getImagenG());//llama a la funcion paint para
pintar en la pantalla
g.drawImage(getImagenPant(), 0, 0, null);
}
@Override
/**accion del mause para mover en la pantalla*/
public boolean mouseUp(Event evt, int x, int y) {
if ( (!isCerrar()) && isClicked() ) {
if (isMoverNodo()) {
// mover el nodo si la nueva posicion no esta muy
cerca a otro nodo o fuera del panel
grafo.getNodos()[nodo1]=new Nodo();
if ( nodohit(x, y, 50) || (x<0) ||
(x>this.size().width) ||(y<0) || (y>this.size().height) ) {
grafo.getNodos()[nodo1]=(Nodo)getAntPos();
getF().mostrarTexto(12);
}
else
grafo.getNodos()[nodo1]=new Nodo(x, y);
for (int i=0;i<getNumeroNodos();i++) {
if (getGrafo().getAristas()[i]
[getNodo1()].getPeso()>0)
getGrafo().nuevoArco(i,
getNodo1(),getGrafo().getAristas()[i][getNodo1()].getPeso());
if (getGrafo().getAristas()[getNodo1()]
[i].getPeso()>0)
getGrafo().nuevoArco(getNodo1(),i,
getGrafo().getAristas()[getNodo1()][i].getPeso());
}
setMoverNodo(false);
}
else
if (isEliminarNodo()) {
eliminarNodo();
setEliminarNodo(false);
}
else
if (isNuevaArista()) {
setNuevaArista(false);
if (nodohit(x, y, Grafo.RADIONODO*2)) {
setNodo2(getHitnodo());
if (getNodo1()!=getNodo2()) {
getGrafo().nuevoArco(getNodo1(),
getNodo2(), 50);
if (getGrafo().getAristas()
[getNodo2()][getNodo1()].getPeso()>0) {
getGrafo().nuevoArco( getNodo
2(),getNodo1(), getGrafo().getAristas()[getNodo2()]
[getNodo1()].getPeso());
}
getF().mostrarTexto(5);
}
else
getF().getJTextAreaEjecucion().se
tText("ups ale");
}
}
else
if (isMoverArista()) {
setMoverArista(false);
if (getGrafo().getAristas()
[getNodo1()][getNodo2()].getPeso()>0)
cambiarPeso(x, y);
}
else
if (isMoverInicial()) {
// si la nueva posicion es un
nodo, este nodo es el nodoInicial
if (nodohit(x, y,
2*Grafo.RADIONODO))
setNodoInicial(getHitnodo());
getGrafo().getNodos()
[getNodoInicial()].setColor(cNodoInic);
setMoverInicial(false);
}
repaint();
}
return true;
}
@Override
/**para mover un nodo*/
public boolean mouseDown(Event evt, int x, int y) {
if (isCerrar())
getF().mostrarTexto(14);
else {
setClicked(true);
if (evt.shiftDown()) {
// mover un nodo
if (nodohit(x, y, 2*Grafo.RADIONODO)) {
setAntPos(getGrafo().getNodos()
[getHitnodo()]);
setNodo1(getHitnodo());
setMoverNodo(true);
}
}
else
if (evt.controlDown()) {
// borrar un nodo
if (nodohit(x, y, 2*Grafo.RADIONODO)) {
setNodo1(getHitnodo());
if (getNodoInicial()==getNodo1()) {
setMoverInicial(true);
setActualPos(new Nodo(x, y));
getGrafo().getNodos()
[getNodoInicial()].setColor(cNodo);
}
else
this.setEliminarNodo(true);
}
}
else
if (clickArista(x, y, 5)) {
// cambiar peso de una arista
setMoverArista(true);
repaint();
}
else
if (nodohit(x, y, Grafo.RADIONODO*2)) {
// dibuja una nueva arista
if (!isNuevaArista()) {
setNuevaArista(true);
setActualPos(new Nodo(x, y));
setNodo1(getHitnodo());
}
}
else
if ( !nodohit(x, y, 50) && !
clickArista(x, y, 50) ) {
// dibuja nuevo nodo
if (getNodosVacios()==0) {
// toma el siguiente punto
disponible en el arreglo
if (getNumeroNodos() <
Grafo.MAXNODOS)
grafo.getNodos()
[numeroNodos++]=new Nodo(x, y);
else
getF().mostrarTexto(15);
}
else {
// tomar un punto vacio en el
array (de algun nodo borrado previamente)
int i;
for
(i=0;i<getNumeroNodos();i++)
if (getGrafo().getNodos()
[i].x==-100)
break;
grafo.getNodos()[i]=new
Nodo(x, y);
setNodosVacios(getNodosVacios
() - 1);
}
}
else
// mouseclick para cerrar a un
point r flecha, probablemente un error
getF().mostrarTexto(12);
repaint();
}
return true;
}
@Override
public boolean mouseDrag(Event evt, int x, int y) {
if ( (!isCerrar()) && isClicked() ) {
if (isMoverNodo()) {
// mover nodo y ajustar aristas entrando/saliendo
del nodo
grafo.getNodos()[nodo1]=new Nodo(x, y);
for (int i=0;i<getNumeroNodos();i++) {
if (getGrafo().getAristas()[i]
[getNodo1()].getPeso()>0) {
getGrafo().nuevoArco(i,
getNodo1(),getGrafo().getAristas()[i][getNodo1()].getPeso());
}
if (getGrafo().getAristas()[getNodo1()]
[i].getPeso()>0) {
getGrafo().nuevoArco(getNodo1(),i,
getGrafo().getAristas()[getNodo1()][i].getPeso());
}
}
repaint();
}
else
if (isMoverInicial() || isNuevaArista()) {
setActualPos(new Punto(x, y));
repaint();
}
else
if (isMoverArista()) {
cambiarPeso(x, y);
repaint();
}
}
return true;
}
grafo.getNodos()[0]=new Nodo(x,y);
grafo.getNodos()[1]=new Nodo(3*x,y);
grafo.getNodos()[2]=new Nodo(5*x,y);
grafo.getNodos()[3]=new Nodo(7*x,y);
grafo.getNodos()[4]=new Nodo(x,4*y);
grafo.getNodos()[5]=new Nodo(3*x,4*y);
grafo.getNodos()[6]=new Nodo(5*x,4*y);
grafo.getNodos()[7]=new Nodo(7*x,4*y);
grafo.getNodos()[8]=new Nodo(x,7*y);
grafo.getNodos()[9]=new Nodo(3*x,7*y);
grafo.getNodos()[10]=new Nodo(5*x,7*y);
grafo.getNodos()[11]=new Nodo(7*x,7*y);
getGrafo().getAristas()[0][1].setPeso(15);
getGrafo().getAristas()[0][4].setPeso(85);
getGrafo().getAristas()[0][5].setPeso(95);
getGrafo().getAristas()[1][0].setPeso(80);
getGrafo().getAristas()[1][2].setPeso(13);
getGrafo().getAristas()[1][5].setPeso(16);
getGrafo().getAristas()[2][6].setPeso(69);
getGrafo().getAristas()[2][1].setPeso(11);
getGrafo().getAristas()[2][3].setPeso(14);
getGrafo().getAristas()[3][2].setPeso(37);
getGrafo().getAristas()[3][7].setPeso(31);
getGrafo().getAristas()[4][0].setPeso(71);
getGrafo().getAristas()[4][5].setPeso(73);
getGrafo().getAristas()[4][8].setPeso(37);
getGrafo().getAristas()[5][1].setPeso(19);
getGrafo().getAristas()[5][6].setPeso(37);
getGrafo().getAristas()[5][9].setPeso(23);
getGrafo().getAristas()[6][7].setPeso(16);
getGrafo().getAristas()[6][10].setPeso(38);
getGrafo().getAristas()[7][6].setPeso(9);
getGrafo().getAristas()[7][11].setPeso(30);
getGrafo().getAristas()[8][9].setPeso(58);
getGrafo().getAristas()[8][4].setPeso(12);
getGrafo().getAristas()[9][5].setPeso(28);
getGrafo().getAristas()[9][8].setPeso(9);
getGrafo().getAristas()[9][10].setPeso(45);
getGrafo().getAristas()[10][6].setPeso(56);
getGrafo().getAristas()[10][11].setPeso(9);
getGrafo().getAristas()[11][7].setPeso(23);
getGrafo().getAristas()[11][10].setPeso(23);
for (int i=0;i<getNumeroNodos();i++)
for (int j=0;j<getNumeroNodos();j++)
if (getGrafo().getAristas()[i][j].getPeso()>0)
getGrafo().nuevoArco(i,
j,getGrafo().getAristas()[i][j].getPeso());
repaint();
}
y1= (int)(getGrafo().getAristas()[i][j].getPFlecha().y -
3*getGrafo().getAristas()[i][j].getDireccionY() -
6*getGrafo().getAristas()[i][j].getDireccionX());
y2= (int)(getGrafo().getAristas()[i][j].getPFlecha().y -
3*getGrafo().getAristas()[i][j].getDireccionY() +
6*getGrafo().getAristas()[i][j].getDireccionX() );
y3= (int)(getGrafo().getAristas()[i][j].getPFlecha().y +
6*getGrafo().getAristas()[i][j].getDireccionY());
int flecha_x[] = { x1, x2, x3, x1 };
int flecha_y[] = { y1, y2, y3, y1 };
// si la arista ya se escogio por el algoritmo cambiar
color
if (getGrafo().getAristas()[i][j].isEstado())
g.setColor(cCorto);
// dibuja arista
g.drawLine(getGrafo().getAristas()[i][j].getPInical().x,
getGrafo().getAristas()[i][j].getPInical().y,
getGrafo().getAristas()[i][j].getPFinal().x,
getGrafo().getAristas()[i][j].getPFinal().y);
//dibuja flecha
g.fillPolygon(flecha_x, flecha_y, 4);
// escribe el peso de la arista en una posicion apropiada
int dx = (int)(Math.abs(7*getGrafo().getAristas()[i]
[j].getDireccionY()));
int dy = (int)(Math.abs(7*getGrafo().getAristas()[i]
[j].getDireccionX()));
String str = new String(" " + getGrafo().getAristas()[i]
[j].getPeso());
g.setColor(Color.black);
if ((getGrafo().getAristas()[i]
[j].getPInical().x>getGrafo().getAristas()[i][j].getPFinal().x)
&& (getGrafo().getAristas()[i]
[j].getPInical().y>=getGrafo().getAristas()[i][j].getPFinal().y))
g.drawString( str, getGrafo().getAristas()[i]
[j].getPFlecha().x + dx, getGrafo().getAristas()[i]
[j].getPFlecha().y - dy);
if ((getGrafo().getAristas()[i]
[j].getPInical().x>=getGrafo().getAristas()[i][j].getPFinal().x)
&& (getGrafo().getAristas()[i]
[j].getPInical().y<getGrafo().getAristas()[i][j].getPFinal().y))
g.drawString( str, getGrafo().getAristas()[i]
[j].getPFlecha().x - getFmetrics().stringWidth(str) - dx
,getGrafo().getAristas()[i][j].getPFlecha().y - dy);
if ((getGrafo().getAristas()[i]
[j].getPInical().x<getGrafo().getAristas()[i][j].getPFinal().x)
&& (getGrafo().getAristas()[i]
[j].getPInical().y<=getGrafo().getAristas()[i][j].getPFinal().y))
g.drawString( str,getGrafo().getAristas()[i]
[j].getPFlecha().x - getFmetrics().stringWidth(str)
,getGrafo().getAristas()[i][j].getPFlecha().y +
getFmetrics().getHeight());
if ((getGrafo().getAristas()[i]
[j].getPInical().x<=getGrafo().getAristas()[i][j].getPFinal().x)
&& (getGrafo().getAristas()[i]
[j].getPInical().y>getGrafo().getAristas()[i][j].getPFinal().y))
g.drawString( str, getGrafo().getAristas()[i]
[j].getPFlecha().x + dx,getGrafo().getAristas()[i]
[j].getPFlecha().y + getFmetrics().getHeight() );
}
g.setColor(cNodo);
}
[getNodo1()][getNodo2()].getPFinal().y-getGrafo().getAristas()
[getNodo1()][getNodo2()].getPInical().y) ) {
siga_x = true;
}
// encuentra la nueva posicion de la flecha, y calcula
// el peso correspondiente
if (siga_x) {
int hbound = Math.max(getGrafo().getAristas()
[getNodo1()][getNodo2()].getPInical().x,getGrafo().getAristas()
[getNodo1()][getNodo2()].getPFinal().x)-Math.abs(diff_x);
int lbound = Math.min(getGrafo().getAristas()
[getNodo1()][getNodo2()].getPInical().x,getGrafo().getAristas()
[getNodo1()][getNodo2()].getPFinal().x)+Math.abs(diff_x);
// la arista debe quedarse entre los nodos
if (x<lbound) {
grafo.getAristas()[nodo1]
[nodo2].getPFlecha().x=lbound;
}
else
if (x>hbound) {
grafo.getAristas()[nodo1]
[nodo2].getPFlecha().x=hbound;
}
else
grafo.getAristas()[nodo1]
[nodo2].getPFlecha().x=x;
grafo.getAristas()[nodo1]
[nodo2].getPFlecha().y=(getGrafo().getAristas()[getNodo1()]
[getNodo2()].getPFlecha().x-getGrafo().getAristas()[getNodo1()]
[getNodo2()].getPInical().x) *(getGrafo().getAristas()
[getNodo1()][getNodo2()].getPFinal().y-getGrafo().getAristas()
[getNodo1()][getNodo2()].getPInical().y)/(getGrafo().getAristas()
[getNodo1()][getNodo2()].getPFinal().x-getGrafo().getAristas()
[getNodo1()][getNodo2()].getPInical().x) +getGrafo().getAristas()
[getNodo1()][getNodo2()].getPInical().y;
// nuevo peso
getGrafo().getAristas()[getNodo1()]
[getNodo2()].setPeso(Math.abs(getGrafo().getAristas()[getNodo1()]
[getNodo2()].getPFlecha().x-getGrafo().getAristas()[getNodo1()]
[getNodo2()].getPInical().x-diff_x)*100/(hbound-lbound));
}
// hacer lo mismo si sigue y
else {
int hbound = Math.max(getGrafo().getAristas()
[getNodo1()][getNodo2()].getPInical().y,getGrafo().getAristas()
[getNodo1()][getNodo2()].getPFinal().y)-Math.abs(diff_y);
@Override
/**metodo extendido de la clase antecesor y nos permite
hacer
*la programacion grafica*/
public void paint(Graphics g) {
setDistanciaMinima(0);
setNodosmin(Grafo.MAXNODOS);
setAristaConDistMin(Grafo.MAXNODOS);
setPosNodoConDistMin(Grafo.MAXNODOS);
for(int i=0; i<Grafo.MAXNODOS; i++)
getGrafo().getNodos()[i].setCambio(false);
setNumCambios(0);
setvecinos(0);
g.setFont(getRoman());
g.setColor(Color.black);
if (getPaso()==1)
g.fillOval(getActualPos().x-Grafo.RADIONODO,
getActualPos().y-Grafo.RADIONODO,Grafo.RADIONODO*2,
Grafo.RADIONODO*2);
g.setColor(Color.black);
// termina este paso del algoritmo
if (isEnEjecucion())
endstepalg(g);
// dibuja circulos negros alrededor de los nodos, escribe
sus nombres a la pantalla
g.setFont(getHelvetica());
for (int i=0; i<getNumeroNodos(); i++)
if (getGrafo().getNodos()[i].x>0) {
g.setColor(Color.black);
g.drawOval(getGrafo().getNodos()[i].x-
Grafo.RADIONODO, getGrafo().getNodos()[i].y-
Grafo.RADIONODO,Grafo.RADIONODO*2,Grafo.RADIONODO*2);
g.setColor(cNodoInic);
g.drawString(intToString(i),
getGrafo().getNodos()[i].x-14, getGrafo().getNodos()[i].y-14);
}
}
/**
* @return the cFondo
*/
public Color getCFondo() {
return cFondo;
}
/**
* @param cFondo the cFondo to set
*/
public void setCFondo(Color cFondo) {
this.cFondo = cFondo;
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final DibujoGrafo other = (DibujoGrafo) obj;
if (this.getGrafo() != other.getGrafo() &&
(this.getGrafo() == null || !this.grafo.equals(other.grafo))) {
return false;
}
return true;
}
@Override
public int hashCode() {
int hash = 5;
hash = 73 * hash + (this.getGrafo() != null ?
this.getGrafo().hashCode() : 0);
return hash;
}
/**
* @return the grafo
*/
public Grafo getGrafo() {
return grafo;
}
/**
* @param grafo the grafo to set
*/
public void setGrafo(Grafo grafo) {
this.grafo = grafo;
}
/**
* @return the roman
*/
public Font getRoman() {
return roman;
}
/**
* @param roman the roman to set
*/
public void setRoman(Font roman) {
this.roman = roman;
}
/**
* @return the helvetica
*/
public Font getHelvetica() {
return helvetica;
}
/**
* @param helvetica the helvetica to set
*/
public void setHelvetica(Font helvetica) {
this.helvetica = helvetica;
}
/**
* @return the fmetrics
*/
public FontMetrics getFmetrics() {
return fmetrics;
}
/**
* @param fmetrics the fmetrics to set
*/
public void setFmetrics(FontMetrics fmetrics) {
this.fmetrics = fmetrics;
}
/**
* @return the nodoInicial
*/
public int getNodoInicial() {
return nodoInicial;
}
/**
* @param nodoInicial the nodoInicial to set
*/
public void setNodoInicial(int nodoInicial) {
this.nodoInicial = nodoInicial;
}
/**
* @return the numeroNodos
*/
public int getNumeroNodos() {
return numeroNodos;
}
/**
* @param numeroNodos the numeroNodos to set
*/
public void setNumeroNodos(int numeroNodos) {
this.numeroNodos = numeroNodos;
}
/**
* @return the numHilos
*/
public int getNumHilos() {
return numHilos;
}
/**
* @param numHilos the numHilos to set
*/
public void setNumHilos(int numHilos) {
this.numHilos = numHilos;
}
/**
* @return the paso
*/
public int getPaso() {
return paso;
}
/**
* @param paso the paso to set
*/
public void setPaso(int paso) {
this.paso = paso;
}
/**
* @return the numCambios
*/
public int getNumCambios() {
return numCambios;
}
/**
* @param numCambios the numCambios to set
*/
public void setNumCambios(int numCambios) {
this.numCambios = numCambios;
}
/**
* @return the vecinos
*/
public int getVecinos() {
return vecinos;
}
/**
* @param vecinos the vecinos to set
*/
public void setvecinos(int vecinos) {
this.vecinos = vecinos;
}
/**
* @return the nodo1
*/
public int getNodo1() {
return nodo1;
}
/**
* @param nodo1 the nodo1 to set
*/
public void setNodo1(int nodo1) {
this.nodo1 = nodo1;
}
/**
* @return the nodo2
*/
public int getNodo2() {
return nodo2;
}
/**
* @param nodo2 the nodo2 to set
*/
public void setNodo2(int nodo2) {
this.nodo2 = nodo2;
}
/**
* @return the distanciaMinima
*/
public int getDistanciaMinima() {
return distanciaMinima;
}
/**
* @param distanciaMinima the distanciaMinima to set
*/
public void setDistanciaMinima(int distanciaMinima) {
this.distanciaMinima = distanciaMinima;
}
/**
* @return the nodosmin
*/
public int getNodosmin() {
return nodosmin;
}
/**
* @param nodosmin the nodosmin to set
*/
public void setNodosmin(int nodosmin) {
this.nodosmin = nodosmin;
}
/**
* @return the aristaConDistMin
*/
public int getAristaConDistMin() {
return aristaConDistMin;
}
/**
* @param aristaConDistMin the aristaConDistMin to set
*/
public void setAristaConDistMin(int aristaConDistMin) {
this.aristaConDistMin = aristaConDistMin;
}
/**
* @return the posNodoConDistMin
*/
public int getPosNodoConDistMin() {
return posNodoConDistMin;
}
/**
* @param posNodoConDistMin the posNodoConDistMin to set
*/
public void setPosNodoConDistMin(int posNodoConDistMin) {
this.posNodoConDistMin = posNodoConDistMin;
/**
* @return the nodosVacios
*/
public int getNodosVacios() {
return nodosVacios;
}
/**
* @param nodosVacios the nodosVacios to set
*/
public void setNodosVacios(int nodosVacios) {
this.nodosVacios = nodosVacios;
}
/**
* @return the h
*/
public int getH() {
return h;
}
/**
* @param h the h to set
*/
public void setH(int h) {
this.h = h;
}
/**
* @return the hitnodo
*/
public int getHitnodo() {
return hitnodo;
}
/**
* @param hitnodo the hitnodo to set
*/
public void setHitnodo(int hitnodo) {
this.hitnodo = hitnodo;
}
/**
* @return the actualPos
*/
/**
* @param actualPos the actualPos to set
*/
public void setActualPos(Punto actualPos) {
this.actualPos = actualPos;
}
/**
* @return the antPos
*/
public Punto getAntPos() {
return antPos;
}
/**
* @param antPos the antPos to set
*/
public void setAntPos(Punto antPos) {
this.antPos = antPos;
}
/**
* @return the enEjecucion
*/
public boolean isEnEjecucion() {
return enEjecucion;
}
/**
* @param enEjecucion the enEjecucion to set
*/
public void setEnEjecucion(boolean enEjecucion) {
this.enEjecucion = enEjecucion;
}
/**
* @return the cerrar
*/
public boolean isCerrar() {
return cerrar;
}
/**
/**
* @return the nuevaArista
*/
public boolean isNuevaArista() {
return nuevaArista;
}
/**
* @param nuevaArista the nuevaArista to set
*/
public void setNuevaArista(boolean nuevaArista) {
this.nuevaArista = nuevaArista;
}
/**
* @return the moverArista
*/
public boolean isMoverArista() {
return moverArista;
}
/**
* @param moverArista the moverArista to set
*/
public void setMoverArista(boolean moverArista) {
this.moverArista = moverArista;
}
/**
* @return the moverNodo
*/
public boolean isMoverNodo() {
return moverNodo;
}
/**
* @param moverNodo the moverNodo to set
*/
public void setMoverNodo(boolean moverNodo) {
this.moverNodo = moverNodo;
}
/**
* @return the eliminarNodo
*/
public boolean isEliminarNodo() {
return eliminarNodo;
}
/**
* @param eliminarNodo the eliminarNodo to set
*/
public void setEliminarNodo(boolean eliminarNodo) {
this.eliminarNodo = eliminarNodo;
}
/**
* @return the clicked
*/
public boolean isClicked() {
return clicked;
}
/**
* @param clicked the clicked to set
*/
public void setClicked(boolean clicked) {
this.clicked = clicked;
}
/**
* @return the moverInicial
*/
public boolean isMoverInicial() {
return moverInicial;
}
/**
* @param moverInicial the moverInicial to set
*/
public void setMoverInicial(boolean moverInicial) {
this.moverInicial = moverInicial;
}
/**
* @return the hilo
*/
public Thread getHilo() {
return hilo;
}
/**
* @param hilo the hilo to set
*/
public void setHilo(Thread hilo) {
this.hilo = hilo;
}
/**
* @return the f
*/
public FrameDijkstra getF() {
return f;
}
/**
* @param f the f to set
*/
public void setF(FrameDijkstra f) {
this.f = f;
}
/**
* @return the sms
*/
public String getSms() {
return sms;
}
/**
* @param sms the sms to set
*/
public void setSms(String sms) {
this.sms = sms;
}
/**
* @return the imagenPant
*/
public Image getImagenPant() {
return imagenPant;
}
/**
* @param imagenPant the imagenPant to set
*/
public void setImagenPant(Image imagenPant) {
this.imagenPant = imagenPant;
}
/**
* @return the imagenG
*/
public Graphics getImagenG() {
return imagenG;
}
/**
* @param imagenG the imagenG to set
*/
public void setImagenG(Graphics imagenG) {
this.imagenG = imagenG;
}
/**
* @return the imagenTam
*/
public Dimension getImagenTam() {
return imagenTam;
}
/**
* @param imagenTam the imagenTam to set
*/
public void setImagenTam(Dimension imagenTam) {
this.imagenTam = imagenTam;
}
}
/**
Name: FrameDijkstra®
Author: ALEJANDRO REYES MARZANO
Description: es una aplicacion de grafos de caminos
minimos
Date: 30/05/09 23:55 PM
Copyright: ©2008-2009 alemsoft corp
*/
package dijkstra;
import javax.swing.*;
import java.io.*;
setDefaultCloseOperation(javax.swing.WindowConstants.DO_N
OTHING_ON_CLOSE);
setTitle(".::Algoritmo de Dijkstra::.");
setMinimumSize(new java.awt.Dimension(900, 700));
jPanelHerramientas.setLayout(new java.awt.GridLayout(1,
0));
jToolBar1.setRollover(true);
jButton1.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/iconos/liveResults
.png"))); // NOI18N
jButton1.setToolTipText("Demo");
jButton1.setFocusable(false);
jButton1.setHorizontalTextPosition(javax.swing.SwingConst
ants.CENTER);
jButton1.setVerticalTextPosition(javax.swing.SwingConstan
ts.BOTTOM);
jButton1.addActionListener(new
java.awt.event.ActionListener() {
public void
actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});
jToolBar1.add(jButton1);
jButtonEjecucion.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/iconos/rerun-
icon.png"))); // NOI18N
jButtonEjecucion.setToolTipText("Ejecutar");
jButtonEjecucion.setFocusable(false);
jButtonEjecucion.setHorizontalTextPosition(javax.swing.Sw
ingConstants.CENTER);
jButtonEjecucion.setVerticalTextPosition(javax.swing.Swin
gConstants.BOTTOM);
jButtonEjecucion.addActionListener(new
java.awt.event.ActionListener() {
public void
actionPerformed(java.awt.event.ActionEvent evt) {
jButtonEjecucionActionPerformed(evt);
}
});
jToolBar1.add(jButtonEjecucion);
jButtonPasoAPaso.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/iconos/autorefresh
-icon.png"))); // NOI18N
jButtonPasoAPaso.setToolTipText("Paso a Paso");
jButtonPasoAPaso.setFocusable(false);
jButtonPasoAPaso.setHorizontalTextPosition(javax.swing.Sw
ingConstants.CENTER);
jButtonPasoAPaso.setVerticalTextPosition(javax.swing.Swin
gConstants.BOTTOM);
jButtonPasoAPaso.addActionListener(new
java.awt.event.ActionListener() {
public void
actionPerformed(java.awt.event.ActionEvent evt) {
jButtonPasoAPasoActionPerformed(evt);
}
});
jToolBar1.add(jButtonPasoAPaso);
jButtonRestablecer.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/iconos/reset-
icon.png"))); // NOI18N
jButtonRestablecer.setToolTipText("Restablecer");
jButtonRestablecer.setFocusable(false);
jButtonRestablecer.setHorizontalTextPosition(javax.swing.
SwingConstants.CENTER);
jButtonRestablecer.setVerticalTextPosition(javax.swing.Sw
ingConstants.BOTTOM);
jButtonRestablecer.addActionListener(new
java.awt.event.ActionListener() {
public void
actionPerformed(java.awt.event.ActionEvent evt) {
jButtonRestablecerActionPerformed(evt);
}
});
jToolBar1.add(jButtonRestablecer);
jButtonBorrar.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/iconos/resetResult
s.png"))); // NOI18N
jButtonBorrar.setToolTipText("Borrar Grafo");
jButtonBorrar.setFocusable(false);
jButtonBorrar.setHorizontalTextPosition(javax.swing.Swing
Constants.CENTER);
jButtonBorrar.setVerticalTextPosition(javax.swing.SwingCo
nstants.BOTTOM);
jButtonBorrar.addActionListener(new
java.awt.event.ActionListener() {
public void
actionPerformed(java.awt.event.ActionEvent evt) {
jButtonBorrarActionPerformed(evt);
}
});
jToolBar1.add(jButtonBorrar);
jPanelHerramientas.add(jToolBar1);
jToolBar2.setRollover(true);
jButtonAyuda.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/iconos/help.gif"))
); // NOI18N
jButtonAyuda.setToolTipText("Ayuda");
jButtonAyuda.setFocusable(false);
jButtonAyuda.setHorizontalTextPosition(javax.swing.SwingC
onstants.CENTER);
jButtonAyuda.setVerticalTextPosition(javax.swing.SwingCon
stants.BOTTOM);
jButtonAyuda.addActionListener(new
java.awt.event.ActionListener() {
public void
actionPerformed(java.awt.event.ActionEvent evt) {
jButtonAyudaActionPerformed(evt);
}
});
jToolBar2.add(jButtonAyuda);
salir.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/iconos/clearFilter
.png"))); // NOI18N
salir.setToolTipText("Salir");
salir.setFocusable(false);
salir.setHorizontalTextPosition(javax.swing.SwingConstant
s.CENTER);
salir.setVerticalTextPosition(javax.swing.SwingConstants.
BOTTOM);
salir.addActionListener(new
java.awt.event.ActionListener() {
public void
actionPerformed(java.awt.event.ActionEvent evt) {
salirActionPerformed(evt);
}
});
jToolBar2.add(salir);
jPanelHerramientas.add(jToolBar2);
jTabbedPane1.addTab("Grafo", jPanelHerramientas);
jToolBar3.setRollover(true);
jButtonNuevo.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/iconos/nuevo.png")
)); // NOI18N
jButtonNuevo.setToolTipText("Nuevo Grafo");
jButtonNuevo.setFocusable(false);
jButtonNuevo.setHorizontalTextPosition(javax.swing.SwingC
onstants.CENTER);
jButtonNuevo.setVerticalTextPosition(javax.swing.SwingCon
stants.BOTTOM);
jToolBar3.add(jButtonNuevo);
jButtonGuardarC.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/iconos/save.png"))
); // NOI18N
jButtonGuardarC.setToolTipText("Guardar Como ...");
jButtonGuardarC.setFocusable(false);
jButtonGuardarC.setHorizontalTextPosition(javax.swing.Swi
ngConstants.CENTER);
jButtonGuardarC.setVerticalTextPosition(javax.swing.Swing
Constants.BOTTOM);
jToolBar3.add(jButtonGuardarC);
jButtonAbrir.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/iconos/open.png"))
); // NOI18N
jButtonAbrir.setToolTipText("Abrir");
jButtonAbrir.setFocusable(false);
jButtonAbrir.setHorizontalTextPosition(javax.swing.SwingC
onstants.CENTER);
jButtonAbrir.setVerticalTextPosition(javax.swing.SwingCon
stants.BOTTOM);
jToolBar3.add(jButtonAbrir);
jButtonGuardar.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/iconos/export.png"
))); // NOI18N
jButtonGuardar.setToolTipText("Guardar");
jButtonGuardar.setFocusable(false);
jButtonGuardar.setHorizontalTextPosition(javax.swing.Swin
gConstants.CENTER);
jButtonGuardar.setVerticalTextPosition(javax.swing.SwingC
onstants.BOTTOM);
jToolBar3.add(jButtonGuardar);
jPanel1.add(jToolBar3);
jTabbedPane1.addTab("Archivo", jPanel1);
jToolBar4.setRollover(true);
jButton7.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/iconos/takeSnapsho
t.png"))); // NOI18N
jButton7.setToolTipText("Color de fondo");
jButton7.setFocusable(false);
jButton7.setHorizontalTextPosition(javax.swing.SwingConst
ants.CENTER);
jButton7.setVerticalTextPosition(javax.swing.SwingConstan
ts.BOTTOM);
jButton7.addActionListener(new
java.awt.event.ActionListener() {
public void
actionPerformed(java.awt.event.ActionEvent evt) {
jButton7ActionPerformed(evt);
}
});
jToolBar4.add(jButton7);
jPanel2.add(jToolBar4);
jTabbedPane1.addTab("Herramientas", jPanel2);
getContentPane().add(jTabbedPane1,
java.awt.BorderLayout.PAGE_START);
jInternalFrame1.setClosable(true);
jInternalFrame1.setIconifiable(true);
jInternalFrame1.setMaximizable(true);
jInternalFrame1.setResizable(true);
jInternalFrame1.setTitle("Salida");
jInternalFrame1.setToolTipText("Salida");
jInternalFrame1.setVisible(true);
jTextAreaEjecucion.setColumns(20);
jTextAreaEjecucion.setFont(new java.awt.Font("Courier
New", 0, 14));
jTextAreaEjecucion.setRows(5);
jScrollPane1.setViewportView(jTextAreaEjecucion);
jInternalFrame1.getContentPane().add(jScrollPane1,
java.awt.BorderLayout.CENTER);
getContentPane().add(jInternalFrame1,
java.awt.BorderLayout.PAGE_END);
jInternalFrameGrafo.setClosable(true);
jInternalFrameGrafo.setIconifiable(true);
jInternalFrameGrafo.setMaximizable(true);
jInternalFrameGrafo.setTitle("Grafos");
jInternalFrameGrafo.setAutoscrolls(true);
jInternalFrameGrafo.setVisible(true);
jInternalFrameGrafo.getContentPane().add(colores,
java.awt.BorderLayout.CENTER);
getContentPane().add(jInternalFrameGrafo,
java.awt.BorderLayout.CENTER);
try {
jInternalFrameGrafo.setMaximum(true);
} catch (java.beans.PropertyVetoException e1) {
e1.printStackTrace();
}
pack();
}// </editor-fold>
private void
jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
if (!cerrar)
dibujo.demo();
else
this.mostrarTexto(14);
private void
jButtonEjecucionActionPerformed(java.awt.event.ActionEvent evt) {
if (!cerrar)
dibujo.ejecucion();
else
this.mostrarTexto(14);
}
private void
jButtonRestablecerActionPerformed(java.awt.event.ActionEvent evt)
{
dibujo.inicializar();
this.jButtonPasoAPaso.setToolTipText("Paso a Paso");
this.mostrarTexto(0);
}
private void
jButtonPasoAPasoActionPerformed(java.awt.event.ActionEvent evt) {
String arg=jButtonPasoAPaso.getToolTipText();
if (evt.getSource() instanceof JButton) {
if (((String)arg).equalsIgnoreCase("Paso a Paso")) {
if (!cerrar) {
jButtonPasoAPaso.setToolTipText("Otro Paso");
dibujo.paso();
}
else
mostrarTexto(14);
}
if (((String)arg).equalsIgnoreCase("Otro Paso"))
dibujo.siguiente();
}
}
private void
jButtonBorrarActionPerformed(java.awt.event.ActionEvent evt) {
dibujo.limpiar();
this.jButtonPasoAPaso.setToolTipText("Paso a Paso");
this.mostrarTexto(14);
}
private void
jButton7ActionPerformed(java.awt.event.ActionEvent evt) {
java.awt.Color c=JColorChooser.showDialog(this, "Grafo
Fisi", java.awt.Color.red);
this.dibujo.setCFondo(c);
}
private void
jButtonAyudaActionPerformed(java.awt.event.ActionEvent evt) {
this.mostrarTexto(0);
}
private void
jButton8ActionPerformed(java.awt.event.ActionEvent evt) {
java.awt.Color c=JColorChooser.showDialog(this, "Grafo
Fisi", java.awt.Color.red);
this.jTextAreaEjecucion.setBackground(c);
}
break;
case
4:getJTextAreaEjecucion().setText(dibujarAristas);
break;
case 5:getJTextAreaEjecucion().setText(cambiarPeso);
break;
case
6:getJTextAreaEjecucion().setText(borrarAristas);
break;
case 7:getJTextAreaEjecucion().setText(borrar);
break;
case 8:getJTextAreaEjecucion().setText(ejecutar);
break;
case 9:getJTextAreaEjecucion().setText(pasoAPaso);
break;
case 10:getJTextAreaEjecucion().setText(demo);
break;
case 11:getJTextAreaEjecucion().setText(dibujarNodo);
break;
case 12:getJTextAreaEjecucion().setText(toclose);
break;
case 13:getJTextAreaEjecucion().setText(fin);
break;
case 14:getJTextAreaEjecucion().setText(cerrado);
break;
case 15:getJTextAreaEjecucion().setText(maxnodos);
break;
case 16:getJTextAreaEjecucion().setText(ninguno);
break;
case 17:getJTextAreaEjecucion().setText(alguno);
break;
}
}
/**
* @retorna el area de texto donde se puede colocar un texto
para
* mostrar en la pantalla
*/
public javax.swing.JTextArea getJTextAreaEjecucion() {
return jTextAreaEjecucion;
}
/**
* @param jTextAreaEjecucion the jTextAreaEjecucion to set
*/
public void setJTextAreaEjecucion(javax.swing.JTextArea
jTextAreaEjecucion) {
this.jTextAreaEjecucion = jTextAreaEjecucion;
}
javax.swing.JOptionPane.showMessageDialog(null,
"Error de archivo inexistente\n"+excepcion.getMessage());
return false;
}
}
}
if(dirty) {
caption = "*" + caption;
}
caption = "contactos - " + caption;
this.setTitle(caption);
}
this.dirty = false;
//lblBarraEstado.setText("Opened "+fila);
tituloAplicacion();
}
catch(Exception ex){
ex.printStackTrace();
}
}
@Override
protected void processWindowEvent(java.awt.event.WindowEvent
e) {
super.processWindowEvent(e);
if(e.getID() == java.awt.event.WindowEvent.WINDOW_CLOSING)
salir(null);
}
void salvar(java.awt.event.ActionEvent e) {
saveFile();
}
public Guardar(FrameDijkstra g) {
this.g = g;
}
Hacer click en el boton demo para poder ejecutar un grafo de demostración del algortimo.
En la pantalla se mostrara el siguiente Grafo y luego hacer click en el botón paso a paso.
Paso 01
Paso 2
Paso 3
Paso 4
Paso 5
Paso 6
Paso 7
Paso 8
Paso 9
Paso 10
Paso 11
Paso 12
Condiciones: Se aplica en una red estrictamente orientada, entendiendo que cada una de sus
ramas es unidireccional y ningún conjunto, de ramas incluidas, forma ciclo. También se utiliza
una etiqueta que puede ser de carácter temporal, o bien permanente, para cada uno de los nodos
graficados. Algo para anotar es que, una red, con todas sus ramas unidireccionales, ya tiene
definido el nodo origen. Los pasos a seguir del algoritmo de Dijkstra son:
1. El nodo origen siempre se etiqueta permanente así: (-, 0) P
2. Enseguida debe etiquetarse permanente aquel nodo que tenga como único inverso al
origen: ( # del origen, costo cero + costo desde el origen ) P
3. A partir de los nodos con permanencia deben etiquetarse en forma temporal, los que sean
nodos vecinos directos conectados a los mismos. Luego se revisan las temporales, con el
propósito de eliminar la etiqueta duplicada y mantener una sola ( la que tenga el menor
costo), para cada nodo directo.
4. Convertir a permanente, aquel nodo que tenga todos sus nodos vecinos inversos con etiqueta
permanente. En caso de empate en menor costo, se deben considerar todas las etiquetas que
cumplan tal condición.
5. Se repite el procedimiento desde el paso 3, hasta que todos los nodos tengan etiqueta
permanente.
6. Las rutas mínimas para cada uno de los nodos, se definen con la identificación del nodo
inmediato anterior de la ruta en el lado izquierdo de la etiqueta permanente, retrocediendo
hacia el origen conforme a lo indicado. El proceso se completa señalando las n-1 rutas
calculadas, tanto en la red como en una tabla.
Ejemplo 4-13. Ruta mínima en red orientada acíclica (RUMINDO1).
En la siguiente red orientada acíclica de 7 nodos (Figura 4-81), determinar las rutas mínimas
desde el origen O hacia los restantes nodos, utilizando el algoritmo de Dijkstra.
Aplicación del algoritmo de Dijkstra al ejemplo Rumindo1.- Primero se verifica que la red
estudiada no presenta ciclos (por favor revise sección de definiciones). Se inicia con el paso 1 en
el origen O etiquetando permanente así: ( - , 0 ) P
En el paso 2 del algoritmo para red orientada, debe buscarse el nodo que tiene como único
inverso al origen O; se observa que el nodo A cumple tal requisito y se etiqueta con permanente:
Para continuar debe anotarse que los nodos O, A, B, tienen permanencia, mientras C y R son
temporales; los nodos S y T aún no se etiquetan. Se regresa al paso 3 para etiquetar con temporal
los nodos vecinos directos de B como sigue: C ( B, 9+5 = 14 ) t ; S ( B, 9+3 = 12 ) t ; R ( B, 9+6
= 15 ) t; en la revisión por duplicidad se eliminan las temporales: C ( B, 14 ) t; R ( B, 15 ) t. En el
paso 4 se revisan los nodos con relación a sus inversos; el nodo S no cumple porque su inverso C
es temporal; el nodo R tampoco cumple porque su inverso S aún es temporal; en cambio el nodo
C ( sus inversos O y B ya tienen permanencia) si cumple y por lo tanto su etiqueta pasa a
permanente: C ( O, 7 ) P COC = 7
Ahora observe que los nodos O, A, B, C, ya tienen permanencia; mientras R y S tienen temporal;
el nodo T aún no se etiqueta. Otra vez en el paso 3, se etiqueta con temporal el nodo S que es
vecino directo del nodo C de reciente permanencia: S, ( C, 7+2 = 9 ) t; en este mismo nodo, por
duplicidad se elimina la temporal S, (B, 12) t y se conserva S, (C, 9) t . El paso 4 empieza con la
revisión de nodos inversos de las etiquetas temporales de R y S. El nodo R no puede pasar a
permanencia, porque su inverso S es temporal; pero el nodo S si puede, porque sus inversos B y
Mínimo Z = 13XOA + 9XOB + 7XOC + 4XAB + 10XAR + 5XBC + 6XBR + 3XBS + 2XCS + 8XRT + 4XSR +
11XST
Tercera parte.- Sujeta a restricciones de conservación de flujo:
Figura 4-84. Red ejemplo RUMINDO2, se muestra solución con rutas de Dijkstra
Bibliografía
https://belenus.unirioja.es/~secarcam/redes/analisis/encaminamiento/algoritmos/dijkstra.html
http://es.wikipedia.org/wiki/Algoritmo_de_Dijkstra
http://www.upiicsa.ipn.mx/polilibros/portal/Polilibros/P_terminados/Investigacion_de_Operacion
es_Careaga/Common/IO-modulo4-rutaminimadijkstra.htm
http://es.wikipedia.org/wiki/Dijkstra
http://www.alumnos.unican.es/uc900/AlgoritmoD1.htm