Merge branch 'develop'

Author: codejsha

README.md

@@ -156,7 +156,7 @@ var list = Arrays.stream(arr).boxed().sorted().collect(Collectors.toCollection(A
 
 - Advancing through an array, EPI#5.4: [c++](cpp-algorithm/src/array) | Advance through the array to the last index.
 - Arbitrary precision operation - increment an arbitrary-precision integer, EPI#5.2: [c++](cpp-algorithm/src/array)(`PlusOne`) | Add one to the number represented by the vector.
-- Arbitrary precision operation - add two arbitrary-precision integers: [c++](cpp-algorithm/src/array)((`StringAddition`)) | Add two numbers represented by strings.
+- Arbitrary precision operation - add two arbitrary-precision integers: [c++](cpp-algorithm/src/array)(`StringAddition`) | Add two numbers represented by strings.
 - Arbitrary precision operation - multiply two arbitrary-precision integers, EPI#5.3: [c++](cpp-algorithm/src/array)(`Multiply`) | Multiply two numbers represented by vectors.
 - Delete duplicates from a sorted array, EPI#5.5: [c++](cpp-algorithm/src/array)(`DeleteDuplicates`) | Delete duplicate elements in the array.
 - Delete duplicates from a sorted array: [c++](cpp-algorithm/src/array)(`DeleteDuplicateElements`) | Delete duplicate elements in the array.
@@ -260,7 +260,7 @@ algorithm DFS-VISIT(G, u):
     u.finished = time
 ```
 
-- Dijkstra's algorithm: [c++](cpp-algorithm/src/graph), [java](java-algorithm/src/main/java/com/example/algorithm/graph) | A single source shortest path algorithm that handle non-negative edge weights. It find the shortest path between two vertices in a graph.
+- Dijkstra's algorithm, CCSP#4.5.1: [c++](cpp-algorithm/src/graph),[python](python-algorithm/algorithm/graph/test)(test), [java](java-algorithm/src/main/java/com/example/algorithm/graph) | A single source the shortest path algorithm that handle non-negative edge weights. It find the shortest path between two vertices in a graph.
 
 ```txt
 algorithm Dijkstra(G, source):
@@ -347,6 +347,7 @@ algorithm Prim(G, root):
 **Examples**
 
 - Maze problem: [java](java-algorithm/src/main/java/com/example/algorithm/graph) | A maze problem is that find a path from the start to the goal. The maze is represented by a graph. The start and the goal are represented by vertices. The path is represented by a sequence of vertices.
+- Minimum spanning tree (Kruskal, Prim, Boruvka), CCSP#4.4.2: [python](python-algorithm/algorithm/graph/test)(test) | Find the minimum spanning tree of a graph.
 
 [:arrow_up_small: back to toc](#table-of-contents)
 
@@ -994,9 +995,9 @@ list.sort(Comparator.comparingInt(String::length));
 
 | **Case**    | **Time complexity** | **Remarks**                                                                             |
 | :---------- | :-----------------: | :-------------------------------------------------------------------------------------- |
-| **Best**    |       $O(n)$        | when the input list is already sorted in the desired order                              |
+| **Best**    |       $O(n)$        | when the input list is already sorted in the desired order (ascending or descending)    |
 | **Worst**   |      $O(n^2)$       | when the input list is already sorted in the reverse order of the desired sorting order |
-| **Average** |      $O(n^2)$       |                                                                                         |
+| **Average** |      $O(n^2)$       | when the input list is in jumbled order                                                 |
 
 - Bucket sort: [java](java-algorithm/src/main/java/com/example/algorithm/sort) | Bucket sort is a sorting algorithm that works by distributing the elements of an array into a number of buckets. Each bucket contains a range of values and the elements are sorted within these buckets using any of the suitable sorting algorithms (such as insertion sort, merge sort, selection sort).<br>(`n` is the number of elements and `k` is the number of buckets)
 
@@ -1008,11 +1009,11 @@ list.sort(Comparator.comparingInt(String::length));
 
 - Counting sort: [java](java-algorithm/src/main/java/com/example/algorithm/sort) | Counting sort is a non-comparative sorting algorithm that sorts the elements of an array by counting the occurrences of each element in the array. The count is stored in an auxiliary array and the sorting is done by mapping the count as an index of the auxiliary array. It is used as a subroutine in radix sort.<br>(`n` is the number of elements and `k` is the range of input values)
 
-| **Case**    | **Time complexity** | **Remarks**                                          |
-| ----------- | :-----------------: | ---------------------------------------------------- |
-| **Best**    |     $O(n + k)$      | when the input elements have a small range of values |
-| **Worst**   |     $O(n + k)$      | when the input elements have a large range of values |
-| **Average** |     $O(n + k)$      |                                                      |
+| **Case**    | **Time complexity** | **Remarks**                                             |
+| ----------- | :-----------------: | ------------------------------------------------------- |
+| **Best**    |     $O(n + k)$      | when the input elements have a small range of values    |
+| **Worst**   |     $O(n + k)$      | when the input elements have a large range of values    |
+| **Average** |     $O(n + k)$      | when the elements are distributed randomly in the array |
 
 - Heap sort: [java](java-algorithm/src/main/java/com/example/algorithm/sort) | Heap sort is a comparison-based sorting algorithm that uses a binary heap data structure to sort an array. It is used for the implementation of priority queue.<br>(`n` is the number of elements)
 
@@ -1062,7 +1063,7 @@ list.sort(Comparator.comparingInt(String::length));
 - Merge two sorted arrays, EPI#13.2, LeetCode#merge-sorted-array: [c++](cpp-algorithm/src/sort)(`MergeTwoSortedArray`) | Merge two sorted array. Merge the second array into the first array.
 - Partitioning and sorting an array with many repeated entries, EPI#13.9: [java](java-algorithm/src/main/java/com/example/algorithm/sort)(`GroupByAge`) | Given an array of objects with an age field, reorder the array so that objects of equal age appear together. They should be sorted in ascending order of age, and the order of objects with the same age is not important.
 - Remove first-name duplicates, EPI#13.4: [c++](cpp-algorithm/src/sort)(`EliminateFirstNameDuplicate`) | Given an array of names, remove the duplicates of the first name.
-- Salary threadhold, EPI#13.12: [java](java-algorithm/src/main/java/com/example/algorithm/sort)(`SalaryThreshold`) | Given an array of salaries and a budget, compute the salary cap so that the total salaries equal the budget.
+- Salary threshold, EPI#13.12: [java](java-algorithm/src/main/java/com/example/algorithm/sort)(`SalaryThreshold`) | Given an array of salaries and a budget, compute the salary cap so that the total salaries equal the budget.
 - Team photo day, EPI#13.10: [java](java-algorithm/src/main/java/com/example/algorithm/sort)(`SortPlayerByHeight`) | Given two arrays of numbers, for team photos, players are arranged in front and back rows and then photographed. The players in the back row must necessarily be taller than those in the front row. Additionally, all players in a row should belong to the same team.
 - Union of intervals, EPI#13.8: [c++](cpp-algorithm/src/sort)(`UnionOfIntervals`) | Given a set of intervals, compute their union.
 

python-algorithm/algorithm/graph/test/graph_data_utils.py

@@ -0,0 +1,85 @@
+import networkx
+
+seattle = 'Seattle'
+san_francisco = 'San Francisco'
+los_angeles = 'Los Angeles'
+riverside = 'Riverside'
+phoenix = 'Phoenix'
+dallas = 'Dallas'
+houston = 'Houston'
+atlanta = 'Atlanta'
+miami = 'Miami'
+chicago = 'Chicago'
+detroit = 'Detroit'
+boston = 'Boston'
+new_york = 'New York'
+philadelphia = 'Philadelphia'
+washington = 'Washington'
+
+
+def create_city_graph() -> networkx.Graph:
+    edges = [
+        (seattle, chicago),
+        (seattle, san_francisco),
+        (san_francisco, riverside),
+        (san_francisco, los_angeles),
+        (los_angeles, riverside),
+        (los_angeles, phoenix),
+        (riverside, phoenix),
+        (riverside, chicago),
+        (phoenix, dallas),
+        (phoenix, houston),
+        (dallas, chicago),
+        (dallas, atlanta),
+        (dallas, houston),
+        (houston, atlanta),
+        (houston, miami),
+        (atlanta, chicago),
+        (atlanta, washington),
+        (atlanta, miami),
+        (miami, washington),
+        (chicago, detroit),
+        (detroit, boston),
+        (detroit, washington),
+        (detroit, new_york),
+        (boston, new_york),
+        (new_york, philadelphia),
+        (philadelphia, washington)
+    ]
+    graph = networkx.Graph()
+    graph.add_edges_from(edges)
+    return graph
+
+
+def create_weighted_city_graph() -> networkx.Graph:
+    weighted_edges = [
+        (seattle, chicago, 1737),
+        (seattle, san_francisco, 678),
+        (san_francisco, riverside, 386),
+        (san_francisco, los_angeles, 348),
+        (los_angeles, riverside, 50),
+        (los_angeles, phoenix, 357),
+        (riverside, phoenix, 307),
+        (riverside, chicago, 1704),
+        (phoenix, dallas, 887),
+        (phoenix, houston, 1015),
+        (dallas, chicago, 805),
+        (dallas, atlanta, 721),
+        (dallas, houston, 225),
+        (houston, atlanta, 702),
+        (houston, miami, 968),
+        (atlanta, chicago, 588),
+        (atlanta, washington, 543),
+        (atlanta, miami, 604),
+        (miami, washington, 923),
+        (chicago, detroit, 238),
+        (detroit, boston, 613),
+        (detroit, washington, 396),
+        (detroit, new_york, 482),
+        (boston, new_york, 190),
+        (new_york, philadelphia, 81),
+        (philadelphia, washington, 123)
+    ]
+    graph = networkx.Graph()
+    graph.add_weighted_edges_from(weighted_edges)
+    return graph

python-algorithm/algorithm/graph/test/test_breadth_first_search.py

@@ -1,78 +1,64 @@
-import pytest, networkx
-
-
-def create_city_graph() -> networkx.Graph:
-    graph = networkx.Graph()
-    graph.add_edge("Seattle", "Chicago")
-    graph.add_edge("Seattle", "San Francisco")
-    graph.add_edge("San Francisco", "Riverside")
-    graph.add_edge("San Francisco", "Los Angeles")
-    graph.add_edge("Los Angeles", "Riverside")
-    graph.add_edge("Los Angeles", "Phoenix")
-    graph.add_edge("Riverside", "Phoenix")
-    graph.add_edge("Riverside", "Chicago")
-    graph.add_edge("Phoenix", "Dallas")
-    graph.add_edge("Phoenix", "Houston")
-    graph.add_edge("Dallas", "Chicago")
-    graph.add_edge("Dallas", "Atlanta")
-    graph.add_edge("Dallas", "Houston")
-    graph.add_edge("Houston", "Atlanta")
-    graph.add_edge("Houston", "Miami")
-    graph.add_edge("Atlanta", "Chicago")
-    graph.add_edge("Atlanta", "Washington")
-    graph.add_edge("Atlanta", "Miami")
-    graph.add_edge("Miami", "Washington")
-    graph.add_edge("Chicago", "Detroit")
-    graph.add_edge("Detroit", "Boston")
-    graph.add_edge("Detroit", "Washington")
-    graph.add_edge("Detroit", "New York")
-    graph.add_edge("Boston", "New York")
-    graph.add_edge("New York", "Philadelphia")
-    graph.add_edge("Philadelphia", "Washington")
-    return graph
+import networkx
+import pytest
 
+from algorithm.graph.test.graph_data_utils import create_city_graph
 
 city_graph = create_city_graph()
 
 
 @pytest.mark.benchmark(group='graph_neighbors')
 @pytest.mark.parametrize(
-    argnames='graph, source, expected',
+    argnames='graph, source, expected_neighbors',
     argvalues=[
-        (city_graph, "Seattle", ["Chicago", "San Francisco"]),
-        (city_graph, "San Francisco", ["Seattle", "Riverside", "Los Angeles"]),
-        (city_graph, "Los Angeles", ["San Francisco", "Riverside", "Phoenix"]),
-        (city_graph, "Riverside", ["San Francisco", "Los Angeles", "Phoenix", "Chicago"]),
-        (city_graph, "Phoenix", ["Los Angeles", "Riverside", "Dallas", "Houston"]),
-        (city_graph, "Chicago", ["Seattle", "Riverside", "Dallas", "Atlanta", "Detroit"]),
-        (city_graph, "Boston", ["Detroit", "New York"]),
-        (city_graph, "New York", ["Detroit", "Boston", "Philadelphia"]),
-        (city_graph, "Atlanta", ["Dallas", "Houston", "Chicago", "Washington", "Miami"]),
-        (city_graph, "Miami", ["Houston", "Atlanta", "Washington"]),
-        (city_graph, "Dallas", ["Phoenix", "Chicago", "Atlanta", "Houston"]),
-        (city_graph, "Houston", ["Phoenix", "Dallas", "Atlanta", "Miami"]),
-        (city_graph, "Detroit", ["Chicago", "Boston", "Washington", "New York"]),
-        (city_graph, "Philadelphia", ["New York", "Washington"]),
-        (city_graph, "Washington", ["Atlanta", "Miami", "Detroit", "Philadelphia"])
+        (city_graph, 'Seattle', ['Chicago', 'San Francisco']),
+        (city_graph, 'San Francisco', ['Seattle', 'Riverside', 'Los Angeles']),
+        (city_graph, 'Los Angeles', ['San Francisco', 'Riverside', 'Phoenix']),
+        (city_graph, 'Riverside', ['San Francisco', 'Los Angeles', 'Phoenix', 'Chicago']),
+        (city_graph, 'Phoenix', ['Los Angeles', 'Riverside', 'Dallas', 'Houston']),
+        (city_graph, 'Chicago', ['Seattle', 'Riverside', 'Dallas', 'Atlanta', 'Detroit']),
+        (city_graph, 'Boston', ['Detroit', 'New York']),
+        (city_graph, 'New York', ['Detroit', 'Boston', 'Philadelphia']),
+        (city_graph, 'Atlanta', ['Dallas', 'Houston', 'Chicago', 'Washington', 'Miami']),
+        (city_graph, 'Miami', ['Houston', 'Atlanta', 'Washington']),
+        (city_graph, 'Dallas', ['Phoenix', 'Chicago', 'Atlanta', 'Houston']),
+        (city_graph, 'Houston', ['Phoenix', 'Dallas', 'Atlanta', 'Miami']),
+        (city_graph, 'Detroit', ['Chicago', 'Boston', 'Washington', 'New York']),
+        (city_graph, 'Philadelphia', ['New York', 'Washington']),
+        (city_graph, 'Washington', ['Atlanta', 'Miami', 'Detroit', 'Philadelphia'])
     ])
-def test_graph_neighbors(benchmark, graph, source, expected):
-    result = benchmark(graph.neighbors, source)
-    assert sorted(expected) == sorted(result)
+def test_graph_neighbors(benchmark, graph, source, expected_neighbors):
+    """
+    Find the neighboring city nodes of the source city node in the United States city graph.
+    :param benchmark: benchmark fixture
+    :param graph: city graph of the United States
+    :param source: source city node
+    :param expected_neighbors: list of neighboring city nodes
+    """
+    neighbor_iterator = benchmark(graph.neighbors, source)
+    assert sorted(expected_neighbors) == sorted(neighbor_iterator)
 
 
 @pytest.mark.benchmark(group='graph_breadth_first_search')
 @pytest.mark.parametrize(
-    argnames='graph, source, distance, expected',
+    argnames='graph, source, distance, expected_nodes',
     argvalues=[
-        (city_graph, "Boston", 1, ["Detroit", "New York"]),
-        (city_graph, "Boston", 2, ["Chicago", "Washington", "Philadelphia"]),
-        (city_graph, "Boston", 3, ["Seattle", "Riverside", "Dallas", "Atlanta", "Miami"]),
+        (city_graph, 'Boston', 1, ['Detroit', 'New York']),
+        (city_graph, 'Boston', 2, ['Chicago', 'Washington', 'Philadelphia']),
+        (city_graph, 'Boston', 3, ['Seattle', 'Riverside', 'Dallas', 'Atlanta', 'Miami']),
     ],
-    ids=["distance1", "distance2", "distance3"])
-def test_graph_breadth_first_search(benchmark, graph, source, distance, expected):
+    ids=['distance1', 'distance2', 'distance3'])
+def test_graph_breadth_first_search(benchmark, graph, source, distance, expected_nodes):
+    """
+    Find the city nodes at a given distance from the source city node in the United States city graph.
+    :param benchmark: benchmark fixture
+    :param graph: city graph of the United States
+    :param source: source city node
+    :param distance: distance from the source city node
+    :param expected_nodes: list of city nodes at the given distance from the source city node
+    """
     bfs_generator = benchmark(networkx.bfs_layers, graph, source)
-    path = []
+    nodes = []
     for i, layer in enumerate(bfs_generator):
         if i == distance:
-            path = list(layer)
-    assert path == expected
+            nodes = list(layer)
+    assert nodes == expected_nodes

python-algorithm/algorithm/graph/test/test_dijkstra.py

@@ -0,0 +1,46 @@
+import networkx
+import pytest
+
+from algorithm.graph.test.graph_data_utils import create_weighted_city_graph
+
+city_graph = create_weighted_city_graph()
+
+
+@pytest.mark.benchmark(group='graph_dijkstra')
+@pytest.mark.parametrize(
+    argnames='graph, source, target, expected_path',
+    argvalues=[
+        (city_graph, 'Los Angeles', 'Boston', ['Los Angeles', 'Riverside', 'Chicago', 'Detroit', 'Boston']),
+    ],
+    ids=['los_angeles_to_boston'])
+def test_graph_dijkstra_path(benchmark, graph, source, target, expected_path):
+    """
+    Find the shortest path between two nodes in a graph using Dijkstra's algorithm.
+    :param benchmark: benchmark fixture
+    :param graph: city graph of the United States
+    :param source: source city node
+    :param target: target city node
+    :param expected_path: expected shortest path
+    """
+    shortest_path = benchmark(networkx.dijkstra_path, graph, source, target)
+    assert shortest_path == expected_path
+
+
+@pytest.mark.benchmark(group='graph_dijkstra')
+@pytest.mark.parametrize(
+    argnames='graph, source, target, expected_distance',
+    argvalues=[
+        (city_graph, 'Los Angeles', 'Boston', 2605),
+    ],
+    ids=['los_angeles_to_boston'])
+def test_graph_dijkstra_distance(benchmark, graph, source, target, expected_distance):
+    """
+    Find the shortest distance between two nodes in a graph using Dijkstra's algorithm.
+    :param benchmark: benchmark fixture
+    :param graph: city graph of the United States
+    :param source: source city node
+    :param target: target city node
+    :param expected_distance: expected shortest distance (weight)
+    """
+    total_weight = benchmark(networkx.dijkstra_path_length, graph, source, target)
+    assert total_weight == expected_distance

python-algorithm/algorithm/graph/test/test_minimum_spanning_tree.py

@@ -0,0 +1,44 @@
+import matplotlib.pyplot as plt
+import networkx
+import pytest
+
+from algorithm.graph.test.graph_data_utils import create_weighted_city_graph
+
+city_graph = create_weighted_city_graph()
+
+
+@pytest.mark.skip(reason='This test is for visualization only')
+def test_graph_mst_temp():
+    mst = networkx.minimum_spanning_tree(city_graph, algorithm='kruskal')
+    pos = networkx.spring_layout(mst)
+    networkx.draw_networkx_nodes(mst, pos)
+    networkx.draw_networkx_edges(mst, pos, width=1)
+    networkx.draw_networkx_labels(mst, pos, font_size=10)
+    plt.show()
+
+
+city_edges = {('Seattle', 'San Francisco'), ('San Francisco', 'Los Angeles'), ('Los Angeles', 'Riverside'),
+              ('Riverside', 'Phoenix'), ('Phoenix', 'Dallas'), ('Dallas', 'Houston'), ('Houston', 'Atlanta'),
+              ('Atlanta', 'Miami'), ('Atlanta', 'Washington'), ('Washington', 'Philadelphia'),
+              ('Philadelphia', 'New York'), ('New York', 'Boston'), ('Washington', 'Detroit'), ('Detroit', 'Chicago')}
+
+
+@pytest.mark.benchmark(group='graph_minimum_spanning_tree')
+@pytest.mark.parametrize(
+    argnames='graph, algorithm, expected_total_weight, expected_edges',
+    argvalues=[
+        (city_graph, 'kruskal', 5372, city_edges),
+        (city_graph, 'prim', 5372, city_edges),
+        (city_graph, 'boruvka', 5372, city_edges),
+    ],
+    ids=['kruskal', 'prim', 'boruvka'])
+def test_graph_mst(benchmark, graph, algorithm, expected_total_weight, expected_edges):
+    mst = benchmark(networkx.minimum_spanning_tree, graph, algorithm=algorithm)
+
+    mst_total_weight = sum(d['weight'] for u, v, d in mst.edges(data=True))
+    assert expected_total_weight == mst_total_weight
+
+    mst_edges = set((u, v) for u, v, d in mst.edges(data=True))
+    normalized_set1 = {tuple(sorted(edge)) for edge in expected_edges}
+    normalized_set2 = {tuple(sorted(edge)) for edge in mst_edges}
+    assert normalized_set1 == normalized_set2

python-algorithm/algorithm/greedy/cashier_change.py

@@ -1,4 +1,10 @@
 def cashier_change(denominations: list[int], price: int) -> int:
+    """
+    Find the minimum number of coins needed to make change for a given amount of money.
+    :param denominations: list of coin denominations
+    :param price: amount of money
+    :return: minimum number of coins
+    """
     change = price
     coins = 0