Пример #1
0
        /**
         * Método que le o arquivo "CaminhosEntreCidadesMarte.txt" e retorna os seus dados numa lista genérica de caminhos.
         */
        public static List <Movimento> LerMovimentos()
        {
            StreamReader     leitorDeArquivos = new StreamReader("CaminhosEntreCidadesMarte.txt", Encoding.GetEncoding("iso-8859-1"));
            List <Movimento> listaMovimentos  = new List <Movimento>();

            while (!leitorDeArquivos.EndOfStream)
            {
                String linhaLida       = leitorDeArquivos.ReadLine();
                int    idCidadeOrigem  = int.Parse(linhaLida.Substring(0, 4).Trim());
                int    idCidadeDestino = int.Parse(linhaLida.Substring(4, 3).Trim());
                int    distancia       = int.Parse(linhaLida.Substring(7, 6).Trim());
                int    tempo           = int.Parse(linhaLida.Substring(13, 4).Trim());
                int    custo           = int.Parse(linhaLida.Substring(17, 3).Trim());

                Movimento novoMovimento = new Movimento(idCidadeOrigem, idCidadeDestino, distancia, tempo, custo);
                listaMovimentos.Add(novoMovimento);
            }
            return(listaMovimentos);
        }
Пример #2
0
        /**
         * Método que retorna a matriz de adjacência, que representa o matrizAdjacencia de cidades.
         * Primeiramente, é criada uma matriz com o tamanho máximo equivalente à quantidade de cidades nos arquivos texto.
         * Após isso, são usados 2 "for" para percorrer os elementos da lista de caminho e verificar se existem caminhos equivalentes ao índices.
         * Se sim, a distância do caminho é armazenada na matriz de adjacência.
         */
        public Movimento[,] MontarMatrizAdjacencia()
        {
            Movimento[,] matrizAdjacencia = new Movimento[QtdCidades, QtdCidades];

            for (int i = 0; i < QtdCidades; i++)
            {
                for (int j = 0; j < QtdCidades; j++)
                {
                    foreach (Movimento mov in ListaMovimentos)
                    {
                        if (mov.IdCidadeOrigem == i && mov.IdCidadeDestino == j)
                        {
                            matrizAdjacencia[i, j] = mov;
                        }
                    }
                }
            }

            return(matrizAdjacencia);
        }
Пример #3
0
        public Movimento[] ExibirPercursos(int inicioPercurso, int fimPercurso)
        {
            int cont = 0;

            Stack <string> pilha = new Stack <string>();

            int onde = fimPercurso;

            while (onde != inicioPercurso)
            {
                onde = percurso[onde].verticePai;
                pilha.Push(vertices[onde].rotulo);
                cont++;
            }

            int i = 0;

            Movimento[] caminho = new Movimento[pilha.Count + 1];
            while (pilha.Count != 0)
            {
                caminho[i] = new Movimento(pilha.Pop());

                i++;
            }

            if ((cont == 1) && (percurso[fimPercurso].distancia == infinity))
            {
                caminho = null;
            }
            else
            {
                caminho[i] = new Movimento(vertices[fimPercurso].rotulo);
            }

            return(caminho);
        }
Пример #4
0
        // Evento click do botão que irá obter as cidades escolhidas pelo usuário e chamará o método de busca de caminhos
        private void BtnBuscar_Click(object sender, EventArgs e)
        {
            int idOrigem  = GetOrigem();
            int idDestino = GetDestino();

            Movimento[] percurso = new Movimento[23];

            if (idOrigem == -1 || idDestino == -1)
            {
                MessageBox.Show("Cidades inválidas");
                return;
            }

            if (idOrigem == idDestino)
            {
                MessageBox.Show("Destino é igual à origem!");
                return;
            }

            if (GetCriterio() == null)
            {
                MessageBox.Show("Selecione o critério desejado!");
                return;
            }


            if (GetMetodo() == null)
            {
                MessageBox.Show("Selecione o método desejado!");
                return;
            }

            var rb = GetMetodo();

            switch (rb.Name)
            {
            case "rbPilhas": caminhos = grafoBacktracking.ProcurarCaminhos(idOrigem, idDestino);
                break;

            case "rbRecursao": caminhos = grafoBacktracking.ProcurarCaminhosRec(idOrigem, idDestino);
                break;

            case "rbDijkstra":  InicializarGrafo();
                percurso = grafoDijkstra.Caminho(idOrigem, idDestino);
                var pilhaLista = GetPilha(percurso);
                caminhos = new PilhaLista <PilhaLista <Movimento> >();
                caminhos.Empilhar(pilhaLista);
                txtTotal.Text = grafoDijkstra.GetTotalPercurso(percurso) + "";
                break;
            }

            LimparDados();
            if (caminhos.GetQtd() > 0)
            {
                ExibirCaminhos();
                ExibirMelhorCaminho();
            }

            if (caminhos.GetQtd() == 0)
            {
                MessageBox.Show("Nenhum caminho foi encontrado!");
            }
            else
            {
                MessageBox.Show("Número de caminhos encontrados: " + caminhos.GetQtd().ToString());
            }
        }