public void SetAresta(int index, Aresta aresta)
{
if (index >= 0 && index <= this.arestas.Count - 1)
{
this.arestas[index] = aresta;
}
}
/// <summary>
/// Insere uma nova aresta na lista de arestas do vértice.
/// Não permite a inserção de arestas repetidas
/// </summary>
/// <param name="aresta"></param>
public void AddAresta(Aresta aresta)
{
if (!this.Contem(aresta))
{
this.arestas.Add(aresta);
}
}
/// <summary>
/// Retorna um grafo que é a "imagem" restante para o grafo original ser completo
/// </summary>
/// <returns></returns>
public Grafo GetComplementar()
{
List <Vertice> vertices = new List <Vertice>();
Vertice v1 = null, v2 = null;
Aresta aresta;
this.vertices.ForEach(vertice =>
{
this.vertices.ForEach(vertice2 =>
{
if (!vertice.Equals(vertice2) && !vertice.TemArestaComVertice(vertice2))
{
v1 = Vertice.Get(vertice, vertices);
v2 = Vertice.Get(vertice2, vertices);
if (v1 == null)
{
v1 = new Vertice(vertice.GetDado());
vertices.Add(v1);
}
if (v2 == null)
{
v2 = new Vertice(vertice2.GetDado());
vertices.Add(v2);
}
aresta = new Aresta(v1, v2, 10);
v1.AddAresta(aresta);
v2.AddAresta(aresta);
}
});
});
return(new Grafo(vertices));
}
/// <summary>
/// Insere uma nova aresta para os vértices aos quais ela está ligada.
/// Se os vértices não estão no grafo, eles são inseridos no grafo.
/// </summary>
/// <param name="aresta"></param>
public void AddAresta(Aresta aresta)
{
if (aresta != null && aresta.getVertice1 != null && aresta.getVertice2 != null)
{
Vertice v1, v2;
v1 = aresta.getVertice1;
v2 = aresta.getVertice2;
if (!this.Contem(v1))
{
this.vertices.Add(v1);
}
if (!this.Contem(v2))
{
this.vertices.Add(v2);
}
if (!v1.Contem(aresta))
{
v1.AddAresta(aresta);
}
if (!v2.Contem(aresta))
{
v2.AddAresta(aresta);
}
this.arestas.Add(aresta);
}
}
/// <summary>
/// Verifica se o vértice já possui uma aresta igual aquela passada por parâmetro
/// </summary>
/// <param name="aresta"></param>
/// <returns></returns>
public bool Contem(Aresta aresta)
{
foreach (Aresta aresta1 in this.arestas)
{
if (aresta1.Equals(aresta))
{
return(true);
}
}
return(false);
}
private Aresta GetMenorArestaDesempate(List <Aresta> arestas)
{
if (arestas.Count == 1)
{
return(arestas[0]);
}
int[] somaIndice = new int[arestas.Count];
for (int i = 0; i < somaIndice.Length; i++) // verifica a soma dos números (índices) dos vértices de cada aresta
{
somaIndice[i] = (int)arestas[i].getValorVertice1 + (int)arestas[i].getValorVertice2; // ~~~~~ ver sobre Dado
}
int menorSoma = int.MaxValue;
for (int i = 0; i < somaIndice.Length; i++) // descobre a menor soma
{
menorSoma = somaIndice[i] < menorSoma ? somaIndice[i] : menorSoma;
}
List <Aresta> segundoEmpate = new List <Aresta>();
for (int i = 0; i < somaIndice.Length; i++) // adiciona a aresta de menor soma na lista de segundo empate
{
if (menorSoma == somaIndice[i])
{
segundoEmpate.Add(arestas[i]);
}
}
if (segundoEmpate.Count == 1) // se não houve segundo empate
{
return(segundoEmpate[0]);
}
int menorIndice = int.MaxValue;
Aresta arestaMenorIndice = null;
for (int i = 0; i < segundoEmpate.Count; i++) // descobre a aresta de vértice de menor número (índice)
{
if ((int)segundoEmpate[i].getValorVertice1 < menorIndice)
{
menorIndice = (int)segundoEmpate[i].getValorVertice1;
arestaMenorIndice = segundoEmpate[i];
}
if ((int)segundoEmpate[i].getValorVertice2 < menorIndice)
{
menorIndice = (int)segundoEmpate[i].getValorVertice2;
arestaMenorIndice = segundoEmpate[i];
}
}
return(arestaMenorIndice);
}
/// <summary>
/// Faz a busca da aresta de menor peso do vertice
/// </summary>
/// <returns>Retorna aresta de menor peso</returns>
public Aresta GetMenorAresta()
{
Aresta aMenor = null;
this.arestas.ForEach(aItem =>
{
if (aMenor == null || aItem.GetPeso() < aMenor.GetPeso())
{
aMenor = aItem;
}
});
return(aMenor);
}
/// <summary>
/// Compara a igualdade entre duas arestas comparando seus vértices e pesos
/// </summary>
/// <param name="aresta"></param>
/// <returns></returns>
public bool Equals(Aresta aresta)
{
try
{
Aresta comparar = (Aresta)aresta;
return(comparar.getDadoVertice1.Equals(this.vertice1.GetDado()) &&
comparar.getDadoVertice2.Equals(this.vertice2.GetDado()) &&
comparar.GetPeso().Equals(this.peso));
}
catch
{
return(false);
}
}
/// <summary>
/// Verifica se o grafo possui uma aresta, fazendo a comparação pelo método
/// Equals da aresta.
/// </summary>
/// <param name="aresta"></param>
/// <returns></returns>
public bool Contem(Aresta aresta)
{
if (aresta != null)
{
foreach (Aresta arestaLocal in this.arestas)
{
if (aresta.Equals(arestaLocal))
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Procura por uma aresta na lista de arestas do vértice e retorna em qual posição da lista
/// essa aresta está. Retorna -1 caso a aresta não exista na lista.
/// </summary>
/// <param name="aresta"></param>
/// <returns></returns>
public int getIndexAresta(Aresta aresta)
{
Aresta atual;
for (int i = 0; i < this.arestas.Count; i++)
{
atual = (Aresta)this.arestas[i];
if (atual.getValorVertice1.Equals(aresta.getValorVertice1) &&
atual.getValorVertice2.Equals(aresta.getValorVertice2) &&
aresta.GetPeso() == atual.GetPeso())
{
return(i);
}
}
return(-1);
}
public IGrafo GetAGMKruskal(out StringBuilder ordemInsercao)
{
Aresta arestaMenor = null;
Vertice v1, v2;
Grafo retorno = new Grafo();
List <Aresta> arestas = this.GetArestas();
ordemInsercao = new StringBuilder();
do
{
arestaMenor = this.GetMenorArestaDesempate(this.GetArestasMenorPeso(arestas));
if (arestaMenor != null)
{
arestas.Remove(arestaMenor);
v1 = arestaMenor.getVertice1;
v2 = arestaMenor.getVertice2;
if (!v1.GetVerticeChefe().Equals(v2.GetVerticeChefe()))
{
if (v1.FoiVisitado())
{
v2.SetVerticeChefe(v1.GetVerticeChefe());
}
else
{
v1.SetVerticeChefe(v2.GetVerticeChefe());
}
v1.SetVisitado(true);
v2.SetVisitado(true);
retorno.AddAresta(arestaMenor);
ordemInsercao.Append(arestaMenor.getValorVertice1 + "-" + arestaMenor.getValorVertice2 + " ");
}
}
} while (arestaMenor != null);
this.ResetarVisitaVertices();
return(retorno);
}
public void RemoverAresta(Aresta a)
{
if (a != null && this.Contem(a))
{
a.getVertice1.RemoverAresta(a);
a.getVertice2.RemoverAresta(a);
//foreach (Vertice v in this.GetVertices())
//{
// if (v.Contem(a))
// {
// Vertice outr = a.GetVerticeDiferente(v);
// v.RemoverAresta(a);
// }
// v.RemoverAresta(a);
//}
this.arestas.Remove(a);
a = null;
}
}
/// <summary>
/// Caso a aresta do parâmetro exista na lista de arestas do vértices, ela é removida
/// </summary>
/// <param name="aresta"></param>
public void RemoverAresta(Aresta aresta)
{
this.arestas.RemoveAll(aresta_local => aresta_local.Equals(aresta));
}