mathdatech/Python
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Python.git synced 2025-04-16 02:37:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

[mypy] Add/fix type annotations for backtracking algorithms (#4055)

Browse Source 
* Fix mypy errors for backtracking algorithms

* Fix CI failure
This commit is contained in:
Dhruv Manilawala 2020-12-24 18:16:21 +05:30 committed by GitHub
parent 0ccb213c11
commit f3ba9b6c50
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 101 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
backtracking/all_subsequences.py
View File

@ -1,5 +1,3 @@
from typing import Any, List
"""
In this problem, we want to determine all possible subsequences
of the given sequence. We use backtracking to solve this problem.
@ -7,6 +5,7 @@ from typing import Any, List
Time complexity: O(2^n),
where n denotes the length of the given sequence.
"""
from typing import Any, List
def generate_all_subsequences(sequence: List[Any]) -> None:
@ -32,15 +31,10 @@ def create_state_space_tree(
current_subsequence.pop()
"""
remove the comment to take an input from the user
if __name__ == "__main__":
seq: List[Any] = [3, 1, 2, 4]
generate_all_subsequences(seq)
print("Enter the elements")
sequence = list(map(int, input().split()))
"""
sequence = [3, 1, 2, 4]
generate_all_subsequences(sequence)
sequence = ["A", "B", "C"]
generate_all_subsequences(sequence)
seq.clear()
seq.extend(["A", "B", "C"])
generate_all_subsequences(seq)

8
backtracking/coloring.py
View File

@ -5,11 +5,11 @@
Wikipedia: https://en.wikipedia.org/wiki/Graph_coloring
"""
from __future__ import annotations
from typing import List
def valid_coloring(
neighbours: list[int], colored_vertices: list[int], color: int
neighbours: List[int], colored_vertices: List[int], color: int
) -> bool:
"""
For each neighbour check if coloring constraint is satisfied
@ -35,7 +35,7 @@ def valid_coloring(
def util_color(
graph: list[list[int]], max_colors: int, colored_vertices: list[int], index: int
graph: List[List[int]], max_colors: int, colored_vertices: List[int], index: int
) -> bool:
"""
Pseudo-Code
@ -86,7 +86,7 @@ def util_color(
return False
def color(graph: list[list[int]], max_colors: int) -> list[int]:
def color(graph: List[List[int]], max_colors: int) -> List[int]:
"""
Wrapper function to call subroutine called util_color
which will either return True or False.

8
backtracking/hamiltonian_cycle.py
View File

@ -6,11 +6,11 @@
Wikipedia: https://en.wikipedia.org/wiki/Hamiltonian_path
"""
from __future__ import annotations
from typing import List
def valid_connection(
graph: list[list[int]], next_ver: int, curr_ind: int, path: list[int]
graph: List[List[int]], next_ver: int, curr_ind: int, path: List[int]
) -> bool:
"""
Checks whether it is possible to add next into path by validating 2 statements
@ -47,7 +47,7 @@ def valid_connection(
return not any(vertex == next_ver for vertex in path)
def util_hamilton_cycle(graph: list[list[int]], path: list[int], curr_ind: int) -> bool:
def util_hamilton_cycle(graph: List[List[int]], path: List[int], curr_ind: int) -> bool:
"""
Pseudo-Code
Base Case:
@ -108,7 +108,7 @@ def util_hamilton_cycle(graph: list[list[int]], path: list[int], curr_ind: int)
return False
def hamilton_cycle(graph: list[list[int]], start_index: int = 0) -> list[int]:
def hamilton_cycle(graph: List[List[int]], start_index: int = 0) -> List[int]:
r"""
Wrapper function to call subroutine called util_hamilton_cycle,
which will either return array of vertices indicating hamiltonian cycle

12
backtracking/knight_tour.py
View File

@ -1,9 +1,9 @@
# Knight Tour Intro: https://www.youtube.com/watch?v=ab_dY3dZFHM
from __future__ import annotations
from typing import List, Tuple
def get_valid_pos(position: tuple[int], n: int) -> list[tuple[int]]:
def get_valid_pos(position: Tuple[int, int], n: int) -> List[Tuple[int, int]]:
"""
Find all the valid positions a knight can move to from the current position.
@ -32,7 +32,7 @@ def get_valid_pos(position: tuple[int], n: int) -> list[tuple[int]]:
return permissible_positions
def is_complete(board: list[list[int]]) -> bool:
def is_complete(board: List[List[int]]) -> bool:
"""
Check if the board (matrix) has been completely filled with non-zero values.
@ -46,7 +46,9 @@ def is_complete(board: list[list[int]]) -> bool:
return not any(elem == 0 for row in board for elem in row)
def open_knight_tour_helper(board: list[list[int]], pos: tuple[int], curr: int) -> bool:
def open_knight_tour_helper(
board: List[List[int]], pos: Tuple[int, int], curr: int
) -> bool:
"""
Helper function to solve knight tour problem.
"""
@ -66,7 +68,7 @@ def open_knight_tour_helper(board: list[list[int]], pos: tuple[int], curr: int)
return False
def open_knight_tour(n: int) -> list[list[int]]:
def open_knight_tour(n: int) -> List[List[int]]:
"""
Find the solution for the knight tour problem for a board of size n. Raises
ValueError if the tour cannot be performed for the given size.

18
backtracking/minimax.py
View File

@ -1,18 +1,18 @@
from __future__ import annotations
import math
""" Minimax helps to achieve maximum score in a game by checking all possible moves
"""
Minimax helps to achieve maximum score in a game by checking all possible moves
depth is current depth in game tree.
nodeIndex is index of current node in scores[].
if move is of maximizer return true else false
leaves of game tree is stored in scores[]
height is maximum height of Game tree
"""
import math
from typing import List
def minimax(
depth: int, node_index: int, is_max: bool, scores: list[int], height: float
depth: int, node_index: int, is_max: bool, scores: List[int], height: float
) -> int:
"""
>>> import math
@ -32,10 +32,6 @@ def minimax(
>>> height = math.log(len(scores), 2)
>>> minimax(0, 0, True, scores, height)
12
>>> minimax('1', 2, True, [], 2 )
Traceback (most recent call last):
...
TypeError: '<' not supported between instances of 'str' and 'int'
"""
if depth < 0:
@ -59,7 +55,7 @@ def minimax(
)
def main():
def main() -> None:
scores = [90, 23, 6, 33, 21, 65, 123, 34423]
height = math.log(len(scores), 2)
print("Optimal value : ", end="")

63
backtracking/n_queens_math.py
View File

@ -75,14 +75,14 @@ Applying this two formulas we can check if a queen in some position is being att
for another one or vice versa.
"""
from __future__ import annotations
from typing import List
def depth_first_search(
possible_board: list[int],
diagonal_right_collisions: list[int],
diagonal_left_collisions: list[int],
boards: list[list[str]],
possible_board: List[int],
diagonal_right_collisions: List[int],
diagonal_left_collisions: List[int],
boards: List[List[str]],
n: int,
) -> None:
"""
@ -94,40 +94,33 @@ def depth_first_search(
['. . Q . ', 'Q . . . ', '. . . Q ', '. Q . . ']
"""
""" Get next row in the current board (possible_board) to fill it with a queen """
# Get next row in the current board (possible_board) to fill it with a queen
row = len(possible_board)
"""
If row is equal to the size of the board it means there are a queen in each row in
the current board (possible_board)
"""
# If row is equal to the size of the board it means there are a queen in each row in
# the current board (possible_board)
if row == n:
"""
We convert the variable possible_board that looks like this: [1, 3, 0, 2] to
this: ['. Q . . ', '. . . Q ', 'Q . . . ', '. . Q . ']
"""
possible_board = [". " * i + "Q " + ". " * (n - 1 - i) for i in possible_board]
boards.append(possible_board)
# We convert the variable possible_board that looks like this: [1, 3, 0, 2] to
# this: ['. Q . . ', '. . . Q ', 'Q . . . ', '. . Q . ']
boards.append([". " * i + "Q " + ". " * (n - 1 - i) for i in possible_board])
return
""" We iterate each column in the row to find all possible results in each row """
# We iterate each column in the row to find all possible results in each row
for col in range(n):
"""
We apply that we learned previously. First we check that in the current board
(possible_board) there are not other same value because if there is it means
that there are a collision in vertical. Then we apply the two formulas we
learned before:
45º: y - x = b or 45: row - col = b
135º: y + x = b or row + col = b.
And we verify if the results of this two formulas not exist in their variables
respectively. (diagonal_right_collisions, diagonal_left_collisions)
If any or these are True it means there is a collision so we continue to the
next value in the for loop.
"""
# We apply that we learned previously. First we check that in the current board
# (possible_board) there are not other same value because if there is it means
# that there are a collision in vertical. Then we apply the two formulas we
# learned before:
#
# 45º: y - x = b or 45: row - col = b
# 135º: y + x = b or row + col = b.
#
# And we verify if the results of this two formulas not exist in their variables
# respectively. (diagonal_right_collisions, diagonal_left_collisions)
#
# If any or these are True it means there is a collision so we continue to the
# next value in the for loop.
if (
col in possible_board
or row - col in diagonal_right_collisions
@ -135,7 +128,7 @@ def depth_first_search(
):
continue
""" If it is False we call dfs function again and we update the inputs """
# If it is False we call dfs function again and we update the inputs
depth_first_search(
possible_board + [col],
diagonal_right_collisions + [row - col],
@ -146,10 +139,10 @@ def depth_first_search(
def n_queens_solution(n: int) -> None:
boards = []
boards: List[List[str]] = []
depth_first_search([], [], [], boards, n)
""" Print all the boards """
# Print all the boards
for board in boards:
for column in board:
print(column)

43
backtracking/sudoku.py
View File

@ -1,7 +1,3 @@
from typing import List, Tuple, Union
Matrix = List[List[int]]
"""
Given a partially filled 9×9 2D array, the objective is to fill a 9×9
square grid with digits numbered 1 to 9, so that every row, column, and
@ -13,8 +9,12 @@ Matrix = List[List[int]]
have solved the puzzle. else, we backtrack and place another number
in that cell and repeat this process.
"""
from typing import List, Optional, Tuple
Matrix = List[List[int]]
# assigning initial values to the grid
initial_grid = [
initial_grid: Matrix = [
[3, 0, 6, 5, 0, 8, 4, 0, 0],
[5, 2, 0, 0, 0, 0, 0, 0, 0],
[0, 8, 7, 0, 0, 0, 0, 3, 1],
@ -27,7 +27,7 @@ initial_grid = [
]
# a grid with no solution
no_solution = [
no_solution: Matrix = [
[5, 0, 6, 5, 0, 8, 4, 0, 3],
[5, 2, 0, 0, 0, 0, 0, 0, 2],
[1, 8, 7, 0, 0, 0, 0, 3, 1],
@ -80,7 +80,7 @@ def is_completed(grid: Matrix) -> bool:
return all(all(cell != 0 for cell in row) for row in grid)
def find_empty_location(grid: Matrix) -> Tuple[int, int]:
def find_empty_location(grid: Matrix) -> Optional[Tuple[int, int]]:
"""
This function finds an empty location so that we can assign a number
for that particular row and column.
@ -89,9 +89,10 @@ def find_empty_location(grid: Matrix) -> Tuple[int, int]:
for j in range(9):
if grid[i][j] == 0:
return i, j
return None
def sudoku(grid: Matrix) -> Union[Matrix, bool]:
def sudoku(grid: Matrix) -> Optional[Matrix]:
"""
Takes a partially filled-in grid and attempts to assign values to
all unassigned locations in such a way to meet the requirements
@ -107,25 +108,30 @@ def sudoku(grid: Matrix) -> Union[Matrix, bool]:
[1, 3, 8, 9, 4, 7, 2, 5, 6],
[6, 9, 2, 3, 5, 1, 8, 7, 4],
[7, 4, 5, 2, 8, 6, 3, 1, 9]]
>>> sudoku(no_solution)
False
>>> sudoku(no_solution) is None
True
"""
if is_completed(grid):
return grid
row, column = find_empty_location(grid)
location = find_empty_location(grid)
if location is not None:
row, column = location
else:
# If the location is ``None``, then the grid is solved.
return grid
for digit in range(1, 10):
if is_safe(grid, row, column, digit):
grid[row][column] = digit
if sudoku(grid):
if sudoku(grid) is not None:
return grid
grid[row][column] = 0
return False
return None
def print_solution(grid: Matrix) -> None:
@ -141,11 +147,12 @@ def print_solution(grid: Matrix) -> None:
if __name__ == "__main__":
# make a copy of grid so that you can compare with the unmodified grid
for grid in (initial_grid, no_solution):
grid = list(map(list, grid))
solution = sudoku(grid)
if solution:
print("grid after solving:")
for example_grid in (initial_grid, no_solution):
print("\nExample grid:\n" + "=" * 20)
print_solution(example_grid)
print("\nExample grid solution:")
solution = sudoku(example_grid)
if solution is not None:
print_solution(solution)
else:
print("Cannot find a solution.")