Merge branch 'master' into add-clear-least-significant-set-bit

Author: deerred643-star

DIRECTORY.md

@@ -187,6 +187,7 @@
   * [Intensity Based Segmentation](computer_vision/intensity_based_segmentation.py)
   * [Mean Threshold](computer_vision/mean_threshold.py)
   * [Mosaic Augmentation](computer_vision/mosaic_augmentation.py)
+  * [Otsu Threshold](computer_vision/otsu_threshold.py)
   * [Pooling Functions](computer_vision/pooling_functions.py)
   * [Vision Transformer](computer_vision/vision_transformer.py)
 
@@ -454,6 +455,7 @@
   * [Minimum Steps To One](dynamic_programming/minimum_steps_to_one.py)
   * [Minimum Tickets Cost](dynamic_programming/minimum_tickets_cost.py)
   * [Narcissistic Number](dynamic_programming/narcissistic_number.py)
+  * [Needleman Wunsch](dynamic_programming/needleman_wunsch.py)
   * [Optimal Binary Search Tree](dynamic_programming/optimal_binary_search_tree.py)
   * [Palindrome Partitioning](dynamic_programming/palindrome_partitioning.py)
   * [Range Sum Query](dynamic_programming/range_sum_query.py)
@@ -613,6 +615,7 @@
     * [Test Johnson](graphs/tests/test_johnson.py)
     * [Test Min Spanning Tree Kruskal](graphs/tests/test_min_spanning_tree_kruskal.py)
     * [Test Min Spanning Tree Prim](graphs/tests/test_min_spanning_tree_prim.py)
+  * [Travelling Salesman Problem](graphs/travelling_salesman_problem.py)
 
 ## [Greedy Methods](greedy_methods)
   * [Best Time To Buy And Sell Stock](greedy_methods/best_time_to_buy_and_sell_stock.py)

graphs/travelling_salesman_problem.py

@@ -0,0 +1,243 @@
+"""Travelling Salesman Problem (TSP)"""
+
+import itertools
+import math
+
+
+class InvalidGraphError(ValueError):
+    """Custom error for invalid graph inputs."""
+
+
+def euclidean_distance(point1: list[float], point2: list[float]) -> float:
+    """
+    Calculate the Euclidean distance between two points in 2D space.
+
+    :param point1: Coordinates of the first point [x, y]
+    :param point2: Coordinates of the second point [x, y]
+    :return: The Euclidean distance between the two points
+
+    >>> euclidean_distance([0, 0], [3, 4])
+    5.0
+    >>> euclidean_distance([1, 1], [1, 1])
+    0.0
+    >>> euclidean_distance([1, 1], ['a', 1])
+    Traceback (most recent call last):
+        ...
+    ValueError: Invalid input: Points must be numerical coordinates
+    """
+    try:
+        return math.sqrt((point2[0] - point1[0]) ** 2 + (point2[1] - point1[1]) ** 2)
+    except TypeError:
+        raise ValueError("Invalid input: Points must be numerical coordinates")
+
+
+def validate_graph(graph_points: dict[str, list[float]]) -> None:
+    """
+    Validate the input graph to ensure it has valid nodes and coordinates.
+
+    :param graph_points: A dictionary where the keys are node names,
+                         and values are 2D coordinates as [x, y]
+    :raises InvalidGraphError: If the graph points are not valid
+
+    >>> validate_graph({"A": [10, 20], "B": [30, 21], "C": [15, 35]})  # Valid graph
+    >>> validate_graph(  # doctest: +IGNORE_EXCEPTION_DETAIL
+    ...     {"A": [10, 20], "B": [30, "invalid"], "C": [15, 35]}
+    ... )
+    Traceback (most recent call last):
+        ...
+    InvalidGraphError: Each node must have a valid 2D coordinate [x, y]
+
+    >>> validate_graph([10, 20])  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+        ...
+    InvalidGraphError: Graph must be a dictionary with node names and coordinates
+
+    >>> validate_graph(  # doctest: +IGNORE_EXCEPTION_DETAIL
+    ...     {"A": [10, 20], "B": [30, 21], "C": [15]}
+    ... )  # Missing coordinate
+    Traceback (most recent call last):
+        ...
+    InvalidGraphError: Each node must have a valid 2D coordinate [x, y]
+    """
+    if not isinstance(graph_points, dict):
+        raise InvalidGraphError(
+            "Graph must be a dictionary with node names and coordinates"
+        )
+
+    for node, coordinates in graph_points.items():
+        if (
+            not isinstance(node, str)
+            or not isinstance(coordinates, list)
+            or len(coordinates) != 2
+            or not all(isinstance(c, (int, float)) for c in coordinates)
+        ):
+            raise InvalidGraphError("Each node must have a valid 2D coordinate [x, y]")
+
+
+# TSP in Brute Force Approach
+def travelling_salesman_brute_force(
+    graph_points: dict[str, list[float]],
+) -> tuple[list[str], float]:
+    """
+    Solve the Travelling Salesman Problem using brute force.
+
+    :param graph_points: A dictionary of nodes and their coordinates {node: [x, y]}
+    :return: The shortest path and its total distance
+
+    >>> graph = {"A": [10, 20], "B": [30, 21], "C": [15, 35]}
+    >>> travelling_salesman_brute_force(graph)
+    (['A', 'B', 'C', 'A'], 56.35465722402588)
+    """
+    validate_graph(graph_points)
+
+    nodes = list(graph_points.keys())  # Extracting the node names (keys)
+
+    # There should be at least 2 nodes for a valid TSP
+    if len(nodes) < 2:
+        raise InvalidGraphError("Graph must have at least two nodes")
+
+    min_path = []  # List that stores shortest path
+    min_distance = float("inf")  # Initialize minimum distance to infinity
+
+    start_node = nodes[0]
+    other_nodes = nodes[1:]
+
+    # Iterating over all permutations of the other nodes
+    for perm in itertools.permutations(other_nodes):
+        path = [start_node, *perm, start_node]
+
+        # Calculating the total distance
+        total_distance = sum(
+            euclidean_distance(graph_points[path[i]], graph_points[path[i + 1]])
+            for i in range(len(path) - 1)
+        )
+
+        # Update minimum distance if shorter path found
+        if total_distance < min_distance:
+            min_distance = total_distance
+            min_path = path
+
+    return min_path, min_distance
+
+
+# TSP in Dynamic Programming approach
+def travelling_salesman_dynamic_programming(
+    graph_points: dict[str, list[float]],
+) -> tuple[list[str], float]:
+    """
+    Solve the Travelling Salesman Problem using dynamic programming.
+
+    :param graph_points: A dictionary of nodes and their coordinates {node: [x, y]}
+    :return: The shortest path and its total distance
+
+    >>> graph = {"A": [10, 20], "B": [30, 21], "C": [15, 35]}
+    >>> travelling_salesman_dynamic_programming(graph)
+    (['A', 'C', 'B', 'A'], 56.35465722402587)
+    """
+    validate_graph(graph_points)
+
+    n = len(graph_points)  # Extracting the node names (keys)
+
+    # There should be at least 2 nodes for a valid TSP
+    if n < 2:
+        raise InvalidGraphError("Graph must have at least two nodes")
+
+    nodes = list(graph_points.keys())  # Extracting the node names (keys)
+
+    # Initialize distance matrix with float values
+    dist = [
+        [
+            euclidean_distance(graph_points[nodes[i]], graph_points[nodes[j]])
+            for j in range(n)
+        ]
+        for i in range(n)
+    ]
+
+    # Initialize a dynamic programming table with infinity
+    dp = [[float("inf")] * n for _ in range(1 << n)]
+    dp[1][0] = 0  # Only visited node is the starting point at node 0
+
+    # Iterate through all masks of visited nodes
+    for mask in range(1 << n):
+        for u in range(n):
+            # If current node 'u' is visited
+            if mask & (1 << u):
+                # Traverse nodes 'v' such that u->v
+                for v in range(n):
+                    if mask & (1 << v) == 0:  # If v is not visited
+                        next_mask = mask | (1 << v)  # Upodate mask to include 'v'
+                        # Update dynamic programming table with minimum distance
+                        dp[next_mask][v] = min(
+                            dp[next_mask][v], dp[mask][u] + dist[u][v]
+                        )
+
+    final_mask = (1 << n) - 1
+    min_cost = float("inf")
+    end_node = -1  # Track the last node in the optimal path
+
+    for u in range(1, n):
+        if min_cost > dp[final_mask][u] + dist[u][0]:
+            min_cost = dp[final_mask][u] + dist[u][0]
+            end_node = u
+
+    path = []
+    mask = final_mask
+    while end_node != 0:
+        path.append(nodes[end_node])
+        for u in range(n):
+            # If current state corresponds to optimal state before visiting end node
+            if (
+                mask & (1 << u)
+                and dp[mask][end_node]
+                == dp[mask ^ (1 << end_node)][u] + dist[u][end_node]
+            ):
+                mask ^= 1 << end_node  # Update mask to remove end node
+                end_node = u  # Set the previous node as end node
+                break
+
+    path.append(nodes[0])  # Bottom-up Order
+    path.reverse()  # Top-Down Order
+    path.append(nodes[0])
+
+    return path, min_cost
+
+
+# Demo Graph
+#        C (15, 35)
+#        |
+#        |
+#        |
+# F (5, 15) --- A (10, 20)
+#        |         |
+#        |         |
+#        |         |
+#        |         |
+# E (25, 5) --- B (30, 21)
+#        |
+#        |
+#        |
+#       D (40, 10)
+#        |
+#        |
+#        |
+#       G (50, 25)
+
+
+if __name__ == "__main__":
+    demo_graph = {
+        "A": [10.0, 20.0],
+        "B": [30.0, 21.0],
+        "C": [15.0, 35.0],
+        "D": [40.0, 10.0],
+        "E": [25.0, 5.0],
+        "F": [5.0, 15.0],
+        "G": [50.0, 25.0],
+    }
+
+    # Brute force
+    brute_force_result = travelling_salesman_brute_force(demo_graph)
+    print(f"Brute force result: {brute_force_result}")
+
+    # Dynamic programming
+    dp_result = travelling_salesman_dynamic_programming(demo_graph)
+    print(f"Dynamic programming result: {dp_result}")

sorts/topological_sort.py

@@ -1,4 +1,4 @@
-"""Topological Sort.
+"""Topological Sort on Directed Acyclic Graph(DAG)
 
 https://en.wikipedia.org/wiki/Topological_sorting
 https://en.wikipedia.org/wiki/Directed_acyclic_graph
@@ -9,19 +9,22 @@
 
 #     a
 #    / \
-#   b  c
+#   b   c
 #  / \
-# d  e
+# d   e
+
 edges: dict[str, list[str]] = {
     "a": ["c", "b"],
     "b": ["d", "e"],
     "c": [],
     "d": [],
     "e": [],
 }
+
 vertices: list[str] = ["a", "b", "c", "d", "e"]
 
 
+# Perform topological sort on a DAG starting from the specified node
 def topological_sort(start: str, visited: list[str], sort: list[str]) -> list[str]:
     """
     Perform topological sort on a directed acyclic graph.
@@ -44,24 +47,34 @@ def topological_sort(start: str, visited: list[str], sort: list[str]) -> list[st
     if not isinstance(sort, list):
         raise ValueError("sort must be a list")
     current = start
-    # add current to visited
+    # Mark the current node as visited
     visited.append(current)
+    # List of all neighbors of current node
     neighbors = edges[current]
+
+    # Traverse all neighbors of the current node
     for neighbor in neighbors:
-        # if neighbor not in visited, visit
+        # Recursively visit each unvisited neighbor
         if neighbor not in visited:
             sort = topological_sort(neighbor, visited, sort)
-    # if all neighbors visited add current to sort
+
+    # After visiting all neighbors, add the current node to the sorted list
     sort.append(current)
-    # if all vertices haven't been visited select a new one to visit
+
+    # If there are some nodes that were not visited (disconnected components)
     if len(visited) != len(vertices):
-        for vertice in vertices:
-            if vertice not in visited:
-                sort = topological_sort(vertice, visited, sort)
-    # return sort
+        for vertex in vertices:
+            if vertex not in visited:
+                sort = topological_sort(vertex, visited, sort)
+
+    # Return sorted list
     return sort
 
 
 if __name__ == "__main__":
+    # Topological Sorting from node "a" (Returns the order in bottom up approach)
     sort = topological_sort("a", [], [])
+
+    # Reversing the list to get the correct topological order (Top down approach)
+    sort.reverse()
     print(sort)