আমি স্যাট সমাধানকারীদের বিশ্বে নতুন এবং নিম্নলিখিত সমস্যা সম্পর্কিত কিছু গাইডেন্সের প্রয়োজন।
এটি বিবেচনা করে:
❶ আমার কাছে একটি 4 * 4 গ্রিডে 14 সংলগ্ন ঘরগুলির একটি নির্বাচন রয়েছে
❷ আমার কাছে 4, 2, 5, 2 এবং 1 টি আকারের 5 টি পলিওমিনোস (এ, বি, সি, ডি, ই) রয়েছে
Poly এই পলিওমিনোগুলি নিখরচায় , অর্থাত তাদের আকৃতি স্থির নয় এবং বিভিন্ন নিদর্শন তৈরি করতে পারে
আমি কীভাবে স্যাট-সলভারের সাথে নির্বাচিত অঞ্চলের (ধূসর রঙের কোষ) অভ্যন্তরে এই 5 টি ফ্রি পলিওমিনোজগুলির সমস্ত সম্ভাব্য সংমিশ্রণগুলি গণনা করতে পারি ?
@ স্পিংকাসের অন্তর্দৃষ্টিপূর্ণ উত্তর এবং ওআর-সরঞ্জামের ডকুমেন্টেশন উভয় থেকে ধার নেওয়া আমি নিম্নলিখিত উদাহরণ কোডটি তৈরি করতে পারি (একটি বৃহত্তর নোটবুকে রান):
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)
সমস্যাটি হ'ল আমার কাছে হার্ড-কোডড ৫ টি অনন্য / ফিক্সড পলিওমিনোস রয়েছে এবং প্রতিবন্ধকতাগুলি কীভাবে সংজ্ঞায়িত করতে হয় তা আমি জানি না যাতে প্রতিটি পলিওমিনোগুলির জন্য প্রতিটি সম্ভাব্য প্যাটার্ন বিবেচনায় নেওয়া হয় (তবে এটি সম্ভব হয়)।
আমি একটি স্যাট-সলভার বা সরঞ্জামগুলি বেশি পছন্দ করতে পছন্দ করি।
—
একসাথে
@ সলুব, মিনিজিংক ভাষা ব্যবহার করে এই জাতীয় সমস্যাটিকে মডেল করা / সমাধান করা বেশ সহজ, যেহেতু কোনও পৃষ্ঠে অনিয়মিত বস্তু স্থাপনের জন্য উচ্চ-স্তরের প্রতিবন্ধকতা রয়েছে। আপনি যদি কুরসেরাতে "অ্যাডভান্সড মডেলিং ফর ডিস্রিট অপটিমাইজেশন" ফ্রি কোর্সটি অতিক্রম করেন তবে আপনাকে কীভাবে এটি করতে হবে তা শেখানো হবে এবং এর কয়েকটি বাস্তব (এবং আরও জটিল) উদাহরণ দেওয়া হবে। অ্যান্ড-টুলসটির মিনিজিংক ভাষার জন্য একটি ইন্টারফেস রয়েছে, তাই আপনি দ্রুত সমাধান খুঁজে পাওয়ার জন্য এর শক্তিকে আরও বাড়িয়ে তুলতে পারেন।
—
প্যাট্রিক ট্রেনটিন
আকর্ষণীয় বলে মনে হচ্ছে, পয়েন্টারের জন্য ধন্যবাদ। নিশ্চিত না যে এটি আমার যে নির্দিষ্ট সমস্যার সাথে জবাব দেবে (ফ্রি পলিওমিনোস জড়িত সংজ্ঞাগুলি স্থির নয়) তবে আমি অবশ্যই এটি লক্ষ্য করব।
—
solub
আমাকে অবশ্যই ক্ষমা চাইতে হবে, আমি এই প্রশ্নটি সম্পর্কে পুরোপুরি ভুলে গিয়েছিলাম। একটি হয়েছে সংশ্লিষ্ট প্রশ্ন মধ্যে
—
প্যাট্রিক ট্রেনটিন
minizincএকটি বিস্তারিত উত্তর যে ব্যবহার সম্পর্কে আমার আগের পরামর্শ জুড়ে দিয়ে ট্যাগ minizinc।
itertools,numpy,networkx?