Connected undirected graph Spanning Tree

Kruskal’s Algorithm
• It is a algorithm used to find a minimum cost spanning tree for connected weighted
undirected graph
• This algorithm first appeared in Proceedings of the American Mathematical Society
in 1956, and was written by Joseph Kruskal

A
1 B 1
A B

4 2
6 2 5
C D C 3 D
3
Connected Weighted • It's a spanning tree because it connects all vertices
without loops.
• Tree weight is minimum of all possibilities hence
minimum cost spanning tree
 Disjoint Sets
• A disjoint set is a data structure which keeps track of all elements that are separated by
a number of disjoint (not connected) subsets.
• It supports three useful operations
• MAKE-SET(x): Make a new set with a single element x
• UNION (S1,S2): Merge the set S1 and set S2
• FIND-SET(x): Find the set containing the element x

6
 Disjoint Sets
• A disjoint set is a data structure which keeps track of all elements that are separated by
a number of disjoint (not connected) subsets.
• It supports three useful operations
• MAKE-SET(x): Make a new set with a single element x
• UNION (S1,S2): Merge the set S1 and set S2
• FIND-SET(x): Find the set containing the element x

1 2 3

S1 S2 S3
MAKE-SET(1), MAKE-SET(2), MAKE-
SET(3) creates new set S1,S2,S3 7
 Disjoint Sets
• A disjoint set is a data structure which keeps track of all elements that are separated by
a number of disjoint (not connected) subsets.
• It supports three useful operations
• MAKE-SET(x): Make a new set with a single element x
• UNION (S1,S2): Merge the set S1 and set S2
• FIND-SET(x): Find the set containing the element x

1 2 3 1 2

S1 S2 S3 S4
MAKE-SET(1), MAKE-SET(2), MAKE- UNION (1,2) merge set S1 and set S2
SET(3) creates new set S1,S2,S3 8
to create set S4
 Disjoint Sets
• A disjoint set is a data structure which keeps track of all elements that are separated by
a number of disjoint (not connected) subsets
• It supports three useful operations
• MAKE-SET(x): Make a new set with a single element x
• UNION (S1,S2): Merge the set S1 and set S2
• FIND-SET(x): Find the set containing the element x

1 2 3 1 2 1 2

S1 S2 S3 S4 S4
MAKE-SET(1), MAKE- UNION (1,2) merge set S1 and set S2 FIND-SET(2) returns set S4
SET(2), MAKE-SET(3) creates to create set S49
new set S1,S2,S3
 Kruskal’s Algorithm
KRUSKAL(V,E):

A=∅
foreach 𝑣∈ V:
MAKE-SET(𝑣)
Sort E by weight increasingly
foreach (𝑣1 ,𝑣2 ) ∈ E:
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )}
UNION(𝑣1 ,𝑣2 )
else
Remove edge (𝑣1 ,𝑣2 )
return A
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 AB 4
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 BC 6
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: CD 3
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} DE 2
UNION(𝑣1 ,𝑣2 )
else EF 4
Remove edge (𝑣1 ,𝑣2 )
return A AF 2

BF 5

CF 1
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 AB 4
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 BC 6
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: CD 3
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={ } DE 2
UNION(𝑣1 ,𝑣2 )
else EF 4
Remove edge (𝑣1 ,𝑣2 )
return A AF 2

BF 5

CF 1
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 AB 4
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 BC 6
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: CD 3
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={ } DE 2
UNION(𝑣1 ,𝑣2 )
else EF 4
Remove edge (𝑣1 ,𝑣2 )
return A AF 2
A B C
BF 5
F E D
CF 1
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={ } CD 3
UNION(𝑣1 ,𝑣2 )
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4
A B C
BF 5
F E D
BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={ } CD 3
UNION(𝑣1 ,𝑣2 )
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4
A B C
BF 5
F E D
BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={ } CD 3
UNION(𝑣1 ,𝑣2 )
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4
A B C
BF 5
F E D
BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F)} CD 3
UNION(𝑣1 ,𝑣2 )
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4
A B C
BF 5
F E D
BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F)} CD 3
UNION(𝑣1 ,𝑣2 )
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A
C,F
FE 4
A B
BF 5
E D
BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F)} CD 3
UNION(𝑣1 ,𝑣2 )
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A
C,F
FE 4
A B
BF 5
E D
BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F)} CD 3
UNION(𝑣1 ,𝑣2 )
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A
C,F
FE 4
A B
BF 5
E D
BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F)} CD 3
UNION(𝑣1 ,𝑣2 )
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A
A,C,F
FE 4
B
BF 5
E D
BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F)} CD 3
UNION(𝑣1 ,𝑣2 )
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A
A,C,F
FE 4
B
BF 5
E D
BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F),(D,E)} CD 3
UNION(𝑣1 ,𝑣2 )
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A
A,C,F
FE 4
B
BF 5
E D
BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F),(D,E)} CD 3
UNION(𝑣1 ,𝑣2 )
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A
A,C,F
FE 4
B
BF 5
D,E
BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F),(D,E)} CD 3
UNION(𝑣1 ,𝑣2 )
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A
A,C,F
FE 4
B
BF 5
D,E
BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F),(D,E), CD 3
UNION(𝑣1 ,𝑣2 ) (C,D)}
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A
A,C,F
FE 4
B
BF 5
D,E
BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F),(D,E), CD 3
UNION(𝑣1 ,𝑣2 ) (C,D)}
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4
B A,C,D,E,F
BF 5

BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F),(D,E), CD 3
UNION(𝑣1 ,𝑣2 ) (C,D)}
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4
B A,C,D,E,F
BF 5

BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F),(D,E), CD 3
UNION(𝑣1 ,𝑣2 ) (C,D),(A,B)}
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4
B A,C,D,E,F
BF 5

BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F),(D,E), CD 3
UNION(𝑣1 ,𝑣2 ) (C,D),(A,B)}
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4
A,B,C,D,E,F
BF 5

BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F),(D,E), CD 3
UNION(𝑣1 ,𝑣2 ) (C,D),(A,B)}
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4
A,B,C,D,E,F
BF 5

BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A It is cyclic
E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F),(D,E), CD 3
UNION(𝑣1 ,𝑣2 ) (C,D),(A,B)}
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4
A,B,C,D,E,F
BF 5
Is in a same set.
BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) 4 AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F),(D,E), CD 3
UNION(𝑣1 ,𝑣2 ) (C,D),(A,B)}
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4
A,B,C,D,E,F
BF 5

BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F),(D,E), CD 3
UNION(𝑣1 ,𝑣2 ) (C,D),(A,B)}
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4
A,B,C,D,E,F
BF 5

BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A
It is cyclic E
MAKE-SET(𝑣) AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F),(D,E), CD 3
UNION(𝑣1 ,𝑣2 ) (C,D),(A,B)}
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4
A,B,C,D,E,F
BF 5
Is in a same set.
BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 5 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F),(D,E), CD 3
UNION(𝑣1 ,𝑣2 ) (C,D),(A,B)}
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4
A,B,C,D,E,F
BF 5

BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F),(D,E), CD 3
UNION(𝑣1 ,𝑣2 ) (C,D),(A,B)}
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4
A,B,C,D,E,F
BF 5

BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 1 CF 1
foreach 𝑣 ∈ V: A
MAKE-SET(𝑣) It is cyclic E AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F),(D,E), CD 3
UNION(𝑣1 ,𝑣2 ) (C,D),(A,B)}
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4
A,B,C,D,E,F
BF 5
Is in a same set.
BC 6
 6 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F),(D,E), CD 3
UNION(𝑣1 ,𝑣2 ) (C,D),(A,B)}
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4
A,B,C,D,E,F
BF 5

BC 6
 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} A ={(C,F),(A,F),(D,E), CD 3
UNION(𝑣1 ,𝑣2 ) (C,D),(A,B)}
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4

BF 5

BC 6
 C 3
KRUSKAL(V,E): B D Edges Weight
4 2
A=∅ 1 CF 1
foreach 𝑣 ∈ V: A E
MAKE-SET(𝑣) AF 2
Sort E by weight increasingly 2 F
foreach (𝑣1 ,𝑣2 ) ∈ E: DE 2
if FIND-SET(𝑣1 ) ≠ FIND-SET(𝑣2 ):
A = A ∪ {(𝑣1 ,𝑣2 )} CD 3
UNION(𝑣1 ,𝑣2 )
else AB 4
Remove edge (𝑣1 ,𝑣2 )
return A FE 4
A ={(C,F),(A,F),(D,E),(C,D),(A,B)}
BF 5
Total Weight :- 1 + 2 + 2 + 3 + 4
= 12 BC 6