Example #1
0
        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();
        }
Example #2
0
        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);
        }
Example #5
0
        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)
                }
            }
        }
Example #9
0
        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];
                }
            }
        }