Post on 03-Dec-2018
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
DIMAp – Departamento de Informática e Matemática Aplicada
UFRN – Universidade Federal do Rio Grande do Norte
__________________________________________
Prof. Dr. Marco César Goldbarg
Examinador interno à Instituição
DIMAp – Departamento de Informática e Matemática Aplicada
UFRN – Universidade Federal do Rio Grande do Norte
__________________________________________
Prof.ª Dra. Iloneide Carlos de Oliveira Ramos
Examinadora externa ao Programa
DEST – Departamento de Estatística
UFRN – Universidade Federal do Rio Grande do Norte
__________________________________________
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 8 – Possibilidades da linha 2 ............................................................................................. 49
Figura 9 – Possibilidades da linha 3 ............................................................................................. 50
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 14 – Passo 2 da busca em profundidade com Backtracking ............................................ 52
Figura 15 – Passo 3 da busca em profundidade com Backtracking ............................................ 52
Figura 16 – Passo 4 da busca em profundidade com Backtracking ............................................ 52
Figura 17 – Passo 5 da busca em profundidade com Backtracking ............................................ 53
Figura 18 – Passo 6 da busca em profundidade com Backtracking ............................................ 53
Figura 19 – Passo 7 da busca em profundidade com Backtracking ............................................ 53
Figura 20 – Passo 8 da busca em profundidade com Backtracking ............................................ 53
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
Gráfico 6 – 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 10 x 10 .............................................. 38
Gráfico 7 – Quantidade de combinações para os casos de teste 20 x 20 do RanPuz ................. 39
Gráfico 8 – 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 20 x 20 .............................................. 39
Gráfico 9 – Quantidade de combinações para os casos de teste 30 x 30 do RanPuz ................. 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. ............................................. 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
Tabela 34 – Resultados do TabuGrama para os casos de teste do RanPuz com tamanho 20 x 20
............................................................................................................................................. 87
Tabela 35 – Resultados do TabuGrama para os casos de teste do RanPuz com tamanho 30 x 30
............................................................................................................................................. 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
Tabela 39 – Resultados do Memetico1 para os casos de teste do RanPuz com tamanho 20 x 20
............................................................................................................................................. 90
Tabela 40 – Resultados do Memetico1 para os casos de teste do RanPuz com tamanho 30 x 30
............................................................................................................................................. 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
Tabela 43 – Resultados do Memetico2 para os casos de teste do RanPuz com tamanho 10 x 10
............................................................................................................................................. 93
Tabela 44 – Resultados do Memetico2 para os casos de teste do RanPuz com tamanho 20 x 20
............................................................................................................................................. 93
Tabela 45 – Resultados do Memetico2 para os casos de teste do RanPuz com tamanho 30 x 30
............................................................................................................................................. 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
Tabela 49 – 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 20x20 ................................. 97
Tabela 50 – 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 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
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
Gráfico 6 – 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 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.
Gráfico 7 – Quantidade de combinações para os casos de teste 20 x 20 do RanPuz
Gráfico 8 – 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 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 9 – Quantidade de combinações para os casos de teste 30 x 30 do RanPuz
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
Casos de teste %RL Tempo Casos de teste %RL Tempo
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
Casos de teste %RL Tempo Casos de teste %RL Tempo
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
Figura 8 – Possibilidades da linha 2
50
Figura 9 – Possibilidades da linha 3
Figura 10 – Possibilidade da linha 4
Figura 11 – Possibilidades da linha 6
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).
Figura 14 – Passo 2 da busca em profundidade com Backtracking
Figura 15 – Passo 3 da busca em profundidade com Backtracking
Figura 16 – Passo 4 da busca em profundidade com Backtracking
53
Figura 17 – Passo 5 da busca em profundidade com Backtracking
Figura 18 – Passo 6 da busca em profundidade com Backtracking
Figura 19 – Passo 7 da busca em profundidade com Backtracking
Figura 20 – Passo 8 da busca em profundidade com Backtracking
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)
S2 ← 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()
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)
S2 ← SortearIndividuo (P)
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)
inserir S na população P
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)
Caso de teste 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)
Caso de teste 300 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)
Caso de teste 300 X 500 Caso de teste 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)
Caso de teste 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
Caso de teste 700 X 900 Caso de teste 700 X 900
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
Caso de teste 700 X 900 Caso de teste 700 X 900
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
Caso de teste 20 X 10
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
Tabela 33 – Resultados do TabuGrama 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
%
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
Tabela 34 – Resultados do TabuGrama 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
%
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.
Tabela 35 – 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
%
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.
Tabela 38 – 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
%
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
Os casos de testes com tamanho 20 x 20 e são solucionados utilizando
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.
Tabela 39 – Resultados do Memetico1 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
%
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
Os casos de testes com tamanho 30 x 30 e são solucionados utilizando
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.
Tabela 40 – Resultados do Memetico1 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
%
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
Tabela 43 – Resultados do Memetico2 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
%
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.
Tabela 44 – 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
%
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.
Tabela 45 – Resultados do Memetico2 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
%
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.
Tabela 49 – 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 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.
Tabela 50 – 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 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 recon- struction 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.