def assign_days(Day_arrangement, cursor):
global Subs
global crsr
crsr = cursor
cursor.execute('''
select sname,count(roll) from Classes,Subjects
where Classes.class=Subjects.class
group by sname
''')
subs = cursor.fetchall()
Subs = []
for i in subs:
#print(i)
Subs.append(i[0])
Arrangement = dict((sub, [1, 2, 3, 4, 5, 6, 7]) for sub in Subs)
#print(Arrangement)
Constraints = [(Subs, day_check)]
Problem = CspProblem(Subs, Arrangement, Constraints)
output = backtrack(Problem)
#print(output)
print()
for y, z in output.items():
print('Day ', z, '==>', y)
if z not in Day_arrangement:
Day_arrangement[z] = []
Day_arrangement[z].append(y)
def resolver(metodo_busqueda, iteraciones):
#problema = CspProblem(variables, dominios, restricciones)
if metodo_busqueda == 'backtrack':
return backtrack(CspProblem(variables, dominios, restricciones))
if metodo_busqueda == 'min_conflicts':
return min_conflicts(CspProblem(variables, dominios, restricciones),
iterations_limit=iteraciones)
def resolver(metodo_busqueda, iteraciones):
problema = CspProblem(slots, dominios, restricciones)
if metodo_busqueda == "backtrack":
resultado = backtrack(problema)
return resultado
if metodo_busqueda == "min_conflicts":
return min_conflicts(problema, iterations_limit=iteraciones)
def solve_sudoku(board):
variables = [(row, col)
for row in range(9)
for col in range(9)]
domains = {variable: list(range(1, 10))
for variable in variables}
for cell, number in board.items():
domains[cell] = [number, ]
constraints = []
for cell1, cell2 in itertools.combinations(variables, 2):
row1, col1 = cell1
row2, col2 = cell2
if (row1 == row2) or (col1 == col2) or (big_square_of(cell1) == big_square_of(cell2)):
constraints.append(((cell1, cell2), different))
problem = CspProblem(variables, domains, constraints)
result = backtrack(problem,
variable_heuristic=MOST_CONSTRAINED_VARIABLE,
inference=True)
return result
def resolver(metodo_busqueda):
problem = CspProblem(variables, dominios, restricciones)
if metodo_busqueda == "backtrack":
r = backtrack(problem, value_heuristic=LEAST_CONSTRAINING_VALUE, variable_heuristic=MOST_CONSTRAINED_VARIABLE, inference=True)
else:
r = min_conflicts(problem, iterations_limit=1000)
return r
def resolver(metodo_busqueda, iteraciones): problem = CspProblem(variables, dominios, restricciones) if metodo_busqueda == 'backtrack': result = backtrack(problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE) else: result = min_conflicts(problem, iterations_limit=iteraciones) return result
def resolver(metodo_busqueda, iteraciones):
problema = generar_problema_entrega2()
if metodo_busqueda == "backtrack":
resultado = backtrack(problema)
elif metodo_busqueda == "min_conflicts":
resultado = min_conflicts(problema, iterations_limit=iteraciones)
return resultado
def resolver(metodo_busqueda, iteraciones):
if metodo_busqueda == "backtrack":
resultado = backtrack(CspProblem(slots, dominios, restricciones), MOST_CONSTRAINED_VARIABLE, LEAST_CONSTRAINING_VALUE)
if metodo_busqueda == "min_conflicts":
resultado = min_conflicts(CspProblem(slots, dominios, restricciones), iterations_limit = iteraciones)
result = {}
for key, value in resultado.items():
result[key] = modulos[value]
return result
def resolver(metodo_busqueda, iteraciones):
problema = csp_conferencia()
if metodo_busqueda == "backtrack":
resultado = backtrack(problema)
#resultado = backtrack(problema, variable_heuristic=MOST_CONSTRAINED_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE)
elif metodo_busqueda == "min_conflicts":
resultado = min_conflicts(problema, iterations_limit=iteraciones)
return resultado
def resolver(metodo_busqueda, iteraciones):
unary()
problem = CspProblem(VARIABLES, DOMAINS, restricciones)
if metodo_busqueda == 'backtrack':
result = backtrack(problem,
value_heuristic=HIGHEST_DEGREE_VARIABLE,
variable_heuristic=MOST_CONSTRAINED_VARIABLE,
inference=False)
if metodo_busqueda == 'min_conflicts':
result = min_conflicts(problem, iterations_limit=iteraciones)
return result
def resolver(metodo_busqueda, iteraciones):
problem = CspProblem(variables, dominios, restricciones)
if metodo_busqueda == 'backtrack':
resultado = backtrack(problem=problem)
grabar('1', resultado, iteraciones=iteraciones)
return resultado
#def backtrack(problem, variable_heuristic='', value_heuristic='', inference=True):
if metodo_busqueda == 'min_conflicts':
resultado = min_conflicts(problem=problem,
iterations_limit=iteraciones)
#print iteraciones, resultado
grabar('2', resultado, iteraciones=iteraciones)
return resultado
def matchMatrix(matrix):
matrix = np.array(matrix, dtype=int)
zero_indices = np.argwhere(matrix == 0)
print zero_indices
variables = list(np.unique(zero_indices[:, 0]))
domains = {}
for v in variables:
domains[v] = list(zero_indices[zero_indices[:, 0] == v][:, 1])
print domains
constraints = [[variables, nonequal_constr]]
csp = CspProblem(variables, domains, constraints)
result = backtrack(csp)
return result
def solve(self):
print 'Please wait while AI is solving the puzzle'
print
print
self.cellVariablesTuple, self.cellDomains, self.cellConstraints = convert_to_binary(self.cellVariablesTuple, self.cellDomains,
self.cellConstraints) #convert fields to binary
problem = CspProblem(self.cellVariablesTuple,self.cellDomains,self.cellConstraints) # initialize the csp problem
self.solution = backtrack(problem) #solve the csp problem.
print 'CSP Problem Is Solved'
print
self.printSolution() #print the solution
return
if (x, y) not in arboles and tiene_vecinos((x, y), arboles)]
# los valores posibles para cada carpa, son las posiciones disponibles
domains = {variable: posiciones[:] for variable in variables}
def carpas_no_estan_vecinas(variables, values):
# restriccion binaria, chequea dos carpas:
# asegurarse de que no estan vecinas
return not tiene_vecinos(values[0], (values[1], ))
def carpas_estan_en_diferentes_posiciones(variables, values):
# restriccion binaria, chequea dos carpas:
# asegurarse de que no estan en la misma posicion
return values[0] != values[1]
constrains = []
for variable1, variable2 in combinations(variables, 2):
# por cada par de carpas, hace falta mirar que no sean vecinas y que no
# esten en la misma posicion
constrains.append(
((variable1, variable2), carpas_estan_en_diferentes_posiciones))
constrains.append(((variable1, variable2), carpas_no_estan_vecinas))
problema = CspProblem(variables, domains, constrains)
result = backtrack(problema)
print result
# restricción: no podemos elegir el laboratorio de plantas y el físico al mismo tiempo
domains["mejora2"].remove(("exp_fisicos", 75, 300))
domains["mejora2"].remove(("exp_plantas", 80, 250))
domains["mejora3"].remove(("exp_fisicos", 75, 300))
domains["mejora3"].remove(("exp_plantas", 80, 250))
# restricción: si están las computadoras, necesitamos que estén las baterías
def computers_require_batteries(variables, values):
has_computers = "computadoras" in [improv[0] for improv in values]
has_batteries = "baterías" in [improv[0] for improv in values]
if has_computers:
return has_batteries
else:
return True
constraints.append((problem_variables, computers_require_batteries))
problem = CspProblem(problem_variables, domains, constraints)
solution = backtrack(problem,
variable_heuristic=HIGHEST_DEGREE_VARIABLE,
value_heuristic=LEAST_CONSTRAINING_VALUE)
print("Solution:")
print(solution)
if values[_values[0]][0] == values[_values[1]][0]:
if set(variables[_variables[0]][3]).intersection(
set(variables[_variables[1]][3])):
return False
elif (variables[_variables[0]][2] == variables[_variables[1]][2]):
return False
return True
constraints = [((i, j), const_different) for i in range(len(variables))
for j in range(i, len(variables)) if i != j]
my_problem = CspProblem(variables.keys(), domains, constraints)
t1 = time.time()
res = backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE)
print('\n\n\n\nMinimum remaining value: {}s'.format(time.time() - t1))
pretty_print(res, variables, values)
t1 = time.time()
res = backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE)
print('\n\n\n\nDegree heuristic: {}s'.format(time.time() - t1))
pretty_print(res, variables, values)
t1 = time.time()
res = backtrack(my_problem, value_heuristic=LEAST_CONSTRAINING_VALUE)
print('\n\n\n\nLeast constraining value: {}s'.format(time.time() - t1))
pretty_print(res, variables, values)
t1 = time.time()
res = min_conflicts(my_problem)
from simpleai.search import CspProblem, backtrack, min_conflicts, MOST_CONSTRAINED_VARIABLE, HIGHEST_DEGREE_VARIABLE, LEAST_CONSTRAINING_VALUE
variables = ('WA', 'NT', 'SA', 'Q', 'NSW', 'V', 'T')
domains = dict((v, ['red', 'green', 'blue']) for v in variables)
def const_different(variables, values):
return values[0] != values[1] # expect the value of the neighbors to be different
constraints = [
(('WA', 'NT'), const_different),
(('WA', 'SA'), const_different),
(('SA', 'NT'), const_different),
(('SA', 'Q'), const_different),
(('NT', 'Q'), const_different),
(('SA', 'NSW'), const_different),
(('Q', 'NSW'), const_different),
(('SA', 'V'), const_different),
(('NSW', 'V'), const_different),
]
my_problem = CspProblem(variables, domains, constraints)
print backtrack(my_problem)
print backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE)
print backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE)
print backtrack(my_problem, value_heuristic=LEAST_CONSTRAINING_VALUE)
print backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE)
print backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE)
print min_conflicts(my_problem)
return constraints
def display_solution(sol):
for i in uppercase[:9]:
print(" ".join([str(sol["%s%d" % (i, j)]) for j in range(1, 10)]))
domains.update(parsepuzzle(sudoku))
# -- Hand made binary constraints --
constraints = mkconstraints()
start = time()
domains0 = deepcopy(domains)
my_problem = CspProblem(variables, domains0, constraints)
sol = backtrack(my_problem)
elapsed = time() - start
display_solution(sol)
print("Took %d seconds to finish using binary constraints" %
elapsed) # because of AC3 should be quick
# -- N-ary constraints made binary using hidden variables --
domains1 = deepcopy(domains)
start = time()
variables1, domains1, constraints = convert_to_binary(variables, domains1,
mknaryconstraints())
my_problem = CspProblem(variables1, domains1, constraints)
sol = backtrack(my_problem)
elapsed = time() - start
display_solution(sol)
print("Took %d seconds to finish using binary constraints (hidden variables)" %
domains[(0, 2)] = [
3,
] # porque la casilla A3 tiene el número 3
constraints = []
def cells_are_different(variables, values):
digit1, digit2 = values
return digit1 != digit2
for row in rows:
cells_in_row = [(row, col) for col in columns]
for cell1, cell2 in combinations(cells_in_row, 2):
constraints.append(((cell1, cell2), cells_are_different))
for col in columns:
cells_in_col = [(row, col) for row in rows]
for cell1, cell2 in combinations(cells_in_col, 2):
constraints.append(((cell1, cell2), cells_are_different))
# TODO 2:
# agregar todas las restricciones de que sean diferentes las celdas dentro de cada mega-cuadrado (de 3x3)
problem = CspProblem(problem_variables, domains, constraints)
solution = backtrack(problem)
print("Solution:")
print(solution)
arriba = (casilla[0]-1,casilla[1])
if arriba[0]<0:
arriba = (-1,-1)
abajo = (casilla[0]+1, casilla[1])
if abajo[0] >= largo:
abajo = (-1,-1)
derecha = (casilla[0], casilla[1]+1)
if derecha[1] >= ancho:
derecha = (-1,-1)
izquierda = (casilla[0], casilla[1]-1)
if izquierda[1] < 0:
izquierda = (-1,-1)
restricciones.append(((arriba, abajo, izquierda, derecha), no_adyacentes))
restricciones.append((variables,cantidad_valida))
def imprimir_tablero(resultado):
print '-'*40
for fila in range(largo):
fila_print = ''
for columna in range(ancho):
fila_print += '|%i' %resultado[(fila, columna)]
print fila_print
print '\n'
print 'Backtrack'
imprimir_tablero(backtrack(CspProblem(variables,dominio,restricciones)))
print 'Min conflicts'
imprimir_tablero(min_conflicts(CspProblem(variables,dominio,restricciones), iterations_limit=5000))
x_b, y_b = b
return not (vals[0] == vals[1] and (x_a == x_b or y_a == y_b))
dominios = {(x, y): range(9) for x in range(9) for y in range(9)}
for valor, posiciones in enumerate(default):
for pos in posiciones:
dominios[pos] = [valor]
variables = dominios.keys()
restricciones = []
for par in itertools.combinations(variables, 2):
restricciones.append((par, eq_fila_columna))
restricciones.append((par, eq_cuadrante))
problem = CspProblem(variables, dominios, restricciones)
print "Inicio..."
print "Min conflicts"
r = min_conflicts(problem, iterations_limit=200)
tablero(r)
print "\n\n"
print "Backtrack"
r = backtrack(problem, value_heuristic=LEAST_CONSTRAINING_VALUE, variable_heuristic=MOST_CONSTRAINED_VARIABLE, inference=True)
tablero(r)
for j in range(ci):
yallah = []
yallah.append('x' + str(i) + str(j))
for a in range(len(cols[j])):
yallah.append('c' + str(j) + str(a))
yallah = tuple(yallah)
constraints.append((yallah, side_const_c))
#binary problem convertion
variables, domains, constraints = convert_to_binary(variables, domains,
constraints)
#csp problem
my_problem = CspProblem(variables, domains, constraints)
#problem solved by backtrack
result = backtrack(my_problem,
variable_heuristic=MOST_CONSTRAINED_VARIABLE,
value_heuristic=LEAST_CONSTRAINING_VALUE)
#result output
for a in range(ri):
for b in range(ci):
if result['x' + str(a) + str(b)] == 1:
print('X', end=' ')
else:
print('O', end=' ')
print('\n')
for esquina in ESQUINAS:
scope = [esquina] + adyacentes_de(esquina)
restricciones.append((scope, una_y_solo_una_pared))
def zona_segura_sin_zombies(variables, values):
"La primer variable es la esquina, el resto son las casillas adyacentes a la misma"
esquina, *adyacentes = values
if esquina != 'zona_segura':
return True
for elemento in adyacentes:
if elemento == 'zombie':
return False
return True
for esquina in ESQUINAS:
scope = [esquina] + adyacentes_de(esquina)
restricciones.append((scope, zona_segura_sin_zombies))
if __name__ == '__main__':
invasion_problem = CspProblem(variables_problema, dominios, restricciones)
inicio = datetime.now()
solution = backtrack(invasion_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE)
segundos = (datetime.now() - inicio).total_seconds()
print(f"Tiempo total: {segundos}s")
pprint(solution)
def const_different(variables, values):
return len(values) == len(set(values)) # remove repeated values and count
constraints = [
(('F', 'T', 'U', 'W', 'R', 'O'), const_different),
(('O', 'R', 'C_10'), lambda vars_, values: values[0] + values[0] == values[1] + 10 * values[2]),
(('C_10', 'W', 'U', 'C_100'), lambda vars_, values: values[0] + values[1] + values[1] == values[2] + 10 * values[3]),
(('C_100', 'T', 'O', 'C_1000'), lambda vars_, values: values[0] + values[1] + values[1] == values[2] + 10 * values[3]),
(('C_1000', 'F'), lambda vars_, values: values[0] == values[1])
]
original_constraints = deepcopy(constraints)
original_domains = deepcopy(domains)
start = time()
problem = CspProblem(variables, original_domains, original_constraints)
result = backtrack(problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE)
elapsed = time() - start
print result
print "Took %d seconds to finish using n-ary constraints" % elapsed
start = time()
variables, domains, constraints = convert_to_binary(variables, domains, constraints)
problem = CspProblem(variables, domains, constraints)
result = backtrack(problem, value_heuristic=LEAST_CONSTRAINING_VALUE)
elapsed = time() - start
print result
print "Took %d seconds to finish using binary constraints" % elapsed
G = G + tareas_aceleradora[var[index]]
if a == 'B':
B = B + tareas_aceleradora[var[index]]
return T <= serv_aceleradora['T'] and G <= serv_aceleradora['G'] and B <= serv_aceleradora['B']
def todos(var, val):
return len(set(val)) == 3
restricciones.append(((variables), procesadores))
restricciones.append(((variables), ram))
restricciones.append(((variables), aceleradora))
# Para que use todos los servidores, no hace falta.
#restricciones.append(((variables), todos))
problem = CspProblem(variables, dominios, restricciones)
resultado = backtrack(problem = problem)
print resultado
# --> Solución <--
# {'A': 'T', 'C': 'T', 'E': 'G', 'G': 'G', 'L': 'T', 'S': 'B'}
# G -> E, G --- > 4 proc, 16 RAM, ag --- > 2 + 2, 14 + 2, 1
# T -> L, C, A --- > 8 proc, 32 RAM --- > 2 + 5 + 1, 10 + 20 + 1
# B -> S --- > 4 proc, 15 RAM --- > 2, 8
# L: requiere 2 procesadores y 10 GB de RAM.
# C: requiere 5 procesadores y 20 GB de RAM.
# E: requiere 2 procesadores, 14 GB de RAM y una aceleradora gráfica.
# A: requiere 1 procesador y 1GB de RAM.
# G: requiere 2 procesadores y 2 GB de RAM.
# S: requiere 2 procesadores y 8 GB de RAM.
def hide_system_and_motor(variables, values):
return not ('motor de salto a velocidad de la luz' in values
and 'sistema de ocultamiento' in values)
constraints.append((variables, hide_system_and_motor))
def lanzador_conexion(variables, values):
p1, p2, p3 = values
return ('lanzador de torpedos de protones' == p1
or 'lanzador de torpedos de protones'
== p2) and 'sistema de apuntamiento de armas' == p3
constraints.append((('p1', 'p2', 'p3'), lanzador_conexion))
def shield_and_communication(variables, values):
return not (set(values) == set(
('escudo mejorado', 'sistema de comunicaciones')))
for interconect in INTERCONECTADAS:
constraints.append((interconect, shield_and_communication))
result = backtrack(CspProblem(variables, domains, constraints))
print('Result: ')
print(result)
LEAST_CONSTRAINING_VALUE, HIGHEST_DEGREE_VARIABLE)
variables = list(range(8))
dominios = {n: list(range(8)) for n in range(8)}
restricciones = []
def no_en_misma_fila(variables, values):
fila_1, fila_2 = values
return fila_1 != fila_2
def no_en_diagonal(variables, values):
col_1, col_2 = variables
fila_1, fila_2 = values
return abs(fila_1 - fila_2) != abs(col_1 - col_2)
for reina_1, reina_2 in itertools.combinations(variables, 2):
restricciones.append(((reina_1, reina_2), no_en_misma_fila))
restricciones.append(((reina_1, reina_2), no_en_diagonal))
problema = CspProblem(variables, dominios, restricciones)
resultado = backtrack(problema,
value_heuristic=LEAST_CONSTRAINING_VALUE,
variable_heuristic=MOST_CONSTRAINED_VARIABLE)
# resultado = min_conflicts(problema, iterations_limit=2)
print(resultado)
def no_supera_3000(variables, valores):
suma = 0
for valor in valores:
suma += equipamientos[valor][1]
return suma < 3000
def no_armadura(variables, valores):
suma1 = 0
for valor in valores:
if equipamientos[valor][0] == 1:
suma1 += 1
return suma1 == 1
def no_espadas(variables, valores):
suma2 = 0
for valor in valores:
if equipamientos[valor][0] == 2:
suma2 += 1
return suma2 == 1
restricciones.append((variables, no_armadura))
restricciones.append((variables, no_espadas))
restricciones.append((variables, no_supera_3000))
print 'Backtrack', backtrack(CspProblem(variables, dominios, restricciones))
print 'Min Conflicts', min_conflicts(CspProblem(variables, dominios,
restricciones),
iterations_limit=10000)
__author__ = 'nathaniel'
from simpleai.search import CspProblem, backtrack, min_conflicts, MOST_CONSTRAINED_VARIABLE
variables = ('one', 'two', 'three', 'four', 'five')
domains = dict((v, range(11)) for v in variables)
# print domains
def const_different(variables, values):
return values[0] != values[1] and abs(values[0] - values[1]) < 11
constraints = []
for v in variables:
for x in variables:
if v != x:
va = (v, x)
constraint = (va, const_different)
constraints.append(constraint)
print constraints
my_problem = CspProblem(variables, domains, constraints)
print backtrack(my_problem)
variables = ('X1', 'X2', 'X3', 'X4', 'X5', 'X6')
domains = dict((v, [False, True]) for v in variables)
constraints = [
(('X1', 'X2', 'X6'), lambda v, values: values[0] or values[1] or values[2]),
(('X1', 'X3', 'X4'), lambda v, values: not values[0] or values[1] or values[2]),
(('X4', 'X5', 'X6'), lambda v, values: not values[0] or not values[1] or values[2]),
(('X2', 'X5', 'X6'), lambda v, values: values[0] or values[1] or not values[2]),
]
original_constraints = deepcopy(constraints)
original_domains = deepcopy(domains)
start = time()
problem = CspProblem(variables, original_domains, original_constraints)
result = backtrack(problem)
elapsed = time() - start
print result
print "Took %d seconds to finish using n-ary constraints" % elapsed
start = time()
variables, domains, constraints = convert_to_binary(variables, domains, constraints)
problem = CspProblem(variables, domains, constraints)
result = backtrack(problem)
elapsed = time() - start
print result
print "Took %d seconds to finish using binary constraints" % elapsed
variables = ('John', 'Anna', 'Tom', 'Patricia')
domains = {
'John': [1, 2, 3],
'Anna': [1, 3],
'Tom': [2, 4],
'Patricia': [2, 3, 4],
}
constraints = [(('John', 'Anna', 'Tom'), constraint_unique),
(('Tom', 'Anna'), constraint_bigger),
(('John', 'Patricia'), constraint_odd_even)]
problem = CspProblem(variables, domains, constraints)
print('\nSolutions:\n\nNormal:', backtrack(problem))
print('\nMost constrained variable:',
backtrack(problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE))
print('\nHighest degree variable:',
backtrack(problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE))
print('\nLeast constraining value:',
backtrack(problem, variable_heuristic=LEAST_CONSTRAINING_VALUE))
print(
'\nMost constrained variable and least constraining value:',
backtrack(problem,
variable_heuristic=MOST_CONSTRAINED_VARIABLE,
value_heuristic=LEAST_CONSTRAINING_VALUE))
return constraints
def display_solution(sol):
for i in uppercase[:9]:
print " ".join([str(sol["%s%d" % (i, j)]) for j in xrange(1, 10)])
domains.update(parsepuzzle(sudoku))
# -- Hand made binary constraints --
constraints = mkconstraints()
start = time()
domains0 = deepcopy(domains)
my_problem = CspProblem(variables, domains0, constraints)
sol = backtrack(my_problem)
elapsed = time() - start
display_solution(sol)
print "Took %d seconds to finish using binary constraints" % elapsed # because of AC3 should be quick
# -- N-ary constraints made binary using hidden variables --
domains1 = deepcopy(domains)
start = time()
variables1, domains1, constraints = convert_to_binary(variables, domains1, mknaryconstraints())
my_problem = CspProblem(variables1, domains1, constraints)
sol = backtrack(my_problem)
elapsed = time() - start
display_solution(sol)
print "Took %d seconds to finish using binary constraints (hidden variables)" % elapsed
def no_en_diagonal(variables, valores):
fila_a = valores[0]
columna_a = int(variables[0][1])
fila_b = valores[1]
columna_b = int(variables[1][1])
return abs(fila_a - fila_b) != abs(columna_a - columna_b)
restricciones = []
for reina_a, reina_b in itertools.combinations(variables, 2):
restricciones.append(((reina_a, reina_b), distinta_fila))
restricciones.append(((reina_a, reina_b), no_en_diagonal))
problem = CspProblem(variables, dominios, restricciones)
print 'backtrack:'
result = backtrack(problem,
variable_heuristic=MOST_CONSTRAINED_VARIABLE,
value_heuristic=LEAST_CONSTRAINING_VALUE,
inference=True)
print result
print 'min_conflicts:'
result = min_conflicts(problem, iterations_limit=100)
print result
constraints = [
(('Mark', 'Julia'), constraint_func),
(('Mark', 'Steve'), constraint_func),
(('Julia', 'Steve'), constraint_func),
(('Julia', 'Amanda'), constraint_func),
(('Julia', 'Derek'), constraint_func),
(('Julia', 'Brian'), constraint_func),
(('Steve', 'Amanda'), constraint_func),
(('Steve', 'Allan'), constraint_func),
(('Steve', 'Michelle'), constraint_func),
(('Amanda', 'Michelle'), constraint_func),
(('Amanda', 'Joanne'), constraint_func),
(('Amanda', 'Derek'), constraint_func),
(('Brian', 'Derek'), constraint_func),
(('Brian', 'Kelly'), constraint_func),
(('Joanne', 'Michelle'), constraint_func),
(('Joanne', 'Amanda'), constraint_func),
(('Joanne', 'Derek'), constraint_func),
(('Joanne', 'Kelly'), constraint_func),
(('Derek', 'Kelly'), constraint_func),
]
# Solve the problem
problem = CspProblem(names, colors, constraints)
# Print the solution
output = backtrack(problem)
print('\nColor mapping:\n')
for k, v in output.items():
print(k, '===>', v)
for v2 in adyacentes_de(variable):
restricciones_eficientes.append(
((variable, v2), no_nidos_y_vereda_o_juego_juntos))
restricciones_eficientes.append(
((variable, v2), contenido_distinto_en_adyacentes))
# para el caso de los arboles y veredas solo debemos generar los pares donde las casillas
# estan adyacentes verticalmente. Lo podemos lograr agregando la variable y la que esta debajo
# total la restriccion contempla el ambos ordenes
if variable[0] < 4: # evitamos la ultima fila
variable_al_sur = (variable[0] + 1, variable[1])
restricciones_eficientes.append(
((variable, variable_al_sur), arboles_al_norte_de_vereda))
if __name__ == '__main__':
# probamos con las restricciones menos eficientes y mas eficientes para comparar
nagai_problem = CspProblem(variables_problema, dominios, restricciones)
inicio = datetime.now()
solution = backtrack(nagai_problem,
variable_heuristic=MOST_CONSTRAINED_VARIABLE)
segundos = (datetime.now() - inicio).total_seconds()
imprimir_solucion(solution, "no eficiente", segundos)
alecto_problem = CspProblem(variables_problema, dominios,
restricciones_eficientes)
inicio = datetime.now()
solution = backtrack(alecto_problem,
variable_heuristic=MOST_CONSTRAINED_VARIABLE)
segundos = (datetime.now() - inicio).total_seconds()
imprimir_solucion(solution, "eficiente", segundos)
def diferentes(variables, valores):
fila0, fila1 = valores
return fila0 != fila1
def no_en_diagonal(variables, valores):
fila0, fila1 = valores
columna0, columna1 = [int(reina[1]) for reina in variables]
dif_col = abs(columna0 - columna1)
dif_fil = abs(fila0 - fila1)
return dif_col != dif_fil
restricciones = []
for par in itertools.combinations(variables, 2):
restricciones.append((par, diferentes))
restricciones.append((par, no_en_diagonal))
csp = CspProblem(variables, dominios, restricciones)
resultado = backtrack(csp,
inference=True,
variable_heuristic=MOST_CONSTRAINED_VARIABLE,
value_heuristic=LEAST_CONSTRAINING_VALUE)
print resultado
def const_different(variables, values):
return values[0] != values[
1] # expect the value of the neighbors to be different
constraints = [
(('WA', 'NT'), const_different),
(('WA', 'SA'), const_different),
(('SA', 'NT'), const_different),
(('SA', 'Q'), const_different),
(('NT', 'Q'), const_different),
(('SA', 'NSW'), const_different),
(('Q', 'NSW'), const_different),
(('SA', 'V'), const_different),
(('NSW', 'V'), const_different),
]
my_problem = CspProblem(variables, domains, constraints)
print backtrack(my_problem)
print backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE)
print backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE)
print backtrack(my_problem, value_heuristic=LEAST_CONSTRAINING_VALUE)
print backtrack(my_problem,
variable_heuristic=MOST_CONSTRAINED_VARIABLE,
value_heuristic=LEAST_CONSTRAINING_VALUE)
print backtrack(my_problem,
variable_heuristic=HIGHEST_DEGREE_VARIABLE,
value_heuristic=LEAST_CONSTRAINING_VALUE)
print min_conflicts(my_problem)
return len(values) == len(set(values)) # remove repeated values and count
# a constraint that expects one variable to be bigger than other
def const_one_bigger_other(variables, values):
return values[0] > values[1]
# a constraint thet expects two variables to be one odd and the other even,
# no matter which one is which type
def const_one_odd_one_even(variables, values):
if values[0] % 2 == 0:
return values[1] % 2 == 1 # first even, expect second to be odd
else:
return values[1] % 2 == 0 # first odd, expect second to be even
constraints = [
(('A', 'B', 'C'), const_different),
(('A', 'C'), const_one_bigger_other),
(('A', 'C'), const_one_odd_one_even),
]
my_problem = CspProblem(variables, domains, constraints)
from simpleai.search import backtrack
# my_problem = ... (steps from the previous section)
result = backtrack(my_problem)
