added Min Cost to Repair Edges

Author: minhyeong-joe

Graph/MinCostToRepairEdges/README.md

@@ -0,0 +1,35 @@
+# Minimum Cost to Repair Edges
+
+[Leetcode Link](https://leetcode.com/discuss/interview-question/357310)
+
+## Problem:
+
+There's an undirected connected graph with n nodes labeled 1..n. But some of the edges has been broken disconnecting the graph. Find the minimum cost to repair the edges so that all the nodes are once again accessible from each other.
+
+Input:
+
+- `n`, an int representing the total number of nodes.
+- `edges`, a list of integer pair representing the nodes connected by an edge.
+- `edgesToRepair`, a list where each element is a triplet representing the pair of nodes between which an edge is currently broken and the cost of reparing that edge, respectively (e.g. [1, 2, 12] means to repear an edge between nodes 1 and 2, the cost would be 12).
+
+## Example:
+
+```
+Input: n = 5, edges = [[1, 2], [2, 3], [3, 4], [4, 5], [1, 5]], edgesToRepair = [[1, 2, 12], [3, 4, 30], [1, 5, 8]]
+Output: 20
+Explanation:
+There are 3 connected components due to broken edges: [1], [2, 3] and [4, 5].
+We can connect these components into a single component by repearing the edges between nodes 1 and 2, and nodes 1 and 5 at a minimum cost 12 + 8 = 20.
+```
+
+```
+Input: n = 6, edges = [[1, 2], [2, 3], [4, 5], [3, 5], [1, 6], [2, 4]], edgesToRepair = [[1, 6, 410], [2, 4, 800]]
+Output: 410
+```
+
+```
+Input: n = 6, edges = [[1, 2], [2, 3], [4, 5], [5, 6], [1, 5], [2, 4], [3, 4]], edgesToRepair = [[1, 5, 110], [2, 4, 84], [3, 4, 79]]
+Output: 79
+```
+
+## Note:

Graph/MinCostToRepairEdges/solution.py

@@ -0,0 +1,41 @@
+from collections import defaultdict
+
+
+def updateCost(neighbors, b, cost):
+    for i in range(len(neighbors)):
+        if neighbors[i][0] == b:
+            neighbors[i][1] = cost
+
+
+def minCostRepair(n, edges, edgesToRepair):
+    # create edge lists associated with cost
+    edgeList = defaultdict(list)
+    for a, b in edges:
+        edgeList[a].append([b, 0])
+        edgeList[b].append([a, 0])
+    # print(edgeList)
+    for a, b, cost in edgesToRepair:
+        updateCost(edgeList[a], b, cost)
+        updateCost(edgeList[b], a, cost)
+    # print(edgeList)
+    # find shorted spanning graph
+    reached = set()
+    totalCost = 0
+    queue = list()
+    queue.append([1, 0])
+    while len(reached) < n:
+        current = queue.pop(0)
+        currentNode = current[0]
+        cost = current[1]
+        if currentNode not in reached:
+            reached.add(currentNode)
+            totalCost += cost
+            queue.extend(edgeList[currentNode])
+            queue.sort(key=lambda pair: pair[1])
+    return totalCost
+
+
+n = 6
+edges = [[1, 2], [2, 3], [4, 5], [5, 6], [1, 5], [2, 4], [3, 4]]
+edgesToRepair = [[1, 5, 110], [2, 4, 84], [3, 4, 79]]
+print(minCostRepair(n, edges, edgesToRepair))

README.md

@@ -77,6 +77,7 @@ Languages used: Java and Python
 - [All Paths From Src To Target](Graph/AllPathsFromSrcToTarget)
 - [Course Schedule II](Graph/CourseSchedule2)
 - [Escape Large Maze](Graph/EscapeLargeMaze)
+- [Minimum Cost to Repair Edges](Graph/MinCostToRepairEdges)
 - [Number to Make Network Connected](Graph/NumToMakeNetworkConnected)
 - [Remove Duplicates from Sorted List](Array/RemoveDuplicatesFromSortedList)
 - [Reconstruct Itinerary](Graph/ReconstructItinerary)