uma investigação de algoritmos exatos e metaheurísticos ... · prof. dr. antônio carlos gay...

UNIVERSIDADE FEDERAL DO RIO GRANDE DO NORTE

CENTRO DE CIÊNCIAS EXATAS E DA TERRA

DEPARTAMENTO DE INFORMÁTICA E MATEMÁTICA APLICADA

PROGRAMA DE PÓS-GRADUAÇÃO EM SISTEMAS E COMPUTAÇÃO

MESTRADO ACADÊMICO EM SISTEMAS E COMPUTAÇÃO

Uma Investigação de Algoritmos Exatos e

Metaheurísticos Aplicados ao Nonograma

Camila Nascimento de Oliveira Taumaturgo

Natal-RN

Fevereiro de 2013

Camila Nascimento de Oliveira Taumaturgo

Uma Investigação de Algoritmos Exatos e Metaheurísticos

Aplicados ao Nonograma

Dissertação de Mestrado apresentado ao

Programa de Pós-Graduação em Sistemas e

Computação do Departamento de Informática e

Matemática Aplicada da Universidade Federal do

Rio Grande do Norte como requisito parcial para

a obtenção do grau de Mestre em Sistemas e

Computação.

Linha de pesquisa:

Algoritmos Experimentais

Orientadora

Prof.ª Dra. Elizabeth Ferreira Gouvêa Goldbarg

PPgSC – Programa de Pós-Graduação em Sistemas e Computação

DIMAp – Departamento de Informática e Matemática Aplicada

CCET – Centro de Ciências Exatas e da Terra

UFRN – Universidade Federal do Rio Grande do Norte

Natal-RN

Fevereiro de 2013

Dissertação de Mestrado sob o título Uma Investigação de Algoritmos Exatos e

Metaheurísticos Aplicados ao Nonograma apresentado por Camila Nascimento de

Oliveira Taumaturgo e aceita pelo Programa de Pós-Graduação em Sistemas e

Computação do Departamento de Informática e Matemática Aplicada da Universidade

Federal do Rio Grande do Norte, sendo aprovada por todos os membros da banca

examinadora abaixo especificada:

__________________________________________

Prof.ª Dra. Elizabeth Ferreira Gouvêa Goldbarg

Presidente



__________________________________________

Prof. Dr. Marco César Goldbarg

Examinador interno à Instituição



__________________________________________

Prof.ª Dra. Iloneide Carlos de Oliveira Ramos

Examinadora externa ao Programa

DEST – Departamento de Estatística


__________________________________________

Prof. Dr. Antônio Carlos Gay Thomé

Examinador externo à Instituição

Departamento de Ciência da Computação

UFRJ – Universidade Federal do Rio de Janeiro

Natal-RN, 01 de fevereiro de 2013.

Dedicatória

Dedico este trabalho ao meu esposo, Renato Taumaturgo. Reno, muito obrigada pelo

seu carinho, apoio e atenção. Sem você esta fase da minha vida não teria sido tão bonita

e repleta de alegrias. Te amo.

Agradecimentos

Quero agradecer primeiramente a Deus, por me ter me concedido tantas graças, por ter

me dado forças, amor e ter colocado na minha vida pessoas muito especiais que tornaram meus

dias mais fáceis e prazerosos.

Em especial, quero agradecer e dedicar este trabalho ao meu amado esposo Renato,

por sempre estar ao meu lado e disposto a me ajudar, por compreender minhas preocupações e

angústias durante todo o trabalho. Obrigada por ter abdicado de suas férias para estar ao me lado

no fim desta fase tão importante na minha vida.

Não posso deixar de agradecer aos meus familiares mais próximos. Aos meus irmãos

pela confiança e admiração ao meu trabalho. Ao meu pai que, sendo professor e mestre, me

inspirou nesta jornada. Em especial, à minha mãe, pelo carinho, paciência e pela torcida; sei que

ela é minha maior fã, e sua dedicação me inspira a me tornar uma profissional e mãe amorosa e

dedicada. E aos meus sobrinhos, principalmente Ana Lu, que entendeu todas as vezes que eu

disse que ela não poderia dormir na minha casa porque eu estava terminando meu Mestrado.

Quero agradecer aos meus sogros e às minhas duas cunhadas pela amizade e pelo

carinho. Eles realmente são minha família, e agradeço a Deus por ter posto eles na minha vida.

Quero agradecer aos meus amigos da UFRN. A Juliana Araújo, por sempre estar feliz

ao meu lado, me dando apoio e me incentivando. A Everton Cavalcante, pelos seus conselhos e

sua amizade, e eu sei que ele sempre está disposto a me ajudar em qualquer situação; muito

obrigada! A Alba Sandyra, minha amiga da UFRN mais antiga, que sempre tem conselhos

sábios, é sincera e fiel; obrigada, Albinha, pela sua amizade.

Aos colegas do LAE quero agradecer pelos momentos de descontração e pelas novas

amizades que fiz durante o Mestrado, e espero que essas amizades sejam eternas. Em especial,

agradeço a Silvia, que iniciou o trabalho com os Nonogramas, me concedeu tudo que havia

pesquisado e sempre esteve disposta a me ajudar e a tirar minhas dúvidas. Com certeza, sem a

ajuda de Silvia, meu Mestrado teria sido mais complicado.

Por último, e não menos importante, quero agradecer à minha orientadora Elizabeth

Goldbarg, pelas conversas, orientações e amizade; obrigada por tudo, professora. Quero também

agradecer ao professor Marco Goldbarg pelas ótimas dicas ao meu trabalho e pela confiança em

mim.

Ainda que eu caminhe por um vale tenebroso, nenhum mal temerei, pois estás junto a

mim.

Salmo 22,4

Uma Investigação de Algoritmos Exatos e Metaheurísticos

Aplicados ao Nonograma

Autora: B.Sc. Camila Nascimento de Oliveira Taumaturgo

Orientadora: Prof.ª Dra. Elizabeth Ferreira Gouvêa Goldbarg

RESUMO

O Nonograma é um jogo lógico cujo problema de decisão associado é NP-completo. Ele

possui aplicação em problemas de identificação de padrões e de compactação de dados,

dentre outros. O jogo consiste em determinar uma alocação de cores em pixels

distribuídos em uma matriz N M atendendo restrições em linhas e colunas. Um

Nonograma é codificado através de vetores cujos elementos especificam o número de

pixels existentes em cada coluna e linha de uma figura, sem especificar suas

coordenadas. Este trabalho apresenta abordagens exatas e heurísticas para solucionar o

Nonograma. A Busca em Profundidade foi uma das abordagens exatas escolhida, por

ser um exemplo típico de algoritmo de força bruta de fácil implementação. Outra

abordagem exata implementada foi baseada no algoritmo Las Vegas, através do qual se

pretende investigar se a aleatoriedade introduzida pelo algoritmo Las Vegas traria

algum benefício em relação à Busca em Profundidade. O Nonograma também é

transformado em um Problema de Satisfação de Restrições. Três abordagens heurísticas

são propostas: uma Busca Tabu e dois algoritmos Memético. Uma nova abordagem para

o cálculo da função objetivo é proposta neste trabalho. As abordagens são testadas em

234 casos de teste de tamanho entre 5 x 5 e 100 x 100, incluindo Nonogramas lógicos e

aleatórios.

Palavras-chave: Nonograma. Busca em Profundidade. Las Vegas. Problema de

Satisfação de Restrições. Busca Tabu. Memético.

Exact and Metaheuristic Algorithms Research Applied to

Nonogram

Author: Camila Nascimento de Oliveira Taumaturgo, B.Sc.

Supervisor: Prof. Elizabeth Ferreira Gouvêa Goldbarg, Ph.D.

ABSTRACT

Nonogram is a logical puzzle whose associated decision problem is NP-complete. It has

applications in pattern recognition problems and data compression, among others. The

puzzle consists in determining an assignment of colors to pixels distributed in a N M

matrix that satisfies line and column constraints. A Nonogram is encoded by a vector

whose elements specify the number of pixels in each row and column of a figure

without specifying their coordinates. This work presents exact and heuristic approaches

to solve Nonograms. The depth first search was one of the chosen exact approaches

because it is a typical example of brute search algorithm that is easy to implement.

Another implemented exact approach was based on the Las Vegas algorithm, so that we

intend to investigate whether the randomness introduce by the Las Vegas-based

algorithm would be an advantage over the depth first search. The Nonogram is also

transformed into a Constraint Satisfaction Problem. Three heuristics approaches are

proposed: a Tabu Search and two memetic algorithms. A new function to calculate the

objective function is proposed. The approaches are applied on 234 instances, the size of

the instances ranging from 5 x 5 to 100 x 100 size, and including logical and random

Nonograms.

Keywords: Nonogram. Depth First Search. Las Vegas. Constraint Satisfaction Problem.

Tabu Search. Memetic.

Lista de Figuras

Figura 1 – Imagem binária com suas projeções horizontal e vertical (Fonte: Batenburg, 2005) 19

Figura 2 – Esquerda: Descrição de um Nonograma. Direita: Solução correspondente do

Nonograma (Fonte: Pic-a-Pix) ............................................................................................. 20

Figura 3 – Exemplo de um Nonograma preto-e-branco e sua solução ....................................... 24

Figura 4 – Nonograma Colorido .................................................................................................. 24

Figura 5 – (a) Dado um puzzle. (b) Três alocações possíveis de blocos para a linha 1. (c) Duas

alocações possíveis de blocos para a linha 2. (d) Duas alocações possíveis de blocos para a

linha 3. (e) Uma alocação de bloco para a linha 4. ............................................................. 35

Figura 6 – Transformando o Nonograma em cláusulas lógicas para as linhas............................ 47

Figura 7 – Possibilidades da linha 1 ............................................................................................. 49



Figura 10 – Possibilidade da linha 4 ............................................................................................ 50

Figura 11 – Possibilidades da linha 6 ........................................................................................... 50

Figura 12 – Um exemplo de DFS. (a) Dado um puzzle. (b) Três possíveis soluções para a linha 1.

(c) Duas soluções possíveis para a linha 2. (d) Duas soluções possíveis para a linha 3. (e)

Uma solução possível para a linha 4. (f) Árvore de busca de (a). ....................................... 51

Figura 13 – Passo 1 da busca em profundidade com Backtracking ............................................ 51








Figura 21 – Sorteia-se uma possibilidade para a primeira linha. ................................................ 54

Figura 22 – Sorteia-se uma possibilidade para a segunda linha. Nota-se uma violação. A

seguencia 3 torna-se proibida. ............................................................................................ 55

Figura 23 – Sorteia-se uma possibilidade para a primeira linha e para a segunda linha. Percebe-

se uma violação e a seguência 4-1 torna-se proibida. ........................................................ 55

Figura 24 – A sequencia 4 torna-se proibida. Sorteia-se uma possibilidade para a primeira linha.

............................................................................................................................................. 55

Figura 25 – Sorteia-se uma possibilidade para a segunda linha, percebe-se uma violação. A

sequência 1 torna-se proibida. ............................................................................................ 55

Figura 26 – Sorteia-se uma possibilidade para a primeira e segunda linha. ............................... 56

Figura 27 – Sorteia-se uma possibilidade para a terceira linha, percebe-se uma violação. A

sequência 2-1-1 torna-se proibida. Sorteia-se outra possibilidade para a terceira linha, e a

sequência 2-1-2 torna-se proibida. ..................................................................................... 56

Figura 28 – Sorteia-se uma possibilidade para a terceira e quarta linha. ................................... 56

Figura 29 – Sorteia-se uma possibilidade para a terceira linha. A solução do puzzle é

encontrada. ......................................................................................................................... 57

Figura 30 – Solução não viável de um Nonograma ..................................................................... 59

Figura 31 – Exemplo de alocação inicial dos blocos .................................................................... 60

Figura 32 – CruzCorte: (a) pai1; (b) pai2; (c) Filho resultante do cruzamento do pai1 com o pai2

............................................................................................................................................. 66

Figura 33 – (a) Número médio de pixels não resolvidos para puzzles 30 x 30 gerados

aleatoriamente, para uma6 porcentagem

variável de pixels pretos, ao usar o Solver1; barras de erro indicam desvio padrão. (b)

Como em (a) para FullSettle (topo do gráfico), Solver0 (meio do gráfico) e Solver1, sem o

desvio padrão .................................................................................................................... 100

Lista de Gráficos

Gráfico 1 – Quantidade de combinações possíveis para os casos de teste do Benchmark Puzzle

(2012). ................................................................................................................................. 36

Gráfico 2 – Tempo em segundos para gerar todas as alocações possíveis de blocos para cada

linha e coluna dos casos de teste do Benchmark Puzzles (2012) ........................................ 36

Gráfico 3 – Quantidade de combinações possíveis para os casos de teste do Nonogram Solver

(2012). ................................................................................................................................. 37

Gráfico 4 – Tempo em segundos para gerar as alocações possíveis de blocos para cada linha e

coluna dos casos de teste do Nonogram Solver (2012). ..................................................... 37

Gráfico 5 – Quantidade de combinações para os casos de teste 10 x 10 do RanPuz ................. 38


coluna dos casos de teste do RanPuz com tamanho 10 x 10 .............................................. 38



coluna dos casos de teste do RanPuz com tamanho 20 x 20 .............................................. 39



coluna dos casos de teste do RanPuz com tamanho 30 x 30. ............................................. 40

Lista de Tabelas

Tabela 1 – Resumo das onze regras lógicas de Jing et al. (2009) e Yu et al. (2009) ................... 41

Tabela 2 – Resultados da aplicação das regras lógicas para os casos de teste do Benchmark

Puzzles (2012) ...................................................................................................................... 43

Tabela 3 – Resultados da aplicação das regras lógicas para os casos de teste do site Nonogram

Solver (2012)........................................................................................................................ 43

Tabela 4 – Resultados da aplicação das regras lógicas para os casos de teste aleatórios .......... 44

Tabela 5 – Resultados da aplicação das regras lógicas para os casos de teste aleatórios do

RanPuz ................................................................................................................................. 45

Tabela 6 – Resultados da aplicação das regras lógicas para os casos de teste aleatórios do

RanPuz ................................................................................................................................. 46

Tabela 7 – Resultados do MiniSat par os casos de teste retirados de jogos para dispositivos

móveis ................................................................................................................................. 48

Tabela 8 – Resultado do DFS e Las Vegas para os casos de teste do Benchmark Puzzles (2012).

............................................................................................................................................. 57

Tabela 9 – p-valores em relação à função objetivo para a decisão da construção da solução

inicial ................................................................................................................................... 70

Tabela 10 – p-valores em relação à função objetivo para o parâmetro iter ............................... 71

Tabela 11 – p-valores em relação ao tempo para o parâmetro iter ........................................... 71

Tabela 12 – p-valores em relação à função objetivo para o parâmetro iterG (400 x 600) ......... 72

Tabela 13 – p-valores em relação ao tempo para o parâmetro iterG (400 x 600) ...................... 72

Tabela 14 – p-valores em relação à função objetivo para o parâmetro iterG (200 x 400) ......... 73

Tabela 15 – p-valores em relação à função objetivo para o parâmetro cont (200 x 500) .......... 73

Tabela 16 – p-valores em relação ao tempo para o parâmetro cont (300 x 500) ....................... 74

Tabela 17 – p-valores em relação à função objetivo para o parâmetro cont (100 x 300) .......... 74

Tabela 18 – p-valores em relação à função objetivo para a decisão da construção da solução

inicial ................................................................................................................................... 75

Tabela 19 – p-valores em relação à função objetivo para a decisão do tamanho da população 76

Tabela 20 – p-valores em relação ao tempo para a decisão do tamanho da população ........... 76

Tabela 21 – p-valores em relação à função objetivo para a decisão do número de gerações ... 77

Tabela 22 – p-valores em relação à função objetivo para a forma de seleção dos pais ............. 78

Tabela 23 – p-valores em relação ao tempo para a decisão da forma de seleção dos pais ....... 78

Tabela 24 – p-valores em relação à função objetivo para o método de cruzamento ................ 79

Tabela 25 – p-valores em relação à função objetivo para a decisão da taxa de cruzamento .... 80

Tabela 26 – p-valores em relação ao tempo para a decisão da taxa de cruzamento ................. 81

Tabela 27 – p-valores em relação à função objetivo para a decisão da taxa de mutação .......... 81

Tabela 28 – p-valores em relação à função objetivo para a decisão do número de iterações da

busca local ........................................................................................................................... 82

Tabela 29 – p-valores em relação à função objetivo para a decisão de nPixel ........................... 83

Tabela 30 – p-valores em relação à função objetivo para a decisão de pAltRC .......................... 84

Tabela 31 – Resultados do TabuGrama para os casos de teste do Benchmark Puzzles (2012) .. 85

Tabela 32 – Resultados do TabuGrama para os casos de teste do Nonogram Solver (2012) ..... 85

Tabela 33 – Resultados do TabuGrama para os casos de teste do RanPuz com tamanho 10 x 10

............................................................................................................................................. 86


............................................................................................................................................. 87


............................................................................................................................................. 87

Tabela 36 – Resultados do Memetico1 para os casos de teste do Benchmark puzzles (2012) .. 88

Tabela 37 – Resultados do Memetico1 para os casos de teste do Nonogram Solver (2012) ..... 89

Tabela 38 – Resultados do Memetico1 para os casos de teste do RanPuz com tamanho 10 x 10

............................................................................................................................................. 89


............................................................................................................................................. 90


............................................................................................................................................. 91

Tabela 41 – Resultados do Memetico2 para os casos de teste do Benchmark puzzles (2012) .. 92

Tabela 42 – Resultados do Memetico2 para os casos de teste do Nonogram Solver (2012) ..... 92


............................................................................................................................................. 93


............................................................................................................................................. 93


............................................................................................................................................. 94

Tabela 46 – p-valores em relação ao tempo para as comparações das heurísticas propostas

para os casos de teste do Benchmark puzzles (2012) ......................................................... 95

Tabela 47 – p-valores em relação à função objetivo para as comparações das heurísticas

propostas para os casos de teste do Nonogram Solver (2012) ........................................... 96

Tabela 48 – p-valores em relação ao tempo para as comparações das heurísticas propostas

para os casos de teste do RanPuz com o tamanho 10x10 .................................................. 96


propostas para os casos de teste do RanPuz com o tamanho 20x20 ................................. 97


propostas para os casos de teste do RanPuz com o tamanho 30x30 ................................. 97

Lista de Quadros

Quadro 1 – Procedimento de busca local ................................................................................... 61

Quadro 2 – Pseudo-código do algoritmo Tabugrama ................................................................. 62

Quadro 3 – Procedimento Busca Local do TabuGrama .............................................................. 63

Quadro 4 – Pseudo-código do algoritmo Memetico1 ................................................................. 65

Quadro 5 – Pseudo-código do algoritmo Memetico2 ................................................................. 67

Lista de abreviaturas e siglas

B&W – Blach and White (Preto e branco)

CCD – Charge-coupled device

CSP – Constraint Satisfaction Problem

CTO – Chief technology officer

DFS – Depth First Search (Busca em Profundidade)

DT – Discrete Tomography (Tomografia Discreta)

FNC – Forma Normal Conjuntiva

LTS – Long Term Support

PS – Soluções possíveis

RAM – Random Access Memory

RGB – Red-green-blue / vermelho-verde-azul

SAT – Satisfabilidades

SBPO – Simpósio Brasileiro de Pesquisa Operacional

%RL – Porcentagem da quantidade de células que foram definidas (pintadas) após as

regras lógicas

Sumário

1 Introdução .......................................................................................................... 19

1.1 Objetivos e Contribuições ......................................................................................... 21

1.2 Organização do trabalho ........................................................................................... 22

1.3 Contribuições ........................................................................................................... 23

2 O Nonograma ..................................................................................................... 24

2.1 História do Nonograma ............................................................................................ 25

2.2 Casos de Teste .......................................................................................................... 26

3 Trabalhos Relacionados ....................................................................................... 28

4 Pré-processamento ............................................................................................. 34

5 Abordagem Exata ............................................................................................... 41

5.1 Regras lógicas ........................................................................................................... 41

5.2 Nonograma como um problema de Satisfação de Restrições ..................................... 46

5.3 Busca em Profundidade ............................................................................................ 48

5.4 Las Vegas Sistemático ............................................................................................... 54

6 Abordagem Heurística ....................................................................................... 58

6.1 Função objetivo ........................................................................................................ 58

6.2 Construção da Solução inicial .................................................................................... 60

6.3 Busca Local............................................................................................................... 61

6.4 Busca Tabu ............................................................................................................... 61

6.5 Memético ................................................................................................................ 64

7 Experimentos Computacionais ........................................................................... 69

7.1 Estudo dos parâmetros ............................................................................................. 69

7.1.1 TabuGrama ................................................................................................................. 69

7.1.2 Memetico1 ................................................................................................................. 75

7.1.3 Memetico2 ................................................................................................................. 82

7.2 Resultados ............................................................................................................... 84

7.2.1 TabuGrama ................................................................................................................. 84

7.2.2 Memetico1 ................................................................................................................. 88

7.2.3 Memetico2 ................................................................................................................. 91

7.3 Comparações ........................................................................................................... 95

8 Conclusão ........................................................................................................... 99

8.2 Trabalhos Futuros .................................................................................................. 100

Referências .......................................................................................................... 102

19

1 Introdução

Os jogos de raciocínio lógico que possuem natureza combinatória têm recebido

uma crescente atenção na Ciência da Computação em virtude do avanço do estado da

arte dos algoritmos para solucionar esses tipos de jogos e o fato de que diversos deles

possuem importantes aplicações práticas. Com o auxílio da ferramenta computacional e

dos recentes meios de mídia novos jogos combinatórios se popularizaram ao longo da

década de 90. Dentre eles encontra-se o Nonograma que consiste em determinar uma

alocação de cores em pixels distribuídos em uma matriz N M atendendo restrições em

linhas e colunas, o qual foi demonstrado ser NP-completo por Ueda e Nagao (1996). O

Nonograma possui aplicações na transmissão de imagens (Sohn et al., 2007) e na

reconstrução de uma imagem discreta a partir de suas projeções, sendo uma

generalização do problema da Tomografia Discreta (Batenburg, 2005).

Segundo Batenburg (2005), o problema da Tomografia Discreta (Discrete

Tomography - DT) consiste na reconstrução de uma imagem discreta a partir de suas

projeções. Um dos problemas principais é a reconstrução de uma imagem binária (preta

e branca) a partir de apenas duas projeções, horizontal e vertical (ver Figura 1). Ryser

(1957) forneceu um algoritmo de tempo polinomial para encontrar uma solução para a

DT. No entanto, no geral um grande número de soluções pode existir. Entre as

aplicações da DT estão a reconstrução da estrutura do cristal a partir de projeções

obtidas por microscopia eletrônica (Kisielowski, et al., 1995); (Schwander, et al., 1993)

e a reconstrução de imagens angiográficas em imagens médicas (Onnasch & Prause,

1999); (Gerbrands & Slump, 1982).

Figura 1 – Imagem binária com suas projeções horizontal e vertical (Fonte: Batenburg, 2005)

Nonogramas (ver Figura 2) podem ser considerados uma generalização do

problema DT. Similar a esse último, o quebra-cabeça é provido de informações sobre a

20

organização horizontal e vertical dos pixels pretos ao longo de cada linha e coluna

(Batenburg, 2005). A partir da descrição do Nonograma, transformando o puzzle em

uma DT, solucionando esse último, uma de suas soluções será a solução do Nonograma.

Figura 2 – Esquerda: Descrição de um Nonograma. Direita: Solução correspondente do Nonograma (Fonte:

Pic-a-Pix)

Segundo Batenburg e Kosters (2009) o Nonograma também pode ser

relacionado a vários problemas job scheduling, onde cada linha corresponde a um único

processador e os trabalhos para os processadores são indicados pelas descrições das

linhas. Em muitos problemas de scheduling, o tipo de restrição que ocorre nos

Nonogramas só é aplicável às linhas ou às colunas, mas geralmente não em ambas.

Com o avanço das imagens em alta definição, torna-se cada dia mais

necessário desenvolver métodos que transmitam imagens de forma otimizada. O fato de

o Nonograma ser um problema NP-Completo indica que nem todos os quebra-cabeças

podem ser resolvidos em um tempo aceitável usando apenas regras lógicas simples ou

abordagens exatas, podendo levar dias ou até anos para se encontrar a solução.

Podem ser considerados diferentes níveis de dificuldade dos Nonogramas. Os

que aparecem em revistas e jornais podem ser resolvidos aplicando uma série de regras

lógicas simples, cada uma das quais considerando apenas uma única linha ou coluna.

Esses quebra-cabeças sempre terão uma única solução. Por outro lado, Nonogramas

grandes e aleatórios podem ser muito difíceis de resolver e podem ter várias soluções ou

nenhuma.

O encaminhamento de solução de jogos de tabuleiros, como o investigado

neste trabalho, através de técnicas algorítmicas tem sido proposto há anos (Laird, 2001);

21

(Herik, Van Den, & Iida, 2000); (Khoo & Zubek, 2002). Por outro lado, o interesse na

aplicação de abordagens heurísticas para resolver quebra-cabeças e jogos tem sido

crescente por diversos motivos, por exemplo, tentar solucionar jogos facilita no

aprendizado de heurísticas atraindo a atenção dos alunos (Vaccaro & Guest, 2005);

(Jefferson, et al., 2006); (Smith, 2007); (Lucas & Kendall, 2006).

Os Nonogramas podem ser lógicos, aqueles que podem ser resolvidos

utilizando apenas regras lógicas, ou aleatórios, aqueles gerados aleatoriamente. No

geral, Nonogramas lógicos são considerados fáceis porque podem ser resolvidos através

de deduções sobre suas restrições. Já os Nonogramas aleatórios podem ser fáceis ou

difíceis dependendo da porcentagem de pixels pretos que os mesmos possuem e seus

tamanhos. De forma geral, o desafio em solucionar Nonogramas está ligado às

restrições do problema. Tais restrições dificultam a elaboração de busca locais eficientes

para o problema.

Em relação a algoritmos para solucionar Nonogramas, existem dois principais

tipos de abordagens que são aplicadas: algoritmos exatos e abordagens metaheurísticas.

As técnicas exatas incluem Programação Linear (Bosh, 2000 e Mingote, 2009), busca

em profundidade (Wiggers, 2004), combinações de regas lógicas (Jing, et al., 2009 e

Yen, et al., 2010), entre outras (Salcedo-Sanz, et al., 2007; Batenburg e Kosters, 2009).

As abordagens heurísticas propostas para o Nonograma incluem Algoritmo Memético

(Batenburg e Kosters, 2004), Genético (Wiggers, 2004), Algoritmos Culturais (Ochoa et

al., 2009), dentre outros. A maioria dos métodos anteriores resolvem Nonogramas

pequenos ou lógicos e não apresentam comparação entre os métodos.

O presente trabalho visa fazer um estudo de algoritmos exatos e heurísticos

para aplicar a Nonogramas lógicos e aleatórios de tamanhos variados. No geral, na

literatura, Nonogramas lógicos são considerados com mais frequência em detrimento

aos Nonogramas aleatórios. Sendo assim, o objetivo deste trabalho é estudar melhor a

eficácia das heurísticas para os casos de testes aleatórios.

1.1 Objetivos e Contribuições

Este trabalho tem os seguintes objetivos:

- Apresentar uma comparação de métodos de solução exata sendo eles: busca

em profundidade, Las Vegas e Programação por restrições. O algoritmo de Busca em

22

Profundidade (DFS – Depth First Search) é um exemplo típico de força bruta de fácil

implementação. Tal abordagem é semelhante à abordagem de Jing et al. (2009). Neste

trabalho, para tentar reduzir o tempo de execução do DFS foi implementado o

Backtracking, Jing et al. (2009) implementaram o Branch Bound. Com o propósito de

testar um algoritmo probabilístico foi implementada uma abordagem Las Vegas. Devido

às restrições de linhas e colunas do Nonograma, foi desenvolvido um modelo de

satisfação de restrições para solucionar o mesmo. Tal resolução é feita através de um

solver, o MiniSat (Eén, 2003).

- Apresentar duas novas abordagens metaheurísticas para o Nonograma

baseadas nas metaheurísticas Busca Tabu e Algoritmo Memético e comparar seus

resultados com outros já apresentados na literatura.

- Fazer um experimento computacional levando em consideração problemas

lógicos e aleatórios com tamanhos que variam de 5 x 5 até 100 x 100, considerados de

grande porte em comparação com os demais apresentados na literatura.

Neste trabalho é analisada uma proposta para o cálculo da função objetivo

apresentada por Maia (2010). Tal função objetivo considera as restrições do problema

de uma forma mais completa que as propostas em trabalhos anteriores. Na literatura, no

geral, o cálculo da função objetivo compara o número de 1’s e 0’s em cada linha e

coluna de uma solução do jogo com o número desejado de 1’s e 0’s. Tal abordagem não

mensura corretamente a distância que uma solução atual do jogo está da solução correta.

1.2 Organização do trabalho

No Capítulo 2 o jogo é apresentado; uma suma da história dos Nonogramas é

explanada e são relatados os casos de teste utilizados no trabalho. No capítulo seguinte é

exposto o estado da arte dos algoritmos propostos para a solução do Nonograma. No

Capítulo 4 é feita uma análise sobre algumas características dos casos de teste. No

capítulo seguinte é feito um estudo sobre as abordagens exatas existentes. Regras

lógicas propostas por Jing et al. (2009) e Yu et al. (2009) foram implementadas e

testadas, e um algoritmo probabilístico, o Las Vegas, é proposto. Também é testado o

algoritmo Busca em Profundidade. No Capítulo 6 são expostas as abordagens

heurísticas propostas para solucionar o Nonograma, a Busca Tabu e duas abordagens

para o Mémetico. É explicado o processo de construção da solução inicial e o método de

23

avaliação das soluções. Posteriormente, no Capítulo 7 são realizados os experimentos

computacionais, expondo o estudo dos parâmetros, os resultados e as comparações entre

as abordagens propostas. Finalmente, no Capítulo 8 conclui-se o trabalho.

1.3 Contribuições

Em 2011 foi publicado no Simpósio Brasileiro de Pesquisa Operacional

(SBPO) uma abordagem da Busca Tabu para solucionar o Nonograma. A abordagem

utiliza os 16 casos de teste classificados como muito difícil retiradas do Benchmark

Puzzles (2011). A busca local realiza o deslizamento de um bloco em uma linha ou

coluna, e a lista tabu é composta por blocos que não deslizam durante cinco iterações. A

abordagem é comparada com a de Ortiz-García et al. (2009), conclui-se que a

abordagem proposta é mais eficiente que a da comparação.

24

2 O Nonograma

O Nonograma é um jogo interessante, que assume a forma de uma grade N x M

com números situados à esquerda das linhas e no topo das colunas. Existem dois tipos

de Nonograma o preto-e-branco (Black and White - B&W) e o colorido. No Nonograma

preto-e-branco os números ao lado das linhas e acima das colunas dão informações

sobre quantas células têm de ser preenchidas na mesma linha ou na mesma coluna,

respectivamente, na ordem em que os números aparecem. Com dois ou mais números os

blocos de células na grade devem ser separados por pelo menos um pixel em branco. A

Figura 3 mostra um exemplo de um Nonograma B&W. Quando todos os requisitos das

linhas e colunas são satisfeitos o Nonograma foi resolvido.

Figura 3 – Exemplo de um Nonograma preto-e-branco e sua solução

Figura 4 – Nonograma Colorido

Nonogramas coloridos seguem regras semelhantes ao quebra-cabeça B&W,

mas levando em conta que os blocos de mesma cor devem ser separados por pelo menos

um pixel em branco e blocos de cor diferente podem ser separados ou não por pixels em

branco. A Figura 4 mostra um exemplo de Nonograma colorido. Na primeira linha

temos [3 1 8 6]. Vemos que o primeiro bloco não precisa ser separado do segundo bloco

25

por pelo menos um pixel branco já que os dois primeiros blocos possuem cores

diferentes. Já os dois últimos blocos precisam ser separados por pelo menos um pixel

em branco. Para aprender como resolver Nonogramas lógicos B&W consulte Dorant

(2005).

2.1 História do Nonograma

Nonogramas são também conhecidos por diversos outros nomes, incluindo

Paint by Numbers, Griddlers, Pic-a-Pix, Picross, PrismaPixels, Pixel Puzzles,

Crucipixel, Edel, FigurePic, Grafilogika, Hanjie, Illust-Logic, Japanese Crosswords,

Japanese Puzzles, Kare Karala!, Logic Art, Logic Square, Logicolor, Logik-Puzzles,

Logimage, Obrazki logiczne, Zakódované obrázky, Maľované krížovky, Oekaki Logic,

Oekaki-Mate, Paint Logic, Shchor Uftor, Gobelini, Picture Logic e Tsunamii. Eles

também são chamados de Paint by Sudoku e Binary Coloring Books, apesar de esses

nomes serem totalmente imprecisos (Wikipedia, 2012).

Em 1987, Non Ishida, um editor gráfico japonês, ganhou uma competição em

Tóquio pelo design de grades de imagens usando luzes de arranha-céus que são ligadas

ou desligadas. Ao mesmo tempo, e sem conexão, um profissional japonês de quebra-

cabeças chamado Tetsuya Nishio inventou o mesmo puzzle. Em 1988, Noh Ishida

publicou três puzzles no Japão sob o nome de “Window Art Puzzles” e Tetsuya Nishio

nomeou seu puzzle de Oekaki Logic, que significa “desenho lógico”. Em 1990, James

Dalgety, no Reino Unido, inventou o nome Nonograma depois que Non Ishida, e The

Sunday Telegraph começou a publicá-lo semanalmente (Conceptis Puzzles, 2012).

Em 1993, Non Ishida publicou o primeiro livro de Nonogramas no Japão e,

mais tarde, o Sunday Telegraph publicou um outro livro no Reino Unido, intitulado The

book of Nonograms. O quebra-cabeça japonês rapidamente se espalhou pelo mundo, e

começou a ser publicado nos Estados Unidos, Suécia, África do Sul, Israel e outros

países. Nos últimos anos, a popularidade desses puzzles tem aumentado bastante.

Existem várias empresas que publicam revistas e páginas da web dedicadas apenas para

os quebra-cabeças japoneses.

Em 1994, Dave Green, que viria a ser fundador e presidente da Conceptis

Puzzles, visita Tóquio, onde conhece esses enigmas de lógica pela primeira vez. Junto

com Igor Lerner, ex-colega e atual CTO da Conceptis Puzzles, o algoritmo de

http://en.wikipedia.org/wiki/Crosswords

http://en.wikipedia.org/wiki/Sudoku

http://en.wikipedia.org/wiki/Binary_code

26

computador foi desenvolvido os primeiros puzzles B&W são produzidos e o nome Pic-

a-Pix é inventado.

Em 1998 The Sunday Telegraph publicou uma competição para escolher o seu

próprio nome para o puzzle. Griddler foi o nome vencedor escolhido pelos leitores do

jornal. No outono de 1999, The Sunday Telegraph publicou o primeiro livro de

Griddler, e tem publicado um por ano desde então.

Os Nonogramas encontrados nas revistas são sempre resolvidos utilizando

lógicas simples. Isto significa que a solução pode ser encontrada com o raciocínio

elementar e sem deduções complexas. Em implementações posteriores serão utilizados

casos de teste que não são resolvidos apenas com raciocínio lógico elementar. O

Nonograma foi demonstrado ser NP-completo por Ueda e Nagao (1996). O fato de

solucionar Nonogramas ser NP-completo indica que nem todos os puzzles podem ser

resolvidos usando simples regras lógicas.

2.2 Casos de Teste

Foram utilizados 16 casos de teste classificados como muito difíceis retirados

do Benchmark Puzzles (2012). Nesse site há cerca de 200 quebra-cabeças classificados

com estrelas de 1 a 9, as com 9 estrelas indicam os jogos mais difíceis. Neste trabalho é

utilizado apenas os Nonogramas com 8 e 9 estrelas. Todos os casos de teste desse site

possuem tamanho 10 x 10. Cada caso de teste retirado do Benchmark Puzzles (2012)

possui apenas uma solução. Esses casos de teste foram utilizados por Ortiz García et al.

(2008) e por Goldbarg et al. (2011).

Cento e oitenta (180) casos de teste foram gerados aleatoriamente

utilizando o gerador RandPuz de Batenburg e Kosters (2009), com { }.

Para cada tamanho de foram gerados 10 casos de teste cada um com diferentes

tamanhos de , com { }, sendo a porcentagem de pixels

pretos. Batenburg e Kosters (2009) mostram resultados para puzzles de tamanho 30 x 30

em que entre 10 e 50 por cento de pixels pretos esses se tornam mais difíceis de resolver

através da abordagem proposta pelos mesmos. Para os casos de teste gerados

aleatoriamente pode-se afirmar que o puzzle tenha ao menos uma solução, mas não se

sabe quantas soluções esse puzzle possui. O nome dos casos de teste aleatórios seguem

o seguinte formato: < >p< >R< >, onde < > é o tamanho do puzzle, < > o percentual

27

de pixels pretos do mesmo e < > o número do caso de teste. Como por exemplo:

10p10R0.

Também são utilizados outros oito casos de teste retirados de jogos para

dispositivos móveis com o intuito de testar o MiniSat (Eén, 2003). Esses 8 casos de

teste são lógicos, resolvidos utilizando apenas regras lógicas e possuem os seguintes

tamanhos: 5 x 5, 6 x 5, 6 x 6, 7 x 5, 8 x 4 e 9 x 6.

Três sites de Nonogramas lógicos são bastante utilizados pelos artigos descritos

no Capítulo 3, Benchmark Puzzles (2012), o Nonogram Solver (2012) e o Hattori

(2012). Trinta casos de teste foram retirados do site Nonogram Solver (2012). O

tamanho dos mesmos variam de 8 x 8 a 100 x 100. Nesse site, usuários podem colocar

seus puzzles, podendo ser lógicos ou aleatórios, e que possuam ao menos uma solução.

No geral, os puzzles do Nonogram Solver (2012) são lógicos e possuem apenas uma

solução. Em suma, serão considerados 234 casos de teste.

28

3 Trabalhos Relacionados

O problema da formação de imagens, a partir de informações sobre seus pixels,

está recebendo intensa atenção, especialmente em anos recentes. Além de constituir em

um desafio lógico, pode implicar na redução da informação necessária à transmissão

dos dados de uma figura. Um dos primeiros trabalhos publicados para a solução desse

problema deve-se a Bosch (2000) que apresentou uma abordagem por Programação

Linear.

Wiggers (2004) propôs um algoritmo genético e compara seu desempenho ao

de um algoritmo de busca em profundidade (depth first search – DFS). O algoritmo

genético proposto emprega uma população de 100 cromossomos, operando com uma

taxa de mutação igual a 5% e uma taxa de crossover igual a 60% e utiliza o método da

roleta para realizar a seleção para a reprodução. O operador de mutação do algoritmo é

simples e apenas altera o valor de um gene (um posição aleatória) em um cromossomo.

A função objetivo é calculada da mesma forma que é feito para um problema de

satisfabilidade (SAT) conforme apresentado por Jong e Spears (1989). No trabalho, o

desempenho dos algoritmos é definido a partir do número de avaliações necessárias para

resolver o problema. Os algoritmos são comparados usando cinco tamanhos sucessivos

do jogo: grades 5 x 5 a 10 x 10. Para tamanhos pequenos do jogo (5 x 5 e 6 x 6) o

algoritmo DFS encontra o resultado em um menor número de avaliações. Para tamanhos

maiores o algoritmo genético encontra o resultado com menos avaliações do que o DFS.

Batenburg e Kosters (2004) desenvolveram um algoritmo memético que

executa, após cada operação de recombinação ou mutação, uma busca hill-climbing até

que a solução atinja um ótimo local. A função de avalição de uma imagem pode ser

obtida pela soma dos desvios de todas as linhas e colunas. O tamanho da população foi

definido igual a 1000 indivíduos, o número de filhos que são criados a cada geração é

fixo e igual a 500. Os autores relatam que o algoritmo resolve um jogo 25 x 25 em 80

minutos e um 30 x 30 em 12 horas em um Pentium IV com 2.4 GHz. Um outro jogo 25

x 25 não foi resolvido, pois o algoritmo converge a um ótimo local.

Benton et al. (2005) tentam solucionar duas perguntas sobre o Nonograma:

Quantas formas possíveis podemos preencher um puzzle com entradas

consistindo apenas de 0 ou 1? Existe um método que encontre todas as possíveis

29

formas? No trabalho os autores fornecem um método para responder ambas as

perguntas.

Sohn et al. (2007) propuseram um método de reconhecimento do alfabeto

impresso utilizando o Nonograma. Um documento é copiado por uma câmera CCD

(charge-coupled device) e convertido em uma imagem preta e branca. Os caracteres são

extraídos da imagem através do método histograma e são normalizados com um

tamanho fixo. Aplica-se o puzzle ao caractere normalizado e assim a imagem é

traduzida em uma informação numérica. Feito isso, o caractere é reconhecido

aplicando-se a informação numérica desse ao modelo padrão. Por fim, o caractere

reconhecido é exportado para um processador de texto editável.

Salcedo-Sanz et al. (2007a) aplicaram na solução do jogo algoritmos

evolucionários com aprendizado. O trabalho emprega uma função objetivo para avaliar

a configuração corrente do jogo que compara o número de 1’s e 0’s em cada linha e

coluna de uma solução do jogo com o número desejado de 1’s e 0’s. Os autores

descrevem três diferentes abordagens de solução com a taxa de crossover e a

taxa de mutação em todas as abordagens. Na primeira, um algoritmo

genético canônico é apresentado, e esse não é capaz de resolver o problema. Na segunda

abordagem, operadores especiais de recombinação são sugeridos. A solução inicial é

criada a partir da localização dos blocos dentro dos limites possíveis dos mesmos – mais

à esquerda e mais à direita possível, respeitando apenas a viabilidade das colunas. Feito

isso, o operador de recombinação troca alelos (que são colunas do tabuleiro de jogo)

entre os pais. Segundo o relato do experimento, essa abordagem consegue viabilizar

quase todas as alocações de blocos, todavia não consegue fazê-lo para todo o tabuleiro.

A última abordagem é a segunda abordagem acrescida de uma busca local (Hill

Climbing), de modo que essa melhoria no algoritmo consegue fazer com que a solução

do jogo seja encontrada. Os autores definem que o número máximo de avaliações

executadas pelos algoritmos evolucionários fosse fixado em 50.000 – a população em

100 indivíduos e a execução terminada após 500 gerações.

Salcedo-Sanz et al. (2007b) implementaram duas abordagem heurísticas ad-

hoc para o Nonograma, uma combinatória e outra lógica. A primeira, Combinatorial

Ad-hoc heuristic, baseia-se em tentar possíveis combinações de soluções em cada linha

e coluna do jogo. A segunda, Logic ad-hoc heuristic, baseia-se em aspectos lógicos do

30

jogo e pode ser estendida para solucionar puzzles coloridos, sendo composta por cinco

sub-procedimentos lógicos que visam completar o jogo. Ambas as heurísticas iniciam o

algoritmo com um procedimento de pré-processamento que implementa três sub-

procedimentos lógicos que visam preencher alguns quadrados. Os autores utilizam

como casos testes os exemplos dos Nonogramas B&W e colorido do site Conceptis

Puzzle. São solucionados 20 quebra-cabeças (dos quais 12 são B&W), sendo o menor

15 × 15 e o maior 60 × 145. Eles compararam as duas heurísticas propostas com o

algoritmo apresentado por Salcedo-Sanz et al. (2007a) e com o algoritmo de solução do

site Conceptis Puzzle, chegando à conclusão de que a abordagem Logic ad-hoc heuristic

mostra-se superior às demais.

Ortiz-García et al. (2007) propuseram um gerador automático de Nonogramas

lógicos, que podem ser resolvidos por pessoas, B&W e coloridos a partir de qualquer

imagem digital de cores RGB (red – green – blue / vermelho – verde – azul).

Apresentaram também uma interface de visualização que fornece várias ferramentas

úteis para a finalização do processo de geração do quebra-cabeça, como a possibilidade

de mudar as cores e exibir o processo de solução do puzzle.

Ortiz-García et al. (2008) implementaram um algoritmo híbrido evolucionário-

lógico para resolver qualquer tipo de Nonograma japonês preto-e-branco, incluindo

aqueles classificados como muito difíceis. Eles propuseram o cálculo de uma

probabilidade a priori para um pixel ser colorido (pintado com a cor preta) ou não.

Essas probabilidades são utilizadas para inicialização da população de cromossomos e

em um operador de mutação especial. A seleção dos indivíduos é feita através do

método da roleta. O operador de recombinação adotado é o de dois pontos. Há um

operador de mutação swap que desliza os blocos pintados e um segundo operador de

mutação denominado diversity guided mutation. O algoritmo é aparelhado também com

uma busca local que aplica as regras lógicas definidas em Salcedo-Sanz et al. (2007a),

buscando viabilizar a alocação dos blocos no tabuleiro. Aplicou-se o algoritmo a todos

os puzzles com 8 e 9 estrelas retirados do Benchmark Puzzles (2012), no qual todos

possuem o tamanho 10 x 10. O algoritmo resolveu o quebra-cabeça em 100% das 50

execuções para doze casos de teste, e outros quatro com uma porcentagem acima de

94% e comparou seus resultados com Salcedo-Sanz et al. (2007a).

Ortiz-García et al. (2009) apresentaram uma heurística baseada no mesmo

31

trabalho (Ortiz-García et al. 2008) e aplicaram essa heurística na solução tanto do

Nonograma quanto do Light-up puzzle. Os autores aplicam sua abordagem a 16 casos

teste, tabuleiros 10 x 10, classificados como difíceis. A comparação foi feita com o

algoritmo de Salcedo-Sanz (2007b) e eles mostraram que a abordagem proposta é mais

eficiente do que a de comparação.

Mingote (2009) apresenta uma abordagem de Programação Linear Inteira para

Nonogramas B&W e coloridos. O autor generaliza a aproximação de Bosh (2000)

desenvolvida apenas para Nonogramas B&W. Foi desenvolvido um gerador de

Nonogramas que permite definir a resolução do puzzle, o seu número de cores e

densidade (número de células pintadas versus resolução).

Batenburg e Kosters (2009) inicialmente consideraram duas relaxações para o

Nonograma que podem ser solucionadas em tempo polinomial. Tais relaxações podem

preencher o puzzle parcialmente. O puzzle resultado das relaxações é combinado a um

problema 2-Satisfabilidade (2-SAT), no qual se pode deduzir as cores de alguns pixels.

Esse processo (relaxações e 2-SAT) é repetido iterativamente possibilitando resolver

completamente ou parcialmente o quebra-cabeça. Nos casos em que os puzzles são

resolvidos parcialmente significa que o mesmo possui diferentes soluções. Os autores

testaram o algoritmo proposto em três bancos de casos de teste; imagens randômicas,

imagens hv-convex e puzzles pequenos (5x5).

Jing et al. (2009) propuseram um método para a resolução do jogo em duas

fases. Na primeira fase onze regras lógicas são deduzidas e utilizadas para fixar alguns

quadrados como pretos ou brancos. Na segunda fase o algoritmo DFS é aplicado para

resolver os quadrados desconhecidos remanescentes, implementado conjuntamente com

uma estratégia branch and bound para melhorar o tempo de processamento.

Ochoa et al. (2009) implementaram uma abordagem multiobjetivo através de

um algoritmo cultural para resolver o Nonograma. O algoritmo cultural implementado

emprega uma busca local hill-climbing. Os autores apresentaram uma solução para um

caso teste 20×20 que levou 80 minutos para ser obtida em um Pentium IV com 2.4GHz.

Yu et al. (2009) apresentaram um algoritmo eficiente para solucionar

Nonogramas lógicos em duas fases. Baseado no fato de que a maioria dos puzzles são

contíguos e compactos, onze regras lógicas foram deduzidas com o objetivo de pintar

32

algumas células, posteriormente foi utilizado um algoritmo backtracking cronológico

para determinar a cor das células remanescentes. Segundo os autores tal abordagem

mostrou-se superior às duas abordagens de Wiggers (2004).

Yen et al. (2010) apresentaram uma abordagem com duas fases para solucionar

Nonogramas lógicos. Na primeira fase é construído um banco de dados com possíveis

combinações para cada linha, na segunda é feita uma interseção dessas combinações do

banco. A abordagem mostrou-se superior às propostas de Jing et al. (2009) e Yu et al.

(2009).

Tsai e Chou (2011) propuseram um algoritmo genético para solucionar os

Nonogramas. Uma codificação condensada foi utilizada para representar uma solução

do puzzle, onde exibe os pixels brancos reais e os pixels pretos condensados em uma

linha, mantendo a viabilidade nas linhas. A população inicial é gerada utilizando a

codificação condensada. O cruzamento troca linhas entre os pais, e a mutação desloca

um pixel preto em uma linha. O algoritmo genético proposto foi testado em dois puzzles

15 x 15, e solucionou os mesmos.

Tsai et al. (2012) utilizaram os Nonogramas para ensinar algoritmos

evolucionários. Um algoritmo genético inteligente (IGA) é proposto e comparado a um

algoritmo genético canônico (CGA), demostrando que o IGA pode encontrar a solução

correta do puzzle eficientemente, enquanto o CGA não pode. O objetivo da proposta é

fazer os estudantes perceberem que estão trabalhando com um método baseado em

algoritmos genéticos e um problema de otimização combinatória. A abordagem IGA

utiliza uma codificação condensada eficaz para representar uma solução do puzzle. No

artigo foi feita uma comparação entre as duas abordagem utilizando um puzzle 15 x 15

(“Bear”).

Tsai (2012) propôs um algoritmo genético baseado no método taguchi (TBGA)

para solucionar o Nonograma. O autor comparou o TBGA a um algoritmo genético

canônico, mostrando que a primeira abordagem é superior a segunda. As abordagens

propostas utilizam uma codificação condensada eficaz para representar uma solução do

puzzle. O tamanho da população foi definida igual a 100 indivíduos, os pais são

selecionados pelo método da roleta, a taxa de cruzamento é igual a 0,9 e a taxa de

mutação igual a 0,05 para ambas as abordagens (TBGA e algoritmo genético). Tal

codificação binária também é utilizada para gerar a população inicial aleatoriamente.

33

Foram realizados testes com três puzzles de tamanho 15 x 15. O algoritmo genético não

solucionou nenhum desses três puzzles, já o TBGA solucionou-os em menos de 30

segundos.

34

4 Pré-processamento

Todos os experimentos foram realizados em uma máquina com processador

Intel Core i7-2600K 3,40 GHz e 4Gb de RAM. A codificação foi feita utilizando a

linguagem C++ e sistema operacional Ubuntu 12.04.01 LTS.

Mensurar a dificuldade de um Nonograma não é um problema trivial, porém

alguns fatores podem indicar a dificuldade dos mesmos, como por exemplo: tamanho do

puzzle; quantidade de pixels pretos; porcentagem de pixels decididos no puzzle após a

aplicação de regras lógicas e quantidade de possibilidades de alocação dos blocos para

cada linha (ou coluna) do quebra-cabeça.

São denominados de blocos os números situados à esquerda das linhas e no

topo das colunas de um puzzle, ver Figura 5 (a). Considerando uma linha, é possível

calcular os limites mais a esquerda e mais a direita de alocação desse bloco (Salcedo-

Sanz et al., 2007a).

Os limites ( ) para cada bloco , onde define a posição mais a

esquerda e a posição mais a direita do bloco preto j de uma linha qualquer. Isto

significa que o bloco j apenas pode ser alocado entre o intercalo . Esses limites

para os blocos das linhas são inicialmente obtidos da seguinte forma:

(1)

∑ ( ) (2)

( ) ∑ ( ) (3)

(4)

Onde, é o tamanho do bloco , a quantidade de blocos pretos para uma

determinada coluna e a quantidade de colunas. O mesmo raciocínio é utilizado para

calcular os limites dos blocos das colunas.

O limite mais a esquerda do primeiro bloco (j = 1) de uma linha é dado pela

equação 1, para os demais blocos é dado pela equação 2. O limite mais a direita do

último bloco (j = d) de uma linha é dado pela equação 4, para os demais é dado pela

equação 3.

A partir dos limites de alocação dos blocos, é possível gerar todas as alocações

35

possíveis desses blocos para cada linha (ou coluna), que são mostradas na Figura 5 (b, c,

d, e). Gerar todas as alocações possíveis dos blocos para as linhas e colunas pode ser

útil para as abordagens exatas e heurísticas. O número total destas alocações para cada

linha (ou coluna), no geral é bem alto. Nos gráficos 1 a 10 são exibidas as quantidades

de alocações possíveis de blocos para as linhas e colunas e os tempos computacional

utilizados para gerá-las, para os casos de teste do Benckmarck Puzzles (2012).

Figura 5 – (a) Dado um puzzle. (b) Três alocações possíveis de blocos para a linha 1. (c) Duas alocações

possíveis de blocos para a linha 2. (d) Duas alocações possíveis de blocos para a linha 3. (e) Uma alocação de

bloco para a linha 4.

No exemplo da Figura 5 observa-se que para um puzzle de tamanho 4 x 6

existem 12 (3 x 2 x 2 x 1) combinações de alocações possíveis dos blocos considerando

as linhas. Antes de gerar as alocações possíveis dos blocos são aplicadas as regras

lógicas de Jing et al. (2009) visando reduzir os limites de alocação. Vale salientar que o

tempo gasto para aplicar as mesmas foram desprezíveis (ver Seção 5.1).

O Gráfico 1 mostra a quantidade de combinações possíveis para linhas e

colunas nos casos de teste do Benchmark Puzzles (2012) após a aplicação das regras

lógicas. O Gráfico 2 mostra o tempo gasto em segundos para gerar todas essas

alocações possíveis de blocos para cada linha e coluna da grade.

36

Gráfico 1– Quantidade de combinações possíveis para os casos de teste do Benchmark Puzzle (2012).

Gráfico 2 – Tempo em segundos para gerar todas as alocações possíveis de blocos para cada linha e coluna dos

casos de teste do Benchmark Puzzles (2012)

Como os casos de teste do Benchmark Puzzles (2012) são pequenos (10 x 10)

gerar todas as alocações possíveis de blocos para cada linha e coluna não consome

muito tempo. Verifica-se que o maior tempo foi na ordem de 10-4

segundos.

Dos trinta casos de teste retiradas do site Nonogram Solver (2012), quinze

foram totalmente resolvidos apenas utilizando-se as regras lógicas. Os resultados das

quantidades de combinações possíveis para cada linha e coluna dos outros quinze são

mostrados no Gráfico 3, o tempo gasto em segundos para gerar essas soluções possíveis

é mostrado no Gráfico 4. Os Gráficos 3 e 4 utilizam a escala logarítmica

0,00E+00

2,00E+18

4,00E+18

6,00E+18

8,00E+18

1,00E+19

1,20E+19

1,40E+19

1,60E+19

Inst

_2

22

Inst

_2

23

Inst

_2

24

Inst

_2

25

Inst

_2

26

Inst

_2

27

Inst

_2

28

Inst

_2

29

Inst

_2

30

Inst

_2

31

Inst

_2

32

Inst

_2

33

Inst

_2

34

Inst

_2

35

Inst

_2

36

Inst

_2

37

Nú

me

ro d

e P

oss

ibili

dad

es

Casos de teste

Possibilidades linhas

Possibilidades Colunas

0

0,00005

0,0001

0,00015

0,0002

0,00025

0,0003

0,00035

0,0004

0,00045

0,0005

Tem

po

em

se

gun

do

s

Casos de teste

37

Gráfico 3 – Quantidade de combinações possíveis para os casos de teste do Nonogram Solver (2012).

Gráfico 4 – Tempo em segundos para gerar as alocações possíveis de blocos para cada linha e coluna dos casos

de teste do Nonogram Solver (2012).

Nos casos de teste do Nonogram Solver (2012), como possui puzzles maiores,

percebe-se que o tempo para gerar as alocações possíveis de blocos para cada linha e

coluna pode ser elevado. Por exemplo, o caso de teste Lancs_19 (33 x 33) gastou

aproximadamente 18 segundos para gerar todas as alocações possíveis de blocos para

cada linha e coluna.

Os gráficos 5, 7 e 9 exibem as quantidades de combinações possíveis para os

casos de teste aleatórios do RanPuz com tamanhos iguais a 10 x 10, 20 x 20 e 30 x 30

respectivamente, e os gráficos 6, 8 e 10 mostram o tempo gasto para gerar essas

alocações possíveis de blocos. Para os casos de teste com sessenta por cento de pixels

1,00E+001,00E+121,00E+241,00E+361,00E+481,00E+601,00E+721,00E+841,00E+96

1,00E+1081,00E+1201,00E+132

PossibilidadesLinhas

PossibilidadesColunas

0,0001

0,001

0,01

0,1

1

10

100

Tem

po

em

Se

gun

do

s

Casos de Teste

38

pretos, a aplicação das regras lógicas resolve mais de noventa e nove por cento dos

pixels desses puzzles.

Os casos de teste do RanPuz com tamanho 10 x 10 e sessenta por cento de

pixels pretos foram todos resolvidos através das regras lógicas. De acordo com o

Gráfico 5 as quantidades de combinações para os casos de teste com tamanho 10 x 10

são inferiores a combinações, um valor considerado baixo. Já de acordo com o

Gráfico 6 observa-se que os tempos para gerar as alocações possíveis de blocos para as

linhas e colunas são inferiores a segundos.

Gráfico 5 – Quantidade de combinações para os casos de teste 10 x 10 do RanPuz


de teste do RanPuz com tamanho 10 x 10

A partir do Gráfico 7 analisam-se que os casos de testes com tamanho 20 x 20

1

100

10000

1000000

100000000

1E+10

1E+12

1E+14

1E+16

10

p1

0R

0

10

p1

0R

3

10

p1

0R

6

10

p1

0R

9

10

p2

0R

2

10

p2

0R

5

10

p2

0R

8

10

p3

0R

1

10

p3

0R

4

10

p3

0R

7

10

p4

0R

0

10

p4

0R

3

10

p4

0R

6

10

p4

0R

9

10

p5

0R

2

10

p5

0R

5

10

p5

0R

8

10

p6

0R

1

10

p6

0R

4

10

p6

0R

7

Nú

me

ro d

e P

oss

ibili

dad

es

Casos de teste

PossibilidadesLinhasPossibilidadesColunas

0

0,0002

0,0004

0,0006

0,0008

0,001

0,0012

Tem

po

em

se

gun

do

s

Casos de teste

39

e entre 20 a 40 por cento de pixels pretos possuem mais combinações, tornando-os mais

difíceis. Os tempos para gerar as alocações possíveis de blocos para esses casos de teste

são inferiores a 0,5 segundos.



de teste do RanPuz com tamanho 20 x 20

Verifica-se que para os casos de teste com tamanho 30 x 30 o tempo gasto para

gerar as alocações possíveis de blocos é alto (Gráfico 10), devido à quantidade de

combinações elevada (Gráfico 9). É importante ressaltar que gerar todas as alocações

possíveis de blocos torna-se indesejável com o aumente do tamanho do puzzle.

1,00E+001,00E+061,00E+121,00E+181,00E+241,00E+301,00E+361,00E+421,00E+481,00E+541,00E+60

20

p1

0R

0

20

p1

0R

3

20

p1

0R

6

20

p1

0R

9

20

p2

0R

2

20

p2

0R

5

20

p2

0R

8

20

p3

0R

1

20

p3

0R

4

20

p3

0R

7

20

p4

0R

0

20

p4

0R

3

20

p4

0R

6

20

p4

0R

9

20

p5

0R

2

20

p5

0R

5

20

p5

0R

8

20

p6

0R

1

20

p6

0R

4

20

p6

0R

7

Nú

me

rp d

e P

oss

ibili

dad

es

Casos de teste

PossibilidadesLinhas

PossibilidadesColunas

0

0,005

0,01

0,015

0,02

0,025

0,03

0,035

0,04

0,045

20

p1

0R

0

20

p1

0R

3

20

p1

0R

6

20

p1

0R

9

20

p2

0R

2

20

p2

0R

5

20

p2

0R

8

20

p3

0R

1

20

p3

0R

4

20

p3

0R

7

20

p4

0R

0

20

p4

0R

3

20

p4

0R

6

20

p4

0R

9

20

p5

0R

2

20

p5

0R

5

20

p5

0R

8

20

p6

0R

1

20

p6

0R

4

20

p6

0R

7

Tem

po

em

se

gun

do

s

Casos de teste

40


Gráfico 10 – Tempo em segundos para gerar as alocações possíveis de blocos para cada linha e coluna dos

casos de teste do RanPuz com tamanho 30 x 30.

De acordo com os gráficos observa-se que com o aumento do tamanho do

puzzle, aumenta-se a quantidade de combinações para as linhas ou colunas. Também é

possível inferir que os casos de teste com porcentagens de pixels pretos entre 20 e 40

por cento possuem mais combinações. Sabe-se que quanto maior o número de

combinações maior é a dificuldade de solucionar o puzzle.

1,00E+001,00E+131,00E+261,00E+391,00E+521,00E+651,00E+781,00E+91

1,00E+1041,00E+1171,00E+1301,00E+143

30

p1

0R

03

0p

10

R3

30

p1

0R

63

0p

10

R9

30

p2

0R

23

0p

20

R5

30

p2

0R

83

0p

30

R1

30

p3

0R

43

0p

30

R7

30

p4

0R

03

0p

40

R3

30

p4

0R

63

0p

40

R9

30

p5

0R

23

0p

50

R5

30

p5

0R

83

0p

60

R1

30

p6

0R

43

0p

60

R7

Nú

me

ro d

e P

oss

ibili

dad

es

Casos de Teste

PossibilidadesLinhasPossibilidadesColunas

0

0,5

1

1,5

2

2,5

3

3,5

4

4,5

5

Tem

po

em

se

gun

do

s

Casos de Teste

41

5 Abordagem Exata

Algumas abordagens exatas, como visto no Capítulo 3, foram propostas para

solucionar o Nonograma. Porém, por ser um problema NP-Completo (Ueda e Nagao,

1996) haverá grades cuja solução via métodos exatos poderá levar horas ou até anos.

Por isso, a abordagem heurística é justificada. Jing et al. (2009) e Yu et al. (2009)

propuseram uma abordagem exata para resolver Nonogramas B&W lógicos, abordagem

essa que consiste na implementação de onze regras lógicas e posteriormente é realizada

uma busca em profundidade com cortes na abordagem de Jing et al. (2009) e um

backtracking cronológico na abordagem de Yu et al. (2009). Neste trabalho, essas onze

regras lógicas foram implementadas e testadas em todos dos casos de teste. Tais regras

lógicas poderão resolver parcialmente o puzzle e reduzir o espaço de busca da

heurística.

5.1 Regras lógicas

As onze regras lógicas de Jing et al. (2009) e Yu et al. (2009) são baseadas nos

limites, mais a direita e mais a esquerda, dos blocos. Essas regras podem ser divididas

em três partes. A primeira determina quais pixels devem ser coloridos ou deixados em

branco, a segunda parte refina os limites dos blocos e a terceira além de refinar os

limites dos blocos também define quais pixels devem ser deixados em branco ou

coloridos. Cada regras é aplicada a cada linha e coluna, todas as regras são aplicadas

sequencialmente e iterativamente. No início todas os pixels são considerados

desconhecidos. A Tabela 1 mostra resumidamente as regras lógicas de Jing et al. (2009)

e Yu et al. (2009).

As regras lógicas implementadas utilizam as ideias de limites ( ) para

cada bloco , demostrado no Capítulo 4.

Tabela 1 – Resumo das onze regras lógicas de Jing et al. (2009) e Yu et al. (2009)

Regras da Primeira Parte

Todas as regras desta parte são usadas para pintar ou deixar em branco um determinado pixel.

Regra 1.1 Para cada intervalo de um bloco, alguns pixels devem ser pintados (preto) se todas as

possíveis soluções desse bloco tem interseções.

Regra 1.2 Quando um pixel não pertence ao intervalo de qualquer bloco, o mesmo deve ser deixado

vazio(branco).

Regra 1.3 Para cada bloco , quando o primeiro pixel do seu limite é pintado, iremos verificar se

esse pixel é coberto por outros blocos. Se o comprimento de todos os blocos que cobrem

42

esse pixel é 1, o pixel anterior deve ser deixado em branco. Da mesma forma, quando

o último pixel do limite de um bloco é pintado, iremos verificar se esse pixel é coberto

por outros blocos. Se o tamanho de todos os blocos que cobrem esse pixel é 1, o pixel

posterior deve ser branco.

Regra 1.4 Pode haver alguns segmentos pretos em uma linha (ou coluna). Se dois segmentos pretos

consecutivos com um pixel desconhecido entre eles, são combinados formando um novo

segmento com tamanho maior do que o tamanho do maior bloco que cobre esse novo

segmento, então esse pixel deverá ser branco.

Regra 1.5 Alguns pixels brancos podem obstruir a expansão de alguns segmentos pretos. Podemos

usar esta propriedade para colorir mais pixels. Por outro lado, para um segmento preto

coberto por limites de blocos nos quais tem o mesmo tamanho, se o tamanho do segmento

for igual ao comprimento dos blocos que o cobrem, os dois pixels das extremidades desse

segmento deve ser deixado em branco.

Regras da Segunda Parte

As regras desta parte são designadas a refinar os limites dos blocos

Regra 2.1 Para dois blocos consecutivos e , o ponto inicial (final) do bloco deve estar na

frente do ponto inicial (final) do bloco .

Regra 2.2 Deve haver ao menos um pixel branco entre dois blocos, então podemos atualizar os limites

do bloco se o pixel ou é preto.

Regra 2.3 Nos limites de um bloco pode haver um ou mais segmentos pretos. Alguns segmentos

pretos podem ter tamanhos maiores do que o tamanho do bloco , e outros não. Para cada

segmento com o tamanho maior do que o bloco , se pudermos determinar que esse

segmento pertence a um bloco anterior ou posterior ao bloco , podemos atualizar os limites

do bloco . Regras da Terceira Parte

O propósito das regras desta parte não é apenas determinas quais pixels devem ser coloridos ou deixados

em branco, mas também refinar os limites de alguns blocos.

Regra 3.1 Quando diversos pixels pretos que pertencem ao mesmo limite de um bloco estão

espalhados, todos os pixels desconhecidos entre eles devem ser preenchidos para forma um

novo segmento, e os limites desse bloco pode ser atualizado.

Regra 3.2 Alguns pixels brancos podem estar espalhados dentro dos limites de um bloco , então

haverá alguns segmentos limitados por esses pixels em branco. O tamanho desses

segmentos pode ser menos do que o tamanho do bloco , esses segmentos podem ser

pulados, e os limites do bloco pode ser atualizado.

Regra 3.3 Esta regra foi desenvolvida para resolver situações onde o intervalo do bloco não sobrepõe

o intervalo do bloco e .

As regras abaixas serão explicadas para a situação em que o intervalo do bloco não

sobrepõe o intervalo do bloco .

Regra 3.3-1 Caso 1: O pixel é preto.

Como o intervalo do bloco não sobrepõe o intervalo do bloco ,

quando primeiro pixel do limite do bloco é preto, podemos terminar de

preencher o bloco.

Regra 3.3-2 Caso 2: Um pixel branco aparece depois de um pixel preto .

Então os pixels antes de não pertence ao limite do bloco , e os limites

desse bloco devem ser atualizados.

Regra 3.3-3 Caso 3: Há mais de um segmento preto dentro dos limites do bloco . Dentro dos limites ( ) encontre o primeiro e o segundo segmento

preto. Se o tamanho do novo segmento, após junta-los, for maior do que o

bloco , então esses dois segmentos não podem pertencer ao mesmo limite.

Se o intervalo do bloco não sobrepõe o intervalo do bloco , podemos tratar esta

situação de forma similar (Regras 3.3-1 a 3.3-3).

Os resultados da implementação destas onze regras lógicas são mostrados nas

Tabelas 2 a 6. Na Tabela 2 são mostradas as porcentagens da quantidade de células

(%RL) que foram definidas após as regras lógicas para os casos de teste retirados do

43

Benchmark Puzzles (2012). Sabe-se que todos esses casos de teste possuem o tamanho

10 x 10, e o tempo de execução das regras lógicas para os mesmos foi menor que

segundos.

Tabela 2 – Resultados da aplicação das regras lógicas para os casos de teste do Benchmark Puzzles (2012)

Casos de teste %RL Casos de teste %RL Casos de teste %RL Casos de teste %RL

222 6 226 7 230 11 234 6

223 1 227 11 231 6 235 3

224 15 228 2 232 2 236 3

225 0 229 14 233 5 237 0

A partir da Tabela 2 percebe-se que poucos pixels são decididos aplicando as

regras lógicas, devido à aleatoriedade dos puzzles em questão.

Na Tabela 3 são mostrados os resultados para os casos de teste retirados do site

Nonogram Solver (2012). A segunda coluna contém o tamanho do puzzle ( ), a

terceira mostra a porcentagem do puzzle (%RL) que foi resolvido utilizando-se as regras

lógicas, a quarta mostra o tempo gasto para executar as regras lógicas em segundos.

Para os casos de teste da Tabela 3 percebe-se que em alguns casos mais pixels

são resolvidos utilizando as regras lógicas. Dos 30 casos de teste 15 são totalmente

resolvidos apenas utilizando as regras lógicas, devido ao caráter lógico de tais puzzles.

Outros três são resolvidos mais de 90% do puzzle, o que significa que tais quebra-

cabeças possuem mais de uma solução.

Tabela 3 – Resultados da aplicação das regras lógicas para os casos de teste do site Nonogram Solver (2012)

Caso de teste Tamanho %RL Tempo (s) Caso de teste Tamanho %RL Tempo (s)

Lancs_1 100 x 75 100 0,07 Lancs_16 30 x 30 99 0,02

Lancs_2 15 x 15 100 0,001 Lancs_17 30 x 30 100 0,02

Lancs_3 15 x 15 20,9 0,0003 Lancs_18 35 x 50 91 0,02

Lancs_4 15 x 13 100 0,0006 Lancs_19 33 x 33 16 0,009

Lancs_5 20 x 20 100 0,004 Lancs_20 30 x 22 5 0,0004

Lancs_6 15 x 15 17 0,0001 Lancs_21 35 x 50 86,6 0,03

Lancs_7 15 x 15 7 0,0001 Lancs_22 40 x 50 100 0,09

Lancs_8 15 x 20 95 0,0002 Lancs_23 30 x 35 100 0,1

Lancs_9 20 x 20 100 0,002 Lancs_24 75 x 100 100 0,1

Lancs_10 25 x 25 100 0,001 Lancs_25 8 x 8 87 0,0003

Lancs_11 20 x 20 100 0,0005 Lancs_26 35 x 25 52 0,002

Lancs_12 25 x 35 100 0,005 Lancs_27 20 x 25 11 0,0007

Lancs_13 35 x 25 100 0,004 Lancs_28 15 x 15 17 0,0002

Lancs_14 25 x 25 12 0,0006 Lancs_29 35 x 45 100 0,06

Lancs_15 18 x 21 27 0,0006 Lancs_30 100 x 100 100 0,2

Os resultados para os casos de teste aleatórios do RandPuz são mostrados nas

Tabelas 4 a 6. A primeira coluna exibe o nome do caso de teste, a segunda a

44

porcentagem de pixels (%RL) decididos após a aplicação das regras lógica e a terceira o

tempo gasto para executar as regras em segundos. Novamente, o tempo gasto para

executar as regras lógicas é insignificante. Na Tabela 4 todos os casos de testes possuem

o tamanho 10 x 10 e as porcentagens de pixels pretos varia de 10 a 60 por cento. De

acordo com os dados da Tabela 4 percebe-se que casos de teste com porcentagens de

pixels pretos iguais ou acima de 50 por cento são resolvidos através das regras lógicas,

tornando esses puzzles mais fáceis. Convém observar que os casos de teste mais difíceis

são os com 30 por cento de pixels pretos.

Tabela 4 – Resultados da aplicação das regras lógicas para os casos de teste aleatórios

Casos de teste %RL Tempo Casos de teste %RL Tempo

10p10R0 80 0,02 10p40R0 100 7x

10p10R1 73 2x 10p40R1 70 6x

10p10R2 51 6x 10p40R2 39 3x

10p10R3 65 1x 10p40R3 76 6x

10p10R4 68 1x 10p40R4 14 1x

10p10R5 54 9x 10p40R5 7 9,7x

10p10R6 65 8x 10p40R6 92 7x

10p10R7 64 8,8x 10p40R7 56 4x

10p10R8 44 6,3x 10p40R8 79 3x

10p10R9 51 7,7x 10p40R9 15 1x

10p20R0 46 2x 10p50R0 100 6x

10p20R1 10 9,8x 10p50R1 100 4x

10p20R2 10 9,5x 10p50R2 96 6x

10p20R3 38 1x 10p50R3 96 8x

10p20R4 10 7x 10p50R4 96 6x

10p20R5 21 9,7x 10p50R5 50 4x

10p20R6 10 7,3x 10p50R6 92 1x

10p20R7 30 1x 10p50R7 100 7x

10p20R8 72 2x 10p50R8 100 5x

10p20R9 40 2x 10p50R9 100 5x

10p30R0 44 2x 10p60R0 100 4x

10p30R1 15 1x 10p60R1 100 4x

10p30R2 4 1x 10p60R2 100 4x

10p30R3 60 3x 10p60R3 100 3x

10p30R4 0 4,6x 10p60R4 100 4x

10p30R5 17 2x 10p60R5 100 3x

10p30R6 0 4,8x 10p60R6 100 5x

10p30R7 0 4,5x 10p60R7 100 4x

10p30R8 78 3x 10p60R8 100 3x

10p30R9 0 4,4x 10p60R9 100 3x

Na Tabela 5 todos os casos de testes possuem o tamanho 20 x 20 e a

porcentagem de pixels pretos varia de 10 a 60 por cento. A partir da Tabela 5 percebe-se

que casos de teste com 50 por cento ou mais de pixels pretos são resolvidos através das

regras lógicas, tornando esses puzzles mais fáceis. Pode-se observar que os casos de

teste mais difíceis são os com 20, 30 e 40 por cento de pixels pretos.

45

Tabela 5 – Resultados da aplicação das regras lógicas para os casos de teste aleatórios do RanPuz


20p10R0 28,75 3,5x 20p40R0 1,25 3x

20p10R1 32 3x 20p40R1 0,25 1,8x

20p10R2 28 2,7x 20p40R2 1 2,8x

20p10R3 23,5 3,2x 20p40R3 0,5 2,1x

20p10R4 10 1,5x 20p40R4 0,25 3x

20p10R5 10,5 1,9x 20p40R5 2 6x

20p10R6 9,75 1,7x 20p40R6 2,5 5,2x

20p10R7 20 2,8x 20p40R7 0 1x

20p10R8 27,75 2,9x 20p40R8 1 2,7x

20p10R9 14,5 2,1x 20p40R9 2,25 5,2x

20p20R0 0 9,4x 20p50R0 24 2x

20p20R1 0 8,9x 20p50R1 97,75 1,7x

20p20R2 0 9,3x 20p50R2 22 2,8x

20p20R3 0 9,2x 20p50R3 29,5 3,4x

20p20R4 5 1,9x 20p50R4 46,25 3,6x

20p20R5 0 9x 20p50R5 45,25 3,6x

20p20R6 0 9,3x 20p50R6 12,25 1,2x

20p20R7 0 8,4x 20p50R7 18,5 3,3x

20p20R8 0 8,4x 20p50R8 10 9,8x

20p20R9 5 2,4x 20p50R9 61,25 5,5x

20p30R0 0 1,1x 20p60R0 100 6,6x

20p30R1 0 9,3x 20p60R1 100 4,5x

20p30R2 0 9,1x 20p60R2 100 4,9x

20p30R3 0 1,2x 20p60R3 99 4,9x

20p30R4 0 1x 20p60R4 100 1x

20p30R5 0 1,1x 20p60R5 100 6,4x

20p30R6 1 3,7x 20p60R6 99 6,1x

20p30R7 0 1x 20p60R7 100 4,9x

20p30R8 0 1x 20p60R8 100 7,2x

20p30R9 0 9,2x 20p60R9 100 5,8x

Na Tabela 6 todos os casos de testes possuem o tamanho 30 x 30 e as

porcentagens de pixels pretos varia de 10 a 60 por cento. De acordo com a Tabela 6

percebe-se que casos de teste com cinquenta por cento ou mais de pixels pretos são

resolvidos através das regras lógicas, tornando esses puzzles mais fáceis. Observa-se

que os casos de teste mais difíceis são os com 10 a 50 por cento de pixels pretos.

Em suma, a partir dos dados das Tabelas 4 a 6, percebe-se que os casos de teste

com mais de 60 por cento de pixels pretos são solucionáveis através das regras lógicas.

No geral, os casos de teste com 20 a 40 por cento de pixels pretos possuem uma menor

quantidade de pixels decididos após a aplicação das regras lógicas.

46

Tabela 6 – Resultados da aplicação das regras lógicas para os casos de teste aleatórios do RanPuz


30p10R0 9,77 1x 30p40R0 0,22 4,1x

30p10R1 3,44 3,8x 30p40R1 0,55 5,7x

30p10R2 9,77 4,5x 30p40R2 0 1,9x

30p10R3 3,33 6,2x 30p40R3 0 1,9x

30p10R4 6,66 3,7x 30p40R4 0,44 5,6x

30p10R5 6,66 4,1x 30p40R5 0 2,2x

30p10R6 6,55 4,5x 30p40R6 1,11 1,4x

30p10R7 3,33 4x 30p40R7 0 2,2x

30p10R8 6,55 7,1x 30p40R8 0 2,1x

30p10R9 6,66 7,5x 30p40R9 1,44 1,6x

30p20R0 3,33 9,4x 30p50R0 4,33 2,4x

30p20R1 0 1,9x 30p50R1 8,77 4,2x

30p20R2 0 1,9x 30p50R2 14,77 6,8x

30p20R3 0 1,7x 30p50R3 1,44 2x

30p20R4 0 1,8x 30p50R4 21,33 0,01

30p20R5 0 1,8x 30p50R5 1,77 8x

30p20R6 0 2x 30p50R6 6,33 3,2x

30p20R7 0 1,7x 30p50R7 3,55 3x

30p20R8 0 2x 30p50R8 4,22 2,1x

30p20R9 0 1,7x 30p50R9 6,22 3x

30p30R0 0 2x 30p60R0 98,55 0,02

30p30R1 0 2,1x 30p60R1 99,11 0,03

30p30R2 0 2,1x 30p60R2 99,55 0,03

30p30R3 0 1,9x 30p60R3 100 0,03

30p30R4 0 1,9x 30p60R4 99,11 0,04

30p30R5 0 2x 30p60R5 100 0,03

30p30R6 0 2,1x 30p60R6 99,55 0,02

30p30R7 0 1,9x 30p60R7 100 0,02

30p30R8 0 2,1x 30p60R8 99,55 0,02

30p30R9 0 1,9x 30p60R9 100 0,03

Observa-se que em todos os casos de teste o tempo de execução das regras

lógicas é insignificante, e que tais regras podem ser usadas sem haver perdas nos

desempenhos das heurísticas ou das abordagens exatas.

5.2 Nonograma como um problema de Satisfação de Restrições

Segundo Batenburg e Kosters (2009) qualquer Nonograma pode ser modelado

como um Constraint Satisfaction Problem (CSP), no qual, as descrições das linhas ou

colunas podem ser traduzidas em restrições. Wiggers (2004) também expôs a

possibilidade de transformar o Nonograma em um CSP. Neste trabalho é proposto a

transformação do Nonograma em um problema de satisfabilidade (SAT) e

posteriormente solucioná-lo no solver MiniSat (Eén, 2003).

Primeiramente deve-se que transformar o Nonograma em cláusulas lógicas, ou

seja, uma disjunção ou conjunção de literais. A Figura 6 exemplifica esse procedimento.

47

Cada quadrado (pixel) da grade é considerado uma variável, cada variável é denominada

por um número, de modo que, por exemplo, tendo-se uma grade 3 x 3 teremos 9

variáveis. A Figura 6 transforma o Nonograma em cláusulas lógicas apenas para as

linhas, o mesmo procedimento deverá ser feito para as colunas.

Figura 6 – Transformando o Nonograma em cláusulas lógicas para as linhas.

Os solvers dos problemas SATs resolvem apenas fórmulas na forma normal

conjuntiva (FNC). A FNC é uma conjunção de cláusulas, onde uma cláusula é uma

disjunção de literais, como em ( ) ( ) ( ), onde , , , e

são literais.

Para solucionar o Nonograma no MiniSat, deve-se transformar a fórmula do

Nonograma na sua equivalente FNC através da distributividade. Para a linha 1 do

exemplo da Figura 6 tem-se (número de variáveis elevado à quantidade de

soluções possíveis para cada linha) cláusulas na FNC.

Em problemas iguais ou superiores ao tamanho 8 x 8 torna-se praticamente

impossível a solução do Nonograma através do MiniSat, devido à quantidade de

cláusulas geradas ser muito grande, e assim o tempo necessário para gerar todas as

cláusulas é muito elevado. Grades de tamanho até 5 x 5 são facilmente resolvidas pelo

48

MiniSat, porém algumas grades de tamanho 6 x 6 não foram resolvidas, demostrando

assim que utilizar solvers SAT para solucionar o Nonograma não é eficaz.

A Tabela 7 mostra os resultados utilizando o solver MiniSat para os casos de

teste retirados de jogos para dispositivos móveis. Na primeira coluna temos o nome dos

casos de teste, na segunda o tamanho dos mesmos. A terceira coluna mostra quantas

cláusulas na FNC o solver terá que resolver. A quarta exibe o tempo em segundos para

resolver tais cláusulas. Para os casos de teste SP:HD_15 e SP:HD_19 a quantidade de

cláusulas é muito grande, e o computador não consegue gerar todas as cláusulas em

tempo hábil, o que também ocorreu para todos os casos de teste do Benchmark Puzzles

(2012) testados (1, 8 e 9 estrelas).

Tabela 7 – Resultados do MiniSat par os casos de teste retirados de jogos para dispositivos móveis

Caso de teste Tamanho Cláusulas na FNC MiniSat: CPU time

SP:HD_5 9 x 6 186708 1,98

SP:HD_7 6 x 5 60525150 23,99

SP:HD_12 6 x 6 282972 0,34

SP:HD_13 5 x 5 6810 0,008

SP:HD_15 8 x 4 2,30584e+18 -

SP:HD_18 6 x 6 98082 0,26

SP:HD_19 7 x 5 4,74756e+12 -

SP:HD_21 6 x 6 241914612 37331,3

5.3 Busca em Profundidade

A Busca em Profundidade ou Depth First Search (DFS) proposto para

solucionar o Nonograma é um algoritmo muito simples. Inicialmente, são geradas todas

as possíveis soluções (PS) para cada linha do puzzle, veja Figura 7 a Figura 11. Após

gerar todas as possíveis soluções para todas as linhas, essas soluções são combinadas,

quando todas as colunas do puzzle estão corretas, o problema é resolvido, isto ocorre

porque cada possibilidade gerada por uma linha já está correta.

O cálculo da quantidade das possíveis soluções para cada linha pode ser

realizado de acordo com a equação 5 (Ortiz-García et al., 2008).

(

) (5)

onde é igual ao número de blocos da linha mais 1, e

∑ (6)

49

é o número total de células brancas situadas entre dois blocos, onde M é a quantidade de

linhas, o número de restrições de uma determinada linha e a k-ésima restrição

da linha . O mesmo raciocínio pode ser utilizado para calcular a

quantidade das possíveis soluções para cada coluna. O cálculo para as colunas é

mostrado nas equações 7 e 8.

(

) (7)

onde é igual ao número de blocos da coluna mais 1, e

∑ (8)

é o número total de células brancas situadas entre dois blocos, onde N é a quantidade de

colunas, o número de restrições de uma determinada coluna e a k-ésima

restrição da coluna .

Figura 7 – Possibilidades da linha 1


50


Figura 10 – Possibilidade da linha 4


O DFS é um algoritmo de busca exaustiva, que sempre irá encontrar a solução

do puzzle, porém o tempo de execução do mesmo pode ser inaceitável. Para diminuir o

tempo de processamento do DFS é realizado um backtracking.

A Figura 12 mostra o grafo de busca para um determinado Nonograma (Jing, et

al. 2009). Dado um puzzle (Fig. 12a), são geradas as soluções possíveis para cada linha

(Fig. 12 b, c, d). A partir das possibilidades gera-se o grafo de busca. Na busca em

profundidade sem o backtracking gera-se inicialmente a sequencia

, e verifica-se se esta não fere as restrições das colunas. Caso não satisfaça

as restrições das colunas, a próxima sequência a ser verificada é

, e assim sucessivamente até que uma sequência satisfaça às restrições das

colunas.

51

Para reduzir o tempo computacional, foi implementado o backtracking durante

a busca no grafo. As Figuras 13 a 20 exemplificam como é feito o backtracking para o

puzzle da Figura 12(a). Inicialmente, escolhe-se a primeira possibilidade da primeira

linha (PS11), ao selecionar a primeira possibilidade da segunda linha (PS21), ocorre uma

violação nas restrições da primeira coluna (Figura 13), então a busca para, e continua na

segunda possibilidade da segunda linha (Figura 14).

Figura 12 – Um exemplo de DFS. (a) Dado um puzzle. (b) Três possíveis soluções para a linha 1. (c) Duas

soluções possíveis para a linha 2. (d) Duas soluções possíveis para a linha 3. (e) Uma solução possível para a

linha 4. (f) Árvore de busca de (a).

Figura 13 – Passo 1 da busca em profundidade com Backtracking

Selecionando a segunda possibilidade da segunda linha (PS22) também

52

provocará a violação de restrições das colunas (Figura 14). Como a segunda linha

possui apenas duas possibilidades, a busca para e retorna para a primeira linha

selecionando a segunda possibilidade (PS12) da mesma (Figura 15). Seleciona-se a PS21

e posteriormente PS22, ambas as possibilidades violam restrições das colunas (Figura 15

e Figura 16). Novamente a busca para e retorna para a primeira linha, selecionando PS13

(Figura 17).




53





Escolhe-se PS21, e nenhuma restrição é violada (Figura 17) então a busca segue

para a terceira linha. PS31 provoca uma violação nas restrições das colunas (Figura 18).

54

Segue-se a busca testando PS32 que não provoca nenhum violação (Figura 19). Em

seguida testa-se PS41, a solução do puzzle é encontrada (Figura 20) e termina-se a busca

em profundidade com backtracking.

Os resultados da busca em profundida (DFS) para os casos de teste do

Benchmark Puzzles (2012) são mostrados na Tabela 8. Para os casos de teste com

tamanhos iguais ou superiores a 20 x 20, os espaços de busca tornam-se muito grandes

provocando vazamentos de memória.

5.4 Las Vegas Sistemático

A ideia central do algoritmo não determinístico Las Vegas é percorrer o grafo

de busca de forma aleatória, ao invés de percorrê-lo de maneira sistemática, como na

busca em profundidade. Foi desenvolvido um algoritmo Las Vegas, que percorre as

soluções possíveis para cada linha de forma aleatória. Também foi utilizado o

Backtracking.

As Figuras 21 a 29 exemplificam como é realizada a busca Las Vegas. Na

Figura 21 tem-se um puzzle 5 x 5, no qual a primeira linha possui 4 soluções possíveis.

Sorteia-se aleatoriamente uma possibilidade desta linha, neste exemplo foi sorteada a

terceira possibilidade. Em seguida, verificam-se as soluções possíveis para a segunda

linha (Figura 22). Sorteia-se uma possibilidade desta linha, e verifica-se se existe

alguma violação de restrições nas colunas. Percebe-se que na coluna 4 ocorreu uma

violação, então a possibilidade 3 – 1 torna-se proibida (vira tabu), como não existe outra

possibilidade na linha 2, a terceira possibilidade da linha 1 também torna-se proibida –

vira tabu – (Figura 22).

Figura 21 – Sorteia-se uma possibilidade para a primeira linha.

55

Figura 22 – Sorteia-se uma possibilidade para a segunda linha. Nota-se uma violação. A seguencia 3 torna-se

proibida.

Então, retorna-se para a linha 1 e outra possibilidade é sorteada (Figura 23).

Neste exemplo é sorteada a quarta possibilidade. Ao inserir a única possibilidade da

segunda linha, também ocorre uma violação na quarta coluna, e a quarta possibilidade

da primeira linha torna-se tabu (Figura 24). Novamente será sorteada uma possibilidade

na primeira linha (Figura 24), a primeira é sorteada. Na Figura 25, percebe-se que na

inserção da possibilidade da segunda linha, irá violar uma restrição da primeira coluna.

Figura 23 – Sorteia-se uma possibilidade para a primeira linha e para a segunda linha. Percebe-se uma

violação e a seguência 4-1 torna-se proibida.

Figura 24 – A sequencia 4 torna-se proibida. Sorteia-se uma possibilidade para a primeira linha.

Figura 25 – Sorteia-se uma possibilidade para a segunda linha, percebe-se uma violação. A sequência 1 torna-

se proibida.

56

Na Figura 26, percebe-se que apenas a segunda possibilidade da primeira linha

pode ser escolhida. Seleciona-se a única possibilidade da segunda linha e prossegue-se

na busca.

Figura 26 – Sorteia-se uma possibilidade para a primeira e segunda linha.

Ao testar a primeira e segunda possibilidades da terceira linha, nota-se que

violam-se restrições das colunas (Figura 27). Então a terceira possibilidade é sorteada

(Figura 28), e prossegue-se para a quarta linha, sorteando-se a terceira possibilidade,

como não há a violação de nenhuma restrição, a busca segue para a quinta linha, onde a

quarta possibilidade é sorteada (Figura 29), a solução do puzzle é encontrada e a busca

encerrada.

Figura 27 – Sorteia-se uma possibilidade para a terceira linha, percebe-se uma violação. A sequência 2-1-1

torna-se proibida. Sorteia-se outra possibilidade para a terceira linha, e a sequência 2-1-2 torna-se proibida.

Figura 28 – Sorteia-se uma possibilidade para a terceira e quarta linha.

57

Figura 29 – Sorteia-se uma possibilidade para a terceira linha. A solução do puzzle é encontrada.

A Tabela 8 mostra o tempo de execução em segundos para o algoritmo DFS e a

média do tempo em segundos para o algoritmo Las Vegas para os 16 casos de teste

classificados como muito difíceis retirados do Benchmark Puzzles (2012). O DFS foi

executado apenas uma vez e o Las Vegas 30 vezes.

Tabela 8 – Resultado do DFS e Las Vegas para os casos de teste do Benchmark Puzzles (2012).

Caso de Teste DFS Las Vegas Caso de Teste DFS Las Vegas

222 0,01 0,87 230 0,02 0,50

223 0,06 0,56 231 0,08 1,77

224 0,62 7,35 232 1,66 9,01

225 0,03 0,38 233 0,78 5,48

226 0,03 1,69 234 0,5 16,86

227 0,39 5,53 235 0,07 7,8

228 0,11 2,94 236 0,06 1,65

229 0,27 7,45 237 0,02 0,46

De acordo com os resultados da Tabela 8 percebe-se que o algoritmo exato

resolve os puzzle do Benchmark Puzzles (2012) eficientemente. Para os casos de teste

com tamanhos iguais ou superiores a 20x20, os espaços de busca tornam-se maiores

provocando vazamentos de memória. Percebe-se também que a aleatoriedade do Las

Vegas não reduziu o tempo gasto para solucionar os puzzles, ou seja, a abordagem DFS

encontra as soluções dos puzzles em um tempo computacional inferior comparando-se

ao Las Vegas.

58

6 Abordagem Heurística

Uma vez que abordagens exatas não são eficientes para resolver qualquer tipo

de Nonograma, este trabalho adota abordagens heurísticas. São propostos uma Busca

Tabu e dois Meméticos para solucionar o Nonograma. São aplicadas onze regras lógicas

(Jing et al., 2009 e Yu et al. 2009), visando definir a cor de algumas células e diminuir

os limites de alocação de alguns blocos pretos, reduzindo o espaço de busca.

A Seção 6.1 explica como é realizada a avaliação de uma solução do jogo. A

Seção seguinte expõe as formas de se construir a solução inicial. A busca local

utilizando a ideia de limites lógicos dos blocos é explicada na Seção 6.3. Nas seções

seguintes são explanadas as abordagens heurísticas propostas para solucionar o

Nonograma.

6.1 Função objetivo

A avaliação de uma solução é feita de acordo com a equação 9 quando as

restrições em linhas são respeitadas. Uma fórmula análoga é utilizada para soluções

onde se respeitam as restrições em colunas. Nesta equação, é o número de colunas,

é o número de linhas, é o tamanho que deve ter o p-ésimo bloco alocado à coluna ,

é o tamanho do p-ésimo bloco que está associado à coluna na solução, é uma

variável binária com valor 1 se o pixel na linha e coluna é preto ou com valor 0 caso

o pixel seja branco, é o número de blocos que devem estar associados à coluna ,

é o número de blocos associados à coluna na solução.

M

k

bbcb

ppkpk

M

k

N

ppk

cb

ppk

kkk

bcxcXf1

},max{

11 11

100

(9)

O valor de ( ) se a solução for viável. O cálculo da função objetivo é

ilustrado com a solução não viável exibida na Figura 30.

59

Figura 30 – Solução não viável de um Nonograma

Neste Nonograma tem-se que e . Os valores de , para k =

1,...,5, são, respectivamente, . O primeiro termo da equação 9 é calculado

por:

∑ |∑ ∑

| |( ) ( )| |( )

( )| | ( )| |( ) (

)| |( ) ( )| (10)

No cálculo da segunda parcela, verifica-se, coluna a coluna, o comprimento

que cada bloco tem em relação ao que deveria ter. Esse valor recebe uma ponderação

100 vezes maior que a da primeira parcela. O valor de , , ou seja,

existem 2 blocos em cada coluna. Na primeira coluna existem dois blocos com

comprimento 2, entretanto, o problema requer que existam dois blocos ambos com

comprimento 1. Cada conjunto é verificado separadamente. O primeiro bloco alocado à

primeira linha conta a violação de 1 pixel. O mesmo se dá com o segundo bloco. Na

coluna 3, deveria existir apenas um bloco de comprimento 4, mas existem dois blocos

de comprimento 1 cada. O primeiro bloco da coluna é comparado ao único bloco que

deveria ter na coluna. Como deveria existir 4 pixels no primeiro bloco e existe apenas 1,

então é contada uma violação de 3 blocos. O segundo bloco da coluna 3 não tem

correspondente. Um correspondente fictício de tamanho 0 é assumido neste caso. A

violação então é igual a 1, o tamanho do segundo bloco existente na coluna 3. O cálculo

da segunda parcela é mostrado a seguir.

1014221121211001001

},max{

1

M

k

bbcb

ppkpk

kk

bc

11221221 =800 (11)

1 1 1 2

1 2 4 2 1

1 1

5

1

3

2 2

60

Desse modo, tem-se que o valor da função objetivo da solução mostrada na

Figura 30 é 804.

6.2 Construção da Solução inicial

Foram implementadas duas formas de construção da solução inicial. Na

primeira forma (GerarSolAle), a solução inicial do algoritmo é construída

aleatoriamente dentro dos limites lógicos das alocações de blocos através do

procedimento proposto por Ortiz-García et. al. (2009). Esse procedimento busca uma

alocação de blocos que atenda à viabilidade em linhas ou em colunas, o que pode ser

feito trivialmente. A posição inicial de cada bloco é sorteada aleatoriamente

respeitando-se os possíveis limites de alocação de cada bloco. A Figura 31 exemplifica

uma solução inicial respeitando-se as restrições das linhas. Na Figura 31, as linhas 1 e 3

têm 2 blocos e a linha 2 tem 1 bloco. A linha 1 possui um bloco de tamanho 1 e um

bloco de tamanho 2. Portanto, na linha 1 os limites para o primeiro bloco correspondem

ao intervalo entre a primeira e a segunda células da matriz, intervalo [1,2], uma vez que

os blocos não podem ser alocados encostados. Já para o segundo bloco, o início

encontra-se no intervalo [3,4]. Supondo que o procedimento sorteie a posição inicial

para o primeiro bloco na célula 1, como na Figura 31, a posição inicial do segundo

bloco poderá ser sorteada no intervalo [3,4]. No caso da figura, a posição sorteada foi a

3. Caso o primeiro bloco da primeira linha fosse alocado na célula 2, o segundo bloco

somente poderia ser alocado a partir da célula 4. A posição inicial do bloco da linha 2

pode ser localizada dentro do intervalo [1, 3]. No caso, o bloco da linha 2 foi alocado

entre as células 2 e 4. Procede-se de forma semelhante para a terceira linha.

1 1 2 2 2

1, 2

3

1,1

Figura 31 – Exemplo de alocação inicial dos blocos

Na segunda forma (GerarSolN) geram-se n possíveis soluções para a primeira

linha, de acordo com os limites de alocação dos blocos desta linha. Todas essas n

61

possibilidades são testadas, e a que possuir a menor função objetivo é escolhida. Esse

procedimento é feito para a segunda linha e assim por diante.

6.3 Busca Local

O procedimento buscalocal( ) é detalhado no Quadro 1. Na função

Rand_Line( ), escolhe-se, aleatoriamente, uma linha ou coluna (dependendo de como foi

construída a solução), e posteriormente na função Rand_Bloco( ) um bloco é sorteado

desta linha ou coluna, também aleatoriamente. Dentro dos limites possíveis de alocação

do bloco sorteado, todas as posições possíveis são testadas para alocá-lo no

procedimento Insert( ) dentro do laço. A solução com a melhor alocação do bloco é

guardada na variável mSol. A qualidade da solução é definida através de sua função

objetivo definida na Seção 6.1, no qual o objetivo é minimizar a função objetivo.

Procedimento buscalocal (SolCor)

1

2

3

4

5

6

7

8

9

Line Rand_Line()

Bloco Rand_Bloco (Line)

f(mSol)

Para toda a posição disponível de Inserção i

Sol Insert (Bloco, SolCor, i)

se (f(Sol) < f(mSol))

mSol Sol

fim para

SolCor mSol

Quadro 1 – Procedimento de busca local

6.4 Busca Tabu

A Busca Tabu é referida na literatura como supostamente proposta por Fred

Glover na década de 80 (Glover, 1986; Glover, 1989). Ainda que pouco conhecido,

Hansen (1986) também apresenta uma proposta semelhante e independentemente

desenvolvida denominada steepest ascent mildest descent.

A Busca Tabu, via de regra, emprega uma estrutura de memória simples,

normalmente uma fila, que controla a diversidade de uma configuração corrente de um

processo de busca. Esse controle da configuração é realizado de forma indireta através

do controle das alterações que essa configuração sofre ao longo da busca. Controlando

as modificações na configuração e não a própria configuração, o esforço de memória é

aliviado, porém a revisita de uma mesma configuração torna-se possível. Dessa forma, a

62

técnica propõe mecanismos adicionais de aceitação ou rejeição de uma dada

configuração foco de busca.

Finalmente, a Busca Tabu também emprega mecanismos que permitem

equilibrar a diversificação e a intensificação da busca através do uso de memória de

médio e longo prazo, oscilação, elitização, etc (Glover e Laguna, 1997).

A busca tabu tem sido fracamente explorada na literatura para o

desenvolvimento de algoritmos metaheurísticos eficientes para a solução de jogos

lógicos. Uma recente exceção é o trabalho de Wang e Chiang (2010) que aplicam a

busca tabu para a solução do Eternity-II puzzles.

A memória de curto prazo do algoritmo tabu, a lista tabu, controla a escolha do

bloco que deverá ser movimentado no quadro do jogo, não propriamente o movimento

do bloco. De fato, o movimento que será escolhido será o melhor possível, segundo a

avaliação da função objetivo. O pseudocódigo do algoritmo TabuGrama está descrito

no Quadro 2. Vale lembrar que as onze regras lógicas (Jing et al. 2009 e Yu et al. 2009)

fazem parte do pré-processamento da heurística.

Algoritmo TabuGrama

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

sol, solCor, mSol

iterG

Lista_Tabu {}

Enquanto (iterG > 0) faça

s rand(0,1)

solCor GerarSolN(s)

cont;

enquanto (cont > 0) faça

para iter de 1 até iter faça

sol buscalocalT(solCor,s, Lista_Tabu);

se (f(sol) < f(mSol))

mSol sol;

fim se

fim para

sol mudarLine(s);

cont cont - 1

fim enquanto

iterG iterG - 1

fim enquanto

Quadro 2 – Pseudo-código do algoritmo Tabugrama

Inicialmente cria-se uma solução no procedimento GerarSolN( ). A solução

criada será viável em linhas ou em colunas de acordo com o parâmetro s passado como

entrada do procedimento. Esse parâmetro é obtido no procedimento rand( ) que retorna

63

0 ou 1 com equiprobabilidade. Caso , a alocação será realizada considerando a

viabilidade das linhas, e se será considerada a viabilidade das colunas. A

estratégia de busca tabu é desenvolvida dentro do procedimento buscalocalT( ) do

Quadro 2. Esse procedimento está detalhado no Quadro 3.

O procedimento buscalocalT( ) é desenvolvido da seguinte forma. No

procedimento Rand_Bloco( ) – linha 1, escolhe-se, aleatoriamente, um bloco de uma

linha ( ) ou coluna ( ), também escolhida aleatoriamente. Dentro dos limites

possíveis de alocação do bloco escolhido na linha ou coluna, todas as posições possíveis

são testadas para alocar o bloco no procedimento Insert( ) – linha 4. A solução com a

melhor alocação do bloco é guardada na variável mSol. No final do laço, a posição do

bloco é guardada na Lista_Tabu no procedimento Insere_Tabu( ) – linha 10. O

procedimento buscalocalT( ) retorna a solução em mSol. Cada bloco selecionado se

torna tabu durante 5 iterações.

Procedimento buscalocalT (SolCor,s,Lista_Tabu)

1

2

3

4

5

6

7

8

9

10

11

Bloco Rand_Bloco (SolCor,s,Lista_Tabu) // Bloco Lista_Tabu //

f(mSol)

Para toda a posição disponível de Inserção i faça

Sol Insert (Bloco, SolCor, s, i)

se (f(Sol) < f(mSol))

mSol Sol

fim se

Tabu Bloco;

fim para

Insere_Tabu (Lista_Tabu, Tabu) // Lista_Tabu possui comprimento 5 //

SolCor mSol

Quadro 3 – Procedimento Busca Local do TabuGrama

A vizinhança explorada na Busca Tabu do Quadro 3 é composta por todas as

configurações possíveis de organizar através da movimentação de um bloco – em linha

ou em coluna, conforme o tipo de solução corrente inicialmente gerado pelo

procedimento do Quadro 2. O procedimento tabu não necessita de uma estratégia de

aspiração, uma vez que o controle se faz sobre o bloco a ser utilizado para gerar a

vizinhança de busca.

Os passos do algoritmo descrito no Quadro 2 que antecedem a chamada do

procedimento de busca tabu têm por objetivo fornecer soluções iniciais diversificadas

para serem exploradas por uma etapa de busca tabu.

64

O procedimento mudarLine( ) – linha 15 – modifica uma linha ( ) ou

coluna ( ) da solução corrente, escolhida aleatoriamente. Sorteia-se uma linha (ou

coluna) aleatoriamente e a posição inicial de cada bloco é sorteada respeitando-se os

limites lógicos do bloco. O objetivo desse procedimento é diversificar as soluções

exploradas pelo algoritmo. Os resultados do TabuGrama são apresentados no Capítulo

7.

6.5 Memético

Sob vários pontos de vista os algoritmos Meméticos podem ser considerados

uma forma híbrida de algoritmos Genéticos. Um algoritmo Genético híbrido é um AG

clássico que utiliza algum método de busca local (Whitley, 1994). A maneira mais

comum de implementar esses algoritmos utiliza um algoritmo simples de busca local

para imprimir melhorias em termos de adequação à população inicial e aos indivíduos

resultantes de operações de recombinação. Nesse contexto, a busca local pode ser vista

como um tipo de “aprendizagem” que ocorre durante o tempo de vida de um indivíduo.

De uma forma geral, os algoritmos Meméticos possuem melhor performance

que os algoritmos genéticos clássicos. Goldberg e Voessner (1999) apresentam uma

análise teórica sobre a economia que ocorre quando uma hibridização eficaz é realizada

em um AG. Essa aprendizagem, no entanto, não é gratuita. As principais vantagens dos

algoritmos Meméticos são: a diversificação, devido à população, crossover e mutação, e

a intensificação devido às buscas locais.

Duas abordagens utilizando a heurística Memético são propostas neste trabalho.

A primeira abordagem é descrita no Quadro 4 e a segunda no Quadro 5. No algoritmo

Memetico1 a construção da solução inicial é realizada através do procedimento

GerarSolN( ), gera-se 20 possíveis soluções para a primeira linha, de acordo com os

limites de alocação dos blocos desta linha. Todas essas 20 possibilidades são testadas, e

a que possuir a menor função objetivo é escolhida. Esse procedimento é feito para a

segunda linha e assim por diante. Metade dos indivíduos são gerados respeitando-se a

viabilidade das linhas e a outra metade a viabilidade das colunas. O tamanho da

população (tamPop) foi definido igual a 700. O critério de parada foi ajustado em 1000

gerações. A taxa de cruzamento foi fixado em 50% e a taxa de mutação igual a 10%. Os

afinamentos desses parâmetros são exibidos na Seção 7.1.2.

65

Algoritmo Memetico1

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

para i de 1 até tamPop faça

S ← GerarSolN()

inserir s na população P

fim_para

iter ← 1000

Enquanto (iter > 0) faça

para i de 1 até quantCruz faça

S1 ← SortearIndividuo (P)


F ← cruzamento(S1 ,S2)

F ← buscaLocal(F)

inseir F na populacao P

fim_para

para i de 1 até quantMut faça

S ← SortearIndividuo(P)

S ← Mutacao(S)

S ← buscaLocal(S)

inserir S na população P

fim_para

iter iter - 1

Fim_enquanto

Quadro 4 – Pseudo-código do algoritmo Memetico1

A seleção dos pais para o cruzamento pode ser realizada de duas formas:

aleatoriamente ou através do método da roleta. Os dois métodos foram analisados e a

seleção aleatória dos pais foi escolhida (Capítulo 7). Caso o primeiro pai sorteado seja

viabilizado em linha, o segundo também deverá ser. Foram testados três métodos de

cruzamento. No primeiro método de cruzamento (cruzCorte), supondo-se que os pais

tenham sido gerados respeitando a viabilidades das linhas, sorteiam-se duas posições do

pai1, e o filho receberá as linhas entre essas posições sorteadas do pai1 e as demais

linhas do pai2. A Figura 32 exemplifica como esse cruzamento ocorre: duas posições

são sorteadas, 2 e 4, o filho (Figura 32 c) recebe as linhas 1 e 5 do pai2 (Figura 32 b) e

as linhas 2, 3 e 4 do pai1 (Figura 32 a).

No segundo método de cruzamento (cruzFO) a primeira linha do filho recebe

aleatoriamente a primeira linha do pai1 ou pai2, a partir da segunda linha, testa-se no

filho a segunda linha do pai1 e do pai2, escolhendo-se a linha que provocar um menor

aumento na função objetivo do filho.

No terceiro método de cruzamento (cruzAle) o filho recebe aleatoriamente as

linhas do pai1 ou do pai2. Na Seção 7.1.2 são exibidos os testes para decidir que tipo de

cruzamento é mais favorável para o algoritmo em questão. O método de cruzamento

selecionado foi o cruzCorte.

66

Figura 32 – CruzCorte: (a) pai1; (b) pai2; (c) Filho resultante do cruzamento do pai1 com o pai2

Após o cruzamento, é realizada uma busca local no filho (linha 11 - Quadro 4),

e o mesmo é inserido na população (linha 12 - Quadro 4) no local do pai com maior

função objetivo. O procedimento da busca local é realizado 300 vezes. Um indivíduo é

sorteado aleatoriamente para sofrer a mutação.

O procedimento mutação – linha 16 (Quadro 4) – modifica uma linha ou coluna

da solução corrente, escolhida aleatoriamente. Sorteia-se uma linha (ou coluna)

aleatoriamente e a posição inicial de cada bloco é sorteada respeitando-se os limites

lógicos do bloco. São sorteadas aleatoriamente cinco linhas (ou colunas) para sofrer a

mutação. O objetivo desse procedimento é diversificar as soluções exploradas pelo

algoritmo. Após a mutação é realizada a busca local (Seção 6.3), e esse procedimento é

executado 300 vezes. A análise de parâmetros e os resultados do Memetico1 são

apresentados no Capítulo 7.

A segunda abordagem do Memético (Memetico2) para solucionar o Nonograma

é descrita no Quadro 5. Para esta abordagem metade dos indivíduos são gerados

respeitando-se a viabilidade das linhas e a outra metade a viabilidade das colunas. Os

indivíduos são gerados através do procedimento GerarSolN( ). O tamanho da população

(tamPop) foi definido igual a 700 indivíduos. O critério de parada foi ajustado em 1000

gerações. A taxa de cruzamento foi fixado em 50% e a taxa de mutação em 10%.

67

Algoritmo Memetico2

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

para i de 1 até tamPop faça

S ← GerarSolN()


fim_para

iter ← 1000

Enquanto (iter > 0) faça

para i de 1 até quantCruz faça



F1 ← cruzamento(S1 ,S2)

Se F1= S1 ou F1= S2 faça

para i de 1 até quantInt faça

F1 ← AlteraPixel(F1)

fim_para

fim_se

F1 ← buscaLocal(F1)

F2 ← AlteraRowCol(F1)

inseir F1 e/ou F2 na populacao P

fim_para

para i de 1 até quantMut faça

S ← SortearIndividuo(P)

para i de 1 até 5 faça

S ← Mutacao(S)

fim_para

S ← buscaLocal(S)


fim_para

iter ←iter - 1

Fim_enquanto

Quadro 5 – Pseudo-código do algoritmo Memetico2

Para realizar o cruzamento, dois indivíduos (pais) são sorteados aleatoriamente.

O método de cruzamento selecionado foi o cruzCorte (Capítulo 7). Caso se verifique

que o filho gerado é igual a um dos pais, o procedimento AlteraPixel( ) é realizado.

Nesse procedimento, escolhe-se a linha (ou coluna) com maior conflito – aplica-se o

cálculo da função objetivo para cada linha (ou coluna), caso nessa linha (ou coluna) haja

mais pixels pretos do que as restrições, blocos são deslocados para diminuir a

quantidade de pixels pretos desta linha (ou coluna). O procedimento AlteraPixel( ) é

repetido 10 vezes (nPixel).

Após o procedimento AlteraPixel( ) é realizada uma busca local (Seção 5.3) no

filho (linha 14 - Quadro 5). Após a buscalocal( ), é realizado o procedimento

AlteraRowCol( ). Caso o indivíduo tenha sido criado respeitando-se as viabilidades das

linhas, o procedimento AlteraRowCol( ) só ocorrerá se a quantidade de colunas que não

estiverem respeitando as restrições for menor ou igual a 10% do número de colunas, ou

seja, em um puzzle de tamanho 20 X 20, se apenas 2 colunas não estiverem respeitando

68

as restrições das mesmas, o procedimento é realizado. Nesse procedimento, caso o

puzzle tenha sido gerado respeitando as viabilidades das linhas, o mesmo será alterado

para respeitar as viabilidades das colunas. Tal procedimento ajuda a sair de ótimos

locais. A partir dos indivíduos S1 , S2 , F1 e F2 mantém-se na população os dois

indivíduos com menor função objetivo (linha 18 - Quadro 5).

O procedimento de mutação – linha 23 (Quadro 5) – modifica uma linha ou

coluna da solução corrente, escolhida aleatoriamente. Sorteia-se uma linha (ou coluna)

aleatoriamente e a posição inicial de cada bloco é sorteada respeitando-se os limites

lógicos do bloco. Esse procedimento é repetido 5 vezes. O objetivo desse procedimento

é diversificar as soluções exploradas pelo algoritmo. Após a mutação, a busca local é

realizada durante 300 iterações. Os resultados do Memetico2 são apresentados no

Capítulo 7.

69

7 Experimentos Computacionais

O U-teste é um teste não-paramétrico que avalia se duas amostras de

observações independentes advêm da mesma distribuição. Este é um dos testes de

hipótese mais conhecidos. A hipótese nula do Mann-Whitney é que as duas amostras

foram obtidas da mesma população (Monteiro, 2009).

Como resultado do teste de Mann-Whitney, obtém-se p-valores. O nível de

significância adotado é de 5% (0,05). Assim, se um algoritmo apresentar p-valor menor

ou igual a 0,05, o resultado é favorável a esse algoritmo.

Neste Capítulo será exposto o estudo dos parâmetros, os resultados e as

comparações das heurísticas propostas para solucionar o Nonograma. Na Seção 7.1 é

exposto o estudo dos parâmetros, a Seção 7.2 exibe os resultados das heurísticas e

finalmente na Seção 7.3 é realizada a comparação das heurísticas propostas.

Todos os experimentos foram realizados em uma máquina com processador

Intel Core i7-2600K 3,40 GHz e 4Gb de RAM. O sistema operacional usado foi o

Ubuntu 12.04.01 LTS e a codificação foi feita utilizando-se a linguagem C++.

7.1 Estudo dos parâmetros

Para o estudo dos parâmetros é utilizado o teste de Mann-Whitney com o nível

de significância igual a 5%. Foram realizadas 10 execuções para cada caso de teste

independentes, para cada configuração dos algoritmos.

7.1.1 TabuGrama

No algoritmo TabuGrama quatro parâmetros são afinados: a forma de

construção da solução inicial, iter, iterG e cont. Foram utilizados 55 casos de testes para

realizar a refinação dos parâmetros do TabuGrama. Foram utilizados os 16 casos de

teste do Benchmark Puzzles (2012) e quarenta do RanPuz, sendo 10 com o tamanho 10

x 10 e , 10 com o tamanho 10 x 10 e , 9 com o tamanho 10 x 10 e

e 10 com o tamanho 20 x 20 e . Vale lembrar que o caso de teste 10p40R0 foi

totalmente resolvido utilizando-se as regras lógicas. Nas tabelas que exibem os

resultados das comparações das configurações A x B, os p-valores em negrito são

favoráveis a configuração A (p-valor < 0,05), e os em itálico são favoráveis a

70

configuração B (p-valor > 0,95).

Inicialmente será decidida a forma de construção da solução inicial (GerarSolN

X GerarSolAle), os demais parâmetros foram inicialmente definidos da seguinte forma:

, e . Neste caso foi utilizado o valor da

função objetivo para a comparação. Em alguns casos de teste, em ambos os parâmetros,

os algoritmos sempre encontrarão as soluções do Nonograma, então para tais algoritmos

não há evidencias de que os resultados da função objetivo dos diferentes parâmetros

sejam diferentes. A Tabela 9 exibe o p-valor para os casos de teste em que nem sempre

o algoritmo encontrará as soluções dos puzzles.

Tabela 9 – p-valores em relação à função objetivo para a decisão da construção da solução inicial

Caso de teste GerarSolN X GerarSolAle

236 0,85

10p20R8 5,3X

10p30R1 4,8X

10p30R8 1,4X

10p40R1 1,4X

10p40R3 4,6X

10p40R6 1,7X

10p40R7 2,7X

10p40R8 2,7X

20p20R0 0,055

20p20R1 0,98

20p20R6 0,18

20p20R7 0,74

20p20R8 0,86

20p20R9 0,34

Dos 55 casos de teste, para 40 não há evidências de qual configuração é

favorável, pois em ambas configurações o algoritmo sempre encontra a solução do

puzzle. Para os demais casos de teste, o p-valor é apresentado na Tabela 9. Oito casos de

testes foram favoráveis a GerarSolN e apenas um (20p20R1) a GerarSolAle. Sendo

assim, a construção da solução inicial será feita de acordo com GerarSolN.

O segundo parâmetro a ser definido será o número de iterações da busca local

(iter). Os valores testados foram e , onde N é o número de linhas e M

o número de colunas do puzzle. Dos 55 casos de teste, para 49 foram incomparáveis

pois em ambas configurações o algoritmo sempre encontra a solução do puzzle. Para os

demais casos de teste, o p-valor é apresentado na Tabela 10. De acordo com os dados da

Tabela 10 não há evidências de que os resultados da função objetivo das duas

configurações sejam diferentes. Então, será utilizado o tempo para decidir pela melhor

71

configuração.

Tabela 10 – p-valores em relação à função objetivo para o parâmetro iter

Caso de teste e

236 0,5

20p20R0 0,59

20p20R1 0,31

20p20R7 0,29

20p20R8 0,74

20p20R9 0,35

A Tabela 11 exibe os resultados dos p-valores para os testes do parâmetro iter

em relação ao tempo gasto pelas configurações. De acordo com a tabela abaixo, a

configuração é mais favorável.

Tabela 11 – p-valores em relação ao tempo para o parâmetro iter

Caso de teste e Caso de teste e

222 0,007 10p30R2 0,052

223 0,1 10p30R3 0,07

224 0,03 10p30R4 0,01

225 0,1 10p30R5 0,07

226 6,1X 10p30R6 0,35

227 0,08 10p30R7 0,059

228 0,003 10p30R8 0,69

229 0,06 10p30R9 0,007

230 0,02 10p40R1 0,49

231 8,2X 10p40R2 0,32

232 0,09 10p40R3 0,059

233 0,1 10p40R4 0,09

234 0,2 10p40R5 0,12

235 0,006 10p40R6 0,12

236 0,72 10p40R7 0,54

237 0,38 10p40R8 0,54

10p20R0 0,1 10p40R9 0,18

10p20R1 0,57 20p20R0 0,001

10p20R2 0,2 20p20R1 5,4X

10p20R3 0,28 20p20R2 0,12

10p20R4 0,36 20p20R3 0,54

10p20R5 0,01 20p20R4 0,1

10p20R6 0,19 20p20R5 0,12

10p20R7 0,12 20p20R6 0,13

10p20R8 0,0003 20p20R7 0,04

10p20R9 0,45 20p20R8 0,36

10p30R0 0,14 20p20R9 0,005

10p30R1 0,65

O próximo parâmetro a ser refinado é o iterG, que define a quantidade de

iterações do algoritmo. Os valores testados para o parâmetro iterG foram iguais a 200,

400 e 600 iterações. Inicialmente, foi comparado 400 X 600 iterações. O resultado do p-

valor é exibido na Tabela 12. De acordo com a Tabela 12, utilizando o valor da função

72

objetivo, não há evidências de que os resultados das duas configurações sejam

diferentes. Então, será utilizado o tempo gasto para decidir pela melhor configuração.

Tabela 12 – p-valores em relação à função objetivo para o parâmetro iterG (400 x 600)

Caso de teste 400 X 600

233 0,84

236 0,509

20p20R0 0,92

20p20R1 0,21

20p20R3 0,86

20p20R4 0,86

20p20R6 0,98

20p20R7 0,18

20p20R8 0,08

20p20R9 0,25

A partir dos dados da Tabela 13, quinze casos de teste foram favoráveis a

e 3 favoráveis a . Então é mais favorável do que

.

Tabela 13 – p-valores em relação ao tempo para o parâmetro iterG (400 x 600)

Caso de teste 400 X 600 Caso de teste 400 X 600

222 0,98 10p30R2 0,06

223 0,12 10p30R3 0,45

224 0,22 10p30R4 0,19

225 0,051 10p30R5 0,09

226 0,19 10p30R6 0,39

227 0,26 10p30R7 0,14

228 0,68 10p30R8 0,0002

229 0,45 10p30R9 0,5

230 0,57 10p40R1 0,02

231 0,97 10p40R2 0,03

232 0,15 10p40R3 0,3

233 0,89 10p40R4 0,16

234 0,04 10p40R5 0,02

235 0,23 10p40R6 0,1

236 0,35 10p40R7 0,009

237 0,08 10p40R8 0,11

10p20R0 0,64 10p40R9 0,013

10p20R1 0,004 20p20R0 0,07

10p20R2 0,04 20p20R1 0,001

10p20R3 0,01 20p20R2 0,68

10p20R4 0,06 20p20R3 0,51

10p20R5 0,3 20p20R4 0,91

10p20R6 0,04 20p20R5 0,65

10p20R7 0,01 20p20R6 0,98

10p20R8 0,25 20p20R7 0,42

10p20R9 0,54 20p20R8 0,24

10p30R0 0,08 20p20R9 0,01

10p30R1 0,009

73

Posteriormente foram comparados os valores 200 e 400 para a quantidade de

iterações do TabuGrama. Os p-valores para esta comparação são exibidos na Tabela

14. De acordo com a mesma, o valor é mais favorável do que o valor

.

Tabela 14 – p-valores em relação à função objetivo para o parâmetro iterG (200 x 400)


233 0,99

236 0,8

237 0,99

10p40R5 0,96

20p20R0 0,72

20p20R1 0,87

20p20R3 0,99

20p20R4 0,52

20p20R6 0,91

20p20R7 0,99

20p20R8 0,98

20p20R9 0,98

Por último, é refinado o parâmetro cont. Para tal parâmetro são definidos os

seguintes valores: 100, 300 e 500. Inicialmente é comparado o valor 300 e 500. A partir

da Tabela 15 não é possível decidir qual a configuração mais favorável. Então, será

utilizado o tempo gasto para decidir pela melhor configuração.

Tabela 15 – p-valores em relação à função objetivo para o parâmetro cont (200 x 500)


236 0,21

237 0,73

20p20R0 0,93

20p20R1 0,86

20p20R3 0,86

20p20R4 0,86

20p20R6 0,98

20p20R9 0,22

A Tabela 16 exibe os p-valores para a comparação de e

. A partir dos valores dessa tabela, 17 casos de teste foram favoráveis a

e apenas um caso de teste (20p20R6) foi favorável a . Posteriormente, será

comparado o valor e .

74

Tabela 16 – p-valores em relação ao tempo para o parâmetro cont (300 x 500)


222 0,24 10p30R2 0,01

223 0,02 10p30R3 0,08

224 0,004 10p30R4 0,26

225 0,02 10p30R5 0,32

226 0,12 10p30R6 0,952

227 0,27 10p30R7 0,21

228 0,03 10p30R8 0,003

229 0,02 10p30R9 0,03

230 0,49 10p40R1 0,008

231 0,36 10p40R2 0,3

232 0,31 10p40R3 0,6

233 0,43 10p40R4 0,64

234 0,02 10p40R5 0,01

235 0,21 10p40R6 0,35

236 0,69 10p40R7 0,15

237 0,53 10p40R8 0,04

10p20R0 0,06 10p40R9 0,006

10p20R1 0,26 20p20R0 0,07

10p20R2 0,58 20p20R1 0,04

10p20R3 0,73 20p20R2 0,6

10p20R4 0,12 20p20R3 0,48

10p20R5 0,34 20p20R4 0,78

10p20R6 0,48 20p20R5 0,75

10p20R7 0,35 20p20R6 0,96

10p20R8 0,03 20p20R7 0,6

10p20R9 0,13 20p20R8 0,8

10p30R0 0,01 20p20R9 0,01

10p30R1 0,55

A Tabela 17 exibe os p-valores para a comparação de e

. A partir dos valores desta tabela, 11 casos de teste são favoráveis a .

Então, foi definido o valor 300 para o parâmetro .

Tabela 17 – p-valores em relação à função objetivo para o parâmetro cont (100 x 300)


232 0,96

233 0,3

236 0,99

237 0,97

10p30R6 0,99

20p20R0 0,86

20p20R1 0,99

20p20R2 0,97

20p20R3 0,99

20p20R4 0,74

20p20R6 0,97

20p20R7 0,99

20p20R8 0,99

20p20R9 0,99

75

Os resultados do TabuGrama após o refinamento dos parâmetros são exibidos

na Seção 7.2.1.

7.1.2 Memetico1

No algoritmo Memetico1 oito parâmetros são afinados: a forma de construção

da solução inicial, taxa de cruzamento (txCruz), taxa de mutação (txMut), número de

gerações (iter), tamanho da população (tamPop), forma de seleção dos indivíduos para o

cruzamento, método de cruzamento e número de iterações da busca local (iterBL).

Foram utilizados 56 casos de testes para realizar a refinação dos parâmetros do

Memetico1. Foram utilizados os 16 casos de teste do Benchmark Puzzles (2012) e

quarenta do RanPuz, sendo 10 com o tamanho 10 x 10 e , 10 com o tamanho 10

x 10 e , 10 com o tamanho 30 x 30 e e 10 com o tamanho 30 x 30 e

. Vale lembrar que o caso de teste 10p40R0 foi totalmente resolvido utilizando

as regras lógicas, totalizando então 55 casos de testes.

Tabela 18 – p-valores em relação à função objetivo para a decisão da construção da solução inicial

Caso de teste GerarSolAle X GerarSolN

232 0,85

30p30R0 0,99

30p30R1 0,68

30p30R2 0,99

30p30R3 0,73

30p30R4 0,93

30p30R5 0,91

30p30R6 0,99

30p30R7 0,99

30p30R8 0,75

30p30R9 0,99

30p40R0 0,99

30p40R1 0,99

30p40R2 0,99

30p40R3 0,42

30p40R4 0,31

30p40R5 0,63

30p40R6 0,99

30p40R7 0,84

30p40R8 0,87

30p40R9 0,99

Inicialmente será decidida a forma de construção da solução inicial, os demais

parâmetros foram inicialmente definidos da seguinte forma: txCruz = 0,6; txMut = 0,05;

iter = 1000; tamPop = 500; seleção dos pais aleatória; cruzFO; porcMut = 0,5 e iterBL

= 200. A Tabela 18 exibe o p-valor para os casos de teste que nem sempre o algoritmo

76

encontrará a solução do puzzle. De acordo com esta tabela, dez casos de teste foram

favoráveis ao algoritmo GerarSolN. Posteriormente será definido o tamanho da

população. Foram testadas populações com 300, 500, 700 e 900 indivíduos. As

comparações são feitas dois a dois, e os resultados dos p-valores mostrados na Tabela

19.

Tabela 19 – p-valores em relação à função objetivo para a decisão do tamanho da população

Caso de teste 300 X 500 500 X 700 700 X 900

232 0,95 0,73

30p30R0 0,86 0,99 0,45

30p30R1 0,65 0,40 0,91

30p30R2 0,65 0,46 0,78

30p30R3 0,52 0,35 0,91

30p30R4 0,86 0,09 0,85

30p30R5 0,97 0,31 0,67

30p30R6 0,99 0,38 0,36

30p30R7 0,99 0,98 0,9

30p30R8 0,41 0,98 0,51

30p30R9 0,93 0,98 0,83

30p40R0 0,93 0,61 0,94

30p40R1 0,96 0,72 0,31

30p40R2 0,98 0,56 0,48

30p40R3 0,6 0,78 0,36

30p40R4 0,95 0,96 0,03

30p40R5 0,61 0,93 0,39

30p40R6 0,75 0,54 0,85

30p40R7 0,9 0,69 0,97

30p40R8 0,99 0,14 0,76

30p40R9 0,93 0,95 0,9

A partir dos resultados da Tabela 19 percebe-se que é mais

favorável do que , e é mais favorável a

. Já para os valores 700 e 900 não há evidência de que os resultados da função

objetivo sejam diferentes. Então o valor do tempo será usado para decidir qual a

configuração mais favorável. De acordo com a Tabela 20, é mais

favorável do que . Então o tamanho da população será definido igual a

700 indivíduos.

Tabela 20 – p-valores em relação ao tempo para a decisão do tamanho da população


222 0,31 10p40R3 0,9

223 0,86 10p40R4 0,09

224 0,73 10p40R5 0,06

225 0,0001 10p40R6 0,003

226 0,03 10p40R7 0,34

227 0,34 10p40R8 0,001

228 0,65 10p40R9 0,06

77

Tabela 20 – (continuação) p-valores em relação ao tempo para a decisão do tamanho da população


229 0,63 30p30R0 0,0001

230 0,08 30p30R1 5,4X

231 0,73 30p30R2 5,4X

232 0,0001 30p30R3 5,4X

233 0,02 30p30R4 5,4X

234 0,84 30p30R5 0,15

235 0,8 30p30R6 5,4X

236 0,45 30p30R7 5,4X

237 0,65 30p30R8 5,4X

10p30R0 0,02 30p30R9 0,0007

10p30R1 0,71 30p40R0 5,4X

10p30R2 0,36 30p40R1 5,4X

10p30R3 0,31 30p40R2 5,4X

10p30R4 0,86 30p40R3 5,4X

10p30R5 0,26 30p40R4 5,4X

10p30R6 0,24 30p40R5 5,4X

10p30R7 0,21 30p40R6 5,4X

10p30R8 0,001 30p40R7 1,1X

10p30R9 0,57 30p40R8 5,4X

10p40R1 0,001 30p40R9 0,0005

10p40R2 0,39

O próximo parâmetro a ser definido será o número de gerações do Memetico1.

Foram testadas 500, 1000 e 1500 gerações. Os p-valores das comparações dois a dois da

função objetivo para essas quantidades de gerações são mostrados na Tabela 21.

Tabela 21 – p-valores em relação à função objetivo para a decisão do número de gerações

Caso de teste 500 X 1000 1000 X 1500

30p30R0 0,99 0,72

30p30R1 0,92 0,87

30p30R2 0,14 0,97

30p30R3 0,83 0,94

30p30R4 0,91 0,99

30p30R5 0,99 0,99

30p30R6 0,9 0,98

30p30R7 0,89 0,99

30p30R8 0,63 0,5

30p30R9 0,84 0,97

30p40R0 0,91 0,93

30p40R1 0,98 0,99

30p40R2 0,99 0,98

30p40R3 0,99 0,87

30p40R4 0,99 0,41

30p40R5 0,99 0,99

30p40R6 0,91 0,99

30p40R7 0,99 0,99

30p40R8 0,99 0,99

30p40R9 0,98 0,99

78

Observa-se que 1000 gerações é mais favorável do que 500 gerações, e 1500

gerações é mais favorável do que 1000 gerações. Porém o tempo gasto em 1500

gerações é muito alto, então o número de gerações do Memetico1 foi definido igual a

1000. Em seguida será definida a forma de seleção dos pais para o cruzamento, que

poderá ser aleatória ou via método da roleta. Posteriormente verifica-se qual forma de

selecionar os pais para o cruzamento é a mais favorável. De acordo com os p-valores da

Tabela 22, não há evidências de que os resultados para a seleção aleatória e via roleta

sejam diferentes. Sendo assim, o tempo será usado para decidir qual a configuração

mais favorável.

Tabela 22 – p-valores em relação à função objetivo para a forma de seleção dos pais

Caso de teste Aleatório X Roleta

30p30R0 0,004

30p30R1 0,31

30p30R2 0,86

30p30R3 0,16

30p30R4 0,83

30p30R5 0,4

30p30R6 0,98

30p30R7 0,79

30p30R8 0,05

30p30R9 0,99

30p40R0 0,75

30p40R1 0,90

30p40R2 0,78

30p40R3 0,002

30p40R4 0,09

30p40R5 0,1

30p40R6 0,9

30p40R7 0,03

30p40R8 0,955

30p40R9 0,66

A Tabela 23 exibe os p-valores em relação ao tempo para a comparação entre

os dois métodos de seleção dos pais para o cruzamento. De acordo com os resultados da

Tabela 23 a seleção dos pais de forma aleatória é mais favorável do que o método da

roleta.

Tabela 23 – p-valores em relação ao tempo para a decisão da forma de seleção dos pais

Caso de teste Aleatório X Roleta Caso de teste Aleatório X Roleta

222 0,09 10p40R3 5,41X

223 0,31 10p40R4 0,08

224 0,9 10p40R5 0,15

225 0,36 10p40R6 5,41X

226 0,63 10p40R7 2,16X

227 0,96 10p40R8 5,41X

79

Tabela 23 – (continuação) p-valores em relação ao tempo para a decisão da forma de seleção dos pais

Caso de teste Aleatório X Roleta Caso de teste Aleatório X Roleta

228 0,48 10p40R9 0,009

229 0,28 30p30R0 0,86

230 0,955 30p30R1 0,82

231 0,17 30p30R2 0,80

232 0,28 30p30R3 0,91

233 0,007 30p30R4 0,96

234 0,54 30p30R5 0,99

235 0,8 30p30R6 0,89

236 0,0003 30p30R7 2,16X

237 0,13 30p30R8 2,16X

10p30R0 0,54 30p30R9 0,45

10p30R1 0,78 30p40R0 0,0001

10p30R2 0,84 30p40R1 0,00005

10p30R3 3,78X 30p40R2 0,99

10p30R4 0,42 30p40R3 0,99

10p30R5 0,005 30p40R4 1

10p30R6 6,49X 30p40R5 5,41X

10p30R7 0,01 30p40R6 5,41X

10p30R8 5,41X 30p40R7 0,77

10p30R9 0,01 30p40R8 1

10p40R1 5,41X 30p40R9 0,99

10p40R2 5,41X

Em seguida será testado o melhor método para o cruzamento. Três métodos

foram implementados: cruzAle, cruzFO e cruzCorte. Inicialmente foram comparados os

métodos cruzCorte e cruzFO. De acordo com a Tabela 24, o método cruzCorte é mais

favorável do que o método cruzFO. Posteriormente foram comprados os métodos

cruzCorte e cruzAle, e novamente o método cruzCorte foi mais favorável. Então, será

selecionado o cruzCorte como método de cruzamento.

Tabela 24 – p-valores em relação à função objetivo para o método de cruzamento

Caso de teste cruzCorte X cruzFO cruzCorte X cruzAle

30p30R0 0,0008 8,78X

30p30R1 0,0005 8,63X

30p30R2 8,43X 0,0001

30p30R3 9,76X 8,39X

30p30R4 8,24X 8,93X

30p30R5 7,03X 7,25X

30p30R6 7,29X 7,38X

30p30R7 7,78X 7,91X

30p30R8 9,91X 7,82X

30p30R9 8,43X 8,48X

30p40R0 0,01 0,99

30p40R1 0,008 0,003

30p40R2 0,01 0,99

30p40R3 0,002 0,68

30p40R4 0,03 0,99

30p40R5 0,02 0,02

80

Tabela 24 – (continuação) p-valores em relação à função objetivo para o método de cruzamento

Caso de teste cruzCorte X cruzFO cruzCorte X cruzAle

30p40R6 0,0006 0,85

30p40R7 0,15 0,99

30p40R8 0,99 0,99

30p40R9 0,001 0,99

O próximo parâmetro a ser definido é a taxa de cruzamento. Inicialmente

foram testados valores iguais a 60 e 70 por cento dos indivíduos sofrendo o cruzamento.

De acordo com Tabela 25, dois casos de teste são favoráveis a taxa de cruzamento igual

a 0,6. Posteriormente foram comparadas as taxa 0,6 e 0,5. Três casos de teste foram

favoráveis à taxa igual a 0,5 e outros três favoráveis à taxa igual a 0,6. Conclui-se que

não há evidências de que os resultados da função objetivo das configurações sejam

diferentes, então será utilizado o tempo gasto pelas configurações.

Tabela 25 – p-valores em relação à função objetivo para a decisão da taxa de cruzamento

Caso de teste 0,6 X 0,7 0,5 X 0,6

30p30R0 0,94 0,15

30p30R1 0,15 0,69

30p30R2 0,53 0,56

30p30R3 0,05 0,88

30p30R4 0,28 0,036

30p30R5 0,09 0,78

30p30R6 0,11 0,98

30p30R7 0,01 0,87

30p30R8 0,25 0,86

30p30R9 0,1 0,91

30p40R0 0,93 0,22

30p40R1 0,01 0,99

30p40R2 0,19 0,22

30p40R3 0,58 0,13

30p40R4 0,19 0,67

30p40R5 0,28 0,46

30p40R6 0,69 0,74

30p40R7 0,36 0,0006

30p40R8 0,5 0,0005

30p40R9 0,13 0,98

A Tabela 26 exibe os p-valores em relação ao tempo para as taxas de

cruzamento igual a 0,5 e 0,6. De acordo com os p-valores mostrados nessa tabela, 16

casos de teste foram favoráveis a taxa de 0,5 e oito favoráveis a taxa de 0,6. Então será

definido que 50 por cento dos indivíduos sofrerá o cruzamento.

81

Tabela 26 – p-valores em relação ao tempo para a decisão da taxa de cruzamento

Caso de teste 0,5 X 0,6 Caso de teste 0,5 X 0,6

222 0,12 10p40R3 0,99

223 0,36 10p40R4 0,31

224 0,04 10p40R5 0,34

225 0,03 10p40R6 0,98

226 0,21 10p40R7 0,037

227 0,1 10p40R8 0,28

228 0,17 10p40R9 0,71

229 0,28 30p30R0 0,009

230 0,63 30p30R1 0,06

231 0,82 30p30R2 0,009

232 0,91 30p30R3 0,031

233 0,97 30p30R4 0,005

234 0,001 30p30R5 0,17

235 0,93 30p30R6 0,12

236 0,34 30p30R7 0,05

237 0,8 30p30R8 0,04

10p30R0 0,31 30p30R9 0,12

10p30R1 0,57 30p40R0 0,007

10p30R2 0,82 30p40R1 5,41X

10p30R3 0,8 30p40R2 5,41X

10p30R4 0,71 30p40R3 2,16X

10p30R5 0,57 30p40R4 5,41X

10p30R6 0,94 30p40R5 1,08X

10p30R7 0,57 30p40R6 0,99

10p30R8 0,99 30p40R7 1

10p30R9 0,34 30p40R8 0,99

10p40R1 1,08X 30p40R9 0,99

10p40R2 0,48

Também será definido a taxa de mutação. Foram testados porcentagens iguais a

5, 10 e 20. A Tabela 27 exibe os p-valores para a comparação dessas porcentagens.

Onze casos de teste foram mais favoráveis a taxa 0,1 do que a 0,05. E todos os casos de

teste foram favoráveis à taxa 0,1 em detrimento à taxa 0,2. Então a taxa de mutação do

Memetico1 será definida igual a 10 por cento.

Tabela 27 – p-valores em relação à função objetivo para a decisão da taxa de mutação

Caso de teste 0,05 X 0,1 0,1 X 0,2

30p30R0 0,98 8,1X

30p30R1 0,94 7,2X

30p30R2 0,4 8,53X

30p30R3 0,96 8,34X

30p30R4 0,59 8,15X

30p30R5 0,04 8,29X

30p30R6 0,87 8,43X

30p30R7 0,99 3,17X

30p30R8 0,956 7,42X

30p30R9 0,99 7,29X

82

Tabela 27 – (continuação) p-valores em relação à função objetivo para a decisão da taxa de mutação

Caso de teste 0,05 X 0,1 0,1 X 0,2

30p40R0 0,81 9,03X

30p40R1 0,99 8,88X

30p40R2 0,98 0,0003

30p40R3 0,96 9,08X

30p40R4 0,98 0,0001

30p40R5 0,67 8,83X

30p40R6 0,98 8,58X

30p40R7 0,78 0,0001

30p40R8 0,28 8,93X

30p40R9 0,99 0,0002

Por último, será analisado o número de iterações da busca local (iterBL).

Foram testados os valores 100, 200 e 300. De acordo com os p-valores apresentados na

Tabela 28, doze casos de teste foram favoráveis a 200 iterações em detrimento a 100.

Cinco casos de teste foram favoráveis a 300 iterações e um a 200. Então o número de

iterações da busca local será definido igual a 300 iterações.

Tabela 28 – p-valores em relação à função objetivo para a decisão do número de iterações da busca local

Caso de teste 100 X 200 200 X 300

30p30R0 0,97 0,98

30p30R1 0,98 0,77

30p30R2 0,92 0,92

30p30R3 0,98 0,88

30p30R4 0,63 0,75

30p30R5 0,26 0,71

30p30R6 0,33 0,95

30p30R7 0,99 0,01

30p30R8 0,35 0,97

30p30R9 0,89 0,5

30p40R0 0,99 0,98

30p40R1 0,99 0,99

30p40R2 0,99 0,89

30p40R3 0,99 0,93

30p40R4 0,99 0,74

30p40R5 0,952 0,99

30p40R6 0,99 0,4

30p40R7 0,94 0,48

30p40R8 0,93 0,40

30p40R9 0,99 0,54

7.1.3 Memetico2

A abordagem Memetico2 difere da Memetico1 devido à utilização dos

procedimentos AlteraPixel( ) e AlteraRowCol( ). Os oito parâmetros refinados para o

Memetico1 serão utilizados no Memetico2. Então a construção da solução incial

utilizará o método GerarSolN( ); txCruz = 0,5; txMut = 0,1; iter = 1000; tamPop = 700;

83

seleção dos pais aleatória; o cruzamento utilizará o método cruzCorte( ) e iterBL = 300.

Porém será refinado o número de iterações do procedimento AlteraPixel( ) – nPixel – e

a porcentagem máxima do número de linhas (ou colunas) que não estejam respeitando

as viabilidades das colunas (ou linhas) para executar o procedimento AlteraRowCol( ) –

pAltRC.

Inicialmente será refinado o número de iterações do procedimento

AlteraPixel(). O valor de pAltRC foi inicialmente definido igual a 10 por cento. Foram

testados valores para nPixel igual a 10 e 20. De acordo com os p-valores da Tabela 29

apenas um caso de teste foi favorável a nPixel igual a 10. Então o número de iterações

de AlteraPixel() será definido igual a 10.

Tabela 29 – p-valores em relação à função objetivo para a decisão de nPixel


30p30R0 0,93

30p30R1 0,59

30p30R2 0,63

30p30R3 0,09

30p30R4 0,21

30p30R5 0,35

30p30R6 0,91

30p30R7 0,78

30p30R8 0,55

30p30R9 0,69

30p40R0 0,23

30p40R1 0,96

30p40R2 0,18

30p40R3 0,74

30p40R4 0,19

30p40R5 0,13

30p40R6 0,79

30p40R7 0,4

30p40R8 0,66

30p40R9 0,19

Por último, será refinado o valor para pAltRC. Foram testadas taxas iguais a 10

e 20 por cento. De acordo com os p-valores exibidos na Tabela 30, três casos de teste

foram favoráveis à taxa do procedimento AlteraRowCol( ) igual a 10 por cento.

84

Tabela 30 – p-valores em relação à função objetivo para a decisão de pAltRC

Caso de teste 0,2 X 0,1

30p30R0 0,96

30p30R1 0,85

30p30R2 0,47

30p30R3 0,2

30p30R4 0,66

30p30R5 0,98

30p30R6 0,35

30p30R7 0,74

30p30R8 0,19

30p30R9 0,35

30p40R0 0,91

30p40R1 0,78

30p40R2 0,98

30p40R3 0,77

30p40R4 0,92

30p40R5 0,4

30p40R6 0,81

30p40R7 0,40

30p40R8 0,65

30p40R9 0,48

Em suma, o número de iterações do procedimento AlteraPixel() foi definido

igual a 10 e o valor de pAltRC igual a 0,1.

7.2 Resultados

Após o refinamento dos parâmetros, cada algoritmo foi executado 20 vezes. Os

resultados do TabuGrama, Memetico1 e Memetico2 são expostos nas Seções

seguintes.

7.2.1 TabuGrama

As Tabelas 31 a 35 mostram os resultados do TabuGrama para os casos de

teste do Benchmark Puzzles (2012), Nonogram Solver (2012) e RanPuz. O algoritmo

TabuGrama foi executado 20 vezes. A primeira coluna exibe as denominações dos

casos de teste, na segunda tem-se o menor do tempo em segundos para as 20 execuções

(Min), a terceira coluna exibe o maior tempo (Max), a quarta o desvio padrão do tempo

em segundos e na quinta tem-se o percentual de vezes que o algoritmo solucionou o

caso de teste correspondente. Observando a Tabela 31, o algoritmo TabuGrama

resolve todos os casos de teste do Benchmark Puzzles (2012), com uma taxa de sucesso

acima de 95% das 20 execuções. O tempo que o TabuGrama gasta para solucionar

esses puzzles é aceitável.

85

Tabela 31 – Resultados do TabuGrama para os casos de teste do Benchmark Puzzles (2012)

Caso

de teste

Min Max Desvio

padrão

% Caso

de teste

Min Max Desvio

padrão

%

222 0,14 7,28 46,78 100 230 1,43 12 47,15 100

223 0,02 7,82 47,09 100 231 0,18 14,18 48,74 100

224 0,3 9,89 47,11 100 232 0,38 55,84 47,67 100

225 0,03 14,4 47,43 100 233 0,14 7,28 47,09 100

226 0,05 8,18 47,84 100 234 0,28 11,6 49,08 100

227 0,04 4,06 48,17 100 235 0 9,96 49,53 100

228 0,06 7,33 47,98 100 236 1,91 117,66 51,94 95

229 0,35 27,7 47,15 100 237 0,58 64,95 51,94 100

A partir dos resultados da Tabela 32 verifica-se que o TabuGrama consegue

resolver seis casos de teste do Nonogram Solver (2012) em todas as execuções. Para

outros seis casos de testes a abordagem não consegue solucionar o puzzle em nenhuma

execução. O tempo gasto nesta abordagem foi, no geral, elevado.

Tabela 32 – Resultados do TabuGrama para os casos de teste do Nonogram Solver (2012)

Caso de

teste

Min Max Desvio

padrão

% Caso de

teste

Min Max Desvio

padrão

%

Lancs_3 4,45 315,91 97,11 95 Lancs_19 2504,88 4591,41 933,64 0

Lancs_6 0 36,72 9,21 100 Lancs_20 3321,07 6356,35 1026,56 0

Lancs_7 9,2 841,02 263,85 80 Lancs_21 0,28 211,38 51,86 100

Lancs_8 0,36 4,38 1,24 100 Lancs_25 0 0,13 0,4 100

Lancs_14 2671,92 4657,23 632,74 0 Lancs_26 2832,16 4548,42 761,70 0

Lancs_15 584,38 1027,78 197,88 0 Lancs_27 2195,04 2303,82 31,43 0

Lancs_16 3,13 95,76 22,36 100 Lancs_28 0,73 76,60 19,52 100

Lancs_18 67,75 8966,93 2570,99 70

Os casos de teste aleatórios do gerador RanPuz com a tamanho 10 x 10 e

, e os casos de teste: 10p40R0, 10p50R0, 10p50R1, 10p50R7, 10p50R8 e

10p50R9 são totalmente resolvidos através das regras lógicas. A Tabela 33 exibe os

resultados para os demais casos aleatórios do gerador RanPuz com o tamanho 10 x 10.

A partir desta tabela percebe-se que o algoritmo TabuGrama consegue solucionar

todos os casos de teste aleatórios com tamanho 10 x 10 em todas as execuções do

algoritmo. O tempo gasto para esses casos de teste nesta abordagem foi aceitável, no

geral inferior a um segundo.

86


Casos de

teste

Min Max Desvio

padrão

% Casos de

teste

Min Max Desvio

padrão

%

10p10R0 0 0,1 0,02 100 10p30R2 0 1,6 0,36 100

10p10R1 0 0,62 0,12 100 10p30R3 0 0,66 0,17 100

10p10R2 0 0 0 100 10p30R4 0,01 0,36 0,1 100

10p10R3 0 0,02 0 100 10p30R5 0,03 0,36 0,1 100

10p10R4 0 0,29 0,06 100 10p30R6 0,29 37,01 9,17 100

10p10R5 0 0,1 0,02 100 10p30R7 0,01 2,5 0,59 100

10p10R6 0 0,46 0,1 100 10p30R8 0 0,03 0,01 100

10p10R7 0 0,05 0,01 100 10p30R9 0,01 0,88 0,28 100

10p10R8 0 0,03 0,01 100 10p40R1 0 0,48 0,15 100

10p10R9 0 0,13 0,02 100 10p40R2 0 0,32 0,09 100

10p20R0 0,01 1,64 0,53 100 10p40R3 0 1,03 0,28 100

10p20R1 0 0,15 0,04 100 10p40R4 0,01 2,45 0,66 100

10p20R2 0 0,07 0,02 100 10p40R5 0,67 31,31 8,87 100

10p20R3 0 0,09 0,02 100 10p40R6 0 0,69 0,2 100

10p20R4 0 0,08 0,02 100 10p40R7 0 0,3 0,08 100

10p20R5 0 0,23 0,06 100 10p40R8 0 0,1 0,02 100

10p20R6 0 0,27 0,07 100 10p40R9 0,28 42,06 10,65 100

10p20R7 0 0,12 0,03 100 10p50R2 0 0,34 0,11 100

10p20R8 0 1,38 0,3 100 10p50R3 0 0,34 0,09 100

10p20R9 0,01 1,51 0,32 100 10p50R4 0 0 0 100

10p30R0 0,01 1,79 0,47 100 10p50R5 0,04 1,08 0,24 100

10p30R1 0,04 2,65 0,59 100 10p50R6 0 0,02 0,01 100

Os casos de testes com tamanho 20 x 20 e são solucionados utilizando

apenas as regras lógicas. O resultado do TabuGrama para os demais casos de teste com

tamanhos 20 x 20 são exibidos na Tabela 34. De acordo com os resultados da mesma,

observa-se que a abordagem sempre resolve os puzzles 20 x 20 com , já para os

puzzles com e , o TabuGrama não consegue encontrar a solução dos

mesmos em nenhuma execução. O caso de teste 20p50R1 foi solucionado pela

abordagem porque o mesmo já havia solucionado 97,75 por cento dos pixels através das

regras lógicas. Em suma, os casos de teste com tamanho 20 x 20 e entre 30 e 50 são

considerados mais difíceis para o TabuGrama. O tempo gasto nas execuções do

algoritmo foi, no geral, elevado.

87


Casos de

teste

Min Max Desvio

padrão

% Casos de

teste

Min Max Desvio

padrão

%

20p10R0 0,14 6,72 1,92 100 20p30R5 939,73 1159,42 45,43 0

20p10R1 0,17 59,18 16,46 100 20p30R6 1204,26 1301,07 20,07 0

20p10R2 0,22 5,42 1,27 100 20p30R7 835,5 1234,38 91 0

20p10R3 0,15 12,08 3,71 100 20p30R8 908,64 1184,25 77,11 0

20p10R4 0,03 1,86 0,45 100 20p30R9 1173,68 1272,72 23,57 0

20p10R5 0,01 8,39 2,27 100 20p40R0 578,34 806,21 52,88 0

20p10R6 0,36 3,85 1,06 100 20p40R1 578,2 585,63 1,72 0

20p10R7 0,08 3,03 0,69 100 20p40R2 594,69 954,21 72,6 0

20p10R8 0,74 17,11 4,56 100 20p40R3 843,67 931,58 22,38 0

20p10R9 0,11 30,74 6,62 100 20p40R4 865,39 950,87 16,94 0

20p20R0 1300,74 2059,29 206,47 0 20p40R5 831,03 900,77 19,66 0

20p20R1 815,95 1917,53 290,37 20 20p40R6 830,33 977,1 29,43 0

20p20R2 2,85 545,75 155,27 100 20p40R7 891,17 930,94 11,1 0

20p20R3 87,9 1875,94 649,68 80 20p40R8 891,57 927,73 11,07 0

20p20R4 24,21 1402,97 418,50 100 20p40R9 892,43 982,09 19,76 0

20p20R5 10,28 344,58 100,31 100 20p50R0 664,25 763,76 22,15 0

20p20R6 122,37 1871,13 583,5 80 20p50R1 0,08 3,82 1,01 100

20p20R7 50,30 1771,9 642,46 80 20p50R2 717,26 770,65 12,67 0

20p20R8 33,22 2028,9 560,65 95 20p50R3 691,65 729,89 11,54 0

20p20R9 328,55 2056,63 435,63 25 20p50R4 683,39 719,96 10,36 0

20p30R0 741,74 1232,15 176,58 0 20p50R5 627,71 677,69 14,88 0

20p30R1 753,26 1221,1 173,53 0 20p50R6 762,44 804,07 11,79 0

20p30R2 789,47 1270,09 162,01 0 20p50R7 627,83 784,39 37,76 0

20p30R3 963,23 1195,58 53,63 0 20p50R8 737,85 776,69 10,42 0

20p30R4 1163,32 1273,26 26,04 0 20p50R9 647,47 681,16 9,62 0

Os casos de testes com tamanho 30 x 30 e são resolvidos utilizando

apenas as regras lógicas. O resultado do TabuGrama para os demais casos de teste com

tamanho 30 x 30 são exibidos na Tabela 35. Percebe-se que, para esses casos de teste a

abordagem apenas soluciona os com 10 por cento de pixels pretos, para os demais a

abordagem não consegue encontrar a solução do puzzle.


Casos de

teste

Min Max Desvio

padrão

% Casos de

teste

Min Max Desvio

padrão

%

30p10R0 13,8 510,19 160,93 100 30p30R5 4204,38 4729,01 134,56 0

30p10R1 1,47 1057,89 250,87 100 30p30R6 3127,96 5166,52 376,48 0

30p10R2 11,05 406,56 96,77 100 30p30R7 4368,85 4895,02 144,46 0

30p10R3 101,96 8905,16 1946,95 100 30p30R8 4344,39 4907,93 152,57 0

30p10R4 1,59 108,86 32,15 100 30p30R9 2877,1 4249,05 503,4 0

30p10R5 2,67 237,3 687,32 100 30p40R0 3056,82 3675,78 215,49 0

30p10R6 47,67 2769,30 687,32 100 30p40R1 3411,82 3512,54 23,42 0

30p10R7 2,11 167,51 43,83 100 30p40R2 2710,86 3507,23 282,96 0

30p10R8 1,52 682,4 161,04 100 30p40R3 3503,49 3951,81 145,6 0

30p10R9 28,49 1463 457,92 100 30p40R4 3836,66 3886,29 10,02 0

30p20R0 5950,7 6704,05 163,34 0 30p40R5 3830,24 3872,93 11,22 0

30p20R1 4941,33 7202,89 772,81 0 30p40R6 3772,62 4008,34 45,28 0

30p20R2 5829,99 6615,68 272,23 0 30p40R7 2047,26 3416,12 476,9 0

30p20R3 5397,71 8057,35 874,58 0 30p40R8 2869,52 3092 58,99 0

88

Tabela 35 – (contituação) Resultados do TabuGrama para os casos de teste do RanPuz com tamanho 30 x 30

Casos de

teste

Min Max Desvio

padrão

% Casos de

teste

Min Max Desvio

padrão

%

30p20R4 4661,48 7052,76 643,02 0 30p40R9 3501,32 3889,41 153,32 0

30p20R5 5210,68 7467,21 653,01 0 30p50R0 2900,62 2984,21 21,72 0

30p20R6 4690,94 8054,89 808,42 0 30p50R1 2500,22 2857,41 87,32 0

30p20R7 6433,83 7299,26 254,88 0 30p50R2 2380,16 2814,47 147,64 0

30p20R8 5482,44 7827 548,7 0 30p50R3 2104,2 2999,22 289,38 0

30p20R9 5525,44 7781,39 572,6 0 30p50R4 2331,2 3072,26 173,38 0

30p30R0 4179,13 4794,44 163,88 0 30p50R5 1822,11 3272,71 326,22 0

30p30R1 4089,2 4683,69 192,41 0 30p50R6 1832,80 3306,53 389,83 0

30p30R2 4310,84 4475,43 37,32 0 30p50R7 2280,03 3071,48 184,14 0

30p30R3 3490,02 5123,02 299,72 0 30p50R8 1822,25 1982,7 32,8 0

30p30R4 4307,74 4990,09 151,77 0 30p50R9 1717,14 2033,23 69,97 0

Em suma, a abordagem TabuGrama soluciona em tempo aceitável os puzzles

com o tamanho 10 x 10, puzzles aleatórios maiores não são solucionáveis na maioria das

vezes. O tempo utilizado pela heurística é no geral bastante elevado.

7.2.2 Memetico1

As Tabelas 36 a 40 mostram os resultados do algoritmo Memetico1 para os

casos de teste do Benchmark puzzles (2012), Nonogram Solver (2012) e RanPuz. O

algoritmo Memetico1 foi executado 20 vezes. A primeira coluna exibe os casos de

teste, na segunda tem-se o menor do tempo em segundos para as 20 execuções (Min), a

terceira coluna exibe o maior tempo (Max), a quarta o desvio padrão do tempo em

segundos e na quinta tem-se o percentual de vezes que o algoritmo solucionou o caso de

teste correspondente.

Tabela 36 – Resultados do Memetico1 para os casos de teste do Benchmark puzzles (2012)

Caso

de

teste

Min Max Desvio

padrão

% Caso

de

teste

Min Max Desvio

padrão

%

222 0,49 7,65 1,97 100 230 1,27 20,65 5,55 100

223 1,39 16,05 3,61 100 231 2,85 18,77 3,74 100

224 1,34 19,15 4,65 100 232 5,32 1191,5 300,54 95

225 1,14 12,46 2,87 100 233 4,45 42,07 8,26 100

226 0,43 4,48 1,32 100 234 0,23 20,05 4,33 100

227 0,32 4,65 1,26 100 235 4,06 14,86 3,13 100

228 1,43 16,72 3,91 100 236 2,12 36,34 9,46 100

229 4,71 13,38 2,53 100 237 3,43 28,26 6,48 100

De acordo com os resultados da Tabela 36, o algoritmo Memetico1 resolve os

dezesseis puzzles do Benchmark puzzles (2012) na maioria das execuções, e o tempo de

execução do algoritmo é no geral baixo. A Tabela 37 exibe os resultados do Memetico1

para os puzzles do Nonogram Solver (2012). De acordo com a mesma, o algoritmo

89

Memetico1 não consegue resolver o puzzle Lancs_19 com tamanho 33 x 33. Para os

demais casos de teste a abordagem consegue solucionar o puzzle na maioria das

execuções, com exceção do Lancs_19 e Lancs_27. Para alguns casos de teste o tempo

de execução excede um minuto.

Tabela 37 – Resultados do Memetico1 para os casos de teste do Nonogram Solver (2012)

Caso de

teste

Min Max Desvio

padrão % Caso de

teste

Min Max Desvio

padrão %

Lancs_3 19,52 122,84 24,57 100 Lancs_19 3831,83 4331,83 160,04 0

Lancs_6 1,48 41,06 10,03 100 Lancs_20 463,82 9761,28 3786,12 90

Lancs_7 37,05 111,3 23,51 100 Lancs_21 30,09 61,2 10,39 100

Lancs_8 0,47 0,84 0,14 100 Lancs_25 0,15 0,16 0 100

Lancs_14 362,89 987,53 176,26 100 Lancs_26 199,97 445,28 55,05 100

Lancs_15 71,76 2606,96 1031,19 75 Lancs_27 1238,46 4752,34 763,56 5

Lancs_16 4,76 53,59 13,17 100 Lancs_28 9,1 34,98 6,82 100

Lancs_18 65,01 249,11 47,22 100

Os casos de teste aleatórios do gerador RanPuz com o tamanho 10 x 10 e

, e os casos de teste: 10p40R0, 10p50R0, 10p50R1, 10p50R7, 10p50R8 e 10p50R9

são totalmente resolvidos através das regras lógicas. A Tabela 38 exibe os resultados

para os demais casos aleatórios do gerador RanPuz com o tamanho 10 x 10. A partir dos

resultados dessa tabela percebe-se que o algoritmo Memetico1 consegue solucionar

todos os casos de teste aleatórios com tamanho 10 x 10 em todas as execuções do

algoritmo. O tempo gasto para esses casos de teste nesta abordagem foi aceitável, no

geral inferior a um segundo.


Casos de

teste

Min Max Desvio

padrão

% Casos de

teste

Min Max Desvio

padrão

%

10p10R0 0,14 0,15 0 100 10p30R2 0,2 5,48 1,04 100

10p10R1 0,14 0,15 0 100 10p30R3 0,16 0,34 0,05 100

10p10R2 0,1 0,18 0,03 100 10p30R4 0,17 0,77 0,13 100

10p10R3 0,15 0,16 0 100 10p30R5 0,24 3,86 0,8 100

10p10R4 0,08 0,16 0,02 100 10p30R6 1,55 66,99 16,37 100

10p10R5 0,16 0,18 0 100 10p30R7 0,51 6,95 1,85 100

10p10R6 0,08 0,15 0,03 100 10p30R8 0,14 0,25 0,05 100

10p10R7 0,08 0,16 0,03 100 10p30R9 0,21 7,46 1,5 100

10p10R8 0,1 0,19 0,03 100 10p40R1 0,17 0,37 0,05 100

10p10R9 0,1 0,18 0,03 100 10p40R2 0,18 2,25 0,43 100

10p20R0 0,13 2,44 0,46 100 10p40R3 0,17 0,76 0,15 100

10p20R1 0,14 0,43 0,08 100 10p40R4 0,31 6,75 1,59 100

10p20R2 0,14 0,32 0,05 100 10p40R5 1,71 21,52 3,89 100

10p20R3 0,13 0,25 0,03 100 10p40R6 0,15 1,81 0,28 100

10p20R4 0,13 0,25 0,02 100 10p40R7 0,29 0,48 0,04 100

10p20R5 0,14 0,48 0,09 100 10p40R8 0,14 0,27 0,03 100

10p20R6 0,15 3,25 0,47 100 10p40R9 1,53 31,92 7,2 100

90

Tabela 38 – (continuação) Resultados do Memetico1 para os casos de teste do RanPuz com tamanho 10 x 10

Casos de

teste

Min Max Desvio

padrão

% Casos de

teste

Min Max Desvio

padrão

%

10p20R7 0,13 0,6 0,09 100 10p50R2 0,16 0,3 0,04 100

10p20R8 0,13 0,23 0,04 100 10p50R3 0,16 0,28 0,04 100

10p20R9 0,13 0,62 0,1 100 10p50R4 0,29 0,3 0 100

10p30R0 0,15 1,86 0,46 100 10p50R5 0,32 1,14 0,23 100

10p30R1 0,17 4,47 0,82 100 10p50R6 0,16 0,3 0,04 100


apenas as regras lógicas. O resultado do Memetico1 para os demais casos de teste com

tamanhos 20 x 20 são exibidos na Tabela 39. De acordo com os resultados da mesma,

observa-se que os puzzles 20 x 20 com são os com maior dificuldade para a

abordagem. Para os demais puzzles o algoritmo soluciona-os na maioria das execuções.

O tempo gasto nas execuções do algoritmo foi, no geral, elevado.


Casos de

teste

Min Max Desvio

padrão

% Casos de

teste

Min Max Desvio

padrão

%

20p10R0 0,99 10,38 3,14 100 20p30R5 348,71 2128,64 373,99 95

20p10R1 1 22,7 5,68 100 20p30R6 217,74 508,66 81,08 100

20p10R2 0,88 5,27 1,15 100 20p30R7 270,14 3165,68 999,33 80

20p10R3 2,14 16,86 3,81 100 20p30R8 324,71 866,65 145,34 100

20p10R4 1,37 2,47 0,31 100 20p30R9 441,42 965,72 157,82 100

20p10R5 0,8 1,86 0,29 100 20p40R0 1806,97 2401,01 156,28 0

20p10R6 1,18 6,28 1,37 100 20p40R1 1578,66 2138,37 193,07 0

20p10R7 0,8 5,85 1,3 100 20p40R2 2046,16 2357,56 112,23 0

20p10R8 2,12 14,99 3,52 100 20p40R3 2220,4 2406,11 63,16 0

20p10R9 1,4 7,25 1,71 100 20p40R4 382,92 2321,07 744 15

20p20R0 29,22 530,22 131,68 100 20p40R5 299,98 2109,4 667,89 5

20p20R1 89,43 478,76 100,73 100 20p40R6 1660,51 2222,78 231,73 0

20p20R2 31,23 197,64 46,09 100 20p40R7 1542,73 2389,6 312,9 0

20p20R3 12,62 327,02 94,47 100 20p40R8 1417,19 1522,6 39,77 0

20p20R4 30,66 206,45 45,68 100 20p40R9 1451,53 1483,94 11 0

20p20R5 38,29 172,04 31,76 100 20p50R0 177,34 1852,09 467,33 20

20p20R6 30,45 250,74 57,81 100 20p50R1 1,58 3,59 0,55 100

20p20R7 38,48 500,97 112,84 100 20p50R2 122,88 1507,75 557,41 40

20p20R8 28,36 407,11 99,27 100 20p50R3 59,12 457,6 147,03 100

20p20R9 46,03 620,57 120,67 100 20p50R4 71,34 333,77 94,26 100

20p30R0 253,72 558,04 77,57 100 20p50R5 60,22 596,59 153,53 100

20p30R1 364,19 1001,67 144,46 100 20p50R6 122,79 1947,89 620,67 50

20p30R2 243,78 2460,67 460,41 100 20p50R7 53,1 172,93 37,75 100

20p30R3 316,4 2315,52 415,3 95 20p50R8 91,8 1965 737,28 80

20p30R4 292,06 981,65 159,05 100 20p50R9 26,95 68,41 13,15 100


apenas as regras lógicas. O resultado do Memético para os demais casos de teste com

tamanho 30 x 30 são exibidos na Tabela 40. Percebe-se que, para esses casos de teste, a

abordagem apenas soluciona os com 10 e 30 por cento de pixels pretos, para os demais,

91

a abordagem não consegue encontrar a solução do puzzle. O tempo de execução do

algoritmo para puzzles 30 x 30 é no geral elevado.


Casos de

teste

Min Max Desvio

padrão

% Casos de

teste

Min Max Desvio

padrão

%

30p10R0 36,01 280,89 53,69 100 30p30R5 2808,99 5283,39 692,83 50

30p10R1 79,52 441,89 92,19 100 30p30R6 2252,41 5762,9 573,21 45

30p10R2 11,56 246,46 53,09 100 30p30R7 3501,63 5240,9 573,21 50

30p10R3 290,65 1947,98 422,08 100 30p30R8 1716,26 5097,84 508,77 80

30p10R4 14,56 267,19 55,35 100 30p30R9 4079,79 5930,84 508,77 30

30p10R5 57,56 267,19 55,35 100 30p40R0 4087,12 4506,51 139,4 0

30p10R6 150,06 563,24 105,02 100 30p40R1 3769,8 4248,74 154,75 0

30p10R7 13,89 180,71 42,32 100 30p40R2 3894,84 4315,92 148,36 0

30p10R8 51,19 257,61 55,66 100 30p40R3 2665,1 4112,89 592,75 0

30p10R9 119,53 651,1 113,38 100 30p40R4 2792,97 3983,49 441,56 0

30p20R0 6108,5 7751,27 512,05 0 30p40R5 3290,72 3919,54 212,2 0

30p20R1 7352,72 8375,99 375,89 0 30p40R6 3345,32 4120,74 227,2 0

30p20R2 7096,53 7751,25 258,35 0 30p40R7 3395,35 3923,34 177,86 0

30p20R3 7101,35 8581,49 551,97 0 30p40R8 3319,98 3987,45 198,84 0

30p20R4 6973,54 7340,53 186,72 0 30p40R9 3413,35 4103,71 208,24 0

30p20R5 6840,78 7957,02 393,87 0 30p50R0 3123,65 3550,12 112,63 0

30p20R6 6982,33 8959,71 753,84 0 30p50R1 2788,21 3365,32 186,41 0

30p20R7 7461,8 7954,27 175,15 0 30p50R2 3209,12 3314,82 34,96 0

30p20R8 8050,17 8413,01 147,34 0 30p50R3 3210,86 3572,15 129,55 0

30p20R9 4967,56 6899,91 791,52 0 30p50R4 3143,77 3304,01 55,73 0

30p30R0 1685,96 5304,20 936,46 85 30p50R5 3295,16 3438,67 52,69 0

30p30R1 2387,28 5698,85 768,33 35 30p50R6 3224,35 3601,6 139,85 0

30p30R2 3640,12 5172,66 485,94 25 30p50R7 2030,23 3202,74 413,46 0

30p30R3 2740,71 5730,53 860,15 40 30p50R8 2193,1 3288,92 427,7 0

30p30R4 3037,44 5576,04 724,35 45 30p50R9 2256,94 3512,56 494,39 0

Em suma, o Memetico1 consegue solucionar puzzles 10 x 10 com um tempo

de execução baixo, e os 20 x 20 com o tempo de execução um pouco elevado. Já para os

30 x 30, só consegue solucionar os puzzles com 10 e 30 por cento de pixels pretos.

7.2.3 Memetico2

As Tabelas 47 a 52 mostram os resultados do algoritmos Memetico2 para os

casos de teste do Benchmark puzzles (2012), Nonogram Solver (2012) e RanPuz. O

algoritmo Memetico2 foi executado 20 vezes. A primeira coluna exibe os casos de

teste, na segunda tem-se o menor do tempo em segundos para as 20 execuções (Min), a

terceira coluna exibe o maior tempo (Max), a quarta o desvio padrão do tempo em

segundos e na quinta tem-se o percentual de vezes que o algoritmo solucionou o caso de

teste correspondente.

92

A Tabela 41 exibe os resultados para os casos de teste do Benchmark puzzles

(2012). Em todas as execuções do Memetico2 para os casos de teste do Benchmark

puzzles (2012), a abordagem encontra a solução correta de todos os puzzle em todas as

execuções. Observa-se que o tempo gasto para encontrar a solução é aceitável.

Tabela 41 – Resultados do Memetico2 para os casos de teste do Benchmark puzzles (2012)

Caso de

teste

Min Max Desvio

padrão % Caso de

teste

Min Max Desvio

padrão %

222 0,66 7,71 2,3 100 230 1,88 12,74 3,27 100

223 0,68 15,62 4,88 100 231 3,56 10,9 2,13 100

224 0,46 10,4 3,09 100 232 5,82 19,91 4,2 100

225 0,73 5,33 1,4 100 233 2,68 16,47 4,16 100

226 0,31 3,77 1,05 100 234 0,5 6,51 1,77 100

227 0,48 2,39 0,59 100 235 3,59 10,4 1,97 100

228 0,47 11,18 3,72 100 236 1,3 14,5 4,34 100

229 4,72 11,62 2,2 100 237 3,23 13,5 3,65 100

De acordo com os resultados da Tabela 42, a abordagem Memetico2 consegue

encontrar a solução para 12 casos de teste do Nonogram Solver (2012) em todas as

execuções do algoritmo, e apenas um caso de teste a abordagem não consegue encontrar

a solução do puzzle. Observa-se que o tempo gasto pelo Memetico2 é no geral

aceitável.

Tabela 42 – Resultados do Memetico2 para os casos de teste do Nonogram Solver (2012)

Caso de

teste

Min Max Desvio

padrão % Caso de

teste

Min Max Desvio

padrão %

Lancs_3 14,34 52,35 13,62 100 Lancs_19 2669,25 4134,19 576,56 0

Lancs_6 6,05 36,04 9,32 100 Lancs_20 257,71 3191,1 1099,15 100

Lancs_7 43,9 87,54 15,5 100 Lancs_21 17,89 42,01 6,73 100

Lancs_8 0,84 0,85 0 100 Lancs_25 0,12 0,16 0,01 100

Lancs_14 252,43 534,23 78,83 100 Lancs_26 100,15 145,75 13,04 100

Lancs_15 96,7 2864,41 815,43 90 Lancs_27 181,83 4154,51 1813,42 50

Lancs_16 4,45 20,8 5,46 100 Lancs_28 8,56 19,7 3,62 100

Lancs_18 38,14 189,58 40,65 100

De acordo com os resultados da Tabela 43 percebe-se que para o Memetico2

consegue solucionar todos os casos de teste aleatórios com tamanho 10 x 10 em todas as

execuções do algoritmo. O tempo gasto para esses casos de teste nesta abordagem foi

aceitável, no geral inferior a um segundo.

93


Casos de

teste

Min Max Desvio

padrão

% Casos de

teste

Min Max Desvio

padrão

%

10p10R0 0,08 0,15 0,03 100 10p30R2 0,18 2,11 0,58 100

10p10R1 0,08 0,15 0,03 100 10p30R3 0,14 0,42 0,08 100

10p10R2 0,09 0,18 0,04 100 10p30R4 0,16 1,36 0,29 100

10p10R3 0,08 0,16 0,03 100 10p30R5 0,25 3,98 1,02 100

10p10R4 0,08 0,15 0,03 100 10p30R6 1,4 26,85 7,69 100

10p10R5 0,09 0,17 0,04 100 10p30R7 0,43 6,91 1,7 100

10p10R6 0,08 0,16 0,03 100 10p30R8 0,13 0,26 0,06 100

10p10R7 0,08 0,15 0,03 100 10p30R9 0,17 4,25 1,22 100

10p10R8 0,09 0,19 0,04 100 10p40R1 0,15 0,57 0,12 100

10p10R9 0,09 0,18 0,04 100 10p40R2 0,17 1,76 0,51 100

10p20R0 0,12 0,72 0,19 100 10p40R3 0,15 0,47 0,1 100

10p20R1 0,13 0,23 0,03 100 10p40R4 0,2 4,32 1,21 100

10p20R2 0,13 0,16 0,01 100 10p40R5 2,22 4,32 1,21 100

10p20R3 0,12 0,19 0,02 100 10p40R6 0,15 0,47 0,1 100

10p20R4 0,13 0,14 0 100 10p40R7 0,16 0,42 0,08 100

10p20R5 0,13 0,16 0,01 100 10p40R8 0,14 0,27 0,06 100

10p20R6 0,15 0,33 0,06 100 10p40R9 1,2 15,57 4,21 100

10p20R7 0,12 0,19 0,02 100 10p50R2 0,16 0,24 0,03 100

10p20R8 0,12 0,12 0 100 10p50R3 0,15 0,17 0 100

10p20R9 0,12 0,35 0,07 100 10p50R4 0,16 0,29 0,05 100

10p30R0 0,14 1,51 0,38 100 10p50R5 0,21 0,56 0,1 100

10p30R1 0,21 2,2 0,53 100 10p50R6 0,16 0,29 0,06 100

A Tabela 44 exibe os resultados para os casos de teste do RanPuz com tamanho

20 x 20. Observa-se que a abordagem tem mais dificuldade em resolver puzzles 20 x 20

com 40 por cento de pixels pretos. Para os demais casos de teste, no geral, o algoritmo

encontrou a solução dos mesmos em 100% das execuções. O tempo de execução do

Memetico2 foi elevado para alguns casos de teste.


Casos de

teste

Min Max Desvio

padrão

% Casos de

teste

Min Max Desvio

padrão

%

20p10R0 0,9 5,31 1,4 100 20p30R5 274,34 464,82 54,34 100

20p10R1 5,86 22,94 5,15 100 20p30R6 259,49 442,31 50,89 100

20p10R2 0,75 2,12 0,47 100 20p30R7 181,83 649,61 133,21 100

20p10R3 1,86 7,02 1,82 100 20p30R8 328,06 818,53 131,96 100

20p10R4 0,83 0,96 0,05 100 20p30R9 214,42 505,02 83,05 100

20p10R5 0,83 5,32 1,72 100 20p40R0 684,79 2847,06 822,79 20

20p10R6 0,82 2,68 0,58 100 20p40R1 434,79 2832,45 1035,71 40

20p10R7 1,05 1,99 0,41 100 20p40R2 440,87 3087,49 1207,58 50

20p10R8 1,63 6,87 1,88 100 20p40R3 2357,14 2651,25 121,01 0

20p10R9 0,94 5,34 1,52 100 20p40R4 199,12 595,82 140,49 100

20p20R0 37,54 318,69 84,52 100 20p40R5 300,69 534,01 90,37 100

20p20R1 116,89 410,34 79,36 100 20p40R6 2416,61 2951,42 217,86 0

20p20R2 55,72 248,69 52 100 20p40R7 2387,18 2858,69 185,97 0

20p20R3 52,94 311,52 71,08 100 20p40R8 269,24 2561,24 888,09 80

20p20R4 25,33 146,04 36,12 100 20p40R9 1768,67 2796,12 513,83 0

20p20R5 34,48 120,69 26,63 100 20p50R0 224 1918,09 579,83 30

20p20R6 38,92 169,38 41,23 100 20p50R1 1,03 1,8 0,33 100

94

Tabela 44 – (continuação) Resultados do Memetico2 para os casos de teste do RanPuz com tamanho 20 x 20

Casos de

teste

Min Max Desvio

padrão

% Casos de

teste

Min Max Desvio

padrão

%

20p20R7 52,37 294,04 83,96 100 20p50R2 189,27 2419,45 681,92 45

20p20R8 109,89 209,66 33,1 100 20p50R3 74,85 185,92 30,92 100

20p20R9 35,49 324,56 86 100 20p50R4 42,09 415,85 100,49 100

20p30R0 263,18 438,66 53,32 100 20p50R5 59,59 89,85 9,71 100

20p30R1 415,25 1008,94 188,7 100 20p50R6 144,81 237,04 28,46 100

20p30R2 297,49 736,03 121,53 100 20p50R7 66,31 94,26 8,36 100

20p30R3 273,15 580,22 90,42 100 20p50R8 117,02 618,57 142,34 100

20p30R4 197,67 447,82 79,52 100 20p50R9 25,04 47,34 6,78 100

A Tabela 45 exibe os resultados para os casos de teste do RanPuz com tamanho

30 x 30. Percebe-se que, para esses casos de teste a abordagem apenas soluciona os com

10, 20 e 30 por cento de pixels pretos, para os demais a abordagem não consegue

encontrar a solução do puzzle. O tempo de execução do algoritmo para puzzles 30 x 30 é

no geral elevado.


Casos de

teste

Min Max Desvio

padrão

% Casos de

teste

Min Max Desvio

padrão

%

30p10R0 59,98 197,43 47,44 100 30p30R5 3303,79 4968,4 477,46 30

30p10R1 54,34 550,08 137,6 100 30p30R6 2697,8 5264,36 716 80

30p10R2 43,36 273,56 73,49 100 30p30R7 2416,7 5097,95 908,51 70

30p10R3 389,15 1940,83 423,31 100 30p30R8 1866,29 5040,76 1129,25 90

30p10R4 10,79 123,41 32,72 100 30p30R9 2258,77 5499,45 1066,27 80

30p10R5 30,44 318,38 84,98 100 30p40R0 2546,23 4162,37 505,64 0

30p10R6 193,63 544,1 91,57 100 30p40R1 2422,46 3833,94 569,78 0

30p10R7 35,04 241,52 67,65 100 30p40R2 2602,59 3976,17 463,31 0

30p10R8 53,85 275,96 78,99 100 30p40R3 2609,67 4074,44 460,45 0

30p10R9 86,88 517,11 123,06 100 30p40R4 2621,15 3909,91 433,61 0

30p20R0 3155,82 8086,39 1549,82 30 30p40R5 2532,31 3939,49 434,92 0

30p20R1 3189,15 8636,98 1583,17 10 30p40R6 3611,02 4528,45 210,03 0

30p20R2 7166,25 8366,84 430,88 0 30p40R7 3254,48 4158,79 305,05 0

30p20R3 7842,2 9102,11 461,72 0 30p40R8 3244,57 4253,87 330,31 0

30p20R4 4559,58 7998,89 1013,15 10 30p40R9 3237,57 4302,18 367,22 0

30p20R5 3348,64 8464,48 1550,05 35 30p50R0 3053,84 3670,66 219,72 0

30p20R6 8039,44 9575,79 525,42 10 30p50R1 3001,43 3670,66 124,17 0

30p20R7 5073,12 8692,23 1139,76 20 30p50R2 2530,2 3480,41 326,26 0

30p20R8 5812,12 8560,4 981,79 0 30p50R3 2572,68 3383,35 309,98 0

30p20R9 4970,22 8404,98 1200,38 10 30p50R4 2707,71 3461,42 274,04 0

30p30R0 2201,77 4589,36 710,26 100 30p50R5 3124,2 3380,53 96,77 0

30p30R1 4312,44 5378,5 379,38 20 30p50R6 3009,68 3515,37 186,68 0

30p30R2 2949,7 5028,78 614,53 20 30p50R7 2324,7 3510,12 533,19 0

30p30R3 3371,52 5358,87 588,51 40 30p50R8 2446,48 3544,65 482,55 0

30p30R4 2521,71 5317,87 953,08 40 30p50R9 2390,55 3707,65 498,62 0

Em suma, o Memetico2 consegue solucionar puzzles 10 x 10 com um tempo

de execução baixo, e os 20 x 20 com o tempo de execução um pouco elevado. Já para os

30 x 30, só consegue solucionar os puzzles com 10 a 30 por cento de pixels pretos, com

95

o tempo de execução elevado.

7.3 Comparações

As comparações das abordagens propostas utilizam o teste de Mann-Whitney

com o nível de significância igual a 5%. Foram realizadas 20 execuções para cada

abordagem heurística. A Tabela 46 exibe os p-valores das comparações, dois a dois, das

abordagens heurísticas propostas neste trabalho para solucionar os casos de teste do

Benchmark puzzles (2012). Para esses casos de teste foi utilizado o tempo para realizar

as comparações, pois ao se utilizar o valor da função objetivo não há evidências para

diferenciar as abordagens, já que as mesmas sempre encontram a solução do puzzle.

Tabela 46 – p-valores em relação ao tempo para as comparações das heurísticas propostas para os casos de

teste do Benchmark puzzles (2012)

Caso

de

teste

Memetico1 x

TabuGrama

Memetico2 x

TabuGrama

Memetico2 x

Memetico1

Caso

de

teste

Memetico1 x

TabuGrama

Memetico2 x

TabuGrama

Memetico2 x

Memetico1

222 0,95 0,87 0,49 230 0,99 0,96 0,18

223 0,99 0,99 0,21 231 0,99 0,99 0,21

224 0,99 0,96 0,64 232 0,92 0,34 0,01

225 0,99 0,95 0,14 233 0,89 0,22 0,007

226 0,95 0,82 0,25 234 0,957 0,76 0,09

227 0,012 0,96 0,07 235 0,99 0,99 0,43

228 0,99 0,99 0,05 236 0,01 0,001 0,04

229 0,99 0,35 0,3 237 0,62 0,21 0,03

De acordo com os resultados dos p-valores da Tabela 46 para os casos de teste

do Benchmark puzzles (2012) em relação ao tempo, a heurística TabuGrama é mais

favorável do que o Memetico1, e o Memetico2 é mais favorável do que o Memetico1.

Em relação ao tempo, o TabuGrama mostrou-se mais favorável do que o Memetico1

para 12 casos de teste (p-valor 0,95), e mais favorável do que o Memetico2 para 8

casos de teste (p-valor 0,95). O Memetico2 mostrou-se mais favorável do que o

Memetico1 para 4 casos de teste (p-valor 0,05)

A Tabela 47 exibe os p-valores das comparações para os casos de teste do

Nonogram Solver (2012). Os campos da tabela com um X demonstram que ambas as

abordagens sempre encontram a solução para o caso de teste em questão. De acordo

com os resultados da Tabela 47, o Memetico1 e o Memetico2 são mais favoráveis do

que o TabuGrama, em relação à função objetivo, pois obtiveram, na maioria das

comparação, p-valores inferiores a 0,05. Já para o Memetico1 e o Memetico2 não há

evidências que os resultados da função objetivo seja, diferentes para os casos de teste do

Nonogram Solver (2012).

96

Tabela 47 – p-valores em relação à função objetivo para as comparações das heurísticas propostas para os

casos de teste do Nonogram Solver (2012)

Caso de

teste

Memetico1

x

TabuGrama

Memetico2

x

TabuGrama

Memetico2

x

Memetico1

Caso de

teste

Memetico1

x

TabuGrama

Memetico2

x

TabuGrama

Memetico2

x

Memetico1

Lancs_3 0,17 0,26 X Lancs_19 1,78X 6,51X 0,61

Lancs_6 X X X Lancs_20 5,75X 5,6X 0,18

Lancs_7 0,01 0,06 X Lancs_21 X X X

Lancs_8 X X X Lancs_25 X X X

Lancs_14 8,55X 5,87X X Lancs_26 3,89X 3,95X X

Lancs_15 1,17X 5,23X 0,14 Lancs_27 2,17X 5,56X 0,006

Lancs_16 X X X Lancs_28 X X X

Lancs_18 0,003 0,03 X

Para os casos de teste do RanPuz com tamanho 10 x 10, as três abordagens

sempre encontram a solução dos mesmos. Então, a Tabela 48 exibe os p-valores para a

comparação do tempo de execução de cada algoritmo. De acordo com os resultados da

Tabela 48, o TabuGrama é mais favorável do que o Memetico1 e o Memetico2, e o

Memetico2 é mais favorável do que o Memetico1, em relação ao tempo.

Tabela 48 – p-valores em relação ao tempo para as comparações das heurísticas propostas para os casos de

teste do RanPuz com o tamanho 10x10

Casos de

teste

Memetico1

x

TabuGrama

Memetico2

x

TabuGrama

Memetico2

x

Memetico1

Casos de

teste

Memetico1

x

TabuGrama

Memetico2

x

TabuGrama

Memetico2

x

Memetico1

10p10R0 0,99 0,99 0,01 10p30R2 0,98 0,98 0,001

10p10R1 0,99 0,99 0,16 10p30R3 0,99 0,98 0,88

10p10R2 0,99 0,99 0,2 10p30R4 0,98 0,99 0,28

10p10R3 0,99 0,99 0,08 10p30R5 0,99 0,99 0,16

10p10R4 0,99 0,99 0,9 10p30R6 0,99 0,94 0,02

10p10R5 1 0,99 0,66 10p30R7 0,99 0,99 0,02

10p10R6 0,99 0,99 0,94 10p30R8 1 1 0,28

10p10R7 0,99 0,99 0,67 10p30R9 0,99 0,99 0,08

10p10R8 0,99 0,99 0,06 10p40R1 0,99 0,99 0,17

10p10R9 0,99 0,99 0,3 10p40R2 0,99 0,99 0,45

10p20R0 0,67 0,14 0,01 10p40R3 0,98 0,92 0,04

10p20R1 0,99 0,99 0,0002 10p40R4 0,99 0,99 0,05

10p20R2 1 1 3,6X 10p40R5 0,74 0,55 0,01

10p20R3 0,99 1 0,004 10p40R6 0,99 0,99 0,49

10p20R4 1 1 1,59X 10p40R7 0,99 0,99 0,19

10p20R5 0,99 0,99 1,19X 10p40R8 1 1 0,49

10p20R6 0,99 0,99 0,002 10p40R9 0,93 0,75 0,05

10p20R7 1 0,99 1,74X 10p50R2 0,98 0,97 0,48

10p20R8 0,08 0,05 1,53X 10p50R3 0,99 0,99 0,25

10p20R9 0,98 0,18 2,47X 10p50R4 1 1 2,89X

10p30R0 0,99 0,81 0,02 10p50R5 0,99 0,97 0,0004

10p30R1 0,99 0,79 0,13 10p50R6 1 1 0,13

Para os casos de teste do RanPuz com tamanho 20 x 20 e 10 por cento de pixels

pretos, as três abordagens sempre encontram a solução dos mesmos. Os p-valores em

relação a função objetivo para os demais casos de teste são exibidos na Tabela 49. Os

campos da tabela com um X demonstra que ambas as abordagens sempre encontram a

97

solução para o caso de teste em questão. Observa-se que o Memetico1 e o Memetico2

são mais favoráveis do que o TabuGrama. O Memetico1 e o Memetico2 sempre

encontram a solução para os puzzles 20 x 20 com vinte por cento de pixels pretos. O

Memetico2 é mais favorável do que o TabuGrama, em relação à função objetivo.


casos de teste do RanPuz com o tamanho 20x20

Casos de

teste

Memetico1

x

TabuGrama

Memetico2

x

TabuGrama

Memetico2

x

Memetico1

Casos de

teste

Memetico1

x

TabuGrama

Memetico2

x

TabuGrama

Memetico2

x

Memetico1

20p20R0 2,54X 2,22X X 20p40R0 3,03X 0,0003 0,004

20p20R1 3,51X 6,34X X 20p40R1 0,0001 0,0003 0,01

20p20R2 X X X 20p40R2 0,0003 0,001 0,34

20p20R3 0,01 0,07 X 20p40R3 0,0003 0,001 0,4

20p20R4 X X X 20p40R4 0,0003 0,0003 0,08

20p20R5 X X X 20p40R5 0,0003 0,0003 0,01

20p20R6 0,01 0,07 X 20p40R6 0,0003 0,001 0,03

20p20R7 0,01 0,07 X 20p40R7 0,0003 0,0003 0,02

20p20R8 0,17 0,26 X 20p40R8 0,0003 0,0003 0,004

20p20R9 9,69X 0,0001 X 20p40R9 0,0003 0,003 0,22

20p30R0 7,92X 2,06X X 20p50R0 5,54X 5,51X 0,29

20p30R1 8,54X 2,19X X 20p50R1 X X X

20p30R2 7,9X 2,05X X 20p50R2 0,0003 1,18X 0,47

20p30R3 8,01X 1,99X 0,26 20p50R3 0,0003 4,04X X

20p30R4 7,87X 2,05X X 20p50R4 0,0003 4,06X X

20p30R5 7,52X 1,88X 0,26 20p50R5 3,95X 3,95X X

20p30R6 7,25X 1,91X X 20p50R6 5,67X 0,15X 0,01

20p30R7 9,57X 2,08X 0,07 20p50R7 4,05X 4,05X X

20p30R8 7,94X 2,06X X 20p50R8 4,88X 4,03X 0,08

20p30R9 1,91X 2,91X X 20p50R9 4,01X 4,01X X

Para os casos de teste do RanPuz com tamanho 30 x 30 e 10 por cento de pixels

pretos, as três abordagens sempre encontram a solução dos mesmos. Os p-valores em

relação à função objetivo para os demais casos de teste são exibidos na Tabela 50.

Observa-se que o Memetico1 e o Memetico2 são mais favoráveis do que o

TabuGrama, e o Memetico2 é mais favorável do que o Memetico1, em relação à

função objetivo.


casos de teste do RanPuz com o tamanho 30x30

Casos de

teste

Memetico1

x

TabuGrama

Memetico2

x

TabuGrama

Memetico2

x

Memetico1

Casos de

teste

Memetico1

x

TabuGrama

Memetico2

x

TabuGrama

Memetico2

x

Memetico1

30p20R0 9,11X 4,99X 0,03 30p40R0 5,96X 5,96X 0,16

30p20R1 2,52X 5,38X 0,004 30p40R1 5,91X 5,96X 0,2

30p20R2 0,0005 1,16X 0,52 30p40R2 5,97X 5,96X 0,75

30p20R3 0,0003 5,31X 0,44 30p40R3 5,91X 5,89X 0,75

30p20R4 0,0003 5,44 X 0,15 30p40R4 5,97X 5,96X 0,08

30p20R5 0,0003 4,71X 0,007 30p40R5 5,95X 5,97X 0,77

30p20R6 0,0003 1,04X 0,38 30p40R6 5,97X 5,91X 0,1

98

Tabela 50 – (continuação) p-valores em relação à função objetivo para as comparações das heurísticas

propostas para os casos de teste do RanPuz com o tamanho 30x3

Casos de

teste

Memetico1

x

TabuGrama

Memetico2

x

TabuGrama

Memetico2

x

Memetico1

Casos de

teste

Memetico1

x

TabuGrama

Memetico2

x

TabuGrama

Memetico2

x

Memetico1

30p20R7 0,0003 5,27X 0,05 30p40R7 5,97X 5,96X 0,05

30p20R8 0,0003 5,41X 0,68 30p40R8 5,93X 5,95X 0,008

30p20R9 0,003 1,15X 0,1 30p40R9 5,95X 5,97X 0,31

30p30R0 9,69X 4,04X 0,11 30p50R0 5,03X 0,0003 0,12

30p30R1 2,87X 5,52X 0,37 30p50R1 3,11X 0,0003 0,08

30p30R2 2,88X 5,49X 0,31 30p50R2 0,0004 0,0004 0,15

30p30R3 2,72X 5,75X 0,59 30p50R3 0,0003 0,0003 0,003

30p30R4 2,38X 5,71X 0,25 30p50R4 1,88X 1,88X 0,07

30p30R5 2,62X 5,61X 0,44 30p50R5 1,88X 0,0003 0,01

30p30R6 2,36X 4,82X 0,03 30p50R6 0,0003 0,0003 0,34

30p30R7 5,58X 4,25X 0,23 30p50R7 1,88X 1,88X 0,02

30p30R8 4,91X 4,52X 0,25 30p50R8 0,0003 0,0003 0,79

30p30R9 5,72X 4,92X 0,006 30p50R9 0,0003 0,0003 0,05

Em suma, percebe-se que o Memetico2 foi a abordagem mais favorável,

mostrando que os procedimentos AlteraPixel( ) e AlteraRowCol( ) foram de relevância.

99

8 Conclusão

O Nonograma é um jogo de quebra-cabeça, que assume a forma de uma grade

N x M com números situados à esquerda das linhas e no topo das colunas. No

Nonograma preto-e-branco os números ao lado das linhas e acima das colunas dão

informação sobre quantas células têm de ser preenchidas na mesma linha ou na mesma

coluna, respectivamente, na ordem em que os números aparecem. Com dois ou mais

números os blocos de células na grade devem ser separados por pelo menos um pixel

em branco.

O Nonograma é um problema bastante interessante para ser usado como

ferramenta para o ensino de algoritmos evolucionários, como visto na literatura

(Salcedo-Sanz et al., 2007; Tsai et al., 2011). O estudo algoritmo para a resolução do

Nonograma ainda é um assunto pouco explanado na literatura atual, tornando o estudo

do tema mais difícil e desafiador.

Foram implementadas as regras lógicas de Jing et al. (2009), uma busca em

profundidade, o Las Vegas e o Nonograma como o problema de Satisfação de

Restrições. Percebe-se que as abordagens exatas só são eficientes para Nonogramas

pequenos ou lógicos. Já para os Nonogramas maiores e aleatórios, o tempo

computacional gasto por uma abordagem exata é muito elevado e no geral ocorre um

vazamento de memória, explicando assim a utilização de uma heurística para solucionar

o problema.

Com o intuito de tentar solucionar Nonogramas maiores e aleatórios, neste

trabalho foram propostas abordagens heurísticas. As abordagens propostas são testadas

em 234 casos de teste de tamanho entre 5 x 5 e 100 x 100, incluindo Nonogramas

lógicos e aleatórios. Batenburg e Kosters (2009) apresentaram um gráfico com os

resultados do algoritmo proposto para puzzles aleatórios com tamanho 30 x 30.

100

Figura 33 – (a) Número médio de pixels não resolvidos para puzzles 30 x 30 gerados aleatoriamente, para uma6

porcentagem variável de pixels pretos, ao usar o Solver1; barras de erro indicam desvio padrão. (b) Como em

(a) para FullSettle (topo do gráfico), Solver0 (meio do gráfico) e Solver1, sem o desvio padrão

De acordo com a Figura 33, a abordagem proposta por Batenburg e Kosters

(2009), não consegue resolver puzzles com tamanho 30x30 e a porcentagem de pixel

pretos variando de 0 a 50 por cento. Neste trabalho é utilizado o mesmo gerador

(RanPuz) do trabalho de Batenburg e Kosters (2009).

Foram apresentados três algoritmos heurísticos, sendo uma a Busca Tabu e

duas abordagens do Memético. O TabuGrama não se mostrou eficiente ao resolver

puzzles maiores. Das duas abordagens do Memético propostas o Memetico2 mostrou-se

mais favorável do que o Memetico1, concluindo que os novos procedimentos

(AlteraPixel( ) e AlteraRowCol( )) foram de relevância para a abordagem. Porém há

uma necessidade de um estudo mais detalhado desses procedimentos, com o intuito de

aprimorar o Memetico2. As abordegens Memetico1 e Memetico2 solucionam puzzles

aleatórios de tamanhos 30 x 30, os quais a abordagem de Batenburg e Kosters (2009)

não soluciona.

8.2 Trabalhos Futuros

Como trabalhos futuros, deverão ser feitos novos estudos sobre as características

dos Nonogramas, aumentar os tamanhos dos mesmos e implementar novos métodos de

busca local que possam ajudar na solução do puzzle. Também há planos de se estender a

abordagem a Nonogramas coloridos.

O problema da Tomografia Discreta (Discrete Tomography - DT) pode ser um

modelo para diversos problemas reais, como no campo da engenharia médica (Wang e

101

Lu, 1992). Tem-se o objetivo de adaptar as metaheurísticas propostas neste trabalho ao

problema da Tomografia Discreta.

O estudo dos parâmetros deve ser ampliado, para chegar na melhor configuração

de cada algoritmo proposto. As heurísticas propostas gastam um tempo elevado para

resolver puzzles maiores, essa limitação deve ser estudada e novas técnicas

implementadas para tentar reduzir o tempo gasto pelas abordagens.

102

Referências

BATENBURG, K. J., & KOSTERS, W. A. A discrete tomography approach to

Japanese puzzles. Proceedings of the Belgian-Dutch Conference on Artificial

Intelligence, p. 243-250, 2004.

BATENBURG, K. J. An evolutionary Algorithm for Discrete Tomography. Discrete

Applied Mathematics, v. 151, n. 1-3, p. 36-54, 2005.

BATENBURG, K. J., & KOSTERS, W. A. Solving Nonograms by combining

relaxations. Advances in combinatorial image analysis, v. 42, n. 8, p. 1672-1683, 2009.

BENCHMARCK PUZZLES. Acesso em 18 de jullho 2012. Disponível em

http://homepages.cwi.nl/~aeb/games/jpuzzlegraded/index.html.

BENTON, J.; SNOW, R.; WALLACH, N. A combinatorial problem associated with

nonograms. Linear Algebra and its Applications, v. 412, p. 30-38, 2005.

BIEDL, T. et al. The Complexity of Clickomania. More Games of No Chance (R.

Nowakowski), p. 384-404, 2002.

BOSCH, R. A. Painting by numbers, Mathematical Programming Society Newsletter,

OPTIMA 65, p. 16-17, 2000.

CONCEPTIS PUZZLES. Pic-a-Pix. Acesso em 18 jul. 2012. Disponível em::

http://www.conceptispuzzles.com/.

CORMODE, G. The hardness of the lemmings game, or Oh no, more NP-completeness

proofs. Proceedings of Third International Conference on Fun with Algorithms, p. 65-

76, 2004.

DOR, D.; ZWICK, U. SOKOBAN and other motion planning problems. Computational

Geometry: Theory and Applications, v. 13, n. 4, p. 215-228, 1999.

DORANT, M. Pic-a-Pix Tutorial and Walkthroughs. Acesso em 12 de Jan. 2012,

disponível em: Conceptis Puzzle: http://conceptispuzzles.com, 2005.

EÉN, N.; SORENSSON, N. An Extensible SAT-solver. The MiniSat page. Acesso em

26 de Ab. 2012. Disponível em: http://minisat.se/MiniSat.html, 2003.

103

FRAENKEL, A. S.; JOHNSON, D. S.; SCHAEFER, T.; & Yesha, Y. The complexity

of checkers on an NxN board - preliminary report. Proceedings of 19th Annual

Symposium on Fundations of Computer Science, p. 55-64, 1978.

FRAENKEL, A. S.; LICHTENSTEIN, D. Computing a perfect strategy fo NxN chess

requires time exponential in n. Jornal of Combinatory Theory, v. 31 (Series A), p. 199-

214, 1981.

FRIEDMAN, E. Spiral Galaxies Puzzles are NP-complete. Disponível em

http://www2.stetson.edu/˜efriedma/papers/spiral.pdf. Acesso em 9 de Jan. 2012.

GERBRANDS, C.; SLUMP, J. A network flow approach to reconstruction of the left

ventricle from two projections. Computer Graphics and Image Processing, v. 18, p. 18-

36, 1982.

GLOVER, F. Future paths for integer programming and links to artificial intelligence,

Computers & Operations Research, v. 13, p. 533-549, 1986.

GLOVER, F. Tabu search – Part I, ORSA Journal on Computing, v. 1, p. 190-206,

1989.

GLOVER, F.; LAGUNA, M. Tabu Search. Kluwer Academic Publishers, 1997.

GOLDBARG, M. C; TAUMATURGO, C. N. O; GOLDBARG, E. F. G. Algoritmo

Busca Tabu para a solução do Nonograma. XLIII Simpósio Brasileiro de PESQUISA

OPERACIONAL, 2011.

GOLDBERG, D. E.; VOESSNER, S. Optimizing global-local search hybrids. GECCO,

p. 220-228, 1999.

HANSEN, P. The steepest ascent mildest descent heuristic for combinatorial

programming. Congress on Numerical Methods in Combinatorial Optimization, Capri,

Italy, 1986.

HATTORI. Acesso em 18 de jul. 2012. Disponível em

http://www.hattori.m78/puzzles/java/stage_01/index.html.

HERIK, H. J.; VAN DEN, H.; IIDA, H. Games in AI Research. University Maastricht,

2000.

104

HOLZER, M.; HOLZER, W. Tantrix rotation puzzles are intractable. Discrete Applied

Mathematics, v. 144, n. 3, 2004.

HOOGEBOOM, H. J.; KOSTERS, W. A. Tetris and decidability. Information

Processing Letter, v. 89, n. 6, p. 267-272, 2004.

JEFFERSON, C. et al. Modelling and solving english peg solitaire. Computers &

Operations Research, v. 33, n. 10, p. 2935-2959, 2006.

JING, M-Q. et al. Solving japanese puzzles with logical rules and depth first search

algorithm, Proceedings of the Eighth International Conference on Machine Learning

and Cybernetics, Baoding, p. 2962-2967, 2009.

JONG, K. A.; SPEARS, W. M. Using genetic algorithm to solve np-complete problems.

In Proc. of the Third Int. Conf. on Genetic Algorithms, p. 24-132, 1989.

KAYE, R. Minesweeper is NP-complete. Mathematical Intelligencer, v. 22, p. 9-15,

2000.

KEMPE, D. On the complexity of the Reflections game. Acesso em 9 de Jan. 2012,

disponível em http://www-bcf.usc.edu/~dkempe/publications/reflections.pdf, 2003.

KHOO, A.; ZUBEK, R. Applying inexpensive AI techniques to computer games. IEEE

Intelligent System, v. 17, n. 4, p. 48-53, 2002.

KISIELOWSKI, C. et al. An approach to quantitative high-resolution transmission

electron microscopy of crystalline materials. Ultramicroscopy, v. 58, p. 131-155, 1995.

KRÁL, D. et al. It is tough to be a plumber. Theoretical Computer Science, v. 313, n. 3,

p. 473-484, 2004.

LAIRD, J. E. Using a computer game to develop advanced AI. IEEE Computer, v. 34,

n. 7, p. 70-75, 2001.

LICHTENSTEIN, D.; SPISER, M. GO is polynomial-space hard. Journal of the ACM,

v. 27, n. 2, p. 393-401, 1980.

LUCAS, S. S.; KENDALL, G. Evolutionary computation and games. IEEE

Computational Intelligence Magazine, v. 1, n. 1, p. 10-18, 2006.

105

McPHAIL, B. P. The Complexity of Puzzles: NP-Completeness Results for Nurikabe

and Minesweeper. Thesis for BA, Division of Mathematics and Natural Sciences, Reed

College. 2003.

McPHAIL, B. Light Up is NP-Complete. Acesso em 9 de Jan. 2012, disponível em

http://www.cs.umass.edu/~mcphailb/papers/2005lightup.pdf, (2005).

MONTEIRO, S. M. D. Algoritmos Evolucionários para o Problema da Configuração do

Traçado de Redes de Distribuição de Gás Natural. Manografia (Graduação em

Engenharia de Computação). Universidade Federal do Rio Grande do Norte, 2009.

MINGOTE, L. P. C. F. Solving Colored Nonograms. 2009. 98f. Dissertação (Mestrado

em Engenharia Informática). Faculdade de Ciência e Tecnologia, Universidade Nova de

Lisboa, Lisboa, 2009.

NONOGRAM SOLVER. Acesso em 18 de julho 2012. Disponível em:

http://www.comp.lancs.ac.uk/~ss/nonogram/.

OCHOA, A. Resolution of a combinatorial problem using cultural algorithms. Journal

of Computers, v. 4, n. 8, 2009.

ONNASCH, D.; Prause, G. Heart chamber reconstruction from biplane angiography. v.

17, n. 12, p. 385-401, 1999.

ORTIZ-GARCÍA, E. G. et al. Automated generation and visualization of picture-logic

puzzles. Computers and Graphics, v. 31, p. 750-760, 2007.

ORTIZ-GARCÍA, E. G. et al. Solving very difficult japanese puzzles with a hybrid

evolutionary-logic algorithm, Lecture Notes in Computer Science, v. 5361, p. 360-369,

2008.

ORTIZ-GARCÍA, E. G. et al. Improving the performance of evolutionary algorithms in

grid-based puzzles resolution, Evolutionary Intelligence, v. 2, n. 4, p. 169-181, 2009.

RYSER, H. J. Combinaorial properties of matrices zeros and ones. Canadian Jornal of

Mathematics, v. 9, p. 371-377, 1957.

SALCEDO-SANZ, S. et al. Teaching advanced features of evolutionary algorithms

using japanese puzzles. IEEE Transactions on Education, v. 50, n. 2, p. 151-156,

2007(a).

106

SALCEDO-SANZ, S. et al. Solving japanese puzzles with heuristics. Proceedings of

the 2007 IEEE Symposium on Computational Intelligence and Games, p. 224-231,

2007(b).

SCHWANDER, P. et al. Mapping projected potential, interfacial roughness, and

composition in general crystalline solids by quantitative transmission electron mi-

croscopy. Physical Review Letters, v. 71, p. 4150-4153, 1993.

SMITH, K. D. Dynamic programming and board games: A survey. European Journal

of Operational Research, v. 176, p. 1299–1318, 2007.

SOHN, Y.-S.; OH, K.; KIM, B. A Recognition Method of the Printed Alphabet by using

Nonogram Puzzle. 2007.

STUCKMAN, J.; ZHANG, G.-Q. Mastermind is NP-complete. INFOCOMP Journal of

Computer Science, v. 5, p. 25-28, 2006.

TAKAHIRO, S. The complexities of puzzles, cross sum and their another solution

problems (ASP). 2001. Dissertação, Department of Information Science, University of

Tokyo. 2001.

TSAI, J.-T. Solving Japanese nonograms by Taguchi-based genetic algorithm. Applied

Intelligence, v. 37, n. 3, p. 405-419, 2012.

TSAI, J.-T.; CHOU, P.-Y. Solving Japanese Puzzles by Genetic Algorithms. Machine

Learning and Cybernetics (ICMLC), v. 2, p. 785-788, 2011.

TSAI, J.-T.; CHOU, P.-Y.; FANG, J.-C. Learning Inteligent Genetic Algorithms Using

Japanese Nonogram. IEEE Transactions on Education, v. 55, n. 2, p. 164-168, 2012.

UEDA, N.; NAGAO, T. Np-completeness Results for Nonogram via Parsimonious

Reductions, 1996.

VACCARO, M.; GUEST, C. C. Planning an endgame move set for the game RISK: a

comparison of search algorithms. IEEE Transactions on Evolutionary Computation, v.

9, n. 6, p. 641-652, 2005.

WANG, W-S.; CHIAGO, T-C. Solving Eternity-II puzzles with a tabu search

algorithm, Proceedings of International Conference on Methaheuristics and Nature

Inspired Computing, META 2010, 2010.

107

WHITLEY, D. A genetic a;gorithm tutorial. Statistics and Computing, v. 4, p. 65-85,

1994.

WIGGERS, W. A comparison of a genetic algorithm and a depth first search algorithm

applied to Japanese nonograms. Proceedings of the first Twente student conference on

IT , 1-6, 2004.

WIKIPEDIA. Nonogram. Acesso em 21 de Jan. 2012. Disponível em Nonogram:

http://en.wikipedia.org/wiki/Nonogram.

YATO, T. On the NP-completeness of the slither link puzzle. IPSJ SIGNotes

Algorithms, v. 74, p. 25-32, 2000.

YATO, T.; SETA, T. Solving Eternity-II puzzles with tabu search algorithm.

Proceedings of International Conference on Metaheuristics and Nature Intired

Computing , META 2010, 2010

YU, C.-H.; LEE, H.-L.; CHEN, L.-H. An efficient algorithm for solving nonograms.

Applied Intelligence, v. 35, p. 18-31, 2009.

YEN, S.-J. et al. Optimization of Nonogram's Solvver by using an Efficient Algorithm.

International Conference on Technologies an Applications of Artificial Intelligence , p.

444-449, 2010.

uma investigação de algoritmos exatos e metaheurísticos ... · prof. dr. antônio carlos gay...

Documents