} /* fim Imprime tempo */

        //------------------------------------------------------------------------------


        /* Coordena as partes do programa */
        static void Main(string[] args)
        {
            int[]  permutacao;   /* vetor com uma possivel rota de viagem */
            Rota[] melhorRota;   /* contera' a melhor rota da viagem */
            int    numCidades,   /* numero de vertices (cidades) do grafo */
                   melhorCusto;  /* custo da viagem pelo grafo (pelas cidades) */

            CaixeiroOtimo caixeiro = new CaixeiroOtimo();
            Grafo         grafo; // = new Grafo();         /* matriz de adjacencia com o grafo */

            Console.Write("\n\n\t\tDigite o numero de cidades: ");
            numCidades = int.Parse(Console.ReadLine());
            caixeiro.montaGrafo(out grafo, numCidades);

            permutacao = new int[numCidades];
            melhorRota = new Rota[numCidades];

            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start(); //Inicia a contagem do tempo
            caixeiro.geraEscolheCaminhos(ref permutacao, grafo, melhorRota, out melhorCusto);
            stopwatch.Stop();  //Encerra a contagem do tempo
            caixeiro.imprimeMelhorCaminho(melhorCusto, melhorRota);
            caixeiro.imprimeTempo(stopwatch);

            Console.ReadKey(true);
        } /* fim main */
        } // fim montaGrafo

        //------------------------------------------------------------------------------

        /*
         *      Gera os possiveis caminhos entre a cidade zero e todas as outras envolvidas
         *   na rota da viagem do caixeiro e escolhe a melhor rota entre todas.
         */
        void geraEscolheCaminhos(ref int[] permutacao, Grafo grafo, 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, grafo, melhorRota, ref melhorCusto, controle, 1);
        } /* fim GeraEscolheCaminhos */
Example #3
0
        const int MaxCusto = 50;// custo ou distância máxima entre duas cidades

        /**
         * Monta a rota obtida através do algortimo guloso
         */
        void encontraCaminho(Grafo grafo, List <Rota> caminho, ref int custo)
        {
            int i, cid1 = 0, cid2 = 0, menorCusto, tamanho = caminho.Capacity;

            int[]      pos         = new int[grafo.M.Length];
            List <int> adicionados = new List <int>(grafo.M.Length); //Lista contendo os vértices que já foram adicionados à rota

            adicionados.Add(0);                                      //adiciona o primeiro vértice (0)
            Rota rota = new Rota();

            custo = 0;

            for (i = 0; i < tamanho; i++)
            {
                menorCusto   = MaxCusto + 1;
                rota.cidade1 = cid1;//Adiciona a cidade 1 à rota

                //No final retorna ao vértice inicial (0)
                if (i == caminho.Capacity - 1)
                {
                    menorCusto = grafo.M[cid1, 0];
                    cid2       = 0;
                }
                else
                {
                    for (int j = 0; j < tamanho; j++)
                    {
                        if (j != cid1 && !adicionados.Contains(j))
                        {
                            //Encontra o arco adjacente com menor peso, e o vértice adjacente a ele
                            if (grafo.M[cid1, j] != 0 && grafo.M[cid1, j] < menorCusto)
                            {
                                menorCusto = grafo.M[cid1, j];
                                cid2       = j;
                            }
                        }
                    }
                }
                rota.cidade2 = cid2;       //adiciona a segunda cidade à rota()
                rota.custo   = menorCusto; //adiciona o custo da rota
                adicionados.Add(cid2);
                custo += menorCusto;       //adiciona o custo da rota a soma do custo total
                caminho.Add(rota);         //Adiciona a rota oa caminho
                rota = new Rota();
                cid1 = cid2;
            }
        }