/**
* Inicializa la matriz de adyacencia según los nodos adyacentes del grafo pasado como parámetro
*
* @param g
*/
private void initAdy(Grafo g) {
for (Eje e : g.dameEjes()) {
int posV1 = pos(e.dameDesde().nodo, g.dameNodosV1());
int posV2 = pos(e.dameHasta().nodo, g.dameNodosV2());
ady[posV1][posV2] = true;
}
}
public int CalcularTiempoDeInfeccion(Grafo<String> grafo, Vertice<String> in) {
int nuevaDist = 0;
int maxDist = 0;
int n = grafo.listaDeVertices().tamanio();
int[] distancias = new int[n];
ColaGenerica<Vertice<String>> q = new ColaGenerica<Vertice<String>>();
for (int c = 0; c < n; c++) {
distancias[c] = Integer.MAX_VALUE;
}
distancias[in.posicion()] = 0;
q.encolar(in);
while (!q.esVacia()) {
Vertice<String> v = q.desencolar();
nuevaDist = distancias[v.posicion()] + 1;
ListaGenerica<Arista<String>> ady = grafo.listaDeAdyacentes(v);
ady.comenzar();
while (!ady.fin()) {
Arista<String> a = ady.proximo();
if (distancias[a.verticeDestino().posicion()] == Integer.MAX_VALUE) {
q.encolar(a.verticeDestino());
distancias[a.verticeDestino().posicion()] = nuevaDist;
if (nuevaDist > maxDist) {
maxDist = nuevaDist;
}
}
}
}
return maxDist;
}
public MatrizAdyacencia(Grafo g) {
int dimV1 = g.dameNodosV1().size();
int dimV2 = g.dameNodosV2().size();
ady = new boolean[dimV1][dimV2];
resetAdy();
initAdy(g);
initEjes(g);
}
public boolean induzido(Grafo grafo) {
int cont;
for (int i = 0; i < vColoridos.size(); i++) {
int nome = ((Integer) vColoridos.get(i)).intValue();
ArrayList adja = grafo.getAdjacencias(grafo.getVerticeByNome(nome));
cont = 0;
for (int j = 0; j < adja.size(); j++)
if ((grafo.getAcendedor()).estaAceso((Vertice) adja.get(j))) cont++;
if (cont != ((ArrayList) aColoridas.get(i)).size()) return false;
}
return true;
}
private void crearGrafoDePartidosArreglados(int cantidad, int cantPartidosArreglados) {
partidosArreglados = new Grafo();
for (int i = 0; i < cantPartidosArreglados; i++) {
partidosArreglados.agregar(s.nextInt(), s.nextInt());
}
// Agrego los nodos sin ejes.
if (partidosArreglados.getListaAdyacencia().keySet().size() != jugadores) {
for (int i = 1; i <= jugadores; i++) {
if (!partidosArreglados.tieneNodo(i)) {
partidosArreglados.agregar(i);
}
}
}
}
public int[][] listaAristas(Grafo g) { // ineficiente para grafos dispersos
int orden = g.orden();
int[][] lista = new int[2][g.cantAristas()];
int contador = 0;
for (int i = 0; i < orden; i++) {
for (int j = i + 1; j < orden; j++) {
if (g.hayArista(i, j)) {
lista[1][contador] = i;
lista[2][contador] = j;
contador++;
}
}
}
return lista;
}
public static void main(String args[]) {
Grafo teste = new Grafo();
teste.setVertices(lerGrafo(args[0]));
Vertice i1 = new Vertice();
Vertice i2 = new Vertice();
i1 = teste.encontrarVertice(args[1]);
i2 = teste.encontrarVertice(args[2]);
List<Vertice> resultado = new ArrayList<Vertice>();
Dijkstra algoritmo = new Dijkstra();
resultado = algoritmo.encontrarMenorCaminhoDijkstra(teste, i1, i2);
System.out.println("Esse é o menor caminho feito pelo algoritmo:" + resultado);
}
/** Test of crearGrafo method, of class Grafo. */
@Test
public void testCrearGrafo() {
System.out.println("crearGrafo");
String[] archivos = {"funcion1.sql", "funcion2.sql", "archivoNoValido.txt"};
String ubicacionArchivos = "/Users/juancarlos/tmp/";
Grafo instance = new Grafo();
List<Nodo> result = instance.crearGrafo(ubicacionArchivos, archivos, null);
for (int y = 0; y < result.size(); y++) {
System.out.println("archivo " + y + " " + result.get(y).getPrograma());
for (int x = 0; x < result.get(y).getLlamadas().size(); x++) {
System.out.println(
"archivo"
+ result.get(y).getPrograma()
+ " llama a "
+ result.get(y).getLlamadas().get(x).getPrograma());
}
}
}
/**
* Constructor copia.
*
* @param original Grafo que va a ser copiado.
*/
public Grafo(Grafo original) {
this();
this.nAristas = original.nAristas;
this.nVertices = original.nVertices;
int n = original.nVertices;
// Copiamos matriz de adyacencias
for (int i = 0; i < n; i++) {
Vertice v = new Vertice<>(original.vertices.get(i));
Integer grado = new Integer((int) original.grados.get(i));
if (i == 0) {
this.vertices.set(0, v);
this.grados.set(0, grado);
} else {
this.vertices.add(v);
this.grados.add(grado);
this.matrizAdyacencias.add(new ArrayList<Arista<N>>());
}
for (int j = 0; j < n; j++) {
Arista a = null;
if (i != j && original.adyacentes(i, j)) {
a = new Arista(original.arista(i, j));
}
if (i == 0 && j == 0) {
this.matrizAdyacencias.get(0).set(0, a);
} else {
this.matrizAdyacencias.get(i).add(a);
}
}
}
// Copiamos listas de adyacencias
for (int i = 0; i < this.nVertices; i++) {
ArrayList<Vertice<T>> nuevaLista = new ArrayList<>();
for (int j = 0; j < this.nVertices; j++) {
if (i != j && this.adyacentes(i, j)) {
nuevaLista.add(this.vertice(j));
}
}
this.listasAdyacencias.put(i, nuevaLista);
}
}
public int[][] listaAristas2(Grafo g) {
int n = g.orden();
int[][] a = new int[g.cantAristas()][2];
int k = -1;
List<Integer> list;
for (int i = 0; i < n; i++) {
list = g.getListaAdy(i);
if (!list.isEmpty()) {
for (Integer aList : list) {
int w = aList;
if (w > i) {
k++;
a[k][0] = i;
a[k][1] = w;
}
}
}
}
return a;
}
@SuppressWarnings("SleepWhileHoldingLock")
@Override
public void run() {
for (Arista actual : arbol.aristasB) {
try {
actual.marcar(lienzo.getGraphics());
sleep(arbol.getVel());
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
try {
sleep(100);
} catch (InterruptedException ex) {
}
arbol.aristasB.clear();
dialog(c[0], c[1]);
}
private void breadthFirstSearch(Grafo grafo, int verticeInicial) {
// long tempoInicial = System.currentTimeMillis();
Queue<Integer> q = new LinkedList<Integer>();
this.distancia[verticeInicial] = 0;
this.visitado[verticeInicial] = true;
q.add(verticeInicial);
while (!q.isEmpty()) {
int vertice = q.remove();
for (int adj : grafo.getVerticesAdjacentes(vertice)) {
if (!this.visitado[adj]) {
this.arestas[adj] = vertice;
this.distancia[adj] = this.distancia[vertice] + 1;
this.visitado[adj] = true;
q.add(adj);
}
}
}
// System.out.println("o bfs executou em " + (System.currentTimeMillis() - tempoInicial)+"ms");
}
public String execAnalise(Grafo grafo) {
vColoridos = new ArrayList(); // vertices coloridos
aColoridas = new ArrayList(); // arestas coloridas
for (int i = 0; i < grafo.getQtdVertices(); i++)
if ((grafo.getAcendedor()).estaAceso(grafo.getVertice(i)))
vColoridos.add(new Integer((grafo.getVertice(i)).getNome()));
if (vColoridos.size() != 0) {
for (int i = 0; i < vColoridos.size(); i++) {
Vertice colorido = grafo.getVerticeByNome(((Integer) vColoridos.get(i)).intValue());
ArrayList adjacencias = grafo.getAdjacencias(colorido);
ArrayList a = new ArrayList();
for (int j = 0; j < adjacencias.size(); j++) {
Vertice V = (Vertice) adjacencias.get(j);
if (pertenceColoridos(V.getNome()))
if ((grafo.getAcendedor()).estaAceso(grafo.getArestaEntreVertices(colorido, V)))
a.add(new Integer(V.getNome()));
}
aColoridas.add(a);
}
return subgrafo(grafo);
} else return "Escolha um subgrafo!";
}
public static List<Vertice> lerGrafo(String nomeArquivo) {
Grafo g = new Grafo();
Vertice v;
File f = new File(nomeArquivo);
String vertices[];
String linha;
ArrayList<String[]> s1 = new ArrayList<String[]>();
try {
BufferedReader br = new BufferedReader(new FileReader(f));
Map<String, Vertice> mapa = new HashMap<String, Vertice>();
while ((linha = br.readLine()) != null) {
if (linha.contains(",")) {
s1.add(linha.split("/"));
vertices = s1.get(0)[0].split(",");
v = (Vertice) mapa.get(vertices[0]);
if (v == null) v = new Vertice();
List<Vertice> vizinhosAtual = new ArrayList<Vertice>();
List<Aresta> arestasAtual = new ArrayList<Aresta>();
v.setDescricao(vertices[0]);
mapa.put(vertices[0], v);
if (linha.contains("/")) {
String pesoArestas[] = s1.get(0)[1].split(",");
for (int i = 1; i < vertices.length; i++) {
Vertice vit;
// vit = g.encontrarVertice(vertices[i]);
vit = mapa.get(vertices[i]);
if (vit == null) vit = new Vertice();
vit.setDescricao(vertices[i]);
vizinhosAtual.add(vit);
mapa.put(vertices[i], vit);
Aresta ait = new Aresta(v, vit);
ait.setPeso(Integer.parseInt(pesoArestas[i - 1]));
arestasAtual.add(ait);
}
v.setVizinhos(vizinhosAtual);
v.setArestas(arestasAtual);
}
}
// Vertices finais
else {
// v = g.encontrarVertice(linha);
v = (Vertice) mapa.get(linha);
if (v == null) v = new Vertice();
v.setDescricao(linha);
mapa.put(linha, v);
}
g.adicionarVertice(v);
s1.clear();
}
// catch do BufferedReader
} catch (FileNotFoundException e) {
System.out.println("Nao encontrou o arquivo");
e.printStackTrace();
}
// catch do readLine
catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// Retornando os vertices
return g.getVertices();
}
public Grafo resolverConGolosoRandom() {
Grafo grafo = instancia.dameGrafoOriginal().clone();
Grafo grafoTotal = instancia.dameGrafo().clone();
LinkedList<Nodo> nodosIV1 = new LinkedList<Nodo>(instancia.dameNodosIV1());
cantidadOperaciones = cantidadOperaciones + instancia.getCantidadDeOperaciones();
LinkedList<Nodo> nodosIV2 = new LinkedList<Nodo>(instancia.dameNodosIV2());
cantidadOperaciones = cantidadOperaciones + instancia.getCantidadDeOperaciones();
cantidadOperaciones = cantidadOperaciones + nodosIV1.size() + nodosIV2.size();
int sizeTotal = nodosIV1.size() + nodosIV2.size();
cantidadOperaciones = cantidadOperaciones + 4;
while (sizeTotal > 0) {
LinkedList<Nodo> nodosActuales;
boolean esIV1;
int randomIVx = randomGenerator.nextInt(2);
cantidadOperaciones = cantidadOperaciones + 1;
cantidadOperaciones = cantidadOperaciones + 1;
if (randomIVx == 0) {
cantidadOperaciones = cantidadOperaciones + nodosIV1.size() + 1;
if (nodosIV1.size() != 0) {
nodosActuales = nodosIV1;
esIV1 = true;
cantidadOperaciones = cantidadOperaciones + 2;
} else {
nodosActuales = nodosIV2;
esIV1 = false;
cantidadOperaciones = cantidadOperaciones + 2;
}
} else {
cantidadOperaciones = cantidadOperaciones + nodosIV2.size() + 1;
if (nodosIV2.size() != 0) {
nodosActuales = nodosIV2;
esIV1 = false;
cantidadOperaciones = cantidadOperaciones + 2;
} else {
nodosActuales = nodosIV1;
esIV1 = true;
cantidadOperaciones = cantidadOperaciones + 2;
}
}
Nodo nodoRandom;
if (esIV1) {
nodoRandom = grafoTotal.dameNodoConMayorGradoDeV1RestringidoA(nodosActuales);
cantidadOperaciones = cantidadOperaciones + grafoTotal.getCantidadDeOperaciones();
} else {
nodoRandom = grafoTotal.dameNodoConMayorGradoDeV2RestringidoA(nodosActuales);
cantidadOperaciones = cantidadOperaciones + grafoTotal.getCantidadDeOperaciones();
}
cantidadOperaciones = cantidadOperaciones + 2;
LinkedList<Eje> adyacentesHastaAhora =
instancia.dameEjesConAdyacentes(grafo, nodoRandom, esIV1);
cantidadOperaciones = cantidadOperaciones + grafo.getCantidadDeOperaciones();
cantidadOperaciones = cantidadOperaciones + instancia.getCantidadDeOperaciones();
int minCruces = Integer.MAX_VALUE;
int posMinCruce = -1;
cantidadOperaciones = cantidadOperaciones + 3;
for (int j = 0; j < (esIV1 ? grafo.dameNodosV1().size() : grafo.dameNodosV2().size()); j++) {
cantidadOperaciones = cantidadOperaciones + grafo.getCantidadDeOperaciones();
int cruces = grafo.cantidadCruces(nodoRandom, adyacentesHastaAhora, j, esIV1);
cantidadOperaciones = cantidadOperaciones + grafo.getCantidadDeOperaciones();
cantidadOperaciones = cantidadOperaciones + 2;
if (minCruces > cruces) {
minCruces = cruces;
posMinCruce = j;
cantidadOperaciones = cantidadOperaciones + 2;
}
}
if (esIV1) {
grafo.agregarNodoYEjesEnV1(nodoRandom, adyacentesHastaAhora, posMinCruce);
cantidadOperaciones = cantidadOperaciones + grafo.getCantidadDeOperaciones();
} else {
grafo.agregarNodoYEjesEnV2(nodoRandom, adyacentesHastaAhora, posMinCruce);
cantidadOperaciones = cantidadOperaciones + grafo.getCantidadDeOperaciones();
}
nodosActuales.remove(nodoRandom);
cantidadOperaciones = cantidadOperaciones + nodosActuales.size();
sizeTotal--;
}
return grafo;
}
///////////////////////////////////////////////////////// Crear grafo a partir de un archivo
// ///////////////////////////////////////////////
public Grafo Grafo(String n) {
Grafo g = null;
File file = new File(n);
try {
String line;
FileReader filer = new FileReader(file);
BufferedReader buf = new BufferedReader(filer);
String linea = buf.readLine().trim();
boolean seguir = true;
if (linea != null) {
if (!linea.equals("d") && !linea.equals("n")) {
System.out.println("El archivo está mal escrito");
} else {
StringTokenizer token = new StringTokenizer(linea);
String Dir = token.nextToken();
linea = buf.readLine().trim();
token = new StringTokenizer(linea);
int nV = Integer.parseInt(token.nextToken());
token = new StringTokenizer(linea);
linea = buf.readLine().trim();
token = new StringTokenizer(linea);
int nL = Integer.parseInt(token.nextToken());
boolean dirigido = false;
if (Dir.equals("d")) {
System.out.println("Dirigido");
g = new GrafoDirigido();
dirigido = true;
} else if (Dir.equals("n")) {
System.out.println("NoDirigido");
g = new GrafoNoDirigido();
dirigido = false;
}
int i = 0;
while (i < nV && (linea = buf.readLine().trim()) != null) {
token = new StringTokenizer(linea);
String idVer = token.nextToken();
double peso = Double.parseDouble(token.nextToken());
Vertice ver = new Vertice(peso, idVer);
g.agregarVertice(g, ver);
i++;
}
i = 0;
while (i < nL && (linea = buf.readLine().trim()) != null) {
token = new StringTokenizer(linea);
String idL = token.nextToken();
String idv1 = token.nextToken();
String idv2 = token.nextToken();
double peso2 = Double.parseDouble(token.nextToken());
if (dirigido == true) {
Arco ac = new Arco(peso2, idL, idv1, idv2);
((GrafoDirigido) g).agregarArco(((GrafoDirigido) g), ac);
} else {
Arista at = new Arista(peso2, idL, idv1, idv2);
((GrafoNoDirigido) g).agregarArista(((GrafoNoDirigido) g), at);
}
;
i++;
}
;
System.out.println("El grafo se creo exitosamente!!");
g.vertices(g);
g.lados(g);
}
}
buf.close();
} catch (FileNotFoundException e) {
System.out.println("El archivo no existe");
g = new GrafoDirigido();
} catch (IOException e) {
System.out.println("Excepcion, intente de nuevo");
}
return g;
}
/** @param g */
private void initEjes(Grafo g) {
ejes = g.dameEjes();
nodos = g.dameNodosV1();
}
public Bfs(Grafo grafo, int verticeInicial) {
this.visitado = new boolean[grafo.getNumeroVertices()];
this.distancia = new double[grafo.getNumeroVertices()];
this.arestas = new int[grafo.getNumeroVertices()];
breadthFirstSearch(grafo, verticeInicial);
}
