Materia: SISTEMAS DE INFORMÁTICA Docente: Mtra. Alma Nidya Cuautle Rodríguez Alumno: Jorge Alexis Perez Cruz Matricula:83934 Grupo: K040 Actividad: Actividad de aprendizaje 4. Teoría de grafos Licenciatura: Ingeniería en Sistemas Computacionales
Actividad de aprendizaje 4. Teoría de grafos En matemáticas y en ciencias de la computación, la teoría de grafos (también llamada teoría de las gráficas) estudia las propiedades de los grafos (también llamadas gráficas). Un grafo es un conjunto, no vacío, de objetos llamados vértices (o nodos) y una selección de pares de vértices, llamados aristas (edges en inglés) que pueden ser orientados o no. Típicamente, un grafo se representa mediante una serie de puntos (los vértices) conectados por líneas (las aristas).
Historia Puentes de Königsberg. El trabajo de Leonhard Euler, en 1736, sobre el problema de los puentes de Königsberg es considerado el primer resultado de la teoría de grafos. También se considera uno de los primeros resultados topológicos en geometría (que no depende de ninguna medida). Este ejemplo ilustra la profunda relación entre la teoría de grafos y la topología. En 1845 Gustav Kirchhoff publicó sus leyes de los circuitos para calcular el voltaje y la corriente en los circuitos eléctricos. En 1852 Francis Guthrie planteó el problema de los cuatro colores que plantea si es posible, utilizando solamente cuatro colores, colorear cualquier mapa de países de tal forma que dos países vecinos nunca tengan el mismo color. Este problema, que no fue resuelto hasta un siglo después por Kenneth Appel y Wolfgang Haken, puede ser considerado como el nacimiento de la teoría de grafos. Al tratar de resolverlo, los matemáticos definieron términos y conceptos teóricos fundamentales de los grafos.
Estructuras de datos en la representación de grafos Existen diferentes formas de almacenar grafos en una computadora. La estructura de datos usada depende de las características del grafo y el algoritmo usado para manipularlo. Entre las estructuras más sencillas y usadas se encuentran las listas y las matrices, aunque frecuentemente se usa una combinación de ambas. Las listas son preferidas en grafos dispersos porque tienen un eficiente uso de la memoria. Por otro lado, las matrices proveen acceso rápido, pero pueden consumir grandes cantidades de memoria.
Código Fuente Clases Creadas
Algoritmo_Dijkstra.java Algoritmo_Prim.java Arboles.java Nodo.java Pintar.java Ventanas
EliminarAristas.java Matrices.java VentanaArista.java VentanaPrincipal.java
Algoritmo_Dijkstra.java package Clases;
import static Ventanas.VentanaPrincipal.jPanel1; import static Ventanas.VentanaPrincipal.R_repaint; import static Ventanas.VentanaPrincipal.ingresarNodoOrigen; import java.awt.Color; import javax.swing.JOptionPane;
public class Algoritmo_Dijkstra { private Arboles arboles; private int subTope; private Nodo auxi=null;
private int auxAumulado; // es un acumulado auxiliar private int subAcomulado; private Nodo nodo[]; private int tope; private int permanente; private int nodoFin;
public Algoritmo_Dijkstra (Arboles arboles, int tope,int permanente, int nodoFin){ this.arboles = arboles; this.tope = tope; this.nodo= new Nodo[tope]; this.permanente = permanente; this.nodoFin = nodoFin;
}
public int getAcumulado(){ return nodo[nodoFin].getAcumulado(); }
public void dijkstra(){ for (int i = 0; i < tope; i++) // creamos el vector nodo del tamaño de tope el cual tiene el numero de nodo pintados nodo[i]= new Nodo();
if(permanente != nodoFin){ jPanel1.paint(jPanel1.getGraphics()); R_repaint(tope, arboles); Pintar.clickSobreNodo(jPanel1.getGraphics(), arboles.getCordeX(permanente), arboles.getCordeY(permanente), null,Color.GREEN); // pinta de color GREEN los nodos
nodo[permanente].setVisitado(true); nodo[permanente].setNombre(permanente);
do{ subAcomulado=0; auxAumulado = 2000000000; // lo igualamos a esta cifra ya q el acomulado de los nodos, supuestamente nunca sera mayor nodo[permanente].setEtiqueta(true); for (int j = 0; j < tope; j++) { if(arboles.getmAdyacencia(j, permanente)==1){ subAcomulado= nodo[permanente].getAcumulado()+arboles.getmCoeficiente(j, permanente); if(subAcomulado <= nodo[j].getAcumulado() && nodo[j].isVisitado()==true && nodo[j].isEtiqueta()== false){ nodo[j].setAcumulado(subAcomulado); nodo[j].setVisitado(true); nodo[j].setNombre(j); nodo[j].setPredecesor(nodo[permanente]); } else if( nodo[j].isVisitado()==false){ nodo[j].setAcumulado(subAcomulado); nodo[j].setVisitado(true); nodo[j].setNombre(j); nodo[j].setPredecesor(nodo[permanente]); } } } for (int i = 0; i
if(nodo[i].getAcumulado()<=auxAumulado){ permanente= nodo[i].getNombre(); auxAumulado= nodo[i].getAcumulado(); } } } subTope++; }while(subTope
}
Algoritmo_Prim.java
package Clases;
import static Ventanas.VentanaPrincipal.R_repaint; import static Ventanas.VentanaPrincipal.ingresarNodoOrigen; import static Ventanas.VentanaPrincipal.jPanel1; import java.awt.Color;
public class Algoritmo_Prim {
private int cumulado; private int aristaMenor; private int fin; private boolean estaNodo=false; private boolean aumentaTamano; private int nodoApuntado; private int nodoApuntador; private int tamano; private int arsitaMayor; private Arboles arboles; private int tope; private int nodoOrigen;
public Algoritmo_Prim(Arboles arbol , int top ,int aristaMayor ){ this.cumulado = 0; this.aristaMenor = 0; this.fin = 0; this.estaNodo=false;
this.aumentaTamano = false; this.nodoApuntado = 0; this.nodoApuntador = 0; this.tamano = 1; this. arsitaMayor=aristaMayor; this.arboles = arbol; this.tope = top; }
public int getCumulado() { return cumulado; }
public void prim(){ this.nodoOrigen= ingresarNodoOrigen("Ingrese Nodo Origen..","nodo Origen No existe",tope); jPanel1.paint(jPanel1.getGraphics()); R_repaint(tope,arboles); arboles.crearEnArbol(tope); arboles.setEnArbol(0, nodoOrigen); //algoritmo de Prim ---->> do{ this.aristaMenor = this.arsitaMayor; this.fin=2; for (int j = 0; j < tamano; j++) { for (int k = 0; k < tope; k++){ if(arboles.getmAdyacencia(k, arboles.getEnArbol(j))==1){ for (int h = 0; h < tamano; h++) { if(arboles.getEnArbol(h)==k ){ this.estaNodo=true;
break; } } if(estaNodo==false){ if(arboles.getmCoeficiente(k, arboles.getEnArbol(j))<=aristaMenor && arboles.getmCoeficiente(k, arboles.getEnArbol(j))>0 ){ aristaMenor=arboles.getmCoeficiente(k, arboles.getEnArbol(j)); this.nodoApuntado=k; this.aumentaTamano=true; this.nodoApuntador=arboles.getEnArbol(j); this.fin=1; } } this.estaNodo=false; } } }//fin for (int j = 0; j < tamano; j++) if(aumentaTamano==true){ Pintar.pintarCamino(jPanel1.getGraphics(),arboles.getCordeX(nodoApuntador), arboles.getCordeY(nodoApuntador),arboles.getCordeX(nodoApuntado), arboles.getCordeY(nodoApuntado),Color.red); Pintar.clickSobreNodo(jPanel1.getGraphics(),arboles.getCordeX(nodoApuntador), arboles.getCordeY(nodoApuntador), null,Color. red); Pintar.clickSobreNodo(jPanel1.getGraphics(),arboles.getCordeX(nodoApuntado), arboles.getCordeY(nodoApuntado), null, Color.red); arboles.setEnArbol(tamano, nodoApuntado); this.tamano++; this.aumentaTamano=false; this.cumulado += this.aristaMenor; }
}while(fin<2); }
}
Arboles.java package Clases;
public class Arboles { private int mCoeficiente[][] = new int [51][51]; private int mAdyacencia [][] = new int [51][51]; private int cordeX [] = new int [51]; private int cordeY [] = new int [51]; private int nombre [] = new int [51]; private int enArbol [];
public Arboles(){
}
public int getmCoeficiente(int i, int j ) { return mCoeficiente[i][j];
}
public int getmAdyacencia(int i,int j) { return mAdyacencia[i][j]; }
public int getCordeX(int i) { return cordeX[i]; }
public int getCordeY(int i) { return cordeY[i]; }
public int getNombre(int i) { return nombre[i]; }
public int getEnArbol(int i) { return enArbol[i]; }
public void setmCoeficiente(int i,int j ,int mCoeficiente) { this.mCoeficiente[i][j] = mCoeficiente; }
public void setmAdyacencia(int i,int j ,int mAdyacencia) { this.mAdyacencia[i][j] = mAdyacencia; }
public void setCordeX(int i,int cordeX) { this.cordeX[i] = cordeX; }
public void setCordeY(int i, int cordeY) { this.cordeY[i] = cordeY; }
public void setNombre(int i,int nombre) { this.nombre[i] = nombre; }
public void setEnArbol(int i,int enArbol) { this.enArbol[i] = enArbol; } public void crearEnArbol(int i){ enArbol = new int [i]; }
}
Nodo.java package Clases;
public class Nodo { private int nombre ; private boolean visitado ; private boolean etiqueta; private int acumulado; // lleva el acoulado de cada nodo private Nodo Predecesor; public Nodo(){
this.nombre =-1; this.visitado = false; this.etiqueta = false; this.Predecesor = null; this.acumulado =0; } public int getNombre() { return nombre; } public boolean isVisitado() { return visitado; } public boolean isEtiqueta() { return etiqueta; } public int getAcumulado() { return acumulado; } public Nodo getPredecesor() { return Predecesor; } public void setNombre(int nombre) { this.nombre = nombre; } public void setVisitado(boolean visitado) { this.visitado = visitado; } public void setEtiqueta(boolean etiqueta) { this.etiqueta = etiqueta; } public void setAcumulado(int acomulado) { this.acumulado = acomulado; } public void setPredecesor(Nodo Predecesor) { this.Predecesor = Predecesor; }
}
Pintar.java package Clases;
import java.awt.BasicStroke; import java.awt.Color; import java.awt.Font; import static java.awt.Font.MONOSPACED; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.RenderingHints;
public class Pintar { Color color;
public Pintar(){
}
public static void pintarCirculo(Graphics g,int x,int y,String n){ //g.drawOval(x, y-10, 20, 20);
((Graphics2D)g).setColor(Color.blue); ((Graphics2D)g).setStroke(new BasicStroke(4));//leda el grosor al circulo ((Graphics2D)g).fillOval(x, y, 15, 15); ((Graphics2D)g).setColor(Color.BLACK); ((Graphics2D)g).drawOval(x, y, 15, 15);
((Graphics2D)g).setColor(Color.ORANGE); Font fuente=new Font("Monospaced",Font.BOLD, 16); g.setFont(fuente); ((Graphics2D)g).drawString(n, x, y);
}
public static void pintarLinea(Graphics g, int x1,int y1,int x2,int y2,int tam){ int xAux = 0; int yAux = 0; ((Graphics2D)g).setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); BasicStroke stroke = new BasicStroke(2); ((Graphics2D)g).setStroke(stroke); ((Graphics2D)g).drawLine(x1+10, y1+10, x2+10, y2+10); if(x1<=x2) xAux=((x2-x1)/2)+x1; if(x1>x2) xAux=((x1-x2)/2)+x2; if(y1=y2) yAux=((y1-y2)/2)+y2; // ((Graphics2D)g).setColor(Color.black); Font fuente=new Font("Monospaced",Font.PLAIN, 12); g.setFont(fuente);
((Graphics2D)g).drawString(String.valueOf(tam), xAux, yAux); } public static void pintarCamino(Graphics g, int x1,int y1,int x2,int y2, Color color){ ((Graphics2D)g).setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); BasicStroke stroke = new BasicStroke(2); ((Graphics2D)g).setStroke(stroke); g.setColor(color); g.drawLine(x1+10, y1+10, x2+10, y2+10); //g.drawString(String.valueOf(tam), x1, y1); } public static void clickSobreNodo(Graphics g,int x,int y,String n,Color co){ //g.drawOval(x, y-10, 20, 20); ((Graphics2D)g).setColor(co); ((Graphics2D)g).setStroke(new BasicStroke(4));//leda el grosor al circulo ((Graphics2D)g).fillOval(x, y, 15, 15); ((Graphics2D)g).setColor(Color.BLACK); ((Graphics2D)g).drawOval(x, y, 15, 15);
} }
EliminarAristas.java
Matrices.java
VentanaArista.java
VentanaPrincipal.java.