Breadth First Search, Dijkstra s Algorithm for Shortest Paths

Size: px
Start display at page:

Transcription

1 CS 374: Algorithms & Models of Computation, Spring 2017 Breadth First Search, Dijkstra s Algorithm for Shortest Paths Lecture 17 March 1, 2017 Chandra Chekuri (UIUC) CS374 1 Spring / 42

2 Part I Breadth First Search Chandra Chekuri (UIUC) CS374 2 Spring / 42

3 Breadth First Search (BFS) Overview (A) BFS is obtained from BasicSearch by processing edges using a data structure called a queue. (B) It processes the vertices in the graph in the order of their shortest distance from the vertex s (the start vertex). As such... 1 DFS good for exploring graph structure 2 BFS good for exploring distances Chandra Chekuri (UIUC) CS374 3 Spring / 42

4 xkcd take on DFS Chandra Chekuri (UIUC) CS374 4 Spring / 42

5 Queue Data Structure Queues A queue is a list of elements which supports the operations: 1 enqueue: Adds an element to the end of the list 2 dequeue: Removes an element from the front of the list Elements are extracted in first-in first-out (FIFO) order, i.e., elements are picked in the order in which they were inserted. Chandra Chekuri (UIUC) CS374 5 Spring / 42

6 BFS Algorithm Given (undirected or directed) graph G = (V, E) and node s V Proposition BFS(s) Mark all vertices as unvisited Initialize search tree T to be empty Mark vertex s as visited set Q to be the empty queue enq(s) while Q is nonempty do u = deq(q) for each vertex v Adj(u) if v is not visited then add edge (u, v) to T Mark v as visited and enq(v) BFS(s) runs in O(n + m) time. Chandra Chekuri (UIUC) CS374 Spring 2017 / 42

7 BFS: An Example in Undirected Graphs [1] Chandra Chekuri (UIUC) CS374 7 Spring / 42

8 BFS: An Example in Undirected Graphs [1] 2. [2,3] Chandra Chekuri (UIUC) CS374 7 Spring / 42

9 BFS: An Example in Undirected Graphs [1] 2. [2,3] 3. [3,4,5] Chandra Chekuri (UIUC) CS374 7 Spring / 42

10 BFS: An Example in Undirected Graphs [1] 4. [4,5,7,8] 2. [2,3] 3. [3,4,5] Chandra Chekuri (UIUC) CS374 7 Spring / 42

11 BFS: An Example in Undirected Graphs [1] 4. [4,5,7,8] 2. [2,3] 5. [5,7,8] 3. [3,4,5] Chandra Chekuri (UIUC) CS374 7 Spring / 42

12 BFS: An Example in Undirected Graphs [1] 4. [4,5,7,8] 2. [2,3] 5. [5,7,8] 3. [3,4,5]. [7,8,] Chandra Chekuri (UIUC) CS374 7 Spring / 42

13 BFS: An Example in Undirected Graphs [1] 4. [4,5,7,8] 7. [8,] 2. [2,3] 5. [5,7,8] 3. [3,4,5]. [7,8,] Chandra Chekuri (UIUC) CS374 7 Spring / 42

14 BFS: An Example in Undirected Graphs [1] 4. [4,5,7,8] 7. [8,] 2. [2,3] 5. [5,7,8] 8. [] 3. [3,4,5]. [7,8,] Chandra Chekuri (UIUC) CS374 7 Spring / 42

15 BFS: An Example in Undirected Graphs [1] 4. [4,5,7,8] 7. [8,] 2. [2,3] 5. [5,7,8] 8. [] 3. [3,4,5]. [7,8,] 9. [] Chandra Chekuri (UIUC) CS374 7 Spring / 42

16 BFS: An Example in Undirected Graphs [1] 4. [4,5,7,8] 7. [8,] 2. [2,3] 5. [5,7,8] 8. [] 3. [3,4,5]. [7,8,] 9. [] BFS tree is the set of black edges. Chandra Chekuri (UIUC) CS374 7 Spring / 42

17 BFS: An Example in Directed Graphs B A C E F D G H lso called a digraph) is G = (V, E), where rtices or nodes set of ordered pairs of vertices called edges Chandra Chekuri (UIUC) CS374 8 Spring / 42

18 BFS with Distance BFS(s) Mark all vertices as unvisited; for each v set dist(v) = Initialize search tree T to be empty Mark vertex s as visited and set dist(s) = 0 set Q to be the empty queue enq(s) while Q is nonempty do u = deq(q) for each vertex v Adj(u) do if v is not visited do add edge (u, v) to T Mark v as visited, enq(v) and set dist(v) = dist(u) + 1 Chandra Chekuri (UIUC) CS374 9 Spring / 42

19 Properties of BFS: Undirected Graphs Theorem The following properties hold upon termination of BFS(s) (A) The search tree contains exactly the set of vertices in the connected component of s. (B) If dist(u) < dist(v) then u is visited before v. (C) For every vertex u, dist(u) is the length of a shortest path (in terms of number of edges) from s to u. (D) If u, v are in connected component of s and e = {u, v} is an edge of G, then dist(u) dist(v) 1. Chandra Chekuri (UIUC) CS Spring / 42

20 Properties of BFS: Directed Graphs Theorem The following properties hold upon termination of BFS(s): (A) The search tree contains exactly the set of vertices reachable from s (B) If dist(u) < dist(v) then u is visited before v (C) For every vertex u, dist(u) is indeed the length of shortest path from s to u (D) If u is reachable from s and e = (u, v) is an edge of G, then dist(v) dist(u) 1. Not necessarily the case that dist(u) dist(v) 1. Chandra Chekuri (UIUC) CS Spring / 42

21 BFS with Layers BFSLayers(s): Mark all vertices as unvisited and initialize T to be empty Mark s as visited and set L 0 = {s} i = 0 while L i is not empty do initialize L i +1 to be an empty list for each u in L i do for each edge (u, v) Adj(u) do if v is not visited mark v as visited add (u, v) to tree T add v to L i +1 i = i + 1 Chandra Chekuri (UIUC) CS Spring / 42

22 BFS with Layers BFSLayers(s): Mark all vertices as unvisited and initialize T to be empty Mark s as visited and set L 0 = {s} i = 0 while L i is not empty do initialize L i +1 to be an empty list for each u in L i do for each edge (u, v) Adj(u) do if v is not visited mark v as visited add (u, v) to tree T add v to L i +1 i = i + 1 Running time: O(n + m) Chandra Chekuri (UIUC) CS Spring / 42

23 Example Chandra Chekuri (UIUC) CS Spring / 42

24 BFS with Layers: Properties Proposition The following properties hold on termination of BFSLayers(s). 1 BFSLayers(s) outputs a BFS tree 2 L i is the set of vertices at distance exactly i from s 3 If G is undirected, each edge e = {u, v} is one of three types: 1 tree edge between two consecutive layers 2 non-tree forward/backward edge between two consecutive layers 3 non-tree cross-edge with both u, v in same layer 4 = Every edge in the graph is either between two vertices that are either (i) in the same layer, or (ii) in two consecutive layers. Chandra Chekuri (UIUC) CS Spring / 42

25 Example B A C E F D G H lso called a digraph) is G = (V, E), where rtices or nodes set of ordered pairs of vertices called edges Chandra Chekuri (UIUC) CS Spring / 42

26 BFS with Layers: Properties For directed graphs Proposition The following properties hold on termination of BFSLayers(s), if G is directed. For each edge e = (u, v) is one of four types: 1 a tree edge between consecutive layers, u L i, v L i +1 for some i 0 2 a non-tree forward edge between consecutive layers 3 a non-tree backward edge 4 a cross-edge with both u, v in same layer Chandra Chekuri (UIUC) CS374 1 Spring / 42

27 Part II Shortest Paths and Dijkstra s Algorithm Chandra Chekuri (UIUC) CS Spring / 42

28 Shortest Path Problems Shortest Path Problems Input A (undirected or directed) graph G = (V, E) with edge lengths (or costs). For edge e = (u, v), l(e) = l(u, v) is its length. 1 Given nodes s, t find shortest path from s to t. 2 Given node s find shortest path from s to all other nodes. 3 Find shortest paths for all pairs of nodes. Chandra Chekuri (UIUC) CS Spring / 42

29 Shortest Path Problems Shortest Path Problems Input A (undirected or directed) graph G = (V, E) with edge lengths (or costs). For edge e = (u, v), l(e) = l(u, v) is its length. 1 Given nodes s, t find shortest path from s to t. 2 Given node s find shortest path from s to all other nodes. 3 Find shortest paths for all pairs of nodes. Many applications! Chandra Chekuri (UIUC) CS Spring / 42

30 Single-Source Shortest Paths: Non-Negative Edge Lengths Single-Source Shortest Path Problems 1 Input: A (undirected or directed) graph G = (V, E) with non-negative edge lengths. For edge e = (u, v), l(e) = l(u, v) is its length. 2 Given nodes s, t find shortest path from s to t. 3 Given node s find shortest path from s to all other nodes. Chandra Chekuri (UIUC) CS Spring / 42

31 Single-Source Shortest Paths: Non-Negative Edge Lengths Single-Source Shortest Path Problems 1 Input: A (undirected or directed) graph G = (V, E) with non-negative edge lengths. For edge e = (u, v), l(e) = l(u, v) is its length. 2 Given nodes s, t find shortest path from s to t. 3 Given node s find shortest path from s to all other nodes. 1 Restrict attention to directed graphs 2 Undirected graph problem can be reduced to directed graph problem - how? Chandra Chekuri (UIUC) CS Spring / 42

32 Single-Source Shortest Paths: Non-Negative Edge Lengths Single-Source Shortest Path Problems 1 Input: A (undirected or directed) graph G = (V, E) with non-negative edge lengths. For edge e = (u, v), l(e) = l(u, v) is its length. 2 Given nodes s, t find shortest path from s to t. 3 Given node s find shortest path from s to all other nodes. 1 Restrict attention to directed graphs 2 Undirected graph problem can be reduced to directed graph problem - how? 1 Given undirected graph G, create a new directed graph G by replacing each edge {u, v} in G by (u, v) and (v, u) in G. 2 set l(u, v) = l(v, u) = l({u, v}) 3 Exercise: show reduction works. Relies on non-negativity! Chandra Chekuri (UIUC) CS Spring / 42

33 Single-Source Shortest Paths via BFS Special case: All edge lengths are 1. Chandra Chekuri (UIUC) CS Spring / 42

34 Single-Source Shortest Paths via BFS Special case: All edge lengths are 1. 1 Run BFS(s) to get shortest path distances from s to all other nodes. 2 O(m + n) time algorithm. Chandra Chekuri (UIUC) CS Spring / 42

35 Single-Source Shortest Paths via BFS Special case: All edge lengths are 1. 1 Run BFS(s) to get shortest path distances from s to all other nodes. 2 O(m + n) time algorithm. Special case: Suppose l(e) is an integer for all e? Can we use BFS? Chandra Chekuri (UIUC) CS Spring / 42

36 Single-Source Shortest Paths via BFS Special case: All edge lengths are 1. 1 Run BFS(s) to get shortest path distances from s to all other nodes. 2 O(m + n) time algorithm. Special case: Suppose l(e) is an integer for all e? Can we use BFS? Reduce to unit edge-length problem by placing l(e) 1 dummy nodes on e Chandra Chekuri (UIUC) CS Spring / 42

37 Single-Source Shortest Paths via BFS Special case: All edge lengths are 1. 1 Run BFS(s) to get shortest path distances from s to all other nodes. 2 O(m + n) time algorithm. Special case: Suppose l(e) is an integer for all e? Can we use BFS? Reduce to unit edge-length problem by placing l(e) 1 dummy nodes on e Let L = max e l(e). New graph has O(mL) edges and O(mL + n) nodes. BFS takes O(mL + n) time. Not efficient if L is large. Chandra Chekuri (UIUC) CS Spring / 42

38 Towards an algorithm Why does BFS work? Chandra Chekuri (UIUC) CS Spring / 42

39 Towards an algorithm Why does BFS work? BFS(s) explores nodes in increasing distance from s Chandra Chekuri (UIUC) CS Spring / 42

40 Towards an algorithm Why does BFS work? BFS(s) explores nodes in increasing distance from s Lemma Let G be a directed graph with non-negative edge lengths. Let dist(s, v) denote the shortest path length from s to v. If s = v 0 v 1 v 2... v k is a shortest path from s to v k then for 1 i < k: 1 s = v 0 v 1 v 2... v i is a shortest path from s to v i 2 dist(s, v i ) dist(s, v k ). Relies on non-neg edge lengths. Chandra Chekuri (UIUC) CS Spring / 42

41 Towards an algorithm Proof. Suppose not. Then for some i < k there is a path P from s to v i of length strictly less than that of s = v 0 v 1... v i. Then P concatenated with v i v i v k contains a strictly shorter path to v k than s = v 0 v 1... v k. For the second part, Chandra observe Chekuri (UIUC) that edge lengths CS374 are non-negative. 21 Spring / 42 Lemma Let G be a directed graph with non-negative edge lengths. Let dist(s, v) denote the shortest path length from s to v. If s = v 0 v 1 v 2... v k is a shortest path from s to v k then for 1 i < k: 1 s = v 0 v 1 v 2... v i is a shortest path from s to v i 2 dist(s, v i ) dist(s, v k ). Relies on non-neg edge lengths.

42 A proof by picture s = v 0 v 2 v 4 v 5 v v 1 v 3 Shortest path from v 0 to v Chandra Chekuri (UIUC) CS Spring / 42

43 A proof by picture Shorter path from v 0 to v 4 s = v 0 v 2 v 4 v 5 v v 1 v 3 Shortest path from v 0 to v Chandra Chekuri (UIUC) CS Spring / 42

44 A proof by picture A shorter path from v 0 to v. A contradiction. s = v 0 v 2 v 4 v 5 v v 1 v 3 Shortest path from v 0 to v Chandra Chekuri (UIUC) CS Spring / 42

45 A Basic Strategy Explore vertices in increasing order of distance from s: (For simplicity assume that nodes are at different distances from s and that no edge has zero length) Initialize for each node v, dist(s, v) = Initialize X = {s}, for i = 2 to V do (* Invariant: X contains the i 1 closest nodes to s *) Among nodes in V X, find the node v that is the i th closest to s Update dist(s, v) X = X {v} Chandra Chekuri (UIUC) CS Spring / 42

46 A Basic Strategy Explore vertices in increasing order of distance from s: (For simplicity assume that nodes are at different distances from s and that no edge has zero length) Initialize for each node v, dist(s, v) = Initialize X = {s}, for i = 2 to V do (* Invariant: X contains the i 1 closest nodes to s *) Among nodes in V X, find the node v that is the i th closest to s Update dist(s, v) X = X {v} How can we implement the step in the for loop? Chandra Chekuri (UIUC) CS Spring / 42

47 Finding the ith closest node 1 X contains the i 1 closest nodes to s 2 Want to find the ith closest node from V X. What do we know about the ith closest node? Chandra Chekuri (UIUC) CS Spring / 42

48 Finding the ith closest node 1 X contains the i 1 closest nodes to s 2 Want to find the ith closest node from V X. What do we know about the ith closest node? Claim Let P be a shortest path from s to v where v is the ith closest node. Then, all intermediate nodes in P belong to X. Chandra Chekuri (UIUC) CS Spring / 42

49 Finding the ith closest node 1 X contains the i 1 closest nodes to s 2 Want to find the ith closest node from V X. What do we know about the ith closest node? Claim Let P be a shortest path from s to v where v is the ith closest node. Then, all intermediate nodes in P belong to X. Proof. If P had an intermediate node u not in X then u will be closer to s than v. Implies v is not the i th closest node to s - recall that X already has the i 1 closest nodes. Chandra Chekuri (UIUC) CS Spring / 42

50 Finding the ith closest node repeatedly An example a Chandra Chekuri (UIUC) CS Spring / 42

51 Finding the ith closest node repeatedly An example a e b 8 c d 11 1 f 19 g h Chandra Chekuri (UIUC) CS Spring / 42

52 Finding the ith closest node repeatedly An example a e b 8 c d 11 1 f 19 g h Chandra Chekuri (UIUC) CS Spring / 42

53 Finding the ith closest node repeatedly An example a e b 9 8 c d 11 1 f 19 g h Chandra Chekuri (UIUC) CS Spring / 42

54 Finding the ith closest node repeatedly An example a e 13 b 9 8 c d 11 1 f 19 g h Chandra Chekuri (UIUC) CS Spring / 42

55 Finding the ith closest node repeatedly An example a e 13 b 9 8 c d f g h Chandra Chekuri (UIUC) CS Spring / 42

56 Finding the ith closest node repeatedly An example a e 13 b 9 8 c d 25 f g h Chandra Chekuri (UIUC) CS Spring / 42

57 Finding the ith closest node repeatedly An example a e 13 b 9 8 c d 25 f g 3 19 h Chandra Chekuri (UIUC) CS Spring / 42

58 Finding the ith closest node repeatedly An example a e 13 b 9 8 c d 25 f g h Chandra Chekuri (UIUC) CS Spring / 42

59 Finding the ith closest node a Corollary The ith closest node is adjacent to X. Chandra Chekuri (UIUC) CS374 2 Spring / 42

60 Finding the ith closest node 1 X contains the i 1 closest nodes to s 2 Want to find the ith closest node from V X. 1 For each u V X let P(s, u, X ) be a shortest path from s to u using only nodes in X as intermediate vertices. 2 Let d (s, u) be the length of P(s, u, X ) Chandra Chekuri (UIUC) CS Spring / 42

61 Finding the ith closest node 1 X contains the i 1 closest nodes to s 2 Want to find the ith closest node from V X. 1 For each u V X let P(s, u, X ) be a shortest path from s to u using only nodes in X as intermediate vertices. 2 Let d (s, u) be the length of P(s, u, X ) Observations: for each u V X, 1 dist(s, u) d (s, u) since we are constraining the paths 2 d (s, u) = min t X (dist(s, t) + l(t, u)) - Why? Chandra Chekuri (UIUC) CS Spring / 42

62 Finding the ith closest node 1 X contains the i 1 closest nodes to s 2 Want to find the ith closest node from V X. 1 For each u V X let P(s, u, X ) be a shortest path from s to u using only nodes in X as intermediate vertices. 2 Let d (s, u) be the length of P(s, u, X ) Observations: for each u V X, 1 dist(s, u) d (s, u) since we are constraining the paths 2 d (s, u) = min t X (dist(s, t) + l(t, u)) - Why? Lemma If v is the ith closest node to s, then d (s, v) = dist(s, v). Chandra Chekuri (UIUC) CS Spring / 42

63 Finding the ith closest node Lemma Given: 1 X : Set of i 1 closest nodes to s. 2 d (s, u) = min t X (dist(s, t) + l(t, u)) If v is an ith closest node to s, then d (s, v) = dist(s, v). Proof. Let v be the ith closest node to s. Then there is a shortest path P from s to v that contains only nodes in X as intermediate nodes (see previous claim). Therefore d (s, v) = dist(s, v). Chandra Chekuri (UIUC) CS Spring / 42

64 Finding the ith closest node Lemma If v is an ith closest node to s, then d (s, v) = dist(s, v). Corollary The ith closest node to s is the node v V X such that d (s, v) = min u V X d (s, u). Proof. For every node u V X, dist(s, u) d (s, u) and for the ith closest node v, dist(s, v) = d (s, v). Moreover, dist(s, u) dist(s, v) for each u V S. Chandra Chekuri (UIUC) CS Spring / 42

65 Algorithm Initialize for each node v: dist(s, v) = Initialize X =, d (s, s) = 0 for i = 1 to V do (* Invariant: X contains the i 1 closest nodes to s *) (* Invariant: d (s, u) is shortest path distance from u to s using only X as intermediate nodes*) Let v be such that d (s, v) = min u V X d (s, u) dist(s, v) = d (s, v) X = X {v} for each node u in V X do ) d (s, u) = min t X (dist(s, t) + l(t, u) Chandra Chekuri (UIUC) CS Spring / 42

66 Algorithm Initialize for each node v: dist(s, v) = Initialize X =, d (s, s) = 0 for i = 1 to V do (* Invariant: X contains the i 1 closest nodes to s *) (* Invariant: d (s, u) is shortest path distance from u to s using only X as intermediate nodes*) Let v be such that d (s, v) = min u V X d (s, u) dist(s, v) = d (s, v) X = X {v} for each node u in V X do ) d (s, u) = min t X (dist(s, t) + l(t, u) Correctness: By induction on i using previous lemmas. Chandra Chekuri (UIUC) CS Spring / 42

67 Algorithm Initialize for each node v: dist(s, v) = Initialize X =, d (s, s) = 0 for i = 1 to V do (* Invariant: X contains the i 1 closest nodes to s *) (* Invariant: d (s, u) is shortest path distance from u to s using only X as intermediate nodes*) Let v be such that d (s, v) = min u V X d (s, u) dist(s, v) = d (s, v) X = X {v} for each node u in V X do ) d (s, u) = min t X (dist(s, t) + l(t, u) Correctness: By induction on i using previous lemmas. Running time: Chandra Chekuri (UIUC) CS Spring / 42

68 Algorithm Initialize for each node v: dist(s, v) = Initialize X =, d (s, s) = 0 for i = 1 to V do (* Invariant: X contains the i 1 closest nodes to s *) (* Invariant: d (s, u) is shortest path distance from u to s using only X as intermediate nodes*) Let v be such that d (s, v) = min u V X d (s, u) dist(s, v) = d (s, v) X = X {v} for each node u in V X do ) d (s, u) = min t X (dist(s, t) + l(t, u) Correctness: By induction on i using previous lemmas. Running time: O(n (n + m)) time. 1 n outer iterations. In each iteration, d (s, u) for each u by scanning all edges out of nodes in X ; O(m + n) time/iteration. Chandra Chekuri (UIUC) CS Spring / 42

69 Example s Chandra Chekuri (UIUC) CS Spring / 42

70 Example s Chandra Chekuri (UIUC) CS Spring / 42

71 Example s Chandra Chekuri (UIUC) CS Spring / 42

72 Example s Chandra Chekuri (UIUC) CS Spring / 42

73 Example s Chandra Chekuri (UIUC) CS Spring / 42

74 Example s Chandra Chekuri (UIUC) CS Spring / 42

75 Example s Chandra Chekuri (UIUC) CS Spring / 42

76 Example s Chandra Chekuri (UIUC) CS Spring / 42

77 Improved Algorithm 1 Main work is to compute the d (s, u) values in each iteration 2 d (s, u) changes from iteration i to i + 1 only because of the node v that is added to X in iteration i. Chandra Chekuri (UIUC) CS Spring / 42

78 Improved Algorithm 1 Main work is to compute the d (s, u) values in each iteration 2 d (s, u) changes from iteration i to i + 1 only because of the node v that is added to X in iteration i. Initialize for each node v, dist(s, v) = d (s, v) = Initialize X =, d (s, s) = 0 for i = 1 to V do // X contains the i 1 closest nodes to s, // and the values of d (s, u) are current Let v be node realizing d (s, v) = min u V X d (s, u) dist(s, v) = d (s, v) X = X {v} Update d (s, u) for( each u in V X as follows: ) d (s, u) = min d (s, u), dist(s, v) + l(v, u) Running time: Chandra Chekuri (UIUC) CS Spring / 42

79 Improved Algorithm Initialize for each node v, dist(s, v) = d (s, v) = Initialize X =, d (s, s) = 0 for i = 1 to V do // X contains the i 1 closest nodes to s, // and the values of d (s, u) are current Let v be node realizing d (s, v) = min u V X d (s, u) dist(s, v) = d (s, v) X = X {v} Update d (s, u) for( each u in V X as follows: ) d (s, u) = min d (s, u), dist(s, v) + l(v, u) Running time: O(m + n 2 ) time. 1 n outer iterations and in each iteration following steps 2 updating d (s, u) after v is added takes O(deg(v)) time so total work is O(m) since a node enters X only once 3 Finding v from d (s, u) values is O(n) time Chandra Chekuri (UIUC) CS Spring / 42

80 Dijkstra s Algorithm 1 eliminate d (s, u) and let dist(s, u) maintain it 2 update dist values after adding v by scanning edges out of v Initialize for each node v, dist(s, v) = Initialize X =, dist(s, s) = 0 for i = 1 to V do Let v be such that dist(s, v) = min u V X dist(s, u) X = X {v} for each u in Adj(v) ( do ) dist(s, u) = min dist(s, u), dist(s, v) + l(v, u) Priority Queues to maintain dist values for faster running time Chandra Chekuri (UIUC) CS Spring / 42

81 Dijkstra s Algorithm 1 eliminate d (s, u) and let dist(s, u) maintain it 2 update dist values after adding v by scanning edges out of v Initialize for each node v, dist(s, v) = Initialize X =, dist(s, s) = 0 for i = 1 to V do Let v be such that dist(s, v) = min u V X dist(s, u) X = X {v} for each u in Adj(v) ( do ) dist(s, u) = min dist(s, u), dist(s, v) + l(v, u) Priority Queues to maintain dist values for faster running time 1 Using heaps and standard priority queues: O((m + n) log n) 2 Using Fibonacci heaps: O(m + n log n). Chandra Chekuri (UIUC) CS Spring / 42

82 Priority Queues Data structure to store a set S of n elements where each element v S has an associated real/integer key k(v) such that the following operations: 1 makepq: create an empty queue. 2 findmin: find the minimum key in S. 3 extractmin: Remove v S with smallest key and return it. 4 insert(v, k(v)): Add new element v with key k(v) to S. 5 delete(v): Remove element v from S. Chandra Chekuri (UIUC) CS Spring / 42

83 Priority Queues Data structure to store a set S of n elements where each element v S has an associated real/integer key k(v) such that the following operations: 1 makepq: create an empty queue. 2 findmin: find the minimum key in S. 3 extractmin: Remove v S with smallest key and return it. 4 insert(v, k(v)): Add new element v with key k(v) to S. 5 delete(v): Remove element v from S. decreasekey(v, k (v)): decrease key of v from k(v) (current key) to k (v) (new key). Assumption: k (v) k(v). 7 meld: merge two separate priority queues into one. Chandra Chekuri (UIUC) CS Spring / 42

84 Priority Queues Data structure to store a set S of n elements where each element v S has an associated real/integer key k(v) such that the following operations: 1 makepq: create an empty queue. 2 findmin: find the minimum key in S. 3 extractmin: Remove v S with smallest key and return it. 4 insert(v, k(v)): Add new element v with key k(v) to S. 5 delete(v): Remove element v from S. decreasekey(v, k (v)): decrease key of v from k(v) (current key) to k (v) (new key). Assumption: k (v) k(v). 7 meld: merge two separate priority queues into one. All operations can be performed in O(log n) time. decreasekey is implemented via delete and insert. Chandra Chekuri (UIUC) CS Spring / 42

85 Dijkstra s Algorithm using Priority Queues Q makepq() insert(q, (s, 0)) for each node u s do insert(q, (u, )) X for i = 1 to V do (v, dist(s, v)) = extractmin(q) X = X {v} for each u in Adj(v) ( do decreasekey Q, ( u, min ( dist(s, u), dist(s, v) + l(v, u) ))). Priority Queue operations: 1 O(n) insert operations 2 O(n) extractmin operations 3 O(m) decreasekey operations Chandra Chekuri (UIUC) CS Spring / 42

86 Implementing Priority Queues via Heaps Using Heaps Store elements in a heap based on the key value 1 All operations can be done in O(log n) time Chandra Chekuri (UIUC) CS374 3 Spring / 42

87 Implementing Priority Queues via Heaps Using Heaps Store elements in a heap based on the key value 1 All operations can be done in O(log n) time Dijkstra s algorithm can be implemented in O((n + m) log n) time. Chandra Chekuri (UIUC) CS374 3 Spring / 42

88 Priority Queues: Fibonacci Heaps/Relaxed Heaps Fibonacci Heaps 1 extractmin, insert, delete, meld in O(log n) time 2 decreasekey in O(1) amortized time: Chandra Chekuri (UIUC) CS Spring / 42

89 Priority Queues: Fibonacci Heaps/Relaxed Heaps Fibonacci Heaps 1 extractmin, insert, delete, meld in O(log n) time 2 decreasekey in O(1) amortized time: l decreasekey operations for l n take together O(l) time 3 Relaxed Heaps: decreasekey in O(1) worst case time but at the expense of meld (not necessary for Dijkstra s algorithm) Chandra Chekuri (UIUC) CS Spring / 42

90 Priority Queues: Fibonacci Heaps/Relaxed Heaps Fibonacci Heaps 1 extractmin, insert, delete, meld in O(log n) time 2 decreasekey in O(1) amortized time: l decreasekey operations for l n take together O(l) time 3 Relaxed Heaps: decreasekey in O(1) worst case time but at the expense of meld (not necessary for Dijkstra s algorithm) 1 Dijkstra s algorithm can be implemented in O(n log n + m) time. If m = Ω(n log n), running time is linear in input size. Chandra Chekuri (UIUC) CS Spring / 42

91 Priority Queues: Fibonacci Heaps/Relaxed Heaps Fibonacci Heaps 1 extractmin, insert, delete, meld in O(log n) time 2 decreasekey in O(1) amortized time: l decreasekey operations for l n take together O(l) time 3 Relaxed Heaps: decreasekey in O(1) worst case time but at the expense of meld (not necessary for Dijkstra s algorithm) 1 Dijkstra s algorithm can be implemented in O(n log n + m) time. If m = Ω(n log n), running time is linear in input size. 2 Data structures are complicated to analyze/implement. Recent work has obtained data structures that are easier to analyze and implement, and perform well in practice. Rank-Pairing Heaps (European Symposium on Algorithms, September 2009!) Chandra Chekuri (UIUC) CS Spring / 42

92 Shortest Path Tree Dijkstra s algorithm finds the shortest path distances from s to V. Question: How do we find the paths themselves? Chandra Chekuri (UIUC) CS Spring / 42

93 Shortest Path Tree Dijkstra s algorithm finds the shortest path distances from s to V. Question: How do we find the paths themselves? Q = makepq() insert(q, (s, 0)) prev(s) null for each node u s do insert(q, (u, ) ) prev(u) null X = for i = 1 to V do (v, dist(s, v)) = extractmin(q) X = X {v} for each u in Adj(v) do if (dist(s, v) + l(v, u) < dist(s, u)) then decreasekey(q, (u, dist(s, v) + l(v, u))) prev(u) = v Chandra Chekuri (UIUC) CS Spring / 42

94 Shortest Path Tree Lemma The edge set (u, prev(u)) is the reverse of a shortest path tree rooted at s. For each u, the reverse of the path from u to s in the tree is a shortest path from s to u. Proof Sketch. 1 The edge set {(u, prev(u)) u V } induces a directed in-tree rooted at s (Why?) 2 Use induction on X to argue that the tree is a shortest path tree for nodes in V. Chandra Chekuri (UIUC) CS Spring / 42

95 Shortest paths to s Dijkstra s algorithm gives shortest paths from s to all nodes in V. How do we find shortest paths from all of V to s? Chandra Chekuri (UIUC) CS Spring / 42

96 Shortest paths to s Dijkstra s algorithm gives shortest paths from s to all nodes in V. How do we find shortest paths from all of V to s? 1 In undirected graphs shortest path from s to u is a shortest path from u to s so there is no need to distinguish. 2 In directed graphs, use Dijkstra s algorithm in G rev! Chandra Chekuri (UIUC) CS Spring / 42

97 Shortest paths between sets of nodes Suppose we are given S V and T V. Want to find shortest path from S to T defined as: dist(s, T ) = min dist(s, t) s S,t T How do we find dist(s, T )? Chandra Chekuri (UIUC) CS Spring / 42

98 Example Problem You want to go from your house to a friend s house. Need to pick up some dessert along the way and hence need to stop at one of the many potential stores along the way. How do you calculate the shortest trip if you include this stop? Chandra Chekuri (UIUC) CS Spring / 42

99 Example Problem You want to go from your house to a friend s house. Need to pick up some dessert along the way and hence need to stop at one of the many potential stores along the way. How do you calculate the shortest trip if you include this stop? Given G = (V, E) and edge lengths l(e), e E. Want to go from s to t. A subset X V that corresponds to stores. Want to find min x X d(s, x) + d(x, t). Chandra Chekuri (UIUC) CS Spring / 42

100 Example Problem You want to go from your house to a friend s house. Need to pick up some dessert along the way and hence need to stop at one of the many potential stores along the way. How do you calculate the shortest trip if you include this stop? Given G = (V, E) and edge lengths l(e), e E. Want to go from s to t. A subset X V that corresponds to stores. Want to find min x X d(s, x) + d(x, t). Basic solution: Compute for each x X, d(s, x) and d(x, t) and take minimum. 2 X shortest path computations. O( X (m + n log n)). Chandra Chekuri (UIUC) CS Spring / 42

101 Example Problem You want to go from your house to a friend s house. Need to pick up some dessert along the way and hence need to stop at one of the many potential stores along the way. How do you calculate the shortest trip if you include this stop? Given G = (V, E) and edge lengths l(e), e E. Want to go from s to t. A subset X V that corresponds to stores. Want to find min x X d(s, x) + d(x, t). Basic solution: Compute for each x X, d(s, x) and d(x, t) and take minimum. 2 X shortest path computations. O( X (m + n log n)). Better solution: Compute shortest path distances from s to every node v V with one Dijkstra. Compute from every node v V shortest path distance to t with one Dijkstra. Chandra Chekuri (UIUC) CS Spring / 42

Single Source Shortest Paths

CMPS 00 Fall 015 Single Source Shortest Paths Carola Wenk Slides courtesy of Charles Leiserson with changes and additions by Carola Wenk 1 Paths in graphs Consider a digraph G = (V, E) with an edge-weight

Dynamic Programming: Shortest Paths and DFA to Reg Exps

CS 374: Algorithms & Models of Computation, Spring 207 Dynamic Programming: Shortest Paths and DFA to Reg Exps Lecture 8 March 28, 207 Chandra Chekuri (UIUC) CS374 Spring 207 / 56 Part I Shortest Paths

Single Source Shortest Paths

CMPS 00 Fall 017 Single Source Shortest Paths Carola Wenk Slides courtesy of Charles Leiserson with changes and additions by Carola Wenk Paths in graphs Consider a digraph G = (V, E) with an edge-weight

BFS Dijkstra. Oct abhi shelat

4102 BFS Dijkstra Oct 22 2009 abhi shelat breadth first search bfs(g, a) 1 2 a b 1 2 d c e f g 2 h bfs theorem Theorem 1 (CLRS, p. 599) Let G =(V, E) be a graph and suppose that BFS is run on G from vertex

Discrete Wiskunde II. Lecture 5: Shortest Paths & Spanning Trees

, 2009 Lecture 5: Shortest Paths & Spanning Trees University of Twente m.uetz@utwente.nl wwwhome.math.utwente.nl/~uetzm/dw/ Shortest Path Problem "#\$%&'%()*%"()\$#+,&- Given directed "#\$%&'()*+,%+('-*.#/'01234564'.*,'7+"-%/8',&'5"4'84%#3

CMPS 2200 Fall Carola Wenk Slides courtesy of Charles Leiserson with small changes by Carola Wenk. 10/8/12 CMPS 2200 Intro.

CMPS 00 Fall 01 Single Source Shortest Paths Carola Wenk Slides courtesy of Charles Leiserson with small changes by Carola Wenk 1 Paths in graphs Consider a digraph G = (V, E) with edge-weight function

CS 4407 Algorithms Lecture: Shortest Path Algorithms

CS 440 Algorithms Lecture: Shortest Path Algorithms Prof. Gregory Provan Department of Computer Science University College Cork 1 Outline Shortest Path Problem General Lemmas and Theorems. Algorithms Bellman-Ford

CMPS 6610 Fall 2018 Shortest Paths Carola Wenk

CMPS 6610 Fall 018 Shortest Paths Carola Wenk Slides courtesy of Charles Leiserson with changes and additions by Carola Wenk Paths in graphs Consider a digraph G = (V, E) with an edge-weight function w

Dynamic Programming: Shortest Paths and DFA to Reg Exps

CS 374: Algorithms & Models of Computation, Fall 205 Dynamic Programming: Shortest Paths and DFA to Reg Exps Lecture 7 October 22, 205 Chandra & Manoj (UIUC) CS374 Fall 205 / 54 Part I Shortest Paths with

Design and Analysis of Algorithms

Design and Analysis of Algorithms CSE 5311 Lecture 21 Single-Source Shortest Paths Junzhou Huang, Ph.D. Department of Computer Science and Engineering CSE5311 Design and Analysis of Algorithms 1 Single-Source

Chapter 5 Data Structures Algorithm Theory WS 2017/18 Fabian Kuhn

Chapter 5 Data Structures Algorithm Theory WS 2017/18 Fabian Kuhn Priority Queue / Heap Stores (key,data) pairs (like dictionary) But, different set of operations: Initialize-Heap: creates new empty heap

Introduction to Algorithms

Introduction to Algorithms 6.046J/8.40J/SMA550 Lecture 7 Prof. Erik Demaine Paths in graphs Consider a digraph G = (V, E) with edge-weight function w : E R. The weight of path p = v v L v k is defined

Introduction to Algorithms

Introduction to Algorithms 6.046J/18.401J LECTURE 14 Shortest Paths I Properties of shortest paths Dijkstra s algorithm Correctness Analysis Breadth-first search Prof. Charles E. Leiserson Paths in graphs

Algorithm Design and Analysis

Algorithm Design and Analysis LECTURE 7 Greedy Graph Algorithms Shortest paths Minimum Spanning Tree Sofya Raskhodnikova 9/14/016 S. Raskhodnikova; based on slides by E. Demaine, C. Leiserson, A. Smith,

Algorithms: Lecture 12. Chalmers University of Technology

Algorithms: Lecture 1 Chalmers University of Technology Today s Topics Shortest Paths Network Flow Algorithms Shortest Path in a Graph Shortest Path Problem Shortest path network. Directed graph G = (V,

Dijkstra s Single Source Shortest Path Algorithm. Andreas Klappenecker

Dijkstra s Single Source Shortest Path Algorithm Andreas Klappenecker Single Source Shortest Path Given: a directed or undirected graph G = (V,E) a source node s in V a weight function w: E -> R. Goal:

CS 161: Design and Analysis of Algorithms

CS 161: Design and Analysis of Algorithms Greedy Algorithms 1: Shortest Paths In Weighted Graphs Greedy Algorithm BFS as a greedy algorithm Shortest Paths in Weighted Graphs Dijsktra s Algorithm Greedy

Introduction to Algorithms

Introduction to Algorithms 6.046J/18.401J LECTURE 17 Shortest Paths I Properties of shortest paths Dijkstra s algorithm Correctness Analysis Breadth-first search Prof. Erik Demaine November 14, 005 Copyright

ne a priority queue for the nodes of G; ile (! PQ.is empty( )) select u PQ with d(u) minimal and remove it; I Informatik 1 Kurt Mehlhorn

n-negative Edge Costs: optimal choice: u U with d(u) minimal. e use a priority queue (de nition on next slide) PQ to maintain the set of pairs, d(u)) ; u U } and obtain Dijkstra s Algorithm: ne a priority

CS60020: Foundations of Algorithm Design and Machine Learning. Sourangshu Bhattacharya

CS6000: Foundations of Algorithm Design and Machine Learning Sourangshu Bhattacharya Paths in graphs Consider a digraph G = (V, E) with edge-weight function w : E R. The weight of path p = v 1 v L v k

1 Matchings in Non-Bipartite Graphs

CS 598CSC: Combinatorial Optimization Lecture date: Feb 9, 010 Instructor: Chandra Chekuri Scribe: Matthew Yancey 1 Matchings in Non-Bipartite Graphs We discuss matching in general undirected graphs. Given

Shortest Path Algorithms

Shortest Path Algorithms Andreas Klappenecker [based on slides by Prof. Welch] 1 Single Source Shortest Path 2 Single Source Shortest Path Given: a directed or undirected graph G = (V,E) a source node

directed weighted graphs as flow networks the Ford-Fulkerson algorithm termination and running time

Network Flow 1 The Maximum-Flow Problem directed weighted graphs as flow networks the Ford-Fulkerson algorithm termination and running time 2 Maximum Flows and Minimum Cuts flows and cuts max flow equals

Analysis of Algorithms. Outline. Single Source Shortest Path. Andres Mendez-Vazquez. November 9, Notes. Notes

Analysis of Algorithms Single Source Shortest Path Andres Mendez-Vazquez November 9, 01 1 / 108 Outline 1 Introduction Introduction and Similar Problems General Results Optimal Substructure Properties

Introduction to Algorithms

Introduction to Algorithms, Lecture 5 // Introduction to Algorithms 6.46J/.4J LECTURE Shortest Paths I Properties o shortest paths Dijkstra s Correctness Analysis Breadth-irst Pro. Manolis Kellis March,

Algorithm Design and Analysis

Algorithm Design and Analysis LECTURE 8 Greedy Algorithms V Huffman Codes Adam Smith Review Questions Let G be a connected undirected graph with distinct edge weights. Answer true or false: Let e be the

Contents Lecture 4. Greedy graph algorithms Dijkstra s algorithm Prim s algorithm Kruskal s algorithm Union-find data structure with path compression

Contents Lecture 4 Greedy graph algorithms Dijkstra s algorithm Prim s algorithm Kruskal s algorithm Union-find data structure with path compression Jonas Skeppstedt (jonasskeppstedt.net) Lecture 4 2018

1 Some loose ends from last time

Cornell University, Fall 2010 CS 6820: Algorithms Lecture notes: Kruskal s and Borůvka s MST algorithms September 20, 2010 1 Some loose ends from last time 1.1 A lemma concerning greedy algorithms and

Fibonacci Heaps These lecture slides are adapted from CLRS, Chapter 20.

Fibonacci Heaps These lecture slides are adapted from CLRS, Chapter 20. Princeton University COS 4 Theory of Algorithms Spring 2002 Kevin Wayne Priority Queues Operation mae-heap insert find- delete- union

CSCE 750 Final Exam Answer Key Wednesday December 7, 2005

CSCE 750 Final Exam Answer Key Wednesday December 7, 2005 Do all problems. Put your answers on blank paper or in a test booklet. There are 00 points total in the exam. You have 80 minutes. Please note

Chapter 4 Greedy Algorithms Slides by Kevin Wayne. Copyright 2005 Pearson-Addison Wesley. All rights reserved. 1 4.1 Interval Scheduling Interval Scheduling Interval scheduling. Job j starts at s j and

L feb abhi shelat

L10 661 feb 17 2009 abhi shelat General-MST-Strategy(G =(V, E)) 1 A 2 repeat V 1 times: 3 Pick a cut (S, V S) that respects A 4 Let e be min-weight edge over cut (S, V S) 5 A A {e} prim General-MST-Strategy(G

CSE 4502/5717 Big Data Analytics Spring 2018; Homework 1 Solutions

CSE 502/5717 Big Data Analytics Spring 2018; Homework 1 Solutions 1. Consider the following algorithm: for i := 1 to α n log e n do Pick a random j [1, n]; If a[j] = a[j + 1] or a[j] = a[j 1] then output:

Discrete Optimization 2010 Lecture 2 Matroids & Shortest Paths

Matroids Shortest Paths Discrete Optimization 2010 Lecture 2 Matroids & Shortest Paths Marc Uetz University of Twente m.uetz@utwente.nl Lecture 2: sheet 1 / 25 Marc Uetz Discrete Optimization Matroids

Maximum flow problem (part I)

Maximum flow problem (part I) Combinatorial Optimization Giovanni Righini Università degli Studi di Milano Definitions A flow network is a digraph D = (N,A) with two particular nodes s and t acting as

Chapter 4 Greedy Algorithms Slides by Kevin Wayne. Copyright Pearson-Addison Wesley. All rights reserved. 4 4.1 Interval Scheduling Interval Scheduling Interval scheduling. Job j starts at s j and finishes

25. Minimum Spanning Trees

695 25. Minimum Spanning Trees Motivation, Greedy, Algorithm Kruskal, General Rules, ADT Union-Find, Algorithm Jarnik, Prim, Dijkstra, Fibonacci Heaps [Ottman/Widmayer, Kap. 9.6, 6.2, 6.1, Cormen et al,

25. Minimum Spanning Trees

Problem Given: Undirected, weighted, connected graph G = (V, E, c). 5. Minimum Spanning Trees Motivation, Greedy, Algorithm Kruskal, General Rules, ADT Union-Find, Algorithm Jarnik, Prim, Dijkstra, Fibonacci

CS 253: Algorithms. Chapter 24. Shortest Paths. Credit: Dr. George Bebis

CS : Algorithms Chapter 4 Shortest Paths Credit: Dr. George Bebis Shortest Path Problems How can we find the shortest route between two points on a road map? Model the problem as a graph problem: Road

Breadth-First Search of Graphs Analysis of Algorithms Prepared by John Reif, Ph.D. Distinguished Professor of Computer Science Duke University Applications of Breadth-First Search of Graphs a) Single Source

Discrete Optimization 2010 Lecture 3 Maximum Flows

Remainder: Shortest Paths Maximum Flows Discrete Optimization 2010 Lecture 3 Maximum Flows Marc Uetz University of Twente m.uetz@utwente.nl Lecture 3: sheet 1 / 29 Marc Uetz Discrete Optimization Outline

Query Processing in Spatial Network Databases

Temporal and Spatial Data Management Fall 0 Query Processing in Spatial Network Databases SL06 Spatial network databases Shortest Path Incremental Euclidean Restriction Incremental Network Expansion Spatial

CPSC 320 Sample Final Examination December 2013

CPSC 320 Sample Final Examination December 2013 [10] 1. Answer each of the following questions with true or false. Give a short justification for each of your answers. [5] a. 6 n O(5 n ) lim n + This is

CS781 Lecture 3 January 27, 2011

CS781 Lecture 3 January 7, 011 Greedy Algorithms Topics: Interval Scheduling and Partitioning Dijkstra s Shortest Path Algorithm Minimum Spanning Trees Single-Link k-clustering Interval Scheduling Interval

CS 6301 PROGRAMMING AND DATA STRUCTURE II Dept of CSE/IT UNIT V GRAPHS

UNIT V GRAPHS Representation of Graphs Breadth-first search Depth-first search Topological sort Minimum Spanning Trees Kruskal and Prim algorithm Shortest path algorithm Dijkstra s algorithm Bellman-Ford

Undirected Graphs. V = { 1, 2, 3, 4, 5, 6, 7, 8 } E = { 1-2, 1-3, 2-3, 2-4, 2-5, 3-5, 3-7, 3-8, 4-5, 5-6 } n = 8 m = 11

Undirected Graphs Undirected graph. G = (V, E) V = nodes. E = edges between pairs of nodes. Captures pairwise relationship between objects. Graph size parameters: n = V, m = E. V = {, 2, 3,,,, 7, 8 } E

NATIONAL UNIVERSITY OF SINGAPORE CS3230 DESIGN AND ANALYSIS OF ALGORITHMS SEMESTER II: Time Allowed 2 Hours

NATIONAL UNIVERSITY OF SINGAPORE CS3230 DESIGN AND ANALYSIS OF ALGORITHMS SEMESTER II: 2017 2018 Time Allowed 2 Hours INSTRUCTIONS TO STUDENTS 1. This assessment consists of Eight (8) questions and comprises

CS 138b Computer Algorithm Homework #14. Ling Li, February 23, Construct the level graph

14.1 Construct the level graph Let s modify BFS slightly to construct the level graph L G = (V, E ) of G = (V, E, c) out of a source s V. We will use a queue Q and an array l containing levels of vertices.

PATH PROBLEMS IN SKEW-SYMMETRIC GRAPHS ANDREW V. GOLDBERG COMPUTER SCIENCE DEPARTMENT STANFORD UNIVERSITY STANFORD, CA

PATH PROBLEMS IN SKEW-SYMMETRIC GRAPHS ANDREW V. GOLDBERG COMPUTER SCIENCE DEPARTMENT STANFORD UNIVERSITY STANFORD, CA 94305 GOLDBERG@CS.STANFORD.EDU AND ALEXANDER V. KARZANOV INSTITUTE FOR SYSTEMS ANALYSIS

Preliminaries. Graphs. E : set of edges (arcs) (Undirected) Graph : (i, j) = (j, i) (edges) V = {1, 2, 3, 4, 5}, E = {(1, 3), (3, 2), (2, 4)}

Preliminaries Graphs G = (V, E), V : set of vertices E : set of edges (arcs) (Undirected) Graph : (i, j) = (j, i) (edges) 1 2 3 5 4 V = {1, 2, 3, 4, 5}, E = {(1, 3), (3, 2), (2, 4)} 1 Directed Graph (Digraph)

Algorithms Theory. 08 Fibonacci Heaps

Algorithms Theory 08 Fibonacci Heaps Prof. Dr. S. Albers Priority queues: operations Priority queue Q Operations: Q.initialize(): initializes an empty queue Q Q.isEmpty(): returns true iff Q is empty Q.insert(e):

Analysis of Algorithms. Outline 1 Introduction Basic Definitions Ordered Trees. Fibonacci Heaps. Andres Mendez-Vazquez. October 29, Notes.

Analysis of Algorithms Fibonacci Heaps Andres Mendez-Vazquez October 29, 2015 1 / 119 Outline 1 Introduction Basic Definitions Ordered Trees 2 Binomial Trees Example 3 Fibonacci Heap Operations Fibonacci

A faster algorithm for the single source shortest path problem with few distinct positive lengths

A faster algorithm for the single source shortest path problem with few distinct positive lengths J. B. Orlin, K. Madduri, K. Subramani, and M. Williamson Journal of Discrete Algorithms 8 (2010) 189 198.

Linear-Time Algorithms for Finding Tucker Submatrices and Lekkerkerker-Boland Subgraphs

Linear-Time Algorithms for Finding Tucker Submatrices and Lekkerkerker-Boland Subgraphs Nathan Lindzey, Ross M. McConnell Colorado State University, Fort Collins CO 80521, USA Abstract. Tucker characterized

CMU Lecture 4: Informed Search. Teacher: Gianni A. Di Caro

CMU 15-781 Lecture 4: Informed Search Teacher: Gianni A. Di Caro UNINFORMED VS. INFORMED Uninformed Can only generate successors and distinguish goals from non-goals Informed Strategies that can distinguish

Ngày 20 tháng 7 năm Discrete Optimization Graphs

Discrete Optimization Graphs Ngày 20 tháng 7 năm 2011 Lecture 6: Graphs In this class we shall prove some simple, useful theorems about graphs. We start with very simple obseravations. Lecture 6: Graphs

Lecture 21 November 11, 2014

CS 224: Advanced Algorithms Fall 2-14 Prof. Jelani Nelson Lecture 21 November 11, 2014 Scribe: Nithin Tumma 1 Overview In the previous lecture we finished covering the multiplicative weights method and

NP Completeness. CS 374: Algorithms & Models of Computation, Spring Lecture 23. November 19, 2015

CS 374: Algorithms & Models of Computation, Spring 2015 NP Completeness Lecture 23 November 19, 2015 Chandra & Lenny (UIUC) CS374 1 Spring 2015 1 / 37 Part I NP-Completeness Chandra & Lenny (UIUC) CS374

Lecture 2: Network Flows 1

Comp 260: Advanced Algorithms Tufts University, Spring 2011 Lecture by: Prof. Cowen Scribe: Saeed Majidi Lecture 2: Network Flows 1 A wide variety of problems, including the matching problems discussed

Slides credited from Hsueh-I Lu & Hsu-Chun Hsiao

Slides credited from Hsueh-I Lu & Hsu-Chun Hsiao Homework 3 released Due on 12/13 (Thur) 14:20 (one week only) Mini-HW 9 released Due on 12/13 (Thur) 14:20 Homework 4 released Due on 1/3 (Thur) 14:20 (four

6.889 Lecture 4: Single-Source Shortest Paths

6.889 Lecture 4: Single-Source Shortest Paths Christian Sommer csom@mit.edu September 19 and 26, 2011 Single-Source Shortest Path SSSP) Problem: given a graph G = V, E) and a source vertex s V, compute

CS 374: Algorithms & Models of Computation, Spring 2017 Greedy Algorithms Lecture 19 April 4, 2017 Chandra Chekuri (UIUC) CS374 1 Spring / 1

CS 374: Algorithms & Models of Computation, Spring 2017 Greedy Algorithms Lecture 19 April 4, 2017 Chandra Chekuri (UIUC) CS374 1 Spring 2017 1 / 1 Part I Greedy Algorithms: Tools and Techniques Chandra

Fundamental Algorithms 11

Technische Universität München WS 2013/14 Institut für Informatik Worksheet Scientific Computing in Computer Science 20.01.2014 Fundamental Algorithms 11 Exercise 1 Hypergraphs A hypergraph extends the

Priority queues implemented via heaps

Priority queues implemented via heaps Comp Sci 1575 Data s Outline 1 2 3 Outline 1 2 3 Priority queue: most important first Recall: queue is FIFO A normal queue data structure will not implement a priority

Algorithms and Theory of Computation. Lecture 11: Network Flow

Algorithms and Theory of Computation Lecture 11: Network Flow Xiaohui Bei MAS 714 September 18, 2018 Nanyang Technological University MAS 714 September 18, 2018 1 / 26 Flow Network A flow network is a

Assignment 5: Solutions

Comp 21: Algorithms and Data Structures Assignment : Solutions 1. Heaps. (a) First we remove the minimum key 1 (which we know is located at the root of the heap). We then replace it by the key in the position

Divide-and-Conquer Algorithms Part Two

Divide-and-Conquer Algorithms Part Two Recap from Last Time Divide-and-Conquer Algorithms A divide-and-conquer algorithm is one that works as follows: (Divide) Split the input apart into multiple smaller

2-INF-237 Vybrané partie z dátových štruktúr 2-INF-237 Selected Topics in Data Structures

2-INF-237 Vybrané partie z dátových štruktúr 2-INF-237 Selected Topics in Data Structures Instructor: Broňa Brejová E-mail: brejova@fmph.uniba.sk Office: M163 Course webpage: http://compbio.fmph.uniba.sk/vyuka/vpds/

Fall 2017 November 10, Written Homework 5

CS1800 Discrete Structures Profs. Aslam, Gold, & Pavlu Fall 2017 November 10, 2017 Assigned: Mon Nov 13 2017 Due: Wed Nov 29 2017 Instructions: Written Homework 5 The assignment has to be uploaded to blackboard

Graph Search Howie Choset

Graph Search Howie Choset 16-11 Outline Overview of Search Techniques A* Search Graphs Collection of Edges and Nodes (Vertices) A tree Grids Stacks and Queues Stack: First in, Last out (FILO) Queue: First

8 Priority Queues. 8 Priority Queues. Prim s Minimum Spanning Tree Algorithm. Dijkstra s Shortest Path Algorithm

8 Priority Queues 8 Priority Queues A Priority Queue S is a dynamic set data structure that supports the following operations: S. build(x 1,..., x n ): Creates a data-structure that contains just the elements

IS 709/809: Computational Methods in IS Research Fall Exam Review

IS 709/809: Computational Methods in IS Research Fall 2017 Exam Review Nirmalya Roy Department of Information Systems University of Maryland Baltimore County www.umbc.edu Exam When: Tuesday (11/28) 7:10pm

Scribes: Po-Hsuan Wei, William Kuzmaul Editor: Kevin Wu Date: October 18, 2016

CS 267 Lecture 7 Graph Spanners Scribes: Po-Hsuan Wei, William Kuzmaul Editor: Kevin Wu Date: October 18, 2016 1 Graph Spanners Our goal is to compress information about distances in a graph by looking

FINAL EXAM PRACTICE PROBLEMS CMSC 451 (Spring 2016)

FINAL EXAM PRACTICE PROBLEMS CMSC 451 (Spring 2016) The final exam will be on Thursday, May 12, from 8:00 10:00 am, at our regular class location (CSI 2117). It will be closed-book and closed-notes, except

CS 410/584, Algorithm Design & Analysis: Lecture Notes 3

CS 410/584, : Lecture Notes 3 Amortized Cost Not an algorithm design mechanism per se For analyzing cost of algorithms - - Example: Exercise 17.3-6 Implement a queue with two stacks Why? 1 enqueue(x, Q)

2 GRAPH AND NETWORK OPTIMIZATION. E. Amaldi Introduction to Operations Research Politecnico Milano 1

2 GRAPH AND NETWORK OPTIMIZATION E. Amaldi Introduction to Operations Research Politecnico Milano 1 A variety of decision-making problems can be formulated in terms of graphs and networks Examples: - transportation

Algorithm Design Strategies V

Algorithm Design Strategies V Joaquim Madeira Version 0.0 October 2016 U. Aveiro, October 2016 1 Overview The 0-1 Knapsack Problem Revisited The Fractional Knapsack Problem Greedy Algorithms Example Coin

The min cost flow problem Course notes for Optimization Spring 2007

The min cost flow problem Course notes for Optimization Spring 2007 Peter Bro Miltersen February 7, 2007 Version 3.0 1 Definition of the min cost flow problem We shall consider a generalization of the

On shredders and vertex connectivity augmentation

On shredders and vertex connectivity augmentation Gilad Liberman The Open University of Israel giladliberman@gmail.com Zeev Nutov The Open University of Israel nutov@openu.ac.il Abstract We consider the

Two Applications of Maximum Flow

Two Applications of Maximum Flow The Bipartite Matching Problem a bipartite graph as a flow network maximum flow and maximum matching alternating paths perfect matchings 2 Circulation with Demands flows

15.082J & 6.855J & ESD.78J. Algorithm Analysis

15.082J & 6.855J & ESD.78J Algorithm Analysis 15.082 Overview of subject Importance of Algorithm Analysis Importance of homework Midterms Moving forward 2 Overview of lecture Proof techniques Proof by

Advanced Combinatorial Optimization September 24, Lecture 5

18.438 Advanced Combinatorial Optimization September 24, 2009 Lecturer: Michel X. Goemans Lecture 5 Scribe: Yehua Wei In this lecture, we establish the connection between nowhere-zero (nwz) k-flow and

arxiv: v1 [cs.dm] 26 Apr 2010

A Simple Polynomial Algorithm for the Longest Path Problem on Cocomparability Graphs George B. Mertzios Derek G. Corneil arxiv:1004.4560v1 [cs.dm] 26 Apr 2010 Abstract Given a graph G, the longest path

Week 4. (1) 0 f ij u ij.

Week 4 1 Network Flow Chapter 7 of the book is about optimisation problems on networks. Section 7.1 gives a quick introduction to the definitions of graph theory. In fact I hope these are already known

Approximation algorithms for cycle packing problems

Approximation algorithms for cycle packing problems Michael Krivelevich Zeev Nutov Raphael Yuster Abstract The cycle packing number ν c (G) of a graph G is the maximum number of pairwise edgedisjoint cycles

Algorithms for pattern involvement in permutations

Algorithms for pattern involvement in permutations M. H. Albert Department of Computer Science R. E. L. Aldred Department of Mathematics and Statistics M. D. Atkinson Department of Computer Science D.

More Approximation Algorithms

CS 473: Algorithms, Spring 2018 More Approximation Algorithms Lecture 25 April 26, 2018 Most slides are courtesy Prof. Chekuri Ruta (UIUC) CS473 1 Spring 2018 1 / 28 Formal definition of approximation

Advanced Combinatorial Optimization Updated February 18, Lecture 5. Lecturer: Michel X. Goemans Scribe: Yehua Wei (2009)

18.438 Advanced Combinatorial Optimization Updated February 18, 2012. Lecture 5 Lecturer: Michel X. Goemans Scribe: Yehua Wei (2009) In this lecture, we establish the connection between nowhere-zero k-flows

Directed Graphs (Digraphs) and Graphs

Directed Graphs (Digraphs) and Graphs Definitions Graph ADT Traversal algorithms DFS Lecturer: Georgy Gimel farb COMPSCI 220 Algorithms and Data Structures 1 / 74 1 Basic definitions 2 Digraph Representation

On Powers of some Intersection Graphs

On Powers of some Intersection Graphs Geir Agnarsson Abstract We first consider m-trapezoid graphs and circular m-trapezoid graphs and give new constructive proofs that both these classes are closed under

Part V. Matchings. Matching. 19 Augmenting Paths for Matchings. 18 Bipartite Matching via Flows

Matching Input: undirected graph G = (V, E). M E is a matching if each node appears in at most one Part V edge in M. Maximum Matching: find a matching of maximum cardinality Matchings Ernst Mayr, Harald

Optimal Tree-decomposition Balancing and Reachability on Low Treewidth Graphs

Optimal Tree-decomposition Balancing and Reachability on Low Treewidth Graphs Krishnendu Chatterjee Rasmus Ibsen-Jensen Andreas Pavlogiannis IST Austria Abstract. We consider graphs with n nodes together

ICS 252 Introduction to Computer Design

ICS 252 fall 2006 Eli Bozorgzadeh Computer Science Department-UCI References and Copyright Textbooks referred [Mic94] G. De Micheli Synthesis and Optimization of Digital Circuits McGraw-Hill, 1994. [CLR90]

Running Time. Assumption. All capacities are integers between 1 and C.

Running Time Assumption. All capacities are integers between and. Invariant. Every flow value f(e) and every residual capacities c f (e) remains an integer throughout the algorithm. Theorem. The algorithm

Introduction to Discrete Optimization

Prof. Friedrich Eisenbrand Martin Niemeier Due Date: April 28, 2009 Discussions: April 2, 2009 Introduction to Discrete Optimization Spring 2009 s 8 Exercise What is the smallest number n such that an

FIBONACCI HEAPS. preliminaries insert extract the minimum decrease key bounding the rank meld and delete. Copyright 2013 Kevin Wayne

FIBONACCI HEAPS preliminaries insert extract the minimum decrease key bounding the rank meld and delete Copyright 2013 Kevin Wayne http://www.cs.princeton.edu/~wayne/kleinberg-tardos Last updated on Sep

Proof methods and greedy algorithms

Proof methods and greedy algorithms Magnus Lie Hetland Lecture notes, May 5th 2008 1 Introduction This lecture in some ways covers two separate topics: (1) how to prove algorithms correct, in general,

Part IA Algorithms Notes

Part IA Algorithms Notes 1 Sorting 1.1 Insertion Sort 1 d e f i n s e r t i o n S o r t ( a ) : 2 f o r i from 1 i n c l u d e d to l e n ( a ) excluded : 3 4 j = i 1 5 w h i l e j >= 0 and a [ i ] > a