コード例 #1
0
        private void CriaCaminho(NoArvore <Cidade> origem, int procurado)
        {
            ListaSimples <Caminho> cam = new ListaSimples <Caminho>(); //Uma lista para armazenar todos os caminhos possíveis
            Caminho inicial            = new Caminho();                //Um caminho inicial apenas para a chamada do método

            VaiPara(ref cam, inicial, origem, procurado);

            txtTeste.Text = cam.ToString();
        }
コード例 #2
0
        private void VaiPara(ref ListaSimples <Caminho> cam, Caminho jaPercorrido, NoArvore <Cidade> origem, int procurado)
        {
            //Como salvamos o valor dos caminhos usando da coluna para marcar a cidade de destino, pensamos em criar um método da matriz esparsa para
            //nos retornar o primeiro membro dessa coluna, desta forma poderíamos ver todas as possibilidades de caminho que levam até a cidade escolhida

            Celula <CaminhoEntreCidades> atual       = caminhos.BuscaColuna(procurado);
            NoArvore <Cidade>            cid         = new NoArvore <Cidade>();                //A Cidade que nos levará até lá
            NoArvore <Cidade>            cidadeAtual = new NoArvore <Cidade>();                //A Cidade que queremos ir

            while (atual.Valor != null)                                                        //Percorre-se até que não aja mais nenhum caminho que nos leve a cidade
            {
                cidades.Existe(new Cidade(procurado, "", 0, 0), ref cidadeAtual);              //Apenas para ajustar o pârametro de referência

                if (cidades.Existe(new Cidade(atual.Valor.IdCidadeOrigem, "", 0, 0), ref cid)) //Idem
                {
                    if (atual.Valor.IdCidadeOrigem != origem.Info.IdCidade)                    //Caso atinjamos a cidade buscada pela cidade de origem podemos encerrar o
                                                                                               //método visto que já conseguimos completar o caminho
                    {
                        if (!jaPercorrido.CidadesVisitadas.ExisteDesordenado(cid.Info) &&
                            !jaPercorrido.CidadesVisitadas.ExisteDesordenado(cidadeAtual.Info)) //Para não passarmos por cidades repetidamente
                                                                                                //E Evitar loops (ir e voltar infinitamente)
                        {
                            Caminho Aux = new Caminho(jaPercorrido);                            //Como ainda existem outros caminhos para se explorar, não podemos perder o valor
                                                                                                //do jaPercorrido Atual que será usado quando este metodo descongelar, então é
                                                                                                //melhor que editemos e mandemos apenas um clone
                            Aux.CidadesVisitadas.InserirAntesDoInicio(cidadeAtual.Info);        //A Cidade Atual é a cidade por qual devemos passar para chegar
                                                                                                //ao destino (ou o próprio destino)
                            Aux.Distancia += atual.Valor.Distancia;
                            Aux.Custo     += atual.Valor.Custo;
                            Aux.Tempo     += atual.Valor.Tempo;

                            VaiPara(ref cam, Aux, origem, cid.Info.IdCidade); //Chamamos o Método Novamente de Forma Recursiva
                        }
                    }
                    else
                    {
                        Caminho Aux = new Caminho(jaPercorrido);                     //Como Anteriormente dito, mesmo que o caminho esteja completo, novos caminhos podem
                                                                                     //ser explorados, então não podemos perder os valores padrões do jaPercorrido

                        Aux.CidadesVisitadas.InserirAntesDoInicio(cidadeAtual.Info); //Inserimos a primeira cidade visitada
                        Aux.Distancia += atual.Valor.Distancia;
                        Aux.Custo     += atual.Valor.Custo;
                        Aux.Tempo     += atual.Valor.Tempo;
                        Aux.CidadesVisitadas.InserirAntesDoInicio(origem.Info); // E por fim a Origem

                        cam.InserirEmOrdem(Aux);                                //Este caminho está completo e deve ser guardado
                    }
                }
                else
                {
                    throw new Exception("Cidade Não Existe");
                }

                atual = atual.Abaixo; //Continuamos a procurar um novo caminho
            }
        }
コード例 #3
0
        private ListaSimples <Rota> obterRotas(Cidade origem, Cidade destino)
        {
            int codOrigem  = origem.Cod;
            int codDestino = destino.Cod;
            ListaSimples <Rota> caminhos = new ListaSimples <Rota>();

            achaProx(ref caminhos, codOrigem, codDestino);

            return(caminhos);
        }
コード例 #4
0
    // exercicio 3

    public void CasamentoCom(ListaSimples <Dado> outra,
                             ref ListaSimples <Dado> nova)
    {
        nova = new ListaSimples <Dado>();
        NoLista <Dado> a = null,
                       b = null;

        while (!this.EstaVazia && !outra.EstaVazia)
        {
            a = this.primeiro;
            b = outra.primeiro;

            if (a.Info.CompareTo(b.Info) < 0)
            {
                this.quantosNos--;
                this.primeiro = this.primeiro.Prox; // avança na lista 1
                nova.InserirAposFim(a);
            }
            else
            if (b.Info.CompareTo(a.Info) < 0)
            {
                outra.quantosNos--;
                outra.primeiro = outra.primeiro.Prox; // avança na lista 2
                nova.InserirAposFim(b);
            }
            else
            {
                this.quantosNos--;
                outra.quantosNos--;
                this.primeiro  = this.primeiro.Prox;  // avança na lista 1
                outra.primeiro = outra.primeiro.Prox; // avança na lista 2
                nova.InserirAposFim(a);
            }
        }
        if (!this.EstaVazia)  // não acabou a lista 1
        {
            nova.ultimo.Prox = this.primeiro;
            nova.ultimo      = this.ultimo;
            nova.quantosNos += this.quantosNos;
        }

        if (!outra.EstaVazia)
        {
            nova.ultimo.Prox = outra.primeiro;
            nova.ultimo      = outra.ultimo;
            nova.quantosNos += outra.quantosNos;
        }

        this.primeiro   = this.ultimo = null;
        this.quantosNos = 0;

        outra = new ListaSimples <Dado>();
    }
コード例 #5
0
    public void Ordenar()
    {
        ListaSimples <Dado> ordenada     = new ListaSimples <Dado>();
        NoLista <Dado>      menorDeTodos = null,
                            antesDoMenor = null;

        while (!this.EstaVazia)
        {
            ProcurarMenorDado(ref menorDeTodos, ref antesDoMenor);

            NoLista <Dado> novoNo = menorDeTodos;
            this.RemoverNo(ref menorDeTodos, ref antesDoMenor);

            ordenada.InserirAposFim(novoNo);
        }
    }
コード例 #6
0
        private void achaProx(ref ListaSimples <Rota> lista, int codO, int codD)
        {
            for (int i = 0; i < quantosdados; i++)
            {
                if (rotasMatriz[i, 0] == codO)
                {
                    for (int a = 0; a < quantosdados; a++)
                    {
                        ListaSimples <Caminho> novaRota = new ListaSimples <Caminho>();

                        if (rotasMatriz[i, a] > 0)
                        {
                            novaRota.InserirAntesDoInicio(new Caminho(rotasMatriz[i, 0], rotasMatriz[a, 0], rotasMatriz[i, a]));

                            if (rotasMatriz[0, a] == codD)
                            {
                                Rota RotaPronta = new Rota();
                                while (!novaRota.EstaVazia)
                                {
                                    RotaPronta.AdicionarCaminho(novaRota.Primeiro.Info);
                                    novaRota.Remover(novaRota.Primeiro.Info);
                                }
                                lista.InserirAposFim(RotaPronta);
                            }
                            else
                            {
                                achaProx(ref lista, rotasMatriz[a, 0], codD);
                            }
                        }
                        else
                        if (a == quantosdados)
                        {
                            novaRota.Remover(novaRota.Ultimo.Info);
                            achaProx(ref lista, novaRota.Ultimo.Info.CodOrigem, codD);
                        }
                    }
                }
            }
        }
コード例 #7
0
        private void BtnBuscar_Click(object sender, EventArgs e)
        {
            dataGridView1.RowCount    = 0;
            dataGridView1.ColumnCount = 6;

            dataGridView2.RowCount    = 0;
            dataGridView2.ColumnCount = 6;

            if (destino != origem)
            {
                ListaSimples <Rota> rotas = obterRotas(origem, destino);

                rotas.Atual = rotas.Primeiro;

                Rota nova, menor = new Rota();
                menor.AdicionarCaminho(new Caminho(-1, -1, int.MaxValue));
                while (rotas.Atual != null)
                {
                    nova = rotas.Atual.Info;
                    if (nova.DistanciaTotal() < menor.DistanciaTotal())
                    {
                        menor = nova;
                    }

                    exibirDgv(nova, dataGridView1);
                    rotas.Atual = rotas.Atual.Prox;
                }
                exibirDgv(menor, dataGridView2);
                podeMostrar = true;
            }
            else
            {
                MessageBox.Show("Você já está onde você quer chegar.");
            }

            marcarOrigem();
            marcarDestino();
        }