static void contabilizaTodosTempos(Cidades matriz)
{
string nomeArquivo = "Dados do exercício.csv";
StreamWriter escreverArquivo = new StreamWriter(nomeArquivo, true); //se existe, continua a escrever
Stopwatch watch;
#region Testando Quadratico
Quadratico CaixeiroQuadratico = new Quadratico();
//inicia contagem do tempo
watch = Stopwatch.StartNew();
Console.Write("\nQuadrático: ");
Console.WriteLine(CaixeiroQuadratico.GerarMelhorCaminho(matriz));
watch.Stop();
//finaliza contagem do tempo
var tempoQuadratico = watch.ElapsedMilliseconds; //salva tempo
#endregion
#region Testando Força Bruta
int[] permutacao; //vetor com um caminho possíveil
Rota[] melhorRota; //contem a melhor rota de viagem
int custo = 0, qtdeCidades = matriz.Matriz.GetLength(0);
Forca_bruta caixeiro_forca_bruta = new Forca_bruta(); //força bruta
permutacao = new int[qtdeCidades];
melhorRota = new Rota[qtdeCidades];
//inicia contagem do tempo
watch = Stopwatch.StartNew();
caixeiro_forca_bruta.Escolher_caminhos(ref permutacao, matriz, melhorRota, out custo);
Console.Write("\nForça bruta: ");
Console.WriteLine(caixeiro_forca_bruta.Imprime_Melhor_Caminho(custo, melhorRota));
watch.Stop();
//finaliza contagem do tempo
var tempoForcaBruta = watch.ElapsedMilliseconds; //salva tempo
#endregion
#region Testando Exponencial
permutacao = new int[qtdeCidades]; //tenho quase certeza que pode tirar isso
melhorRota = new Rota[qtdeCidades]; //tenho quase certeza que pode tirar isso
Exponencial vizinho = new Exponencial();
//inicia contagem do tempo
watch = Stopwatch.StartNew();
vizinho.Permutacoes(matriz, matriz.Matriz.GetLength(0), permutacao);
watch.Stop();
//finaliza contagem do tempo
var tempoExponencial = watch.ElapsedMilliseconds; //salva tempo
#endregion
Console.Write("\nExponencial: ");
Console.WriteLine(vizinho.imprimeResultados(permutacao, matriz));
escreverArquivo.WriteLine("{0};{1};{2};{3}", matriz.Matriz.GetLength(0), tempoForcaBruta, tempoExponencial, tempoQuadratico);
Console.WriteLine("---------//-----------------//---------------//---------------//----------------------//----------");
escreverArquivo.Close();
}
static void Inicializa(int qtdeCidades)
{
Cidades matriz = new Cidades(qtdeCidades);
matriz.Preencher();
contabilizaTodosTempos(matriz);
}
public string imprimeResultados(int [] melhorRota, Cidades matriz)//Imprimir resultados no Main.
{
int custo = calcularDistancia(melhorRota, matriz);
StringBuilder aux = new StringBuilder();
for (int pos = 0; pos < melhorRota.Length; pos++)
{
aux.Append(melhorRota[pos] + " ");
}
return(new Trajeto(aux.ToString(), custo).ToString());
}
public void Escolher_caminhos(ref int[] permutacao, Cidades matrizDistancias, Rota[] melhorRota, out int melhorCusto)
{
int controle = -1;
melhorCusto = int.MaxValue;
for (int i = 0; i < melhorRota.Length; i++)
{
melhorRota[i] = new Rota();
}
/* Gera os caminhos possiveis e escolhe o melhor, chamando a funcao recursiva
* permuta */
permuta(permutacao, matrizDistancias, melhorRota, ref melhorCusto, controle, 1);
}
private int calcularDistancia(int[] melhorCaminho, Cidades matriz)
{
int valorTotal = 0;
for (int pos = 0; pos < melhorCaminho.Length; pos++)
{
if (pos + 1 >= melhorCaminho.Length)
{
valorTotal += matriz.Matriz[melhorCaminho[pos], 0];
}
else
{
valorTotal += matriz.Matriz[melhorCaminho[pos], melhorCaminho[pos + 1]];
}
}
return(valorTotal);
}
public void Melhor_caminho(Cidades matriz, Rota[] melhorRota, ref int melhorCusto, int[] permutacao)
{
int j, k; /* contadores: auxiliam a montagem das rotas */
int cid1, cid2; /* cidades da melhor rota */
int custo; /* custo total da melhor rota */
int[] proxDaRota; /* vetor que armazena a sequencia de cidades que estao
* em uma rota, tal que um indice indica uma cidade e
* o conteudo deste indice, a proxima cidade da rota */
proxDaRota = new int[melhorRota.Length];
/* monta uma rota com a permutacao */
cid1 = 0; /* a primeira cidade é a cidade 0 */
cid2 = permutacao[1];
custo = matriz.Matriz[cid1, cid2];
proxDaRota[cid1] = cid2;
for (j = 2; j < melhorRota.Length; j++)
{
cid1 = cid2;
cid2 = permutacao[j];
custo += matriz.Matriz[cid1, cid2]; /* calcula o custo parcial da rota */
proxDaRota[cid1] = cid2; /* armazena a rota fornecida pela permutacao */
}
proxDaRota[cid2] = 0; /* completa o ciclo da viagem */
custo += matriz.Matriz[cid2, 0]; /* custo total desta rota */
if (custo < melhorCusto) /* procura pelo melhor (menor) custo */
{
melhorCusto = custo;
cid2 = 0;
for (k = 0; k < melhorRota.Length; k++) /* guarda a melhor rota */
{
cid1 = cid2;
cid2 = proxDaRota[cid1];
melhorRota[k].cidade1 = cid1;
melhorRota[k].cidade2 = cid2;
melhorRota[k].custo = matriz.Matriz[cid1, cid2];
}
}
}
void permuta(int[] permutacao, Cidades matrizDistancias, Rota[] melhorRota, ref int melhorCusto, int controle, int k)
{
int i;
permutacao[k] = ++controle;
if (controle == (melhorRota.Length - 1)) /* se gerou um caminho então verifica se ele é melhor */
{
Melhor_caminho(matrizDistancias, melhorRota, ref melhorCusto, permutacao);
}
else
{
for (i = 1; i < melhorRota.Length; i++)
{
if (permutacao[i] == 0)
{
permuta(permutacao, matrizDistancias, melhorRota, ref melhorCusto, controle, i);
}
}
}
controle--;
permutacao[k] = 0;
}
public void Permutacoes(Cidades cidades, int tam, int[] vetResp)
{
int[] vet = new int[tam]; //cria vetor cujo tamanho é o número de cidades
int aux = 0, fat = Fatorial(tam - 1); //aciona a recursividade do número de permutações possíveis
vetResp[0] = 0;
for (int i = 0; i < tam; i++)//Preenche vetor com as cidades.
{
vet[i] = i;
}
for (int n = 0; n < fat; n++) //Total de permutações
{
for (int i = 1; i < tam - 1; i++) //Permutar e compor o caminho.
{
Menor_Caminho(vet, cidades, vetResp); //aciona método do menor caminho
aux = vet[i]; //auxiliar recebe 1ª cidade
vet[i] = vet[i + 1]; //1ª cidade recebe 2ª cidade
vet[i + 1] = aux; //2ª cidade recebe auxiliar (1ª cidade)
}
}
}
public string GerarMelhorCaminho(Cidades matriz)
{
int quantidadeCidades = matriz.Matriz.GetLength(0);
int[] melhorCaminho = new int[quantidadeCidades]; //preenche a rota mais rapida
bool[] cidadeVisitada = new bool[quantidadeCidades]; //sei se a cidade foi visitada ou nãp
//Vamos começar da cidade 0 ou primeira cidade
melhorCaminho[0] = 0; //começamos da cidade 0 ou primeira cidade
cidadeVisitada[0] = true; //cidade 0 foi visitada
//gerar melhor caminho a partir da segunda posição
int percorreMelhorCaminho = 1;
while (!TodosVisitados(cidadeVisitada))// enquanto não visitar todos
{
int menorDistancia = int.MaxValue, guardaPosicaoMenor = -1;
for (int proximaCidade = 1; proximaCidade < quantidadeCidades; proximaCidade++) //percorro todas as cidades
{
if (!cidadeVisitada[proximaCidade]) //se a cidade foi visitada, não precisa contar ela
{
//Console.Write(" " + proximaCidade);
int cidadeAtual = melhorCaminho[percorreMelhorCaminho];
if (menorDistancia > matriz.Matriz[proximaCidade, cidadeAtual])
{
guardaPosicaoMenor = proximaCidade;
menorDistancia = matriz.Matriz[proximaCidade, cidadeAtual];
}
}
}
cidadeVisitada[guardaPosicaoMenor] = true;
melhorCaminho[percorreMelhorCaminho] = guardaPosicaoMenor;
percorreMelhorCaminho++;
}
return(new Trajeto(ConverterVetor(melhorCaminho), calcularDistancia(melhorCaminho, matriz)).ToString());
}
public void Menor_Caminho(int[] vetCaminho, Cidades cidades, int[] vetResp)//Verifica menor caminho.
{
int aux_2 = 0;
for (int i = 0; i < vetCaminho.Length - 1; i++)//Custo total do caminho.
{
aux_2 += cidades.Matriz[vetCaminho[i], vetCaminho[i + 1]];
if (aux_2 > somaTotal)
{
i = vetCaminho.Length;
}
}
if (aux_2 < somaTotal)//Menor caminho calculado.
{
somaTotal = aux_2;
for (int i = 0; i < vetCaminho.Length; i++)
{
vetResp[i] = vetCaminho[i];
}
}
}