Download presentation

Presentation is loading. Please wait.

Published byCarter Nokes Modified about 1 year ago

1
1 Lecturer : Dr Ali Al Najjar H

2
2 Theorem. Starting from empty Fibonacci heap, any sequence of a 1 insert, a 2 delete-min, and a 3 decrease-key operations takes O(a 1 + a 2 log n + a 3 ) time. make-heap Operation insert find-min delete-min union decrease-key delete 1 Binary Heap log n 1 n 1 Binomial Heap log n 1 Fibonacci Heap † 1 1 log n Relaxed Heap 1 1 log n Linked List 1 n n 1 n n is-empty11111 Priority Queues Performance Cost Summary † amortizedn = number of elements in priority queue

3
3 Hopeless challenge. O(1) insert, delete-min and decrease-key. Why? Priority Queues Performance Cost Summary make-heap Operation insert find-min delete-min union decrease-key delete 1 Binary Heap log n 1 n 1 Binomial Heap log n 1 Fibonacci Heap † 1 1 log n Relaxed Heap 1 1 log n Linked List 1 n n 1 n n is-empty11111 † amortizedn = number of elements in priority queue

4
4 Fibonacci Heaps History. [Fredman and Tarjan, 1986] n Ingenious data structure and analysis. Original motivation: improve Dijkstra's shortest path algorithm from O(E log V ) to O(E + V log V ). Basic idea. n Similar to binomial heaps, but less rigid structure. Binomial heap: eagerly consolidate trees after each insert. Fibonacci heap: lazily defer consolidation until next delete-min. V insert, V delete-min, E decrease-key

5
Heap H Fibonacci Heaps: Structure Fibonacci heap. n Set of heap-ordered trees. n Maintain pointer to minimum element. n Set of marked nodes. roots heap-ordered tree each parent larger than its children

6
Heap H Fibonacci Heaps: Structure Fibonacci heap. n Set of heap-ordered trees. n Maintain pointer to minimum element. n Set of marked nodes. min find-min takes O(1) time

7
Heap H Fibonacci Heaps: Structure Fibonacci heap. n Set of heap-ordered trees. n Maintain pointer to minimum element. n Set of marked nodes. min use to keep heaps flat (stay tuned) marked

8
8 Fibonacci Heaps: Notation Notation. n = number of nodes in heap. rank(x) = number of children of node x. rank(H) = max rank of any node in heap H. trees(H) = number of trees in heap H. marks(H) = number of marked nodes in heap H rank = 3 min Heap H trees(H) = 5 marks(H) = 3 marked n = 14

9
9 Fibonacci Heaps: Potential Function (H) = 3 = min Heap H (H) = trees(H) + 2 marks(H) potential of heap H trees(H) = 5 marks(H) = 3 marked

10
10 Insert

11
11 Fibonacci Heaps: Insert Insert. n Create a new singleton tree. n Add to root list; update min pointer (if necessary) insert 21 min Heap H

12
12 Fibonacci Heaps: Insert Insert. n Create a new singleton tree. n Add to root list; update min pointer (if necessary) min Heap H insert 21

13
13 Fibonacci Heaps: Insert Analysis Actual cost. O(1) Change in potential. +1 Amortized cost. O(1) min Heap H (H) = trees(H) + 2 marks(H) potential of heap H

14
14 Delete Min

15
15 Linking Operation Linking operation. Make larger root be a child of smaller root tree T 1 tree T tree T' smaller root larger rootstill heap-ordered

16
16 Fibonacci Heaps: Delete Min Delete min. n Delete min; meld its children into root list; update min. n Consolidate trees so that no two roots have same rank min

17
17 Fibonacci Heaps: Delete Min Delete min. n Delete min; meld its children into root list; update min. n Consolidate trees so that no two roots have same rank min

18
18 Fibonacci Heaps: Delete Min Delete min. n Delete min; meld its children into root list; update min. n Consolidate trees so that no two roots have same rank min current

19
19 Fibonacci Heaps: Delete Min Delete min. n Delete min; meld its children into root list; update min. n Consolidate trees so that no two roots have same rank current min rank

20
20 Fibonacci Heaps: Delete Min Delete min. n Delete min; meld its children into root list; update min. n Consolidate trees so that no two roots have same rank min current rank

21
21 Fibonacci Heaps: Delete Min Delete min. n Delete min; meld its children into root list; update min. n Consolidate trees so that no two roots have same rank min current rank

22
22 Fibonacci Heaps: Delete Min Delete min. n Delete min; meld its children into root list; update min. n Consolidate trees so that no two roots have same rank min current rank link 23 into 17

23
23 Fibonacci Heaps: Delete Min Delete min. n Delete min; meld its children into root list; update min. n Consolidate trees so that no two roots have same rank min current rank link 17 into 7

24
24 Fibonacci Heaps: Delete Min Delete min. n Delete min; meld its children into root list; update min. n Consolidate trees so that no two roots have same rank current min rank link 24 into 7

25
25 Fibonacci Heaps: Delete Min Delete min. n Delete min; meld its children into root list; update min. n Consolidate trees so that no two roots have same rank min current rank

26
26 Fibonacci Heaps: Delete Min Delete min. n Delete min; meld its children into root list; update min. n Consolidate trees so that no two roots have same rank min current rank

27
27 Fibonacci Heaps: Delete Min Delete min. n Delete min; meld its children into root list; update min. n Consolidate trees so that no two roots have same rank min current rank

28
28 Fibonacci Heaps: Delete Min Delete min. n Delete min; meld its children into root list; update min. n Consolidate trees so that no two roots have same rank min current rank link 41 into 18

29
29 Fibonacci Heaps: Delete Min Delete min. n Delete min; meld its children into root list; update min. n Consolidate trees so that no two roots have same rank min current rank

30
30 Fibonacci Heaps: Delete Min Delete min. n Delete min; meld its children into root list; update min. n Consolidate trees so that no two roots have same rank min rank current

31
31 Fibonacci Heaps: Delete Min Delete min. n Delete min; meld its children into root list; update min. n Consolidate trees so that no two roots have same rank min stop

32
32 Fibonacci Heaps: Delete Min Analysis Delete min. Actual cost. O(rank(H)) + O(trees(H)) O(rank(H)) to meld min's children into root list. O(rank(H)) + O(trees(H)) to update min. O(rank(H)) + O(trees(H)) to consolidate trees. Change in potential. O(rank(H)) - trees(H) trees(H' ) rank(H) + 1 since no two trees have same rank. (H) rank(H) trees(H). Amortized cost. O(rank(H)) (H) = trees(H) + 2 marks(H) potential function

33
33 Q. Is amortized cost of O(rank(H)) good? A. Yes, if only insert and delete-min operations. n In this case, all trees are binomial trees. This implies rank(H) lg n. A. Yes, we'll implement decrease-key so that rank(H) = O(log n). Fibonacci Heaps: Delete Min Analysis B0B0 B1B1 B2B2 B3B3 we only link trees of equal rank

34
34 Decrease Key

35
35 Intuition for deceasing the key of node x. If heap-order is not violated, just decrease the key of x. Otherwise, cut tree rooted at x and meld into root list. n To keep trees flat: as soon as a node has its second child cut, cut it off and meld into root list (and unmark it) Fibonacci Heaps: Decrease Key 35 min marked node: one child already cut

36
36 Case 1. [heap order not violated] Decrease key of x. n Change heap min pointer (if necessary) Fibonacci Heaps: Decrease Key min x decrease-key of x from 46 to 29

37
37 Case 1. [heap order not violated] Decrease key of x. n Change heap min pointer (if necessary) Fibonacci Heaps: Decrease Key 35 min x decrease-key of x from 46 to 29

38
38 Case 2a. [heap order violated] Decrease key of x. Cut tree rooted at x, meld into root list, and unmark. If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child) Fibonacci Heaps: Decrease Key min decrease-key of x from 29 to 15 p x

39
39 Case 2a. [heap order violated] Decrease key of x. Cut tree rooted at x, meld into root list, and unmark. If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child) Fibonacci Heaps: Decrease Key 35 min decrease-key of x from 29 to 15 p x

40
40 Case 2a. [heap order violated] Decrease key of x. Cut tree rooted at x, meld into root list, and unmark. If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child) Fibonacci Heaps: Decrease Key 35 min decrease-key of x from 29 to 15 p x

41
41 Case 2a. [heap order violated] Decrease key of x. Cut tree rooted at x, meld into root list, and unmark. If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child) Fibonacci Heaps: Decrease Key 35 min decrease-key of x from 29 to 15 p x mark parent 24

42
42 35 Case 2b. [heap order violated] Decrease key of x. Cut tree rooted at x, meld into root list, and unmark. If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child) Fibonacci Heaps: Decrease Key 5 min x p decrease-key of x from 35 to 5

43
43 5 Case 2b. [heap order violated] Decrease key of x. Cut tree rooted at x, meld into root list, and unmark. If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child) Fibonacci Heaps: Decrease Key min x p decrease-key of x from 35 to 5

44
44 Fibonacci Heaps: Decrease Key decrease-key of x from 35 to 5 x p min Case 2b. [heap order violated] Decrease key of x. Cut tree rooted at x, meld into root list, and unmark. If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child).

45
45 Case 2b. [heap order violated] Decrease key of x. Cut tree rooted at x, meld into root list, and unmark. If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child) Fibonacci Heaps: Decrease Key decrease-key of x from 35 to 5 x p second child cut min

46
46 Case 2b. [heap order violated] Decrease key of x. Cut tree rooted at x, meld into root list, and unmark. If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child) Fibonacci Heaps: Decrease Key decrease-key of x from 35 to 5 xp min

47
47 Case 2b. [heap order violated] Decrease key of x. Cut tree rooted at x, meld into root list, and unmark. If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child) Fibonacci Heaps: Decrease Key decrease-key of x from 35 to 5 xp p' second child cut min

48
48 Case 2b. [heap order violated] Decrease key of x. Cut tree rooted at x, meld into root list, and unmark. If parent p of x is unmarked (hasn't yet lost a child), mark it; Otherwise, cut p, meld into root list, and unmark (and do so recursively for all ancestors that lose a second child) Fibonacci Heaps: Decrease Key decrease-key of x from 35 to 5 xpp' min don't mark parent if it's a root p''

49
49 Decrease-key. Actual cost. O(c) n O(1) time for changing the key. O(1) time for each of c cuts, plus melding into root list. Change in potential. O(1) - c trees(H') = trees(H) + c. marks(H') marks(H) - c + 2. c + 2 (-c + 2) = 4 - c. Amortized cost. O(1) Fibonacci Heaps: Decrease Key Analysis (H) = trees(H) + 2 marks(H) potential function

50
50 Analysis

51
51 Analysis Summary Insert.O(1) Delete-min.O(rank(H)) † Decrease-key.O(1) † Key lemma. rank(H) = O(log n). † amortized number of nodes is exponential in rank

52
52 Fibonacci Heaps: Bounding the Rank Lemma. Fix a point in time. Let x be a node, and let y 1, …, y k denote its children in the order in which they were linked to x. Then: Pf. When y i was linked into x, x had at least i -1 children y 1, …, y i-1. Since only trees of equal rank are linked, at that time rank(y i ) = rank(x i ) i - 1. Since then, y i has lost at most one child. Thus, right now rank(y i ) i - 2. or y i would have been cut x y1y1 y2y2 ykyk …

53
53 Fibonacci Heaps: Bounding the Rank Lemma. Fix a point in time. Let x be a node, and let y 1, …, y k denote its children in the order in which they were linked to x. Then: Def. Let F k be smallest possible tree of rank k satisfying property. F0F0 F1F1 F2F2 F3F3 F4F4 F5F x y1y1 y2y2 ykyk …

54
54 Fibonacci Heaps: Bounding the Rank Lemma. Fix a point in time. Let x be a node, and let y 1, …, y k denote its children in the order in which they were linked to x. Then: Def. Let F k be smallest possible tree of rank k satisfying property. F4F4 F5F5 813 F6F = 21 x y1y1 y2y2 ykyk …

55
55 Fibonacci Heaps: Bounding the Rank Lemma. Fix a point in time. Let x be a node, and let y 1, …, y k denote its children in the order in which they were linked to x. Then: Def. Let F k be smallest possible tree of rank k satisfying property. Fibonacci fact. F k k, where = (1 + 5) / 2 Corollary. rank(H) log n. golden ratio x y1y1 y2y2 ykyk …

56
56 Fibonacci Numbers

57
57 Fibonacci Numbers: Exponential Growth Def. The Fibonacci sequence is: 1, 2, 3, 5, 8, 13, 21, … Lemma. F k k, where = (1 + 5) / 2 Pf. [by induction on k] Base cases: F 0 = 1 1, F 1 = 2 . Inductive hypotheses: F k k and F k+1 k + 1 slightly non-standard definition ( 2 = + 1) (inductive hypothesis) (definition) (algebra)

58
58 Fibonacci Numbers and Nature pinecone cauliflower

59
59 Union

60
60 Fibonacci Heaps: Union Union. Combine two Fibonacci heaps. Representation. Root lists are circular, doubly linked lists min Heap H'Heap H''

61
61 Fibonacci Heaps: Union Union. Combine two Fibonacci heaps. Representation. Root lists are circular, doubly linked lists min Heap H

62
62 Fibonacci Heaps: Union Actual cost. O(1) Change in potential. 0 Amortized cost. O(1) (H) = trees(H) + 2 marks(H) potential function min Heap H

63
63 Delete

64
64 Delete node x. decrease-key of x to - . delete-min element in heap. Amortized cost. O(rank(H)) O(1) amortized for decrease-key. O(rank(H)) amortized for delete-min. Fibonacci Heaps: Delete (H) = trees(H) + 2 marks(H) potential function

65
65 make-heap Operation insert find-min delete-min union decrease-key delete 1 Binary Heap log n 1 n 1 Binomial Heap log n 1 Fibonacci Heap † 1 1 log n Relaxed Heap 1 1 log n Linked List 1 n n 1 n n is-empty11111 Priority Queues Performance Cost Summary † amortizedn = number of elements in priority queue

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google