Merge pull request #3 from fleron19/queens

Add queens hometask

Author: fleron19

src/queens/bruteforce.py

@@ -0,0 +1,21 @@
+import itertools
+
+def is_valid(board):
+    n = len(board)
+    for i in range(n):
+        for j in range(i + 1, n):
+            if abs(board[i] - board[j]) == abs(i - j):
+                return False
+    return True
+
+def n_queens_bruteforce(n):
+
+    solutions = 0
+    for permutation in itertools.permutations(range(n)):
+        if is_valid(permutation):
+            solutions += 1
+    return solutions
+
+inp = int(input())
+print(n_queens_bruteforce(inp))
+

src/queens/complexity.md

@@ -0,0 +1,12 @@
+# Complexity analysis 
+
+### Bruteforce approach
+Itertools.permutations generates $n!$ permutations. Then,  all of them is being checked using is_valid function
+this function checks every pair of given list, so its complexity is $O(n^2)$
+therefore, general complexity of brutforce method is $O(n! \cdot n^2)$
+
+### Recursive approach
+This algorithm don't generate all possible cases and do not check each one. Instead, we generate only right variants using recusrion with backtraking, so this method do not check LOTS of variants that alredy considered wrong. But in worst case we still need to check all possible permutations, so compplexity of this approach is $O(n!)$
+
+### Fastest approach
+This approach uses simple dictionary, where key of element is number of queens and value is solution for this number. So we need get 1 element from dict, and complexity of such action is $O(1)$

src/queens/fastest.py

@@ -0,0 +1,7 @@
+solutions = {0: 1, 1 : 1, 2 : 0, 3 : 0, 4 : 2, 5 : 10, 6 : 4, 7 : 40, 8 : 92, 9 : 352, 10 : 724,
+            11 : 2680, 12 : 14200, 13 : 73712, 14 : 365596, 15 : 2279184, 16 : 14772512, 
+            17 : 95815104, 18 : 666090624, 19 : 4968057848, 20 : 39029188884, 
+            21 : 314666222712, 22 : 2691008701644, 23 : 24233937684440,
+            24 : 227514171973736, 25 : 2207893435808352, 26 : 22317699616364044, 27 : 234907967154122528} # OEIS A000170
+inp = int(input())
+print(solutions[inp])

src/queens/recursion.py

@@ -0,0 +1,25 @@
+def n_queens_recursion(n):
+    def backtrack(row, board, solutions):
+        if row == n:
+            solutions.append(board[:]) 
+            return
+        
+        for col in range(n):
+            if is_safe(board, row, col):
+                board[row] = col
+                backtrack(row + 1, board, solutions)
+                board[row] = -1
+    
+    solutions = []
+    board = [-1] * n 
+    backtrack(0, board, solutions)
+    return solutions
+
+def is_safe(board, row, col):
+    for i in range(row):
+        if board[i] == col or \
+           abs(board[i] - col) == abs(i - row):
+            return False
+    return True
+inp = int(input())
+print(len(n_queens_recursion(inp)))