Prims and kruskal algorithms

Preview:

Citation preview

Minimum Spanning Trees (MST)• A minimum spanning tree (MST) or minimum

weight spanning tree is a spanning tree of a connected, undirected graph. • It connects all the vertices together with the

minimal total weighting for its edges.• MST is a tree ,because it is acyclic• Any undirected graph has a minimum spanning

forest, which is a union of minimum spanning trees for its connected components.• If a graph has N vertices then the spanning tree

will have N-1 edges

Minimum Spanning Trees (MST)

Minimum Spanning Trees (MST)

2 199

1

5

13

1725

148

21

Prims Algorithm• Prim's algorithm is a greedy algorithm that

finds a minimum spanning tree for a weighted undirected graph.• It finds a subset of the edges that forms a tree

that includes every vertex, where the total weight of all the edges in the tree is minimized.• The algorithm operates by building this tree

one vertex at a time, from an arbitrary starting vertex, at each step adding the cheapest possible connection from the tree to another vertex.

Prims AlgorithmProcedure:

• Initialize the min priority queue Q to contain all the vertices.• Set the key of each vertex to ∞ and root’s

key is set to zero• Set the parent of root to NIL• If weight of vertex is less than key value

of the vertex, connect the graph.• Repeat the process till all vertex are

used.

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

Initialize the min priority queue Q to contain all the vertices.

Set the key of each vertex to ∞

Set the parent of root to NIL

Root’s key is set to 0

Until queue become null set

Input– Graph, Weight, Root

Set the parent of ‘v’ as ‘u’

Set the key of v = weight of edge connecting uv

Prims Algorithm

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

14 10

3

6 45

2

9

15

8

Run on example graph

Prims Algorithm

14 10

3

6 45

2

9

15

8

Run on example graph

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

Prims Algorithm

0

14 10

3

6 45

2

9

15

8

Pick a start vertex r

r

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

Prims Algorithm

0

14 10

3

6 45

2

9

15

8

Black vertices have been removed from Q

u

Prims AlgorithmMST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

0

3

14 10

3

6 45

2

9

15

8

Black arrows indicate parent pointers

u

Prims AlgorithmMST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

14

0

3

14 10

3

6 45

2

9

15

8

u

Prims AlgorithmMST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

14

0

3

14 10

3

6 45

2

9

15

8u

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

Prims Algorithm

14

0 8

3

14 10

3

6 45

2

9

15

8u

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

Prims Algorithm

10

0 8

3

14 10

3

6 45

2

9

15

8u

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

Prims Algorithm

10

0 8

3

14 10

3

6 45

2

9

15

8u

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

Prims Algorithm

10 2

0 8

3

14 10

3

6 45

2

9

15

8u

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

Prims Algorithm

10 2

0 8 15

3

14 10

3

6 45

2

9

15

8u

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

Prims Algorithm

10 2

0 8 15

3

14 10

3

6 45

2

9

15

8

u

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

Prims Algorithm

10 2 9

0 8 15

3

14 10

3

6 45

2

9

15

8

u

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

Prims Algorithm

10 2 9

0 8 15

3

4

14 10

3

6 45

2

9

15

8

u

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

Prims Algorithm

5 2 9

0 8 15

3

4

14 10

3

6 45

2

9

15

8

u

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

Prims Algorithm

5 2 9

0 8 15

3

4

14 10

3

6 45

2

9

15

8

u

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

Prims Algorithm

5 2 9

0 8 15

3

4

14 10

3

6 45

2

9

15

8

u

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

Prims Algorithm

5 2 9

0 8 15

3

4

14 10

3

6 45

2

9

15

8

u

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

Prims Algorithm

5 2 9

0 8 15

3

4

14 10

3

6 45

2

9

15

8

u

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

Prims Algorithm

MST-Prim(G, w, r) Q = V[G]; for each u Q key[u] = ; key[r] = 0; p[r] = NULL; while (Q not empty) u = ExtractMin(Q); for each v Adj[u] if (v Q and w(u,v) < key[v]) p[v] = u; key[v] = w(u,v);

5 2 9

0 8 15

3

4

3

45

2

9

15

8

Prims Algorithm

Kruskals Algorithm• Kruskal's algorithm is a minimum-

spanning-tree algorithm which finds an edge of the least possible weight that connects any two trees in the forest.• It is a greedy algorithm, adding

increasing cost arcs at each step.• This means it finds a subset of the edges

that forms a tree that includes every vertex, where the total weight of all the edges in the tree is minimized.• To visit all nodes, with minimum cost,

without cycle formation

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

Kruskals AlgorithmT-TreeE-EdgeV-Verticesv-Vertex

MakeSet(x): S = S U {{x}}Union(Si, Sj): S = S - {Si, Sj} U {Si U Sj}FindSet(X): return Si S such that x Si

2 199

1

5

13

1725

148

21

Run the algorithm:

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

Kruskals Algorithm

2 199

1

5

13

1725

148

21

Run the algorithm:

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

Kruskals Algorithm

2 199

1?

5

13

1725

148

21

Run the algorithm:

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

Kruskals Algorithm

2 199

1

5

13

1725

148

21

Run the algorithm:

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

Kruskals Algorithm

2? 199

1

5

13

1725

148

21

Run the algorithm:

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

Kruskals Algorithm

2 199

1

5

13

1725

148

21

Run the algorithm:

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

Kruskals Algorithm

2 199

1

5?

13

1725

148

21

Run the algorithm:

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

Kruskals Algorithm

2 199

1

5

13

1725

148

21

Run the algorithm:

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

Kruskals Algorithm

2 199

1

5

13

1725

148?

21

Run the algorithm:

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

Kruskals Algorithm

2 199

1

5

13

1725

148

21

Run the algorithm:

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

Kruskals Algorithm

2 199?

1

5

13

1725

148

21

Run the algorithm:

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

Kruskals Algorithm

2 199

1

5

13

1725

148

21

Run the algorithm:

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

Kruskals Algorithm

2 199

1

5

13?

1725

148

21

Run the algorithm:

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

Kruskals Algorithm

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

2 199

1

5

13

1725

148

21

Run the algorithm:

Kruskals Algorithm

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

2 199

1

5

13

1725

14?8

21

Run the algorithm:

Kruskals Algorithm

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

2 199

1

5

13

1725

148

21

Run the algorithm:

Kruskals Algorithm

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

2 199

1

5

13

17?25

148

21

Run the algorithm:

Kruskals Algorithm

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

2 19?9

1

5

13

1725

148

21

Run the algorithm:

Kruskals Algorithm

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

2 199

1

5

13

1725

148

21?

Run the algorithm:

Kruskals Algorithm

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

2 199

1

5

13

1725?

148

21

Run the algorithm:

Kruskals Algorithm

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

2 199

1

5

13

1725

148

21

Run the algorithm:

Kruskals Algorithm

Kruskal()

{

T = ;

for each v V

MakeSet(v);

sort E by increasing edge weight w

for each (u,v) E (in sorted order)

if FindSet(u) FindSet(v)

T = T U {{u,v}};

Union(FindSet(u), FindSet(v));

}

2 199

1

5

13

1725

148

21

Run the algorithm:

Kruskals Algorithm

Thank You

Recommended