private int BuscaMenorDistancia(VerticeModel destino)
{
if (distancia.TryGetValue(destino, out int d))
{
return(d);
}
else
{
return(int.MaxValue);
}
}
private int BuscaDistancia(VerticeModel nodo, VerticeModel nodoDestino)
{
foreach (ArestaModel aresta in arestas)
{
if (aresta.Origem.Equals(nodo) &&
aresta.Destino.Equals(nodoDestino))
{
return(aresta.Peso);
}
}
throw new System.Exception();
}
//adiciona um trajeto para ser inserido no Grafo. (ex.: A distância da cidade A (origemAresta) até a cidade B (destinoAresta) é 5 (duração))
private void AdicionaAresta(String id, int origemAresta, int destinoAresta, int duracao)
{
//verifica se há de fato um vertice representando a origem e outro representando o destino da aresta
VerticeModel origem = new VerticeModel("Nodo_" + origemAresta, "Nodo_" + origemAresta);
VerticeModel destino = new VerticeModel("Nodo_" + destinoAresta, "Nodo_" + destinoAresta);
if (nodos.Contains(origem) &&
nodos.Contains(destino))
{
ArestaModel faixa = new ArestaModel(id, nodos[nodos.IndexOf(origem)], nodos[nodos.IndexOf(destino)], duracao);
arestas.Add(faixa);
}
}
private List <VerticeModel> BuscaNodosVizinhos(VerticeModel nodo)
{
List <VerticeModel> vizinhos = new List <VerticeModel>();
foreach (ArestaModel aresta in arestas)
{
if (aresta.Origem.Equals(nodo) &&
!Resolvido(aresta.Destino))
{
vizinhos.Add(aresta.Destino);
}
}
return(vizinhos);
}
public static void main()
{
nodos = new List <VerticeModel>();
arestas = new List <ArestaModel>();
for (int i = 0; i < 8; i++)
{
VerticeModel location = new VerticeModel("Node_" + i, "Node_" + i);
nodos.Add(location);
}
addLane("Edge_0", 0, 1, 5);
addLane("Edge_1", 0, 3, 5);
addLane("Edge_2", 0, 4, 7);
addLane("Edge_3", 1, 2, 4);
addLane("Edge_4", 2, 3, 8);
addLane("Edge_5", 2, 4, 2);
addLane("Edge_6", 3, 2, 8);
addLane("Edge_7", 3, 4, 6);
addLane("Edge_8", 4, 1, 3);
// A distância da cidade A até a cidade B é 5.
// A distância da cidade A até a cidade D é 5.
// A distância da cidade A até a cidade E é 7.
// A distância da cidade B até a cidade C é 4.
// A distância da cidade C até a cidade D é 8.
// A distância da cidade C até a cidade E é 2.
// A distância da cidade D até a cidade C é 8.
// A distância da cidade D até a cidade E é 6.
// A distância da cidade E até a cidade B é 3.
// Lets check from location Loc_1 to Loc_10
GrafoModel graph = new GrafoModel(nodos, arestas);
Dijkstra dijkstra = new Dijkstra(graph);
dijkstra.Executa(nodos[2]);
List <VerticeModel> path = dijkstra.BuscaCaminho(nodos[2]);
if (path == null || path.Count <= 0)
{
throw new System.Exception();
}
foreach (VerticeModel vertex in path)
{
Console.WriteLine(vertex);
}
}
private void EncontraDistanciasMinimas(VerticeModel nodo)
{
//busca os nodos vizinhos (os quais o nodo principal tem acesso)
List <VerticeModel> nodosAdjacentes = BuscaNodosVizinhos(nodo);
foreach (VerticeModel nodoDestino in nodosAdjacentes)
{
if (BuscaMenorDistancia(nodoDestino) > BuscaMenorDistancia(nodo)
+ BuscaDistancia(nodo, nodoDestino))
{
distancia.Add(nodoDestino, BuscaMenorDistancia(nodo)
+ BuscaDistancia(nodo, nodoDestino));
antecessores.Add(nodoDestino, nodo);
nodosNaoResolvidos.Add(nodoDestino);
}
}
}
public void Executa(VerticeModel origem)
{
nodosResolvidos = new HashSet <VerticeModel>();
nodosNaoResolvidos = new HashSet <VerticeModel>();
distancia = new Dictionary <VerticeModel, int>();
antecessores = new Dictionary <VerticeModel, VerticeModel>();
//cria uma distancia inicial 0, ja que origem até origem tem distancia = 0
distancia.Add(origem, 0);
//lista de nodos que ainda não foram testados
nodosNaoResolvidos.Add(origem);
while (nodosNaoResolvidos.Count > 0)
{
VerticeModel node = BuscaMenor(nodosNaoResolvidos);
nodosResolvidos.Add(node);
nodosNaoResolvidos.Remove(node);
EncontraDistanciasMinimas(node);
}
}
/*
* Esse método retorna o caminho da origem até o destino ou Null caso o caminho seja impossível
*/
public List <VerticeModel> BuscaCaminho(VerticeModel nodoDestino)
{
LinkedList <VerticeModel> caminho = new LinkedList <VerticeModel>();
VerticeModel aux = nodoDestino;
// checa se o caminho existe, verificando a exitencia do destino nos nodos encontrados
if (!antecessores.TryGetValue(aux, out VerticeModel verticeRetornado))
{
return(null);
}
caminho.AddLast(aux);
while (antecessores.TryGetValue(aux, out verticeRetornado))
{
aux = antecessores[aux];
caminho.AddLast(aux);
}
// coloca a lista na ordem correta
return(caminho.Reverse().ToList());
}
private VerticeModel BuscaMenor(HashSet <VerticeModel> vertices)
{
VerticeModel minimo = null;
foreach (VerticeModel vertice in vertices)
{
if (minimo == null)
{
minimo = vertice;
}
else
{
if (BuscaMenorDistancia(vertice) < BuscaMenorDistancia(minimo))
{
minimo = vertice;
}
}
}
return(minimo);
}
public GrafoModel MontaGrafo(String caminho)
{
nodos = new List <VerticeModel>();
arestas = new List <ArestaModel>();
//cria a lista de nodos do grafo
string[] caminhoArray = null;
if (caminho != null)
{
caminhoArray = caminho.Split('_');
for (int i = 0; i < caminhoArray.Length; i++)
{
VerticeModel location = new VerticeModel("Nodo_" + caminhoArray[i], "Nodo_" + caminhoArray[i]);
nodos.Add(location);
}
}
else
{
for (int i = 0; i < 8; i++)
{
VerticeModel location = new VerticeModel("Nodo_" + i, "Nodo_" + i);
nodos.Add(location);
}
}
//adiciona as ligações possíveis (ex.: A --- 5 ---> B)
AdicionaAresta("Trajeto_0", 0, 1, 5);
AdicionaAresta("Trajeto_1", 0, 3, 5);
AdicionaAresta("Trajeto_2", 0, 4, 7);
AdicionaAresta("Trajeto_3", 1, 2, 4);
AdicionaAresta("Trajeto_4", 2, 3, 8);
AdicionaAresta("Trajeto_5", 2, 4, 2);
AdicionaAresta("Trajeto_6", 3, 2, 8);
AdicionaAresta("Trajeto_7", 3, 4, 6);
AdicionaAresta("Trajeto_8", 4, 1, 3);
// cria o Grafo com os Nodos e Arestas criados
return(new GrafoModel(nodos, arestas));
}
private bool Resolvido(VerticeModel vertice)
{
return(nodosResolvidos.Contains(vertice));
}
