def arrange(self, event):
self.frame_body.pack_forget()
self.frame_body = Frame(self.frame)
self.csp = None
self.list_of_jadwal_ruangan = []
self.list_of_jadwal_kegiatan = []
self.csp = CSP(self.dasbor.entry_nama_file.get())
if self.pilihan_algoritma.get() == 0:
schedule = Schedule()
hill = HillClimbing()
hill.algorithm(schedule, self.csp, int(self.dasbor.entry_iterasi_maksimal.get()))
elif self.pilihan_algoritma.get() == 1:
Schedule1 = Schedule()
Schedule1.inisialisasi(self.csp)
SimulatedAnnealing1 = SimulatedAnnealing(float(self.dasbor.entry_T.get()), float(self.dasbor.entry_Tmin.get()), float(self.dasbor.entry_alpha.get()))
SimulatedAnnealing1.inisialisasi(Schedule1, self.csp)
elif self.pilihan_algoritma.get() == 2:
for i in range(int(self.dasbor.entry_iterasi_maksimal.get())):
PopulasiGA1 = PopulasiGA()
PopulasiGA1.isiPopulasi(self.csp.getListOfJadwal(), self.csp.getListOfRuangan())
PopulasiGA1.selection()
PopulasiGA1.crossOver()
PopulasiGA1.mutasi(self.csp)
konflikMinimal, idxMinimal = PopulasiGA1.cekKonflikPopulasi()
self.csp.setJumlahConflict2(konflikMinimal)
if (konflikMinimal == 0):
break
PopulasiGA1.assignToCSP(PopulasiGA1.getIndividuByIndex(idxMinimal), self.csp)
self.dasbor.label_angka_jadwal_bentrok.config(text=str(self.csp.getJumlahConflict2()))
self.dasbor.label_angka_persentase.config(text=str(self.csp.hitungEfisiensi()*100)+'%')
for ruangan in self.csp.getListOfRuangan():
self.list_of_jadwal_ruangan.append(JadwalRuangan(self.frame_body, ruangan))
for kegiatan in self.csp.getListOfJadwal():
self.list_of_jadwal_kegiatan.append(JadwalKegiatan(self.list_of_jadwal_ruangan, kegiatan))
#BINDING
for jadwal_ruangan in self.list_of_jadwal_ruangan:
for index_baris in range (2,13):
for index_kolom in range (1,6):
frame_jadwal_ruangan = jadwal_ruangan.matrix_of_frame_jadwal_ruangan[index_baris][index_kolom]
frame_jadwal_ruangan.bind('<Button-1>', lambda event, a=jadwal_ruangan, b=index_baris, c=index_kolom: self.pindah_jadwal(a,b,c))
for jadwal_kegiatan in self.list_of_jadwal_kegiatan:
for button in jadwal_kegiatan.list_of_button:
button.bind('<Button-1>', lambda event, a=button.cget('text'), b=jadwal_kegiatan: self.pilih_kegiatan(a,b))
#SHOW
for jadwal_ruangan in self.list_of_jadwal_ruangan:
jadwal_ruangan.show()
for jadwal_kegiatan in self.list_of_jadwal_kegiatan:
jadwal_kegiatan.show()
self.frame_body.pack(side=TOP, expand=True)
def toCSP(self) -> CSP:
"""
Transforms the map into a CSP
:return: the CSP
"""
csp = CSP()
for p in self._region:
v = Variable(
'region ' + str('%.3f' % p.x()) + '-' + str('%.3f' % p.y()),
self._color)
csp.addVariable(v)
for l in self._borders:
csp.addBinaryConstraint(
csp.getVariable('region ' + str('%.3f' % l[0].x()) + '-' +
str('%.3f' % l[0].y())), Constraint(different),
csp.getVariable('region ' + str('%.3f' % l[1].x()) + '-' +
str('%.3f' % l[1].y())))
return csp
def main():
"""
task:
0 - N queens
1 - Latin square
size:
algorithm:
0 - forward checking
1 - backtracking
"""
size = int(input("Specify the desired size of the board: "))
csp = CSP.CSP(task=1, size=size)
results = csp.start(algorithm=1)
# for r in results:
# print(r)
print("Solutions found: ", len(results[0]), "Number of iterations: ",
results[1])
def new_sudoku(file=None): if not file: # Create empty sudoku with domains 1-9 for every cell X = [0] * DIM*DIM D = [ list(range(1,DIM+1)) for _ in range(len(X)) ] else: # Read a sudoku and fill in domain values X = read_sudoku(file) D = [] for i in range(len(X)): if X[i] == 0: D.append( list(range(1,DIM+1)) ) else: D.append( [ X[i] ] ) # Only one constraint to satisfy (on a variety of arcs) C = [ alldiff ] # Seems like it could be done more correctly # Generate all rows, columns, and boxes box_size = int(sqrt(DIM)) rows, cols, boxes = [], [], [] for i in range(0,DIM): row, col, box = [], [], [] for j in range(0,DIM): row.append(i + DIM*j) col.append(DIM*i + j) box.append( (j%box_size) + DIM*(j//box_size) + box_size*(i%box_size) + DIM*box_size*(i//box_size) ) rows.append(tuple(row)) cols.append(tuple(col)) boxes.append(tuple(box)) # Convert all groups into binary arcs groups = rows + cols + boxes arcs = [] for group in groups: arcs += binary_arcs(group) # Return a CSP representation of the sudoku return CSP.CSP(X, D, C, arcs)
def __init__(self, N=1):
def leftDiagonalConstraint(state, values, size=N):
pairs = values.items()
validStates = list(
range(
state.state -
min(state.state // size, state.state % size) * (size + 1),
size**2, size + 1))
validPairs = list(
filter(lambda pair: pair[1] and pair[0].state in validStates,
pairs))
statesToConsider = map(lambda x: x[1], validPairs)
return sum(statesToConsider) <= 1
def rightDiagonalConstraint(state, values, size=N):
pairs = values.items()
validStates = list(
range(
state.state - min(state.state // size,
(N - 1) - state.state % size) *
(size - 1), size**2, (size - 1)))
validPairs = list(
filter(lambda pair: pair[1] and pair[0].state in validStates,
pairs))
statesToConsider = map(lambda x: x[1], validPairs)
return sum(statesToConsider) <= 1
self._number = N
goal = lambda values, size=N: sum(map(lambda v: v[1], values.items())
) == size
self._CSP = CSP(goal, ChessState(0, set([True, False]), N))
for i in range(N * N):
self._CSP.addVariable(ChessState(i, set([True, False]), N))
self._CSP.addConstraint(leftDiagonalConstraint)
self._CSP.addConstraint(rightDiagonalConstraint)
def __init__(self, filename,domain):
self.csp1 = CSP.CSP(filename, domain)
self.csp1.parseFile()
self.finalassignment = {}
self.cnt = 0
def solve_mrv(self):
aus = CSP(self.vars, self.doms, self.cons)
return aus.backtrack(aus.mrv, aus.order_values, aus.simple)
def simplesolve(self):
aus = CSP(self.vars, self.doms, self.cons)
return aus.backtrack(aus.select_unnassigned, aus.order_values,
aus.simple)
import CSP
import numpy as np
import matplotlib.pyplot as plt
# csp_bt_6 = CSP.CSP(size=6, domain_size=3).backtracking_map()[0]
########################################################################################################################
# --------------------------------------------------KOLOROWANIE GRAFU---------------------------------------------------
########################################################################################################################
# ------------------------------------------PORÓWNANIE CZASU DLA 5 ROZMIARÓW--------------------------------------------
objects = ('6 x 6', '9 x 9', '12 x 12', '15 x 15' '18 x 18')
y_pos = np.arange(len(objects))
csp_bt_6 = CSP.CSP(size=6, domain_size=5).backtracking_map()[0]
csp_bt_9 = CSP.CSP(size=9, domain_size=5).backtracking_map()[0]
csp_bt_12 = CSP.CSP(size=12, domain_size=5).backtracking_map()[0]
csp_bt_15 = CSP.CSP(size=15, domain_size=5).backtracking_map()[0]
csp_bt_18 = CSP.CSP(size=18, domain_size=5).backtracking_map()[0]
csp_fc_6 = CSP.CSP(size=6, domain_size=5).forward_checking_map()[0]
csp_fc_9 = CSP.CSP(size=9, domain_size=5).forward_checking_map()[0]
csp_fc_12 = CSP.CSP(size=12, domain_size=5).forward_checking_map()[0]
csp_fc_15 = CSP.CSP(size=15, domain_size=5).forward_checking_map()[0]
csp_fc_18 = CSP.CSP(size=18, domain_size=5).forward_checking_map()[0]
backtracking = [csp_bt_6, csp_bt_9, csp_bt_12, csp_bt_15, csp_bt_18]
forward_checking = [csp_fc_6, csp_fc_9, csp_fc_12, csp_fc_15, csp_fc_18]
plt.bar(y_pos, backtracking, align='center', alpha=0.5)
plt.bar(y_pos, forward_checking, align='center', alpha=0.5)
def main():
# set up the variables and domains in the Australia example so it can be solved with AC3
variables = [
"Alabama", "Arizona", "Arkansas", "California", "Colorado",
"Connecticut", "Delaware", "Florida", 'Georgia', 'Idaho', 'Illinois',
'Indiana', 'Iowa', 'Kansas', 'Kentucky', 'Louisiana', 'Maine',
'Maryland', 'Massachusetts', 'Michigan', 'Minnesota', 'Mississippi',
'Missouri', 'Montana', 'Nebraska', 'Nevada', 'New Hampshire',
'New Jersey', 'New Mexico', 'New York', 'North Carolina',
'North Dakota', 'Ohio', 'Oklahoma', 'Oregon', 'Pennsylvania',
'Rhode Island', 'South Carolina', 'South Dakota', 'Tennessee', 'Texas',
'Utah', 'Vermont', 'Virginia', 'Washington', 'West Virginia',
'Wisconsin', 'Wyoming'
]
domains = {}
for variable in variables:
domains[variable] = ["red", "white", "blue", 'yellow']
myCSP = CSP(variables, domains)
myCSP.addConstraint("Alabama", "Florida")
myCSP.addConstraint("Alabama", "Georgia")
myCSP.addConstraint("Alabama", "Mississippi")
myCSP.addConstraint("Alabama", "Tennessee")
myCSP.addConstraint("Arizona", "California")
myCSP.addConstraint("Arizona", "Colorado")
myCSP.addConstraint("Arizona", "Nevada")
myCSP.addConstraint("Arizona", "New Mexico")
myCSP.addConstraint("Arizona", "Utah")
myCSP.addConstraint("Arkansas", "Louisiana")
myCSP.addConstraint("Arkansas", "Mississippi")
myCSP.addConstraint("Arkansas", "Missouri")
myCSP.addConstraint("Arkansas", "Oklahoma")
myCSP.addConstraint("Arkansas", "Tennessee")
myCSP.addConstraint("Arkansas", "Texas")
myCSP.addConstraint("California", "Arizona")
myCSP.addConstraint("California", "Nevada")
myCSP.addConstraint("California", "Oregon")
myCSP.addConstraint("Colorado", "Arizona")
myCSP.addConstraint("Colorado", "Kansas")
myCSP.addConstraint("Colorado", "Nebraska")
myCSP.addConstraint("Colorado", "New Mexico")
myCSP.addConstraint("Colorado", "Oklahoma")
myCSP.addConstraint("Colorado", "Utah")
myCSP.addConstraint("Colorado", "Wyoming")
myCSP.addConstraint("Colorado", "Massachusetts")
myCSP.addConstraint("Colorado", "New York")
myCSP.addConstraint("Colorado", "Rhode Island")
myCSP.addConstraint("Delaware", "Maryland")
myCSP.addConstraint("Delaware", "New Jersey")
myCSP.addConstraint("Delaware", "Pennsylvania")
myCSP.addConstraint("Florida", "Alabama")
myCSP.addConstraint("Florida", "Georgia")
myCSP.addConstraint("Georgia", "Alabama")
myCSP.addConstraint("Georgia", "Florida")
myCSP.addConstraint("Georgia", "North Carolina")
myCSP.addConstraint("Georgia", "South Carolina")
myCSP.addConstraint("Georgia", "Tennessee")
myCSP.addConstraint("Idaho", "Montana")
myCSP.addConstraint("Idaho", "Nevada")
myCSP.addConstraint("Idaho", "Oregon")
myCSP.addConstraint("Idaho", "Utah")
myCSP.addConstraint("Idaho", "Washington")
myCSP.addConstraint("Idaho", "Wyoming")
myCSP.addConstraint("Illinois", "Indiana")
myCSP.addConstraint("Illinois", "Iowa")
myCSP.addConstraint("Illinois", "Michigan")
myCSP.addConstraint("Illinois", "Kentucky")
myCSP.addConstraint("Illinois", "Missouri")
myCSP.addConstraint("Illinois", "Wisconsin")
myCSP.addConstraint("Indiana", "Illinois")
myCSP.addConstraint("Indiana", "Kentucky")
myCSP.addConstraint("Indiana", "Michigan")
myCSP.addConstraint("Indiana", "Ohio")
myCSP.addConstraint("Iowa", "Illinois")
myCSP.addConstraint("Iowa", "Minnesota")
myCSP.addConstraint("Iowa", "Missouri")
myCSP.addConstraint("Iowa", "Nebraska")
myCSP.addConstraint("Iowa", "South Dakota")
myCSP.addConstraint("Iowa", "Wisconsin")
myCSP.addConstraint("Kansas", "Colorado")
myCSP.addConstraint("Kansas", "Missouri")
myCSP.addConstraint("Kansas", "Nebraska")
myCSP.addConstraint("Kansas", "Oklahoma")
myCSP.addConstraint("Kentucky", "Illinois")
myCSP.addConstraint("Kentucky", "Indiana")
myCSP.addConstraint("Kentucky", "Missouri")
myCSP.addConstraint("Kentucky", "Ohio")
myCSP.addConstraint("Kentucky", "Tennessee")
myCSP.addConstraint("Kentucky", "Virginia")
myCSP.addConstraint("Kentucky", "West Virginia")
myCSP.addConstraint("Louisiana", "Arkansas")
myCSP.addConstraint("Louisiana", "Mississippi")
myCSP.addConstraint("Louisiana", "Texas")
myCSP.addConstraint("Louisiana", "New Hampshire")
myCSP.addConstraint("Maryland", "Delaware")
myCSP.addConstraint("Maryland", "Pennsylvania")
myCSP.addConstraint("Maryland", "Virginia")
myCSP.addConstraint("Maryland", "West Virginia")
myCSP.addConstraint("Massachusetts", "Connecticut")
myCSP.addConstraint("Massachusetts", "New Hampshire")
myCSP.addConstraint("Massachusetts", "New York")
myCSP.addConstraint("Massachusetts", "Rhode Island")
myCSP.addConstraint("Massachusetts", "Vermont")
myCSP.addConstraint("Michigan", "Illinois")
myCSP.addConstraint("Michigan", "Indiana")
myCSP.addConstraint("Michigan", "Minnesota")
myCSP.addConstraint("Michigan", "Ohio")
myCSP.addConstraint("Michigan", "Wisconsin")
myCSP.addConstraint("Minnesota", "Iowa")
myCSP.addConstraint("Minnesota", "Michigan")
myCSP.addConstraint("Minnesota", "North Dakota")
myCSP.addConstraint("Minnesota", "South Dakota")
myCSP.addConstraint("Minnesota", "Wisconsin")
myCSP.addConstraint("Mississippi", "Alabama")
myCSP.addConstraint("Mississippi", "Arkansas")
myCSP.addConstraint("Mississippi", "Louisiana")
myCSP.addConstraint("Mississippi", "Tennessee")
myCSP.addConstraint("Missouri", "Arkansas")
myCSP.addConstraint("Missouri", "Illinois")
myCSP.addConstraint("Missouri", "Iowa")
myCSP.addConstraint("Missouri", "Kansas")
myCSP.addConstraint("Missouri", "Kentucky")
myCSP.addConstraint("Missouri", "Nebraska")
myCSP.addConstraint("Missouri", "Oklahoma")
myCSP.addConstraint("Missouri", "Tennessee")
myCSP.addConstraint("Montana", "Idaho")
myCSP.addConstraint("Montana", "North Dakota")
myCSP.addConstraint("Montana", "South Dakota")
myCSP.addConstraint("Montana", "Wyoming")
myCSP.addConstraint("Nebraska", "Colorado")
myCSP.addConstraint("Nebraska", "Iowa")
myCSP.addConstraint("Nebraska", "Kansas")
myCSP.addConstraint("Nebraska", "Missouri")
myCSP.addConstraint("Nebraska", "South Dakota")
myCSP.addConstraint("Nebraska", "Wyoming")
myCSP.addConstraint("Nevada", "Arizona")
myCSP.addConstraint("Nevada", "California")
myCSP.addConstraint("Nevada", "Idaho")
myCSP.addConstraint("Nevada", "Oregon")
myCSP.addConstraint("Nevada", "Utah")
myCSP.addConstraint("New Hampshire", "Maine")
myCSP.addConstraint("New Hampshire", "Massachusetts")
myCSP.addConstraint("New Hampshire", "Vermont")
myCSP.addConstraint("New Jersey", "Delaware")
myCSP.addConstraint("New Jersey", "New York")
myCSP.addConstraint("New Jersey", "Pennsylvania")
myCSP.addConstraint("New Mexico", "Arizona")
myCSP.addConstraint("New Mexico", "Colorado")
myCSP.addConstraint("New Mexico", "Oklahoma")
myCSP.addConstraint("New Mexico", "Texas")
myCSP.addConstraint("New Mexico", "Utah")
myCSP.addConstraint("New York", "Connecticut")
myCSP.addConstraint("New York", "Massachusetts")
myCSP.addConstraint("New York", "New Jersey")
myCSP.addConstraint("New York", "Pennsylvania")
myCSP.addConstraint("New York", "Rhode Island")
myCSP.addConstraint("New York", "Vermont")
myCSP.addConstraint("North Carolina", "Georgia")
myCSP.addConstraint("North Carolina", "South Carolina")
myCSP.addConstraint("North Carolina", "Tennessee")
myCSP.addConstraint("North Carolina", "Virginia")
myCSP.addConstraint("North Dakota", "Minnesota")
myCSP.addConstraint("North Dakota", "Montana")
myCSP.addConstraint("North Dakota", "South Dakota")
myCSP.addConstraint("Ohio", "Indiana")
myCSP.addConstraint("Ohio", "Kentucky")
myCSP.addConstraint("Ohio", "Michigan")
myCSP.addConstraint("Ohio", "Pennsylvania")
myCSP.addConstraint("Ohio", "West Virginia")
myCSP.addConstraint("Oklahoma", "Arkansas")
myCSP.addConstraint("Oklahoma", "Colorado")
myCSP.addConstraint("Oklahoma", "Kansas")
myCSP.addConstraint("Oklahoma", "Missouri")
myCSP.addConstraint("Oklahoma", "New Mexico")
myCSP.addConstraint("Oklahoma", "Texas")
myCSP.addConstraint("Oregon", "California")
myCSP.addConstraint("Oregon", "Idaho")
myCSP.addConstraint("Oregon", "Nevada")
myCSP.addConstraint("Oregon", "Washington")
myCSP.addConstraint("Pennsylvania", "Delaware")
myCSP.addConstraint("Pennsylvania", "Maryland")
myCSP.addConstraint("Pennsylvania", "New Jersey")
myCSP.addConstraint("Pennsylvania", "New York")
myCSP.addConstraint("Pennsylvania", "Ohio")
myCSP.addConstraint("Pennsylvania", "West Virginia")
myCSP.addConstraint("Rhode Island", "Connecticut")
myCSP.addConstraint("Rhode Island", "Massachusetts")
myCSP.addConstraint("Rhode Island", "New York")
myCSP.addConstraint("South Carolina", "Georgia")
myCSP.addConstraint("South Carolina", "North Carolina")
myCSP.addConstraint("South Dakota", "Iowa")
myCSP.addConstraint("South Dakota", "Minnesota")
myCSP.addConstraint("South Dakota", "Montana")
myCSP.addConstraint("South Dakota", "Nebraska")
myCSP.addConstraint("South Dakota", "North Dakota")
myCSP.addConstraint("South Dakota", "Wyoming")
myCSP.addConstraint("Tennessee", "Alabama")
myCSP.addConstraint("Tennessee", "Arkansas")
myCSP.addConstraint("Tennessee", "Georgia")
myCSP.addConstraint("Tennessee", "Kentucky")
myCSP.addConstraint("Tennessee", "Mississippi")
myCSP.addConstraint("Tennessee", "Missouri")
myCSP.addConstraint("Tennessee", "North Carolina")
myCSP.addConstraint("Tennessee", "Virginia")
myCSP.addConstraint("Texas", "Arkansas")
myCSP.addConstraint("Texas", "Louisiana")
myCSP.addConstraint("Texas", "New Mexico")
myCSP.addConstraint("Texas", "Oklahoma")
myCSP.addConstraint("Utah", "Arizona")
myCSP.addConstraint("Utah", "Colorado")
myCSP.addConstraint("Utah", "Idaho")
myCSP.addConstraint("Utah", "Nevada")
myCSP.addConstraint("Utah", "New Mexico")
myCSP.addConstraint("Utah", "Wyoming")
myCSP.addConstraint("Vermont", "Massachusetts")
myCSP.addConstraint("Vermont", "New Hampshire")
myCSP.addConstraint("Vermont", "New York")
myCSP.addConstraint("Virginia", "Kentucky")
myCSP.addConstraint("Virginia", "Maryland")
myCSP.addConstraint("Virginia", "North Carolina")
myCSP.addConstraint("Virginia", "Tennessee")
myCSP.addConstraint("Virginia", "West Virginia")
myCSP.addConstraint("Washington", "Idaho")
myCSP.addConstraint("Washington", "Oregon")
myCSP.addConstraint("West Virginia", "Kentucky")
myCSP.addConstraint("West Virginia", "Maryland")
myCSP.addConstraint("West Virginia", "Ohio")
myCSP.addConstraint("West Virginia", "Pennsylvania")
myCSP.addConstraint("West Virginia", "Virginia")
myCSP.addConstraint("Wisconsin", "Illinois")
myCSP.addConstraint("Wisconsin", "Iowa")
myCSP.addConstraint("Wisconsin", "Michigan")
myCSP.addConstraint("Wisconsin", "Minnesota")
myCSP.addConstraint("Wyoming", "Colorado")
myCSP.addConstraint("Wyoming", "Idaho")
myCSP.addConstraint("Wyoming", "Montana")
myCSP.addConstraint("Wyoming", "Nebraska")
myCSP.addConstraint("Wyoming", "South Dakota")
myCSP.addConstraint("Wyoming", "Utah")
#myCSP.addConstraint("Hawaii", "None")
#myCSP.addConstraint("Alaska", "None")
myCSP.ac3()
myCSP.print()
myCSP.search()
myCSP.print()
from sys import *
import local_search
import input
import heuristics as h
import CSP
import time
if __name__ == "__main__":
time1 = time.clock()
sud = None
# The solution method: either CSP or local search
if argv[1] == "CSP":
# choosing the grid
if argv[2] == "easy":
sud = CSP.CSP(3, input.easy9)
elif argv[2] == "hard":
sud = CSP.CSP(3, input.hard9)
elif argv[2] == "16":
sud = CSP.CSP(4, input.mid16)
# choosing set of heuristics
if argv[3] == '1':
order = h.by_order
value = h.random_value
strategy1 = h.arc_consistency
strategy2 = h.forward_checking
sud.solve(order, value, strategy1, strategy2)
elif argv[3] == '2':
order = h.by_order
value = h.random_value
newDomain = {}
for key in domains:
newValue = []
value = domains[key]
for domainList in value:
newDomainList = []
for domain in domainList:
newDomainList.append(domain)
newValue.append(newDomainList)
newDomain[key] = newValue
return newDomain
backTrackSearch = BacktrackingSearch()
csp = CSP(10, 0)
start = time.time()
result = backTrackSearch.backtrackingSearch(csp)
print(result)
print(time.time() - start)
StructureVisual().drawStructure(result[0])
# csp = CSP(10, 0)
# finalMap = {}
# for i in range(50):
# result = backTrackSearch.backtrackingSearch(csp)
# finalMap[i] = result[1]
# print(finalMap)
# file = open('testData.txt', 'a')
# file.write(json.dumps(finalMap))
# file.close()
# Name: Erin Cole # Description: Tester file for CSP.py import CSP # Test on .mat file from BCI Competition IV dataset 3 f = 'S1.mat' CSP.CSP(f)
def main():
start = time.time()
with open('input.txt', 'r') as openFile:
fileData = openFile.readlines()
openFile.close()
cspInfo = [line.strip() for line in fileData]
#Assign variables
dNumOfGroups = int(cspInfo[0])
dNumOfPots = int(cspInfo[1])
lsVariables = []
dctVarInfo = collections.defaultdict(list)
dctDomains = collections.defaultdict(list)
count = 2
intPotNum = 1
for pot in range(dNumOfPots):
splitLine = cspInfo[count].split(',')
for country in splitLine:
lsVariables.append(country)
dctVarInfo[country].append(intPotNum)
for num in range(1, dNumOfGroups + 1):
dctDomains[country].append(num)
count = count + 1
intPotNum = intPotNum + 1
for confederation in range(6):
#parse string
splitLine = cspInfo[count].split(':')
strConfederation = splitLine.pop(0)
splitLine = str(splitLine)
splitLine = splitLine.split(',')
count = count + 1
if 'None' not in ''.join(splitLine):
for word in splitLine:
word = word.strip('[')
word = word.strip(']')
word = word.strip("'")
dctVarInfo[word].append(strConfederation)
dctNeighboringCountries = collections.defaultdict(list)
for country in dctVarInfo.keys():
for checkCountry in lsVariables:
if country != checkCountry:
if dctVarInfo[country][0] == dctVarInfo[checkCountry][0]:
if checkCountry not in dctNeighboringCountries[country]:
dctNeighboringCountries[country].append(checkCountry)
if dctVarInfo[country][1] == dctVarInfo[checkCountry][1]:
if checkCountry not in dctNeighboringCountries[country]:
dctNeighboringCountries[country].append(checkCountry)
dctAssignments = {}
if len(lsVariables) >= 20:
consistencyCheck = 'hc'
else:
consistencyCheck = 'bc'
print("Size of variables is %s using: %s" %
(len(lsVariables), consistencyCheck))
cspProblem = CSP.CSP(lsVariables, dctVarInfo, dctDomains,
dctNeighboringCountries, None)
solve = SearchAndCheck.SearchAndCheck(cspProblem)
if consistencyCheck == 'bc':
solution = solve.BacktrackSearch(dctAssignments, consistencyCheck)
else:
solution = solve.HillClimbing(1000, dctAssignments)
if solution is not None:
with open("output.txt", 'w') as openFile:
finalSolution = collections.defaultdict(list)
for country, group in solution.iteritems():
finalSolution[group].append(country)
openFile.write("Yes")
for group in finalSolution.keys():
countries = ','.join(finalSolution[group])
openFile.write('\n')
openFile.write(countries)
else:
with open("output.txt", 'w') as openFile:
openFile.write("No")
end = time.time()
print(end - start)
