private void ConverterParaPosfixa(FilaLista <char> seqInfixa, ref string posfixa)
{
char operadorComMaiorPrecedencia;
PilhaLista <char> pilha = new PilhaLista <char>(); //pilha que será usada para empilhar operadores
do
{
char simboloLido = seqInfixa.Retirar(); //simbolo lido é retirado da fila de sequencia infixa
if (!(simboloLido <= 'Z' && simboloLido >= 'A')) //se o simbolo lido não estiver entre A e Z, ou seja, for um operador
{
if (pilha.EstaVazia()) //se a pilha estiver vazia, empilha-se simbolo lido
{
pilha.Empilhar(simboloLido);
}
else //se não estiver vazia
{
while (!pilha.EstaVazia() && DeveDesempilhar(pilha.OTopo(), simboloLido)) //enquanto a pilha não estiver vazia e deve desempilhar, ou seja, o topo da pilha tem precedencia sobre o simbolo lido
{
operadorComMaiorPrecedencia = pilha.Desempilhar(); //armazena-se operador com maior precedencia, tirando-o do topo
if (operadorComMaiorPrecedencia != '(') //caso não seja '(', pois não se coloca parêntesis em sequências posfixas
{
seqPosfixa.Enfileirar(operadorComMaiorPrecedencia); //enfileira-se na seqPosfixa
posfixa += operadorComMaiorPrecedencia; //concatena-se na string de posfixa
}
}
if (simboloLido != ')') // empilha-se o simbolo lido, a menos que ele seja um ')'
{
pilha.Empilhar(simboloLido);
}
else
{
if (!pilha.EstaVazia() && pilha.OTopo() == '(') //se o simbolo lido for ')' e já foi feito o método acima sobre as precedencias, restará um parentesis aberto no topo da pilha, a menos que a sequência não esteja balanceada
{
operadorComMaiorPrecedencia = pilha.Desempilhar();
}
else
{
erro = true;
}
}
}
}
else // se for letra
{
seqPosfixa.Enfileirar(simboloLido); //enfileira-se letra na sequência
posfixa += simboloLido; //concatena-se a letra na string posfixa
}
}while (!seqInfixa.EstaVazia() && !erro); //enquando não estiver vazia e não houver nenhum erro, continua-se a expressão
while (!pilha.EstaVazia() && !erro) // se a fila de sequência ja estiver acabado mas houver operandos na pilha e não tiver dado erro
{
operadorComMaiorPrecedencia = pilha.Desempilhar(); //desempilha-se elemento da pilha
if (operadorComMaiorPrecedencia != '(') //se não for '('
{
seqPosfixa.Enfileirar(operadorComMaiorPrecedencia); //enfileira elemento
posfixa += operadorComMaiorPrecedencia; //concatena à string posfixa
}
}
}
private void Converter(string inf)
{
string elemento = "";
string op = "";
for (int i = 0; i < inf.Length; i++) //Passa por todos os itens da sequencia infixa
{
elemento = "";
if (!ops.Contains(inf[i])) //Se o item lido não for um operador
{
elemento = "";
int inicial = i; //index do início do numero
while (inicial + elemento.Length < inf.Length && (!ops.Contains(inf[inicial + elemento.Length].ToString()) || inf[inicial + elemento.Length] == '.')) //Enquanto o elemento ainda for um número
{
elemento += inf[inicial + elemento.Length]; //O número é incrementado
}
i = inicial + elemento.Length - 1; //o for continua a partir de onde a leitura parou
posfixa.Enfileirar(elemento); //O número é adicionado na fila posfixa
}
else //Se o item lido for um operador
{
elemento = inf[i].ToString(); //O elemento recebe o item lido
while (!pilOps.EstaVazia() && Precedencia(pilOps.OTopo()) >= Precedencia(elemento[0].ToString())) //Enquanto o primeiro operador da pilha tiver precedência sobre os outros
{
op = pilOps.OTopo(); //Identifica o operador a ser tratado
if (op == "(")
{
break;
}
posfixa.Enfileirar(op.ToString()); //O operador é adicionado na sequencia posfixa
pilOps.Desempilhar(); //E removido da pilha
}
if (elemento == ")") //Se o operador for o fecha parênteses
{
pilOps.Desempilhar(); //Desempilha o ultimo operador
}
else //Se não
{
pilOps.Empilhar(elemento); //Empilha o operador normalmente
}
}
if (elemento != "(" && elemento != ")") //Verifica se o item não é ( nem ), pois esses não entram na sequência
{
infixa.Enfileirar(elemento); //Adiciona o item na infixa
}
}
while (!pilOps.EstaVazia()) //Até a pilha ficar vazia
{
op = pilOps.Desempilhar(); //Desempilha o operador
if (op != "(" && op != ")") //Verifica se o item não é ( nem ), pois esses não entram na sequência
{
posfixa.Enfileirar(op); //Enfilera o operador na posfixa
}
}
}
//private string ParaPosfixa(string infixa)
//{
// string ret = "";
// char[] exp = infixa.ToCharArray();
// string ops = "()^*/+-";
// PilhaLista<char> seq = new PilhaLista<char>();
// //foreach (char c in exp)
// //{
// // if (ops.Contains(c))
// // {
// // if (seq.EstaVazia())
// // seq.Empilhar(c);
// // else
// // {
// // if (MaiorPrecedencia(seq.OTopo(), c) == seq.OTopo())
// // {
// // if (c == ')')
// // {
// // while (!seq.EstaVazia() && seq.OTopo() != '(')
// // ret += seq.Desempilhar();
// // }
// // else
// // {
// // ret += seq.Desempilhar();
// // seq.Empilhar(c);
// // }
// // }
// // else
// // seq.Empilhar(c);
// // }
// // }
// // else
// // ret += c;
// //}
// for (int i=0; i<infixa.Length; i++)
// {
// char c = infixa[i];
// if (ops.Contains(c))
// {
// if (seq.EstaVazia())
// {
// seq.Empilhar(c);
// }
// else
// {
// if (MaiorPrecedencia(seq.OTopo(), c) == seq.OTopo())
// {
// if (c == '+' || c == '-')
// {
// ret += seq.Desempilhar();
// i--;
// }
// else
// {
// ret += seq.Desempilhar();
// i--;
// }
// }
// else
// {
// if (c == '+' || c == '-')
// {
// ret += seq.Desempilhar();
// seq.Empilhar(c);
// }
// else
// {
// seq.Empilhar(c);
// }
// }
// }
// }
// else
// {
// ret += c;
// }
// }
// return ret;
//}
//public string ParaPosfixa(string inf)
//{
// string ret = "";
// char[] exp = inf.ToCharArray();
// string ops = "()^*/+-";
// PilhaLista<string> pilOps = new PilhaLista<string>();
// for (int i = 0; i < inf.Length; i++)
// {
// string elemento = "";
// if (!ops.Contains(inf[i].ToString()))
// {
// elemento = "";
// int inicial = i;
// while (inicial + elemento.Length < inf.Length && (!ops.Contains(inf[inicial + elemento.Length].ToString()) || inf[inicial + elemento.Length] == '.'))
// elemento += inf[inicial + elemento.Length];
// i = inicial + elemento.Length - 1;
// //posfixa.Enfileirar(elemento);
// }
// else
// {
// if (inf[i] == '+' && (i == 0 || inf[i - 1] == '('))
// elemento = "#";
// else
// if (inf[i] == '-' && (i == 0 || inf[i - 1] == '('))
// elemento = "@";
// else
// elemento = inf[i] + "";
// while (!pilOps.EstaVazia() && Precedencia(pilOps.OTopo()[0] )> Precedencia (elemento[0]))
// {
// string op = pilOps.Desempilhar();
// /*if (op != "(" && op != ")")
// posfixa.Enfileirar(op);*/
// }
// if (elemento != ")")
// pilOps.Empilhar(elemento);
// }
// if (elemento != "(" && elemento != ")")
// ret += elemento;
// //infixa.Enfileirar(elemento);
// }
// //TratarPilhaOperadores();
// while (!pilOps.EstaVazia())
// {
// string o = pilOps.Desempilhar();
// ret += o;
// }
// //sequenciaInfixa = EscreverSequencia(infixa);
// //sequenciaPosfixa = EscreverSequencia(posfixa);
// //resultado = CalcularResultado();
// //return resultado;
// return ret;
//}
private void Converter(string inf)
{
for (int i = 0; i < inf.Length; i++)
{
string elemento = "";
if (ops.Contains(inf[i]))
{
elemento = "";
int inicial = i;
while (inicial + elemento.Length < inf.Length && (!ops.Contains(inf[inicial + elemento.Length].ToString()) || inf[inicial + elemento.Length] == '.'))
{
elemento += inf[inicial + elemento.Length];
}
i = inicial + elemento.Length - 1;
posfixa.Enfileirar(elemento);
}
else
{
elemento = inf[i].ToString();
while (!pilOps.EstaVazia() && Precedencia(pilOps.OTopo()) > Precedencia(elemento[0].ToString()))
{
char op = pilOps.OTopo()[0];
if (op == '(')
{
break;
}
posfixa.Enfileirar(op.ToString());
pilOps.Desempilhar();
}
if (elemento != ")")
{
pilOps.Empilhar(elemento);
}
else
{
pilOps.Desempilhar();
}
}
if (elemento != "(" && elemento != ")")
{
infixa.Enfileirar(elemento);
}
}
while (!pilOps.EstaVazia())
{
string op = pilOps.Desempilhar();
if (op != "(" && op != ")")
{
posfixa.Enfileirar(op);
}
}
}
// MÉTODO PARA TRANSFORMAR A EXPRESSÃO INFIXA PARA PÓSFIXA
private static void InfixaParaPosfixa(string expLetras, ref string expPosfixa)
{
PilhaLista <char> pilha = new PilhaLista <char>(); // para empilhar os operadores
expPosfixa = ""; // expressão pósfixa com letras
for (int posExp = 0; posExp < expLetras.Length; posExp++)
{
char c = Convert.ToChar(expLetras.Substring(posExp, 1)); // caracter lido
if (!IsOperador(c)) // se não é operador, ou seja, é letra (valor)
{
expPosfixa += c; // adiciona na expressão
}
else
{
if (pilha.EstaVazia() && c != ')')
{
pilha.Empilhar(c); // empilha o operador
}
else
{
if (c == ')') // se achamos um ")", existem operações prioritárias
{
while (pilha.OTopo() != '(') // enquanto não acharmos o correspondente
{
expPosfixa += pilha.Desempilhar(); // desempilha os operadores priorizados
}
pilha.Desempilhar(); // desempilha o próprio "("
}
else
{
while (Precedencia(pilha.OTopo(), c) && pilha.OTopo() != '(')
{
expPosfixa += pilha.Desempilhar(); // o topo tem precedência, então devem vir primeiro (desempilhando)
if (pilha.EstaVazia())
{
break;
}
}
pilha.Empilhar(c); // empilha o novo caracter lido
}
}
}
}
while (!pilha.EstaVazia()) // acabou a expressão, então se sobrou operadores
{
expPosfixa += pilha.Desempilhar(); // desempilhamos, já que está na ordem certa
}
}
private string paraPosfixa(string infixa)
{
string ret = "";
char[] exp = infixa.ToCharArray();
string ops = "()^*/+-";
PilhaLista <char> seq = new PilhaLista <char>();
foreach (char c in exp)
{
if (ops.Contains(c))
{
if (seq.EstaVazia())
{
seq.Empilhar(c);
}
else
{
if (MaiorPrecedencia(seq.OTopo(), c) == seq.OTopo())
{
if (c == ')')
{
while (!seq.EstaVazia() && seq.OTopo() != '(')
{
ret += seq.Desempilhar();
}
}
else
{
ret += seq.Desempilhar();
seq.Empilhar(c);
}
}
else
{
seq.Empilhar(c);
}
}
}
else
{
ret += c;
}
}
return(ret);
}
public PilhaLista <Dado> Inverter()
{
PilhaLista <Dado> aux = this;
PilhaLista <Dado> outra = new PilhaLista <Dado>();
while (!aux.EstaVazia())
{
outra.Empilhar(aux.Desempilhar());
}
return(outra);
}
public PilhaLista <Dado> Copia()
{
PilhaLista <Dado> s1 = new PilhaLista <Dado>();
PilhaLista <Dado> s2 = new PilhaLista <Dado>();
while (!this.EstaVazia())
{
s1.Empilhar(this.Desempilhar());
}
while (!s1.EstaVazia())
{
var obj = s1.Desempilhar();
this.Empilhar(obj);
s2.Empilhar(obj.Copia());
}
return(s2);
}
public PilhaLista <Dado> Clone()
{
PilhaLista <Dado> aux = new PilhaLista <Dado>();
while (!this.EstaVazia())
{
aux.Empilhar(this.Desempilhar());
}
PilhaLista <Dado> copia = new PilhaLista <Dado>();
while (!aux.EstaVazia())
{
Dado d = aux.Desempilhar();
this.Empilhar(d);
copia.Empilhar(d);
}
return(copia);
}
private void btnIgual_Click(object sender, EventArgs e)
{
FilaLista <string> infixa = new FilaLista <string>();
FilaLista <string> posfixa = new FilaLista <string>();
PilhaLista <string> ops = new PilhaLista <string>(); //declara e instancia as 3 listas
string expressao = txtVisor.Text; //expressão a ser calculada
for (int i = 0; i < expressao.Length; i++) //for até o fim da expressão
{
string elemento = "";
if (!IsOp(expressao[i].ToString())) //se não for uma operção
{
elemento = "";
int inicial = i;
while (inicial + elemento.Length < expressao.Length && (!IsOp(expressao[inicial + elemento.Length].ToString()) || expressao[inicial + elemento.Length] == '.')) //enquanto não acabou a expressão, não for operação ou não for ponto
{
elemento += expressao[inicial + elemento.Length]; //incrementa o elemento com o valor da posição específic da expressão
}
i = inicial + elemento.Length - 1;
posfixa.Enfileirar(elemento); //enfileira na posfixa o elemento
}
else //se for operação
{
elemento = expressao[i] + "";
while (!ops.EstaVazia() && TemPrecedencia(ops.OTopo()[0], elemento[0])) //enquanto não estiver vazia e tiver precedência
{
char op = ops.OTopo()[0];
if (op == '(')
{
break;
}
else //se não for abre parenteses
{
posfixa.Enfileirar(op + ""); //enfileira
ops.Desempilhar(); //desempilha
}
}
if (elemento != ")") //se não for fecha parenteses
{
ops.Empilhar(elemento); //empilha
}
else //se for
{
ops.Desempilhar(); //desempilha
}
}
if (elemento != "(" && elemento != ")") //se não for parenteses
{
infixa.Enfileirar(elemento); //enfileira o elemento
}
}
while (!ops.EstaVazia()) //enquanto não estiver vazia
{
string op = ops.Desempilhar(); //pega o primeiro da pilha
if (op != "(" && op != ")") //se não for parenteses
{
posfixa.Enfileirar(op); //enfileira
}
}
escreverSeq(infixa, posfixa); //escreve na tela as sequências
txtResultado.Text = CalcularResultado(posfixa).ToString(); //calcula e escreve o resultado
}
static void Main(string[] args)
{
const int maxCidade = 11;
const int cidadeFinal = 3;
const int cidadeInicial = 6;
PilhaLista <Movimento> pilha = new PilhaLista <Movimento>();
List <int> todosAndados = new List <int>();
bool[] passouCidade = { false, false, false, false, false, false, false, false, false, false, false };
int saidaAtual = 0;
while (!(cidadeAtual == cidadeInicial && saidaAtual == maxCidade))
{
if (saidaAtual < maxCidade && cidadeAtual != cidadeFinal)
{
while (saidaAtual < maxCidade)
{
if (passouCidade[saidaAtual] == false && cidades[cidadeAtual, saidaAtual] > -1)
{
break;
}
saidaAtual++;
}
if (saidaAtual != maxCidade)
{
passouCidade[cidadeAtual] = true;
pilha.Empilhar(new Movimento(cidadeAtual, saidaAtual, cidades[cidadeAtual, saidaAtual]));
cidadeAtual = saidaAtual;
saidaAtual = 0;
}
}
else
{
if (cidadeAtual == cidadeFinal)
{
PilhaLista <Movimento> inver = new PilhaLista <Movimento>();
inver.Empilhar(new Movimento(cidadeAtual, saidaAtual, 0));
while (!pilha.EstaVazia())
{
inver.Empilhar(pilha.Desempilhar());
}
int totalAndado = 0;
Write("Caminho encontrado: ");
while (!inver.EstaVazia())
{
Movimento mov = inver.Desempilhar();
totalAndado += mov.Valor;
Write(mov + "; ");
pilha.Empilhar(mov);
}
Write("Total andado: " + totalAndado);
WriteLine();
todosAndados.Add(totalAndado);
pilha.Desempilhar();
}
passouCidade[cidadeAtual] = false;
Movimento m = pilha.Desempilhar();
cidadeAtual = m.Cidade;
saidaAtual = m.Saida + 1;
}
}
int menor = 0;
int maior = 0;
for (int i = 0; i < todosAndados.Count; i++)
{
if (todosAndados[i] < todosAndados[menor])
{
menor = i;
}
if (todosAndados[i] > todosAndados[maior])
{
maior = 1;
}
}
WriteLine("Menor caminho: " + (menor + 1));
WriteLine("Maior caminho: " + (maior + 1));
ReadLine();
}
private void btnIgual_Click(object sender, EventArgs e)
{
FilaLista <string> infixa = new FilaLista <string>();
FilaLista <string> posfixa = new FilaLista <string>();
PilhaLista <string> ops = new PilhaLista <string>();
string expressao = txtVisor.Text;
for (int i = 0; i < expressao.Length; i++)
{
string elemento = "";
if (!IsOp(expressao[i].ToString()))
{
elemento = "";
int inicial = i;
while (inicial + elemento.Length < expressao.Length && (!IsOp(expressao[inicial + elemento.Length].ToString()) || expressao[inicial + elemento.Length] == '.'))
{
elemento += expressao[inicial + elemento.Length];
}
i = inicial + elemento.Length - 1;
posfixa.Enfileirar(elemento);
}
else
{
elemento = expressao[i] + "";
while (!ops.EstaVazia() && TemPrecedencia(ops.OTopo()[0], elemento[0]))
{
char op = ops.OTopo()[0];
if (op == '(')
{
break;
}
else
{
posfixa.Enfileirar(op + "");
ops.Desempilhar();
}
}
if (elemento != ")")
{
ops.Empilhar(elemento);
}
else
{
ops.Desempilhar();
}
}
if (elemento != "(" && elemento != ")")
{
infixa.Enfileirar(elemento);
}
}
while (!ops.EstaVazia())
{
string op = ops.Desempilhar();
if (op != "(" && op != ")")
{
posfixa.Enfileirar(op);
}
}
escreverSeq(infixa, posfixa);
txtResultado.Text = CalcularResultado(posfixa).ToString();
}
void Processar()
{
lsbBalanceado.Items.Clear();
lsbOriginal.Items.Clear();
bool houveErro = false;
int numeroDoBloco = 0;
var pilha = new PilhaLista <Palavra>();
var arquivo = new StreamReader(dlgAbrir.FileName);
while (!arquivo.EndOfStream && !houveErro)
{
string linha = arquivo.ReadLine();
string linhaDeSaida = "";
int posicaoNaLinha = 0;
while (posicaoNaLinha < linha.Length && !houveErro)
{
string palavraLida = "";
char caracter = linha[posicaoNaLinha];
if (EhLetra(caracter)) // começou palavra, percorremos até terminar a palavra
{
int ondeComecouAPalavra = posicaoNaLinha;
while (posicaoNaLinha < linha.Length && EhLetra(linha[posicaoNaLinha]))
{
posicaoNaLinha++;
}
int quantosCaracteresTemAPalavra = posicaoNaLinha - ondeComecouAPalavra;
palavraLida = linha.Substring(ondeComecouAPalavra, quantosCaracteresTemAPalavra);
string palavraEmMaiusculo = palavraLida.ToUpper();
if (palavraEmMaiusculo.Equals("BEGIN") || // palavra abre bloco de comando?
palavraEmMaiusculo.Equals("CASE") ||
palavraEmMaiusculo.Equals("REPEAT"))
{
numeroDoBloco++;
pilha.Empilhar(new Palavra(palavraLida, numeroDoBloco));
linhaDeSaida += palavraLida + " {" + numeroDoBloco + "} ";
}
else // poderá ser palavra que encerra bloco de comandos
if (palavraEmMaiusculo.Equals("END") || // palavra abre bloco de comando?
palavraEmMaiusculo.Equals("UNTIL"))
{
var palavraDesempilhada = pilha.Desempilhar();
if (palavraEmMaiusculo.Equals("END"))
{
if (palavraDesempilhada.palavra.ToUpper().Equals("BEGIN") || // está correto
palavraDesempilhada.palavra.ToUpper().Equals("CASE")
)
{
linhaDeSaida += palavraLida + " {" + palavraDesempilhada.numero + "} ";
}
else
{
houveErro = true;
linhaDeSaida += "END sem o Begin ou Case correspondente.";
}
}
else
if (palavraEmMaiusculo.Equals("UNTIL"))
{
if (palavraDesempilhada.palavra.ToUpper().Equals("REPEAT")) // está correto
{
linhaDeSaida += palavraLida + " {" + palavraDesempilhada.numero + "} ";
}
else
{
houveErro = true;
linhaDeSaida += "UNTIL sem o Repeat correspondente.";
}
}
}
else
{
linhaDeSaida += palavraLida;
}
}
else
{
linhaDeSaida += caracter.ToString();
posicaoNaLinha++;
}
} // while
lsbOriginal.Items.Add(linha);
lsbBalanceado.Items.Add(linhaDeSaida);
}
if (houveErro)
{
lsbBalanceado.Items.Add("Desbalanceado!");
}
if (!pilha.EstaVazia())
{
lsbBalanceado.Items.Add("Há begin, Case ou Repeat a mais.");
}
arquivo.Close();
}
public List <List <CaminhoEntreCidades> > Calcular(int origem, int destino)
{
PilhaLista <CaminhoEntreCidades> pilha = new PilhaLista <CaminhoEntreCidades>(); //Serivirá para fazer o Backtracking
List <List <CaminhoEntreCidades> > ret = new List <List <CaminhoEntreCidades> >(); //Armazenará todos os caminhos que encontramos
bool[] passouCidade = new bool[qtdCidades]; //Armazenaremos por quais cidades passamos
int cidadeAtual = origem;
int saidaAtual = 0; //Indica qual cidade tentaremos seguir
while (!(cidadeAtual == origem && saidaAtual == qtdCidades)) //Enquanto não tentamos todas as possibilidades da cidade inicial
{
if (saidaAtual < qtdCidades && cidadeAtual != destino) //Apenas continuaremos andando caso ainda hajam cidades a tentar e a
//cidade que estamos não é o destino
{
for (; saidaAtual < qtdCidades; saidaAtual++) //Tentaremos nos mover para todas as cidades
{
if (passouCidade[saidaAtual] == false && cidades[saidaAtual, cidadeAtual] != null)
{
break; //Caso não passamos pela cidade sendo testada e caso exista uma conecção entre as cidades,
}
}
//podemos sair do for
if (saidaAtual != qtdCidades) //Verificaremos se já tentamos todas as cidades, ou seja, se achamos algum caminho possível
{
//Se achamos algum caminho
passouCidade[cidadeAtual] = true; //Marcaremos que passados pela determinada cidade
pilha.Empilhar(cidades[saidaAtual, cidadeAtual]); //Guardaremos o movimento que fizemos
cidadeAtual = saidaAtual; //Avançaremos a cidade
saidaAtual = 0; //Prepararemos a variável para o próximo ciclo
}
}
else
{
if (cidadeAtual == destino) //Caso achamos o destino
{
/*
* Iremos guardar o caminho feito até então, para isso, devemos esvaziar a pilha.
* Porém, existe a chance de ainda precisarmos usar a pilha nesse método, ou seja,
* a pilha deve continuar igual após lermos seus dados.
* Por conta disso, devemos colocar os dados da pilha atual numa auxiliar (1), vamos trabalhar
* com os dados (2) quando os repassarmos para a pilha atual (3).
* Por fim, forçaremos um backtracking, fazendo com que o algoritmo tente descobrir um novo caminho
*/
PilhaLista <CaminhoEntreCidades> inver = new PilhaLista <CaminhoEntreCidades>();
List <CaminhoEntreCidades> nova = new List <CaminhoEntreCidades>();
while (!pilha.EstaVazia()) //(1)
{
inver.Empilhar(pilha.Desempilhar());
}
while (!inver.EstaVazia()) //(3)
{
CaminhoEntreCidades cid = inver.Desempilhar();
pilha.Empilhar(cid);
nova.Add(cid); //(2)
}
ret.Add(nova); //Guardaremos o caminho descoberto
}
//Fazendo Backtracking
passouCidade[cidadeAtual] = false; //Desmarcaremos que passamos pela cidade
CaminhoEntreCidades c = pilha.Desempilhar(); //Recuperaremos o último movimento que fizemos
cidadeAtual = c.Origem; //Voltaremos a cidade
saidaAtual = c.Destino + 1; //Evitaremos a possibilidade de acessarmos o mesmo caminho anterior
}
}
return(ret);
}
