250 lines
6.7 KiB
Python
250 lines
6.7 KiB
Python
# Copyright 2010 Hakan Kjellerstrand hakank@bonetmail.com
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the 'License');
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an 'AS IS' BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
"""
|
|
|
|
Nonogram (Painting by numbers) in Google CP Solver.
|
|
|
|
http://en.wikipedia.org/wiki/Nonogram
|
|
'''
|
|
Nonograms or Paint by Numbers are picture logic puzzles in which cells in a
|
|
grid have to be colored or left blank according to numbers given at the
|
|
side of the grid to reveal a hidden picture. In this puzzle type, the
|
|
numbers measure how many unbroken lines of filled-in squares there are
|
|
in any given row or column. For example, a clue of '4 8 3' would mean
|
|
there are sets of four, eight, and three filled squares, in that order,
|
|
with at least one blank square between successive groups.
|
|
|
|
'''
|
|
|
|
See problem 12 at http://www.csplib.org/.
|
|
|
|
http://www.puzzlemuseum.com/nonogram.htm
|
|
|
|
Haskell solution:
|
|
http://twan.home.fmf.nl/blog/haskell/Nonograms.details
|
|
|
|
Brunetti, Sara & Daurat, Alain (2003)
|
|
'An algorithm reconstructing convex lattice sets'
|
|
http://geodisi.u-strasbg.fr/~daurat/papiers/tomoqconv.pdf
|
|
|
|
|
|
The Comet model (http://www.hakank.org/comet/nonogram_regular.co)
|
|
was a major influence when writing this Google CP solver model.
|
|
|
|
I have also blogged about the development of a Nonogram solver in Comet
|
|
using the regular constraint.
|
|
* 'Comet: Nonogram improved: solving problem P200 from 1:30 minutes
|
|
to about 1 second'
|
|
http://www.hakank.org/constraint_programming_blog/2009/03/comet_nonogram_improved_solvin_1.html
|
|
|
|
* 'Comet: regular constraint, a much faster Nonogram with the regular
|
|
constraint,
|
|
some OPL models, and more'
|
|
http://www.hakank.org/constraint_programming_blog/2009/02/comet_regular_constraint_a_muc_1.html
|
|
|
|
Compare with the other models:
|
|
* Gecode/R: http://www.hakank.org/gecode_r/nonogram.rb (using 'regexps')
|
|
* MiniZinc: http://www.hakank.org/minizinc/nonogram_regular.mzn
|
|
* MiniZinc: http://www.hakank.org/minizinc/nonogram_create_automaton.mzn
|
|
* MiniZinc: http://www.hakank.org/minizinc/nonogram_create_automaton2.mzn
|
|
Note: nonogram_create_automaton2.mzn is the preferred model
|
|
|
|
This model was created by Hakan Kjellerstrand (hakank@bonetmail.com)
|
|
Also see my other Google CP Solver models:
|
|
http://www.hakank.org/google_or_tools/
|
|
|
|
"""
|
|
|
|
import sys
|
|
|
|
from ortools.constraint_solver import pywrapcp
|
|
|
|
|
|
#
|
|
# Make a transition (automaton) list of tuples from a
|
|
# single pattern, e.g. [3,2,1]
|
|
#
|
|
def make_transition_tuples(pattern):
|
|
p_len = len(pattern)
|
|
num_states = p_len + sum(pattern)
|
|
|
|
tuples = pywrapcp.IntTupleSet(3)
|
|
|
|
# this is for handling 0-clues. It generates
|
|
# just the minimal state
|
|
if num_states == 0:
|
|
tuples.Insert3(1, 0, 1)
|
|
return (tuples, 1)
|
|
|
|
# convert pattern to a 0/1 pattern for easy handling of
|
|
# the states
|
|
tmp = [0]
|
|
c = 0
|
|
for pattern_index in range(p_len):
|
|
tmp.extend([1] * pattern[pattern_index])
|
|
tmp.append(0)
|
|
|
|
for i in range(num_states):
|
|
state = i + 1
|
|
if tmp[i] == 0:
|
|
tuples.Insert3(state, 0, state)
|
|
tuples.Insert3(state, 1, state + 1)
|
|
else:
|
|
if i < num_states - 1:
|
|
if tmp[i + 1] == 1:
|
|
tuples.Insert3(state, 1, state + 1)
|
|
else:
|
|
tuples.Insert3(state, 0, state + 1)
|
|
tuples.Insert3(num_states, 0, num_states)
|
|
return (tuples, num_states)
|
|
|
|
|
|
#
|
|
# check each rule by creating an automaton and transition constraint.
|
|
#
|
|
def check_rule(rules, y):
|
|
cleaned_rule = [rules[i] for i in range(len(rules)) if rules[i] > 0]
|
|
(transition_tuples, last_state) = make_transition_tuples(cleaned_rule)
|
|
|
|
initial_state = 1
|
|
accepting_states = [last_state]
|
|
|
|
solver = y[0].solver()
|
|
solver.Add(solver.TransitionConstraint(y,
|
|
transition_tuples,
|
|
initial_state,
|
|
accepting_states))
|
|
|
|
|
|
def main(rows, row_rule_len, row_rules, cols, col_rule_len, col_rules):
|
|
|
|
# Create the solver.
|
|
solver = pywrapcp.Solver('Regular test')
|
|
|
|
#
|
|
# variables
|
|
#
|
|
board = {}
|
|
for i in range(rows):
|
|
for j in range(cols):
|
|
board[i, j] = solver.IntVar(0, 1, 'board[%i, %i]' % (i, j))
|
|
board_flat = [board[i, j] for i in range(rows) for j in range(cols)]
|
|
|
|
# Flattened board for labeling.
|
|
# This labeling was inspired by a suggestion from
|
|
# Pascal Van Hentenryck about my Comet nonogram model.
|
|
board_label = []
|
|
if rows * row_rule_len < cols * col_rule_len:
|
|
for i in range(rows):
|
|
for j in range(cols):
|
|
board_label.append(board[i, j])
|
|
else:
|
|
for j in range(cols):
|
|
for i in range(rows):
|
|
board_label.append(board[i, j])
|
|
|
|
#
|
|
# constraints
|
|
#
|
|
for i in range(rows):
|
|
check_rule(row_rules[i], [board[i, j] for j in range(cols)])
|
|
|
|
for j in range(cols):
|
|
check_rule(col_rules[j], [board[i, j] for i in range(rows)])
|
|
|
|
#
|
|
# solution and search
|
|
#
|
|
db = solver.Phase(board_label,
|
|
solver.CHOOSE_FIRST_UNBOUND,
|
|
solver.ASSIGN_MIN_VALUE)
|
|
|
|
print 'before solver, wall time = ', solver.WallTime(), 'ms'
|
|
solver.NewSearch(db)
|
|
|
|
num_solutions = 0
|
|
while solver.NextSolution():
|
|
print
|
|
num_solutions += 1
|
|
for i in range(rows):
|
|
row = [board[i, j].Value() for j in range(cols)]
|
|
row_pres = []
|
|
for j in row:
|
|
if j == 1:
|
|
row_pres.append('#')
|
|
else:
|
|
row_pres.append(' ')
|
|
print ' ', ''.join(row_pres)
|
|
|
|
print
|
|
print ' ', '-' * cols
|
|
|
|
if num_solutions >= 2:
|
|
print '2 solutions is enough...'
|
|
break
|
|
|
|
solver.EndSearch()
|
|
print
|
|
print 'num_solutions:', num_solutions
|
|
print 'failures:', solver.Failures()
|
|
print 'branches:', solver.Branches()
|
|
print 'WallTime:', solver.WallTime(), 'ms'
|
|
|
|
|
|
#
|
|
# Default problem
|
|
#
|
|
# From http://twan.home.fmf.nl/blog/haskell/Nonograms.details
|
|
# The lambda picture
|
|
#
|
|
rows = 12
|
|
row_rule_len = 3
|
|
row_rules = [
|
|
[0, 0, 2],
|
|
[0, 1, 2],
|
|
[0, 1, 1],
|
|
[0, 0, 2],
|
|
[0, 0, 1],
|
|
[0, 0, 3],
|
|
[0, 0, 3],
|
|
[0, 2, 2],
|
|
[0, 2, 1],
|
|
[2, 2, 1],
|
|
[0, 2, 3],
|
|
[0, 2, 2]
|
|
]
|
|
|
|
cols = 10
|
|
col_rule_len = 2
|
|
col_rules = [
|
|
[2, 1],
|
|
[1, 3],
|
|
[2, 4],
|
|
[3, 4],
|
|
[0, 4],
|
|
[0, 3],
|
|
[0, 3],
|
|
[0, 3],
|
|
[0, 2],
|
|
[0, 2]
|
|
]
|
|
|
|
|
|
if __name__ == '__main__':
|
|
if len(sys.argv) > 1:
|
|
file = sys.argv[1]
|
|
execfile(file)
|
|
main(rows, row_rule_len, row_rules, cols, col_rule_len, col_rules)
|