private int BuscarCorApropriada(Vertice pVertice)
{
int iCor = 0;
List<int> listaExcecao = new List<int>();
List<int> listaFinal = new List<int>();
foreach (Vertice grau in pVertice.Adjacentes)
{
if(grau.CorVertice > 0)
listaExcecao.Add(grau.CorVertice);
}
if (listaExcecao.Count > 0)
{
for (int i = 0; i < vetorCores.Count; i++)
{
if (!listaExcecao.Contains(vetorCores[i]))
listaFinal.Add(vetorCores[i]);
}
}
if (listaFinal.Count > 0)
iCor = listaFinal[0];
return iCor;
}
public Arco(Vertice pOrigem, Vertice pDestino, double pPeso)
{
this.Origem = pOrigem;
this.Destino = pDestino;
this.Peso = pPeso;
Origem.AdicionarArco(this);//Verificar se é necessário
Destino.AdicionarArco(this);//Verificar se é necessário
}
private Vertice ventanaVertice; // ventana para agregar los vértices
#endregion Fields
#region Constructors
public Simulador()
{
InitializeComponent();
nuevoNodo = null;
var_control = 0;
ventanaVertice = new Vertice();
ventanaArco = new Arco();
ventanaRecorrido = new Recorrido();
this.SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint | ControlStyles.DoubleBuffer, true);
}
public static void InserirVertice(Grafo grafo)
{
Console.Write("Digite o nome do vertice: ");
String nomeVertice = Console.ReadLine();
var listaVertices2 = grafo.ListaVertices;
Grafos.Vertice V = new Grafos.Vertice(idVertices++, nomeVertice, grafo);
listaVertices2.Add(V);
grafo.ListaVertices = listaVertices2;
Console.WriteLine("\n\nVértice '" + nomeVertice + "' inserido no grafo '" + grafo.Nome + "'.");
_ = Console.ReadLine();
}
public static GrafoNaoDirigido execute(Vertice origem, GrafoNaoDirigido grafo)
{
GrafoNaoDirigido arvore = new GrafoNaoDirigido(grafo.gerarGrafoNulo());
vOrigem = origem;
Aresta aresta = selecionarAresta(origem);
while (aresta != null)
{
//adiciona a aresta a arvore
arvore.adicionarAresta(vOrigem.id, aresta.vertice.id, aresta.peso);
//seleciona a aresta de menor peso
aresta = selecionarAresta(aresta.vertice);
}
return(arvore);
}
public int getGrauEntrada(Vertice v1)
{
int grauEntrada = 0;
//Busca em todos os vertices e seus respectivos vertices sucessores se existe uma correspondencia com o
//vertice passado por parâmetro, significando
foreach (Vertice vertice in vertices)
{
foreach (var aresta in vertice.adjacentes)
{
if (aresta.vertice == v1)
{
grauEntrada++;
}
}
}
return(grauEntrada);
}
//Metodo Visitar da busca em profundidade, procurando por uma aresta de retorno.
private bool hasArestaRetorno(Vertice vertice)
{
vertice.cor = "CINZA";
foreach (var aresta in vertice.adjacentes)
{
if (aresta.vertice.cor == "BRANCO")
{
hasArestaRetorno(aresta.vertice);
}
//Achou uma aresta de retorno, significando que o grafo tem um ciclo
if (aresta.vertice.cor == "CINZA")
{
return(true);
}
}
vertice.cor = "PRETO";
return(false);
}
public bool isPendente(Vertice v)
{
int counter = 0;
for (int i = 1; i < matadj.GetLength(0); ++i)
{
if (matadj[v.Vert, i] == 0)
{
counter++;
}
}
if (counter == 1)
{
Console.WriteLine("Pendente");
return(true);
}
else
{
Console.WriteLine("Não e pendente");
return(false);
}
}
// Para verificar se a aresta que será incluida é de ciclo e feita uma busca em profundidade
// percorrendo todos os vertices de origem da subArvore procurando algum vértice que tenha alguma
// ligação com o vértice da aresta. Se tiver possui ciclo.
private static bool VerificaArestaCiclo(Vertice verticeOrigem, Aresta aresta)
{
arvore.vertices[verticeOrigem.id - 1].cor = "VERDE";
if (aresta.vertice.id == verticeOrigem.id)
{
return(true);
}
else
{
foreach (var a in arvore.vertices[verticeOrigem.id - 1].adjacentes)
{
if (a.vertice.cor == "BRANCO")
{
if (VerificaArestaCiclo(a.vertice, aresta))
{
return(true);
}
}
}
return(false);
}
}
// Pendentes são vertices que possuem somente uma aresta adjacente
public bool isPendente(Vertice v1)
{
return(getGrau(v1) == 1);
}
private void VerificarConectividade(Vertice pVertice, int pContador)
{
raiz = pVertice;
bool bProxVertice = false;
Vertice novoVertice = null;
while (pVertice != null)
{
if (pVertice.listaArcos.Where(item => item.Destino.Id != pVertice.Id).Count() > 0) {
foreach (Arco dest in pVertice.listaArcos.Where(item => item.Destino.Id != pVertice.Id))
{
pContador++;
if (dest.Destino.Id == raiz.Id)
{
bProxVertice = false;
novoVertice = null;
pVertice = null;
break;
}
else
{
bProxVertice = true;
novoVertice = dest.Destino;
}
}
if (pContador > filaAuxiliar.Count)
{
bContinuarLaco = false;
pVertice = null;
bEhConexo = false;
}
else if (bProxVertice)
{
pVertice = novoVertice;
bProxVertice = false;
}
}
else
{
bProxVertice = false;
novoVertice = null;
pVertice = null;
bEhConexo = false;
break;
}
}
}
public static Aresta ArestasComMesmoPeso(Aresta aresta1, Vertice vertice1, Aresta aresta2, Vertice vertice2)
{
if ((vertice1.id + aresta1.vertice.id) >= (vertice2.id + aresta2.vertice.id))
{
vOrigem = vertice2;
return(aresta2);
}
else
{
if ((vertice1.id + aresta1.vertice.id) == (vertice2.id + aresta2.vertice.id))
{
int indice1 = Math.Min(vertice1.id, aresta1.vertice.id);
int indice2 = Math.Min(vertice2.id, aresta2.vertice.id);
if (indice2 < indice1)
{
vOrigem = vertice2;
return(aresta2);
}
else
{
return(aresta1);
}
}
return(aresta1);
}
}
private void BuscarProximosIndices()
{
int iNumVertices = 0;
Vertice vAuxiliar = null;
iContadorLacos++;
if (listaAnalise.AsEnumerable().Where(item => !item.Visitado).Count() > 0)
{
foreach (Vertice v in listaAnalise)
{
if (!v.Visitado && iNumVertices == 0)
{
vAuxiliar = vAnalise1;
vAnalise1 = v;
v.Visitado = true;
iNumVertices++;
}
if (iNumVertices == 1 && !v.Visitado)
{
vAnalise2 = v;
iNumVertices++;
}
if (iNumVertices == 2)
{
bTodosVisitados = false;
DefinirValoresPeso(vAnalise1.Id, vAnalise2.Id);
break;
}
}
if(iNumVertices == 1)
{
if (listaAnalise.AsEnumerable().Where(item => !item.Visitado).Count() == 0)
{
bTodosVisitados = true;
vAnalise1 = vAuxiliar;
}
}
}
else
bTodosVisitados = true;
if (!bTodosVisitados)
{
sbLog.AppendLine("Vértices em análise: ");
sbLog.AppendLine();
sbLog.Append(vAnalise1.Rotulo);
sbLog.Append("-->");
sbLog.Append(vAnalise2.Rotulo);
sbLog.AppendLine();
}
}
private void EncontrarMenorValor()
{
int iLinhaMenorValor = 0;
int iColunaMenorValor = 0;
for (int i = 0; i < dtbDuplicada.Rows.Count; i++)
{
for (int j = 0; j < dtbDuplicada.Columns.Count; j++)
{
if (dtbDuplicada.Rows[i][j] != DBNull.Value)
{
if (Convert.ToDouble(dtbDuplicada.Rows[i][j]) > 0)
{
if (Convert.ToDouble(dtbDuplicada.Rows[i][j]) < nMenorValor)
{
nMenorValor = Convert.ToDouble(dtbDuplicada.Rows[i][j]);
iLinhaMenorValor = i;
iColunaMenorValor = j;
}
}
}
}
}
string sLinhaMenorValor = Vertices.AsEnumerable().Where(item => item.Id.Equals(iLinhaMenorValor)).FirstOrDefault().Rotulo;
string sColunaMenorValor = Vertices.AsEnumerable().Where(item => item.Id.Equals(iColunaMenorValor)).FirstOrDefault().Rotulo;
iIdFindColuna = iColunaMenorValor;
iIdFindLinha = iLinhaMenorValor;
vAnalise1 = Vertices.AsEnumerable().Where(item => item.Id.Equals(iLinhaMenorValor)).FirstOrDefault();
vAnalise2 = Vertices.AsEnumerable().Where(item => item.Id.Equals(iColunaMenorValor)).FirstOrDefault();
vInicial = vAnalise1;
Vertice novoVertice = new Vertice(0, 0, vAnalise1.Id, vAnalise1.Rotulo);
novoVertice.ValorCaixeiro = vAnalise1.ValorCaixeiro;
listaAnalise.Add(Vertices.AsEnumerable().Where(item => item.Id.Equals(iIdFindLinha)).FirstOrDefault());//Adiciona o destino
listaAnalise.Add(Vertices.AsEnumerable().Where(item => item.Id.Equals(iIdFindColuna)).FirstOrDefault());//Adiciona o primeiro
listaAnalise.Add(novoVertice);//Adiciona o destino
ReordenarIndices();
vAnalise1.Visitado = true;
DefinirValoresPeso(iIdFindLinha, iIdFindColuna);
iCustoTotal += vAnalise1.ValorCaixeiro + vAnalise2.ValorCaixeiro;
PreencherListaTestes(sLinhaMenorValor, sColunaMenorValor);
sbLog.AppendLine();
sbLog.AppendLine();
sbLog.AppendLine("Menor valor encontrado: " + nMenorValor);
sbLog.AppendLine();
sbLog.AppendLine("Vértices em análise: ");
sbLog.AppendLine();
sbLog.Append(vAnalise1.Rotulo);
sbLog.Append("-->");
sbLog.Append(vAnalise2.Rotulo);
sbLog.AppendLine();
LogInicial();
AplicarTestes();
}
public int AcharIndice(Vertice v)
{
return(vertices.FindIndex(r => r.element == v.element));
}
public bool ehAdjacente(Vertice v, Vertice w)
{
return(tabela[vertices.IndexOf(v), vertices.IndexOf(w)] != null);
}
private Vertice ProximoVertice(Vertice pVertice)
{
Vertice verticeRetorno = null;
foreach (Arco arcos in pVertice.listaArcos.Where(item => item.Destino.Id != pVertice.Id && !item.Destino.Visitado))
{
verticeRetorno = arcos.Destino;
break;
}
return verticeRetorno;
}
public static void Importar(List <Grafo> lista_g)
{
Console.Write("Digite o caminho do arquivo .txt : ");
String caminho = Console.ReadLine();
List <String> textoArquivo = new List <String>();
try
{ // Open the text file using a stream reader.
using (StreamReader sr = new StreamReader(caminho))
{
string line;
// Read and display lines from the file until the end of
// the file is reached.
while ((line = sr.ReadLine()) != null)
{
textoArquivo.Add(line);
}
}
}
catch (IOException e)
{
Console.WriteLine("Erro ao ler arquivo.\n");
Console.WriteLine(e.Message);
_ = Console.ReadLine();
}
foreach (var line in textoArquivo)
{
if (line.StartsWith("Grafo = "))
{
String linhaGrafo = line.Replace("Grafo = ", "");
String[] propriedades = linhaGrafo.Split(new Char[] { ',' });
int ponderado = int.Parse(propriedades[1]);
int dirigido = int.Parse(propriedades[2]);
Grafo grafo = new Grafo(propriedades[0], ponderado, dirigido, idGrafos++);
lista_g.Add(grafo);
Console.WriteLine("\nGrafo '" + grafo.Nome + "' criado com Sucesso!");
}
if (line.StartsWith("Vertice = "))
{
String linhaGrafo = line.Replace("Vertice = ", "");
String[] propriedades = linhaGrafo.Split(new Char[] { ',' });
foreach (var grafo in lista_g)
{
if (grafo.Nome.Equals(propriedades[1]))
{
Vertice V = new Grafos.Vertice(idVertices++, propriedades[0], grafo);
grafo.ListaVertices.Add(V);
Console.WriteLine("Vértice '" + V.Nome + "' inserido no grafo '" + grafo.Nome + "' com sucesso!");
}
}
}
if (line.StartsWith("Aresta = "))
{
String linhaGrafo = line.Replace("Aresta = ", "");
String[] propriedades = linhaGrafo.Split(new Char[] { ',' });
foreach (var grafo in lista_g)
{
if (grafo.Nome.Equals(propriedades[1]))
{
foreach (var verO in grafo.ListaVertices)
{
if (verO.Nome.Equals(propriedades[2]))
{
Vertice vO = verO;
foreach (var verD in grafo.ListaVertices)
{
if (verD.Nome.Equals(propriedades[3]))
{
Vertice vD = verD;
int peso = int.Parse(propriedades[4]);
Aresta A = new Aresta(idArestas++, propriedades[0], grafo, vO, vD, peso);
grafo.ListaArestas.Add(A);
Console.WriteLine("Aresta '" + A.Nome + "' inserida no grafo '" + grafo.Nome + "'com sucesso!");
}
}
}
}
}
}
}
}
}
public Aresta(Vertice vertice, int peso)
{
this.vertice = vertice;
this.peso = peso;
}
static void Main(string[] args)
{
string[] leitor = File.ReadAllLines(@"../../../Teste.txt");
Console.WriteLine("\t Alunos: " +
"\n Ana Luiza Gonçalves Lourenço Barros" +
"\n Douglas Barbosa da Silva" +
"\n Jonathan William de Paiva" +
"\n Lucas Gomes Oliveira" +
"\n Victor Henrique de Souza Oliveira \n");
Grafo nv = new Grafo(Convert.ToInt32(leitor[0]) + 1);
bool naodirigido = true;
foreach (string linha in leitor)
{
string[] corte = linha.Split(';');
if (corte.Length > 3)
{
Vertice Vert1;
Vertice Vert2;
int peso;
int direcao;
if (corte.Length == 1)
{
}
else
{
naodirigido = false;
Vert1 = new Vertice(Convert.ToInt32(corte[0]));
Vert2 = new Vertice(Convert.ToInt32(corte[1]));
peso = Convert.ToInt32(corte[2]);
direcao = Convert.ToInt32(corte[3]);
nv.adicionarVertice(Vert1);
nv.adicionarVertice(Vert2);
nv.adicionarArestaDirigida(Vert1, Vert2, peso, direcao);
}
}
else
{
Vertice Vert1;
Vertice Vert2;
int peso;
if (corte.Length == 1)
{
}
else
{
Vert1 = new Vertice(Convert.ToInt32(corte[0]));
Vert2 = new Vertice(Convert.ToInt32(corte[1]));
peso = Convert.ToInt32(corte[2]);
nv.adicionarVertice(Vert1);
nv.adicionarVertice(Vert2);
nv.adicionarAresta(Vert1, Vert2, peso);
nv.isAdjacente(Vert1, Vert2);
nv.getGrau(Vert1);
nv.getGrau(Vert2);
nv.adjacentes(Vert1);
}
}
}
if (naodirigido)
{
Console.WriteLine(nv.printarMatriz());
foreach (var item in nv.vertices)
{
Console.WriteLine("O grau do vertice {0} = {1}", item.Vert, nv.getGrau(item));
nv.isPendente(item);
}
if (nv.IsIsolado())
{
Console.WriteLine("E isolado");
}
else
{
Console.WriteLine("Não e isolado");
}
if (nv.isRegular())
{
Console.WriteLine("E regular");
}
else
{
Console.WriteLine("Não e regular");
}
if (nv.isNulo())
{
Console.WriteLine("E nulo");
}
else
{
Console.WriteLine("Não e nulo");
}
if (nv.isCompleto())
{
Console.WriteLine("E um grafo completo");
}
else
{
Console.WriteLine("Não e um grafo completo");
}
if (nv.isConexo())
{
Console.WriteLine("E um grafo Conexo");
}
else
{
Console.WriteLine("Não e um grafo Conexo");
}
if (nv.isEuleriano())
{
Console.WriteLine("E euleriano");
}
else
{
Console.WriteLine("Não e euleriano");
}
if (nv.isUnicursal())
{
Console.WriteLine("E Unicursal");
}
else
{
Console.WriteLine("Não e Unicursal");
}
Grafo arvore = nv.getAGMPrim();
Grafo arvore2 = nv.getAGMKruskal();
Console.WriteLine("\n Matriz da prim");
Console.WriteLine(arvore.printarMatriz());
Console.WriteLine("Matriz da Kruskal");
Console.WriteLine(arvore2.printarMatriz());
nv.getCutVertices();
}
else
{
Console.WriteLine(nv.printarMatriz());
foreach (var item in nv.vertices)
{
Console.WriteLine("O grau de entrada do vertice {0} = {1}", item.Vert, nv.getGrauEntrada(item));
Console.WriteLine("O grau de saida do vertice {0} = {1}", item.Vert, nv.getGrauSaida(item));
}
if (nv.hasCiclo())
{
Console.WriteLine("Este grafo possui ciclo");
}
else
{
Console.WriteLine("Este grafo não possui ciclo");
}
}
Console.ReadKey();
}
public Aresta(Vertice vert1, Vertice vert2, int peso)
{
this.vert1 = vert1;
this.vert2 = vert2;
this.peso = peso;
}
private void ColorirVertice(Vertice pVertice)
{
if(pVertice.CorVertice == 0)
{
int iCor = BuscarCorApropriada(pVertice);
if (iCor == 0)
{
vetorCores.Add(iContadorCores);
pVertice.CorVertice = iContadorCores;
iContadorCores++;
}
else
{
pVertice.CorVertice = iCor;
}
}
}
public bool isIsolado(Vertice v1)
{
return(getGrau(v1) == 0);
}
public void AdicionarVertice(int pId, string pRotulo, float pPosX, float pPosY)
{
novoVertice = new Vertice(pPosX, pPosY, pId, pRotulo);
Vertices.Add(novoVertice);
}
public GrafoNaoDirigido getAGMPrim(Vertice v1)
{
this.LimparCorVertices();
return(Prim.execute(v1, this));
}
public void substituir(Vertice v, object x)
{
v.element = x;
}
private static bool HasCiclo(Vertice verticeOrigem, Aresta aresta)
{
arvore.LimparCorVertices();
return(VerificaArestaCiclo(verticeOrigem, aresta));
}
public Vertice oposto(Vertice v, Aresta a)
{
return(a.verticeInicial() == v?a.verticeFinal() : (a.verticeFinal() == v ? a.verticeInicial() : throw new Exception("Nenhum dos dois vértices é um vértice da aresta!")));
}
public Aresta(Vertice vertice, TextBox value)
{
this.Vertice = vertice;
this.value = value;
}
public Aresta(Vertice vertice, TextBox value, Point p1, Point p2) : this(vertice, value)
{
this.p1 = p1;
this.p2 = p2;
}
public int GetIndice(Vertice v)
{
return(Vertices.FindIndex(x => x == v));
}
private void DefinirPesoNovoVertice(Vertice pNovoVertice)
{
pNovoVertice.ValorCaixeiro = Convert.ToDouble(dtbAdjacencia.Rows[vAnalise1.Id][pNovoVertice.Id]);
vAnalise2.ValorCaixeiro = Convert.ToDouble(dtbAdjacencia.Rows[pNovoVertice.Id][vAnalise2.Id]);
}
public static GrafoDirigido GrafoDirigido(String nomeArquivo)
{
String s;
String[] aux;
StreamReader arquivoGrafo;
try
{
arquivoGrafo = new StreamReader(nomeArquivo);
int qtdVertices = int.Parse(arquivoGrafo.ReadLine());
s = arquivoGrafo.ReadLine();
Vertice[] vertices = new Vertice[qtdVertices];
int verticeX;
int verticeY;
while (s != null)
{
aux = s.Split(';');
verticeX = int.Parse(aux[0]) - 1;
verticeY = int.Parse(aux[1]) - 1;
if (vertices[verticeX] == null)
{
vertices[verticeX] = new Vertice(verticeX + 1);
}
if (vertices[verticeY] == null)
{
vertices[verticeY] = new Vertice(verticeY + 1);
}
int adjacencia = int.Parse(aux[3]);
if (adjacencia > 0)
{
vertices[verticeX].AddVerticeAdjacente(vertices[verticeY], int.Parse(aux[2]));
}
else
{
vertices[verticeY].AddVerticeAdjacente(vertices[verticeX], int.Parse(aux[2]));
}
s = arquivoGrafo.ReadLine();
}
GrafoDirigido grafo = new GrafoDirigido(VerticesPendentes(vertices));
arquivoGrafo.Close();
return(grafo);
}
catch (FileNotFoundException ex)
{
throw ex;
}
catch (Exception ex)
{
throw ex;
}
}
private void OrdenarGrafo(Vertice pVerticeInserir)
{
//listaAnalise.Insert(vAnalise1.IndiceCaixeiro + 1, pVerticeInserir);
listaAnalise.Insert(iIndiceInserir + 1, pVerticeInserir);
ReordenarIndices();
}
public void AddVertice(int id)
{
Vertice v = new Vertice(id);
Verticess.Add(id, v);
}
public void AddVerticeAdjacente(Vertice vertice, int peso)
{
adjacentes.Add(new Aresta(vertice, peso));
}
public TorresDeRadio()
{
grafo = new Grafo();
grafo.inserirVertice("Brasil");
grafo.inserirVertice("Argentina");
grafo.inserirVertice("Uruguai");
grafo.inserirVertice("Paraguai");
grafo.inserirVertice("Bolívia");
grafo.inserirVertice("Peru");
grafo.inserirVertice("Chile");
grafo.inserirVertice("Colômbia");
grafo.inserirVertice("Equador");
grafo.inserirVertice("Venezuela");
grafo.inserirVertice("Guiana");
grafo.inserirVertice("Suriname");
grafo.inserirVertice("Guiana Francesa");
Vertice Brasil = new Vertice("Brasil");
Vertice Argentina = new Vertice("Argentina");
Vertice Uruguai = new Vertice("Uruguai");
Vertice Paraguai = new Vertice("Paraguai");
Vertice Bolivia = new Vertice("Bolívia");
Vertice Peru = new Vertice("Peru");
Vertice Chile = new Vertice("Chile");
Vertice Colombia = new Vertice("Colômbia");
Vertice Equador = new Vertice("Equador");
Vertice Venezuela = new Vertice("Venezuela");
Vertice Guiana = new Vertice("Guiana");
Vertice Suriname = new Vertice("Suriname");
Vertice GuianaFrancesa = new Vertice("Guiana Francesa");
vertices = grafo.getVertices();
//Brasil e suas Fronteiras
grafo.inserirAresta(grafo.AcharIndice(Brasil), grafo.AcharIndice(Uruguai), 0, false);
grafo.inserirAresta(grafo.AcharIndice(Brasil), grafo.AcharIndice(Argentina), 0, false);
grafo.inserirAresta(grafo.AcharIndice(Brasil), grafo.AcharIndice(Paraguai), 0, false);
grafo.inserirAresta(grafo.AcharIndice(Brasil), grafo.AcharIndice(Bolivia), 0, false);
grafo.inserirAresta(grafo.AcharIndice(Brasil), grafo.AcharIndice(Peru), 0, false);
grafo.inserirAresta(grafo.AcharIndice(Brasil), grafo.AcharIndice(Colombia), 0, false);
grafo.inserirAresta(grafo.AcharIndice(Brasil), grafo.AcharIndice(Venezuela), 0, false);
grafo.inserirAresta(grafo.AcharIndice(Brasil), grafo.AcharIndice(Guiana), 0, false);
grafo.inserirAresta(grafo.AcharIndice(Brasil), grafo.AcharIndice(Suriname), 0, false);
grafo.inserirAresta(grafo.AcharIndice(Brasil), grafo.AcharIndice(GuianaFrancesa), 0, false);
//Argentina e suas Fronteiras
grafo.inserirAresta(grafo.AcharIndice(Argentina), grafo.AcharIndice(Uruguai), 0, false);
grafo.inserirAresta(grafo.AcharIndice(Argentina), grafo.AcharIndice(Paraguai), 0, false);
grafo.inserirAresta(grafo.AcharIndice(Argentina), grafo.AcharIndice(Bolivia), 0, false);
grafo.inserirAresta(grafo.AcharIndice(Argentina), grafo.AcharIndice(Chile), 0, false);
//Paraguai e suas Fronteiras
grafo.inserirAresta(grafo.AcharIndice(Paraguai), grafo.AcharIndice(Bolivia), 0, false);
//Bolívia e suas Fronteiras
grafo.inserirAresta(grafo.AcharIndice(Bolivia), grafo.AcharIndice(Chile), 0, false);
grafo.inserirAresta(grafo.AcharIndice(Bolivia), grafo.AcharIndice(Peru), 0, false);
//Colômbia e suas Fronteiras
grafo.inserirAresta(grafo.AcharIndice(Colombia), grafo.AcharIndice(Peru), 0, false);
grafo.inserirAresta(grafo.AcharIndice(Colombia), grafo.AcharIndice(Equador), 0, false);
grafo.inserirAresta(grafo.AcharIndice(Colombia), grafo.AcharIndice(Venezuela), 0, false);
//Equador e suas Fronteiras
grafo.inserirAresta(grafo.AcharIndice(Equador), grafo.AcharIndice(Peru), 0, false);
//Venezuela e suas Fronteiras
grafo.inserirAresta(grafo.AcharIndice(Venezuela), grafo.AcharIndice(Guiana), 0, false);
//Guiana e suas Fronteiras
grafo.inserirAresta(grafo.AcharIndice(Guiana), grafo.AcharIndice(Suriname), 0, false);
//Suriname e suas Fronteiras
grafo.inserirAresta(grafo.AcharIndice(Suriname), grafo.AcharIndice(GuianaFrancesa), 0, false);
//Peru e suas Fronteiras
grafo.inserirAresta(grafo.AcharIndice(Peru), grafo.AcharIndice(Chile), 0, false);
grafo.mostrarSoTabela();
Console.ReadKey();
}
private static void RemoveArestaGrafoCompleto(Vertice v1, Aresta aresta)
{
grafoOrigem.vertices[v1.id - 1].adjacentes.Remove(aresta);
grafoOrigem.vertices[aresta.vertice.id - 1].RemoveVerticeAdjacente(v1.id);
}
public int getGrauSaida(Vertice v1)
{
return(v1.adjacentes.Count());
}
public List <Aresta> arestasPorVertice(Vertice v)
{
return(arestas.Where(a => a.Vert1.Equals(v) || a.Vert2.Equals(v)).ToList());
}
private void EncontrarCaminhoMinimo(double[,] matriz, Grafo grafo, string vx, string vy)
{
var x = grafo.GetVertice(vx);
var y = grafo.GetVertice(vy);
tbMain.AppendText($"Encontrando caminho do vértice {x} ao vértice {y}..." + Environment.NewLine);
List <Vertice> _IN;
Vertice p;
var d = new double[grafo.Vertices.Count];
var s = new Vertice[grafo.Vertices.Count];
_IN = new List <Vertice>()
{
x
};
d[grafo.GetIndice(x)] = 0;
foreach (Vertice z in grafo.Vertices.Where(z => !_IN.Contains(z)))
{
d[grafo.GetIndice(z)] = matriz[grafo.GetIndice(x), grafo.GetIndice(z)];
s[grafo.GetIndice(z)] = x;
}
while (!_IN.Contains(y))
{
p = grafo.Vertices.Where(z => !_IN.Contains(z)).OrderBy(z => d[grafo.GetIndice(z)]).First();
_IN.Add(p);
foreach (Vertice z in grafo.Vertices.Where(z => !_IN.Contains(z)))
{
var distAnterior = d[grafo.GetIndice(z)];
d[grafo.GetIndice(z)] = Math.Min(d[grafo.GetIndice(z)], d[grafo.GetIndice(p)] + matriz[grafo.GetIndice(p), grafo.GetIndice(z)]);
if (!(d[grafo.GetIndice(z)] == distAnterior))
{
s[grafo.GetIndice(z)] = p;
}
}
}
//exibir
if (d[grafo.GetIndice(y)] == Double.PositiveInfinity)
{
tbMain.AppendText(Environment.NewLine + "Não há caminho entre esses dois vértices.");
}
else
{
var caminho = new List <string>();
tbMain.AppendText(Environment.NewLine + "Em ordem inversa, o caminho é:" + Environment.NewLine);
tbMain.AppendText(y + Environment.NewLine);
var _z = y;
caminho.Add(_z.Nome);
while (_z != x)
{
var sz = s[grafo.GetIndice(_z)];
tbMain.AppendText(sz + Environment.NewLine);
caminho.Add(sz.Nome);
_z = sz;
}
caminho.Reverse();
tbMain.AppendText(Environment.NewLine + "O caminho, na ordem certa, é:" + Environment.NewLine);
caminho.ForEach(v => tbMain.AppendText(v + Environment.NewLine));
tbMain.AppendText(Environment.NewLine + $"A distância do caminho é: {d[grafo.GetIndice(y)]}");
}
}