CSC 41/513: Intro to Algorithms Linear-Time Sorting Algorithms.
CSC 413/513: Intro to Algorithms
-
Upload
latifah-chavez -
Category
Documents
-
view
33 -
download
0
description
Transcript of CSC 413/513: Intro to Algorithms
![Page 1: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/1.jpg)
CSC 413/513: Intro to Algorithms
Single-Source Shortest Path
![Page 2: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/2.jpg)
Single-Source Shortest Path
● Problem: given a weighted directed graph G, find the minimum-weight path from a given source vertex s to another vertex v■ “Shortest-path” = minimum weight ■ Weight of path is sum of edges■ E.g., a road map: what is the shortest path from
Hattiesburg to Nashville?
![Page 3: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/3.jpg)
Shortest Path Properties
● Again, we have optimal substructure: the shortest path consists of shortest subpaths:
■ Proof: suppose some subpath is not a shortest path○ There must then exist a shorter subpath ○ Could substitute the shorter subpath for a shorter path○ But then overall path is not shortest path. Contradiction
■ E.g., if C->D could be improved, then so could A->B
A C D B
![Page 4: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/4.jpg)
Shortest Path Properties
● Define (u,v) to be the weight of the shortest path from u to v
● Shortest paths satisfy the triangle inequality: (u,v) (u,x) + (x,v)
● “Proof”: x
u v
This path is no longer than any other path
![Page 5: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/5.jpg)
Shortest Path Properties
● In graphs with negative weight cycles, some shortest paths will not exist (Why?):
< 0
![Page 6: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/6.jpg)
Relaxation
● A key technique in shortest path algorithms is relaxation■ Idea: for all v, maintain upper bound d[v] on (s,v)Relax(u,v,w) {
if (d[v] > d[u]+w) then d[v]← d[u]+w;}
952
752
Relax
652
652
Relax
![Page 7: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/7.jpg)
Bellman-Ford Algorithm
BellmanFord()
for each v V d[v] = ; d[s] = 0;
for i=1 to |V|-1
for each edge (u,v) E Relax(u,v, w(u,v));
for each edge (u,v) E if (d[v] > d[u] + w(u,v))
return “no solution”;
Relax(u,v,w): if (d[v] > d[u]+w) then d[v]=d[u]+w
Initialize d[], whichwill converge to shortest-path value
Relaxation: Make |V|-1 passes, relaxing each edge
Test for solution Under what conditiondo we get a solution?
![Page 8: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/8.jpg)
Bellman-Ford Algorithm
BellmanFord()
for each v V d[v] = ; d[s] = 0;
for i=1 to |V|-1
for each edge (u,v) E Relax(u,v, w(u,v));
for each edge (u,v) E if (d[v] > d[u] + w(u,v))
return “no solution”;
Relax(u,v,w): if (d[v] > d[u]+w) then d[v]=d[u]+w
What will be the running time?
![Page 9: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/9.jpg)
Bellman-Ford Algorithm
BellmanFord()
for each v V d[v] = ; d[s] = 0;
for i=1 to |V|-1
for each edge (u,v) E Relax(u,v, w(u,v));
for each edge (u,v) E if (d[v] > d[u] + w(u,v))
return “no solution”;
Relax(u,v,w): if (d[v] > d[u]+w) then d[v]=d[u]+w
What will be the running time?
A: O(VE)
![Page 10: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/10.jpg)
Bellman-Ford Algorithm
BellmanFord()
for each v V d[v] = ; d[s] = 0;
for i=1 to |V|-1
for each edge (u,v) E Relax(u,v, w(u,v));
for each edge (u,v) E if (d[v] > d[u] + w(u,v))
return “no solution”;
Relax(u,v,w): if (d[v] > d[u]+w) then d[v]=d[u]+w
B
E
DC
A
-1 2
2
1-3
5
3
4
Ex: work on board
s
![Page 11: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/11.jpg)
Bellman-Ford
● Note that order in which edges are processed affects how quickly it converges
● Correctness: show d[v] = (s,v) after |V|-1 passes■ Lemma: d[v] (s,v) always
○ Initially true○ If possible, let v be first vertex for which d[v] < (s,v)○ Let u be the vertex that caused d[v] to change:
d[v] = d[u] + w(u,v)○ Then d[v] < (s,v)
(s,v) (s,u) + w(u,v) (Why?) (s,u) + w(u,v) d[u] + w(u,v) (Why?)
○ So d[v] < d[u] + w(u,v). Contradiction.
![Page 12: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/12.jpg)
Bellman-Ford
● Prove: after |V|-1 passes, all d values correct■ Consider shortest path from s to v:
s v1 v2 v3 v4 v○ Initially, d[s] = 0 is correct, and doesn’t change (Why?)
○ After 1 pass through edges, d[v1] is correct (Why?) and doesn’t change
○ After 2 passes, d[v2] is correct and doesn’t change
○ …○ Terminates in |V| - 1 passes: (Why?) ○ What if values haven’t converged yet?
![Page 13: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/13.jpg)
DAG Shortest Paths
● Problem: finding shortest paths in DAG; can have negative weights■ Bellman-Ford takes O(VE) time. ■ How can we do better?■ Idea: use topological sort first
○ Then, process vertices from left to right, relaxing outgoing edges; would be done in one pass
○ Every path in a dag is subsequence of topologically sorted vertex order, so processing verts in that order, we will do each path in forward order (will never relax edges out of a vertex before relaxing all edges into that vertex).
○ Thus: just one pass. What will be the running time?
![Page 14: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/14.jpg)
Dijkstra’s Algorithm
● If cycles, but no negative edge weights in directed graph, again we can beat BF
● Similar to breadth-first search■ Grow a tree gradually, advancing from vertices
taken from a queue
● Also similar to Prim’s algorithm for MST■ Use a priority queue keyed on d[v]
![Page 15: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/15.jpg)
Dijkstra’s Algorithm
Dijkstra(G)
for each v V d[v] = ; d[s] = 0; S = ; Q = V; while (Q ) u = ExtractMin(Q);
S = S U {u}; for each v u->Adj[] if (d[v] > d[u]+w(u,v))
d[v] = d[u]+w(u,v);RelaxationStepNote: this
is really a call to Q->DecreaseKey()
B
C
DA
10
4 3
2
15
Ex: run the algorithm
![Page 16: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/16.jpg)
Dijkstra’s Algorithm
Dijkstra(G)
for each v V d[v] = ; d[s] = 0; S = ; Q = V; while (Q ) u = ExtractMin(Q);
S = S U {u}; for each v u->Adj[] if (d[v] > d[u]+w(u,v))
d[v] = d[u]+w(u,v);
How many times is ExtractMin() called?
How many times is DecreaseKey() called?
What will be the total running time?
![Page 17: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/17.jpg)
Dijkstra’s Algorithm
Dijkstra(G)
for each v V d[v] = ; d[s] = 0; S = ; Q = V; while (Q ) u = ExtractMin(Q);
S = S U {u}; for each v u->Adj[] if (d[v] > d[u]+w(u,v))
d[v] = d[u]+w(u,v);
How many times is ExtractMin() called?
How many times is DecreaseKey() called?
A: O(E lg V) using binary heap for QCan acheive O(V lg V + E) with Fibonacci heaps
![Page 18: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/18.jpg)
Dijkstra’s Algorithm
Dijkstra(G)
for each v V d[v] = ; d[s] = 0; S = ; Q = V; while (Q ) u = ExtractMin(Q);
S = S U{u}; for each v u->Adj[] if (d[v] > d[u]+w(u,v))
d[v] = d[u]+w(u,v);Correctness: we must show that when u is removed from Q, it has already converged
![Page 19: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/19.jpg)
Correctness Of Dijkstra's Algorithm
● Note that d[v] (s,v) v ● Let u be first vertex picked s.t. shorter path than d[u] d[u] > (s,u)● Let y be first vertex V-S on actual shortest path from su d[y] = (s,y)
■ Because d[x] is set correctly for y's predecessor x S on the shortest path, and■ When we put x into S, we relaxed (x,y), giving d[y] the correct value
s
xy
up2
p1
S u is about to be addedto set S
![Page 20: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/20.jpg)
Correctness Of Dijkstra's Algorithm
● Note that d[v] (s,v) v ● Let u be first vertex picked s.t. shorter path than d[u] d[u] > (s,u)● Let y be first vertex V-S on actual shortest path from su d[y] = (s,y)● d[u] > (s,u)
= (s,y) + (y,u) (Why?)= d[y] + (y,u) d[y] But if d[u] > d[y], wouldn't have chosen u. Contradiction.
s
xy
up2
p2
S
![Page 21: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/21.jpg)
Disjoint-Set Union Problem
● Want a data structure to support disjoint sets ■ Collection of disjoint sets S = {Si}, Si ∩ Sj =
● Need to support following operations:■ 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
● Before discussing implementation details, we look at example application: Kruskal’s algorithm for MSTs
![Page 22: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/22.jpg)
MST revisited
![Page 23: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/23.jpg)
Kruskal’s 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));
}
![Page 24: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/24.jpg)
Kruskal’s 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:
![Page 25: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/25.jpg)
Kruskal’s 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:
![Page 26: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/26.jpg)
Kruskal’s 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:
![Page 27: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/27.jpg)
Kruskal’s 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:
![Page 28: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/28.jpg)
Kruskal’s 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:
![Page 29: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/29.jpg)
Kruskal’s 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:
![Page 30: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/30.jpg)
Kruskal’s 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:
![Page 31: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/31.jpg)
Kruskal’s 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:
![Page 32: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/32.jpg)
Kruskal’s 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:
![Page 33: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/33.jpg)
Kruskal’s 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:
![Page 34: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/34.jpg)
Kruskal’s 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:
![Page 35: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/35.jpg)
Kruskal’s 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:
![Page 36: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/36.jpg)
Kruskal’s 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:
![Page 37: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/37.jpg)
Kruskal’s 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:
![Page 38: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/38.jpg)
Kruskal’s 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:
![Page 39: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/39.jpg)
Kruskal’s 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
14?8
21
Run the algorithm:
![Page 40: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/40.jpg)
Kruskal’s 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:
![Page 41: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/41.jpg)
Kruskal’s 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
17?25
148
21
Run the algorithm:
![Page 42: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/42.jpg)
Kruskal’s 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:
![Page 43: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/43.jpg)
Kruskal’s 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:
![Page 44: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/44.jpg)
Kruskal’s 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:
![Page 45: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/45.jpg)
Kruskal’s 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:
![Page 46: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/46.jpg)
Kruskal’s 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
Result:
![Page 47: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/47.jpg)
Correctness Of Kruskal’s Algorithm
● Sketch of a proof that this algorithm produces an MST for T:■ Assume algorithm is wrong: result is not an MST■ Then algorithm adds a wrong edge at some point■ If it adds a wrong edge, there must be a lower weight
edge (cut and paste argument)■ But algorithm chooses lowest weight edge at each step.
Contradiction
● Again, important to be comfortable with cut and paste arguments
![Page 48: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/48.jpg)
Kruskal’s 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));
}
What will affect the running time?
![Page 49: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/49.jpg)
Kruskal’s 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));
}
What will affect the running time? 1 Sort
O(V) MakeSet() callsO(E) FindSet() callsO(V) Union() calls
![Page 50: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/50.jpg)
Kruskal’s Algorithm: Running Time
● To summarize: ■ Sort edges: O(E lg E) ■ O(V) MakeSet()’s■ O(E) FindSet()’s■ O(V) Union()’s
● Upshot: ■ Best disjoint-set algorithms makes above 3 operations
take O(E(E,V)), almost constant (see 21.3, 21.4)■ Overall thus O(E lg E), almost linear w/o sorting
![Page 51: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/51.jpg)
Disjoint Set Union
● So how do we implement disjoint-set union?■ Naïve implementation: use a linked list to
represent each set:
○ MakeSet(): ??? time○ FindSet(): ??? time○ Union(A,B): “copy” elements of A into B: ??? time
![Page 52: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/52.jpg)
Disjoint Set Union
● So how do we implement disjoint-set union?■ Naïve implementation: use a linked list to represent each
set:
○ MakeSet(): O(1) time○ FindSet(): O(1) time○ Union(A,B): “copy” elements of A into B: O(A) time
■ How long can a single Union() take?■ How long will n Union()’s take?
![Page 53: CSC 413/513: Intro to Algorithms](https://reader036.fdocuments.in/reader036/viewer/2022062422/5681375b550346895d9ee915/html5/thumbnails/53.jpg)
Disjoint Set Union: Analysis
● Worst-case analysis: O(n2) time for n Union’sUnion(S1, S2) “copy” 1 element
Union(S2, S3) “copy” 2 elements
…
Union(Sn-1, Sn) “copy” n-1 elements
O(n2)
● Improvement: always copy smaller into larger■ Why will this make things better?■ What is the worst-case time of Union()?
● But now n Union’s take only O(n lg n) time!