CS 303 Design and Analysis of Algorithms

Transcription

1 inal Exam S 0 esign and nalsis of lgorithms Review or inal Exam ong Xu (Based on class note of avid Luebke) am-0am, onda, a 0 lose book Bring our calculator 40% of our final score Office hours during final ong (09 EBW) : :0pm-4pm, rida, a 7 shwin (0 EBN) : am-pm, Thursda, a 6 am-pm, Wednesda, a (an opportunit to verif the grading of final and quiz scores). /9/004 /9/004 inal Exam Tips 7 problems (6 with pts, with 0 pts) Review our quizzes and homework hard problem in dnamic programming overage.,.,..,.,. 4., 4..,.,. 6., 6. Binar search tree Red-black tree Review Topics ugmenting data structure namic programming Greed algorithm /9/004 4 /9/004 Review: Binar Search Trees BST propert: ke[left(x)] ke[x] ke[right(x)] Example: B Review: Inorder Tree Walk n inorder walk prints the set in sorted order: TreeWalk(x) TreeWalk(left[x]); print(x); TreeWalk(right[x]); Eas to show b induction on the BST propert K /9/004 6 /9/004

2 Review: BST Search Review: BST Insert TreeSearch(x, k) if (x = NULL or k = ke[x]) if (k < ke[x]) return TreeSearch(left[x], k); return TreeSearch(right[x], k); dds an element x to the tree so that the binar search tree propert continues to hold The basic algorithm Like the search procedure above Insert x in place of NULL Use a trailing pointer to keep track of where ou came from (like inserting into singl linked list) Like search, takes time O(h), h = tree height 7 /9/004 /9/004 Review: Sorting With BSTs Review: Sorting With BSTs Basic algorithm: Insert elements of unsorted arra from..n o an inorder tree walk to print in sorted order Running time: Best case: Ω(n lg n) (it s a comparison sort) Worst case: O(n ) verage case: O(n lg n) (it s a quick sort!) verage case analsis It s a form of quicksort! for i= to n TreeInsert([i]); InorderTreeWalk(root); /9/004 0 /9/004 Review: ore BST Operations Review: ore BST Operations inimum: ind leftmost node in tree Successor: x has a right subtree: successor is minimum node in right subtree x has no right subtree: successor is first ancestor of x whose left child is also ancestor of x Intuition: s long as ou move to the left up the tree, ou re visiting smaller nodes. redecessor: similar to successor elete: x has no children: Remove x x has one child: Splice out x x has two children: Swap x with successor erform case or to delete it B Example: delete K or or B K /9/004 /9/004

3 Review: Red-Black Trees Red-black trees: Binar search trees augmented with node color Operations designed to guarantee that the height h = O(lg n) Red-Black roperties The red-black properties:. Ever node is either red or black. Ever leaf (NULL pointer) is black Note: this means ever real node has children. If a node is red, both children are black Note: can t have consecutive reds on a path 4. Ever path from node to descendent leaf contains the same number of black nodes. The root is alwas black black-height: # black nodes on path to leaf Lets us prove RB tree has height h lg(n+) /9/004 4 /9/004 Operations On RB Trees Since height is O(lg n), we can show that all BST operations take O(lg n) time roblem: BST Insert() and elete() modif the tree and could destro red-black properties Solution: restructure the tree in O(lg n) time You should understand the basic approach of these operations Ke operation: rotation RB Trees: Rotation Our basic operation for changing tree structure: x rightrotate() leftrotate(x) B B Rotation preserves inorder ke ordering Rotation takes O() time (just swaps pointers) x /9/004 6 /9/004 Review: namic Order Statistics We ve seen algorithms for finding the ith element of an unordered set in O(n) time OS-Trees: a structure to support finding the ith element of a dnamic set in O(lg n) time Support standard dnamic set operations (Insert(), elete(), in(), ax(), Succ(), red()) lso support these order statistic operations: void OS-Select(root, i); int OS-Rank(x); 7 /9/004 Review: Order Statistic Trees OS Trees augment red-black trees: ssociate a size field with each node in the tree x->size records the size of subtree rooted at x, including x itself: /9/004

4 Example: show OS-Select(root, ): Example: show OS-Select(root, ): r = x->left->size + ; if (i < r) r = x->left->size + ; if (i < r) i = 9 /9/004 0 /9/004 Example: show OS-Select(root, ): Example: show OS-Select(root, ): r = x->left->size + ; if (i < r) i = r = i = r = x->left->size + ; if (i < r) i = r = i = i = r = /9/004 /9/004 Example: show OS-Select(root, ): Example: show OS-Select(root, ): r = x->left->size + ; if (i < r) i = r = i = r = i = i = r = r = x->left->size + ; if (i < r) i = r = i = r = i = i = r = Note: use a sentinel NIL element at the leaves with size = 0 to simplif code, avoid testing for NULL /9/004 4 /9/004 4

5 Review: etermining The Rank Of n Element Idea: rank of right child x is one more than its parent s rank, plus the size of x s left subtree r = x->left->size + ; = x; while (!= T->root) if ( == ->p->right) r = r + ->p->left->size + ; = ->p; /9/004 Review: etermining The Rank Of n Element Example : find rank of element with ke r = x->left->size + ; = x; while (!= T->root) if ( == ->p->right) r = r + ->p->left->size + ; = ->p; r = 6 /9/004 Review: etermining The Rank Of n Element Example : find rank of element with ke r = x->left->size + ; = x; while (!= T->root) if ( == ->p->right) r = r + ->p->left->size + ; = ->p; r = ++ = r = 7 /9/004 Review: etermining The Rank Of n Element Example : find rank of element with ke r = x->left->size + ; = x; while (!= T->root) r = ++ = if ( == ->p->right) r = r + ->p->left->size + ; = ->p; r = r = /9/004 Review: etermining The Rank Of n Element Example : find rank of element with ke r = x->left->size + ; = x; while (!= T->root) r = if ( == ->p->right) r = r + ->p->left->size + ; = ->p; r = r = r = 9 /9/004 Review: aintaining Subtree Sizes So b keeping subtree sizes, order statistic operations can be done in O(lg n) time Next: maintain sizes during Insert() and elete() operations Insert(): Increment size fields of nodes traversed during search down the tree elete(): ecrement sizes along a path from the deleted node to the root Both: Update sizes correctl during rotations 0 /9/004

6 Reivew: aintaining Subtree Sizes x rightrotate() 7 leftrotate(x) 6 Note that rotation invalidates onl x and an recalculate their sizes in constant time x Thm.: can compute an propert in O(lg n) time that depends onl on node, left child, and right child Review: namic rogramming Summar of the basic idea: Optimal substructure: optimal solution to problem consists of optimal solutions to subproblems Overlapping subproblems: few subproblems in total, man recurring instances of each Solve bottom-up, building a table of solved subproblems that are used to solve larger ones /9/004 /9/004 oncrete Instance of LS atrix hain-roducts atrix hain-roduct: ompute = 0 * * * n- i is d i d i+ roblem: ow to parenthesize? atrix hain-roduct lg.: Tr all possible was to parenthesize = 0 * * * n- alculate number of ops for each one ick the one that is best /9/004 4 /9/004 Recursive pproach efine subproblems: ind the best parenthesization of i * i+ * * j. Let N i,j denote the number of operations done b this subproblem. The optimal solution for the whole problem is N 0,n-. Subproblem optimalit: The optimal solution can be defined in terms of optimal subproblems ssume the final multipl is at index i: ( 0 * * i )*( i+ * * n- ). Then the optimal solution N 0,n- is the sum of two optimal subproblems, N 0,i and N i+,n- plus the time for the last multipl. /9/004 haracterizing Equation Let us consider all possible places for that final multipl: Recall that i is a d i d i+ dimensional matrix. So, a characterizing equation for N i,j is the following: N i, j = j+ i k< j min Ni, k + Nk +, j + didk+ d Note that subproblems are not independent--the subproblems overlap. 6 /9/004 6

7 Greed lgorithms greed algorithm alwas makes the choice that looks best at the moment Indicators: Optimal substructure Greed choice propert: a locall optimal choice leads to a globall optimal solution namic programming can be overkill; greed algorithms tend to be easier to code ctivit-selection ormall: Given a set S of n activities s i = start time of activit i f i = finish time of activit i ind max-size subset of compatible activities 4 ssume that f f f n 6 7 /9/004 /9/004 ctivit Selection: Greed lgorithm So actual algorithm is simple: Sort the activities b finish time Schedule the first activit Then schedule the next activit in sorted list which starts after previous activit finishes Repeat until no more activities Intuition is even more simple: lwas pick the activit with the nearest finish time available and reject the conflicts Review: The Knapsack roblem The famous knapsack problem: thief breaks into a museum. abulous paintings, sculptures, and jewels are everwhere. The thief has a good ee for the value of these objects, and knows that each will fetch hundreds or thousands of dollars on the clandestine art collector s market. But, the thief has onl brought a single knapsack to the scene of the robber, and can take awa onl what he can carr. What items should the thief take to maximize the haul? 9 /9/ /9/004 Review: The Knapsack roblem ore formall, the 0- knapsack problem: The thief must choose among n items, where the ith item worth v i dollars and weighs w i pounds arring at most W pounds, maximize value Note: assume v i, w i, and W are all integers 0- b/c each item must be taken or left in entiret variation, the fractional knapsack problem: Thief can take fractions of items Think of items in 0- problem as gold ingots, in fractional problem as buckets of gold dust Solving The Knapsack roblem The optimal solution to the fractional knapsack problem can be found with a greed algorithm ow? The optimal solution to the 0- problem cannot be found with the same greed strateg Greed strateg: take in order of dollars/pound Example: items weighing 0, 0, and 0 pounds, knapsack can hold 0 pounds Suppose item is worth $00. ssign values to the other items so that the greed strateg will fail 4 /9/004 4 /9/004 7

8 This is a knapsack ax weight: W = 0 W = 0 0- Knapsack problem: a picture Items Weight w i 4 Benefit value b i 4 0- Knapsack problem: bruteforce approach Since there are n items, there are n possible combinations of items. We go through all combinations and find the one with the most total value and with total weight less or equal to W Running time will be O( n ) an be done with better efficienc /9/ /9/004