# Capítulo 3 - Resolvendo Problemas Pesquisando #

[ Flashcards para resumo do capítulo ] ( http://www.cram.com/flashcards/chapter-

3-7507199)

Para ser concluído:

3.4

## Exercício 3.1 ##
Explique por que a formulação do problema deve seguir a formulação do objetivo

### Solução ###

O objetivo faz parte da definição do problema. Um objetivo diferente pode
resultar em um problema totalmente diferente

## Exercício 3.2 ##
Considere o mundo acessível do vácuo em dois locais sob a Lei de Murphy. Mostre
isso para
cada estado inicial, há uma sequência de ações que garantem atingir um estado
objetivo.

### Solução ###

Como o mundo é acessível, basta seguir os passos: Se houver sujeira, chupe, senão
mova-se

## Exercício 3.3 ##
Forneça o estado inicial, o teste de meta, os operadores e a função de custo do
caminho para cada um dos itens a seguir.
Existem diversas formulações possíveis para cada problema, com variados níveis de
detalhe. O
O principal é que suas formulações sejam precisas e "colocadas" para que possam
ser
implementado.

1. Você deseja encontrar o número de telefone do Sr. Jimwill Zollicoffer, que

mora na Alameda,
dada uma pilha de diretórios ordenados alfabeticamente por cidade.
2. Quanto à parte (a), mas você esqueceu o sobrenome de Jimwill .
3. Você está perdido na selva amazônica e precisa chegar ao mar. Há um riacho
próximo.
4. Você deve colorir um mapa plano complexo usando apenas quatro cores, sem duas
cores adjacentes.
regiões tenham a mesma cor.
5. Um macaco está em uma sala com uma caixa, com bananas suspensas no teto, fora
do alcance.
Ele gostaria de pegar as bananas.
6. Você está perdido em uma pequena cidade do interior e precisa encontrar uma
drogaria antes da febre do feno
torna-se intolerável. Não há mapas e os nativos estão todos trancados em casa.

### Solução ###

#### 1º trimestre ####
* Estado inicial - x listas telefônicas contendo n nomes
* Teste de Meta - O nome corresponde
* Operadoras - Selecione agenda telefônica: conjunto de páginas; selecione
página: conjunto de nomes; selecione o nome.
* Custo Passado - Tempo necessário para encontrar o nome
* Algoritmo - Selecione o diretório pelo nome da cidade, selecione a página pelo
início do sobrenome, selecione o nome pelo nome

#### 2º trimestre ####

* Estado inicial - x listas telefônicas contendo n nomes
* Teste de Meta - O nome corresponde
* Operadoras - Selecione agenda telefônica: conjunto de páginas; selecione
página: conjunto de nomes; selecione o nome.
* Custo Passado - Tempo necessário para encontrar o nome
* Algoritmo - Selecione o diretório pelo nome da cidade, percorra cada página
procurando pelo primeiro nome

####T3####
* Estado inicial - Posição lat /long/alt, localização do mar
* Teste de Meta - Você está no mar
* Operadores - Caminhada
* Custo Passado - Tempo necessário para chegar ao mar
* Algoritmo - Siga o riacho em declive enquanto o mar está em 0 alt

#### 4º trimestre ####

* Estado Inicial - Posição/Bordas dos planos
* Teste de meta - Todos os planos são coloridos, sem regiões adjacentes com cores
correspondentes
* Operadores - Preencha o plano com 1 de quatro cores
* Custo Passado - Número de ações necessárias
* Algoritmo - CSP, pode usar algoritmos como Most Constrained Variable

####Q5####
* Estado Inicial - Localização do macaco, caixa e bananas
* Teste de Meta - O macaco está com as bananas
* Operadores - O macaco pode mover a si mesmo e a caixa
* Custo Passado - Tempo gasto
* Algoritmo - Mova a caixa sob as bananas. Análise Meios-Fins

####Q6####
* Estado inicial - Layout da cidade, sua localização
* Teste de Meta - Você está na farmácia
* Operadores - Caminhe, olhe, faça mapa
* Custo Passado - Tempo gasto
* Algoritmo - Caminhe em direção à área mais construída e trabalhe a partir daí

## Exercício 3.4 ##
Implemente o problema dos missionários e canibais e use a pesquisa ampla para
encontrar o
solução mais curta. É uma boa ideia verificar estados repetidos? Desenhe um
diagrama completo
espaço de estado para ajudá-lo a decidir

### Solução ###

missionaries_and_cannibals.py implementa ambiente/pesquisa com base na descrição
do livro. Infelizmente o livro
A descrição é insolúvel porque considera apenas os pontos finais importantes,
enquanto a solução real requer
uma variável separada para quem está sentado no barco, em vez de apenas quem está
de que lado da margem.

Pode adicionar solução real em um estágio posterior

## Exercício 3.5 ##
Na página 76, dissemos que não consideraríamos problemas com custos de caminho
negativo. Nisso
exercício, exploramos isso com mais profundidade.

1. Suponha que um limite inferior negativo c seja colocado no custo de qualquer

etapa - isto é,
custos negativos são permitidos, mas o custo de uma etapa não pode ser inferior a
c. Isso permite
pesquisa de custo uniforme para evitar pesquisar a árvore inteira?
2. Suponha que exista um conjunto de operadores que formam um loop, de modo que a
execução do conjunto em algum
ordem não resulta em nenhuma mudança líquida no estado. Se todos esses operadores
tiverem custo negativo, o que
isso implica no comportamento ideal de um agente em tal ambiente ? :
3. É fácil imaginar operadores com custos negativos elevados, mesmo em domínios
como a localização de rotas.
Por exemplo, alguns trechos de estrada podem ter paisagens tão bonitas que chegam
a longe.
superam os custos normais em termos de tempo e combustível. Explique, em termos
precisos, por que os humanos
não dirija em voltas cênicas indefinidamente e explique como definir o espaço do
estado e eu
operadores para localização de rotas, para que agentes artificiais também possam
evitar loopings.
4. Você consegue pensar em um domínio real em que os custos da etapa sejam tais
que causem looping?

### Solução ###

1. Não se quiser encontrar a solução ótima, porque sempre existe a possibilidade

de um loop de
custo negativo no futuro que pode desfazer todas as ações de custo positivo
2. Se eles são os únicos nós de custo negativo no ambiente, então o comportamento
ideal dos agentes é um loop contínuo
3. Você pode explicar isso dizendo que os estados têm um viés que decai para 0
cada vez que o agente visita. Começa em grande
custo negativo e reduz até que tomar a rota panorâmica tenha menos utilidade do
que pegar a rodovia
4. Se a recompensa de um robô a vácuo fosse baseada apenas na sujeira coletada,
ele poderia constantemente coletar e colocar sujeira

## Exercício 3.6 ##
O algoritmo GENERAL-SEARCH consiste em três etapas: teste de meta, geração e
função de ordenação, nesta ordem.
Parece uma pena gerar um nó que é de fato uma solução, mas deixar de reconhecê-lo
porque o pedido
a função não consegue colocá-lo primeiro.

1. Escreva uma versão do GENERAL-SEARCH que teste cada nó assim que ele é gerado
e pare imediatamente se encontrar um objetivo.
2. Mostre como o algoritmo GENERAL-SEARCH pode ser usado inalterado para fazer
isso, fornecendo-lhe a função de ordenação adequada

### Solução ###

1. GeneralSearchImmediateCheck ( ) em imediato_search.py
2. BreadthFirstSearchImmediateCheck ( ) em imediato_search.py
## Exercício 3.7 ##
A formulação do problema, solução e algoritmo de busca dada neste capítulo
explicitamente
menciona o caminho para um estado objetivo. Isso ocorre porque o caminho é
importante em muitos problemas. Para
outros problemas, o caminho é irrelevante e apenas o estado objetivo importa.
Considere o problema
"Encontre a raiz quadrada de 123454321." Uma busca no espaço dos números pode
passar por
muitos estados, mas o único que importa é o estado objetivo, o número 11111.
Claro, de um ponto de vista
do ponto de vista teórico, é fácil executar o algoritmo de busca geral e depois
ignorar todos os
caminho, exceto o estado objetivo. Mas como programador, você pode obter um ganho
de eficiência codificando um
versão do algoritmo de busca que não rastreia caminhos. Considere uma versão do
problema
resolver onde não há caminhos e apenas os estados importam. Escreva definições de
problema e
solução e o algoritmo de busca geral. Qual dos problemas da Seção 3.3 usaria
melhor
esse algoritmo, e qual deve usar a versão que rastreia os caminhos?

### Solução ###

Problema - Resolvendo um quebra-cabeça
Solução – Quando cada peça está no lugar correto
Pesquisa Geral - Onde cada peça precisa ser colocada

Como todas as ações podem ser consideradas independentemente, a ordem dos

caminhos é irrelevante e, portanto, o problema
pode ser resolvido com a necessidade de acompanhar os caminhos

## Exercício 3.8 ##
Dado um algoritmo de busca sem caminho como o solicitado no Exercício 3.7,
explique como
você pode modificar os operadores para acompanhar os caminhos como parte das
informações em um estado. Mostrar
os operadores precisavam resolver os problemas de localização de rotas e turismo.

### Solução ###

Como o nó contém o nó pai e o operador, você pode simplesmente rastrear os nós
pais para
determinar quais operações precisam chegar a esse ponto, sem precisar estar
contido no próprio estado
## Exercício 3.9 ##
Descreva um espaço de busca no qual a busca iterativa por aprofundamento tem um
desempenho muito pior do que a busca em profundidade

### Solução ###

O Depth First teria um desempenho melhor se o fator de ramificação fosse muito
baixo, mas o estado da meta fosse bastante profundo ou o caminho correto
acontece de estar no caminho das primeiras opções.

## Exercício 3.10 ##
A Figura 3.17 mostra uma visão esquemática da busca bidirecional. Por que você
acha que escolhemos
para mostrar árvores crescendo a partir dos estados inicial e objetivo, em vez de
duas árvores de pesquisa crescendo
horizontalmente um em direção ao outro

### Solução ###

As dimensões junto com a expansão do espaço de pesquisa dependem apenas do nó
raiz e da política de pesquisa,
o nó de destino poderia essencialmente ser posicionado em torno de qualquer ponto
do nó inicial

## Exercício 3.11 ##
Escreva o algoritmo para busca bidirecional, em pseudocódigo ou em uma
programação
linguagem. Suponha que cada pesquisa será uma pesquisa em largura e que as
pesquisas direta e
pesquisas retroativas se revezam na expansão de um nó por vez. Tenha cuidado para
evitar verificar cada nó
na pesquisa direta em cada nó na pesquisa regressiva

### Solução ###

Pesquisa bidirecional ( ) em search.py. Usa GeneralSearch atualizado com nós com
hash e capacidade de expansão em etapas

## Exercício 3.12 ##
Dê a complexidade temporal da pesquisa bidirecional quando o teste para conectar
os dois
pesquisas são feitas comparando um estado recém-gerado na direção direta com
todos os
estados gerados na direção inversa, um de cada vez.
### Solução ###
O(n^2). Na pior das hipóteses, cada nó é comparado com metade dos outros nós
(fator constante)

## Exercício 3.13 ##
Dissemos que pelo menos uma direção de uma busca bidirecional deve ser uma busca
em largura.
Qual seria uma boa escolha para a outra direção? Por que?

Para otimização com custo de etapa constante, BFS ou UCS funcionarão, a

profundidade primeiro pode se transformar em loops.
Do ponto de vista das pesquisas do lado da meta, há apenas um nó de meta
adicional adicionado a cada etapa.

## Exercício 3.14 ##
Considere o seguinte operador para o problema das 8 rainhas: coloque uma rainha
na coluna
com o menor número de casas não atacadas, de forma que não ataque nenhuma outra
rainha. Como
muitos nós isso se expande antes de encontrar uma solução? (Você pode querer ter
um programa
calcule isso para você.)

### Solução ###

Execute n_queens.py com pesquisa como algoritmo relevante. Usar o DepthFirst pode
resolver aproximadamente 2.000 nós expandidos.
Usar BreadthFirst pode resolver aproximadamente 120.000 verificações (muito mais
lento também na concatenação de lista)

## Exercício 3.15 ##
O problema da cadeia (Figura 3.20) consiste em vários comprimentos de cadeia que
devem ser reconfigurados
em novos arranjos. Os operadores podem abrir um link e fechar um link. No padrão
Na forma do problema, o estado inicial contém quatro cadeias, cada uma com três
elos. O estado objetivo
consiste em uma única cadeia de 12 elos em um círculo. Configure isso como um
problema de pesquisa formal e encontre
a solução mais curta.

### Solução ###

Consulte chain_problem.py. Bastante lento, pois a cópia profunda do nó leva tempo
e o problema tem um alto fator de ramificação.
Implementação ligeiramente diferente da descrição, pois cada lado pode ser aberto
e fechado de forma independente,
em vez de o link estar aberto e ter no máximo 2 outros links adicionados. Pode
revisitar no futuro

Solução mais curta 8 ações para este modelo, seja abrindo e conectando cada link
de borda,
ou dividindo uma corrente em 3 elos e conectando cada um deles.

## Exercício 3.16 ##
Os testes de inteligência humana geralmente contêm problemas de previsão de
sequências. O objetivo em
tais problemas é prever o próximo membro de uma sequência de inteiros, assumindo
que o número
na posição n da sequência é gerada usando alguma função de sequência s(n), onde o
primeiro
elemento da sequência corresponde a n = 0. Por exemplo, a função s(n) = 2**n gera
o
sequência [1,2,4,8,16, ...].

Neste exercício, você projetará um sistema de resolução de problemas capaz de

resolver tais previsões
problemas. O sistema irá procurar no espaço de funções possíveis até encontrar
uma que
corresponde à sequência observada. O espaço de funções de sequência que
consideraremos consiste
de todas as expressões possíveis construídas a partir dos elementos 1 e n, e as
funções +, x, —, /, e
exponenciação. Por exemplo, a função 2 **n torna-se (1 + 1)* * n nesta linguagem.
Será útil
pensar em expressões de função como árvores binárias, com operadores nos nós
internos e 1 's e
n está nas folhas.

1. Primeiro, escreva a função de teste de meta. Seu argumento será uma função de
sequência candidata s. Isto
conterá a sequência de números observada como estado local.
2. Agora escreva a função sucessora. Dada uma expressão de função s, ela deve
gerar todos
expressões um passo mais complexas que s. Isto pode ser feito substituindo
qualquer folha do
expressão com uma árvore binária de duas folhas.
3. Qual dos algoritmos discutidos neste capítulo seria adequado para este
problema?
Implemente-o e use-o para encontrar expressões de sequência para as sequências [
1,2,3,4,5 ],
[1,2,4,8,16, ... ] e [ 0,5,2,4,5,8 ].
4. Se o nível d do espaço de busca contém todas as expressões de complexidade d
+1, onde complexidade
é medido pelo número de nós folha (por exemplo, n + (1 xn) tem complexidade 3),
prove por
indução de que existem aproximadamente 20* *d* (d+1)! expressões no nível d.
5. Comente sobre a adequação de algoritmos de busca desinformados para resolver
este problema. Pode
você sugere outras abordagens?

### Solução ###

1. Consulte goal_test (nó) em sequencia_predictor.py
2. Consulte expand_node (nó) em sequencia_predictor.py
3. [ 1,2,3,4,5 ] = (1 + n); [1,2,4,8,16, ...] = ((1+1) **n); [ 0,5,2,4,5,8 ] =
((n+1)** (1+1))/(1+1) (Adivinhação manual,
programa interrompido após 40.000 pesquisas ~ 15 minutos)
4. d camadas ** (5 símbolos [+, -, *, /, **] x 2 itens [1, n] x (d-1)!
agrupamentos [() em torno de subagrupamentos])
= 10* *(d* (d-1)!). Não tenho certeza de como 20* *d* (d+1)! veio quantidade
5. Muito inadequado, o espaço de pesquisa contém muitas funções reversíveis.
Outras abordagens poderiam ser tentadas para gerar
um intervalo de valores válidos e usá-los de alguma forma, por exemplo, armazenar
uma maneira de obter 2, 3, 4, 5 etc. em nós independentes
e então combine então com n. Ou identifique nós que não têm efeito, como (nn) =
0, e não expandam nós
contendo essas estruturas

## Exercício 3.17 ##
O mundo do vácuo total dos exercícios do Capítulo 2 pode ser visto como um
problema de busca
no sentido que definimos, desde que assumamos que o estado inicial é
completamente conhecido.

1. Defina o estado inicial, os operadores, a função de teste de meta e a função

de custo do caminho.
2. Qual dos algoritmos definidos neste capítulo seria apropriado para este
problema?
3. Aplique um deles para calcular uma sequência ideal de ações para um mundo 3 x
3 com sujeira
o centro e os quadrados iniciais.
4. Construir um agente de busca para o mundo do vácuo e avaliar seu desempenho em
um conjunto de
Mundos 3x3 com probabilidade 0,2 de sujeira em cada quadrado. Inclua o custo de
pesquisa, bem como
custo do caminho na medida de desempenho, usando uma taxa de câmbio razoável.
5. Compare o desempenho do seu agente de pesquisa com o desempenho dos agentes
construídos
para os exercícios do Capítulo 2. O que acontece se você incluir o tempo de
cálculo em
medida de desempenho, a diversas "taxas de câmbio" em relação ao custo de tomar
um
pisar no meio ambiente?
6. Considere o que aconteceria se o mundo fosse ampliado para nx n. Como é o
desempenho
do agente de busca variam com n? Dos agentes reflexos?

### Solução ###

1. * Estado inicial: [[ A->, D ][ D, E]]. Grade de 2x2 com agente no canto
superior esquerdo voltado para a direita e sujeira em 2 quadrados
* Operadores: Avançar, Chupar, Vire à Esquerda, Vire à Direita, Desligue
* Teste de meta: Se não houver sujeira e o agente estiver desligado enquanto está
sentado na casa
* Custo do caminho: +1 por ação realizada, -100 por pedaço de sujeira sugado,
1000 por não estar no quadrado inicial ao desligar.
Para tornar isso monotônico pode ser 101 por ação realizada, 0 se estiver sugando
sujeira, 1100 por não estar em casa
2. Custo Uniforme. Você deseja minimizar o custo do caminho enquanto atinge a
meta
3. Defina env = make_3x3() em Vacuum_world.py e execute usando UniformCostSearch
( UniformCost resolve em 502, BreadthFirst em 624)
4. Defina env = make_random_3x3() em Vacuum_world.py e inclua search_cost nos
argumentos search.find _path ()
5. Se o custo de pesquisa for suficientemente elevado, então pode ser mais eficaz
utilizar um agente mais simples
6. É possível criar um VacuumEnvironment ( ) padrão e aplicar a pesquisa para
testá-lo. O espaço de pesquisa se expande aproximadamente
(altura * largura) ^ ações em que altura e largura são o número de novas células
adicionadas. Porcentagem de sujeira também
tem um impacto enorme, pois cada pedaço adicional de sujeira normalmente requer 5
ações adicionadas [2 x giros, 2 x movimento, 1 x sucção],
por exemplo, 3x3 cheio de sujeira leva cerca de 28 ações (da solução manual), o
que equivale a 28 ^ 5 estados para expandir

## Exercício 3.18 ##
Os agentes de busca que discutimos fazem uso de um modelo completo do mundo para
construir uma solução que eles então executam. Modifique o algoritmo de busca em
profundidade com repetições
verificação de estado para que um agente possa usá-la para explorar um mundo de
vácuo arbitrário, mesmo sem um
modelo das localizações de paredes e sujeira. Não deve ficar preso mesmo em loops
ou becos sem saída.
Você também pode desejar que seu agente construa uma descrição de ambiente do
tipo usado por
os algoritmos de pesquisa padrão.

### Solução ###

Todas as classes de pesquisa implementam verificação de estado por meio de hash
de estado/operador

## Exercício 3.19 ##
Ao discutir o problema criptoaritmético, propusemos que um operador deveria
atribuir
um valor para qualquer letra que tenha o menor valor restante possível. Esta
regra é garantida para
produzir o menor espaço de busca possível? Por que não)?

### Solução ###

Não. Reduzir o espaço de busca envolve restringir possíveis ações, atribuindo um
valor com base em variáveis
com o mínimo de valores restantes possíveis terá o efeito oposto de manter o
fator de ramificação alto
e, portanto, o espaço de busca grande

## Exercício 3.20 ##
Defina cada um dos seguintes problemas como problemas de satisfação de
restrições:

1. O problema criptoaritmético.
2. O problema de roteamento de canal no layout VLSI.
3. O problema da coloração do mapa. Na coloração de mapas, o objetivo é colorir
países em um mapa usando
um determinado conjunto de cores, de modo que não haja dois países adjacentes da
mesma cor.
4. O problema do planejamento retilíneo, que envolve encontrar locais não
sobrepostos em
um retângulo grande para vários retângulos menores.
### Solução ###
1. * X = {(L1, ..., Ln), W1, W2, W3 } Cada letra mais três palavras
* D = {(0, 1, ..., 9), [L1, ..., Ln], [L1, ..., Ln], [L1, ..., Ln ]} Contém um
número ou uma lista de cartas
* C = { R (W1) + R(W2) = R(W3) } Quando letras são substituídas (R) por números,
a sequência deve ser uma adição válida

2. Não tenho certeza de como o VLSI funciona, posso voltar a isso

3. * X = {(Países )} Cada país definido por arestas

* D = {(Cores )} Conjunto de cores
* C = {Para todo x1, x2 Adjacente(x1, x2) deve ter Cor(x1) != Cor(x2) }

4. * X = {Dimensões do retângulo grande}

* D = {[Retângulos pequenos]}
* C = {Para todas as posições x (x) no retângulo grande existe 1 PositionSR (x)
ou 0 PositionSR (x) }
A lógica está um pouco enferrujada, pode voltar depois de capítulos posteriores

## Exercício 3.21 ##
Implemente um sistema de satisfação de restrições da seguinte forma:

1. Defina um tipo de dados para CSPs com domínios discretos e finitos. Você
precisará encontrar uma maneira de
representam domínios e restrições.
2. Implementar operadores que atribuam valores às variáveis, onde as variáveis
são atribuídas em um
ordem fixa em cada nível da árvore.
3. Implemente um teste de meta que verifique um estado completo para satisfação
de todas as restrições.
4. Implemente o retrocesso modificando DEPTH-FIRST-SEARCH.
5. Adicione verificação futura ao seu algoritmo de retrocesso.
6. Execute os três algoritmos em alguns exemplos de problemas e compare seu
desempenho.

### Solução ###

1. Veja as classes Variable( ) e ConstraintSatisfactionProblem () em csp.py
2. Veja solve( ) em ConstraintSatisfactionSolver () em csp.py
3. Veja is_solution ( ) em ConstraintSatisfactionProblem () em csp.py
4. Verifique se is_valid foi adicionado ao início de solve( ), bem como a fila de
profundidade no final de solve()
5. Consulte forward_checking ( ) em ConstraintSatisfactionSolver ()
6. CSP trivial com valores em uma matriz 2x2 com restrição e objetivo incluídos
em csp.py