CS253: Minimum Spanning Trees (2019)

Transcript

1. Minimum Spanning Tree Data Structures and Algorithms Emory University Jinho D. Choi
2. Types of Graphs 2
3. Types of Graphs 2 G = ( , )
4. Types of Graphs 2 V G = ( , )
5. Types of Graphs 2 0 1 2 3 4 V G = ( , )
6. Types of Graphs 2 0 1 2 3 4 V E G = ( , )
7. Types of Graphs 2 0 1 2 3 4 V E G = ( , ) Undirected
8. Types of Graphs 2 0 1 2 3 4 V E G = ( , ) Undirected
9. Types of Graphs 2 0 1 2 3 4 V E G = ( , ) Undirected Weighted
10. Types of Graphs 2 0 1 2 3 4 3 4 1 2 3 2 4 V E G = ( , ) Undirected Weighted
11. Types of Graphs 2 0 1 2 3 4 3 4 1 2 3 2 4 V E G = ( , ) Undirected Directed Weighted
12. Types of Graphs 2 0 1 2 3 4 3 4 1 2 3 2 4 V E G = ( , ) Undirected Directed Weighted
13. Types of Graphs 2 0 1 2 3 4 3 4 1 2 3 2 4 V E G = ( , ) Undirected Directed Weighted Acyclic
14. Types of Graphs 2 0 1 2 3 4 3 1 2 3 2 4 V E G = ( , ) Undirected Directed Weighted Acyclic
15. Types of Graphs 2 0 1 2 3 4 3 1 2 3 2 4 V E G = ( , ) Undirected Directed Weighted Acyclic Tree
16. Types of Graphs 2 0 1 2 3 4 3 1 2 3 2 4 V E G = ( , ) Undirected Directed Weighted Acyclic Tree Every node except for the root must have exactly one incoming edge.
17. Types of Graphs 2 0 1 2 3 4 3 1 2 2 V E G = ( , ) Undirected Directed Weighted Acyclic Tree Every node except for the root must have exactly one incoming edge.
18. Types of Graphs 2 0 1 2 3 4 3 1 2 2 V E G = ( , ) Undirected Directed Weighted Acyclic Tree Every node except for the root must have exactly one incoming edge. Every node must be reachable from the root.
19. Types of Graphs 2 0 1 2 3 4 1 2 2 V E G = ( , ) Undirected Directed Weighted Acyclic Tree Every node except for the root must have exactly one incoming edge. Every node must be reachable from the root.
20. Types of Graphs 2 0 1 2 3 4 1 2 2 V E G = ( , ) Undirected Directed Weighted Acyclic Tree Every node except for the root must have exactly one incoming edge. Every node must be reachable from the root. Forest
21. Types of Graphs 2 0 1 2 3 4 1 2 2 V E G = ( , ) Undirected Directed Weighted Acyclic Tree Every node except for the root must have exactly one incoming edge. Every node must be reachable from the root. Forest
22. Undirected vs. Directed Graph 3
23. Undirected vs. Directed Graph 3 Can we represent undirected graphs using directed graphs?
24. Undirected vs. Directed Graph 3 0 1 2 3 4 Can we represent undirected graphs using directed graphs?
25. Undirected vs. Directed Graph 3 0 1 2 3 4 Can we represent undirected graphs using directed graphs?
26. Edge 4
27. Edge 4 1 0 3.2
28. Edge 4 1 0 public class Edge implements Comparable<Edge> { private int source; private int target; private double weight; public Edge(int source, int target, double weight) { setSource(source); setTarget(target); setWeight(weight); } } 3.2
29. Edge 4 1 0 public class Edge implements Comparable<Edge> { private int source; private int target; private double weight; public Edge(int source, int target, double weight) { setSource(source); setTarget(target); setWeight(weight); } } 3.2
30. Edge 4 1 0 public class Edge implements Comparable<Edge> { private int source; private int target; private double weight; public Edge(int source, int target, double weight) { setSource(source); setTarget(target); setWeight(weight); } } by weight 3.2
31. Edge 4 1 0 public class Edge implements Comparable<Edge> { private int source; private int target; private double weight; public Edge(int source, int target, double weight) { setSource(source); setTarget(target); setWeight(weight); } } by weight 3.2 public int compareTo(Edge edge) { double diff = weight - edge.weight; if (diff > 0) return 1; else if (diff < 0) return -1; else return 0; }
32. Graph 5
33. Graph 5 0 1 2
34. Graph 5 public class Graph { private List<Edge>[] incoming_edges; public Graph(int size) { incoming_edges = (List<Edge>[])Stream.generate(ArrayList<Edge>::new) .limit(size).toArray(List<?>[]::new); } public List<Edge> getIncomingEdges(int target) { return incoming_edges[target]; } } 0 1 2
35. Graph 5 public class Graph { private List<Edge>[] incoming_edges; public Graph(int size) { incoming_edges = (List<Edge>[])Stream.generate(ArrayList<Edge>::new) .limit(size).toArray(List<?>[]::new); } public List<Edge> getIncomingEdges(int target) { return incoming_edges[target]; } } 0 1 2
36. Graph 5 public class Graph { private List<Edge>[] incoming_edges; public Graph(int size) { incoming_edges = (List<Edge>[])Stream.generate(ArrayList<Edge>::new) .limit(size).toArray(List<?>[]::new); } public List<Edge> getIncomingEdges(int target) { return incoming_edges[target]; } } 0 1 2 incoming_edges[0] = {}; incoming_edges[1] = {1 <- 0, 1 <- 2}; incoming_edges[2] = {2 <- 0};
37. Graph 5 public class Graph { private List<Edge>[] incoming_edges; public Graph(int size) { incoming_edges = (List<Edge>[])Stream.generate(ArrayList<Edge>::new) .limit(size).toArray(List<?>[]::new); } public List<Edge> getIncomingEdges(int target) { return incoming_edges[target]; } } 0 1 2 incoming_edges[0] = {}; incoming_edges[1] = {1 <- 0, 1 <- 2}; incoming_edges[2] = {2 <- 0};
38. Graph 5 public class Graph { private List<Edge>[] incoming_edges; public Graph(int size) { incoming_edges = (List<Edge>[])Stream.generate(ArrayList<Edge>::new) .limit(size).toArray(List<?>[]::new); } public List<Edge> getIncomingEdges(int target) { return incoming_edges[target]; } } 0 1 2 incoming_edges[0] = {}; incoming_edges[1] = {1 <- 0, 1 <- 2}; incoming_edges[2] = {2 <- 0}; getIncomingEdges(1);
39. Graph 5 public class Graph { private List<Edge>[] incoming_edges; public Graph(int size) { incoming_edges = (List<Edge>[])Stream.generate(ArrayList<Edge>::new) .limit(size).toArray(List<?>[]::new); } public List<Edge> getIncomingEdges(int target) { return incoming_edges[target]; } } 0 1 2 incoming_edges[0] = {}; incoming_edges[1] = {1 <- 0, 1 <- 2}; incoming_edges[2] = {2 <- 0}; getIncomingEdges(1);
40. Graph 6
41. Graph 6 T S
42. Graph 6 public void setDirectedEdge(int source, int target, double weight) { List<Edge> edges = getIncomingEdges(target); edges.add(new Edge(source, target, weight)); } T S
43. Graph 6 public void setDirectedEdge(int source, int target, double weight) { List<Edge> edges = getIncomingEdges(target); edges.add(new Edge(source, target, weight)); } T S
44. Graph 6 public void setDirectedEdge(int source, int target, double weight) { List<Edge> edges = getIncomingEdges(target); edges.add(new Edge(source, target, weight)); } T S
45. Graph 6 public void setDirectedEdge(int source, int target, double weight) { List<Edge> edges = getIncomingEdges(target); edges.add(new Edge(source, target, weight)); } T S
46. Graph 6 public void setDirectedEdge(int source, int target, double weight) { List<Edge> edges = getIncomingEdges(target); edges.add(new Edge(source, target, weight)); } T S
47. Graph 6 public void setDirectedEdge(int source, int target, double weight) { List<Edge> edges = getIncomingEdges(target); edges.add(new Edge(source, target, weight)); } public void setUndirectedEdge(int source, int target, double weight) { setDirectedEdge(source, target, weight); setDirectedEdge(target, source, weight); } T S
48. Graph 6 public void setDirectedEdge(int source, int target, double weight) { List<Edge> edges = getIncomingEdges(target); edges.add(new Edge(source, target, weight)); } public void setUndirectedEdge(int source, int target, double weight) { setDirectedEdge(source, target, weight); setDirectedEdge(target, source, weight); } T S
49. Graph 6 public void setDirectedEdge(int source, int target, double weight) { List<Edge> edges = getIncomingEdges(target); edges.add(new Edge(source, target, weight)); } public void setUndirectedEdge(int source, int target, double weight) { setDirectedEdge(source, target, weight); setDirectedEdge(target, source, weight); } T S
50. Minimum Spanning Tree 7 0 1 2 3 4 3 4 1 2 3 2 4
51. Minimum Spanning Tree 7 0 1 2 3 4 3 4 1 2 3 2 4
52. Minimum Spanning Tree 7 0 1 2 3 4 3 4 1 2 3 2 4
53. Minimum Spanning Tree 7 0 1 2 3 4 3 4 1 2 3 2 4
54. Minimum Spanning Tree 7 0 1 2 3 4 3 4 1 2 3 2 4
55. Minimum Spanning Tree 8
56. Minimum Spanning Tree 8 GA NY CO IA TX
57. Minimum Spanning Tree 8 GA NY CO IA TX $465 $395 $178 $198 $490 $372 $270 $193 $446 $434
58. Spanning Tree 9 public class SpanningTree implements Comparable<SpanningTree> { private List<Edge> edges; private double total_weight; public SpanningTree() { edges = new ArrayList<>(); } public void addEdge(Edge edge) { edges.add(edge); total_weight += edge.getWeight(); } } public int size() { return edges.size(); } public double getTotalWeight() { return total_weight; } public int compareTo(SpanningTree tree) { double diff = total_weight - tree.total_weight; if (diff > 0) return 1; else if (diff < 0) return -1; else return 0; }
59. Spanning Tree 9 public class SpanningTree implements Comparable<SpanningTree> { private List<Edge> edges; private double total_weight; public SpanningTree() { edges = new ArrayList<>(); } public void addEdge(Edge edge) { edges.add(edge); total_weight += edge.getWeight(); } } public int size() { return edges.size(); } public double getTotalWeight() { return total_weight; } public int compareTo(SpanningTree tree) { double diff = total_weight - tree.total_weight; if (diff > 0) return 1; else if (diff < 0) return -1; else return 0; }
60. Spanning Tree 9 public class SpanningTree implements Comparable<SpanningTree> { private List<Edge> edges; private double total_weight; public SpanningTree() { edges = new ArrayList<>(); } public void addEdge(Edge edge) { edges.add(edge); total_weight += edge.getWeight(); } } public int size() { return edges.size(); } public double getTotalWeight() { return total_weight; } public int compareTo(SpanningTree tree) { double diff = total_weight - tree.total_weight; if (diff > 0) return 1; else if (diff < 0) return -1; else return 0; }
61. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 3 2 4
62. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 3 2 4
63. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 3 2 4
64. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 3 2 4
65. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 3 2 4 0 <- 3
66. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 3 2 4 0 <- 3
67. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 3 2 4 0 <- 3
68. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 3 2 4 0 <- 3
69. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 3 2 4 0 <- 3 0 <- 4
70. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 3 2 4 0 <- 3 0 <- 4
71. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 2 4 0 <- 3 0 <- 4
72. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 2 4 0 <- 3 0 <- 4
73. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 2 4 0 <- 3 0 <- 4 0 <- 1
74. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 2 4 0 <- 3 0 <- 4 0 <- 1
75. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 2 4 0 <- 3 0 <- 4 0 <- 1
76. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 2 4 0 <- 3 0 <- 4 0 <- 1
77. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 2 4 0 <- 3 0 <- 4 0 <- 1 1 <- 2
78. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 2 4 0 <- 3 0 <- 4 0 <- 1 1 <- 2
79. Prim’s Algorithm 10 0 1 2 3 4 3 4 1 2 2 4 0 <- 3 0 <- 4 0 <- 1 1 <- 2 A spanning tree is found!
80. Prim’s Algorithm 11 public SpanningTree getMinimumSpanningTree(Graph graph) { PriorityQueue<Edge> queue = new PriorityQueue<>(); SpanningTree tree = new SpanningTree(); Set<Integer> set = new HashSet<>(); Edge edge; add(queue, set, graph, 0); while (!queue.isEmpty()) { edge = queue.poll(); if (!set.contains(edge.getSource())) { tree.addEdge(edge); if (tree.size()+1 == graph.size()) break; add(queue, set, graph, edge.getSource()); } } return tree; }
81. Prim’s Algorithm 11 public SpanningTree getMinimumSpanningTree(Graph graph) { PriorityQueue<Edge> queue = new PriorityQueue<>(); SpanningTree tree = new SpanningTree(); Set<Integer> set = new HashSet<>(); Edge edge; add(queue, set, graph, 0); while (!queue.isEmpty()) { edge = queue.poll(); if (!set.contains(edge.getSource())) { tree.addEdge(edge); if (tree.size()+1 == graph.size()) break; add(queue, set, graph, edge.getSource()); } } return tree; }
82. Prim’s Algorithm 11 public SpanningTree getMinimumSpanningTree(Graph graph) { PriorityQueue<Edge> queue = new PriorityQueue<>(); SpanningTree tree = new SpanningTree(); Set<Integer> set = new HashSet<>(); Edge edge; add(queue, set, graph, 0); while (!queue.isEmpty()) { edge = queue.poll(); if (!set.contains(edge.getSource())) { tree.addEdge(edge); if (tree.size()+1 == graph.size()) break; add(queue, set, graph, edge.getSource()); } } return tree; }
83. Prim’s Algorithm 11 public SpanningTree getMinimumSpanningTree(Graph graph) { PriorityQueue<Edge> queue = new PriorityQueue<>(); SpanningTree tree = new SpanningTree(); Set<Integer> set = new HashSet<>(); Edge edge; add(queue, set, graph, 0); while (!queue.isEmpty()) { edge = queue.poll(); if (!set.contains(edge.getSource())) { tree.addEdge(edge); if (tree.size()+1 == graph.size()) break; add(queue, set, graph, edge.getSource()); } } return tree; }
84. Prim’s Algorithm 11 public SpanningTree getMinimumSpanningTree(Graph graph) { PriorityQueue<Edge> queue = new PriorityQueue<>(); SpanningTree tree = new SpanningTree(); Set<Integer> set = new HashSet<>(); Edge edge; add(queue, set, graph, 0); while (!queue.isEmpty()) { edge = queue.poll(); if (!set.contains(edge.getSource())) { tree.addEdge(edge); if (tree.size()+1 == graph.size()) break; add(queue, set, graph, edge.getSource()); } } return tree; } Complexity?
85. Kruskal’s Algorithm 12 0 1 2 3 4 3 4 1 2 3 2 4
86. Kruskal’s Algorithm 12 0 1 2 3 4 3 4 1 2 3 2 4
87. Kruskal’s Algorithm 12 0 1 2 3 4 3 4 1 2 3 2 4
88. Kruskal’s Algorithm 12 0 1 2 3 4 3 4 1 2 3 2 4 0 <- 3
89. Kruskal’s Algorithm 12 0 1 2 3 4 3 4 1 2 3 2 4 0 <- 3
90. Kruskal’s Algorithm 12 0 1 2 3 4 3 4 1 2 3 2 4 0 <- 3
91. Kruskal’s Algorithm 12 0 1 2 3 4 3 4 1 2 3 2 4 0 <- 3 1 <- 2
92. Kruskal’s Algorithm 12 0 1 2 3 4 3 4 1 2 3 2 4 0 <- 3 1 <- 2
93. Kruskal’s Algorithm 12 0 1 2 3 4 3 4 1 2 3 2 4 0 <- 3 1 <- 2
94. Kruskal’s Algorithm 12 0 1 2 3 4 3 4 1 2 3 2 4 0 <- 3 1 <- 2 0 <- 4
95. Kruskal’s Algorithm 12 0 1 2 3 4 3 4 1 2 3 2 4 0 <- 3 1 <- 2 0 <- 4
96. Kruskal’s Algorithm 12 0 1 2 3 4 3 4 1 2 3 2 4 0 <- 3 1 <- 2 0 <- 4
97. Kruskal’s Algorithm 12 0 1 2 3 4 3 4 1 2 3 2 4 0 <- 3 1 <- 2 0 <- 4 0 <- 1
98. Kruskal’s Algorithm 12 0 1 2 3 4 3 4 1 2 3 2 4 0 <- 3 1 <- 2 0 <- 4 0 <- 1
99. Kruskal’s Algorithm 13 public SpanningTree getMinimumSpanningTree(Graph graph) { PriorityQueue<Edge> queue = new PriorityQueue<>(graph.getAllEdges()); DisjointSet forest = new DisjointSet(graph.size()); SpanningTree tree = new SpanningTree(); Edge edge; while (!queue.isEmpty()) { edge = queue.poll(); if (!forest.inSameSet(edge.getTarget(), edge.getSource())) { tree.addEdge(edge); if (tree.size()+1 == graph.size()) break; forest.union(edge.getTarget(), edge.getSource()); } } return tree; }
100. Kruskal’s Algorithm 13 public SpanningTree getMinimumSpanningTree(Graph graph) { PriorityQueue<Edge> queue = new PriorityQueue<>(graph.getAllEdges()); DisjointSet forest = new DisjointSet(graph.size()); SpanningTree tree = new SpanningTree(); Edge edge; while (!queue.isEmpty()) { edge = queue.poll(); if (!forest.inSameSet(edge.getTarget(), edge.getSource())) { tree.addEdge(edge); if (tree.size()+1 == graph.size()) break; forest.union(edge.getTarget(), edge.getSource()); } } return tree; }
101. Kruskal’s Algorithm 13 public SpanningTree getMinimumSpanningTree(Graph graph) { PriorityQueue<Edge> queue = new PriorityQueue<>(graph.getAllEdges()); DisjointSet forest = new DisjointSet(graph.size()); SpanningTree tree = new SpanningTree(); Edge edge; while (!queue.isEmpty()) { edge = queue.poll(); if (!forest.inSameSet(edge.getTarget(), edge.getSource())) { tree.addEdge(edge); if (tree.size()+1 == graph.size()) break; forest.union(edge.getTarget(), edge.getSource()); } } return tree; }
102. Kruskal’s Algorithm 13 public SpanningTree getMinimumSpanningTree(Graph graph) { PriorityQueue<Edge> queue = new PriorityQueue<>(graph.getAllEdges()); DisjointSet forest = new DisjointSet(graph.size()); SpanningTree tree = new SpanningTree(); Edge edge; while (!queue.isEmpty()) { edge = queue.poll(); if (!forest.inSameSet(edge.getTarget(), edge.getSource())) { tree.addEdge(edge); if (tree.size()+1 == graph.size()) break; forest.union(edge.getTarget(), edge.getSource()); } } return tree; }
103. Proof by Induction 14
104. Proof by Induction 14 k X n=0 = k(k + 1) 2
105. Proof by Induction 15
106. Proof by Induction 15 Base
107. Proof by Induction 15 0 X n=0 = 0 · 1 2 = 0 Base
108. Proof by Induction 15 0 X n=0 = 0 · 1 2 = 0 Base Induction
109. Proof by Induction 15 0 X n=0 = 0 · 1 2 = 0 Base Induction k X n=0 = k(k + 1) 2 Assume
110. Proof by Induction 15 0 X n=0 = 0 · 1 2 = 0 Base Induction k X n=0 = k(k + 1) 2 Assume k X n=0 +(k + 1) = k(k + 1) 2 + (k + 1) = K2 + 3k + 2 2 = (k + 1)(k + 2) 2 Then,
111. Proof by Contradiction 16
112. Proof by Contradiction 16 n2 = n · n = 2k · 2k = 2(2 · 2k2)
113. Proof by Contradiction 16 n2 = n · n = 2k · 2k = 2(2 · 2k2) Contradiction
114. Correctness of Prim’s Algorithm 17
115. Correctness of Prim’s Algorithm 18 0 1 2 3 4 3 4 1 2 3 2 4
116. Correctness of Prim’s Algorithm 18 0 1 2 3 4 3 4 1 2 3 2 4 Prim’s algorithm finds e.
117. Correctness of Prim’s Algorithm 18 0 1 2 3 4 3 4 1 2 3 2 4 Prim’s algorithm finds e.
118. Correctness of Prim’s Algorithm 18 0 1 2 3 4 3 4 1 2 3 2 4 Prim’s algorithm finds e. Suppose that there exists another path p from T to 1 whose total weight < e.
119. Correctness of Prim’s Algorithm 18 0 1 2 3 4 3 4 1 2 3 2 4 Prim’s algorithm finds e. Suppose that there exists another path p from T to 1 whose total weight < e.
120. Correctness of Prim’s Algorithm 18 0 1 2 3 4 3 4 1 2 3 2 4 Prim’s algorithm finds e. Suppose that there exists another path p from T to 1 whose total weight < e. Then, all edges in p must have a weight < e.
121. Correctness of Prim’s Algorithm 18 0 1 2 3 4 3 4 1 2 3 2 4 Prim’s algorithm finds e. Suppose that there exists another path p from T to 1 whose total weight < e. Then, all edges in p must have a weight < e.
122. Correctness of Prim’s Algorithm 18 0 1 2 3 4 3 4 1 2 3 2 4 Prim’s algorithm finds e. Suppose that there exists another path p from T to 1 whose total weight < e. Then, all edges in p must have a weight < e. Proof by contradiction!
123. Correctness of Kruskal’s Algorithm 19
124. Correctness of Kruskal’s Algorithm 20 0 1 2 3 4 3 4 1 2 3 2 4
125. Correctness of Kruskal’s Algorithm 20 0 1 2 3 4 3 4 1 2 3 2 4
126. Correctness of Kruskal’s Algorithm 20 0 1 2 3 4 3 4 1 2 3 2 4 Kruskal’s algorithm finds e.
127. Correctness of Kruskal’s Algorithm 20 0 1 2 3 4 3 4 1 2 3 2 4 Kruskal’s algorithm finds e. Suppose that there exists another path p from Ts to Tt whose total weight < e.
128. Correctness of Kruskal’s Algorithm 20 0 1 2 3 4 3 4 1 2 3 2 4 Kruskal’s algorithm finds e. Suppose that there exists another path p from Ts to Tt whose total weight < e.
129. Correctness of Kruskal’s Algorithm 20 0 1 2 3 4 3 4 1 2 3 2 4 Kruskal’s algorithm finds e. Suppose that there exists another path p from Ts to Tt whose total weight < e. Then, all edges in p must have a weight < e.
130. Correctness of Kruskal’s Algorithm 20 0 1 2 3 4 3 4 1 2 3 2 4 Kruskal’s algorithm finds e. Suppose that there exists another path p from Ts to Tt whose total weight < e. Then, all edges in p must have a weight < e.
131. Correctness of Kruskal’s Algorithm 20 0 1 2 3 4 3 4 1 2 3 2 4 Kruskal’s algorithm finds e. Suppose that there exists another path p from Ts to Tt whose total weight < e. Then, all edges in p must have a weight < e. Proof by contradiction!
132. Chu–Liu-Edmonds’ Algorithm 21
133. Chu–Liu-Edmonds’ Algorithm 21 • Chu–Liu-Edmonds’ algorithm
134. Chu–Liu-Edmonds’ Algorithm 21 • Chu–Liu-Edmonds’ algorithm - Finding minimum spanning trees in directed graphs.
135. Chu–Liu-Edmonds’ Algorithm 21 • Chu–Liu-Edmonds’ algorithm - Finding minimum spanning trees in directed graphs. • Algorithm
136. Chu–Liu-Edmonds’ Algorithm 21 • Chu–Liu-Edmonds’ algorithm - Finding minimum spanning trees in directed graphs. • Algorithm 1. Initially, every vertex is considered a tree.
137. Chu–Liu-Edmonds’ Algorithm 21 • Chu–Liu-Edmonds’ algorithm - Finding minimum spanning trees in directed graphs. • Algorithm 1. Initially, every vertex is considered a tree. 2. For each tree, keep 1 incoming edge with the minimum weight.
138. Chu–Liu-Edmonds’ Algorithm 21 • Chu–Liu-Edmonds’ algorithm - Finding minimum spanning trees in directed graphs. • Algorithm 1. Initially, every vertex is considered a tree. 2. For each tree, keep 1 incoming edge with the minimum weight. 3. If there is no cycle, go to #5.
139. Chu–Liu-Edmonds’ Algorithm 21 • Chu–Liu-Edmonds’ algorithm - Finding minimum spanning trees in directed graphs. • Algorithm 1. Initially, every vertex is considered a tree. 2. For each tree, keep 1 incoming edge with the minimum weight. 3. If there is no cycle, go to #5. 4. If there is a cycle, merge trees with the cycle into one and update scores for all incoming edges to this tree, and goto #2.
140. Chu–Liu-Edmonds’ Algorithm 21 • Chu–Liu-Edmonds’ algorithm - Finding minimum spanning trees in directed graphs. • Algorithm 1. Initially, every vertex is considered a tree. 2. For each tree, keep 1 incoming edge with the minimum weight. 3. If there is no cycle, go to #5. 4. If there is a cycle, merge trees with the cycle into one and update scores for all incoming edges to this tree, and goto #2. • For each vertex in the tree, add the weight of its outgoing edge chain to its incoming edges not in the tree.
141. Chu–Liu-Edmonds’ Algorithm 21 • Chu–Liu-Edmonds’ algorithm - Finding minimum spanning trees in directed graphs. • Algorithm 1. Initially, every vertex is considered a tree. 2. For each tree, keep 1 incoming edge with the minimum weight. 3. If there is no cycle, go to #5. 4. If there is a cycle, merge trees with the cycle into one and update scores for all incoming edges to this tree, and goto #2. • For each vertex in the tree, add the weight of its outgoing edge chain to its incoming edges not in the tree. 5. Break all cycles by removing edges that cause multiple parents.
142. Chu–Liu-Edmonds’ Algorithm 22 0 1 2 3 4 20 10 4 3 15 28 20 5 8 12 4 2 6 30 7 5 List<Set<Integer>> forest = initForest(graph.size());
143. Chu–Liu-Edmonds’ Algorithm 22 0 1 2 3 4 20 10 4 3 15 28 20 5 8 12 4 2 6 30 7 5 List<Set<Integer>> forest = initForest(graph.size());
144. Chu–Liu-Edmonds’ Algorithm 23 0 1 2 3 4 20 10 4 3 15 28 20 5 8 12 4 2 6 30 7 5 SpanningTree tree = 
 getMinimumIncomingEdges
 (graph, forest);
145. Chu–Liu-Edmonds’ Algorithm 23 0 1 2 3 4 20 10 4 3 15 28 20 5 8 12 4 2 6 30 7 5 SpanningTree tree = 
 getMinimumIncomingEdges
 (graph, forest);
146. Chu–Liu-Edmonds’ Algorithm 24 0 1 2 3 4 20 10 4 3 15 28 20 5 8 12 4 2 6 30 7 5 List<List<Edge>> cycles = tree.getCycles();
147. Chu–Liu-Edmonds’ Algorithm 24 0 1 2 3 4 20 10 4 3 15 28 20 5 8 12 4 2 6 30 7 5 List<List<Edge>> cycles = tree.getCycles();
148. Chu–Liu-Edmonds’ Algorithm 25 0 1 2 3 4 20 10 4 3 15 28 20 5 8 12 4 2 6 30 7 5 forest = updateEdgeWeights
 (graph, cycles);
149. Chu–Liu-Edmonds’ Algorithm 25 0 1 2 3 4 20 10 4 3 15 28 20 5 8 12 4 2 6 30 7 5 forest = updateEdgeWeights
 (graph, cycles); 3
150. Chu–Liu-Edmonds’ Algorithm 25 0 1 2 3 4 20 10 4 3 15 28 20 5 8 12 4 2 6 30 7 5 forest = updateEdgeWeights
 (graph, cycles); 3 23 8 8
151. Chu–Liu-Edmonds’ Algorithm 25 0 1 2 3 4 20 10 4 3 15 28 20 5 8 12 4 2 6 30 7 5 forest = updateEdgeWeights
 (graph, cycles); 3 23 8 8 2
152. Chu–Liu-Edmonds’ Algorithm 25 0 1 2 3 4 20 10 4 3 15 28 20 5 8 12 4 2 6 30 7 5 forest = updateEdgeWeights
 (graph, cycles); 3 23 8 8 6 10 2 32
153. Chu–Liu-Edmonds’ Algorithm 26 0 1 2 3 4 20 10 6 3 15 28 23 8 10 12 4 2 6 32 7 8 SpanningTree tree = 
 getMinimumIncomingEdges
 (graph, forest);
154. Chu–Liu-Edmonds’ Algorithm 26 0 1 2 3 4 20 10 6 3 15 28 23 8 10 12 4 2 6 32 7 8 SpanningTree tree = 
 getMinimumIncomingEdges
 (graph, forest);
155. Chu–Liu-Edmonds’ Algorithm 27 0 1 2 3 4 20 10 6 3 15 28 23 8 10 12 4 6 32 7 8 addEdgesFromCycles
 (tree, cyclicEdges); 2
156. Chu–Liu-Edmonds’ Algorithm 27 0 1 2 3 4 20 10 6 3 15 28 23 8 10 12 4 6 32 7 8 addEdgesFromCycles
 (tree, cyclicEdges); 2
157. Chu–Liu-Edmonds’ Algorithm 28 0 1 2 3 4 4 1 3 2 4
158. Chu–Liu-Edmonds’ Algorithm 28 0 1 2 3 4 4 1 3 2 4
159. Chu–Liu-Edmonds’ Algorithm 28 0 1 2 3 4 4 1 3 2 4
160. Chu–Liu-Edmonds’ Algorithm 28 0 1 2 3 4 4 1 3 2 →5 4
161. Chu–Liu-Edmonds’ Algorithm 28 0 1 2 3 4 4 1 3 2 →5 4
162. Chu–Liu-Edmonds’ Algorithm 28 0 1 2 3 4 4 1 3 2 →5 →7 4
163. Chu–Liu-Edmonds’ Algorithm 28 0 1 2 3 4 4 1 3 2 →5 →7 4
164. Chu–Liu-Edmonds’ Algorithm 28 0 1 2 3 4 4 1 3 2 →5 →7 →6 4
165. Chu–Liu-Edmonds’ Algorithm 28 0 1 2 3 4 4 1 3 2 →5 →7 →6 4
166. Chu–Liu-Edmonds’ Algorithm 28 0 1 2 3 4 4 1 3 2 →5 →7 →6 4
167. Chu–Liu-Edmonds’ Algorithm 28 0 1 2 3 4 4 1 3 2 →5 →7 →6 4 Minimum Spanning Tree?
168. Chu–Liu-Edmonds’ Algorithm 29 0 1 2 3 4 4 1 3 2 4
169. Chu–Liu-Edmonds’ Algorithm 29 0 1 2 3 4 4 1 3 2 4
170. Chu–Liu-Edmonds’ Algorithm 29 0 1 2 3 4 4 1 3 2 →8 4
171. Chu–Liu-Edmonds’ Algorithm 29 0 1 2 3 4 4 1 3 2 →8 4
172. Chu–Liu-Edmonds’ Algorithm 29 0 1 2 3 4 4 1 3 2 →8 →9 4
173. Chu–Liu-Edmonds’ Algorithm 29 0 1 2 3 4 4 1 3 2 →8 →9 4
174. Chu–Liu-Edmonds’ Algorithm 29 0 1 2 3 4 4 1 3 2 →8 →9 →7 4
175. Chu–Liu-Edmonds’ Algorithm 29 0 1 2 3 4 4 1 3 2 →8 →9 →7 4
176. Chu–Liu-Edmonds’ Algorithm 29 0 1 2 3 4 4 1 3 2 →8 →9 →7 4