Queen placement (Chapter 4)

4.Complexity-of-algorithms-and-problems/Task_1/Queen-placement-v.1.0.0.py

@@ -0,0 +1,25 @@
+import itertools
+
+# Переборное решение
+
+def enumeration_solution(n):
+    if n < 0:
+        print("Введите неотрицательное число")
+        return 0
+    count = 0
+    for permutation in itertools.permutations(range(n)):
+        valid = True
+        for i in range(n):
+            for j in range(i+1, n):
+                if abs(i - j) == abs(permutation[i] - permutation[j]):
+                    valid = False
+                    break
+            if not valid:
+                break
+        if valid:
+            count += 1
+    return count
+
+size = int(input("Введите число N: "))
+result = enumeration_solution(size)
+print(f"Количество решений: {result}")

4.Complexity-of-algorithms-and-problems/Task_1/Queen-placement-v.1.1.0.py

@@ -0,0 +1,32 @@
+# Рекурсивное решение
+
+def recursive_solution(n):
+    if n <= 0:
+        print("Введите неотрицательное число")
+        return 0
+    count = 0
+    array = [0] * n
+
+    def check(line, column):
+        for i in range(line):
+            if array[i] == column or abs(array[i] - column) == abs(i - line):
+                return False
+        return True
+
+    def solve(line):
+        nonlocal count
+        if line == n:
+            count += 1
+            return
+
+        for column in range(n):
+            if check(line, column):
+                array[line] = column
+                solve(line + 1)
+
+    solve(0)
+    return count
+
+size = int(input("Введите число N: "))
+result = recursive_solution(size)
+print(f"Количество решений: {result}")

4.Complexity-of-algorithms-and-problems/Task_1/Queen-placement-v.1.2.0.py

@@ -0,0 +1,80 @@
+from multiprocessing import Pool
+from multiprocessing import cpu_count
+
+# Быстрое решение
+
+def recursive_solution(n):
+    if n <= 0:
+        print("Введите неотрицательное число")
+        return 0
+    count = 0
+    array = [0] * n
+
+    def check(line, column):
+        for i in range(line):
+            if array[i] == column or abs(array[i] - column) == abs(i - line):
+                return False
+        return True
+
+    def solve(line):
+        nonlocal count
+        if line == n:
+            count += 1
+            return
+
+        for column in range(n):
+            if check(line, column):
+                array[line] = column
+                solve(line + 1)
+
+    solve(0)
+    return count
+
+
+def wrapper(args):
+    n, first_col = args
+
+    array = [first_col] + [0] * (n - 1)
+    count = 0
+
+    def check(line, column):
+        for i in range(line):
+            if array[i] == column or abs(array[i] - column) == abs(i - line):
+                return False
+        return True
+
+    def solve(line):
+        nonlocal count
+        if line == n:
+            count += 1
+            return
+
+        for column in range(n):
+            if check(line, column):
+                array[line] = column
+                solve(line + 1)
+
+    solve(1)
+    return count
+
+def parallel_solution(n):
+    if n <= 0:
+        print("Введите неотрицательное число")
+        return 0
+
+    tasks = [(n, col) for col in range(n)]
+
+    with Pool(processes=cpu_count()) as pool:
+        results = pool.map(wrapper, tasks)
+
+    return sum(results)
+
+if __name__ == "__main__":
+    size = int(input("Введите число N: "))
+
+    if size <= 8:
+        result = recursive_solution(size)
+    else:
+        result = parallel_solution(size)
+
+    print(f"Количество решений: {result}")

4.Complexity-of-algorithms-and-problems/Task_1/complexity.md

@@ -0,0 +1,61 @@
+# Задача о расстановке ферзей
+
+## Описание
+Три версии программы реализуют одну задачу по-разному: 
+
+## Структура проекта
+- Queen-placement-v.1.0.0 - Переборное решение
+- Queen-placement-v.1.1.0 - Рекурсивное решение
+- Queen-placement-v.1.2.0 - Самое быстрое решение, которое получилось.
+
+## Оценка сложности
+### Переборное решение
+Сложность: O(n! × n²)
+Обоснование: 
+n! - генерация всех возможных перестоновок ферзей
+n² - проверка каждой перестоновки на конфликт по диагонали
+
+### Рекрусивное решение
+Сложность: O(n!)
+Обоснование: 1-я строка: n вариантов, 2-я строка: (n-1) вариантов и т.д.. В худшем случае получаем n!
+
+### Быстрое решение
+Сложность: O(n!)
+Обоснование: То же, что и с рекрусивным решением, но чуть быстрее за счёт многопоточности
+
+
+## Тест скорости
+
+Для тестирования используются оптимально подобранные значения N, чтобы:
+- Продемонстрировать разницу в производительности
+- Избежать ожидания по несколько часов для больших n
+
+Конфигурация системы:
+- CPU: AMD Ryzen 5 5500 (6)
+- GPU: 00:02.0 VMware SVGA II Adapter
+- RAM: 5846MiB
+- OS: Ubuntu 24.04.2 LTS x86_64
+
+### Переборное решение
+n = 11
+Результат: 24 секунды
+
+n = 12
+Результат: более 5 минут
+
+### рекрусивное решение
+n = 12
+Результат: 4 секунды
+
+n = 13
+Результат: 21 секунда
+
+n = 14
+Результат: 2 минуты 34 секунды
+
+### Самое быстрое решение
+n = 14
+Результат: 34 секунды
+
+n = 15
+Результат: 4 минуты 6 секунд