// Busca a aresta de menor peso
private static Aresta FindArestaMenorPeso()
{
int pesoMenor = 1000;
Aresta arestaMenorPeso = null;
grafoOrigem.LimparCorVertices();
foreach (Vertice vertice in grafoOrigem.vertices)
{
foreach (Aresta aresta in vertice.adjacentes)
{
if (aresta.peso <= pesoMenor && aresta.vertice.cor == "BRANCO")
{
if (aresta.peso == pesoMenor)
{
Aresta arestaEscolhida = Prim.ArestasComMesmoPeso(arestaMenorPeso, verticeOrigem, aresta, vertice);
pesoMenor = arestaEscolhida.peso;
arestaMenorPeso = arestaEscolhida;
}
else
{
pesoMenor = aresta.peso;
arestaMenorPeso = aresta;
verticeOrigem = vertice;
}
}
}
vertice.cor = "VERDE";
}
return(arestaMenorPeso);
}
private static Aresta encontrarMenorPeso()
{
int peso = 10000;
Aresta arestaSelecionada = null;
foreach (Vertice v in verticesConhecidos)
{
foreach (Aresta aresta in v.adjacentes)
{
if (aresta.peso <= peso && aresta.vertice.cor == "BRANCO")
{
if (aresta.peso == peso)
{
Aresta arestaEscolhida = ArestasComMesmoPeso(arestaSelecionada, vOrigem, aresta, v);
peso = arestaEscolhida.peso;
arestaSelecionada = arestaEscolhida;
}
else
{
peso = aresta.peso;
arestaSelecionada = aresta;
vOrigem = v;
}
}
}
}
return(arestaSelecionada);
}
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);
}
}
public void adicionarArestaDirigida(Vertice Vert1, Vertice Vert2, int peso, int direcao)
{
matadj[Vert1.Vert, Vert2.Vert] = 1;
matadj[Vert2.Vert, Vert1.Vert] = 1;
Aresta aresta = new Aresta(Vert1, Vert2, peso, direcao);
arestas.Add(aresta);
}
public object removerAresta(Aresta a)
{
arestas.Remove(a);
int indiceInicial = vertices.IndexOf(a.verticeInicial()), indiceFinal = vertices.IndexOf(a.verticeFinal());
tabela[indiceInicial, indiceFinal].Remove(a);
if (!a.Direcionada)
{
tabela[indiceFinal, indiceInicial].Remove(a);
}
return(a.element);
}
public void RemoveVerticeAdjacente(int id)
{
Aresta arestaRetirar = null;
foreach (var aresta in adjacentes)
{
if (aresta.vertice.id == id)
{
arestaRetirar = aresta;
break;
}
}
adjacentes.Remove(arestaRetirar);
}
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 void inserirAresta(int v, int w, object obj, bool direcionada)
{
Aresta a = new Aresta(vertices.ElementAt(v), vertices.ElementAt(w), obj, direcionada);
if (tabela[v, w] == null)
{
tabela[v, w] = new List <Aresta>();
if (!direcionada)
{
tabela[w, v] = new List <Aresta>();
}
}
tabela[v, w].Add(a);
if (!direcionada)
{
tabela[w, v].Add(a);
}
arestas.Add(a);
}
public static GrafoNaoDirigido execute(GrafoNaoDirigido grafo)
{
grafoOrigem = new GrafoNaoDirigido(grafo.vertices);
arvore = new GrafoNaoDirigido(grafo.gerarGrafoNulo());
Aresta aresta = FindArestaMenorPeso();
while (aresta != null)
{
if (!HasCiclo(verticeOrigem, aresta))
{
arvore.adicionarAresta(verticeOrigem.id, aresta.vertice.id, aresta.peso);
}
RemoveArestaGrafoCompleto(verticeOrigem, aresta);
aresta = FindArestaMenorPeso();
}
return(arvore);
}
// 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);
}
}
private static bool HasCiclo(Vertice verticeOrigem, Aresta aresta)
{
arvore.LimparCorVertices();
return(VerificaArestaCiclo(verticeOrigem, aresta));
}
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 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 Vertice[] verticesFinais(Aresta a)
{
return(new Vertice[] { a.verticeInicial(), a.verticeFinal() });
}
public void substituir(Aresta e, object x)
{
e.element = x;
}
public void removerAresta(Aresta aresta)
{
matadj[aresta.Vert1.Vert, aresta.Vert2.Vert] = 0;
matadj[aresta.Vert2.Vert, aresta.Vert1.Vert] = 0;
arestas.Remove(aresta);
}
