===============================================

Algoritmos de Busca Heur stica (PARTE 2) Busca Heur stica em GrafosOU Prof. Alexandre Direne DInf-UFPR

===============================================

Recomendao de Bibliograa: ca
Articial Intelligence: A Modern Approach. Stuart Russell e Peter Novig. Second Edition, Prentice Hall, 2003. Programming in Prolog. William F. Clocksin and C. S. Mellish. Springer-Verlag, 1987. Inteligncia Articial: Ferramentas e Teorias. Guilherme Bittencourt. Terceira Ed., Editora da UFSC, e 2006. Articial Intelligence. Elaine Rich e Kevin Knight. Second Edition, McGraw Hill, 1993. Articial Intelligence. Patrick H. Winston. Second Edition, Addison-Wesley, 1993. Introduction to Articial Intelligence. Eugene Charniak e Drew McDermott. Addison-Wesley, 1989. Inteligncia Articial - um curso prtico. G. Arariia. Editora LTC - Livros Tcnicos e Cient e a o e cos, 1989 (do qual a maior parte deste arquivo foi composto ***).

Recomendao de Pginas Web: ca a

http://www.cs.dartmouth.edu/~brd/Teaching/AI/Lectures/Summaries/search.html http://www.decom.ufop.br/prof/guarda/CIC250/index.htm http://aima.cs.berkeley.edu/ http://aima.cs.berkeley.edu/newchap05.pdf

Recomendao de Software: ca
Pacote de software para a Programao em Inteligncia Articial (ambiente Poplog): ca e http://www.cs.bham.ac.uk/research/poplog/freepoplog.html Pacote de software para a Programao em Prolog (SWIProlog): ca http://www.swi-prolog.org

Busca Heur stica em GrafosOU

co Os principais algoritmos de busca desta parte so as variaes da busca em GrafosOU. Tais variaes a co se baseiam em uma srie de formalismos que podem ser denidos como abordagens mais espec e cas de busca sobre o conceito de rvores de estados como espaos de soluo de problemas. Estes formalismos esto a c ca a apresentados nas sees seguintes, logo antes das descries das variaes dos algoritmos propriamente ditos. co co co

1
1.1

Mtodos de Busca Cega ou Fora Bruta e c

Busca em Amplitude

Considere a vore de busca genericamente apresentada na Figura 1. Observe o seguinte: a a a O estado inicial da rvore est representado pelo nodo b e o estado nal pelo nodo n. O percurso da rvore se inicia com a investigao dos nodos c d e, os quais esto distantes da raiz a ca a apenas um ramo de altura. Passa-se ento para a investigao dos nodos g h i j k, distantes dois ramos de altura da raiz. a ca Finalmente, investiga-se os nodos n m. a Para isso, o processo de busca em largura deve contar com uma F ila, a qual contm trajetrias ` espera e o ca a de sua expanso, de sua eliminao ou mesmo para anunciar a suspenso do processo de busca como a um todo. Cada trajetria pode ser representada por uma lista de estruturas de dados (da linguagem Prolog), o sendo que cada estrutura de dado tem o formato r(R, N), onde R o ramo (ou transformao atmica) e ca o que liga o nodo N ao pai dele. Por exemplo, na Figura 1, a trajetria que sai de b, passa por c e chega em h representada por: o e [ r(5,h), r(1,c), r(raiz,b) ] Note que, como a raiz no tem pai, a estrutura de dado r(raiz, b) que a simboliza tem a palavra raiz a no lugar do argumento reservado ao ramo. Depois do primeiro ciclo do processo de busca em amplitude, a F ila possui o seguinte valor: Fila = [ [ r(1,c), r(raiz,b) ], [ r(2,d), r(raiz,b) ], [ r(3,e), r(raiz,b) ] ] Neste ponto, o processo tem continuidade por meio da vericao da existncia do estado nal (ou ca e estado meta) na trajetria que est na frete da F ila. o a Como ela no inclui o estado nal, o processo cria uma lista contendo todas as poss a veis maneiras de expandir a trajetria da frente de F ila para conter os lhos de c. o Essa lista chamada de lista de extenses e contm o seguinte valor no momento: e o e ListaExtensoes = [ [ r(4,g), r(1,c), r(raiz,b) ], [ r(5,h), r(1,c), r(raiz,b) ], [ r(6,i), r(1,c), r(raiz,b) ] ] 2

Figura 1: Exemplo de rvore com ordem de busca em aplitude a As trajetrias da lista de extenses levam a dois ramos de altura em distncia da raiz, fazendo com que o o a sejam investigados apenas depois das que esto na F ila. a Isto signica que a lista de extenses deve ser concatenada atrs de todas as trajetrias que esto na o a o a F ila, a qual car assim: a FilaEstendida = [ [ [ [ [ [ r(2,d), r(3,e), r(4,g), r(5,h), r(6,i), r(raiz,b) ], r(raiz,b) ], r(1,c), r(raiz,b) ], r(1,c), r(raiz,b) ], r(1,c), r(raiz,b) ] ]

Note que a trajetria [r(1, c), r(raiz, b)] foi retirada da F ila porque j se veriou que ela no possui o o a a estado nal. A prxima trajetria a ser investigada [r(2, d), r(raiz, b)], a qual tambm no possui o estado nal, o o e e a sendo igualmente retirada da F ila. Neste caso, nenhuma lista de extenses criada pois o nodo d no tem lhos. o e a A F ila se torna ento: a Fila= [ [ [ [ [ r(3,e), r(4,g), r(5,h), r(6,i), r(raiz,b) ], r(1,c), r(raiz,b) ], r(1,c), r(raiz,b) ], r(1,c), r(raiz,b) ] ]

A prxima trajetria a ser investigada [r(3, e), r(raiz, b)], a qual tambm no possui o estado nal, o o e e a sendo igualmente retirada da F ila. Neste ponto, monta-se a lista de extenses, a qual colocada no m da F ila. Seu valor agora o o e e seguinte:

Figura 2: Um estado inicial para o problema de movimentao das chas ca FilaEstendida = [ [ [ [ [ [ r(4,g), r(5,h), r(6,i), r(7,j), r(8,k), r(1,c), r(1,c), r(1,c), r(3,e), r(3,e), r(raiz,b) r(raiz,b) r(raiz,b) r(raiz,b) r(raiz,b) ], ], ], ], ] ]

A trajetria [r(4, g), r(1, c), r(raiz, b)] no possui o estado nal e retirada da F ila, fazendo o processo o a e seguir de maneira semelhante. Depois de vrios ciclos, nalmente, temos a F ila no seguinte estado: a Fila = [ [ r(9, n), r(5,h), r(1,c), r(raiz,b) ], [ r(10,m), r(5,h), r(1,c), r(raiz,b) ] ] Agora a primeira trajetria da F ila possui o estado nal n e, desta forma, pode ser considerada como o a soluo do problema de busca. ca A resposta que dever ser impressa pela mquina algo como: a a e

b c h n
Em resumo, o algoritmo de busca em amplitude pode ser resumidamente descrito assim: retira-se a trajetria que est na cabea da F ila; o a c se a trajetria da cabea no inclui o estado nal, uma lista (possivelmente vazia) composta com as o c a e trajetrias expandidas (sem repetio de estados) a partir da trajetria da cabea da F ila (a qual o ca o c e totalmente descartada em seguida); a lista de trajetrias expandidas ento concatenada no nal da F ila; o e a se a trajetria da cabea inclui o estado nal, o conte do da trajetria impresso e o algoritmo pra. o c u o e a Para ilustrar a implementao do algoritmo de busca em amplitude, ser considerado o problema de como ca a posicionar duas chas pretas entre duas chas brancas. Para especicar melhor tal problema, tome como objeto de apoio uma bandeja que possui cinco lacunas de encaixe. Em seu estado inicial, as quatro chas podem ocupar qualquer posio relativa das lacunas, cando sempre uma lacuna vazia. A Figura 2 mostra ca uma das poss veis conguraes de Estados Iniciais para o problema referido. co veis so as seguintes: a As duas operaes atmicas poss co o fazer com que uma cha deslize para a lacuna vazia, se a lacuna vazia estiver imediatamente ao lado (esquerdo ou direito) da cha; fazer com que uma cha salte para a lacuna vazia, se o salto ocorrer por cima de uma unica cha. 4

Figura 3: Fragmento da rvore de busca para o problema de movimentao das chas a ca Por enquanto, para simplicar a apresentao dos conceitos de implementao, importante notar que ca ca e os custos de ambas as operao atmicas so os mesmos. ca o a A Figura 3 mostra um fragmento da rvore de busca para o problema de movimentao das chas o qual a ca inclui a ocorrncia em altura m e nima de um dos poss veis Estados Finais. O programa em Prolog que segue capaz de realizar a busca em amplitude. Um dos poss e veis Estados Iniciais est listado (como comentrio) no nal do cdigo e coincide com o Estado Inicial da Figura 2. a a o

% ------------------------------------------------------------% PREDICADOS UTILITARIOS PARA A BUSCA (PROBLEMA DAS FICHAS) % ------------------------------------------------------------concatenadas([], L, L) :!. concatenadas([X|C1], L2, [X|C3]) :concatenadas(C1, L2, C3). pertence_a(X, [X|_]) :!. 5

pertence_a(X, [_|C]) :pertence_a(X, C). trajetoria_impressa([ r(raiz,Raiz) ]) :write(Estado Inicial: ), write(Raiz), write(. \n), !. trajetoria_impressa([ r(Operacao,Nodo) | Resto ]) :trajetoria_impressa(Resto), write(Operacao), write( para obter o estado: ), write(Nodo), write(. \n). transformado([v, transformado([A, transformado([A, transformado([A, transformado([A, transformado([A, transformado([A, transformado([A, transformado([v, transformado([A, transformado([A, transformado([A, transformado([A, transformado([A, A, v, v, B, B, B, B, B, A, v, B, B, B, B, B, B, B, v, v, C, C, C, B, B, v, v, C, C, C, C, C, C, C, v, v, D, C, C, C, C, v, D, D], D], D], D], D], D], D], v], D], D], D], D], D], v], *, *, *, v, o, operacao(deslisa), [A, v, B, C, D]). operacao(deslisa), [v, A, B, C, D]). operacao(deslisa), [A, B, v, C, D]). operacao(deslisa), [A, v, B, C, D]). operacao(deslisa), [A, B, C, v, D]). operacao(deslisa), [A, B, v, C, D]). operacao(deslisa), [A, B, C, D, v]). operacao(deslisa), [A, B, C, v, D]). operacao(salta), [B, A, v, C, D]). operacao(salta), [A, C, B, v, D]). operacao(salta), [v, B, A, C, D]). operacao(salta), [A, B, D, C, v]). operacao(salta), [A, v, C, B, D]). operacao(salta), [A, B, v, D, C]).

e_estado_final([v, e_estado_final([o, e_estado_final([o, e_estado_final([o, e_estado_final([o,

o, v, *, *, *,

*, *, v, *, *,

o]). o]). o]). o]). v]).

trajetoria_expandida([r(Ramo,Nodo) | Resto], [r(Op,Filho), r(Ramo,Nodo) | Resto]) :transformado(Nodo, operacao(Op), Filho), not(produz_ciclo(Filho, [r(Ramo,Nodo) | Resto])). produz_ciclo(Estado, Trajetoria) :pertence_a(r(_,Estado), Trajetoria). adjacentes(Trajetoria, Adjacentes) :findall(Ti, trajetoria_expandida(Trajetoria, Ti), Adjacentes), !. adjacentes( _ , [] ). possui_estado_final([ r(_,Nodo) | _ ]) :e_estado_final(Nodo).

% ------------------------------------------------------------% BUSCA EM AMPLITUDE % ------------------------------------------------------------solucao_computada_em_amplitude([ Solucao | _ ], Solucao) :possui_estado_final(Solucao), !. solucao_computada_em_amplitude([ Trajetoria | Fila ], Solucao) :adjacentes(Trajetoria, Lista_de_Trajetorias_Expandidas), concatenadas(Fila, Lista_de_Trajetorias_Expandidas, Fila_Expandida), solucao_computada_em_amplitude(Fila_Expandida, Solucao). % *** Exemplo de Estado Inicial: [o, o, v, *, *] solucao_da_busca_em_amplitude_a_partir_do(Estado_Inicial) :solucao_computada_em_amplitude([ [ r(raiz,Estado_Inicial) ] ], Trajetoria), trajetoria_impressa(Trajetoria).

Para ilustrar a aplicao do predicado solucao_da_busca_em_amplitude_a_partir_do basta compilar ca seu cdigo e executar a seguinte consulta: o ?- solucao_da_busca_em_amplitude_a_partir_do([o, o, v, *, *]). Estado Inicial: [o, o, v, *, *]. deslisa para obter o estado: [o, v, o, *, *]. salta para obter o estado: [o, *, o, v, *]. deslisa para obter o estado: [o, *, v, o, *]. salta para obter o estado: [o, *, *, o, v]. yes

1.2

Busca em Profundidade

Na busca em profundidade, as trajetrias recm produzidas so inclu o e a das em uma P ilha e no em uma la. a Na vore de busca genericamente apresentada na Figura 1, o Estado Final n pode ser encontrado efetuando-se a a busca em profundidade. Suponha que as seguintes trajetrias estejam na P ilha para serem examinadas ao o nal do primeiro ciclo de busca: Pilha = [ [ r(1,c), r(raiz,b) ], [ r(2,d), r(raiz,b) ], [ r(3,e), r(raiz,b) ] ] Retirando-se a trajetria do topo da P ilha, verica-se que ela no inclui o Estado Final. Empilha-se o a ento as trajetrias extandidas com os lhos do nodo c, as quais deixam a P ilha no seguinte estado: a o NovaPilha = [ [ [ [ [ [ r(4,g), r(5,h), r(6,i), r(2,d), r(3,e), r(1,c), r(raiz,b) ], r(1,c), r(raiz,b) ], r(1,c), r(raiz,b) ], r(raiz,b) ], r(raiz,b) ] ]

Como a trajetria do topo de P ilha no inclui o Estado Final e no pode ser expandida, a P ilha ca no o a a seguinte estado: Pilha = [ [ [ [ [ r(5,h), r(6,i), r(2,d), r(3,e), r(1,c), r(raiz,b) ], r(1,c), r(raiz,b) ], r(raiz,b) ], r(raiz,b) ] ]

Agora, apesar da trajetria do topo de P ilha no incluir o Estado Final, uma de suas formas expandidas o a possui. No nal do processo de busca, a P ilha est assim: a Pilha = [ [ [ [ [ [ r(9,n), r(5,h), r(1,c), r(raiz,b) ], r(10,m), r(5,h), r(1,c), r(raiz,b) ], r(6,i), r(1,c), r(raiz,b) ], r(2,d), r(raiz,b) ], r(3,e), r(raiz,b) ] ]

Uma das variaes de implementao de programa em Prolog que capaz de realizar a busca em proco ca e fundidade mais completa, adotando a eliminao de trajetrias que possuem estados repetidos, est listado ca o a a abaixo. Note que os predicados utilitrios so exatamente os mesmos denidos no programa que implementa a a buca em amplitude (por isso no foram repetidos aqui). a

% ------------------------------------------------------------% BUSCA EM PROFUNDIDADE (COM PILHA EXPLICITA DE TRAJETORIAS) % ------------------------------------------------------------solucao_computada_em_profundidade([ Solucao | _ ], Solucao) :possui_estado_final(Solucao), !. solucao_computada_em_profundidade([ Trajetoria | Pilha ], Solucao) :adjacentes(Trajetoria, Lista_de_Trajetorias_Expandidas), concatenadas(Lista_de_Trajetorias_Expandidas, Pilha, Pilha_Expandida), solucao_computada_em_profundidade(Pilha_Expandida, Solucao). % *** Exemplo de Estado Inicial: [o, o, v, *, *] solucao_da_busca_em_profundidade_a_partir_do(Estado_Inicial) :solucao_computada_em_profundidade([ [ r(raiz,Estado_Inicial) ] ], Trajetoria), trajetoria_impressa(Trajetoria).

Para ilustrar a aplicao do predicado solucao_da_busca_em_profundidade_a_partir_do basta comca pilar seu cdigo e executar a seguinte consulta: o ?- solucao_da_busca_em_profundidade_a_partir_do([o, o, v, *, *]). Estado Inicial: [o, o, v, *, *]. deslisa para obter o estado: [o, v, o, *, *]. salta para obter o estado: [o, *, o, v, *]. deslisa para obter o estado: [o, *, v, o, *]. deslisa para obter o estado: [o, v, *, o, *]. deslisa para obter o estado: [v, o, *, o, *]. 8

salta para obter o deslisa para obter salta para obter o deslisa para obter salta para obter o deslisa para obter deslisa para obter salta para obter o yes

estado: [*, o, v, o, *]. o estado: [*, v, o, o, *]. estado: [*, o, o, v, *]. o estado: [*, o, o, *, v]. estado: [*, o, v, *, o]. o estado: [*, v, o, *, o]. o estado: [v, *, o, *, o]. estado: [o, *, v, *, o].

Note os seguites pontos: a soluo do mesmo problema bem mais longa do que a encontrada pela busca em amplitude; ca e isso ocorre pois as trajetrias recm-expandidas so sempre mais longas (possuem um ramo a mais) o e a e so elas as inseridas no topo da P ilha para serem investigadas primeiro do que as mais curtas. Na a prtica, este procedimento leva, em geral, o algoritmo a encontrar solues mais longas; a co tal desvantagem compensada pelo fato de pilhas serem mais ecientemente implementadas em e computadores do que las, tanto por gastarem menos tempo de manipulao de sua estrutura de ca dado quanto por economizarem memria (apesar do programa anterior no economizar memria como o a o deveria); isso signica que a linguagem Prolog pode ser utilizada de forma mais adequada ainda para a implementao da busca em profundidade do que mostrou o programa acima (economizando memria ao ca o ponto de alocar apenas o espao de uma trajetria). c o Uma segunda maneira de implementao da busca em profundidade est listada no programa em Prolog ca a que segue. Note que ele no manipula explicitamente nenhuma P ilha. a % ---------------------------------------------------------------% BUSCA EM PROFUNDIDADE (SEM A PILHA DE TRAJETORIAS) % ---------------------------------------------------------------solucao_computada_em_profundidade(Solucao, Solucao) :possui_estado_final(Solucao), !. solucao_computada_em_profundidade(Trajetoria, Solucao) :trajetoria_expandida(Trajetoria, T2), solucao_computada_em_profundidade(T2, Solucao). % *** Exemplo de Estado Inicial: [o, o, v, *, *] solucao_da_busca_em_profundidade_sem_pilha_a_partir_do(Estado_Inicial) :solucao_computada_em_profundidade([ r(raiz,Estado_Inicial) ], Trajetoria), trajetoria_impressa(Trajetoria). Observe duas coisas importantes: o primeiro termo do predicado solucao_computada_em_profundidade agora apenas uma trajetria e o e no mais uma P ilha; a 9

 a segunda clusula do predicado solucao_computada_em_profundidade permite a retroao (backtracking) a ca intra-clusula. a Uma terceira variao de implementao da busca em profundidade ainda pode ser atingida por meio do ca ca uso expl cito do predicado f ail. Ele ir forar a produo de todos os estados diretamente ating a c ca veis a partir do estado atual (ou estado corrente).

Mtodos de Busca Heur e stica

nio do problema para Os mtodos de busca heur e stica fazem uso de conhecimento espec co sobre o dom guiar o processo de busca. Muitos dos referidos mtodos procuram atribuir uma nota a cada nodo da rvore de busca para representar e a uma estimativa (ou funo heur ca stica) do custo de transformao do Estado Atual no Estado Final. ca Os conceitos bsicos que so tipicamente necessrios ao entendimento esto apresentados a seguir. a a a a Mtodo de Busca Admiss e vel: Um mtodo de busca admiss se ele sempre encontra a soluo de e e vel ca menor custo (quando h ao menos uma soluo). a ca a Funo Heur ca stica Admiss vel: funo que nunca superestima o que chamamos genericamente de distncia ca conceitual (custo) entre o Estado Atual e o Estado Final. Funo Monotnica do Custo de Caminhos: funo que nunca decresce (pode ser estvel) em seu valor ca o ca a de custo real acumulado (custo realizado) para cobrir um caminho exclusivo qualquer entre o Estado Inicial e o Estado Atual (i.e., no h caminho com custo negativo). a a Desigualdade Triangular da Funo de Custo de Caminhos: uma funo de custo real acumulado (custo ca ca realizado) obedece ` desigualdade triangular se o custo do caminho direto entre dois nodos for sempre a menor que a soma dos custos de dois ou mais caminhos indiretos que ligam os mesmos dois nodos. Funo Heur ca stica Mais Informada: h2 uma funo mais informada do que h1 se ambas forem ade ca miss veis e ainda ocorrer que

E ConjuntoEstadosF inais(h2(E) h1(E)) /

2.1 Algoritmo A
O Algoritmo A adota como base de orientao da busca a estimativa de transformao do Estado Inicial ca ca (Ei ) at o no Estado Final (Ef ), passando pelo Estado Atual (Ea ). Tal estimativa pode ser expressa pela e seguinte frmula: o

f (Ea ) = g(Ea) + h(Ea)

Nesta frmula, temos os seguintes detalhes: o ca a funo g(Ea ) expressa o custo (j conhecido) de transformao do Ei em Ea ; ca a a funo h(Ea ) sintetiza a estimativa do custo (desconhecido) de transformao do Ea em Ef . ca ca O processo de busca executado por meio do algoritmo A reorganiza, a cada ciclo, as trajetrias da o Lista de Prioridades de modo que aquelas com menor f (Ea ) venham para a frente e sejam investigadas primeiro. Um exemplo concreto de aplicao do A se destina a encontrar um caminho que leva, por exemplo, da ca cidade b ` cidade s no mapa da Figura 4. Sobre o mapa, pode-se dizer que: a 10

9 8

q
7

b
6

a
4 3

d n s c g h

2 1

10

11

12

13

14

Figura 4: Mapa com ligaes entre cidades e suas distncias euclidianas co a as cidades so localizadas pelas coordenadas X e Y ; a o custo necessrio para se realizar o percurso entre duas cidades que possuem ligao direta uma a ca com a outra e que esto localizadas respectivamente nas coordenadas (X1 , Y1 ) e (X2 , Y2) a distncia a e a Euclidiana:

(X1 X2)2 + (Y1 Y2)2

Suponha que a investigao da mquina entre b e s atinja a cidade d. Pode-se dizer ento que: ca a a o custo g(d) para se chegar a ela a soma dos custos para viajar pelas cidade que ligam b a d, ou seja, e a distncia Euclidiana de b at c somada com a de c at d; a e e a estimativa de custo h(d) para viajar da cidade d ` cidade s tambm asumida como a distncia a e e a Euclidiana (em linha reta) entre elas (mesmo que no haja ligao direta). a ca O programa em Prolog abaixo realiza a busca A pela trajetria m o nima entre duas cidades. Algumas de suas caracter sticas so: a o primeiro argumento da estrutura de dado t( , , ) fornece f (Ea ); 11

 o segundo argumento da mesma estrutura fornece g(Ea ); o terceiro argumento de t fornece os ramos da trajetria, tal qual t o nhamos adotado na busca cega; a lista de prioridades sempre mantida em ordem crescente das trajetrias com base na chave f (Ea ) e o e, por isso, sero investigadas antes. a

% ------------------------------------------------------------% PREDICADOS UTILITARIOS (PROBLEMA DO CAMINHO ENTRE 2 CIDADES) % ------------------------------------------------------------pertence_a(X, [X|_]) :!. pertence_a(X, [_|C]) :pertence_a(X, C). trajetoria_impressa(t(F,G,T)) :trajetoria_impressa_1(T). trajetoria_impressa_1([ r(raiz,Raiz) ]) :write(Estado Inicial: ), write(Raiz), write(. \n), !. trajetoria_impressa_1([ r(Operacao,Nodo) | Resto ]) :trajetoria_impressa_1(Resto), write(Operacao), write( a cidade: ), write(Nodo), write(. \n). ligada_a(a,b). ligada_a(m,f). ligada_a(q,p). ligada_a(p,s). ligada_a(c,d). ligada_a(d,n). ligada_a(n,h). ligada_a(h,g). ligada_a(b,m). ligada_a(f,q). ligada_a(p,n). ligada_a(b,c). ligada_a(d,q). ligada_a(d,g). ligada_a(n,s).

coord(a, 2, 4) :coord(c, 4, 2) :coord(f, 7, 8) :coord(h, 10, 1) :coord(n, 11, 3) :coord(q, 11, 7) :-

!. !. !. !. !. !.

coord(b, 5, 6) :coord(d, 7, 4) :coord(g, 8, 2) :coord(m, 9, 6) :coord(p, 12, 6) :coord(s, 13, 2).

!. !. !. !. !.

inserida(T, [], [T]). inserida(t(F1,G1,Ramos1), [ t(F2,G2,Ramos2) | Resto ], [ t(F1,G1,Ramos1), t(F2,G2,Ramos2) | Resto ]) :12

F1 < F2, !. inserida(t(F1,G1,Ramos1), [ t(F2,G2,Ramos2) | Resto ], [ t(F2,G2,Ramos2) | Resto2 ]) :inserida(t(F1,G1,Ramos1), Resto, Resto2).

inseridas_as_trajetorias([], Fila, Fila). inseridas_as_trajetorias([T|C], Fila, Fila3) :inserida(T,Fila, Fila2), inseridas_as_trajetorias(C, Fila2, Fila3). trajetoria_expandida(t(F, G, [r(Ramo, Nodo) | Resto]), t(F1, G1, [r(vai_para, Filho), r(Ramo,Nodo) | Resto])) :ligada_a(Nodo, Filho), not(produz_ciclo(Filho, [r(Ramo,Nodo) | Resto])), funcao_h(Filho, H1), custo(Nodo, Filho, Custo), G1 is G + Custo, F1 is G1 + H1. produz_ciclo(Estado, Trajetoria) :pertence_a(r(_,Estado), Trajetoria). custo(Nodo, Filho, Custo) :coord(Nodo, XN, YN), coord(Filho, XF, YF), X is (XN-XF)*(XN-XF) + (YN-YF)*(YN-YF), prolog_eval(sqrt(X),Custo), !. funcao_h(Ea, H) :e_estado_final(Ef), coord(Ef, XEf, YEf), coord(Ea, XEa, YEa), X is (XEa-XEf)*(XEa-XEf) + (YEa-YEf)*(YEa-YEf), prolog_eval(sqrt(X),H), !. adjacentes(X, Y, Z) :findall(X, Y, Z), !. adjacentes(_ , _ , [] ). e_estado_final(s). possui_estado_final(t(_,_,[r(_,Nodo)|_])) :e_estado_final(Nodo). % ------------------------------------------------------------% BUSCA HEURISTICA PELO A* 13

% ------------------------------------------------------------solucao_computada_por_A_estrela([ Solucao | _ ], Solucao) :possui_estado_final(Solucao), !. solucao_computada_por_A_estrela([ Trajetoria | Fila ], Solucao) :adjacentes(T2, trajetoria_expandida(Trajetoria, T2), Lista_de_Trajetorias_Expandidas), inseridas_as_trajetorias(Lista_de_Trajetorias_Expandidas, Fila, Fila_Expandida), solucao_computada_por_A_estrela(Fila_Expandida, Solucao). % *** Exemplo de Estado Inicial: b solucao_da_busca_por_A_estrela_a_partir_do(Estado_Inicial) :funcao_h(Estado_Inicial, H), solucao_computada_por_A_estrela([ t(H,0,[r(raiz,Estado_Inicial)]) ], Trajetoria), trajetoria_impressa(Trajetoria).

Para ilustrar a aplicao do predicado solucao_da_busca_por_A_estrela_a_partir_do basta compilar ca seu cdigo e executar a seguinte consulta: o ?- solucao_da_busca_por_A_estrela_a_partir_do(b). Estado Inicial: b. vai_para a cidade: c. vai_para a cidade: d. vai_para a cidade: n. vai_para a cidade: s. yes Note os seguintes pontos: o algoritmo A um mtodo de busca admiss quando a sua funo heur e e vel ca stica for admiss vel; o algoritmo de busca em P rof undidade no um mtodo admiss a e e vel; importante no confundir encontrar a trajetria mais curta com encontrar mais rapidamente a e a o trajetria (a busca em Amplitude encontra a trajetria mais curta, dadas as condies acima, mas o o co isso no quer dizer que ela a encontre mais rapidamente); a a busca de Custo Uniforme pode ser vista como uma variao do mtodo A quando h(Ea ) = 0, ou seja, ca e se f (Ea ) = g(Ea ), ento o mtodo investigar primeiro os nodos mais prximos do Ei (aproximadamente a e a o como a busca em Amplitude se comporta para os casos em que a funo de custo monotnica e ainda ca e o obedece ` desigualdade triangular); a o algoritmo de busca de Custo Uniforme um mtodo admiss apenas quando a funo de custo real e e vel ca monotonicamente crescente; e nos casos onde a estimativa h(Ea ) bem menor que o custo real, o A tender a gastar bastante memria e a o com a manuteno de sua lista de prioridades. ca

14

2.2

Algoritmo IDA

O nome IDA signica Iterative Deepening A . Para descrever melhor os seus conceitos bsicos, alm de a e conhecer o A , preciso abordar os seguintes elementos: e busca de altura xa; aumento iterativo da altura de busca; c contornos de custo do espao de busca. A busca de altura xa capaz de evitar at mesmo as decincias da busca em profundidade (que em e e e geral acha solues muito longas). Note os aspectos abaixo. co O algoritmo precisa impor um corte na trajetria que atingir a altura mxima sem incluir o Ef para o a dar continuidade ` busca por meio de outra trajetria que ainda possa inclu (Ef ) dentro da mesma a o -lo altura mxima. a Por exemplo, em um mapa com 20 cidades, se houver soluo para um dado problema, a trajetria ter ca o a um tamanho mximo de 19 ramos. a A busca de altura xa completa (dependendo de sua altura mxima) mas no minimalista. e a a e sticas: O aumento iterativo da busca, combinado com a busca de altura xa inclui as seguintes caracter O algoritmo inicia com altura zero (uma questo formal que traz resultados interessantes quando o a limite passar a ser o custo da trajetria e no o seu tamanho). o a Cada ciclo que termina sem incluir o Ef seguido de outro com exatamente 1 (um) ramo a mais no e limite de tamanho da trajetria. o A busca em profundidade de altura xa com aumento iterativo da altura minimalista e completa. e c e O conceito de contorno de custo do espao de busca dado por um valor-limite para custo. Isso resulta na possibilidade de se manter a expanso de trajetrias cujos valores de f esto comprendidos dentro do a o a valor-limite. Note agora os seguintes itens. Cada ciclo do IDA* realizado por meio de uma Busca em Profundidade dentro do contorno de custo, e a a com aumento iterativo do valor-limite de custo (e no da altura mxima). O valor-limite do primeiro contorno de custo f (Ei ). e No havendo soluo dentro do contorno de custo atual, um novo valor-limite ajustado pelo menor a ca e valor de f do ciclo anterior. Vrios contornos de custo podem ser ajustados durante o processo para que um novo ciclo de busca a possa se re-iniciar, sempre a partir do Ei , e tente incluir o Ef . ca Exerc cio: Implemente a soluo para o problema dos Ladrilhos Deslizantes (8 P uzzle) por meio do algoritmo IDA .

15

2.3

Algoritmo SMA

O nome SMA signica Simplied Memory-Bouded A . Para descrever melhor os seus conceitos bsicos, a alm de conhecer o A , preciso abordar os seguintes elementos: e e o busca de tamanho xo de memria (a la de trajetrias sofre controle por meio de um valor de tamanho o mximo que representa a soma dos tamanhos das trajetrias registradas no momento); a o eliminao da pior trajetria para que uma nova trajetria seja inserida; ca o o dominuio da repetio de expanso de estados por meio do registro do custo de uma trajetria ca ca a o eliminada.

2.4

Algoritmo de Busca Gulosa (Greedy - Best-rst)

O de busca pela Melhor Escolha assim conhecido por ser uma variao da busca em profundidade ree ca orientada apenas pelo menor valor da funo heur ca istica h aplicada aos descendentes do Ea (estado atual). Em outras palavras, o algoritmo guiado apenas pela estimativa de menor distncia do Ea ao Ef . Suas e a caracter sticas so: a pode ter bom desempenho se a funo heur ca stica for boa; mas sofre dos mesmos problemas da busca em profundidade (pode seguir caminhos infrut feros, inclusive innitos); e no oferece nem completude nem minimizao da soluo. a ca ca

2.5

Busca por Satisfao de Restries ca co

O de busca por Satisfao de Restries assim conhecido por ser mais uma variao da busca em profunca co e ca didade, porm, re-orientada tipicamente por parmetros de natureza meta-heur e a istica. Suas caracter sticas so: a meta-heur istica gerada com base na quantidade de restries e de valores representados nos estados e co utilizados para representar o dom nio do problema; o Ef (estado nal) geralmente no conhecido em um enunciado t a e pico da classe dos dom nios nos quais a soluo de problemas pode ser encontrada por este algoritmo; ca e a soluo de problema pode ser absoluta (o teste de Ef denido precisamente) ou relativa (o teste de ca Ef se resume ` ultrapassagem de um limiar). a As principais meta-heu isticas utilizadas por este algoritmo so duas. a Varivel mais restrita: a Varivel mais restritiva: a Valor menos restritivo:

16