Fixed 1135

Author: luceCoding

leetcode/medium/1135_connecting_cities_with_minimum_cost.md

@@ -1,18 +1,18 @@
 # 1135. Connecting Cities With Minimum Cost
 
 ## Prim's Algorithm Solution
-- Run-time: O((V + E) log(V))
-- Space: O(E)
-- E - Number of Edges
+- Run-time: O(N^2)
+- Space: O(N)
+- N = Number of cities
 
-This is question requires a minimum span tree(MST) algothrim.
-I choose to use Prim's algothrim because it is similar to Dijkstra's algorithm over Kruskal's algorithm.
+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 vetrex as visited and add it's neighboring vertices' edges to the heap.
+Each time we pop from the heap, we mark that vertex as visited and add it's neighboring vertices' edges to the heap.
 
 The pseudocode could be represented as such:
 1. Select an arbitrary vertex to start with and add its neighboring vertices to the heap.
@@ -22,48 +22,44 @@ The pseudocode could be represented as such:
     - Add the selected vertex to the visited vertices.
     - Add selected vertex's neighboring edges of unvisited vertices into the heap.
 
-Since we are sorting based on vertices, the sorting will take log(V) run-time.
-However, we have to sort this based on number of vertices or edges because we can be given a graph of islands or nodes that have edges to all nodes.
-That is why its O((V+E) log(V)) run-time.
+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.
+
+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).
 
 ```
 from collections import defaultdict
 
 class Solution:
     def minimumCost(self, N: int, connections: List[List[int]]) -> int:
 
-        def create_adj_list(connections):
+        def create_adj_list():
             adj_list = defaultdict(list)
+            for n in range(1, N + 1): # incase there are cities with no connections
+                adj_list[n]
             for city1, city2, cost in connections:
-                adj_list[city1].append(Vertex(city2, cost))
-                adj_list[city2].append(Vertex(city1, cost))
+                adj_list[city1].append((city2, cost))
+                adj_list[city2].append((city1, cost))
             return adj_list
 
-        adj_list = create_adj_list(connections)
-        visited = set([N])
-        min_heap = list(adj_list[N] if N in adj_list else [])
-        heapq.heapify(min_heap)
+        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:
-            vertex = heapq.heappop(min_heap)
-            if vertex.to in visited:
+            cost, city = heapq.heappop(min_heap)
+            if city in visited: # skip this city
                 continue
-            visited.add(vertex.to)
-            min_cost += vertex.cost
-            for vertex in adj_list[vertex.to]:
-                if vertex.to not in visited:
-                    heapq.heappush(min_heap, vertex)
+            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))
         return min_cost if len(visited) == N else -1
-
-class Vertex(object):
-
-    def __init__(self, to, cost):
-        self.to = to
-        self.cost = cost
-
-    def __lt__(self, other):
-        return self.cost < other.cost
-
-    def __repr__(self):
-        return 'To: {}, Cost: {}'.format(self.to, self.cost)
 ```