- 238 Views
- Uploaded on

Download Presentation
## PowerPoint Slideshow about 'CS 332: Algorithms' - andrew

**An Image/Link below is provided (as is) to download presentation**

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

Review: Breadth-First Search

BFS(G, s) {

initialize vertices;

Q = {s}; // Q is a queue (duh); initialize to s

while (Q not empty) {

u = RemoveTop(Q);

for each v u->adj {

if (v->color == WHITE)

v->color = GREY;

v->d = u->d + 1;

v->p = u;

Enqueue(Q, v);

}

u->color = BLACK;

}

}

v->d represents depth in tree

v->p represents parent in tree

David Luebke 23/10/2014

DFS(G)

{

for each vertex u G->V

{

u->color = WHITE;

}

time = 0;

for each vertex u G->V

{

if (u->color == WHITE)

DFS_Visit(u);

}

}

DFS_Visit(u)

{

u->color = YELLOW;

time = time+1;

u->d = time;

for each v u->Adj[]

{

if (v->color == WHITE)

DFS_Visit(v);

}

u->color = BLACK;

time = time+1;

u->f = time;

}

Review: DFS CodeDavid Luebke 33/10/2014

Review: Kinds Of Edges

- Thm: If G is undirected, a DFS produces only tree and back edges
- Thm: An undirected graph is acyclic iff a DFS yields no back edges
- Thus, can run DFS to find cycles

David Luebke 213/10/2014

Review: Kinds of Edges

sourcevertex

d f

1 |12

8 |11

13|16

2 | 7

9 |10

3 | 4

5 | 6

14|15

Tree edges

Back edges

Forward edges

Cross edges

David Luebke 223/10/2014

DFS And Cycles

- Running time: O(V+E)
- We can actually determine if cycles exist in O(V) time:
- In an undirected acyclic forest, |E| |V| - 1
- So count the edges: if ever see |V| distinct edges, must have seen a back edge along the way
- Why not just test if |E| <|V| and answer the question in constant time?

David Luebke 233/10/2014

Directed Acyclic Graphs

- A directed acyclic graph or DAG is a directed graph with no directed cycles:

David Luebke 243/10/2014

DFS and DAGs

- Argue that a directed graph G is acyclic iff a DFS of G yields no back edges:
- Forward: if G is acyclic, will be no back edges
- Trivial: a back edge implies a cycle
- Backward: if no back edges, G is acyclic
- Argue contrapositive: G has a cycle a back edge
- Let v be the vertex on the cycle first discovered, and u be the predecessor of v on the cycle
- When v discovered, whole cycle is white
- Must visit everything reachable from v before returning from DFS-Visit()
- So path from uv is yellowyellow, thus (u, v) is a back edge

David Luebke 253/10/2014

Topological Sort

- Topological sort of a DAG:
- Linear ordering of all vertices in graph G such that vertex u comes before vertex v if edge (u, v) G
- Real-world example: getting dressed

David Luebke 263/10/2014

Getting Dressed

Underwear

Socks

Watch

Pants

Shoes

Shirt

Belt

Tie

Jacket

Socks

Underwear

Pants

Shoes

Watch

Shirt

Belt

Tie

Jacket

David Luebke 283/10/2014

Topological Sort Algorithm

Topological-Sort()

{

Run DFS

When a vertex is finished, output it

Vertices are output in reverse topological order

}

- Time: O(V+E)
- Correctness: Want to prove that (u,v) G uf > vf

David Luebke 293/10/2014

Correctness of Topological Sort

- Claim: (u,v) G uf > vf
- When (u,v) is explored, u is yellow
- v = yellow (u,v) is back edge. Contradiction (Why?)
- v = white v becomes descendent of u vf < uf (since must finish v before backtracking and finishing u)
- v = black v already finished vf < uf

David Luebke 303/10/2014

Minimum Spanning Tree

- Problem: given a connected, undirected, weighted graph:

6

4

5

9

14

2

10

15

3

8

David Luebke 313/10/2014

Minimum Spanning Tree

- Problem: given a connected, undirected, weighted graph, find a spanning tree using edges that minimize the total weight

6

4

5

9

14

2

10

15

3

8

David Luebke 323/10/2014

Minimum Spanning Tree

- Which edges form the minimum spanning tree (MST) of the below graph?

A

6

4

5

9

H

B

C

14

2

10

15

G

E

D

3

8

F

David Luebke 333/10/2014

Minimum Spanning Tree

- MSTs satisfy the optimal substructure property: an optimal tree is composed of optimal subtrees
- Let T be an MST of G with an edge (u,v) in the middle
- Removing (u,v) partitions T into two trees T1 and T2
- Claim: T1 is an MST of G1 = (V1,E1), and T2 is an MST of G2 = (V2,E2) (Do V1 and V2 share vertices? Why?)
- Proof: w(T) = w(u,v) + w(T1) + w(T2)(There can’t be a better tree than T1 or T2, or T would be suboptimal)

David Luebke 353/10/2014

Minimum Spanning Tree

- Thm:
- Let T be MST of G, and let A T be subtree of T
- Let (u,v) be min-weight edge connecting A to V-A
- Then (u,v) T

David Luebke 363/10/2014

Minimum Spanning Tree

- Thm:
- Let T be MST of G, and let A T be subtree of T
- Let (u,v) be min-weight edge connecting A to V-A
- Then (u,v) T
- Proof: in book (see Thm 24.1)

David Luebke 373/10/2014

Prim’s 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);

David Luebke 383/10/2014

Prim’s 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);

6

4

9

5

14

2

10

15

3

8

Run on example graph

David Luebke 393/10/2014

Prim’s 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);

6

4

9

5

14

2

10

15

3

8

Run on example graph

David Luebke 403/10/2014

Prim’s 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);

6

4

9

5

14

2

10

15

r

0

3

8

Pick a start vertex r

David Luebke 413/10/2014

Prim’s 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);

6

4

9

5

14

2

10

15

u

0

3

8

Red vertices have been removed from Q

David Luebke 423/10/2014

Prim’s 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);

6

4

9

5

14

2

10

15

u

0

3

8

3

Red arrows indicate parent pointers

David Luebke 433/10/2014

Prim’s 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);

6

4

9

5

14

14

2

10

15

u

0

3

8

3

David Luebke 443/10/2014

Prim’s 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);

6

4

9

5

14

14

2

10

15

0

3

8

3

u

David Luebke 453/10/2014

Prim’s 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);

6

4

9

5

14

14

2

10

15

0

8

3

8

3

u

David Luebke 463/10/2014

Prim’s 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);

6

4

9

5

10

14

2

10

15

0

8

3

8

3

u

David Luebke 473/10/2014

Prim’s 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);

6

4

9

5

10

14

2

10

15

0

8

3

8

3

u

David Luebke 483/10/2014

Prim’s 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);

6

4

9

5

10

2

14

2

10

15

0

8

3

8

3

u

David Luebke 493/10/2014

Prim’s 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);

6

4

9

5

10

2

14

2

10

15

0

8

15

3

8

3

u

David Luebke 503/10/2014

Prim’s Algorithm

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);

6

4

9

5

10

2

14

2

10

15

0

8

15

3

8

3

David Luebke 513/10/2014

Prim’s Algorithm

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);

6

4

9

5

10

2

9

14

2

10

15

0

8

15

3

8

3

David Luebke 523/10/2014

Prim’s Algorithm

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);

4

6

4

9

5

10

2

9

14

2

10

15

0

8

15

3

8

3

David Luebke 533/10/2014

Prim’s Algorithm

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);

4

6

4

9

5

5

2

9

14

2

10

15

0

8

15

3

8

3

David Luebke 543/10/2014

Prim’s Algorithm

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);

4

6

4

9

5

5

2

9

14

2

10

15

0

8

15

3

8

3

David Luebke 553/10/2014

Prim’s Algorithm

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);

4

6

4

9

5

5

2

9

14

2

10

15

0

8

15

3

8

3

David Luebke 563/10/2014

Prim’s Algorithm

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);

4

6

4

9

5

5

2

9

14

2

10

15

0

8

15

3

8

3

David Luebke 573/10/2014

Prim’s 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);

4

6

4

9

5

5

2

9

u

14

2

10

15

0

8

15

3

8

3

David Luebke 583/10/2014

Review: Prim’s 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);

What is the hidden cost in this code?

David Luebke 593/10/2014

Review: Prim’s 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;

DecreaseKey(v, w(u,v));

David Luebke 603/10/2014

Review: Prim’s 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;

DecreaseKey(v, w(u,v));

How often is ExtractMin() called?

How often is DecreaseKey() called?

David Luebke 613/10/2014

Review: Prim’s 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);

What will be the running time?A: Depends on queue binary heap: O(E lg V) Fibonacci heap: O(V lg V + E)

David Luebke 623/10/2014

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 Chapel Hill to Charlottesville?

David Luebke 633/10/2014

Download Presentation

Connecting to Server..