Backtracking ohne Inferences

P2.py

@@ -4,6 +4,7 @@ import random
 class Field:
     def __init__(self, init_state=None):
         self.state = []
+        self.domain_values = [1, 2, 3, 4, 5, 6, 7, 8]
 
         if init_state is None:
             for i in range(8):
@@ -20,12 +21,25 @@ class Field:
     def get_state(self):
         return self.state
 
+    def get_domain_values(self):
+        return self.domain_values
+
     # Actions
     def set_state(self, column, row=None):
         if row is None:
             self.state[column] = random.randint(1, 8)
-        if 0 < row and row < 9:
-            self.state[column] = row
+        elif 0 < row < 9:
+            if column < len(self.state):
+                self.state[column] = row
+            elif column == len(self.state):
+                self.state.append(row)
+
+    def set_domain_values(self, new_domain):
+        self.domain_values = new_domain
+
+    def add_state(self, row):
+        if len(self.get_state()) < 8:
+            self.set_state(len(self.get_state()), row)
 
     def move_queen(self, column, new_row=None):
         self.set_state(column, new_row)
@@ -64,7 +78,8 @@ class Field:
         for row in range(8, 0, -1):  # (0:8]
             row_string = ""
             for line in range(8):
-                if line < len(self.state) and row is self.state[line]:  # is there a Queen in this line (spalte) in this row
+                if line < len(self.state) and row is self.state[
+                    line]:  # is there a Queen in this line (spalte) in this row
                     if (row + line) % 2 == 0:
                         row_string += "▌Q▐│"
                     else:
@@ -154,15 +169,82 @@ class Genetic:
         return best_field
 
 
+def consistency(field, new_row):
+    current_state = field.get_state().copy()
+    current_state.append(new_row)
+    new_field = Field(current_state)
 
+    if new_field.threats > 0:
+        return False
+    else:
+        return True
+
+
+def inference(field):
+    inferences = []
+    column = len(field.get_state()) - 1
+    state = field.get_state().copy()
+    row = state[column]
+
+    for i in range(len(field.get_state()), 8):
+        removed_values = []
+        for new_row in field.get_domain_values():
+            new_state = state.copy()
+            new_state.append(new_row)
+            new_field = Field(new_state)
+            if new_field.threats > 0:
+                removed_values.append(new_row)
+
+        for i in removed_values:
+            if i in field.get_domain_values():
+                field.get_domain_values().remove(i)
+
+        inferences.extend(removed_values)
+
+        if len(field.get_domain_values()) == 0:
+            return False, inferences
+
+    return True, inferences
+
+
+def backtracing(field):
+    if len(field.get_state()) == 8:
+        return [Field(field.get_state().copy())]
+
+    solutions = []
+    iter_domain = field.get_domain_values().copy()
+
+    for row in iter_domain:
+        if consistency(field, row):
+            field.add_state(row)
+            result = backtracing(field)
+            if len(result) != 0:
+                solutions.extend(result)
+
+            field.get_state().pop()
+
+    return solutions
+
+
+def backtracing_helper(field):
+    results = backtracing(field)
+
+    return results
 
 
 def main():
     new_field = Field(
-        init_state=[1,2,3])  # [8, 4, 5, 4, 4, 3, 7, 6] [5, 5, 5, 5, 1, 2, 8, 5] [6,3,5,7,1,4,2,8]
+        init_state=[])  # [8, 4, 5, 4, 4, 3, 7, 6] [5, 5, 5, 5, 1, 2, 8, 5] [6,3,5,7,1,4,2,8]
     new_field.print_field()
     print(new_field.collisions())
 
+    print("Backtrack Algorithm")
+    results = []
+    for i in range(1, 9):
+        results.extend(backtracing_helper(Field([i])))
+    for i, result in enumerate(results):
+        print(f"{i+1} {result.get_state()}")
+
     print("Genetic Algorithm")
     genetic = Genetic(500)
     best_genetic_field = genetic.genetic_algorithm(100)
@@ -170,8 +252,4 @@ def main():
     print(best_genetic_field.get_fitness())
 
 
-
-
-
-
 main()