मैं सैट सॉल्वरों की दुनिया में नया हूं और निम्नलिखित समस्या के बारे में कुछ मार्गदर्शन की आवश्यकता होगी।
उस पर विचार करना:
❶ मेरे पास 4 * 4 ग्रिड में 14 आसन्न कोशिकाओं का चयन है
❷ मैं 5 है polyominoes आकार 4, 2, 5, 2 और 1 के (ए, बी, सी, डी, ई)
❸ ये पॉलीओमीनो मुक्त होते हैं , अर्थात इनका आकार निश्चित नहीं होता है और ये विभिन्न पैटर्न बना सकते हैं
मैं एसएटी-सॉल्वर के साथ चयनित क्षेत्र (ग्रे में सेल) के अंदर इन 5 मुक्त पॉलीमिनोइन के सभी संभावित संयोजनों की गणना कैसे कर सकता हूं ?
@ स्पिंकस के आनंददायक उत्तर और OR- टूल डॉक्यूमेंटेशन दोनों से उधार लेकर मैं निम्नलिखित उदाहरण कोड (ज्यूपिटर नोटबुक में चलाता है) बना सकता हूं:
from ortools.sat.python import cp_model
import numpy as np
import more_itertools as mit
import matplotlib.pyplot as plt
%matplotlib inline
W, H = 4, 4 #Dimensions of grid
sizes = (4, 2, 5, 2, 1) #Size of each polyomino
labels = np.arange(len(sizes)) #Label of each polyomino
colors = ('#FA5454', '#21D3B6', '#3384FA', '#FFD256', '#62ECFA')
cdict = dict(zip(labels, colors)) #Color dictionary for plotting
inactiveCells = (0, 1) #Indices of disabled cells (in 1D)
activeCells = set(np.arange(W*H)).difference(inactiveCells) #Cells where polyominoes can be fitted
ranges = [(next(g), list(g)[-1]) for g in mit.consecutive_groups(activeCells)] #All intervals in the stack of active cells
def main():
model = cp_model.CpModel()
#Create an Int var for each cell of each polyomino constrained to be within Width and Height of grid.
pminos = [[] for s in sizes]
for idx, s in enumerate(sizes):
for i in range(s):
pminos[idx].append([model.NewIntVar(0, W-1, 'p%i'%idx + 'c%i'%i + 'x'), model.NewIntVar(0, H-1, 'p%i'%idx + 'c%i'%i + 'y')])
#Define the shapes by constraining the cells relative to each other
## 1st polyomino -> tetromino ##
# #
# #
# # #
# ### #
# #
################################
p0 = pminos[0]
model.Add(p0[1][0] == p0[0][0] + 1) #'x' of 2nd cell == 'x' of 1st cell + 1
model.Add(p0[2][0] == p0[1][0] + 1) #'x' of 3rd cell == 'x' of 2nd cell + 1
model.Add(p0[3][0] == p0[0][0] + 1) #'x' of 4th cell == 'x' of 1st cell + 1
model.Add(p0[1][1] == p0[0][1]) #'y' of 2nd cell = 'y' of 1st cell
model.Add(p0[2][1] == p0[1][1]) #'y' of 3rd cell = 'y' of 2nd cell
model.Add(p0[3][1] == p0[1][1] - 1) #'y' of 3rd cell = 'y' of 2nd cell - 1
## 2nd polyomino -> domino ##
# #
# #
# # #
# # #
# #
#############################
p1 = pminos[1]
model.Add(p1[1][0] == p1[0][0])
model.Add(p1[1][1] == p1[0][1] + 1)
## 3rd polyomino -> pentomino ##
# #
# ## #
# ## #
# # #
# #
################################
p2 = pminos[2]
model.Add(p2[1][0] == p2[0][0] + 1)
model.Add(p2[2][0] == p2[0][0])
model.Add(p2[3][0] == p2[0][0] + 1)
model.Add(p2[4][0] == p2[0][0])
model.Add(p2[1][1] == p2[0][1])
model.Add(p2[2][1] == p2[0][1] + 1)
model.Add(p2[3][1] == p2[0][1] + 1)
model.Add(p2[4][1] == p2[0][1] + 2)
## 4th polyomino -> domino ##
# #
# #
# # #
# # #
# #
#############################
p3 = pminos[3]
model.Add(p3[1][0] == p3[0][0])
model.Add(p3[1][1] == p3[0][1] + 1)
## 5th polyomino -> monomino ##
# #
# #
# # #
# #
# #
###############################
#No constraints because 1 cell only
#No blocks can overlap:
block_addresses = []
n = 0
for p in pminos:
for c in p:
n += 1
block_address = model.NewIntVarFromDomain(cp_model.Domain.FromIntervals(ranges),'%i' % n)
model.Add(c[0] + c[1] * W == block_address)
block_addresses.append(block_address)
model.AddAllDifferent(block_addresses)
#Solve and print solutions as we find them
solver = cp_model.CpSolver()
solution_printer = SolutionPrinter(pminos)
status = solver.SearchForAllSolutions(model, solution_printer)
print('Status = %s' % solver.StatusName(status))
print('Number of solutions found: %i' % solution_printer.count)
class SolutionPrinter(cp_model.CpSolverSolutionCallback):
''' Print a solution. '''
def __init__(self, variables):
cp_model.CpSolverSolutionCallback.__init__(self)
self.variables = variables
self.count = 0
def on_solution_callback(self):
self.count += 1
plt.figure(figsize = (2, 2))
plt.grid(True)
plt.axis([0,W,H,0])
plt.yticks(np.arange(0, H, 1.0))
plt.xticks(np.arange(0, W, 1.0))
for i, p in enumerate(self.variables):
for c in p:
x = self.Value(c[0])
y = self.Value(c[1])
rect = plt.Rectangle((x, y), 1, 1, fc = cdict[i])
plt.gca().add_patch(rect)
for i in inactiveCells:
x = i%W
y = i//W
rect = plt.Rectangle((x, y), 1, 1, fc = 'None', hatch = '///')
plt.gca().add_patch(rect)
समस्या यह है कि मेरे पास हार्ड-कोडेड 5 अद्वितीय / फिक्स्ड पॉलीओमिनोइज़ हैं और मुझे नहीं पता कि बाधाओं को कैसे परिभाषित किया जाए ताकि प्रत्येक पॉलीमिनो के लिए प्रत्येक संभव पैटर्न को ध्यान में रखा जाए (बशर्ते यह संभव हो)।
मैं एक सॉल-सॉल्वर का उपयोग करना पसंद करूंगा, या उपकरण को अधिमानतः।
—
solub
@solub मिनीज़िंक भाषा का उपयोग करके इस तरह की समस्या को हल करना / हल करना बहुत आसान है, क्योंकि एक सतह पर अनियमित वस्तुओं को रखने के लिए उच्च-स्तरीय बाधाएं हैं। यदि आप कौरसेरा पर मुफ्त कोर्स "एडवांस्ड मॉडलिंग फॉर डिस्क्रीट ऑप्टिमाइजेशन" के माध्यम से चलते हैं, तो आपको वास्तव में यह सिखाया जाएगा कि इसे कैसे किया जाए और कुछ व्यावहारिक (और अधिक जटिल) उदाहरण दिए जाएं। Or-Tools में MiniZinc भाषा के लिए एक इंटरफ़ेस है, जिससे आप अभी भी इसकी शक्ति का उपयोग कर इसका त्वरित समाधान पा सकते हैं।
—
पैट्रिक ट्रेंटिन
दिलचस्प लगता है, सूचक के लिए धन्यवाद। निश्चित नहीं है कि यह उस विशिष्ट समस्या का उत्तर देगा जो मेरे पास है (मुक्त पॉलीमिनोइज़ को शामिल करने में अड़चन को परिभाषित करते हुए, स्थिर नहीं) लेकिन मैं निश्चित रूप से इस पर एक नज़र डालूंगा।
—
solub
मुझे माफी मांगनी चाहिए, मैं इस प्रश्न के बारे में पूरी तरह से भूल गया था। एक हुई है संबंधित सवाल में
—
पैट्रिक ट्रेंटिन
minizincएक विस्तृत जवाब यह है कि उपयोग के बारे में मेरे पिछले सुझाव को शामिल किया गया साथ टैग minizinc।
itertools,numpy,networkx?