Added lazy delete with heapq

Author: luceCoding

leetcode/medium/1135_connecting_cities_with_minimum_cost.md

@@ -1,37 +1,33 @@
 # 1135. Connecting Cities With Minimum Cost
 
-## Prim's Algorithm Solution
-- Run-time: O(N^2)
-- Space: O(N)
-- N = Number of cities
+## Prim's Algorithm Solution with Heaps
+- Run-time: O((V + E)logV)
+- Space: O(V)
+- V = Vertices
+- E = Edges
 
-This is question requires a minimum spanning tree (MST) algorithm.
-I choose to use Prim's algorithm because it is similar to Dijkstra's algorithm over Kruskal's algorithm, both are greedy algorithms.
-Knowing one will help you in learning the other.
-
-The idea with Prim's is to utilize a heap of vertices and an adjacent list.
-The resulting MST cannot produce a cycle due to the method of selecting an edge of an unvisited vertex.
-To select an edge, we use the heap sorted by the cost or weight of the edge.
-Each time we pop from the heap, we mark that vertex as visited and add it's neighboring vertices' edges to the heap.
+This question requires a minimum spanning tree (MST) algorithm.
+I choose to use Prim's algorithm over Kruskal's algorithm because it is similar to Dijkstra's algorithm, both are greedy algorithms.
+Knowing one will help you learn the other.
 
 The pseudocode could be represented as such:
-1. Select an arbitrary vertex to start with and add its neighboring vertices to the heap.
-2. Mark that arbitrary vertex as visited.
-3. While there are unvisited vertices:
-    - Select the edge with the min weight of an unvisited vertex from top of heap.
+1. Select an arbitrary vertex to start with and add it to the heap.
+2. While the heap isn't empty:
+    - Select the min edge/weight of an unvisited vertex from top of heap.
     - Add the selected vertex to the visited vertices.
-    - Add selected vertex's neighboring edges of unvisited vertices into the heap.
+    - Take note of the cost or path taken.
+    - Add/Update selected vertex's neighboring edges/weights of unvisited vertices into the heap.
 
 As of the time of writing this, Python 3.7 doesn't have an adaptable priority queue implementation.
-So this is why this version of Prim's runs at O(N^2) time.
-This example is more of a lazy heap implementation.
-If we were to use an adaptable priority queue, we would see O(MlogN) run-time.
-This is because we will only have at most N cities in the heap, no duplicates.
-There would be a feature to update a specific city's cost in the heap and bubble up and down the heap to maintain the heap property.
-With an adaptable priority queue, there would be no need to use a visited set.
-
+If there was a real adaptable priority queue, there would be a feature to update a specific city's cost in the heap and bubble up and down the heap to maintain the heap property.
 To read more about adaptable priority queues, check out [Data Structures and Algorithms in Python 1st Edition](https://www.amazon.com/Structures-Algorithms-Python-Michael-Goodrich/dp/1118290275).
 
+This example is more of a lazy heap implementation, looking at the heapq documentation, they show an implementation of a lazy adaptable priority queue.
+This will help us to get O((V + E)logV) run-time.
+Without performing the lazy delete technique with a heaq, we would get O(V^2(V + E)logV) run-time.
+That is because in a undirected dense graph, we would be adding duplicate entries of the same nodes into the heap.
+There are a lot of incorrect implementations of Prim's Algorithm using heapq that do not perform lazy deletes out there, so be warned.
+
 ```
 from collections import defaultdict
 
@@ -47,19 +43,32 @@ class Solution:
                 adj_list[city2].append((city1, cost))
             return adj_list
 
+        def add_city(new_city, new_cost):
+            new_node = [new_cost, new_city, False]
+            city_to_heap_node[new_city] = new_node
+            heapq.heappush(min_heap, new_node)
+
         adj_list = create_adj_list()
-        min_heap = list([(0, 1)]) # start at city #1
-        visited = set()
-        min_cost = 0
-        while min_heap and len(visited) != N:
-            cost, city = heapq.heappop(min_heap)
-            if city in visited: # skip this city
+        start_node = [0, 1, False] # cost, city, remove
+        min_heap = list([start_node]) # start at city #1
+        city_to_heap_node = dict({1 : start_node})
+        visited, min_cost = set(), 0
+        while min_heap:
+            cost, city, remove = heapq.heappop(min_heap)
+            if remove: # lazy delete
                 continue
             visited.add(city)
             min_cost += cost
             for next_city, next_cost in adj_list[city]:
                 if next_city in visited:
                     continue
-                heapq.heappush(min_heap, (next_cost, next_city))
+                elif next_city in city_to_heap_node:
+                    heap_node = city_to_heap_node[next_city]
+                    if next_cost < heap_node[0]: # lower cost?
+                        heap_node[2] = True # lazy delete
+                        add_city(next_city, next_cost)
+                else:
+                    add_city(next_city, next_cost)
+            city_to_heap_node.pop(city)
         return min_cost if len(visited) == N else -1
 ```