/*
* algoritmo de kruskal se baseia em guardar primeiro a aresta de menor custo.
* procurar pela proxima aresta de menor custo e gravar na arvore.
*/
public Graph Kruskal(string name)
{
Graph arvore = new Graph();
Edge arestaMenorCusto = null;
List <Edge> listaArestas = new List <Edge>();
List <Edge> listaMenorCustoArestas = new List <Edge>();
List <Node> nosVisitados = new List <Node>();
foreach (Node n in this.nodes)
{
foreach (Edge e in n.Edges)
{
listaArestas.Add(e);
}
}
foreach (Node n in this.nodes)
{
arvore.AddNode(n.Name);
}
//ordena todas as arestas por ordem
while (listaArestas.Count != 0)
{
arestaMenorCusto = listaArestas[0];
foreach (Edge e in listaArestas)
{
if (e.Cost <= arestaMenorCusto.Cost)
{
arestaMenorCusto = e;
}
}
listaMenorCustoArestas.Add(arestaMenorCusto);
listaArestas.Remove(arestaMenorCusto);
}
//armazena nos dentro de uma lista para conferir
nosVisitados.Add(listaMenorCustoArestas[0].From);
foreach (Edge e in listaMenorCustoArestas)
{
//para cada no se ele ainda nao foi adicionado armazene na arvore
if (!nosVisitados.Contains(e.To))
{
nosVisitados.Add(e.To);
arvore.AddEdge(e.From.Name, e.To.Name, e.Cost);
arvore.AddEdge(e.To.Name, e.From.Name, e.Cost);
}
}
return(arvore);
}
private bool Hamiltonian(Node n)
{
// Cria lista para armazenar o resultado..
Queue <Node> queue = new Queue <Node>();
// Arvore
Graph arvore = new Graph();
int id = 0;
id++;
arvore.AddNode(id.ToString(), n.Name);
queue.Enqueue(arvore.Find(id.ToString()));
// Realiza a busca..
while (queue.Count > 0)
{
Node np = queue.Dequeue();
Node currentNode = this.Find(np.Info.ToString());
if (this.nodes.Count == CountNodes(np))
{
return(true);
}
foreach (Edge edge in currentNode.Edges)
{
if (!ExistNode(np, edge.To.Name))
{
id++;
arvore.AddNode(id.ToString(), edge.To.Name);
Node nf = arvore.Find(id.ToString());
queue.Enqueue(nf);
arvore.AddEdge(nf.Name, np.Name, 1);
}
}
}
return(false);
}
public Graph Kruskal(string name)
{
Graph gTree = new Graph();
List <Edge> eList = new List <Edge>();
foreach (Node n in nodes)
{
gTree.AddNode(n.Name, n.Info);
eList.AddRange(n.Edges);
}
eList = eList.OrderBy(c => c.Cost).ToList();
foreach (Edge e in eList)
{
if (!ExistEdge(gTree.Find(e.To.Name), gTree))
{
gTree.Find(e.From.Name).AddEdge(e.To, e.Cost);
}
}
return(gTree);
}
/*
* o algoritmo de prim pega um vertice aleatorio e através dele armazena-se a aresta com menor valor
* sendo feito isso até o grafo novo estar com o mesmo tamanho
*/
public Graph Prim(string name)
{
Graph arvore = new Graph();
Random rdn = new Random();
List <Node> listaNos = new List <Node>();
List <Edge> listaArestas = new List <Edge>();
List <Edge> listaArestasMenorCusto = new List <Edge>();
Edge menorAresta = null;
int contadorNos = -1;
double cost = 0;
//arvore.AddNode(no.Name);
listaNos.Add(this.nodes[rdn.Next(this.nodes.Count)]);
if (listaNos[0].Edges.Count > 0)
{
do
{
//para cada aresta encontrada na lista dos nos armazenados
//guarda-se todas as arestas
foreach (Node n in listaNos)
{
foreach (Edge e in n.Edges)
{
if (!listaArestas.Contains(e))
{
listaArestas.Add(e);
}
}
}
menorAresta = null;
//pega aresta de maior valor na lista
foreach (Edge e in listaArestas)
{
if (cost < e.Cost)
{
cost = e.Cost;
}
}
//emcontra a aresta de menor custo
//armazena a aresta de menor custo na lista de aresta de menor custo
foreach (Edge e in listaArestas)
{
if (cost > e.Cost && !listaArestasMenorCusto.Contains(e) && !listaNos.Contains(e.To))
{
cost = e.Cost;
menorAresta = e;
}
}
//se aresta for encontrada adiciona na lista de menor aresta
if (menorAresta != null)
{
listaNos.Add(menorAresta.To);
listaArestasMenorCusto.Add(menorAresta);
arvore.AddNode(menorAresta.From.Name);
arvore.AddNode(menorAresta.To.Name);
arvore.AddEdge(menorAresta.From.Name, menorAresta.To.Name, menorAresta.Cost);
arvore.AddEdge(menorAresta.To.Name, menorAresta.From.Name, menorAresta.Cost);
}
contadorNos++;
} while (arvore.nodes.Count != contadorNos);
}
return(arvore);
}