mathdatech/Python
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Python.git synced 2025-02-25 10:28:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: mathdatech:8d30f5cf2aabb7207e7a47f7814c9308159f94aa
Branches Tags
mathdatech:master
mathdatech:uv-again
mathdatech:gh-pages
mathdatech:cclauss-patch-2
mathdatech:Fewer-forward-propogations-to-speed-tests
mathdatech:cclauss-patch-1
mathdatech:Python-3.12-on-Debian-bookworm
mathdatech:fix-maclaurin_series-on-Python3.12
mathdatech:quantum_random.py.disabled
...
compare: mathdatech:d6dc09432b31f43bdc5b75c9a6b5f64215975230
Branches Tags
mathdatech:master
mathdatech:uv-again
mathdatech:gh-pages
mathdatech:cclauss-patch-2
mathdatech:Fewer-forward-propogations-to-speed-tests
mathdatech:cclauss-patch-1
mathdatech:Python-3.12-on-Debian-bookworm
mathdatech:fix-maclaurin_series-on-Python3.12
mathdatech:quantum_random.py.disabled

3 Commits
8d30f5cf2a ... d6dc09432b

Author SHA1 Message Date
miltonbhowmick
d6dc09432b Changed large grid to small grid for final as github ci build failded for long characters in the doctest output 2023-08-12 21:32:33 +06:00
miltonbhowmick
e2a380ed13 Fixed long 88 characters line and object name issue and shortent learning source link 2023-08-12 21:22:34 +06:00
miltonbhowmick
89c60510dc Re-added doctest as per reviewer said and also added learning source link for user 2023-08-12 21:09:25 +06:00
1 changed files with 121 additions and 68 deletions
Show Stats Expand all files Collapse all files

189
graphs/uniform_search_cost.py
View File

@ -1,3 +1,19 @@
##################### -- Learning Source -- #####################
# 1. https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
# 2. https://www.educative.io/answers/what-is-uniform-cost-search
# In above 1 no. link, you will get about dijkstra algorithm.
# You may have to scroll down a little bit.
# And you will get a section titled as "Practical optimizations and infinite graphs"
# This section explains about Uniform Cost Search algorithm.
# Uniform search cost is slightly similar to dijkstra.
# The main different between them is that UCS is having multiple goals.
# Below code is fully based on 2D Grid environment
##################### --------------------- #####################
# diagonal clockwise # diagonal clockwise
dxy1 = [ dxy1 = [
[1, 1], [1, 1],
@ -81,12 +97,14 @@ class UniformCostSearch:
) -> list[list[float]] | list[list[int]]: ) -> list[list[float]] | list[list[int]]:
""" """
Return 2D list where optimal path is stored. Return 2D list where optimal path is stored.
# >>> start = [0,0] >>> start = [0,0]
# >>> end = [1, 2] >>> end = [1, 1]
# >>> dist = [[1,0],[0,2]] >>> dist = [[1,0],[0,2]]
# >>> dxy = [(1, 1),(1, 0),(1, -1),(0, -1),(-1, -1),(-1, 0),(-1, 1),(0, 1)] >>> grid = [[0,0],[0,0]]
# >>> get_shortest_path(start,end,dist,dxy) >>> dxy = [[1, 1],[1, 0],[1, -1],[0, -1],[-1, -1],[-1, 0],[-1, 1],[0, 1]]
# [[0,0],[1,1]] >>> obj = UniformCostSearch(grid)
>>> obj.get_shortest_path(start,end,dist,dxy)
[[1, 1], [0, 1], [1, 0], [0, 0]]
""" """
shortest_path = [] shortest_path = []
curr_node = None curr_node = None
@ -121,13 +139,46 @@ class UniformCostSearch:
) -> list[list[float]] | list[list[int]] | None: ) -> list[list[float]] | list[list[int]] | None:
""" """
Return 2D list where optimal path is stored. Return 2D list where optimal path is stored.
# >>> current = [0, 0]
# >>> final = [[1, 1]] Examples:
# >>> grid = [[0,0],[0,0]]
# >>> dxy = [(1, 1),(1, 0),(1, -1),(0, -1),(-1, -1),(-1, 0),(-1, 1),(0, 1)] >>> current = [0, 0]
# >>> goal_answer = [1000000, 100000] >>> final = [[1, 1]]
# >>> ucs(current,final,grid,dxy,goal_answer) >>> grid = [[0,0],[0,0]]
# [[0,2],[1,1]] >>> goal_answer = [100000000]
>>> dxy = [[1, 1],[1, 0],[1, -1],[0, -1],[-1, -1],[-1, 0],[-1, 1],[0, 1]]
>>> obj = UniformCostSearch(grid)
>>> obj.ucs(current, final, grid, dxy, goal_answer)
Increment
Extended distance
[[1, 1], [0, 0]]
>>> current = [0, 0]
>>> final = [[2, 2]]
>>> grid = [[0,1,0],[1,0,1],[1,0,0]]
>>> goal_answer = [100000000]
>>> dxy = [[1, 1],[1, 0],[1, -1],[0, -1],[-1, -1],[-1, 0],[-1, 1],[0, 1]]
>>> obj = UniformCostSearch(grid)
>>> obj.ucs(current, final, grid, dxy, goal_answer)
Increment
Extended distance
[[2, 2], [1, 1], [0, 0]]
>>> current = [0, 0]
>>> final = [[2, 2],[2,1]] # multiple goals
>>> grid = [[0,1,0],[1,0,1],[1,0,0]]
>>> goal_answer = [100000000, 100000000]
>>> dxy = [[1, 1],[1, 0],[1, -1],[0, -1],[-1, -1],[-1, 0],[-1, 1],[0, 1]]
>>> obj = UniformCostSearch(grid)
>>> obj.ucs(current, final, grid, dxy, goal_answer)
Increment
Extended distance
Increment
Extended distance
[[2, 2], [1, 1], [0, 0]]
""" """
dist = [[float("inf") for _ in range(self.m)] for _ in range(self.n)] dist = [[float("inf") for _ in range(self.m)] for _ in range(self.n)]
@ -163,26 +214,39 @@ class UniformCostSearch:
ry = dy + y ry = dy + y
if 0 <= rx < self.m and 0 <= ry < self.n and grid[rx][ry] != 1: if 0 <= rx < self.m and 0 <= ry < self.n and grid[rx][ry] != 1:
weight = 1 weight = 1
# diagonal_weight = 1.414
# if (
# (dx == -1 and dy == -1)
# or (dx == 1 and dy == 1)
# or (dx == 1 and dy == -1)
# or (dx == -1 and dy == 1)
# ):
# new_dist = d + diagonal_weight
# else:
new_dist = d + weight new_dist = d + weight
if new_dist < dist[rx][ry]: if new_dist < dist[rx][ry]:
dist[rx][ry] = new_dist dist[rx][ry] = new_dist
heap.append([new_dist, rx, ry]) heap.append([new_dist, rx, ry])
return None return None
def your_algorithm( def execute_algorithm(
self, start_point: list[int], end_point: list[int], grid: list[list[int]] self, start_point: list[int], end_point: list[int], grid: list[list[int]]
) -> list[list[float]] | list[list[int]] | None: ) -> list[list[float]] | list[list[int]] | None:
""" """
Return 2D list where optimal path is stored. Return 2D list where optimal path is stored.
>>> start_point = [0, 0]
>>> end_point = [1, 1]
>>> grid = [[0,0],[0,0]]
>>> dxy = [[1, 1],[1, 0],[1, -1],[0, -1],[-1, -1],[-1, 0],[-1, 1],[0, 1]]
>>> goal_answer = [100000000]
>>> obj = UniformCostSearch(grid)
>>> obj.execute_algorithm(start_point, end_point, grid)
Increment
Extended distance
[[1, 1], [0, 0]]
>>> start_point = [0, 0]
>>> end_point = [2, 2]
>>> grid = [[0,1,0],[1,0,1],[1,0,0]]
>>> dxy = [[1, 1],[1, 0],[1, -1],[0, -1],[-1, -1],[-1, 0],[-1, 1],[0, 1]]
>>> goal_answer = [100000000]
>>> obj = UniformCostSearch(grid)
>>> obj.execute_algorithm(start_point, end_point, grid)
Increment
Extended distance
[[2, 2], [1, 1], [0, 0]]
""" """
dxy = [] dxy = []
if start_point[1] - end_point[1] == 0 and start_point[0] - end_point[0] < 0: if start_point[1] - end_point[1] == 0 and start_point[0] - end_point[0] < 0:
@ -206,55 +270,44 @@ class UniformCostSearch:
return path return path
if __name__ == "__main__": def run() -> None:
executed_object = UniformCostSearch( """
Return nothing. Its a run whole algorithm and print the answer.
>>> run()
Increment
Extended distance
[[7, 7], [6, 6], [5, 5], [4, 4], [3, 3], [2, 2], [1, 1], [0, 0]]
"""
ucs_object = UniformCostSearch(
[ [
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
], ],
) )
path_result = executed_object.your_algorithm( path_result = ucs_object.execute_algorithm(
[0, 7], [0, 0],
[19, 17], [7, 7],
[ [
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
], ],
) )
print(path_result) print(path_result)
if __name__ == "__main__":
import doctest
doctest.testmod()